moving from https://github.com/perberos/mate-desktop-environment

173 files changed, 88353 insertions, 0 deletions

diff --git a/src/50-marco-desktop-key.xml.in b/src/50-marco-desktop-key.xml.in
new file mode 100644
index 00000000..5705607d
--- /dev/null
+++ b/src/50-marco-desktop-key.xml.in
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<KeyListEntries _name="Desktop" wm_name="Marco" package="marco">
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/panel_run_dialog" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/panel_main_menu" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/run_command_screenshot" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/run_command_window_screenshot" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/run_command_terminal" />
+
+</KeyListEntries>
+
diff --git a/src/50-marco-key.xml.in b/src/50-marco-key.xml.in
new file mode 100644
index 00000000..62c98236
--- /dev/null
+++ b/src/50-marco-key.xml.in
@@ -0,0 +1,269 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<KeyListEntries _name="Window Management" wm_name="Marco" package="marco">
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/activate_window_menu" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/toggle_fullscreen" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/toggle_maximized" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/maximize" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/unmaximize" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/toggle_shaded" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/close" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/minimize" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/begin_move" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/begin_resize" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/toggle_on_all_workspaces"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/raise_or_lower" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/raise" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/lower" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/maximize_vertically" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/maximize_horizontally" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_1"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_2"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_3"
+	value="2"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_4"
+	value="3"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_5"
+	value="4"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_6"
+	value="5"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_7"
+	value="6"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_8"
+	value="7"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_9"
+	value="8"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_10"
+	value="9"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_11"
+	value="10"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_12"
+	value="11"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_left"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_right"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_up"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/window_keybindings/move_to_workspace_down"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_windows" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_group" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_panels" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/cycle_windows" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/cycle_group" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/cycle_panels" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/show_desktop" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_1"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_2"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_3"
+	value="2"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_4"
+	value="3"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_5"
+	value="4"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_6"
+	value="5"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_7"
+	value="6"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_8"
+	value="7"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_9"
+	value="8"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_10"
+	value="9"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_11"
+	value="10"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_12"
+	value="11"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_left"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_right"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_up"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+	<KeyListEntry
+	name="/apps/marco/global_keybindings/switch_to_workspace_down"
+	value="1"
+	key="/apps/marco/general/num_workspaces"
+	comparison="gt" />
+
+</KeyListEntries>
+
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 00000000..52223298
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,223 @@
+lib_LTLIBRARIES = libmarco-private.la
+
+SUBDIRS=wm-tester tools themes
+
+INCLUDES = \
+	-I$(srcdir)/include \
+	-DMARCO_LIBEXECDIR=\"$(libexecdir)\" \
+	-DHOST_ALIAS=\"@HOST_ALIAS@\" \
+	-DMARCO_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" \
+	-DMARCO_PKGDATADIR=\"$(pkgdatadir)\" \
+	-DMARCO_DATADIR=\"$(datadir)\" \
+	-DG_LOG_DOMAIN=\"marco\" \
+	-DSN_API_NOT_YET_FROZEN=1 \
+	@MARCO_CFLAGS@
+
+marco_SOURCES = \
+	core/async-getprop.c \
+	core/async-getprop.h \
+	core/atomnames.h \
+	core/bell.c \
+	core/bell.h \
+	core/boxes.c \
+	include/boxes.h \
+	compositor/compositor.c \
+	compositor/compositor-private.h \
+	compositor/compositor-xrender.c \
+	compositor/compositor-xrender.h \
+	include/compositor.h \
+	core/constraints.c \
+	core/constraints.h \
+	core/core.c \
+	core/delete.c \
+	core/display.c \
+	core/display-private.h \
+	include/display.h \
+	ui/draw-workspace.c \
+	ui/draw-workspace.h \
+	core/edge-resistance.c \
+	core/edge-resistance.h \
+	core/effects.c \
+	core/effects.h \
+	core/errors.c \
+	include/errors.h \
+	core/eventqueue.c \
+	core/eventqueue.h \
+	core/frame.c \
+	core/frame-private.h \
+	include/frame.h \
+	ui/gradient.c \
+	ui/gradient.h \
+	core/group-private.h \
+	core/group-props.c \
+	core/group-props.h \
+	core/group.c \
+	core/group.h \
+	core/iconcache.c \
+	core/iconcache.h \
+	core/keybindings.c \
+	core/keybindings.h \
+	core/main.c \
+	include/main.h \
+	core/marco-Xatomtype.h \
+	core/place.c \
+	core/place.h \
+	core/prefs.c \
+	include/prefs.h \
+	core/screen.c \
+	core/screen-private.h \
+	include/screen.h \
+	include/types.h \
+	core/session.c \
+	core/session.h \
+	core/stack.c \
+	core/stack.h \
+	core/util.c \
+	include/util.h \
+	core/window-props.c \
+	core/window-props.h \
+	core/window.c \
+	core/window-private.h \
+	include/window.h \
+	core/workspace.c \
+	core/workspace.h \
+	core/xprops.c \
+	include/xprops.h \
+	include/common.h \
+	include/core.h \
+	include/ui.h \
+	ui/fixedtip.c \
+	ui/fixedtip.h \
+	ui/frames.c \
+	ui/frames.h \
+	ui/menu.c \
+	ui/menu.h \
+	ui/metaaccellabel.c \
+	ui/metaaccellabel.h \
+	ui/resizepopup.c \
+	include/resizepopup.h \
+	ui/tabpopup.c \
+	include/tabpopup.h \
+	ui/theme-parser.c \
+	ui/theme-parser.h \
+	ui/theme.c \
+	ui/theme.h \
+	ui/themewidget.c \
+	ui/themewidget.h \
+	ui/ui.c \
+	include/all-keybindings.h
+
+# by setting libmarco_private_la_CFLAGS, the files shared with
+# marco proper will be compiled with different names.
+libmarco_private_la_CFLAGS =
+libmarco_private_la_SOURCES = \
+	core/boxes.c \
+	include/boxes.h \
+	ui/gradient.c \
+	ui/gradient.h \
+	core/util.c \
+	include/util.h \
+	include/common.h \
+	ui/preview-widget.c \
+	ui/preview-widget.h \
+	ui/theme-parser.c \
+	ui/theme-parser.h \
+	ui/theme.c \
+	ui/theme.h
+
+libmarco_private_la_LDFLAGS = -no-undefined
+libmarco_private_la_LIBADD = @MARCO_LIBS@
+
+libmarcoincludedir = $(includedir)/marco-1/marco-private
+
+libmarcoinclude_HEADERS = \
+	include/boxes.h \
+	ui/gradient.h \
+	include/util.h \
+	include/common.h \
+	ui/preview-widget.h \
+	ui/theme-parser.h \
+	ui/theme.h
+
+marco_theme_viewer_SOURCES= \
+	ui/theme-viewer.c
+
+schema_bindings_SOURCES = \
+	core/schema-bindings.c \
+	marco.schemas.in.in
+
+schema_bindings_LDADD = @MARCO_LIBS@
+marco.schemas.in: schema_bindings ${srcdir}/marco.schemas.in.in
+	@echo Generating keybinding schemas... ${srcdir}/marco.schemas.in.in
+	${builddir}/schema_bindings ${srcdir}/marco.schemas.in.in ${builddir}/marco.schemas.in
+
+bin_PROGRAMS=marco marco-theme-viewer
+
+EFENCE=
+marco_LDADD=@MARCO_LIBS@ $(EFENCE)
+marco_theme_viewer_LDADD= @MARCO_LIBS@ libmarco-private.la
+
+testboxes_SOURCES=include/util.h core/util.c include/boxes.h core/boxes.c core/testboxes.c
+testgradient_SOURCES=ui/gradient.h ui/gradient.c ui/testgradient.c
+testasyncgetprop_SOURCES=core/async-getprop.h core/async-getprop.c core/testasyncgetprop.c
+
+noinst_PROGRAMS=testboxes testgradient testasyncgetprop schema_bindings
+
+testboxes_LDADD= @MARCO_LIBS@
+testgradient_LDADD= @MARCO_LIBS@
+testasyncgetprop_LDADD= @MARCO_LIBS@
+
+@INTLTOOL_DESKTOP_RULE@
+
+desktopfilesdir=$(datadir)/applications
+desktopfiles_in_files=marco.desktop.in
+desktopfiles_files=$(desktopfiles_in_files:.desktop.in=.desktop)
+desktopfiles_DATA = $(desktopfiles_files)
+
+wmpropertiesdir=$(datadir)/mate/wm-properties
+wmproperties_in_files=marco-wm.desktop.in
+wmproperties_files=$(wmproperties_in_files:.desktop.in=.desktop)
+wmproperties_DATA = $(wmproperties_files)
+
+schemadir = @MATECONF_SCHEMA_FILE_DIR@
+schema_in_files = marco.schemas.in
+schema_DATA = $(schema_in_files:.schemas.in=.schemas)
+
+@INTLTOOL_XML_NOMERGE_RULE@
+
+xmldir = @MATE_KEYBINDINGS_KEYSDIR@
+xml_in_files = 50-marco-desktop-key.xml.in 50-marco-key.xml.in
+xml_DATA = $(xml_in_files:.xml.in=.xml)
+
+@INTLTOOL_SCHEMAS_RULE@
+
+if MATECONF_SCHEMAS_INSTALL
+install-data-local:
+	MATECONF_CONFIG_SOURCE=$(MATECONF_SCHEMA_CONFIG_SOURCE) $(MATECONFTOOL) --makefile-install-rule $(schema_DATA)
+else
+install-data-local:
+endif
+
+BUILT_SOURCES =
+CLEANFILES = \
+	marco.desktop \
+	marco-wm.desktop \
+	marco.schemas \
+	marco.schemas.in \
+	50-marco-desktop-key.xml \
+	50-marco-key.xml
+
+pkgconfigdir = $(libdir)/pkgconfig
+
+pkgconfig_DATA = libmarco-private.pc
+
+EXTRA_DIST=$(desktopfiles_files) \
+	$(wmproperties_files) \
+	$(IMAGES) \
+	$(schema_DATA) \
+	$(desktopfiles_in_files) \
+	$(wmproperties_in_files) \
+	$(schema_in_files) \
+	$(xml_in_files) \
+	libmarco-private.pc.in
+
diff --git a/src/compositor/compositor-private.h b/src/compositor/compositor-private.h
new file mode 100644
index 00000000..ef9f8023
--- /dev/null
+++ b/src/compositor/compositor-private.h
@@ -0,0 +1,54 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_COMPOSITOR_PRIVATE_H
+#define META_COMPOSITOR_PRIVATE_H
+
+#include "compositor.h"
+
+struct _MetaCompositor
+{
+  void (* destroy) (MetaCompositor *compositor);
+
+  void (*manage_screen) (MetaCompositor *compositor,
+                         MetaScreen     *screen);
+  void (*unmanage_screen) (MetaCompositor *compositor,
+                           MetaScreen     *screen);
+  void (*add_window) (MetaCompositor    *compositor,
+                      MetaWindow        *window,
+                      Window             xwindow,
+                      XWindowAttributes *attrs);
+  void (*remove_window) (MetaCompositor *compositor,
+                         Window          xwindow);
+  void (*set_updates) (MetaCompositor *compositor,
+                       MetaWindow     *window,
+                       gboolean        update);
+  void (*process_event) (MetaCompositor *compositor,
+                         XEvent         *event,
+                         MetaWindow     *window);
+  Pixmap (*get_window_pixmap) (MetaCompositor *compositor,
+                               MetaWindow     *window);
+  void (*set_active_window) (MetaCompositor *compositor,
+                             MetaScreen     *screen,
+                             MetaWindow     *window);
+};
+
+#endif
diff --git a/src/compositor/compositor-xrender.c b/src/compositor/compositor-xrender.c
new file mode 100644
index 00000000..e0938706
--- /dev/null
+++ b/src/compositor/compositor-xrender.c
@@ -0,0 +1,3078 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2007 Iain Holmes
+ * Based on xcompmgr - (c) 2003 Keith Packard
+ *          xfwm4    - (c) 2005-2007 Olivier Fourdan
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE 500 /* for usleep() */
+
+#include <config.h>
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+
+#include <gdk/gdk.h>
+
+#include "display.h"
+#include "screen.h"
+#include "frame.h"
+#include "errors.h"
+#include "window.h"
+#include "compositor-private.h"
+#include "compositor-xrender.h"
+#include "xprops.h"
+#include <X11/Xatom.h>
+#include <X11/extensions/shape.h>
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xfixes.h>
+#include <X11/extensions/Xrender.h>
+
+#if COMPOSITE_MAJOR > 0 || COMPOSITE_MINOR >= 2
+#define HAVE_NAME_WINDOW_PIXMAP 1
+#endif
+
+#if COMPOSITE_MAJOR > 0 || COMPOSITE_MINOR >= 3
+#define HAVE_COW 1
+#else
+/* Don't have a cow man...HAAHAAHAA */
+#endif
+
+#define USE_IDLE_REPAINT 1
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+static inline gboolean
+composite_at_least_version (MetaDisplay *display,
+                            int maj, int min)
+{
+  static int major = -1;
+  static int minor = -1;
+
+  if (major == -1)
+    meta_display_get_compositor_version (display, &major, &minor);
+
+  return (major > maj || (major == maj && minor >= min));
+}
+
+#define have_name_window_pixmap(display) \
+  composite_at_least_version (display, 0, 2)
+#define have_cow(display) \
+  composite_at_least_version (display, 0, 3)
+
+#endif
+
+typedef enum _MetaCompWindowType
+{
+  META_COMP_WINDOW_NORMAL,
+  META_COMP_WINDOW_DND,
+  META_COMP_WINDOW_DESKTOP,
+  META_COMP_WINDOW_DOCK,
+  META_COMP_WINDOW_MENU,
+  META_COMP_WINDOW_DROP_DOWN_MENU,
+  META_COMP_WINDOW_TOOLTIP,
+} MetaCompWindowType;
+
+typedef enum _MetaShadowType
+{
+  META_SHADOW_SMALL,
+  META_SHADOW_MEDIUM,
+  META_SHADOW_LARGE,
+  LAST_SHADOW_TYPE
+} MetaShadowType;
+
+typedef struct _MetaCompositorXRender
+{
+  MetaCompositor compositor;
+
+  MetaDisplay *display;
+
+  Atom atom_x_root_pixmap;
+  Atom atom_x_set_root;
+  Atom atom_net_wm_window_opacity;
+  Atom atom_net_wm_window_type_dnd;
+
+  Atom atom_net_wm_window_type;
+  Atom atom_net_wm_window_type_desktop;
+  Atom atom_net_wm_window_type_dock;
+  Atom atom_net_wm_window_type_menu;
+  Atom atom_net_wm_window_type_dialog;
+  Atom atom_net_wm_window_type_normal;
+  Atom atom_net_wm_window_type_utility;
+  Atom atom_net_wm_window_type_splash;
+  Atom atom_net_wm_window_type_toolbar;
+  Atom atom_net_wm_window_type_dropdown_menu;
+  Atom atom_net_wm_window_type_tooltip;
+
+#ifdef USE_IDLE_REPAINT
+  guint repaint_id;
+#endif
+  guint enabled : 1;
+  guint show_redraw : 1;
+  guint debug : 1;
+} MetaCompositorXRender;
+
+typedef struct _conv
+{
+  int size;
+  double *data;
+} conv;
+
+typedef struct _shadow
+{
+  conv *gaussian_map;
+  guchar *shadow_corner;
+  guchar *shadow_top;
+} shadow;
+
+typedef struct _MetaCompScreen
+{
+  MetaScreen *screen;
+  GList *windows;
+  GHashTable *windows_by_xid;
+
+  MetaWindow *focus_window;
+
+  Window output;
+
+  gboolean have_shadows;
+  shadow *shadows[LAST_SHADOW_TYPE];
+
+  Picture root_picture;
+  Picture root_buffer;
+  Picture black_picture;
+  Picture trans_black_picture;
+  Picture root_tile;
+  XserverRegion all_damage;
+
+  guint overlays;
+  gboolean compositor_active;
+  gboolean clip_changed;
+
+  GSList *dock_windows;
+} MetaCompScreen;
+
+typedef struct _MetaCompWindow
+{
+  MetaScreen *screen;
+  MetaWindow *window; /* May be NULL if this window isn't managed by Marco */
+  Window id;
+  XWindowAttributes attrs;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  Pixmap back_pixmap;
+
+  /* When the window is shaded back_pixmap will be replaced with the pixmap
+     for the shaded window. This is a copy of the original unshaded window
+     so that we can still see what the window looked like when it is needed
+     for the _get_window_pixmap function */
+  Pixmap shaded_back_pixmap;
+#endif
+
+  int mode;
+
+  gboolean damaged;
+  gboolean shaped;
+
+  MetaCompWindowType type;
+
+  Damage damage;
+  Picture picture;
+  Picture alpha_pict;
+
+  gboolean needs_shadow;
+  MetaShadowType shadow_type;
+  Picture shadow_pict;
+
+  XserverRegion border_size;
+  XserverRegion extents;
+
+  Picture shadow;
+  int shadow_dx;
+  int shadow_dy;
+  int shadow_width;
+  int shadow_height;
+
+  guint opacity;
+
+  XserverRegion border_clip;
+
+  gboolean updates_frozen;
+  gboolean update_pending;
+} MetaCompWindow;
+
+#define OPAQUE 0xffffffff
+
+#define WINDOW_SOLID 0
+#define WINDOW_ARGB 1
+
+#define SHADOW_SMALL_RADIUS 3.0
+#define SHADOW_MEDIUM_RADIUS 6.0
+#define SHADOW_LARGE_RADIUS 12.0
+
+#define SHADOW_SMALL_OFFSET_X (SHADOW_SMALL_RADIUS * -3 / 2)
+#define SHADOW_SMALL_OFFSET_Y (SHADOW_SMALL_RADIUS * -3 / 2)
+#define SHADOW_MEDIUM_OFFSET_X (SHADOW_MEDIUM_RADIUS * -3 / 2)
+#define SHADOW_MEDIUM_OFFSET_Y (SHADOW_MEDIUM_RADIUS * -5 / 4)
+#define SHADOW_LARGE_OFFSET_X -15
+#define SHADOW_LARGE_OFFSET_Y -15
+
+#define SHADOW_OPACITY 0.66
+
+#define TRANS_OPACITY 0.75
+
+#define DISPLAY_COMPOSITOR(display) ((MetaCompositorXRender *) meta_display_get_compositor (display))
+
+/* Gaussian stuff for creating the shadows */
+static double
+gaussian (double r,
+          double x,
+          double y)
+{
+  return ((1 / (sqrt (2 * G_PI * r))) *
+          exp ((- (x * x + y * y)) / (2 * r * r)));
+}
+
+static conv *
+make_gaussian_map (double r)
+{
+  conv *c;
+  int size, centre;
+  int x, y;
+  double t, g;
+
+  size = ((int) ceil ((r * 3)) + 1) & ~1;
+  centre = size / 2;
+  c = g_malloc (sizeof (conv) + size * size * sizeof (double));
+  c->size = size;
+  c->data = (double *) (c + 1);
+  t = 0.0;
+
+  for (y = 0; y < size; y++)
+    {
+      for (x = 0; x < size; x++)
+        {
+          g = gaussian (r, (double) (x - centre), (double) (y - centre));
+          t += g;
+          c->data[y * size + x] = g;
+        }
+    }
+
+  for (y = 0; y < size; y++)
+    {
+      for (x = 0; x < size; x++)
+        {
+          c->data[y * size + x] /= t;
+        }
+    }
+
+  return c;
+}
+
+static void
+dump_xserver_region (const char   *location,
+                     MetaDisplay  *display,
+                     XserverRegion region)
+{
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  int nrects;
+  XRectangle *rects;
+  XRectangle bounds;
+
+  if (!compositor->debug)
+    return;
+
+  if (region)
+    {
+      rects = XFixesFetchRegionAndBounds (xdisplay, region, &nrects, &bounds);
+      if (nrects > 0)
+        {
+          int i;
+          fprintf (stderr, "%s (XSR): %d rects, bounds: %d,%d (%d,%d)\n",
+                   location, nrects, bounds.x, bounds.y, bounds.width, bounds.height);
+          for (i = 1; i < nrects; i++)
+            fprintf (stderr, "\t%d,%d (%d,%d)\n",
+                     rects[i].x, rects[i].y, rects[i].width, rects[i].height);
+        }
+      else
+        fprintf (stderr, "%s (XSR): empty\n", location);
+      XFree (rects);
+    }
+  else
+    fprintf (stderr, "%s (XSR): null\n", location);
+}
+
+/*
+* A picture will help
+*
+*      -center   0                width  width+center
+*  -center +-----+-------------------+-----+
+*          |     |                   |     |
+*          |     |                   |     |
+*        0 +-----+-------------------+-----+
+*          |     |                   |     |
+*          |     |                   |     |
+*          |     |                   |     |
+*   height +-----+-------------------+-----+
+*          |     |                   |     |
+* height+  |     |                   |     |
+*  center  +-----+-------------------+-----+
+*/
+static guchar
+sum_gaussian (conv          *map,
+              double         opacity,
+              int            x,
+              int            y,
+              int            width,
+              int            height)
+{
+  double *g_data, *g_line;
+  double v;
+  int fx, fy;
+  int fx_start, fx_end;
+  int fy_start, fy_end;
+  int g_size, centre;
+
+  g_line = map->data;
+  g_size = map->size;
+  centre = g_size / 2;
+  fx_start = centre - x;
+  if (fx_start < 0)
+    fx_start = 0;
+
+  fx_end = width + centre - x;
+  if (fx_end > g_size)
+    fx_end = g_size;
+
+  fy_start = centre - y;
+  if (fy_start < 0)
+    fy_start = 0;
+
+  fy_end = height + centre - y;
+  if (fy_end > g_size)
+    fy_end = g_size;
+
+  g_line = g_line + fy_start * g_size + fx_start;
+
+  v = 0.0;
+  for (fy = fy_start; fy < fy_end; fy++)
+    {
+      g_data = g_line;
+      g_line += g_size;
+
+      for (fx = fx_start; fx < fx_end; fx++)
+        v += *g_data++;
+    }
+
+  if (v > 1.0)
+    v = 1.0;
+
+  return ((guchar) (v * opacity * 255.0));
+}
+
+/* precompute shadow corners and sides to save time for large windows */
+static void
+presum_gaussian (shadow *shad)
+{
+  int centre;
+  int opacity, x, y;
+  int msize;
+  conv *map;
+
+  map = shad->gaussian_map;
+  msize = map->size;
+  centre = map->size / 2;
+
+  if (shad->shadow_corner)
+    g_free (shad->shadow_corner);
+  if (shad->shadow_top)
+    g_free (shad->shadow_top);
+
+  shad->shadow_corner = (guchar *)(g_malloc ((msize + 1) * (msize + 1) * 26));
+  shad->shadow_top = (guchar *) (g_malloc ((msize + 1) * 26));
+
+  for (x = 0; x <= msize; x++)
+    {
+
+      shad->shadow_top[25 * (msize + 1) + x] =
+        sum_gaussian (map, 1, x - centre, centre, msize * 2, msize * 2);
+      for (opacity = 0; opacity < 25; opacity++)
+        {
+          shad->shadow_top[opacity * (msize + 1) + x] =
+            shad->shadow_top[25 * (msize + 1) + x] * opacity / 25;
+        }
+
+      for (y = 0; y <= x; y++)
+        {
+          shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                              + y * (msize + 1)
+                              + x]
+            = sum_gaussian (map, 1, x - centre, y - centre,
+                            msize * 2, msize * 2);
+
+          shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                              + x * (msize + 1) + y] =
+            shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                                + y * (msize + 1) + x];
+
+          for (opacity = 0; opacity < 25; opacity++)
+            {
+              shad->shadow_corner[opacity * (msize + 1) * (msize + 1)
+                                  + y * (msize + 1) + x]
+                = shad->shadow_corner[opacity * (msize + 1) * (msize + 1)
+                                      + x * (msize + 1) + y]
+                = shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                                      + y * (msize + 1) + x] * opacity / 25;
+            }
+        }
+    }
+}
+
+static void
+generate_shadows (MetaCompScreen *info)
+{
+  double radii[LAST_SHADOW_TYPE] = {SHADOW_SMALL_RADIUS,
+                                    SHADOW_MEDIUM_RADIUS,
+                                    SHADOW_LARGE_RADIUS};
+  int i;
+
+  for (i = 0; i < LAST_SHADOW_TYPE; i++) {
+    shadow *shad = g_new0 (shadow, 1);
+
+    shad->gaussian_map = make_gaussian_map (radii[i]);
+    presum_gaussian (shad);
+
+    info->shadows[i] = shad;
+  }
+}
+
+static XImage *
+make_shadow (MetaDisplay   *display,
+             MetaScreen    *screen,
+             MetaShadowType shadow_type,
+             double         opacity,
+             int            width,
+             int            height)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XImage *ximage;
+  guchar *data;
+  shadow *shad;
+  int msize;
+  int ylimit, xlimit;
+  int swidth, sheight;
+  int centre;
+  int x, y;
+  guchar d;
+  int x_diff;
+  int opacity_int = (int)(opacity * 25);
+  int screen_number = meta_screen_get_screen_number (screen);
+
+  if (info==NULL)
+    {
+      return NULL;
+    }
+
+  shad = info->shadows[shadow_type];
+  msize = shad->gaussian_map->size;
+  swidth = width + msize;
+  sheight = height + msize;
+  centre = msize / 2;
+
+  data = g_malloc (swidth * sheight * sizeof (guchar));
+
+  ximage = XCreateImage (xdisplay, DefaultVisual (xdisplay, screen_number),
+                         8, ZPixmap, 0, (char *) data,
+                         swidth, sheight, 8, swidth * sizeof (guchar));
+  if (!ximage)
+    {
+      g_free (data);
+      return NULL;
+    }
+
+  /*
+   * Build the gaussian in sections
+   */
+
+  /*
+   * centre (fill the complete data array
+   */
+  if (msize > 0)
+    d = shad->shadow_top[opacity_int * (msize + 1) + msize];
+  else
+    d = sum_gaussian (shad->gaussian_map, opacity, centre,
+                      centre, width, height);
+  memset (data, d, sheight * swidth);
+
+  /*
+   * corners
+   */
+  ylimit = msize;
+  if (ylimit > sheight / 2)
+    ylimit = (sheight + 1) / 2;
+
+  xlimit = msize;
+  if (xlimit > swidth / 2)
+    xlimit = (swidth + 1) / 2;
+
+  for (y = 0; y < ylimit; y++)
+    {
+      for (x = 0; x < xlimit; x++)
+        {
+
+          if (xlimit == msize && ylimit == msize)
+            d = shad->shadow_corner[opacity_int * (msize + 1) * (msize + 1) + y * (msize + 1) + x];
+          else
+            d = sum_gaussian (shad->gaussian_map, opacity, x - centre,
+                              y - centre, width, height);
+
+          data[y * swidth + x] = d;
+          data[(sheight - y - 1) * swidth + x] = d;
+          data[(sheight - y - 1) * swidth + (swidth - x - 1)] = d;
+          data[y * swidth + (swidth - x - 1)] = d;
+        }
+    }
+
+  /* top/bottom */
+  x_diff = swidth - (msize * 2);
+  if (x_diff > 0 && ylimit > 0)
+    {
+      for (y = 0; y < ylimit; y++)
+        {
+          if (ylimit == msize)
+            d = shad->shadow_top[opacity_int * (msize + 1) + y];
+          else
+            d = sum_gaussian (shad->gaussian_map, opacity, centre,
+                              y - centre, width, height);
+
+          memset (&data[y * swidth + msize], d, x_diff);
+          memset (&data[(sheight - y - 1) * swidth + msize], d, x_diff);
+        }
+    }
+
+  /*
+   * sides
+   */
+  for (x = 0; x < xlimit; x++)
+    {
+      if (xlimit == msize)
+        d = shad->shadow_top[opacity_int * (msize + 1) + x];
+      else
+        d = sum_gaussian (shad->gaussian_map, opacity, x - centre,
+                          centre, width, height);
+
+      for (y = msize; y < sheight - msize; y++)
+        {
+          data[y * swidth + x] = d;
+          data[y * swidth + (swidth - x - 1)] = d;
+        }
+    }
+
+  return ximage;
+}
+
+static Picture
+shadow_picture (MetaDisplay   *display,
+                MetaScreen    *screen,
+                MetaShadowType shadow_type,
+                double         opacity,
+                Picture        alpha_pict,
+                int            width,
+                int            height,
+                int           *wp,
+                int           *hp)
+{
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XImage *shadow_image;
+  Pixmap shadow_pixmap;
+  Picture shadow_picture;
+  Window xroot = meta_screen_get_xroot (screen);
+  GC gc;
+
+  shadow_image = make_shadow (display, screen, shadow_type,
+                              opacity, width, height);
+  if (!shadow_image)
+    return None;
+
+  shadow_pixmap = XCreatePixmap (xdisplay, xroot,
+                                 shadow_image->width, shadow_image->height, 8);
+  if (!shadow_pixmap)
+    {
+      XDestroyImage (shadow_image);
+      return None;
+    }
+
+  shadow_picture = XRenderCreatePicture (xdisplay, shadow_pixmap,
+                                         XRenderFindStandardFormat (xdisplay,
+PictStandardA8),
+                                         0, 0);
+  if (!shadow_picture)
+    {
+      XDestroyImage (shadow_image);
+      XFreePixmap (xdisplay, shadow_pixmap);
+      return None;
+    }
+
+  gc = XCreateGC (xdisplay, shadow_pixmap, 0, 0);
+  if (!gc)
+    {
+      XDestroyImage (shadow_image);
+      XFreePixmap (xdisplay, shadow_pixmap);
+      XRenderFreePicture (xdisplay, shadow_picture);
+      return None;
+    }
+
+  XPutImage (xdisplay, shadow_pixmap, gc, shadow_image, 0, 0, 0, 0,
+             shadow_image->width, shadow_image->height);
+  *wp = shadow_image->width;
+  *hp = shadow_image->height;
+
+  XFreeGC (xdisplay, gc);
+  XDestroyImage (shadow_image);
+  XFreePixmap (xdisplay, shadow_pixmap);
+
+  return shadow_picture;
+}
+
+static MetaCompWindow *
+find_window_for_screen (MetaScreen *screen,
+                        Window      xwindow)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (info == NULL)
+    return NULL;
+
+  return g_hash_table_lookup (info->windows_by_xid, (gpointer) xwindow);
+}
+
+static MetaCompWindow *
+find_window_in_display (MetaDisplay *display,
+                        Window       xwindow)
+{
+  GSList *index;
+
+  for (index = meta_display_get_screens (display); index; index = index->next)
+    {
+      MetaCompWindow *cw = find_window_for_screen (index->data, xwindow);
+
+      if (cw != NULL)
+        return cw;
+    }
+
+  return NULL;
+}
+
+static MetaCompWindow *
+find_window_for_child_window_in_display (MetaDisplay *display,
+                                         Window       xwindow)
+{
+  Window ignored1, *ignored2;
+  Window parent;
+  guint ignored_children;
+
+  XQueryTree (meta_display_get_xdisplay (display), xwindow, &ignored1,
+              &parent, &ignored2, &ignored_children);
+
+  if (parent != None)
+    return find_window_in_display (display, parent);
+
+  return NULL;
+}
+
+static Picture
+solid_picture (MetaDisplay *display,
+               MetaScreen  *screen,
+               gboolean     argb,
+               double       a,
+               double       r,
+               double       g,
+               double       b)
+{
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Pixmap pixmap;
+  Picture picture;
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *render_format;
+  XRenderColor c;
+  Window xroot = meta_screen_get_xroot (screen);
+
+  render_format = XRenderFindStandardFormat (xdisplay,
+                                             argb ? PictStandardARGB32 : PictStandardA8);
+
+  pixmap = XCreatePixmap (xdisplay, xroot, 1, 1, argb ? 32 : 8);
+  g_return_val_if_fail (pixmap != None, None);
+
+  pa.repeat = TRUE;
+  picture = XRenderCreatePicture (xdisplay, pixmap, render_format,
+                                  CPRepeat, &pa);
+  if (picture == None)
+    {
+      XFreePixmap (xdisplay, pixmap);
+      g_warning ("(picture != None) failed");
+      return None;
+    }
+
+  c.alpha = a * 0xffff;
+  c.red = r * 0xffff;
+  c.green = g * 0xffff;
+  c.blue = b * 0xffff;
+
+  XRenderFillRectangle (xdisplay, PictOpSrc, picture, &c, 0, 0, 1, 1);
+  XFreePixmap (xdisplay, pixmap);
+
+  return picture;
+}
+
+static Picture
+root_tile (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Picture picture;
+  Pixmap pixmap;
+  gboolean fill = FALSE;
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *format;
+  int p;
+  Atom background_atoms[2];
+  Atom pixmap_atom;
+  int screen_number = meta_screen_get_screen_number (screen);
+  Window xroot = meta_screen_get_xroot (screen);
+
+  pixmap = None;
+  background_atoms[0] = DISPLAY_COMPOSITOR (display)->atom_x_root_pixmap;
+  background_atoms[1] = DISPLAY_COMPOSITOR (display)->atom_x_set_root;
+
+  pixmap_atom = XInternAtom (xdisplay, "PIXMAP", False);
+  for (p = 0; p < 2; p++)
+    {
+      Atom actual_type;
+      int actual_format;
+      gulong nitems, bytes_after;
+      guchar *prop;
+
+      if (XGetWindowProperty (xdisplay, xroot,
+                              background_atoms[p],
+                              0, 4, FALSE, AnyPropertyType,
+                              &actual_type, &actual_format,
+                              &nitems, &bytes_after, &prop) == Success)
+        {
+          if (actual_type == pixmap_atom &&
+              actual_format == 32 &&
+              nitems == 1)
+            {
+              memcpy (&pixmap, prop, 4);
+              XFree (prop);
+              fill = FALSE;
+              break;
+            }
+        }
+    }
+
+  if (!pixmap)
+    {
+      pixmap = XCreatePixmap (xdisplay, xroot, 1, 1,
+                              DefaultDepth (xdisplay, screen_number));
+      g_return_val_if_fail (pixmap != None, None);
+      fill = TRUE;
+    }
+
+  pa.repeat = TRUE;
+  format = XRenderFindVisualFormat (xdisplay, DefaultVisual (xdisplay,
+                                                             screen_number));
+  g_return_val_if_fail (format != NULL, None);
+
+  picture = XRenderCreatePicture (xdisplay, pixmap, format, CPRepeat, &pa);
+  if ((picture != None) && (fill))
+    {
+      XRenderColor c;
+
+      /* Background default to just plain ugly grey */
+      c.red = 0x8080;
+      c.green = 0x8080;
+      c.blue = 0x8080;
+      c.alpha = 0xffff;
+
+      XRenderFillRectangle (xdisplay, PictOpSrc, picture, &c, 0, 0, 1, 1);
+      XFreePixmap (xdisplay, pixmap);
+    }
+
+  return picture;
+}
+
+static Picture
+create_root_buffer (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Picture pict;
+  XRenderPictFormat *format;
+  Pixmap root_pixmap;
+  Visual *visual;
+  int depth, screen_width, screen_height, screen_number;
+
+  if (info == NULL)
+    {
+      return None;
+    }
+
+  meta_screen_get_size (screen, &screen_width, &screen_height);
+  screen_number = meta_screen_get_screen_number (screen);
+  visual = DefaultVisual (xdisplay, screen_number);
+  depth = DefaultDepth (xdisplay, screen_number);
+
+  format = XRenderFindVisualFormat (xdisplay, visual);
+  g_return_val_if_fail (format != NULL, None);
+
+  root_pixmap = XCreatePixmap (xdisplay, info->output,
+                               screen_width, screen_height, depth);
+  g_return_val_if_fail (root_pixmap != None, None);
+
+  pict = XRenderCreatePicture (xdisplay, root_pixmap, format, 0, NULL);
+  XFreePixmap (xdisplay, root_pixmap);
+
+  return pict;
+}
+
+static void
+paint_root (MetaScreen *screen,
+            Picture     root_buffer)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  int width, height;
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  g_return_if_fail (root_buffer != None);
+
+  if (info->root_tile == None)
+    {
+      info->root_tile = root_tile (screen);
+      g_return_if_fail (info->root_tile != None);
+    }
+
+  meta_screen_get_size (screen, &width, &height);
+  XRenderComposite (xdisplay, PictOpSrc, info->root_tile, None, root_buffer,
+                    0, 0, 0, 0, 0, 0, width, height);
+}
+
+static gboolean
+window_has_shadow (MetaCompWindow *cw)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (cw->screen);
+
+  if (info == NULL || info->have_shadows == FALSE)
+    return FALSE;
+
+  /* Always put a shadow around windows with a frame - This should override
+     the restriction about not putting a shadow around shaped windows
+     as the frame might be the reason the window is shaped */
+  if (cw->window)
+    {
+      if (meta_window_get_frame (cw->window)) {
+        meta_verbose ("Window has shadow because it has a frame\n");
+        return TRUE;
+      }
+    }
+
+  /* Never put a shadow around shaped windows */
+  if (cw->shaped) {
+    meta_verbose ("Window has no shadow as it is shaped\n");
+    return FALSE;
+  }
+
+  /* Don't put shadow around DND icon windows */
+  if (cw->type == META_COMP_WINDOW_DND ||
+      cw->type == META_COMP_WINDOW_DESKTOP) {
+    meta_verbose ("Window has no shadow as it is DND or Desktop\n");
+    return FALSE;
+  }
+
+  if (cw->mode != WINDOW_ARGB) {
+    meta_verbose ("Window has shadow as it is not ARGB\n");
+    return TRUE;
+  }
+
+  if (cw->type == META_COMP_WINDOW_MENU ||
+      cw->type == META_COMP_WINDOW_DROP_DOWN_MENU) {
+    meta_verbose ("Window has shadow as it is a menu\n");
+    return TRUE;
+  }
+
+  if (cw->type == META_COMP_WINDOW_TOOLTIP) {
+    meta_verbose ("Window has shadow as it is a tooltip\n");
+    return TRUE;
+  }
+
+  meta_verbose ("Window has no shadow as it fell through\n");
+  return FALSE;
+}
+
+double shadow_offsets_x[LAST_SHADOW_TYPE] = {SHADOW_SMALL_OFFSET_X,
+                                             SHADOW_MEDIUM_OFFSET_X,
+                                             SHADOW_LARGE_OFFSET_X};
+double shadow_offsets_y[LAST_SHADOW_TYPE] = {SHADOW_SMALL_OFFSET_Y,
+                                             SHADOW_MEDIUM_OFFSET_Y,
+                                             SHADOW_LARGE_OFFSET_Y};
+static XserverRegion
+win_extents (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRectangle r;
+
+  r.x = cw->attrs.x;
+  r.y = cw->attrs.y;
+  r.width = cw->attrs.width + cw->attrs.border_width * 2;
+  r.height = cw->attrs.height + cw->attrs.border_width * 2;
+
+  if (cw->needs_shadow)
+    {
+      XRectangle sr;
+
+      cw->shadow_dx = shadow_offsets_x [cw->shadow_type];
+      cw->shadow_dy = shadow_offsets_y [cw->shadow_type];
+
+      if (!cw->shadow)
+        {
+          double opacity = SHADOW_OPACITY;
+          if (cw->opacity != (guint) OPAQUE)
+            opacity = opacity * ((double) cw->opacity) / ((double) OPAQUE);
+
+          cw->shadow = shadow_picture (display, screen, cw->shadow_type,
+                                       opacity, cw->alpha_pict,
+                                       cw->attrs.width + cw->attrs.border_width * 2,
+                                       cw->attrs.height + cw->attrs.border_width * 2,
+                                       &cw->shadow_width, &cw->shadow_height);
+        }
+
+      sr.x = cw->attrs.x + cw->shadow_dx;
+      sr.y = cw->attrs.y + cw->shadow_dy;
+      sr.width = cw->shadow_width;
+      sr.height = cw->shadow_height;
+
+      if (sr.x < r.x)
+        {
+          r.width = (r.x + r.width) - sr.x;
+          r.x = sr.x;
+        }
+
+      if (sr.y < r.y)
+        {
+          r.height = (r.y + r.height) - sr.y;
+          r.y = sr.y;
+        }
+
+      if (sr.x + sr.width > r.x + r.width)
+        r.width = sr.x + sr.width - r.x;
+
+      if (sr.y + sr.height > r.y + r.height)
+        r.height = sr.y + sr.height - r.y;
+    }
+
+  return XFixesCreateRegion (xdisplay, &r, 1);
+}
+
+static XserverRegion
+border_size (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion border;
+
+  meta_error_trap_push (display);
+  border = XFixesCreateRegionFromWindow (xdisplay, cw->id,
+                                         WindowRegionBounding);
+  meta_error_trap_pop (display, FALSE);
+
+  g_return_val_if_fail (border != None, None);
+  XFixesTranslateRegion (xdisplay, border,
+                         cw->attrs.x + cw->attrs.border_width,
+                         cw->attrs.y + cw->attrs.border_width);
+  return border;
+}
+
+static XRenderPictFormat *
+get_window_format (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRenderPictFormat *format;
+  int screen_number = meta_screen_get_screen_number (screen);
+
+  format = XRenderFindVisualFormat (xdisplay, cw->attrs.visual);
+  if (!format)
+    format = XRenderFindVisualFormat (xdisplay,
+                                      DefaultVisual (xdisplay, screen_number));
+  return format;
+}
+
+static Picture
+get_window_picture (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *format;
+  Drawable draw;
+
+  draw = cw->id;
+
+  meta_error_trap_push (display);
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (have_name_window_pixmap (display))
+    {
+      if (cw->back_pixmap == None)
+        cw->back_pixmap = XCompositeNameWindowPixmap (xdisplay, cw->id);
+
+      if (cw->back_pixmap != None)
+        draw = cw->back_pixmap;
+    }
+#endif
+
+  format = get_window_format (cw);
+  if (format)
+    {
+      Picture pict;
+
+      pa.subwindow_mode = IncludeInferiors;
+
+      pict = XRenderCreatePicture (xdisplay, draw, format, CPSubwindowMode, &pa);
+      meta_error_trap_pop (display, FALSE);
+
+      return pict;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+  return None;
+}
+
+static void
+paint_dock_shadows (MetaScreen   *screen,
+                    Picture       root_buffer,
+                    XserverRegion region)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  GSList *d;
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  for (d = info->dock_windows; d; d = d->next)
+    {
+      MetaCompWindow *cw = d->data;
+      XserverRegion shadow_clip;
+
+      if (cw->shadow)
+        {
+          shadow_clip = XFixesCreateRegion (xdisplay, NULL, 0);
+          XFixesIntersectRegion (xdisplay, shadow_clip,
+                                 cw->border_clip, region);
+
+          XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0, shadow_clip);
+
+          XRenderComposite (xdisplay, PictOpOver, info->black_picture,
+                            cw->shadow, root_buffer,
+                            0, 0, 0, 0,
+                            cw->attrs.x + cw->shadow_dx,
+                            cw->attrs.y + cw->shadow_dy,
+                            cw->shadow_width, cw->shadow_height);
+          XFixesDestroyRegion (xdisplay, shadow_clip);
+        }
+    }
+}
+
+static void
+paint_windows (MetaScreen   *screen,
+               GList        *windows,
+               Picture       root_buffer,
+               XserverRegion region)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  GList *index, *last;
+  int screen_width, screen_height, screen_number;
+  Window xroot;
+  MetaCompWindow *cw;
+  XserverRegion paint_region, desktop_region;
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  meta_screen_get_size (screen, &screen_width, &screen_height);
+  screen_number = meta_screen_get_screen_number (screen);
+  xroot = meta_screen_get_xroot (screen);
+
+  if (region == None)
+    {
+      XRectangle r;
+      r.x = 0;
+      r.y = 0;
+      r.width = screen_width;
+      r.height = screen_height;
+      paint_region = XFixesCreateRegion (xdisplay, &r, 1);
+    }
+  else
+    {
+      paint_region = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, paint_region, region);
+    }
+
+  desktop_region = None;
+
+  /*
+   * Painting from top to bottom, reducing the clipping area at
+   * each iteration. Only the opaque windows are painted 1st.
+   */
+  last = NULL;
+  for (index = windows; index; index = index->next)
+    {
+      /* Store the last window we dealt with */
+      last = index;
+
+      cw = (MetaCompWindow *) index->data;
+      if (!cw->damaged)
+        {
+          /* Not damaged */
+          continue;
+        }
+
+#if 0
+      if ((cw->attrs.x + cw->attrs.width < 1) ||
+          (cw->attrs.y + cw->attrs.height < 1) ||
+          (cw->attrs.x >= screen_width) || (cw->attrs.y >= screen_height))
+        {
+          /* Off screen */
+          continue;
+        }
+#endif
+
+      if (cw->picture == None)
+        cw->picture = get_window_picture (cw);
+
+      /* If the clip region of the screen has been changed
+         then we need to recreate the extents of the window */
+      if (info->clip_changed)
+        {
+          if (cw->border_size)
+            {
+              XFixesDestroyRegion (xdisplay, cw->border_size);
+              cw->border_size = None;
+            }
+
+#if 0
+          if (cw->extents)
+            {
+              XFixesDestroyRegion (xdisplay, cw->extents);
+              cw->extents = None;
+            }
+#endif
+        }
+
+      if (cw->border_size == None)
+        cw->border_size = border_size (cw);
+
+      if (cw->extents == None)
+        cw->extents = win_extents (cw);
+
+      if (cw->mode == WINDOW_SOLID)
+        {
+          int x, y, wid, hei;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+          if (have_name_window_pixmap (display))
+            {
+              x = cw->attrs.x;
+              y = cw->attrs.y;
+              wid = cw->attrs.width + cw->attrs.border_width * 2;
+              hei = cw->attrs.height + cw->attrs.border_width * 2;
+            }
+          else
+#endif
+            {
+              x = cw->attrs.x + cw->attrs.border_width;
+              y = cw->attrs.y + cw->attrs.border_width;
+              wid = cw->attrs.width;
+              hei = cw->attrs.height;
+            }
+
+          XFixesSetPictureClipRegion (xdisplay, root_buffer,
+                                      0, 0, paint_region);
+          XRenderComposite (xdisplay, PictOpSrc, cw->picture,
+                            None, root_buffer, 0, 0, 0, 0,
+                            x, y, wid, hei);
+
+          if (cw->type == META_COMP_WINDOW_DESKTOP)
+            {
+              desktop_region = XFixesCreateRegion (xdisplay, 0, 0);
+              XFixesCopyRegion (xdisplay, desktop_region, paint_region);
+            }
+
+          XFixesSubtractRegion (xdisplay, paint_region,
+                                paint_region, cw->border_size);
+        }
+
+      if (!cw->border_clip)
+        {
+          cw->border_clip = XFixesCreateRegion (xdisplay, 0, 0);
+          XFixesCopyRegion (xdisplay, cw->border_clip, paint_region);
+        }
+    }
+
+  XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0, paint_region);
+  paint_root (screen, root_buffer);
+
+  paint_dock_shadows (screen, root_buffer, desktop_region == None ?
+                      paint_region : desktop_region);
+  if (desktop_region != None)
+    XFixesDestroyRegion (xdisplay, desktop_region);
+
+  /*
+   * Painting from bottom to top, translucent windows and shadows are painted
+   */
+  for (index = last; index; index = index->prev)
+    {
+      cw = (MetaCompWindow *) index->data;
+
+      if (cw->picture)
+        {
+          if (cw->shadow && cw->type != META_COMP_WINDOW_DOCK)
+            {
+              XserverRegion shadow_clip;
+
+              shadow_clip = XFixesCreateRegion (xdisplay, NULL, 0);
+              XFixesSubtractRegion (xdisplay, shadow_clip, cw->border_clip,
+                                    cw->border_size);
+              XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0,
+                                          shadow_clip);
+
+              XRenderComposite (xdisplay, PictOpOver, info->black_picture,
+                                cw->shadow, root_buffer,
+                                0, 0, 0, 0,
+                                cw->attrs.x + cw->shadow_dx,
+                                cw->attrs.y + cw->shadow_dy,
+                                cw->shadow_width, cw->shadow_height);
+              if (shadow_clip)
+                XFixesDestroyRegion (xdisplay, shadow_clip);
+            }
+
+          if ((cw->opacity != (guint) OPAQUE) && !(cw->alpha_pict))
+            {
+              cw->alpha_pict = solid_picture (display, screen, FALSE,
+                                              (double) cw->opacity / OPAQUE,
+                                              0, 0, 0);
+            }
+
+          XFixesIntersectRegion (xdisplay, cw->border_clip, cw->border_clip,
+                                 cw->border_size);
+          XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0,
+                                      cw->border_clip);
+          if (cw->mode == WINDOW_ARGB)
+            {
+              int x, y, wid, hei;
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+              if (have_name_window_pixmap (display))
+                {
+                  x = cw->attrs.x;
+                  y = cw->attrs.y;
+                  wid = cw->attrs.width + cw->attrs.border_width * 2;
+                  hei = cw->attrs.height + cw->attrs.border_width * 2;
+                }
+              else
+#endif
+                {
+                  x = cw->attrs.x + cw->attrs.border_width;
+                  y = cw->attrs.y + cw->attrs.border_width;
+                  wid = cw->attrs.width;
+                  hei = cw->attrs.height;
+                }
+
+              XRenderComposite (xdisplay, PictOpOver, cw->picture,
+                                cw->alpha_pict, root_buffer, 0, 0, 0, 0,
+                                x, y, wid, hei);
+            }
+        }
+
+      if (cw->border_clip)
+        {
+          XFixesDestroyRegion (xdisplay, cw->border_clip);
+          cw->border_clip = None;
+        }
+    }
+
+  XFixesDestroyRegion (xdisplay, paint_region);
+}
+
+static void
+paint_all (MetaScreen   *screen,
+           XserverRegion region)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  int screen_width, screen_height;
+
+  /* Set clipping to the given region */
+  XFixesSetPictureClipRegion (xdisplay, info->root_picture, 0, 0, region);
+
+  meta_screen_get_size (screen, &screen_width, &screen_height);
+
+  if (DISPLAY_COMPOSITOR (display)->show_redraw)
+    {
+      Picture overlay;
+
+      dump_xserver_region ("paint_all", display, region);
+
+      /* Make a random colour overlay */
+      overlay = solid_picture (display, screen, TRUE, 1, /* 0.3, alpha */
+                               ((double) (rand () % 100)) / 100.0,
+                               ((double) (rand () % 100)) / 100.0,
+                               ((double) (rand () % 100)) / 100.0);
+
+      XRenderComposite (xdisplay, PictOpOver, overlay, None, info->root_picture,
+                        0, 0, 0, 0, 0, 0, screen_width, screen_height);
+      XRenderFreePicture (xdisplay, overlay);
+      XFlush (xdisplay);
+      usleep (100 * 1000);
+    }
+
+  if (info->root_buffer == None)
+    info->root_buffer = create_root_buffer (screen);
+
+  paint_windows (screen, info->windows, info->root_buffer, region);
+
+  XFixesSetPictureClipRegion (xdisplay, info->root_buffer, 0, 0, region);
+  XRenderComposite (xdisplay, PictOpSrc, info->root_buffer, None,
+                    info->root_picture, 0, 0, 0, 0, 0, 0,
+                    screen_width, screen_height);
+}
+
+static void
+repair_screen (MetaScreen *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (info!=NULL && info->all_damage != None)
+    {
+      meta_error_trap_push (display);
+      paint_all (screen, info->all_damage);
+      XFixesDestroyRegion (xdisplay, info->all_damage);
+      info->all_damage = None;
+      info->clip_changed = FALSE;
+      meta_error_trap_pop (display, FALSE);
+    }
+}
+
+static void
+repair_display (MetaDisplay *display)
+{
+  GSList *screens = meta_display_get_screens (display);
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+
+#ifdef USE_IDLE_REPAINT
+  if (compositor->repaint_id > 0)
+    {
+      g_source_remove (compositor->repaint_id);
+      compositor->repaint_id = 0;
+    }
+#endif
+
+  for (; screens; screens = screens->next)
+    repair_screen ((MetaScreen *) screens->data);
+}
+
+#ifdef USE_IDLE_REPAINT
+static gboolean
+compositor_idle_cb (gpointer data)
+{
+  MetaCompositorXRender *compositor = (MetaCompositorXRender *) data;
+
+  compositor->repaint_id = 0;
+  repair_display (compositor->display);
+
+  return FALSE;
+}
+
+static void
+add_repair (MetaDisplay *display)
+{
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+
+  if (compositor->repaint_id > 0)
+    return;
+
+#if 1
+  compositor->repaint_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+                                            compositor_idle_cb, compositor,
+                                            NULL);
+#else
+  /* Limit it to 50fps */
+  compositor->repaint_id = g_timeout_add_full (G_PRIORITY_HIGH, 20,
+                                               compositor_idle_cb, compositor,
+                                               NULL);
+#endif
+}
+#endif
+
+static void
+add_damage (MetaScreen     *screen,
+            XserverRegion   damage)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  /*  dump_xserver_region ("add_damage", display, damage); */
+
+  if (info != NULL && info->all_damage)
+    {
+      XFixesUnionRegion (xdisplay, info->all_damage, info->all_damage, damage);
+      XFixesDestroyRegion (xdisplay, damage);
+    }
+  else
+    info->all_damage = damage;
+
+#ifdef USE_IDLE_REPAINT
+  add_repair (display);
+#endif
+}
+
+static void
+damage_screen (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion region;
+  int width, height;
+  XRectangle r;
+
+  r.x = 0;
+  r.y = 0;
+  meta_screen_get_size (screen, &width, &height);
+  r.width = width;
+  r.height = height;
+
+  region = XFixesCreateRegion (xdisplay, &r, 1);
+  dump_xserver_region ("damage_screen", display, region);
+  add_damage (screen, region);
+}
+
+static void
+repair_win (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion parts;
+
+  meta_error_trap_push (display);
+  if (!cw->damaged)
+    {
+      parts = win_extents (cw);
+      XDamageSubtract (xdisplay, cw->damage, None, None);
+    }
+  else
+    {
+      parts = XFixesCreateRegion (xdisplay, 0, 0);
+      XDamageSubtract (xdisplay, cw->damage, None, parts);
+      XFixesTranslateRegion (xdisplay, parts,
+                             cw->attrs.x + cw->attrs.border_width,
+                             cw->attrs.y + cw->attrs.border_width);
+    }
+
+  meta_error_trap_pop (display, FALSE);
+
+  dump_xserver_region ("repair_win", display, parts);
+  add_damage (screen, parts);
+  cw->damaged = TRUE;
+}
+
+static void
+free_win (MetaCompWindow *cw,
+          gboolean        destroy)
+{
+  MetaDisplay *display = meta_screen_get_display (cw->screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (cw->screen);
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (have_name_window_pixmap (display))
+    {
+      /* See comment in map_win */
+      if (cw->back_pixmap && destroy)
+        {
+          XFreePixmap (xdisplay, cw->back_pixmap);
+          cw->back_pixmap = None;
+        }
+
+      if (cw->shaded_back_pixmap && destroy)
+        {
+          XFreePixmap (xdisplay, cw->shaded_back_pixmap);
+          cw->shaded_back_pixmap = None;
+        }
+    }
+#endif
+
+  if (cw->picture)
+    {
+      XRenderFreePicture (xdisplay, cw->picture);
+      cw->picture = None;
+    }
+
+  if (cw->shadow)
+    {
+      XRenderFreePicture (xdisplay, cw->shadow);
+      cw->shadow = None;
+    }
+
+  if (cw->alpha_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->alpha_pict);
+      cw->alpha_pict = None;
+    }
+
+  if (cw->shadow_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->shadow_pict);
+      cw->shadow_pict = None;
+    }
+
+  if (cw->border_size)
+    {
+      XFixesDestroyRegion (xdisplay, cw->border_size);
+      cw->border_size = None;
+    }
+
+  if (cw->border_clip)
+    {
+      XFixesDestroyRegion (xdisplay, cw->border_clip);
+      cw->border_clip = None;
+    }
+
+  if (cw->extents)
+    {
+      XFixesDestroyRegion (xdisplay, cw->extents);
+      cw->extents = None;
+    }
+
+  if (destroy)
+    {
+      if (cw->damage != None) {
+        meta_error_trap_push (display);
+        XDamageDestroy (xdisplay, cw->damage);
+        meta_error_trap_pop (display, FALSE);
+
+        cw->damage = None;
+      }
+
+      /* The window may not have been added to the list in this case,
+         but we can check anyway */
+      if (info!=NULL && cw->type == META_COMP_WINDOW_DOCK)
+        info->dock_windows = g_slist_remove (info->dock_windows, cw);
+
+      g_free (cw);
+    }
+}
+
+static void
+map_win (MetaDisplay *display,
+         MetaScreen  *screen,
+         Window       id)
+{
+  MetaCompWindow *cw = find_window_for_screen (screen, id);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (cw == NULL)
+    return;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  /* The reason we deallocate this here and not in unmap
+     is so that we will still have a valid pixmap for
+     whenever the window is unmapped */
+  if (cw->back_pixmap)
+    {
+      XFreePixmap (xdisplay, cw->back_pixmap);
+      cw->back_pixmap = None;
+    }
+
+  if (cw->shaded_back_pixmap)
+    {
+      XFreePixmap (xdisplay, cw->shaded_back_pixmap);
+      cw->shaded_back_pixmap = None;
+    }
+#endif
+
+  cw->attrs.map_state = IsViewable;
+  cw->damaged = FALSE;
+}
+
+static void
+unmap_win (MetaDisplay *display,
+           MetaScreen  *screen,
+           Window       id)
+{
+  MetaCompWindow *cw = find_window_for_screen (screen, id);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (cw == NULL || info == NULL)
+    {
+      return;
+    }
+
+  if (cw->window && cw->window == info->focus_window)
+    info->focus_window = NULL;
+
+  cw->attrs.map_state = IsUnmapped;
+  cw->damaged = FALSE;
+
+  if (cw->extents != None)
+    {
+      dump_xserver_region ("unmap_win", display, cw->extents);
+      add_damage (screen, cw->extents);
+      cw->extents = None;
+    }
+
+  free_win (cw, FALSE);
+  info->clip_changed = TRUE;
+}
+
+static void
+determine_mode (MetaDisplay    *display,
+                MetaScreen     *screen,
+                MetaCompWindow *cw)
+{
+  XRenderPictFormat *format;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (cw->alpha_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->alpha_pict);
+      cw->alpha_pict = None;
+    }
+
+  if (cw->shadow_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->shadow_pict);
+      cw->shadow_pict = None;
+    }
+
+  if (cw->attrs.class == InputOnly)
+    format = NULL;
+  else
+    format = XRenderFindVisualFormat (xdisplay, cw->attrs.visual);
+
+  if ((format && format->type == PictTypeDirect && format->direct.alphaMask)
+      || cw->opacity != (guint) OPAQUE)
+    cw->mode = WINDOW_ARGB;
+  else
+    cw->mode = WINDOW_SOLID;
+
+  if (cw->extents)
+    {
+      XserverRegion damage;
+      damage = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, damage, cw->extents);
+
+      dump_xserver_region ("determine_mode", display, damage);
+      add_damage (screen, damage);
+    }
+}
+
+static gboolean
+is_shaped (MetaDisplay *display,
+           Window       xwindow)
+{
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  int xws, yws, xbs, ybs;
+  unsigned wws, hws, wbs, hbs;
+  int bounding_shaped, clip_shaped;
+
+  if (meta_display_has_shape (display))
+    {
+      XShapeQueryExtents (xdisplay, xwindow, &bounding_shaped,
+                          &xws, &yws, &wws, &hws, &clip_shaped,
+                          &xbs, &ybs, &wbs, &hbs);
+      return (bounding_shaped != 0);
+    }
+
+  return FALSE;
+}
+
+static void
+get_window_type (MetaDisplay    *display,
+                 MetaCompWindow *cw)
+{
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+  int n_atoms;
+  Atom *atoms, type_atom;
+  int i;
+
+  type_atom = None;
+  n_atoms = 0;
+  atoms = NULL;
+
+  meta_prop_get_atom_list (display, cw->id,
+                           compositor->atom_net_wm_window_type,
+                           &atoms, &n_atoms);
+
+  for (i = 0; i < n_atoms; i++)
+    {
+      if (atoms[i] == compositor->atom_net_wm_window_type_dnd ||
+          atoms[i] == compositor->atom_net_wm_window_type_desktop ||
+          atoms[i] == compositor->atom_net_wm_window_type_dock ||
+          atoms[i] == compositor->atom_net_wm_window_type_toolbar ||
+          atoms[i] == compositor->atom_net_wm_window_type_menu ||
+          atoms[i] == compositor->atom_net_wm_window_type_dialog ||
+          atoms[i] == compositor->atom_net_wm_window_type_normal ||
+          atoms[i] == compositor->atom_net_wm_window_type_utility ||
+          atoms[i] == compositor->atom_net_wm_window_type_splash ||
+          atoms[i] == compositor->atom_net_wm_window_type_dropdown_menu ||
+          atoms[i] == compositor->atom_net_wm_window_type_tooltip)
+        {
+          type_atom = atoms[i];
+          break;
+        }
+    }
+
+  meta_XFree (atoms);
+
+  if (type_atom == compositor->atom_net_wm_window_type_dnd)
+    cw->type = META_COMP_WINDOW_DND;
+  else if (type_atom == compositor->atom_net_wm_window_type_desktop)
+    cw->type = META_COMP_WINDOW_DESKTOP;
+  else if (type_atom == compositor->atom_net_wm_window_type_dock)
+    cw->type = META_COMP_WINDOW_DOCK;
+  else if (type_atom == compositor->atom_net_wm_window_type_menu)
+    cw->type = META_COMP_WINDOW_MENU;
+  else if (type_atom == compositor->atom_net_wm_window_type_dropdown_menu)
+    cw->type = META_COMP_WINDOW_DROP_DOWN_MENU;
+  else if (type_atom == compositor->atom_net_wm_window_type_tooltip)
+    cw->type = META_COMP_WINDOW_TOOLTIP;
+  else
+    cw->type = META_COMP_WINDOW_NORMAL;
+
+/*   meta_verbose ("Window is %d\n", cw->type); */
+}
+
+/* Must be called with an error trap in place */
+static void
+add_win (MetaScreen *screen,
+         MetaWindow *window,
+         Window     xwindow)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaCompWindow *cw;
+  gulong event_mask;
+
+  if (info == NULL)
+    return;
+
+  if (xwindow == info->output)
+    return;
+
+  cw = g_new0 (MetaCompWindow, 1);
+  cw->screen = screen;
+  cw->window = window;
+  cw->id = xwindow;
+
+  if (!XGetWindowAttributes (xdisplay, xwindow, &cw->attrs))
+    {
+      g_free (cw);
+      return;
+    }
+  get_window_type (display, cw);
+
+  /* If Marco has decided not to manage this window then the input events
+     won't have been set on the window */
+  event_mask = cw->attrs.your_event_mask | PropertyChangeMask;
+
+  XSelectInput (xdisplay, xwindow, event_mask);
+
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  cw->back_pixmap = None;
+  cw->shaded_back_pixmap = None;
+#endif
+
+  cw->damaged = FALSE;
+  cw->shaped = is_shaped (display, xwindow);
+
+  if (cw->attrs.class == InputOnly)
+    cw->damage = None;
+  else
+    cw->damage = XDamageCreate (xdisplay, xwindow, XDamageReportNonEmpty);
+
+  cw->alpha_pict = None;
+  cw->shadow_pict = None;
+  cw->border_size = None;
+  cw->extents = None;
+  cw->shadow = None;
+  cw->shadow_dx = 0;
+  cw->shadow_dy = 0;
+  cw->shadow_width = 0;
+  cw->shadow_height = 0;
+
+  if (window && meta_window_has_focus (window))
+    cw->shadow_type = META_SHADOW_LARGE;
+  else
+    cw->shadow_type = META_SHADOW_MEDIUM;
+
+  cw->opacity = OPAQUE;
+
+  cw->border_clip = None;
+
+  determine_mode (display, screen, cw);
+  cw->needs_shadow = window_has_shadow (cw);
+
+  /* Only add the window to the list of docks if it needs a shadow */
+  if (cw->type == META_COMP_WINDOW_DOCK && cw->needs_shadow)
+    {
+      meta_verbose ("Appending %p to dock windows\n", cw);
+      info->dock_windows = g_slist_append (info->dock_windows, cw);
+    }
+
+  /* Add this to the list at the top of the stack
+     before it is mapped so that map_win can find it again */
+  info->windows = g_list_prepend (info->windows, cw);
+  g_hash_table_insert (info->windows_by_xid, (gpointer) xwindow, cw);
+
+  if (cw->attrs.map_state == IsViewable)
+    map_win (display, screen, xwindow);
+}
+
+static void
+destroy_win (MetaDisplay *display,
+             Window       xwindow,
+             gboolean     gone)
+{
+  MetaScreen *screen;
+  MetaCompScreen *info;
+  MetaCompWindow *cw;
+
+  cw = find_window_in_display (display, xwindow);
+
+  if (cw == NULL)
+    return;
+
+  screen = cw->screen;
+
+  if (cw->extents != None)
+    {
+      dump_xserver_region ("destroy_win", display, cw->extents);
+      add_damage (screen, cw->extents);
+      cw->extents = None;
+    }
+
+  info = meta_screen_get_compositor_data (screen);
+  if (info != NULL)
+    {
+      info->windows = g_list_remove (info->windows, (gconstpointer) cw);
+      g_hash_table_remove (info->windows_by_xid, (gpointer) xwindow);
+    }
+
+  free_win (cw, TRUE);
+}
+
+static void
+restack_win (MetaCompWindow *cw,
+             Window          above)
+{
+  MetaScreen *screen;
+  MetaCompScreen *info;
+  Window previous_above;
+  GList *sibling, *next;
+
+  screen = cw->screen;
+  info = meta_screen_get_compositor_data (screen);
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  sibling = g_list_find (info->windows, (gconstpointer) cw);
+  next = g_list_next (sibling);
+  previous_above = None;
+
+  if (next)
+    {
+      MetaCompWindow *ncw = (MetaCompWindow *) next->data;
+      previous_above = ncw->id;
+    }
+
+  /* If above is set to None, the window whose state was changed is on
+   * the bottom of the stack with respect to sibling.
+   */
+  if (above == None)
+    {
+      /* Insert at bottom of window stack */
+      info->windows = g_list_delete_link (info->windows, sibling);
+      info->windows = g_list_append (info->windows, cw);
+    }
+  else if (previous_above != above)
+    {
+      GList *index;
+
+      for (index = info->windows; index; index = index->next) {
+        MetaCompWindow *cw2 = (MetaCompWindow *) index->data;
+        if (cw2->id == above)
+          break;
+      }
+
+      if (index != NULL)
+        {
+          info->windows = g_list_delete_link (info->windows, sibling);
+          info->windows = g_list_insert_before (info->windows, index, cw);
+        }
+    }
+}
+
+static void
+resize_win (MetaCompWindow *cw,
+            int             x,
+            int             y,
+            int             width,
+            int             height,
+            int             border_width,
+            gboolean        override_redirect)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  XserverRegion damage;
+  gboolean debug;
+
+  debug = DISPLAY_COMPOSITOR (display)->debug;
+
+  if (cw->extents)
+    {
+      damage = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, damage, cw->extents);
+    }
+  else
+    {
+      damage = None;
+      if (debug)
+        fprintf (stderr, "no extents to damage !\n");
+    }
+
+  /*  { // Damage whole screen each time ! ;-)
+    XRectangle r;
+
+    r.x = 0;
+    r.y = 0;
+    meta_screen_get_size (screen, &r.width, &r.height);
+    fprintf (stderr, "Damage whole screen %d,%d (%d %d)\n",
+             r.x, r.y, r.width, r.height);
+
+    damage = XFixesCreateRegion (xdisplay, &r, 1);
+    } */
+
+  cw->attrs.x = x;
+  cw->attrs.y = y;
+
+  if (cw->attrs.width != width || cw->attrs.height != height)
+    {
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+      if (have_name_window_pixmap (display))
+        {
+          if (cw->shaded_back_pixmap)
+            {
+              XFreePixmap (xdisplay, cw->shaded_back_pixmap);
+              cw->shaded_back_pixmap = None;
+            }
+
+          if (cw->back_pixmap)
+            {
+              /* If the window is shaded, we store the old backing pixmap
+                 so we can return a proper image of the window */
+              if (cw->window && meta_window_is_shaded (cw->window))
+                {
+                  cw->shaded_back_pixmap = cw->back_pixmap;
+                  cw->back_pixmap = None;
+                }
+              else
+                {
+                  XFreePixmap (xdisplay, cw->back_pixmap);
+                  cw->back_pixmap = None;
+                }
+            }
+        }
+#endif
+      if (cw->picture)
+        {
+          XRenderFreePicture (xdisplay, cw->picture);
+          cw->picture = None;
+        }
+
+      if (cw->shadow)
+        {
+          XRenderFreePicture (xdisplay, cw->shadow);
+          cw->shadow = None;
+        }
+    }
+
+  cw->attrs.width = width;
+  cw->attrs.height = height;
+  cw->attrs.border_width = border_width;
+  cw->attrs.override_redirect = override_redirect;
+
+  if (cw->extents)
+    XFixesDestroyRegion (xdisplay, cw->extents);
+
+  cw->extents = win_extents (cw);
+
+  if (damage)
+    {
+      if (debug)
+        fprintf (stderr, "Inexplicable intersection with new extents!\n");
+
+      XFixesUnionRegion (xdisplay, damage, damage, cw->extents);
+    }
+  else
+    {
+      damage = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, damage, cw->extents);
+    }
+
+  dump_xserver_region ("resize_win", display, damage);
+  add_damage (screen, damage);
+
+  if (info != NULL)
+    {
+      info->clip_changed = TRUE;
+    }
+}
+
+/* event processors must all be called with an error trap in place */
+static void
+process_circulate_notify (MetaCompositorXRender  *compositor,
+                          XCirculateEvent        *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+  MetaCompWindow *top;
+  MetaCompScreen *info;
+  MetaScreen *screen;
+  GList *first;
+  Window above;
+
+  if (!cw)
+    return;
+
+  screen = cw->screen;
+  info = meta_screen_get_compositor_data (screen);
+  first = info->windows;
+  top = (MetaCompWindow *) first->data;
+
+  if ((event->place == PlaceOnTop) && top)
+    above = top->id;
+  else
+    above = None;
+  restack_win (cw, above);
+
+  if (info != NULL)
+    {
+      info->clip_changed = TRUE;
+    }
+
+#ifdef USE_IDLE_REPAINT
+  add_repair (compositor->display);
+#endif
+}
+
+static void
+process_configure_notify (MetaCompositorXRender  *compositor,
+                          XConfigureEvent        *event)
+{
+  MetaDisplay *display = compositor->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompWindow *cw = find_window_in_display (display, event->window);
+
+  if (cw)
+    {
+#if 0
+      int x = -1, y = -1, width = -1, height = -1;
+      int ex = -1, ey = -1, ewidth = -1, eheight = -1;
+      MetaRectangle *rect;
+
+      if (cw->window) {
+        rect = meta_window_get_rect (cw->window);
+        x = rect->x;
+        y = rect->y;
+        width = rect->width;
+        height = rect->height;
+      }
+      fprintf (stderr, "configure notify xy (%d %d) -> (%d %d), wh (%d %d) -> (%d %d)\n",
+               x, y, event->x, event->y,
+               width, height, event->width, event->height);
+#endif
+
+      if (compositor->debug)
+        {
+          fprintf (stderr, "configure notify %d %d %d\n", cw->damaged,
+                   cw->shaped, cw->needs_shadow);
+          dump_xserver_region ("\textents", display, cw->extents);
+          fprintf (stderr, "\txy (%d %d), wh (%d %d)\n",
+                   event->x, event->y, event->width, event->height);
+        }
+
+      restack_win (cw, event->above);
+      resize_win (cw, event->x, event->y, event->width, event->height,
+                  event->border_width, event->override_redirect);
+    }
+  else
+    {
+      MetaScreen *screen;
+      MetaCompScreen *info;
+
+      /* Might be the root window? */
+      screen = meta_display_screen_for_root (display, event->window);
+      if (screen == NULL)
+        return;
+
+      info = meta_screen_get_compositor_data (screen);
+      if (info != NULL && info->root_buffer)
+        {
+          XRenderFreePicture (xdisplay, info->root_buffer);
+          info->root_buffer = None;
+        }
+
+      damage_screen (screen);
+    }
+}
+
+static void
+process_property_notify (MetaCompositorXRender *compositor,
+                         XPropertyEvent        *event)
+{
+  MetaDisplay *display = compositor->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaScreen *screen;
+  int p;
+  Atom background_atoms[2];
+
+  /* Check for the background property changing */
+  background_atoms[0] = compositor->atom_x_root_pixmap;
+  background_atoms[1] = compositor->atom_x_set_root;
+
+  for (p = 0; p < 2; p++)
+    {
+      if (event->atom == background_atoms[p])
+        {
+          screen = meta_display_screen_for_root (display, event->window);
+          if (screen)
+            {
+              MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+              Window xroot = meta_screen_get_xroot (screen);
+
+              if (info != NULL && info->root_tile)
+                {
+                  XClearArea (xdisplay, xroot, 0, 0, 0, 0, TRUE);
+                  XRenderFreePicture (xdisplay, info->root_tile);
+                  info->root_tile = None;
+
+                  /* Damage the whole screen as we may need to redraw the
+                     background ourselves */
+                  damage_screen (screen);
+#ifdef USE_IDLE_REPAINT
+                  add_repair (display);
+#endif
+
+                  return;
+                }
+            }
+        }
+    }
+
+  /* Check for the opacity changing */
+  if (event->atom == compositor->atom_net_wm_window_opacity)
+    {
+      MetaCompWindow *cw = find_window_in_display (display, event->window);
+      gulong value;
+
+      if (!cw)
+        {
+          /* Applications can set this for their toplevel windows, so
+           * this must be propagated to the window managed by the compositor
+           */
+          cw = find_window_for_child_window_in_display (display, event->window);
+        }
+
+      if (!cw)
+        return;
+
+      if (meta_prop_get_cardinal (display, event->window,
+                                  compositor->atom_net_wm_window_opacity,
+                                  &value) == FALSE)
+        value = OPAQUE;
+
+      cw->opacity = (guint)value;
+      determine_mode (display, cw->screen, cw);
+      cw->needs_shadow = window_has_shadow (cw);
+
+      if (cw->shadow)
+        {
+          XRenderFreePicture (xdisplay, cw->shadow);
+          cw->shadow = None;
+        }
+
+      if (cw->extents)
+        XFixesDestroyRegion (xdisplay, cw->extents);
+      cw->extents = win_extents (cw);
+
+      cw->damaged = TRUE;
+#ifdef USE_IDLE_REPAINT
+      add_repair (display);
+#endif
+
+      return;
+    }
+
+  if (event->atom == compositor->atom_net_wm_window_type) {
+    MetaCompWindow *cw = find_window_in_display (display, event->window);
+
+    if (!cw)
+      return;
+
+    get_window_type (display, cw);
+    cw->needs_shadow = window_has_shadow (cw);
+    return;
+  }
+}
+
+static void
+expose_area (MetaScreen *screen,
+             XRectangle *rects,
+             int         nrects)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion region;
+
+  region = XFixesCreateRegion (xdisplay, rects, nrects);
+
+  dump_xserver_region ("expose_area", display, region);
+  add_damage (screen, region);
+}
+
+static void
+process_expose (MetaCompositorXRender *compositor,
+                XExposeEvent          *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+  MetaScreen *screen = NULL;
+  XRectangle rect[1];
+  int origin_x = 0, origin_y = 0;
+
+  if (cw != NULL)
+    {
+      screen = cw->screen;
+      origin_x = cw->attrs.x; /* + cw->attrs.border_width; ? */
+      origin_y = cw->attrs.y; /* + cw->attrs.border_width; ? */
+    }
+  else
+    {
+      screen = meta_display_screen_for_root (compositor->display,
+                                             event->window);
+      if (screen == NULL)
+        return;
+    }
+
+  rect[0].x = event->x + origin_x;
+  rect[0].y = event->y + origin_y;
+  rect[0].width = event->width;
+  rect[0].height = event->height;
+
+  expose_area (screen, rect, 1);
+}
+
+static void
+process_unmap (MetaCompositorXRender *compositor,
+               XUnmapEvent           *event)
+{
+  MetaCompWindow *cw;
+
+  if (event->from_configure)
+    {
+      /* Ignore unmap caused by parent's resize */
+      return;
+    }
+
+
+  cw = find_window_in_display (compositor->display, event->window);
+  if (cw)
+    unmap_win (compositor->display, cw->screen, event->window);
+}
+
+static void
+process_map (MetaCompositorXRender *compositor,
+             XMapEvent             *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+
+  if (cw)
+    map_win (compositor->display, cw->screen, event->window);
+}
+
+static void
+process_reparent (MetaCompositorXRender *compositor,
+                  XReparentEvent        *event,
+                  MetaWindow            *window)
+{
+  MetaScreen *screen;
+
+  screen = meta_display_screen_for_root (compositor->display, event->parent);
+  if (screen != NULL)
+    add_win (screen, window, event->window);
+  else
+    destroy_win (compositor->display, event->window, FALSE);
+}
+
+static void
+process_create (MetaCompositorXRender *compositor,
+                XCreateWindowEvent    *event,
+                MetaWindow            *window)
+{
+  MetaScreen *screen;
+  /* We are only interested in top level windows, others will
+     be caught by normal marco functions */
+
+  screen = meta_display_screen_for_root (compositor->display, event->parent);
+  if (screen == NULL)
+    return;
+
+  if (!find_window_in_display (compositor->display, event->window))
+    add_win (screen, window, event->window);
+}
+
+static void
+process_destroy (MetaCompositorXRender *compositor,
+                 XDestroyWindowEvent   *event)
+{
+  destroy_win (compositor->display, event->window, FALSE);
+}
+
+static void
+process_damage (MetaCompositorXRender *compositor,
+                XDamageNotifyEvent    *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->drawable);
+  if (cw == NULL)
+    return;
+
+  repair_win (cw);
+
+#ifdef USE_IDLE_REPAINT
+  if (event->more == FALSE)
+    add_repair (compositor->display);
+#endif
+}
+
+static void
+process_shape (MetaCompositorXRender *compositor,
+               XShapeEvent           *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+
+  if (cw == NULL)
+    return;
+
+  if (event->kind == ShapeBounding)
+    {
+      if (!event->shaped && cw->shaped)
+        cw->shaped = FALSE;
+
+      resize_win (cw, cw->attrs.x, cw->attrs.y,
+                  event->width + event->x, event->height + event->y,
+                  cw->attrs.border_width, cw->attrs.override_redirect);
+
+      if (event->shaped && !cw->shaped)
+        cw->shaped = TRUE;
+    }
+}
+
+static int
+timeout_debug (MetaCompositorXRender *compositor)
+{
+  compositor->show_redraw = (g_getenv ("MARCO_DEBUG_REDRAWS") != NULL);
+  compositor->debug = (g_getenv ("MARCO_DEBUG_COMPOSITOR") != NULL);
+
+  return FALSE;
+}
+
+static void
+xrender_add_window (MetaCompositor    *compositor,
+                    MetaWindow        *window,
+                    Window             xwindow,
+                    XWindowAttributes *attrs)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+  MetaScreen *screen = meta_screen_for_x_screen (attrs->screen);
+
+  meta_error_trap_push (xrc->display);
+  add_win (screen, window, xwindow);
+  meta_error_trap_pop (xrc->display, FALSE);
+#endif
+}
+
+static void
+xrender_remove_window (MetaCompositor *compositor,
+                       Window          xwindow)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+show_overlay_window (MetaScreen *screen,
+                     Window      cow)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+#ifdef HAVE_COW
+  if (have_cow (display))
+    {
+      XserverRegion region;
+
+      region = XFixesCreateRegion (xdisplay, NULL, 0);
+
+      XFixesSetWindowShapeRegion (xdisplay, cow, ShapeBounding, 0, 0, 0);
+      XFixesSetWindowShapeRegion (xdisplay, cow, ShapeInput, 0, 0, region);
+
+      XFixesDestroyRegion (xdisplay, region);
+
+      damage_screen (screen);
+    }
+#endif
+}
+
+static void
+hide_overlay_window (MetaScreen *screen,
+                     Window      cow)
+{
+#ifdef HAVE_COW
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion region;
+
+  region = XFixesCreateRegion (xdisplay, NULL, 0);
+  XFixesSetWindowShapeRegion (xdisplay, cow, ShapeBounding, 0, 0, region);
+  XFixesDestroyRegion (xdisplay, region);
+#endif
+}
+
+static Window
+get_output_window (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window output, xroot;
+
+  xroot = meta_screen_get_xroot (screen);
+
+#ifdef HAVE_COW
+  if (have_cow (display))
+    {
+      output = XCompositeGetOverlayWindow (xdisplay, xroot);
+      XSelectInput (xdisplay, output, ExposureMask);
+    }
+  else
+#endif
+    {
+      output = xroot;
+    }
+
+  return output;
+}
+
+static void
+xrender_manage_screen (MetaCompositor *compositor,
+                       MetaScreen     *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompScreen *info;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *visual_format;
+  int screen_number = meta_screen_get_screen_number (screen);
+  Window xroot = meta_screen_get_xroot (screen);
+
+  /* Check if the screen is already managed */
+  if (meta_screen_get_compositor_data (screen))
+    return;
+
+  gdk_error_trap_push ();
+  XCompositeRedirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
+  XSync (xdisplay, FALSE);
+
+  if (gdk_error_trap_pop ())
+    {
+      g_warning ("Another compositing manager is running on screen %i",
+                 screen_number);
+      return;
+    }
+
+  info = g_new0 (MetaCompScreen, 1);
+  info->screen = screen;
+
+  meta_screen_set_compositor_data (screen, info);
+
+  visual_format = XRenderFindVisualFormat (xdisplay, DefaultVisual (xdisplay,
+                                                                    screen_number));
+  if (!visual_format)
+    {
+      g_warning ("Cannot find visual format on screen %i", screen_number);
+      return;
+    }
+
+  info->output = get_output_window (screen);
+
+  pa.subwindow_mode = IncludeInferiors;
+  info->root_picture = XRenderCreatePicture (xdisplay, info->output,
+                                             visual_format,
+                                             CPSubwindowMode, &pa);
+  if (info->root_picture == None)
+    {
+      g_warning ("Cannot create root picture on screen %i", screen_number);
+      return;
+    }
+
+  info->root_buffer = None;
+  info->black_picture = solid_picture (display, screen, TRUE, 1, 0, 0, 0);
+
+  info->root_tile = None;
+  info->all_damage = None;
+
+  info->windows = NULL;
+  info->windows_by_xid = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+  info->focus_window = meta_display_get_focus_window (display);
+
+  info->compositor_active = TRUE;
+  info->overlays = 0;
+  info->clip_changed = TRUE;
+
+  info->have_shadows = (g_getenv("META_DEBUG_NO_SHADOW") == NULL);
+  if (info->have_shadows)
+    {
+      meta_verbose ("Enabling shadows\n");
+      generate_shadows (info);
+    }
+  else
+    meta_verbose ("Disabling shadows\n");
+
+  XClearArea (xdisplay, info->output, 0, 0, 0, 0, TRUE);
+
+  meta_screen_set_cm_selection (screen);
+
+  /* Now we're up and running we can show the output if needed */
+  show_overlay_window (screen, info->output);
+#endif
+}
+
+static void
+xrender_unmanage_screen (MetaCompositor *compositor,
+                         MetaScreen     *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info;
+  Window xroot = meta_screen_get_xroot (screen);
+  GList *index;
+
+  info = meta_screen_get_compositor_data (screen);
+
+  /* This screen isn't managed */
+  if (info == NULL)
+    return;
+
+  hide_overlay_window (screen, info->output);
+
+  /* Destroy the windows */
+  for (index = info->windows; index; index = index->next)
+    {
+      MetaCompWindow *cw = (MetaCompWindow *) index->data;
+      free_win (cw, TRUE);
+    }
+  g_list_free (info->windows);
+  g_hash_table_destroy (info->windows_by_xid);
+
+  if (info->root_picture)
+    XRenderFreePicture (xdisplay, info->root_picture);
+
+  if (info->black_picture)
+    XRenderFreePicture (xdisplay, info->black_picture);
+
+  if (info->have_shadows)
+    {
+      int i;
+
+      for (i = 0; i < LAST_SHADOW_TYPE; i++)
+        g_free (info->shadows[i]->gaussian_map);
+    }
+
+  XCompositeUnredirectSubwindows (xdisplay, xroot,
+                                  CompositeRedirectManual);
+  meta_screen_unset_cm_selection (screen);
+
+#ifdef HAVE_COW
+  XCompositeReleaseOverlayWindow (xdisplay, info->output);
+#endif
+
+  g_free (info);
+
+  meta_screen_set_compositor_data (screen, NULL);
+#endif
+}
+
+static void
+xrender_set_updates (MetaCompositor *compositor,
+                     MetaWindow     *window,
+                     gboolean        updates)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+
+#endif
+}
+
+static void
+xrender_destroy (MetaCompositor *compositor)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  g_free (compositor);
+#endif
+}
+
+#if 0
+/* Taking these out because they're empty and never called, and the
+ * compiler complains -- tthurman
+ */
+
+static void
+xrender_begin_move (MetaCompositor *compositor,
+                    MetaWindow     *window,
+                    MetaRectangle  *initial,
+                    int             grab_x,
+                    int             grab_y)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+xrender_update_move (MetaCompositor *compositor,
+                     MetaWindow     *window,
+                     int             x,
+                     int             y)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+xrender_end_move (MetaCompositor *compositor,
+                  MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+xrender_free_window (MetaCompositor *compositor,
+                     MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  /* FIXME: When an undecorated window is hidden this is called,
+     but the window does not get readded if it is subsequentally shown again
+     See http://bugzilla.gnome.org/show_bug.cgi?id=504876
+
+     I don't *think* theres any need for this call anyway, leaving it out
+     does not seem to cause any side effects so far, but I should check with
+     someone who understands more. */
+  /* destroy_win (compositor->display, window->xwindow, FALSE); */
+#endif
+}
+#endif /* 0 */
+
+static void
+xrender_process_event (MetaCompositor *compositor,
+                       XEvent         *event,
+                       MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+  /*
+   * This trap is so that none of the compositor functions cause
+   * X errors. This is really a hack, but I'm afraid I don't understand
+   * enough about Marco/X to know how else you are supposed to do it
+   */
+  meta_error_trap_push (xrc->display);
+  switch (event->type)
+    {
+    case CirculateNotify:
+      process_circulate_notify (xrc, (XCirculateEvent *) event);
+      break;
+
+    case ConfigureNotify:
+      process_configure_notify (xrc, (XConfigureEvent *) event);
+      break;
+
+    case PropertyNotify:
+      process_property_notify (xrc, (XPropertyEvent *) event);
+      break;
+
+    case Expose:
+      process_expose (xrc, (XExposeEvent *) event);
+      break;
+
+    case UnmapNotify:
+      process_unmap (xrc, (XUnmapEvent *) event);
+      break;
+
+    case MapNotify:
+      process_map (xrc, (XMapEvent *) event);
+      break;
+
+    case ReparentNotify:
+      process_reparent (xrc, (XReparentEvent *) event, window);
+      break;
+
+    case CreateNotify:
+      process_create (xrc, (XCreateWindowEvent *) event, window);
+      break;
+
+    case DestroyNotify:
+      process_destroy (xrc, (XDestroyWindowEvent *) event);
+      break;
+
+    default:
+      if (event->type == meta_display_get_damage_event_base (xrc->display) + XDamageNotify)
+        process_damage (xrc, (XDamageNotifyEvent *) event);
+#ifdef HAVE_SHAPE
+      else if (event->type == meta_display_get_shape_event_base (xrc->display) + ShapeNotify)
+        process_shape (xrc, (XShapeEvent *) event);
+#endif /* HAVE_SHAPE */
+      else
+        {
+          meta_error_trap_pop (xrc->display, FALSE);
+          return;
+        }
+      break;
+    }
+
+  meta_error_trap_pop (xrc->display, FALSE);
+#ifndef USE_IDLE_REPAINT
+  repair_display (xrc->display);
+#endif
+
+  return;
+#endif
+}
+
+static Pixmap
+xrender_get_window_pixmap (MetaCompositor *compositor,
+                           MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompWindow *cw = NULL;
+  MetaScreen *screen = meta_window_get_screen (window);
+  MetaFrame *frame = meta_window_get_frame (window);
+
+  cw = find_window_for_screen (screen, frame ? meta_frame_get_xwindow (frame) :
+                               meta_window_get_xwindow (window));
+  if (cw == NULL)
+    return None;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (have_name_window_pixmap (meta_window_get_display (window)))
+    {
+      if (meta_window_is_shaded (window))
+        return cw->shaded_back_pixmap;
+      else
+        return cw->back_pixmap;
+    }
+  else
+#endif
+    return None;
+#endif
+}
+
+static void
+xrender_set_active_window (MetaCompositor *compositor,
+                           MetaScreen     *screen,
+                           MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+  MetaDisplay *display;
+  Display *xdisplay;
+  MetaCompWindow *old_focus = NULL, *new_focus = NULL;
+  MetaCompScreen *info = NULL;
+  MetaWindow *old_focus_win = NULL;
+
+  if (compositor == NULL)
+    return;
+
+  display = xrc->display;
+  xdisplay = meta_display_get_xdisplay (display);
+  info = meta_screen_get_compositor_data (screen);
+
+  if (info != NULL)
+    {
+      old_focus_win = info->focus_window;
+    }
+
+  if (old_focus_win)
+    {
+      MetaFrame *f = meta_window_get_frame (old_focus_win);
+
+      old_focus = find_window_for_screen (screen,
+                                          f ? meta_frame_get_xwindow (f) :
+                                          meta_window_get_xwindow (old_focus_win));
+    }
+
+  if (window)
+    {
+      MetaFrame *f = meta_window_get_frame (window);
+      new_focus = find_window_for_screen (screen,
+                                          f ? meta_frame_get_xwindow (f) :
+                                          meta_window_get_xwindow (window));
+    }
+
+  if (info != NULL)
+    {
+      info->focus_window = window;
+    }
+
+  if (old_focus)
+    {
+      XserverRegion damage;
+
+      /* Tear down old shadows */
+      old_focus->shadow_type = META_SHADOW_MEDIUM;
+      determine_mode (display, screen, old_focus);
+      old_focus->needs_shadow = window_has_shadow (old_focus);
+
+      if (old_focus->attrs.map_state == IsViewable)
+        {
+          if (old_focus->shadow)
+            {
+              XRenderFreePicture (xdisplay, old_focus->shadow);
+              old_focus->shadow = None;
+            }
+
+          if (old_focus->extents)
+            {
+              damage = XFixesCreateRegion (xdisplay, NULL, 0);
+              XFixesCopyRegion (xdisplay, damage, old_focus->extents);
+              XFixesDestroyRegion (xdisplay, old_focus->extents);
+            }
+          else
+            damage = None;
+
+          /* Build new extents */
+          old_focus->extents = win_extents (old_focus);
+
+          if (damage)
+            XFixesUnionRegion (xdisplay, damage, damage, old_focus->extents);
+          else
+            {
+              damage = XFixesCreateRegion (xdisplay, NULL, 0);
+              XFixesCopyRegion (xdisplay, damage, old_focus->extents);
+            }
+
+          dump_xserver_region ("resize_win", display, damage);
+          add_damage (screen, damage);
+
+          if (info != NULL)
+            {
+              info->clip_changed = TRUE;
+            }
+        }
+    }
+
+  if (new_focus)
+    {
+      XserverRegion damage;
+
+      new_focus->shadow_type = META_SHADOW_LARGE;
+      determine_mode (display, screen, new_focus);
+      new_focus->needs_shadow = window_has_shadow (new_focus);
+
+      if (new_focus->shadow)
+        {
+          XRenderFreePicture (xdisplay, new_focus->shadow);
+          new_focus->shadow = None;
+        }
+
+      if (new_focus->extents)
+        {
+          damage = XFixesCreateRegion (xdisplay, NULL, 0);
+          XFixesCopyRegion (xdisplay, damage, new_focus->extents);
+          XFixesDestroyRegion (xdisplay, new_focus->extents);
+        }
+      else
+        damage = None;
+
+      /* Build new extents */
+      new_focus->extents = win_extents (new_focus);
+
+      if (damage)
+        XFixesUnionRegion (xdisplay, damage, damage, new_focus->extents);
+      else
+        {
+          damage = XFixesCreateRegion (xdisplay, NULL, 0);
+          XFixesCopyRegion (xdisplay, damage, new_focus->extents);
+        }
+
+      dump_xserver_region ("resize_win", display, damage);
+      add_damage (screen, damage);
+
+      if (info != NULL)
+        {
+          info->clip_changed = TRUE;
+        }
+    }
+#ifdef USE_IDLE_REPAINT
+  add_repair (display);
+#endif
+#endif
+}
+
+static MetaCompositor comp_info = {
+  xrender_destroy,
+  xrender_manage_screen,
+  xrender_unmanage_screen,
+  xrender_add_window,
+  xrender_remove_window,
+  xrender_set_updates,
+  xrender_process_event,
+  xrender_get_window_pixmap,
+  xrender_set_active_window
+};
+
+MetaCompositor *
+meta_compositor_xrender_new (MetaDisplay *display)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  char *atom_names[] = {
+    "_XROOTPMAP_ID",
+    "_XSETROOT_ID",
+    "_NET_WM_WINDOW_OPACITY",
+    "_NET_WM_WINDOW_TYPE_DND",
+    "_NET_WM_WINDOW_TYPE",
+    "_NET_WM_WINDOW_TYPE_DESKTOP",
+    "_NET_WM_WINDOW_TYPE_DOCK",
+    "_NET_WM_WINDOW_TYPE_MENU",
+    "_NET_WM_WINDOW_TYPE_DIALOG",
+    "_NET_WM_WINDOW_TYPE_NORMAL",
+    "_NET_WM_WINDOW_TYPE_UTILITY",
+    "_NET_WM_WINDOW_TYPE_SPLASH",
+    "_NET_WM_WINDOW_TYPE_TOOLBAR",
+    "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU",
+    "_NET_WM_WINDOW_TYPE_TOOLTIP"
+  };
+  Atom atoms[G_N_ELEMENTS(atom_names)];
+  MetaCompositorXRender *xrc;
+  MetaCompositor *compositor;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  xrc = g_new (MetaCompositorXRender, 1);
+  xrc->compositor = comp_info;
+
+  compositor = (MetaCompositor *) xrc;
+
+  xrc->display = display;
+
+  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
+  XInternAtoms (xdisplay, atom_names, G_N_ELEMENTS (atom_names),
+                False, atoms);
+
+  xrc->atom_x_root_pixmap = atoms[0];
+  xrc->atom_x_set_root = atoms[1];
+  xrc->atom_net_wm_window_opacity = atoms[2];
+  xrc->atom_net_wm_window_type_dnd = atoms[3];
+  xrc->atom_net_wm_window_type = atoms[4];
+  xrc->atom_net_wm_window_type_desktop = atoms[5];
+  xrc->atom_net_wm_window_type_dock = atoms[6];
+  xrc->atom_net_wm_window_type_menu = atoms[7];
+  xrc->atom_net_wm_window_type_dialog = atoms[8];
+  xrc->atom_net_wm_window_type_normal = atoms[9];
+  xrc->atom_net_wm_window_type_utility = atoms[10];
+  xrc->atom_net_wm_window_type_splash = atoms[11];
+  xrc->atom_net_wm_window_type_toolbar = atoms[12];
+  xrc->atom_net_wm_window_type_dropdown_menu = atoms[13];
+  xrc->atom_net_wm_window_type_tooltip = atoms[14];
+
+#ifdef USE_IDLE_REPAINT
+  meta_verbose ("Using idle repaint\n");
+  xrc->repaint_id = 0;
+#endif
+
+  xrc->enabled = TRUE;
+  g_timeout_add (2000, (GSourceFunc) timeout_debug, xrc);
+
+  return compositor;
+#else
+  return NULL;
+#endif
+}
+
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
+
diff --git a/src/compositor/compositor-xrender.h b/src/compositor/compositor-xrender.h
new file mode 100644
index 00000000..5c8a36c0
--- /dev/null
+++ b/src/compositor/compositor-xrender.h
@@ -0,0 +1,31 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* 
+ * Copyright (C) 2007 Iain Holmes
+ * Based on xcompmgr - (c) 2003 Keith Packard
+ *          xfwm4    - (c) 2005-2007 Olivier Fourdan
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_COMPOSITOR_XRENDER_H_
+#define META_COMPOSITOR_XRENDER_H_
+
+#include "types.h"
+
+MetaCompositor *meta_compositor_xrender_new (MetaDisplay *display);
+
+#endif
diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c
new file mode 100644
index 00000000..975bf341
--- /dev/null
+++ b/src/compositor/compositor.c
@@ -0,0 +1,159 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "compositor-private.h"
+#include "compositor-xrender.h"
+
+MetaCompositor *
+meta_compositor_new (MetaDisplay *display)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  /* At some point we would have a way to select between backends */
+  return meta_compositor_xrender_new (display);
+#else
+  return NULL;
+#endif
+}
+
+void
+meta_compositor_destroy (MetaCompositor *compositor)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->destroy)
+    compositor->destroy (compositor);
+#endif
+}
+
+void
+meta_compositor_add_window (MetaCompositor    *compositor,
+                            MetaWindow        *window,
+                            Window             xwindow,
+                            XWindowAttributes *attrs)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->add_window)
+    compositor->add_window (compositor, window, xwindow, attrs);
+#endif
+}
+
+void
+meta_compositor_remove_window (MetaCompositor *compositor,
+                               Window          xwindow)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->remove_window)
+    compositor->remove_window (compositor, xwindow);
+#endif
+}
+
+void
+meta_compositor_manage_screen (MetaCompositor *compositor,
+                               MetaScreen     *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->manage_screen)
+    compositor->manage_screen (compositor, screen);
+#endif
+}
+
+void
+meta_compositor_unmanage_screen (MetaCompositor *compositor,
+                                 MetaScreen     *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->unmanage_screen)
+    compositor->unmanage_screen (compositor, screen);
+#endif
+}
+
+void
+meta_compositor_set_updates (MetaCompositor *compositor,
+                             MetaWindow     *window,
+                             gboolean        updates)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->set_updates)
+    compositor->set_updates (compositor, window, updates);
+#endif
+}
+
+void
+meta_compositor_process_event (MetaCompositor *compositor,
+                               XEvent         *event,
+                               MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->process_event)
+    compositor->process_event (compositor, event, window);
+#endif
+}
+
+Pixmap
+meta_compositor_get_window_pixmap (MetaCompositor *compositor,
+                                   MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->get_window_pixmap)
+    return compositor->get_window_pixmap (compositor, window);
+  else 
+    return None;
+#else
+  return None;
+#endif
+}
+
+void
+meta_compositor_set_active_window (MetaCompositor *compositor,
+                                   MetaScreen     *screen,
+                                   MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->set_active_window) 
+    compositor->set_active_window (compositor, screen, window);
+#endif
+}
+
+/* These functions are unused at the moment */
+void meta_compositor_begin_move (MetaCompositor *compositor,
+                                 MetaWindow     *window,
+                                 MetaRectangle  *initial,
+                                 int             grab_x, 
+                                 int             grab_y)
+{
+}
+
+void meta_compositor_update_move (MetaCompositor *compositor,
+                                  MetaWindow     *window,
+                                  int             x, 
+                                  int             y)
+{
+}
+
+void meta_compositor_end_move (MetaCompositor *compositor,
+                               MetaWindow     *window)
+{
+}
+
+void meta_compositor_free_window (MetaCompositor *compositor,
+                                  MetaWindow     *window)
+{
+}
diff --git a/src/core/async-getprop.c b/src/core/async-getprop.c
new file mode 100644
index 00000000..80322b41
--- /dev/null
+++ b/src/core/async-getprop.c
@@ -0,0 +1,680 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Asynchronous X property getting hack */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ * Copyright (C) 1986, 1998  The Open Group
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ */
+
+#include <assert.h>
+
+#undef DEBUG_SPEW
+#ifdef DEBUG_SPEW
+#include <stdio.h>
+#endif
+
+#include "async-getprop.h"
+
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+typedef struct _ListNode ListNode;
+typedef struct _AgPerDisplayData AgPerDisplayData;
+
+struct _ListNode
+{
+  ListNode *next;
+};
+
+struct _AgGetPropertyTask
+{
+  ListNode node;
+  
+  AgPerDisplayData *dd;
+  Window window;
+  Atom property;
+
+  unsigned long request_seq;
+  int error;
+
+  Atom actual_type;
+  int  actual_format;
+
+  unsigned long  n_items;
+  unsigned long  bytes_after;
+  char          *data;
+
+  Bool have_reply;
+};
+
+struct _AgPerDisplayData
+{
+  ListNode node;
+  _XAsyncHandler async;
+  
+  Display *display;
+  ListNode *pending_tasks;
+  ListNode *pending_tasks_tail;
+  ListNode *completed_tasks;
+  ListNode *completed_tasks_tail;
+  int n_tasks_pending;
+  int n_tasks_completed;
+};
+
+static ListNode *display_datas = NULL;
+static ListNode *display_datas_tail = NULL;
+
+static void
+append_to_list (ListNode **head,
+                ListNode **tail,
+                ListNode  *task)
+{
+  task->next = NULL;
+  
+  if (*tail == NULL)
+    {
+      assert (*head == NULL);
+      *head = task;
+      *tail = task;
+    }
+  else
+    {
+      (*tail)->next = task;
+      *tail = task;
+    }
+}
+
+static void
+remove_from_list (ListNode **head,
+                  ListNode **tail,
+                  ListNode  *task)
+{
+  ListNode *prev;
+  ListNode *node;
+
+  prev = NULL;
+  node = *head;
+  while (node != NULL)
+    {
+      if (node == task)
+        {
+          if (prev)
+            prev->next = node->next;
+          else
+            *head = node->next;
+
+          if (node == *tail)
+            *tail = prev;
+          
+          break;
+        }
+      
+      prev = node;
+      node = node->next;
+    }
+
+  /* can't remove what's not there */
+  assert (node != NULL);
+
+  node->next = NULL;
+}
+
+static void
+move_to_completed (AgPerDisplayData  *dd,
+                   AgGetPropertyTask *task)
+{
+  remove_from_list (&dd->pending_tasks,
+                    &dd->pending_tasks_tail,
+                    &task->node);
+  
+  append_to_list (&dd->completed_tasks,
+                  &dd->completed_tasks_tail,
+                  &task->node);
+
+  dd->n_tasks_pending -= 1;
+  dd->n_tasks_completed += 1;
+}
+
+static AgGetPropertyTask*
+find_pending_by_request_sequence (AgPerDisplayData *dd,
+                                  unsigned long     request_seq)
+{
+  ListNode *node;
+
+  /* if the sequence is after our last pending task, we
+   * aren't going to find a match
+   */
+  {
+    AgGetPropertyTask *task = (AgGetPropertyTask*) dd->pending_tasks_tail;
+    if (task != NULL)
+      {
+        if (task->request_seq < request_seq)
+          return NULL;
+        else if (task->request_seq == request_seq)
+          return task; /* why not check this */
+      }
+  }
+
+  /* Generally we should get replies in the order we sent
+   * requests, so we should usually be using the task
+   * at the head of the list, if we use any task at all.
+   * I'm not sure this is 100% guaranteed, if it is,
+   * it would be a big speedup.
+   */
+  
+  node = dd->pending_tasks;
+  while (node != NULL)
+    {
+      AgGetPropertyTask *task = (AgGetPropertyTask*) node;
+      
+      if (task->request_seq == request_seq)
+        return task;
+      
+      node = node->next;
+    }
+  
+  return NULL;
+}
+
+static Bool
+async_get_property_handler (Display *dpy,
+                            xReply  *rep,
+                            char    *buf,
+                            int      len,
+                            XPointer data)
+{
+  xGetPropertyReply  replbuf;
+  xGetPropertyReply *reply;
+  AgGetPropertyTask *task;
+  AgPerDisplayData *dd;
+  int bytes_read;
+
+  dd = (AgPerDisplayData*) data;
+  
+#if 0
+  printf ("%s: seeing request seq %ld buflen %d\n", __FUNCTION__,
+          dpy->last_request_read, len);
+#endif
+  
+  task = find_pending_by_request_sequence (dd, dpy->last_request_read);
+
+  if (task == NULL)
+    return False;
+
+  assert (dpy->last_request_read == task->request_seq);
+
+  task->have_reply = True;
+  move_to_completed (dd, task);
+  
+  /* read bytes so far */
+  bytes_read = SIZEOF (xReply);
+
+  if (rep->generic.type == X_Error)
+    {
+      xError errbuf;
+
+      task->error = rep->error.errorCode;
+      
+#ifdef DEBUG_SPEW
+      printf ("%s: error code = %d (ignoring error, eating %d bytes, generic.length = %ld)\n",
+              __FUNCTION__, task->error, (SIZEOF (xError) - bytes_read),
+              rep->generic.length);
+#endif
+
+      /* We return True (meaning we consumed the reply)
+       * because otherwise it would invoke the X error handler,
+       * and an async API is useless if you have to synchronously
+       * trap X errors. Also GetProperty can always fail, pretty
+       * much, so trapping errors is always what you want.
+       *
+       * We have to eat all the error reply data here.
+       * (kind of a charade as we know sizeof(xError) == sizeof(xReply))
+       *
+       * Passing discard = True seems to break things; I don't understand
+       * why, because there should be no extra data in an error reply,
+       * right?
+       */
+      _XGetAsyncReply (dpy, (char *)&errbuf, rep, buf, len,
+                       (SIZEOF (xError) - bytes_read) >> 2, /* in 32-bit words */
+                       False); /* really seems like it should be True */
+      
+      return True;
+    }
+
+#ifdef DEBUG_SPEW
+  printf ("%s: already read %d bytes reading %d more for total of %d; generic.length = %ld\n",
+          __FUNCTION__, bytes_read, (SIZEOF (xGetPropertyReply) - bytes_read) >> 2,
+          SIZEOF (xGetPropertyReply), rep->generic.length);
+#endif
+
+  /* (kind of a silly as we know sizeof(xGetPropertyReply) == sizeof(xReply)) */
+  reply = (xGetPropertyReply *)
+    _XGetAsyncReply (dpy, (char *)&replbuf, rep, buf, len,
+                     (SIZEOF (xGetPropertyReply) - bytes_read) >> 2, /* in 32-bit words */
+                     False); /* False means expecting more data to follow,
+                              * don't eat the rest of the reply
+                              */
+
+  bytes_read = SIZEOF (xGetPropertyReply);
+
+#ifdef DEBUG_SPEW
+  printf ("%s: have reply propertyType = %ld format = %d n_items = %ld\n",
+          __FUNCTION__, reply->propertyType, reply->format, reply->nItems);
+#endif
+
+  assert (task->data == NULL);
+
+  /* This is all copied from XGetWindowProperty().  Not sure we should
+   * LockDisplay(). Not sure I'm passing the right args to
+   * XGetAsyncData(). Not sure about a lot of things.
+   */
+
+  /* LockDisplay (dpy); */
+
+  if (reply->propertyType != None)
+    {
+      long nbytes, netbytes;
+
+      /* this alignment macro from matecorba2 */
+#define ALIGN_VALUE(this, boundary) \
+  (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
+
+      switch (reply->format)
+        {
+          /*
+           * One extra byte is malloced than is needed to contain the property
+           * data, but this last byte is null terminated and convenient for
+           * returning string properties, so the client doesn't then have to
+           * recopy the string to make it null terminated.
+           */
+        case 8:
+          nbytes = reply->nItems;
+          /* there's padding to word boundary */
+          netbytes = ALIGN_VALUE (nbytes, 4);
+          if (nbytes + 1 > 0 &&
+              (task->data = (char *) Xmalloc ((unsigned)nbytes + 1)))
+            {
+#ifdef DEBUG_SPEW
+              printf ("%s: already read %d bytes using %ld, more eating %ld more\n",
+                      __FUNCTION__, bytes_read, nbytes, netbytes);
+#endif
+              /* _XReadPad (dpy, (char *) task->data, netbytes); */
+              _XGetAsyncData (dpy, task->data, buf, len,
+                              bytes_read, nbytes,
+                              netbytes);
+            }
+          break;
+
+        case 16:
+          nbytes = reply->nItems * sizeof (short);
+          netbytes = reply->nItems << 1;
+          netbytes = ALIGN_VALUE (netbytes, 4); /* align to word boundary */
+          if (nbytes + 1 > 0 &&
+              (task->data = (char *) Xmalloc ((unsigned)nbytes + 1)))
+            {
+#ifdef DEBUG_SPEW
+              printf ("%s: already read %d bytes using %ld more, eating %ld more\n",
+                      __FUNCTION__, bytes_read, nbytes, netbytes);
+#endif
+              /* _XRead16Pad (dpy, (short *) task->data, netbytes); */
+              _XGetAsyncData (dpy, task->data, buf, len,
+                              bytes_read, nbytes, netbytes);
+            }
+          break;
+
+        case 32:
+          /* NOTE buffer is in longs to match XGetWindowProperty() */
+          nbytes = reply->nItems * sizeof (long);
+          netbytes = reply->nItems << 2; /* wire size is always 32 bits though */
+          if (nbytes + 1 > 0 &&
+              (task->data = (char *) Xmalloc ((unsigned)nbytes + 1)))
+            {
+#ifdef DEBUG_SPEW
+              printf ("%s: already read %d bytes using %ld more, eating %ld more\n",
+                      __FUNCTION__, bytes_read, nbytes, netbytes);
+#endif
+
+              /* We have to copy the XGetWindowProperty() crackrock
+               * and get format 32 as long even on 64-bit platforms.
+               */
+              if (sizeof (long) == 8)
+                {
+                  char *netdata;
+                  char *lptr;
+                  char *end_lptr;
+                  
+                  /* Store the 32-bit values in the end of the array */
+                  netdata = task->data + nbytes / 2;
+
+                  _XGetAsyncData (dpy, netdata, buf, len,
+                                  bytes_read, netbytes,
+                                  netbytes);
+
+                  /* Now move the 32-bit values to the front */
+                  
+                  lptr = task->data;
+                  end_lptr = task->data + nbytes;
+                  while (lptr != end_lptr)
+                    {
+                      *(long*) lptr = *(CARD32*) netdata;
+                      lptr += sizeof (long);
+                      netdata += sizeof (CARD32);
+                    }
+                }
+              else
+                {
+                  /* Here the wire format matches our actual format */
+                  _XGetAsyncData (dpy, task->data, buf, len,
+                                  bytes_read, netbytes,
+                                  netbytes);
+                }
+            }
+          break;
+
+        default:
+          /*
+           * This part of the code should never be reached.  If it is,
+           * the server sent back a property with an invalid format.
+           * This is a BadImplementation error.
+           *
+           * However this async GetProperty API doesn't report errors
+           * via the standard X mechanism, so don't do anything about
+           * it, other than store it in task->error.
+           */
+          {
+#if 0
+            xError error;
+#endif
+            
+            task->error = BadImplementation;
+
+#if 0
+            error.sequenceNumber = task->request_seq;
+            error.type = X_Error;
+            error.majorCode = X_GetProperty;
+            error.minorCode = 0;
+            error.errorCode = BadImplementation;
+
+            _XError (dpy, &error);
+#endif
+          }
+
+          nbytes = netbytes = 0L;
+          break;
+        }
+
+      if (task->data == NULL)
+        {
+          task->error = BadAlloc;
+
+#ifdef DEBUG_SPEW
+          printf ("%s: already read %d bytes eating %ld\n",
+                  __FUNCTION__, bytes_read, netbytes);
+#endif
+          /* _XEatData (dpy, (unsigned long) netbytes); */
+          _XGetAsyncData (dpy, NULL, buf, len,
+                          bytes_read, 0, netbytes);
+
+          /* UnlockDisplay (dpy); */
+          return BadAlloc; /* not Success */
+        }
+
+      (task->data)[nbytes] = '\0';
+    }
+
+#ifdef DEBUG_SPEW
+  printf ("%s: have data\n", __FUNCTION__);
+#endif
+
+  task->actual_type = reply->propertyType;
+  task->actual_format = reply->format;
+  task->n_items = reply->nItems;
+  task->bytes_after = reply->bytesAfter;
+
+  /* UnlockDisplay (dpy); */
+
+  return True;
+}
+
+static AgPerDisplayData*
+get_display_data (Display *display,
+                  Bool     create)
+{
+  ListNode *node;
+  AgPerDisplayData *dd;
+  
+  node = display_datas;
+  while (node != NULL)
+    {
+      dd = (AgPerDisplayData*) node;
+      
+      if (dd->display == display)
+        return dd;
+      
+      node = node->next;
+    }
+
+  if (!create)
+    return NULL;
+  
+  dd = Xcalloc (1, sizeof (AgPerDisplayData));
+  if (dd == NULL)
+    return NULL;
+
+  dd->display = display;
+  dd->async.next = display->async_handlers;
+  dd->async.handler = async_get_property_handler;
+  dd->async.data = (XPointer) dd;
+  dd->display->async_handlers = &dd->async;
+
+  append_to_list (&display_datas,
+                  &display_datas_tail,
+                  &dd->node);
+  
+  return dd;
+}
+
+static void
+maybe_free_display_data (AgPerDisplayData *dd)
+{
+  if (dd->pending_tasks == NULL &&
+      dd->completed_tasks == NULL)
+    {
+      DeqAsyncHandler (dd->display, &dd->async);
+      remove_from_list (&display_datas, &display_datas_tail,
+                        &dd->node);
+      XFree (dd);
+    }
+}
+
+AgGetPropertyTask*
+ag_task_create (Display *dpy,
+                Window   window,
+                Atom     property,
+                long     offset,
+                long     length,
+                Bool     delete,
+                Atom     req_type)
+{
+  AgGetPropertyTask *task;
+  xGetPropertyReq *req;
+  AgPerDisplayData *dd;  
+  
+  /* Fire up our request */
+  LockDisplay (dpy);
+
+  dd = get_display_data (dpy, True);
+  if (dd == NULL)
+    {
+      UnlockDisplay (dpy);
+      return NULL;
+    }
+  
+  GetReq (GetProperty, req);
+  req->window = window;
+  req->property = property;
+  req->type = req_type;
+  req->delete = delete;
+  req->longOffset = offset;
+  req->longLength = length;
+
+  /* Queue up our async task */
+  task = Xcalloc (1, sizeof (AgGetPropertyTask));
+  if (task == NULL)
+    {
+      UnlockDisplay (dpy);
+      return NULL;
+    }
+
+  task->dd = dd;
+  task->window = window;
+  task->property = property;
+  task->request_seq = dpy->request;
+
+  append_to_list (&dd->pending_tasks,
+                  &dd->pending_tasks_tail,
+                  &task->node);
+  dd->n_tasks_pending += 1;
+  
+  UnlockDisplay (dpy);
+
+  SyncHandle ();
+
+  return task;
+}
+
+static void
+free_task (AgGetPropertyTask *task)
+{
+  remove_from_list (&task->dd->completed_tasks,
+                    &task->dd->completed_tasks_tail,
+                    &task->node);
+  task->dd->n_tasks_completed -= 1;
+  maybe_free_display_data (task->dd);
+  XFree (task);
+}
+
+Status
+ag_task_get_reply_and_free (AgGetPropertyTask  *task,
+                            Atom               *actual_type,
+                            int                *actual_format,
+                            unsigned long      *nitems,
+                            unsigned long      *bytesafter,
+                            unsigned char     **prop)
+{
+  Display *dpy;
+
+  *prop = NULL;
+
+  dpy = task->dd->display; /* Xlib macros require a variable named "dpy" */
+  
+  if (task->error != Success)
+    {
+      Status s = task->error;
+
+      free_task (task);
+      
+      return s;
+    }
+
+  if (!task->have_reply)
+    {
+      free_task (task);
+
+      return BadAlloc; /* not Success */
+    }
+
+  *actual_type = task->actual_type;
+  *actual_format = task->actual_format;
+  *nitems = task->n_items;
+  *bytesafter = task->bytes_after;
+
+  *prop = (unsigned char*) task->data; /* pass out ownership of task->data */
+
+  SyncHandle ();
+
+  free_task (task);
+  
+  return Success;
+}
+
+Bool
+ag_task_have_reply (AgGetPropertyTask *task)
+{
+  return task->have_reply;
+}
+
+Atom
+ag_task_get_property (AgGetPropertyTask *task)
+{
+  return task->property;
+}
+
+Window
+ag_task_get_window (AgGetPropertyTask *task)
+{
+  return task->window;
+}
+
+Display*
+ag_task_get_display (AgGetPropertyTask *task)
+{
+  return task->dd->display;
+}
+
+AgGetPropertyTask*
+ag_get_next_completed_task (Display *display)
+{
+  AgPerDisplayData *dd;
+
+  dd = get_display_data (display, False);
+
+  if (dd == NULL)
+    return NULL;
+  
+#ifdef DEBUG_SPEW
+  printf ("%d pending %d completed\n",
+          dd->n_tasks_pending,
+          dd->n_tasks_completed);
+#endif
+
+  return (AgGetPropertyTask*) dd->completed_tasks;
+}
+
+void*
+ag_Xmalloc (unsigned long bytes)
+{
+  return (void*) Xmalloc (bytes);
+}
+
+void*
+ag_Xmalloc0 (unsigned long bytes)
+{
+  return (void*) Xcalloc (bytes, 1);
+}
diff --git a/src/core/async-getprop.h b/src/core/async-getprop.h
new file mode 100644
index 00000000..c857e930
--- /dev/null
+++ b/src/core/async-getprop.h
@@ -0,0 +1,67 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Asynchronous X property getting hack */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef ASYNC_GETPROP_H
+#define ASYNC_GETPROP_H
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+typedef struct _AgGetPropertyTask AgGetPropertyTask;
+
+AgGetPropertyTask* ag_task_create             (Display            *display,
+                                               Window              window,
+                                               Atom                property,
+                                               long                offset,
+                                               long                length,
+                                               Bool                delete,
+                                               Atom                req_type);
+Status             ag_task_get_reply_and_free (AgGetPropertyTask  *task,
+                                               Atom               *actual_type,
+                                               int                *actual_format,
+                                               unsigned long      *nitems,
+                                               unsigned long      *bytesafter,
+                                               unsigned char     **prop);
+
+Bool     ag_task_have_reply   (AgGetPropertyTask *task);
+Atom     ag_task_get_property (AgGetPropertyTask *task);
+Window   ag_task_get_window   (AgGetPropertyTask *task);
+Display* ag_task_get_display  (AgGetPropertyTask *task);
+
+AgGetPropertyTask* ag_get_next_completed_task (Display *display);
+
+/* so other headers don't have to include internal Xlib goo */
+void*    ag_Xmalloc  (unsigned long bytes);
+void*    ag_Xmalloc0 (unsigned long bytes);
+
+#endif
+
+
+
+
diff --git a/src/core/atomnames.h b/src/core/atomnames.h
new file mode 100644
index 00000000..551482ac
--- /dev/null
+++ b/src/core/atomnames.h
@@ -0,0 +1,166 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * Copyright (C) 2008 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file atomnames.h  A list of atom names.
+ *
+ * This is a list of the names of all the X atoms that Marco uses.
+ * Each is wrapped in a macro "item()" which is undefined here; the
+ * idea is that when you need to make a big list of all the X atoms,
+ * you can define item(), include this file, and then undefine it
+ * again.
+ *
+ * If you also define EWMH_ATOMS_ONLY then you will only get _NET_WM_*
+ * atoms rather than all of them.
+ */
+
+#ifndef item
+#error "item(x) must be defined when you include atomnames.h"
+#endif
+
+#ifndef EWMH_ATOMS_ONLY
+
+item(WM_PROTOCOLS)
+item(WM_TAKE_FOCUS)
+item(WM_DELETE_WINDOW)
+item(WM_STATE)
+item(_MOTIF_WM_HINTS)
+item(WM_CHANGE_STATE)
+item(SM_CLIENT_ID)
+item(WM_CLIENT_LEADER)
+item(WM_WINDOW_ROLE)
+item(UTF8_STRING)
+item(WM_ICON_SIZE)
+item(_KWM_WIN_ICON)
+item(_MARCO_RESTART_MESSAGE)    
+item(_MARCO_RELOAD_THEME_MESSAGE)
+item(_MARCO_SET_KEYBINDINGS_MESSAGE)
+item(_MARCO_TOGGLE_VERBOSE)
+item(_MATE_PANEL_ACTION)
+item(_MATE_PANEL_ACTION_MAIN_MENU)
+item(_MATE_PANEL_ACTION_RUN_DIALOG)
+item(_MARCO_SENTINEL)
+item(_MARCO_VERSION)
+item(WM_CLIENT_MACHINE)
+item(MANAGER)
+item(TARGETS)
+item(MULTIPLE)
+item(TIMESTAMP)
+item(VERSION)
+item(ATOM_PAIR)
+
+/* Oddities: These are used, and we need atoms for them,
+ * but when we need all _NET_WM hints (i.e. when we're making
+ * lists of which _NET_WM hints we support in order to advertise
+ * it) we haven't historically listed them.  I don't know what
+ * the reason for this is.  It may be a bug.
+ */
+item(_NET_WM_SYNC_REQUEST)
+item(_NET_WM_SYNC_REQUEST_COUNTER)
+item(_NET_WM_VISIBLE_NAME)
+item(_NET_WM_VISIBLE_ICON_NAME)
+item(_NET_SUPPORTING_WM_CHECK)
+
+/* But I suppose it's quite reasonable not to advertise using
+ * _NET_SUPPORTED that we support _NET_SUPPORTED :)
+ */
+item(_NET_SUPPORTED)
+
+#endif /* !EWMH_ATOMS_ONLY */
+
+/**************************************************************************/
+
+item(_NET_WM_NAME)
+item(_NET_CLOSE_WINDOW)
+item(_NET_WM_STATE)
+item(_NET_WM_STATE_SHADED)
+item(_NET_WM_STATE_MAXIMIZED_HORZ)
+item(_NET_WM_STATE_MAXIMIZED_VERT)
+item(_NET_WM_DESKTOP)
+item(_NET_NUMBER_OF_DESKTOPS)
+item(_NET_CURRENT_DESKTOP)
+item(_NET_WM_WINDOW_TYPE)
+item(_NET_WM_WINDOW_TYPE_DESKTOP)
+item(_NET_WM_WINDOW_TYPE_DOCK)
+item(_NET_WM_WINDOW_TYPE_TOOLBAR)
+item(_NET_WM_WINDOW_TYPE_MENU)
+item(_NET_WM_WINDOW_TYPE_DIALOG)
+item(_NET_WM_WINDOW_TYPE_NORMAL)
+item(_NET_WM_STATE_MODAL)
+item(_NET_CLIENT_LIST)
+item(_NET_CLIENT_LIST_STACKING)
+item(_NET_WM_STATE_SKIP_TASKBAR)
+item(_NET_WM_STATE_SKIP_PAGER)
+item(_NET_WM_ICON_NAME)
+item(_NET_WM_ICON)
+item(_NET_WM_ICON_GEOMETRY)
+item(_NET_WM_MOVERESIZE)
+item(_NET_ACTIVE_WINDOW)
+item(_NET_WM_STRUT)
+item(_NET_WM_STATE_HIDDEN)
+item(_NET_WM_WINDOW_TYPE_UTILITY)
+item(_NET_WM_WINDOW_TYPE_SPLASH)
+item(_NET_WM_STATE_FULLSCREEN)
+item(_NET_WM_PING)
+item(_NET_WM_PID)
+item(_NET_WORKAREA)
+item(_NET_SHOWING_DESKTOP)
+item(_NET_DESKTOP_LAYOUT)
+item(_NET_DESKTOP_NAMES)
+item(_NET_WM_ALLOWED_ACTIONS)
+item(_NET_WM_ACTION_MOVE)
+item(_NET_WM_ACTION_RESIZE)
+item(_NET_WM_ACTION_SHADE)
+item(_NET_WM_ACTION_STICK)
+item(_NET_WM_ACTION_MAXIMIZE_HORZ)
+item(_NET_WM_ACTION_MAXIMIZE_VERT)
+item(_NET_WM_ACTION_CHANGE_DESKTOP)
+item(_NET_WM_ACTION_CLOSE)
+item(_NET_WM_STATE_ABOVE)
+item(_NET_WM_STATE_BELOW)
+item(_NET_STARTUP_ID)
+item(_NET_WM_STRUT_PARTIAL)
+item(_NET_WM_ACTION_FULLSCREEN)
+item(_NET_WM_ACTION_MINIMIZE)
+item(_NET_FRAME_EXTENTS)
+item(_NET_REQUEST_FRAME_EXTENTS)
+item(_NET_WM_USER_TIME)
+item(_NET_WM_STATE_DEMANDS_ATTENTION)
+item(_NET_MOVERESIZE_WINDOW)
+item(_NET_DESKTOP_GEOMETRY)
+item(_NET_DESKTOP_VIEWPORT)
+item(_NET_WM_USER_TIME_WINDOW)
+item(_NET_WM_ACTION_ABOVE)
+item(_NET_WM_ACTION_BELOW)
+item(_NET_WM_STATE_STICKY)
+item(_NET_WM_FULLSCREEN_MONITORS)
+
+#if 0
+/* We apparently never use: */
+/* item(_NET_RESTACK_WINDOW) */
+#endif
+
+/* eof atomnames.h */
+
diff --git a/src/core/bell.c b/src/core/bell.c
new file mode 100644
index 00000000..560b3569
--- /dev/null
+++ b/src/core/bell.c
@@ -0,0 +1,397 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco visual bell */
+
+/*
+ * Copyright (C) 2002 Sun Microsystems Inc.
+ * Copyright (C) 2005, 2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file bell.c Ring the bell or flash the screen
+ *
+ * Sometimes, X programs "ring the bell", whatever that means. Marco lets
+ * the user configure the bell to be audible or visible (aka visual), and
+ * if it's visual it can be configured to be frame-flash or fullscreen-flash.
+ * We never get told about audible bells; X handles them just fine by itself.
+ *
+ * Visual bells come in at meta_bell_notify(), which checks we are actually
+ * in visual mode and calls through to bell_visual_notify(). That
+ * function then checks what kind of visual flash you like, and calls either
+ * bell_flash_fullscreen()-- which calls bell_flash_screen() to do
+ * its work-- or bell_flash_frame(), which flashes the focussed window
+ * using bell_flash_window_frame(), unless there is no such window, in
+ * which case it flashes the screen instead. bell_flash_window_frame()
+ * flashes the frame and calls bell_unflash_frame() as a timeout to
+ * remove the flash.
+ *
+ * The visual bell was the result of a discussion in Bugzilla here:
+ * <http://bugzilla.gnome.org/show_bug.cgi?id=99886>.
+ *
+ * Several of the functions in this file are ifdeffed out entirely if we are
+ * found not to have the XKB extension, which is required to do these clever
+ * things with bells; some others are entirely no-ops in that case.
+ */
+
+#include <config.h>
+#include "bell.h"
+#include "screen-private.h"
+#include "prefs.h"
+#include <canberra-gtk.h>
+
+/**
+ * Flashes one entire screen.  This is done by making a window the size of the
+ * whole screen (or reusing the old one, if it's still around), mapping it,
+ * painting it white and then black, and then unmapping it. We set saveunder so
+ * that all the windows behind it come back immediately.
+ *
+ * Unlike frame flashes, we don't do fullscreen flashes with a timeout; rather,
+ * we do them in one go, because we don't have to rely on the theme code
+ * redrawing the frame for us in order to do the flash.
+ *
+ * \param display  The display which owns the screen (rather redundant)
+ * \param screen   The screen to flash
+ *
+ * \bug The way I read it, this appears not to do the flash
+ * the first time we flash a particular display. Am I wrong?
+ *
+ * \bug This appears to destroy our current XSync status.
+ */
+static void
+bell_flash_screen (MetaDisplay *display,
+			MetaScreen  *screen)
+{
+  Window root = screen->xroot;
+  int width = screen->rect.width;
+  int height = screen->rect.height;
+
+  if (screen->flash_window == None)
+    {
+      Visual *visual = (Visual *)CopyFromParent;
+      XSetWindowAttributes xswa;
+      int depth = CopyFromParent;
+      xswa.save_under = True;
+      xswa.override_redirect = True;
+      /*
+       * TODO: use XGetVisualInfo and determine which is an
+       * overlay, if one is present, and use the Overlay visual
+       * for this window (for performance reasons).
+       * Not sure how to tell this yet...
+       */
+      screen->flash_window = XCreateWindow (display->xdisplay, root,
+					    0, 0, width, height,
+					    0, depth,
+					    InputOutput,
+					    visual,
+				    /* note: XSun doesn't like SaveUnder here */
+					    CWSaveUnder | CWOverrideRedirect,
+					    &xswa);
+      XSelectInput (display->xdisplay, screen->flash_window, ExposureMask);
+      XMapWindow (display->xdisplay, screen->flash_window);
+      XSync (display->xdisplay, False);
+      XFlush (display->xdisplay);
+      XUnmapWindow (display->xdisplay, screen->flash_window);
+    }
+  else
+    {
+      /* just draw something in the window */
+      GC gc = XCreateGC (display->xdisplay, screen->flash_window, 0, NULL);
+      XMapWindow (display->xdisplay, screen->flash_window);
+      XSetForeground (display->xdisplay, gc,
+		      WhitePixel (display->xdisplay,
+				  XScreenNumberOfScreen (screen->xscreen)));
+      XFillRectangle (display->xdisplay, screen->flash_window, gc,
+		      0, 0, width, height);
+      XSetForeground (display->xdisplay, gc,
+		      BlackPixel (display->xdisplay,
+				  XScreenNumberOfScreen (screen->xscreen)));
+      XFillRectangle (display->xdisplay, screen->flash_window, gc,
+		      0, 0, width, height);
+      XFlush (display->xdisplay);
+      XSync (display->xdisplay, False);
+      XUnmapWindow (display->xdisplay, screen->flash_window);
+      XFreeGC (display->xdisplay, gc);
+    }
+
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK &&
+      !display->mouse_mode)
+    meta_display_increment_focus_sentinel (display);
+  XFlush (display->xdisplay);
+}
+
+/**
+ * Flashes one screen, or all screens, in response to a bell event.
+ * If the event is on a particular window, flash the screen that
+ * window is on. Otherwise, flash every screen on this display.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the event came in on
+ * \param xkb_ev   The bell event
+ */
+#ifdef HAVE_XKB
+static void
+bell_flash_fullscreen (MetaDisplay *display,
+			    XkbAnyEvent *xkb_ev)
+{
+  XkbBellNotifyEvent *xkb_bell_ev = (XkbBellNotifyEvent *) xkb_ev;
+  MetaScreen *screen;
+
+  g_assert (xkb_ev->xkb_type == XkbBellNotify);
+  if (xkb_bell_ev->window != None)
+    {
+      screen = meta_display_screen_for_xwindow (display, xkb_bell_ev->window);
+      if (screen)
+	bell_flash_screen (display, screen);
+    }
+  else
+    {
+      GSList *screen_list = display->screens;
+      while (screen_list)
+	{
+	  screen = (MetaScreen *) screen_list->data;
+	  bell_flash_screen (display, screen);
+	  screen_list = screen_list->next;
+	}
+    }
+}
+
+/**
+ * Makes a frame be not flashed; this is the timeout half of
+ * bell_flash_window_frame(). This is done simply by clearing the
+ * flash flag and queuing a redraw of the frame.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param data  The frame to unflash, cast to a gpointer so it can go into
+ *              a callback function.
+ * \return Always FALSE, so we don't get called again.
+ *
+ * \bug This is the parallel to bell_flash_window_frame(), so it should
+ * really be called meta_bell_unflash_window_frame().
+ */
+static gboolean
+bell_unflash_frame (gpointer data)
+{
+  MetaFrame *frame = (MetaFrame *) data;
+  frame->is_flashing = 0;
+  meta_frame_queue_draw (frame);
+  return FALSE;
+}
+
+/**
+ * Makes a frame flash and then return to normal shortly afterwards.
+ * This is done by setting a flag so that the theme
+ * code will temporarily draw the frame as focussed if it's unfocussed and
+ * vice versa, and then queueing a redraw. Lastly, we create a timeout so
+ * that the flag can be unset and the frame re-redrawn.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param window  The window to flash
+ */
+static void
+bell_flash_window_frame (MetaWindow *window)
+{
+  g_assert (window->frame != NULL);
+  window->frame->is_flashing = 1;
+  meta_frame_queue_draw (window->frame);
+  g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE, 100,
+      bell_unflash_frame, window->frame, NULL);
+}
+
+/**
+ * Flashes the frame of the focussed window. If there is no focussed window,
+ * flashes the screen.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ */
+static void
+bell_flash_frame (MetaDisplay *display,
+		  XkbAnyEvent *xkb_ev)
+{
+  XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent *) xkb_ev;
+  MetaWindow *window;
+
+  g_assert (xkb_ev->xkb_type == XkbBellNotify);
+  window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+  if (!window && (display->focus_window))
+    {
+      window = display->focus_window;
+    }
+  if (window && window->frame)
+    {
+      bell_flash_window_frame (window);
+    }
+  else /* revert to fullscreen flash if there's no focussed window */
+    {
+      bell_flash_fullscreen (display, xkb_ev);
+    }
+}
+
+/**
+ * Gives the user some kind of visual bell substitute, in response to a
+ * bell event. What this is depends on the "visual bell type" pref.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ *
+ * \bug This should be merged with meta_bell_notify().
+ */
+static void
+bell_visual_notify (MetaDisplay *display,
+			 XkbAnyEvent *xkb_ev)
+{
+  switch (meta_prefs_get_visual_bell_type ())
+    {
+    case META_VISUAL_BELL_FULLSCREEN_FLASH:
+      bell_flash_fullscreen (display, xkb_ev);
+      break;
+    case META_VISUAL_BELL_FRAME_FLASH:
+      bell_flash_frame (display, xkb_ev); /* does nothing yet */
+      break;
+    case META_VISUAL_BELL_INVALID:
+      /* do nothing */
+      break;
+    }
+}
+
+void
+meta_bell_notify (MetaDisplay *display,
+		  XkbAnyEvent *xkb_ev)
+{
+  /* flash something */
+  if (meta_prefs_get_visual_bell ())
+    bell_visual_notify (display, xkb_ev);
+
+  if (meta_prefs_bell_is_audible ())
+    {
+      ca_proplist *p;
+      XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
+      MetaWindow *window;
+      int res;
+
+      ca_proplist_create (&p);
+      ca_proplist_sets (p, CA_PROP_EVENT_ID, "bell-window-system");
+      ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION, _("Bell event"));
+      ca_proplist_sets (p, CA_PROP_CANBERRA_CACHE_CONTROL, "permanent");
+
+      window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+      if (!window && (display->focus_window) && (display->focus_window->frame))
+        window = display->focus_window;
+
+      if (window)
+        {
+          ca_proplist_sets (p, CA_PROP_WINDOW_NAME, window->title);
+          ca_proplist_setf (p, CA_PROP_WINDOW_X11_XID, "%lu", (unsigned long)window->xwindow);
+          ca_proplist_sets (p, CA_PROP_APPLICATION_NAME, window->res_name);
+          ca_proplist_setf (p, CA_PROP_APPLICATION_PROCESS_ID, "%d", window->net_wm_pid);
+        }
+
+      /* First, we try to play a real sound ... */
+      res = ca_context_play_full (ca_gtk_context_get (), 1, p, NULL, NULL);
+
+      ca_proplist_destroy (p);
+
+      if (res != CA_SUCCESS && res != CA_ERROR_DISABLED)
+        {
+          /* ...and in case that failed we use the classic X11 bell. */
+          XkbForceDeviceBell (display->xdisplay,
+                              xkb_bell_event->device,
+                              xkb_bell_event->bell_class,
+                              xkb_bell_event->bell_id,
+                              xkb_bell_event->percent);
+        }
+    }
+}
+#endif /* HAVE_XKB */
+
+void
+meta_bell_set_audible (MetaDisplay *display, gboolean audible)
+{
+}
+
+gboolean
+meta_bell_init (MetaDisplay *display)
+{
+#ifdef HAVE_XKB
+  int xkb_base_error_type, xkb_opcode;
+
+  if (!XkbQueryExtension (display->xdisplay, &xkb_opcode,
+			  &display->xkb_base_event_type,
+			  &xkb_base_error_type,
+			  NULL, NULL))
+    {
+      display->xkb_base_event_type = -1;
+      g_message ("could not find XKB extension.");
+      return FALSE;
+    }
+  else
+    {
+      unsigned int mask = XkbBellNotifyMask;
+      gboolean visual_bell_auto_reset = FALSE;
+      /* TRUE if and when non-broken version is available */
+      XkbSelectEvents (display->xdisplay,
+		       XkbUseCoreKbd,
+		       XkbBellNotifyMask,
+		       XkbBellNotifyMask);
+      XkbChangeEnabledControls (display->xdisplay,
+				XkbUseCoreKbd,
+				XkbAudibleBellMask,
+                                0);
+      if (visual_bell_auto_reset) {
+	XkbSetAutoResetControls (display->xdisplay,
+				 XkbAudibleBellMask,
+				 &mask,
+				 &mask);
+      }
+      return TRUE;
+    }
+#endif
+  return FALSE;
+}
+
+void
+meta_bell_shutdown (MetaDisplay *display)
+{
+#ifdef HAVE_XKB
+  /* TODO: persist initial bell state in display, reset here */
+  XkbChangeEnabledControls (display->xdisplay,
+			    XkbUseCoreKbd,
+			    XkbAudibleBellMask,
+			    XkbAudibleBellMask);
+#endif
+}
+
+/**
+ * Deals with a frame being destroyed. This is important because if we're
+ * using a visual bell, we might be flashing the edges of the frame, and
+ * so we'd have a timeout function waiting ready to un-flash them. If the
+ * frame's going away, we can tell the timeout not to bother.
+ *
+ * \param frame  The frame which is being destroyed
+ */
+void
+meta_bell_notify_frame_destroy (MetaFrame *frame)
+{
+  if (frame->is_flashing)
+    g_source_remove_by_funcs_user_data (&g_timeout_funcs, frame);
+}
diff --git a/src/core/bell.h b/src/core/bell.h
new file mode 100644
index 00000000..95e3ea9e
--- /dev/null
+++ b/src/core/bell.h
@@ -0,0 +1,108 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file bell.h Ring the bell or flash the screen
+ *
+ * Sometimes, X programs "ring the bell", whatever that means. Marco lets
+ * the user configure the bell to be audible or visible (aka visual), and
+ * if it's visual it can be configured to be frame-flash or fullscreen-flash.
+ * We never get told about audible bells; X handles them just fine by itself.
+ *
+ * The visual bell was the result of a discussion in Bugzilla here:
+ * <http://bugzilla.gnome.org/show_bug.cgi?id=99886>.
+ */
+
+/*
+ * Copyright (C) 2002 Sun Microsystems Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <X11/Xlib.h>
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#endif
+#include "display-private.h"
+#include "frame-private.h"
+
+#ifdef HAVE_XKB
+/**
+ * Gives the user some kind of visual bell; in fact, this is our response
+ * to any kind of bell request, but we set it up so that we only get
+ * notified about visual bells, and X deals with audible ones.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ */
+void meta_bell_notify (MetaDisplay *display, XkbAnyEvent *xkb_ev);
+#endif
+
+/**
+ * Turns the bell to audible or visual. This tells X what to do, but
+ * not Marco; you will need to set the "visual bell" pref for that.
+ *
+ * If the configure script found we had no XKB, this is a no-op.
+ *
+ * \param display  The display we're configuring
+ * \param audible  True for an audible bell, false for a visual bell
+ */
+void meta_bell_set_audible (MetaDisplay *display, gboolean audible);
+
+/**
+ * Initialises the bell subsystem. This involves intialising
+ * XKB (which, despite being a keyboard extension, is the
+ * place to look for bell notifications), then asking it
+ * to send us bell notifications, and then also switching
+ * off the audible bell if we're using a visual one ourselves.
+ *
+ * Unlike most X extensions we use, we only initialise XKB here
+ * (rather than in main()). It's possible that XKB is not
+ * installed at all, but if that was known at build time
+ * we will have HAVE_XKB undefined, which will cause this
+ * function to be a no-op.
+ *
+ * \param display  The display which is opening
+ *
+ * \bug There is a line of code that's never run that tells
+ * XKB to reset the bell status after we quit. Bill H said
+ * (<http://bugzilla.gnome.org/show_bug.cgi?id=99886#c12>)
+ * that XFree86's implementation is broken so we shouldn't
+ * call it, but that was in 2002. Is it working now?
+ */
+gboolean meta_bell_init (MetaDisplay *display);
+
+/**
+ * Shuts down the bell subsystem.
+ *
+ * \param display  The display which is closing
+ *
+ * \bug This is never called! If we had XkbSetAutoResetControls
+ * enabled in meta_bell_init(), this wouldn't be a problem, but
+ * we don't.
+ */
+void meta_bell_shutdown (MetaDisplay *display);
+
+/**
+ * Deals with a frame being destroyed. This is important because if we're
+ * using a visual bell, we might be flashing the edges of the frame, and
+ * so we'd have a timeout function waiting ready to un-flash them. If the
+ * frame's going away, we can tell the timeout not to bother.
+ *
+ * \param frame  The frame which is being destroyed
+ */
+void meta_bell_notify_frame_destroy (MetaFrame *frame);
diff --git a/src/core/boxes.c b/src/core/boxes.c
new file mode 100644
index 00000000..2ae5f06a
--- /dev/null
+++ b/src/core/boxes.c
@@ -0,0 +1,1926 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Simple box operations */
+
+/*
+ * Copyright (C) 2005, 2006 Elijah Newren
+ * [meta_rectangle_intersect() is copyright the GTK+ Team according to Havoc,
+ * see gdkrectangle.c.  As far as Havoc knows, he probably wrote
+ * meta_rectangle_equal(), and I'm guessing it's (C) Red Hat.  So...]
+ * Copyright (C) 1995-2000  GTK+ Team
+ * Copyright (C) 2002 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "boxes.h"
+#include "util.h"
+#include <X11/Xutil.h>  /* Just for the definition of the various gravities */
+
+char*
+meta_rectangle_to_string (const MetaRectangle *rect,
+                          char                *output)
+{
+  /* 25 chars: 2 commas, space, plus, trailing \0 + 5 for each digit.
+   * Should be more than enough space.  Note that of this space, the
+   * trailing \0 will be overwritten for all but the last rectangle.
+   */
+  g_snprintf (output, RECT_LENGTH, "%d,%d +%d,%d",
+              rect->x, rect->y, rect->width, rect->height);
+
+  return output;
+}
+
+char*
+meta_rectangle_region_to_string (GList      *region,
+                                 const char *separator_string,
+                                 char       *output)
+{
+  /* 27 chars: 2 commas, 2 square brackets, space, plus, trailing \0 + 5
+   * for each digit.  Should be more than enough space.  Note that of this
+   * space, the trailing \0 will be overwritten for all but the last
+   * rectangle.
+   */
+  char rect_string[RECT_LENGTH];
+
+  GList *tmp = region;
+  char *cur = output;
+
+  if (region == NULL)
+    g_snprintf (output, 10, "(EMPTY)");
+
+  while (tmp)
+    {
+      MetaRectangle *rect = tmp->data;
+      g_snprintf (rect_string, RECT_LENGTH, "[%d,%d +%d,%d]",
+                  rect->x, rect->y, rect->width, rect->height);
+      cur = g_stpcpy (cur, rect_string);
+      tmp = tmp->next;
+      if (tmp)
+        cur = g_stpcpy (cur, separator_string);
+    }
+
+  return output;
+}
+
+char*
+meta_rectangle_edge_to_string (const MetaEdge *edge,
+                               char           *output)
+{
+  /* 25 chars: 2 commas, space, plus, trailing \0 + 5 for each digit.
+   * Should be more than enough space.  Note that of this space, the
+   * trailing \0 will be overwritten for all but the last rectangle.
+   *
+   * Plus 2 for parenthesis, 4 for 2 more numbers, 2 more commas, and
+   * 2 more spaces, for a total of 10 more.
+   */
+  g_snprintf (output, EDGE_LENGTH, "[%d,%d +%d,%d], %2d, %2d",
+              edge->rect.x, edge->rect.y, edge->rect.width, edge->rect.height,
+              edge->side_type, edge->edge_type);
+
+  return output;
+}
+
+char*
+meta_rectangle_edge_list_to_string (GList      *edge_list,
+                                    const char *separator_string,
+                                    char       *output)
+{
+  /* 27 chars: 2 commas, 2 square brackets, space, plus, trailing \0 + 5 for
+   * each digit.  Should be more than enough space.  Note that of this
+   * space, the trailing \0 will be overwritten for all but the last
+   * rectangle.
+   *
+   * Plus 2 for parenthesis, 4 for 2 more numbers, 2 more commas, and
+   * 2 more spaces, for a total of 10 more.
+   */
+  char rect_string[EDGE_LENGTH];
+
+  char *cur = output;
+  GList *tmp = edge_list;
+
+  if (edge_list == NULL)
+    g_snprintf (output, 10, "(EMPTY)");
+
+  while (tmp)
+    {
+      MetaEdge      *edge = tmp->data;
+      MetaRectangle *rect = &edge->rect;
+      g_snprintf (rect_string, EDGE_LENGTH, "([%d,%d +%d,%d], %2d, %2d)",
+                  rect->x, rect->y, rect->width, rect->height,
+                  edge->side_type, edge->edge_type);
+      cur = g_stpcpy (cur, rect_string);
+      tmp = tmp->next;
+      if (tmp)
+        cur = g_stpcpy (cur, separator_string);
+    }
+
+  return output;
+}
+
+MetaRectangle
+meta_rect (int x, int y, int width, int height)
+{
+  MetaRectangle temporary;
+  temporary.x = x;
+  temporary.y = y;
+  temporary.width  = width;
+  temporary.height = height;
+
+  return temporary;
+}
+
+int
+meta_rectangle_area (const MetaRectangle *rect)
+{
+  g_return_val_if_fail (rect != NULL, 0);
+  return rect->width * rect->height;
+}
+
+gboolean
+meta_rectangle_intersect (const MetaRectangle *src1,
+			  const MetaRectangle *src2,
+			  MetaRectangle *dest)
+{
+  int dest_x, dest_y;
+  int dest_w, dest_h;
+  int return_val;
+
+  g_return_val_if_fail (src1 != NULL, FALSE);
+  g_return_val_if_fail (src2 != NULL, FALSE);
+  g_return_val_if_fail (dest != NULL, FALSE);
+
+  return_val = FALSE;
+
+  dest_x = MAX (src1->x, src2->x);
+  dest_y = MAX (src1->y, src2->y);
+  dest_w = MIN (src1->x + src1->width, src2->x + src2->width) - dest_x;
+  dest_h = MIN (src1->y + src1->height, src2->y + src2->height) - dest_y;
+
+  if (dest_w > 0 && dest_h > 0)
+    {
+      dest->x = dest_x;
+      dest->y = dest_y;
+      dest->width = dest_w;
+      dest->height = dest_h;
+      return_val = TRUE;
+    }
+  else
+    {
+      dest->width = 0;
+      dest->height = 0;
+    }
+
+  return return_val;
+}
+
+gboolean
+meta_rectangle_equal (const MetaRectangle *src1,
+                      const MetaRectangle *src2)
+{
+  return ((src1->x == src2->x) &&
+          (src1->y == src2->y) &&
+          (src1->width == src2->width) &&
+          (src1->height == src2->height));
+}
+
+void
+meta_rectangle_union (const MetaRectangle *rect1,
+                      const MetaRectangle *rect2,
+                      MetaRectangle       *dest)
+{
+  int dest_x, dest_y;
+  int dest_w, dest_h;
+
+  dest_x = rect1->x;
+  dest_y = rect1->y;
+  dest_w = rect1->width;
+  dest_h = rect1->height;
+
+  if (rect2->x < dest_x)
+    {
+      dest_w += dest_x - rect2->x;
+      dest_x = rect2->x;
+    }
+  if (rect2->y < dest_y)
+    {
+      dest_h += dest_y - rect2->y;
+      dest_y = rect2->y;
+    }
+  if (rect2->x + rect2->width > dest_x + dest_w)
+    dest_w = rect2->x + rect2->width - dest_x;
+  if (rect2->y + rect2->height > dest_y + dest_h)
+    dest_h = rect2->y + rect2->height - dest_y;
+
+  dest->x = dest_x;
+  dest->y = dest_y;
+  dest->width = dest_w;
+  dest->height = dest_h;
+}
+
+gboolean
+meta_rectangle_overlap (const MetaRectangle *rect1,
+                        const MetaRectangle *rect2)
+{
+  g_return_val_if_fail (rect1 != NULL, FALSE);
+  g_return_val_if_fail (rect2 != NULL, FALSE);
+
+  return !((rect1->x + rect1->width  <= rect2->x) ||
+           (rect2->x + rect2->width  <= rect1->x) ||
+           (rect1->y + rect1->height <= rect2->y) ||
+           (rect2->y + rect2->height <= rect1->y));
+}
+
+gboolean
+meta_rectangle_vert_overlap (const MetaRectangle *rect1,
+                             const MetaRectangle *rect2)
+{
+  return (rect1->y < rect2->y + rect2->height &&
+          rect2->y < rect1->y + rect1->height);
+}
+
+gboolean
+meta_rectangle_horiz_overlap (const MetaRectangle *rect1,
+                              const MetaRectangle *rect2)
+{
+  return (rect1->x < rect2->x + rect2->width &&
+          rect2->x < rect1->x + rect1->width);
+}
+
+gboolean
+meta_rectangle_could_fit_rect (const MetaRectangle *outer_rect,
+                               const MetaRectangle *inner_rect)
+{
+  return (outer_rect->width  >= inner_rect->width &&
+          outer_rect->height >= inner_rect->height);
+}
+
+gboolean
+meta_rectangle_contains_rect  (const MetaRectangle *outer_rect,
+                               const MetaRectangle *inner_rect)
+{
+  return
+    inner_rect->x                      >= outer_rect->x &&
+    inner_rect->y                      >= outer_rect->y &&
+    inner_rect->x + inner_rect->width  <= outer_rect->x + outer_rect->width &&
+    inner_rect->y + inner_rect->height <= outer_rect->y + outer_rect->height;
+}
+
+void
+meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
+                                    MetaRectangle       *rect,
+                                    int                  gravity,
+                                    int                  new_width,
+                                    int                  new_height)
+{
+  /* FIXME: I'm too deep into this to know whether the below comment is
+   * still clear or not now that I've moved it out of constraints.c.
+   * boxes.h has a good comment, but I'm not sure if the below info is also
+   * helpful on top of that (or whether it has superfluous info).
+   */
+
+  /* These formulas may look overly simplistic at first but you can work
+   * everything out with a left_frame_with, right_frame_width,
+   * border_width, and old and new client area widths (instead of old total
+   * width and new total width) and you come up with the same formulas.
+   *
+   * Also, note that the reason we can treat NorthWestGravity and
+   * StaticGravity the same is because we're not given a location at
+   * which to place the window--the window was already placed
+   * appropriately before.  So, NorthWestGravity for this function
+   * means to just leave the upper left corner of the outer window
+   * where it already is, and StaticGravity for this function means to
+   * just leave the upper left corner of the inner window where it
+   * already is.  But leaving either of those two corners where they
+   * already are will ensure that the other corner is fixed as well
+   * (since frame size doesn't change)--thus making the two
+   * equivalent.
+   */
+
+  /* First, the x direction */
+  int adjust = 0;
+  switch (gravity)
+    {
+    case NorthWestGravity:
+    case WestGravity:
+    case SouthWestGravity:
+      rect->x = old_rect->x;
+      break;
+
+    case NorthGravity:
+    case CenterGravity:
+    case SouthGravity:
+      /* FIXME: Needing to adjust new_width kind of sucks, but not doing so
+       * would cause drift.
+       */
+      new_width -= (old_rect->width - new_width) % 2;
+      rect->x = old_rect->x + (old_rect->width - new_width)/2;
+      break;
+
+    case NorthEastGravity:
+    case EastGravity:
+    case SouthEastGravity:
+      rect->x = old_rect->x + (old_rect->width - new_width);
+      break;
+
+    case StaticGravity:
+    default:
+      rect->x = old_rect->x;
+      break;
+    }
+  rect->width = new_width;
+
+  /* Next, the y direction */
+  adjust = 0;
+  switch (gravity)
+    {
+    case NorthWestGravity:
+    case NorthGravity:
+    case NorthEastGravity:
+      rect->y = old_rect->y;
+      break;
+
+    case WestGravity:
+    case CenterGravity:
+    case EastGravity:
+      /* FIXME: Needing to adjust new_height kind of sucks, but not doing so
+       * would cause drift.
+       */
+      new_height -= (old_rect->height - new_height) % 2;
+      rect->y = old_rect->y + (old_rect->height - new_height)/2;
+      break;
+
+    case SouthWestGravity:
+    case SouthGravity:
+    case SouthEastGravity:
+      rect->y = old_rect->y + (old_rect->height - new_height);
+      break;
+
+    case StaticGravity:
+    default:
+      rect->y = old_rect->y;
+      break;
+    }
+  rect->height = new_height;
+}
+
+/* Not so simple helper function for get_minimal_spanning_set_for_region() */
+static GList*
+merge_spanning_rects_in_region (GList *region)
+{
+  /* NOTE FOR ANY OPTIMIZATION PEOPLE OUT THERE: Please see the
+   * documentation of get_minimal_spanning_set_for_region() for performance
+   * considerations that also apply to this function.
+   */
+
+  GList* compare;
+  compare = region;
+
+  if (region == NULL)
+    {
+      meta_warning ("Region to merge was empty!  Either you have a some "
+                    "pathological STRUT list or there's a bug somewhere!\n");
+      return NULL;
+    }
+
+  while (compare && compare->next)
+    {
+      MetaRectangle *a = compare->data;
+      GList *other = compare->next;
+
+      g_assert (a->width > 0 && a->height > 0);
+
+      while (other)
+        {
+          MetaRectangle *b = other->data;
+          GList *delete_me = NULL;
+
+          g_assert (b->width > 0 && b->height > 0);
+
+          /* If a contains b, just remove b */
+          if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = other;
+            }
+          /* If b contains a, just remove a */
+          else if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = compare;
+            }
+          /* If a and b might be mergeable horizontally */
+          else if (a->y == b->y && a->height == b->height)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                }
+              /* If a and b are adjacent */
+              else if (a->x + a->width == b->x || a->x == b->x + b->width)
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                }
+            }
+          /* If a and b might be mergeable vertically */
+          else if (a->x == b->x && a->width == b->width)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                }
+              /* If a and b are adjacent */
+              else if (a->y + a->height == b->y || a->y == b->y + b->height)
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                }
+            }
+
+          other = other->next;
+
+          /* Delete any rectangle in the list that is no longer wanted */
+          if (delete_me != NULL)
+            {
+              /* Deleting the rect we compare others to is a little tricker */
+              if (compare == delete_me)
+                {
+                  compare = compare->next;
+                  other = compare->next;
+                  a = compare->data;
+                }
+
+              /* Okay, we can free it now */
+              g_free (delete_me->data);
+              region = g_list_delete_link (region, delete_me);
+            }
+
+        }
+
+      compare = compare->next;
+    }
+
+  return region;
+}
+
+/* Simple helper function for get_minimal_spanning_set_for_region()... */
+static gint
+compare_rect_areas (gconstpointer a, gconstpointer b)
+{
+  const MetaRectangle *a_rect = (gconstpointer) a;
+  const MetaRectangle *b_rect = (gconstpointer) b;
+
+  int a_area = meta_rectangle_area (a_rect);
+  int b_area = meta_rectangle_area (b_rect);
+
+  return b_area - a_area; /* positive ret value denotes b > a, ... */
+}
+
+/* This function is trying to find a "minimal spanning set (of rectangles)"
+ * for a given region.
+ *
+ * The region is given by taking basic_rect, then removing the areas
+ * covered by all the rectangles in the all_struts list, and then expanding
+ * the resulting region by the given number of pixels in each direction.
+ *
+ * A "minimal spanning set (of rectangles)" is the best name I could come
+ * up with for the concept I had in mind.  Basically, for a given region, I
+ * want a set of rectangles with the property that a window is contained in
+ * the region if and only if it is contained within at least one of the
+ * rectangles.
+ *
+ * The GList* returned will be a list of (allocated) MetaRectangles.
+ * The list will need to be freed by calling
+ * meta_rectangle_free_spanning_set() on it (or by manually
+ * implementing that function...)
+ */
+GList*
+meta_rectangle_get_minimal_spanning_set_for_region (
+  const MetaRectangle *basic_rect,
+  const GSList  *all_struts)
+{
+  /* NOTE FOR OPTIMIZERS: This function *might* be somewhat slow,
+   * especially due to the call to merge_spanning_rects_in_region() (which
+   * is O(n^2) where n is the size of the list generated in this function).
+   * This is made more onerous due to the fact that it involves a fair
+   * number of memory allocation and deallocation calls.  However, n is 1
+   * for default installations of Mate (because partial struts aren't used
+   * by default and only partial struts increase the size of the spanning
+   * set generated).  With one partial strut, n will be 2 or 3.  With 2
+   * partial struts, n will probably be 4 or 5.  So, n probably isn't large
+   * enough to make this worth bothering.  Further, it is only called from
+   * workspace.c:ensure_work_areas_validated (at least as of the time of
+   * writing this comment), which in turn should only be called if the
+   * strut list changes or the screen or xinerama size changes.  If it ever
+   * does show up on profiles (most likely because people start using
+   * ridiculously huge numbers of partial struts), possible optimizations
+   * include:
+   *
+   * (1) rewrite merge_spanning_rects_in_region() to be O(n) or O(nlogn).
+   *     I'm not totally sure it's possible, but with a couple copies of
+   *     the list and sorting them appropriately, I believe it might be.
+   * (2) only call merge_spanning_rects_in_region() with a subset of the
+   *     full list of rectangles.  I believe from some of my preliminary
+   *     debugging and thinking about it that it is possible to figure out
+   *     apriori groups of rectangles which are only merge candidates with
+   *     each other.  (See testboxes.c:get_screen_region() when which==2
+   *     and track the steps of this function carefully to see what gave
+   *     me the hint that this might work)
+   * (3) figure out how to avoid merge_spanning_rects_in_region().  I think
+   *     it might be possible to modify this function to make that
+   *     possible, and I spent just a little while thinking about it, but n
+   *     wasn't large enough to convince me to care yet.
+   * (4) Some of the stuff Rob mentioned at http://mail.gnome.org/archives\
+   *     /marco-devel-list/2005-November/msg00028.html.  (Sorry for the
+   *     URL splitting.)
+   */
+
+  GList         *ret;
+  GList         *tmp_list;
+  const GSList  *strut_iter;
+  MetaRectangle *temp_rect;
+
+  /* The algorithm is basically as follows:
+   *   Initialize rectangle_set to basic_rect
+   *   Foreach strut:
+   *     Foreach rectangle in rectangle_set:
+   *       - Split the rectangle into new rectangles that don't overlap the
+   *         strut (but which are as big as possible otherwise)
+   *       - Remove the old (pre-split) rectangle from the rectangle_set,
+   *         and replace it with the new rectangles generated from the
+   *         splitting
+   */
+
+  temp_rect = g_new (MetaRectangle, 1);
+  *temp_rect = *basic_rect;
+  ret = g_list_prepend (NULL, temp_rect);
+
+  strut_iter = all_struts;
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
+    {
+      GList *rect_iter;
+      MetaRectangle *strut_rect = &((MetaStrut*)strut_iter->data)->rect;
+
+      tmp_list = ret;
+      ret = NULL;
+      rect_iter = tmp_list;
+      while (rect_iter)
+        {
+          MetaRectangle *rect = (MetaRectangle*) rect_iter->data;
+          if (!meta_rectangle_overlap (rect, strut_rect))
+            ret = g_list_prepend (ret, rect);
+          else
+            {
+              /* If there is area in rect left of strut */
+              if (BOX_LEFT (*rect) < BOX_LEFT (*strut_rect))
+                {
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  temp_rect->width = BOX_LEFT (*strut_rect) - BOX_LEFT (*rect);
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              /* If there is area in rect right of strut */
+              if (BOX_RIGHT (*rect) > BOX_RIGHT (*strut_rect))
+                {
+                  int new_x;
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  new_x = BOX_RIGHT (*strut_rect);
+                  temp_rect->width = BOX_RIGHT(*rect) - new_x;
+                  temp_rect->x = new_x;
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              /* If there is area in rect above strut */
+              if (BOX_TOP (*rect) < BOX_TOP (*strut_rect))
+                {
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  temp_rect->height = BOX_TOP (*strut_rect) - BOX_TOP (*rect);
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              /* If there is area in rect below strut */
+              if (BOX_BOTTOM (*rect) > BOX_BOTTOM (*strut_rect))
+                {
+                  int new_y;
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  new_y = BOX_BOTTOM (*strut_rect);
+                  temp_rect->height = BOX_BOTTOM (*rect) - new_y;
+                  temp_rect->y = new_y;
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              g_free (rect);
+            }
+          rect_iter = rect_iter->next;
+        }
+      g_list_free (tmp_list);
+    }
+
+  /* Sort by maximal area, just because I feel like it... */
+  ret = g_list_sort (ret, compare_rect_areas);
+
+  /* Merge rectangles if possible so that the list really is minimal */
+  ret = merge_spanning_rects_in_region (ret);
+
+  return ret;
+}
+
+GList*
+meta_rectangle_expand_region (GList     *region,
+                              const int  left_expand,
+                              const int  right_expand,
+                              const int  top_expand,
+                              const int  bottom_expand)
+{
+  return meta_rectangle_expand_region_conditionally (region,
+                                                     left_expand,
+                                                     right_expand,
+                                                     top_expand,
+                                                     bottom_expand,
+                                                     0,
+                                                     0);
+}
+
+GList*
+meta_rectangle_expand_region_conditionally (GList     *region,
+                                            const int  left_expand,
+                                            const int  right_expand,
+                                            const int  top_expand,
+                                            const int  bottom_expand,
+                                            const int  min_x,
+                                            const int  min_y)
+{
+  GList *tmp_list = region;
+  while (tmp_list)
+    {
+      MetaRectangle *rect = (MetaRectangle*) tmp_list->data;
+      if (rect->width >= min_x)
+        {
+          rect->x      -= left_expand;
+          rect->width  += (left_expand + right_expand);
+        }
+      if (rect->height >= min_y)
+        {
+          rect->y      -= top_expand;
+          rect->height += (top_expand + bottom_expand);
+        }
+      tmp_list = tmp_list->next;
+    }
+
+  return region;
+}
+
+void
+meta_rectangle_expand_to_avoiding_struts (MetaRectangle       *rect,
+                                          const MetaRectangle *expand_to,
+                                          const MetaDirection  direction,
+                                          const GSList        *all_struts)
+{
+  const GSList *strut_iter;
+
+  /* If someone wants this function to handle more fine-grained
+   * direction expanding in the future (e.g. only left, or fully
+   * horizontal plus upward), feel free.  But I'm hard-coding for both
+   * horizontal directions (exclusive-)or both vertical directions.
+   */
+  g_assert ((direction == META_DIRECTION_HORIZONTAL) ^
+            (direction == META_DIRECTION_VERTICAL  ));
+
+  if (direction == META_DIRECTION_HORIZONTAL)
+    {
+      rect->x      = expand_to->x;
+      rect->width  = expand_to->width;
+    }
+  else
+    {
+      rect->y      = expand_to->y;
+      rect->height = expand_to->height;
+    }
+
+
+  /* Run over all struts */
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
+    {
+      MetaStrut *strut = (MetaStrut*) strut_iter->data;
+
+      /* Skip struts that don't overlap */
+      if (!meta_rectangle_overlap (&strut->rect, rect))
+        continue;
+
+      if (direction == META_DIRECTION_HORIZONTAL)
+        {
+          if (strut->side == META_SIDE_LEFT)
+            {
+              int offset = BOX_RIGHT(strut->rect) - BOX_LEFT(*rect);
+              rect->x     += offset;
+              rect->width -= offset;
+            }
+          else if (strut->side == META_SIDE_RIGHT)
+            {
+              int offset = BOX_RIGHT (*rect) - BOX_LEFT(strut->rect);
+              rect->width -= offset;
+            }
+          /* else ignore the strut */
+        }
+      else /* direction == META_DIRECTION_VERTICAL */
+        {
+          if (strut->side == META_SIDE_TOP)
+            {
+              int offset = BOX_BOTTOM(strut->rect) - BOX_TOP(*rect);
+              rect->y      += offset;
+              rect->height -= offset;
+            }
+          else if (strut->side == META_SIDE_BOTTOM)
+            {
+              int offset = BOX_BOTTOM(*rect) - BOX_TOP(strut->rect);
+              rect->height -= offset;
+            }
+          /* else ignore the strut */
+        }
+    } /* end loop over struts */
+} /* end meta_rectangle_expand_to_avoiding_struts */
+
+void
+meta_rectangle_free_list_and_elements (GList *filled_list)
+{
+  g_list_foreach (filled_list,
+                  (void (*)(gpointer,gpointer))&g_free, /* ew, for ugly */
+                  NULL);
+  g_list_free (filled_list);
+}
+
+gboolean
+meta_rectangle_could_fit_in_region (const GList         *spanning_rects,
+                                    const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     could_fit;
+
+  temp = spanning_rects;
+  could_fit = FALSE;
+  while (!could_fit && temp != NULL)
+    {
+      could_fit = could_fit || meta_rectangle_could_fit_rect (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return could_fit;
+}
+
+gboolean
+meta_rectangle_contained_in_region (const GList         *spanning_rects,
+                                    const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     contained;
+
+  temp = spanning_rects;
+  contained = FALSE;
+  while (!contained && temp != NULL)
+    {
+      contained = contained || meta_rectangle_contains_rect (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return contained;
+}
+
+gboolean
+meta_rectangle_overlaps_with_region (const GList         *spanning_rects,
+                                     const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     overlaps;
+
+  temp = spanning_rects;
+  overlaps = FALSE;
+  while (!overlaps && temp != NULL)
+    {
+      overlaps = overlaps || meta_rectangle_overlap (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return overlaps;
+}
+
+
+void
+meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
+                                         FixedDirections      fixed_directions,
+                                         MetaRectangle       *rect,
+                                         const MetaRectangle *min_size)
+{
+  const GList *temp;
+  const MetaRectangle *best_rect = NULL;
+  int                  best_overlap = 0;
+
+  /* First, find best rectangle from spanning_rects to which we can clamp
+   * rect to fit into.
+   */
+  for (temp = spanning_rects; temp; temp = temp->next)
+    {
+      MetaRectangle *compare_rect = temp->data;
+      int            maximal_overlap_amount_for_compare;
+
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_X) &&
+          (compare_rect->x > rect->x ||
+           compare_rect->x + compare_rect->width < rect->x + rect->width))
+        continue;
+
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_Y) &&
+          (compare_rect->y > rect->y ||
+           compare_rect->y + compare_rect->height < rect->y + rect->height))
+        continue;
+
+      /* If compare can't hold the min_size window, skip this rectangle. */
+      if (compare_rect->width  < min_size->width ||
+          compare_rect->height < min_size->height)
+        continue;
+
+      /* Determine maximal overlap amount */
+      maximal_overlap_amount_for_compare =
+        MIN (rect->width,  compare_rect->width) *
+        MIN (rect->height, compare_rect->height);
+
+      /* See if this is the best rect so far */
+      if (maximal_overlap_amount_for_compare > best_overlap)
+        {
+          best_rect    = compare_rect;
+          best_overlap = maximal_overlap_amount_for_compare;
+        }
+    }
+
+  /* Clamp rect appropriately */
+  if (best_rect == NULL)
+    {
+      meta_warning ("No rect whose size to clamp to found!\n");
+
+      /* If it doesn't fit, at least make it no bigger than it has to be */
+      if (!(fixed_directions & FIXED_DIRECTION_X))
+        rect->width  = min_size->width;
+      if (!(fixed_directions & FIXED_DIRECTION_Y))
+        rect->height = min_size->height;
+    }
+  else
+    {
+      rect->width  = MIN (rect->width,  best_rect->width);
+      rect->height = MIN (rect->height, best_rect->height);
+    }
+}
+
+void
+meta_rectangle_clip_to_region (const GList         *spanning_rects,
+                               FixedDirections      fixed_directions,
+                               MetaRectangle       *rect)
+{
+  const GList *temp;
+  const MetaRectangle *best_rect = NULL;
+  int                  best_overlap = 0;
+
+  /* First, find best rectangle from spanning_rects to which we will clip
+   * rect into.
+   */
+  for (temp = spanning_rects; temp; temp = temp->next)
+    {
+      MetaRectangle *compare_rect = temp->data;
+      MetaRectangle  overlap;
+      int            maximal_overlap_amount_for_compare;
+
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip the rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_X) &&
+          (compare_rect->x > rect->x ||
+           compare_rect->x + compare_rect->width < rect->x + rect->width))
+        continue;
+
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip the rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_Y) &&
+          (compare_rect->y > rect->y ||
+           compare_rect->y + compare_rect->height < rect->y + rect->height))
+        continue;
+
+      /* Determine maximal overlap amount */
+      meta_rectangle_intersect (rect, compare_rect, &overlap);
+      maximal_overlap_amount_for_compare = meta_rectangle_area (&overlap);
+
+      /* See if this is the best rect so far */
+      if (maximal_overlap_amount_for_compare > best_overlap)
+        {
+          best_rect    = compare_rect;
+          best_overlap = maximal_overlap_amount_for_compare;
+        }
+    }
+
+  /* Clip rect appropriately */
+  if (best_rect == NULL)
+    meta_warning ("No rect to clip to found!\n");
+  else
+    {
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_X))
+        {
+          /* Find the new left and right */
+          int new_x = MAX (rect->x, best_rect->x);
+          rect->width = MIN ((rect->x + rect->width)           - new_x,
+                             (best_rect->x + best_rect->width) - new_x);
+          rect->x = new_x;
+        }
+
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_Y))
+        {
+          /* Clip the top, if needed */
+          int new_y = MAX (rect->y, best_rect->y);
+          rect->height = MIN ((rect->y + rect->height)           - new_y,
+                              (best_rect->y + best_rect->height) - new_y);
+          rect->y = new_y;
+        }
+    }
+}
+
+void
+meta_rectangle_shove_into_region (const GList         *spanning_rects,
+                                  FixedDirections      fixed_directions,
+                                  MetaRectangle       *rect)
+{
+  const GList *temp;
+  const MetaRectangle *best_rect = NULL;
+  int                  best_overlap = 0;
+  int                  shortest_distance = G_MAXINT;
+
+  /* First, find best rectangle from spanning_rects to which we will shove
+   * rect into.
+   */
+
+  for (temp = spanning_rects; temp; temp = temp->next)
+    {
+      MetaRectangle *compare_rect = temp->data;
+      int            maximal_overlap_amount_for_compare;
+      int            dist_to_compare;
+
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_X) &&
+          (compare_rect->x > rect->x ||
+           compare_rect->x + compare_rect->width < rect->x + rect->width))
+        continue;
+
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_Y) &&
+          (compare_rect->y > rect->y ||
+           compare_rect->y + compare_rect->height < rect->y + rect->height))
+        continue;
+
+      /* Determine maximal overlap amount between rect & compare_rect */
+      maximal_overlap_amount_for_compare =
+        MIN (rect->width,  compare_rect->width) *
+        MIN (rect->height, compare_rect->height);
+
+      /* Determine distance necessary to put rect into compare_rect */
+      dist_to_compare = 0;
+      if (compare_rect->x > rect->x)
+        dist_to_compare += compare_rect->x - rect->x;
+      if (compare_rect->x + compare_rect->width < rect->x + rect->width)
+        dist_to_compare += (rect->x + rect->width) -
+                           (compare_rect->x + compare_rect->width);
+      if (compare_rect->y > rect->y)
+        dist_to_compare += compare_rect->y - rect->y;
+      if (compare_rect->y + compare_rect->height < rect->y + rect->height)
+        dist_to_compare += (rect->y + rect->height) -
+                           (compare_rect->y + compare_rect->height);
+
+      /* See if this is the best rect so far */
+      if ((maximal_overlap_amount_for_compare > best_overlap) ||
+          (maximal_overlap_amount_for_compare == best_overlap &&
+           dist_to_compare                    <  shortest_distance))
+        {
+          best_rect         = compare_rect;
+          best_overlap      = maximal_overlap_amount_for_compare;
+          shortest_distance = dist_to_compare;
+        }
+    }
+
+  /* Shove rect appropriately */
+  if (best_rect == NULL)
+    meta_warning ("No rect to shove into found!\n");
+  else
+    {
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_X))
+        {
+          /* Shove to the right, if needed */
+          if (best_rect->x > rect->x)
+            rect->x = best_rect->x;
+
+          /* Shove to the left, if needed */
+          if (best_rect->x + best_rect->width < rect->x + rect->width)
+            rect->x = (best_rect->x + best_rect->width) - rect->width;
+        }
+
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_Y))
+        {
+          /* Shove down, if needed */
+          if (best_rect->y > rect->y)
+            rect->y = best_rect->y;
+
+          /* Shove up, if needed */
+          if (best_rect->y + best_rect->height < rect->y + rect->height)
+            rect->y = (best_rect->y + best_rect->height) - rect->height;
+        }
+    }
+}
+
+void
+meta_rectangle_find_linepoint_closest_to_point (double x1,
+                                                double y1,
+                                                double x2,
+                                                double y2,
+                                                double px,
+                                                double py,
+                                                double *valx,
+                                                double *valy)
+{
+  /* I'll use the shorthand rx, ry for the return values, valx & valy.
+   * Now, we need (rx,ry) to be on the line between (x1,y1) and (x2,y2).
+   * For that to happen, we first need the slope of the line from (x1,y1)
+   * to (rx,ry) must match the slope of (x1,y1) to (x2,y2), i.e.:
+   *   (ry-y1)   (y2-y1)
+   *   ------- = -------
+   *   (rx-x1)   (x2-x1)
+   * If x1==x2, though, this gives divide by zero errors, so we want to
+   * rewrite the equation by multiplying both sides by (rx-x1)*(x2-x1):
+   *   (ry-y1)(x2-x1) = (y2-y1)(rx-x1)
+   * This is a valid requirement even when x1==x2 (when x1==x2, this latter
+   * equation will basically just mean that rx must be equal to both x1 and
+   * x2)
+   *
+   * The other requirement that we have is that the line from (rx,ry) to
+   * (px,py) must be perpendicular to the line from (x1,y1) to (x2,y2).  So
+   * we just need to get a vector in the direction of each line, take the
+   * dot product of the two, and ensure that the result is 0:
+   *   (rx-px)*(x2-x1) + (ry-py)*(y2-y1) = 0.
+   *
+   * This gives us two equations and two unknowns:
+   *
+   *   (ry-y1)(x2-x1) = (y2-y1)(rx-x1)
+   *   (rx-px)*(x2-x1) + (ry-py)*(y2-y1) = 0.
+   *
+   * This particular pair of equations is always solvable so long as
+   * (x1,y1) and (x2,y2) are not the same point (and note that anyone who
+   * calls this function that way is braindead because it means that they
+   * really didn't specify a line after all).  However, the caller should
+   * be careful to avoid making (x1,y1) and (x2,y2) too close (e.g. like
+   * 10^{-8} apart in each coordinate), otherwise roundoff error could
+   * cause issues.  Solving these equations by hand (or using Maple(TM) or
+   * Mathematica(TM) or whatever) results in slightly messy expressions,
+   * but that's all the below few lines do.
+   */
+
+  double diffx, diffy, den;
+  diffx = x2 - x1;
+  diffy = y2 - y1;
+  den = diffx * diffx + diffy * diffy;
+
+  *valx = (py * diffx * diffy + px * diffx * diffx +
+           y2 * x1 * diffy - y1 * x2 * diffy) / den;
+  *valy = (px * diffx * diffy + py * diffy * diffy +
+           x2 * y1 * diffx - x1 * y2 * diffx) / den;
+}
+
+/***************************************************************************/
+/*                                                                         */
+/* Switching gears to code for edges instead of just rectangles            */
+/*                                                                         */
+/***************************************************************************/
+
+gboolean
+meta_rectangle_edge_aligns (const MetaRectangle *rect, const MetaEdge *edge)
+{
+  /* The reason for the usage of <= below instead of < is because we are
+   * interested in in-the-way-or-adject'ness.  So, a left (i.e. vertical
+   * edge) occupying y positions 0-9 (which has a y of 0 and a height of
+   * 10) and a rectangle with top at y=10 would be considered to "align" by
+   * this function.
+   */
+  switch (edge->side_type)
+    {
+    case META_SIDE_LEFT:
+    case META_SIDE_RIGHT:
+      return BOX_TOP (*rect)      <= BOX_BOTTOM (edge->rect) &&
+             BOX_TOP (edge->rect) <= BOX_BOTTOM (*rect);
+    case META_SIDE_TOP:
+    case META_SIDE_BOTTOM:
+      return BOX_LEFT (*rect)      <= BOX_RIGHT (edge->rect) &&
+             BOX_LEFT (edge->rect) <= BOX_RIGHT (*rect);
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static GList*
+get_rect_minus_overlap (const GList   *rect_in_list,
+                        MetaRectangle *overlap)
+{
+  MetaRectangle *temp;
+  MetaRectangle *rect = rect_in_list->data;
+  GList *ret = NULL;
+
+  if (BOX_LEFT (*rect) < BOX_LEFT (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      *temp = *rect;
+      temp->width = BOX_LEFT (*overlap) - BOX_LEFT (*rect);
+      ret = g_list_prepend (ret, temp);
+    }
+  if (BOX_RIGHT (*rect) > BOX_RIGHT (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      *temp = *rect;
+      temp->x = BOX_RIGHT (*overlap);
+      temp->width = BOX_RIGHT (*rect) - BOX_RIGHT (*overlap);
+      ret = g_list_prepend (ret, temp);
+    }
+  if (BOX_TOP (*rect) < BOX_TOP (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      temp->x      = overlap->x;
+      temp->width  = overlap->width;
+      temp->y      = BOX_TOP (*rect);
+      temp->height = BOX_TOP (*overlap) - BOX_TOP (*rect);
+      ret = g_list_prepend (ret, temp);
+    }
+  if (BOX_BOTTOM (*rect) > BOX_BOTTOM (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      temp->x      = overlap->x;
+      temp->width  = overlap->width;
+      temp->y      = BOX_BOTTOM (*overlap);
+      temp->height = BOX_BOTTOM (*rect) - BOX_BOTTOM (*overlap);
+      ret = g_list_prepend (ret, temp);
+    }
+
+  return ret;
+}
+
+static GList*
+replace_rect_with_list (GList *old_element,
+                        GList *new_list)
+{
+  GList *ret;
+  g_assert (old_element != NULL);
+
+  if (!new_list)
+    {
+      /* If there is no new list, just remove the old_element */
+      ret = g_list_remove_link (old_element, old_element);
+    }
+  else
+    {
+      /* Fix up the prev and next pointers everywhere */
+      ret = new_list;
+      if (old_element->prev)
+        {
+          old_element->prev->next = new_list;
+          new_list->prev = old_element->prev;
+        }
+      if (old_element->next)
+        {
+          GList *tmp = g_list_last (new_list);
+          old_element->next->prev = tmp;
+          tmp->next = old_element->next;
+        }
+    }
+
+  /* Free the old_element and return the appropriate "next" point */
+  g_free (old_element->data);
+  g_list_free_1 (old_element);
+  return ret;
+}
+
+/* Make a copy of the strut list, make sure that copy only contains parts
+ * of the old_struts that intersect with the region rect, and then do some
+ * magic to make all the new struts disjoint (okay, we we break up struts
+ * that aren't disjoint in a way that the overlapping part is only included
+ * once, so it's not really magic...).
+ */
+static GList*
+get_disjoint_strut_rect_list_in_region (const GSList        *old_struts,
+                                        const MetaRectangle *region)
+{
+  GList *strut_rects;
+  GList *tmp;
+
+  /* First, copy the list */
+  strut_rects = NULL;
+  while (old_struts)
+    {
+      MetaRectangle *cur = &((MetaStrut*)old_struts->data)->rect;
+      MetaRectangle *copy = g_new (MetaRectangle, 1);
+      *copy = *cur;
+      if (meta_rectangle_intersect (copy, region, copy))
+        strut_rects = g_list_prepend (strut_rects, copy);
+      else
+        g_free (copy);
+
+      old_struts = old_struts->next;
+    }
+
+  /* Now, loop over the list and check for intersections, fixing things up
+   * where they do intersect.
+   */
+  tmp = strut_rects;
+  while (tmp)
+    {
+      GList *compare;
+
+      MetaRectangle *cur = tmp->data;
+
+      compare = tmp->next;
+      while (compare)
+        {
+          MetaRectangle *comp = compare->data;
+          MetaRectangle overlap;
+
+          if (meta_rectangle_intersect (cur, comp, &overlap))
+            {
+              /* Get a list of rectangles for each strut that don't overlap
+               * the intersection region.
+               */
+              GList *cur_leftover  = get_rect_minus_overlap (tmp,  &overlap);
+              GList *comp_leftover = get_rect_minus_overlap (compare, &overlap);
+
+              /* Add the intersection region to cur_leftover */
+              MetaRectangle *overlap_allocated = g_new (MetaRectangle, 1);
+              *overlap_allocated = overlap;
+              cur_leftover = g_list_prepend (cur_leftover, overlap_allocated);
+
+              /* Fix up tmp, compare, and cur -- maybe struts too */
+              if (strut_rects == tmp)
+                {
+                  strut_rects = replace_rect_with_list (tmp, cur_leftover);
+                  tmp = strut_rects;
+                }
+              else
+                tmp   = replace_rect_with_list (tmp,     cur_leftover);
+              compare = replace_rect_with_list (compare, comp_leftover);
+
+              if (compare == NULL)
+                break;
+
+              cur = tmp->data;
+            }
+
+          compare = compare->next;
+        }
+
+      tmp = tmp->next;
+    }
+
+  return strut_rects;
+}
+
+gint
+meta_rectangle_edge_cmp_ignore_type (gconstpointer a, gconstpointer b)
+{
+  const MetaEdge *a_edge_rect = (gconstpointer) a;
+  const MetaEdge *b_edge_rect = (gconstpointer) b;
+  int a_compare, b_compare;
+
+  /* Edges must be both vertical or both horizontal, or it doesn't make
+   * sense to compare them.
+   */
+  g_assert ((a_edge_rect->rect.width  == 0 && b_edge_rect->rect.width == 0) ||
+            (a_edge_rect->rect.height == 0 && b_edge_rect->rect.height == 0));
+
+  a_compare = b_compare = 0;  /* gcc-3.4.2 sucks at figuring initialized'ness */
+
+  if (a_edge_rect->side_type == META_SIDE_LEFT ||
+      a_edge_rect->side_type == META_SIDE_RIGHT)
+    {
+      a_compare = a_edge_rect->rect.x;
+      b_compare = b_edge_rect->rect.x;
+      if (a_compare == b_compare)
+        {
+          a_compare = a_edge_rect->rect.y;
+          b_compare = b_edge_rect->rect.y;
+        }
+    }
+  else if (a_edge_rect->side_type == META_SIDE_TOP ||
+           a_edge_rect->side_type == META_SIDE_BOTTOM)
+    {
+      a_compare = a_edge_rect->rect.y;
+      b_compare = b_edge_rect->rect.y;
+      if (a_compare == b_compare)
+        {
+          a_compare = a_edge_rect->rect.x;
+          b_compare = b_edge_rect->rect.x;
+        }
+    }
+  else
+    g_assert ("Some idiot wanted to sort sides of different types.\n");
+
+  return a_compare - b_compare; /* positive value denotes a > b ... */
+}
+
+/* To make things easily testable, provide a nice way of sorting edges */
+gint
+meta_rectangle_edge_cmp (gconstpointer a, gconstpointer b)
+{
+  const MetaEdge *a_edge_rect = (gconstpointer) a;
+  const MetaEdge *b_edge_rect = (gconstpointer) b;
+
+  int a_compare, b_compare;
+
+  a_compare = a_edge_rect->side_type;
+  b_compare = b_edge_rect->side_type;
+
+  if (a_compare == b_compare)
+    return meta_rectangle_edge_cmp_ignore_type (a, b);
+
+  return a_compare - b_compare; /* positive value denotes a > b ... */
+}
+
+/* Determine whether two given edges overlap */
+static gboolean
+edges_overlap (const MetaEdge *edge1,
+               const MetaEdge *edge2)
+{
+  if (edge1->rect.width == 0 && edge2->rect.width == 0)
+    {
+      return meta_rectangle_vert_overlap (&edge1->rect, &edge2->rect) &&
+             edge1->rect.x == edge2->rect.x;
+    }
+  else if (edge1->rect.height == 0 && edge2->rect.height == 0)
+    {
+      return meta_rectangle_horiz_overlap (&edge1->rect, &edge2->rect) &&
+             edge1->rect.y == edge2->rect.y;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+static gboolean
+rectangle_and_edge_intersection (const MetaRectangle *rect,
+                                 const MetaEdge      *edge,
+                                 MetaEdge            *overlap,
+                                 int                 *handle_type)
+{
+  const MetaRectangle *rect2  = &edge->rect;
+  MetaRectangle *result = &overlap->rect;
+  gboolean intersect = TRUE;
+
+  /* We don't know how to set these, so set them to invalid values */
+  overlap->edge_type = -1;
+  overlap->side_type = -1;
+
+  /* Figure out what the intersection is */
+  result->x = MAX (rect->x, rect2->x);
+  result->y = MAX (rect->y, rect2->y);
+  result->width  = MIN (BOX_RIGHT (*rect),  BOX_RIGHT (*rect2))  - result->x;
+  result->height = MIN (BOX_BOTTOM (*rect), BOX_BOTTOM (*rect2)) - result->y;
+
+  /* Find out if the intersection is empty; have to do it this way since
+   * edges have a thickness of 0
+   */
+  if ((result->width <  0 || result->height <  0) ||
+      (result->width == 0 && result->height == 0))
+    {
+      result->width = 0;
+      result->height = 0;
+      intersect = FALSE;
+    }
+  else
+    {
+      /* Need to figure out the handle_type, a somewhat weird quantity:
+       *   0 - overlap is in middle of rect
+       *  -1 - overlap is at the side of rect, and is on the opposite side
+       *       of rect than the edge->side_type side
+       *   1 - overlap is at the side of rect, and the side of rect it is
+       *       on is the edge->side_type side
+       */
+      switch (edge->side_type)
+        {
+        case META_SIDE_LEFT:
+          if (result->x == rect->x)
+            *handle_type = 1;
+          else if (result->x == BOX_RIGHT (*rect))
+            *handle_type = -1;
+          else
+            *handle_type = 0;
+          break;
+        case META_SIDE_RIGHT:
+          if (result->x == rect->x)
+            *handle_type = -1;
+          else if (result->x == BOX_RIGHT (*rect))
+            *handle_type = 1;
+          else
+            *handle_type = 0;
+          break;
+        case META_SIDE_TOP:
+          if (result->y == rect->y)
+            *handle_type = 1;
+          else if (result->y == BOX_BOTTOM (*rect))
+            *handle_type = -1;
+          else
+            *handle_type = 0;
+          break;
+        case META_SIDE_BOTTOM:
+          if (result->y == rect->y)
+            *handle_type = -1;
+          else if (result->y == BOX_BOTTOM (*rect))
+            *handle_type = 1;
+          else
+            *handle_type = 0;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+    }
+  return intersect;
+}
+
+/* Add all edges of the given rect to cur_edges and return the result.  If
+ * rect_is_internal is false, the side types are switched (LEFT<->RIGHT and
+ * TOP<->BOTTOM).
+ */
+static GList*
+add_edges (GList               *cur_edges,
+           const MetaRectangle *rect,
+           gboolean             rect_is_internal)
+{
+  MetaEdge *temp_edge;
+  int i;
+
+  for (i=0; i<4; i++)
+    {
+      temp_edge = g_new (MetaEdge, 1);
+      temp_edge->rect = *rect;
+      switch (i)
+        {
+        case 0:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_LEFT : META_SIDE_RIGHT;
+          temp_edge->rect.width = 0;
+          break;
+        case 1:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_RIGHT : META_SIDE_LEFT;
+          temp_edge->rect.x     += temp_edge->rect.width;
+          temp_edge->rect.width  = 0;
+          break;
+        case 2:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_TOP : META_SIDE_BOTTOM;
+          temp_edge->rect.height = 0;
+          break;
+        case 3:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_BOTTOM : META_SIDE_TOP;
+          temp_edge->rect.y      += temp_edge->rect.height;
+          temp_edge->rect.height  = 0;
+          break;
+        }
+      temp_edge->edge_type = META_EDGE_SCREEN;
+      cur_edges = g_list_prepend (cur_edges, temp_edge);
+    }
+
+  return cur_edges;
+}
+
+/* Remove any part of old_edge that intersects remove and add any resulting
+ * edges to cur_list.  Return cur_list when finished.
+ */
+static GList*
+split_edge (GList *cur_list,
+            const MetaEdge *old_edge,
+            const MetaEdge *remove)
+{
+  MetaEdge *temp_edge;
+  switch (old_edge->side_type)
+    {
+    case META_SIDE_LEFT:
+    case META_SIDE_RIGHT:
+      g_assert (meta_rectangle_vert_overlap (&old_edge->rect, &remove->rect));
+      if (BOX_TOP (old_edge->rect)  < BOX_TOP (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.height = BOX_TOP (remove->rect)
+                                 - BOX_TOP (old_edge->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      if (BOX_BOTTOM (old_edge->rect) > BOX_BOTTOM (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.y      = BOX_BOTTOM (remove->rect);
+          temp_edge->rect.height = BOX_BOTTOM (old_edge->rect)
+                                 - BOX_BOTTOM (remove->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      break;
+    case META_SIDE_TOP:
+    case META_SIDE_BOTTOM:
+      g_assert (meta_rectangle_horiz_overlap (&old_edge->rect, &remove->rect));
+      if (BOX_LEFT (old_edge->rect)  < BOX_LEFT (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.width = BOX_LEFT (remove->rect)
+                                - BOX_LEFT (old_edge->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      if (BOX_RIGHT (old_edge->rect) > BOX_RIGHT (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.x     = BOX_RIGHT (remove->rect);
+          temp_edge->rect.width = BOX_RIGHT (old_edge->rect)
+                                - BOX_RIGHT (remove->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+  return cur_list;
+}
+
+/* Split up edge and remove preliminary edges from strut_edges depending on
+ * if and how rect and edge intersect.
+ */
+static void
+fix_up_edges (MetaRectangle *rect,         MetaEdge *edge,
+              GList         **strut_edges, GList    **edge_splits,
+              gboolean      *edge_needs_removal)
+{
+  MetaEdge overlap;
+  int      handle_type;
+
+  if (!rectangle_and_edge_intersection (rect, edge, &overlap, &handle_type))
+    return;
+
+  if (handle_type == 0 || handle_type == 1)
+    {
+      /* Put the result of removing overlap from edge into edge_splits */
+      *edge_splits = split_edge (*edge_splits, edge, &overlap);
+      *edge_needs_removal = TRUE;
+    }
+
+  if (handle_type == -1 || handle_type == 1)
+    {
+      /* Remove the overlap from strut_edges */
+      /* First, loop over the edges of the strut */
+      GList *tmp = *strut_edges;
+      while (tmp)
+        {
+          MetaEdge *cur = tmp->data;
+          /* If this is the edge that overlaps, then we need to split it */
+          if (edges_overlap (cur, &overlap))
+            {
+              GList *delete_me = tmp;
+
+              /* Split this edge into some new ones */
+              *strut_edges = split_edge (*strut_edges, cur, &overlap);
+
+              /* Delete the old one */
+              tmp = tmp->next;
+              g_free (cur);
+              *strut_edges = g_list_delete_link (*strut_edges, delete_me);
+            }
+          else
+            tmp = tmp->next;
+        }
+    }
+}
+
+/* This function removes intersections of edges with the rectangles from the
+ * list of edges.
+ */
+GList*
+meta_rectangle_remove_intersections_with_boxes_from_edges (
+  GList        *edges,
+  const GSList *rectangles)
+{
+  const GSList *rect_iter;
+  const int opposing = 1;
+
+  /* Now remove all intersections of rectangles with the edge list */
+  rect_iter = rectangles;
+  while (rect_iter)
+    {
+      MetaRectangle *rect = rect_iter->data;
+      GList *edge_iter = edges;
+      while (edge_iter)
+        {
+          MetaEdge *edge = edge_iter->data;
+          MetaEdge overlap;
+          int      handle;
+          gboolean edge_iter_advanced = FALSE;
+
+          /* If this edge overlaps with this rect... */
+          if (rectangle_and_edge_intersection (rect, edge, &overlap, &handle))
+            {
+
+              /* "Intersections" where the edges touch but are opposite
+               * sides (e.g. a left edge against the right edge) should not
+               * be split.  Note that the comments in
+               * rectangle_and_edge_intersection() say that opposing edges
+               * occur when handle is -1, BUT you need to remember that we
+               * treat the left side of a window as a right edge because
+               * it's what the right side of the window being moved should
+               * be-resisted-by/snap-to.  So opposing is really 1.  Anyway,
+               * we just keep track of it in the opposing constant set up
+               * above and if handle isn't equal to that, then we know the
+               * edge should be split.
+               */
+              if (handle != opposing)
+                {
+                  /* Keep track of this edge so we can delete it below */
+                  GList *delete_me = edge_iter;
+                  edge_iter = edge_iter->next;
+                  edge_iter_advanced = TRUE;
+
+                  /* Split the edge and add the result to beginning of edges */
+                  edges = split_edge (edges, edge, &overlap);
+
+                  /* Now free the edge... */
+                  g_free (edge);
+                  edges = g_list_delete_link (edges, delete_me);
+                }
+            }
+
+          if (!edge_iter_advanced)
+            edge_iter = edge_iter->next;
+        }
+
+      rect_iter = rect_iter->next;
+    }
+
+  return edges;
+}
+
+/* This function is trying to find all the edges of an onscreen region. */
+GList*
+meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
+                                    const GSList        *all_struts)
+{
+  GList        *ret;
+  GList        *fixed_strut_rects;
+  GList        *edge_iter;
+  const GList  *strut_rect_iter;
+
+  /* The algorithm is basically as follows:
+   *   Make sure the struts are disjoint
+   *   Initialize the edge_set to the edges of basic_rect
+   *   Foreach strut:
+   *     Put together a preliminary new edge from the edges of the strut
+   *     Foreach edge in edge_set:
+   *       - Split the edge if it is partially contained inside the strut
+   *       - If the edge matches an edge of the strut (i.e. a strut just
+   *         against the edge of the screen or a not-next-to-edge-of-screen
+   *         strut adjacent to another), then both the edge from the
+   *         edge_set and the preliminary edge for the strut will need to
+   *         be split
+   *     Add any remaining "preliminary" strut edges to the edge_set
+   */
+
+  /* Make sure the struts are disjoint */
+  fixed_strut_rects =
+    get_disjoint_strut_rect_list_in_region (all_struts, basic_rect);
+
+  /* Start off the list with the edges of basic_rect */
+  ret = add_edges (NULL, basic_rect, TRUE);
+
+  strut_rect_iter = fixed_strut_rects;
+  while (strut_rect_iter)
+    {
+      MetaRectangle *strut_rect = (MetaRectangle*) strut_rect_iter->data;
+
+      /* Get the new possible edges we may need to add from the strut */
+      GList *new_strut_edges = add_edges (NULL, strut_rect, FALSE);
+
+      edge_iter = ret;
+      while (edge_iter)
+        {
+          MetaEdge *cur_edge = edge_iter->data;
+          GList *splits_of_cur_edge = NULL;
+          gboolean edge_needs_removal = FALSE;
+
+          fix_up_edges (strut_rect,       cur_edge,
+                        &new_strut_edges, &splits_of_cur_edge,
+                        &edge_needs_removal);
+
+          if (edge_needs_removal)
+            {
+              /* Delete the old edge */
+              GList *delete_me = edge_iter;
+              edge_iter = edge_iter->next;
+              g_free (cur_edge);
+              ret = g_list_delete_link (ret, delete_me);
+
+              /* Add the new split parts of the edge */
+              ret = g_list_concat (splits_of_cur_edge, ret);
+            }
+          else
+            {
+              edge_iter = edge_iter->next;
+            }
+
+          /* edge_iter was already advanced above */
+        }
+
+      ret = g_list_concat (new_strut_edges, ret);
+      strut_rect_iter = strut_rect_iter->next;
+    }
+
+  /* Sort the list */
+  ret = g_list_sort (ret, meta_rectangle_edge_cmp);
+
+  /* Free the fixed struts list */
+  meta_rectangle_free_list_and_elements (fixed_strut_rects);
+
+  return ret;
+}
+
+GList*
+meta_rectangle_find_nonintersected_xinerama_edges (
+                                    const GList         *xinerama_rects,
+                                    const GSList        *all_struts)
+{
+  /* This function cannot easily be merged with
+   * meta_rectangle_find_onscreen_edges() because real screen edges
+   * and strut edges both are of the type "there ain't anything
+   * immediately on the other side"; xinerama edges are different.
+   */
+  GList *ret;
+  const GList  *cur;
+  GSList *temp_rects;
+
+  /* Initialize the return list to be empty */
+  ret = NULL;
+
+  /* start of ret with all the edges of xineramas that are adjacent to
+   * another xinerama.
+   */
+  cur = xinerama_rects;
+  while (cur)
+    {
+      MetaRectangle *cur_rect = cur->data;
+      const GList *compare = xinerama_rects;
+      while (compare)
+        {
+          MetaRectangle *compare_rect = compare->data;
+
+          /* Check if cur might be horizontally adjacent to compare */
+          if (meta_rectangle_vert_overlap(cur_rect, compare_rect))
+            {
+              MetaSide side_type;
+              int y      = MAX (cur_rect->y, compare_rect->y);
+              int height = MIN (BOX_BOTTOM (*cur_rect) - y,
+                                BOX_BOTTOM (*compare_rect) - y);
+              int width  = 0;
+              int x;
+
+              if (BOX_LEFT (*cur_rect)  == BOX_RIGHT (*compare_rect))
+                {
+                  /* compare_rect is to the left of cur_rect */
+                  x = BOX_LEFT (*cur_rect);
+                  side_type = META_SIDE_LEFT;
+                }
+              else if (BOX_RIGHT (*cur_rect) == BOX_LEFT (*compare_rect))
+                {
+                  /* compare_rect is to the right of cur_rect */
+                  x = BOX_RIGHT (*cur_rect);
+                  side_type = META_SIDE_RIGHT;
+                }
+              else
+                /* These rectangles aren't adjacent after all */
+                x = INT_MIN;
+
+              /* If the rectangles really are adjacent */
+              if (x != INT_MIN)
+                {
+                  /* We need a left edge for the xinerama on the right, and
+                   * a right edge for the xinerama on the left.  Just fill
+                   * up the edges and stick 'em on the list.
+                   */
+                  MetaEdge *new_edge  = g_new (MetaEdge, 1);
+
+                  new_edge->rect = meta_rect (x, y, width, height);
+                  new_edge->side_type = side_type;
+                  new_edge->edge_type = META_EDGE_XINERAMA;
+
+                  ret = g_list_prepend (ret, new_edge);
+                }
+            }
+
+          /* Check if cur might be vertically adjacent to compare */
+          if (meta_rectangle_horiz_overlap(cur_rect, compare_rect))
+            {
+              MetaSide side_type;
+              int x      = MAX (cur_rect->x, compare_rect->x);
+              int width  = MIN (BOX_RIGHT (*cur_rect) - x,
+                                BOX_RIGHT (*compare_rect) - x);
+              int height = 0;
+              int y;
+
+              if (BOX_TOP (*cur_rect)  == BOX_BOTTOM (*compare_rect))
+                {
+                  /* compare_rect is to the top of cur_rect */
+                  y = BOX_TOP (*cur_rect);
+                  side_type = META_SIDE_TOP;
+                }
+              else if (BOX_BOTTOM (*cur_rect) == BOX_TOP (*compare_rect))
+                {
+                  /* compare_rect is to the bottom of cur_rect */
+                  y = BOX_BOTTOM (*cur_rect);
+                  side_type = META_SIDE_BOTTOM;
+                }
+              else
+                /* These rectangles aren't adjacent after all */
+                y = INT_MIN;
+
+              /* If the rectangles really are adjacent */
+              if (y != INT_MIN)
+                {
+                  /* We need a top edge for the xinerama on the bottom, and
+                   * a bottom edge for the xinerama on the top.  Just fill
+                   * up the edges and stick 'em on the list.
+                   */
+                  MetaEdge *new_edge = g_new (MetaEdge, 1);
+
+                  new_edge->rect = meta_rect (x, y, width, height);
+                  new_edge->side_type = side_type;
+                  new_edge->edge_type = META_EDGE_XINERAMA;
+
+                  ret = g_list_prepend (ret, new_edge);
+                }
+            }
+
+          compare = compare->next;
+        }
+      cur = cur->next;
+    }
+
+  temp_rects = NULL;
+  for (; all_struts; all_struts = all_struts->next)
+    temp_rects = g_slist_prepend (temp_rects,
+                                  &((MetaStrut*)all_struts->data)->rect);
+  ret = meta_rectangle_remove_intersections_with_boxes_from_edges (ret,
+                                                                   temp_rects);
+  g_slist_free (temp_rects);
+
+  /* Sort the list */
+  ret = g_list_sort (ret, meta_rectangle_edge_cmp);
+
+  return ret;
+}
diff --git a/src/core/constraints.c b/src/core/constraints.c
new file mode 100644
index 00000000..6abc7d5c
--- /dev/null
+++ b/src/core/constraints.c
@@ -0,0 +1,1382 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco size/position constraints */
+
+/*
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2005, 2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "constraints.h"
+#include "workspace.h"
+#include "place.h"
+#include "prefs.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+#if 0
+ // This is the short and sweet version of how to hack on this file; see
+ // doc/how-constraints-works.txt for the gory details.  The basics of
+ // understanding this file can be shown by the steps needed to add a new
+ // constraint, which are:
+ //   1) Add a new entry in the ConstraintPriority enum; higher values
+ //      have higher priority
+ //   2) Write a new function following the format of the example below,
+ //      "constrain_whatever".
+ //   3) Add your function to the all_constraints and all_constraint_names
+ //      arrays (the latter of which is for debugging purposes)
+ // 
+ // An example constraint function, constrain_whatever:
+ //
+ // /* constrain_whatever does the following:
+ //  *   Quits (returning true) if priority is higher than PRIORITY_WHATEVER
+ //  *   If check_only is TRUE
+ //  *     Returns whether the constraint is satisfied or not
+ //  *   otherwise
+ //  *     Enforces the constraint
+ //  * Note that the value of PRIORITY_WHATEVER is centralized with the
+ //  * priorities of other constraints in the definition of ConstrainPriority
+ //  * for easier maintenance and shuffling of priorities.
+ //  */
+ // static gboolean
+ // constrain_whatever (MetaWindow         *window,
+ //                     ConstraintInfo     *info,
+ //                     ConstraintPriority  priority,
+ //                     gboolean            check_only)
+ // {
+ //   if (priority > PRIORITY_WHATEVER)
+ //     return TRUE;
+ //
+ //   /* Determine whether constraint applies; note that if the constraint
+ //    * cannot possibly be satisfied, constraint_applies should be set to
+ //    * false.  If we don't do this, all constraints with a lesser priority
+ //    * will be dropped along with this one, and we'd rather apply as many as
+ //    * possible.
+ //    */
+ //   if (!constraint_applies)
+ //     return TRUE;
+ //
+ //   /* Determine whether constraint is already satisfied; if we're only
+ //    * checking the status of whether the constraint is satisfied, we end
+ //    * here.
+ //    */
+ //   if (check_only || constraint_already_satisfied)
+ //     return constraint_already_satisfied;
+ //
+ //   /* Enforce constraints */
+ //   return TRUE;  /* Note that we exited early if check_only is FALSE; also,
+ //                  * we know we can return TRUE here because we exited early
+ //                  * if the constraint could not be satisfied; not that the
+ //                  * return value is heeded in this case...
+ //                  */
+ // }
+#endif
+
+typedef enum
+{
+  PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */
+  PRIORITY_ASPECT_RATIO = 0,
+  PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA = 0,
+  PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA = 1,
+  PRIORITY_SIZE_HINTS_INCREMENTS = 1,
+  PRIORITY_MAXIMIZATION = 2,
+  PRIORITY_FULLSCREEN = 2,
+  PRIORITY_SIZE_HINTS_LIMITS = 3,
+  PRIORITY_TITLEBAR_VISIBLE = 4,
+  PRIORITY_PARTIALLY_VISIBLE_ON_WORKAREA = 4,
+  PRIORITY_MAXIMUM = 4 /* Dummy value used for loop end = max(all priorities) */
+} ConstraintPriority;
+
+typedef enum
+{
+  ACTION_MOVE,
+  ACTION_RESIZE,
+  ACTION_MOVE_AND_RESIZE
+} ActionType;
+
+typedef struct
+{
+  MetaRectangle        orig;
+  MetaRectangle        current;
+  MetaFrameGeometry   *fgeom;
+  ActionType           action_type;
+  gboolean             is_user_action;
+
+  /* I know that these two things probably look similar at first, but they
+   * have much different uses.  See doc/how-constraints-works.txt for for
+   * explanation of the differences and similarity between resize_gravity
+   * and fixed_directions
+   */
+  int                  resize_gravity;
+  FixedDirections      fixed_directions;
+
+  /* work_area_xinerama - current xinerama region minus struts
+   * entire_xinerama    - current xienrama, including strut regions
+   */
+  MetaRectangle        work_area_xinerama;
+  MetaRectangle        entire_xinerama;
+
+  /* Spanning rectangles for the non-covered (by struts) region of the
+   * screen and also for just the current xinerama
+   */
+  GList  *usable_screen_region;
+  GList  *usable_xinerama_region;
+} ConstraintInfo;
+
+static gboolean constrain_maximization       (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_fullscreen         (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_size_increments    (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_size_limits        (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_aspect_ratio       (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_to_single_xinerama (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_fully_onscreen     (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_titlebar_visible   (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_partially_onscreen (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+
+static void setup_constraint_info        (ConstraintInfo      *info,
+                                          MetaWindow          *window,
+                                          MetaFrameGeometry   *orig_fgeom,
+                                          MetaMoveResizeFlags  flags,
+                                          int                  resize_gravity,
+                                          const MetaRectangle *orig,
+                                          MetaRectangle       *new);
+static void place_window_if_needed       (MetaWindow     *window,
+                                          ConstraintInfo *info);
+static void update_onscreen_requirements (MetaWindow     *window,
+                                          ConstraintInfo *info);
+static void extend_by_frame              (MetaRectangle           *rect,
+                                          const MetaFrameGeometry *fgeom);
+static void unextend_by_frame            (MetaRectangle           *rect,
+                                          const MetaFrameGeometry *fgeom);
+static inline void get_size_limits       (const MetaWindow        *window,
+                                          const MetaFrameGeometry *fgeom,
+                                          gboolean include_frame,
+                                          MetaRectangle *min_size,
+                                          MetaRectangle *max_size);
+
+typedef gboolean (* ConstraintFunc) (MetaWindow         *window,
+                                     ConstraintInfo     *info,
+                                     ConstraintPriority  priority,
+                                     gboolean            check_only);
+
+typedef struct {
+  ConstraintFunc func;
+  const char* name;
+} Constraint;
+
+static const Constraint all_constraints[] = {
+  {constrain_maximization,       "constrain_maximization"},
+  {constrain_fullscreen,         "constrain_fullscreen"},
+  {constrain_size_increments,    "constrain_size_increments"},
+  {constrain_size_limits,        "constrain_size_limits"},
+  {constrain_aspect_ratio,       "constrain_aspect_ratio"},
+  {constrain_to_single_xinerama, "constrain_to_single_xinerama"},
+  {constrain_fully_onscreen,     "constrain_fully_onscreen"},
+  {constrain_titlebar_visible,   "constrain_titlebar_visible"},
+  {constrain_partially_onscreen, "constrain_partially_onscreen"},
+  {NULL,                         NULL}
+};
+
+static gboolean
+do_all_constraints (MetaWindow         *window,
+                    ConstraintInfo     *info,
+                    ConstraintPriority  priority,
+                    gboolean            check_only)
+{
+  const Constraint *constraint;
+  gboolean          satisfied;
+
+  constraint = &all_constraints[0];
+  satisfied = TRUE;
+  while (constraint->func != NULL)
+    {
+      satisfied = satisfied &&
+                  (*constraint->func) (window, info, priority, check_only);
+
+      if (!check_only)
+        {
+          /* Log how the constraint modified the position */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "info->current is %d,%d +%d,%d after %s\n",
+                      info->current.x, info->current.y, 
+                      info->current.width, info->current.height,
+                      constraint->name);
+        }
+      else if (!satisfied)
+        {
+          /* Log which constraint was not satisfied */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "constraint %s not satisfied.\n",
+                      constraint->name);
+          return FALSE;
+        }
+      ++constraint;
+    }
+
+  return TRUE;
+}
+
+void
+meta_window_constrain (MetaWindow          *window,
+                       MetaFrameGeometry   *orig_fgeom,
+                       MetaMoveResizeFlags  flags,
+                       int                  resize_gravity,
+                       const MetaRectangle *orig,
+                       MetaRectangle       *new)
+{
+  ConstraintInfo info;
+  ConstraintPriority priority = PRIORITY_MINIMUM;
+  gboolean satisfied = FALSE;
+
+  /* WARNING: orig and new specify positions and sizes of the inner window,
+   * not the outer.  This is a common gotcha since half the constraints
+   * deal with inner window position/size and half deal with outer.  See
+   * doc/how-constraints-works.txt for more information.
+   */
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Constraining %s in move from %d,%d %dx%d to %d,%d %dx%d\n",
+              window->desc,
+              orig->x, orig->y, orig->width, orig->height,
+              new->x,  new->y,  new->width,  new->height);
+
+  setup_constraint_info (&info,
+                         window, 
+                         orig_fgeom, 
+                         flags,
+                         resize_gravity,
+                         orig,
+                         new);
+  place_window_if_needed (window, &info);
+
+  while (!satisfied && priority <= PRIORITY_MAXIMUM) {
+    gboolean check_only = TRUE;
+
+    /* Individually enforce all the high-enough priority constraints */
+    do_all_constraints (window, &info, priority, !check_only);
+
+    /* Check if all high-enough priority constraints are simultaneously 
+     * satisfied
+     */
+    satisfied = do_all_constraints (window, &info, priority, check_only);
+
+    /* Drop the least important constraints if we can't satisfy them all */
+    priority++;
+  }
+
+  /* Make sure we use the constrained position */
+  *new = info.current;
+
+  /* We may need to update window->require_fully_onscreen,
+   * window->require_on_single_xinerama, and perhaps other quantities
+   * if this was a user move or user move-and-resize operation.
+   */
+  update_onscreen_requirements (window, &info);
+
+  /* Ew, what an ugly way to do things.  Destructors (in a real OOP language,
+   * not gobject-style--gobject would be more pain than it's worth) or
+   * smart pointers would be so much nicer here.  *shrug*
+   */
+  if (!orig_fgeom)
+    g_free (info.fgeom);
+}
+
+static void
+setup_constraint_info (ConstraintInfo      *info,
+                       MetaWindow          *window,
+                       MetaFrameGeometry   *orig_fgeom,
+                       MetaMoveResizeFlags  flags,
+                       int                  resize_gravity,
+                       const MetaRectangle *orig,
+                       MetaRectangle       *new)
+{
+  const MetaXineramaScreenInfo *xinerama_info;
+  MetaWorkspace *cur_workspace;
+
+  info->orig    = *orig;
+  info->current = *new;
+
+  /* Create a fake frame geometry if none really exists */
+  if (orig_fgeom && !window->fullscreen)
+    info->fgeom = orig_fgeom;
+  else
+    info->fgeom = g_new0 (MetaFrameGeometry, 1);
+
+  if (flags & META_IS_MOVE_ACTION && flags & META_IS_RESIZE_ACTION)
+    info->action_type = ACTION_MOVE_AND_RESIZE;
+  else if (flags & META_IS_RESIZE_ACTION)
+    info->action_type = ACTION_RESIZE;
+  else if (flags & META_IS_MOVE_ACTION)
+    info->action_type = ACTION_MOVE;
+  else
+    g_error ("BAD, BAD developer!  No treat for you!  (Fix your calls to "
+             "meta_window_move_resize_internal()).\n");
+
+  info->is_user_action = (flags & META_IS_USER_ACTION);
+
+  info->resize_gravity = resize_gravity;
+
+  /* FIXME: fixed_directions might be more sane if we (a) made it
+   * depend on the grab_op type instead of current amount of movement
+   * (thus implying that it only has effect when user_action is true,
+   * and (b) ignored it for aspect ratio windows -- at least in those
+   * cases where both directions do actually change size.
+   */
+  info->fixed_directions = FIXED_DIRECTION_NONE;
+  /* If x directions don't change but either y direction does */
+  if ( orig->x == new->x && orig->x + orig->width  == new->x + new->width   &&
+      (orig->y != new->y || orig->y + orig->height != new->y + new->height))
+    {
+      info->fixed_directions = FIXED_DIRECTION_X;
+    }
+  /* If y directions don't change but either x direction does */
+  if ( orig->y == new->y && orig->y + orig->height == new->y + new->height  &&
+      (orig->x != new->x || orig->x + orig->width  != new->x + new->width ))
+    {
+      info->fixed_directions = FIXED_DIRECTION_Y;
+    }
+  /* The point of fixed directions is just that "move to nearest valid
+   * position" is sometimes a poorer choice than "move to nearest
+   * valid position but only change this coordinate" for windows the
+   * user is explicitly moving.  This isn't ever true for things that
+   * aren't explicit user interaction, though, so just clear it out.
+   */
+  if (!info->is_user_action)
+    info->fixed_directions = FIXED_DIRECTION_NONE;
+
+  xinerama_info =
+    meta_screen_get_xinerama_for_rect (window->screen, &info->current);
+  meta_window_get_work_area_for_xinerama (window,
+                                          xinerama_info->number,
+                                          &info->work_area_xinerama);
+
+  if (!window->fullscreen || window->fullscreen_monitors[0] == -1)
+    {
+      info->entire_xinerama = xinerama_info->rect;
+    }
+  else
+    {
+      int i = 0;
+      long monitor;
+
+      monitor = window->fullscreen_monitors[i];
+      info->entire_xinerama =
+        window->screen->xinerama_infos[monitor].rect;
+      for (i = 1; i <= 3; i++)
+        {
+          monitor = window->fullscreen_monitors[i];
+          meta_rectangle_union (&info->entire_xinerama,
+                                &window->screen->xinerama_infos[monitor].rect,
+                                &info->entire_xinerama);
+        }
+    }
+
+  cur_workspace = window->screen->active_workspace;
+  info->usable_screen_region   = 
+    meta_workspace_get_onscreen_region (cur_workspace);
+  info->usable_xinerama_region = 
+    meta_workspace_get_onxinerama_region (cur_workspace, 
+                                          xinerama_info->number);
+
+  /* Workaround braindead legacy apps that don't know how to
+   * fullscreen themselves properly.
+   */
+  if (meta_prefs_get_force_fullscreen() &&
+      meta_rectangle_equal (new, &xinerama_info->rect) &&
+      window->has_fullscreen_func &&
+      !window->fullscreen)
+    {
+      /*
+      meta_topic (META_DEBUG_GEOMETRY,
+      */
+      meta_warning (
+                  "Treating resize request of legacy application %s as a "
+                  "fullscreen request\n",
+                  window->desc);
+      meta_window_make_fullscreen_internal (window);
+    }
+
+  /* Log all this information for debugging */
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting up constraint info:\n"
+              "  orig: %d,%d +%d,%d\n"
+              "  new : %d,%d +%d,%d\n"
+              "  fgeom: %d,%d,%d,%d\n"
+              "  action_type     : %s\n"
+              "  is_user_action  : %s\n"
+              "  resize_gravity  : %s\n"
+              "  fixed_directions: %s\n"
+              "  work_area_xinerama: %d,%d +%d,%d\n"
+              "  entire_xinerama   : %d,%d +%d,%d\n",
+              info->orig.x, info->orig.y, info->orig.width, info->orig.height,
+              info->current.x, info->current.y, 
+                info->current.width, info->current.height,
+              info->fgeom->left_width, info->fgeom->right_width,
+                info->fgeom->top_height, info->fgeom->bottom_height,
+              (info->action_type == ACTION_MOVE) ? "Move" :
+                (info->action_type == ACTION_RESIZE) ? "Resize" :
+                (info->action_type == ACTION_MOVE_AND_RESIZE) ? "Move&Resize" :
+                "Freakin' Invalid Stupid",
+              (info->is_user_action) ? "true" : "false",
+              meta_gravity_to_string (info->resize_gravity),
+              (info->fixed_directions == FIXED_DIRECTION_NONE) ? "None" :
+                (info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" :
+                (info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" :
+                "Freakin' Invalid Stupid",
+              info->work_area_xinerama.x, info->work_area_xinerama.y,
+                info->work_area_xinerama.width, 
+                info->work_area_xinerama.height,
+              info->entire_xinerama.x, info->entire_xinerama.y,
+                info->entire_xinerama.width, info->entire_xinerama.height);
+}
+
+static void
+place_window_if_needed(MetaWindow     *window,
+                       ConstraintInfo *info)
+{
+  gboolean did_placement;
+
+  /* Do placement if any, so we go ahead and apply position
+   * constraints in a move-only context. Don't place
+   * maximized/minimized/fullscreen windows until they are
+   * unmaximized, unminimized and unfullscreened.
+   */
+  did_placement = FALSE;
+  if (!window->placed &&
+      window->calc_placement &&
+      !(window->maximized_horizontally ||
+        window->maximized_vertically) &&
+      !window->minimized &&
+      !window->fullscreen)
+    {
+      MetaRectangle placed_rect = info->orig;
+      MetaWorkspace *cur_workspace;
+      const MetaXineramaScreenInfo *xinerama_info;
+
+      meta_window_place (window, info->fgeom, info->orig.x, info->orig.y,
+                         &placed_rect.x, &placed_rect.y);
+      did_placement = TRUE;
+
+      /* placing the window may have changed the xinerama.  Find the
+       * new xinerama and update the ConstraintInfo
+       */
+      xinerama_info =
+        meta_screen_get_xinerama_for_rect (window->screen, &placed_rect);
+      info->entire_xinerama = xinerama_info->rect;
+      meta_window_get_work_area_for_xinerama (window,
+                                              xinerama_info->number,
+                                              &info->work_area_xinerama);
+      cur_workspace = window->screen->active_workspace;
+      info->usable_xinerama_region = 
+        meta_workspace_get_onxinerama_region (cur_workspace, 
+                                              xinerama_info->number);
+
+
+      info->current.x = placed_rect.x;
+      info->current.y = placed_rect.y;
+
+      /* Since we just barely placed the window, there's no reason to
+       * consider any of the directions fixed.
+       */
+      info->fixed_directions = FIXED_DIRECTION_NONE;
+    }
+
+  if (window->placed || did_placement)
+    {
+      if (window->maximize_horizontally_after_placement ||
+          window->maximize_vertically_after_placement   ||
+          window->fullscreen_after_placement)
+        {
+          /* define a sane saved_rect so that the user can unmaximize or
+           * make unfullscreen to something reasonable.
+           */
+          if (info->current.width >= info->work_area_xinerama.width)
+            {
+              info->current.width = .75 * info->work_area_xinerama.width;
+              info->current.x = info->work_area_xinerama.x +
+                       .125 * info->work_area_xinerama.width;
+            }
+          if (info->current.height >= info->work_area_xinerama.height)
+            {
+              info->current.height = .75 * info->work_area_xinerama.height;
+              info->current.y = info->work_area_xinerama.y +
+                       .083 * info->work_area_xinerama.height;
+            }
+
+          if (window->maximize_horizontally_after_placement ||
+              window->maximize_vertically_after_placement)
+            meta_window_maximize_internal (window,   
+                (window->maximize_horizontally_after_placement ?
+                 META_MAXIMIZE_HORIZONTAL : 0 ) |
+                (window->maximize_vertically_after_placement ?
+                 META_MAXIMIZE_VERTICAL : 0), &info->current);
+
+          /* maximization may have changed frame geometry */
+          if (window->frame && !window->fullscreen)
+            meta_frame_calc_geometry (window->frame, info->fgeom);
+
+          if (window->fullscreen_after_placement)
+            {
+              window->saved_rect = info->current;
+              window->fullscreen = TRUE;
+              window->fullscreen_after_placement = FALSE;
+            }
+
+          window->maximize_horizontally_after_placement = FALSE;
+          window->maximize_vertically_after_placement = FALSE;
+        }
+      if (window->minimize_after_placement)
+        {
+          meta_window_minimize (window);
+          window->minimize_after_placement = FALSE;
+        }
+    }
+}
+
+static void
+update_onscreen_requirements (MetaWindow     *window,
+                              ConstraintInfo *info)
+{
+  gboolean old;
+
+  /* We only apply the various onscreen requirements to normal windows */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    return;
+
+  /* We don't want to update the requirements for fullscreen windows;
+   * fullscreen windows are specially handled anyway, and it updating
+   * the requirements when windows enter fullscreen mode mess up the
+   * handling of the window when it leaves that mode (especially when
+   * the application sends a bunch of configurerequest events).  See
+   * #353699.
+   */
+  if (window->fullscreen)
+    return;
+
+  /* USABILITY NOTE: Naturally, I only want the require_fully_onscreen,
+   * require_on_single_xinerama, and require_titlebar_visible flags to
+   * *become false* due to user interactions (which is allowed since
+   * certain constraints are ignored for user interactions regardless of
+   * the setting of these flags).  However, whether to make these flags
+   * *become true* due to just an application interaction is a little
+   * trickier.  It's possible that users may find not doing that strange
+   * since two application interactions that resize in opposite ways don't
+   * necessarily end up cancelling--but it may also be strange for the user
+   * to have an application resize the window so that it's onscreen, the
+   * user forgets about it, and then later the app is able to resize itself
+   * off the screen.  Anyway, for now, I think the latter is the more
+   * problematic case but this may need to be revisited.
+   */
+
+  /* The require onscreen/on-single-xinerama and titlebar_visible
+   * stuff is relative to the outer window, not the inner
+   */
+  extend_by_frame (&info->current, info->fgeom);
+
+  /* Update whether we want future constraint runs to require the
+   * window to be on fully onscreen.
+   */
+  old = window->require_fully_onscreen;
+  window->require_fully_onscreen =
+    meta_rectangle_contained_in_region (info->usable_screen_region,
+                                        &info->current);
+  if (old ^ window->require_fully_onscreen)
+    meta_topic (META_DEBUG_GEOMETRY,
+                "require_fully_onscreen for %s toggled to %s\n",
+                window->desc,
+                window->require_fully_onscreen ? "TRUE" : "FALSE");
+
+  /* Update whether we want future constraint runs to require the
+   * window to be on a single xinerama.
+   */
+  old = window->require_on_single_xinerama;
+  window->require_on_single_xinerama =
+    meta_rectangle_contained_in_region (info->usable_xinerama_region,
+                                        &info->current);
+  if (old ^ window->require_on_single_xinerama)
+    meta_topic (META_DEBUG_GEOMETRY,
+                "require_on_single_xinerama for %s toggled to %s\n",
+                window->desc, 
+                window->require_on_single_xinerama ? "TRUE" : "FALSE");
+
+  /* Update whether we want future constraint runs to require the
+   * titlebar to be visible.
+   */
+  if (window->frame && window->decorated)
+    {
+      MetaRectangle titlebar_rect;
+
+      titlebar_rect = info->current;
+      titlebar_rect.height = info->fgeom->top_height;
+      old = window->require_titlebar_visible;
+      window->require_titlebar_visible =
+        meta_rectangle_overlaps_with_region (info->usable_screen_region,
+                                             &titlebar_rect);
+      if (old ^ window->require_titlebar_visible)
+        meta_topic (META_DEBUG_GEOMETRY,
+                    "require_titlebar_visible for %s toggled to %s\n",
+                    window->desc,
+                    window->require_titlebar_visible ? "TRUE" : "FALSE");
+    }
+
+  /* Don't forget to restore the position of the window */
+  unextend_by_frame (&info->current, info->fgeom);
+}
+
+static void
+extend_by_frame (MetaRectangle           *rect,
+                 const MetaFrameGeometry *fgeom)
+{
+  rect->x -= fgeom->left_width;
+  rect->y -= fgeom->top_height;
+  rect->width  += fgeom->left_width + fgeom->right_width;
+  rect->height += fgeom->top_height + fgeom->bottom_height;
+}
+
+static void
+unextend_by_frame (MetaRectangle           *rect,
+                   const MetaFrameGeometry *fgeom)
+{
+  rect->x += fgeom->left_width;
+  rect->y += fgeom->top_height;
+  rect->width  -= fgeom->left_width + fgeom->right_width;
+  rect->height -= fgeom->top_height + fgeom->bottom_height;
+}
+
+static inline void
+get_size_limits (const MetaWindow        *window,
+                 const MetaFrameGeometry *fgeom,
+                 gboolean                 include_frame,
+                 MetaRectangle *min_size,
+                 MetaRectangle *max_size)
+{
+  /* We pack the results into MetaRectangle structs just for convienience; we
+   * don't actually use the position of those rects.
+   */
+  min_size->width  = window->size_hints.min_width;
+  min_size->height = window->size_hints.min_height;
+  max_size->width  = window->size_hints.max_width;
+  max_size->height = window->size_hints.max_height;
+
+  if (include_frame)
+    {
+      int fw = fgeom->left_width + fgeom->right_width;
+      int fh = fgeom->top_height + fgeom->bottom_height;
+
+      min_size->width  += fw;
+      min_size->height += fh;
+      max_size->width  += fw;
+      max_size->height += fh;
+    }
+}
+
+static gboolean
+constrain_maximization (MetaWindow         *window,
+                        ConstraintInfo     *info,
+                        ConstraintPriority  priority,
+                        gboolean            check_only)
+{
+  MetaRectangle target_size;
+  MetaRectangle min_size, max_size;
+  gboolean hminbad, vminbad;
+  gboolean horiz_equal, vert_equal;
+  gboolean constraint_already_satisfied;
+
+  if (priority > PRIORITY_MAXIMIZATION)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  if (!window->maximized_horizontally && !window->maximized_vertically)
+    return TRUE;
+
+  /* Calculate target_size = maximized size of (window + frame) */
+  if (window->maximized_horizontally && window->maximized_vertically)
+    target_size = info->work_area_xinerama;
+  else
+    {
+      /* Amount of maximization possible in a single direction depends
+       * on which struts could occlude the window given its current
+       * position.  For example, a vertical partial strut on the right
+       * is only relevant for a horizontally maximized window when the
+       * window is at a vertical position where it could be occluded
+       * by that partial strut.
+       */
+      MetaDirection  direction;
+      GSList        *active_workspace_struts;
+
+      if (window->maximized_horizontally)
+        direction = META_DIRECTION_HORIZONTAL;
+      else
+        direction = META_DIRECTION_VERTICAL;
+      active_workspace_struts = window->screen->active_workspace->all_struts;
+
+      target_size = info->current;
+      extend_by_frame (&target_size, info->fgeom);
+      meta_rectangle_expand_to_avoiding_struts (&target_size,
+                                                &info->entire_xinerama,
+                                                direction,
+                                                active_workspace_struts);
+   }
+  /* Now make target_size = maximized size of client window */
+  unextend_by_frame (&target_size, info->fgeom);
+
+  /* Check min size constraints; max size constraints are ignored for maximized
+   * windows, as per bug 327543.
+   */
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  hminbad = target_size.width < min_size.width && window->maximized_horizontally;
+  vminbad = target_size.height < min_size.height && window->maximized_vertically;
+  if (hminbad || vminbad)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  horiz_equal = target_size.x      == info->current.x &&
+                target_size.width  == info->current.width;
+  vert_equal  = target_size.y      == info->current.y &&
+                target_size.height == info->current.height;
+  constraint_already_satisfied =
+    (horiz_equal || !window->maximized_horizontally) &&
+    (vert_equal  || !window->maximized_vertically);
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  if (window->maximized_horizontally)
+    {
+      info->current.x      = target_size.x;
+      info->current.width  = target_size.width;
+    }
+  if (window->maximized_vertically)
+    {
+      info->current.y      = target_size.y;
+      info->current.height = target_size.height;
+    }
+  return TRUE;
+}
+
+static gboolean
+constrain_fullscreen (MetaWindow         *window,
+                      ConstraintInfo     *info,
+                      ConstraintPriority  priority,
+                      gboolean            check_only)
+{
+  MetaRectangle min_size, max_size, xinerama;
+  gboolean too_big, too_small, constraint_already_satisfied;
+
+  if (priority > PRIORITY_FULLSCREEN)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  if (!window->fullscreen)
+    return TRUE;
+
+  xinerama = info->entire_xinerama;
+
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  too_big =   !meta_rectangle_could_fit_rect (&xinerama, &min_size);
+  too_small = !meta_rectangle_could_fit_rect (&max_size, &xinerama);
+  if (too_big || too_small)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  constraint_already_satisfied =
+    meta_rectangle_equal (&info->current, &xinerama);
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  info->current = xinerama;
+  return TRUE;
+}
+
+static gboolean
+constrain_size_increments (MetaWindow         *window,
+                           ConstraintInfo     *info,
+                           ConstraintPriority  priority,
+                           gboolean            check_only)
+{
+  int bh, hi, bw, wi, extra_height, extra_width;
+  int new_width, new_height;
+  gboolean constraint_already_satisfied;
+  MetaRectangle *start_rect;
+
+  if (priority > PRIORITY_SIZE_HINTS_INCREMENTS)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  if (META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
+      info->action_type == ACTION_MOVE)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  bh = window->size_hints.base_height;
+  hi = window->size_hints.height_inc;
+  bw = window->size_hints.base_width;
+  wi = window->size_hints.width_inc;
+  extra_height = (info->current.height - bh) % hi;
+  extra_width  = (info->current.width  - bw) % wi;
+  /* ignore size increments for maximized windows */
+  if (window->maximized_horizontally)
+    extra_width *= 0;
+  if (window->maximized_vertically)
+    extra_height *= 0;
+  /* constraint is satisfied iff there is no extra height or width */
+  constraint_already_satisfied = 
+    (extra_height == 0 && extra_width == 0);
+
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  new_width  = info->current.width  - extra_width;
+  new_height = info->current.height - extra_height;
+
+  /* Adjusting down instead of up (as done in the above two lines) may
+   * violate minimum size constraints; fix the adjustment if this
+   * happens.
+   */
+  if (new_width  < window->size_hints.min_width)
+    new_width  += ((window->size_hints.min_width  - new_width)/wi  + 1)*wi;
+  if (new_height < window->size_hints.min_height)
+    new_height += ((window->size_hints.min_height - new_height)/hi + 1)*hi;
+
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+    
+  /* Resize to the new size */
+  meta_rectangle_resize_with_gravity (start_rect,
+                                      &info->current, 
+                                      info->resize_gravity,
+                                      new_width,
+                                      new_height);
+  return TRUE;
+}
+
+static gboolean
+constrain_size_limits (MetaWindow         *window,
+                       ConstraintInfo     *info,
+                       ConstraintPriority  priority,
+                       gboolean            check_only)
+{
+  MetaRectangle min_size, max_size;
+  gboolean too_big, too_small, constraint_already_satisfied;
+  int new_width, new_height;
+  MetaRectangle *start_rect;
+
+  if (priority > PRIORITY_SIZE_HINTS_LIMITS)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't.
+   *
+   * Note: The old code didn't apply this constraint for fullscreen or
+   * maximized windows--but that seems odd to me.  *shrug*
+   */
+  if (info->action_type == ACTION_MOVE)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  /* We ignore max-size limits for maximized windows; see #327543 */
+  if (window->maximized_horizontally)
+    max_size.width = MAX (max_size.width, info->current.width);
+  if (window->maximized_vertically)
+    max_size.height = MAX (max_size.height, info->current.height);
+  too_small = !meta_rectangle_could_fit_rect (&info->current, &min_size);
+  too_big   = !meta_rectangle_could_fit_rect (&max_size, &info->current);
+  constraint_already_satisfied = !too_big && !too_small;
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  new_width  = CLAMP (info->current.width,  min_size.width,  max_size.width);
+  new_height = CLAMP (info->current.height, min_size.height, max_size.height);
+  
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+  
+  meta_rectangle_resize_with_gravity (start_rect,
+                                      &info->current, 
+                                      info->resize_gravity,
+                                      new_width,
+                                      new_height);
+  return TRUE;
+}
+
+static gboolean
+constrain_aspect_ratio (MetaWindow         *window,
+                        ConstraintInfo     *info,
+                        ConstraintPriority  priority,
+                        gboolean            check_only)
+{
+  double minr, maxr;
+  gboolean constraints_are_inconsistent, constraint_already_satisfied;
+  int fudge, new_width, new_height;
+  double best_width, best_height;
+  double alt_width, alt_height;
+  MetaRectangle *start_rect;
+
+  if (priority > PRIORITY_ASPECT_RATIO)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't. */
+  minr =         window->size_hints.min_aspect.x /
+         (double)window->size_hints.min_aspect.y;
+  maxr =         window->size_hints.max_aspect.x /
+         (double)window->size_hints.max_aspect.y;
+  constraints_are_inconsistent = minr > maxr;
+  if (constraints_are_inconsistent ||
+      META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
+      info->action_type == ACTION_MOVE)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is.  We
+   * need the following to hold:
+   *
+   *                 width
+   *         minr <= ------ <= maxr
+   *                 height
+   *
+   * But we need to allow for some slight fudging since width and height
+   * are integers instead of floating point numbers (this is particularly
+   * important when minr == maxr), so we allow width and height to be off
+   * a little bit from strictly satisfying these equations.  For just one
+   * sided resizing, we have to make the fudge factor a little bigger
+   * because of how meta_rectangle_resize_with_gravity treats those as
+   * being a resize increment (FIXME: I should handle real resize
+   * increments better here...)
+   */
+  switch (info->resize_gravity)
+    {
+    case WestGravity:
+    case NorthGravity:
+    case SouthGravity:
+    case EastGravity:
+      fudge = 2;
+      break;
+
+    case NorthWestGravity:
+    case SouthWestGravity:
+    case CenterGravity:
+    case NorthEastGravity:
+    case SouthEastGravity:
+    case StaticGravity:
+    default:
+      fudge = 1;
+      break;
+    }
+  constraint_already_satisfied = 
+    info->current.width - (info->current.height * minr ) > -minr*fudge &&
+    info->current.width - (info->current.height * maxr ) <  maxr*fudge;
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  new_width = info->current.width;
+  new_height = info->current.height;
+
+  switch (info->resize_gravity)
+    {
+    case WestGravity:
+    case EastGravity:
+      /* Yeah, I suck for doing implicit rounding -- sue me */
+      new_height = CLAMP (new_height, new_width / maxr,  new_width / minr);
+      break;
+
+    case NorthGravity:
+    case SouthGravity:
+      /* Yeah, I suck for doing implicit rounding -- sue me */
+      new_width  = CLAMP (new_width,  new_height * minr, new_height * maxr);
+      break;
+
+    case NorthWestGravity:
+    case SouthWestGravity:
+    case CenterGravity:
+    case NorthEastGravity:
+    case SouthEastGravity:
+    case StaticGravity:
+    default:
+      /* Find what width would correspond to new_height, and what height would
+       * correspond to new_width */
+      alt_width  = CLAMP (new_width,  new_height * minr, new_height * maxr);
+      alt_height = CLAMP (new_height, new_width / maxr,  new_width / minr);
+
+      /* The line connecting the points (alt_width, new_height) and
+       * (new_width, alt_height) provide a range of
+       * valid-for-the-aspect-ratio-constraint sizes.  We want the
+       * size in that range closest to the value requested, i.e. the
+       * point on the line which is closest to the point (new_width,
+       * new_height)
+       */
+      meta_rectangle_find_linepoint_closest_to_point (alt_width, new_height,
+                                                      new_width, alt_height,
+                                                      new_width, new_height,
+                                                      &best_width, &best_height);
+
+      /* Yeah, I suck for doing implicit rounding -- sue me */
+      new_width  = best_width;
+      new_height = best_height;
+
+      break;
+    }
+
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+
+  meta_rectangle_resize_with_gravity (start_rect,
+                                      &info->current, 
+                                      info->resize_gravity,
+                                      new_width,
+                                      new_height);
+
+  return TRUE;
+}
+
+static gboolean
+do_screen_and_xinerama_relative_constraints (
+  MetaWindow     *window,
+  GList          *region_spanning_rectangles,
+  ConstraintInfo *info,
+  gboolean        check_only)
+{
+  gboolean exit_early = FALSE, constraint_satisfied;
+  MetaRectangle how_far_it_can_be_smushed, min_size, max_size;
+
+#ifdef WITH_VERBOSE_MODE
+  if (meta_is_verbose ())
+    {
+      /* First, log some debugging information */
+      char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
+
+      meta_topic (META_DEBUG_GEOMETRY,
+             "screen/xinerama constraint; region_spanning_rectangles: %s\n",
+             meta_rectangle_region_to_string (region_spanning_rectangles, ", ",
+                                              spanning_region));
+    }
+#endif
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  how_far_it_can_be_smushed = info->current;
+  get_size_limits (window, info->fgeom, TRUE, &min_size, &max_size);
+  extend_by_frame (&info->current, info->fgeom);
+
+  if (info->action_type != ACTION_MOVE)
+    {
+      if (!(info->fixed_directions & FIXED_DIRECTION_X))
+        how_far_it_can_be_smushed.width = min_size.width;
+
+      if (!(info->fixed_directions & FIXED_DIRECTION_Y))
+        how_far_it_can_be_smushed.height = min_size.height;
+    }
+  if (!meta_rectangle_could_fit_in_region (region_spanning_rectangles,
+                                           &how_far_it_can_be_smushed))
+    exit_early = TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  constraint_satisfied = 
+    meta_rectangle_contained_in_region (region_spanning_rectangles,
+                                        &info->current);
+  if (exit_early || constraint_satisfied || check_only)
+    {
+      unextend_by_frame (&info->current, info->fgeom);
+      return constraint_satisfied;
+    }
+
+  /* Enforce constraint */
+
+  /* Clamp rectangle size for resize or move+resize actions */
+  if (info->action_type != ACTION_MOVE)
+    meta_rectangle_clamp_to_fit_into_region (region_spanning_rectangles,
+                                             info->fixed_directions,
+                                             &info->current,
+                                             &min_size);
+
+  if (info->is_user_action && info->action_type == ACTION_RESIZE)
+    /* For user resize, clip to the relevant region */
+    meta_rectangle_clip_to_region (region_spanning_rectangles,
+                                   info->fixed_directions,
+                                   &info->current);
+  else
+    /* For everything else, shove the rectangle into the relevant region */
+    meta_rectangle_shove_into_region (region_spanning_rectangles,
+                                      info->fixed_directions,
+                                      &info->current);
+
+  unextend_by_frame (&info->current, info->fgeom);
+  return TRUE;
+}
+
+static gboolean
+constrain_to_single_xinerama (MetaWindow         *window,
+                              ConstraintInfo     *info,
+                              ConstraintPriority  priority,
+                              gboolean            check_only)
+{
+  if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA)
+    return TRUE;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut) and we can't apply it to frameless windows
+   * or else users will be unable to move windows such as XMMS across xineramas.
+   */
+  if (window->type == META_WINDOW_DESKTOP   ||
+      window->type == META_WINDOW_DOCK      ||
+      window->screen->n_xinerama_infos == 1 ||
+      !window->require_on_single_xinerama   ||
+      !window->frame                        ||
+      info->is_user_action)
+    return TRUE;
+
+  /* Have a helper function handle the constraint for us */
+  return do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_xinerama_region,
+                                                 info,
+                                                 check_only);
+}
+
+static gboolean
+constrain_fully_onscreen (MetaWindow         *window,
+                          ConstraintInfo     *info,
+                          ConstraintPriority  priority,
+                          gboolean            check_only)
+{
+  if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA)
+    return TRUE;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK    ||
+      window->fullscreen                  ||
+      !window->require_fully_onscreen     || 
+      info->is_user_action)
+    return TRUE;
+
+  /* Have a helper function handle the constraint for us */
+  return do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+}
+
+static gboolean
+constrain_titlebar_visible (MetaWindow         *window,
+                            ConstraintInfo     *info,
+                            ConstraintPriority  priority,
+                            gboolean            check_only)
+{
+  gboolean unconstrained_user_action;
+  gboolean retval;
+  int bottom_amount;
+  int horiz_amount_offscreen, vert_amount_offscreen;
+  int horiz_amount_onscreen,  vert_amount_onscreen;
+
+  if (priority > PRIORITY_TITLEBAR_VISIBLE)
+    return TRUE;
+
+  /* Allow the titlebar beyond the top of the screen only if the user wasn't
+   * clicking on the frame to start the move.
+   */
+  unconstrained_user_action =
+    info->is_user_action && !window->display->grab_frame_action;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK    ||
+      window->fullscreen                  ||
+      !window->require_titlebar_visible   ||
+      !window->decorated                  ||
+      unconstrained_user_action)
+    return TRUE;
+
+  /* Determine how much offscreen things are allowed.  We first need to
+   * figure out how much must remain on the screen.  For that, we use 25%
+   * window width/height but clamp to the range of (10,75) pixels.  This is
+   * somewhat of a seat of my pants random guess at what might look good.
+   * Then, the amount that is allowed off is just the window size minus
+   * this amount (but no less than 0 for tiny windows).
+   */
+  horiz_amount_onscreen = info->current.width  / 4;
+  vert_amount_onscreen  = info->current.height / 4;
+  horiz_amount_onscreen = CLAMP (horiz_amount_onscreen, 10, 75);
+  vert_amount_onscreen  = CLAMP (vert_amount_onscreen,  10, 75);
+  horiz_amount_offscreen = info->current.width - horiz_amount_onscreen;
+  vert_amount_offscreen  = info->current.height - vert_amount_onscreen;
+  horiz_amount_offscreen = MAX (horiz_amount_offscreen, 0);
+  vert_amount_offscreen  = MAX (vert_amount_offscreen,  0);
+  /* Allow the titlebar to touch the bottom panel;  If there is no titlebar,
+   * require vert_amount to remain on the screen.
+   */
+  if (window->frame)
+    {
+      bottom_amount = info->current.height + info->fgeom->bottom_height;
+      vert_amount_onscreen = info->fgeom->top_height;
+    }
+  else
+    bottom_amount = vert_amount_offscreen;
+
+  /* Extend the region, have a helper function handle the constraint,
+   * then return the region to its original size.
+   */
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              horiz_amount_offscreen,
+                                              horiz_amount_offscreen, 
+                                              0, /* Don't let titlebar off */
+                                              bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+  retval =
+    do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              -horiz_amount_offscreen,
+                                              -horiz_amount_offscreen,
+                                              0, /* Don't let titlebar off */
+                                              -bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+
+  return retval;
+}
+
+static gboolean
+constrain_partially_onscreen (MetaWindow         *window,
+                              ConstraintInfo     *info,
+                              ConstraintPriority  priority,
+                              gboolean            check_only)
+{
+  gboolean retval;
+  int top_amount, bottom_amount;
+  int horiz_amount_offscreen, vert_amount_offscreen;
+  int horiz_amount_onscreen,  vert_amount_onscreen;
+
+  if (priority > PRIORITY_PARTIALLY_VISIBLE_ON_WORKAREA)
+    return TRUE;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    return TRUE;
+
+  /* Determine how much offscreen things are allowed.  We first need to
+   * figure out how much must remain on the screen.  For that, we use 25%
+   * window width/height but clamp to the range of (10,75) pixels.  This is
+   * somewhat of a seat of my pants random guess at what might look good.
+   * Then, the amount that is allowed off is just the window size minus
+   * this amount (but no less than 0 for tiny windows).
+   */
+  horiz_amount_onscreen = info->current.width  / 4;
+  vert_amount_onscreen  = info->current.height / 4;
+  horiz_amount_onscreen = CLAMP (horiz_amount_onscreen, 10, 75);
+  vert_amount_onscreen  = CLAMP (vert_amount_onscreen,  10, 75);
+  horiz_amount_offscreen = info->current.width - horiz_amount_onscreen;
+  vert_amount_offscreen  = info->current.height - vert_amount_onscreen;
+  horiz_amount_offscreen = MAX (horiz_amount_offscreen, 0);
+  vert_amount_offscreen  = MAX (vert_amount_offscreen,  0);
+  top_amount = vert_amount_offscreen;
+  /* Allow the titlebar to touch the bottom panel;  If there is no titlebar,
+   * require vert_amount to remain on the screen.
+   */
+  if (window->frame)
+    {
+      bottom_amount = info->current.height + info->fgeom->bottom_height;
+      vert_amount_onscreen = info->fgeom->top_height;
+    }
+  else
+    bottom_amount = vert_amount_offscreen;
+
+  /* Extend the region, have a helper function handle the constraint,
+   * then return the region to its original size.
+   */
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              horiz_amount_offscreen,
+                                              horiz_amount_offscreen, 
+                                              top_amount,
+                                              bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+  retval =
+    do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              -horiz_amount_offscreen,
+                                              -horiz_amount_offscreen,
+                                              -top_amount,
+                                              -bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+
+  return retval;
+}
diff --git a/src/core/constraints.h b/src/core/constraints.h
new file mode 100644
index 00000000..d374581f
--- /dev/null
+++ b/src/core/constraints.h
@@ -0,0 +1,48 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco size/position constraints */
+
+/* 
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_CONSTRAINTS_H
+#define META_CONSTRAINTS_H
+
+#include "util.h"
+#include "window-private.h"
+#include "frame-private.h"
+
+typedef enum
+{
+  META_IS_CONFIGURE_REQUEST = 1 << 0,
+  META_DO_GRAVITY_ADJUST    = 1 << 1,
+  META_IS_USER_ACTION       = 1 << 2,
+  META_IS_MOVE_ACTION       = 1 << 3,
+  META_IS_RESIZE_ACTION     = 1 << 4
+} MetaMoveResizeFlags;
+
+void meta_window_constrain (MetaWindow          *window,
+                            MetaFrameGeometry   *orig_fgeom,
+                            MetaMoveResizeFlags  flags,
+                            int                  resize_gravity,
+                            const MetaRectangle *orig,
+                            MetaRectangle       *new);
+
+#endif /* META_CONSTRAINTS_H */
diff --git a/src/core/core.c b/src/core/core.c
new file mode 100644
index 00000000..963cbfa7
--- /dev/null
+++ b/src/core/core.c
@@ -0,0 +1,779 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco interface used by GTK+ UI to talk to core */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "core.h"
+#include "frame-private.h"
+#include "workspace.h"
+#include "prefs.h"
+
+/* Looks up the MetaWindow representing the frame of the given X window.
+ * Used as a helper function by a bunch of the functions below.
+ *
+ * FIXME: The functions that use this function throw the result away
+ * after use. Many of these functions tend to be called in small groups,
+ * which results in get_window() getting called several times in succession
+ * with the same parameters. We should profile to see whether this wastes
+ * much time, and if it does we should look into a generalised
+ * meta_core_get_window_info() which takes a bunch of pointers to variables
+ * to put its results in, and only fills in the non-null ones.
+ */
+static MetaWindow *
+get_window (Display *xdisplay,
+            Window   frame_xwindow)
+{
+  MetaDisplay *display;
+  MetaWindow *window;
+  
+  display = meta_display_for_x_display (xdisplay);
+  window = meta_display_lookup_x_window (display, frame_xwindow);
+
+  if (window == NULL || window->frame == NULL)
+    {
+      meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+      return NULL;
+    }
+
+  return window;
+}
+
+void
+meta_core_get (Display *xdisplay,
+    Window xwindow,
+    ...)
+{
+  va_list args;
+  MetaCoreGetType request;
+
+  MetaDisplay *display = meta_display_for_x_display (xdisplay);
+  MetaWindow *window = meta_display_lookup_x_window (display, xwindow);
+
+  va_start (args, xwindow);
+
+  request = va_arg (args, MetaCoreGetType);
+
+  /* Now, we special-case the first request slightly. Mostly, requests
+   * for information on windows which have no frame are errors.
+   * But sometimes we may want to know *whether* a window has a frame.
+   * In this case, pass the key META_CORE_WINDOW_HAS_FRAME
+   * as the *first* request, with a pointer to a boolean; if the window
+   * has no frame, this will be set to False and meta_core_get will
+   * exit immediately (so the values of any other requests will be
+   * undefined). Otherwise it will be set to True and meta_core_get will
+   * continue happily on its way.
+   */
+
+  if (request != META_CORE_WINDOW_HAS_FRAME &&
+      (window == NULL || window->frame == NULL)) {
+    meta_bug ("No such frame window 0x%lx!\n", xwindow);
+    return;
+  }
+
+  while (request != META_CORE_GET_END) {
+    
+    gpointer answer = va_arg (args, gpointer);
+
+    switch (request) {
+      case META_CORE_WINDOW_HAS_FRAME:
+        *((gboolean*)answer) = window != NULL && window->frame != NULL;
+        if (!*((gboolean*)answer)) return; /* see above */
+        break; 
+      case META_CORE_GET_CLIENT_WIDTH:
+        *((gint*)answer) = window->rect.width;
+        break;
+      case META_CORE_GET_CLIENT_HEIGHT:
+        *((gint*)answer) = window->rect.height;
+        break;
+      case META_CORE_IS_TITLEBAR_ONSCREEN:
+        *((gboolean*)answer) = meta_window_titlebar_is_onscreen (window);
+        break;
+      case META_CORE_GET_CLIENT_XWINDOW:
+        *((Window*)answer) = window->xwindow;
+        break;
+      case META_CORE_GET_FRAME_FLAGS:
+        *((MetaFrameFlags*)answer) = meta_frame_get_flags (window->frame);
+        break; 
+      case META_CORE_GET_FRAME_TYPE:
+          {
+          MetaFrameType base_type = META_FRAME_TYPE_LAST;
+
+          switch (window->type)
+            {
+            case META_WINDOW_NORMAL:
+              base_type = META_FRAME_TYPE_NORMAL;
+              break;
+
+            case META_WINDOW_DIALOG:
+              base_type = META_FRAME_TYPE_DIALOG;
+              break;
+
+            case META_WINDOW_MODAL_DIALOG:
+              base_type = META_FRAME_TYPE_MODAL_DIALOG;
+              break;
+
+            case META_WINDOW_MENU:
+              base_type = META_FRAME_TYPE_MENU;
+              break;
+
+            case META_WINDOW_UTILITY:
+              base_type = META_FRAME_TYPE_UTILITY;
+              break;
+
+            case META_WINDOW_DESKTOP:
+            case META_WINDOW_DOCK:
+            case META_WINDOW_TOOLBAR:
+            case META_WINDOW_SPLASHSCREEN:
+              /* No frame */
+              base_type = META_FRAME_TYPE_LAST;
+              break;
+
+            }
+
+          if (base_type == META_FRAME_TYPE_LAST)
+            {
+              /* can't add border if undecorated */
+              *((MetaFrameType*)answer) = META_FRAME_TYPE_LAST; 
+            }
+          else if (window->border_only)
+            {
+              /* override base frame type */
+              *((MetaFrameType*)answer) = META_FRAME_TYPE_BORDER; 
+            }
+          else
+            {
+              *((MetaFrameType*)answer) = base_type;
+            }
+
+          break; 
+          }
+      case META_CORE_GET_MINI_ICON:
+        *((GdkPixbuf**)answer) = window->mini_icon;
+        break;
+      case META_CORE_GET_ICON:
+        *((GdkPixbuf**)answer) = window->icon;
+        break;
+      case META_CORE_GET_X:
+        meta_window_get_position (window, (int*)answer, NULL);
+        break;
+      case META_CORE_GET_Y:
+        meta_window_get_position (window, NULL, (int*)answer);
+        break;
+      case META_CORE_GET_FRAME_WORKSPACE:
+        *((gint*)answer) = meta_window_get_net_wm_desktop (window);
+        break;
+      case META_CORE_GET_FRAME_X:
+        *((gint*)answer) = window->frame->rect.x;
+        break;
+      case META_CORE_GET_FRAME_Y:
+        *((gint*)answer) = window->frame->rect.y;
+        break;
+      case META_CORE_GET_FRAME_WIDTH:
+        *((gint*)answer) = window->frame->rect.width;
+        break;
+      case META_CORE_GET_FRAME_HEIGHT:
+        *((gint*)answer) = window->frame->rect.height;
+        break;
+      case META_CORE_GET_SCREEN_WIDTH:
+        *((gint*)answer) = window->screen->rect.width;
+        break;
+      case META_CORE_GET_SCREEN_HEIGHT:
+        *((gint*)answer) = window->screen->rect.height;
+        break;
+
+      default:
+        meta_warning(_("Unknown window information request: %d"), request);
+    }
+
+    request = va_arg (args, MetaCoreGetType);
+  } 
+
+  va_end (args);
+}
+
+void
+meta_core_queue_frame_resize (Display *xdisplay,
+                              Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_core_user_move (Display *xdisplay,
+                     Window   frame_xwindow,
+                     int      x,
+                     int      y)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_move (window, TRUE, x, y);
+}
+
+void
+meta_core_user_resize  (Display *xdisplay,
+                        Window   frame_xwindow,
+                        int      gravity,
+                        int      width,
+                        int      height)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_resize_with_gravity (window, TRUE, width, height, gravity);
+}
+
+void
+meta_core_user_raise (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_raise (window);
+}
+
+void
+meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                  Window   frame_xwindow,
+                                  guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_lower (window);
+
+  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+      meta_prefs_get_raise_on_click ())
+    {
+      /* Move window to the back of the focusing workspace's MRU list.
+       * Do extra sanity checks to avoid possible race conditions.
+       * (Borrowed from window.c.)
+       */
+      if (window->screen->active_workspace &&
+          meta_window_located_on_workspace (window, 
+                                            window->screen->active_workspace))
+        {
+          GList* link;
+          link = g_list_find (window->screen->active_workspace->mru_list, 
+                              window);
+          g_assert (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_remove_link (window->screen->active_workspace->mru_list,
+                                link);
+          g_list_free (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_append (window->screen->active_workspace->mru_list, 
+                           window);
+        }
+    }
+
+  /* focus the default window, if needed */
+  if (window->has_focus)
+    meta_workspace_focus_default_window (window->screen->active_workspace,
+                                         NULL,
+                                         timestamp);
+}
+
+void
+meta_core_user_focus (Display *xdisplay,
+                      Window   frame_xwindow,
+                      guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_focus (window, timestamp);
+}
+
+void
+meta_core_minimize (Display *xdisplay,
+                    Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_minimize (window);
+}
+
+void
+meta_core_maximize (Display *xdisplay,
+                    Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  meta_window_maximize (window, 
+                        META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_toggle_maximize_vertically (Display *xdisplay,
+				      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED_VERTICALLY (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_VERTICAL);
+  else
+    meta_window_maximize (window,
+    			    META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_toggle_maximize_horizontally (Display *xdisplay,
+				        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED_HORIZONTALLY (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_HORIZONTAL);
+  else
+    meta_window_maximize (window,
+    			    META_MAXIMIZE_HORIZONTAL);
+}
+
+void
+meta_core_toggle_maximize (Display *xdisplay,
+                           Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+  else
+    meta_window_maximize (window,
+                          META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_unmaximize (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  meta_window_unmaximize (window,
+                          META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_delete (Display *xdisplay,
+                  Window   frame_xwindow,
+                  guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+     
+  meta_window_delete (window, timestamp);
+}
+
+void
+meta_core_unshade (Display *xdisplay,
+                   Window   frame_xwindow,
+                   guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unshade (window, timestamp);
+}
+
+void
+meta_core_shade (Display *xdisplay,
+                 Window   frame_xwindow,
+                 guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_shade (window, timestamp);
+}
+
+void
+meta_core_unstick (Display *xdisplay,
+                   Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unstick (window);
+}
+
+void
+meta_core_make_above (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_make_above (window);
+}
+
+void
+meta_core_unmake_above (Display *xdisplay,
+                        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unmake_above (window);
+}
+
+void
+meta_core_stick (Display *xdisplay,
+                 Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_stick (window);
+}
+
+void
+meta_core_change_workspace (Display *xdisplay,
+                            Window   frame_xwindow,
+                            int      new_workspace)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_change_workspace (window,
+                                meta_screen_get_workspace_by_index (window->screen,
+                                                                    new_workspace));
+}
+
+int
+meta_core_get_num_workspaces (Screen  *xscreen)
+{
+  MetaScreen *screen;
+
+  screen = meta_screen_for_x_screen (xscreen);
+
+  return meta_screen_get_n_workspaces (screen);
+}
+
+int
+meta_core_get_active_workspace (Screen *xscreen)
+{
+  MetaScreen *screen;
+
+  screen = meta_screen_for_x_screen (xscreen);
+
+  return meta_workspace_index (screen->active_workspace);
+}
+
+void
+meta_core_show_window_menu (Display *xdisplay,
+                            Window   frame_xwindow,
+                            int      root_x,
+                            int      root_y,
+                            int      button,
+                            guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+  meta_window_focus (window, timestamp);
+
+  meta_window_show_menu (window, root_x, root_y, button, timestamp);
+}
+
+void
+meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
+                                int                  workspace,
+                                unsigned int        *keysym,
+                                MetaVirtualModifier *modifiers)
+{
+  const char *name;
+
+  name = NULL;
+  
+  switch (menu_op)
+    {
+    case META_MENU_OP_NONE:
+      /* No keybinding for this one */
+      break;
+    case META_MENU_OP_DELETE:
+      name = "close";
+      break;
+    case META_MENU_OP_MINIMIZE:
+      name = "minimize";
+      break;
+    case META_MENU_OP_UNMAXIMIZE:
+      name = "unmaximize";
+      break;
+    case META_MENU_OP_MAXIMIZE:
+      name = "maximize";
+      break;
+    case META_MENU_OP_UNSHADE:
+    case META_MENU_OP_SHADE:
+      name = "toggle_shaded";
+      break;
+    case META_MENU_OP_UNSTICK:
+    case META_MENU_OP_STICK:
+      name = "toggle_on_all_workspaces";
+      break;
+    case META_MENU_OP_ABOVE:
+    case META_MENU_OP_UNABOVE:
+      name = "toggle_above";
+      break;
+    case META_MENU_OP_WORKSPACES:
+      switch (workspace)
+        {
+        case 1:
+          name = "move_to_workspace_1";
+          break;
+        case 2:
+          name = "move_to_workspace_2";
+          break;
+        case 3:
+          name = "move_to_workspace_3";
+          break; 
+        case 4:
+          name = "move_to_workspace_4";
+          break; 
+        case 5:
+          name = "move_to_workspace_5";
+          break; 
+        case 6:
+          name = "move_to_workspace_6";
+          break; 
+        case 7:
+          name = "move_to_workspace_7";
+          break; 
+        case 8:
+          name = "move_to_workspace_8";
+          break; 
+        case 9:
+          name = "move_to_workspace_9";
+          break; 
+        case 10:
+          name = "move_to_workspace_10";
+          break;
+        case 11:
+          name = "move_to_workspace_11";
+          break;
+        case 12:
+          name = "move_to_workspace_12";
+          break;
+        }
+      break;
+    case META_MENU_OP_MOVE:
+      name = "begin_move";
+      break;
+    case META_MENU_OP_RESIZE:
+      name = "begin_resize";
+      break;
+    case META_MENU_OP_MOVE_LEFT:
+      name = "move_to_workspace_left";
+      break;
+    case META_MENU_OP_MOVE_RIGHT:
+      name = "move_to_workspace_right";
+      break;
+    case META_MENU_OP_MOVE_UP:
+      name = "move_to_workspace_up";
+      break;
+    case META_MENU_OP_MOVE_DOWN:
+      name = "move_to_workspace_down";
+      break;
+    case META_MENU_OP_RECOVER:
+      /* No keybinding for this one */
+      break;
+    }
+
+  if (name)
+    {
+      meta_prefs_get_window_binding (name, keysym, modifiers);
+    }
+  else
+    {
+      *keysym = 0;
+      *modifiers = 0;
+    }
+}
+
+const char*
+meta_core_get_workspace_name_with_index (Display *xdisplay,
+                                         Window   xroot,
+                                         int      index)
+{
+  MetaDisplay *display;
+  MetaScreen *screen;
+  MetaWorkspace *workspace;
+
+  display = meta_display_for_x_display (xdisplay);
+  screen = meta_display_screen_for_root (display, xroot);
+  g_assert (screen != NULL);
+  workspace = meta_screen_get_workspace_by_index (screen, index);
+  return workspace ? meta_workspace_get_name (workspace) : NULL;
+}
+
+gboolean
+meta_core_begin_grab_op (Display    *xdisplay,
+                         Window      frame_xwindow,
+                         MetaGrabOp  op,
+                         gboolean    pointer_already_grabbed,
+                         gboolean    frame_action,
+                         int         button,
+                         gulong      modmask,
+                         guint32     timestamp,
+                         int         root_x,
+                         int         root_y)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  MetaDisplay *display;
+  MetaScreen *screen;
+  
+  display = meta_display_for_x_display (xdisplay);
+  screen = meta_display_screen_for_xwindow (display, frame_xwindow);
+
+  g_assert (screen != NULL);
+  
+  return meta_display_begin_grab_op (display, screen, window,
+                                     op, pointer_already_grabbed,
+                                     frame_action,
+                                     button, modmask,
+                                     timestamp, root_x, root_y);
+}
+
+void
+meta_core_end_grab_op (Display *xdisplay,
+                       guint32  timestamp)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  meta_display_end_grab_op (display, timestamp);
+}
+
+MetaGrabOp
+meta_core_get_grab_op (Display *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  return display->grab_op;
+}
+
+Window
+meta_core_get_grab_frame (Display *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  g_assert (display != NULL);
+  g_assert (display->grab_op == META_GRAB_OP_NONE || 
+            display->grab_screen != NULL);
+  g_assert (display->grab_op == META_GRAB_OP_NONE ||
+            display->grab_screen->display->xdisplay == xdisplay);
+  
+  if (display->grab_op != META_GRAB_OP_NONE &&
+      display->grab_window &&
+      display->grab_window->frame)
+    return display->grab_window->frame->xwindow;
+  else
+    return None;
+}
+
+int
+meta_core_get_grab_button (Display  *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  if (display->grab_op == META_GRAB_OP_NONE)
+    return -1;
+  
+  return display->grab_button;
+}
+
+void
+meta_core_grab_buttons  (Display *xdisplay,
+                         Window   frame_xwindow)
+{
+  MetaDisplay *display;
+    
+  display = meta_display_for_x_display (xdisplay);
+
+  meta_verbose ("Grabbing buttons on frame 0x%lx\n", frame_xwindow);
+  meta_display_grab_window_buttons (display, frame_xwindow);
+}
+
+void
+meta_core_set_screen_cursor (Display *xdisplay,
+                             Window   frame_on_screen,
+                             MetaCursor cursor)
+{
+  MetaWindow *window = get_window (xdisplay, frame_on_screen);
+
+  meta_frame_set_screen_cursor (window->frame, cursor);
+}
+
+void
+meta_core_increment_event_serial (Display *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  meta_display_increment_event_serial (display);
+}
+
+void
+meta_invalidate_default_icons (void)
+{
+  MetaDisplay *display = meta_get_display ();
+  GSList *windows;
+  GSList *l;
+
+  if (display == NULL)
+    return; /* We can validly be called before the display is opened. */
+
+  windows = meta_display_list_windows (display);
+  for (l = windows; l != NULL; l = l->next)
+    {
+      MetaWindow *window = (MetaWindow*)l->data;
+
+      if (window->icon_cache.origin == USING_FALLBACK_ICON)
+        {
+          meta_icon_cache_free (&(window->icon_cache));
+          meta_window_update_icon_now (window);
+        }
+    }
+
+  g_slist_free (windows);
+}
+
diff --git a/src/core/delete.c b/src/core/delete.c
new file mode 100644
index 00000000..f0590e3b
--- /dev/null
+++ b/src/core/delete.c
@@ -0,0 +1,266 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window deletion */
+
+/*
+ * Copyright (C) 2001, 2002 Havoc Pennington
+ * Copyright (C) 2004 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for gethostname() */
+
+#include <config.h>
+#include "util.h"
+#include "window-private.h"
+#include "errors.h"
+#include "workspace.h"
+
+#include <sys/types.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void meta_window_present_delete_dialog (MetaWindow *window,
+                                               guint32     timestamp);
+
+static void
+delete_ping_reply_func (MetaDisplay *display,
+                        Window       xwindow,
+                        guint32      timestamp,
+                        void        *user_data)
+{
+  meta_topic (META_DEBUG_PING,
+              "Got reply to delete ping for %s\n",
+              ((MetaWindow*)user_data)->desc);
+
+  /* we do nothing */
+}
+
+static void
+dialog_exited (GPid     pid,
+               int      status,
+               gpointer user_data)
+{
+  MetaWindow *ours = (MetaWindow*) user_data;
+
+  ours->dialog_pid = -1;
+
+  /* exit status of 1 means the user pressed "Force Quit" */
+  if (WIFEXITED (status) && WEXITSTATUS (status) == 1)
+    meta_window_kill (ours);
+}
+
+static void
+delete_ping_timeout_func (MetaDisplay *display,
+                          Window       xwindow,
+                          guint32      timestamp,
+                          void        *user_data)
+{
+  MetaWindow *window = user_data;
+  char *window_title;
+  gchar *window_content, *tmp;
+  GPid dialog_pid;
+
+  meta_topic (META_DEBUG_PING,
+              "Got delete ping timeout for %s\n",
+              window->desc);
+
+  if (window->dialog_pid >= 0)
+    {
+      meta_window_present_delete_dialog (window, timestamp);
+      return;
+    }
+
+  window_title = g_locale_from_utf8 (window->title, -1, NULL, NULL, NULL);
+
+  /* Translators: %s is a window title */
+  tmp = g_strdup_printf (_("<tt>%s</tt> is not responding."),
+                         window_title);
+  window_content = g_strdup_printf (
+      "<big><b>%s</b></big>\n\n<i>%s</i>",
+      tmp,
+      _("You may choose to wait a short while for it to "
+        "continue or force the application to quit entirely."));
+
+  g_free (window_title);
+
+  dialog_pid =
+    meta_show_dialog ("--question",
+                      window_content, 0,
+                      window->screen->number,
+                      _("_Wait"), _("_Force Quit"), window->xwindow,
+                      NULL, NULL);
+
+  g_free (window_content);
+  g_free (tmp);
+
+  window->dialog_pid = dialog_pid;
+  g_child_watch_add (dialog_pid, dialog_exited, window);
+}
+
+void
+meta_window_delete (MetaWindow  *window,
+                    guint32      timestamp)
+{
+  meta_error_trap_push (window->display);
+  if (window->delete_window)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Deleting %s with delete_window request\n",
+                  window->desc);
+      meta_window_send_icccm_message (window,
+                                      window->display->atom_WM_DELETE_WINDOW,
+                                      timestamp);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Deleting %s with explicit kill\n",
+                  window->desc);
+      XKillClient (window->display->xdisplay, window->xwindow);
+    }
+  meta_error_trap_pop (window->display, FALSE);
+
+  meta_display_ping_window (window->display,
+                            window,
+                            timestamp,
+                            delete_ping_reply_func,
+                            delete_ping_timeout_func,
+                            window);
+
+  if (window->has_focus)
+    {
+      /* FIXME Clean this up someday
+       * http://bugzilla.gnome.org/show_bug.cgi?id=108706
+       */
+#if 0
+      /* This is unfortunately going to result in weirdness
+       * if the window doesn't respond to the delete event.
+       * I don't know how to avoid that though.
+       */
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window because focus window %s was deleted/killed\n",
+                  window->desc);
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window);
+#else
+      meta_topic (META_DEBUG_FOCUS,
+                  "Not unfocusing %s on delete/kill\n",
+                  window->desc);
+#endif
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Window %s was deleted/killed but didn't have focus\n",
+                  window->desc);
+    }
+}
+
+
+void
+meta_window_kill (MetaWindow *window)
+{
+  char buf[257];
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Killing %s brutally\n",
+              window->desc);
+
+  if (window->wm_client_machine != NULL &&
+      window->net_wm_pid > 0)
+    {
+      if (gethostname (buf, sizeof(buf)-1) == 0)
+        {
+          if (strcmp (buf, window->wm_client_machine) == 0)
+            {
+              meta_topic (META_DEBUG_WINDOW_OPS,
+                          "Killing %s with kill()\n",
+                          window->desc);
+
+              if (kill (window->net_wm_pid, 9) < 0)
+                meta_topic (META_DEBUG_WINDOW_OPS,
+                            "Failed to signal %s: %s\n",
+                            window->desc, strerror (errno));
+            }
+        }
+      else
+        {
+          meta_warning (_("Failed to get hostname: %s\n"),
+                        strerror (errno));
+        }
+    }
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Disconnecting %s with XKillClient()\n",
+              window->desc);
+  meta_error_trap_push (window->display);
+  XKillClient (window->display->xdisplay, window->xwindow);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_free_delete_dialog (MetaWindow *window)
+{
+  if (window->dialog_pid >= 0)
+    {
+      kill (window->dialog_pid, 9);
+      window->dialog_pid = -1;
+    }
+}
+
+static void
+meta_window_present_delete_dialog (MetaWindow *window, guint32 timestamp)
+{
+  meta_topic (META_DEBUG_PING,
+              "Presenting existing ping dialog for %s\n",
+              window->desc);
+
+  if (window->dialog_pid >= 0)
+    {
+      GSList *windows;
+      GSList *tmp;
+
+      /* Activate transient for window that belongs to
+       * marco-dialog
+       */
+
+      windows = meta_display_list_windows (window->display);
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *w = tmp->data;
+
+          if (w->xtransient_for == window->xwindow &&
+              w->res_class &&
+              g_ascii_strcasecmp (w->res_class, "marco-dialog") == 0)
+            {
+              meta_window_activate (w, timestamp);
+              break;
+            }
+
+          tmp = tmp->next;
+        }
+
+      g_slist_free (windows);
+    }
+}
diff --git a/src/core/display-private.h b/src/core/display-private.h
new file mode 100644
index 00000000..692e25f2
--- /dev/null
+++ b/src/core/display-private.h
@@ -0,0 +1,513 @@
+/* Marco X display handler */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_DISPLAY_PRIVATE_H
+#define META_DISPLAY_PRIVATE_H
+
+#ifndef PACKAGE
+	#error "config.h not included"
+#endif
+
+#include <glib.h>
+#include <X11/Xlib.h>
+#include "eventqueue.h"
+#include "common.h"
+#include "boxes.h"
+#include "display.h"
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+	#include <libsn/sn.h>
+#endif
+
+#ifdef HAVE_XSYNC
+	#include <X11/extensions/sync.h>
+#endif
+
+typedef struct _MetaKeyBinding MetaKeyBinding;
+typedef struct _MetaStack      MetaStack;
+typedef struct _MetaUISlave    MetaUISlave;
+typedef struct _MetaWorkspace  MetaWorkspace;
+
+typedef struct _MetaGroupPropHooks  MetaGroupPropHooks;
+
+typedef struct MetaEdgeResistanceData MetaEdgeResistanceData;
+
+typedef void (*MetaWindowPingFunc) (MetaDisplay* display, Window xwindow, guint32 timestamp, gpointer user_data);
+
+
+#define _NET_WM_STATE_REMOVE        0    /* remove/unset property */
+#define _NET_WM_STATE_ADD           1    /* add/set property */
+#define _NET_WM_STATE_TOGGLE        2    /* toggle property  */
+
+/* This is basically a bogus number, just has to be large enough
+ * to handle the expected case of the alt+tab operation, where
+ * we want to ignore serials from UnmapNotify on the tab popup,
+ * and the LeaveNotify/EnterNotify from the pointer ungrab
+ */
+#define N_IGNORED_SERIALS           4
+
+struct _MetaDisplay {
+	char* name;
+	Display* xdisplay;
+
+	Window leader_window;
+	Window timestamp_pinging_window;
+
+	/* Pull in all the names of atoms as fields; we will intern them when the
+	 * class is constructed.
+	 */
+	#define item(x)  Atom atom_##x;
+		#include "atomnames.h"
+	#undef item
+
+	/* This is the actual window from focus events,
+	 * not the one we last set
+	 */
+	MetaWindow* focus_window;
+
+	/* window we are expecting a FocusIn event for or the current focus
+	 * window if we are not expecting any FocusIn/FocusOut events; not
+	 * perfect because applications can call XSetInputFocus directly.
+	 * (It could also be messed up if a timestamp later than current
+	 * time is sent to meta_display_set_input_focus_window, though that
+	 * would be a programming error).  See bug 154598 for more info.
+	 */
+	MetaWindow* expected_focus_window;
+
+	/* last timestamp passed to XSetInputFocus */
+	guint32 last_focus_time;
+
+	/* last user interaction time in any app */
+	guint32 last_user_time;
+
+	/* whether we're using mousenav (only relevant for sloppy&mouse focus modes;
+	 * !mouse_mode means "keynav mode")
+	 */
+	guint mouse_mode: 1;
+
+	/* Helper var used when focus_new_windows setting is 'strict'; only
+	 * relevant in 'strict' mode and if the focus window is a terminal.
+	 * In that case, we don't allow new windows to take focus away from
+	 * a terminal, but if the user explicitly did something that should
+	 * allow a different window to gain focus (e.g. global keybinding or
+	 * clicking on a dock), then we will allow the transfer.
+	 */
+	guint allow_terminal_deactivation: 1;
+
+	guint static_gravity_works: 1;
+
+	/*< private-ish >*/
+	guint error_trap_synced_at_last_pop: 1;
+	MetaEventQueue* events;
+	GSList* screens;
+	MetaScreen* active_screen;
+	GHashTable* window_ids;
+	int error_traps;
+	int (*error_trap_handler) (Display* display, XErrorEvent* error);  
+	int server_grab_count;
+
+	/* serials of leave/unmap events that may
+	 * correspond to an enter event we should
+	 * ignore
+	 */
+	unsigned long ignored_serials[N_IGNORED_SERIALS];
+	Window ungrab_should_not_cause_focus_window;
+  
+	guint32 current_time;
+
+	/* Pings which we're waiting for a reply from */
+	GSList* pending_pings;
+
+	/* Pending autoraise */
+	guint       autoraise_timeout_id;
+	MetaWindow* autoraise_window;
+
+	/* Alt+click button grabs */
+	unsigned int window_grab_modifiers;
+
+	/* current window operation */
+	MetaGrabOp  grab_op;
+	MetaScreen* grab_screen;
+	MetaWindow* grab_window;
+	Window      grab_xwindow;
+	int         grab_button;
+	int         grab_anchor_root_x;
+	int         grab_anchor_root_y;
+	MetaRectangle grab_anchor_window_pos;
+	int         grab_latest_motion_x;
+	int         grab_latest_motion_y;
+	gulong      grab_mask;
+	guint       grab_have_pointer : 1;
+	guint       grab_have_keyboard : 1;
+	guint       grab_wireframe_active : 1;
+	guint       grab_was_cancelled : 1;    /* Only used in wireframe mode */
+	guint       grab_frame_action : 1;
+	MetaRectangle grab_wireframe_rect;
+	MetaRectangle grab_wireframe_last_xor_rect;
+	MetaRectangle grab_initial_window_pos;
+	int         grab_initial_x, grab_initial_y;  /* These are only relevant for */
+	gboolean    grab_threshold_movement_reached; /* raise_on_click == FALSE.    */
+	MetaResizePopup* grab_resize_popup;
+	GTimeVal    grab_last_moveresize_time;
+	guint32     grab_motion_notify_time;
+	int         grab_wireframe_last_display_width;
+	int         grab_wireframe_last_display_height;
+	GList*      grab_old_window_stacking;
+	MetaEdgeResistanceData* grab_edge_resistance_data;
+	unsigned int grab_last_user_action_was_snap;
+
+	/* we use property updates as sentinels for certain window focus events
+	 * to avoid some race conditions on EnterNotify events
+	 */
+	int         sentinel_counter;
+
+	#ifdef HAVE_XKB
+		int         xkb_base_event_type;
+		guint32     last_bell_time;
+	#endif
+	
+	#ifdef HAVE_XSYNC
+		/* alarm monitoring client's _NET_WM_SYNC_REQUEST_COUNTER */
+		XSyncAlarm  grab_sync_request_alarm;
+	#endif
+	
+	int       grab_resize_timeout_id;
+
+	/* Keybindings stuff */
+	MetaKeyBinding* key_bindings;
+	int             n_key_bindings;
+	int             min_keycode;
+	int             max_keycode;
+	KeySym* keymap;
+	int keysyms_per_keycode;
+	XModifierKeymap* modmap;
+	unsigned int ignored_modifier_mask;
+	unsigned int num_lock_mask;
+	unsigned int scroll_lock_mask;
+	unsigned int hyper_mask;
+	unsigned int super_mask;
+	unsigned int meta_mask;
+
+	/* Xinerama cache */
+	unsigned int xinerama_cache_invalidated: 1;
+
+	/* Opening the display */
+	unsigned int display_opening: 1;
+
+	/* Closing down the display */
+	int closing;
+
+	/* To detect double clicks
+	 *
+	 * https://github.com/stefano-k/Mate-Desktop-Environment/commit/b0e5fb03eb21dae8f02692f11ef391bfc5ccba33
+	 */
+	guint button_click_number;
+	Window button_click_window;
+	int button_click_x;
+	int button_click_y;
+	guint32 button_click_time;
+
+	/* Managed by group.c */
+	GHashTable* groups_by_leader;
+
+	/* currently-active window menu if any */
+	MetaWindowMenu* window_menu;
+	MetaWindow* window_with_menu;
+
+	/* Managed by window-props.c */
+	gpointer* prop_hooks_table;
+	GHashTable* prop_hooks;
+
+	/* Managed by group-props.c */
+	MetaGroupPropHooks* group_prop_hooks;
+
+	/* Managed by compositor.c */
+	MetaCompositor* compositor;
+  
+	#ifdef HAVE_STARTUP_NOTIFICATION
+		SnDisplay* sn_display;
+	#endif
+	
+	#ifdef HAVE_XSYNC
+		int xsync_event_base;
+		int xsync_error_base;
+	#endif
+	
+	#ifdef HAVE_SHAPE
+		int shape_event_base;
+		int shape_error_base;
+	#endif
+	
+	#ifdef HAVE_RENDER
+		int render_event_base;
+		int render_error_base;
+	#endif
+	
+	#ifdef HAVE_COMPOSITE_EXTENSIONS
+		int composite_event_base;
+		int composite_error_base;
+		int composite_major_version;
+		int composite_minor_version;
+		int damage_event_base;
+		int damage_error_base;
+		int xfixes_event_base;
+		int xfixes_error_base;
+	#endif
+	
+	#ifdef HAVE_XSYNC
+		unsigned int have_xsync : 1;
+		#define META_DISPLAY_HAS_XSYNC(display) ((display)->have_xsync)
+	#else
+		#define META_DISPLAY_HAS_XSYNC(display) FALSE
+	#endif
+	
+	#ifdef HAVE_SHAPE
+		unsigned int have_shape : 1;
+		#define META_DISPLAY_HAS_SHAPE(display) ((display)->have_shape)
+	#else
+		#define META_DISPLAY_HAS_SHAPE(display) FALSE
+	#endif
+	
+	#ifdef HAVE_RENDER
+		unsigned int have_render : 1;
+		#define META_DISPLAY_HAS_RENDER(display) ((display)->have_render)
+	#else
+		#define META_DISPLAY_HAS_RENDER(display) FALSE
+	#endif
+	
+	#ifdef HAVE_COMPOSITE_EXTENSIONS
+		unsigned int have_composite : 1;
+		unsigned int have_damage : 1;
+		unsigned int have_xfixes : 1;
+		#define META_DISPLAY_HAS_COMPOSITE(display) ((display)->have_composite)
+		#define META_DISPLAY_HAS_DAMAGE(display) ((display)->have_damage)
+		#define META_DISPLAY_HAS_XFIXES(display) ((display)->have_xfixes)
+	#else
+		#define META_DISPLAY_HAS_COMPOSITE(display) FALSE
+		#define META_DISPLAY_HAS_DAMAGE(display) FALSE
+		#define META_DISPLAY_HAS_XFIXES(display) FALSE
+	#endif
+};
+
+/* Xserver time can wraparound, thus comparing two timestamps needs to take
+ * this into account.  Here's a little macro to help out.  If no wraparound
+ * has occurred, this is equivalent to
+ *   time1 < time2
+ * Of course, the rest of the ugliness of this macro comes from accounting
+ * for the fact that wraparound can occur and the fact that a timestamp of
+ * 0 must be special-cased since it means older than anything else. 
+ *
+ * Note that this is NOT an equivalent for time1 <= time2; if that's what
+ * you need then you'll need to swap the order of the arguments and negate
+ * the result.
+ */
+#define XSERVER_TIME_IS_BEFORE_ASSUMING_REAL_TIMESTAMPS(time1, time2) \
+	( (( (time1) < (time2) ) && ( (time2) - (time1) < ((guint32)-1)/2 )) || \
+		(( (time1) > (time2) ) && ( (time1) - (time2) > ((guint32)-1)/2 )) \
+	)
+#define XSERVER_TIME_IS_BEFORE(time1, time2) \
+	( (time1) == 0 || \
+		(XSERVER_TIME_IS_BEFORE_ASSUMING_REAL_TIMESTAMPS(time1, time2) && \
+		(time2) != 0) \
+	)
+
+gboolean      meta_display_open                (void);
+void          meta_display_close               (MetaDisplay *display,
+                                                guint32      timestamp);
+MetaScreen*   meta_display_screen_for_x_screen (MetaDisplay *display,
+                                                Screen      *screen);
+MetaScreen*   meta_display_screen_for_xwindow  (MetaDisplay *display,
+                                                Window       xindow);
+void          meta_display_grab                (MetaDisplay *display);
+void          meta_display_ungrab              (MetaDisplay *display);
+
+void          meta_display_unmanage_screen     (MetaDisplay **display,
+                                                MetaScreen  *screen,
+                                                guint32      timestamp);
+
+void          meta_display_unmanage_windows_for_screen (MetaDisplay *display,
+                                                        MetaScreen  *screen,
+                                                        guint32      timestamp);
+
+/* Utility function to compare the stacking of two windows */
+int           meta_display_stack_cmp           (const void *a,
+                                                const void *b);
+
+/* A given MetaWindow may have various X windows that "belong"
+ * to it, such as the frame window.
+ */
+MetaWindow* meta_display_lookup_x_window     (MetaDisplay *display,
+                                              Window       xwindow);
+void        meta_display_register_x_window   (MetaDisplay *display,
+                                              Window      *xwindowp,
+                                              MetaWindow  *window);
+void        meta_display_unregister_x_window (MetaDisplay *display,
+                                              Window       xwindow);
+/* Return whether the xwindow is a no focus window for any of the screens */
+gboolean    meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
+                                                       Window xwindow);
+
+GSList*     meta_display_list_windows        (MetaDisplay *display);
+
+MetaDisplay* meta_display_for_x_display  (Display     *xdisplay);
+MetaDisplay* meta_get_display            (void);
+
+Cursor         meta_display_create_x_cursor (MetaDisplay *display,
+                                             MetaCursor   cursor);
+
+void     meta_display_set_grab_op_cursor (MetaDisplay *display,
+                                          MetaScreen  *screen,
+                                          MetaGrabOp   op,
+                                          gboolean     change_pointer,
+                                          Window       grab_xwindow,
+                                          guint32      timestamp);
+
+gboolean meta_display_begin_grab_op (MetaDisplay *display,
+                                     MetaScreen  *screen,
+                                     MetaWindow  *window,
+                                     MetaGrabOp   op,
+                                     gboolean     pointer_already_grabbed,
+                                     gboolean     frame_action,
+                                     int          button,
+                                     gulong       modmask,
+                                     guint32      timestamp,
+                                     int          root_x,
+                                     int          root_y);
+void     meta_display_end_grab_op   (MetaDisplay *display,
+                                     guint32      timestamp);
+
+void    meta_display_check_threshold_reached (MetaDisplay *display,
+                                              int          x,
+                                              int          y);
+void     meta_display_grab_window_buttons    (MetaDisplay *display,
+                                              Window       xwindow);
+void     meta_display_ungrab_window_buttons  (MetaDisplay *display,
+                                              Window       xwindow);
+
+void meta_display_grab_focus_window_button   (MetaDisplay *display,
+                                              MetaWindow  *window);
+void meta_display_ungrab_focus_window_button (MetaDisplay *display,
+                                              MetaWindow  *window);
+
+/* Next two functions are defined in edge-resistance.c */
+void meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display);
+void meta_display_cleanup_edges                         (MetaDisplay *display);
+
+/* make a request to ensure the event serial has changed */
+void     meta_display_increment_event_serial (MetaDisplay *display);
+
+void     meta_display_update_active_window_hint (MetaDisplay *display);
+
+guint32  meta_display_get_current_time           (MetaDisplay *display);
+guint32  meta_display_get_current_time_roundtrip (MetaDisplay *display);
+
+/* utility goo */
+const char* meta_event_mode_to_string   (int m);
+const char* meta_event_detail_to_string (int d);
+
+void meta_display_queue_retheme_all_windows (MetaDisplay *display);
+void meta_display_retheme_all (void);
+
+void meta_display_set_cursor_theme (const char *theme, 
+				    int         size);
+
+void meta_display_ping_window      (MetaDisplay        *display,
+                                    MetaWindow         *window,
+                                    guint32             timestamp,
+                                    MetaWindowPingFunc  ping_reply_func,
+                                    MetaWindowPingFunc  ping_timeout_func,
+                                    void               *user_data);
+gboolean meta_display_window_has_pending_pings (MetaDisplay        *display,
+						MetaWindow         *window);
+
+typedef enum
+{
+  META_TAB_LIST_NORMAL,
+  META_TAB_LIST_DOCKS,
+  META_TAB_LIST_GROUP
+} MetaTabList;
+
+typedef enum
+{
+  META_TAB_SHOW_ICON,      /* Alt-Tab mode */
+  META_TAB_SHOW_INSTANTLY  /* Alt-Esc mode */
+} MetaTabShowType;
+
+GList* meta_display_get_tab_list (MetaDisplay   *display,
+                                  MetaTabList    type,
+                                  MetaScreen    *screen,
+                                  MetaWorkspace *workspace);
+
+MetaWindow* meta_display_get_tab_next (MetaDisplay   *display,
+                                       MetaTabList    type,
+				       MetaScreen    *screen,
+                                       MetaWorkspace *workspace,
+                                       MetaWindow    *window,
+                                       gboolean       backward);
+
+MetaWindow* meta_display_get_tab_current (MetaDisplay   *display,
+                                          MetaTabList    type,
+                                          MetaScreen    *screen,
+                                          MetaWorkspace *workspace);
+
+int meta_resize_gravity_from_grab_op (MetaGrabOp op);
+
+gboolean meta_grab_op_is_moving   (MetaGrabOp op);
+gboolean meta_grab_op_is_resizing (MetaGrabOp op);
+
+void meta_display_devirtualize_modifiers (MetaDisplay        *display,
+                                          MetaVirtualModifier modifiers,
+                                          unsigned int       *mask);
+
+void meta_display_increment_focus_sentinel (MetaDisplay *display);
+void meta_display_decrement_focus_sentinel (MetaDisplay *display);
+gboolean meta_display_focus_sentinel_clear (MetaDisplay *display);
+
+/* meta_display_set_input_focus_window is like XSetInputFocus, except
+ * that (a) it can't detect timestamps later than the current time,
+ * since Marco isn't part of the XServer, and thus gives erroneous
+ * behavior in this circumstance (so don't do it), (b) it uses
+ * display->last_focus_time since we don't have access to the true
+ * Xserver one, (c) it makes use of display->user_time since checking
+ * whether a window should be allowed to be focused should depend
+ * on user_time events (see bug 167358, comment 15 in particular)
+ */
+void meta_display_set_input_focus_window   (MetaDisplay *display, 
+                                            MetaWindow  *window,
+                                            gboolean     focus_frame,
+                                            guint32      timestamp);
+
+/* meta_display_focus_the_no_focus_window is called when the
+ * designated no_focus_window should be focused, but is otherwise the
+ * same as meta_display_set_input_focus_window
+ */
+void meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                             MetaScreen  *screen,
+                                             guint32      timestamp);
+
+void meta_display_queue_autoraise_callback  (MetaDisplay *display,
+                                             MetaWindow  *window);
+void meta_display_remove_autoraise_callback (MetaDisplay *display);
+
+#endif /* META_DISPLAY_PRIVATE_H */
diff --git a/src/core/display.c b/src/core/display.c
new file mode 100644
index 00000000..59ec9021
--- /dev/null
+++ b/src/core/display.c
@@ -0,0 +1,5355 @@
+/* Marco X display handler */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file display.c Handles operations on an X display.
+ *
+ * The display is represented as a MetaDisplay struct.
+ */
+
+#include <config.h>
+#include "display-private.h"
+#include "util.h"
+#include "main.h"
+#include "screen-private.h"
+#include "window-private.h"
+#include "window-props.h"
+#include "group-props.h"
+#include "frame-private.h"
+#include "errors.h"
+#include "keybindings.h"
+#include "prefs.h"
+#include "resizepopup.h"
+#include "xprops.h"
+#include "workspace.h"
+#include "bell.h"
+#include "effects.h"
+#include "compositor.h"
+#include <X11/Xatom.h>
+#include <X11/cursorfont.h>
+
+#ifdef HAVE_SOLARIS_XINERAMA
+	#include <X11/extensions/xinerama.h>
+#endif
+
+#ifdef HAVE_XFREE_XINERAMA
+	#include <X11/extensions/Xinerama.h>
+#endif
+
+#ifdef HAVE_RANDR
+	#include <X11/extensions/Xrandr.h>
+#endif
+
+#ifdef HAVE_SHAPE
+	#include <X11/extensions/shape.h>
+#endif
+
+#ifdef HAVE_RENDER
+	#include <X11/extensions/Xrender.h>
+#endif
+
+#ifdef HAVE_XKB
+	#include <X11/XKBlib.h>
+#endif
+
+#ifdef HAVE_XCURSOR
+	#include <X11/Xcursor/Xcursor.h>
+#endif
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+	#include <X11/extensions/Xcomposite.h>
+	#include <X11/extensions/Xdamage.h>
+	#include <X11/extensions/Xfixes.h>
+	#include <gtk/gtk.h>
+#endif
+
+#include <string.h>
+
+#define GRAB_OP_IS_WINDOW_SWITCH(g)                     \
+        (g == META_GRAB_OP_KEYBOARD_TABBING_NORMAL  ||  \
+         g == META_GRAB_OP_KEYBOARD_TABBING_DOCK    ||  \
+         g == META_GRAB_OP_KEYBOARD_TABBING_GROUP   ||  \
+         g == META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL ||  \
+         g == META_GRAB_OP_KEYBOARD_ESCAPING_DOCK   ||  \
+         g == META_GRAB_OP_KEYBOARD_ESCAPING_GROUP)
+
+/**
+ * \defgroup pings Pings
+ *
+ * Sometimes we want to see whether a window is responding,
+ * so we send it a "ping" message and see whether it sends us back a "pong"
+ * message within a reasonable time. Here we have a system which lets us
+ * nominate one function to be called if we get the pong in time and another
+ * function if we don't. The system is rather more complicated than it needs
+ * to be, since we only ever use it to destroy windows which are asked to
+ * close themselves and don't do so within a reasonable amount of time, and
+ * therefore we always use the same callbacks. It's possible that we might
+ * use it for other things in future, or on the other hand we might decide
+ * that we're never going to do so and simplify it a bit.
+ */
+
+/**
+ * Describes a ping on a window. When we send a ping to a window, we build
+ * one of these structs, and it eventually gets passed to the timeout function
+ * or to the function which handles the response from the window. If the window
+ * does or doesn't respond to the ping, we use this information to deal with
+ * these facts; we have a handler function for each.
+ *
+ * \ingroup pings
+ */
+typedef struct 
+{
+  MetaDisplay *display;
+  Window       xwindow;
+  guint32      timestamp;
+  MetaWindowPingFunc ping_reply_func;
+  MetaWindowPingFunc ping_timeout_func;
+  void        *user_data;
+  guint        ping_timeout_id;
+} MetaPingData;
+
+typedef struct 
+{
+  MetaDisplay *display;
+  Window xwindow;
+} MetaAutoRaiseData;
+
+/**
+ * The display we're managing.  This is a singleton object.  (Historically,
+ * this was a list of displays, but there was never any way to add more
+ * than one element to it.)  The goofy name is because we don't want it
+ * to shadow the parameter in its object methods.
+ */
+static MetaDisplay *the_display = NULL;
+
+#ifdef WITH_VERBOSE_MODE
+static void   meta_spew_event           (MetaDisplay    *display,
+                                         XEvent         *event);
+#endif
+
+static gboolean event_callback          (XEvent         *event,
+                                         gpointer        data);
+static Window event_get_modified_window (MetaDisplay    *display,
+                                         XEvent         *event);
+static guint32 event_get_time           (MetaDisplay    *display,
+                                         XEvent         *event);
+static void    process_request_frame_extents (MetaDisplay    *display,
+                                              XEvent         *event);
+static void    process_pong_message     (MetaDisplay    *display,
+                                         XEvent         *event);
+static void    process_selection_request (MetaDisplay   *display,
+                                          XEvent        *event);
+static void    process_selection_clear   (MetaDisplay   *display,
+                                          XEvent        *event);
+
+static void    update_window_grab_modifiers (MetaDisplay *display);
+
+static void    prefs_changed_callback    (MetaPreference pref,
+                                          void          *data);
+
+static void    sanity_check_timestamps   (MetaDisplay *display,
+                                          guint32      known_good_timestamp);
+
+MetaGroup*     get_focussed_group (MetaDisplay *display);
+
+/**
+ * Destructor for MetaPingData structs. Will destroy the
+ * event source for the struct as well.
+ *
+ * \ingroup pings
+ */
+static void
+ping_data_free (MetaPingData *ping_data)
+{
+  /* Remove the timeout */
+  if (ping_data->ping_timeout_id != 0)
+    g_source_remove (ping_data->ping_timeout_id);
+
+  g_free (ping_data);
+}
+
+/**
+ * Frees every pending ping structure for the given X window on the
+ * given display. This means that we also destroy the timeouts.
+ *
+ * \param display The display the window appears on
+ * \param xwindow The X ID of the window whose pings we should remove
+ *
+ * \ingroup pings
+ *
+ */
+static void
+remove_pending_pings_for_window (MetaDisplay *display, Window xwindow)
+{
+  GSList *tmp;
+  GSList *dead;
+
+  /* could obviously be more efficient, don't care */
+  
+  /* build list to be removed */
+  dead = NULL;
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (ping_data->xwindow == xwindow)
+        dead = g_slist_prepend (dead, ping_data);
+    }
+
+  /* remove what we found */
+  for (tmp = dead; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
+      ping_data_free (ping_data);
+    }
+
+  g_slist_free (dead);
+}
+
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static void
+sn_error_trap_push (SnDisplay *sn_display,
+                    Display   *xdisplay)
+{
+  MetaDisplay *display;
+  display = meta_display_for_x_display (xdisplay);
+  if (display != NULL)
+    meta_error_trap_push (display);
+}
+
+static void
+sn_error_trap_pop (SnDisplay *sn_display,
+                   Display   *xdisplay)
+{
+  MetaDisplay *display;
+  display = meta_display_for_x_display (xdisplay);
+  if (display != NULL)
+    meta_error_trap_pop (display, FALSE);
+}
+#endif
+
+static void
+enable_compositor (MetaDisplay *display,
+                   gboolean     composite_windows)
+{
+  GSList *list;
+
+  if (!META_DISPLAY_HAS_COMPOSITE (display) ||
+      !META_DISPLAY_HAS_DAMAGE (display) ||
+      !META_DISPLAY_HAS_XFIXES (display) ||
+      !META_DISPLAY_HAS_RENDER (display))
+    {
+      meta_warning (_("Missing %s extension required for compositing"),
+                    !META_DISPLAY_HAS_COMPOSITE (display) ? "composite" :
+                    !META_DISPLAY_HAS_DAMAGE (display) ? "damage" :
+                    !META_DISPLAY_HAS_XFIXES (display) ? "xfixes" : "render");
+      return;
+    }
+
+  if (!display->compositor)
+      display->compositor = meta_compositor_new (display);
+
+  if (!display->compositor)
+    return;
+  
+  for (list = display->screens; list != NULL; list = list->next)
+    {
+      MetaScreen *screen = list->data;
+      
+      meta_compositor_manage_screen (screen->display->compositor,
+				     screen);
+
+      if (composite_windows)
+        meta_screen_composite_all_windows (screen);
+    }
+}
+
+static void
+disable_compositor (MetaDisplay *display)
+{
+  GSList *list;
+  
+  if (!display->compositor)
+    return;
+  
+  for (list = display->screens; list != NULL; list = list->next)
+    {
+      MetaScreen *screen = list->data;
+      
+      meta_compositor_unmanage_screen (screen->display->compositor,
+				       screen);
+    }
+  
+  meta_compositor_destroy (display->compositor);
+  display->compositor = NULL;
+}
+
+/**
+ * Opens a new display, sets it up, initialises all the X extensions
+ * we will need, and adds it to the list of displays.
+ *
+ * \return True if the display was opened successfully, and False
+ * otherwise-- that is, if the display doesn't exist or it already
+ * has a window manager.
+ *
+ * \ingroup main
+ */
+gboolean
+meta_display_open (void)
+{
+  Display *xdisplay;
+  GSList *screens;
+  GSList *tmp;
+  int i;
+  guint32 timestamp;
+
+  /* A list of all atom names, so that we can intern them in one go. */
+  char *atom_names[] = {
+#define item(x) #x,
+#include "atomnames.h"
+#undef item
+  };
+  Atom atoms[G_N_ELEMENTS(atom_names)];
+  
+  meta_verbose ("Opening display '%s'\n", XDisplayName (NULL));
+
+  xdisplay = meta_ui_get_display ();
+  
+  if (xdisplay == NULL)
+    {
+      meta_warning (_("Failed to open X Window System display '%s'\n"),
+		    XDisplayName (NULL));
+      return FALSE;
+    }
+
+  if (meta_is_syncing ())
+    XSynchronize (xdisplay, True);
+  
+  g_assert (the_display == NULL);
+  the_display = g_new (MetaDisplay, 1);
+
+  the_display->closing = 0;
+  
+  /* here we use XDisplayName which is what the user
+   * probably put in, vs. DisplayString(display) which is
+   * canonicalized by XOpenDisplay()
+   */
+  the_display->name = g_strdup (XDisplayName (NULL));
+  the_display->xdisplay = xdisplay;
+  the_display->error_trap_synced_at_last_pop = TRUE;
+  the_display->error_traps = 0;
+  the_display->error_trap_handler = NULL;
+  the_display->server_grab_count = 0;
+  the_display->display_opening = TRUE;
+
+  the_display->pending_pings = NULL;
+  the_display->autoraise_timeout_id = 0;
+  the_display->autoraise_window = NULL;
+  the_display->focus_window = NULL;
+  the_display->expected_focus_window = NULL;
+  the_display->grab_old_window_stacking = NULL;
+
+  the_display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */
+  the_display->allow_terminal_deactivation = TRUE; /* Only relevant for when a
+                                                  terminal has the focus */
+
+#ifdef HAVE_XSYNC
+  the_display->grab_sync_request_alarm = None;
+#endif
+  
+  /* FIXME copy the checks from GDK probably */
+  the_display->static_gravity_works = g_getenv ("MARCO_USE_STATIC_GRAVITY") != NULL;
+  
+  meta_bell_init (the_display);
+
+  meta_display_init_keys (the_display);
+
+  update_window_grab_modifiers (the_display);
+
+  meta_prefs_add_listener (prefs_changed_callback, the_display);
+
+  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
+  XInternAtoms (the_display->xdisplay, atom_names, G_N_ELEMENTS (atom_names),
+                False, atoms);
+  {
+    int i = 0;    
+#define item(x) the_display->atom_##x = atoms[i++];
+#include "atomnames.h"
+#undef item
+  }
+
+  the_display->prop_hooks = NULL;
+  meta_display_init_window_prop_hooks (the_display);
+  the_display->group_prop_hooks = NULL;
+  meta_display_init_group_prop_hooks (the_display);
+  
+  /* Offscreen unmapped window used for _NET_SUPPORTING_WM_CHECK,
+   * created in screen_new
+   */
+  the_display->leader_window = None;
+  the_display->timestamp_pinging_window = None;
+
+  the_display->xinerama_cache_invalidated = TRUE;
+
+  the_display->groups_by_leader = NULL;
+
+  the_display->window_with_menu = NULL;
+  the_display->window_menu = NULL;
+  
+  the_display->screens = NULL;
+  the_display->active_screen = NULL;
+  
+#ifdef HAVE_STARTUP_NOTIFICATION
+  the_display->sn_display = sn_display_new (the_display->xdisplay,
+                                        sn_error_trap_push,
+                                        sn_error_trap_pop);
+#endif
+  
+  the_display->events = NULL;
+
+  /* Get events */
+  meta_ui_add_event_func (the_display->xdisplay,
+                          event_callback,
+                          the_display);
+  
+  the_display->window_ids = g_hash_table_new (meta_unsigned_long_hash,
+                                          meta_unsigned_long_equal);
+  
+  i = 0;
+  while (i < N_IGNORED_SERIALS)
+    {
+      the_display->ignored_serials[i] = 0;
+      ++i;
+    }
+  the_display->ungrab_should_not_cause_focus_window = None;
+  
+  the_display->current_time = CurrentTime;
+  the_display->sentinel_counter = 0;
+
+  the_display->grab_resize_timeout_id = 0;
+  the_display->grab_have_keyboard = FALSE;
+  
+#ifdef HAVE_XKB  
+  the_display->last_bell_time = 0;
+#endif
+
+  the_display->grab_op = META_GRAB_OP_NONE;
+  the_display->grab_wireframe_active = FALSE;
+  the_display->grab_window = NULL;
+  the_display->grab_screen = NULL;
+  the_display->grab_resize_popup = NULL;
+
+  the_display->grab_edge_resistance_data = NULL;
+
+#ifdef HAVE_XSYNC
+  {
+    int major, minor;
+
+    the_display->have_xsync = FALSE;
+    
+    the_display->xsync_error_base = 0;
+    the_display->xsync_event_base = 0;
+
+    /* I don't think we really have to fill these in */
+    major = SYNC_MAJOR_VERSION;
+    minor = SYNC_MINOR_VERSION;
+    
+    if (!XSyncQueryExtension (the_display->xdisplay,
+                              &the_display->xsync_event_base,
+                              &the_display->xsync_error_base) ||
+        !XSyncInitialize (the_display->xdisplay,
+                          &major, &minor))
+      {
+        the_display->xsync_error_base = 0;
+        the_display->xsync_event_base = 0;
+      }
+    else
+      the_display->have_xsync = TRUE;
+    
+    meta_verbose ("Attempted to init Xsync, found version %d.%d error base %d event base %d\n",
+                  major, minor,
+                  the_display->xsync_error_base,
+                  the_display->xsync_event_base);
+  }
+#else  /* HAVE_XSYNC */
+  meta_verbose ("Not compiled with Xsync support\n");
+#endif /* !HAVE_XSYNC */
+
+
+#ifdef HAVE_SHAPE
+  {
+    the_display->have_shape = FALSE;
+    
+    the_display->shape_error_base = 0;
+    the_display->shape_event_base = 0;
+    
+    if (!XShapeQueryExtension (the_display->xdisplay,
+                               &the_display->shape_event_base,
+                               &the_display->shape_error_base))
+      {
+        the_display->shape_error_base = 0;
+        the_display->shape_event_base = 0;
+      }
+    else
+      the_display->have_shape = TRUE;
+    
+    meta_verbose ("Attempted to init Shape, found error base %d event base %d\n",
+                  the_display->shape_error_base,
+                  the_display->shape_event_base);
+  }
+#else  /* HAVE_SHAPE */
+  meta_verbose ("Not compiled with Shape support\n");
+#endif /* !HAVE_SHAPE */
+
+#ifdef HAVE_RENDER
+  {
+    the_display->have_render = FALSE;
+    
+    the_display->render_error_base = 0;
+    the_display->render_event_base = 0;
+    
+    if (!XRenderQueryExtension (the_display->xdisplay,
+                                &the_display->render_event_base,
+                                &the_display->render_error_base))
+      {
+        the_display->render_error_base = 0;
+        the_display->render_event_base = 0;
+      }
+    else
+      the_display->have_render = TRUE;
+    
+    meta_verbose ("Attempted to init Render, found error base %d event base %d\n",
+                  the_display->render_error_base,
+                  the_display->render_event_base);
+  }
+#else  /* HAVE_RENDER */
+  meta_verbose ("Not compiled with Render support\n");
+#endif /* !HAVE_RENDER */
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  {
+    the_display->have_composite = FALSE;
+
+    the_display->composite_error_base = 0;
+    the_display->composite_event_base = 0;
+
+    if (!XCompositeQueryExtension (the_display->xdisplay,
+                                   &the_display->composite_event_base,
+                                   &the_display->composite_error_base))
+      {
+        the_display->composite_error_base = 0;
+        the_display->composite_event_base = 0;
+      } 
+    else
+      {
+        the_display->composite_major_version = 0;
+        the_display->composite_minor_version = 0;
+        if (XCompositeQueryVersion (the_display->xdisplay,
+                                    &the_display->composite_major_version,
+                                    &the_display->composite_minor_version))
+          {
+            the_display->have_composite = TRUE;
+          }
+        else
+          {
+            the_display->composite_major_version = 0;
+            the_display->composite_minor_version = 0;
+          }
+      }
+
+    meta_verbose ("Attempted to init Composite, found error base %d event base %d "
+                  "extn ver %d %d\n",
+                  the_display->composite_error_base, 
+                  the_display->composite_event_base,
+                  the_display->composite_major_version,
+                  the_display->composite_minor_version);
+
+    the_display->have_damage = FALSE;
+
+    the_display->damage_error_base = 0;
+    the_display->damage_event_base = 0;
+
+    if (!XDamageQueryExtension (the_display->xdisplay,
+                                &the_display->damage_event_base,
+                                &the_display->damage_error_base))
+      {
+        the_display->damage_error_base = 0;
+        the_display->damage_event_base = 0;
+      } 
+    else
+      the_display->have_damage = TRUE;
+
+    meta_verbose ("Attempted to init Damage, found error base %d event base %d\n",
+                  the_display->damage_error_base, 
+                  the_display->damage_event_base);
+
+    the_display->have_xfixes = FALSE;
+
+    the_display->xfixes_error_base = 0;
+    the_display->xfixes_event_base = 0;
+
+    if (!XFixesQueryExtension (the_display->xdisplay,
+                               &the_display->xfixes_event_base,
+                               &the_display->xfixes_error_base))
+      {
+        the_display->xfixes_error_base = 0;
+        the_display->xfixes_event_base = 0;
+      } 
+    else
+      the_display->have_xfixes = TRUE;
+
+    meta_verbose ("Attempted to init XFixes, found error base %d event base %d\n",
+                  the_display->xfixes_error_base, 
+                  the_display->xfixes_event_base);
+  }
+#else /* HAVE_COMPOSITE_EXTENSIONS */
+  meta_verbose ("Not compiled with Composite support\n");
+#endif /* !HAVE_COMPOSITE_EXTENSIONS */
+      
+#ifdef HAVE_XCURSOR
+  {
+    XcursorSetTheme (the_display->xdisplay, meta_prefs_get_cursor_theme ());
+    XcursorSetDefaultSize (the_display->xdisplay, meta_prefs_get_cursor_size ());
+  }
+#else /* HAVE_XCURSOR */
+  meta_verbose ("Not compiled with Xcursor support\n");
+#endif /* !HAVE_XCURSOR */
+
+  /* Create the leader window here. Set its properties and
+   * use the timestamp from one of the PropertyNotify events
+   * that will follow.
+   */
+  {
+    gulong data[1];
+    XEvent event;
+
+    /* We only care about the PropertyChangeMask in the next 30 or so lines of
+     * code.  Note that gdk will at some point unset the PropertyChangeMask for
+     * this window, so we can't rely on it still being set later.  See bug
+     * 354213 for details.
+     */
+    the_display->leader_window =
+      meta_create_offscreen_window (the_display->xdisplay,
+                                    DefaultRootWindow (the_display->xdisplay),
+                                    PropertyChangeMask);
+
+    meta_prop_set_utf8_string_hint (the_display,
+                                    the_display->leader_window,
+                                    the_display->atom__NET_WM_NAME,
+                                    "Marco");
+    
+    meta_prop_set_utf8_string_hint (the_display,
+                                    the_display->leader_window,
+                                    the_display->atom__MARCO_VERSION,
+                                    VERSION);
+
+    data[0] = the_display->leader_window;
+    XChangeProperty (the_display->xdisplay,
+                     the_display->leader_window,
+                     the_display->atom__NET_SUPPORTING_WM_CHECK,
+                     XA_WINDOW,
+                     32, PropModeReplace, (guchar*) data, 1);
+
+    XWindowEvent (the_display->xdisplay,
+                  the_display->leader_window,
+                  PropertyChangeMask,
+                  &event);
+
+    timestamp = event.xproperty.time;
+
+    /* Make it painfully clear that we can't rely on PropertyNotify events on
+     * this window, as per bug 354213.
+     */
+    XSelectInput(the_display->xdisplay,
+                 the_display->leader_window,
+                 NoEventMask);
+  }
+
+  /* Make a little window used only for pinging the server for timestamps; note
+   * that meta_create_offscreen_window already selects for PropertyChangeMask.
+   */
+  the_display->timestamp_pinging_window =
+    meta_create_offscreen_window (the_display->xdisplay,
+                                  DefaultRootWindow (the_display->xdisplay),
+                                  PropertyChangeMask);
+
+  the_display->last_focus_time = timestamp;
+  the_display->last_user_time = timestamp;
+  the_display->compositor = NULL;
+  
+  screens = NULL;
+  
+  i = 0;
+  while (i < ScreenCount (xdisplay))
+    {
+      MetaScreen *screen;
+
+      screen = meta_screen_new (the_display, i, timestamp);
+
+      if (screen)
+        screens = g_slist_prepend (screens, screen);
+      ++i;
+    }
+  
+  the_display->screens = screens;
+  
+  if (screens == NULL)
+    {
+      /* This would typically happen because all the screens already
+       * have window managers.
+       */
+      meta_display_close (the_display, timestamp);
+      return FALSE;
+    }
+
+  /* We don't composite the windows here because they will be composited 
+     faster with the call to meta_screen_manage_all_windows further down 
+     the code */
+  if (meta_prefs_get_compositing_manager ())
+    enable_compositor (the_display, FALSE);
+   
+  meta_display_grab (the_display);
+  
+  /* Now manage all existing windows */
+  tmp = the_display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+	
+      meta_screen_manage_all_windows (screen);
+
+      tmp = tmp->next;
+    }
+
+  {
+    Window focus;
+    int ret_to;
+
+    /* kinda bogus because GetInputFocus has no possible errors */
+    meta_error_trap_push (the_display);
+
+    /* FIXME: This is totally broken; see comment 9 of bug 88194 about this */
+    focus = None;
+    ret_to = RevertToPointerRoot;
+    XGetInputFocus (the_display->xdisplay, &focus, &ret_to);
+
+    /* Force a new FocusIn (does this work?) */
+
+    /* Use the same timestamp that was passed to meta_screen_new(),
+     * as it is the most recent timestamp.
+     */
+    if (focus == None || focus == PointerRoot)
+      /* Just focus the no_focus_window on the first screen */
+      meta_display_focus_the_no_focus_window (the_display,
+                                              the_display->screens->data,
+                                              timestamp);
+    else
+      {
+        MetaWindow * window;
+        window  = meta_display_lookup_x_window (the_display, focus);
+        if (window)
+          meta_display_set_input_focus_window (the_display, window, FALSE, timestamp);
+        else
+          /* Just focus the no_focus_window on the first screen */
+          meta_display_focus_the_no_focus_window (the_display,
+                                                  the_display->screens->data,
+                                                  timestamp);
+      }
+
+    meta_error_trap_pop (the_display, FALSE);
+  }
+  
+  meta_display_ungrab (the_display);  
+
+  /* Done opening new display */
+  the_display->display_opening = FALSE;
+
+  return TRUE;
+}
+
+static void
+listify_func (gpointer key, gpointer value, gpointer data)
+{
+  GSList **listp;
+
+  listp = data;
+  *listp = g_slist_prepend (*listp, value);
+}
+
+static gint
+ptrcmp (gconstpointer a, gconstpointer b)
+{
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
+}
+
+GSList*
+meta_display_list_windows (MetaDisplay *display)
+{
+  GSList *winlist;
+  GSList *tmp;
+  GSList *prev;
+  
+  winlist = NULL;
+  g_hash_table_foreach (display->window_ids,
+                        listify_func,
+                        &winlist);
+
+  /* Uniquify the list, since both frame windows and plain
+   * windows are in the hash
+   */
+  winlist = g_slist_sort (winlist, ptrcmp);
+
+  prev = NULL;
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      GSList *next;
+
+      next = tmp->next;
+      
+      if (next &&
+          next->data == tmp->data)
+        {
+          /* Delete tmp from list */
+
+          if (prev)
+            prev->next = next;
+
+          if (tmp == winlist)
+            winlist = next;
+          
+          g_slist_free_1 (tmp);
+
+          /* leave prev unchanged */
+        }
+      else
+        {
+          prev = tmp;
+        }
+      
+      tmp = next;
+    }
+
+  return winlist;
+}
+
+void
+meta_display_close (MetaDisplay *display,
+                    guint32      timestamp)
+{
+  GSList *tmp;
+
+  g_assert (display != NULL);
+
+  if (display->closing != 0)
+    {
+      /* The display's already been closed. */
+      return;
+    }
+
+  if (display->error_traps > 0)
+    meta_bug ("Display closed with error traps pending\n");
+
+  display->closing += 1;
+
+  meta_prefs_remove_listener (prefs_changed_callback, display);
+  
+  meta_display_remove_autoraise_callback (display);
+
+  if (display->grab_old_window_stacking)
+    g_list_free (display->grab_old_window_stacking);
+  
+  /* Stop caring about events */
+  meta_ui_remove_event_func (display->xdisplay,
+                             event_callback,
+                             display);
+  
+  /* Free all screens */
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+      meta_screen_free (screen, timestamp);
+      tmp = tmp->next;
+    }
+
+  g_slist_free (display->screens);
+  display->screens = NULL;
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  if (display->sn_display)
+    {
+      sn_display_unref (display->sn_display);
+      display->sn_display = NULL;
+    }
+#endif
+  
+  /* Must be after all calls to meta_window_free() since they
+   * unregister windows
+   */
+  g_hash_table_destroy (display->window_ids);
+
+  if (display->leader_window != None)
+    XDestroyWindow (display->xdisplay, display->leader_window);
+
+  XFlush (display->xdisplay);
+
+  meta_display_free_window_prop_hooks (display);
+  meta_display_free_group_prop_hooks (display);
+  
+  g_free (display->name);
+
+  meta_display_shutdown_keys (display);
+
+  if (display->compositor)
+    meta_compositor_destroy (display->compositor);
+  
+  g_free (display);
+  display = NULL;
+
+  meta_quit (META_EXIT_SUCCESS);
+}
+
+MetaScreen*
+meta_display_screen_for_root (MetaDisplay *display,
+                              Window       xroot)
+{
+  GSList *tmp;
+
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+
+      if (xroot == screen->xroot)
+        return screen;
+
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+MetaScreen*
+meta_display_screen_for_xwindow (MetaDisplay *display,
+                                 Window       xwindow)
+{
+  XWindowAttributes attr;
+  int result;
+  
+  meta_error_trap_push (display);
+  attr.screen = NULL;
+  result = XGetWindowAttributes (display->xdisplay, xwindow, &attr);
+  meta_error_trap_pop (display, TRUE);
+
+  /* Note, XGetWindowAttributes is on all kinds of crack
+   * and returns 1 on success 0 on failure, rather than Success
+   * on success.
+   */
+  if (result == 0 || attr.screen == NULL)
+    return NULL;
+  
+  return meta_display_screen_for_x_screen (display, attr.screen);
+}
+
+MetaScreen*
+meta_display_screen_for_x_screen (MetaDisplay *display,
+                                  Screen      *xscreen)
+{
+  GSList *tmp;
+
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+
+      if (xscreen == screen->xscreen)
+        return screen;
+
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+/* Grab/ungrab routines taken from fvwm */
+void
+meta_display_grab (MetaDisplay *display)
+{
+  if (display->server_grab_count == 0)
+    {
+      XGrabServer (display->xdisplay);
+    }
+  display->server_grab_count += 1;
+  meta_verbose ("Grabbing display, grab count now %d\n",
+                display->server_grab_count);
+}
+
+void
+meta_display_ungrab (MetaDisplay *display)
+{
+  if (display->server_grab_count == 0)
+    meta_bug ("Ungrabbed non-grabbed server\n");
+  
+  display->server_grab_count -= 1;
+  if (display->server_grab_count == 0)
+    {
+      /* FIXME we want to purge all pending "queued" stuff
+       * at this point, such as window hide/show
+       */
+      XUngrabServer (display->xdisplay);
+      XFlush (display->xdisplay);
+    }
+
+  meta_verbose ("Ungrabbing display, grab count now %d\n",
+                display->server_grab_count);
+}
+
+/**
+ * Returns the singleton MetaDisplay if "xdisplay" matches the X display it's
+ * managing; otherwise gives a warning and returns NULL.  When we were claiming
+ * to be able to manage multiple displays, this was supposed to find the
+ * display out of the list which matched that display.  Now it's merely an
+ * extra sanity check.
+ *
+ * \param xdisplay  An X display
+ * \return  The singleton X display, or NULL if "xdisplay" isn't the one
+ *          we're managing.
+ */
+MetaDisplay*
+meta_display_for_x_display (Display *xdisplay)
+{
+  if (the_display->xdisplay == xdisplay)
+    return the_display;
+
+  meta_warning ("Could not find display for X display %p, probably going to crash\n",
+                xdisplay);
+  
+  return NULL;
+}
+
+/**
+ * Accessor for the singleton MetaDisplay.
+ *
+ * \return  The only MetaDisplay there is.  This can be NULL, but only
+ *          during startup.
+ */
+MetaDisplay*
+meta_get_display (void)
+{
+  return the_display;
+}
+
+#ifdef WITH_VERBOSE_MODE
+static gboolean dump_events = TRUE;
+#endif
+
+static gboolean
+grab_op_is_mouse_only (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:      
+    case META_GRAB_OP_RESIZING_SW:      
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+static gboolean
+grab_op_is_mouse (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:      
+    case META_GRAB_OP_RESIZING_SW:      
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_MOVING:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+static gboolean
+grab_op_is_keyboard (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_KEYBOARD_MOVING:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+    case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+    case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+    case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+    case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+    case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+    case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+gboolean
+meta_grab_op_is_resizing (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:      
+    case META_GRAB_OP_RESIZING_SW:      
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+gboolean
+meta_grab_op_is_moving (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_KEYBOARD_MOVING:
+      return TRUE;
+      
+    default:
+      return FALSE;
+    }
+}
+
+/* Get time of current event, or CurrentTime if none. */
+guint32
+meta_display_get_current_time (MetaDisplay *display)
+{
+  return display->current_time;
+}
+
+/* Get a timestamp, even if it means a roundtrip */
+guint32
+meta_display_get_current_time_roundtrip (MetaDisplay *display)
+{
+  guint32 timestamp;
+  
+  timestamp = meta_display_get_current_time (display);
+  if (timestamp == CurrentTime)
+    {
+      XEvent property_event;
+
+      /* Using the property XA_PRIMARY because it's safe; nothing
+       * would use it as a property. The type doesn't matter.
+       */
+      XChangeProperty (display->xdisplay,
+                       display->timestamp_pinging_window,
+                       XA_PRIMARY, XA_STRING, 8,
+                       PropModeAppend, NULL, 0);
+      XWindowEvent (display->xdisplay,
+                    display->timestamp_pinging_window,
+                    PropertyChangeMask,
+                    &property_event);
+      timestamp = property_event.xproperty.time;
+    }
+
+  sanity_check_timestamps (display, timestamp);
+
+  return timestamp;
+}
+
+static void
+add_ignored_serial (MetaDisplay  *display,
+                    unsigned long serial)
+{
+  int i;
+
+  /* don't add the same serial more than once */
+  if (display->ignored_serials[N_IGNORED_SERIALS-1] == serial)
+    return;
+  
+  /* shift serials to the left */
+  i = 0;
+  while (i < (N_IGNORED_SERIALS - 1))
+    {
+      display->ignored_serials[i] = display->ignored_serials[i+1];
+      ++i;
+    }
+  /* put new one on the end */
+  display->ignored_serials[i] = serial;
+}
+
+static gboolean
+serial_is_ignored (MetaDisplay  *display,
+                   unsigned long serial)
+{
+  int i;
+
+  i = 0;
+  while (i < N_IGNORED_SERIALS)
+    {
+      if (display->ignored_serials[i] == serial)
+        return TRUE;
+      ++i;
+    }
+  return FALSE;
+}
+
+static void
+reset_ignores (MetaDisplay *display)
+{
+  int i;
+
+  i = 0;
+  while (i < N_IGNORED_SERIALS)
+    {
+      display->ignored_serials[i] = 0;
+      ++i;
+    }
+
+  display->ungrab_should_not_cause_focus_window = None;
+}
+
+static gboolean 
+window_raise_with_delay_callback (void *data)
+{
+  MetaWindow *window;
+  MetaAutoRaiseData *auto_raise;
+
+  auto_raise = data;
+
+  meta_topic (META_DEBUG_FOCUS, 
+	      "In autoraise callback for window 0x%lx\n", 
+	      auto_raise->xwindow);
+
+  auto_raise->display->autoraise_timeout_id = 0;
+  auto_raise->display->autoraise_window = NULL;
+
+  window  = meta_display_lookup_x_window (auto_raise->display, 
+					  auto_raise->xwindow);
+  
+  if (window == NULL) 
+    return FALSE;
+
+  /* If we aren't already on top, check whether the pointer is inside
+   * the window and raise the window if so.
+   */      
+  if (meta_stack_get_top (window->screen->stack) != window) 
+    {
+      int x, y, root_x, root_y;
+      Window root, child;
+      unsigned int mask;
+      gboolean same_screen;
+      gboolean point_in_window;
+
+      meta_error_trap_push (window->display);
+      same_screen = XQueryPointer (window->display->xdisplay,
+				   window->xwindow,
+				   &root, &child,
+				   &root_x, &root_y, &x, &y, &mask);
+      meta_error_trap_pop (window->display, TRUE);
+
+      point_in_window = 
+        (window->frame && POINT_IN_RECT (root_x, root_y, window->frame->rect)) ||
+        (window->frame == NULL && POINT_IN_RECT (root_x, root_y, window->rect));
+      if (same_screen && point_in_window)
+	meta_window_raise (window);
+      else
+	meta_topic (META_DEBUG_FOCUS, 
+		    "Pointer not inside window, not raising %s\n", 
+		    window->desc);
+    }
+
+  return FALSE;
+}
+
+void
+meta_display_queue_autoraise_callback (MetaDisplay *display,
+                                       MetaWindow  *window)
+{
+  MetaAutoRaiseData *auto_raise_data;
+
+  meta_topic (META_DEBUG_FOCUS, 
+              "Queuing an autoraise timeout for %s with delay %d\n", 
+              window->desc, 
+              meta_prefs_get_auto_raise_delay ());
+  
+  auto_raise_data = g_new (MetaAutoRaiseData, 1);
+  auto_raise_data->display = window->display;
+  auto_raise_data->xwindow = window->xwindow;
+  
+  if (display->autoraise_timeout_id != 0)
+    g_source_remove (display->autoraise_timeout_id);
+
+  display->autoraise_timeout_id = 
+    g_timeout_add_full (G_PRIORITY_DEFAULT,
+                        meta_prefs_get_auto_raise_delay (),
+                        window_raise_with_delay_callback,
+                        auto_raise_data,
+                        g_free);
+  display->autoraise_window = window;
+}
+
+#if 0
+static void
+handle_net_restack_window (MetaDisplay* display,
+                           XEvent *event)
+{
+  MetaWindow *window;
+
+  window = meta_display_lookup_x_window (display,
+                                         event->xclient.window);
+
+  if (window)
+    {
+      /* FIXME: The EWMH includes a sibling for the restack request, but we
+       * (stupidly) don't currently support these types of raises.
+       *
+       * Also, unconditionally following these is REALLY stupid--we should
+       * combine this code with the stuff in
+       * meta_window_configure_request() which is smart about whether to
+       * follow the request or do something else (though not smart enough
+       * and is also too stupid to handle the sibling stuff).
+       */
+      switch (event->xclient.data.l[2])
+        {
+        case Above:
+          meta_window_raise (window);
+          break;
+        case Below:
+          meta_window_lower (window);
+          break;
+        case TopIf:
+        case BottomIf:
+        case Opposite:
+          break;          
+        }
+    }
+}
+#endif
+
+/* We do some of our event handling in core/frames.c, which expects
+ * GDK events delivered by GTK+.  However, since the transition to
+ * client side windows, we can't let GDK see button events, since the
+ * client-side tracking of implicit and explicit grabs it does will
+ * get confused by our direct use of X grabs.
+ *
+ * So we do a very minimal GDK => GTK event conversion here and send on the
+ * events we care about, and then filter them out so they don't go
+ * through the normal GDK event handling.
+ *
+ * To reduce the amount of code, the only events fields filled out
+ * below are the ones that frames.c uses. If frames.c is modified to
+ * use more fields, more fields need to be filled out below.
+ * 
+ * https://github.com/stefano-k/Mate-Desktop-Environment/commit/b0e5fb03eb21dae8f02692f11ef391bfc5ccba33
+ */
+
+static gboolean maybe_send_event_to_gtk(MetaDisplay* display, XEvent* xevent)
+{
+	/* We're always using the default display */
+	GdkDisplay* gdk_display = gdk_display_get_default();
+	GdkEvent gdk_event;
+	GdkWindow* gdk_window;
+	Window window;
+
+	switch (xevent->type)
+	{
+		case ButtonPress:
+		case ButtonRelease:
+			window = xevent->xbutton.window;
+			break;
+
+		case MotionNotify:
+			window = xevent->xmotion.window;
+			break;
+
+		case EnterNotify:
+
+		case LeaveNotify:
+			window = xevent->xcrossing.window;
+			break;
+
+		default:
+			return FALSE;
+	}
+
+	gdk_window = gdk_window_lookup_for_display(gdk_display, window);
+
+	if (gdk_window == NULL)
+	{
+		return FALSE;
+	}
+
+	/* If GDK already things it has a grab, we better let it see events; this
+	 * is the menu-navigation case and events need to get sent to the appropriate
+	 * (client-side) subwindow for individual menu items.
+	 */
+
+	if (gdk_display_pointer_is_grabbed(gdk_display))
+	{
+		return FALSE;
+	}
+
+	memset(&gdk_event, 0, sizeof(gdk_event));
+
+	switch (xevent->type)
+	{
+
+		case ButtonPress:
+
+		case ButtonRelease:
+
+			if (xevent->type == ButtonPress)
+			{
+				GtkSettings* settings = gtk_settings_get_default();
+
+				int double_click_time;
+				int double_click_distance;
+
+				g_object_get (settings,
+					"gtk-double-click-time", &double_click_time,
+					"gtk-double-click-distance", &double_click_distance,
+					NULL);
+
+				if (xevent->xbutton.button == display->button_click_number &&
+					xevent->xbutton.window == display->button_click_window &&
+					xevent->xbutton.time < display->button_click_time + double_click_time &&
+					ABS(xevent->xbutton.x - display->button_click_x) <= double_click_distance &&
+					ABS (xevent->xbutton.y - display->button_click_y) <= double_click_distance)
+				{
+
+					gdk_event.button.type = GDK_2BUTTON_PRESS;
+					display->button_click_number = 0;
+				}
+				else
+				{
+					gdk_event.button.type = GDK_BUTTON_PRESS;
+					display->button_click_number = xevent->xbutton.button;
+					display->button_click_window = xevent->xbutton.window;
+					display->button_click_time = xevent->xbutton.time;
+					display->button_click_x = xevent->xbutton.x;
+					display->button_click_y = xevent->xbutton.y;
+				}
+			}
+			else
+			{
+				gdk_event.button.type = GDK_BUTTON_RELEASE;
+			}
+
+			gdk_event.button.window = gdk_window;
+			gdk_event.button.button = xevent->xbutton.button;
+			gdk_event.button.time = xevent->xbutton.time;
+			gdk_event.button.x = xevent->xbutton.x;
+			gdk_event.button.y = xevent->xbutton.y;
+			gdk_event.button.x_root = xevent->xbutton.x_root;
+			gdk_event.button.y_root = xevent->xbutton.y_root;
+
+			break;
+
+		case MotionNotify:
+			gdk_event.motion.type = GDK_MOTION_NOTIFY;
+			gdk_event.motion.window = gdk_window;
+			break;
+
+		case EnterNotify:
+
+		case LeaveNotify:
+			gdk_event.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
+			gdk_event.crossing.window = gdk_window;
+			gdk_event.crossing.x = xevent->xcrossing.x;
+			gdk_event.crossing.y = xevent->xcrossing.y;
+			break;
+
+		default:
+			g_assert_not_reached();
+			break;
+	}
+
+	/* If we've gotten here, we've filled in the gdk_event and should send it on */
+	gtk_main_do_event(&gdk_event);
+	return TRUE;
+}
+
+/**
+ * This is the most important function in the whole program. It is the heart,
+ * it is the nexus, it is the Grand Central Station of Marco's world.
+ * When we create a MetaDisplay, we ask GDK to pass *all* events for *all*
+ * windows to this function. So every time anything happens that we might
+ * want to know about, this function gets called. You see why it gets a bit
+ * busy around here. Most of this function is a ginormous switch statement
+ * dealing with all the kinds of events that might turn up.
+ *
+ * \param event The event that just happened
+ * \param data  The MetaDisplay that events are coming from, cast to a gpointer
+ *              so that it can be sent to a callback
+ *
+ * \ingroup main
+ */
+static gboolean event_callback(XEvent* event, gpointer data)
+{
+  MetaWindow *window;
+  MetaWindow *property_for_window;
+  MetaDisplay *display;
+  Window modified;
+  gboolean frame_was_receiver;
+  gboolean filter_out_event;
+
+  display = data;
+  
+#ifdef WITH_VERBOSE_MODE
+  if (dump_events)
+    meta_spew_event (display, event);
+#endif
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  sn_display_process_event (display->sn_display, event);
+#endif
+  
+  filter_out_event = FALSE;
+  display->current_time = event_get_time (display, event);
+  display->xinerama_cache_invalidated = TRUE;
+  
+  modified = event_get_modified_window (display, event);
+  
+  if (event->type == ButtonPress)
+    {
+      /* filter out scrollwheel */
+      if (event->xbutton.button == 4 ||
+	  event->xbutton.button == 5)
+	return FALSE;
+    }
+  else if (event->type == UnmapNotify)
+    {
+      if (meta_ui_window_should_not_cause_focus (display->xdisplay,
+                                                 modified))
+        {
+          add_ignored_serial (display, event->xany.serial);
+          meta_topic (META_DEBUG_FOCUS,
+                      "Adding EnterNotify serial %lu to ignored focus serials\n",
+                      event->xany.serial);
+        }
+    }
+  else if (event->type == LeaveNotify &&
+           event->xcrossing.mode == NotifyUngrab &&
+           modified == display->ungrab_should_not_cause_focus_window)
+    {
+      add_ignored_serial (display, event->xany.serial);
+      meta_topic (META_DEBUG_FOCUS,
+                  "Adding LeaveNotify serial %lu to ignored focus serials\n",
+                  event->xany.serial);
+    }
+
+  if (modified != None)
+    window = meta_display_lookup_x_window (display, modified);
+  else
+    window = NULL;
+
+  /* We only want to respond to _NET_WM_USER_TIME property notify
+   * events on _NET_WM_USER_TIME_WINDOW windows; in particular,
+   * responding to UnmapNotify events is kind of bad.
+   */
+  property_for_window = NULL;
+  if (window && modified == window->user_time_window)
+    {
+      property_for_window = window;
+      window = NULL;
+    }
+    
+
+  frame_was_receiver = FALSE;
+  if (window &&
+      window->frame &&
+      modified == window->frame->xwindow)
+    {
+      /* Note that if the frame and the client both have an
+       * XGrabButton (as is normal with our setup), the event
+       * goes to the frame.
+       */
+      frame_was_receiver = TRUE;
+      meta_topic (META_DEBUG_EVENTS, "Frame was receiver of event for %s\n",
+                  window->desc);
+    }
+
+#ifdef HAVE_XSYNC
+  if (META_DISPLAY_HAS_XSYNC (display) && 
+      event->type == (display->xsync_event_base + XSyncAlarmNotify) &&
+      ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_sync_request_alarm)
+    {
+      filter_out_event = TRUE; /* GTK doesn't want to see this really */
+      
+      if (display->grab_op != META_GRAB_OP_NONE &&
+          display->grab_window != NULL &&
+          grab_op_is_mouse (display->grab_op))
+	meta_window_handle_mouse_grab_op_event (display->grab_window, event);
+    }
+#endif /* HAVE_XSYNC */
+
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display) && 
+      event->type == (display->shape_event_base + ShapeNotify))
+    {
+      filter_out_event = TRUE; /* GTK doesn't want to see this really */
+      
+      if (window && !frame_was_receiver)
+        {
+          XShapeEvent *sev = (XShapeEvent*) event;
+
+          if (sev->kind == ShapeBounding)
+            {
+              if (sev->shaped && !window->has_shape)
+                {
+                  window->has_shape = TRUE;                  
+                  meta_topic (META_DEBUG_SHAPES,
+                              "Window %s now has a shape\n",
+                              window->desc);
+                }
+              else if (!sev->shaped && window->has_shape)
+                {
+                  window->has_shape = FALSE;
+                  meta_topic (META_DEBUG_SHAPES,
+                              "Window %s no longer has a shape\n",
+                              window->desc);
+                }
+              else
+                {
+                  meta_topic (META_DEBUG_SHAPES,
+                              "Window %s shape changed\n",
+                              window->desc);
+                }
+
+              if (window->frame)
+                {
+                  window->frame->need_reapply_frame_shape = TRUE;
+		  meta_warning("from event callback\n");		  
+                  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+                }
+            }
+        }
+      else
+        {
+          meta_topic (META_DEBUG_SHAPES,
+                      "ShapeNotify not on a client window (window %s frame_was_receiver = %d)\n",
+                      window ? window->desc : "(none)",
+                      frame_was_receiver);
+        }
+    }
+#endif /* HAVE_SHAPE */
+
+  if (window && ((event->type == KeyPress) || (event->type == ButtonPress)))
+    {
+      if (CurrentTime == display->current_time)
+        {
+          /* We can't use missing (i.e. invalid) timestamps to set user time,
+           * nor do we want to use them to sanity check other timestamps.
+           * See bug 313490 for more details.
+           */
+          meta_warning ("Event has no timestamp! You may be using a broken "
+                        "program such as xse.  Please ask the authors of that "
+                        "program to fix it.\n");
+        }
+      else
+        {
+          meta_window_set_user_time (window, display->current_time);
+          sanity_check_timestamps (display, display->current_time);
+        }
+    }
+  
+  switch (event->type)
+    {
+    case KeyPress:
+    case KeyRelease:
+      meta_display_process_key_event (display, window, event);
+      break;
+    case ButtonPress:
+      if ((window &&
+           grab_op_is_mouse (display->grab_op) &&
+           display->grab_button != (int) event->xbutton.button &&
+           display->grab_window == window) ||
+          grab_op_is_keyboard (display->grab_op))
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Ending grab op %u on window %s due to button press\n",
+                      display->grab_op,
+                      (display->grab_window ?
+                       display->grab_window->desc : 
+                       "none"));
+          if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
+            {
+              MetaScreen *screen;
+              meta_topic (META_DEBUG_WINDOW_OPS, 
+                          "Syncing to old stack positions.\n");
+              screen = 
+                meta_display_screen_for_root (display, event->xany.window);
+
+              if (screen!=NULL)
+                meta_stack_set_positions (screen->stack,
+                                          display->grab_old_window_stacking);
+            }
+          meta_display_end_grab_op (display,
+                                    event->xbutton.time);
+        }
+      else if (window && display->grab_op == META_GRAB_OP_NONE)
+        {
+          gboolean begin_move = FALSE;
+          unsigned int grab_mask;
+          gboolean unmodified;
+
+          grab_mask = display->window_grab_modifiers;
+          if (g_getenv ("MARCO_DEBUG_BUTTON_GRABS"))
+            grab_mask |= ControlMask;
+
+          /* Two possible sources of an unmodified event; one is a
+           * client that's letting button presses pass through to the
+           * frame, the other is our focus_window_grab on unmodified
+           * button 1.  So for all such events we focus the window.
+           */
+          unmodified = (event->xbutton.state & grab_mask) == 0;
+          
+          if (unmodified ||
+              event->xbutton.button == 1)
+            {
+              /* don't focus if frame received, will be lowered in
+               * frames.c or special-cased if the click was on a
+               * minimize/close button.
+               */
+              if (!frame_was_receiver)
+                {
+                  if (meta_prefs_get_raise_on_click ()) 
+                    meta_window_raise (window);
+                  else
+                    meta_topic (META_DEBUG_FOCUS,
+                                "Not raising window on click due to don't-raise-on-click option\n");
+
+                  /* Don't focus panels--they must explicitly request focus.
+                   * See bug 160470
+                   */
+		  if (window->type != META_WINDOW_DOCK)
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Focusing %s due to unmodified button %u press (display.c)\n",
+                                  window->desc, event->xbutton.button);
+                      meta_window_focus (window, event->xbutton.time);
+                    }
+                  else
+                    /* However, do allow terminals to lose focus due to new
+                     * window mappings after the user clicks on a panel.
+                     */
+                    display->allow_terminal_deactivation = TRUE;
+                }
+              
+              /* you can move on alt-click but not on
+               * the click-to-focus
+               */
+              if (!unmodified)
+                begin_move = TRUE;
+            }
+          else if (!unmodified && event->xbutton.button == meta_prefs_get_mouse_button_resize())
+            {
+              if (window->has_resize_func)
+                {
+                  gboolean north, south;
+                  gboolean west, east;
+                  int root_x, root_y;
+                  MetaGrabOp op;
+
+                  meta_window_get_position (window, &root_x, &root_y);
+
+                  west = event->xbutton.x_root <  (root_x + 1 * window->rect.width  / 3);
+                  east = event->xbutton.x_root >  (root_x + 2 * window->rect.width  / 3);
+                  north = event->xbutton.y_root < (root_y + 1 * window->rect.height / 3);
+                  south = event->xbutton.y_root > (root_y + 2 * window->rect.height / 3);
+
+                  if (north && west)
+                    op = META_GRAB_OP_RESIZING_NW;
+                  else if (north && east)
+                    op = META_GRAB_OP_RESIZING_NE;
+                  else if (south && west)
+                    op = META_GRAB_OP_RESIZING_SW;
+                  else if (south && east)
+                    op = META_GRAB_OP_RESIZING_SE;
+                  else if (north)
+                    op = META_GRAB_OP_RESIZING_N;
+                  else if (west)
+                    op = META_GRAB_OP_RESIZING_W;
+                  else if (east)
+                    op = META_GRAB_OP_RESIZING_E;
+                  else if (south)
+                    op = META_GRAB_OP_RESIZING_S;
+                  else /* Middle region is no-op to avoid user triggering wrong action */
+                    op = META_GRAB_OP_NONE;
+                  
+                  if (op != META_GRAB_OP_NONE)
+                    meta_display_begin_grab_op (display,
+                                                window->screen,
+                                                window,
+                                                op,
+                                                TRUE,
+                                                FALSE,
+                                                event->xbutton.button,
+                                                0,
+                                                event->xbutton.time,
+                                                event->xbutton.x_root,
+                                                event->xbutton.y_root);
+                }
+            }
+          else if (event->xbutton.button == meta_prefs_get_mouse_button_menu())
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_show_menu (window,
+                                     event->xbutton.x_root,
+                                     event->xbutton.y_root,
+                                     event->xbutton.button,
+                                     event->xbutton.time);
+            }
+
+          if (!frame_was_receiver && unmodified)
+            {
+              /* This is from our synchronous grab since
+               * it has no modifiers and was on the client window
+               */
+              int mode;
+              
+              /* When clicking a different app in click-to-focus
+               * in application-based mode, and the different
+               * app is not a dock or desktop, eat the focus click.
+               */
+              if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+                  meta_prefs_get_application_based () &&
+                  !window->has_focus &&
+                  window->type != META_WINDOW_DOCK &&
+                  window->type != META_WINDOW_DESKTOP &&
+                  (display->focus_window == NULL ||
+                   !meta_window_same_application (window,
+                                                  display->focus_window)))
+                mode = AsyncPointer; /* eat focus click */
+              else
+                mode = ReplayPointer; /* give event back */
+
+              meta_verbose ("Allowing events mode %s time %u\n",
+                            mode == AsyncPointer ? "AsyncPointer" : "ReplayPointer",
+                            (unsigned int)event->xbutton.time);
+              
+              XAllowEvents (display->xdisplay,
+                            mode, event->xbutton.time);
+            }
+
+          if (begin_move && window->has_move_func)
+            {
+              meta_display_begin_grab_op (display,
+                                          window->screen,
+                                          window,
+                                          META_GRAB_OP_MOVING,
+                                          TRUE,
+                                          FALSE,
+                                          event->xbutton.button,
+                                          0,
+                                          event->xbutton.time,
+                                          event->xbutton.x_root,
+                                          event->xbutton.y_root);
+            }
+        }
+      break;
+    case ButtonRelease:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_event (window, event);
+      break;
+    case MotionNotify:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_event (window, event);
+      break;
+    case EnterNotify:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        {
+          meta_window_handle_mouse_grab_op_event (window, event);
+          break;
+        }
+
+      /* If the mouse switches screens, active the default window on the new
+       * screen; this will make keybindings and workspace-launched items
+       * actually appear on the right screen.
+       */
+      {
+        MetaScreen *new_screen = 
+          meta_display_screen_for_root (display, event->xcrossing.root);
+
+        if (new_screen != NULL && display->active_screen != new_screen)
+          meta_workspace_focus_default_window (new_screen->active_workspace, 
+                                               NULL,
+                                               event->xcrossing.time);
+      }
+
+      /* Check if we've entered a window; do this even if window->has_focus to
+       * avoid races.
+       */
+      if (window && !serial_is_ignored (display, event->xany.serial) &&
+               event->xcrossing.mode != NotifyGrab && 
+               event->xcrossing.mode != NotifyUngrab &&
+               event->xcrossing.detail != NotifyInferior &&
+               meta_display_focus_sentinel_clear (display))
+        {
+          switch (meta_prefs_get_focus_mode ())
+            {
+            case META_FOCUS_MODE_SLOPPY:
+            case META_FOCUS_MODE_MOUSE:
+              display->mouse_mode = TRUE;
+              if (window->type != META_WINDOW_DOCK &&
+                  window->type != META_WINDOW_DESKTOP)
+                {
+                  meta_topic (META_DEBUG_FOCUS,
+                              "Focusing %s due to enter notify with serial %lu "
+                              "at time %lu, and setting display->mouse_mode to "
+                              "TRUE.\n",
+                              window->desc, 
+                              event->xany.serial,
+                              event->xcrossing.time);
+
+                  meta_window_focus (window, event->xcrossing.time);
+
+                  /* stop ignoring stuff */
+                  reset_ignores (display);
+                  
+                  if (meta_prefs_get_auto_raise ()) 
+                    {
+                      meta_display_queue_autoraise_callback (display, window);
+                    }
+                  else
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Auto raise is disabled\n");		      
+                    }
+                }
+              /* In mouse focus mode, we defocus when the mouse *enters*
+               * the DESKTOP window, instead of defocusing on LeaveNotify.
+               * This is because having the mouse enter override-redirect
+               * child windows unfortunately causes LeaveNotify events that
+               * we can't distinguish from the mouse actually leaving the
+               * toplevel window as we expect.  But, since we filter out
+               * EnterNotify events on override-redirect windows, this
+               * alternative mechanism works great.
+               */
+              if (window->type == META_WINDOW_DESKTOP &&
+                  meta_prefs_get_focus_mode() == META_FOCUS_MODE_MOUSE &&
+                  display->expected_focus_window != NULL)
+                {
+                  meta_topic (META_DEBUG_FOCUS,
+                              "Unsetting focus from %s due to mouse entering "
+                              "the DESKTOP window\n",
+                              display->expected_focus_window->desc);
+                  meta_display_focus_the_no_focus_window (display, 
+                                                          window->screen,
+                                                          event->xcrossing.time);
+                }
+              break;
+            case META_FOCUS_MODE_CLICK:
+              break;
+            }
+          
+          if (window->type == META_WINDOW_DOCK)
+            meta_window_raise (window);
+        }
+      break;
+    case LeaveNotify:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_event (window, event);
+      else if (window != NULL)
+        {
+          if (window->type == META_WINDOW_DOCK &&
+              event->xcrossing.mode != NotifyGrab &&
+              event->xcrossing.mode != NotifyUngrab &&
+              !window->has_focus)
+            meta_window_lower (window);
+        }
+      break;
+    case FocusIn:
+    case FocusOut:
+      if (window)
+        {
+          meta_window_notify_focus (window, event);
+        }
+      else if (meta_display_xwindow_is_a_no_focus_window (display,
+                                                          event->xany.window))
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focus %s event received on no_focus_window 0x%lx "
+                      "mode %s detail %s\n",
+                      event->type == FocusIn ? "in" :
+                      event->type == FocusOut ? "out" :
+                      "???",
+                      event->xany.window,
+                      meta_event_mode_to_string (event->xfocus.mode),
+                      meta_event_detail_to_string (event->xfocus.detail));
+        }
+      else
+        {
+          MetaScreen *screen =
+                meta_display_screen_for_root(display,
+                                             event->xany.window);
+          if (screen == NULL)
+            break;
+
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focus %s event received on root window 0x%lx "
+                      "mode %s detail %s\n",
+                      event->type == FocusIn ? "in" :
+                      event->type == FocusOut ? "out" :
+                      "???",
+                      event->xany.window,
+                      meta_event_mode_to_string (event->xfocus.mode),
+                      meta_event_detail_to_string (event->xfocus.detail));
+          
+          if (event->type == FocusIn &&
+              event->xfocus.detail == NotifyDetailNone)
+            {
+              meta_topic (META_DEBUG_FOCUS, 
+                          "Focus got set to None, probably due to "
+                          "brain-damage in the X protocol (see bug "
+                          "125492).  Setting the default focus window.\n");
+              meta_workspace_focus_default_window (screen->active_workspace,
+                                                   NULL,
+                                                   meta_display_get_current_time_roundtrip (display));
+            }
+          else if (event->type == FocusIn &&
+              event->xfocus.mode == NotifyNormal &&
+              event->xfocus.detail == NotifyInferior)
+            {
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focus got set to root window, probably due to "
+                          "mate-session logout dialog usage (see bug "
+                          "153220).  Setting the default focus window.\n");
+              meta_workspace_focus_default_window (screen->active_workspace,
+                                                   NULL,
+                                                   meta_display_get_current_time_roundtrip (display));
+            }
+
+        }
+      break;
+    case KeymapNotify:
+      break;
+    case Expose:
+      break;
+    case GraphicsExpose:
+      break;
+    case NoExpose:
+      break;
+    case VisibilityNotify:
+      break;
+    case CreateNotify:
+      break;
+      
+    case DestroyNotify:
+      if (window)
+        {
+          /* FIXME: It sucks that DestroyNotify events don't come with
+           * a timestamp; could we do something better here?  Maybe X
+           * will change one day?
+           */
+          guint32 timestamp;
+          timestamp = meta_display_get_current_time_roundtrip (display);
+
+          if (display->grab_op != META_GRAB_OP_NONE &&
+              display->grab_window == window)
+            meta_display_end_grab_op (display, timestamp);
+          
+          if (frame_was_receiver)
+            {
+              meta_warning ("Unexpected destruction of frame 0x%lx, not sure if this should silently fail or be considered a bug\n",
+                            window->frame->xwindow);
+              meta_error_trap_push (display);
+              meta_window_destroy_frame (window->frame->window);
+              meta_error_trap_pop (display, FALSE);
+            }
+          else
+            {
+              /* Unmanage destroyed window */
+              meta_window_free (window, timestamp);
+              window = NULL;
+            }
+        }
+      break;
+    case UnmapNotify:
+      if (window)
+        {
+          /* FIXME: It sucks that UnmapNotify events don't come with
+           * a timestamp; could we do something better here?  Maybe X
+           * will change one day?
+           */
+          guint32 timestamp;
+          timestamp = meta_display_get_current_time_roundtrip (display);
+
+          if (display->grab_op != META_GRAB_OP_NONE &&
+              display->grab_window == window &&
+              ((window->frame == NULL) || !window->frame->mapped))
+            meta_display_end_grab_op (display, timestamp);
+      
+          if (!frame_was_receiver)
+            {
+              if (window->unmaps_pending == 0)
+                {
+                  meta_topic (META_DEBUG_WINDOW_STATE,
+                              "Window %s withdrawn\n",
+                              window->desc);
+
+                  meta_effect_run_close (window, NULL, NULL);
+
+                  /* Unmanage withdrawn window */		  
+                  window->withdrawn = TRUE;
+                  meta_window_free (window, timestamp);
+                  window = NULL;
+                }
+              else
+                {
+                  window->unmaps_pending -= 1;
+                  meta_topic (META_DEBUG_WINDOW_STATE,
+                              "Received pending unmap, %d now pending\n",
+                              window->unmaps_pending);
+                }
+            }
+
+          /* Unfocus on UnmapNotify, do this after the possible
+           * window_free above so that window_free can see if window->has_focus
+           * and move focus to another window
+           */
+          if (window)
+            meta_window_notify_focus (window, event);
+        }
+      break;
+    case MapNotify:
+      break;
+    case MapRequest:
+      if (window == NULL)
+        {
+          window = meta_window_new (display, event->xmaprequest.window,
+                                    FALSE);
+        }
+      /* if frame was receiver it's some malicious send event or something */
+      else if (!frame_was_receiver && window)        
+        {
+          meta_verbose ("MapRequest on %s mapped = %d minimized = %d\n",
+                        window->desc, window->mapped, window->minimized);
+          if (window->minimized)
+            {
+              meta_window_unminimize (window);
+              if (window->workspace != window->screen->active_workspace)
+                {
+                  meta_verbose ("Changing workspace due to MapRequest mapped = %d minimized = %d\n",
+                                window->mapped, window->minimized);
+                  meta_window_change_workspace (window,
+                                                window->screen->active_workspace);
+                }
+            }
+        }
+      break;
+    case ReparentNotify:
+      break;
+    case ConfigureNotify:
+      /* Handle screen resize */
+      {
+	MetaScreen *screen;
+
+        screen = meta_display_screen_for_root (display,
+                                               event->xconfigure.window);
+
+	if (screen != NULL)
+          {
+#ifdef HAVE_RANDR
+            /* do the resize the official way */
+            XRRUpdateConfiguration (event);
+#else
+            /* poke around in Xlib */
+            screen->xscreen->width   = event->xconfigure.width;
+            screen->xscreen->height  = event->xconfigure.height;
+#endif
+            
+            meta_screen_resize (screen, 
+                                event->xconfigure.width,
+                                event->xconfigure.height);
+          }
+      }
+      break;
+    case ConfigureRequest:
+      /* This comment and code is found in both twm and fvwm */
+      /*
+       * According to the July 27, 1988 ICCCM draft, we should ignore size and
+       * position fields in the WM_NORMAL_HINTS property when we map a window.
+       * Instead, we'll read the current geometry.  Therefore, we should respond
+       * to configuration requests for windows which have never been mapped.
+       */
+      if (window == NULL)
+        {
+          unsigned int xwcm;
+          XWindowChanges xwc;
+          
+          xwcm = event->xconfigurerequest.value_mask &
+            (CWX | CWY | CWWidth | CWHeight | CWBorderWidth);
+
+          xwc.x = event->xconfigurerequest.x;
+          xwc.y = event->xconfigurerequest.y;
+          xwc.width = event->xconfigurerequest.width;
+          xwc.height = event->xconfigurerequest.height;
+          xwc.border_width = event->xconfigurerequest.border_width;
+
+          meta_verbose ("Configuring withdrawn window to %d,%d %dx%d border %d (some values may not be in mask)\n",
+                        xwc.x, xwc.y, xwc.width, xwc.height, xwc.border_width);
+          meta_error_trap_push (display);
+          XConfigureWindow (display->xdisplay, event->xconfigurerequest.window,
+                            xwcm, &xwc);
+          meta_error_trap_pop (display, FALSE);
+        }
+      else
+        {
+          if (!frame_was_receiver)
+            meta_window_configure_request (window, event);
+        }
+      break;
+    case GravityNotify:
+      break;
+    case ResizeRequest:
+      break;
+    case CirculateNotify:
+      break;
+    case CirculateRequest:
+      break;
+    case PropertyNotify:
+      {
+        MetaGroup *group;
+        MetaScreen *screen;
+        
+        if (window && !frame_was_receiver)
+          meta_window_property_notify (window, event);
+        else if (property_for_window && !frame_was_receiver)
+          meta_window_property_notify (property_for_window, event);
+
+        group = meta_display_lookup_group (display,
+                                           event->xproperty.window);
+        if (group != NULL)
+          meta_group_property_notify (group, event);
+        
+        screen = NULL;
+        if (window == NULL &&
+            group == NULL) /* window/group != NULL means it wasn't a root window */
+          screen = meta_display_screen_for_root (display,
+                                                 event->xproperty.window);
+            
+        if (screen != NULL)
+          {
+            if (event->xproperty.atom ==
+                display->atom__NET_DESKTOP_LAYOUT)
+              meta_screen_update_workspace_layout (screen);
+            else if (event->xproperty.atom ==
+                     display->atom__NET_DESKTOP_NAMES)
+              meta_screen_update_workspace_names (screen);
+#if 0
+            else if (event->xproperty.atom ==
+                     display->atom__NET_RESTACK_WINDOW)
+              handle_net_restack_window (display, event);
+#endif
+
+            /* we just use this property as a sentinel to avoid
+             * certain race conditions.  See the comment for the
+             * sentinel_counter variable declaration in display.h
+	     */
+	    if (event->xproperty.atom ==
+		display->atom__MARCO_SENTINEL)
+	      {
+		meta_display_decrement_focus_sentinel (display);
+	      }
+          }
+      }
+      break;
+    case SelectionClear:
+      /* do this here instead of at end of function
+       * so we can return
+       */
+
+      /* FIXME: Clearing display->current_time here makes no sense to
+       * me; who put this here and why?
+       */
+      display->current_time = CurrentTime;
+
+      process_selection_clear (display, event);
+      /* Note that processing that may have resulted in
+       * closing the display... so return right away.
+       */
+      return FALSE;
+    case SelectionRequest:
+      process_selection_request (display, event);
+      break;
+    case SelectionNotify:
+      break;
+    case ColormapNotify:
+      if (window && !frame_was_receiver)
+        window->colormap = event->xcolormap.colormap;
+      break;
+    case ClientMessage:
+      if (window)
+        {
+          if (!frame_was_receiver)
+            meta_window_client_message (window, event);
+        }
+      else
+        {
+          MetaScreen *screen;
+
+          screen = meta_display_screen_for_root (display,
+                                                 event->xclient.window);
+          
+          if (screen)
+            {
+              if (event->xclient.message_type ==
+                  display->atom__NET_CURRENT_DESKTOP)
+                {
+                  int space;
+                  MetaWorkspace *workspace;
+                  guint32 time;
+              
+                  space = event->xclient.data.l[0];
+                  time = event->xclient.data.l[1];
+              
+                  meta_verbose ("Request to change current workspace to %d with "
+                                "specified timestamp of %u\n",
+                                space, time);
+
+                  workspace =
+                    meta_screen_get_workspace_by_index (screen,
+                                                        space);
+
+                  /* Handle clients using the older version of the spec... */
+                  if (time == 0 && workspace)
+                    {
+                      meta_warning ("Received a NET_CURRENT_DESKTOP message "
+                                    "from a broken (outdated) client who sent "
+                                    "a 0 timestamp\n");
+                      time = meta_display_get_current_time_roundtrip (display);
+                    }
+
+                  if (workspace)
+                    meta_workspace_activate (workspace, time);
+                  else
+                    meta_verbose ("Don't know about workspace %d\n", space);
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__NET_NUMBER_OF_DESKTOPS)
+                {
+                  int num_spaces;
+              
+                  num_spaces = event->xclient.data.l[0];
+              
+                  meta_verbose ("Request to set number of workspaces to %d\n",
+                                num_spaces);
+
+                  meta_prefs_set_num_workspaces (num_spaces);
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__NET_SHOWING_DESKTOP)
+                {
+                  gboolean showing_desktop;
+                  guint32  timestamp;
+                  
+                  showing_desktop = event->xclient.data.l[0] != 0;
+                  /* FIXME: Braindead protocol doesn't have a timestamp */
+                  timestamp = meta_display_get_current_time_roundtrip (display);
+                  meta_verbose ("Request to %s desktop\n",
+                                showing_desktop ? "show" : "hide");
+                  
+                  if (showing_desktop)
+                    meta_screen_show_desktop (screen, timestamp);
+                  else
+                    {
+                      meta_screen_unshow_desktop (screen);
+                      meta_workspace_focus_default_window (screen->active_workspace, NULL, timestamp);
+                    }
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_RESTART_MESSAGE)
+                {
+                  meta_verbose ("Received restart request\n");
+                  meta_restart ();
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_RELOAD_THEME_MESSAGE)
+                {
+                  meta_verbose ("Received reload theme request\n");
+                  meta_ui_set_current_theme (meta_prefs_get_theme (),
+                                             TRUE);
+                  meta_display_retheme_all ();
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_SET_KEYBINDINGS_MESSAGE)
+                {
+                  meta_verbose ("Received set keybindings request = %d\n",
+                                (int) event->xclient.data.l[0]);
+                  meta_set_keybindings_disabled (!event->xclient.data.l[0]);
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_TOGGLE_VERBOSE)
+                {
+                  meta_verbose ("Received toggle verbose message\n");
+                  meta_set_verbose (!meta_is_verbose ());
+                }
+	      else if (event->xclient.message_type ==
+		       display->atom_WM_PROTOCOLS) 
+		{
+                  meta_verbose ("Received WM_PROTOCOLS message\n");
+                  
+		  if ((Atom)event->xclient.data.l[0] == display->atom__NET_WM_PING)
+                    {
+                      process_pong_message (display, event);
+
+                      /* We don't want ping reply events going into
+                       * the GTK+ event loop because gtk+ will treat
+                       * them as ping requests and send more replies.
+                       */
+                      filter_out_event = TRUE;
+                    }
+		}
+            }
+
+          if (event->xclient.message_type ==
+              display->atom__NET_REQUEST_FRAME_EXTENTS)
+            {
+              meta_verbose ("Received _NET_REQUEST_FRAME_EXTENTS message\n");
+              process_request_frame_extents (display, event);
+            }
+        }
+      break;
+    case MappingNotify:
+      {
+        gboolean ignore_current;
+
+        ignore_current = FALSE;
+        
+        /* Check whether the next event is an identical MappingNotify
+         * event.  If it is, ignore the current event, we'll update
+         * when we get the next one.
+         */
+	if (XPending (display->xdisplay))
+          {
+            XEvent next_event;
+            
+            XPeekEvent (display->xdisplay, &next_event);
+            
+            if (next_event.type == MappingNotify &&
+                next_event.xmapping.request == event->xmapping.request)
+              ignore_current = TRUE;
+          }
+
+        if (!ignore_current)
+          {
+            /* Let XLib know that there is a new keyboard mapping.
+             */
+            XRefreshKeyboardMapping (&event->xmapping);
+            meta_display_process_mapping_event (display, event);
+          }
+      }
+      break;
+    default:
+#ifdef HAVE_XKB
+      if (event->type == display->xkb_base_event_type) 
+	{
+	  XkbAnyEvent *xkb_ev = (XkbAnyEvent *) event;
+	  
+	  switch (xkb_ev->xkb_type)
+	    {
+	    case XkbBellNotify:
+              if (XSERVER_TIME_IS_BEFORE(display->last_bell_time,
+                                         xkb_ev->time - 100))
+                {
+                  display->last_bell_time = xkb_ev->time;
+                  meta_bell_notify (display, xkb_ev);
+                }
+	      break;
+	    }
+	}
+#endif
+      break;
+    }
+
+	if (display->compositor)
+	{
+		meta_compositor_process_event (display->compositor, event, window);
+	}
+  
+	/* generates event on wrong window.
+  	 * https://github.com/stefano-k/Mate-Desktop-Environment/commit/b0e5fb03eb21dae8f02692f11ef391bfc5ccba33
+  	 */
+	if (maybe_send_event_to_gtk(display, event))
+	{
+		filter_out_event = TRUE;
+	}
+
+	display->current_time = CurrentTime;
+	return filter_out_event;
+}
+
+/* Return the window this has to do with, if any, rather
+ * than the frame or root window that was selecting
+ * for substructure
+ */
+static Window
+event_get_modified_window (MetaDisplay *display,
+                           XEvent *event)
+{
+  switch (event->type)
+    {
+    case KeyPress:
+    case KeyRelease:
+    case ButtonPress:
+    case ButtonRelease:
+    case MotionNotify:
+    case FocusIn:
+    case FocusOut:
+    case KeymapNotify:
+    case Expose:
+    case GraphicsExpose:
+    case NoExpose:
+    case VisibilityNotify:
+    case ResizeRequest:
+    case PropertyNotify:
+    case SelectionClear:
+    case SelectionRequest:
+    case SelectionNotify:
+    case ColormapNotify:
+    case ClientMessage:
+    case EnterNotify:
+    case LeaveNotify:
+      return event->xany.window;
+      
+    case CreateNotify:
+      return event->xcreatewindow.window;
+      
+    case DestroyNotify:
+      return event->xdestroywindow.window;
+
+    case UnmapNotify:
+      return event->xunmap.window;
+
+    case MapNotify:
+      return event->xmap.window;
+
+    case MapRequest:
+      return event->xmaprequest.window;
+
+    case ReparentNotify:
+     return event->xreparent.window;
+      
+    case ConfigureNotify:
+      return event->xconfigure.window;
+      
+    case ConfigureRequest:
+      return event->xconfigurerequest.window;
+
+    case GravityNotify:
+      return event->xgravity.window;
+
+    case CirculateNotify:
+      return event->xcirculate.window;
+
+    case CirculateRequest:
+      return event->xcirculaterequest.window;
+
+    case MappingNotify:
+      return None;
+
+    default:
+#ifdef HAVE_SHAPE
+      if (META_DISPLAY_HAS_SHAPE (display) && 
+          event->type == (display->shape_event_base + ShapeNotify))
+        {
+          XShapeEvent *sev = (XShapeEvent*) event;
+          return sev->window;
+        }
+#endif
+
+      return None;
+    }
+}
+
+static guint32
+event_get_time (MetaDisplay *display,
+                XEvent      *event)
+{
+  switch (event->type)
+    {
+    case KeyPress:
+    case KeyRelease:
+      return event->xkey.time;
+      
+    case ButtonPress:
+    case ButtonRelease:
+      return event->xbutton.time;
+      
+    case MotionNotify:
+      return event->xmotion.time;
+
+    case PropertyNotify:
+      return event->xproperty.time;
+
+    case SelectionClear:
+    case SelectionRequest:
+    case SelectionNotify:
+      return event->xselection.time;
+
+    case EnterNotify:
+    case LeaveNotify:
+      return event->xcrossing.time;
+
+    case FocusIn:
+    case FocusOut:
+    case KeymapNotify:      
+    case Expose:
+    case GraphicsExpose:
+    case NoExpose:
+    case MapNotify:
+    case UnmapNotify:
+    case VisibilityNotify:
+    case ResizeRequest:
+    case ColormapNotify:
+    case ClientMessage:
+    case CreateNotify:
+    case DestroyNotify:
+    case MapRequest:
+    case ReparentNotify:
+    case ConfigureNotify:
+    case ConfigureRequest:
+    case GravityNotify:
+    case CirculateNotify:
+    case CirculateRequest:
+    case MappingNotify:
+    default:
+      return CurrentTime;
+    }
+}
+
+#ifdef WITH_VERBOSE_MODE
+const char*
+meta_event_detail_to_string (int d)
+{
+  const char *detail = "???";
+  switch (d)
+    {
+      /* We are an ancestor in the A<->B focus change relationship */
+    case NotifyAncestor:
+      detail = "NotifyAncestor";
+      break;
+    case NotifyDetailNone:
+      detail = "NotifyDetailNone";
+      break;
+      /* We are a descendant in the A<->B focus change relationship */
+    case NotifyInferior:
+      detail = "NotifyInferior";
+      break;
+    case NotifyNonlinear:
+      detail = "NotifyNonlinear";
+      break;
+    case NotifyNonlinearVirtual:
+      detail = "NotifyNonlinearVirtual";
+      break;
+    case NotifyPointer:
+      detail = "NotifyPointer";
+      break;
+    case NotifyPointerRoot:
+      detail = "NotifyPointerRoot";
+      break;
+    case NotifyVirtual:
+      detail = "NotifyVirtual";
+      break;
+    }
+
+  return detail;
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+const char*
+meta_event_mode_to_string (int m)
+{
+  const char *mode = "???";
+  switch (m)
+    {
+    case NotifyNormal:
+      mode = "NotifyNormal";
+      break;
+    case NotifyGrab:
+      mode = "NotifyGrab";
+      break;
+    case NotifyUngrab:
+      mode = "NotifyUngrab";
+      break;
+      /* not sure any X implementations are missing this, but
+       * it seems to be absent from some docs.
+       */
+#ifdef NotifyWhileGrabbed
+    case NotifyWhileGrabbed:
+      mode = "NotifyWhileGrabbed";
+      break;
+#endif
+    }
+
+  return mode;
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+stack_mode_to_string (int mode)
+{
+  switch (mode)
+    {
+    case Above:
+      return "Above";
+    case Below:
+      return "Below";
+    case TopIf:
+      return "TopIf";
+    case BottomIf:
+      return "BottomIf";
+    case Opposite:
+      return "Opposite";      
+    }
+
+  return "Unknown";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static char*
+key_event_description (Display *xdisplay,
+                       XEvent  *event)
+{
+  KeySym keysym;
+  const char *str;
+  
+  keysym = XKeycodeToKeysym (xdisplay, event->xkey.keycode, 0);  
+
+  str = XKeysymToString (keysym);
+  
+  return g_strdup_printf ("Key '%s' state 0x%x", 
+                          str ? str : "none", event->xkey.state);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef HAVE_XSYNC
+#ifdef WITH_VERBOSE_MODE
+static gint64
+sync_value_to_64 (const XSyncValue *value)
+{
+  gint64 v;
+
+  v = XSyncValueLow32 (*value);
+  v |= (((gint64)XSyncValueHigh32 (*value)) << 32);
+  
+  return v;
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+alarm_state_to_string (XSyncAlarmState state)
+{
+  switch (state)
+    {
+    case XSyncAlarmActive:
+      return "Active";
+    case XSyncAlarmInactive:
+      return "Inactive";
+    case XSyncAlarmDestroyed:
+      return "Destroyed";
+    default:
+      return "(unknown)";
+    }
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#endif /* HAVE_XSYNC */
+
+#ifdef WITH_VERBOSE_MODE
+static void
+meta_spew_event (MetaDisplay *display,
+                 XEvent      *event)
+{
+  const char *name = NULL;
+  char *extra = NULL;
+  char *winname;
+  MetaScreen *screen;
+
+  if (!meta_is_verbose())
+    return;
+  
+  /* filter overnumerous events */
+  if (event->type == Expose || event->type == MotionNotify ||
+      event->type == NoExpose)
+    return;
+      
+  switch (event->type)
+    {
+    case KeyPress:
+      name = "KeyPress";
+      extra = key_event_description (display->xdisplay, event);
+      break;
+    case KeyRelease:
+      name = "KeyRelease";
+      extra = key_event_description (display->xdisplay, event);
+      break;
+    case ButtonPress:
+      name = "ButtonPress";
+      extra = g_strdup_printf ("button %u state 0x%x x %d y %d root 0x%lx same_screen %d",
+                               event->xbutton.button,
+                               event->xbutton.state,
+                               event->xbutton.x,
+                               event->xbutton.y,
+                               event->xbutton.root,
+                               event->xbutton.same_screen);
+      break;
+    case ButtonRelease:
+      name = "ButtonRelease";
+      extra = g_strdup_printf ("button %u state 0x%x x %d y %d root 0x%lx same_screen %d",
+                               event->xbutton.button,
+                               event->xbutton.state,
+                               event->xbutton.x,
+                               event->xbutton.y,
+                               event->xbutton.root,
+                               event->xbutton.same_screen);
+      break;
+    case MotionNotify:
+      name = "MotionNotify";
+      extra = g_strdup_printf ("win: 0x%lx x: %d y: %d",
+                               event->xmotion.window,
+                               event->xmotion.x,
+                               event->xmotion.y);
+      break;
+    case EnterNotify:
+      name = "EnterNotify";
+      extra = g_strdup_printf ("win: 0x%lx root: 0x%lx subwindow: 0x%lx mode: %s detail: %s focus: %d x: %d y: %d",
+                               event->xcrossing.window,
+                               event->xcrossing.root,
+                               event->xcrossing.subwindow,
+                               meta_event_mode_to_string (event->xcrossing.mode),
+                               meta_event_detail_to_string (event->xcrossing.detail),
+                               event->xcrossing.focus,
+                               event->xcrossing.x,
+                               event->xcrossing.y);
+      break;
+    case LeaveNotify:
+      name = "LeaveNotify";
+      extra = g_strdup_printf ("win: 0x%lx root: 0x%lx subwindow: 0x%lx mode: %s detail: %s focus: %d x: %d y: %d",
+                               event->xcrossing.window,
+                               event->xcrossing.root,
+                               event->xcrossing.subwindow,
+                               meta_event_mode_to_string (event->xcrossing.mode),
+                               meta_event_detail_to_string (event->xcrossing.detail),
+                               event->xcrossing.focus,
+                               event->xcrossing.x,
+                               event->xcrossing.y);
+      break;
+    case FocusIn:
+      name = "FocusIn";
+      extra = g_strdup_printf ("detail: %s mode: %s\n",
+                               meta_event_detail_to_string (event->xfocus.detail),
+                               meta_event_mode_to_string (event->xfocus.mode));
+      break;
+    case FocusOut:
+      name = "FocusOut";
+      extra = g_strdup_printf ("detail: %s mode: %s\n",
+                               meta_event_detail_to_string (event->xfocus.detail),
+                               meta_event_mode_to_string (event->xfocus.mode));
+      break;
+    case KeymapNotify:
+      name = "KeymapNotify";
+      break;
+    case Expose:
+      name = "Expose";
+      break;
+    case GraphicsExpose:
+      name = "GraphicsExpose";
+      break;
+    case NoExpose:
+      name = "NoExpose";
+      break;
+    case VisibilityNotify:
+      name = "VisibilityNotify";
+      break;
+    case CreateNotify:
+      name = "CreateNotify";
+      extra = g_strdup_printf ("parent: 0x%lx window: 0x%lx",
+                               event->xcreatewindow.parent,
+                               event->xcreatewindow.window);
+      break;
+    case DestroyNotify:
+      name = "DestroyNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx",
+                               event->xdestroywindow.event,
+                               event->xdestroywindow.window);
+      break;
+    case UnmapNotify:
+      name = "UnmapNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx from_configure: %d",
+                               event->xunmap.event,
+                               event->xunmap.window,
+                               event->xunmap.from_configure);
+      break;
+    case MapNotify:
+      name = "MapNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx override_redirect: %d",
+                               event->xmap.event,
+                               event->xmap.window,
+                               event->xmap.override_redirect);
+      break;
+    case MapRequest:
+      name = "MapRequest";
+      extra = g_strdup_printf ("window: 0x%lx parent: 0x%lx\n",
+                               event->xmaprequest.window,
+                               event->xmaprequest.parent);
+      break;
+    case ReparentNotify:
+      name = "ReparentNotify";
+      extra = g_strdup_printf ("window: 0x%lx parent: 0x%lx event: 0x%lx\n",
+                               event->xreparent.window,
+                               event->xreparent.parent,
+                               event->xreparent.event);
+      break;
+    case ConfigureNotify:
+      name = "ConfigureNotify";
+      extra = g_strdup_printf ("x: %d y: %d w: %d h: %d above: 0x%lx override_redirect: %d",
+                               event->xconfigure.x,
+                               event->xconfigure.y,
+                               event->xconfigure.width,
+                               event->xconfigure.height,
+                               event->xconfigure.above,
+                               event->xconfigure.override_redirect);
+      break;
+    case ConfigureRequest:
+      name = "ConfigureRequest";
+      extra = g_strdup_printf ("parent: 0x%lx window: 0x%lx x: %d %sy: %d %sw: %d %sh: %d %sborder: %d %sabove: %lx %sstackmode: %s %s",
+                               event->xconfigurerequest.parent,
+                               event->xconfigurerequest.window,
+                               event->xconfigurerequest.x,
+                               event->xconfigurerequest.value_mask &
+                               CWX ? "" : "(unset) ",
+                               event->xconfigurerequest.y,
+                               event->xconfigurerequest.value_mask &
+                               CWY ? "" : "(unset) ",
+                               event->xconfigurerequest.width,
+                               event->xconfigurerequest.value_mask &
+                               CWWidth ? "" : "(unset) ",
+                               event->xconfigurerequest.height,
+                               event->xconfigurerequest.value_mask &
+                               CWHeight ? "" : "(unset) ",
+                               event->xconfigurerequest.border_width,
+                               event->xconfigurerequest.value_mask &
+                               CWBorderWidth ? "" : "(unset)",
+                               event->xconfigurerequest.above,
+                               event->xconfigurerequest.value_mask &
+                               CWSibling ? "" : "(unset)",
+                               stack_mode_to_string (event->xconfigurerequest.detail),
+                               event->xconfigurerequest.value_mask &
+                               CWStackMode ? "" : "(unset)");
+      break;
+    case GravityNotify:
+      name = "GravityNotify";
+      break;
+    case ResizeRequest:
+      name = "ResizeRequest";
+      extra = g_strdup_printf ("width = %d height = %d",
+                               event->xresizerequest.width,
+                               event->xresizerequest.height);
+      break;
+    case CirculateNotify:
+      name = "CirculateNotify";
+      break;
+    case CirculateRequest:
+      name = "CirculateRequest";
+      break;
+    case PropertyNotify:
+      {
+        char *str;
+        const char *state;
+            
+        name = "PropertyNotify";
+            
+        meta_error_trap_push (display);
+        str = XGetAtomName (display->xdisplay,
+                            event->xproperty.atom);
+        meta_error_trap_pop (display, TRUE);
+
+        if (event->xproperty.state == PropertyNewValue)
+          state = "PropertyNewValue";
+        else if (event->xproperty.state == PropertyDelete)
+          state = "PropertyDelete";
+        else
+          state = "???";
+            
+        extra = g_strdup_printf ("atom: %s state: %s",
+                                 str ? str : "(unknown atom)",
+                                 state);
+        meta_XFree (str);
+      }
+      break;
+    case SelectionClear:
+      name = "SelectionClear";
+      break;
+    case SelectionRequest:
+      name = "SelectionRequest";
+      break;
+    case SelectionNotify:
+      name = "SelectionNotify";
+      break;
+    case ColormapNotify:
+      name = "ColormapNotify";
+      break;
+    case ClientMessage:
+      {
+        char *str;
+        name = "ClientMessage";
+        meta_error_trap_push (display);
+        str = XGetAtomName (display->xdisplay,
+                            event->xclient.message_type);
+        meta_error_trap_pop (display, TRUE);
+        extra = g_strdup_printf ("type: %s format: %d\n",
+                                 str ? str : "(unknown atom)",
+                                 event->xclient.format);
+        meta_XFree (str);
+      }
+      break;
+    case MappingNotify:
+      name = "MappingNotify";
+      break;
+    default:
+#ifdef HAVE_XSYNC
+      if (META_DISPLAY_HAS_XSYNC (display) && 
+          event->type == (display->xsync_event_base + XSyncAlarmNotify))
+        {
+          XSyncAlarmNotifyEvent *aevent = (XSyncAlarmNotifyEvent*) event;
+          
+          name = "XSyncAlarmNotify";
+          extra =
+            g_strdup_printf ("alarm: 0x%lx"
+                             " counter_value: %" G_GINT64_FORMAT
+                             " alarm_value: %" G_GINT64_FORMAT
+                             " time: %u alarm state: %s",
+                             aevent->alarm,
+                             (gint64) sync_value_to_64 (&aevent->counter_value),
+                             (gint64) sync_value_to_64 (&aevent->alarm_value),
+                             (unsigned int)aevent->time,
+                             alarm_state_to_string (aevent->state));
+        }
+      else
+#endif /* HAVE_XSYNC */
+#ifdef HAVE_SHAPE
+        if (META_DISPLAY_HAS_SHAPE (display) && 
+            event->type == (display->shape_event_base + ShapeNotify))
+          {
+            XShapeEvent *sev = (XShapeEvent*) event;
+
+            name = "ShapeNotify";
+
+            extra =
+              g_strdup_printf ("kind: %s "
+                               "x: %d y: %d w: %u h: %u "
+                               "shaped: %d",
+                               sev->kind == ShapeBounding ?
+                               "ShapeBounding" :
+                               (sev->kind == ShapeClip ?
+                               "ShapeClip" : "(unknown)"),
+                               sev->x, sev->y, sev->width, sev->height,
+                               sev->shaped);
+          }
+        else
+#endif /* HAVE_SHAPE */      
+        {
+          name = "(Unknown event)";
+          extra = g_strdup_printf ("type: %d", event->xany.type);
+        }
+      break;
+    }
+
+  screen = meta_display_screen_for_root (display, event->xany.window);
+      
+  if (screen)
+    winname = g_strdup_printf ("root %d", screen->number);
+  else
+    winname = g_strdup_printf ("0x%lx", event->xany.window);
+      
+  meta_topic (META_DEBUG_EVENTS,
+              "%s on %s%s %s %sserial %lu\n", name, winname,
+              extra ? ":" : "", extra ? extra : "",
+              event->xany.send_event ? "SEND " : "",
+              event->xany.serial);
+
+  g_free (winname);
+
+  if (extra)
+    g_free (extra);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+MetaWindow*
+meta_display_lookup_x_window (MetaDisplay *display,
+                              Window       xwindow)
+{
+  return g_hash_table_lookup (display->window_ids, &xwindow);
+}
+
+void
+meta_display_register_x_window (MetaDisplay *display,
+                                Window      *xwindowp,
+                                MetaWindow  *window)
+{
+  g_return_if_fail (g_hash_table_lookup (display->window_ids, xwindowp) == NULL);
+  
+  g_hash_table_insert (display->window_ids, xwindowp, window);
+}
+
+void
+meta_display_unregister_x_window (MetaDisplay *display,
+                                  Window       xwindow)
+{
+  g_return_if_fail (g_hash_table_lookup (display->window_ids, &xwindow) != NULL);
+
+  g_hash_table_remove (display->window_ids, &xwindow);
+
+  /* Remove any pending pings */
+  remove_pending_pings_for_window (display, xwindow);
+}
+
+gboolean
+meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
+                                           Window xwindow)
+{
+  gboolean is_a_no_focus_window = FALSE;
+  GSList *temp = display->screens;
+  while (temp != NULL) {
+    MetaScreen *screen = temp->data;
+    if (screen->no_focus_window == xwindow) {
+      is_a_no_focus_window = TRUE;
+      break;
+    }
+    temp = temp->next;
+  }
+
+  return is_a_no_focus_window;
+}
+
+Cursor
+meta_display_create_x_cursor (MetaDisplay *display,
+                              MetaCursor cursor)
+{
+  Cursor xcursor;
+  guint glyph;
+
+  switch (cursor)
+    {
+    case META_CURSOR_DEFAULT:
+      glyph = XC_left_ptr;
+      break;
+    case META_CURSOR_NORTH_RESIZE:
+      glyph = XC_top_side;
+      break;
+    case META_CURSOR_SOUTH_RESIZE:
+      glyph = XC_bottom_side;
+      break;
+    case META_CURSOR_WEST_RESIZE:
+      glyph = XC_left_side;
+      break;
+    case META_CURSOR_EAST_RESIZE:
+      glyph = XC_right_side;
+      break;
+    case META_CURSOR_SE_RESIZE:
+      glyph = XC_bottom_right_corner;
+      break;
+    case META_CURSOR_SW_RESIZE:
+      glyph = XC_bottom_left_corner;
+      break;
+    case META_CURSOR_NE_RESIZE:
+      glyph = XC_top_right_corner;
+      break;
+    case META_CURSOR_NW_RESIZE:
+      glyph = XC_top_left_corner;
+      break;
+    case META_CURSOR_MOVE_OR_RESIZE_WINDOW:
+      glyph = XC_fleur;
+      break;
+    case META_CURSOR_BUSY:
+      glyph = XC_watch;
+      break;
+      
+    default:
+      g_assert_not_reached ();
+      glyph = 0; /* silence compiler */
+      break;
+    }
+  
+  xcursor = XCreateFontCursor (display->xdisplay, glyph);
+
+  return xcursor;
+}
+
+static Cursor
+xcursor_for_op (MetaDisplay *display,
+                MetaGrabOp   op)
+{
+  MetaCursor cursor = META_CURSOR_DEFAULT;
+  
+  switch (op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+      cursor = META_CURSOR_SE_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+      cursor = META_CURSOR_SOUTH_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+      cursor = META_CURSOR_SW_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+      cursor = META_CURSOR_NORTH_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+      cursor = META_CURSOR_NE_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      cursor = META_CURSOR_NW_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+      cursor = META_CURSOR_WEST_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+      cursor = META_CURSOR_EAST_RESIZE;
+      break;
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_KEYBOARD_MOVING:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+      cursor = META_CURSOR_MOVE_OR_RESIZE_WINDOW;
+      break;
+      
+    default:
+      break;
+    }
+
+  if (cursor == META_CURSOR_DEFAULT)
+    return None;
+  return meta_display_create_x_cursor (display, cursor);
+}
+
+void
+meta_display_set_grab_op_cursor (MetaDisplay *display,
+                                 MetaScreen  *screen,
+                                 MetaGrabOp   op,
+                                 gboolean     change_pointer,
+                                 Window       grab_xwindow,
+                                 guint32      timestamp)
+{
+  Cursor cursor;
+
+  cursor = xcursor_for_op (display, op);
+
+#define GRAB_MASK (PointerMotionMask |                          \
+                   ButtonPressMask | ButtonReleaseMask |        \
+		   EnterWindowMask | LeaveWindowMask)
+
+  if (change_pointer)
+    {
+      meta_error_trap_push_with_return (display);
+      XChangeActivePointerGrab (display->xdisplay,
+                                GRAB_MASK,
+                                cursor,
+                                timestamp);
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Changed pointer with XChangeActivePointerGrab()\n");
+
+      if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Error trapped from XChangeActivePointerGrab()\n");
+          if (display->grab_have_pointer)
+            display->grab_have_pointer = FALSE;
+        }
+    }
+  else
+    {
+      g_assert (screen != NULL);
+
+      meta_error_trap_push (display);
+      if (XGrabPointer (display->xdisplay,
+                        grab_xwindow,
+                        False,
+                        GRAB_MASK,
+                        GrabModeAsync, GrabModeAsync,
+                        screen->xroot,
+                        cursor,
+                        timestamp) == GrabSuccess)
+        {
+          display->grab_have_pointer = TRUE;
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "XGrabPointer() returned GrabSuccess time %u\n",
+                      timestamp);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "XGrabPointer() failed time %u\n",
+                      timestamp);
+        }
+      meta_error_trap_pop (display, TRUE);
+    }
+
+#undef GRAB_MASK
+  
+  if (cursor != None)
+    XFreeCursor (display->xdisplay, cursor);
+}
+
+gboolean
+meta_display_begin_grab_op (MetaDisplay *display,
+			    MetaScreen  *screen,
+                            MetaWindow  *window,
+                            MetaGrabOp   op,
+                            gboolean     pointer_already_grabbed,
+                            gboolean     frame_action,
+                            int          button,
+                            gulong       modmask,
+                            guint32      timestamp,
+                            int          root_x,
+                            int          root_y)
+{
+  Window grab_xwindow;
+  
+  if (grab_op_is_mouse (op) && meta_grab_op_is_moving (op))
+    {
+      if (display->compositor)
+	{
+	  meta_compositor_begin_move (display->compositor,
+				      window, &window->rect,
+				      root_x, root_y);
+	}
+    }
+  
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Doing grab op %u on window %s button %d pointer already grabbed: %d pointer pos %d,%d\n",
+              op, window ? window->desc : "none", button, pointer_already_grabbed,
+              root_x, root_y);
+  
+  if (display->grab_op != META_GRAB_OP_NONE)
+    {
+      if (window)
+        meta_warning ("Attempt to perform window operation %u on window %s when operation %u on %s already in effect\n",
+                      op, window->desc, display->grab_op,
+                      display->grab_window ? display->grab_window->desc : "none");
+      return FALSE;
+    }
+
+  if (window &&
+      (meta_grab_op_is_moving (op) || meta_grab_op_is_resizing (op)))
+    {
+      if (meta_prefs_get_raise_on_click ())
+        meta_window_raise (window);
+      else
+        {
+          display->grab_initial_x = root_x;
+          display->grab_initial_y = root_y;
+          display->grab_threshold_movement_reached = FALSE;
+        }
+    }
+
+  /* FIXME:
+   *   If we have no MetaWindow we do our best
+   *   and try to do the grab on the RootWindow.
+   *   This will fail if anyone else has any
+   *   key grab on the RootWindow.
+   */
+  if (window)
+    grab_xwindow = window->frame ? window->frame->xwindow : window->xwindow;
+  else
+    grab_xwindow = screen->xroot;
+
+  display->grab_have_pointer = FALSE;
+  
+  if (pointer_already_grabbed)
+    display->grab_have_pointer = TRUE;
+  
+  meta_display_set_grab_op_cursor (display, screen, op, FALSE, grab_xwindow,
+                                   timestamp);
+
+  if (!display->grab_have_pointer)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "XGrabPointer() failed\n");
+      return FALSE;
+    }
+
+  /* Grab keys for keyboard ops and mouse move/resizes; see #126497 */
+  if (grab_op_is_keyboard (op) || grab_op_is_mouse_only (op))
+    {
+      if (window)
+        display->grab_have_keyboard =
+                     meta_window_grab_all_keys (window, timestamp);
+
+      else
+        display->grab_have_keyboard =
+                     meta_screen_grab_all_keys (screen, timestamp);
+      
+      if (!display->grab_have_keyboard)
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "grabbing all keys failed, ungrabbing pointer\n");
+          XUngrabPointer (display->xdisplay, timestamp);
+          display->grab_have_pointer = FALSE;
+          return FALSE;
+        }
+    }
+  
+  display->grab_op = op;
+  display->grab_window = window;
+  display->grab_screen = screen;
+  display->grab_xwindow = grab_xwindow;
+  display->grab_button = button;
+  display->grab_mask = modmask;
+  display->grab_anchor_root_x = root_x;
+  display->grab_anchor_root_y = root_y;
+  display->grab_latest_motion_x = root_x;
+  display->grab_latest_motion_y = root_y;
+  display->grab_last_moveresize_time.tv_sec = 0;
+  display->grab_last_moveresize_time.tv_usec = 0;
+  display->grab_motion_notify_time = 0;
+  display->grab_old_window_stacking = NULL;
+#ifdef HAVE_XSYNC
+  display->grab_sync_request_alarm = None;
+  display->grab_last_user_action_was_snap = FALSE;
+#endif
+  display->grab_was_cancelled = FALSE;
+  display->grab_frame_action = frame_action;
+
+  if (display->grab_resize_timeout_id)
+    {
+      g_source_remove (display->grab_resize_timeout_id);
+      display->grab_resize_timeout_id = 0;
+    }
+	
+  if (display->grab_window)
+    {
+      meta_window_get_client_root_coords (display->grab_window,
+                                          &display->grab_initial_window_pos);
+      display->grab_anchor_window_pos = display->grab_initial_window_pos;
+
+      display->grab_wireframe_active =
+        (meta_prefs_get_reduced_resources () && !meta_prefs_get_mate_accessibility ())  && 
+        (meta_grab_op_is_resizing (display->grab_op) ||
+         meta_grab_op_is_moving (display->grab_op));
+      
+      if (display->grab_wireframe_active)
+        {
+          meta_window_calc_showing (display->grab_window);
+          meta_window_begin_wireframe (window);
+        }
+      
+#ifdef HAVE_XSYNC
+      if (!display->grab_wireframe_active &&
+          meta_grab_op_is_resizing (display->grab_op) &&
+          display->grab_window->sync_request_counter != None)
+        {
+          XSyncAlarmAttributes values;
+	  XSyncValue init;
+
+          meta_error_trap_push_with_return (display);
+
+	  /* Set the counter to 0, so we know that the application's
+	   * responses to the client messages will always trigger
+	   * a PositiveTransition
+	   */
+	  
+	  XSyncIntToValue (&init, 0);
+	  XSyncSetCounter (display->xdisplay,
+			   display->grab_window->sync_request_counter, init);
+	  
+	  display->grab_window->sync_request_serial = 0;
+	  display->grab_window->sync_request_time.tv_sec = 0;
+	  display->grab_window->sync_request_time.tv_usec = 0;
+	  
+          values.trigger.counter = display->grab_window->sync_request_counter;
+          values.trigger.value_type = XSyncAbsolute;
+          values.trigger.test_type = XSyncPositiveTransition;
+          XSyncIntToValue (&values.trigger.wait_value,
+			   display->grab_window->sync_request_serial + 1);
+	  
+          /* After triggering, increment test_value by this.
+           * (NOT wait_value above)
+           */
+          XSyncIntToValue (&values.delta, 1);
+	  
+          /* we want events (on by default anyway) */
+          values.events = True;
+          
+          display->grab_sync_request_alarm = XSyncCreateAlarm (display->xdisplay,
+                                                         XSyncCACounter |
+                                                         XSyncCAValueType |
+                                                         XSyncCAValue |
+                                                         XSyncCATestType |
+                                                         XSyncCADelta |
+                                                         XSyncCAEvents,
+                                                         &values);
+
+          if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+	    display->grab_sync_request_alarm = None;
+
+          meta_topic (META_DEBUG_RESIZING,
+                      "Created update alarm 0x%lx\n",
+                      display->grab_sync_request_alarm);
+        }
+#endif
+    }
+  
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Grab op %u on window %s successful\n",
+              display->grab_op, window ? window->desc : "(null)");
+
+  g_assert (display->grab_window != NULL || display->grab_screen != NULL);
+  g_assert (display->grab_op != META_GRAB_OP_NONE);
+
+  /* If this is a move or resize, cache the window edges for
+   * resistance/snapping
+   */
+  if (meta_grab_op_is_resizing (display->grab_op) || 
+      meta_grab_op_is_moving (display->grab_op))
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Computing edges to resist-movement or snap-to for %s.\n",
+                  window->desc);
+      meta_display_compute_resistance_and_snapping_edges (display);
+    }
+
+  /* Save the old stacking */
+  if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Saving old stack positions; old pointer was %p.\n",
+                  display->grab_old_window_stacking);
+      display->grab_old_window_stacking = 
+        meta_stack_get_positions (screen->stack);
+    }
+
+  /* Do this last, after everything is set up. */
+  switch (op)
+    {
+    case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_NORMAL,
+                                    META_TAB_SHOW_ICON);
+      break;
+    case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_NORMAL,
+                                    META_TAB_SHOW_INSTANTLY);
+      break;
+
+    case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_DOCKS,
+                                    META_TAB_SHOW_ICON);
+      break;
+    case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_DOCKS,
+                                    META_TAB_SHOW_INSTANTLY);
+      break;
+    case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_GROUP,
+                                    META_TAB_SHOW_ICON);
+      break;
+     case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_GROUP,
+                                    META_TAB_SHOW_INSTANTLY);
+      
+    case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+      meta_screen_ensure_workspace_popup (screen);
+      break;
+
+    default:
+      break;
+    }
+
+  if (display->grab_window)
+    {
+      meta_window_refresh_resize_popup (display->grab_window);
+    }
+  
+  return TRUE;
+}
+
+void
+meta_display_end_grab_op (MetaDisplay *display,
+                          guint32      timestamp)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Ending grab op %u at time %u\n", display->grab_op, timestamp);
+  
+  if (display->grab_op == META_GRAB_OP_NONE)
+    return;
+
+  if (display->grab_window != NULL)
+    display->grab_window->shaken_loose = FALSE;
+  
+  if (display->grab_window != NULL &&
+      !meta_prefs_get_raise_on_click () &&
+      (meta_grab_op_is_moving (display->grab_op) ||
+       meta_grab_op_is_resizing (display->grab_op)))
+    {
+      /* Only raise the window in orthogonal raise
+       * ('do-not-raise-on-click') mode if the user didn't try to move
+       * or resize the given window by at least a threshold amount.
+       * For raise on click mode, the window was raised at the
+       * beginning of the grab_op.
+       */
+      if (!display->grab_threshold_movement_reached)
+        meta_window_raise (display->grab_window);
+    }
+
+  if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op) ||
+      display->grab_op == META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING)
+    {
+      meta_ui_tab_popup_free (display->grab_screen->tab_popup);
+      display->grab_screen->tab_popup = NULL;
+
+      /* If the ungrab here causes an EnterNotify, ignore it for
+       * sloppy focus
+       */
+      display->ungrab_should_not_cause_focus_window = display->grab_xwindow;
+    }
+  
+  /* If this was a move or resize clear out the edge cache */
+  if (meta_grab_op_is_resizing (display->grab_op) || 
+      meta_grab_op_is_moving (display->grab_op))
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Clearing out the edges for resistance/snapping");
+      meta_display_cleanup_edges (display);
+    }
+
+  if (display->grab_old_window_stacking != NULL)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Clearing out the old stack position, which was %p.\n",
+                  display->grab_old_window_stacking);
+      g_list_free (display->grab_old_window_stacking);
+      display->grab_old_window_stacking = NULL;
+    }
+
+  if (display->grab_wireframe_active)
+    {
+      display->grab_wireframe_active = FALSE;
+      meta_window_end_wireframe (display->grab_window);
+
+      if (!display->grab_was_cancelled)
+        {
+          if (meta_grab_op_is_moving (display->grab_op))
+            meta_window_move (display->grab_window,
+                              TRUE,
+                              display->grab_wireframe_rect.x,
+                              display->grab_wireframe_rect.y);
+          if (meta_grab_op_is_resizing (display->grab_op))
+            meta_window_resize_with_gravity (display->grab_window,
+                                             TRUE,
+                                             display->grab_wireframe_rect.width,
+                                             display->grab_wireframe_rect.height,
+                                             meta_resize_gravity_from_grab_op (display->grab_op));
+        }
+      meta_window_calc_showing (display->grab_window);
+    }
+
+  if (display->compositor &&
+      display->grab_window &&
+      grab_op_is_mouse (display->grab_op) && 
+      meta_grab_op_is_moving (display->grab_op))
+    {
+      meta_compositor_end_move (display->compositor,
+				display->grab_window);
+    }
+  
+  if (display->grab_have_pointer)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Ungrabbing pointer with timestamp %u\n", timestamp);
+      XUngrabPointer (display->xdisplay, timestamp);
+    }
+
+  if (display->grab_have_keyboard)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Ungrabbing all keys timestamp %u\n", timestamp);
+      if (display->grab_window)
+        meta_window_ungrab_all_keys (display->grab_window, timestamp);
+      else
+        meta_screen_ungrab_all_keys (display->grab_screen, timestamp);
+    }
+
+#ifdef HAVE_XSYNC
+  if (display->grab_sync_request_alarm != None)
+    {
+      XSyncDestroyAlarm (display->xdisplay,
+                         display->grab_sync_request_alarm);
+      display->grab_sync_request_alarm = None;
+    }
+#endif /* HAVE_XSYNC */
+  
+  display->grab_window = NULL;
+  display->grab_screen = NULL;
+  display->grab_xwindow = None;
+  display->grab_op = META_GRAB_OP_NONE;
+
+  if (display->grab_resize_popup)
+    {
+      meta_ui_resize_popup_free (display->grab_resize_popup);
+      display->grab_resize_popup = NULL;
+    }
+
+  if (display->grab_resize_timeout_id)
+    {
+      g_source_remove (display->grab_resize_timeout_id);
+      display->grab_resize_timeout_id = 0;
+    }
+}
+
+void
+meta_display_check_threshold_reached (MetaDisplay *display,
+                                      int          x,
+                                      int          y)
+{
+  /* Don't bother doing the check again if we've already reached the threshold */
+  if (meta_prefs_get_raise_on_click () ||
+      display->grab_threshold_movement_reached)
+    return;
+
+  if (ABS (display->grab_initial_x - x) >= 8 ||
+      ABS (display->grab_initial_y - y) >= 8)
+    display->grab_threshold_movement_reached = TRUE;
+}
+
+static void
+meta_change_button_grab (MetaDisplay *display,
+                         Window       xwindow,
+                         gboolean     grab,
+                         gboolean     sync,
+                         int          button,
+                         int          modmask)
+{
+  unsigned int ignored_mask;
+
+  meta_verbose ("%s 0x%lx sync = %d button = %d modmask 0x%x\n",
+                grab ? "Grabbing" : "Ungrabbing",
+                xwindow,
+                sync, button, modmask);
+  
+  meta_error_trap_push (display);
+  
+  ignored_mask = 0;
+  while (ignored_mask <= display->ignored_modifier_mask)
+    {
+      if (ignored_mask & ~(display->ignored_modifier_mask))
+        {
+          /* Not a combination of ignored modifiers
+           * (it contains some non-ignored modifiers)
+           */
+          ++ignored_mask;
+          continue;
+        }
+
+      if (meta_is_debugging ())
+        meta_error_trap_push_with_return (display);
+
+      /* GrabModeSync means freeze until XAllowEvents */
+      
+      if (grab)
+        XGrabButton (display->xdisplay, button, modmask | ignored_mask,
+                     xwindow, False,
+                     ButtonPressMask | ButtonReleaseMask |    
+                     PointerMotionMask | PointerMotionHintMask,
+                     sync ? GrabModeSync : GrabModeAsync,
+                     GrabModeAsync,
+                     False, None);
+      else
+        XUngrabButton (display->xdisplay, button, modmask | ignored_mask,
+                       xwindow);
+
+      if (meta_is_debugging ())
+        {
+          int result;
+          
+          result = meta_error_trap_pop_with_return (display, FALSE);
+          
+          if (result != Success)
+            meta_verbose ("Failed to %s button %d with mask 0x%x for window 0x%lx error code %d\n",
+                          grab ? "grab" : "ungrab",
+                          button, modmask | ignored_mask, xwindow, result);
+        }
+      
+      ++ignored_mask;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+void
+meta_display_grab_window_buttons (MetaDisplay *display,
+                                  Window       xwindow)
+{  
+  /* Grab Alt + button1 for moving window.
+   * Grab Alt + button2 for resizing window.
+   * Grab Alt + button3 for popping up window menu.
+   * Grab Alt + Shift + button1 for snap-moving window.
+   */
+  meta_verbose ("Grabbing window buttons for 0x%lx\n", xwindow);
+  
+  /* FIXME If we ignored errors here instead of spewing, we could
+   * put one big error trap around the loop and avoid a bunch of
+   * XSync()
+   */
+
+  if (display->window_grab_modifiers != 0)
+    {
+      gboolean debug = g_getenv ("MARCO_DEBUG_BUTTON_GRABS") != NULL;
+      int i;
+      for (i = 1; i < 4; i++)
+        {
+          meta_change_button_grab (display, xwindow,
+                                   TRUE,
+                                   FALSE,
+                                   i, display->window_grab_modifiers);  
+          
+          /* This is for debugging, since I end up moving the Xnest
+           * otherwise ;-)
+           */
+          if (debug)
+            meta_change_button_grab (display, xwindow,
+                                     TRUE,
+                                     FALSE,
+                                     i, ControlMask);
+        }
+
+      /* In addition to grabbing Alt+Button1 for moving the window,
+       * grab Alt+Shift+Button1 for snap-moving the window.  See bug
+       * 112478.  Unfortunately, this doesn't work with
+       * Shift+Alt+Button1 for some reason; so at least part of the
+       * order still matters, which sucks (please FIXME).
+       */
+      meta_change_button_grab (display, xwindow,
+                               TRUE,
+                               FALSE,
+                               1, display->window_grab_modifiers | ShiftMask);
+    }
+}
+
+void
+meta_display_ungrab_window_buttons  (MetaDisplay *display,
+                                     Window       xwindow)
+{
+  gboolean debug;
+  int i;
+
+  if (display->window_grab_modifiers == 0)
+    return;
+  
+  debug = g_getenv ("MARCO_DEBUG_BUTTON_GRABS") != NULL;
+  i = 1;
+  while (i < 4)
+    {
+      meta_change_button_grab (display, xwindow,
+                               FALSE, FALSE, i,
+                               display->window_grab_modifiers);
+      
+      if (debug)
+        meta_change_button_grab (display, xwindow,
+                                 FALSE, FALSE, i, ControlMask);
+      
+      ++i;
+    }
+}
+
+/* Grab buttons we only grab while unfocused in click-to-focus mode */
+#define MAX_FOCUS_BUTTON 4
+void
+meta_display_grab_focus_window_button (MetaDisplay *display,
+                                       MetaWindow  *window)
+{
+  /* Grab button 1 for activating unfocused windows */
+  meta_verbose ("Grabbing unfocused window buttons for %s\n", window->desc);
+
+#if 0
+  /* FIXME:115072 */
+  /* Don't grab at all unless in click to focus mode. In click to
+   * focus, we may sometimes be clever about intercepting and eating
+   * the focus click. But in mouse focus, we never do that since the
+   * focus window may not be raised, and who wants to think about
+   * mouse focus anyway.
+   */
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK)
+    {
+      meta_verbose (" (well, not grabbing since not in click to focus mode)\n");
+      return;
+    }
+#endif
+  
+  if (window->have_focus_click_grab)
+    {
+      meta_verbose (" (well, not grabbing since we already have the grab)\n");
+      return;
+    }
+  
+  /* FIXME If we ignored errors here instead of spewing, we could
+   * put one big error trap around the loop and avoid a bunch of
+   * XSync()
+   */
+  
+  {
+    int i = 1;
+    while (i < MAX_FOCUS_BUTTON)
+      {
+        meta_change_button_grab (display,
+                                 window->xwindow,
+                                 TRUE, TRUE,
+                                 i, 0);
+        
+        ++i;
+      }
+
+    window->have_focus_click_grab = TRUE;
+  }
+}
+
+void
+meta_display_ungrab_focus_window_button (MetaDisplay *display,
+                                         MetaWindow  *window)
+{
+  meta_verbose ("Ungrabbing unfocused window buttons for %s\n", window->desc);
+
+  if (!window->have_focus_click_grab)
+    return;
+  
+  {
+    int i = 1;
+    while (i < MAX_FOCUS_BUTTON)
+      {
+        meta_change_button_grab (display, window->xwindow,
+                                 FALSE, FALSE, i, 0);
+        
+        ++i;
+      }
+
+    window->have_focus_click_grab = FALSE;
+  }
+}
+
+void
+meta_display_increment_event_serial (MetaDisplay *display)
+{
+  /* We just make some random X request */
+  XDeleteProperty (display->xdisplay, display->leader_window,
+                   display->atom__MOTIF_WM_HINTS);
+}
+
+void
+meta_display_update_active_window_hint (MetaDisplay *display)
+{
+  GSList *tmp;
+  
+  gulong data[1];
+
+  if (display->focus_window)
+    data[0] = display->focus_window->xwindow;
+  else
+    data[0] = None;
+  
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+      
+      meta_error_trap_push (display);
+      XChangeProperty (display->xdisplay, screen->xroot,
+                       display->atom__NET_ACTIVE_WINDOW,
+                       XA_WINDOW,
+                       32, PropModeReplace, (guchar*) data, 1);
+
+      meta_error_trap_pop (display, FALSE);
+
+      tmp = tmp->next;
+    }
+}
+
+void
+meta_display_queue_retheme_all_windows (MetaDisplay *display)
+{
+  GSList* windows;
+  GSList *tmp;
+
+  windows = meta_display_list_windows (display);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+      
+      meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+      if (window->frame)
+        {
+          window->frame->need_reapply_frame_shape = TRUE;
+          
+          meta_frame_queue_draw (window->frame);
+        }
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+}
+
+void
+meta_display_retheme_all (void)
+{
+  meta_display_queue_retheme_all_windows (meta_get_display ());
+}
+
+void 
+meta_display_set_cursor_theme (const char *theme, 
+			       int         size)
+{
+#ifdef HAVE_XCURSOR     
+  GSList *tmp;
+
+  MetaDisplay *display = meta_get_display ();
+
+  XcursorSetTheme (display->xdisplay, theme);
+  XcursorSetDefaultSize (display->xdisplay, size);
+
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+	  	  
+      meta_screen_update_cursor (screen);
+
+      tmp = tmp->next;
+    }
+
+#endif
+}
+
+/**
+ * Stores whether syncing is currently enabled.
+ */
+static gboolean is_syncing = FALSE;
+
+/**
+ * Returns whether X synchronisation is currently enabled.
+ *
+ * \return true if we must wait for events whenever we send X requests;
+ * false otherwise.
+ *
+ * \bug This is *only* called by meta_display_open, but by that time
+ * we have already turned syncing on or off on startup, and we don't
+ * have any way to do so while Marco is running, so it's rather
+ * pointless.
+ */
+gboolean
+meta_is_syncing (void)
+{
+  return is_syncing;
+}
+
+/**
+ * A handy way to turn on synchronisation on or off for every display.
+ *
+ * \bug Of course there is only one display ever anyway, so this can
+ * be rather hugely simplified.
+ */
+void
+meta_set_syncing (gboolean setting)
+{
+  if (setting != is_syncing)
+    {
+      is_syncing = setting;
+      if (meta_get_display ())
+        XSynchronize (meta_get_display ()->xdisplay, is_syncing);
+    }
+}
+
+/**
+ * How long, in milliseconds, we should wait after pinging a window
+ * before deciding it's not going to get back to us.
+ */
+#define PING_TIMEOUT_DELAY 5000
+
+/**
+ * Does whatever it is we decided to do when a window didn't respond
+ * to a ping. We also remove the ping from the display's list of
+ * pending pings. This function is called by the event loop when the timeout
+ * times out which we created at the start of the ping.
+ *
+ * \param data All the information about this ping. It is a MetaPingData
+ *             cast to a void* in order to be passable to a timeout function.
+ *             This function will also free this parameter.
+ *
+ * \return Always returns false, because this function is called as a
+ *         timeout and we don't want to run the timer again.
+ *
+ * \ingroup pings
+ */
+static gboolean
+meta_display_ping_timeout (gpointer data)
+{
+  MetaPingData *ping_data;
+
+  ping_data = data;
+
+  ping_data->ping_timeout_id = 0;
+
+  meta_topic (META_DEBUG_PING,
+              "Ping %u on window %lx timed out\n",
+              ping_data->timestamp, ping_data->xwindow);
+  
+  (* ping_data->ping_timeout_func) (ping_data->display, ping_data->xwindow,
+                                    ping_data->timestamp, ping_data->user_data);
+
+  ping_data->display->pending_pings =
+    g_slist_remove (ping_data->display->pending_pings,
+                    ping_data);
+  ping_data_free (ping_data);
+  
+  return FALSE;
+}
+
+/**
+ * Sends a ping request to a window. The window must respond to
+ * the request within a certain amount of time. If it does, we
+ * will call one callback; if the time passes and we haven't had
+ * a response, we call a different callback. The window must have
+ * the hint showing that it can respond to a ping; if it doesn't,
+ * we call the "got a response" callback immediately and return.
+ * This function returns straight away after setting things up;
+ * the callbacks will be called from the event loop.
+ *
+ * \param display  The MetaDisplay that the window is on
+ * \param window   The MetaWindow to send the ping to
+ * \param timestamp The timestamp of the ping. Used for uniqueness.
+ *                  Cannot be CurrentTime; use a real timestamp!
+ * \param ping_reply_func The callback to call if we get a response.
+ * \param ping_timeout_func The callback to call if we don't get a response.
+ * \param user_data Arbitrary data that will be passed to the callback
+ *                  function. (In practice it's often a pointer to
+ *                  the window.)
+ *
+ * \bug This should probably be a method on windows, rather than displays
+ *      for one of their windows.
+ *
+ * \ingroup pings
+ */
+void
+meta_display_ping_window (MetaDisplay       *display,
+			  MetaWindow        *window,
+			  guint32            timestamp,
+			  MetaWindowPingFunc ping_reply_func,
+			  MetaWindowPingFunc ping_timeout_func,
+			  gpointer           user_data)
+{
+  MetaPingData *ping_data;
+
+  if (timestamp == CurrentTime)
+    {
+      meta_warning ("Tried to ping a window with CurrentTime! Not allowed.\n");
+      return;
+    }
+
+  if (!window->net_wm_ping)
+    {
+      if (ping_reply_func)
+        (* ping_reply_func) (display, window->xwindow, timestamp, user_data);
+
+      return;
+    }
+  
+  ping_data = g_new (MetaPingData, 1);
+  ping_data->display = display;
+  ping_data->xwindow = window->xwindow;
+  ping_data->timestamp = timestamp;
+  ping_data->ping_reply_func = ping_reply_func;
+  ping_data->ping_timeout_func = ping_timeout_func;
+  ping_data->user_data = user_data;
+  ping_data->ping_timeout_id = g_timeout_add (PING_TIMEOUT_DELAY,
+					      meta_display_ping_timeout,
+					      ping_data);
+  
+  display->pending_pings = g_slist_prepend (display->pending_pings, ping_data);
+
+  meta_topic (META_DEBUG_PING,
+              "Sending ping with timestamp %u to window %s\n",
+              timestamp, window->desc);
+  meta_window_send_icccm_message (window,
+                                  display->atom__NET_WM_PING,
+                                  timestamp);
+}
+
+static void
+process_request_frame_extents (MetaDisplay    *display,
+                               XEvent         *event)
+{
+  /* The X window whose frame extents will be set. */
+  Window xwindow = event->xclient.window;
+  unsigned long data[4] = { 0, 0, 0, 0 };
+
+  MotifWmHints *hints = NULL;
+  gboolean hints_set = FALSE;
+
+  meta_verbose ("Setting frame extents for 0x%lx\n", xwindow);
+
+  /* See if the window is decorated. */
+  hints_set = meta_prop_get_motif_hints (display,
+                                         xwindow,
+                                         display->atom__MOTIF_WM_HINTS,
+                                         &hints);
+  if ((hints_set && hints->decorations) || !hints_set)
+    {
+      int top = 0;
+      int bottom = 0;
+      int left = 0;
+      int right = 0;
+
+      MetaScreen *screen;
+
+      screen = meta_display_screen_for_xwindow (display,
+                                                event->xclient.window);
+      if (screen == NULL)
+        {
+          meta_warning ("Received request to set _NET_FRAME_EXTENTS "
+                        "on 0x%lx which is on a screen we are not managing\n",
+                        event->xclient.window);
+          meta_XFree (hints);
+          return;
+        }
+
+      /* Return estimated frame extents for a normal window. */
+      meta_ui_theme_get_frame_borders (screen->ui,
+                                       META_FRAME_TYPE_NORMAL,
+                                       0,
+                                       &top,
+                                       &bottom,
+                                       &left,
+                                       &right);
+
+      data[0] = left;
+      data[1] = right;
+      data[2] = top;
+      data[3] = bottom;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting _NET_FRAME_EXTENTS on unmanaged window 0x%lx "
+              "to top = %lu, left = %lu, bottom = %lu, right = %lu\n",
+              xwindow, data[0], data[1], data[2], data[3]);
+
+  meta_error_trap_push (display);
+  XChangeProperty (display->xdisplay, xwindow,
+                   display->atom__NET_FRAME_EXTENTS,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 4);
+  meta_error_trap_pop (display, FALSE);
+
+  meta_XFree (hints);
+}
+
+/**
+ * Process the pong (the response message) from the ping we sent
+ * to the window. This involves removing the timeout, calling the
+ * reply handler function, and freeing memory.
+ *
+ * \param display  the display we got the pong from
+ * \param event    the XEvent which is a pong; we can tell which
+ *                 ping it corresponds to because it bears the
+ *                 same timestamp.
+ *
+ * \ingroup pings
+ */
+static void
+process_pong_message (MetaDisplay    *display,
+                      XEvent         *event)
+{
+  GSList *tmp;
+  guint32 timestamp = event->xclient.data.l[1];
+
+  meta_topic (META_DEBUG_PING, "Received a pong with timestamp %u\n",
+              timestamp);
+  
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+			  
+      if (timestamp == ping_data->timestamp)
+        {
+          meta_topic (META_DEBUG_PING,
+                      "Matching ping found for pong %u\n", 
+                      ping_data->timestamp);
+
+          /* Remove the ping data from the list */
+          display->pending_pings = g_slist_remove (display->pending_pings,
+                                                   ping_data);
+
+          /* Remove the timeout */
+          if (ping_data->ping_timeout_id != 0)
+            {
+              g_source_remove (ping_data->ping_timeout_id);
+              ping_data->ping_timeout_id = 0;
+            }
+          
+          /* Call callback */
+          (* ping_data->ping_reply_func) (display, 
+                                          ping_data->xwindow,
+                                          ping_data->timestamp, 
+                                          ping_data->user_data);
+			      
+          ping_data_free (ping_data);
+
+          break;
+        }
+    }
+}
+
+/**
+ * Finds whether a window has any pings waiting on it.
+ *
+ * \param display The MetaDisplay of the window.
+ * \param window  The MetaWindow whose pings we want to know about.
+ *
+ * \return True if there is at least one ping which has been sent
+ *         to the window without getting a response; false otherwise.
+ *
+ * \bug This should probably be a method on windows, rather than displays
+ *      for one of their windows.
+ *
+ * \ingroup pings
+ */
+gboolean
+meta_display_window_has_pending_pings (MetaDisplay *display,
+				       MetaWindow  *window)
+{
+  GSList *tmp;
+
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (ping_data->xwindow == window->xwindow) 
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+MetaGroup*
+get_focussed_group (MetaDisplay *display)
+{
+  if (display->focus_window)
+    return display->focus_window->group;
+  else
+    return NULL;
+}
+
+#define IN_TAB_CHAIN(w,t) (((t) == META_TAB_LIST_NORMAL && META_WINDOW_IN_NORMAL_TAB_CHAIN (w)) \
+    || ((t) == META_TAB_LIST_DOCKS && META_WINDOW_IN_DOCK_TAB_CHAIN (w)) \
+    || ((t) == META_TAB_LIST_GROUP && META_WINDOW_IN_GROUP_TAB_CHAIN (w, get_focussed_group(w->display))))
+
+static MetaWindow*
+find_tab_forward (MetaDisplay   *display,
+                  MetaTabList    type,
+                  MetaScreen    *screen, 
+                  MetaWorkspace *workspace,
+                  GList         *start,
+                  gboolean       skip_first)
+{
+  GList *tmp;
+
+  g_return_val_if_fail (start != NULL, NULL);
+  g_return_val_if_fail (workspace != NULL, NULL);
+
+  tmp = start;
+  if (skip_first)
+    tmp = tmp->next;
+
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (window->screen == screen &&
+	  IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->next;
+    }
+
+  tmp = workspace->mru_list;
+  while (tmp != start && tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->next;
+    }  
+
+  return NULL;
+}
+
+static MetaWindow*
+find_tab_backward (MetaDisplay   *display,
+                   MetaTabList    type,
+                   MetaScreen    *screen, 
+                   MetaWorkspace *workspace,
+                   GList         *start,
+                   gboolean       skip_last)
+{
+  GList *tmp;
+
+  g_return_val_if_fail (start != NULL, NULL);
+  g_return_val_if_fail (workspace != NULL, NULL);
+
+  tmp = start;
+  if (skip_last)  
+    tmp = tmp->prev;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (window->screen == screen &&
+	  IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->prev;
+    }
+
+  tmp = g_list_last (workspace->mru_list);
+  while (tmp != start)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->prev;
+    }
+
+  return NULL;
+}
+
+GList*
+meta_display_get_tab_list (MetaDisplay   *display,
+                           MetaTabList    type,
+                           MetaScreen    *screen,
+                           MetaWorkspace *workspace)
+{
+  GList *tab_list;
+
+  g_return_val_if_fail (workspace != NULL, NULL);
+
+  /* Windows sellout mode - MRU order. Collect unminimized windows
+   * then minimized so minimized windows aren't in the way so much.
+   */
+  {
+    GList *tmp;
+    
+    tab_list = NULL;
+    tmp = workspace->mru_list;
+    while (tmp != NULL)
+      {
+        MetaWindow *window = tmp->data;
+        
+        if (!window->minimized &&
+            window->screen == screen &&
+            IN_TAB_CHAIN (window, type))
+          tab_list = g_list_prepend (tab_list, window);
+        
+        tmp = tmp->next;
+      }
+  }
+
+  {
+    GList *tmp;
+    
+    tmp = workspace->mru_list;
+    while (tmp != NULL)
+      {
+        MetaWindow *window = tmp->data;
+        
+        if (window->minimized &&
+            window->screen == screen &&
+            IN_TAB_CHAIN (window, type))
+          tab_list = g_list_prepend (tab_list, window);
+        
+        tmp = tmp->next;
+      }
+  }
+
+  tab_list = g_list_reverse (tab_list);
+
+  {
+    GSList *tmp;
+    MetaWindow *l_window;
+
+    tmp = meta_display_list_windows (display);
+
+    /* Go through all windows */
+    while (tmp != NULL)
+      {
+        l_window=tmp->data;
+
+        /* Check to see if it demands attention */
+        if (l_window->wm_state_demands_attention && 
+            l_window->workspace!=workspace &&
+            IN_TAB_CHAIN (l_window, type)) 
+          {
+            /* if it does, add it to the popup */
+            tab_list = g_list_prepend (tab_list, l_window);
+          }
+
+        tmp = tmp->next;
+      } /* End while tmp!=NULL */
+  }
+  
+  return tab_list;
+}
+
+MetaWindow*
+meta_display_get_tab_next (MetaDisplay   *display,
+                           MetaTabList    type,
+                           MetaScreen    *screen,
+                           MetaWorkspace *workspace,
+                           MetaWindow    *window,
+                           gboolean       backward)
+{
+  gboolean skip;
+  GList *tab_list;
+  MetaWindow *ret;
+  tab_list = meta_display_get_tab_list(display,
+                                       type,
+                                       screen,
+                                       workspace);
+
+  if (tab_list == NULL)
+    return NULL;
+  
+  if (window != NULL)
+    {
+      g_assert (window->display == display);
+      
+      if (backward)
+        ret = find_tab_backward (display, type, screen, workspace,
+                                 g_list_find (tab_list,
+                                              window),
+                                 TRUE);
+      else
+        ret = find_tab_forward (display, type, screen, workspace,
+                                g_list_find (tab_list,
+                                             window),
+                                TRUE);
+    }
+  else
+    {
+      skip = display->focus_window != NULL && 
+             tab_list->data == display->focus_window;
+      if (backward)
+        ret = find_tab_backward (display, type, screen, workspace,
+                                 tab_list, skip);
+      else
+        ret = find_tab_forward (display, type, screen, workspace,
+                                tab_list, skip);
+    }
+
+  g_list_free (tab_list);
+  return ret;
+}
+
+MetaWindow*
+meta_display_get_tab_current (MetaDisplay   *display,
+                              MetaTabList    type,
+                              MetaScreen    *screen,
+                              MetaWorkspace *workspace)
+{
+  MetaWindow *window;
+
+  window = display->focus_window;
+  
+  if (window != NULL &&
+      window->screen == screen &&
+      IN_TAB_CHAIN (window, type) &&
+      (workspace == NULL ||
+       meta_window_located_on_workspace (window, workspace)))
+    return window;
+  else
+    return NULL;
+}
+
+int
+meta_resize_gravity_from_grab_op (MetaGrabOp op)
+{
+  int gravity;
+  
+  gravity = -1;
+  switch (op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+      gravity = NorthWestGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_RESIZING_S:
+      gravity = NorthGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_RESIZING_SW:
+      gravity = NorthEastGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_RESIZING_N:
+      gravity = SouthGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NE:
+      gravity = SouthWestGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_NW:
+      gravity = SouthEastGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_RESIZING_E:
+      gravity = WestGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_RESIZING_W:
+      gravity = EastGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+      gravity = CenterGravity;
+      break;
+    default:
+      break;
+    }
+
+  return gravity;
+}
+
+static MetaScreen*
+find_screen_for_selection (MetaDisplay *display,
+                           Window       owner,
+                           Atom         selection)
+{  
+  GSList *tmp;  
+  
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+      
+      if (screen->wm_sn_selection_window == owner &&
+          screen->wm_sn_atom == selection)
+        return screen;
+  
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+/* from fvwm2, Copyright Matthias Clasen, Dominik Vogt */
+static gboolean
+convert_property (MetaDisplay *display,
+                  MetaScreen  *screen,
+                  Window       w,
+                  Atom         target,
+                  Atom         property)
+{
+#define N_TARGETS 4
+  Atom conversion_targets[N_TARGETS];
+  long icccm_version[] = { 2, 0 };
+
+  conversion_targets[0] = display->atom_TARGETS;
+  conversion_targets[1] = display->atom_MULTIPLE;
+  conversion_targets[2] = display->atom_TIMESTAMP;
+  conversion_targets[3] = display->atom_VERSION;
+
+  meta_error_trap_push_with_return (display);
+  if (target == display->atom_TARGETS)
+    XChangeProperty (display->xdisplay, w, property,
+		     XA_ATOM, 32, PropModeReplace,
+		     (unsigned char *)conversion_targets, N_TARGETS);
+  else if (target == display->atom_TIMESTAMP)
+    XChangeProperty (display->xdisplay, w, property,
+		     XA_INTEGER, 32, PropModeReplace,
+		     (unsigned char *)&screen->wm_sn_timestamp, 1);
+  else if (target == display->atom_VERSION)
+    XChangeProperty (display->xdisplay, w, property,
+		     XA_INTEGER, 32, PropModeReplace,
+		     (unsigned char *)icccm_version, 2);
+  else
+    {
+      meta_error_trap_pop_with_return (display, FALSE);
+      return FALSE;
+    }
+  
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    return FALSE;
+
+  /* Be sure the PropertyNotify has arrived so we
+   * can send SelectionNotify
+   */
+  /* FIXME the error trap pop synced anyway, right? */
+  meta_topic (META_DEBUG_SYNC, "Syncing on %s\n", G_STRFUNC);
+  XSync (display->xdisplay, False);
+
+  return TRUE;
+}
+
+/* from fvwm2, Copyright Matthias Clasen, Dominik Vogt */
+static void
+process_selection_request (MetaDisplay   *display,
+                           XEvent        *event)
+{
+  XSelectionEvent reply;
+  MetaScreen *screen;
+
+  screen = find_screen_for_selection (display,
+                                      event->xselectionrequest.owner,
+                                      event->xselectionrequest.selection);
+
+  if (screen == NULL)
+    {
+      char *str;
+      
+      meta_error_trap_push (display);
+      str = XGetAtomName (display->xdisplay,
+                          event->xselectionrequest.selection);
+      meta_error_trap_pop (display, TRUE);
+      
+      meta_verbose ("Selection request with selection %s window 0x%lx not a WM_Sn selection we recognize\n",
+                    str ? str : "(bad atom)", event->xselectionrequest.owner);
+      
+      meta_XFree (str);
+
+      return;
+    }
+  
+  reply.type = SelectionNotify;
+  reply.display = display->xdisplay;
+  reply.requestor = event->xselectionrequest.requestor;
+  reply.selection = event->xselectionrequest.selection;
+  reply.target = event->xselectionrequest.target;
+  reply.property = None;
+  reply.time = event->xselectionrequest.time;
+
+  if (event->xselectionrequest.target == display->atom_MULTIPLE)
+    {
+      if (event->xselectionrequest.property != None)
+        {
+          Atom type, *adata;
+          int i, format;
+          unsigned long num, rest;
+          unsigned char *data;
+
+          meta_error_trap_push_with_return (display);
+          if (XGetWindowProperty (display->xdisplay,
+                                  event->xselectionrequest.requestor,
+                                  event->xselectionrequest.property, 0, 256, False,
+                                  display->atom_ATOM_PAIR,
+                                  &type, &format, &num, &rest, &data) != Success)
+            {
+              meta_error_trap_pop_with_return (display, TRUE);
+              return;
+            }
+          
+          if (meta_error_trap_pop_with_return (display, TRUE) == Success)
+            {              
+              /* FIXME: to be 100% correct, should deal with rest > 0,
+               * but since we have 4 possible targets, we will hardly ever
+               * meet multiple requests with a length > 8
+               */
+              adata = (Atom*)data;
+              i = 0;
+              while (i < (int) num)
+                {
+                  if (!convert_property (display, screen,
+                                         event->xselectionrequest.requestor,
+                                         adata[i], adata[i+1]))
+                    adata[i+1] = None;
+                  i += 2;
+                }
+
+              meta_error_trap_push (display);
+              XChangeProperty (display->xdisplay,
+                               event->xselectionrequest.requestor,
+                               event->xselectionrequest.property,
+                               display->atom_ATOM_PAIR,
+                               32, PropModeReplace, data, num);
+              meta_error_trap_pop (display, FALSE);
+              meta_XFree (data);
+            }
+        }
+    }
+  else
+    {
+      if (event->xselectionrequest.property == None)
+        event->xselectionrequest.property = event->xselectionrequest.target;
+      
+      if (convert_property (display, screen,
+                            event->xselectionrequest.requestor,
+                            event->xselectionrequest.target,
+                            event->xselectionrequest.property))
+        reply.property = event->xselectionrequest.property;
+    }
+
+  XSendEvent (display->xdisplay,
+              event->xselectionrequest.requestor,
+              False, 0L, (XEvent*)&reply);
+
+  meta_verbose ("Handled selection request\n");
+}
+
+static void
+process_selection_clear (MetaDisplay   *display,
+                         XEvent        *event)
+{
+  /* We need to unmanage the screen on which we lost the selection */
+  MetaScreen *screen;
+
+  screen = find_screen_for_selection (display,
+                                      event->xselectionclear.window,
+                                      event->xselectionclear.selection);
+  
+
+  if (screen != NULL)
+    {
+      meta_verbose ("Got selection clear for screen %d on display %s\n",
+                    screen->number, display->name);
+      
+      meta_display_unmanage_screen (&display, 
+                                    screen,
+                                    event->xselectionclear.time);
+
+      if (!display)
+        the_display = NULL;
+
+      /* display and screen may both be invalid memory... */
+      
+      return;
+    }
+
+  {
+    char *str;
+            
+    meta_error_trap_push (display);
+    str = XGetAtomName (display->xdisplay,
+                        event->xselectionclear.selection);
+    meta_error_trap_pop (display, TRUE);
+
+    meta_verbose ("Selection clear with selection %s window 0x%lx not a WM_Sn selection we recognize\n",
+                  str ? str : "(bad atom)", event->xselectionclear.window);
+
+    meta_XFree (str);
+  }
+}
+
+void
+meta_display_unmanage_screen (MetaDisplay **displayp,
+                              MetaScreen  *screen,
+                              guint32      timestamp)
+{
+  MetaDisplay *display = *displayp;
+
+  meta_verbose ("Unmanaging screen %d on display %s\n",
+                screen->number, display->name);
+  
+  g_return_if_fail (g_slist_find (display->screens, screen) != NULL);
+  
+  meta_screen_free (screen, timestamp);
+  display->screens = g_slist_remove (display->screens, screen);
+
+  if (display->screens == NULL)
+    {
+      meta_display_close (display, timestamp);
+      *displayp = NULL;
+    }
+}
+
+void
+meta_display_unmanage_windows_for_screen (MetaDisplay *display,
+                                          MetaScreen  *screen,
+                                          guint32      timestamp)
+{
+  GSList *tmp;
+  GSList *winlist;
+
+  winlist = meta_display_list_windows (display);
+  winlist = g_slist_sort (winlist, meta_display_stack_cmp);
+
+  /* Unmanage all windows */
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      meta_window_free (tmp->data, timestamp);
+      
+      tmp = tmp->next;
+    }
+  g_slist_free (winlist);
+}
+
+int
+meta_display_stack_cmp (const void *a,
+                        const void *b)
+{
+  MetaWindow *aw = (void*) a;
+  MetaWindow *bw = (void*) b;
+
+  if (aw->screen == bw->screen)
+    return meta_stack_windows_cmp (aw->screen->stack, aw, bw);
+  /* Then assume screens are stacked by number */
+  else if (aw->screen->number < bw->screen->number)
+    return -1;
+  else if (aw->screen->number > bw->screen->number)
+    return 1;
+  else
+    return 0; /* not reached in theory, if windows on same display */
+}
+
+void
+meta_display_devirtualize_modifiers (MetaDisplay        *display,
+                                     MetaVirtualModifier modifiers,
+                                     unsigned int       *mask)
+{
+  *mask = 0;
+  
+  if (modifiers & META_VIRTUAL_SHIFT_MASK)
+    *mask |= ShiftMask;
+  if (modifiers & META_VIRTUAL_CONTROL_MASK)
+    *mask |= ControlMask;
+  if (modifiers & META_VIRTUAL_ALT_MASK)
+    *mask |= Mod1Mask;
+  if (modifiers & META_VIRTUAL_META_MASK)
+    *mask |= display->meta_mask;
+  if (modifiers & META_VIRTUAL_HYPER_MASK)
+    *mask |= display->hyper_mask;
+  if (modifiers & META_VIRTUAL_SUPER_MASK)
+    *mask |= display->super_mask;
+  if (modifiers & META_VIRTUAL_MOD2_MASK)
+    *mask |= Mod2Mask;
+  if (modifiers & META_VIRTUAL_MOD3_MASK)
+    *mask |= Mod3Mask;
+  if (modifiers & META_VIRTUAL_MOD4_MASK)
+    *mask |= Mod4Mask;
+  if (modifiers & META_VIRTUAL_MOD5_MASK)
+    *mask |= Mod5Mask;  
+}
+
+static void
+update_window_grab_modifiers (MetaDisplay *display)
+     
+{
+  MetaVirtualModifier virtual_mods;
+  unsigned int mods;
+    
+  virtual_mods = meta_prefs_get_mouse_button_mods ();
+  meta_display_devirtualize_modifiers (display, virtual_mods,
+                                       &mods);
+    
+  display->window_grab_modifiers = mods;
+}
+
+static void
+prefs_changed_callback (MetaPreference pref,
+                        void          *data)
+{
+  MetaDisplay *display = data;
+  
+  /* It may not be obvious why we regrab on focus mode
+   * change; it's because we handle focus clicks a
+   * bit differently for the different focus modes.
+   */
+  if (pref == META_PREF_MOUSE_BUTTON_MODS ||
+      pref == META_PREF_FOCUS_MODE)
+    {
+      MetaDisplay *display = data;
+      GSList *windows;
+      GSList *tmp;
+      
+      windows = meta_display_list_windows (display);
+      
+      /* Ungrab all */
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *w = tmp->data;
+          meta_display_ungrab_window_buttons (display, w->xwindow);
+          meta_display_ungrab_focus_window_button (display, w);
+          tmp = tmp->next;
+        }
+
+      /* change our modifier */
+      if (pref == META_PREF_MOUSE_BUTTON_MODS)
+        update_window_grab_modifiers (display);
+
+      /* Grab all */
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *w = tmp->data;
+          if (w->type != META_WINDOW_DOCK)
+            {
+              meta_display_grab_focus_window_button (display, w);
+              meta_display_grab_window_buttons (display, w->xwindow);
+            }
+          tmp = tmp->next;
+        }
+
+      g_slist_free (windows);
+    }
+  else if (pref == META_PREF_AUDIBLE_BELL)
+    {
+      meta_bell_set_audible (display, meta_prefs_bell_is_audible ());
+    }
+  else if (pref == META_PREF_COMPOSITING_MANAGER)
+    {
+      gboolean cm = meta_prefs_get_compositing_manager ();
+
+      if (cm)
+        enable_compositor (display, TRUE);
+      else
+	disable_compositor (display);
+    }
+}
+
+void
+meta_display_increment_focus_sentinel (MetaDisplay *display)
+{
+  unsigned long data[1];
+
+  data[0] = meta_display_get_current_time (display);
+  
+  XChangeProperty (display->xdisplay,
+                   ((MetaScreen*) display->screens->data)->xroot,
+                   display->atom__MARCO_SENTINEL,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  
+  display->sentinel_counter += 1;
+}
+
+void
+meta_display_decrement_focus_sentinel (MetaDisplay *display)
+{
+  display->sentinel_counter -= 1;
+
+  if (display->sentinel_counter < 0)
+    display->sentinel_counter = 0;
+}
+
+gboolean
+meta_display_focus_sentinel_clear (MetaDisplay *display)
+{
+  return (display->sentinel_counter == 0);
+}
+
+static void
+sanity_check_timestamps (MetaDisplay *display,
+                         guint32      timestamp)
+{
+  if (XSERVER_TIME_IS_BEFORE (timestamp, display->last_focus_time))
+    {
+      meta_warning ("last_focus_time (%u) is greater than comparison "
+                    "timestamp (%u).  This most likely represents a buggy "
+                    "client sending inaccurate timestamps in messages such as "
+                    "_NET_ACTIVE_WINDOW.  Trying to work around...\n",
+                    display->last_focus_time, timestamp);
+      display->last_focus_time = timestamp;
+    }
+  if (XSERVER_TIME_IS_BEFORE (timestamp, display->last_user_time))
+    {
+      GSList *windows;
+      GSList *tmp;
+
+      meta_warning ("last_user_time (%u) is greater than comparison "
+                    "timestamp (%u).  This most likely represents a buggy "
+                    "client sending inaccurate timestamps in messages such as "
+                    "_NET_ACTIVE_WINDOW.  Trying to work around...\n",
+                    display->last_user_time, timestamp);
+      display->last_user_time = timestamp;
+
+      windows = meta_display_list_windows (display);
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *window = tmp->data;
+          
+          if (XSERVER_TIME_IS_BEFORE (timestamp, window->net_wm_user_time))
+            {
+              meta_warning ("%s appears to be one of the offending windows "
+                            "with a timestamp of %u.  Working around...\n",
+                            window->desc, window->net_wm_user_time);
+              window->net_wm_user_time = timestamp;
+            }
+          
+          tmp = tmp->next;
+        }
+
+      g_slist_free (windows);
+    }
+}
+
+static gboolean
+timestamp_too_old (MetaDisplay *display,
+                   MetaWindow  *window,
+                   guint32     *timestamp)
+{
+  /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
+   * us to sanity check the timestamp here and ensure it doesn't correspond to
+   * a future time (though we would want to rename to 
+   * timestamp_too_old_or_in_future).
+   */
+
+  if (*timestamp == CurrentTime)
+    {
+      meta_warning ("Got a request to focus %s with a timestamp of 0.  This "
+                    "shouldn't happen!\n",
+                    window ? window->desc : "the no_focus_window");
+      meta_print_backtrace ();
+      *timestamp = meta_display_get_current_time_roundtrip (display);
+      return FALSE;
+    }
+  else if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_focus_time))
+    {
+      if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_user_time))
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Ignoring focus request for %s since %u "
+                      "is less than %u and %u.\n",
+                      window ? window->desc : "the no_focus_window",
+                      *timestamp,
+                      display->last_user_time,
+                      display->last_focus_time);
+          return TRUE;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Received focus request for %s which is newer than most "
+                      "recent user_time, but less recent than "
+                      "last_focus_time (%u < %u < %u); adjusting "
+                      "accordingly.  (See bug 167358)\n",
+                      window ? window->desc : "the no_focus_window",
+                      display->last_user_time,
+                      *timestamp,
+                      display->last_focus_time);
+          *timestamp = display->last_focus_time;
+          return FALSE;
+        }
+    }
+
+  return FALSE;
+}
+
+void
+meta_display_set_input_focus_window (MetaDisplay *display, 
+                                     MetaWindow  *window,
+                                     gboolean     focus_frame,
+                                     guint32      timestamp)
+{
+  if (timestamp_too_old (display, window, &timestamp))
+    return;
+
+  meta_error_trap_push (display);
+  XSetInputFocus (display->xdisplay,
+                  focus_frame ? window->frame->xwindow : window->xwindow,
+                  RevertToPointerRoot,
+                  timestamp);
+  meta_error_trap_pop (display, FALSE);
+
+  display->expected_focus_window = window;
+  display->last_focus_time = timestamp;
+  display->active_screen = window->screen;
+
+  if (window != display->autoraise_window)
+    meta_display_remove_autoraise_callback (window->display);
+}
+
+void
+meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                        MetaScreen  *screen,
+                                        guint32      timestamp)
+{
+  if (timestamp_too_old (display, NULL, &timestamp))
+    return;
+
+  XSetInputFocus (display->xdisplay,
+                  screen->no_focus_window,
+                  RevertToPointerRoot,
+                  timestamp);
+  display->expected_focus_window = NULL;
+  display->last_focus_time = timestamp;
+  display->active_screen = screen;
+
+  meta_display_remove_autoraise_callback (display);
+}
+
+void
+meta_display_remove_autoraise_callback (MetaDisplay *display)
+{
+  if (display->autoraise_timeout_id != 0)
+    {
+      g_source_remove (display->autoraise_timeout_id);
+      display->autoraise_timeout_id = 0;
+      display->autoraise_window = NULL;
+    }
+}
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+void
+meta_display_get_compositor_version (MetaDisplay *display,
+                                     int         *major,
+                                     int         *minor)
+{
+  *major = display->composite_major_version;
+  *minor = display->composite_minor_version;
+}
+#endif
+
+Display *
+meta_display_get_xdisplay (MetaDisplay *display)
+{
+  return display->xdisplay;
+}
+
+MetaCompositor *
+meta_display_get_compositor (MetaDisplay *display)
+{
+  return display->compositor;
+}
+
+GSList *
+meta_display_get_screens (MetaDisplay *display)
+{
+  return display->screens;
+}
+
+gboolean
+meta_display_has_shape (MetaDisplay *display)
+{
+  return META_DISPLAY_HAS_SHAPE (display);
+}
+
+MetaWindow *
+meta_display_get_focus_window (MetaDisplay *display)
+{
+  return display->focus_window;
+}
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+int 
+meta_display_get_damage_event_base (MetaDisplay *display)
+{
+  return display->damage_event_base;
+}
+#endif
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#ifdef HAVE_SHAPE
+int
+meta_display_get_shape_event_base (MetaDisplay *display)
+{
+  return display->shape_event_base;
+}
+#endif
+#endif
diff --git a/src/core/edge-resistance.c b/src/core/edge-resistance.c
new file mode 100644
index 00000000..fd3f2d44
--- /dev/null
+++ b/src/core/edge-resistance.c
@@ -0,0 +1,1277 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Edge resistance for move/resize operations */
+
+/* 
+ * Copyright (C) 2005, 2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "edge-resistance.h"
+#include "boxes.h"
+#include "display-private.h"
+#include "workspace.h"
+
+/* A simple macro for whether a given window's edges are potentially
+ * relevant for resistance/snapping during a move/resize operation
+ */
+#define WINDOW_EDGES_RELEVANT(window, display) \
+  meta_window_should_be_showing (window) &&    \
+  window->screen == display->grab_screen &&    \
+  window         != display->grab_window &&    \
+  window->type   != META_WINDOW_DESKTOP &&     \
+  window->type   != META_WINDOW_MENU    &&     \
+  window->type   != META_WINDOW_SPLASHSCREEN
+
+struct ResistanceDataForAnEdge
+{
+  gboolean     timeout_setup;
+  guint        timeout_id;
+  int          timeout_edge_pos;
+  gboolean     timeout_over;
+  GSourceFunc  timeout_func;
+  MetaWindow  *window;
+  int          keyboard_buildup;
+};
+typedef struct ResistanceDataForAnEdge ResistanceDataForAnEdge;
+
+struct MetaEdgeResistanceData
+{
+  GArray *left_edges;
+  GArray *right_edges;
+  GArray *top_edges;
+  GArray *bottom_edges;
+
+  ResistanceDataForAnEdge left_data;
+  ResistanceDataForAnEdge right_data;
+  ResistanceDataForAnEdge top_data;
+  ResistanceDataForAnEdge bottom_data;
+};
+
+/* !WARNING!: this function can return invalid indices (namely, either -1 or
+ * edges->len); this is by design, but you need to remember this.
+ */
+static int
+find_index_of_edge_near_position (const GArray *edges,
+                                  int           position,
+                                  gboolean      want_interval_min,
+                                  gboolean      horizontal)
+{
+  /* This is basically like a binary search, except that we're trying to
+   * find a range instead of an exact value.  So, if we have in our array
+   *   Value: 3  27 316 316 316 505 522 800 1213
+   *   Index: 0   1   2   3   4   5   6   7    8
+   * and we call this function with position=500 & want_interval_min=TRUE
+   * then we should get 5 (because 505 is the first value bigger than 500).
+   * If we call this function with position=805 and want_interval_min=FALSE
+   * then we should get 7 (because 800 is the last value smaller than 800).
+   * A couple more, to make things clear:
+   *    position  want_interval_min  correct_answer
+   *         316               TRUE               2
+   *         316              FALSE               4
+   *           2              FALSE              -1
+   *        2000               TRUE               9
+   */
+  int low, high, mid;
+  int compare;
+  MetaEdge *edge;
+
+  /* Initialize mid, edge, & compare in the off change that the array only
+   * has one element.
+   */
+  mid  = 0;
+  edge = g_array_index (edges, MetaEdge*, mid);
+  compare = horizontal ? edge->rect.x : edge->rect.y;
+
+  /* Begin the search... */
+  low  = 0;
+  high = edges->len - 1;
+  while (low < high)
+    {
+      mid = low + (high - low)/2;
+      edge = g_array_index (edges, MetaEdge*, mid);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+
+      if (compare == position)
+        break;
+
+      if (compare > position)
+        high = mid - 1;
+      else
+        low = mid + 1;
+    }
+
+  /* mid should now be _really_ close to the index we want, so we start
+   * linearly searching.  However, note that we don't know if mid is less
+   * than or greater than what we need and it's possible that there are
+   * several equal values equal to what we were searching for and we ended
+   * up in the middle of them instead of at the end.  So we may need to
+   * move mid multiple locations over.
+   */
+  if (want_interval_min)
+    {
+      while (compare >= position && mid > 0)
+        {
+          mid--;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+      while (compare < position && mid < (int)edges->len - 1)
+        {
+          mid++;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+
+      /* Special case for no values in array big enough */
+      if (compare < position)
+        return edges->len;
+
+      /* Return the found value */
+      return mid;
+    }
+  else
+    {
+      while (compare <= position && mid < (int)edges->len - 1)
+        {
+          mid++;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+      while (compare > position && mid > 0)
+        {
+          mid--;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+
+      /* Special case for no values in array small enough */
+      if (compare > position)
+        return -1;
+
+      /* Return the found value */
+      return mid;
+    }
+}
+
+static gboolean
+points_on_same_side (int ref, int pt1, int pt2)
+{
+  return (pt1 - ref) * (pt2 - ref) > 0;
+}
+
+static int
+find_nearest_position (const GArray        *edges,
+                       int                  position,
+                       int                  old_position,
+                       const MetaRectangle *new_rect,
+                       gboolean             horizontal,
+                       gboolean             only_forward)
+{
+  /* This is basically just a binary search except that we're looking
+   * for the value closest to position, rather than finding that
+   * actual value.  Also, we ignore any edges that aren't relevant
+   * given the horizontal/vertical position of new_rect.
+   */
+  int low, high, mid;
+  int compare;
+  MetaEdge *edge;
+  int best, best_dist, i;
+  gboolean edges_align;
+
+  /* Initialize mid, edge, & compare in the off change that the array only
+   * has one element.
+   */
+  mid  = 0;
+  edge = g_array_index (edges, MetaEdge*, mid);
+  compare = horizontal ? edge->rect.x : edge->rect.y;
+
+  /* Begin the search... */
+  low  = 0;
+  high = edges->len - 1;
+  while (low < high)
+    {
+      mid = low + (high - low)/2;
+      edge = g_array_index (edges, MetaEdge*, mid);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+
+      if (compare == position)
+        break;
+
+      if (compare > position)
+        high = mid - 1;
+      else
+        low = mid + 1;
+    }
+
+  /* mid should now be _really_ close to the index we want, so we
+   * start searching nearby for something that overlaps and is closer
+   * than the original position.
+   */
+  best = old_position;
+  best_dist = INT_MAX;
+
+  /* Start the search at mid */
+  edge = g_array_index (edges, MetaEdge*, mid);
+  compare = horizontal ? edge->rect.x : edge->rect.y;
+  edges_align = meta_rectangle_edge_aligns (new_rect, edge);
+  if (edges_align &&
+      (!only_forward || !points_on_same_side (position, compare, old_position)))
+    {
+      int dist = ABS (compare - position);
+      if (dist < best_dist)
+        {
+          best = compare;
+          best_dist = dist;
+        }
+    }
+
+  /* Now start searching higher than mid */
+  for (i = mid + 1; i < (int)edges->len; i++)
+    {
+      edge = g_array_index (edges, MetaEdge*, i);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+  
+      edges_align = horizontal ? 
+        meta_rectangle_vert_overlap (&edge->rect, new_rect) :
+        meta_rectangle_horiz_overlap (&edge->rect, new_rect);
+
+      if (edges_align &&
+          (!only_forward ||
+           !points_on_same_side (position, compare, old_position)))
+        {
+          int dist = ABS (compare - position);
+          if (dist < best_dist)
+            {
+              best = compare;
+              best_dist = dist;
+            }
+          break;
+        }
+    }
+
+  /* Now start searching lower than mid */
+  for (i = mid-1; i >= 0; i--)
+    {
+      edge = g_array_index (edges, MetaEdge*, i);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+  
+      edges_align = horizontal ? 
+        meta_rectangle_vert_overlap (&edge->rect, new_rect) :
+        meta_rectangle_horiz_overlap (&edge->rect, new_rect);
+
+      if (edges_align &&
+          (!only_forward ||
+           !points_on_same_side (position, compare, old_position)))
+        {
+          int dist = ABS (compare - position);
+          if (dist < best_dist)
+            {
+              best = compare;
+              best_dist = dist;
+            }
+          break;
+        }
+    }
+
+  /* Return the best one found */
+  return best;
+}
+
+static gboolean
+movement_towards_edge (MetaSide side, int increment)
+{
+  switch (side)
+    {
+    case META_SIDE_LEFT:
+    case META_SIDE_TOP:
+      return increment < 0;
+    case META_SIDE_RIGHT:
+    case META_SIDE_BOTTOM:
+      return increment > 0;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static gboolean
+edge_resistance_timeout (gpointer data)
+{
+  ResistanceDataForAnEdge *resistance_data = data;
+
+  resistance_data->timeout_over = TRUE;
+  resistance_data->timeout_id = 0;
+  (*resistance_data->timeout_func)(resistance_data->window);
+
+  return FALSE;
+}
+
+static int
+apply_edge_resistance (MetaWindow                *window,
+                       int                        old_pos,
+                       int                        new_pos,
+                       const MetaRectangle       *old_rect,
+                       const MetaRectangle       *new_rect,
+                       GArray                    *edges,
+                       ResistanceDataForAnEdge   *resistance_data,
+                       GSourceFunc                timeout_func,
+                       gboolean                   xdir,
+                       gboolean                   keyboard_op)
+{
+  int i, begin, end;
+  int last_edge;
+  gboolean increasing = new_pos > old_pos;
+  int      increment = increasing ? 1 : -1;
+
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW    = 16;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW   =  0;
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA  = 32;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA =  0;
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN    = 32;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN   =  0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW   =   0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA =   0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN   =   0;
+
+  /* Quit if no movement was specified */
+  if (old_pos == new_pos)
+    return new_pos;
+
+  /* Remove the old timeout if it's no longer relevant */
+  if (resistance_data->timeout_setup &&
+      ((resistance_data->timeout_edge_pos > old_pos &&
+        resistance_data->timeout_edge_pos > new_pos)  ||
+       (resistance_data->timeout_edge_pos < old_pos &&
+        resistance_data->timeout_edge_pos < new_pos)))
+    {
+      resistance_data->timeout_setup = FALSE;
+      if (resistance_data->timeout_id != 0)
+        {
+          g_source_remove (resistance_data->timeout_id);
+          resistance_data->timeout_id = 0;
+        }
+    }
+
+  /* Get the range of indices in the edge array that we move past/to. */
+  begin = find_index_of_edge_near_position (edges, old_pos,  increasing, xdir);
+  end   = find_index_of_edge_near_position (edges, new_pos, !increasing, xdir);
+
+  /* begin and end can be outside the array index, if the window is partially
+   * off the screen
+   */
+  last_edge = edges->len - 1;
+  begin = CLAMP (begin, 0, last_edge);
+  end   = CLAMP (end,   0, last_edge);
+
+  /* Loop over all these edges we're moving past/to. */
+  i = begin;
+  while ((increasing  && i <= end) ||
+         (!increasing && i >= end))
+    {
+      gboolean  edges_align;
+      MetaEdge *edge = g_array_index (edges, MetaEdge*, i);
+      int       compare = xdir ? edge->rect.x : edge->rect.y;
+
+      /* Find out if this edge is relevant */
+      edges_align = meta_rectangle_edge_aligns (new_rect, edge)  ||
+                    meta_rectangle_edge_aligns (old_rect, edge);
+
+      /* Nothing to do unless the edges align */
+      if (!edges_align)
+        {
+          /* Go to the next edge in the range */
+          i += increment;
+          continue;
+        }
+
+      /* Rest is easier to read if we split on keyboard vs. mouse op */
+      if (keyboard_op)
+        {
+          if ((old_pos < compare && compare < new_pos) ||
+              (old_pos > compare && compare > new_pos))
+            return compare;
+        }
+      else /* mouse op */
+        {
+          int threshold;
+
+          /* TIMEOUT RESISTANCE: If the edge is relevant and we're moving
+           * towards it, then we may want to have some kind of time delay
+           * before the user can move past this edge.
+           */
+          if (movement_towards_edge (edge->side_type, increment))
+            {
+              /* First, determine the length of time for the resistance */
+              int timeout_length_ms = 0;
+              switch (edge->edge_type)
+                {
+                case META_EDGE_WINDOW:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW;
+                  break;
+                case META_EDGE_XINERAMA:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA;
+                  break;
+                case META_EDGE_SCREEN:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
+                  break;
+                }
+
+              if (!resistance_data->timeout_setup &&
+                  timeout_length_ms != 0)
+                {
+                  resistance_data->timeout_id = 
+                    g_timeout_add (timeout_length_ms,
+                                   edge_resistance_timeout,
+                                   resistance_data);
+                  resistance_data->timeout_setup = TRUE;
+                  resistance_data->timeout_edge_pos = compare;
+                  resistance_data->timeout_over = FALSE;
+                  resistance_data->timeout_func = timeout_func;
+                  resistance_data->window = window;
+                }
+              if (!resistance_data->timeout_over &&
+                  timeout_length_ms != 0)
+                return compare;
+            }
+
+          /* PIXEL DISTANCE MOUSE RESISTANCE: If the edge matters and the
+           * user hasn't moved at least threshold pixels past this edge,
+           * stop movement at this edge.  (Note that this is different from
+           * keyboard resistance precisely because keyboard move ops are
+           * relative to previous positions, whereas mouse move ops are
+           * relative to differences in mouse position and mouse position
+           * is an absolute quantity rather than a relative quantity)
+           */
+
+          /* First, determine the threshold */
+          threshold = 0;
+          switch (edge->edge_type)
+            {
+            case META_EDGE_WINDOW:
+              if (movement_towards_edge (edge->side_type, increment))
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW;
+              else
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW;
+              break;
+            case META_EDGE_XINERAMA:
+              if (movement_towards_edge (edge->side_type, increment))
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA;
+              else
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA;
+              break;
+            case META_EDGE_SCREEN:
+              if (movement_towards_edge (edge->side_type, increment))
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN;
+              else
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN;
+              break;
+            }
+
+          if (ABS (compare - new_pos) < threshold)
+            return compare;
+        }
+
+      /* Go to the next edge in the range */
+      i += increment;
+    }
+
+  return new_pos;
+}
+
+static int
+apply_edge_snapping (int                  old_pos,
+                     int                  new_pos,
+                     const MetaRectangle *new_rect,
+                     GArray              *edges,
+                     gboolean             xdir,
+                     gboolean             keyboard_op)
+{
+  int snap_to;
+
+  if (old_pos == new_pos)
+    return new_pos;
+
+  snap_to = find_nearest_position (edges,
+                                   new_pos,
+                                   old_pos,
+                                   new_rect,
+                                   xdir,
+                                   keyboard_op);
+
+  /* If mouse snap-moving, the user could easily accidentally move just a
+   * couple pixels in a direction they didn't mean to move; so ignore snap
+   * movement in those cases unless it's only a small number of pixels
+   * anyway.
+   */
+  if (!keyboard_op &&
+      ABS (snap_to - old_pos) >= 8 &&
+      ABS (new_pos - old_pos) < 8)
+    return old_pos;
+  else
+    /* Otherwise, return the snapping position found */
+    return snap_to;
+}
+
+/* This function takes the position (including any frame) of the window and
+ * a proposed new position (ignoring edge resistance/snapping), and then
+ * applies edge resistance to EACH edge (separately) updating new_outer.
+ * It returns true if new_outer is modified, false otherwise.
+ *
+ * display->grab_edge_resistance_data MUST already be setup or calling this
+ * function will cause a crash.
+ */
+static gboolean 
+apply_edge_resistance_to_each_side (MetaDisplay         *display,
+                                    MetaWindow          *window,
+                                    const MetaRectangle *old_outer,
+                                    MetaRectangle       *new_outer,
+                                    GSourceFunc          timeout_func,
+                                    gboolean             auto_snap,
+                                    gboolean             keyboard_op,
+                                    gboolean             is_resize)
+{
+  MetaEdgeResistanceData *edge_data;
+  MetaRectangle           modified_rect;
+  gboolean                modified;
+  int new_left, new_right, new_top, new_bottom;
+
+  g_assert (display->grab_edge_resistance_data != NULL);
+  edge_data = display->grab_edge_resistance_data;
+
+  if (auto_snap)
+    {
+      /* Do the auto snapping instead of normal edge resistance; in all
+       * cases, we allow snapping to opposite kinds of edges (e.g. left
+       * sides of windows to both left and right edges.
+       */
+
+      new_left   = apply_edge_snapping (BOX_LEFT (*old_outer),
+                                        BOX_LEFT (*new_outer),
+                                        new_outer,
+                                        edge_data->left_edges,
+                                        TRUE,
+                                        keyboard_op);
+
+      new_right  = apply_edge_snapping (BOX_RIGHT (*old_outer),
+                                        BOX_RIGHT (*new_outer),
+                                        new_outer,
+                                        edge_data->right_edges,
+                                        TRUE,
+                                        keyboard_op);
+
+      new_top    = apply_edge_snapping (BOX_TOP (*old_outer),
+                                        BOX_TOP (*new_outer),
+                                        new_outer,
+                                        edge_data->top_edges,
+                                        FALSE,
+                                        keyboard_op);
+
+      new_bottom = apply_edge_snapping (BOX_BOTTOM (*old_outer),
+                                        BOX_BOTTOM (*new_outer),
+                                        new_outer,
+                                        edge_data->bottom_edges,
+                                        FALSE,
+                                        keyboard_op);
+    }
+  else
+    {
+      /* Disable edge resistance for resizes when windows have size
+       * increment hints; see #346782.  For all other cases, apply
+       * them.
+       */
+      if (!is_resize || window->size_hints.width_inc == 1)
+        {
+          /* Now, apply the normal horizontal edge resistance */
+          new_left   = apply_edge_resistance (window,
+                                              BOX_LEFT (*old_outer),
+                                              BOX_LEFT (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->left_edges,
+                                              &edge_data->left_data,
+                                              timeout_func,
+                                              TRUE,
+                                              keyboard_op);
+          new_right  = apply_edge_resistance (window,
+                                              BOX_RIGHT (*old_outer),
+                                              BOX_RIGHT (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->right_edges,
+                                              &edge_data->right_data,
+                                              timeout_func,
+                                              TRUE,
+                                              keyboard_op);
+        }
+      else
+        {
+          new_left  = new_outer->x;
+          new_right = new_outer->x + new_outer->width;
+        }
+      /* Same for vertical resizes... */
+      if (!is_resize || window->size_hints.height_inc == 1)
+        {
+          new_top    = apply_edge_resistance (window,
+                                              BOX_TOP (*old_outer),
+                                              BOX_TOP (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->top_edges,
+                                              &edge_data->top_data,
+                                              timeout_func,
+                                              FALSE,
+                                              keyboard_op);
+          new_bottom = apply_edge_resistance (window,
+                                              BOX_BOTTOM (*old_outer),
+                                              BOX_BOTTOM (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->bottom_edges,
+                                              &edge_data->bottom_data,
+                                              timeout_func,
+                                              FALSE,
+                                              keyboard_op);
+        }
+      else
+        {
+          new_top    = new_outer->y;
+          new_bottom = new_outer->y + new_outer->height;
+        }
+    }
+
+  /* Determine whether anything changed, and save the changes */
+  modified_rect = meta_rect (new_left, 
+                             new_top,
+                             new_right - new_left,
+                             new_bottom - new_top);
+  modified = !meta_rectangle_equal (new_outer, &modified_rect);
+  *new_outer = modified_rect;
+  return modified;
+}
+
+void
+meta_display_cleanup_edges (MetaDisplay *display)
+{
+  guint i,j;
+  MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data;
+  GHashTable *edges_to_be_freed;
+
+  g_assert (edge_data != NULL);
+
+  /* We first need to clean out any window edges */
+  edges_to_be_freed = g_hash_table_new_full (g_direct_hash, g_direct_equal,
+                                             g_free, NULL);
+  for (i = 0; i < 4; i++)
+    {
+      GArray *tmp = NULL;
+      MetaSide side;
+      switch (i)
+        {
+        case 0:
+          tmp = edge_data->left_edges;
+          side = META_SIDE_LEFT;
+          break;
+        case 1:
+          tmp = edge_data->right_edges;
+          side = META_SIDE_RIGHT;
+          break;
+        case 2:
+          tmp = edge_data->top_edges;
+          side = META_SIDE_TOP;
+          break;
+        case 3:
+          tmp = edge_data->bottom_edges;
+          side = META_SIDE_BOTTOM;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+
+      for (j = 0; j < tmp->len; j++)
+        {
+          MetaEdge *edge = g_array_index (tmp, MetaEdge*, j);
+          if (edge->edge_type == META_EDGE_WINDOW &&
+              edge->side_type == side)
+            {
+              /* The same edge will appear in two arrays, and we can't free
+               * it yet we still need to compare edge->side_type for the other
+               * array that it is in.  So store it in a hash table for later
+               * freeing.  Could also do this in a simple linked list.
+               */
+              g_hash_table_insert (edges_to_be_freed, edge, edge);
+            }
+        }
+    }
+
+  /* Now free all the window edges (the key destroy function is g_free) */
+  g_hash_table_destroy (edges_to_be_freed);
+
+  /* Now free the arrays and data */
+  g_array_free (edge_data->left_edges, TRUE);
+  g_array_free (edge_data->right_edges, TRUE);
+  g_array_free (edge_data->top_edges, TRUE);
+  g_array_free (edge_data->bottom_edges, TRUE);
+  edge_data->left_edges = NULL;
+  edge_data->right_edges = NULL;
+  edge_data->top_edges = NULL;
+  edge_data->bottom_edges = NULL;
+
+  /* Cleanup the timeouts */
+  if (edge_data->left_data.timeout_setup   &&
+      edge_data->left_data.timeout_id   != 0)
+    g_source_remove (edge_data->left_data.timeout_id);
+  if (edge_data->right_data.timeout_setup  &&
+      edge_data->right_data.timeout_id  != 0)
+    g_source_remove (edge_data->right_data.timeout_id);
+  if (edge_data->top_data.timeout_setup    &&
+      edge_data->top_data.timeout_id    != 0)
+    g_source_remove (edge_data->top_data.timeout_id);
+  if (edge_data->bottom_data.timeout_setup &&
+      edge_data->bottom_data.timeout_id != 0)
+    g_source_remove (edge_data->bottom_data.timeout_id);
+
+  g_free (display->grab_edge_resistance_data);
+  display->grab_edge_resistance_data = NULL;
+}
+
+static int
+stupid_sort_requiring_extra_pointer_dereference (gconstpointer a, 
+                                                 gconstpointer b)
+{
+  const MetaEdge * const *a_edge = a;
+  const MetaEdge * const *b_edge = b;
+  return meta_rectangle_edge_cmp_ignore_type (*a_edge, *b_edge);
+}
+
+static void
+cache_edges (MetaDisplay *display,
+             GList *window_edges,
+             GList *xinerama_edges,
+             GList *screen_edges)
+{
+  MetaEdgeResistanceData *edge_data;
+  GList *tmp;
+  int num_left, num_right, num_top, num_bottom;
+  int i;
+
+  /*
+   * 0th: Print debugging information to the log about the edges
+   */
+#ifdef WITH_VERBOSE_MODE
+  if (meta_is_verbose())
+    {
+      int max_edges = MAX (MAX( g_list_length (window_edges), 
+                                g_list_length (xinerama_edges)),
+                           g_list_length (screen_edges));
+      char big_buffer[(EDGE_LENGTH+2)*max_edges];
+
+      meta_rectangle_edge_list_to_string (window_edges, ", ", big_buffer);
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "Window edges for resistance  : %s\n", big_buffer);
+
+      meta_rectangle_edge_list_to_string (xinerama_edges, ", ", big_buffer);
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "Xinerama edges for resistance: %s\n", big_buffer);
+
+      meta_rectangle_edge_list_to_string (screen_edges, ", ", big_buffer);
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "Screen edges for resistance  : %s\n", big_buffer);
+    }
+#endif
+
+  /*
+   * 1st: Get the total number of each kind of edge
+   */
+  num_left = num_right = num_top = num_bottom = 0;
+  for (i = 0; i < 3; i++)
+    {
+      tmp = NULL;
+      switch (i)
+        {
+        case 0:
+          tmp = window_edges;
+          break;
+        case 1:
+          tmp = xinerama_edges;
+          break;
+        case 2:
+          tmp = screen_edges;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+
+      while (tmp)
+        {
+          MetaEdge *edge = tmp->data;
+          switch (edge->side_type)
+            {
+            case META_SIDE_LEFT:
+              num_left++;
+              break;
+            case META_SIDE_RIGHT:
+              num_right++;
+              break;
+            case META_SIDE_TOP:
+              num_top++;
+              break;
+            case META_SIDE_BOTTOM:
+              num_bottom++;
+              break;
+            default:
+              g_assert_not_reached ();
+            }
+          tmp = tmp->next;
+        }
+    }
+
+  /*
+   * 2nd: Allocate the edges
+   */
+  g_assert (display->grab_edge_resistance_data == NULL);
+  display->grab_edge_resistance_data = g_new (MetaEdgeResistanceData, 1);
+  edge_data = display->grab_edge_resistance_data;
+  edge_data->left_edges   = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_left + num_right);
+  edge_data->right_edges  = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_left + num_right);
+  edge_data->top_edges    = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_top + num_bottom);
+  edge_data->bottom_edges = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_top + num_bottom);
+
+  /*
+   * 3rd: Add the edges to the arrays
+   */
+  for (i = 0; i < 3; i++)
+    {
+      tmp = NULL;
+      switch (i)
+        {
+        case 0:
+          tmp = window_edges;
+          break;
+        case 1:
+          tmp = xinerama_edges;
+          break;
+        case 2:
+          tmp = screen_edges;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+
+      while (tmp)
+        {
+          MetaEdge *edge = tmp->data;
+          switch (edge->side_type)
+            {
+            case META_SIDE_LEFT:
+            case META_SIDE_RIGHT:
+              g_array_append_val (edge_data->left_edges, edge);
+              g_array_append_val (edge_data->right_edges, edge);
+              break;
+            case META_SIDE_TOP:
+            case META_SIDE_BOTTOM:
+              g_array_append_val (edge_data->top_edges, edge);
+              g_array_append_val (edge_data->bottom_edges, edge);
+              break;
+            default:
+              g_assert_not_reached ();
+            }
+          tmp = tmp->next;
+        }
+    }
+
+  /*
+   * 4th: Sort the arrays (FIXME: This is kinda dumb since the arrays were
+   * individually sorted earlier and we could have done this faster and
+   * avoided this sort by sticking them into the array with some simple
+   * merging of the lists).
+   */
+  g_array_sort (display->grab_edge_resistance_data->left_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+  g_array_sort (display->grab_edge_resistance_data->right_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+  g_array_sort (display->grab_edge_resistance_data->top_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+  g_array_sort (display->grab_edge_resistance_data->bottom_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+}
+
+static void
+initialize_grab_edge_resistance_data (MetaDisplay *display)
+{
+  MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data;
+
+  edge_data->left_data.timeout_setup   = FALSE;
+  edge_data->right_data.timeout_setup  = FALSE;
+  edge_data->top_data.timeout_setup    = FALSE;
+  edge_data->bottom_data.timeout_setup = FALSE;
+
+  edge_data->left_data.keyboard_buildup   = 0;
+  edge_data->right_data.keyboard_buildup  = 0;
+  edge_data->top_data.keyboard_buildup    = 0;
+  edge_data->bottom_data.keyboard_buildup = 0;
+}
+
+void
+meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display)
+{
+  GList *stacked_windows;
+  GList *cur_window_iter;
+  GList *edges;
+  /* Lists of window positions (rects) and their relative stacking positions */
+  int stack_position;
+  GSList *obscuring_windows, *window_stacking;
+  /* The portions of the above lists that still remain at the stacking position
+   * in the layer that we are working on
+   */
+  GSList *rem_windows, *rem_win_stacking;
+
+  /*
+   * 1st: Get the list of relevant windows, from bottom to top
+   */
+  stacked_windows = 
+    meta_stack_list_windows (display->grab_screen->stack,
+                             display->grab_screen->active_workspace);
+
+  /*
+   * 2nd: we need to separate that stacked list into a list of windows that
+   * can obscure other edges.  To make sure we only have windows obscuring
+   * those below it instead of going both ways, we also need to keep a
+   * counter list.  Messy, I know.
+   */
+  obscuring_windows = window_stacking = NULL;
+  cur_window_iter = stacked_windows;
+  stack_position = 0;
+  while (cur_window_iter != NULL)
+    {
+      MetaWindow *cur_window = cur_window_iter->data;
+      if (WINDOW_EDGES_RELEVANT (cur_window, display))
+        {
+          MetaRectangle *new_rect;
+          new_rect = g_new (MetaRectangle, 1);
+          meta_window_get_outer_rect (cur_window, new_rect);
+          obscuring_windows = g_slist_prepend (obscuring_windows, new_rect);
+          window_stacking = 
+            g_slist_prepend (window_stacking, GINT_TO_POINTER (stack_position));
+        }
+
+      stack_position++;
+      cur_window_iter = cur_window_iter->next;
+    }
+  /* Put 'em in bottom to top order */
+  rem_windows = obscuring_windows = g_slist_reverse (obscuring_windows);
+  rem_win_stacking = window_stacking = g_slist_reverse (window_stacking);
+
+  /*
+   * 3rd: loop over the windows again, this time getting the edges from
+   * them and removing intersections with the relevant obscuring_windows &
+   * obscuring_docks.
+   */
+  edges = NULL;
+  stack_position = 0;
+  cur_window_iter = stacked_windows;
+  while (cur_window_iter != NULL)
+    {
+      MetaRectangle  cur_rect;
+      MetaWindow    *cur_window = cur_window_iter->data;
+      meta_window_get_outer_rect (cur_window, &cur_rect);
+
+      /* Check if we want to use this window's edges for edge
+       * resistance (note that dock edges are considered screen edges
+       * which are handled separately
+       */
+      if (WINDOW_EDGES_RELEVANT (cur_window, display) &&
+          cur_window->type != META_WINDOW_DOCK)
+        {
+          GList *new_edges;
+          MetaEdge *new_edge;
+          MetaRectangle reduced;
+
+          /* We don't care about snapping to any portion of the window that
+           * is offscreen (we also don't care about parts of edges covered
+           * by other windows or DOCKS, but that's handled below).
+           */
+          meta_rectangle_intersect (&cur_rect, 
+                                    &display->grab_screen->rect,
+                                    &reduced);
+
+          new_edges = NULL;
+
+          /* Left side of this window is resistance for the right edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.width = 0;
+          new_edge->side_type = META_SIDE_RIGHT;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+
+          /* Right side of this window is resistance for the left edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.x += new_edge->rect.width;
+          new_edge->rect.width = 0;
+          new_edge->side_type = META_SIDE_LEFT;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+          
+          /* Top side of this window is resistance for the bottom edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.height = 0;
+          new_edge->side_type = META_SIDE_BOTTOM;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+
+          /* Top side of this window is resistance for the bottom edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.y += new_edge->rect.height;
+          new_edge->rect.height = 0;
+          new_edge->side_type = META_SIDE_TOP;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+
+          /* Update the remaining windows to only those at a higher
+           * stacking position than this one.
+           */
+          while (rem_win_stacking && 
+                 stack_position >= GPOINTER_TO_INT (rem_win_stacking->data))
+            {
+              rem_windows      = rem_windows->next;
+              rem_win_stacking = rem_win_stacking->next;
+            }
+
+          /* Remove edge portions overlapped by rem_windows and rem_docks */
+          new_edges = 
+            meta_rectangle_remove_intersections_with_boxes_from_edges (
+              new_edges,
+              rem_windows);
+
+          /* Save the new edges */
+          edges = g_list_concat (new_edges, edges);
+        }
+
+      stack_position++;
+      cur_window_iter = cur_window_iter->next;
+    }
+
+  /*
+   * 4th: Free the extra memory not needed and sort the list
+   */
+  g_list_free (stacked_windows);
+  /* Free the memory used by the obscuring windows/docks lists */
+  g_slist_free (window_stacking);
+  /* FIXME: Shouldn't there be a helper function to make this one line of code
+   * to free a list instead of four ugly ones?
+   */
+  g_slist_foreach (obscuring_windows, 
+                   (void (*)(gpointer,gpointer))&g_free, /* ew, for ugly */
+                   NULL);
+  g_slist_free (obscuring_windows);
+
+  /* Sort the list.  FIXME: Should I bother with this sorting?  I just
+   * sort again later in cache_edges() anyway...
+   */
+  edges = g_list_sort (edges, meta_rectangle_edge_cmp);
+
+  /*
+   * 5th: Cache the combination of these edges with the onscreen and
+   * xinerama edges in an array for quick access.  Free the edges since
+   * they've been cached elsewhere.
+   */
+  cache_edges (display,
+               edges,
+               display->grab_screen->active_workspace->xinerama_edges,
+               display->grab_screen->active_workspace->screen_edges);
+  g_list_free (edges);
+
+  /*
+   * 6th: Initialize the resistance timeouts and buildups
+   */
+  initialize_grab_edge_resistance_data (display);
+}
+
+/* Note that old_[xy] and new_[xy] are with respect to inner positions of
+ * the window.
+ */
+void
+meta_window_edge_resistance_for_move (MetaWindow  *window,
+                                      int          old_x,
+                                      int          old_y,
+                                      int         *new_x,
+                                      int         *new_y,
+                                      GSourceFunc  timeout_func,
+                                      gboolean     snap,
+                                      gboolean     is_keyboard_op)
+{
+  MetaRectangle old_outer, proposed_outer, new_outer;
+  gboolean is_resize;
+
+  if (window == window->display->grab_window &&
+      window->display->grab_wireframe_active)
+    {
+      meta_window_get_xor_rect (window,
+                                &window->display->grab_wireframe_rect,
+                                &old_outer);
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &old_outer);
+    }
+  proposed_outer = old_outer;
+  proposed_outer.x += (*new_x - old_x);
+  proposed_outer.y += (*new_y - old_y);
+  new_outer = proposed_outer;
+
+  window->display->grab_last_user_action_was_snap = snap;
+  is_resize = FALSE;
+  if (apply_edge_resistance_to_each_side (window->display,
+                                          window,
+                                          &old_outer,
+                                          &new_outer,
+                                          timeout_func,
+                                          snap,
+                                          is_keyboard_op,
+                                          is_resize))
+    {
+      /* apply_edge_resistance_to_each_side independently applies
+       * resistance to both the right and left edges of new_outer as both
+       * could meet areas of resistance.  But we don't want a resize, so we
+       * just have both edges move according to the stricter of the
+       * resistances.  Same thing goes for top & bottom edges.
+       */
+      MetaRectangle *reference;
+      int left_change, right_change, smaller_x_change;
+      int top_change, bottom_change, smaller_y_change;
+
+      if (snap && !is_keyboard_op)
+        reference = &proposed_outer;
+      else
+        reference = &old_outer;
+
+      left_change  = BOX_LEFT (new_outer)  - BOX_LEFT (*reference);
+      right_change = BOX_RIGHT (new_outer) - BOX_RIGHT (*reference);
+      if (     snap && is_keyboard_op && left_change == 0)
+        smaller_x_change = right_change;
+      else if (snap && is_keyboard_op && right_change == 0)
+        smaller_x_change = left_change;
+      else if (ABS (left_change) < ABS (right_change))
+        smaller_x_change = left_change;
+      else
+        smaller_x_change = right_change;
+
+      top_change    = BOX_TOP (new_outer)    - BOX_TOP (*reference);
+      bottom_change = BOX_BOTTOM (new_outer) - BOX_BOTTOM (*reference);
+      if (     snap && is_keyboard_op && top_change == 0)
+        smaller_y_change = bottom_change;
+      else if (snap && is_keyboard_op && bottom_change == 0)
+        smaller_y_change = top_change;
+      else if (ABS (top_change) < ABS (bottom_change))
+        smaller_y_change = top_change;
+      else
+        smaller_y_change = bottom_change;
+
+      *new_x = old_x + smaller_x_change + 
+              (BOX_LEFT (*reference) - BOX_LEFT (old_outer));
+      *new_y = old_y + smaller_y_change +
+              (BOX_TOP (*reference) - BOX_TOP (old_outer));
+
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "outer x & y move-to coordinate changed from %d,%d to %d,%d\n",
+                  proposed_outer.x, proposed_outer.y,
+                  old_outer.x + (*new_x - old_x),
+                  old_outer.y + (*new_y - old_y));
+    }
+}
+
+/* Note that old_(width|height) and new_(width|height) are with respect to
+ * sizes of the inner window.
+ */
+void
+meta_window_edge_resistance_for_resize (MetaWindow  *window,
+                                        int          old_width,
+                                        int          old_height,
+                                        int         *new_width,
+                                        int         *new_height,
+                                        int          gravity,
+                                        GSourceFunc  timeout_func,
+                                        gboolean     snap,
+                                        gboolean     is_keyboard_op)
+{
+  MetaRectangle old_outer, new_outer;
+  int proposed_outer_width, proposed_outer_height;
+  gboolean is_resize;
+
+  if (window == window->display->grab_window &&
+      window->display->grab_wireframe_active)
+    {
+      meta_window_get_xor_rect (window,
+                                &window->display->grab_wireframe_rect,
+                                &old_outer);
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &old_outer);
+    }
+  proposed_outer_width  = old_outer.width  + (*new_width  - old_width);
+  proposed_outer_height = old_outer.height + (*new_height - old_height);
+  meta_rectangle_resize_with_gravity (&old_outer, 
+                                      &new_outer,
+                                      gravity,
+                                      proposed_outer_width,
+                                      proposed_outer_height);
+
+  window->display->grab_last_user_action_was_snap = snap;
+  is_resize = TRUE;
+  if (apply_edge_resistance_to_each_side (window->display,
+                                          window,
+                                          &old_outer,
+                                          &new_outer,
+                                          timeout_func,
+                                          snap,
+                                          is_keyboard_op,
+                                          is_resize))
+    {
+      *new_width  = old_width  + (new_outer.width  - old_outer.width);
+      *new_height = old_height + (new_outer.height - old_outer.height);
+
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "outer width & height got changed from %d,%d to %d,%d\n",
+                  proposed_outer_width, proposed_outer_height,
+                  new_outer.width, new_outer.height);
+    }
+}
diff --git a/src/core/edge-resistance.h b/src/core/edge-resistance.h
new file mode 100644
index 00000000..14ba17a0
--- /dev/null
+++ b/src/core/edge-resistance.h
@@ -0,0 +1,48 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Edge resistance for move/resize operations */
+
+/* 
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_EDGE_RESISTANCE_H
+#define META_EDGE_RESISTANCE_H
+
+#include "window-private.h"
+
+void        meta_window_edge_resistance_for_move   (MetaWindow  *window,
+                                                    int          old_x,
+                                                    int          old_y,
+                                                    int         *new_x,
+                                                    int         *new_y,
+                                                    GSourceFunc  timeout_func,
+                                                    gboolean     snap,
+                                                    gboolean     is_keyboard_op);
+void        meta_window_edge_resistance_for_resize (MetaWindow  *window,
+                                                    int          old_width,
+                                                    int          old_height,
+                                                    int         *new_width,
+                                                    int         *new_height,
+                                                    int          gravity,
+                                                    GSourceFunc  timeout_func,
+                                                    gboolean     snap,
+                                                    gboolean     is_keyboard_op);
+
+#endif /* META_EDGE_RESISTANCE_H */
+
diff --git a/src/core/effects.c b/src/core/effects.c
new file mode 100644
index 00000000..1392b7c2
--- /dev/null
+++ b/src/core/effects.c
@@ -0,0 +1,735 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file effects.c "Special effects" other than compositor effects.
+ * 
+ * Before we had a serious compositor, we supported swooping
+ * rectangles for minimising and so on.  These are still supported
+ * today, even when the compositor is enabled.  The file contains two
+ * parts:
+ *
+ *  1) A set of functions, each of which implements a special effect.
+ *     (Only the minimize function does anything interesting; we should
+ *      probably get rid of the rest.)
+ *
+ *  2) A set of functions for moving a highlighted wireframe box around
+ *     the screen, optionally with height and width shown in the middle.
+ *     This is used for moving and resizing when reduced_resources is set.
+ *
+ * There was formerly a system which allowed callers to drop in their
+ * own handlers for various things; it was never used (people who want
+ * their own handlers can just modify this file, after all) and it added
+ * a good deal of extra complexity, so it has been removed.  If you want it,
+ * it can be found in svn r3769.
+ *
+ * Once upon a time there were three different ways of drawing the box
+ * animation: window wireframe, window opaque, and root. People who had
+ * the shape extension theoretically had the choice of all three, and
+ * people who didn't weren't given the choice of the wireframe option.
+ * In practice, though, the opaque animation was never perfect, so it came
+ * down to the wireframe option for those who had the extension and
+ * the root option for those who didn't; there was actually no way of choosing
+ * any other option anyway.  Work on the opaque animation stopped in 2002;
+ * anyone who wants something like that these days will be using the
+ * compositor anyway.
+ *
+ * In svn r3769 this was made explicit.
+ */
+
+/* 
+ * Copyright (C) 2001 Anders Carlsson, Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "effects.h"
+#include "display-private.h"
+#include "ui.h"
+#include "window-private.h"
+#include "prefs.h"
+
+#ifdef HAVE_SHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+#define META_MINIMIZE_ANIMATION_LENGTH 0.25
+#define META_SHADE_ANIMATION_LENGTH 0.2
+
+#include <string.h>
+
+typedef struct MetaEffect MetaEffect;
+typedef struct MetaEffectPriv MetaEffectPriv;
+
+typedef struct
+{
+  MetaScreen *screen;
+
+  double millisecs_duration;
+  GTimeVal start_time;
+
+#ifdef HAVE_SHAPE
+  /** For wireframe window */
+  Window wireframe_xwindow;
+#else
+  /** Rectangle to erase */
+  MetaRectangle last_rect;
+
+  /** First time we've plotted anything in this animation? */
+  gboolean first_time;
+
+  /** For wireframe drawn on root window */
+  GC gc;
+#endif
+
+  MetaRectangle start_rect;
+  MetaRectangle end_rect;
+  
+} BoxAnimationContext;
+
+/**
+ * Information we need to know during a maximise or minimise effect.
+ */
+typedef struct
+{
+  /** This is the normal-size window. */
+  MetaRectangle window_rect;
+  /** This is the size of the window when it's an icon. */
+  MetaRectangle icon_rect;
+} MetaMinimizeEffect, MetaUnminimizeEffect;
+
+struct MetaEffectPriv
+{
+  MetaEffectFinished finished;
+  gpointer           finished_data;
+};
+
+struct MetaEffect
+{
+  /** The window the effect is applied to. */
+  MetaWindow *window;
+  /** Which effect is happening here. */
+  MetaEffectType type;
+  /** The effect handler can hang data here. */
+  gpointer info;
+
+  union
+  {
+    MetaMinimizeEffect      minimize;
+    /* ... and theoretically anything else */
+  } u;
+  
+  MetaEffectPriv *priv;
+};
+
+static void run_default_effect_handler (MetaEffect *effect);
+static void run_handler (MetaEffect *effect);
+static void effect_free (MetaEffect *effect);
+
+static MetaEffect *
+create_effect (MetaEffectType      type,
+               MetaWindow         *window,
+               MetaEffectFinished  finished,
+               gpointer            finished_data);
+
+static void
+draw_box_animation (MetaScreen     *screen,
+                    MetaRectangle  *initial_rect,
+                    MetaRectangle  *destination_rect,
+                    double          seconds_duration);
+
+/**
+ * Creates an effect.
+ *
+ */
+static MetaEffect*
+create_effect (MetaEffectType      type,
+               MetaWindow         *window,
+               MetaEffectFinished  finished,
+               gpointer            finished_data)
+{
+    MetaEffect *effect = g_new (MetaEffect, 1);
+
+    effect->type = type;
+    effect->window = window;
+    effect->priv = g_new (MetaEffectPriv, 1);
+    effect->priv->finished = finished;
+    effect->priv->finished_data = finished_data;
+
+    return effect;
+}
+
+/**
+ * Destroys an effect.  If the effect has a "finished" hook, it will be
+ * called before cleanup.
+ *
+ * \param effect  The effect.
+ */
+static void
+effect_free (MetaEffect *effect)
+{
+  if (effect->priv->finished)
+    effect->priv->finished (effect->priv->finished_data);
+    
+  g_free (effect->priv);
+  g_free (effect);
+}
+
+void
+meta_effect_run_focus (MetaWindow	    *window,
+		       MetaEffectFinished   finished,
+		       gpointer		    data)
+{
+    MetaEffect *effect;
+
+    g_return_if_fail (window != NULL);
+
+    effect = create_effect (META_EFFECT_FOCUS, window, finished, data);
+    
+    run_handler (effect);
+}
+
+void
+meta_effect_run_minimize (MetaWindow         *window,
+                          MetaRectangle      *window_rect,
+                          MetaRectangle      *icon_rect,
+                          MetaEffectFinished  finished,
+                          gpointer            data)
+{
+    MetaEffect *effect;
+
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (icon_rect != NULL);
+    
+    effect = create_effect (META_EFFECT_MINIMIZE, window, finished, data);
+
+    effect->u.minimize.window_rect = *window_rect;
+    effect->u.minimize.icon_rect = *icon_rect;
+
+    run_handler (effect);
+}
+
+void
+meta_effect_run_unminimize (MetaWindow         *window,
+                            MetaRectangle      *window_rect,
+                            MetaRectangle      *icon_rect,
+                            MetaEffectFinished  finished,
+                            gpointer            data)
+{
+    MetaEffect *effect;
+
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (icon_rect != NULL);
+    
+    effect = create_effect (META_EFFECT_UNMINIMIZE, window, finished, data);
+
+    effect->u.minimize.window_rect = *window_rect;
+    effect->u.minimize.icon_rect = *icon_rect;
+
+    run_handler (effect);
+}
+
+void
+meta_effect_run_close (MetaWindow         *window,
+		       MetaEffectFinished  finished,
+		       gpointer            data)
+{
+    MetaEffect *effect;
+    
+    g_return_if_fail (window != NULL);
+
+    effect = create_effect (META_EFFECT_CLOSE, window,
+                            finished, data);
+
+    run_handler (effect);
+}
+
+
+/* old ugly minimization effect */
+
+#ifdef HAVE_SHAPE  
+static void
+update_wireframe_window (MetaDisplay         *display,
+                         Window               xwindow,
+                         const MetaRectangle *rect)
+{
+  XMoveResizeWindow (display->xdisplay,
+                     xwindow,
+                     rect->x, rect->y,
+                     rect->width, rect->height);
+
+#define OUTLINE_WIDTH 3
+  
+  if (rect->width > OUTLINE_WIDTH * 2 &&
+      rect->height > OUTLINE_WIDTH * 2)
+    {
+      XRectangle xrect;
+      Region inner_xregion;
+      Region outer_xregion;
+      
+      inner_xregion = XCreateRegion ();
+      outer_xregion = XCreateRegion ();
+
+      xrect.x = 0;
+      xrect.y = 0;
+      xrect.width = rect->width;
+      xrect.height = rect->height;
+  
+      XUnionRectWithRegion (&xrect, outer_xregion, outer_xregion);
+  
+      xrect.x += OUTLINE_WIDTH;
+      xrect.y += OUTLINE_WIDTH;
+      xrect.width -= OUTLINE_WIDTH * 2;
+      xrect.height -= OUTLINE_WIDTH * 2;  
+  
+      XUnionRectWithRegion (&xrect, inner_xregion, inner_xregion);
+
+      XSubtractRegion (outer_xregion, inner_xregion, outer_xregion);
+
+      XShapeCombineRegion (display->xdisplay, xwindow,
+                           ShapeBounding, 0, 0, outer_xregion, ShapeSet);
+  
+      XDestroyRegion (outer_xregion);
+      XDestroyRegion (inner_xregion);
+    }
+  else
+    {
+      /* Unset the shape */
+      XShapeCombineMask (display->xdisplay, xwindow,
+                         ShapeBounding, 0, 0, None, ShapeSet);
+    }
+}
+#endif
+
+/**
+ * A hack to force the X server to synchronize with the
+ * graphics hardware.
+ */
+static void
+graphics_sync (BoxAnimationContext *context)
+{
+  XImage *image;
+  
+  image = XGetImage (context->screen->display->xdisplay,
+                     context->screen->xroot,
+                     0, 0, 1, 1,
+                     AllPlanes, ZPixmap);
+
+  XDestroyImage (image);
+}
+
+static gboolean
+effects_draw_box_animation_timeout (BoxAnimationContext *context)
+{
+  double elapsed;
+  GTimeVal current_time;
+  MetaRectangle draw_rect;
+  double fraction;
+  
+#ifndef HAVE_SHAPE
+  if (!context->first_time)
+    {
+       /* Restore the previously drawn background */
+       XDrawRectangle (context->screen->display->xdisplay,
+                       context->screen->xroot,
+                       context->gc,
+                       context->last_rect.x, context->last_rect.y,
+                       context->last_rect.width, context->last_rect.height);
+    }
+  else
+    context->first_time = FALSE;
+
+#endif /* !HAVE_SHAPE */
+
+  g_get_current_time (&current_time);
+  
+  /* We use milliseconds for all times */
+  elapsed =
+    ((((double)current_time.tv_sec - context->start_time.tv_sec) * G_USEC_PER_SEC +
+      (current_time.tv_usec - context->start_time.tv_usec))) / 1000.0;
+  
+  if (elapsed < 0)
+    {
+      /* Probably the system clock was set backwards? */
+      meta_warning ("System clock seemed to go backwards?\n");
+      elapsed = G_MAXDOUBLE; /* definitely done. */
+    }
+
+  if (elapsed > context->millisecs_duration)
+    {
+      /* All done */
+#ifdef HAVE_SHAPE
+        XDestroyWindow (context->screen->display->xdisplay,
+                          context->wireframe_xwindow);
+#else
+        meta_display_ungrab (context->screen->display);
+        meta_ui_pop_delay_exposes (context->screen->ui);
+        XFreeGC (context->screen->display->xdisplay,
+                 context->gc);
+#endif /* !HAVE_SHAPE */
+
+      graphics_sync (context);
+      
+      g_free (context);
+      return FALSE;
+    }
+
+  g_assert (context->millisecs_duration > 0.0);
+  fraction = elapsed / context->millisecs_duration;
+  
+  draw_rect = context->start_rect;
+  
+  /* Now add a delta proportional to elapsed time. */
+  draw_rect.x += (context->end_rect.x - context->start_rect.x) * fraction;
+  draw_rect.y += (context->end_rect.y - context->start_rect.y) * fraction;
+  draw_rect.width += (context->end_rect.width - context->start_rect.width) * fraction;
+  draw_rect.height += (context->end_rect.height - context->start_rect.height) * fraction;
+  
+  /* don't confuse X or gdk-pixbuf with bogus rectangles */
+  if (draw_rect.width < 1)
+    draw_rect.width = 1;
+  if (draw_rect.height < 1)
+    draw_rect.height = 1;
+
+#ifdef HAVE_SHAPE
+  update_wireframe_window (context->screen->display,
+                           context->wireframe_xwindow,
+                           &draw_rect);
+#else
+  context->last_rect = draw_rect;
+
+  /* Draw the rectangle */
+  XDrawRectangle (context->screen->display->xdisplay,
+                  context->screen->xroot,
+                  context->gc,
+                  draw_rect.x, draw_rect.y,
+                  draw_rect.width, draw_rect.height);
+    
+#endif /* !HAVE_SHAPE */
+
+  /* kick changes onto the server */
+  graphics_sync (context);
+  
+  return TRUE;
+}
+ 
+void
+draw_box_animation (MetaScreen     *screen,
+                    MetaRectangle  *initial_rect,
+                    MetaRectangle  *destination_rect,
+                    double          seconds_duration)
+{
+  BoxAnimationContext *context;
+
+#ifdef HAVE_SHAPE
+  XSetWindowAttributes attrs;
+#else
+  XGCValues gc_values;
+#endif
+    
+  g_return_if_fail (seconds_duration > 0.0);
+
+  if (g_getenv ("MARCO_DEBUG_EFFECTS"))
+    seconds_duration *= 10; /* slow things down */
+  
+  /* Create the animation context */
+  context = g_new0 (BoxAnimationContext, 1);
+
+  context->screen = screen;
+
+  context->millisecs_duration = seconds_duration * 1000.0;
+
+  context->start_rect = *initial_rect;
+  context->end_rect = *destination_rect;
+
+#ifdef HAVE_SHAPE
+
+  attrs.override_redirect = True;
+  attrs.background_pixel = BlackPixel (screen->display->xdisplay,
+                                       screen->number);
+
+  context->wireframe_xwindow = XCreateWindow (screen->display->xdisplay,
+                                              screen->xroot,
+                                              initial_rect->x,
+                                              initial_rect->y,
+                                              initial_rect->width,
+                                              initial_rect->height,
+                                              0,
+                                              CopyFromParent,
+                                              CopyFromParent,
+                                              (Visual *)CopyFromParent,
+                                              CWOverrideRedirect | CWBackPixel,
+                                              &attrs);
+
+  update_wireframe_window (screen->display,
+                           context->wireframe_xwindow,
+                           initial_rect);
+
+  XMapWindow (screen->display->xdisplay,
+              context->wireframe_xwindow);
+
+#else /* !HAVE_SHAPE */
+
+  context->first_time = TRUE;
+  gc_values.subwindow_mode = IncludeInferiors;
+  gc_values.function = GXinvert;
+
+  context->gc = XCreateGC (screen->display->xdisplay,
+                           screen->xroot,
+                           GCSubwindowMode | GCFunction,
+                           &gc_values);
+      
+  /* Grab the X server to avoid screen dirt */
+  meta_display_grab (context->screen->display);
+  meta_ui_push_delay_exposes (context->screen->ui);
+#endif
+
+  /* Do this only after we get the pixbuf from the server,
+   * so that the animation doesn't get truncated.
+   */
+  g_get_current_time (&context->start_time);
+  
+  /* Add the timeout - a short one, could even use an idle,
+   * but this is maybe more CPU-friendly.
+   */
+  g_timeout_add (15,
+                 (GSourceFunc)effects_draw_box_animation_timeout,
+                 context);
+
+  /* kick changes onto the server */
+  XFlush (context->screen->display->xdisplay);  
+}
+
+void
+meta_effects_begin_wireframe (MetaScreen          *screen,
+                              const MetaRectangle *rect,
+                              int                  width,
+                              int                  height)
+{
+  /* Grab the X server to avoid screen dirt */
+  meta_display_grab (screen->display);
+  meta_ui_push_delay_exposes (screen->ui);  
+
+  meta_effects_update_wireframe (screen, 
+                                 NULL, -1, -1,
+                                 rect, width, height);
+}
+
+static void
+draw_xor_rect (MetaScreen          *screen,
+               const MetaRectangle *rect,
+               int                  width,
+               int                  height)
+{
+  /* The lines in the center can't overlap the rectangle or each
+   * other, or the XOR gets reversed. So we have to draw things
+   * a bit oddly.
+   */
+  XSegment segments[8];
+  MetaRectangle shrunk_rect;
+  int i;
+  
+#define LINE_WIDTH META_WIREFRAME_XOR_LINE_WIDTH
+
+  /* We don't want the wireframe going outside the window area.
+   * It makes it harder for the user to position windows and it exposes other
+   * annoying bugs.
+   */
+  shrunk_rect = *rect;
+
+  shrunk_rect.x += LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  shrunk_rect.y += LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  shrunk_rect.width -= LINE_WIDTH + 2 * (LINE_WIDTH % 2);
+  shrunk_rect.height -= LINE_WIDTH + 2 * (LINE_WIDTH % 2);
+
+  XDrawRectangle (screen->display->xdisplay,
+                  screen->xroot,
+                  screen->root_xor_gc,
+                  shrunk_rect.x, shrunk_rect.y,
+                  shrunk_rect.width, shrunk_rect.height);
+
+  /* Don't put lines inside small rectangles where they won't fit */
+  if (shrunk_rect.width < (LINE_WIDTH * 4) ||
+      shrunk_rect.height < (LINE_WIDTH * 4))
+    return;
+
+  if ((width >= 0) && (height >= 0))
+    {
+      XGCValues gc_values = { 0 };
+
+      if (XGetGCValues (screen->display->xdisplay,
+                        screen->root_xor_gc, 
+                        GCFont, &gc_values))
+        {
+          char *text;
+          int text_length;
+
+          XFontStruct *font_struct;
+          int text_width, text_height; 
+          int box_x, box_y;
+          int box_width, box_height;
+
+          font_struct = XQueryFont (screen->display->xdisplay,
+                                    gc_values.font);
+
+          if (font_struct != NULL)
+            {
+              text = g_strdup_printf ("%d x %d", width, height);
+              text_length = strlen (text);
+
+              text_width = text_length * font_struct->max_bounds.width;
+              text_height = font_struct->max_bounds.descent + 
+                            font_struct->max_bounds.ascent;
+
+              box_width = text_width + 2 * LINE_WIDTH;
+              box_height = text_height + 2 * LINE_WIDTH;
+
+
+              box_x = shrunk_rect.x + (shrunk_rect.width - box_width) / 2;
+              box_y = shrunk_rect.y + (shrunk_rect.height - box_height) / 2;
+
+              if ((box_width < shrunk_rect.width) &&
+                  (box_height < shrunk_rect.height))
+                {
+                  XFillRectangle (screen->display->xdisplay,
+                                  screen->xroot,
+                                  screen->root_xor_gc,
+                                  box_x, box_y,
+                                  box_width, box_height);
+                  XDrawString (screen->display->xdisplay, 
+                               screen->xroot,
+                               screen->root_xor_gc,
+                               box_x + LINE_WIDTH,
+                               box_y + LINE_WIDTH + font_struct->max_bounds.ascent,
+                               text, text_length);
+                }
+
+              g_free (text);
+
+              XFreeFontInfo (NULL, font_struct, 1);
+
+              if ((box_width + LINE_WIDTH) >= (shrunk_rect.width / 3))
+                return;
+
+              if ((box_height + LINE_WIDTH) >= (shrunk_rect.height / 3))
+                return;
+            }
+        }
+    }
+
+  /* Two vertical lines at 1/3 and 2/3 */
+  segments[0].x1 = shrunk_rect.x + shrunk_rect.width / 3;
+  segments[0].y1 = shrunk_rect.y + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[0].x2 = segments[0].x1;
+  segments[0].y2 = shrunk_rect.y + shrunk_rect.height - LINE_WIDTH / 2;  
+
+  segments[1] = segments[0];
+  segments[1].x1 = shrunk_rect.x + (shrunk_rect.width / 3) * 2;
+  segments[1].x2 = segments[1].x1;
+
+  /* Now make two horizontal lines at 1/3 and 2/3, but not
+   * overlapping the verticals
+   */
+
+  segments[2].x1 = shrunk_rect.x + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[2].x2 = segments[0].x1 - LINE_WIDTH / 2;
+  segments[2].y1 = shrunk_rect.y + shrunk_rect.height / 3;
+  segments[2].y2 = segments[2].y1;
+
+  segments[3] = segments[2];
+  segments[3].x1 = segments[2].x2 + LINE_WIDTH;
+  segments[3].x2 = segments[1].x1 - LINE_WIDTH / 2;
+  
+  segments[4] = segments[3];
+  segments[4].x1 = segments[3].x2 + LINE_WIDTH;
+  segments[4].x2 = shrunk_rect.x + shrunk_rect.width - LINE_WIDTH / 2;
+
+  /* Second horizontal line is just like the first, but
+   * shifted down
+   */
+  i = 5;
+  while (i < 8)
+    {
+      segments[i] = segments[i - 3];
+      segments[i].y1 = shrunk_rect.y + (shrunk_rect.height / 3) * 2;
+      segments[i].y2 = segments[i].y1;
+      ++i;
+    }
+  
+  XDrawSegments (screen->display->xdisplay,
+                 screen->xroot,
+                 screen->root_xor_gc,
+                 segments,
+                 G_N_ELEMENTS (segments));
+}
+
+void
+meta_effects_update_wireframe (MetaScreen          *screen,
+                               const MetaRectangle *old_rect,
+                               int                  old_width,
+                               int                  old_height,
+                               const MetaRectangle *new_rect,
+                               int                  new_width,
+                               int                  new_height)
+{
+  if (old_rect)
+    draw_xor_rect (screen, old_rect, old_width, old_height);
+    
+  if (new_rect)
+    draw_xor_rect (screen, new_rect, new_width, new_height);
+    
+  XFlush (screen->display->xdisplay);
+}
+
+void
+meta_effects_end_wireframe (MetaScreen          *screen,
+                            const MetaRectangle *old_rect,
+                            int                  old_width,
+                            int                  old_height)
+{
+  meta_effects_update_wireframe (screen, 
+                                 old_rect, old_width, old_height,
+                                 NULL, -1, -1);
+  
+  meta_display_ungrab (screen->display);
+  meta_ui_pop_delay_exposes (screen->ui);
+}
+
+static void
+run_default_effect_handler (MetaEffect *effect)
+{
+    switch (effect->type)
+    {
+    case META_EFFECT_MINIMIZE:
+       draw_box_animation (effect->window->screen,
+                     &(effect->u.minimize.window_rect),
+                     &(effect->u.minimize.icon_rect),
+                     META_MINIMIZE_ANIMATION_LENGTH);
+       break;
+
+    default:
+       break;
+    }
+}
+
+static void
+run_handler (MetaEffect *effect)
+{
+  if (meta_prefs_get_mate_animations ())
+    run_default_effect_handler (effect);
+
+  effect_free (effect);
+}
diff --git a/src/core/effects.h b/src/core/effects.h
new file mode 100644
index 00000000..91d09e15
--- /dev/null
+++ b/src/core/effects.h
@@ -0,0 +1,170 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file effects.h "Special effects" other than compositor effects.
+ * 
+ * Before we had a serious compositor, we supported swooping
+ * rectangles for minimising and so on.  These are still supported
+ * today, even when the compositor is enabled.  The file contains two
+ * parts:
+ *
+ *  1) A set of functions, each of which implements a special effect.
+ *     (Only the minimize function does anything interesting; we should
+ *      probably get rid of the rest.)
+ *
+ *  2) A set of functions for moving a highlighted wireframe box around
+ *     the screen, optionally with height and width shown in the middle.
+ *     This is used for moving and resizing when reduced_resources is set.
+ *
+ * There was formerly a system which allowed callers to drop in their
+ * own handlers for various things; it was never used (people who want
+ * their own handlers can just modify this file, after all) and it added
+ * a good deal of extra complexity, so it has been removed.  If you want it,
+ * it can be found in svn r3769.
+ */
+
+/* 
+ * Copyright (C) 2001 Anders Carlsson, Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_EFFECTS_H
+#define META_EFFECTS_H
+
+#include "util.h"
+#include "screen-private.h"
+
+typedef enum
+{
+  META_EFFECT_MINIMIZE,
+  META_EFFECT_UNMINIMIZE,
+  META_EFFECT_FOCUS,
+  META_EFFECT_CLOSE,
+  META_NUM_EFFECTS
+} MetaEffectType;
+
+/**
+ * A callback which will be called when the effect has finished.
+ */
+typedef void (* MetaEffectFinished) (gpointer    data);
+
+/**
+ * Performs the minimize effect.
+ *
+ * \param window       The window we're moving
+ * \param window_rect  Its current state
+ * \param target       Where it should end up
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_minimize     (MetaWindow         *window,
+                                          MetaRectangle	     *window_rect,
+                                          MetaRectangle	     *target,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Performs the unminimize effect.  There is no such effect.
+ * FIXME: delete this.
+ *
+ * \param window       The window we're moving
+ * \param icon_rect    Its current state
+ * \param window_rect  Where it should end up
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_unminimize (MetaWindow         *window,
+                                          MetaRectangle      *window_rect,
+                                          MetaRectangle      *icon_rect,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Performs the close effect.  There is no such effect.
+ * FIXME: delete this.
+ *
+ * \param window       The window we're moving
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_close        (MetaWindow         *window,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Performs the focus effect.  There is no such effect.
+ * FIXME: delete this.
+ *
+ * \param window       The window we're moving
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_focus        (MetaWindow         *window,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Grabs the server and paints a wireframe rectangle on the screen.
+ * Since this involves starting a grab, please be considerate of other
+ * users and don't keep the grab for long.  You may move the wireframe
+ * around using meta_effects_update_wireframe() and remove it, and undo
+ * the grab, using meta_effects_end_wireframe().
+ *
+ * \param screen  The screen to draw the rectangle on.
+ * \param rect    The size of the rectangle to draw.
+ * \param width   The width to display in the middle (or 0 not to)
+ * \param height  The width to display in the middle (or 0 not to)
+ */
+void meta_effects_begin_wireframe  (MetaScreen          *screen,
+                                    const MetaRectangle *rect,
+                                    int                  width,
+                                    int                  height);
+
+/**
+ * Moves a wireframe rectangle around after its creation by
+ * meta_effects_begin_wireframe().  (Perhaps we ought to remember the old
+ * positions and not require people to pass them in?)
+ *
+ * \param old_rect  Where the rectangle is now
+ * \param old_width The width that was displayed on it (or 0 if there wasn't)
+ * \param old_height The height that was displayed on it (or 0 if there wasn't)
+ * \param new_rect  Where the rectangle is going
+ * \param new_width The width that will be displayed on it (or 0 not to)
+ * \param new_height The height that will be displayed on it (or 0 not to)
+ */
+void meta_effects_update_wireframe (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect,
+                                    int                  old_width,
+                                    int                  old_height,
+                                    const MetaRectangle *new_rect,
+                                    int                  new_width,
+                                    int                  new_height);
+
+/**
+ * Removes a wireframe rectangle from the screen and ends the grab started by
+ * meta_effects_begin_wireframe().
+ *
+ * \param old_rect  Where the rectangle is now
+ * \param old_width The width that was displayed on it (or 0 if there wasn't)
+ * \param old_height The height that was displayed on it (or 0 if there wasn't)
+ */
+void meta_effects_end_wireframe    (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect,
+                                    int                  width,
+                                    int                  height);
+
+#endif /* META_EFFECTS_H */
diff --git a/src/core/errors.c b/src/core/errors.c
new file mode 100644
index 00000000..3b2a6334
--- /dev/null
+++ b/src/core/errors.c
@@ -0,0 +1,288 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X error handling */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington, error trapping inspired by GDK
+ * code copyrighted by the GTK team.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "errors.h"
+#include "display-private.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <gdk/gdk.h>
+
+static int x_error_handler    (Display     *display,
+                               XErrorEvent *error);
+static int x_io_error_handler (Display     *display);
+
+void
+meta_errors_init (void)
+{
+  XSetErrorHandler (x_error_handler);
+  XSetIOErrorHandler (x_io_error_handler);
+}
+
+typedef struct ForeignDisplay ForeignDisplay;
+
+struct ForeignDisplay
+{
+    Display *dpy;
+    ErrorHandler handler;
+    gpointer data;
+    ForeignDisplay *next;
+};
+
+static ForeignDisplay *foreign_displays;
+
+void
+meta_errors_register_foreign_display (Display      *foreign_dpy,
+				      ErrorHandler  handler,
+				      gpointer      data)
+{
+    ForeignDisplay *info = g_new0 (ForeignDisplay, 1);
+    info->dpy = foreign_dpy;
+    info->handler = handler;
+    info->data = data;
+    info->next = foreign_displays;
+    foreign_displays = info;
+}
+
+static void
+meta_error_trap_push_internal (MetaDisplay *display,
+                               gboolean     need_sync)
+{
+  /* GDK resets the error handler on each push */
+  int (* old_error_handler) (Display     *,
+                             XErrorEvent *);
+
+  if (need_sync)
+    {
+      XSync (display->xdisplay, False);
+    }
+  
+  gdk_error_trap_push ();
+
+  /* old_error_handler will just be equal to x_error_handler
+   * for nested traps
+   */
+  old_error_handler = XSetErrorHandler (x_error_handler);
+  
+  /* Replace GDK handler, but save it so we can chain up */
+  if (display->error_trap_handler == NULL)
+    {
+      g_assert (display->error_traps == 0);
+      display->error_trap_handler = old_error_handler;
+      g_assert (display->error_trap_handler != x_error_handler);
+    }
+
+  display->error_traps += 1;
+
+  meta_topic (META_DEBUG_ERRORS, "%d traps remain\n", display->error_traps);
+}
+
+static int
+meta_error_trap_pop_internal  (MetaDisplay *display,
+                               gboolean     need_sync)
+{
+  int result;
+
+  g_assert (display->error_traps > 0);
+
+  if (need_sync)
+    {
+      XSync (display->xdisplay, False);
+    }
+
+  result = gdk_error_trap_pop ();
+
+  display->error_traps -= 1;
+  
+  if (display->error_traps == 0)
+    {
+      /* check that GDK put our handler back; this
+       * assumes that there are no pending GDK traps from GDK itself
+       */
+      
+      int (* restored_error_handler) (Display     *,
+                                      XErrorEvent *);
+
+      restored_error_handler = XSetErrorHandler (x_error_handler);
+
+      /* remove this */
+      display->error_trap_handler = NULL;
+    }
+
+  meta_topic (META_DEBUG_ERRORS, "%d traps\n", display->error_traps);
+  
+  return result;
+}
+
+void
+meta_error_trap_push (MetaDisplay *display)
+{
+  meta_error_trap_push_internal (display, FALSE);
+}
+
+void
+meta_error_trap_pop (MetaDisplay *display,
+                     gboolean     last_request_was_roundtrip)
+{
+  gboolean need_sync;
+
+  /* we only have to sync when popping the outermost trap */
+  need_sync = (display->error_traps == 1 && !last_request_was_roundtrip);
+
+  if (need_sync)
+    meta_topic (META_DEBUG_SYNC, "Syncing on error_trap_pop, traps = %d, roundtrip = %d\n",
+                display->error_traps, last_request_was_roundtrip);
+
+  display->error_trap_synced_at_last_pop = need_sync || last_request_was_roundtrip;
+  
+  meta_error_trap_pop_internal (display, need_sync);
+}
+
+void
+meta_error_trap_push_with_return (MetaDisplay *display)
+{
+  gboolean need_sync;
+
+  /* We don't sync on push_with_return if there are no traps
+   * currently, because we assume that any errors were either covered
+   * by a previous pop, or were fatal.
+   *
+   * More generally, we don't sync if we were synchronized last time
+   * we popped. This is known to be the case if there are no traps,
+   * but we also keep a flag so we know whether it's the case otherwise.
+   */
+
+  if (!display->error_trap_synced_at_last_pop)
+    need_sync = TRUE;
+  else
+    need_sync = FALSE;
+
+  if (need_sync)
+    meta_topic (META_DEBUG_SYNC, "Syncing on error_trap_push_with_return, traps = %d\n",
+                display->error_traps);
+  
+  meta_error_trap_push_internal (display, FALSE);
+}
+
+int
+meta_error_trap_pop_with_return  (MetaDisplay *display,
+                                  gboolean     last_request_was_roundtrip)
+{
+  if (!last_request_was_roundtrip)
+    meta_topic (META_DEBUG_SYNC, "Syncing on error_trap_pop_with_return, traps = %d, roundtrip = %d\n",
+                display->error_traps, last_request_was_roundtrip);
+
+  display->error_trap_synced_at_last_pop = TRUE;
+  
+  return meta_error_trap_pop_internal (display,
+                                       !last_request_was_roundtrip);
+}
+
+static int
+x_error_handler (Display     *xdisplay,
+                 XErrorEvent *error)
+{
+  int retval;
+  gchar buf[64];
+  MetaDisplay *display;
+  ForeignDisplay *foreign;
+
+  for (foreign = foreign_displays; foreign != NULL; foreign = foreign->next)
+  {
+      if (foreign->dpy == xdisplay)
+      {
+	  foreign->handler (xdisplay, error, foreign->data);
+
+	  return 0;
+      }
+  }
+  
+  XGetErrorText (xdisplay, error->error_code, buf, 63);  
+
+  display = meta_display_for_x_display (xdisplay);
+
+  /* Display can be NULL here because the compositing manager
+   * has its own Display, but Xlib only has one global error handler
+   */
+  if (display->error_traps > 0)
+    {
+      /* we're in an error trap, chain to the trap handler
+       * saved from GDK
+       */
+      meta_verbose ("X error: %s serial %ld error_code %d request_code %d minor_code %d)\n",
+                    buf,
+                    error->serial, 
+                    error->error_code, 
+                    error->request_code,
+                    error->minor_code);
+
+      g_assert (display->error_trap_handler != NULL);
+      g_assert (display->error_trap_handler != x_error_handler);
+      
+      retval = (* display->error_trap_handler) (xdisplay, error);
+    }
+  else
+    {
+      meta_bug ("Unexpected X error: %s serial %ld error_code %d request_code %d minor_code %d)\n",
+                buf,
+                error->serial, 
+                error->error_code, 
+                error->request_code,
+                error->minor_code);
+
+      retval = 1; /* compiler warning */
+    }
+
+  return retval;
+}
+
+static int
+x_io_error_handler (Display *xdisplay)
+{
+  MetaDisplay *display;
+
+  display = meta_display_for_x_display (xdisplay);
+
+  if (display == NULL)
+    meta_bug ("IO error received for unknown display?\n");
+  
+  if (errno == EPIPE)
+    {
+      meta_warning (_("Lost connection to the display '%s';\n"
+                      "most likely the X server was shut down or you killed/destroyed\n"
+                      "the window manager.\n"),
+                    display->name);
+    }
+  else
+    {
+      meta_warning (_("Fatal IO error %d (%s) on display '%s'.\n"),
+                    errno, g_strerror (errno),
+                    display->name);
+    }
+
+  /* Xlib would force an exit anyhow */
+  exit (1);
+  
+  return 0;
+}
diff --git a/src/core/eventqueue.c b/src/core/eventqueue.c
new file mode 100644
index 00000000..2799cae9
--- /dev/null
+++ b/src/core/eventqueue.c
@@ -0,0 +1,184 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X event source for main loop */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington (based on GDK code (C) Owen
+ * Taylor, Red Hat Inc.)
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  */
+
+#include "eventqueue.h"
+#include <X11/Xlib.h>
+
+static gboolean eq_prepare  (GSource     *source,
+                             gint        *timeout);
+static gboolean eq_check    (GSource     *source);
+static gboolean eq_dispatch (GSource     *source,
+                             GSourceFunc  callback,
+                             gpointer     user_data);
+static void     eq_destroy  (GSource     *source);
+
+static GSourceFuncs eq_funcs = {
+  eq_prepare,
+  eq_check,
+  eq_dispatch,
+  eq_destroy
+};
+
+struct _MetaEventQueue
+{
+  GSource source;
+
+  Display *display;
+  GPollFD poll_fd;
+  int connection_fd;
+  GQueue *events;
+};
+
+MetaEventQueue*
+meta_event_queue_new (Display *display, MetaEventQueueFunc func, gpointer data)
+{
+  GSource *source;
+  MetaEventQueue *eq;
+
+  source = g_source_new (&eq_funcs, sizeof (MetaEventQueue));
+  eq = (MetaEventQueue*) source;
+  
+  eq->connection_fd = ConnectionNumber (display);
+  eq->poll_fd.fd = eq->connection_fd;
+  eq->poll_fd.events = G_IO_IN;
+
+  eq->events = g_queue_new ();
+
+  eq->display = display;
+  
+  g_source_set_priority (source, G_PRIORITY_DEFAULT);
+  g_source_add_poll (source, &eq->poll_fd);
+  g_source_set_can_recurse (source, TRUE);
+
+  g_source_set_callback (source, (GSourceFunc) func, data, NULL);
+  
+  g_source_attach (source, NULL);
+  g_source_unref (source);
+
+  return eq;
+}
+
+void
+meta_event_queue_free (MetaEventQueue *eq)
+{
+  GSource *source;
+
+  source = (GSource*) eq;
+  
+  g_source_destroy (source);
+}
+
+static gboolean
+eq_events_pending (MetaEventQueue *eq)
+{
+  return eq->events->length > 0 || XPending (eq->display);
+}
+
+static void
+eq_queue_events (MetaEventQueue *eq)
+{
+  XEvent xevent;
+
+  while (XPending (eq->display))
+    {
+      XEvent *copy;
+      
+      XNextEvent (eq->display, &xevent);
+
+      copy = g_new (XEvent, 1);
+      *copy = xevent;
+
+      g_queue_push_tail (eq->events, copy);
+    }
+}
+
+static gboolean  
+eq_prepare (GSource *source, gint *timeout)
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+  
+  *timeout = -1;
+
+  return eq_events_pending (eq);
+}
+
+static gboolean  
+eq_check (GSource  *source) 
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+
+  if (eq->poll_fd.revents & G_IO_IN)
+    return eq_events_pending (eq);
+  else
+    return FALSE;
+}
+
+static gboolean  
+eq_dispatch (GSource *source, GSourceFunc callback, gpointer user_data)
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+  
+  eq_queue_events (eq);
+
+  if (eq->events->length > 0)
+    {
+      XEvent *event;
+      MetaEventQueueFunc func;
+
+      event = g_queue_pop_head (eq->events);
+      func = (MetaEventQueueFunc) callback;
+      
+      (* func) (event, user_data);
+
+      g_free (event);
+    }
+  
+  return TRUE;
+}
+
+static void
+eq_destroy (GSource *source)
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+
+  while (eq->events->length > 0)
+    {
+      XEvent *event;
+      
+      event = g_queue_pop_head (eq->events);
+
+      g_free (event);
+    }
+
+  g_queue_free (eq->events);
+
+  /* source itself is freed by glib */
+}
diff --git a/src/core/eventqueue.h b/src/core/eventqueue.h
new file mode 100644
index 00000000..8f3596af
--- /dev/null
+++ b/src/core/eventqueue.h
@@ -0,0 +1,40 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X event source for main loop */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_EVENT_QUEUE_H
+#define META_EVENT_QUEUE_H
+
+#include <glib.h>
+#include <X11/Xlib.h>
+
+typedef struct _MetaEventQueue MetaEventQueue;
+
+typedef void   (* MetaEventQueueFunc) (XEvent         *event,
+                                       gpointer        data);
+
+MetaEventQueue* meta_event_queue_new  (Display            *display,
+                                       MetaEventQueueFunc  func,
+                                       gpointer            data);
+void            meta_event_queue_free (MetaEventQueue     *eq);
+
+#endif
diff --git a/src/core/frame-private.h b/src/core/frame-private.h
new file mode 100644
index 00000000..bde352dc
--- /dev/null
+++ b/src/core/frame-private.h
@@ -0,0 +1,88 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X window decorations */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_FRAME_PRIVATE_H
+#define META_FRAME_PRIVATE_H
+
+#include "frame.h"
+#include "window-private.h"
+
+typedef struct _MetaFrameGeometry MetaFrameGeometry;
+
+struct _MetaFrameGeometry
+{  
+  /* border sizes (space between frame and child) */
+  int left_width;
+  int right_width;
+  int top_height;
+  int bottom_height;
+};
+
+struct _MetaFrame
+{
+  /* window we frame */
+  MetaWindow *window;
+
+  /* reparent window */
+  Window xwindow;
+
+  MetaCursor current_cursor;
+
+  /* This rect is trusted info from where we put the
+   * frame, not the result of ConfigureNotify
+   */
+  MetaRectangle rect;
+
+  /* position of client, size of frame */
+  int child_x;
+  int child_y;
+  int right_width;
+  int bottom_height;
+
+  guint mapped : 1;
+  guint need_reapply_frame_shape : 1;
+  guint is_flashing : 1; /* used by the visual bell flash */
+};
+
+void     meta_window_ensure_frame           (MetaWindow *window);
+void     meta_window_destroy_frame          (MetaWindow *window);
+void     meta_frame_queue_draw              (MetaFrame  *frame);
+
+MetaFrameFlags meta_frame_get_flags (MetaFrame *frame);
+
+/* These should ONLY be called from meta_window_move_resize_internal */
+void meta_frame_calc_geometry      (MetaFrame         *frame,
+                                    MetaFrameGeometry *geomp);
+void meta_frame_sync_to_window     (MetaFrame         *frame,
+                                    int                gravity,
+                                    gboolean           need_move,
+                                    gboolean           need_resize);
+
+void meta_frame_set_screen_cursor (MetaFrame	*frame,
+				   MetaCursor	cursor);
+
+#endif
+
+
+
+
diff --git a/src/core/frame.c b/src/core/frame.c
new file mode 100644
index 00000000..2d0bbb51
--- /dev/null
+++ b/src/core/frame.c
@@ -0,0 +1,421 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X window decorations */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "frame-private.h"
+#include "bell.h"
+#include "errors.h"
+#include "keybindings.h"
+
+#ifdef HAVE_RENDER
+#include <X11/extensions/Xrender.h>
+#endif
+
+#define EVENT_MASK (SubstructureRedirectMask |                     \
+                    StructureNotifyMask | SubstructureNotifyMask | \
+                    ExposureMask |                                 \
+                    ButtonPressMask | ButtonReleaseMask |          \
+                    PointerMotionMask | PointerMotionHintMask |    \
+                    EnterWindowMask | LeaveWindowMask |            \
+                    FocusChangeMask |                              \
+                    ColormapChangeMask)
+
+void
+meta_window_ensure_frame (MetaWindow *window)
+{
+  MetaFrame *frame;
+  XSetWindowAttributes attrs;
+  Visual *visual;
+  
+  if (window->frame)
+    return;
+  
+  /* See comment below for why this is required. */
+  meta_display_grab (window->display);
+  
+  frame = g_new (MetaFrame, 1);
+
+  frame->window = window;
+  frame->xwindow = None;
+
+  frame->rect = window->rect;
+  frame->child_x = 0;
+  frame->child_y = 0;
+  frame->bottom_height = 0;
+  frame->right_width = 0;
+  frame->current_cursor = 0;
+
+  frame->mapped = FALSE;
+  frame->need_reapply_frame_shape = TRUE;
+  frame->is_flashing = FALSE;
+  
+  meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
+                window->desc,
+                XVisualIDFromVisual (window->xvisual) ==
+                XVisualIDFromVisual (window->screen->default_xvisual) ?
+                "is" : "is not",
+                window->depth, window->screen->default_depth);
+  meta_verbose ("Frame geometry %d,%d  %dx%d\n",
+                frame->rect.x, frame->rect.y,
+                frame->rect.width, frame->rect.height);
+  
+  /* Default depth/visual handles clients with weird visuals; they can
+   * always be children of the root depth/visual obviously, but
+   * e.g. DRI games can't be children of a parent that has the same
+   * visual as the client. NULL means default visual.
+   *
+   * We look for an ARGB visual if we can find one, otherwise use
+   * the default of NULL.
+   */
+  
+  /* Special case for depth 32 windows (assumed to be ARGB),
+   * we use the window's visual. Otherwise we just use the system visual.
+   */
+  if (window->depth == 32)
+    visual = window->xvisual;
+  else
+    visual = NULL;
+  
+  frame->xwindow = meta_ui_create_frame_window (window->screen->ui,
+                                                window->display->xdisplay,
+                                                visual,
+                                                frame->rect.x,
+                                                frame->rect.y,
+						frame->rect.width,
+						frame->rect.height,
+						frame->window->screen->number);
+
+  meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow);
+  attrs.event_mask = EVENT_MASK;
+  XChangeWindowAttributes (window->display->xdisplay,
+			   frame->xwindow, CWEventMask, &attrs);
+  
+  meta_display_register_x_window (window->display, &frame->xwindow, window);
+
+  /* Now that frame->xwindow is registered with window, we can set its
+   * background.
+   */
+  meta_ui_reset_frame_bg (window->screen->ui, frame->xwindow);
+
+  /* Reparent the client window; it may be destroyed,
+   * thus the error trap. We'll get a destroy notify later
+   * and free everything. Comment in FVWM source code says
+   * we need a server grab or the child can get its MapNotify
+   * before we've finished reparenting and getting the decoration
+   * window onscreen, so ensure_frame must be called with
+   * a grab.
+   */
+  meta_error_trap_push (window->display);
+  if (window->mapped)
+    {
+      window->mapped = FALSE; /* the reparent will unmap the window,
+                               * we don't want to take that as a withdraw
+                               */
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Incrementing unmaps_pending on %s for reparent\n", window->desc);
+      window->unmaps_pending += 1;
+    }
+  /* window was reparented to this position */
+  window->rect.x = 0;
+  window->rect.y = 0;
+
+  XReparentWindow (window->display->xdisplay,
+                   window->xwindow,
+                   frame->xwindow,
+                   window->rect.x,
+                   window->rect.y);
+  /* FIXME handle this error */
+  meta_error_trap_pop (window->display, FALSE);
+  
+  /* stick frame to the window */
+  window->frame = frame;
+  
+  if (window->title)
+    meta_ui_set_frame_title (window->screen->ui,
+                             window->frame->xwindow,
+                             window->title);
+
+  /* Move keybindings to frame instead of window */
+  meta_window_grab_keys (window);
+
+  /* Shape mask */
+  meta_ui_apply_frame_shape (frame->window->screen->ui,
+                             frame->xwindow,
+                             frame->rect.width,
+                             frame->rect.height,
+                             frame->window->has_shape);
+  frame->need_reapply_frame_shape = FALSE;
+  
+  meta_display_ungrab (window->display);
+}
+
+void
+meta_window_destroy_frame (MetaWindow *window)
+{
+  MetaFrame *frame;
+  
+  if (window->frame == NULL)
+    return;
+
+  meta_verbose ("Unframing window %s\n", window->desc);
+  
+  frame = window->frame;
+  
+  meta_bell_notify_frame_destroy (frame);
+  
+  /* Unparent the client window; it may be destroyed,
+   * thus the error trap.
+   */
+  meta_error_trap_push (window->display);
+  if (window->mapped)
+    {
+      window->mapped = FALSE; /* Keep track of unmapping it, so we
+                               * can identify a withdraw initiated
+                               * by the client.
+                               */
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Incrementing unmaps_pending on %s for reparent back to root\n", window->desc);
+      window->unmaps_pending += 1;
+    }
+  XReparentWindow (window->display->xdisplay,
+                   window->xwindow,
+                   window->screen->xroot,
+                   /* Using anything other than meta_window_get_position()
+                    * coordinates here means we'll need to ensure a configure
+                    * notify event is sent; see bug 399552.
+                    */
+                   window->frame->rect.x,
+                   window->frame->rect.y);
+  meta_error_trap_pop (window->display, FALSE);
+
+  meta_ui_destroy_frame_window (window->screen->ui, frame->xwindow);
+
+  meta_display_unregister_x_window (window->display,
+                                    frame->xwindow);
+  
+  window->frame = NULL;
+
+  /* Move keybindings to window instead of frame */
+  meta_window_grab_keys (window);
+  
+  g_free (frame);
+  
+  /* Put our state back where it should be */
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+
+MetaFrameFlags
+meta_frame_get_flags (MetaFrame *frame)
+{
+  MetaFrameFlags flags;
+
+  flags = 0;
+
+  if (frame->window->border_only)
+    {
+      ; /* FIXME this may disable the _function_ as well as decor
+         * in some cases, which is sort of wrong.
+         */
+    }
+  else
+    {
+      flags |= META_FRAME_ALLOWS_MENU;
+      
+      if (frame->window->has_close_func)
+        flags |= META_FRAME_ALLOWS_DELETE;
+      
+      if (frame->window->has_maximize_func)
+        flags |= META_FRAME_ALLOWS_MAXIMIZE;
+      
+      if (frame->window->has_minimize_func)
+        flags |= META_FRAME_ALLOWS_MINIMIZE;
+      
+      if (frame->window->has_shade_func)
+        flags |= META_FRAME_ALLOWS_SHADE;
+    }  
+  
+  if (META_WINDOW_ALLOWS_MOVE (frame->window))
+    flags |= META_FRAME_ALLOWS_MOVE;
+
+  if (META_WINDOW_ALLOWS_HORIZONTAL_RESIZE (frame->window))
+    flags |= META_FRAME_ALLOWS_HORIZONTAL_RESIZE;
+
+  if (META_WINDOW_ALLOWS_VERTICAL_RESIZE (frame->window))
+    flags |= META_FRAME_ALLOWS_VERTICAL_RESIZE;
+  
+  if (frame->window->has_focus)
+    flags |= META_FRAME_HAS_FOCUS;
+
+  if (frame->window->shaded)
+    flags |= META_FRAME_SHADED;
+
+  if (frame->window->on_all_workspaces)
+    flags |= META_FRAME_STUCK;
+
+  /* FIXME: Should we have some kind of UI for windows that are just vertically
+   * maximized or just horizontally maximized?
+   */
+  if (META_WINDOW_MAXIMIZED (frame->window))
+    flags |= META_FRAME_MAXIMIZED;
+
+  if (frame->window->fullscreen)
+    flags |= META_FRAME_FULLSCREEN;
+
+  if (frame->is_flashing)
+    flags |= META_FRAME_IS_FLASHING;
+
+  if (frame->window->wm_state_above)
+    flags |= META_FRAME_ABOVE;
+  
+  return flags;
+}
+
+void
+meta_frame_calc_geometry (MetaFrame         *frame,
+                          MetaFrameGeometry *geomp)
+{
+  MetaFrameGeometry geom;
+  MetaWindow *window;
+
+  window = frame->window;
+
+  meta_ui_get_frame_geometry (window->screen->ui,
+                              frame->xwindow,
+                              &geom.top_height,
+                              &geom.bottom_height,
+                              &geom.left_width,
+                              &geom.right_width);
+  
+  *geomp = geom;
+}
+
+static void
+update_shape (MetaFrame *frame)
+{
+  if (frame->need_reapply_frame_shape)
+    {
+      meta_ui_apply_frame_shape (frame->window->screen->ui,
+                                 frame->xwindow,
+                                 frame->rect.width,
+                                 frame->rect.height,
+                                 frame->window->has_shape);
+      frame->need_reapply_frame_shape = FALSE;
+    }
+}
+
+void
+meta_frame_sync_to_window (MetaFrame *frame,
+                           int        resize_gravity,
+                           gboolean   need_move,
+                           gboolean   need_resize)
+{
+  if (!(need_move || need_resize))
+    {
+      update_shape (frame);
+      return;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Syncing frame geometry %d,%d %dx%d (SE: %d,%d)\n",
+              frame->rect.x, frame->rect.y,
+              frame->rect.width, frame->rect.height,
+              frame->rect.x + frame->rect.width,
+              frame->rect.y + frame->rect.height);
+
+  /* set bg to none to avoid flicker */
+  if (need_resize)
+    {
+      meta_ui_unflicker_frame_bg (frame->window->screen->ui,
+                                  frame->xwindow,
+                                  frame->rect.width,
+                                  frame->rect.height);
+
+      /* we need new shape if we're resized */
+      frame->need_reapply_frame_shape = TRUE;
+    }
+
+  /* Done before the window resize, because doing it before means
+   * part of the window being resized becomes unshaped, which may
+   * be sort of hard to see with bg = None. If we did it after
+   * window resize, part of the window being resized would become
+   * shaped, which might be more visible.
+   */
+  update_shape (frame);
+  
+  meta_ui_move_resize_frame (frame->window->screen->ui,
+			     frame->xwindow,
+			     frame->rect.x,
+			     frame->rect.y,
+			     frame->rect.width,
+			     frame->rect.height);
+
+  if (need_resize)
+    {
+      meta_ui_reset_frame_bg (frame->window->screen->ui,
+                              frame->xwindow);
+
+      /* If we're interactively resizing the frame, repaint
+       * it immediately so we don't start to lag.
+       */
+      if (frame->window->display->grab_window ==
+          frame->window)
+        meta_ui_repaint_frame (frame->window->screen->ui,
+                               frame->xwindow);
+    }
+}
+
+void
+meta_frame_queue_draw (MetaFrame *frame)
+{
+  meta_ui_queue_frame_draw (frame->window->screen->ui,
+                            frame->xwindow);
+}
+
+void
+meta_frame_set_screen_cursor (MetaFrame	*frame,
+			      MetaCursor cursor)
+{
+  Cursor xcursor;
+  if (cursor == frame->current_cursor)
+    return;
+  frame->current_cursor = cursor;
+  if (cursor == META_CURSOR_DEFAULT)
+    XUndefineCursor (frame->window->display->xdisplay, frame->xwindow);
+  else
+    { 
+      xcursor = meta_display_create_x_cursor (frame->window->display, cursor);
+      XDefineCursor (frame->window->display->xdisplay, frame->xwindow, xcursor);
+      XFlush (frame->window->display->xdisplay);
+      XFreeCursor (frame->window->display->xdisplay, xcursor);
+    }
+}
+
+Window
+meta_frame_get_xwindow (MetaFrame *frame)
+{
+  return frame->xwindow;
+}
diff --git a/src/core/group-private.h b/src/core/group-private.h
new file mode 100644
index 00000000..bf8dd5a3
--- /dev/null
+++ b/src/core/group-private.h
@@ -0,0 +1,43 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window group private header */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_GROUP_PRIVATE_H
+#define META_GROUP_PRIVATE_H
+
+#include "group.h"
+
+struct _MetaGroup
+{
+  int refcount;
+  MetaDisplay *display;
+  GSList *windows;
+  Window group_leader;
+  char *startup_id;
+  char *wm_client_machine;
+};
+
+#endif
+
+
+
+
diff --git a/src/core/group-props.c b/src/core/group-props.c
new file mode 100644
index 00000000..05e82900
--- /dev/null
+++ b/src/core/group-props.c
@@ -0,0 +1,234 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* MetaGroup property handling */
+
+/* 
+ * Copyright (C) 2002 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "group-props.h"
+#include "group-private.h"
+#include "xprops.h"
+#include <X11/Xatom.h>
+
+typedef void (* InitValueFunc)   (MetaDisplay   *display,
+                                  Atom           property,
+                                  MetaPropValue *value);
+typedef void (* ReloadValueFunc) (MetaGroup     *group,
+                                  MetaPropValue *value);
+
+struct _MetaGroupPropHooks
+{
+  Atom property;
+  InitValueFunc   init_func;
+  ReloadValueFunc reload_func;
+};
+
+static void                init_prop_value   (MetaDisplay   *display,
+                                              Atom           property,
+                                              MetaPropValue *value);
+static void                reload_prop_value (MetaGroup     *group,
+                                              MetaPropValue *value);
+static MetaGroupPropHooks* find_hooks        (MetaDisplay   *display,
+                                              Atom           property);
+
+
+
+void
+meta_group_reload_property (MetaGroup *group,
+                            Atom       property)
+{
+  meta_group_reload_properties (group, &property, 1);
+}
+
+void
+meta_group_reload_properties (MetaGroup  *group,
+                              const Atom *properties,
+                              int         n_properties)
+{
+  int i;
+  MetaPropValue *values;
+
+  g_return_if_fail (properties != NULL);
+  g_return_if_fail (n_properties > 0);
+  
+  values = g_new0 (MetaPropValue, n_properties);
+  
+  i = 0;
+  while (i < n_properties)
+    {
+      init_prop_value (group->display, properties[i], &values[i]);
+      ++i;
+    }
+  
+  meta_prop_get_values (group->display, group->group_leader,
+                        values, n_properties);
+
+  i = 0;
+  while (i < n_properties)
+    {
+      reload_prop_value (group, &values[i]);
+      
+      ++i;
+    }
+
+  meta_prop_free_values (values, n_properties);
+  
+  g_free (values);
+}
+
+/* Fill in the MetaPropValue used to get the value of "property" */
+static void
+init_prop_value (MetaDisplay   *display,
+                 Atom           property,
+                 MetaPropValue *value)
+{
+  MetaGroupPropHooks *hooks;  
+
+  value->type = META_PROP_VALUE_INVALID;
+  value->atom = None;
+  
+  hooks = find_hooks (display, property);
+  if (hooks && hooks->init_func != NULL)
+    (* hooks->init_func) (display, property, value);
+}
+
+static void
+reload_prop_value (MetaGroup    *group,
+                   MetaPropValue *value)
+{
+  MetaGroupPropHooks *hooks;  
+  
+  hooks = find_hooks (group->display, value->atom);
+  if (hooks && hooks->reload_func != NULL)
+    (* hooks->reload_func) (group, value);
+}
+
+static void
+init_wm_client_machine (MetaDisplay   *display,
+                        Atom           property,
+                        MetaPropValue *value)
+{
+  value->type = META_PROP_VALUE_STRING;
+  value->atom = display->atom_WM_CLIENT_MACHINE;
+}
+
+static void
+reload_wm_client_machine (MetaGroup     *group,
+                          MetaPropValue *value)
+{
+  g_free (group->wm_client_machine);
+  group->wm_client_machine = NULL;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    group->wm_client_machine = g_strdup (value->v.str);
+
+  meta_verbose ("Group has client machine \"%s\"\n",
+                group->wm_client_machine ? group->wm_client_machine : "unset");
+}
+
+static void
+init_net_startup_id (MetaDisplay   *display,
+                     Atom           property,
+                     MetaPropValue *value)
+{
+  value->type = META_PROP_VALUE_UTF8;
+  value->atom = display->atom__NET_STARTUP_ID;
+}
+
+static void
+reload_net_startup_id (MetaGroup     *group,
+                       MetaPropValue *value)
+{
+  g_free (group->startup_id);
+  group->startup_id = NULL;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    group->startup_id = g_strdup (value->v.str);
+  
+  meta_verbose ("Group has startup id \"%s\"\n",
+                group->startup_id ? group->startup_id : "unset");
+}
+
+#define N_HOOKS 3
+
+void
+meta_display_init_group_prop_hooks (MetaDisplay *display)
+{
+  int i;
+  MetaGroupPropHooks *hooks;
+  
+  g_assert (display->group_prop_hooks == NULL);
+
+  display->group_prop_hooks = g_new0 (MetaGroupPropHooks, N_HOOKS); 
+  hooks = display->group_prop_hooks;
+  
+  i = 0;
+
+  hooks[i].property = display->atom_WM_CLIENT_MACHINE;
+  hooks[i].init_func = init_wm_client_machine;
+  hooks[i].reload_func = reload_wm_client_machine;
+  ++i;
+
+  hooks[i].property = display->atom__NET_WM_PID;
+  hooks[i].init_func = NULL;
+  hooks[i].reload_func = NULL;
+  ++i;
+
+  hooks[i].property = display->atom__NET_STARTUP_ID;
+  hooks[i].init_func = init_net_startup_id;
+  hooks[i].reload_func = reload_net_startup_id;
+  ++i;
+  
+  if (i != N_HOOKS)
+    {
+      g_error ("Initialized %d group hooks should have been %d\n", i, N_HOOKS);
+    }
+}
+
+void
+meta_display_free_group_prop_hooks (MetaDisplay *display)
+{
+  g_assert (display->group_prop_hooks != NULL);
+  
+  g_free (display->group_prop_hooks);
+  display->group_prop_hooks = NULL;
+}
+
+static MetaGroupPropHooks*
+find_hooks (MetaDisplay *display,
+            Atom         property)
+{
+  int i;
+
+  /* FIXME we could sort the array and do binary search or
+   * something
+   */
+  
+  i = 0;
+  while (i < N_HOOKS)
+    {
+      if (display->group_prop_hooks[i].property == property)
+        return &display->group_prop_hooks[i];
+      
+      ++i;
+    }
+
+  return NULL;
+}
diff --git a/src/core/group-props.h b/src/core/group-props.h
new file mode 100644
index 00000000..ffde0901
--- /dev/null
+++ b/src/core/group-props.h
@@ -0,0 +1,37 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* MetaGroup property handling */
+
+/* 
+ * Copyright (C) 2002 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_GROUP_PROPS_H
+#define META_GROUP_PROPS_H
+
+#include "group.h"
+
+void meta_group_reload_property         (MetaGroup   *group,
+                                         Atom         property);
+void meta_group_reload_properties       (MetaGroup   *group,
+                                         const Atom  *properties,
+                                         int          n_properties);
+void meta_display_init_group_prop_hooks (MetaDisplay *display);
+void meta_display_free_group_prop_hooks (MetaDisplay *display);
+
+#endif /* META_GROUP_PROPS_H */
diff --git a/src/core/group.c b/src/core/group.c
new file mode 100644
index 00000000..35db53c7
--- /dev/null
+++ b/src/core/group.c
@@ -0,0 +1,274 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window groups */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "util.h"
+#include "group-private.h"
+#include "group-props.h"
+#include "window.h"
+
+static MetaGroup*
+meta_group_new (MetaDisplay *display,
+                Window       group_leader)
+{
+  MetaGroup *group;
+#define N_INITIAL_PROPS 3
+  Atom initial_props[N_INITIAL_PROPS];
+  int i;
+  
+  g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props));
+  
+  group = g_new0 (MetaGroup, 1);
+
+  group->display = display;
+  group->windows = NULL;
+  group->group_leader = group_leader;
+  group->refcount = 1; /* owned by caller, hash table has only weak ref */
+  
+  if (display->groups_by_leader == NULL)
+    display->groups_by_leader = g_hash_table_new (meta_unsigned_long_hash,
+                                                  meta_unsigned_long_equal);
+
+  g_assert (g_hash_table_lookup (display->groups_by_leader, &group_leader) == NULL);
+
+  g_hash_table_insert (display->groups_by_leader,
+                       &group->group_leader,
+                       group);
+
+  /* Fill these in the order we want them to be gotten */
+  i = 0;
+  initial_props[i++] = display->atom_WM_CLIENT_MACHINE;
+  initial_props[i++] = display->atom__NET_WM_PID;
+  initial_props[i++] = display->atom__NET_STARTUP_ID;
+  g_assert (N_INITIAL_PROPS == i);
+  
+  meta_group_reload_properties (group, initial_props, N_INITIAL_PROPS);
+
+  meta_topic (META_DEBUG_GROUPS,
+              "Created new group with leader 0x%lx\n",
+              group->group_leader);
+  
+  return group;
+}
+
+static void
+meta_group_unref (MetaGroup *group)
+{
+  g_return_if_fail (group->refcount > 0);
+
+  group->refcount -= 1;
+  if (group->refcount == 0)
+    {
+      meta_topic (META_DEBUG_GROUPS,
+                  "Destroying group with leader 0x%lx\n",
+                  group->group_leader);      
+      
+      g_assert (group->display->groups_by_leader != NULL);
+      
+      g_hash_table_remove (group->display->groups_by_leader,
+                           &group->group_leader);
+
+      /* mop up hash table, this is how it gets freed on display close */
+      if (g_hash_table_size (group->display->groups_by_leader) == 0)
+        {
+          g_hash_table_destroy (group->display->groups_by_leader);
+          group->display->groups_by_leader = NULL;
+        }
+
+      g_free (group->wm_client_machine);
+      g_free (group->startup_id);
+      
+      g_free (group);
+    }
+}
+
+MetaGroup*
+meta_window_get_group (MetaWindow *window)
+{
+  if (window->unmanaging)
+    return NULL;
+
+  return window->group;
+}
+
+void
+meta_window_compute_group (MetaWindow* window)
+{
+  MetaGroup *group;
+  MetaWindow *ancestor;
+
+  /* use window->xwindow if no window->xgroup_leader */
+      
+  group = NULL;
+      
+  /* Determine the ancestor of the window; its group setting will override the
+   * normal grouping rules; see bug 328211.
+   */
+  ancestor = meta_window_find_root_ancestor (window);
+
+  if (window->display->groups_by_leader)
+    {
+      if (ancestor != window)
+        group = ancestor->group;
+      else if (window->xgroup_leader != None)
+        group = g_hash_table_lookup (window->display->groups_by_leader,
+                                     &window->xgroup_leader);
+      else
+        group = g_hash_table_lookup (window->display->groups_by_leader,
+                                     &window->xwindow);
+    }
+      
+  if (group != NULL)
+    {
+      window->group = group;
+      group->refcount += 1;
+    }
+  else
+    {
+      if (ancestor != window && ancestor->xgroup_leader != None)
+        group = meta_group_new (window->display,
+                                ancestor->xgroup_leader);
+      else if (window->xgroup_leader != None)
+        group = meta_group_new (window->display,
+                                window->xgroup_leader);
+      else
+        group = meta_group_new (window->display,
+                                window->xwindow);
+          
+      window->group = group;
+    }
+
+  window->group->windows = g_slist_prepend (window->group->windows, window);
+
+  meta_topic (META_DEBUG_GROUPS,
+              "Adding %s to group with leader 0x%lx\n",
+              window->desc, group->group_leader);
+
+}
+
+static void
+remove_window_from_group (MetaWindow *window)
+{
+  if (window->group != NULL)
+    {
+      meta_topic (META_DEBUG_GROUPS,
+                  "Removing %s from group with leader 0x%lx\n",
+                  window->desc, window->group->group_leader);
+      
+      window->group->windows =
+        g_slist_remove (window->group->windows,
+                        window);
+      meta_group_unref (window->group);
+      window->group = NULL;
+    }
+}
+
+void
+meta_window_group_leader_changed (MetaWindow *window)
+{
+  remove_window_from_group (window);
+  meta_window_compute_group (window);
+}
+
+void
+meta_window_shutdown_group (MetaWindow *window)
+{
+  remove_window_from_group (window);
+}
+
+MetaGroup*
+meta_display_lookup_group (MetaDisplay *display,
+                           Window       group_leader)
+{
+  MetaGroup *group;
+  
+  group = NULL;
+  
+  if (display->groups_by_leader)
+    group = g_hash_table_lookup (display->groups_by_leader,
+                                 &group_leader);
+
+  return group;
+}
+
+GSList*
+meta_group_list_windows (MetaGroup *group)
+{
+  return g_slist_copy (group->windows);
+}
+
+void
+meta_group_update_layers (MetaGroup *group)
+{
+  GSList *tmp;
+  GSList *frozen_stacks;
+  
+  if (group->windows == NULL)
+    return;
+
+  frozen_stacks = NULL;
+  tmp = group->windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      /* we end up freezing the same stack a lot of times,
+       * but doesn't hurt anything. have to handle
+       * groups that span 2 screens.
+       */
+      meta_stack_freeze (window->screen->stack);
+      frozen_stacks = g_slist_prepend (frozen_stacks, window->screen->stack);
+
+      meta_stack_update_layer (window->screen->stack,
+                               window);
+      
+      tmp = tmp->next;
+    }
+
+  tmp = frozen_stacks;
+  while (tmp != NULL)
+    {
+      meta_stack_thaw (tmp->data);
+      tmp = tmp->next;
+    }
+
+  g_slist_free (frozen_stacks);
+}
+
+const char*
+meta_group_get_startup_id (MetaGroup *group)
+{
+  return group->startup_id;
+}
+
+gboolean
+meta_group_property_notify (MetaGroup  *group,
+                            XEvent     *event)
+{
+  meta_group_reload_property (group,
+                              event->xproperty.atom);
+
+  return TRUE;
+
+}
diff --git a/src/core/group.h b/src/core/group.h
new file mode 100644
index 00000000..f71c2c47
--- /dev/null
+++ b/src/core/group.h
@@ -0,0 +1,53 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window groups */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_GROUP_H
+#define META_GROUP_H
+
+#include "window-private.h"
+
+/* note, can return NULL */
+MetaGroup* meta_window_get_group       (MetaWindow *window);
+void       meta_window_compute_group   (MetaWindow* window);
+void       meta_window_shutdown_group  (MetaWindow *window);
+
+void       meta_window_group_leader_changed (MetaWindow *window);
+
+/* note, can return NULL */
+MetaGroup* meta_display_lookup_group   (MetaDisplay *display,
+                                        Window       group_leader);
+
+GSList*    meta_group_list_windows     (MetaGroup *group);
+
+void       meta_group_update_layers    (MetaGroup *group);
+
+const char* meta_group_get_startup_id  (MetaGroup *group);
+
+gboolean meta_group_property_notify   (MetaGroup  *group,
+                                       XEvent     *event);
+
+#endif
+
+
+
+
diff --git a/src/core/iconcache.c b/src/core/iconcache.c
new file mode 100644
index 00000000..af9411ba
--- /dev/null
+++ b/src/core/iconcache.c
@@ -0,0 +1,849 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window icons */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "iconcache.h"
+#include "ui.h"
+#include "errors.h"
+
+#include <X11/Xatom.h>
+
+/* The icon-reading code is also in libwnck, please sync bugfixes */
+
+static void
+get_fallback_icons (MetaScreen     *screen,
+                    GdkPixbuf     **iconp,
+                    int             ideal_width,
+                    int             ideal_height,
+                    GdkPixbuf     **mini_iconp,
+                    int             ideal_mini_width,
+                    int             ideal_mini_height)
+{
+  /* we don't scale, should be fixed if we ever un-hardcode the icon
+   * size
+   */
+  *iconp = meta_ui_get_default_window_icon (screen->ui);
+  *mini_iconp = meta_ui_get_default_mini_icon (screen->ui);
+}
+
+static gboolean
+find_largest_sizes (gulong *data,
+                    gulong  nitems,
+                    int    *width,
+                    int    *height)
+{
+  *width = 0;
+  *height = 0;
+
+  while (nitems > 0)
+    {
+      int w, h;
+
+      if (nitems < 3)
+        return FALSE; /* no space for w, h */
+
+      w = data[0];
+      h = data[1];
+
+      if (nitems < ((gulong)(w * h) + 2))
+        return FALSE; /* not enough data */
+
+      *width = MAX (w, *width);
+      *height = MAX (h, *height);
+
+      data += (w * h) + 2;
+      nitems -= (w * h) + 2;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+find_best_size (gulong  *data,
+                gulong   nitems,
+                int      ideal_width,
+                int      ideal_height,
+                int     *width,
+                int     *height,
+                gulong **start)
+{
+  int best_w;
+  int best_h;
+  gulong *best_start;
+  int max_width, max_height;
+
+  *width = 0;
+  *height = 0;
+  *start = NULL;
+
+  if (!find_largest_sizes (data, nitems, &max_width, &max_height))
+    return FALSE;
+
+  if (ideal_width < 0)
+    ideal_width = max_width;
+  if (ideal_height < 0)
+    ideal_height = max_height;
+
+  best_w = 0;
+  best_h = 0;
+  best_start = NULL;
+
+  while (nitems > 0)
+    {
+      int w, h;
+      gboolean replace;
+
+      replace = FALSE;
+
+      if (nitems < 3)
+        return FALSE; /* no space for w, h */
+
+      w = data[0];
+      h = data[1];
+
+      if (nitems < ((gulong)(w * h) + 2))
+        break; /* not enough data */
+
+      if (best_start == NULL)
+        {
+          replace = TRUE;
+        }
+      else
+        {
+          /* work with averages */
+          const int ideal_size = (ideal_width + ideal_height) / 2;
+          int best_size = (best_w + best_h) / 2;
+          int this_size = (w + h) / 2;
+
+          /* larger than desired is always better than smaller */
+          if (best_size < ideal_size &&
+              this_size >= ideal_size)
+            replace = TRUE;
+          /* if we have too small, pick anything bigger */
+          else if (best_size < ideal_size &&
+                   this_size > best_size)
+            replace = TRUE;
+          /* if we have too large, pick anything smaller
+           * but still >= the ideal
+           */
+          else if (best_size > ideal_size &&
+                   this_size >= ideal_size &&
+                   this_size < best_size)
+            replace = TRUE;
+        }
+
+      if (replace)
+        {
+          best_start = data + 2;
+          best_w = w;
+          best_h = h;
+        }
+
+      data += (w * h) + 2;
+      nitems -= (w * h) + 2;
+    }
+
+  if (best_start)
+    {
+      *start = best_start;
+      *width = best_w;
+      *height = best_h;
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+static void
+argbdata_to_pixdata (gulong *argb_data, int len, guchar **pixdata)
+{
+  guchar *p;
+  int i;
+
+  *pixdata = g_new (guchar, len * 4);
+  p = *pixdata;
+
+  /* One could speed this up a lot. */
+  i = 0;
+  while (i < len)
+    {
+      guint argb;
+      guint rgba;
+
+      argb = argb_data[i];
+      rgba = (argb << 8) | (argb >> 24);
+
+      *p = rgba >> 24;
+      ++p;
+      *p = (rgba >> 16) & 0xff;
+      ++p;
+      *p = (rgba >> 8) & 0xff;
+      ++p;
+      *p = rgba & 0xff;
+      ++p;
+
+      ++i;
+    }
+}
+
+static gboolean
+read_rgb_icon (MetaDisplay   *display,
+               Window         xwindow,
+               int            ideal_width,
+               int            ideal_height,
+               int            ideal_mini_width,
+               int            ideal_mini_height,
+               int           *width,
+               int           *height,
+               guchar       **pixdata,
+               int           *mini_width,
+               int           *mini_height,
+               guchar       **mini_pixdata)
+{
+  Atom type;
+  int format;
+  gulong nitems;
+  gulong bytes_after;
+  int result, err;
+  guchar *data;
+  gulong *best;
+  int w, h;
+  gulong *best_mini;
+  int mini_w, mini_h;
+  gulong *data_as_long;
+
+  meta_error_trap_push_with_return (display);
+  type = None;
+  data = NULL;
+  result = XGetWindowProperty (display->xdisplay,
+			       xwindow,
+                               display->atom__NET_WM_ICON,
+			       0, G_MAXLONG,
+			       False, XA_CARDINAL, &type, &format, &nitems,
+			       &bytes_after, &data);
+  err = meta_error_trap_pop_with_return (display, TRUE);
+
+  if (err != Success ||
+      result != Success)
+    return FALSE;
+
+  if (type != XA_CARDINAL)
+    {
+      XFree (data);
+      return FALSE;
+    }
+
+  data_as_long = (gulong *)data;
+
+  if (!find_best_size (data_as_long, nitems,
+                       ideal_width, ideal_height,
+                       &w, &h, &best))
+    {
+      XFree (data);
+      return FALSE;
+    }
+
+  if (!find_best_size (data_as_long, nitems,
+                       ideal_mini_width, ideal_mini_height,
+                       &mini_w, &mini_h, &best_mini))
+    {
+      XFree (data);
+      return FALSE;
+    }
+
+  *width = w;
+  *height = h;
+
+  *mini_width = mini_w;
+  *mini_height = mini_h;
+
+  argbdata_to_pixdata (best, w * h, pixdata);
+  argbdata_to_pixdata (best_mini, mini_w * mini_h, mini_pixdata);
+
+  XFree (data);
+
+  return TRUE;
+}
+
+static void
+free_pixels (guchar *pixels, gpointer data)
+{
+  g_free (pixels);
+}
+
+static void
+get_pixmap_geometry (MetaDisplay *display,
+                     Pixmap       pixmap,
+                     int         *w,
+                     int         *h,
+                     int         *d)
+{
+  Window root_ignored;
+  int x_ignored, y_ignored;
+  guint width, height;
+  guint border_width_ignored;
+  guint depth;
+
+  if (w)
+    *w = 1;
+  if (h)
+    *h = 1;
+  if (d)
+    *d = 1;
+
+  XGetGeometry (display->xdisplay,
+                pixmap, &root_ignored, &x_ignored, &y_ignored,
+                &width, &height, &border_width_ignored, &depth);
+
+  if (w)
+    *w = width;
+  if (h)
+    *h = height;
+  if (d)
+    *d = depth;
+}
+
+static GdkPixbuf*
+apply_mask (GdkPixbuf *pixbuf,
+            GdkPixbuf *mask)
+{
+  int w, h;
+  int i, j;
+  GdkPixbuf *with_alpha;
+  guchar *src;
+  guchar *dest;
+  int src_stride;
+  int dest_stride;
+
+  w = MIN (gdk_pixbuf_get_width (mask), gdk_pixbuf_get_width (pixbuf));
+  h = MIN (gdk_pixbuf_get_height (mask), gdk_pixbuf_get_height (pixbuf));
+
+  with_alpha = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+
+  dest = gdk_pixbuf_get_pixels (with_alpha);
+  src = gdk_pixbuf_get_pixels (mask);
+
+  dest_stride = gdk_pixbuf_get_rowstride (with_alpha);
+  src_stride = gdk_pixbuf_get_rowstride (mask);
+
+  i = 0;
+  while (i < h)
+    {
+      j = 0;
+      while (j < w)
+        {
+          guchar *s = src + i * src_stride + j * 3;
+          guchar *d = dest + i * dest_stride + j * 4;
+
+          /* s[0] == s[1] == s[2], they are 255 if the bit was set, 0
+           * otherwise
+           */
+          if (s[0] == 0)
+            d[3] = 0;   /* transparent */
+          else
+            d[3] = 255; /* opaque */
+
+          ++j;
+        }
+
+      ++i;
+    }
+
+  return with_alpha;
+}
+
+static gboolean
+try_pixmap_and_mask (MetaDisplay *display,
+                     Pixmap       src_pixmap,
+                     Pixmap       src_mask,
+                     GdkPixbuf  **iconp,
+                     int          ideal_width,
+                     int          ideal_height,
+                     GdkPixbuf  **mini_iconp,
+                     int          ideal_mini_width,
+                     int          ideal_mini_height)
+{
+  GdkPixbuf *unscaled = NULL;
+  GdkPixbuf *mask = NULL;
+  int w, h;
+
+  if (src_pixmap == None)
+    return FALSE;
+
+  meta_error_trap_push (display);
+
+  get_pixmap_geometry (display, src_pixmap, &w, &h, NULL);
+
+  unscaled = meta_gdk_pixbuf_get_from_pixmap (NULL,
+                                              src_pixmap,
+                                              0, 0, 0, 0,
+                                              w, h);
+
+  if (unscaled && src_mask != None)
+    {
+      get_pixmap_geometry (display, src_mask, &w, &h, NULL);
+      mask = meta_gdk_pixbuf_get_from_pixmap (NULL,
+                                              src_mask,
+                                              0, 0, 0, 0,
+                                              w, h);
+    }
+
+  meta_error_trap_pop (display, FALSE);
+
+  if (mask)
+    {
+      GdkPixbuf *masked;
+
+      masked = apply_mask (unscaled, mask);
+      g_object_unref (G_OBJECT (unscaled));
+      unscaled = masked;
+
+      g_object_unref (G_OBJECT (mask));
+      mask = NULL;
+    }
+
+  if (unscaled)
+    {
+      *iconp =
+        gdk_pixbuf_scale_simple (unscaled,
+                                 ideal_width > 0 ? ideal_width :
+                                 gdk_pixbuf_get_width (unscaled),
+                                 ideal_height > 0 ? ideal_height :
+                                 gdk_pixbuf_get_height (unscaled),
+                                 GDK_INTERP_BILINEAR);
+      *mini_iconp =
+        gdk_pixbuf_scale_simple (unscaled,
+                                 ideal_mini_width > 0 ? ideal_mini_width :
+                                 gdk_pixbuf_get_width (unscaled),
+                                 ideal_mini_height > 0 ? ideal_mini_height :
+                                 gdk_pixbuf_get_height (unscaled),
+                                 GDK_INTERP_BILINEAR);
+
+      g_object_unref (G_OBJECT (unscaled));
+      
+      if (*iconp && *mini_iconp)
+        return TRUE;
+      else
+        {
+          if (*iconp)
+            g_object_unref (G_OBJECT (*iconp));
+          if (*mini_iconp)
+            g_object_unref (G_OBJECT (*mini_iconp));
+          return FALSE;
+        }
+    }
+  else
+    return FALSE;
+}
+
+static void
+get_kwm_win_icon (MetaDisplay *display,
+                  Window       xwindow,
+                  Pixmap      *pixmap,
+                  Pixmap      *mask)
+{
+  Atom type;
+  int format;
+  gulong nitems;
+  gulong bytes_after;
+  guchar *data;
+  Pixmap *icons;
+  int err, result;
+
+  *pixmap = None;
+  *mask = None;
+
+  meta_error_trap_push_with_return (display);
+  icons = NULL;
+  result = XGetWindowProperty (display->xdisplay, xwindow,
+                               display->atom__KWM_WIN_ICON,
+			       0, G_MAXLONG,
+			       False,
+                               display->atom__KWM_WIN_ICON,
+			       &type, &format, &nitems,
+			       &bytes_after, &data);
+  icons = (Pixmap *)data;
+
+  err = meta_error_trap_pop_with_return (display, TRUE);
+  if (err != Success ||
+      result != Success)
+    return;
+
+  if (type != display->atom__KWM_WIN_ICON)
+    {
+      XFree (icons);
+      return;
+    }
+
+  *pixmap = icons[0];
+  *mask = icons[1];
+
+  XFree (icons);
+
+  return;
+}
+
+void
+meta_icon_cache_init (MetaIconCache *icon_cache)
+{
+  g_return_if_fail (icon_cache != NULL);
+
+  icon_cache->origin = USING_NO_ICON;
+  icon_cache->prev_pixmap = None;
+  icon_cache->prev_mask = None;
+#if 0
+  icon_cache->icon = NULL;
+  icon_cache->mini_icon = NULL;
+  icon_cache->ideal_width = -1; /* won't be a legit width */
+  icon_cache->ideal_height = -1;
+  icon_cache->ideal_mini_width = -1;
+  icon_cache->ideal_mini_height = -1;
+#endif
+  icon_cache->want_fallback = TRUE;
+  icon_cache->wm_hints_dirty = TRUE;
+  icon_cache->kwm_win_icon_dirty = TRUE;
+  icon_cache->net_wm_icon_dirty = TRUE;
+}
+
+static void
+clear_icon_cache (MetaIconCache *icon_cache,
+                  gboolean       dirty_all)
+{
+#if 0
+  if (icon_cache->icon)
+    g_object_unref (G_OBJECT (icon_cache->icon));
+  icon_cache->icon = NULL;
+
+  if (icon_cache->mini_icon)
+    g_object_unref (G_OBJECT (icon_cache->mini_icon));
+  icon_cache->mini_icon = NULL;
+#endif
+  
+  icon_cache->origin = USING_NO_ICON;
+
+  if (dirty_all)
+    {
+      icon_cache->wm_hints_dirty = TRUE;
+      icon_cache->kwm_win_icon_dirty = TRUE;
+      icon_cache->net_wm_icon_dirty = TRUE;
+    }
+}
+
+void
+meta_icon_cache_free (MetaIconCache *icon_cache)
+{
+  clear_icon_cache (icon_cache, FALSE);
+}
+
+void
+meta_icon_cache_property_changed (MetaIconCache *icon_cache,
+                                  MetaDisplay   *display,
+                                  Atom           atom)
+{
+  if (atom == display->atom__NET_WM_ICON)
+    icon_cache->net_wm_icon_dirty = TRUE;
+  else if (atom == display->atom__KWM_WIN_ICON)
+    icon_cache->kwm_win_icon_dirty = TRUE;
+  else if (atom == XA_WM_HINTS)
+    icon_cache->wm_hints_dirty = TRUE;
+}
+
+gboolean
+meta_icon_cache_get_icon_invalidated (MetaIconCache *icon_cache)
+{
+  if (icon_cache->origin <= USING_KWM_WIN_ICON &&
+      icon_cache->kwm_win_icon_dirty)
+    return TRUE;
+  else if (icon_cache->origin <= USING_WM_HINTS &&
+           icon_cache->wm_hints_dirty)
+    return TRUE;
+  else if (icon_cache->origin <= USING_NET_WM_ICON &&
+           icon_cache->net_wm_icon_dirty)
+    return TRUE;
+  else if (icon_cache->origin < USING_FALLBACK_ICON &&
+           icon_cache->want_fallback)
+    return TRUE;
+  else if (icon_cache->origin == USING_NO_ICON)
+    return TRUE;
+  else if (icon_cache->origin == USING_FALLBACK_ICON &&
+           !icon_cache->want_fallback)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static void
+replace_cache (MetaIconCache *icon_cache,
+               IconOrigin     origin,
+               GdkPixbuf     *new_icon,
+               GdkPixbuf     *new_mini_icon)
+{
+  clear_icon_cache (icon_cache, FALSE);
+
+  icon_cache->origin = origin;
+
+#if 0
+  if (new_icon)
+    g_object_ref (G_OBJECT (new_icon));
+
+  icon_cache->icon = new_icon;
+
+  if (new_mini_icon)
+    g_object_ref (G_OBJECT (new_mini_icon));
+
+  icon_cache->mini_icon = new_mini_icon;
+#endif
+}
+
+static GdkPixbuf*
+scaled_from_pixdata (guchar *pixdata,
+                     int     w,
+                     int     h,
+                     int     new_w,
+                     int     new_h)
+{
+  GdkPixbuf *src;
+  GdkPixbuf *dest;
+  
+  src = gdk_pixbuf_new_from_data (pixdata,
+                                  GDK_COLORSPACE_RGB,
+                                  TRUE,
+                                  8,
+                                  w, h, w * 4,
+                                  free_pixels, 
+                                  NULL);
+
+  if (src == NULL)
+    return NULL;
+
+  if (w != h)
+    {
+      GdkPixbuf *tmp;
+      int size;
+
+      size = MAX (w, h);
+      
+      tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, size, size);
+
+      if (tmp)
+	{
+	  gdk_pixbuf_fill (tmp, 0);
+	  gdk_pixbuf_copy_area (src, 0, 0, w, h,
+				tmp,
+				(size - w) / 2, (size - h) / 2);
+	  
+	  g_object_unref (src);
+	  src = tmp;
+	}
+    }
+  
+  if (w != new_w || h != new_h)
+    {
+      dest = gdk_pixbuf_scale_simple (src, new_w, new_h, GDK_INTERP_BILINEAR);
+      
+      g_object_unref (G_OBJECT (src));
+    }
+  else
+    {
+      dest = src;
+    }
+
+  return dest;
+}
+
+gboolean
+meta_read_icons (MetaScreen     *screen,
+                 Window          xwindow,
+                 MetaIconCache  *icon_cache,
+                 Pixmap          wm_hints_pixmap,
+                 Pixmap          wm_hints_mask,
+                 GdkPixbuf     **iconp,
+                 int             ideal_width,
+                 int             ideal_height,
+                 GdkPixbuf     **mini_iconp,
+                 int             ideal_mini_width,
+                 int             ideal_mini_height)
+{
+  guchar *pixdata;
+  int w, h;
+  guchar *mini_pixdata;
+  int mini_w, mini_h;
+  Pixmap pixmap;
+  Pixmap mask;
+
+  /* Return value is whether the icon changed */
+
+  g_return_val_if_fail (icon_cache != NULL, FALSE);
+
+  *iconp = NULL;
+  *mini_iconp = NULL;
+
+#if 0
+  if (ideal_width != icon_cache->ideal_width ||
+      ideal_height != icon_cache->ideal_height ||
+      ideal_mini_width != icon_cache->ideal_mini_width ||
+      ideal_mini_height != icon_cache->ideal_mini_height)
+    clear_icon_cache (icon_cache, TRUE);
+
+  icon_cache->ideal_width = ideal_width;
+  icon_cache->ideal_height = ideal_height;
+  icon_cache->ideal_mini_width = ideal_mini_width;
+  icon_cache->ideal_mini_height = ideal_mini_height;
+#endif
+  
+  if (!meta_icon_cache_get_icon_invalidated (icon_cache))
+    return FALSE; /* we have no new info to use */
+
+  pixdata = NULL;
+
+  /* Our algorithm here assumes that we can't have for example origin
+   * < USING_NET_WM_ICON and icon_cache->net_wm_icon_dirty == FALSE
+   * unless we have tried to read NET_WM_ICON.
+   *
+   * Put another way, if an icon origin is not dirty, then we have
+   * tried to read it at the current size. If it is dirty, then
+   * we haven't done that since the last change.
+   */
+
+  if (icon_cache->origin <= USING_NET_WM_ICON &&
+      icon_cache->net_wm_icon_dirty)
+
+    {
+      icon_cache->net_wm_icon_dirty = FALSE;
+
+      if (read_rgb_icon (screen->display, xwindow,
+                         ideal_width, ideal_height,
+                         ideal_mini_width, ideal_mini_height,
+                         &w, &h, &pixdata,
+                         &mini_w, &mini_h, &mini_pixdata))
+        {
+          *iconp = scaled_from_pixdata (pixdata, w, h,
+                                        ideal_width, ideal_height);
+
+          *mini_iconp = scaled_from_pixdata (mini_pixdata, mini_w, mini_h,
+                                             ideal_mini_width, ideal_mini_height);
+
+          if (*iconp && *mini_iconp)
+            {
+              replace_cache (icon_cache, USING_NET_WM_ICON,
+                             *iconp, *mini_iconp);
+              
+              return TRUE;
+            }
+          else
+            {
+              if (*iconp)
+                g_object_unref (G_OBJECT (*iconp));
+              if (*mini_iconp)
+                g_object_unref (G_OBJECT (*mini_iconp));
+            }
+        }
+    }
+
+  if (icon_cache->origin <= USING_WM_HINTS &&
+      icon_cache->wm_hints_dirty)
+    {
+      icon_cache->wm_hints_dirty = FALSE;
+
+      pixmap = wm_hints_pixmap;
+      mask = wm_hints_mask;
+
+      /* We won't update if pixmap is unchanged;
+       * avoids a get_from_drawable() on every geometry
+       * hints change
+       */
+      if ((pixmap != icon_cache->prev_pixmap ||
+           mask != icon_cache->prev_mask) &&
+          pixmap != None)
+        {
+          if (try_pixmap_and_mask (screen->display,
+                                   pixmap, mask,
+                                   iconp, ideal_width, ideal_height,
+                                   mini_iconp, ideal_mini_width, ideal_mini_height))
+            {
+              icon_cache->prev_pixmap = pixmap;
+              icon_cache->prev_mask = mask;
+
+              replace_cache (icon_cache, USING_WM_HINTS,
+                             *iconp, *mini_iconp);
+
+              return TRUE;
+            }
+        }
+    }
+
+  if (icon_cache->origin <= USING_KWM_WIN_ICON &&
+      icon_cache->kwm_win_icon_dirty)
+    {
+      icon_cache->kwm_win_icon_dirty = FALSE;
+
+      get_kwm_win_icon (screen->display, xwindow, &pixmap, &mask);
+
+      if ((pixmap != icon_cache->prev_pixmap ||
+           mask != icon_cache->prev_mask) &&
+          pixmap != None)
+        {
+          if (try_pixmap_and_mask (screen->display, pixmap, mask,
+                                   iconp, ideal_width, ideal_height,
+                                   mini_iconp, ideal_mini_width, ideal_mini_height))
+            {
+              icon_cache->prev_pixmap = pixmap;
+              icon_cache->prev_mask = mask;
+
+              replace_cache (icon_cache, USING_KWM_WIN_ICON,
+                             *iconp, *mini_iconp);
+
+              return TRUE;
+            }
+        }
+    }
+
+  if (icon_cache->want_fallback &&
+      icon_cache->origin < USING_FALLBACK_ICON)
+    {
+      get_fallback_icons (screen,
+                          iconp,
+                          ideal_width,
+                          ideal_height,
+                          mini_iconp,
+                          ideal_mini_width,
+                          ideal_mini_height);
+
+      replace_cache (icon_cache, USING_FALLBACK_ICON,
+                     *iconp, *mini_iconp);
+      
+      return TRUE;
+    }
+
+  if (!icon_cache->want_fallback &&
+      icon_cache->origin == USING_FALLBACK_ICON)
+    {
+      /* Get rid of current icon */
+      clear_icon_cache (icon_cache, FALSE);
+
+      return TRUE;
+    }
+
+  /* found nothing new */
+  return FALSE;
+}
diff --git a/src/core/iconcache.h b/src/core/iconcache.h
new file mode 100644
index 00000000..85ea9c66
--- /dev/null
+++ b/src/core/iconcache.h
@@ -0,0 +1,79 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window icons */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_ICON_CACHE_H
+#define META_ICON_CACHE_H
+
+#include "screen-private.h"
+
+typedef struct _MetaIconCache MetaIconCache;
+
+typedef enum
+{
+  /* These MUST be in ascending order of preference;
+   * i.e. if we get _NET_WM_ICON and already have
+   * WM_HINTS, we prefer _NET_WM_ICON
+   */
+  USING_NO_ICON,
+  USING_FALLBACK_ICON,
+  USING_KWM_WIN_ICON,
+  USING_WM_HINTS,
+  USING_NET_WM_ICON
+} IconOrigin;
+
+struct _MetaIconCache
+{
+  int origin;
+  Pixmap prev_pixmap;
+  Pixmap prev_mask;
+  guint want_fallback : 1;
+  /* TRUE if these props have changed */
+  guint wm_hints_dirty : 1;
+  guint kwm_win_icon_dirty : 1;
+  guint net_wm_icon_dirty : 1;
+};
+
+void           meta_icon_cache_init                 (MetaIconCache *icon_cache);
+void           meta_icon_cache_free                 (MetaIconCache *icon_cache);
+void           meta_icon_cache_property_changed     (MetaIconCache *icon_cache,
+                                                     MetaDisplay   *display,
+                                                     Atom           atom);
+gboolean       meta_icon_cache_get_icon_invalidated (MetaIconCache *icon_cache);
+
+gboolean meta_read_icons         (MetaScreen     *screen,
+                                  Window          xwindow,
+                                  MetaIconCache  *icon_cache,
+                                  Pixmap          wm_hints_pixmap,
+                                  Pixmap          wm_hints_mask,
+                                  GdkPixbuf     **iconp,
+                                  int             ideal_width,
+                                  int             ideal_height,
+                                  GdkPixbuf     **mini_iconp,
+                                  int             ideal_mini_width,
+                                  int             ideal_mini_height);
+
+#endif
+
+
+
+
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
new file mode 100644
index 00000000..b9371c85
--- /dev/null
+++ b/src/core/keybindings.c
@@ -0,0 +1,3352 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Keybindings */ 
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for putenv() */
+
+#include <config.h>
+#include "keybindings.h"
+#include "workspace.h"
+#include "errors.h"
+#include "edge-resistance.h"
+#include "ui.h"
+#include "frame-private.h"
+#include "place.h"
+#include "prefs.h"
+#include "effects.h"
+#include "util.h"
+
+#include <X11/keysym.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#endif
+
+static gboolean all_bindings_disabled = FALSE;
+
+typedef void (* MetaKeyHandlerFunc) (MetaDisplay    *display,
+                                     MetaScreen     *screen,
+                                     MetaWindow     *window,
+                                     XEvent         *event,
+                                     MetaKeyBinding *binding);
+
+/* Prototypes for handlers */
+#define keybind(name, handler, param, flags, stroke, description) \
+static void \
+handler (MetaDisplay    *display,\
+         MetaScreen     *screen,\
+         MetaWindow     *window,\
+         XEvent         *event,\
+         MetaKeyBinding *binding);
+#include "all-keybindings.h"
+#undef keybind
+
+/* These can't be bound to anything, but they are used to handle
+ * various other events.  TODO: Possibly we should include them as event
+ * handler functions and have some kind of flag to say they're unbindable.
+ */
+
+static void handle_workspace_switch  (MetaDisplay    *display,
+                                      MetaScreen     *screen,
+                                      MetaWindow     *window,
+                                      XEvent         *event,
+                                      MetaKeyBinding *binding);
+
+static gboolean process_mouse_move_resize_grab (MetaDisplay *display,
+                                                MetaScreen  *screen,
+                                                MetaWindow  *window,
+                                                XEvent      *event,
+                                                KeySym       keysym);
+
+static gboolean process_keyboard_move_grab (MetaDisplay *display,
+                                            MetaScreen  *screen,
+                                            MetaWindow  *window,
+                                            XEvent      *event,
+                                            KeySym       keysym);
+
+static gboolean process_keyboard_resize_grab (MetaDisplay *display,
+                                              MetaScreen  *screen,
+                                              MetaWindow  *window,
+                                              XEvent      *event,
+                                              KeySym       keysym);
+
+static gboolean process_tab_grab           (MetaDisplay *display,
+                                            MetaScreen  *screen,
+                                            XEvent      *event,
+                                            KeySym       keysym);
+
+static gboolean process_workspace_switch_grab (MetaDisplay *display,
+                                               MetaScreen  *screen,
+                                               XEvent      *event,
+                                               KeySym       keysym);
+
+static void regrab_key_bindings         (MetaDisplay *display);
+
+typedef struct
+{
+  const char *name;
+  MetaKeyHandlerFunc func;
+  gint data, flags;
+} MetaKeyHandler;
+
+struct _MetaKeyBinding
+{
+  const char *name;
+  KeySym keysym;
+  KeyCode keycode;
+  unsigned int mask;
+  MetaVirtualModifier modifiers;
+  const MetaKeyHandler *handler;
+};
+
+#define keybind(name, handler, param, flags, stroke, description) \
+   { #name, handler, param, flags },
+static const MetaKeyHandler key_handlers[] = {
+#include "all-keybindings.h"
+   { NULL, NULL, 0, 0 }
+};
+#undef keybind
+
+static void
+reload_keymap (MetaDisplay *display)
+{
+  if (display->keymap)
+    meta_XFree (display->keymap);
+
+  display->keymap = XGetKeyboardMapping (display->xdisplay,
+                                         display->min_keycode,
+                                         display->max_keycode -
+                                         display->min_keycode + 1,
+                                         &display->keysyms_per_keycode);  
+}
+
+static void
+reload_modmap (MetaDisplay *display)
+{
+  XModifierKeymap *modmap;
+  int map_size;
+  int i;
+  
+  if (display->modmap)
+    XFreeModifiermap (display->modmap);
+
+  modmap = XGetModifierMapping (display->xdisplay);
+  display->modmap = modmap;
+
+  display->ignored_modifier_mask = 0;
+
+  /* Multiple bits may get set in each of these */
+  display->num_lock_mask = 0;
+  display->scroll_lock_mask = 0;
+  display->meta_mask = 0;
+  display->hyper_mask = 0;
+  display->super_mask = 0;
+  
+  /* there are 8 modifiers, and the first 3 are shift, shift lock,
+   * and control
+   */
+  map_size = 8 * modmap->max_keypermod;
+  i = 3 * modmap->max_keypermod;
+  while (i < map_size)
+    {
+      /* get the key code at this point in the map,
+       * see if its keysym is one we're interested in
+       */
+      int keycode = modmap->modifiermap[i];
+      
+      if (keycode >= display->min_keycode &&
+          keycode <= display->max_keycode)
+        {
+          int j = 0;
+          KeySym *syms = display->keymap +
+            (keycode - display->min_keycode) * display->keysyms_per_keycode;
+
+          while (j < display->keysyms_per_keycode)
+            {
+              if (syms[j] != 0)
+                {
+                  const char *str;
+                  
+                  str = XKeysymToString (syms[j]);
+                  meta_topic (META_DEBUG_KEYBINDINGS,
+                              "Keysym %s bound to modifier 0x%x\n",
+                              str ? str : "none",
+                              (1 << ( i / modmap->max_keypermod)));
+                }
+              
+              if (syms[j] == XK_Num_Lock)
+                {
+                  /* Mod1Mask is 1 << 3 for example, i.e. the
+                   * fourth modifier, i / keyspermod is the modifier
+                   * index
+                   */
+                  
+                  display->num_lock_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              else if (syms[j] == XK_Scroll_Lock)
+                {
+                  display->scroll_lock_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              else if (syms[j] == XK_Super_L ||
+                       syms[j] == XK_Super_R)
+                {
+                  display->super_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              else if (syms[j] == XK_Hyper_L ||
+                       syms[j] == XK_Hyper_R)
+                {
+                  display->hyper_mask |= (1 << ( i / modmap->max_keypermod));
+                }              
+              else if (syms[j] == XK_Meta_L ||
+                       syms[j] == XK_Meta_R)
+                {
+                  display->meta_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              
+              ++j;
+            }
+        }
+      
+      ++i;
+    }
+
+  display->ignored_modifier_mask = (display->num_lock_mask |
+                                    display->scroll_lock_mask |
+                                    LockMask);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Ignoring modmask 0x%x num lock 0x%x scroll lock 0x%x hyper 0x%x super 0x%x meta 0x%x\n",
+              display->ignored_modifier_mask,
+              display->num_lock_mask,
+              display->scroll_lock_mask,
+              display->hyper_mask,
+              display->super_mask,
+              display->meta_mask);
+}
+
+static void
+reload_keycodes (MetaDisplay *display)
+{
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Reloading keycodes for binding tables\n");
+
+  if (display->key_bindings)
+    {
+      int i;
+      
+      i = 0;
+      while (i < display->n_key_bindings)
+        {
+          if (display->key_bindings[i].keycode == 0)
+              display->key_bindings[i].keycode = XKeysymToKeycode (
+                      display->xdisplay, display->key_bindings[i].keysym);
+          
+          ++i;
+        }
+    }
+}
+
+static void
+reload_modifiers (MetaDisplay *display)
+{
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Reloading keycodes for binding tables\n");
+  
+  if (display->key_bindings)
+    {
+      int i;
+      
+      i = 0;
+      while (i < display->n_key_bindings)
+        {
+          meta_display_devirtualize_modifiers (display,
+                                               display->key_bindings[i].modifiers,
+                                               &display->key_bindings[i].mask);
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      " Devirtualized mods 0x%x -> 0x%x (%s)\n",
+                      display->key_bindings[i].modifiers,
+                      display->key_bindings[i].mask,
+                      display->key_bindings[i].name);          
+          
+          ++i;
+        }
+    }
+}
+
+
+static int
+count_bindings (const MetaKeyPref *prefs,
+                int                n_prefs)
+{
+  int i;
+  int count;
+
+  count = 0;
+  i = 0;
+  while (i < n_prefs)
+    {
+      GSList *tmp = prefs[i].bindings;
+
+      while (tmp)
+        {
+          MetaKeyCombo *combo = tmp->data;
+
+          if (combo && (combo->keysym != None || combo->keycode != 0))
+            {
+              count += 1;
+
+              if (prefs[i].add_shift &&
+                  (combo->modifiers & META_VIRTUAL_SHIFT_MASK) == 0)
+                count += 1;
+            }
+
+          tmp = tmp->next;
+        }
+      
+      ++i;
+    }
+
+  return count;
+}
+
+/* FIXME: replace this with a temporary hash */
+static const MetaKeyHandler*
+find_handler (const MetaKeyHandler *handlers,
+              const char           *name)
+{
+  const MetaKeyHandler *iter;
+
+  iter = handlers;
+  while (iter->name)
+    {
+      if (strcmp (iter->name, name) == 0)
+        return iter;
+
+      ++iter;
+    }
+
+  return NULL;
+}
+
+static void
+rebuild_binding_table (MetaDisplay        *display,
+                       MetaKeyBinding    **bindings_p,
+                       int                *n_bindings_p,
+                       const MetaKeyPref  *prefs,
+                       int                 n_prefs)
+{
+  int n_bindings;
+  int src, dest;
+  
+  n_bindings = count_bindings (prefs, n_prefs);
+  g_free (*bindings_p);
+  *bindings_p = g_new0 (MetaKeyBinding, n_bindings);
+
+  src = 0;
+  dest = 0;
+  while (src < n_prefs)
+    {
+      GSList *tmp = prefs[src].bindings;
+
+      while (tmp)
+        {
+          MetaKeyCombo *combo = tmp->data;
+
+          if (combo && (combo->keysym != None || combo->keycode != 0))
+            {
+              const MetaKeyHandler *handler = find_handler (key_handlers, prefs[src].name);
+
+              (*bindings_p)[dest].name = prefs[src].name;
+              (*bindings_p)[dest].handler = handler;
+              (*bindings_p)[dest].keysym = combo->keysym;
+              (*bindings_p)[dest].keycode = combo->keycode;
+              (*bindings_p)[dest].modifiers = combo->modifiers;
+              (*bindings_p)[dest].mask = 0;
+          
+              ++dest;
+
+              if (prefs[src].add_shift &&
+                  (combo->modifiers & META_VIRTUAL_SHIFT_MASK) == 0)
+                {
+                  meta_topic (META_DEBUG_KEYBINDINGS,
+                              "Binding %s also needs Shift grabbed\n",
+                               prefs[src].name);
+              
+                  (*bindings_p)[dest].name = prefs[src].name;
+                  (*bindings_p)[dest].handler = handler;
+                  (*bindings_p)[dest].keysym = combo->keysym;
+                  (*bindings_p)[dest].keycode = combo->keycode;
+                  (*bindings_p)[dest].modifiers = combo->modifiers |
+                    META_VIRTUAL_SHIFT_MASK;
+                  (*bindings_p)[dest].mask = 0;
+              
+                  ++dest;
+                }
+            }
+            
+          tmp = tmp->next;
+        }
+      
+      ++src;
+    }
+
+  g_assert (dest == n_bindings);
+  
+  *n_bindings_p = dest;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              " %d bindings in table\n",
+              *n_bindings_p);
+}
+
+static void
+rebuild_key_binding_table (MetaDisplay *display)
+{
+  const MetaKeyPref *prefs;
+  int n_prefs;
+  
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Rebuilding key binding table from preferences\n");
+  
+  meta_prefs_get_key_bindings (&prefs, &n_prefs);
+  rebuild_binding_table (display,
+                         &display->key_bindings,
+                         &display->n_key_bindings,
+                         prefs, n_prefs);
+}
+
+static void
+regrab_key_bindings (MetaDisplay *display)
+{
+  GSList *tmp;
+  GSList *windows;
+
+  meta_error_trap_push (display); /* for efficiency push outer trap */
+  
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+
+      meta_screen_ungrab_keys (screen);
+      meta_screen_grab_keys (screen);
+
+      tmp = tmp->next;
+    }
+
+  windows = meta_display_list_windows (display);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+      
+      meta_window_ungrab_keys (w);
+      meta_window_grab_keys (w);
+      
+      tmp = tmp->next;
+    }
+  meta_error_trap_pop (display, FALSE);
+
+  g_slist_free (windows);
+}
+
+static MetaKeyBindingAction
+display_get_keybinding_action (MetaDisplay  *display,
+                               unsigned int  keysym,
+                               unsigned int  keycode,
+                               unsigned long mask)
+{
+  int i;
+
+  i = display->n_key_bindings - 1;
+  while (i >= 0)
+    {
+      if (display->key_bindings[i].keysym == keysym &&
+          display->key_bindings[i].keycode == keycode &&
+          display->key_bindings[i].mask == mask)
+        {
+          return meta_prefs_get_keybinding_action (display->key_bindings[i].name);
+        }
+      
+      --i;
+    }
+
+  return META_KEYBINDING_ACTION_NONE;
+}
+
+void
+meta_display_process_mapping_event (MetaDisplay *display,
+                                    XEvent      *event)
+{ 
+  if (event->xmapping.request == MappingModifier)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Received MappingModifier event, will reload modmap and redo keybindings\n");
+
+      reload_modmap (display);
+
+      reload_modifiers (display);
+      
+      regrab_key_bindings (display);
+    }
+  else if (event->xmapping.request == MappingKeyboard)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Received MappingKeyboard event, will reload keycodes and redo keybindings\n");
+
+      reload_keymap (display);
+      reload_modmap (display);
+      
+      reload_keycodes (display);
+
+      regrab_key_bindings (display);
+    }
+}
+
+static void
+bindings_changed_callback (MetaPreference pref,
+                           void          *data)
+{
+  MetaDisplay *display;
+
+  display = data;
+  
+  switch (pref)
+    {
+    case META_PREF_KEYBINDINGS:
+      rebuild_key_binding_table (display);
+      reload_keycodes (display);
+      reload_modifiers (display);
+      regrab_key_bindings (display);
+      break;
+    default:
+      break;
+    }
+}
+
+
+void
+meta_display_init_keys (MetaDisplay *display)
+{
+  /* Keybindings */
+  display->keymap = NULL;
+  display->keysyms_per_keycode = 0;
+  display->modmap = NULL;
+  display->min_keycode = 0;
+  display->max_keycode = 0;
+  display->ignored_modifier_mask = 0;
+  display->num_lock_mask = 0;
+  display->scroll_lock_mask = 0;
+  display->hyper_mask = 0;
+  display->super_mask = 0;
+  display->meta_mask = 0;
+  display->key_bindings = NULL;
+  display->n_key_bindings = 0;
+
+  XDisplayKeycodes (display->xdisplay,
+                    &display->min_keycode,
+                    &display->max_keycode);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Display has keycode range %d to %d\n",
+              display->min_keycode,
+              display->max_keycode);
+
+  reload_keymap (display);
+  reload_modmap (display);
+
+  rebuild_key_binding_table (display);
+
+  reload_keycodes (display);
+  reload_modifiers (display);
+  
+  /* Keys are actually grabbed in meta_screen_grab_keys() */
+  
+  meta_prefs_add_listener (bindings_changed_callback, display);
+}
+
+void
+meta_display_shutdown_keys (MetaDisplay *display)
+{
+  /* Note that display->xdisplay is invalid in this function */
+  
+  meta_prefs_remove_listener (bindings_changed_callback, display);
+
+  if (display->keymap)
+    meta_XFree (display->keymap);
+  
+  if (display->modmap)
+    XFreeModifiermap (display->modmap);
+  g_free (display->key_bindings);
+}
+
+static const char*
+keysym_name (int keysym)
+{
+  const char *name;
+  
+  name = XKeysymToString (keysym);
+  if (name == NULL)
+    name = "(unknown)";
+
+  return name;
+}
+
+/* Grab/ungrab, ignoring all annoying modifiers like NumLock etc. */
+static void
+meta_change_keygrab (MetaDisplay *display,
+                     Window       xwindow,
+                     gboolean     grab,
+                     int          keysym,
+                     unsigned int keycode,
+                     int          modmask)
+{
+  unsigned int ignored_mask;
+
+  /* Grab keycode/modmask, together with
+   * all combinations of ignored modifiers.
+   * X provides no better way to do this.
+   */
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "%s keybinding %s keycode %d mask 0x%x on 0x%lx\n",
+              grab ? "Grabbing" : "Ungrabbing",
+              keysym_name (keysym), keycode,
+              modmask, xwindow);
+
+  /* efficiency, avoid so many XSync() */
+  meta_error_trap_push (display);
+  
+  ignored_mask = 0;
+  while (ignored_mask <= display->ignored_modifier_mask)
+    {
+      if (ignored_mask & ~(display->ignored_modifier_mask))
+        {
+          /* Not a combination of ignored modifiers
+           * (it contains some non-ignored modifiers)
+           */
+          ++ignored_mask;
+          continue;
+        }
+
+      if (meta_is_debugging ())
+        meta_error_trap_push_with_return (display);
+      if (grab)
+        XGrabKey (display->xdisplay, keycode,
+                  modmask | ignored_mask,
+                  xwindow,
+                  True,
+                  GrabModeAsync, GrabModeSync);
+      else
+        XUngrabKey (display->xdisplay, keycode,
+                    modmask | ignored_mask,
+                    xwindow);
+
+      if (meta_is_debugging ())
+        {
+          int result;
+          
+          result = meta_error_trap_pop_with_return (display, FALSE);
+          
+          if (grab && result != Success)
+            {      
+              if (result == BadAccess)
+                meta_warning (_("Some other program is already using the key %s with modifiers %x as a binding\n"), keysym_name (keysym), modmask | ignored_mask);
+              else
+                meta_topic (META_DEBUG_KEYBINDINGS,
+                            "Failed to grab key %s with modifiers %x\n",
+                            keysym_name (keysym), modmask | ignored_mask);
+            }
+        }
+
+      ++ignored_mask;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+static void
+meta_grab_key (MetaDisplay *display,
+               Window       xwindow,
+               int          keysym,
+               unsigned int keycode,
+               int          modmask)
+{
+  meta_change_keygrab (display, xwindow, TRUE, keysym, keycode, modmask);
+}
+
+static void
+grab_keys (MetaKeyBinding *bindings,
+           int             n_bindings,
+           MetaDisplay    *display,
+           Window          xwindow,
+           gboolean        binding_per_window)
+{
+  int i;
+
+  g_assert (n_bindings == 0 || bindings != NULL);
+
+  meta_error_trap_push (display);
+  
+  i = 0;
+  while (i < n_bindings)
+    {
+      if (!!binding_per_window ==
+          !!(bindings[i].handler->flags & BINDING_PER_WINDOW) &&
+          bindings[i].keycode != 0)
+        {
+          meta_grab_key (display, xwindow,
+                         bindings[i].keysym,
+                         bindings[i].keycode,
+                         bindings[i].mask);
+        }
+      
+      ++i;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+static void
+ungrab_all_keys (MetaDisplay *display,
+                 Window       xwindow)
+{
+  if (meta_is_debugging ())
+    meta_error_trap_push_with_return (display);
+  else
+    meta_error_trap_push (display);
+
+  XUngrabKey (display->xdisplay, AnyKey, AnyModifier,
+              xwindow);
+
+  if (meta_is_debugging ())
+    {
+      int result;
+      
+      result = meta_error_trap_pop_with_return (display, FALSE);
+      
+      if (result != Success)    
+        meta_topic (META_DEBUG_KEYBINDINGS,
+                    "Ungrabbing all keys on 0x%lx failed\n", xwindow);
+    }
+  else
+    meta_error_trap_pop (display, FALSE);
+}
+
+void
+meta_screen_grab_keys (MetaScreen *screen)
+{
+  if (screen->all_keys_grabbed)
+    return;
+
+  if (screen->keys_grabbed)
+    return;
+
+  grab_keys (screen->display->key_bindings,
+             screen->display->n_key_bindings,
+             screen->display, screen->xroot,
+             FALSE);
+
+  screen->keys_grabbed = TRUE;
+}
+
+void
+meta_screen_ungrab_keys (MetaScreen  *screen)
+{
+  if (screen->keys_grabbed)
+    {
+      ungrab_all_keys (screen->display, screen->xroot);
+      screen->keys_grabbed = FALSE;
+    }
+}
+
+void
+meta_window_grab_keys (MetaWindow  *window)
+{
+  if (window->all_keys_grabbed)
+    return;
+
+  if (window->type == META_WINDOW_DOCK)
+    {
+      if (window->keys_grabbed)
+        ungrab_all_keys (window->display, window->xwindow);
+      window->keys_grabbed = FALSE;
+      return;
+    }
+  
+  if (window->keys_grabbed)
+    {
+      if (window->frame && !window->grab_on_frame)
+        ungrab_all_keys (window->display, window->xwindow);
+      else if (window->frame == NULL &&
+               window->grab_on_frame)
+        ; /* continue to regrab on client window */
+      else
+        return; /* already all good */
+    }
+  
+  grab_keys (window->display->key_bindings,
+             window->display->n_key_bindings,
+             window->display,
+             window->frame ? window->frame->xwindow : window->xwindow,
+             TRUE);
+
+  window->keys_grabbed = TRUE;
+  window->grab_on_frame = window->frame != NULL;
+}
+
+void
+meta_window_ungrab_keys (MetaWindow  *window)
+{
+  if (window->keys_grabbed)
+    {
+      if (window->grab_on_frame &&
+          window->frame != NULL)
+        ungrab_all_keys (window->display,
+                         window->frame->xwindow);
+      else if (!window->grab_on_frame)
+        ungrab_all_keys (window->display,
+                         window->xwindow);
+
+      window->keys_grabbed = FALSE;
+    }
+}
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+grab_status_to_string (int status)
+{
+  switch (status)
+    {
+    case AlreadyGrabbed:
+      return "AlreadyGrabbed";
+    case GrabSuccess:
+      return "GrabSuccess";
+    case GrabNotViewable:
+      return "GrabNotViewable";
+    case GrabFrozen:
+      return "GrabFrozen";
+    case GrabInvalidTime:
+      return "GrabInvalidTime";
+    default:
+      return "(unknown)";
+    }
+}
+#endif /* WITH_VERBOSE_MODE */
+
+static gboolean
+grab_keyboard (MetaDisplay *display,
+               Window       xwindow,
+               guint32      timestamp)
+{
+  int result;
+  int grab_status;
+  
+  /* Grab the keyboard, so we get key releases and all key
+   * presses
+   */
+  meta_error_trap_push_with_return (display);
+
+  grab_status = XGrabKeyboard (display->xdisplay,
+                               xwindow, True,
+                               GrabModeAsync, GrabModeAsync,
+                               timestamp);
+  
+  if (grab_status != GrabSuccess)
+    {
+      meta_error_trap_pop_with_return (display, TRUE);
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "XGrabKeyboard() returned failure status %s time %u\n",
+                  grab_status_to_string (grab_status),
+                  timestamp);
+      return FALSE;
+    }
+  else
+    {
+      result = meta_error_trap_pop_with_return (display, TRUE);
+      if (result != Success)
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "XGrabKeyboard() resulted in an error\n");
+          return FALSE;
+        }
+    }
+       
+  meta_topic (META_DEBUG_KEYBINDINGS, "Grabbed all keys\n");
+       
+  return TRUE;
+}
+
+static void
+ungrab_keyboard (MetaDisplay *display, guint32 timestamp)
+{
+  meta_error_trap_push (display);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Ungrabbing keyboard with timestamp %u\n",
+              timestamp);
+  XUngrabKeyboard (display->xdisplay, timestamp);
+  meta_error_trap_pop (display, FALSE);
+}
+
+gboolean
+meta_screen_grab_all_keys (MetaScreen *screen, guint32 timestamp)
+{
+  gboolean retval;
+
+  if (screen->all_keys_grabbed)
+    return FALSE;
+  
+  if (screen->keys_grabbed)
+    meta_screen_ungrab_keys (screen);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Grabbing all keys on RootWindow\n");
+  retval = grab_keyboard (screen->display, screen->xroot, timestamp);
+  if (retval)
+    screen->all_keys_grabbed = TRUE;
+  else
+    meta_screen_grab_keys (screen);
+
+  return retval;
+}
+
+void
+meta_screen_ungrab_all_keys (MetaScreen *screen, guint32 timestamp)
+{
+  if (screen->all_keys_grabbed)
+    {
+      ungrab_keyboard (screen->display, timestamp);
+
+      screen->all_keys_grabbed = FALSE;
+      screen->keys_grabbed = FALSE;
+
+      /* Re-establish our standard bindings */
+      meta_screen_grab_keys (screen);
+    }
+}
+
+gboolean
+meta_window_grab_all_keys (MetaWindow  *window,
+                           guint32      timestamp)
+{
+  Window grabwindow;
+  gboolean retval;
+  
+  if (window->all_keys_grabbed)
+    return FALSE;
+  
+  if (window->keys_grabbed)
+    meta_window_ungrab_keys (window);
+
+  /* Make sure the window is focused, otherwise the grab
+   * won't do a lot of good.
+   */
+  meta_topic (META_DEBUG_FOCUS,
+              "Focusing %s because we're grabbing all its keys\n",
+              window->desc);
+  meta_window_focus (window, timestamp);
+  
+  grabwindow = window->frame ? window->frame->xwindow : window->xwindow;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Grabbing all keys on window %s\n", window->desc);
+  retval = grab_keyboard (window->display, grabwindow, timestamp);
+  if (retval)
+    {
+      window->keys_grabbed = FALSE;
+      window->all_keys_grabbed = TRUE;
+      window->grab_on_frame = window->frame != NULL;
+    }
+
+  return retval;
+}
+
+void
+meta_window_ungrab_all_keys (MetaWindow *window, guint32 timestamp)
+{
+  if (window->all_keys_grabbed)
+    {
+      ungrab_keyboard (window->display, timestamp);
+
+      window->grab_on_frame = FALSE;
+      window->all_keys_grabbed = FALSE;
+      window->keys_grabbed = FALSE;
+
+      /* Re-establish our standard bindings */
+      meta_window_grab_keys (window);
+    }
+}
+
+static gboolean 
+is_modifier (MetaDisplay *display,
+             unsigned int keycode)
+{
+  int i;
+  int map_size;
+  gboolean retval = FALSE;  
+
+  g_assert (display->modmap);
+  
+  map_size = 8 * display->modmap->max_keypermod;
+  i = 0;
+  while (i < map_size)
+    {
+      if (keycode == display->modmap->modifiermap[i])
+        {
+          retval = TRUE;
+          break;
+        }
+      ++i;
+    }
+  
+  return retval;
+}
+
+/* Indexes:
+ * shift = 0
+ * lock = 1
+ * control = 2
+ * mod1 = 3
+ * mod2 = 4
+ * mod3 = 5
+ * mod4 = 6
+ * mod5 = 7
+ */
+
+static gboolean 
+is_specific_modifier (MetaDisplay *display,
+                      unsigned int keycode,
+                      unsigned int mask)
+{
+  int i;
+  int end;
+  gboolean retval = FALSE;
+  int mod_index;
+  
+  g_assert (display->modmap);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Checking whether code 0x%x is bound to modifier 0x%x\n",
+              keycode, mask);
+  
+  mod_index = 0;
+  mask = mask >> 1;
+  while (mask != 0)
+    {
+      mod_index += 1;
+      mask = mask >> 1;
+    }
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Modifier has index %d\n", mod_index);
+  
+  end = (mod_index + 1) * display->modmap->max_keypermod;
+  i = mod_index * display->modmap->max_keypermod;
+  while (i < end)
+    {
+      if (keycode == display->modmap->modifiermap[i])
+        {
+          retval = TRUE;
+          break;
+        }
+      ++i;
+    }
+  
+  return retval;
+}
+
+static unsigned int
+get_primary_modifier (MetaDisplay *display,
+                      unsigned int entire_binding_mask)
+{
+  /* The idea here is to see if the "main" modifier
+   * for Alt+Tab has been pressed/released. So if the binding
+   * is Alt+Shift+Tab then releasing Alt is the thing that
+   * ends the operation. It's pretty random how we order
+   * these.
+   */
+  unsigned int masks[] = { Mod5Mask, Mod4Mask, Mod3Mask,
+                           Mod2Mask, Mod1Mask, ControlMask,
+                           ShiftMask, LockMask };
+
+  int i;
+  
+  i = 0;
+  while (i < (int) G_N_ELEMENTS (masks))
+    {
+      if (entire_binding_mask & masks[i])
+        return masks[i];
+      ++i;
+    }
+
+  return 0;
+}
+
+static gboolean
+keycode_is_primary_modifier (MetaDisplay *display,
+                             unsigned int keycode,
+                             unsigned int entire_binding_mask)
+{
+  unsigned int primary_modifier;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Checking whether code 0x%x is the primary modifier of mask 0x%x\n",
+              keycode, entire_binding_mask);
+  
+  primary_modifier = get_primary_modifier (display, entire_binding_mask);
+  if (primary_modifier != 0)
+    return is_specific_modifier (display, keycode, primary_modifier);
+  else
+    return FALSE;
+}
+
+static gboolean
+primary_modifier_still_pressed (MetaDisplay *display,
+                                unsigned int entire_binding_mask)
+{
+  unsigned int primary_modifier;
+  int x, y, root_x, root_y;
+  Window root, child;
+  guint mask;
+  MetaScreen *random_screen;
+  Window      random_xwindow;
+  
+  primary_modifier = get_primary_modifier (display, entire_binding_mask);
+  
+  random_screen = display->screens->data;
+  random_xwindow = random_screen->no_focus_window;
+  XQueryPointer (display->xdisplay,
+                 random_xwindow, /* some random window */
+                 &root, &child,
+                 &root_x, &root_y,
+                 &x, &y,
+                 &mask);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Primary modifier 0x%x full grab mask 0x%x current state 0x%x\n",
+              primary_modifier, entire_binding_mask, mask);
+  
+  if ((mask & primary_modifier) == 0)
+    return FALSE;
+  else
+    return TRUE;
+}
+
+/* now called from only one place, may be worth merging */
+static gboolean
+process_event (MetaKeyBinding       *bindings,
+               int                   n_bindings,
+               MetaDisplay          *display,
+               MetaScreen           *screen,
+               MetaWindow           *window,
+               XEvent               *event,
+               KeySym                keysym,
+               gboolean              on_window)
+{
+  int i;
+
+  /* we used to have release-based bindings but no longer. */
+  if (event->type == KeyRelease)
+    return FALSE;
+
+  /*
+   * TODO: This would be better done with a hash table;
+   * it doesn't suit to use O(n) for such a common operation.
+   */
+  for (i=0; i<n_bindings; i++)
+    {
+      const MetaKeyHandler *handler = bindings[i].handler;
+
+      if ((!on_window && handler->flags & BINDING_PER_WINDOW) ||
+          event->type != KeyPress ||
+          bindings[i].keycode != event->xkey.keycode ||
+          ((event->xkey.state & 0xff & ~(display->ignored_modifier_mask)) !=
+           bindings[i].mask))
+        continue;
+        
+      /*
+       * window must be non-NULL for on_window to be true,
+       * and so also window must be non-NULL if we get here and
+       * this is a BINDING_PER_WINDOW binding.
+       */
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Binding keycode 0x%x mask 0x%x matches event 0x%x state 0x%x\n",
+                  bindings[i].keycode, bindings[i].mask,
+                  event->xkey.keycode, event->xkey.state);
+
+      if (handler == NULL)
+        meta_bug ("Binding %s has no handler\n", bindings[i].name);
+      else
+        meta_topic (META_DEBUG_KEYBINDINGS,
+                    "Running handler for %s\n",
+                    bindings[i].name);
+          
+      /* Global keybindings count as a let-the-terminal-lose-focus
+       * due to new window mapping until the user starts
+       * interacting with the terminal again.
+       */
+      display->allow_terminal_deactivation = TRUE;
+
+      (* handler->func) (display, screen,
+                         bindings[i].handler->flags & BINDING_PER_WINDOW? window: NULL,
+                         event,
+                         &bindings[i]);
+      return TRUE;
+    }
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "No handler found for this event in this binding table\n");
+  return FALSE;
+}
+
+/* Handle a key event. May be called recursively: some key events cause
+ * grabs to be ended and then need to be processed again in their own
+ * right. This cannot cause infinite recursion because we never call
+ * ourselves when there wasn't a grab, and we always clear the grab
+ * first; the invariant is enforced using an assertion. See #112560.
+ * FIXME: We need to prove there are no race conditions here.
+ * FIXME: Does it correctly handle alt-Tab being followed by another
+ * grabbing keypress without letting go of alt?
+ * FIXME: An iterative solution would probably be simpler to understand
+ * (and help us solve the other fixmes).
+ */
+void
+meta_display_process_key_event (MetaDisplay *display,
+                                MetaWindow  *window,
+                                XEvent      *event)
+{
+  KeySym keysym;
+  gboolean keep_grab;
+  gboolean all_keys_grabbed;
+  const char *str;
+  MetaScreen *screen;
+
+  XAllowEvents (display->xdisplay,
+                all_bindings_disabled ? ReplayKeyboard : AsyncKeyboard,
+                event->xkey.time);
+  if (all_bindings_disabled)
+    return;
+  
+  /* if key event was on root window, we have a shortcut */
+  screen = meta_display_screen_for_root (display, event->xkey.window);
+  
+  /* else round-trip to server */
+  if (screen == NULL)
+    screen = meta_display_screen_for_xwindow (display,
+                                              event->xany.window);
+
+  if (screen == NULL)
+    return; /* event window is destroyed */
+  
+  /* ignore key events on popup menus and such. */
+  if (window == NULL &&
+      meta_ui_window_is_widget (screen->ui, event->xany.window))
+    return;
+  
+  /* window may be NULL */
+  
+  keysym = XKeycodeToKeysym (display->xdisplay, event->xkey.keycode, 0);
+
+  str = XKeysymToString (keysym);
+  
+  /* was topic */
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Processing key %s event, keysym: %s state: 0x%x window: %s\n",
+              event->type == KeyPress ? "press" : "release",
+              str ? str : "none", event->xkey.state,
+              window ? window->desc : "(no window)");
+
+  keep_grab = TRUE;
+  all_keys_grabbed = window ? window->all_keys_grabbed : screen->all_keys_grabbed;
+  if (all_keys_grabbed)
+    {
+      if (display->grab_op == META_GRAB_OP_NONE)
+        return;
+      /* If we get here we have a global grab, because
+        * we're in some special keyboard mode such as window move
+        * mode.
+        */
+      if (window ? (window == display->grab_window) :
+          (screen == display->grab_screen))
+        {
+          switch (display->grab_op)
+            {
+            case META_GRAB_OP_MOVING:
+            case META_GRAB_OP_RESIZING_SE:
+            case META_GRAB_OP_RESIZING_S:      
+            case META_GRAB_OP_RESIZING_SW:      
+            case META_GRAB_OP_RESIZING_N:
+            case META_GRAB_OP_RESIZING_NE:
+            case META_GRAB_OP_RESIZING_NW:
+            case META_GRAB_OP_RESIZING_W:
+            case META_GRAB_OP_RESIZING_E:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for mouse-only move/resize\n");
+              g_assert (window != NULL);
+              keep_grab = process_mouse_move_resize_grab (display, screen,
+                                                          window, event, keysym);
+              break;
+ 
+            case META_GRAB_OP_KEYBOARD_MOVING:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard move\n");
+              g_assert (window != NULL);
+              keep_grab = process_keyboard_move_grab (display, screen,
+                                                      window, event, keysym);
+              break;
+              
+            case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+            case META_GRAB_OP_KEYBOARD_RESIZING_S:
+            case META_GRAB_OP_KEYBOARD_RESIZING_N:
+            case META_GRAB_OP_KEYBOARD_RESIZING_W:
+            case META_GRAB_OP_KEYBOARD_RESIZING_E:
+            case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+            case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+            case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+            case META_GRAB_OP_KEYBOARD_RESIZING_NW:          
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard resize\n");
+              g_assert (window != NULL);
+              keep_grab = process_keyboard_resize_grab (display, screen,
+                                                        window, event, keysym);
+              break;
+ 
+            case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+            case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+            case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+            case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+            case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+            case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard tabbing/cycling\n");
+              keep_grab = process_tab_grab (display, screen, event, keysym);
+              break;
+              
+            case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard workspace switching\n");
+              keep_grab = process_workspace_switch_grab (display, screen, event, keysym);
+              break;
+ 
+            default:
+              break;
+            }
+        }
+      if (!keep_grab)
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Ending grab op %u on key event sym %s\n",
+                      display->grab_op, XKeysymToString (keysym));
+          meta_display_end_grab_op (display, event->xkey.time);
+          return;
+        }
+      }
+  /* Do the normal keybindings */
+  process_event (display->key_bindings,
+                 display->n_key_bindings,
+                 display, screen, window, event, keysym,
+                 !all_keys_grabbed && window);
+}
+
+static gboolean
+process_mouse_move_resize_grab (MetaDisplay *display,
+                                MetaScreen  *screen,
+                                MetaWindow  *window,
+                                XEvent      *event,
+                                KeySym       keysym)
+{
+  /* don't care about releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  if (keysym == XK_Escape)
+    {
+      /* End move or resize and restore to original state.  If the
+       * window was a maximized window that had been "shaken loose" we
+       * need to remaximize it.  In normal cases, we need to do a
+       * moveresize now to get the position back to the original.  In
+       * wireframe mode, we just need to set grab_was_cancelled to tru
+       * to avoid avoid moveresizing to the position of the wireframe.
+       */
+      if (window->shaken_loose)
+        meta_window_maximize (window,
+                              META_MAXIMIZE_HORIZONTAL |
+                              META_MAXIMIZE_VERTICAL);
+      else if (!display->grab_wireframe_active)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_initial_window_pos.x,
+                                 display->grab_initial_window_pos.y,
+                                 display->grab_initial_window_pos.width,
+                                 display->grab_initial_window_pos.height);
+      else
+        display->grab_was_cancelled = TRUE;
+
+      /* End grab */
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+process_keyboard_move_grab (MetaDisplay *display,
+                            MetaScreen  *screen,
+                            MetaWindow  *window,
+                            XEvent      *event,
+                            KeySym       keysym)
+{
+  gboolean handled;
+  int x, y;
+  int incr;
+  gboolean smart_snap;
+  
+  handled = FALSE;
+
+  /* don't care about releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  if (display->grab_wireframe_active)
+    {
+      x = display->grab_wireframe_rect.x;
+      y = display->grab_wireframe_rect.y;
+    }
+  else
+    {
+      meta_window_get_position (window, &x, &y);
+    }
+
+  smart_snap = (event->xkey.state & ShiftMask) != 0;
+  
+#define SMALL_INCREMENT 1
+#define NORMAL_INCREMENT 10
+
+  if (smart_snap)
+    incr = 1;
+  else if (event->xkey.state & ControlMask)
+    incr = SMALL_INCREMENT;
+  else
+    incr = NORMAL_INCREMENT;
+
+  if (keysym == XK_Escape)
+    {
+      /* End move and restore to original state.  If the window was a
+       * maximized window that had been "shaken loose" we need to
+       * remaximize it.  In normal cases, we need to do a moveresize
+       * now to get the position back to the original.  In wireframe
+       * mode, we just need to set grab_was_cancelled to tru to avoid
+       * avoid moveresizing to the position of the wireframe.
+       */
+      if (window->shaken_loose)
+        meta_window_maximize (window,
+                              META_MAXIMIZE_HORIZONTAL |
+                              META_MAXIMIZE_VERTICAL);
+      else if (!display->grab_wireframe_active)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_initial_window_pos.x,
+                                 display->grab_initial_window_pos.y,
+                                 display->grab_initial_window_pos.width,
+                                 display->grab_initial_window_pos.height);
+      else
+        display->grab_was_cancelled = TRUE;
+    }
+  
+  /* When moving by increments, we still snap to edges if the move
+   * to the edge is smaller than the increment. This is because
+   * Shift + arrow to snap is sort of a hidden feature. This way
+   * people using just arrows shouldn't get too frustrated.
+   */
+  switch (keysym)
+    {
+    case XK_KP_Home:
+    case XK_KP_Prior:
+    case XK_Up:
+    case XK_KP_Up:
+      y -= incr;
+      handled = TRUE;
+      break;
+    case XK_KP_End:
+    case XK_KP_Next:
+    case XK_Down:
+    case XK_KP_Down:
+      y += incr;
+      handled = TRUE;
+      break;
+    }
+  
+  switch (keysym)
+    {
+    case XK_KP_Home:
+    case XK_KP_End:
+    case XK_Left:
+    case XK_KP_Left:
+      x -= incr;
+      handled = TRUE;
+      break;
+    case XK_KP_Prior:
+    case XK_KP_Next:
+    case XK_Right:
+    case XK_KP_Right:
+      x += incr;
+      handled = TRUE;
+      break;
+    }
+
+  if (handled)
+    {
+      MetaRectangle old_rect;
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Computed new window location %d,%d due to keypress\n",
+                  x, y);
+
+      if (display->grab_wireframe_active)
+        old_rect = display->grab_wireframe_rect;
+      else
+        meta_window_get_client_root_coords (window, &old_rect);
+
+      meta_window_edge_resistance_for_move (window, 
+                                            old_rect.x,
+                                            old_rect.y,
+                                            &x,
+                                            &y,
+                                            NULL,
+                                            smart_snap,
+                                            TRUE);
+
+      if (display->grab_wireframe_active)
+        {
+          meta_window_update_wireframe (window, x, y,
+                                        display->grab_wireframe_rect.width,
+                                        display->grab_wireframe_rect.height);
+        }
+      else
+        {
+          meta_window_move (window, TRUE, x, y);
+        }
+      
+      meta_window_update_keyboard_move (window);
+    }
+
+  return handled;
+}
+
+static gboolean
+process_keyboard_resize_grab_op_change (MetaDisplay *display,
+                                        MetaScreen  *screen,
+                                        MetaWindow  *window,
+                                        XEvent      *event,
+                                        KeySym       keysym)
+{
+  gboolean handled;
+
+  handled = FALSE;
+  switch (display->grab_op)
+    {
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+      switch (keysym)
+        {
+        case XK_Up:
+        case XK_KP_Up:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;          
+          handled = TRUE;
+          break;
+        case XK_Down:
+        case XK_KP_Down:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          handled = TRUE;
+          break;
+        case XK_Left:
+        case XK_KP_Left:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          handled = TRUE;
+          break;
+        case XK_Right:
+        case XK_KP_Right:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          handled = TRUE;
+          break;
+        }
+      break;
+      
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+      switch (keysym)
+        {
+        case XK_Left:
+        case XK_KP_Left:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          handled = TRUE;
+          break;
+        case XK_Right:
+        case XK_KP_Right:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          handled = TRUE;
+          break;
+        }
+      break;
+
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+      switch (keysym)
+        {
+        case XK_Left:
+        case XK_KP_Left:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          handled = TRUE;
+          break;
+        case XK_Right:
+        case XK_KP_Right:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          handled = TRUE;
+          break;
+        }
+      break;
+      
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+      switch (keysym)
+        {
+        case XK_Up:
+        case XK_KP_Up:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;          
+          handled = TRUE;
+          break;
+        case XK_Down:
+        case XK_KP_Down:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          handled = TRUE;
+          break;
+        }
+      break;
+
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+      switch (keysym)
+        {
+        case XK_Up:
+        case XK_KP_Up:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N; 
+          handled = TRUE;
+          break;
+        case XK_Down:
+        case XK_KP_Down:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          handled = TRUE;
+          break;
+        }
+      break;
+      
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  if (handled)
+    {
+      meta_window_update_keyboard_resize (window, TRUE);
+      return TRUE; 
+    }
+
+  return FALSE;
+}
+
+static gboolean
+process_keyboard_resize_grab (MetaDisplay *display,
+                              MetaScreen  *screen,
+                              MetaWindow  *window,
+                              XEvent      *event,
+                              KeySym       keysym)
+{
+  gboolean handled;
+  int height_inc;
+  int width_inc;
+  int width, height;
+  gboolean smart_snap;
+  int gravity;
+  
+  handled = FALSE;
+
+  /* don't care about releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  if (keysym == XK_Escape)
+    {
+      /* End resize and restore to original state.  If not in
+       * wireframe mode, we need to do a moveresize now to get the
+       * position back to the original.  If we are in wireframe mode,
+       * we need to avoid moveresizing to the position of the
+       * wireframe.
+       */
+      if (!display->grab_wireframe_active)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_initial_window_pos.x,
+                                 display->grab_initial_window_pos.y,
+                                 display->grab_initial_window_pos.width,
+                                 display->grab_initial_window_pos.height);
+      else
+        display->grab_was_cancelled = TRUE;
+
+      return FALSE;
+    }
+
+  if (process_keyboard_resize_grab_op_change (display, screen, window, 
+                                              event, keysym))
+    return TRUE;
+
+  if (display->grab_wireframe_active)
+    {
+      width = display->grab_wireframe_rect.width;
+      height = display->grab_wireframe_rect.height;
+    }
+  else
+    {
+      width = window->rect.width;
+      height = window->rect.height;
+    }
+
+  gravity = meta_resize_gravity_from_grab_op (display->grab_op);
+
+  smart_snap = (event->xkey.state & ShiftMask) != 0;
+  
+#define SMALL_INCREMENT 1
+#define NORMAL_INCREMENT 10
+
+  if (smart_snap)
+    {
+      height_inc = 1;
+      width_inc = 1;
+    }
+  else if (event->xkey.state & ControlMask)
+    {
+      width_inc = SMALL_INCREMENT;
+      height_inc = SMALL_INCREMENT;
+    }  
+  else
+    {
+      width_inc = NORMAL_INCREMENT;
+      height_inc = NORMAL_INCREMENT;
+    }
+
+  /* If this is a resize increment window, make the amount we resize
+   * the window by match that amount (well, unless snap resizing...)
+   */
+  if (window->size_hints.width_inc > 1)
+    width_inc = window->size_hints.width_inc;
+  if (window->size_hints.height_inc > 1)
+    height_inc = window->size_hints.height_inc;
+  
+  switch (keysym)
+    {
+    case XK_Up:
+    case XK_KP_Up:
+      switch (gravity)
+        {
+        case NorthGravity:
+        case NorthWestGravity:
+        case NorthEastGravity:
+          /* Move bottom edge up */
+          height -= height_inc;
+          break;
+
+        case SouthGravity:
+        case SouthWestGravity:
+        case SouthEastGravity:
+          /* Move top edge up */
+          height += height_inc;
+          break;
+
+        case EastGravity:
+        case WestGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+
+    case XK_Down:
+    case XK_KP_Down:
+      switch (gravity)
+        {
+        case NorthGravity:
+        case NorthWestGravity:
+        case NorthEastGravity:
+          /* Move bottom edge down */
+          height += height_inc;
+          break;
+
+        case SouthGravity:
+        case SouthWestGravity:
+        case SouthEastGravity:
+          /* Move top edge down */
+          height -= height_inc;
+          break;
+
+        case EastGravity:
+        case WestGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+      
+    case XK_Left:
+    case XK_KP_Left:
+      switch (gravity)
+        {
+        case EastGravity:
+        case SouthEastGravity:
+        case NorthEastGravity:
+          /* Move left edge left */
+          width += width_inc;
+          break;
+
+        case WestGravity:
+        case SouthWestGravity:
+        case NorthWestGravity:
+          /* Move right edge left */
+          width -= width_inc;
+          break;
+
+        case NorthGravity:
+        case SouthGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+      
+    case XK_Right:
+    case XK_KP_Right:
+      switch (gravity)
+        {
+        case EastGravity:
+        case SouthEastGravity:
+        case NorthEastGravity:
+          /* Move left edge right */
+          width -= width_inc;
+          break;
+
+        case WestGravity:
+        case SouthWestGravity:
+        case NorthWestGravity:
+          /* Move right edge right */
+          width += width_inc;
+          break;
+
+        case NorthGravity:
+        case SouthGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+          
+    default:
+      break;
+    }
+
+  /* fixup hack (just paranoia, not sure it's required) */
+  if (height < 1)
+    height = 1;
+  if (width < 1)
+    width = 1;
+  
+  if (handled)
+    {
+      MetaRectangle old_rect;
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Computed new window size due to keypress: "
+                  "%dx%d, gravity %s\n",
+                  width, height, meta_gravity_to_string (gravity));
+      
+      if (display->grab_wireframe_active)
+        old_rect = display->grab_wireframe_rect;
+      else
+        old_rect = window->rect;  /* Don't actually care about x,y */
+
+      /* Do any edge resistance/snapping */
+      meta_window_edge_resistance_for_resize (window,
+                                              old_rect.width,
+                                              old_rect.height,
+                                              &width,
+                                              &height,
+                                              gravity,
+                                              NULL,
+                                              smart_snap,
+                                              TRUE);
+
+      if (display->grab_wireframe_active)
+        {
+          MetaRectangle new_position;
+          meta_rectangle_resize_with_gravity (&display->grab_wireframe_rect, 
+                                              &new_position,
+                                              gravity,
+                                              width,
+                                              height);
+          meta_window_update_wireframe (window, 
+                                        new_position.x,
+                                        new_position.y,
+                                        new_position.width, 
+                                        new_position.height);
+        }
+      else
+        {
+          /* We don't need to update unless the specified width and height
+           * are actually different from what we had before.
+           */
+          if (window->rect.width != width || window->rect.height != height)
+            meta_window_resize_with_gravity (window, 
+                                             TRUE,
+                                             width,
+                                             height,
+                                             gravity);
+        }
+      meta_window_update_keyboard_resize (window, FALSE);
+    }
+
+  return handled;
+}
+
+static gboolean
+end_keyboard_grab (MetaDisplay *display,
+		   unsigned int keycode)
+{
+#ifdef HAVE_XKB
+  if (display->xkb_base_event_type > 0)
+    {
+      unsigned int primary_modifier;
+      XkbStateRec state;
+  
+      primary_modifier = get_primary_modifier (display, display->grab_mask);
+      
+      XkbGetState (display->xdisplay, XkbUseCoreKbd, &state);
+
+      if (!(primary_modifier & state.mods))
+	return TRUE;
+    }
+  else
+#endif
+    {
+      if (keycode_is_primary_modifier (display, keycode, display->grab_mask))
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+process_tab_grab (MetaDisplay *display,
+                  MetaScreen  *screen,
+                  XEvent      *event,
+                  KeySym       keysym)
+{
+  MetaKeyBindingAction action;
+  gboolean popup_not_showing;
+  gboolean backward;
+  gboolean key_used;
+  Window      prev_xwindow;
+  MetaWindow *prev_window;
+
+  if (screen != display->grab_screen)
+    return FALSE;
+
+  g_return_val_if_fail (screen->tab_popup != NULL, FALSE);
+
+  if (event->type == KeyRelease &&
+      end_keyboard_grab (display, event->xkey.keycode))
+    {
+      /* We're done, move to the new window. */
+      Window target_xwindow;
+      MetaWindow *target_window;
+
+      target_xwindow =
+        (Window) meta_ui_tab_popup_get_selected (screen->tab_popup);
+      target_window =
+        meta_display_lookup_x_window (display, target_xwindow);
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Ending tab operation, primary modifier released\n");
+      
+      if (target_window)
+        {
+          target_window->tab_unminimized = FALSE;
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Activating target window\n");
+
+          meta_topic (META_DEBUG_FOCUS, "Activating %s due to tab popup "
+                      "selection and turning mouse_mode off\n",
+                      target_window->desc);
+          display->mouse_mode = FALSE;
+          meta_window_activate (target_window, event->xkey.time);
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Ending grab early so we can focus the target window\n");
+          meta_display_end_grab_op (display, event->xkey.time);
+
+          return TRUE; /* we already ended the grab */
+        }
+      
+      return FALSE; /* end grab */
+    }
+  
+  /* don't care about other releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  prev_xwindow = (Window) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  prev_window  = meta_display_lookup_x_window (display, prev_xwindow);
+  action = display_get_keybinding_action (display,
+                                          keysym,
+                                          event->xkey.keycode,
+                                          display->grab_mask);
+
+  /* Cancel when alt-Escape is pressed during using alt-Tab, and vice
+   * versa.
+   */
+  switch (action)
+    {
+    case META_KEYBINDING_ACTION_CYCLE_PANELS:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS:
+    case META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD:
+      /* CYCLE_* are traditionally Escape-based actions,
+       * and should cancel traditionally Tab-based ones.
+       */
+       switch (display->grab_op)
+        {
+        case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+        case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+         /* carry on */
+          break;
+        default:
+          return FALSE;
+        }
+       break;
+    case META_KEYBINDING_ACTION_SWITCH_PANELS:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS:
+    case META_KEYBINDING_ACTION_SWITCH_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD:
+      /* SWITCH_* are traditionally Tab-based actions,
+       * and should cancel traditionally Escape-based ones.
+       */
+      switch (display->grab_op)
+        {
+        case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+        case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+          /* carry on */
+          break;
+        default:
+          /* Also, we must re-lower and re-minimize whatever window
+           * we'd previously raised and unminimized.
+           */
+          meta_stack_set_positions (screen->stack,
+                                    screen->display->grab_old_window_stacking);
+          if (prev_window && prev_window->tab_unminimized)
+            {
+              meta_window_minimize (prev_window);
+              prev_window->tab_unminimized = FALSE;
+            }
+          return FALSE;
+        }
+      break;
+    case META_KEYBINDING_ACTION_CYCLE_GROUP:
+    case META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD:
+      switch (display->grab_op)
+        {
+        case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+        case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+          /* carry on */
+             break;
+        default:
+             return FALSE;
+        }
+ 
+      break;
+    default:
+      break;
+    }
+
+  /* !! TO HERE !!
+   * alt-f6 during alt-{Tab,Escape} does not end the grab
+   * but does change the grab op (and redraws the window,
+   * of course).
+   * See _{SWITCH,CYCLE}_GROUP.@@@
+   */
+   
+  popup_not_showing = FALSE;
+  key_used = FALSE;
+  backward = FALSE;
+
+  switch (action)
+    {
+    case META_KEYBINDING_ACTION_CYCLE_PANELS:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS:
+    case META_KEYBINDING_ACTION_CYCLE_GROUP:
+      popup_not_showing = TRUE;
+      key_used = TRUE;
+      break;
+    case META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD:
+    case META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD:
+      popup_not_showing = TRUE;
+      key_used = TRUE;
+      backward = TRUE;
+      break;
+    case META_KEYBINDING_ACTION_SWITCH_PANELS:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP:
+      key_used = TRUE;
+      break;
+    case META_KEYBINDING_ACTION_SWITCH_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD:
+      key_used = TRUE;
+      backward = TRUE;
+      break;
+    default:
+      break;
+    }
+  
+  if (key_used)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Key pressed, moving tab focus in popup\n");
+
+      if (event->xkey.state & ShiftMask)
+        backward = !backward;
+
+      if (backward)
+        meta_ui_tab_popup_backward (screen->tab_popup);
+      else
+        meta_ui_tab_popup_forward (screen->tab_popup);
+      
+      if (popup_not_showing)
+        {
+          /* We can't actually change window focus, due to the grab.
+           * but raise the window.
+           */
+          Window target_xwindow;
+          MetaWindow *target_window;
+
+          meta_stack_set_positions (screen->stack,
+                                    display->grab_old_window_stacking);
+
+          target_xwindow =
+            (Window) meta_ui_tab_popup_get_selected (screen->tab_popup);
+          target_window =
+            meta_display_lookup_x_window (display, target_xwindow);
+          
+          if (prev_window && prev_window->tab_unminimized)
+            {
+              prev_window->tab_unminimized = FALSE;
+              meta_window_minimize (prev_window);
+            }
+
+          if (target_window)
+            {
+              meta_window_raise (target_window);
+              target_window->tab_unminimized = target_window->minimized;
+              meta_window_unminimize (target_window);
+            }
+        }
+    }
+  else
+    {
+      /* end grab */
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Ending tabbing/cycling, uninteresting key pressed\n");
+
+      meta_topic (META_DEBUG_KEYBINDINGS, 
+                  "Syncing to old stack positions.\n");
+      meta_stack_set_positions (screen->stack,
+                                screen->display->grab_old_window_stacking);
+
+      if (prev_window && prev_window->tab_unminimized)
+        {
+          meta_window_minimize (prev_window);
+          prev_window->tab_unminimized = FALSE;
+        }
+    }
+  
+  return key_used;
+}
+
+static void
+handle_switch_to_workspace (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *event_window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  gint which = binding->handler->data;
+  MetaWorkspace *workspace;
+  
+  if (which < 0)
+    {
+      /* Negative workspace numbers are directions with respect to the
+       * current workspace.  While we could insta-switch here by setting
+       * workspace to the result of meta_workspace_get_neighbor(), when
+       * people request a workspace switch to the left or right via
+       * the keyboard, they actually want a tab popup.  So we should
+       * go there instead.
+       *
+       * Note that we're the only caller of that function, so perhaps
+       * we should merge with it.
+       */
+      handle_workspace_switch (display, screen, event_window, event, binding);
+      return;
+    }
+
+  workspace = meta_screen_get_workspace_by_index (screen, which);
+  
+  if (workspace)
+    {
+      meta_workspace_activate (workspace, event->xkey.time);
+    }
+  else
+    {
+      /* We could offer to create it I suppose */
+    }
+}
+
+static void
+error_on_command (int         command_index,
+                  const char *command,
+                  const char *message,
+                  int         screen_number,
+                  guint32     timestamp)
+{
+  if (command_index < 0)
+    meta_warning ("Error on terminal command \"%s\": %s\n", command, message);  
+  else
+    meta_warning ("Error on command %d \"%s\": %s\n",
+                  command_index, command, message);  
+
+  /*
+    marco-dialog said:
+        
+    FIXME offer to change the value of the command's mateconf key
+  */
+
+  if (command && strcmp(command, "")!=0)
+    {
+      char *text = g_strdup_printf (
+                                    /* Displayed when a keybinding which is
+                                     * supposed to launch a program fails.
+                                     */
+                                    _("There was an error running "
+                                      "<tt>%s</tt>:\n\n%s"),
+                                    command,
+                                    message);
+
+      meta_show_dialog ("--error",
+                        text,
+                        NULL,
+                        screen_number,
+                        NULL, NULL, 0,
+                        NULL, NULL);
+
+      g_free (text);
+
+    }
+  else
+    {
+      meta_show_dialog ("--error",
+                        message,
+                        NULL,
+                        screen_number,
+                        NULL, NULL, 0,
+                        NULL, NULL);
+    }
+}
+
+static void
+set_display_setup_func (void *data)
+{
+  const char *screen_name = data;
+  char *full;
+
+  full = g_strdup_printf ("DISPLAY=%s", screen_name);
+
+  putenv (full);
+
+  /* do not free full, because putenv is lame */
+} 
+
+static gboolean
+meta_spawn_command_line_async_on_screen (const gchar *command_line,
+                                         MetaScreen  *screen,
+                                         GError     **error)
+{
+  gboolean retval;
+  gchar **argv = NULL;
+
+  g_return_val_if_fail (command_line != NULL, FALSE);
+
+  if (!g_shell_parse_argv (command_line,
+                           NULL, &argv,
+                           error))
+    return FALSE;
+  
+  retval = g_spawn_async (NULL,
+                          argv,
+                          NULL,
+                          G_SPAWN_SEARCH_PATH,
+                          set_display_setup_func,
+                          screen->screen_name,
+                          NULL,
+                          error);
+  g_strfreev (argv);
+
+  return retval;
+}
+
+
+static void
+handle_run_command (MetaDisplay    *display,
+                    MetaScreen     *screen,
+                    MetaWindow     *window,
+                    XEvent         *event,
+                    MetaKeyBinding *binding)
+{
+  gint which = binding->handler->data;
+  const char *command;
+  GError *err;
+  
+  command = meta_prefs_get_command (which);
+
+  if (command == NULL)
+    {
+      char *s;
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "No command %d to run in response to keybinding press\n",
+                  which);
+      
+      s = g_strdup_printf (_("No command %d has been defined.\n"),
+                           which + 1);
+      error_on_command (which, NULL, s, screen->number, event->xkey.time);
+      g_free (s);
+      
+      return;
+    }
+
+  err = NULL;
+  if (!meta_spawn_command_line_async_on_screen (command, screen, &err))
+    {
+      error_on_command (which, command, err->message, screen->number, event->xkey.time);
+      
+      g_error_free (err);
+    }
+}
+
+
+static void
+handle_maximize_vertically (MetaDisplay    *display,
+                      MetaScreen     *screen,
+                      MetaWindow     *window,
+                      XEvent         *event,
+                      MetaKeyBinding *binding)
+{
+  if (window->has_resize_func)
+    {
+      if (window->maximized_vertically)
+        meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL);
+      else
+        meta_window_maximize (window, META_MAXIMIZE_VERTICAL);
+    }
+}
+
+static void
+handle_maximize_horizontally (MetaDisplay    *display,
+                       MetaScreen     *screen,
+                       MetaWindow     *window,
+                       XEvent         *event,
+                       MetaKeyBinding *binding)
+{
+  if (window->has_resize_func)
+    {
+      if (window->maximized_horizontally)
+        meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL);
+      else
+        meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL);
+    }
+}
+
+/* Move a window to a corner; to_bottom/to_right are FALSE for the
+ * top or left edge, or TRUE for the bottom/right edge.  xchange/ychange
+ * are FALSE if that dimension is not to be changed, TRUE otherwise.
+ * Together they describe which of the four corners, or four sides,
+ * is desired.
+ */
+static void
+handle_move_to_corner_backend (MetaDisplay    *display,
+           MetaScreen     *screen,
+           MetaWindow     *window,
+           gboolean        xchange,
+           gboolean        ychange,
+           gboolean        to_right,
+           gboolean        to_bottom)
+{
+  MetaRectangle work_area;
+  MetaRectangle outer;
+  int orig_x, orig_y;
+  int new_x, new_y;
+  int frame_width, frame_height;
+
+  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_position (window, &orig_x, &orig_y);
+
+  frame_width = (window->frame ? window->frame->child_x : 0);
+  frame_height = (window->frame ? window->frame->child_y : 0);
+
+  if (xchange) {
+    new_x = work_area.x + (to_right ?
+            (work_area.width + frame_width) - outer.width :
+            0);
+  } else {
+    new_x = orig_x;
+  }
+
+  if (ychange) {
+    new_y = work_area.y + (to_bottom ?
+            (work_area.height + frame_height) - outer.height :
+            0);
+  } else {
+    new_y = orig_y;
+  }
+
+  meta_window_move_resize (window,
+          FALSE,
+          new_x,
+          new_y,
+          window->rect.width,
+          window->rect.height);
+}
+
+static void
+handle_move_to_corner_nw  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, FALSE);
+}
+
+static void
+handle_move_to_corner_ne  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, FALSE);
+}
+
+static void
+handle_move_to_corner_sw  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, TRUE);
+}
+
+static void
+handle_move_to_corner_se  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, TRUE);
+}
+
+static void
+handle_move_to_side_n     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, FALSE);
+}
+
+static void
+handle_move_to_side_s     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, TRUE);
+}
+
+static void
+handle_move_to_side_e     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, TRUE, FALSE);
+}
+
+static void
+handle_move_to_side_w     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, FALSE, FALSE);
+}
+
+static void
+handle_move_to_center  (MetaDisplay    *display,
+                        MetaScreen     *screen,
+                        MetaWindow     *window,
+                        XEvent         *event,
+                        MetaKeyBinding *binding)
+{
+  MetaRectangle work_area;
+  MetaRectangle outer;
+  int orig_x, orig_y;
+  int frame_width, frame_height;
+
+  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_position (window, &orig_x, &orig_y);
+
+  frame_width = (window->frame ? window->frame->child_x : 0);
+  frame_height = (window->frame ? window->frame->child_y : 0);
+
+  meta_window_move_resize (window,
+          TRUE,
+          work_area.x + (work_area.width +frame_width -outer.width )/2,
+          work_area.y + (work_area.height+frame_height-outer.height)/2,
+          window->rect.width,
+          window->rect.height);
+}
+
+static gboolean
+process_workspace_switch_grab (MetaDisplay *display,
+                               MetaScreen  *screen,
+                               XEvent      *event,
+                               KeySym       keysym)
+{
+  MetaWorkspace *workspace;
+
+  if (screen != display->grab_screen)
+    return FALSE;
+
+  g_return_val_if_fail (screen->tab_popup != NULL, FALSE);
+
+  if (event->type == KeyRelease &&
+      end_keyboard_grab (display, event->xkey.keycode))
+    {
+      /* We're done, move to the new workspace. */
+      MetaWorkspace *target_workspace;
+
+      target_workspace =
+        (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Ending workspace tab operation, primary modifier released\n");
+
+      if (target_workspace == screen->active_workspace)
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Ending grab so we can focus on the target workspace\n");
+          meta_display_end_grab_op (display, event->xkey.time);
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Focusing default window on target workspace\n");
+
+          meta_workspace_focus_default_window (target_workspace, 
+                                               NULL,
+                                               event->xkey.time);
+
+          return TRUE; /* we already ended the grab */
+        }
+
+      /* Workspace switching should have already occurred on KeyPress */
+      meta_warning ("target_workspace != active_workspace.  Some other event must have occurred.\n");
+      
+      return FALSE; /* end grab */
+    }
+  
+  /* don't care about other releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  /* select the next workspace in the tabpopup */
+  workspace =
+    (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  
+  if (workspace)
+    {
+      MetaWorkspace *target_workspace;
+      MetaKeyBindingAction action;
+
+      action = display_get_keybinding_action (display,
+                                              keysym,
+                                              event->xkey.keycode,
+                                              display->grab_mask);
+
+      switch (action)
+        {
+        case META_KEYBINDING_ACTION_WORKSPACE_UP:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_UP);
+          break;
+
+        case META_KEYBINDING_ACTION_WORKSPACE_DOWN:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_DOWN);
+          break;
+
+        case META_KEYBINDING_ACTION_WORKSPACE_LEFT:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_LEFT);
+          break;
+
+        case META_KEYBINDING_ACTION_WORKSPACE_RIGHT:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_RIGHT);
+          break;
+
+        default:
+          target_workspace = NULL;
+          break;
+        }
+
+      if (target_workspace)
+        {
+          meta_ui_tab_popup_select (screen->tab_popup,
+                                    (MetaTabEntryKey) target_workspace);
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Tab key pressed, moving tab focus in popup\n");
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Activating target workspace\n");
+
+          meta_workspace_activate (target_workspace, event->xkey.time);
+
+          return TRUE; /* we already ended the grab */
+        }
+    }
+
+  /* end grab */
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Ending workspace tabbing & focusing default window; uninteresting key pressed\n");
+  workspace =
+    (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  meta_workspace_focus_default_window (workspace, NULL, event->xkey.time);
+  return FALSE;
+}
+
+static void
+handle_show_desktop (MetaDisplay    *display,
+                       MetaScreen     *screen,
+                       MetaWindow     *window,
+                       XEvent         *event,
+                       MetaKeyBinding *binding)
+{
+  if (screen->active_workspace->showing_desktop)
+    {
+      meta_screen_unshow_desktop (screen);
+      meta_workspace_focus_default_window (screen->active_workspace, 
+                                           NULL,
+                                           event->xkey.time);
+    }
+  else
+    meta_screen_show_desktop (screen, event->xkey.time);
+}
+
+static void
+handle_panel (MetaDisplay    *display,
+                         MetaScreen     *screen,
+                         MetaWindow     *window,
+                         XEvent         *event,
+                         MetaKeyBinding *binding)
+{
+  MetaKeyBindingAction action = binding->handler->data;
+  Atom action_atom;
+  XClientMessageEvent ev;
+
+  action_atom = None;
+  switch (action)
+    {
+    /* FIXME: The numbers are wrong */
+    case META_KEYBINDING_ACTION_PANEL_MAIN_MENU:
+      action_atom = display->atom__MATE_PANEL_ACTION_MAIN_MENU;
+      break;
+    case META_KEYBINDING_ACTION_PANEL_RUN_DIALOG:
+      action_atom = display->atom__MATE_PANEL_ACTION_RUN_DIALOG;
+      break;
+    default:
+      return;
+    }
+   
+  ev.type = ClientMessage;
+  ev.window = screen->xroot;
+  ev.message_type = display->atom__MATE_PANEL_ACTION;
+  ev.format = 32;
+  ev.data.l[0] = action_atom;
+  ev.data.l[1] = event->xkey.time;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Sending panel message with timestamp %lu, and turning mouse_mode "
+              "off due to keybinding press\n", event->xkey.time);
+  display->mouse_mode = FALSE;
+
+  meta_error_trap_push (display);
+
+  /* Release the grab for the panel before sending the event */
+  XUngrabKeyboard (display->xdisplay, event->xkey.time);
+
+  XSendEvent (display->xdisplay,
+	      screen->xroot,
+	      False,
+	      StructureNotifyMask,
+	      (XEvent*) &ev);
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+static void
+handle_activate_window_menu (MetaDisplay    *display,
+                      MetaScreen     *screen,
+                      MetaWindow     *event_window,
+                      XEvent         *event,
+                      MetaKeyBinding *binding)
+{
+  if (display->focus_window)
+    {
+      int x, y;
+
+      meta_window_get_position (display->focus_window,
+                                &x, &y);
+      
+      if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+	  x += display->focus_window->rect.width;
+
+      meta_window_show_menu (display->focus_window,
+                             x, y,
+                             0,
+                             event->xkey.time);
+    }
+}
+
+static MetaGrabOp
+tab_op_from_tab_type (MetaTabList type)
+{
+  switch (type)
+    {
+    case META_TAB_LIST_NORMAL:
+      return META_GRAB_OP_KEYBOARD_TABBING_NORMAL;
+    case META_TAB_LIST_DOCKS:
+      return META_GRAB_OP_KEYBOARD_TABBING_DOCK;
+    case META_TAB_LIST_GROUP:
+      return META_GRAB_OP_KEYBOARD_TABBING_GROUP;
+    }
+
+  g_assert_not_reached ();
+  
+  return 0;
+}
+
+static MetaGrabOp
+cycle_op_from_tab_type (MetaTabList type)
+{
+  switch (type)
+    {
+    case META_TAB_LIST_NORMAL:
+      return META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL;
+    case META_TAB_LIST_DOCKS:
+      return META_GRAB_OP_KEYBOARD_ESCAPING_DOCK;
+    case META_TAB_LIST_GROUP:
+      return META_GRAB_OP_KEYBOARD_ESCAPING_GROUP;
+    }
+
+  g_assert_not_reached ();
+  
+  return 0;
+}
+
+static void
+do_choose_window (MetaDisplay    *display,
+                  MetaScreen     *screen,
+                  MetaWindow     *event_window,
+                  XEvent         *event,
+                  MetaKeyBinding *binding,
+                  gboolean        backward,
+                  gboolean        show_popup)
+{
+  MetaTabList type = binding->handler->data;
+  MetaWindow *initial_selection;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Tab list = %u show_popup = %d\n", type, show_popup);
+  
+  /* reverse direction if shift is down */
+  if (event->xkey.state & ShiftMask)
+    backward = !backward;
+  
+  initial_selection = meta_display_get_tab_next (display,
+                                                 type,
+                                                 screen,
+                                                 screen->active_workspace,
+                                                 NULL,
+                                                 backward);
+
+  /* Note that focus_window may not be in the tab chain, but it's OK */
+  if (initial_selection == NULL)
+    initial_selection = meta_display_get_tab_current (display,
+                                                      type, screen,
+                                                      screen->active_workspace);
+  
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Initially selecting window %s\n",
+              initial_selection ? initial_selection->desc : "(none)");  
+
+  if (initial_selection != NULL)
+    {
+      if (binding->mask == 0)
+        {
+          /* If no modifiers, we can't do the "hold down modifier to keep
+           * moving" thing, so we just instaswitch by one window.
+           */
+          meta_topic (META_DEBUG_FOCUS,
+                      "Activating %s and turning off mouse_mode due to "
+                      "switch/cycle windows with no modifiers\n",
+                      initial_selection->desc);
+          display->mouse_mode = FALSE;
+          meta_window_activate (initial_selection, event->xkey.time);
+        }
+      else if (meta_display_begin_grab_op (display,
+                                           screen,
+                                           NULL,
+                                           show_popup ?
+                                           tab_op_from_tab_type (type) :
+                                           cycle_op_from_tab_type (type),
+                                           FALSE,
+                                           FALSE,
+                                           0,
+                                           binding->mask,
+                                           event->xkey.time,
+                                           0, 0))
+        {
+          if (!primary_modifier_still_pressed (display,
+                                               binding->mask))
+            {
+              /* This handles a race where modifier might be released
+               * before we establish the grab. must end grab
+               * prior to trying to focus a window.
+               */
+              meta_topic (META_DEBUG_FOCUS, 
+                          "Ending grab, activating %s, and turning off "
+                          "mouse_mode due to switch/cycle windows where "
+                          "modifier was released prior to grab\n",
+                          initial_selection->desc);
+              meta_display_end_grab_op (display, event->xkey.time);
+              display->mouse_mode = FALSE;
+              meta_window_activate (initial_selection, event->xkey.time);
+            }
+          else
+            {
+              meta_ui_tab_popup_select (screen->tab_popup,
+                                        (MetaTabEntryKey) initial_selection->xwindow);
+              
+              if (show_popup)
+                meta_ui_tab_popup_set_showing (screen->tab_popup,
+                                               TRUE);
+              else
+                {
+                  meta_window_raise (initial_selection);
+                  initial_selection->tab_unminimized = 
+                    initial_selection->minimized;
+                  meta_window_unminimize (initial_selection);
+                }
+            }
+        }
+    }
+}
+
+static void
+handle_switch (MetaDisplay    *display,
+                    MetaScreen     *screen,
+                    MetaWindow     *event_window,
+                    XEvent         *event,
+                    MetaKeyBinding *binding)
+{
+  gint backwards = binding->handler->flags & BINDING_IS_REVERSED;
+
+  do_choose_window (display, screen, event_window, event, binding,
+                    backwards, TRUE);
+}
+
+static void
+handle_cycle (MetaDisplay    *display,
+                    MetaScreen     *screen,
+                    MetaWindow     *event_window,
+                    XEvent         *event,
+                    MetaKeyBinding *binding)
+{
+  gint backwards = binding->handler->flags & BINDING_IS_REVERSED;
+
+  do_choose_window (display, screen, event_window, event, binding,
+                    backwards, FALSE);
+}
+
+
+static void
+handle_toggle_fullscreen  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->fullscreen)
+    meta_window_unmake_fullscreen (window);
+  else if (window->has_fullscreen_func)
+    meta_window_make_fullscreen (window);
+}
+
+static void
+handle_toggle_above       (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->wm_state_above)
+    meta_window_unmake_above (window);
+  else
+    meta_window_make_above (window);
+}
+
+static void
+handle_toggle_maximized    (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (META_WINDOW_MAXIMIZED (window))
+    meta_window_unmaximize (window,
+                            META_MAXIMIZE_HORIZONTAL |
+                            META_MAXIMIZE_VERTICAL);
+  else if (window->has_maximize_func)
+    meta_window_maximize (window,
+                          META_MAXIMIZE_HORIZONTAL |
+                          META_MAXIMIZE_VERTICAL);
+}
+
+static void
+handle_maximize           (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_maximize_func)
+    meta_window_maximize (window,
+                          META_MAXIMIZE_HORIZONTAL |
+                          META_MAXIMIZE_VERTICAL);
+}
+
+static void
+handle_unmaximize         (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->maximized_vertically || window->maximized_horizontally)
+    meta_window_unmaximize (window,
+                            META_MAXIMIZE_HORIZONTAL |
+                            META_MAXIMIZE_VERTICAL);
+}
+
+static void
+handle_toggle_shaded      (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->shaded)
+    meta_window_unshade (window, event->xkey.time);
+  else if (window->has_shade_func)
+    meta_window_shade (window, event->xkey.time);
+}
+
+static void
+handle_close              (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_close_func)
+    meta_window_delete (window, event->xkey.time);
+}
+
+static void
+handle_minimize        (MetaDisplay    *display,
+                        MetaScreen     *screen,
+                        MetaWindow     *window,
+                        XEvent         *event,
+                        MetaKeyBinding *binding)
+{
+  if (window->has_minimize_func)
+    meta_window_minimize (window);
+}
+
+static void
+handle_begin_move         (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_move_func)
+    {
+      meta_window_begin_grab_op (window,
+                                 META_GRAB_OP_KEYBOARD_MOVING,
+                                 FALSE,
+                                 event->xkey.time);
+    }
+}
+
+static void
+handle_begin_resize       (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_resize_func)
+    {
+      meta_window_begin_grab_op (window,
+                                 META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+                                 FALSE,
+                                 event->xkey.time);
+    }
+}
+
+static void
+handle_toggle_on_all_workspaces (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->on_all_workspaces)
+    meta_window_unstick (window);
+  else
+    meta_window_stick (window);
+}
+
+static void
+handle_move_to_workspace  (MetaDisplay    *display,
+                              MetaScreen     *screen,
+                              MetaWindow     *window,
+                              XEvent         *event,
+                              MetaKeyBinding *binding)
+{
+  gint which = binding->handler->data;
+  gboolean flip = (which < 0);
+  MetaWorkspace *workspace;
+  
+  /* If which is zero or positive, it's a workspace number, and the window
+   * should move to the workspace with that number.
+   *
+   * However, if it's negative, it's a direction with respect to the current
+   * position; it's expressed as a member of the MetaMotionDirection enum,
+   * all of whose members are negative.  Such a change is called a flip.
+   */
+
+  if (window->always_sticky)
+    return;
+  
+  workspace = NULL;
+  if (flip)
+    {      
+      workspace = meta_workspace_get_neighbor (screen->active_workspace,
+                                               which);
+    }
+  else
+    {
+      workspace = meta_screen_get_workspace_by_index (screen, which);
+    }
+  
+  if (workspace)
+    {
+      /* Activate second, so the window is never unmapped */
+      meta_window_change_workspace (window, workspace);
+      if (flip)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Resetting mouse_mode to FALSE due to "
+                      "handle_move_to_workspace() call with flip set.\n");
+          workspace->screen->display->mouse_mode = FALSE;
+          meta_workspace_activate_with_focus (workspace,
+                                              window,
+                                              event->xkey.time);
+        }
+    }
+  else
+    {
+      /* We could offer to create it I suppose */
+    }  
+}
+
+static void 
+handle_raise_or_lower (MetaDisplay    *display,
+                       MetaScreen     *screen,
+		       MetaWindow     *window,
+		       XEvent         *event,
+		       MetaKeyBinding *binding)
+{
+  /* Get window at pointer */
+  
+  MetaWindow *above = NULL;
+      
+  /* Check if top */
+  if (meta_stack_get_top (window->screen->stack) == window)
+    {
+      meta_window_lower (window);
+      return;
+    }
+      
+  /* else check if windows in same layer are intersecting it */
+  
+  above = meta_stack_get_above (window->screen->stack, window, TRUE); 
+
+  while (above)
+    {
+      MetaRectangle tmp, win_rect, above_rect;
+      
+      if (above->mapped)
+        {
+          meta_window_get_outer_rect (window, &win_rect);
+          meta_window_get_outer_rect (above, &above_rect);
+          
+          /* Check if obscured */
+          if (meta_rectangle_intersect (&win_rect, &above_rect, &tmp))
+            {
+              meta_window_raise (window);
+              return;
+            }
+        }
+	  
+      above = meta_stack_get_above (window->screen->stack, above, TRUE); 
+    }
+
+  /* window is not obscured */
+  meta_window_lower (window);
+}
+
+static void
+handle_raise (MetaDisplay    *display,
+              MetaScreen     *screen,
+              MetaWindow     *window,
+              XEvent         *event,
+              MetaKeyBinding *binding)
+{
+  meta_window_raise (window);
+}
+
+static void
+handle_lower (MetaDisplay    *display,
+              MetaScreen     *screen,
+              MetaWindow     *window,
+              XEvent         *event,
+              MetaKeyBinding *binding)
+{
+  meta_window_lower (window);
+}
+
+static void
+handle_workspace_switch  (MetaDisplay    *display,
+                          MetaScreen     *screen,
+                          MetaWindow     *window,
+                          XEvent         *event,
+                          MetaKeyBinding *binding)
+{
+  gint motion = binding->handler->data;
+  unsigned int grab_mask;
+     
+  g_assert (motion < 0); 
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Starting tab between workspaces, showing popup\n");
+
+  /* FIXME should we use binding->mask ? */
+  grab_mask = event->xkey.state & ~(display->ignored_modifier_mask);
+  
+  if (meta_display_begin_grab_op (display,
+                                  screen,
+                                  NULL,
+                                  META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING,
+                                  FALSE,
+                                  FALSE,
+                                  0,
+                                  grab_mask,
+                                  event->xkey.time,
+                                  0, 0))
+    {
+      MetaWorkspace *next;
+      gboolean grabbed_before_release;
+      
+      next = meta_workspace_get_neighbor (screen->active_workspace, motion);
+      g_assert (next); 
+
+      grabbed_before_release = primary_modifier_still_pressed (display, grab_mask);
+      
+      meta_topic (META_DEBUG_KEYBINDINGS,
+		  "Activating target workspace\n");
+
+      if (!grabbed_before_release)
+        {
+          /* end the grab right away, modifier possibly released
+           * before we could establish the grab and receive the
+           * release event. Must end grab before we can switch
+           * spaces.
+           */
+          meta_display_end_grab_op (display, event->xkey.time);
+        }
+      
+      meta_workspace_activate (next, event->xkey.time);
+
+      if (grabbed_before_release)
+        {
+          meta_ui_tab_popup_select (screen->tab_popup, (MetaTabEntryKey) next);
+          
+          /* only after selecting proper space */
+          meta_ui_tab_popup_set_showing (screen->tab_popup, TRUE);
+        }
+    }
+}
+
+static void
+handle_set_spew_mark (MetaDisplay    *display,
+                  MetaScreen     *screen,
+                  MetaWindow     *window,
+                  XEvent         *event,
+                  MetaKeyBinding *binding)
+{
+  meta_verbose ("-- MARK MARK MARK MARK --\n");
+}
+
+void
+meta_set_keybindings_disabled (gboolean setting)
+{
+  all_bindings_disabled = setting;
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Keybindings %s\n", all_bindings_disabled ? "disabled" : "enabled");
+}
+
+static void
+handle_run_terminal (MetaDisplay    *display,
+                     MetaScreen     *screen,
+                     MetaWindow     *window,
+                     XEvent         *event,
+                     MetaKeyBinding *binding)
+{
+  const char *command;
+  GError *err;
+  
+  command = meta_prefs_get_terminal_command ();
+
+  if (command == NULL)
+    {
+      char *s;
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "No terminal command to run in response to "
+		  "keybinding press\n");
+      
+      s = g_strdup_printf (_("No terminal command has been defined.\n"));
+      error_on_command (-1, NULL, s, screen->number, event->xkey.time);
+      g_free (s);
+      
+      return;
+    }
+
+  err = NULL;
+  if (!meta_spawn_command_line_async_on_screen (command, screen, &err))
+    {
+      error_on_command (-1, command, err->message, screen->number,
+                        event->xkey.time);
+      
+      g_error_free (err);
+    }
+}
diff --git a/src/core/keybindings.h b/src/core/keybindings.h
new file mode 100644
index 00000000..618520b4
--- /dev/null
+++ b/src/core/keybindings.h
@@ -0,0 +1,60 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file keybindings.h  Grab and ungrab keys, and process the key events
+ *
+ * Performs global X grabs on the keys we need to be told about, like
+ * the one to close a window.  It also deals with incoming key events.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_KEYBINDINGS_H
+#define META_KEYBINDINGS_H
+
+#include "display-private.h"
+#include "window.h"
+
+void     meta_display_init_keys             (MetaDisplay *display);
+void     meta_display_shutdown_keys         (MetaDisplay *display);
+void     meta_screen_grab_keys              (MetaScreen  *screen);
+void     meta_screen_ungrab_keys            (MetaScreen  *screen);
+gboolean meta_screen_grab_all_keys          (MetaScreen  *screen,
+                                             guint32      timestamp);
+void     meta_screen_ungrab_all_keys        (MetaScreen  *screen, 
+                                             guint32      timestamp);
+void     meta_window_grab_keys              (MetaWindow  *window);
+void     meta_window_ungrab_keys            (MetaWindow  *window);
+gboolean meta_window_grab_all_keys          (MetaWindow  *window,
+                                             guint32      timestamp);
+void     meta_window_ungrab_all_keys        (MetaWindow  *window,
+                                             guint32      timestamp);
+void     meta_display_process_key_event     (MetaDisplay *display,
+                                             MetaWindow  *window,
+                                             XEvent      *event);
+void     meta_set_keybindings_disabled      (gboolean     setting);
+void     meta_display_process_mapping_event (MetaDisplay *display,
+                                             XEvent      *event);
+
+#endif
+
+
+
+
diff --git a/src/core/main.c b/src/core/main.c
new file mode 100644
index 00000000..38c69b0a
--- /dev/null
+++ b/src/core/main.c
@@ -0,0 +1,673 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco main() */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file 
+ * Program startup.
+ * Functions which parse the command-line arguments, create the display,
+ * kick everything off and then close down Marco when it's time to go.
+ */
+
+/**
+ * \mainpage
+ * Marco - a boring window manager for the adult in you
+ *
+ * Many window managers are like Marshmallow Froot Loops; Marco
+ * is like Cheerios.
+ *
+ * The best way to get a handle on how the whole system fits together
+ * is discussed in doc/code-overview.txt; if you're looking for functions
+ * to investigate, read main(), meta_display_open(), and event_callback().
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for putenv() and some signal-related functions */
+
+#include <config.h>
+#include "main.h"
+#include "util.h"
+#include "display-private.h"
+#include "errors.h"
+#include "ui.h"
+#include "session.h"
+#include "prefs.h"
+
+#include <glib-object.h>
+#include <glib/gprintf.h>
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <wait.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <locale.h>
+#include <time.h>
+#include <unistd.h>
+
+/**
+ * The exit code we'll return to our parent process when we eventually die.
+ */
+static MetaExitCode meta_exit_code = META_EXIT_SUCCESS;
+
+/**
+ * Handle on the main loop, so that we have an easy way of shutting Marco
+ * down.
+ */
+static GMainLoop *meta_main_loop = NULL;
+
+/**
+ * If set, Marco will spawn an identical copy of itself immediately
+ * before quitting.
+ */
+static gboolean meta_restart_after_quit = FALSE;
+
+static void prefs_changed_callback (MetaPreference pref,
+                                    gpointer       data);
+
+/**
+ * Prints log messages. If Marco was compiled with backtrace support,
+ * also prints a backtrace (see meta_print_backtrace()).
+ *
+ * \param log_domain  the domain the error occurred in (we ignore this)
+ * \param log_level   the log level so that we can filter out less
+ *                    important messages
+ * \param message     the message to log
+ * \param user_data   arbitrary data (we ignore this)
+ */
+static void
+log_handler (const gchar   *log_domain,
+             GLogLevelFlags log_level,
+             const gchar   *message,
+             gpointer       user_data)
+{
+  meta_warning ("Log level %d: %s\n", log_level, message);
+  meta_print_backtrace ();
+}
+
+/**
+ * Prints the version notice. This is shown when Marco is called
+ * with the --version switch.
+ */
+static void
+version (void)
+{
+  const int latest_year = 2009;
+  char yearbuffer[256];
+  GDate date;
+
+  /* this is all so the string to translate stays constant.
+   * see how much we love the translators.
+   */
+  g_date_set_dmy (&date, 1, G_DATE_JANUARY, latest_year);
+  if (g_date_strftime (yearbuffer, sizeof (yearbuffer), "%Y", &date)==0)
+    /* didn't work?  fall back to decimal representation */
+    g_sprintf (yearbuffer, "%d", latest_year);
+
+  g_print (_("marco %s\n"
+             "Copyright (C) 2001-%s Havoc Pennington, Red Hat, Inc., and others\n"
+             "This is free software; see the source for copying conditions.\n"
+             "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"),
+           VERSION, yearbuffer);
+  exit (0);
+}
+
+/**
+ * Prints a list of which configure script options were used to
+ * build this copy of Marco. This is actually always called
+ * on startup, but it's all no-op unless we're in verbose mode
+ * (see meta_set_verbose).
+ */
+static void
+meta_print_compilation_info (void)
+{
+#ifdef HAVE_SHAPE
+  meta_verbose ("Compiled with shape extension\n");
+#else
+  meta_verbose ("Compiled without shape extension\n");
+#endif
+#ifdef HAVE_XINERAMA
+  meta_topic (META_DEBUG_XINERAMA, "Compiled with Xinerama extension\n");
+#else
+  meta_topic (META_DEBUG_XINERAMA, "Compiled without Xinerama extension\n");
+#endif
+#ifdef HAVE_XFREE_XINERAMA
+  meta_topic (META_DEBUG_XINERAMA, " (using XFree86 Xinerama)\n");
+#else
+  meta_topic (META_DEBUG_XINERAMA, " (not using XFree86 Xinerama)\n");
+#endif
+#ifdef HAVE_SOLARIS_XINERAMA
+  meta_topic (META_DEBUG_XINERAMA, " (using Solaris Xinerama)\n");
+#else
+  meta_topic (META_DEBUG_XINERAMA, " (not using Solaris Xinerama)\n");
+#endif
+#ifdef HAVE_XSYNC
+  meta_verbose ("Compiled with sync extension\n");
+#else
+  meta_verbose ("Compiled without sync extension\n");
+#endif
+#ifdef HAVE_RANDR
+  meta_verbose ("Compiled with randr extension\n");
+#else
+  meta_verbose ("Compiled without randr extension\n");
+#endif
+#ifdef HAVE_STARTUP_NOTIFICATION
+  meta_verbose ("Compiled with startup notification\n");
+#else
+  meta_verbose ("Compiled without startup notification\n");
+#endif
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  meta_verbose ("Compiled with composite extensions\n");
+#else
+  meta_verbose ("Compiled without composite extensions\n");
+#endif
+}
+
+/**
+ * Prints the version number, the current timestamp (not the
+ * build date), the locale, the character encoding, and a list
+ * of configure script options that were used to build this
+ * copy of Marco. This is actually always called
+ * on startup, but it's all no-op unless we're in verbose mode
+ * (see meta_set_verbose).
+ */
+static void
+meta_print_self_identity (void)
+{
+  char buf[256];
+  GDate d;
+  const char *charset;
+
+  /* Version and current date. */
+  g_date_clear (&d, 1);
+  g_date_set_time_t (&d, time (NULL));
+  g_date_strftime (buf, sizeof (buf), "%x", &d);
+  meta_verbose ("Marco version %s running on %s\n",
+    VERSION, buf);
+  
+  /* Locale and encoding. */
+  g_get_charset (&charset);
+  meta_verbose ("Running in locale \"%s\" with encoding \"%s\"\n",
+    setlocale (LC_ALL, NULL), charset);
+
+  /* Compilation settings. */
+  meta_print_compilation_info ();
+}
+
+/**
+ * The set of possible options that can be set on Marco's
+ * command line. This type exists so that meta_parse_options() can
+ * write to an instance of it.
+ */
+typedef struct
+{
+  gchar *save_file;
+  gchar *display_name;
+  gchar *client_id;
+  gboolean replace_wm;
+  gboolean disable_sm;
+  gboolean print_version;
+  gboolean sync;
+  gboolean composite;
+  gboolean no_composite;
+  gboolean no_force_fullscreen;
+} MetaArguments;
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#define COMPOSITE_OPTS_FLAGS 0
+#else /* HAVE_COMPOSITE_EXTENSIONS */
+/* No compositor, so don't show the arguments in --help */
+#define COMPOSITE_OPTS_FLAGS G_OPTION_FLAG_HIDDEN
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
+
+/**
+ * Parses argc and argv and returns the
+ * arguments that Marco understands in meta_args.
+ *
+ * The strange call signature has to be written like it is so
+ * that g_option_context_parse() gets a chance to modify argc and
+ * argv.
+ *
+ * \param argc  Pointer to the number of arguments Marco was given
+ * \param argv  Pointer to the array of arguments Marco was given
+ * \param meta_args  The result of parsing the arguments.
+ **/
+static void
+meta_parse_options (int *argc, char ***argv,
+                    MetaArguments *meta_args)
+{
+  MetaArguments my_args = {NULL, NULL, NULL,
+                           FALSE, FALSE, FALSE, FALSE, FALSE};
+  GOptionEntry options[] = {
+    {
+      "sm-disable", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.disable_sm,
+      N_("Disable connection to session manager"),
+      NULL
+    },
+    {
+      "replace", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.replace_wm,
+      N_("Replace the running window manager with Marco"),
+      NULL
+    },
+    {
+      "sm-client-id", 0, 0, G_OPTION_ARG_STRING,
+      &my_args.client_id,
+      N_("Specify session management ID"),
+      "ID"
+    },
+    {
+      "display", 'd', 0, G_OPTION_ARG_STRING,
+      &my_args.display_name, N_("X Display to use"),
+      "DISPLAY"
+    },
+    {
+      "sm-save-file", 0, 0, G_OPTION_ARG_FILENAME,
+      &my_args.save_file,
+      N_("Initialize session from savefile"),
+      "FILE"
+    },
+    {
+      "version", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.print_version,
+      N_("Print version"),
+      NULL
+    },
+    {
+      "sync", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.sync,
+      N_("Make X calls synchronous"),
+      NULL
+    },
+    {
+      "composite", 'c', COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.composite,
+      N_("Turn compositing on"),
+      NULL
+    },
+    {
+      "no-composite", 0, COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.no_composite,
+      N_("Turn compositing off"),
+      NULL
+    },
+    {
+      "no-force-fullscreen", 0, COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.no_force_fullscreen,
+      N_("Don't make fullscreen windows that are maximized and have no decorations"),
+      NULL
+    },
+    {NULL}
+  };
+  GOptionContext *ctx;
+  GError *error = NULL;
+
+  ctx = g_option_context_new (NULL);
+  g_option_context_add_main_entries (ctx, options, "marco");
+  if (!g_option_context_parse (ctx, argc, argv, &error))
+    {
+      g_print ("marco: %s\n", error->message);
+      exit(1);
+    }
+  g_option_context_free (ctx);
+  /* Return the parsed options through the meta_args param. */
+  *meta_args = my_args;
+}
+
+/**
+ * Selects which display Marco should use. It first tries to use
+ * display_name as the display. If display_name is NULL then
+ * try to use the environment variable MARCO_DISPLAY. If that
+ * also is NULL, use the default - :0.0
+ */
+static void
+meta_select_display (gchar *display_name)
+{
+  gchar *envVar = "";
+  if (display_name)
+    envVar = g_strconcat ("DISPLAY=", display_name, NULL);
+  else if (g_getenv ("MARCO_DISPLAY"))
+    envVar = g_strconcat ("DISPLAY=",
+      g_getenv ("MARCO_DISPLAY"), NULL);
+  /* DO NOT FREE envVar, putenv() sucks */
+  putenv (envVar);
+}
+
+static void
+meta_finalize (void)
+{
+  MetaDisplay *display = meta_get_display();
+
+  meta_session_shutdown ();
+
+  if (display)
+    meta_display_close (display,
+                        CurrentTime); /* I doubt correct timestamps matter here */
+}
+
+static int sigterm_pipe_fds[2] = { -1, -1 };
+
+static void
+sigterm_handler (int signum)
+{
+  if (sigterm_pipe_fds[1] >= 0)
+    {
+      int dummy;
+
+      dummy = write (sigterm_pipe_fds[1], "", 1);
+      close (sigterm_pipe_fds[1]);
+      sigterm_pipe_fds[1] = -1;
+    }
+}
+
+static gboolean
+on_sigterm (void)
+{
+  meta_quit (META_EXIT_SUCCESS);
+  return FALSE;
+}
+
+/**
+ * This is where the story begins. It parses commandline options and
+ * environment variables, sets up the screen, hands control off to
+ * GTK, and cleans up afterwards.
+ *
+ * \param argc Number of arguments (as usual)
+ * \param argv Array of arguments (as usual)
+ *
+ * \bug It's a bit long. It would be good to split it out into separate
+ * functions.
+ */
+int
+main (int argc, char **argv)
+{
+  struct sigaction act;
+  sigset_t empty_mask;
+  MetaArguments meta_args;
+  const gchar *log_domains[] = {
+    NULL, G_LOG_DOMAIN, "Gtk", "Gdk", "GLib",
+    "Pango", "GLib-GObject", "GThread"
+  };
+  guint i;
+  GIOChannel *channel;
+
+  if (!g_thread_supported ())
+    g_thread_init (NULL);
+  
+  if (setlocale (LC_ALL, "") == NULL)
+    meta_warning ("Locale not understood by C library, internationalization will not work\n");
+
+  g_type_init ();
+  
+  sigemptyset (&empty_mask);
+  act.sa_handler = SIG_IGN;
+  act.sa_mask    = empty_mask;
+  act.sa_flags   = 0;
+  if (sigaction (SIGPIPE,  &act, NULL) < 0)
+    g_printerr ("Failed to register SIGPIPE handler: %s\n",
+                g_strerror (errno));
+#ifdef SIGXFSZ
+  if (sigaction (SIGXFSZ,  &act, NULL) < 0)
+    g_printerr ("Failed to register SIGXFSZ handler: %s\n",
+                g_strerror (errno));
+#endif
+
+  if (pipe (sigterm_pipe_fds) != 0)
+    g_printerr ("Failed to create SIGTERM pipe: %s\n",
+                g_strerror (errno));
+
+  channel = g_io_channel_unix_new (sigterm_pipe_fds[0]);
+  g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
+  g_io_add_watch (channel, G_IO_IN, (GIOFunc) on_sigterm, NULL);
+  g_io_channel_set_close_on_unref (channel, TRUE);
+  g_io_channel_unref (channel);
+
+  act.sa_handler = &sigterm_handler;
+  if (sigaction (SIGTERM, &act, NULL) < 0)
+    g_printerr ("Failed to register SIGTERM handler: %s\n",
+		g_strerror (errno));
+
+  if (g_getenv ("MARCO_VERBOSE"))
+    meta_set_verbose (TRUE);
+  if (g_getenv ("MARCO_DEBUG"))
+    meta_set_debugging (TRUE);
+
+  if (g_get_home_dir ())
+    if (chdir (g_get_home_dir ()) < 0)
+      meta_warning ("Could not change to home directory %s.\n",
+                    g_get_home_dir ());
+
+  meta_print_self_identity ();
+  
+  bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  textdomain (GETTEXT_PACKAGE);
+
+  /* Parse command line arguments.*/
+  meta_parse_options (&argc, &argv, &meta_args);
+
+  meta_set_syncing (meta_args.sync || (g_getenv ("MARCO_SYNC") != NULL));
+
+  if (meta_args.print_version)
+    version ();
+
+  meta_select_display (meta_args.display_name);
+  
+  if (meta_args.replace_wm)
+    meta_set_replace_current_wm (TRUE);
+
+  if (meta_args.save_file && meta_args.client_id)
+    meta_fatal ("Can't specify both SM save file and SM client id\n");
+  
+  meta_main_loop = g_main_loop_new (NULL, FALSE);
+  
+  meta_ui_init (&argc, &argv);  
+
+  /* must be after UI init so we can override GDK handlers */
+  meta_errors_init ();
+
+  /* Load prefs */
+  meta_prefs_init ();
+  meta_prefs_add_listener (prefs_changed_callback, NULL);
+
+
+#if 1
+
+  for (i=0; i<G_N_ELEMENTS(log_domains); i++)
+    g_log_set_handler (log_domains[i],
+                       G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
+                       log_handler, NULL);
+
+#endif
+
+  if (g_getenv ("MARCO_G_FATAL_WARNINGS") != NULL)
+    g_log_set_always_fatal (G_LOG_LEVEL_MASK);
+  
+  meta_ui_set_current_theme (meta_prefs_get_theme (), FALSE);
+
+  /* Try to find some theme that'll work if the theme preference
+   * doesn't exist.  First try Simple (the default theme) then just
+   * try anything in the themes directory.
+   */
+  if (!meta_ui_have_a_theme ())
+    meta_ui_set_current_theme ("Simple", FALSE);
+  
+  if (!meta_ui_have_a_theme ())
+    {
+      const char *dir_entry = NULL;
+      GError *err = NULL;
+      GDir   *themes_dir = NULL;
+      
+      if (!(themes_dir = g_dir_open (MARCO_DATADIR"/themes", 0, &err)))
+        {
+          meta_fatal (_("Failed to scan themes directory: %s\n"), err->message);
+          g_error_free (err);
+        } 
+      else 
+        {
+          while (((dir_entry = g_dir_read_name (themes_dir)) != NULL) && 
+                 (!meta_ui_have_a_theme ()))
+            {
+              meta_ui_set_current_theme (dir_entry, FALSE);
+            }
+          
+          g_dir_close (themes_dir);
+        }
+    }
+  
+  if (!meta_ui_have_a_theme ())
+    meta_fatal (_("Could not find a theme! Be sure %s exists and contains the usual themes.\n"),
+                MARCO_DATADIR"/themes");
+  
+  /* Connect to SM as late as possible - but before managing display,
+   * or we might try to manage a window before we have the session
+   * info
+   */
+  if (!meta_args.disable_sm)
+    {
+      if (meta_args.client_id == NULL)
+        {
+          const gchar *desktop_autostart_id;
+  
+          desktop_autostart_id = g_getenv ("DESKTOP_AUTOSTART_ID");
+ 
+          if (desktop_autostart_id != NULL)
+            meta_args.client_id = g_strdup (desktop_autostart_id);
+        }
+
+      /* Unset DESKTOP_AUTOSTART_ID in order to avoid child processes to
+       * use the same client id. */
+      g_unsetenv ("DESKTOP_AUTOSTART_ID");
+
+      meta_session_init (meta_args.client_id, meta_args.save_file);
+    }
+  /* Free memory possibly allocated by the argument parsing which are
+   * no longer needed.
+   */
+  g_free (meta_args.save_file);
+  g_free (meta_args.display_name);
+  g_free (meta_args.client_id);
+
+  if (meta_args.composite || meta_args.no_composite)
+    meta_prefs_set_compositing_manager (meta_args.composite);
+
+  if (meta_args.no_force_fullscreen)
+    meta_prefs_set_force_fullscreen (FALSE);
+
+  if (!meta_display_open ())
+    meta_exit (META_EXIT_ERROR);
+  
+  g_main_loop_run (meta_main_loop);
+
+  meta_finalize ();
+
+  if (meta_restart_after_quit)
+    {
+      GError *err;
+
+      err = NULL;
+      if (!g_spawn_async (NULL,
+                          argv,
+                          NULL,
+                          G_SPAWN_SEARCH_PATH,
+                          NULL,
+                          NULL,
+                          NULL,
+                          &err))
+        {
+          meta_fatal (_("Failed to restart: %s\n"),
+                      err->message);
+          g_error_free (err); /* not reached anyhow */
+          meta_exit_code = META_EXIT_ERROR;
+        }
+    }
+  
+  return meta_exit_code;
+}
+
+/**
+ * Stops Marco. This tells the event loop to stop processing; it is rather
+ * dangerous to use this rather than meta_restart() because this will leave
+ * the user with no window manager. We generally do this only if, for example,
+ * the session manager asks us to; we assume the session manager knows what
+ * it's talking about.
+ *
+ * \param code The success or failure code to return to the calling process.
+ */
+void
+meta_quit (MetaExitCode code)
+{
+  meta_exit_code = code;
+
+  if (g_main_loop_is_running (meta_main_loop))
+    g_main_loop_quit (meta_main_loop);
+}
+
+/**
+ * Restarts Marco. In practice, this tells the event loop to stop
+ * processing, having first set the meta_restart_after_quit flag which
+ * tells Marco to spawn an identical copy of itself before quitting.
+ * This happens on receipt of a _MARCO_RESTART_MESSAGE client event.
+ */
+void
+meta_restart (void)
+{
+  meta_restart_after_quit = TRUE;
+  meta_quit (META_EXIT_SUCCESS);
+}
+
+/**
+ * Called on pref changes. (One of several functions of its kind and purpose.)
+ *
+ * \bug Why are these particular prefs handled in main.c and not others?
+ * Should they be?
+ *
+ * \param pref  Which preference has changed
+ * \param data  Arbitrary data (which we ignore)
+ */
+static void
+prefs_changed_callback (MetaPreference pref,
+                        gpointer       data)
+{
+  switch (pref)
+    {
+    case META_PREF_THEME:
+      meta_ui_set_current_theme (meta_prefs_get_theme (), FALSE);
+      meta_display_retheme_all ();
+      break;
+
+    case META_PREF_CURSOR_THEME:
+    case META_PREF_CURSOR_SIZE:
+      meta_display_set_cursor_theme (meta_prefs_get_cursor_theme (),
+				     meta_prefs_get_cursor_size ());
+      break;
+    default:
+      /* handled elsewhere or otherwise */
+      break;
+    }
+}
diff --git a/src/core/marco-Xatomtype.h b/src/core/marco-Xatomtype.h
new file mode 100644
index 00000000..5698ed31
--- /dev/null
+++ b/src/core/marco-Xatomtype.h
@@ -0,0 +1,136 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file marco-Xatomtype.h  Types for communicating with X about properties
+ *
+ * This files defines crock C structures for calling XGetWindowProperty and
+ * XChangeProperty.  All fields must be longs as the semantics of property
+ * routines will handle conversion to and from actual 32 bit objects.  If your
+ * compiler doesn't treat &structoflongs the same as &arrayoflongs[0], you
+ * will have some work to do.
+ */
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef _XATOMTYPE_H_
+#define _XATOMTYPE_H_
+
+#define BOOL long
+#define SIGNEDINT long
+#define UNSIGNEDINT unsigned long
+#define RESOURCEID unsigned long
+
+
+/* this structure may be extended, but do not change the order */
+typedef struct {
+    UNSIGNEDINT flags;
+    SIGNEDINT x, y, width, height;	/* need to cvt; only for pre-ICCCM */
+    SIGNEDINT minWidth, minHeight;	/* need to cvt */
+    SIGNEDINT maxWidth, maxHeight;	/* need to cvt */
+    SIGNEDINT widthInc, heightInc;	/* need to cvt */
+    SIGNEDINT minAspectX, minAspectY;	/* need to cvt */
+    SIGNEDINT maxAspectX, maxAspectY;	/* need to cvt */
+    SIGNEDINT baseWidth,baseHeight;	/* need to cvt; ICCCM version 1 */
+    SIGNEDINT winGravity;		/* need to cvt; ICCCM version 1 */
+} xPropSizeHints;
+#define OldNumPropSizeElements 15	/* pre-ICCCM */
+#define NumPropSizeElements 18		/* ICCCM version 1 */
+
+/* this structure may be extended, but do not change the order */
+/* RGB properties */
+typedef struct {
+	RESOURCEID colormap;
+	UNSIGNEDINT red_max;
+	UNSIGNEDINT red_mult;
+	UNSIGNEDINT green_max;
+	UNSIGNEDINT green_mult;
+	UNSIGNEDINT blue_max;
+	UNSIGNEDINT blue_mult;
+	UNSIGNEDINT base_pixel;
+	RESOURCEID visualid;		/* ICCCM version 1 */
+	RESOURCEID killid;		/* ICCCM version 1 */
+} xPropStandardColormap;
+#define OldNumPropStandardColormapElements 8  /* pre-ICCCM */
+#define NumPropStandardColormapElements 10  /* ICCCM version 1 */
+
+
+/* this structure may be extended, but do not change the order */
+typedef struct {
+    UNSIGNEDINT flags;
+    BOOL input;				/* need to convert */
+    SIGNEDINT initialState;		/* need to cvt */
+    RESOURCEID iconPixmap;
+    RESOURCEID iconWindow;
+    SIGNEDINT  iconX;			/* need to cvt */
+    SIGNEDINT  iconY;			/* need to cvt */
+    RESOURCEID iconMask;
+    UNSIGNEDINT windowGroup;
+  } xPropWMHints;
+#define NumPropWMHintsElements 9 /* number of elements in this structure */
+
+/* this structure defines the icon size hints information */
+typedef struct {
+    SIGNEDINT minWidth, minHeight;	/* need to cvt */
+    SIGNEDINT maxWidth, maxHeight;	/* need to cvt */
+    SIGNEDINT widthInc, heightInc;	/* need to cvt */
+  } xPropIconSize;
+#define NumPropIconSizeElements 6 /* number of elements in this structure */
+
+/* this structure defines the window manager state information */
+typedef struct {
+    SIGNEDINT state;			/* need to cvt */
+    RESOURCEID iconWindow;
+} xPropWMState;
+#define NumPropWMStateElements 2	/* number of elements in struct */
+
+#undef BOOL
+#undef SIGNEDINT
+#undef UNSIGNEDINT
+#undef RESOURCEID
+
+#endif /* _XATOMTYPE_H_ */
diff --git a/src/core/place.c b/src/core/place.c
new file mode 100644
index 00000000..cb1458f0
--- /dev/null
+++ b/src/core/place.c
@@ -0,0 +1,932 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window placement */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "place.h"
+#include "workspace.h"
+#include "prefs.h"
+#include <gdk/gdk.h>
+#include <math.h>
+#include <stdlib.h>
+
+typedef enum
+{
+  META_LEFT,
+  META_RIGHT,
+  META_TOP,
+  META_BOTTOM
+} MetaWindowDirection;
+
+static gint
+northwestcmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+  int from_origin_a;
+  int from_origin_b;
+  int ax, ay, bx, by;
+
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    {
+      ax = aw->frame->rect.x;
+      ay = aw->frame->rect.y;
+    }
+  else
+    {
+      ax = aw->rect.x;
+      ay = aw->rect.y;
+    }
+
+  if (bw->frame)
+    {
+      bx = bw->frame->rect.x;
+      by = bw->frame->rect.y;
+    }
+  else
+    {
+      bx = bw->rect.x;
+      by = bw->rect.y;
+    }
+  
+  /* probably there's a fast good-enough-guess we could use here. */
+  from_origin_a = sqrt (ax * ax + ay * ay);
+  from_origin_b = sqrt (bx * bx + by * by);
+    
+  if (from_origin_a < from_origin_b)
+    return -1;
+  else if (from_origin_a > from_origin_b)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+find_next_cascade (MetaWindow *window,
+                   MetaFrameGeometry *fgeom,
+                   /* visible windows on relevant workspaces */
+                   GList      *windows,
+                   int         x,
+                   int         y,
+                   int        *new_x,
+                   int        *new_y)
+{
+  GList *tmp;
+  GList *sorted;
+  int cascade_x, cascade_y;
+  int x_threshold, y_threshold;
+  int window_width, window_height;
+  int cascade_stage;
+  MetaRectangle work_area;
+  const MetaXineramaScreenInfo* current;
+  
+  sorted = g_list_copy (windows);
+  sorted = g_list_sort (sorted, northwestcmp);
+
+  /* This is a "fuzzy" cascade algorithm. 
+   * For each window in the list, we find where we'd cascade a
+   * new window after it. If a window is already nearly at that
+   * position, we move on.
+   */
+  
+  /* arbitrary-ish threshold, honors user attempts to
+   * manually cascade.
+   */
+#define CASCADE_FUZZ 15
+  if (fgeom)
+    {
+      x_threshold = MAX (fgeom->left_width, CASCADE_FUZZ);
+      y_threshold = MAX (fgeom->top_height, CASCADE_FUZZ);
+    }
+  else
+    {
+      x_threshold = CASCADE_FUZZ;
+      y_threshold = CASCADE_FUZZ;
+    }
+  
+  /* Find furthest-SE origin of all workspaces.
+   * cascade_x, cascade_y are the target position
+   * of NW corner of window frame.
+   */
+
+  current = meta_screen_get_current_xinerama (window->screen);
+  meta_window_get_work_area_for_xinerama (window, current->number, &work_area);
+
+  cascade_x = MAX (0, work_area.x);
+  cascade_y = MAX (0, work_area.y);
+  
+  /* Find first cascade position that's not used. */
+  
+  window_width = window->frame ? window->frame->rect.width : window->rect.width;
+  window_height = window->frame ? window->frame->rect.height : window->rect.height;
+  
+  cascade_stage = 0;
+  tmp = sorted;
+  while (tmp != NULL)
+    {
+      MetaWindow *w;
+      int wx, wy;
+      
+      w = tmp->data;
+
+      /* we want frame position, not window position */
+      if (w->frame)
+        {
+          wx = w->frame->rect.x;
+          wy = w->frame->rect.y;
+        }
+      else
+        {
+          wx = w->rect.x;
+          wy = w->rect.y;
+        }
+      
+      if (ABS (wx - cascade_x) < x_threshold &&
+          ABS (wy - cascade_y) < y_threshold)
+        {
+          /* This window is "in the way", move to next cascade
+           * point. The new window frame should go at the origin
+           * of the client window we're stacking above.
+           */
+          meta_window_get_position (w, &wx, &wy);
+          cascade_x = wx;
+          cascade_y = wy;
+          
+          /* If we go off the screen, start over with a new cascade */
+	  if (((cascade_x + window_width) >
+               (work_area.x + work_area.width)) ||
+              ((cascade_y + window_height) >
+	       (work_area.y + work_area.height)))
+	    {
+	      cascade_x = MAX (0, work_area.x);
+	      cascade_y = MAX (0, work_area.y);
+              
+#define CASCADE_INTERVAL 50 /* space between top-left corners of cascades */
+              cascade_stage += 1;
+	      cascade_x += CASCADE_INTERVAL * cascade_stage;
+              
+	      /* start over with a new cascade translated to the right, unless
+               * we are out of space
+               */
+              if ((cascade_x + window_width) <
+                  (work_area.x + work_area.width))
+                {
+                  tmp = sorted;
+                  continue;
+                }
+              else
+                {
+                  /* All out of space, this cascade_x won't work */
+                  cascade_x = MAX (0, work_area.x);
+                  break;
+                }
+	    }
+        }
+      else
+        {
+          /* Keep searching for a further-down-the-diagonal window. */
+        }
+        
+      tmp = tmp->next;
+    }
+
+  /* cascade_x and cascade_y will match the last window in the list
+   * that was "in the way" (in the approximate cascade diagonal)
+   */
+  
+  g_list_free (sorted);
+
+  /* Convert coords to position of window, not position of frame. */
+  if (fgeom == NULL)
+    {
+      *new_x = cascade_x;
+      *new_y = cascade_y;
+    }
+  else
+    {
+      *new_x = cascade_x + fgeom->left_width;
+      *new_y = cascade_y + fgeom->top_height;
+    }
+}
+
+static void
+find_most_freespace (MetaWindow *window,
+                     MetaFrameGeometry *fgeom,
+                     /* visible windows on relevant workspaces */
+                     MetaWindow *focus_window,
+                     int         x,
+                     int         y,
+                     int        *new_x,
+                     int        *new_y)
+{
+  MetaWindowDirection side;
+  int max_area;
+  int max_width, max_height, left, right, top, bottom;
+  int left_space, right_space, top_space, bottom_space;
+  int frame_size_left, frame_size_top;
+  MetaRectangle work_area;
+  MetaRectangle avoid;
+  MetaRectangle outer;
+
+  frame_size_left = fgeom ? fgeom->left_width : 0;
+  frame_size_top  = fgeom ? fgeom->top_height : 0;
+
+  meta_window_get_work_area_current_xinerama (focus_window, &work_area);
+  meta_window_get_outer_rect (focus_window, &avoid);
+  meta_window_get_outer_rect (window, &outer);
+
+  /* Find the areas of choosing the various sides of the focus window */
+  max_width  = MIN (avoid.width, outer.width);
+  max_height = MIN (avoid.height, outer.height);
+  left_space   = avoid.x - work_area.x;
+  right_space  = work_area.width - (avoid.x + avoid.width - work_area.x);
+  top_space    = avoid.y - work_area.y;
+  bottom_space = work_area.height - (avoid.y + avoid.height - work_area.y);
+  left   = MIN (left_space,   outer.width);
+  right  = MIN (right_space,  outer.width);
+  top    = MIN (top_space,    outer.height);
+  bottom = MIN (bottom_space, outer.height);
+
+  /* Find out which side of the focus_window can show the most of the window */
+  side = META_LEFT;
+  max_area = left*max_height;
+  if (right*max_height > max_area)
+    {
+      side = META_RIGHT;
+      max_area = right*max_height;
+    }
+  if (top*max_width > max_area)
+    {
+      side = META_TOP;
+      max_area = top*max_width;
+    }
+  if (bottom*max_width > max_area)
+    {
+      side = META_BOTTOM;
+      max_area = bottom*max_width;
+    }
+
+  /* Give up if there's no where to put it (i.e. focus window is maximized) */
+  if (max_area == 0)
+    return;
+
+  /* Place the window on the relevant side; if the whole window fits,
+   * make it adjacent to the focus window; if not, make sure the
+   * window doesn't go off the edge of the screen.
+   */
+  switch (side)
+    {
+    case META_LEFT:
+      *new_y = avoid.y + frame_size_top;
+      if (left_space > outer.width)
+        *new_x = avoid.x - outer.width + frame_size_left;
+      else
+        *new_x = work_area.x + frame_size_left;
+      break;
+    case META_RIGHT:
+      *new_y = avoid.y + frame_size_top;
+      if (right_space > outer.width)
+        *new_x = avoid.x + avoid.width + frame_size_left;
+      else
+        *new_x = work_area.x + work_area.width - outer.width + frame_size_left;
+      break;
+    case META_TOP:
+      *new_x = avoid.x + frame_size_left;
+      if (top_space > outer.height)
+        *new_y = avoid.y - outer.height + frame_size_top;
+      else
+        *new_y = work_area.y + frame_size_top;
+      break;
+    case META_BOTTOM:
+      *new_x = avoid.x + frame_size_left;
+      if (bottom_space > outer.height)
+        *new_y = avoid.y + avoid.height + frame_size_top;
+      else
+        *new_y = work_area.y + work_area.height - outer.height + frame_size_top;
+      break;
+    }
+}
+
+static void
+avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
+                                             MetaFrameGeometry *fgeom,
+                                             int        *x,
+                                             int        *y)
+{
+  /* We can't center this dialog if it was denied focus and it
+   * overlaps with the focus window and this dialog is modal and this
+   * dialog is in the same app as the focus window (*phew*...please
+   * don't make me say that ten times fast). See bug 307875 comment 11
+   * and 12 for details, but basically it means this is probably a
+   * second modal dialog for some app while the focus window is the
+   * first modal dialog.  We should probably make them simultaneously
+   * visible in general, but it becomes mandatory to do so due to
+   * buggy apps (e.g. those using gtk+ *sigh*) because in those cases
+   * this second modal dialog also happens to be modal to the first
+   * dialog in addition to the main window, while it has only let us
+   * know about the modal-to-the-main-window part.
+   */
+
+  MetaWindow *focus_window;
+  MetaRectangle overlap;
+
+  focus_window = window->display->focus_window;
+
+  if (window->denied_focus_and_not_transient &&
+      window->wm_state_modal && /* FIXME: Maybe do this for all transients? */
+      meta_window_same_application (window, focus_window) &&
+      meta_rectangle_intersect (&window->rect,
+                                &focus_window->rect,
+                                &overlap))
+    {
+      find_most_freespace (window, fgeom, focus_window, *x, *y, x, y);
+      meta_topic (META_DEBUG_PLACEMENT,
+                  "Dialog window %s was denied focus but may be modal "
+                  "to the focus window; had to move it to avoid the "
+                  "focus window\n",
+                  window->desc);
+    }
+}
+
+static gboolean
+rectangle_overlaps_some_window (MetaRectangle *rect,
+                                GList         *windows)
+{
+  GList *tmp;
+  MetaRectangle dest;
+  
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *other = tmp->data;
+      MetaRectangle other_rect;      
+
+      switch (other->type)
+        {
+        case META_WINDOW_DOCK:
+        case META_WINDOW_SPLASHSCREEN:
+        case META_WINDOW_DESKTOP:
+        case META_WINDOW_DIALOG:
+        case META_WINDOW_MODAL_DIALOG:
+          break;
+
+        case META_WINDOW_NORMAL:
+        case META_WINDOW_UTILITY:
+        case META_WINDOW_TOOLBAR:
+        case META_WINDOW_MENU:
+          meta_window_get_outer_rect (other, &other_rect);
+          
+          if (meta_rectangle_intersect (rect, &other_rect, &dest))
+            return TRUE;
+          break;
+        }
+      
+      tmp = tmp->next;
+    }
+
+  return FALSE;
+}
+
+static gint
+leftmost_cmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+  int ax, bx;
+
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    ax = aw->frame->rect.x;
+  else
+    ax = aw->rect.x;
+
+  if (bw->frame)
+    bx = bw->frame->rect.x;
+  else
+    bx = bw->rect.x;
+
+  if (ax < bx)
+    return -1;
+  else if (ax > bx)
+    return 1;
+  else
+    return 0;
+}
+
+static gint
+topmost_cmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+  int ay, by;
+
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    ay = aw->frame->rect.y;
+  else
+    ay = aw->rect.y;
+
+  if (bw->frame)
+    by = bw->frame->rect.y;
+  else
+    by = bw->rect.y;
+
+  if (ay < by)
+    return -1;
+  else if (ay > by)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+center_tile_rect_in_area (MetaRectangle *rect,
+                          MetaRectangle *work_area)
+{
+  int fluff;
+
+  /* The point here is to tile a window such that "extra"
+   * space is equal on either side (i.e. so a full screen
+   * of windows tiled this way would center the windows
+   * as a group)
+   */
+
+  fluff = (work_area->width % (rect->width+1)) / 2;
+  rect->x = work_area->x + fluff;
+  fluff = (work_area->height % (rect->height+1)) / 3;
+  rect->y = work_area->y + fluff;
+}
+
+/* Find the leftmost, then topmost, empty area on the workspace
+ * that can contain the new window.
+ *
+ * Cool feature to have: if we can't fit the current window size,
+ * try shrinking the window (within geometry constraints). But
+ * beware windows such as Emacs with no sane minimum size, we
+ * don't want to create a 1x1 Emacs.
+ */
+static gboolean
+find_first_fit (MetaWindow *window,
+                MetaFrameGeometry *fgeom,
+                /* visible windows on relevant workspaces */
+                GList      *windows,
+		int         xinerama,
+                int         x,
+                int         y,
+                int        *new_x,
+                int        *new_y)
+{
+  /* This algorithm is limited - it just brute-force tries
+   * to fit the window in a small number of locations that are aligned
+   * with existing windows. It tries to place the window on
+   * the bottom of each existing window, and then to the right
+   * of each existing window, aligned with the left/top of the
+   * existing window in each of those cases.
+   */  
+  int retval;
+  GList *below_sorted;
+  GList *right_sorted;
+  GList *tmp;
+  MetaRectangle rect;
+  MetaRectangle work_area;
+  
+  retval = FALSE;
+
+  /* Below each window */
+  below_sorted = g_list_copy (windows);
+  below_sorted = g_list_sort (below_sorted, leftmost_cmp);
+  below_sorted = g_list_sort (below_sorted, topmost_cmp);  
+
+  /* To the right of each window */
+  right_sorted = g_list_copy (windows);
+  right_sorted = g_list_sort (right_sorted, topmost_cmp);
+  right_sorted = g_list_sort (right_sorted, leftmost_cmp);
+  
+  rect.width = window->rect.width;
+  rect.height = window->rect.height;
+  
+  if (fgeom)
+    {
+      rect.width += fgeom->left_width + fgeom->right_width;
+      rect.height += fgeom->top_height + fgeom->bottom_height;
+    }
+
+#ifdef WITH_VERBOSE_MODE
+    {
+      char xinerama_location_string[RECT_LENGTH];
+      meta_rectangle_to_string (&window->screen->xinerama_infos[xinerama].rect,
+                                xinerama_location_string);
+      meta_topic (META_DEBUG_XINERAMA,
+		  "Natural xinerama is %s\n",
+		  xinerama_location_string);
+    }
+#endif
+
+    meta_window_get_work_area_for_xinerama (window, xinerama, &work_area);
+
+    center_tile_rect_in_area (&rect, &work_area);
+
+    if (meta_rectangle_contains_rect (&work_area, &rect) &&
+        !rectangle_overlaps_some_window (&rect, windows))
+      {
+        *new_x = rect.x;
+        *new_y = rect.y;
+        if (fgeom)
+          {
+            *new_x += fgeom->left_width;
+            *new_y += fgeom->top_height;
+          }
+    
+        retval = TRUE;
+       
+        goto out;
+      }
+
+    /* try below each window */
+    tmp = below_sorted;
+    while (tmp != NULL)
+      {
+        MetaWindow *w = tmp->data;
+        MetaRectangle outer_rect;
+
+        meta_window_get_outer_rect (w, &outer_rect);
+      
+        rect.x = outer_rect.x;
+        rect.y = outer_rect.y + outer_rect.height;
+      
+        if (meta_rectangle_contains_rect (&work_area, &rect) &&
+            !rectangle_overlaps_some_window (&rect, below_sorted))
+          {
+            *new_x = rect.x;
+            *new_y = rect.y;
+            if (fgeom)
+              {
+                *new_x += fgeom->left_width;
+                *new_y += fgeom->top_height;
+              }
+          
+            retval = TRUE;
+          
+            goto out;
+          }
+
+        tmp = tmp->next;
+      }
+
+    /* try to the right of each window */
+    tmp = right_sorted;
+    while (tmp != NULL)
+      {
+        MetaWindow *w = tmp->data;
+        MetaRectangle outer_rect;
+   
+        meta_window_get_outer_rect (w, &outer_rect);
+     
+        rect.x = outer_rect.x + outer_rect.width;
+        rect.y = outer_rect.y;
+   
+        if (meta_rectangle_contains_rect (&work_area, &rect) &&
+            !rectangle_overlaps_some_window (&rect, right_sorted))
+          {
+            *new_x = rect.x;
+            *new_y = rect.y;
+            if (fgeom)
+              {
+                *new_x += fgeom->left_width;
+                *new_y += fgeom->top_height;
+              }
+        
+            retval = TRUE;
+       
+            goto out;
+          }
+
+        tmp = tmp->next;
+      }
+      
+ out:
+
+  g_list_free (below_sorted);
+  g_list_free (right_sorted);
+  return retval;
+}
+
+void
+meta_window_place (MetaWindow        *window,
+                   MetaFrameGeometry *fgeom,
+                   int                x,
+                   int                y,
+                   int               *new_x,
+                   int               *new_y)
+{
+  GList *windows;
+  const MetaXineramaScreenInfo *xi;
+
+  /* frame member variables should NEVER be used in here, only
+   * MetaFrameGeometry. But remember fgeom == NULL
+   * for undecorated windows. Also, this function should
+   * NEVER have side effects other than computing the
+   * placement coordinates.
+   */
+  
+  meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);
+
+  windows = NULL;
+  
+  switch (window->type)
+    {
+      /* Run placement algorithm on these. */
+    case META_WINDOW_NORMAL:
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+    case META_WINDOW_SPLASHSCREEN:
+      break;
+          
+      /* Assume the app knows best how to place these, no placement
+       * algorithm ever (other than "leave them as-is")
+       */
+    case META_WINDOW_DESKTOP:
+    case META_WINDOW_DOCK:
+    case META_WINDOW_TOOLBAR:
+    case META_WINDOW_MENU:
+    case META_WINDOW_UTILITY:
+      goto done_no_constraints;
+    }
+  
+  if (meta_prefs_get_disable_workarounds ())
+    {
+      switch (window->type)
+        {
+          /* Only accept USPosition on normal windows because the app is full
+           * of shit claiming the user set -geometry for a dialog or dock
+           */
+        case META_WINDOW_NORMAL:
+          if (window->size_hints.flags & USPosition)
+            {
+              /* don't constrain with placement algorithm */
+              meta_topic (META_DEBUG_PLACEMENT,
+                          "Honoring USPosition for %s instead of using placement algorithm\n", window->desc);
+
+              goto done;
+            }
+          break;
+
+          /* Ignore even USPosition on dialogs, splashscreen */
+        case META_WINDOW_DIALOG:
+        case META_WINDOW_MODAL_DIALOG:
+        case META_WINDOW_SPLASHSCREEN:
+          break;
+          
+          /* Assume the app knows best how to place these. */
+        case META_WINDOW_DESKTOP:
+        case META_WINDOW_DOCK:
+        case META_WINDOW_TOOLBAR:
+        case META_WINDOW_MENU:
+        case META_WINDOW_UTILITY:
+          if (window->size_hints.flags & PPosition)
+            {
+              meta_topic (META_DEBUG_PLACEMENT,
+                          "Not placing non-normal non-dialog window with PPosition set\n");
+              goto done_no_constraints;
+            }
+          break;
+        }
+    }
+  else
+    {
+      /* workarounds enabled */
+      
+      if ((window->size_hints.flags & PPosition) ||
+          (window->size_hints.flags & USPosition))
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Not placing window with PPosition or USPosition set\n");
+          avoid_being_obscured_as_second_modal_dialog (window, fgeom, &x, &y);
+          goto done_no_constraints;
+        }
+    }
+  
+  if ((window->type == META_WINDOW_DIALOG ||
+       window->type == META_WINDOW_MODAL_DIALOG) &&
+      window->xtransient_for != None)
+    {
+      /* Center horizontally, at top of parent vertically */
+
+      MetaWindow *parent;
+          
+      parent =
+        meta_display_lookup_x_window (window->display,
+                                      window->xtransient_for);
+
+      if (parent)
+        {
+          int w;
+
+          meta_window_get_position (parent, &x, &y);
+          w = parent->rect.width;
+
+          /* center of parent */
+          x = x + w / 2;
+          /* center of child over center of parent */
+          x -= window->rect.width / 2;
+
+          /* "visually" center window over parent, leaving twice as
+           * much space below as on top.
+           */
+          y += (parent->rect.height - window->rect.height)/3;
+
+          /* put top of child's frame, not top of child's client */
+          if (fgeom)
+            y += fgeom->top_height;
+
+          meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
+                      window->desc);
+          
+          avoid_being_obscured_as_second_modal_dialog (window, fgeom, &x, &y);
+
+          goto done;
+        }
+    }
+  
+  /* FIXME UTILITY with transient set should be stacked up
+   * on the sides of the parent window or something.
+   */
+  
+  if (window->type == META_WINDOW_DIALOG ||
+      window->type == META_WINDOW_MODAL_DIALOG ||
+      window->type == META_WINDOW_SPLASHSCREEN)
+    {
+      /* Center on current xinerama (i.e. on current monitor) */
+      int w, h;
+
+      /* Warning, this function is a round trip! */
+      xi = meta_screen_get_current_xinerama (window->screen);
+
+      w = xi->rect.width;
+      h = xi->rect.height;
+
+      x = (w - window->rect.width) / 2;
+      y = (h - window->rect.height) / 2;
+
+      x += xi->rect.x;
+      y += xi->rect.y;
+      
+      meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d xinerama %d\n",
+                  window->desc, window->screen->number, xi->number);
+
+      goto done_check_denied_focus;
+    }
+  
+  /* Find windows that matter (not minimized, on same workspace
+   * as placed window, may be shaded - if shaded we pretend it isn't
+   * for placement purposes)
+   */
+  {
+    GSList *all_windows;
+    GSList *tmp;
+    
+    all_windows = meta_display_list_windows (window->display);
+
+    tmp = all_windows;
+    while (tmp != NULL)
+      {
+        MetaWindow *w = tmp->data;
+
+        if (meta_window_showing_on_its_workspace (w) &&
+            w != window && 
+            (window->workspace == w->workspace ||
+             window->on_all_workspaces || w->on_all_workspaces))
+          windows = g_list_prepend (windows, w);
+
+        tmp = tmp->next;
+      }
+
+    g_slist_free (all_windows);
+  }
+
+  /* Warning, this is a round trip! */
+  xi = meta_screen_get_current_xinerama (window->screen);
+  
+  /* "Origin" placement algorithm */
+  x = xi->rect.x;
+  y = xi->rect.y;
+
+  if (find_first_fit (window, fgeom, windows,
+                      xi->number,
+                      x, y, &x, &y))
+    goto done_check_denied_focus;
+
+  /* Maximize windows if they are too big for their work area (bit of
+   * a hack here). Assume undecorated windows probably don't intend to
+   * be maximized.  
+   */
+  if (window->has_maximize_func && window->decorated &&
+      !window->fullscreen)
+    {
+      MetaRectangle workarea;
+      MetaRectangle outer;
+
+      meta_window_get_work_area_for_xinerama (window,
+                                              xi->number,
+                                              &workarea);      
+      meta_window_get_outer_rect (window, &outer);
+      
+      /* If the window is bigger than the screen, then automaximize.  Do NOT
+       * auto-maximize the directions independently.  See #419810.
+       */
+      if (outer.width >= workarea.width && outer.height >= workarea.height)
+        {
+          window->maximize_horizontally_after_placement = TRUE;
+          window->maximize_vertically_after_placement = TRUE;
+        }
+    }
+
+  /* If no placement has been done, revert to cascade to avoid 
+   * fully overlapping window (e.g. starting multiple terminals)
+   * */
+  if (x == xi->rect.x && y == xi->rect.y)  
+    find_next_cascade (window, fgeom, windows, x, y, &x, &y);
+
+ done_check_denied_focus:
+  /* If the window is being denied focus and isn't a transient of the
+   * focus window, we do NOT want it to overlap with the focus window
+   * if at all possible.  This is guaranteed to only be called if the
+   * focus_window is non-NULL, and we try to avoid that window.
+   */
+  if (window->denied_focus_and_not_transient)
+    {
+      gboolean       found_fit;
+      MetaWindow    *focus_window;
+      MetaRectangle  overlap;
+
+      focus_window = window->display->focus_window;
+      g_assert (focus_window != NULL);
+
+      /* No need to do anything if the window doesn't overlap at all */
+      found_fit = !meta_rectangle_intersect (&window->rect,
+                                             &focus_window->rect,
+                                             &overlap);
+
+      /* Try to do a first fit again, this time only taking into account the
+       * focus window.
+       */
+      if (!found_fit)
+        {
+          GList *focus_window_list;
+          focus_window_list = g_list_prepend (NULL, focus_window);
+
+          /* Reset x and y ("origin" placement algorithm) */
+          x = xi->rect.x;
+          y = xi->rect.y;
+
+          found_fit = find_first_fit (window, fgeom, focus_window_list,
+                                      xi->number,
+                                      x, y, &x, &y);
+          g_list_free (focus_window_list);
+	}
+
+      /* If that still didn't work, just place it where we can see as much
+       * as possible.
+       */
+      if (!found_fit)
+        find_most_freespace (window, fgeom, focus_window, x, y, &x, &y);
+    }
+  
+ done:
+  g_list_free (windows);
+  
+ done_no_constraints:
+
+  *new_x = x;
+  *new_y = y;
+}
diff --git a/src/core/place.h b/src/core/place.h
new file mode 100644
index 00000000..85b7cd3f
--- /dev/null
+++ b/src/core/place.h
@@ -0,0 +1,37 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window placement */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_PLACE_H
+#define META_PLACE_H
+
+#include "window-private.h"
+#include "frame-private.h"
+
+void meta_window_place (MetaWindow *window,
+                        MetaFrameGeometry *fgeom,
+                        int         x,
+                        int         y,
+                        int        *new_x,
+                        int        *new_y);
+
+#endif
diff --git a/src/core/prefs.c b/src/core/prefs.c
new file mode 100644
index 00000000..494d3da1
--- /dev/null
+++ b/src/core/prefs.c
@@ -0,0 +1,2794 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco preferences */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington, Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2006 Elijah Newren
+ * Copyright (C) 2008 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "prefs.h"
+#include "ui.h"
+#include "util.h"
+#ifdef HAVE_MATECONF
+#include <mateconf/mateconf-client.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#define MAX_REASONABLE_WORKSPACES 36
+
+#define MAX_COMMANDS (32 + NUM_EXTRA_COMMANDS)
+#define NUM_EXTRA_COMMANDS 2
+#define SCREENSHOT_COMMAND_IDX (MAX_COMMANDS - 2)
+#define WIN_SCREENSHOT_COMMAND_IDX (MAX_COMMANDS - 1)
+
+/* If you add a key, it needs updating in init() and in the mateconf
+ * notify listener and of course in the .schemas file.
+ *
+ * Keys which are handled by one of the unified handlers below are
+ * not given a name here, because the purpose of the unified handlers
+ * is that keys should be referred to exactly once.
+ */
+#define KEY_TITLEBAR_FONT "/apps/marco/general/titlebar_font"
+#define KEY_NUM_WORKSPACES "/apps/marco/general/num_workspaces"
+#define KEY_COMPOSITOR "/apps/marco/general/compositing_manager"
+#define KEY_MATE_ACCESSIBILITY "/desktop/mate/interface/accessibility"
+
+#define KEY_COMMAND_DIRECTORY "/apps/marco/keybinding_commands"
+#define KEY_COMMAND_PREFIX "/apps/marco/keybinding_commands/command_"
+
+#define KEY_TERMINAL_DIR "/desktop/mate/applications/terminal"
+#define KEY_TERMINAL_COMMAND KEY_TERMINAL_DIR "/exec"
+
+#define KEY_SCREEN_BINDINGS_PREFIX "/apps/marco/global_keybindings"
+#define KEY_WINDOW_BINDINGS_PREFIX "/apps/marco/window_keybindings"
+#define KEY_LIST_BINDINGS_SUFFIX "_list"
+
+#define KEY_WORKSPACE_NAME_DIRECTORY "/apps/marco/workspace_names"
+#define KEY_WORKSPACE_NAME_PREFIX "/apps/marco/workspace_names/name_"
+
+
+#ifdef HAVE_MATECONF
+static MateConfClient *default_client = NULL;
+static GList *changes = NULL;
+static guint changed_idle;
+static GList *listeners = NULL;
+#endif
+
+static gboolean use_system_font = FALSE;
+static PangoFontDescription *titlebar_font = NULL;
+static MetaVirtualModifier mouse_button_mods = Mod1Mask;
+static MetaFocusMode focus_mode = META_FOCUS_MODE_CLICK;
+static MetaFocusNewWindows focus_new_windows = META_FOCUS_NEW_WINDOWS_SMART;
+static gboolean raise_on_click = TRUE;
+static char* current_theme = NULL;
+static int num_workspaces = 4;
+static MetaActionTitlebar action_double_click_titlebar = META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE;
+static MetaActionTitlebar action_middle_click_titlebar = META_ACTION_TITLEBAR_LOWER;
+static MetaActionTitlebar action_right_click_titlebar = META_ACTION_TITLEBAR_MENU;
+static gboolean application_based = FALSE;
+static gboolean disable_workarounds = FALSE;
+static gboolean auto_raise = FALSE;
+static gboolean auto_raise_delay = 500;
+static gboolean provide_visual_bell = FALSE;
+static gboolean bell_is_audible = TRUE;
+static gboolean reduced_resources = FALSE;
+static gboolean mate_accessibility = FALSE;
+static gboolean mate_animations = TRUE;
+static char *cursor_theme = NULL;
+static int   cursor_size = 24;
+static gboolean compositing_manager = FALSE;
+static gboolean resize_with_right_button = FALSE;
+static gboolean force_fullscreen = TRUE;
+
+static MetaVisualBellType visual_bell_type = META_VISUAL_BELL_FULLSCREEN_FLASH;
+static MetaButtonLayout button_layout;
+
+/* The screenshot commands are at the end */
+static char *commands[MAX_COMMANDS] = { NULL, };
+
+static char *terminal_command = NULL;
+
+static char *workspace_names[MAX_REASONABLE_WORKSPACES] = { NULL, };
+
+#ifdef HAVE_MATECONF
+static gboolean handle_preference_update_enum (const gchar *key, MateConfValue *value);
+
+static gboolean update_key_binding     (const char *name,
+                                        const char *value);
+static gboolean find_and_update_list_binding (MetaKeyPref *bindings,
+                                              const char  *name,
+                                              GSList      *value);
+static gboolean update_key_list_binding (const char *name,
+                                         GSList      *value);
+static gboolean update_command            (const char  *name,
+                                           const char  *value);
+static gboolean update_workspace_name     (const char  *name,
+                                           const char  *value);
+
+static void change_notify (MateConfClient    *client,
+                           guint           cnxn_id,
+                           MateConfEntry     *entry,
+                           gpointer        user_data);
+
+static char* mateconf_key_for_workspace_name (int i);
+
+static void queue_changed (MetaPreference  pref);
+
+typedef enum
+  {
+    META_LIST_OF_STRINGS,
+    META_LIST_OF_MATECONFVALUE_STRINGS
+  } MetaStringListType;
+
+static gboolean update_list_binding       (MetaKeyPref *binding,
+                                           GSList      *value,
+                                           MetaStringListType type_of_value);
+
+static void     cleanup_error             (GError **error);
+static gboolean get_bool                  (const char *key, gboolean *val);
+static void maybe_give_disable_workarounds_warning (void);
+
+static void titlebar_handler (MetaPreference, const gchar*, gboolean*);
+static void theme_name_handler (MetaPreference, const gchar*, gboolean*);
+static void mouse_button_mods_handler (MetaPreference, const gchar*, gboolean*);
+static void button_layout_handler (MetaPreference, const gchar*, gboolean*);
+
+#endif /* HAVE_MATECONF */
+
+static gboolean update_binding            (MetaKeyPref *binding,
+                                           const char  *value);
+
+static void     init_bindings             (void);
+static void     init_commands             (void);
+static void     init_workspace_names      (void);
+
+#ifndef HAVE_MATECONF
+static void     init_button_layout        (void);
+#endif /* !HAVE_MATECONF */
+
+#ifdef HAVE_MATECONF
+
+typedef struct
+{
+  MetaPrefsChangedFunc func;
+  gpointer data;
+} MetaPrefsListener;
+
+static MateConfEnumStringPair symtab_focus_mode[] =
+  {
+    { META_FOCUS_MODE_CLICK,  "click" },
+    { META_FOCUS_MODE_SLOPPY, "sloppy" },
+    { META_FOCUS_MODE_MOUSE,  "mouse" },
+    { 0, NULL },
+  };
+
+static MateConfEnumStringPair symtab_focus_new_windows[] =
+  {
+    { META_FOCUS_NEW_WINDOWS_SMART,  "smart" },
+    { META_FOCUS_NEW_WINDOWS_STRICT, "strict" },
+    { 0, NULL },
+  };
+
+static MateConfEnumStringPair symtab_visual_bell_type[] =
+  {
+    /* Note to the reader: 0 is an invalid value; these start at 1. */
+    { META_VISUAL_BELL_FULLSCREEN_FLASH, "fullscreen" },
+    { META_VISUAL_BELL_FRAME_FLASH,      "frame_flash" },
+    { 0, NULL },
+  };
+
+static MateConfEnumStringPair symtab_titlebar_action[] =
+  {
+    { META_ACTION_TITLEBAR_TOGGLE_SHADE,    "toggle_shade" },
+    { META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE, "toggle_maximize" },
+    { META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_HORIZONTALLY,
+                                "toggle_maximize_horizontally" },
+    { META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_VERTICALLY,
+                                "toggle_maximize_vertically" },
+    { META_ACTION_TITLEBAR_MINIMIZE,        "minimize" },
+    { META_ACTION_TITLEBAR_NONE,            "none" },
+    { META_ACTION_TITLEBAR_LOWER,           "lower" },
+    { META_ACTION_TITLEBAR_MENU,            "menu" },
+    { META_ACTION_TITLEBAR_TOGGLE_SHADE,    "toggle_shade" },
+    { 0, NULL },
+  };
+
+/**
+ * The details of one preference which is constrained to be
+ * one of a small number of string values-- in other words,
+ * an enumeration.
+ *
+ * We could have done this other ways.  One particularly attractive
+ * possibility would have been to represent the entire symbol table
+ * as a space-separated string literal in the list of symtabs, so
+ * the focus mode enums could have been represented simply by
+ * "click sloppy mouse".  However, the simplicity gained would have
+ * been outweighed by the bugs caused when the ordering of the enum
+ * strings got out of sync with the actual enum statement.  Also,
+ * there is existing library code to use this kind of symbol tables.
+ *
+ * Other things we might consider doing to clean this up in the
+ * future include:
+ *
+ *   - most of the keys begin with the same prefix, and perhaps we
+ *     could assume it if they don't start with a slash
+ *
+ *   - there are several cases where a single identifier could be used
+ *     to generate an entire entry, and perhaps this could be done
+ *     with a macro.  (This would reduce clarity, however, and is
+ *     probably a bad thing.)
+ *
+ *   - these types all begin with a gchar* (and contain a MetaPreference)
+ *     and we can factor out the repeated code in the handlers by taking
+ *     advantage of this using some kind of union arrangement.
+ */
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+  MateConfEnumStringPair *symtab;
+  gpointer target;
+} MetaEnumPreference;
+
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+  gboolean *target;
+  gboolean becomes_true_on_destruction;
+} MetaBoolPreference;
+
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+
+  /**
+   * A handler.  Many of the string preferences aren't stored as
+   * strings and need parsing; others of them have default values
+   * which can't be solved in the general case.  If you include a
+   * function pointer here, it will be called before the string
+   * value is written out to the target variable.
+   *
+   * The function is passed two arguments: the preference, and
+   * the new string as a gchar*.  It returns a gboolean;
+   * only if this is true, the listeners will be informed that
+   * the preference has changed.
+   *
+   * This may be NULL.  If it is, see "target", below.
+   */
+  void (*handler) (MetaPreference pref,
+                     const gchar *string_value,
+                     gboolean *inform_listeners);
+
+  /**
+   * Where to write the incoming string.
+   *
+   * This must be NULL if the handler is non-NULL.
+   * If the incoming string is NULL, no change will be made.
+   */
+  gchar **target;
+
+} MetaStringPreference;
+
+#define METAINTPREFERENCE_NO_CHANGE_ON_DESTROY G_MININT
+
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+  gint *target;
+  /**
+   * Minimum and maximum values of the integer.
+   * If the new value is out of bounds, it will be discarded with a warning.
+   */
+  gint minimum, maximum;
+  /**
+   * Value to use if the key is destroyed.
+   * If this is METAINTPREFERENCE_NO_CHANGE_ON_DESTROY, it will
+   * not be changed when the key is destroyed.
+   */
+  gint value_if_destroyed;
+} MetaIntPreference;
+
+/* FIXMEs: */
+/* @@@ Don't use NULL lines at the end; glib can tell you how big it is */
+/* @@@ /apps/marco/general should be assumed if first char is not / */
+/* @@@ Will it ever be possible to merge init and update? If not, why not? */
+
+static MetaEnumPreference preferences_enum[] =
+  {
+    { "/apps/marco/general/focus_new_windows",
+      META_PREF_FOCUS_NEW_WINDOWS,
+      symtab_focus_new_windows,
+      &focus_new_windows,
+    },
+    { "/apps/marco/general/focus_mode",
+      META_PREF_FOCUS_MODE,
+      symtab_focus_mode,
+      &focus_mode,
+    },
+    { "/apps/marco/general/visual_bell_type",
+      META_PREF_VISUAL_BELL_TYPE,
+      symtab_visual_bell_type,
+      &visual_bell_type,
+    },
+    { "/apps/marco/general/action_double_click_titlebar",
+      META_PREF_ACTION_DOUBLE_CLICK_TITLEBAR,
+      symtab_titlebar_action,
+      &action_double_click_titlebar,
+    },
+    { "/apps/marco/general/action_middle_click_titlebar",
+      META_PREF_ACTION_MIDDLE_CLICK_TITLEBAR,
+      symtab_titlebar_action,
+      &action_middle_click_titlebar,
+    },
+    { "/apps/marco/general/action_right_click_titlebar",
+      META_PREF_ACTION_RIGHT_CLICK_TITLEBAR,
+      symtab_titlebar_action,
+      &action_right_click_titlebar,
+    },
+    { NULL, 0, NULL, NULL },
+  };
+
+static MetaBoolPreference preferences_bool[] =
+  {
+    { "/apps/marco/general/raise_on_click",
+      META_PREF_RAISE_ON_CLICK,
+      &raise_on_click,
+      TRUE,
+    },
+    { "/apps/marco/general/titlebar_uses_system_font",
+      META_PREF_TITLEBAR_FONT, /* note! shares a pref */
+      &use_system_font,
+      TRUE,
+    },
+    { "/apps/marco/general/application_based",
+      META_PREF_APPLICATION_BASED,
+      NULL, /* feature is known but disabled */
+      FALSE,
+    },
+    { "/apps/marco/general/disable_workarounds",
+      META_PREF_DISABLE_WORKAROUNDS,
+      &disable_workarounds,
+      FALSE,
+    },
+    { "/apps/marco/general/auto_raise",
+      META_PREF_AUTO_RAISE,
+      &auto_raise,
+      FALSE,
+    },
+    { "/apps/marco/general/visual_bell",
+      META_PREF_VISUAL_BELL,
+      &provide_visual_bell, /* FIXME: change the name: it's confusing */
+      FALSE,
+    },
+    { "/apps/marco/general/audible_bell",
+      META_PREF_AUDIBLE_BELL,
+      &bell_is_audible, /* FIXME: change the name: it's confusing */
+      FALSE,
+    },
+    { "/apps/marco/general/reduced_resources",
+      META_PREF_REDUCED_RESOURCES,
+      &reduced_resources,
+      FALSE,
+    },
+    { "/desktop/mate/interface/accessibility",
+      META_PREF_MATE_ACCESSIBILITY,
+      &mate_accessibility,
+      FALSE,
+    },
+    { "/desktop/mate/interface/enable_animations",
+      META_PREF_MATE_ANIMATIONS,
+      &mate_animations,
+      TRUE,
+    },
+    { "/apps/marco/general/compositing_manager",
+      META_PREF_COMPOSITING_MANAGER,
+      &compositing_manager,
+      FALSE,
+    },
+    { "/apps/marco/general/resize_with_right_button",
+      META_PREF_RESIZE_WITH_RIGHT_BUTTON,
+      &resize_with_right_button,
+      FALSE,
+    },
+    { NULL, 0, NULL, FALSE },
+  };
+
+static MetaStringPreference preferences_string[] =
+  {
+    { "/apps/marco/general/mouse_button_modifier",
+      META_PREF_MOUSE_BUTTON_MODS,
+      mouse_button_mods_handler,
+      NULL,
+    },
+    { "/apps/marco/general/theme",
+      META_PREF_THEME,
+      theme_name_handler,
+      NULL,
+    },
+    { KEY_TITLEBAR_FONT,
+      META_PREF_TITLEBAR_FONT,
+      titlebar_handler,
+      NULL,
+    },
+    { KEY_TERMINAL_COMMAND,
+      META_PREF_TERMINAL_COMMAND,
+      NULL,
+      &terminal_command,
+    },
+    { "/apps/marco/general/button_layout",
+      META_PREF_BUTTON_LAYOUT,
+      button_layout_handler,
+      NULL,
+    },
+    { "/desktop/mate/peripherals/mouse/cursor_theme",
+      META_PREF_CURSOR_THEME,
+      NULL,
+      &cursor_theme,
+    },
+    { NULL, 0, NULL, NULL },
+  };
+
+static MetaIntPreference preferences_int[] =
+  {
+    { "/apps/marco/general/num_workspaces",
+      META_PREF_NUM_WORKSPACES,
+      &num_workspaces,
+      /* I would actually recommend we change the destroy value to 4
+       * and get rid of METAINTPREFERENCE_NO_CHANGE_ON_DESTROY entirely.
+       *  -- tthurman
+       */
+      1, MAX_REASONABLE_WORKSPACES, METAINTPREFERENCE_NO_CHANGE_ON_DESTROY,
+    },
+    { "/apps/marco/general/auto_raise_delay",
+      META_PREF_AUTO_RAISE_DELAY,
+      &auto_raise_delay,
+      0, 10000, 0,
+      /* @@@ Get rid of MAX_REASONABLE_AUTO_RAISE_DELAY */
+    },
+    { "/desktop/mate/peripherals/mouse/cursor_size",
+      META_PREF_CURSOR_SIZE,
+      &cursor_size,
+      1, 128, 24,
+    },
+    { NULL, 0, NULL, 0, 0, 0, },
+  };
+
+static void
+handle_preference_init_enum (void)
+{
+  MetaEnumPreference *cursor = preferences_enum;
+
+  while (cursor->key!=NULL)
+    {
+      char *value;
+      GError *error = NULL;
+
+      if (cursor->target==NULL)
+        {
+          ++cursor;
+          continue;
+        }
+
+      value = mateconf_client_get_string (default_client,
+                                       cursor->key,
+                                       &error);
+      cleanup_error (&error);
+
+      if (value==NULL)
+        {
+          ++cursor;
+          continue;
+        }
+
+      if (!mateconf_string_to_enum (cursor->symtab,
+                                 value,
+                                 (gint *) cursor->target))
+        meta_warning (_("MateConf key '%s' is set to an invalid value\n"),
+                      cursor->key);
+
+      g_free (value);
+
+      ++cursor;
+    }
+}
+
+static void
+handle_preference_init_bool (void)
+{
+  MetaBoolPreference *cursor = preferences_bool;
+
+  while (cursor->key!=NULL)
+    {
+      if (cursor->target!=NULL)
+        get_bool (cursor->key, cursor->target);
+
+      ++cursor;
+    }
+
+  maybe_give_disable_workarounds_warning ();
+}
+
+static void
+handle_preference_init_string (void)
+{
+  MetaStringPreference *cursor = preferences_string;
+
+  while (cursor->key!=NULL)
+    {
+      char *value;
+      GError *error = NULL;
+      gboolean dummy = TRUE;
+
+      /* the string "value" will be newly allocated */
+      value = mateconf_client_get_string (default_client,
+                                       cursor->key,
+                                       &error);
+      cleanup_error (&error);
+
+      if (cursor->handler)
+        {
+          if (cursor->target)
+            meta_bug ("%s has both a target and a handler\n", cursor->key);
+
+          cursor->handler (cursor->pref, value, &dummy);
+
+          g_free (value);
+        }
+      else if (cursor->target)
+        {
+          if (*(cursor->target))
+            g_free (*(cursor->target));
+
+          *(cursor->target) = value;
+        }
+
+      ++cursor;
+    }
+}
+
+static void
+handle_preference_init_int (void)
+{
+  MetaIntPreference *cursor = preferences_int;
+
+  
+  while (cursor->key!=NULL)
+    {
+      gint value;
+      GError *error = NULL;
+
+      value = mateconf_client_get_int (default_client,
+                                    cursor->key,
+                                    &error);
+      cleanup_error (&error);
+
+      if (value < cursor->minimum || value > cursor->maximum)
+        {
+          meta_warning (_("%d stored in MateConf key %s is out of range %d to %d\n"),
+                        value, cursor->key,  cursor->minimum, cursor->maximum);
+          /* Former behaviour for out-of-range values was:
+           *   - number of workspaces was clamped;
+           *   - auto raise delay was always reset to zero even if too high!;
+           *   - cursor size was ignored.
+           *
+           * These seem to be meaningless variations.  If they did
+           * have meaning we could have put them into MetaIntPreference.
+           * The last of these is the closest to how we behave for
+           * other types, so I think we should standardise on that.
+           */
+        }
+      else if (cursor->target)
+        *cursor->target = value;
+
+      ++cursor;
+    }
+}
+
+static gboolean
+handle_preference_update_enum (const gchar *key, MateConfValue *value)
+{
+  MetaEnumPreference *cursor = preferences_enum;
+  gint old_value;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+      
+  /* Setting it to null (that is, removing it) always means
+   * "don't change".
+   */
+
+  if (value==NULL)
+    return TRUE;
+
+  /* Check the type.  Enums are always strings. */
+
+  if (value->type != MATECONF_VALUE_STRING)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  /* We need to know whether the value changes, so
+   * store the current value away.
+   */
+
+  old_value = * ((gint *) cursor->target);
+  
+  /* Now look it up... */
+
+  if (!mateconf_string_to_enum (cursor->symtab,
+                             mateconf_value_get_string (value),
+                             (gint *) cursor->target))
+    {
+      /*
+       * We found it, but it was invalid.  Complain.
+       *
+       * FIXME: This replicates the original behaviour, but in the future
+       * we might consider reverting invalid keys to their original values.
+       * (We know the old value, so we can look up a suitable string in
+       * the symtab.)
+       *
+       * (Empty comment follows so the translators don't see this.)
+       */
+
+      /*  */      
+      meta_warning (_("MateConf key '%s' is set to an invalid value\n"),
+                    key);
+      return TRUE;
+    }
+
+  /* Did it change?  If so, tell the listeners about it. */
+
+  if (old_value != *((gint *) cursor->target))
+    queue_changed (cursor->pref);
+
+  return TRUE;
+}
+
+static gboolean
+handle_preference_update_bool (const gchar *key, MateConfValue *value)
+{
+  MetaBoolPreference *cursor = preferences_bool;
+  gboolean old_value;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+
+  if (cursor->target==NULL)
+    /* No work for us to do. */
+    return TRUE;
+      
+  if (value==NULL)
+    {
+      /* Value was destroyed; let's get out of here. */
+
+      if (cursor->becomes_true_on_destruction)
+        /* This preserves the behaviour of the old system, but
+         * for all I know that might have been an oversight.
+         */
+        *((gboolean *)cursor->target) = TRUE;
+
+      return TRUE;
+    }
+
+  /* Check the type. */
+
+  if (value->type != MATECONF_VALUE_BOOL)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  /* We need to know whether the value changes, so
+   * store the current value away.
+   */
+
+  old_value = * ((gboolean *) cursor->target);
+  
+  /* Now look it up... */
+
+  *((gboolean *) cursor->target) = mateconf_value_get_bool (value);
+
+  /* Did it change?  If so, tell the listeners about it. */
+
+  if (old_value != *((gboolean *) cursor->target))
+    queue_changed (cursor->pref);
+
+  if (cursor->pref==META_PREF_DISABLE_WORKAROUNDS)
+    maybe_give_disable_workarounds_warning ();
+
+  return TRUE;
+}
+
+static gboolean
+handle_preference_update_string (const gchar *key, MateConfValue *value)
+{
+  MetaStringPreference *cursor = preferences_string;
+  const gchar *value_as_string;
+  gboolean inform_listeners = TRUE;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+
+  if (value==NULL)
+    return TRUE;
+
+  /* Check the type. */
+
+  if (value->type != MATECONF_VALUE_STRING)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  /* Docs: "The returned string is not a copy, don't try to free it." */
+  value_as_string = mateconf_value_get_string (value);
+
+  if (cursor->handler)
+    cursor->handler (cursor->pref, value_as_string, &inform_listeners);
+  else if (cursor->target)
+    {
+      if (*(cursor->target))
+        g_free(*(cursor->target));
+
+      if (value_as_string!=NULL)
+        *(cursor->target) = g_strdup (value_as_string);
+      else
+        *(cursor->target) = NULL;
+
+      inform_listeners =
+        (value_as_string==NULL && *(cursor->target)==NULL) ||
+        (value_as_string!=NULL && *(cursor->target)!=NULL &&
+         strcmp (value_as_string, *(cursor->target))==0);
+    }
+
+  if (inform_listeners)
+    queue_changed (cursor->pref);
+
+  return TRUE;
+}
+
+static gboolean
+handle_preference_update_int (const gchar *key, MateConfValue *value)
+{
+  MetaIntPreference *cursor = preferences_int;
+  gint new_value;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+
+  if (cursor->target==NULL)
+    /* No work for us to do. */
+    return TRUE;
+      
+  if (value==NULL)
+    {
+      /* Value was destroyed. */
+
+      if (cursor->value_if_destroyed != METAINTPREFERENCE_NO_CHANGE_ON_DESTROY)
+        *((gint *)cursor->target) = cursor->value_if_destroyed;
+
+      return TRUE;
+    }
+
+  /* Check the type. */
+
+  if (value->type != MATECONF_VALUE_INT)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  new_value = mateconf_value_get_int (value);
+
+  if (new_value < cursor->minimum || new_value > cursor->maximum)
+    {
+      meta_warning (_("%d stored in MateConf key %s is out of range %d to %d\n"),
+                    new_value, cursor->key,
+                    cursor->minimum, cursor->maximum);
+      return TRUE;
+    }
+
+  /* Did it change?  If so, tell the listeners about it. */
+
+  if (*cursor->target != new_value)
+    {
+      *cursor->target = new_value;
+      queue_changed (cursor->pref);
+    }
+
+  return TRUE;
+  
+}
+
+
+/****************************************************************************/
+/* Listeners.                                                               */
+/****************************************************************************/
+
+void
+meta_prefs_add_listener (MetaPrefsChangedFunc func,
+                         gpointer             data)
+{
+  MetaPrefsListener *l;
+
+  l = g_new (MetaPrefsListener, 1);
+  l->func = func;
+  l->data = data;
+
+  listeners = g_list_prepend (listeners, l);
+}
+
+void
+meta_prefs_remove_listener (MetaPrefsChangedFunc func,
+                            gpointer             data)
+{
+  GList *tmp;
+
+  tmp = listeners;
+  while (tmp != NULL)
+    {
+      MetaPrefsListener *l = tmp->data;
+
+      if (l->func == func &&
+          l->data == data)
+        {
+          g_free (l);
+          listeners = g_list_delete_link (listeners, tmp);
+
+          return;
+        }
+      
+      tmp = tmp->next;
+    }
+
+  meta_bug ("Did not find listener to remove\n");
+}
+
+static void
+emit_changed (MetaPreference pref)
+{
+  GList *tmp;
+  GList *copy;
+
+  meta_topic (META_DEBUG_PREFS, "Notifying listeners that pref %s changed\n",
+              meta_preference_to_string (pref));
+  
+  copy = g_list_copy (listeners);
+  
+  tmp = copy;
+
+  while (tmp != NULL)
+    {
+      MetaPrefsListener *l = tmp->data;
+
+      (* l->func) (pref, l->data);
+
+      tmp = tmp->next;
+    }
+
+  g_list_free (copy);
+}
+
+static gboolean
+changed_idle_handler (gpointer data)
+{
+  GList *tmp;
+  GList *copy;
+
+  changed_idle = 0;
+  
+  copy = g_list_copy (changes); /* reentrancy paranoia */
+
+  g_list_free (changes);
+  changes = NULL;
+  
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaPreference pref = GPOINTER_TO_INT (tmp->data);
+
+      emit_changed (pref);
+      
+      tmp = tmp->next;
+    }
+
+  g_list_free (copy);
+  
+  return FALSE;
+}
+
+static void
+queue_changed (MetaPreference pref)
+{
+  meta_topic (META_DEBUG_PREFS, "Queueing change of pref %s\n",
+              meta_preference_to_string (pref));  
+
+  if (g_list_find (changes, GINT_TO_POINTER (pref)) == NULL)
+    changes = g_list_prepend (changes, GINT_TO_POINTER (pref));
+  else
+    meta_topic (META_DEBUG_PREFS, "Change of pref %s was already pending\n",
+                meta_preference_to_string (pref));
+
+  /* add idle at priority below the mateconf notify idle */
+  if (changed_idle == 0)
+    changed_idle = g_idle_add_full (META_PRIORITY_PREFS_NOTIFY,
+                                    changed_idle_handler, NULL, NULL);
+}
+
+#else /* HAVE_MATECONF */
+
+void
+meta_prefs_add_listener (MetaPrefsChangedFunc func,
+                         gpointer             data)
+{
+  /* Nothing, because they have mateconf turned off */
+}
+
+void
+meta_prefs_remove_listener (MetaPrefsChangedFunc func,
+                            gpointer             data)
+{
+  /* Nothing, because they have mateconf turned off */
+}
+
+#endif /* HAVE_MATECONF */
+
+
+/****************************************************************************/
+/* Initialisation.                                                          */
+/****************************************************************************/
+
+#ifdef HAVE_MATECONF
+/* @@@ again, use glib's ability to tell you the size of the array */
+static gchar *mateconf_dirs_we_are_interested_in[] = {
+  "/apps/marco",
+  KEY_TERMINAL_DIR,
+  KEY_MATE_ACCESSIBILITY,
+  "/desktop/mate/peripherals/mouse",
+  "/desktop/mate/interface",
+  NULL,
+};
+#endif
+
+void
+meta_prefs_init (void)
+{
+#ifdef HAVE_MATECONF
+  GError *err = NULL;
+  gchar **mateconf_dir_cursor;
+  
+  if (default_client != NULL)
+    return;
+  
+  /* returns a reference which we hold forever */
+  default_client = mateconf_client_get_default ();
+
+  for (mateconf_dir_cursor=mateconf_dirs_we_are_interested_in;
+       *mateconf_dir_cursor!=NULL;
+       mateconf_dir_cursor++)
+    {
+      mateconf_client_add_dir (default_client,
+                            *mateconf_dir_cursor,
+                            MATECONF_CLIENT_PRELOAD_RECURSIVE,
+                            &err);
+      cleanup_error (&err);
+    }
+
+  /* Pick up initial values. */
+
+  handle_preference_init_enum ();
+  handle_preference_init_bool ();
+  handle_preference_init_string ();
+  handle_preference_init_int ();
+
+  /* @@@ Is there any reason we don't do the add_dir here? */
+  for (mateconf_dir_cursor=mateconf_dirs_we_are_interested_in;
+       *mateconf_dir_cursor!=NULL;
+       mateconf_dir_cursor++)
+    {
+      mateconf_client_notify_add (default_client,
+                               *mateconf_dir_cursor,
+                               change_notify,
+                               NULL,
+                               NULL,
+                               &err);
+      cleanup_error (&err);
+    }
+
+#else  /* HAVE_MATECONF */
+
+  /* Set defaults for some values that can't be set at initialization time of
+   * the static globals.  In the case of the theme, note that there is code
+   * elsewhere that will do everything possible to fallback to an existing theme
+   * if the one here does not exist.
+   */
+  titlebar_font = pango_font_description_from_string ("Sans Bold 10");
+  current_theme = g_strdup ("ClearlooksRe");
+  
+  init_button_layout();
+#endif /* HAVE_MATECONF */
+  
+  init_bindings ();
+  init_commands ();
+  init_workspace_names ();
+}
+
+
+/****************************************************************************/
+/* Updates.                                                                 */
+/****************************************************************************/
+
+#ifdef HAVE_MATECONF
+
+gboolean (*preference_update_handler[]) (const gchar*, MateConfValue*) = {
+  handle_preference_update_enum,
+  handle_preference_update_bool,
+  handle_preference_update_string,
+  handle_preference_update_int,
+  NULL
+};
+
+static void
+change_notify (MateConfClient    *client,
+               guint           cnxn_id,
+               MateConfEntry     *entry,
+               gpointer        user_data)
+{
+  const char *key;
+  MateConfValue *value;
+  gint i=0;
+  
+  key = mateconf_entry_get_key (entry);
+  value = mateconf_entry_get_value (entry);
+
+  /* First, search for a handler that might know what to do. */
+
+  /* FIXME: When this is all working, since the first item in every
+   * array is the gchar* of the key, there's no reason we can't
+   * find the correct record for that key here and save code duplication.
+   */
+
+  while (preference_update_handler[i]!=NULL)
+    {
+      if (preference_update_handler[i] (key, value))
+        goto out; /* Get rid of this eventually */
+
+      i++;
+    }
+  
+  if (g_str_has_prefix (key, KEY_WINDOW_BINDINGS_PREFIX) ||
+      g_str_has_prefix (key, KEY_SCREEN_BINDINGS_PREFIX))
+    {
+      if (g_str_has_suffix (key, KEY_LIST_BINDINGS_SUFFIX))
+        {
+          GSList *list;
+
+          if (value && value->type != MATECONF_VALUE_LIST)
+            {
+              meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                            key);
+              goto out;
+            }
+
+          list = value ? mateconf_value_get_list (value) : NULL;
+
+          if (update_key_list_binding (key, list))
+            queue_changed (META_PREF_KEYBINDINGS);
+        }
+      else
+        {
+          const char *str;
+
+          if (value && value->type != MATECONF_VALUE_STRING)
+            {
+              meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                            key);
+              goto out;
+            }
+
+          str = value ? mateconf_value_get_string (value) : NULL;
+
+          if (update_key_binding (key, str))
+            queue_changed (META_PREF_KEYBINDINGS);
+        }
+    }
+  else if (g_str_has_prefix (key, KEY_COMMAND_PREFIX))
+    {
+      const char *str;
+
+      if (value && value->type != MATECONF_VALUE_STRING)
+        {
+          meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                        key);
+          goto out;
+        }
+
+      str = value ? mateconf_value_get_string (value) : NULL;
+
+      if (update_command (key, str))
+        queue_changed (META_PREF_COMMANDS);
+    }
+  else if (g_str_has_prefix (key, KEY_WORKSPACE_NAME_PREFIX))
+    {
+      const char *str;
+
+      if (value && value->type != MATECONF_VALUE_STRING)
+        {
+          meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                        key);
+          goto out;
+        }
+
+      str = value ? mateconf_value_get_string (value) : NULL;
+
+      if (update_workspace_name (key, str))
+        queue_changed (META_PREF_WORKSPACE_NAMES);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_PREFS, "Key %s doesn't mean anything to Marco\n",
+                  key);
+    }
+  
+ out:
+  /* nothing */
+  return; /* AIX compiler wants something after a label like out: */
+}
+
+static void
+cleanup_error (GError **error)
+{
+  if (*error)
+    {
+      meta_warning ("%s\n", (*error)->message);
+      
+      g_error_free (*error);
+      *error = NULL;
+    }
+}
+
+/* get_bool returns TRUE if *val is filled in, FALSE otherwise */
+/* @@@ probably worth moving this inline; only used once */
+static gboolean
+get_bool (const char *key, gboolean *val)
+{
+  GError     *err = NULL;
+  MateConfValue *value;
+  gboolean    filled_in = FALSE;
+
+  value = mateconf_client_get (default_client, key, &err);
+  cleanup_error (&err);
+  if (value)
+    {
+      if (value->type == MATECONF_VALUE_BOOL)
+        {
+          *val = mateconf_value_get_bool (value);
+          filled_in = TRUE;
+        }
+      mateconf_value_free (value);
+    }
+
+  return filled_in;
+}
+
+/**
+ * Special case: give a warning the first time disable_workarounds
+ * is turned on.
+ */
+static void
+maybe_give_disable_workarounds_warning (void)
+{
+  static gboolean first_disable = TRUE;
+    
+  if (first_disable && disable_workarounds)
+    {
+      first_disable = FALSE;
+
+      meta_warning (_("Workarounds for broken applications disabled. "
+                      "Some applications may not behave properly.\n"));
+    }
+}
+
+#endif /* HAVE_MATECONF */
+
+MetaVirtualModifier
+meta_prefs_get_mouse_button_mods  (void)
+{
+  return mouse_button_mods;
+}
+
+MetaFocusMode
+meta_prefs_get_focus_mode (void)
+{
+  return focus_mode;
+}
+
+MetaFocusNewWindows
+meta_prefs_get_focus_new_windows (void)
+{
+  return focus_new_windows;
+}
+
+gboolean
+meta_prefs_get_raise_on_click (void)
+{
+  /* Force raise_on_click on for click-to-focus, as requested by Havoc
+   * in #326156.
+   */
+  return raise_on_click || focus_mode == META_FOCUS_MODE_CLICK;
+}
+
+const char*
+meta_prefs_get_theme (void)
+{
+  return current_theme;
+}
+
+const char*
+meta_prefs_get_cursor_theme (void)
+{
+  return cursor_theme;
+}
+
+int
+meta_prefs_get_cursor_size (void)
+{
+  return cursor_size;
+}
+
+
+/****************************************************************************/
+/* Handlers for string preferences.                                         */
+/****************************************************************************/
+
+#ifdef HAVE_MATECONF
+
+static void
+titlebar_handler (MetaPreference pref,
+                  const gchar    *string_value,
+                  gboolean       *inform_listeners)
+{
+  PangoFontDescription *new_desc = NULL;
+
+  if (string_value)
+    new_desc = pango_font_description_from_string (string_value);
+
+  if (new_desc == NULL)
+    {
+      meta_warning (_("Could not parse font description "
+                      "\"%s\" from MateConf key %s\n"),
+                    string_value ? string_value : "(null)",
+                    KEY_TITLEBAR_FONT);
+
+      *inform_listeners = FALSE;
+
+      return;
+    }
+
+  /* Is the new description the same as the old? */
+
+  if (titlebar_font &&
+      pango_font_description_equal (new_desc, titlebar_font))
+    {
+      pango_font_description_free (new_desc);
+      *inform_listeners = FALSE;
+      return;
+    }
+
+  /* No, so free the old one and put ours in instead. */
+
+  if (titlebar_font)
+    pango_font_description_free (titlebar_font);
+
+  titlebar_font = new_desc;
+
+}
+
+static void
+theme_name_handler (MetaPreference pref,
+                    const gchar *string_value,
+                    gboolean *inform_listeners)
+{
+  g_free (current_theme);
+
+  /* Fallback crackrock */
+  if (string_value == NULL)
+    current_theme = g_strdup ("ClearlooksRe");
+  else
+    current_theme = g_strdup (string_value);
+}
+
+static void
+mouse_button_mods_handler (MetaPreference pref,
+                           const gchar *string_value,
+                           gboolean *inform_listeners)
+{
+  MetaVirtualModifier mods;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Mouse button modifier has new mateconf value \"%s\"\n",
+              string_value);
+  if (string_value && meta_ui_parse_modifier (string_value, &mods))
+    {
+      mouse_button_mods = mods;
+    }
+  else
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Failed to parse new mateconf value\n");
+          
+      meta_warning (_("\"%s\" found in configuration database is "
+                      "not a valid value for mouse button modifier\n"),
+                    string_value);
+
+      *inform_listeners = FALSE;
+    }
+}
+
+static gboolean
+button_layout_equal (const MetaButtonLayout *a,
+                     const MetaButtonLayout *b)
+{  
+  int i;
+
+  i = 0;
+  while (i < MAX_BUTTONS_PER_CORNER)
+    {
+      if (a->left_buttons[i] != b->left_buttons[i])
+        return FALSE;
+      if (a->right_buttons[i] != b->right_buttons[i])
+        return FALSE;
+      if (a->left_buttons_has_spacer[i] != b->left_buttons_has_spacer[i])
+        return FALSE;
+      if (a->right_buttons_has_spacer[i] != b->right_buttons_has_spacer[i])
+        return FALSE;
+      ++i;
+    }
+
+  return TRUE;
+}
+
+static MetaButtonFunction
+button_function_from_string (const char *str)
+{
+  /* FIXME: mateconf_string_to_enum is the obvious way to do this */
+
+  if (strcmp (str, "menu") == 0)
+    return META_BUTTON_FUNCTION_MENU;
+  else if (strcmp (str, "minimize") == 0)
+    return META_BUTTON_FUNCTION_MINIMIZE;
+  else if (strcmp (str, "maximize") == 0)
+    return META_BUTTON_FUNCTION_MAXIMIZE;
+  else if (strcmp (str, "close") == 0)
+    return META_BUTTON_FUNCTION_CLOSE;
+  else if (strcmp (str, "shade") == 0)
+    return META_BUTTON_FUNCTION_SHADE;
+  else if (strcmp (str, "above") == 0)
+    return META_BUTTON_FUNCTION_ABOVE;
+  else if (strcmp (str, "stick") == 0)
+    return META_BUTTON_FUNCTION_STICK;
+  else 
+    /* don't know; give up */
+    return META_BUTTON_FUNCTION_LAST;
+}
+
+static MetaButtonFunction
+button_opposite_function (MetaButtonFunction ofwhat)
+{
+  switch (ofwhat)
+    {
+    case META_BUTTON_FUNCTION_SHADE:
+      return META_BUTTON_FUNCTION_UNSHADE;
+    case META_BUTTON_FUNCTION_UNSHADE:
+      return META_BUTTON_FUNCTION_SHADE;
+
+    case META_BUTTON_FUNCTION_ABOVE:
+      return META_BUTTON_FUNCTION_UNABOVE;
+    case META_BUTTON_FUNCTION_UNABOVE:
+      return META_BUTTON_FUNCTION_ABOVE;
+
+    case META_BUTTON_FUNCTION_STICK:
+      return META_BUTTON_FUNCTION_UNSTICK;
+    case META_BUTTON_FUNCTION_UNSTICK:
+      return META_BUTTON_FUNCTION_STICK;
+
+    default:
+      return META_BUTTON_FUNCTION_LAST;
+    }
+}
+
+static void
+button_layout_handler (MetaPreference pref,
+                         const gchar *string_value,
+                         gboolean *inform_listeners)
+{
+  MetaButtonLayout new_layout;
+  char **sides = NULL;
+  int i;
+  
+  /* We need to ignore unknown button functions, for
+   * compat with future versions
+   */
+  
+  if (string_value)
+    sides = g_strsplit (string_value, ":", 2);
+
+  if (sides != NULL && sides[0] != NULL)
+    {
+      char **buttons;
+      int b;
+      gboolean used[META_BUTTON_FUNCTION_LAST];
+
+      i = 0;
+      while (i < META_BUTTON_FUNCTION_LAST)
+        {
+          used[i] = FALSE;
+          new_layout.left_buttons_has_spacer[i] = FALSE;
+          ++i;
+        }
+      
+      buttons = g_strsplit (sides[0], ",", -1);
+      i = 0;
+      b = 0;
+      while (buttons[b] != NULL)
+        {
+          MetaButtonFunction f = button_function_from_string (buttons[b]);
+          if (i > 0 && strcmp("spacer", buttons[b]) == 0)
+            {
+              new_layout.left_buttons_has_spacer[i-1] = TRUE;
+              f = button_opposite_function (f);
+
+              if (f != META_BUTTON_FUNCTION_LAST)
+                {
+                  new_layout.left_buttons_has_spacer[i-2] = TRUE;
+                }
+            }
+          else
+            {
+              if (f != META_BUTTON_FUNCTION_LAST && !used[f])
+                {
+                  new_layout.left_buttons[i] = f;
+                  used[f] = TRUE;
+                  ++i;
+
+                  f = button_opposite_function (f);
+
+                  if (f != META_BUTTON_FUNCTION_LAST)
+                      new_layout.left_buttons[i++] = f;
+
+                }
+              else
+                {
+                  meta_topic (META_DEBUG_PREFS, "Ignoring unknown or already-used button name \"%s\"\n",
+                              buttons[b]);
+                }
+            }
+          
+          ++b;
+        }
+
+      new_layout.left_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      new_layout.left_buttons_has_spacer[i] = FALSE;
+      
+      g_strfreev (buttons);
+    }
+
+  if (sides != NULL && sides[0] != NULL && sides[1] != NULL)
+    {
+      char **buttons;
+      int b;
+      gboolean used[META_BUTTON_FUNCTION_LAST];
+
+      i = 0;
+      while (i < META_BUTTON_FUNCTION_LAST)
+        {
+          used[i] = FALSE;
+          new_layout.right_buttons_has_spacer[i] = FALSE;
+          ++i;
+        }
+      
+      buttons = g_strsplit (sides[1], ",", -1);
+      i = 0;
+      b = 0;
+      while (buttons[b] != NULL)
+        {
+          MetaButtonFunction f = button_function_from_string (buttons[b]);
+          if (i > 0 && strcmp("spacer", buttons[b]) == 0)
+            {
+              new_layout.right_buttons_has_spacer[i-1] = TRUE;
+              f = button_opposite_function (f);
+              if (f != META_BUTTON_FUNCTION_LAST)
+                {
+                  new_layout.right_buttons_has_spacer[i-2] = TRUE;
+                }
+            }
+          else
+            {
+              if (f != META_BUTTON_FUNCTION_LAST && !used[f])
+                {
+                  new_layout.right_buttons[i] = f;
+                  used[f] = TRUE;
+                  ++i;
+
+                  f = button_opposite_function (f);
+
+                  if (f != META_BUTTON_FUNCTION_LAST)
+                      new_layout.right_buttons[i++] = f;
+
+                }
+              else
+                {
+                  meta_topic (META_DEBUG_PREFS, "Ignoring unknown or already-used button name \"%s\"\n",
+                              buttons[b]);
+                }
+            }
+          
+          ++b;
+        }
+
+      new_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      new_layout.right_buttons_has_spacer[i] = FALSE;
+      
+      g_strfreev (buttons);
+    }
+
+  g_strfreev (sides);
+  
+  /* Invert the button layout for RTL languages */
+  if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+  {
+    MetaButtonLayout rtl_layout;
+    int j;
+    
+    for (i = 0; new_layout.left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
+    for (j = 0; j < i; j++)
+      {
+        rtl_layout.right_buttons[j] = new_layout.left_buttons[i - j - 1];
+        if (j == 0)
+          rtl_layout.right_buttons_has_spacer[i - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
+        else
+          rtl_layout.right_buttons_has_spacer[j - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
+      }
+    rtl_layout.right_buttons[j] = META_BUTTON_FUNCTION_LAST;
+    rtl_layout.right_buttons_has_spacer[j] = FALSE;
+      
+    for (i = 0; new_layout.right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
+    for (j = 0; j < i; j++)
+      {
+        rtl_layout.left_buttons[j] = new_layout.right_buttons[i - j - 1];
+        if (j == 0)
+          rtl_layout.left_buttons_has_spacer[i - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
+        else
+          rtl_layout.left_buttons_has_spacer[j - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
+      }
+    rtl_layout.left_buttons[j] = META_BUTTON_FUNCTION_LAST;
+    rtl_layout.left_buttons_has_spacer[j] = FALSE;
+
+    new_layout = rtl_layout;
+  }
+  
+  if (button_layout_equal (&button_layout, &new_layout))
+    {
+      /* Same as before, so duck out */
+      *inform_listeners = FALSE;
+    }
+  else
+    {
+      button_layout = new_layout;
+    }
+}
+
+#endif /* HAVE_MATECONF */
+
+const PangoFontDescription*
+meta_prefs_get_titlebar_font (void)
+{
+  if (use_system_font)
+    return NULL;
+  else
+    return titlebar_font;
+}
+
+int
+meta_prefs_get_num_workspaces (void)
+{
+  return num_workspaces;
+}
+
+gboolean
+meta_prefs_get_application_based (void)
+{
+  return FALSE; /* For now, we never want this to do anything */
+  
+  return application_based;
+}
+
+gboolean
+meta_prefs_get_disable_workarounds (void)
+{
+  return disable_workarounds;
+}
+
+#ifdef HAVE_MATECONF
+#define MAX_REASONABLE_AUTO_RAISE_DELAY 10000
+  
+#endif /* HAVE_MATECONF */
+
+#ifdef WITH_VERBOSE_MODE
+const char*
+meta_preference_to_string (MetaPreference pref)
+{
+  /* FIXME: another case for mateconf_string_to_enum */
+  switch (pref)
+    {
+    case META_PREF_MOUSE_BUTTON_MODS:
+      return "MOUSE_BUTTON_MODS";
+
+    case META_PREF_FOCUS_MODE:
+      return "FOCUS_MODE";
+
+    case META_PREF_FOCUS_NEW_WINDOWS:
+      return "FOCUS_NEW_WINDOWS";
+
+    case META_PREF_RAISE_ON_CLICK:
+      return "RAISE_ON_CLICK";
+      
+    case META_PREF_THEME:
+      return "THEME";
+
+    case META_PREF_TITLEBAR_FONT:
+      return "TITLEBAR_FONT";
+
+    case META_PREF_NUM_WORKSPACES:
+      return "NUM_WORKSPACES";
+
+    case META_PREF_APPLICATION_BASED:
+      return "APPLICATION_BASED";
+
+    case META_PREF_KEYBINDINGS:
+      return "KEYBINDINGS";
+
+    case META_PREF_DISABLE_WORKAROUNDS:
+      return "DISABLE_WORKAROUNDS";
+
+    case META_PREF_ACTION_DOUBLE_CLICK_TITLEBAR:
+      return "ACTION_DOUBLE_CLICK_TITLEBAR";
+
+    case META_PREF_ACTION_MIDDLE_CLICK_TITLEBAR:
+      return "ACTION_MIDDLE_CLICK_TITLEBAR";
+
+    case META_PREF_ACTION_RIGHT_CLICK_TITLEBAR:
+      return "ACTION_RIGHT_CLICK_TITLEBAR";
+
+    case META_PREF_AUTO_RAISE:
+      return "AUTO_RAISE";
+      
+    case META_PREF_AUTO_RAISE_DELAY:
+      return "AUTO_RAISE_DELAY";
+
+    case META_PREF_COMMANDS:
+      return "COMMANDS";
+
+    case META_PREF_TERMINAL_COMMAND:
+      return "TERMINAL_COMMAND";
+
+    case META_PREF_BUTTON_LAYOUT:
+      return "BUTTON_LAYOUT";
+
+    case META_PREF_WORKSPACE_NAMES:
+      return "WORKSPACE_NAMES";
+
+    case META_PREF_VISUAL_BELL:
+      return "VISUAL_BELL";
+
+    case META_PREF_AUDIBLE_BELL:
+      return "AUDIBLE_BELL";
+
+    case META_PREF_VISUAL_BELL_TYPE:
+      return "VISUAL_BELL_TYPE";
+
+    case META_PREF_REDUCED_RESOURCES:
+      return "REDUCED_RESOURCES";
+
+    case META_PREF_MATE_ACCESSIBILITY:
+      return "MATE_ACCESSIBILTY";
+
+    case META_PREF_MATE_ANIMATIONS:
+      return "MATE_ANIMATIONS";
+
+    case META_PREF_CURSOR_THEME:
+      return "CURSOR_THEME";
+
+    case META_PREF_CURSOR_SIZE:
+      return "CURSOR_SIZE";
+
+    case META_PREF_COMPOSITING_MANAGER:
+      return "COMPOSITING_MANAGER";
+
+    case META_PREF_RESIZE_WITH_RIGHT_BUTTON:
+      return "RESIZE_WITH_RIGHT_BUTTON";
+
+    case META_PREF_FORCE_FULLSCREEN:
+      return "FORCE_FULLSCREEN";
+    }
+
+  return "(unknown)";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+void
+meta_prefs_set_num_workspaces (int n_workspaces)
+{
+#ifdef HAVE_MATECONF
+  GError *err;
+  
+  if (default_client == NULL)
+    return;
+
+  if (n_workspaces < 1)
+    n_workspaces = 1;
+  if (n_workspaces > MAX_REASONABLE_WORKSPACES)
+    n_workspaces = MAX_REASONABLE_WORKSPACES;
+  
+  err = NULL;
+  mateconf_client_set_int (default_client,
+                        KEY_NUM_WORKSPACES,
+                        n_workspaces,
+                        &err);
+
+  if (err)
+    {
+      meta_warning (_("Error setting number of workspaces to %d: %s\n"),
+                    num_workspaces,
+                    err->message);
+      g_error_free (err);
+    }
+#endif /* HAVE_MATECONF */
+}
+
+#define keybind(name, handler, param, flags, stroke, description) \
+  { #name, NULL, !!(flags & BINDING_REVERSES), !!(flags & BINDING_PER_WINDOW) },
+static MetaKeyPref key_bindings[] = {
+#include "all-keybindings.h"
+  { NULL, NULL, FALSE }
+};
+#undef keybind
+
+#ifndef HAVE_MATECONF
+
+/**
+ * A type to map names of keybindings (such as "switch_windows")
+ * to the binding strings themselves (such as "<Alt>Tab").
+ * It exists only when MateConf is turned off in ./configure and
+ * functions as a sort of ersatz MateConf.
+ */
+typedef struct
+{
+  const char *name;
+  const char *keybinding;
+} MetaSimpleKeyMapping;
+
+/* FIXME: This would be neater if the array only contained entries whose
+ * default keystroke was non-null.  You COULD do this by defining
+ * ONLY_BOUND_BY_DEFAULT around various blocks at the cost of making
+ * the bindings file way more complicated.  However, we could stop this being
+ * data and move it into code.  Then the compiler would optimise away
+ * the problem lines.
+ */
+
+#define keybind(name, handler, param, flags, stroke, description) \
+  { #name, stroke },
+
+static MetaSimpleKeyMapping key_string_bindings[] = {
+#include "all-keybindings.h"
+  { NULL, NULL }
+};
+#undef keybind
+
+#endif /* NOT HAVE_MATECONF */
+
+static void
+init_bindings (void)
+{
+#ifdef HAVE_MATECONF
+  const char *prefix[] = {
+    KEY_WINDOW_BINDINGS_PREFIX,
+    KEY_SCREEN_BINDINGS_PREFIX,
+    NULL
+  };
+  int i;
+  GSList *list, *l, *list_val;
+  const char *str_val;
+  const char *key;
+  MateConfEntry *entry;
+  MateConfValue *value;
+
+  for (i = 0; prefix[i]; i++)
+    {
+      list = mateconf_client_all_entries (default_client, prefix[i], NULL);
+      for (l = list; l; l = l->next)
+        {
+          entry = l->data;
+          key = mateconf_entry_get_key (entry);
+          value = mateconf_entry_get_value (entry);
+          if (g_str_has_suffix (key, KEY_LIST_BINDINGS_SUFFIX))
+            {
+              list_val = mateconf_client_get_list (default_client, key, MATECONF_VALUE_STRING, NULL);
+ 
+              update_key_list_binding (key, list_val);
+              g_slist_foreach (list_val, (GFunc)g_free, NULL);
+              g_slist_free (list_val);
+            }
+          else
+            {
+              str_val = mateconf_value_get_string (value);
+              update_key_binding (key, str_val);
+            }
+          mateconf_entry_free (entry);
+        }
+      g_slist_free (list);
+    }
+#else /* HAVE_MATECONF */
+  int i = 0;
+  int which = 0;
+  while (key_string_bindings[i].name)
+    {
+      if (key_string_bindings[i].keybinding == NULL) {
+        ++i;
+        continue;
+      }
+    
+      while (strcmp(key_bindings[which].name, 
+                    key_string_bindings[i].name) != 0)
+        which++;
+
+      /* Set the binding */
+      update_binding (&key_bindings[which], 
+                      key_string_bindings[i].keybinding);
+
+      ++i;
+    }
+#endif /* HAVE_MATECONF */
+}
+
+static void
+init_commands (void)
+{
+#ifdef HAVE_MATECONF
+  GSList *list, *l;
+  const char *str_val;
+  const char *key;
+  MateConfEntry *entry;
+  MateConfValue *value;
+
+  list = mateconf_client_all_entries (default_client, KEY_COMMAND_DIRECTORY, NULL);
+  for (l = list; l; l = l->next)
+    {
+      entry = l->data;
+      key = mateconf_entry_get_key (entry);
+      value = mateconf_entry_get_value (entry);
+      str_val = mateconf_value_get_string (value);
+      update_command (key, str_val);
+      mateconf_entry_free (entry);
+    }
+  g_slist_free (list);
+#else
+  int i;
+  for (i = 0; i < MAX_COMMANDS; i++)
+    commands[i] = NULL;
+#endif /* HAVE_MATECONF */
+}
+
+static void
+init_workspace_names (void)
+{
+#ifdef HAVE_MATECONF
+  GSList *list, *l;
+  const char *str_val;
+  const char *key;
+  MateConfEntry *entry;
+  MateConfValue *value;
+
+  list = mateconf_client_all_entries (default_client, KEY_WORKSPACE_NAME_DIRECTORY, NULL);
+  for (l = list; l; l = l->next)
+    {
+      entry = l->data;
+      key = mateconf_entry_get_key (entry);
+      value = mateconf_entry_get_value (entry);
+      str_val = mateconf_value_get_string (value);
+      update_workspace_name (key, str_val);
+      mateconf_entry_free (entry);
+    }
+  g_slist_free (list);
+#else
+  int i;
+  for (i = 0; i < MAX_REASONABLE_WORKSPACES; i++)
+    workspace_names[i] = g_strdup_printf (_("Workspace %d"), i + 1);
+
+  meta_topic (META_DEBUG_PREFS,
+              "Initialized workspace names\n");
+#endif /* HAVE_MATECONF */
+}
+
+static gboolean
+update_binding (MetaKeyPref *binding,
+                const char  *value)
+{
+  unsigned int keysym;
+  unsigned int keycode;
+  MetaVirtualModifier mods;
+  MetaKeyCombo *combo;
+  gboolean changed;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Binding \"%s\" has new mateconf value \"%s\"\n",
+              binding->name, value ? value : "none");
+  
+  keysym = 0;
+  keycode = 0;
+  mods = 0;
+  if (value)
+    {
+      if (!meta_ui_parse_accelerator (value, &keysym, &keycode, &mods))
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Failed to parse new mateconf value\n");
+          meta_warning (_("\"%s\" found in configuration database is not a valid value for keybinding \"%s\"\n"),
+                        value, binding->name);
+
+          return FALSE;
+        }
+    }
+
+  /* If there isn't already a first element, make one. */
+  if (!binding->bindings)
+    {
+      MetaKeyCombo *blank = g_malloc0 (sizeof (MetaKeyCombo));
+      binding->bindings = g_slist_alloc();
+      binding->bindings->data = blank;
+    }
+  
+   combo = binding->bindings->data;
+
+#ifdef HAVE_MATECONF
+   /* Bug 329676: Bindings which can be shifted must not have no modifiers,
+    * nor only SHIFT as a modifier.
+    */
+
+  if (binding->add_shift &&
+      0 != keysym &&
+      (META_VIRTUAL_SHIFT_MASK == mods || 0 == mods))
+    {
+      gchar *old_setting;
+      gchar *key;
+      GError *err = NULL;
+      
+      meta_warning ("Cannot bind \"%s\" to %s: it needs a modifier "
+                    "such as Ctrl or Alt.\n",
+                    binding->name,
+                    value);
+
+      old_setting = meta_ui_accelerator_name (combo->keysym,
+                                              combo->modifiers);
+
+      if (!strcmp(old_setting, value))
+        {
+          /* We were about to set it to the same value
+           * that it had originally! This must be caused
+           * by getting an invalid string back from
+           * meta_ui_accelerator_name. Bail out now
+           * so we don't get into an infinite loop.
+           */
+           g_free (old_setting);
+           return TRUE;
+        }
+
+      meta_warning ("Reverting \"%s\" to %s.\n",
+                    binding->name,
+                    old_setting);
+
+      /* FIXME: add_shift is currently screen_bindings only, but
+       * there's no really good reason it should always be.
+       * So we shouldn't blindly add KEY_SCREEN_BINDINGS_PREFIX
+       * onto here.
+       */
+      key = g_strconcat (KEY_SCREEN_BINDINGS_PREFIX, "/",
+                         binding->name, NULL);
+      
+      mateconf_client_set_string (mateconf_client_get_default (),
+                               key, old_setting, &err);
+
+      if (err)
+        {
+          meta_warning ("Error while reverting keybinding: %s\n",
+                        err->message);
+          g_error_free (err);
+          err = NULL;
+        }
+      
+      g_free (old_setting);
+      g_free (key);
+
+      /* The call to mateconf_client_set_string() will cause this function
+       * to be called again with the new value, so there's no need to
+       * carry on.
+       */
+      return TRUE;
+    }
+#endif
+  
+  changed = FALSE;
+  if (keysym != combo->keysym ||
+      keycode != combo->keycode ||
+      mods != combo->modifiers)
+    {
+      changed = TRUE;
+      
+      combo->keysym = keysym;
+      combo->keycode = keycode;
+      combo->modifiers = mods;
+      
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "New keybinding for \"%s\" is keysym = 0x%x keycode = 0x%x mods = 0x%x\n",
+                  binding->name, combo->keysym, combo->keycode,
+                  combo->modifiers);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Keybinding for \"%s\" is unchanged\n", binding->name);
+    }
+  
+  return changed;
+}
+
+#ifdef HAVE_MATECONF
+static gboolean
+update_list_binding (MetaKeyPref *binding,
+                     GSList      *value,
+                     MetaStringListType type_of_value)
+{
+  unsigned int keysym;
+  unsigned int keycode;
+  MetaVirtualModifier mods;
+  gboolean changed = FALSE;
+  const gchar *pref_string;
+  GSList *pref_iterator = value, *tmp;
+  MetaKeyCombo *combo;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Binding \"%s\" has new mateconf value\n",
+              binding->name);
+  
+  if (binding->bindings == NULL)
+    {
+      /* We need to insert a dummy element into the list, because the first
+       * element is the one governed by update_binding. We only handle the
+       * subsequent elements.
+       */
+      MetaKeyCombo *blank = g_malloc0 (sizeof (MetaKeyCombo));
+      binding->bindings = g_slist_alloc();
+      binding->bindings->data = blank;
+    }
+       
+  /* Okay, so, we're about to provide a new list of key combos for this
+   * action. Delete any pre-existing list.
+   */
+  tmp = binding->bindings->next;
+  while (tmp)
+    {
+      g_free (tmp->data);
+      tmp = tmp->next;
+    }
+  g_slist_free (binding->bindings->next);
+  binding->bindings->next = NULL;
+  
+  while (pref_iterator)
+    {
+      keysym = 0;
+      keycode = 0;
+      mods = 0;
+
+      if (!pref_iterator->data)
+        {
+          pref_iterator = pref_iterator->next;
+          continue;
+        }
+
+      switch (type_of_value)
+        {
+        case META_LIST_OF_STRINGS:
+          pref_string = pref_iterator->data;
+          break;
+        case META_LIST_OF_MATECONFVALUE_STRINGS:
+          pref_string = mateconf_value_get_string (pref_iterator->data);
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+      
+      if (!meta_ui_parse_accelerator (pref_string, &keysym, &keycode, &mods))
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Failed to parse new mateconf value\n");
+          meta_warning (_("\"%s\" found in configuration database is not a valid value for keybinding \"%s\"\n"),
+                        pref_string, binding->name);
+
+          /* Should we remove this value from the list in mateconf? */
+          pref_iterator = pref_iterator->next;
+          continue;
+        }
+
+      /* Bug 329676: Bindings which can be shifted must not have no modifiers,
+       * nor only SHIFT as a modifier.
+       */
+
+      if (binding->add_shift &&
+          0 != keysym &&
+          (META_VIRTUAL_SHIFT_MASK == mods || 0 == mods))
+        {
+          meta_warning ("Cannot bind \"%s\" to %s: it needs a modifier "
+                        "such as Ctrl or Alt.\n",
+                        binding->name,
+                        pref_string);
+
+          /* Should we remove this value from the list in mateconf? */
+
+          pref_iterator = pref_iterator->next;
+          continue;
+        }
+  
+      changed = TRUE;
+
+      combo = g_malloc0 (sizeof (MetaKeyCombo));
+      combo->keysym = keysym;
+      combo->keycode = keycode;
+      combo->modifiers = mods;
+      binding->bindings->next = g_slist_prepend (binding->bindings->next, combo);
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                      "New keybinding for \"%s\" is keysym = 0x%x keycode = 0x%x mods = 0x%x\n",
+                      binding->name, keysym, keycode, mods);
+
+      pref_iterator = pref_iterator->next;
+    }  
+  return changed;
+}
+
+static const gchar*
+relative_key (const gchar* key)
+{
+  const gchar* end;
+  
+  end = strrchr (key, '/');
+
+  ++end;
+
+  return end;
+}
+
+/* Return value is TRUE if a preference changed and we need to
+ * notify
+ */
+static gboolean
+find_and_update_binding (MetaKeyPref *bindings, 
+                         const char  *name,
+                         const char  *value)
+{
+  const char *key;
+  int i;
+  
+  if (*name == '/')
+    key = relative_key (name);
+  else
+    key = name;
+
+  i = 0;
+  while (bindings[i].name &&
+         strcmp (key, bindings[i].name) != 0)
+    ++i;
+
+  if (bindings[i].name)
+    return update_binding (&bindings[i], value);
+  else
+    return FALSE;
+}
+
+static gboolean
+update_key_binding (const char *name,
+                       const char *value)
+{
+  return find_and_update_binding (key_bindings, name, value);
+}
+
+static gboolean
+find_and_update_list_binding (MetaKeyPref *bindings,
+                              const char  *name,
+                              GSList      *value)
+{
+  const char *key;
+  int i;
+  gchar *name_without_suffix = g_strdup(name);
+
+  name_without_suffix[strlen(name_without_suffix) - strlen(KEY_LIST_BINDINGS_SUFFIX)] = 0;
+
+  if (*name_without_suffix == '/')
+    key = relative_key (name_without_suffix);
+  else
+    key = name_without_suffix;
+
+  i = 0;
+  while (bindings[i].name &&
+         strcmp (key, bindings[i].name) != 0)
+    ++i;
+
+  g_free (name_without_suffix);
+
+  if (bindings[i].name)
+    return update_list_binding (&bindings[i], value, META_LIST_OF_MATECONFVALUE_STRINGS);
+  else
+    return FALSE;
+}
+
+static gboolean
+update_key_list_binding (const char *name,
+                            GSList *value)
+{
+  return find_and_update_list_binding (key_bindings, name, value);
+}
+
+static gboolean
+update_command (const char  *name,
+                const char  *value)
+{
+  char *p;
+  int i;
+  
+  p = strrchr (name, '_');
+  if (p == NULL)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Command %s has no underscore?\n", name);
+      return FALSE;
+    }
+  
+  ++p;
+
+  if (g_ascii_isdigit (*p))
+    {
+      i = atoi (p);
+      i -= 1; /* count from 0 not 1 */
+    }
+  else
+    {
+      p = strrchr (name, '/');
+      ++p;
+
+      if (strcmp (p, "command_screenshot") == 0)
+        {
+          i = SCREENSHOT_COMMAND_IDX;
+        }
+      else if (strcmp (p, "command_window_screenshot") == 0)
+        {
+          i = WIN_SCREENSHOT_COMMAND_IDX;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Command %s doesn't end in number?\n", name);
+          return FALSE;
+        }
+    }
+  
+  if (i >= MAX_COMMANDS)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Command %d is too highly numbered, ignoring\n", i);
+      return FALSE;
+    }
+
+  if ((commands[i] == NULL && value == NULL) ||
+      (commands[i] && value && strcmp (commands[i], value) == 0))
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Command %d is unchanged\n", i);
+      return FALSE;
+    }
+  
+  g_free (commands[i]);
+  commands[i] = g_strdup (value);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Updated command %d to \"%s\"\n",
+              i, commands[i] ? commands[i] : "none");
+  
+  return TRUE;
+}
+
+#endif /* HAVE_MATECONF */
+
+const char*
+meta_prefs_get_command (int i)
+{
+  g_return_val_if_fail (i >= 0 && i < MAX_COMMANDS, NULL);
+  
+  return commands[i];
+}
+
+char*
+meta_prefs_get_mateconf_key_for_command (int i)
+{
+  char *key;
+
+  switch (i)
+    {
+    case SCREENSHOT_COMMAND_IDX:
+      key = g_strdup (KEY_COMMAND_PREFIX "screenshot");
+      break;
+    case WIN_SCREENSHOT_COMMAND_IDX:
+      key = g_strdup (KEY_COMMAND_PREFIX "window_screenshot");
+      break;
+    default:
+      key = g_strdup_printf (KEY_COMMAND_PREFIX"%d", i + 1);
+      break;
+    }
+  
+  return key;
+}
+
+const char*
+meta_prefs_get_terminal_command (void)
+{
+  return terminal_command;
+}
+
+const char*
+meta_prefs_get_mateconf_key_for_terminal_command (void)
+{
+  return KEY_TERMINAL_COMMAND;
+}
+
+#ifdef HAVE_MATECONF
+static gboolean
+update_workspace_name (const char  *name,
+                       const char  *value)
+{
+  char *p;
+  int i;
+  
+  p = strrchr (name, '_');
+  if (p == NULL)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %s has no underscore?\n", name);
+      return FALSE;
+    }
+  
+  ++p;
+
+  if (!g_ascii_isdigit (*p))
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %s doesn't end in number?\n", name);
+      return FALSE;
+    }
+  
+  i = atoi (p);
+  i -= 1; /* count from 0 not 1 */
+  
+  if (i >= MAX_REASONABLE_WORKSPACES)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %d is too highly numbered, ignoring\n", i);
+      return FALSE;
+    }
+
+  if (workspace_names[i] && value && strcmp (workspace_names[i], value) == 0)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %d is unchanged\n", i);
+      return FALSE;
+    }  
+
+  /* This is a bad hack. We have to treat empty string as
+   * "unset" because the root window property can't contain
+   * null. So it gets empty string instead and we don't want
+   * that to result in setting the empty string as a value that
+   * overrides "unset".
+   */
+  if (value != NULL && *value != '\0')
+    {
+      g_free (workspace_names[i]);
+      workspace_names[i] = g_strdup (value);
+    }
+  else
+    {
+      /* use a default name */
+      char *d;
+
+      d = g_strdup_printf (_("Workspace %d"), i + 1);
+      if (workspace_names[i] && strcmp (workspace_names[i], d) == 0)
+        {
+          g_free (d);
+          return FALSE;
+        }
+      else
+        {
+          g_free (workspace_names[i]);
+          workspace_names[i] = d;
+        }
+    }
+  
+  meta_topic (META_DEBUG_PREFS,
+              "Updated workspace name %d to \"%s\"\n",
+              i, workspace_names[i] ? workspace_names[i] : "none");
+  
+  return TRUE;
+}
+#endif /* HAVE_MATECONF */
+
+const char*
+meta_prefs_get_workspace_name (int i)
+{
+  g_return_val_if_fail (i >= 0 && i < MAX_REASONABLE_WORKSPACES, NULL);
+
+  g_assert (workspace_names[i] != NULL);
+
+  meta_topic (META_DEBUG_PREFS,
+              "Getting workspace name for %d: \"%s\"\n",
+              i, workspace_names[i]);
+  
+  return workspace_names[i];
+}
+
+void
+meta_prefs_change_workspace_name (int         i,
+                                  const char *name)
+{
+#ifdef HAVE_MATECONF
+  char *key;
+  GError *err;
+  
+  g_return_if_fail (i >= 0 && i < MAX_REASONABLE_WORKSPACES);
+
+  meta_topic (META_DEBUG_PREFS,
+              "Changing name of workspace %d to %s\n",
+              i, name ? name : "none");
+
+  /* This is a bad hack. We have to treat empty string as
+   * "unset" because the root window property can't contain
+   * null. So it gets empty string instead and we don't want
+   * that to result in setting the empty string as a value that
+   * overrides "unset".
+   */
+  if (name && *name == '\0')
+    name = NULL;
+  
+  if ((name == NULL && workspace_names[i] == NULL) ||
+      (name && workspace_names[i] && strcmp (name, workspace_names[i]) == 0))
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace %d already has name %s\n",
+                  i, name ? name : "none");
+      return;
+    }
+  
+  key = mateconf_key_for_workspace_name (i);
+
+  err = NULL;
+  if (name != NULL)
+    mateconf_client_set_string (default_client,
+                             key, name,
+                             &err);
+  else
+    mateconf_client_unset (default_client,
+                        key, &err);
+
+  
+  if (err)
+    {
+      meta_warning (_("Error setting name for workspace %d to \"%s\": %s\n"),
+                    i, name ? name : "none",
+                    err->message);
+      g_error_free (err);
+    }
+  
+  g_free (key);
+#else
+  g_free (workspace_names[i]);
+  workspace_names[i] = g_strdup (name);
+#endif /* HAVE_MATECONF */
+}
+
+#ifdef HAVE_MATECONF
+static char*
+mateconf_key_for_workspace_name (int i)
+{
+  char *key;
+  
+  key = g_strdup_printf (KEY_WORKSPACE_NAME_PREFIX"%d", i + 1);
+  
+  return key;
+}
+#endif /* HAVE_MATECONF */
+
+void
+meta_prefs_get_button_layout (MetaButtonLayout *button_layout_p)
+{
+  *button_layout_p = button_layout;
+}
+
+gboolean
+meta_prefs_get_visual_bell (void)
+{
+  return provide_visual_bell;
+}
+
+gboolean
+meta_prefs_bell_is_audible (void)
+{
+  return bell_is_audible;
+}
+
+MetaVisualBellType
+meta_prefs_get_visual_bell_type (void)
+{
+  return visual_bell_type;
+}
+
+void
+meta_prefs_get_key_bindings (const MetaKeyPref **bindings,
+                                int                *n_bindings)
+{
+  
+  *bindings = key_bindings;
+  *n_bindings = (int) G_N_ELEMENTS (key_bindings) - 1;
+}
+
+MetaActionTitlebar
+meta_prefs_get_action_double_click_titlebar (void)
+{
+  return action_double_click_titlebar;
+}
+
+MetaActionTitlebar
+meta_prefs_get_action_middle_click_titlebar (void)
+{
+  return action_middle_click_titlebar;
+}
+
+MetaActionTitlebar
+meta_prefs_get_action_right_click_titlebar (void)
+{
+  return action_right_click_titlebar;
+}
+
+gboolean
+meta_prefs_get_auto_raise (void)
+{
+  return auto_raise;
+}
+
+int
+meta_prefs_get_auto_raise_delay (void)
+{
+  return auto_raise_delay;
+}
+
+gboolean
+meta_prefs_get_reduced_resources (void)
+{
+  return reduced_resources;
+}
+
+gboolean
+meta_prefs_get_mate_accessibility ()
+{
+  return mate_accessibility;
+}
+
+gboolean
+meta_prefs_get_mate_animations ()
+{
+  return mate_animations;
+}
+
+MetaKeyBindingAction
+meta_prefs_get_keybinding_action (const char *name)
+{
+  int i;
+
+  i = G_N_ELEMENTS (key_bindings) - 2; /* -2 for dummy entry at end */
+  while (i >= 0)
+    {
+      if (strcmp (key_bindings[i].name, name) == 0)
+        return (MetaKeyBindingAction) i;
+      
+      --i;
+    }
+
+  return META_KEYBINDING_ACTION_NONE;
+}
+
+/* This is used by the menu system to decide what key binding
+ * to display next to an option. We return the first non-disabled
+ * binding, if any.
+ */
+void
+meta_prefs_get_window_binding (const char          *name,
+                               unsigned int        *keysym,
+                               MetaVirtualModifier *modifiers)
+{
+  int i;
+
+  i = G_N_ELEMENTS (key_bindings) - 2; /* -2 for dummy entry at end */
+  while (i >= 0)
+    {
+      if (key_bindings[i].per_window &&
+          strcmp (key_bindings[i].name, name) == 0)
+        {
+          GSList *s = key_bindings[i].bindings;
+
+          while (s)
+            {
+              MetaKeyCombo *c = s->data;
+
+              if (c->keysym!=0 || c->modifiers!=0)
+                {
+                  *keysym = c->keysym;
+                  *modifiers = c->modifiers;
+                  return;
+                }
+
+              s = s->next;
+            }
+
+          /* Not found; return the disabled value */
+          *keysym = *modifiers = 0;
+          return;
+        }
+      
+      --i;
+    }
+
+  g_assert_not_reached ();
+}
+
+gboolean
+meta_prefs_get_compositing_manager (void)
+{
+  return compositing_manager;
+}
+
+guint
+meta_prefs_get_mouse_button_resize (void)
+{
+  return resize_with_right_button ? 3: 2;
+}
+
+guint
+meta_prefs_get_mouse_button_menu (void)
+{
+  return resize_with_right_button ? 2: 3;
+}
+
+gboolean
+meta_prefs_get_force_fullscreen (void)
+{
+  return force_fullscreen;
+}
+
+void
+meta_prefs_set_compositing_manager (gboolean whether)
+{
+#ifdef HAVE_MATECONF
+  GError *err = NULL;
+
+  mateconf_client_set_bool (default_client,
+                         KEY_COMPOSITOR,
+                         whether,
+                         &err);
+
+  if (err)
+    {
+      meta_warning (_("Error setting compositor status: %s\n"),
+                    err->message);
+      g_error_free (err);
+    }
+#else
+  compositing_manager = whether;
+#endif
+}
+
+#ifndef HAVE_MATECONF
+static void
+init_button_layout(void)
+{
+  MetaButtonLayout button_layout_ltr = {
+    {    
+      /* buttons in the group on the left side */
+      META_BUTTON_FUNCTION_MENU,
+      META_BUTTON_FUNCTION_LAST
+    },
+    {
+      /* buttons in the group on the right side */
+      META_BUTTON_FUNCTION_MINIMIZE,
+      META_BUTTON_FUNCTION_MAXIMIZE,
+      META_BUTTON_FUNCTION_CLOSE,
+      META_BUTTON_FUNCTION_LAST
+    }
+  };
+  MetaButtonLayout button_layout_rtl = {
+    {    
+      /* buttons in the group on the left side */
+      META_BUTTON_FUNCTION_CLOSE,
+      META_BUTTON_FUNCTION_MAXIMIZE,
+      META_BUTTON_FUNCTION_MINIMIZE,
+      META_BUTTON_FUNCTION_LAST
+    },
+    {
+      /* buttons in the group on the right side */
+      META_BUTTON_FUNCTION_MENU,
+      META_BUTTON_FUNCTION_LAST
+    }
+  };
+
+  button_layout = meta_ui_get_direction() == META_UI_DIRECTION_LTR ?
+    button_layout_ltr : button_layout_rtl;
+};
+
+#endif
+
+void
+meta_prefs_set_force_fullscreen (gboolean whether)
+{
+  force_fullscreen = whether;
+}
+
diff --git a/src/core/schema-bindings.c b/src/core/schema-bindings.c
new file mode 100644
index 00000000..2f1da821
--- /dev/null
+++ b/src/core/schema-bindings.c
@@ -0,0 +1,195 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Thomas Thurman
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/** \file  Schema bindings generator.
+ *
+ * This program simply takes the items given in the binding list in
+ * all-keybindings.h and turns them into a portion of
+ * the MateConf .schemas file.
+ *
+ * FIXME: also need to make 50-marco-desktop-key.xml
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <glib.h>
+#include "config.h"
+
+#define _(x) x
+
+static void single_stanza (gboolean is_window, const char *name,
+               const char *default_value,
+               gboolean can_reverse,
+               const char *description);
+
+char *about_keybindings, *about_reversible_keybindings;
+
+char *source_filename, *target_filename;
+FILE *source_file, *target_file;
+
+static void
+single_stanza (gboolean is_window, const char *name,
+               const char *default_value,
+               gboolean can_reverse,
+               const char *description)
+{
+  char *keybinding_type = is_window? "window": "global";
+  char *escaped_default_value, *escaped_description;
+
+  if (description==NULL)
+    return; /* it must be undocumented, so it can't go in this table */
+
+  escaped_description = g_markup_escape_text (description, -1);
+  escaped_default_value = default_value==NULL? "disabled":
+        g_markup_escape_text (default_value, -1);
+  
+  fprintf (target_file, "    <schema>\n");
+  fprintf (target_file, "      <key>/schemas/apps/marco/%s_keybindings/%s</key>\n",
+            keybinding_type, name);
+  fprintf (target_file, "      <applyto>/apps/marco/%s_keybindings/%s</applyto>\n",
+            keybinding_type, name);
+  fprintf (target_file, "      <owner>marco</owner>\n");
+  fprintf (target_file, "      <type>string</type>\n");
+  fprintf (target_file, "      <default>%s</default>\n", escaped_default_value);
+  
+  fprintf (target_file, "      <locale name=\"C\">\n");
+  fprintf (target_file, "        <short>%s</short>\n", description);
+  fprintf (target_file, "        <long>%s</long>\n",
+                   can_reverse? about_reversible_keybindings:
+                   about_keybindings);
+  fprintf (target_file, "      </locale>\n");
+  fprintf (target_file, "    </schema>\n\n");
+
+  g_free (escaped_description);
+
+  if (default_value!=NULL)
+    g_free (escaped_default_value);
+}
+
+static void produce_bindings ();
+
+static void
+produce_bindings ()
+{
+  /* 10240 is ridiculous overkill; we're writing the input file and
+   * the lines are always 80 chars or less.
+   */
+  char buffer[10240];
+
+  source_file = fopen(source_filename, "r");
+
+  if (!source_file)
+    {
+      g_error ("Cannot compile without %s: %s\n",
+        source_filename, strerror (errno));
+    }
+
+  target_file = fopen(target_filename, "w");
+
+  if (!target_file)
+    {
+      g_error ("Cannot create %s: %s\n",
+        target_filename, strerror (errno));
+    }
+
+  while (fgets (buffer, sizeof (buffer), source_file))
+    {
+      if (strstr (buffer, "<!-- GENERATED -->"))
+         break;
+         
+      fprintf (target_file, "%s", buffer);
+    }
+
+  if (!feof (source_file))
+    {
+#define keybind(name, handler, param, flags, stroke, description) \
+  single_stanza ( \
+               flags & BINDING_PER_WINDOW, \
+               #name, \
+               stroke, \
+               flags & BINDING_REVERSES, \
+               description);
+#include "all-keybindings.h"
+#undef keybind
+    }
+
+  while (fgets (buffer, sizeof (buffer), source_file))
+      fprintf (target_file, "%s", buffer);
+
+  if (fclose (source_file)!=0)
+    {
+      g_error ("Cannot close %s: %s\n",
+        source_filename, strerror (errno));
+    }
+
+  if (fclose (target_file)!=0)
+    {
+      g_error ("Cannot close %s: %s\n",
+        target_filename, strerror (errno));
+    }
+}
+
+int
+main (int argc, char **argv)
+{
+  if (argc!=3)
+    {
+      g_error ("Syntax: %s <source.in.in> <target.in>\n", argv[0]);
+    }
+  
+  source_filename = argv[1];
+  target_filename = argv[2];
+
+  /* Translators: Please don't translate "Control", "Shift", etc, since these
+   * are hardcoded (in gtk/gtkaccelgroup.c; it's not marco's fault).
+   * "disabled" must also stay as it is.
+   */
+  about_keybindings = g_markup_escape_text(_( \
+        "The format looks like \"<Control>a\" or \"<Shift><Alt>F1\".\n\n"\
+        "The parser is fairly liberal and allows "\
+  	"lower or upper case, and also abbreviations such as \"<Ctl>\" and " \
+	"\"<Ctrl>\". If you set the option to the special string " \
+	"\"disabled\", then there will be no keybinding for this action."),
+        -1);
+
+  about_reversible_keybindings = g_markup_escape_text(_( \
+        "The format looks like \"<Control>a\" or \"<Shift><Alt>F1\".\n\n"\
+        "The parser is fairly liberal and allows "\
+  	"lower or upper case, and also abbreviations such as \"<Ctl>\" and " \
+	"\"<Ctrl>\". If you set the option to the special string " \
+	"\"disabled\", then there will be no keybinding for this action.\n\n"\
+	"This keybinding may be reversed by holding down the \"shift\" key; "
+	"therefore, \"shift\" cannot be one of the keys it uses."),
+	-1);
+
+  produce_bindings ();
+
+  g_free (about_keybindings);
+  g_free (about_reversible_keybindings);
+  
+  return 0;
+}
+
+/* eof schema-bindings.c */
+
diff --git a/src/core/screen-private.h b/src/core/screen-private.h
new file mode 100644
index 00000000..30941eab
--- /dev/null
+++ b/src/core/screen-private.h
@@ -0,0 +1,226 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file screen-private.h  Screens which Marco manages
+ *
+ * Managing X screens.
+ * This file contains methods on this class which are available to
+ * routines in core but not outside it.  (See screen.h for the routines
+ * which the rest of the world is allowed to use.)
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_SCREEN_PRIVATE_H
+#define META_SCREEN_PRIVATE_H
+
+#include "display-private.h"
+#include "screen.h"
+#include <X11/Xutil.h>
+#include "ui.h"
+
+typedef struct _MetaXineramaScreenInfo MetaXineramaScreenInfo;
+
+struct _MetaXineramaScreenInfo
+{
+  int number;
+  MetaRectangle rect;
+};
+
+typedef void (* MetaScreenWindowFunc) (MetaScreen *screen, MetaWindow *window,
+                                       gpointer user_data);
+
+typedef enum
+{
+  META_SCREEN_TOPLEFT,
+  META_SCREEN_TOPRIGHT,
+  META_SCREEN_BOTTOMLEFT,
+  META_SCREEN_BOTTOMRIGHT
+} MetaScreenCorner;
+
+typedef enum
+{
+  META_SCREEN_UP,
+  META_SCREEN_DOWN,
+  META_SCREEN_LEFT,
+  META_SCREEN_RIGHT
+} MetaScreenDirection;
+
+#define META_WIREFRAME_XOR_LINE_WIDTH 2
+
+struct _MetaScreen
+{
+  MetaDisplay *display;
+  int number;
+  char *screen_name;
+  Screen *xscreen;
+  Window xroot;
+  int default_depth;
+  Visual *default_xvisual;
+  MetaRectangle rect;  /* Size of screen; rect.x & rect.y are always 0 */
+  MetaUI *ui;
+  MetaTabPopup *tab_popup;
+  
+  MetaWorkspace *active_workspace;
+
+  /* This window holds the focus when we don't want to focus
+   * any actual clients
+   */
+  Window no_focus_window;
+  
+  GList *workspaces;
+
+  MetaStack *stack;
+
+  MetaCursor current_cursor;
+
+  Window flash_window;
+
+  Window wm_sn_selection_window;
+  Atom wm_sn_atom;
+  guint32 wm_sn_timestamp;
+  
+  MetaXineramaScreenInfo *xinerama_infos;
+  int n_xinerama_infos;
+
+  /* Cache the current Xinerama */
+  int last_xinerama_index;
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  SnMonitorContext *sn_context;
+  GSList *startup_sequences;
+  guint startup_sequence_timeout;
+#endif
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  Window wm_cm_selection_window;
+  guint32 wm_cm_timestamp;
+#endif
+
+  guint work_area_idle;
+
+  int rows_of_workspaces;
+  int columns_of_workspaces;
+  MetaScreenCorner starting_corner;
+  guint vertical_workspaces : 1;
+  
+  guint keys_grabbed : 1;
+  guint all_keys_grabbed : 1;
+  
+  int closing;
+
+  /* gc for XOR on root window */
+  GC root_xor_gc;
+
+  /* Managed by compositor.c */
+  gpointer compositor_data;
+};
+
+MetaScreen*   meta_screen_new                 (MetaDisplay                *display,
+                                               int                         number,
+                                               guint32                     timestamp);
+void          meta_screen_free                (MetaScreen                 *screen,
+                                               guint32                     timestamp);
+void          meta_screen_manage_all_windows  (MetaScreen                 *screen);
+void          meta_screen_foreach_window      (MetaScreen                 *screen,
+                                               MetaScreenWindowFunc        func,
+                                               gpointer                    data);
+void          meta_screen_queue_frame_redraws (MetaScreen                 *screen);
+void          meta_screen_queue_window_resizes (MetaScreen                 *screen);
+
+int           meta_screen_get_n_workspaces    (MetaScreen                 *screen);
+
+MetaWorkspace* meta_screen_get_workspace_by_index (MetaScreen    *screen,
+                                                   int            index);
+
+void          meta_screen_set_cursor          (MetaScreen                 *screen,
+                                               MetaCursor                  cursor);
+void          meta_screen_update_cursor       (MetaScreen                 *screen);
+
+void          meta_screen_ensure_tab_popup    (MetaScreen                 *screen,
+                                               MetaTabList                 list_type,
+                                               MetaTabShowType             show_type);
+void          meta_screen_ensure_workspace_popup (MetaScreen *screen);
+
+MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
+                                                MetaWindow                 *not_this_one);
+
+const MetaXineramaScreenInfo* meta_screen_get_current_xinerama    (MetaScreen    *screen);
+const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_rect   (MetaScreen    *screen,
+                                                                   MetaRectangle *rect);
+const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen    *screen,
+                                                                   MetaWindow    *window);
+
+
+const MetaXineramaScreenInfo* meta_screen_get_xinerama_neighbor (MetaScreen *screen,
+                                                                 int         which_xinerama,
+                                                                 MetaScreenDirection dir);
+void          meta_screen_get_natural_xinerama_list (MetaScreen *screen,
+                                                     int**       xineramas_list,
+                                                     int*        n_xineramas);
+
+void          meta_screen_update_workspace_layout (MetaScreen             *screen);
+void          meta_screen_update_workspace_names  (MetaScreen             *screen);
+void          meta_screen_queue_workarea_recalc   (MetaScreen             *screen);
+
+Window meta_create_offscreen_window (Display *xdisplay,
+                                     Window   parent,
+                                     long     valuemask);
+
+typedef struct MetaWorkspaceLayout MetaWorkspaceLayout;
+
+struct MetaWorkspaceLayout
+{
+  int rows;
+  int cols;
+  int *grid;
+  int grid_area;
+  int current_row;
+  int current_col;
+};
+
+void meta_screen_calc_workspace_layout (MetaScreen          *screen,
+                                        int                  num_workspaces,
+                                        int                  current_space,
+                                        MetaWorkspaceLayout *layout);
+void meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout);
+
+void meta_screen_resize (MetaScreen *screen,
+                         int         width,
+                         int         height);
+
+void     meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
+                                                              MetaWindow *keep);
+
+/* Show/hide the desktop (temporarily hide all windows) */
+void     meta_screen_show_desktop        (MetaScreen *screen,
+                                          guint32     timestamp);
+void     meta_screen_unshow_desktop      (MetaScreen *screen);
+
+/* Update whether the destkop is being shown for the current active_workspace */
+void     meta_screen_update_showing_desktop_hint          (MetaScreen *screen);
+
+gboolean meta_screen_apply_startup_properties (MetaScreen *screen,
+                                               MetaWindow *window);
+void	 meta_screen_composite_all_windows (MetaScreen *screen);
+
+#endif
diff --git a/src/core/screen.c b/src/core/screen.c
new file mode 100644
index 00000000..f9db9c71
--- /dev/null
+++ b/src/core/screen.c
@@ -0,0 +1,2815 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X screen handler */
+
+/* 
+ * Copyright (C) 2001, 2002 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat Inc.
+ * Some ICCCM manager selection code derived from fvwm2,
+ * Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "screen-private.h"
+#include "util.h"
+#include "errors.h"
+#include "window-private.h"
+#include "frame-private.h"
+#include "prefs.h"
+#include "workspace.h"
+#include "keybindings.h"
+#include "stack.h"
+#include "xprops.h"
+#include "compositor.h"
+
+#ifdef HAVE_SOLARIS_XINERAMA
+#include <X11/extensions/xinerama.h>
+#endif
+#ifdef HAVE_XFREE_XINERAMA
+#include <X11/extensions/Xinerama.h>
+#endif
+
+#include <X11/Xatom.h>
+#include <locale.h>
+#include <string.h>
+#include <stdio.h>
+
+static char* get_screen_name (MetaDisplay *display,
+                              int          number);
+
+static void update_num_workspaces  (MetaScreen *screen,
+                                    guint32     timestamp);
+static void update_focus_mode      (MetaScreen *screen);
+static void set_workspace_names    (MetaScreen *screen);
+static void prefs_changed_callback (MetaPreference pref,
+                                    gpointer       data);
+
+static void set_desktop_geometry_hint (MetaScreen *screen);
+static void set_desktop_viewport_hint (MetaScreen *screen);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static void meta_screen_sn_event   (SnMonitorEvent *event,
+                                    void           *user_data);
+#endif
+
+static int
+set_wm_check_hint (MetaScreen *screen)
+{
+  unsigned long data[1];
+
+  g_return_val_if_fail (screen->display->leader_window != None, 0);
+  
+  data[0] = screen->display->leader_window;
+
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_SUPPORTING_WM_CHECK,
+                   XA_WINDOW,
+                   32, PropModeReplace, (guchar*) data, 1);
+
+  return Success;
+}
+
+static void
+unset_wm_check_hint (MetaScreen *screen)
+{
+  XDeleteProperty (screen->display->xdisplay, screen->xroot, 
+                   screen->display->atom__NET_SUPPORTING_WM_CHECK);
+}
+
+static int
+set_supported_hint (MetaScreen *screen)
+{
+  Atom atoms[] = {
+#define EWMH_ATOMS_ONLY
+#define item(x)  screen->display->atom_##x,
+#include "atomnames.h"
+#undef item
+#undef EWMH_ATOMS_ONLY
+  };
+
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_SUPPORTED,
+                   XA_ATOM,
+                   32, PropModeReplace,
+                   (guchar*) atoms, G_N_ELEMENTS(atoms));
+  
+  return Success;
+}
+
+static int
+set_wm_icon_size_hint (MetaScreen *screen)
+{
+#define N_VALS 6
+  gulong vals[N_VALS];
+
+  /* min width, min height, max w, max h, width inc, height inc */
+  vals[0] = META_ICON_WIDTH;
+  vals[1] = META_ICON_HEIGHT;
+  vals[2] = META_ICON_WIDTH;
+  vals[3] = META_ICON_HEIGHT;
+  vals[4] = 0;
+  vals[5] = 0;
+  
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom_WM_ICON_SIZE,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) vals, N_VALS);
+  
+  return Success;
+#undef N_VALS
+}
+
+static void
+reload_xinerama_infos (MetaScreen *screen)
+{
+  MetaDisplay *display;
+
+  {
+    GList *tmp;
+
+    tmp = screen->workspaces;
+    while (tmp != NULL)
+      {
+        MetaWorkspace *space = tmp->data;
+
+        meta_workspace_invalidate_work_area (space);
+        
+        tmp = tmp->next;
+      }
+  }
+
+  display = screen->display;
+  
+  if (screen->xinerama_infos)
+    g_free (screen->xinerama_infos);
+  
+  screen->xinerama_infos = NULL;
+  screen->n_xinerama_infos = 0;
+  screen->last_xinerama_index = 0;
+
+  screen->display->xinerama_cache_invalidated = TRUE;
+  
+#ifdef HAVE_XFREE_XINERAMA
+  if (XineramaIsActive (display->xdisplay))
+    {
+      XineramaScreenInfo *infos;
+      int n_infos;
+      int i;
+      
+      n_infos = 0;
+      infos = XineramaQueryScreens (display->xdisplay, &n_infos);
+
+      meta_topic (META_DEBUG_XINERAMA,
+                  "Found %d Xinerama screens on display %s\n",
+                  n_infos, display->name);
+
+      if (n_infos > 0)
+        {
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_infos);
+          screen->n_xinerama_infos = n_infos;
+          
+          i = 0;
+          while (i < n_infos)
+            {
+              screen->xinerama_infos[i].number = infos[i].screen_number;
+              screen->xinerama_infos[i].rect.x = infos[i].x_org;
+              screen->xinerama_infos[i].rect.y = infos[i].y_org;
+              screen->xinerama_infos[i].rect.width = infos[i].width;
+              screen->xinerama_infos[i].rect.height = infos[i].height;
+
+              meta_topic (META_DEBUG_XINERAMA,
+                          "Xinerama %d is %d,%d %d x %d\n",
+                          screen->xinerama_infos[i].number,
+                          screen->xinerama_infos[i].rect.x,
+                          screen->xinerama_infos[i].rect.y,
+                          screen->xinerama_infos[i].rect.width,
+                          screen->xinerama_infos[i].rect.height);
+              
+              ++i;
+            }
+        }
+      
+      meta_XFree (infos);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_XINERAMA,
+                  "No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n",
+                  display->name);
+    }
+#else
+  meta_topic (META_DEBUG_XINERAMA,
+              "Marco compiled without XFree86 Xinerama support\n");
+#endif /* HAVE_XFREE_XINERAMA */
+
+#ifdef HAVE_SOLARIS_XINERAMA
+  /* This code from GDK, Copyright (C) 2002 Sun Microsystems */
+  if (screen->n_xinerama_infos == 0 &&
+      XineramaGetState (screen->display->xdisplay,
+                        screen->number))
+    {
+      XRectangle monitors[MAXFRAMEBUFFERS];
+      unsigned char hints[16];
+      int result;
+      int n_monitors;
+      int i;
+
+      n_monitors = 0;
+      result = XineramaGetInfo (screen->display->xdisplay,
+                                screen->number,
+				monitors, hints,
+                                &n_monitors);
+      /* Yes I know it should be Success but the current implementation 
+       * returns the num of monitor
+       */
+      if (result > 0)
+	{
+          g_assert (n_monitors > 0);
+          
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_monitors);
+          screen->n_xinerama_infos = n_monitors;
+          
+          i = 0;
+          while (i < n_monitors)
+            {
+              screen->xinerama_infos[i].number = i;
+              screen->xinerama_infos[i].rect.x = monitors[i].x;
+              screen->xinerama_infos[i].rect.y = monitors[i].y;
+              screen->xinerama_infos[i].rect.width = monitors[i].width;
+              screen->xinerama_infos[i].rect.height = monitors[i].height;
+
+              meta_topic (META_DEBUG_XINERAMA,
+                          "Xinerama %d is %d,%d %d x %d\n",
+                          screen->xinerama_infos[i].number,
+                          screen->xinerama_infos[i].rect.x,
+                          screen->xinerama_infos[i].rect.y,
+                          screen->xinerama_infos[i].rect.width,
+                          screen->xinerama_infos[i].rect.height);              
+              
+              ++i;
+            }
+	}
+    }
+  else if (screen->n_xinerama_infos == 0)
+    {
+      meta_topic (META_DEBUG_XINERAMA,
+                  "No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n",
+                  display->name);
+    }
+#else
+  meta_topic (META_DEBUG_XINERAMA,
+              "Marco compiled without Solaris Xinerama support\n");
+#endif /* HAVE_SOLARIS_XINERAMA */
+
+  
+  /* If no Xinerama, fill in the single screen info so
+   * we can use the field unconditionally
+   */
+  if (screen->n_xinerama_infos == 0)
+    {
+      if (g_getenv ("MARCO_DEBUG_XINERAMA"))
+        {
+          meta_topic (META_DEBUG_XINERAMA,
+                      "Pretending a single monitor has two Xinerama screens\n");
+          
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 2);
+          screen->n_xinerama_infos = 2;
+          
+          screen->xinerama_infos[0].number = 0;
+          screen->xinerama_infos[0].rect = screen->rect;
+          screen->xinerama_infos[0].rect.width = screen->rect.width / 2;
+
+          screen->xinerama_infos[1].number = 1;
+          screen->xinerama_infos[1].rect = screen->rect;
+          screen->xinerama_infos[1].rect.x = screen->rect.width / 2;
+          screen->xinerama_infos[1].rect.width = screen->rect.width / 2;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_XINERAMA,
+                      "No Xinerama screens, using default screen info\n");
+          
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 1);
+          screen->n_xinerama_infos = 1;
+          
+          screen->xinerama_infos[0].number = 0;
+          screen->xinerama_infos[0].rect = screen->rect;
+        }
+    }
+
+  g_assert (screen->n_xinerama_infos > 0);
+  g_assert (screen->xinerama_infos != NULL);
+}
+
+MetaScreen*
+meta_screen_new (MetaDisplay *display,
+                 int          number,
+                 guint32      timestamp)
+{
+  MetaScreen *screen;
+  Window xroot;
+  Display *xdisplay;
+  XWindowAttributes attr;
+  Window new_wm_sn_owner;
+  Window current_wm_sn_owner;
+  gboolean replace_current_wm;
+  Atom wm_sn_atom;
+  char buf[128];
+  guint32 manager_timestamp;
+  gulong current_workspace;
+  
+  replace_current_wm = meta_get_replace_current_wm ();
+  
+  /* Only display->name, display->xdisplay, and display->error_traps
+   * can really be used in this function, since normally screens are
+   * created from the MetaDisplay constructor
+   */
+  
+  xdisplay = display->xdisplay;
+  
+  meta_verbose ("Trying screen %d on display '%s'\n",
+                number, display->name);
+
+  xroot = RootWindow (xdisplay, number);
+
+  /* FVWM checks for None here, I don't know if this
+   * ever actually happens
+   */
+  if (xroot == None)
+    {
+      meta_warning (_("Screen %d on display '%s' is invalid\n"),
+                    number, display->name);
+      return NULL;
+    }
+
+  sprintf (buf, "WM_S%d", number);
+  wm_sn_atom = XInternAtom (xdisplay, buf, False);  
+  
+  current_wm_sn_owner = XGetSelectionOwner (xdisplay, wm_sn_atom);
+
+  if (current_wm_sn_owner != None)
+    {
+      XSetWindowAttributes attrs;
+      
+      if (!replace_current_wm)
+        {
+          meta_warning (_("Screen %d on display \"%s\" already has a window manager; try using the --replace option to replace the current window manager.\n"),
+                        number, display->name);
+
+          return NULL;
+        }
+
+      /* We want to find out when the current selection owner dies */
+      meta_error_trap_push_with_return (display);
+      attrs.event_mask = StructureNotifyMask;
+      XChangeWindowAttributes (xdisplay,
+                               current_wm_sn_owner, CWEventMask, &attrs);
+      if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+        current_wm_sn_owner = None; /* don't wait for it to die later on */
+    }
+
+  /* We need SelectionClear and SelectionRequest events on the new_wm_sn_owner,
+   * but those cannot be masked, so we only need NoEventMask.
+   */
+  new_wm_sn_owner = meta_create_offscreen_window (xdisplay, xroot, NoEventMask);
+
+  manager_timestamp = timestamp;
+  
+  XSetSelectionOwner (xdisplay, wm_sn_atom, new_wm_sn_owner,
+                      manager_timestamp);
+
+  if (XGetSelectionOwner (xdisplay, wm_sn_atom) != new_wm_sn_owner)
+    {
+      meta_warning (_("Could not acquire window manager selection on screen %d display \"%s\"\n"),
+                    number, display->name);
+
+      XDestroyWindow (xdisplay, new_wm_sn_owner);
+      
+      return NULL;
+    }
+  
+  {
+    /* Send client message indicating that we are now the WM */
+    XClientMessageEvent ev;
+    
+    ev.type = ClientMessage;
+    ev.window = xroot;
+    ev.message_type = display->atom_MANAGER;
+    ev.format = 32;
+    ev.data.l[0] = manager_timestamp;
+    ev.data.l[1] = wm_sn_atom;
+
+    XSendEvent (xdisplay, xroot, False, StructureNotifyMask, (XEvent*)&ev);
+  }
+
+  /* Wait for old window manager to go away */
+  if (current_wm_sn_owner != None)
+    {
+      XEvent event;
+
+      /* We sort of block infinitely here which is probably lame. */
+      
+      meta_verbose ("Waiting for old window manager to exit\n");
+      do
+        {
+          XWindowEvent (xdisplay, current_wm_sn_owner,
+                        StructureNotifyMask, &event);
+        }
+      while (event.type != DestroyNotify);
+    }
+  
+  /* select our root window events */
+  meta_error_trap_push_with_return (display);
+
+  /* We need to or with the existing event mask since
+   * gtk+ may be interested in other events.
+   */
+  XGetWindowAttributes (xdisplay, xroot, &attr);
+  XSelectInput (xdisplay,
+                xroot,
+                SubstructureRedirectMask | SubstructureNotifyMask |
+                ColormapChangeMask | PropertyChangeMask |
+                LeaveWindowMask | EnterWindowMask |
+                KeyPressMask | KeyReleaseMask |
+                FocusChangeMask | StructureNotifyMask |
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+                ExposureMask |
+#endif
+		attr.your_event_mask);
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    {
+      meta_warning (_("Screen %d on display \"%s\" already has a window manager\n"),
+                    number, display->name);
+
+      XDestroyWindow (xdisplay, new_wm_sn_owner);
+      
+      return NULL;
+    }
+  
+  screen = g_new (MetaScreen, 1);
+  screen->closing = 0;
+  
+  screen->display = display;
+  screen->number = number;
+  screen->screen_name = get_screen_name (display, number);
+  screen->xscreen = ScreenOfDisplay (xdisplay, number);
+  screen->xroot = xroot;
+  screen->rect.x = screen->rect.y = 0;
+  screen->rect.width = WidthOfScreen (screen->xscreen);
+  screen->rect.height = HeightOfScreen (screen->xscreen);
+  screen->current_cursor = -1; /* invalid/unset */
+  screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen);
+  screen->default_depth = DefaultDepthOfScreen (screen->xscreen);
+  screen->flash_window = None;
+
+  screen->wm_sn_selection_window = new_wm_sn_owner;
+  screen->wm_sn_atom = wm_sn_atom;
+  screen->wm_sn_timestamp = manager_timestamp;
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  screen->wm_cm_selection_window = meta_create_offscreen_window (xdisplay, 
+                                                                 xroot, 
+                                                                 NoEventMask);
+#endif
+  screen->work_area_idle = 0;
+
+  screen->active_workspace = NULL;
+  screen->workspaces = NULL;
+  screen->rows_of_workspaces = 1;
+  screen->columns_of_workspaces = -1;
+  screen->vertical_workspaces = FALSE;
+  screen->starting_corner = META_SCREEN_TOPLEFT;
+  screen->compositor_data = NULL;
+
+  {
+    XFontStruct *font_info;
+    XGCValues gc_values;
+    gulong value_mask = 0;
+    
+    gc_values.subwindow_mode = IncludeInferiors;
+    value_mask |= GCSubwindowMode;
+    gc_values.function = GXinvert;
+    value_mask |= GCFunction;
+    gc_values.line_width = META_WIREFRAME_XOR_LINE_WIDTH;
+    value_mask |= GCLineWidth;
+
+    font_info = XLoadQueryFont (screen->display->xdisplay, "fixed");
+
+    if (font_info != NULL)
+      {
+        gc_values.font = font_info->fid;
+        value_mask |= GCFont;
+        XFreeFontInfo (NULL, font_info, 1);
+      }
+    else
+      meta_warning ("xserver doesn't have 'fixed' font.\n");
+
+    screen->root_xor_gc = XCreateGC (screen->display->xdisplay,
+                                     screen->xroot,
+                                     value_mask,
+                                     &gc_values);
+  }
+  
+  screen->xinerama_infos = NULL;
+  screen->n_xinerama_infos = 0;
+  screen->last_xinerama_index = 0;  
+  
+  reload_xinerama_infos (screen);
+  
+  meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
+
+  /* Handle creating a no_focus_window for this screen */  
+  screen->no_focus_window =
+    meta_create_offscreen_window (display->xdisplay,
+                                  screen->xroot,
+                                  FocusChangeMask|KeyPressMask|KeyReleaseMask);
+  XMapWindow (display->xdisplay, screen->no_focus_window);
+  /* Done with no_focus_window stuff */
+  
+  set_wm_icon_size_hint (screen);
+  
+  set_supported_hint (screen);
+  
+  set_wm_check_hint (screen);
+
+  set_desktop_viewport_hint (screen);
+
+  set_desktop_geometry_hint (screen);
+
+  meta_screen_update_workspace_layout (screen);
+
+  /* Get current workspace */
+  current_workspace = 0;
+  if (meta_prop_get_cardinal (screen->display,
+                              screen->xroot,
+                              screen->display->atom__NET_CURRENT_DESKTOP,
+                              &current_workspace))
+    meta_verbose ("Read existing _NET_CURRENT_DESKTOP = %d\n",
+                  (int) current_workspace);
+  else
+    meta_verbose ("No _NET_CURRENT_DESKTOP present\n");
+  
+  /* Screens must have at least one workspace at all times,
+   * so create that required workspace.
+   */
+  meta_workspace_activate (meta_workspace_new (screen), timestamp);
+  update_num_workspaces (screen, timestamp);
+  
+  set_workspace_names (screen);
+
+  screen->all_keys_grabbed = FALSE;
+  screen->keys_grabbed = FALSE;
+  meta_screen_grab_keys (screen);
+
+  screen->ui = meta_ui_new (screen->display->xdisplay,
+                            screen->xscreen);
+
+  screen->tab_popup = NULL;
+  
+  screen->stack = meta_stack_new (screen);
+
+  meta_prefs_add_listener (prefs_changed_callback, screen);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  screen->sn_context =
+    sn_monitor_context_new (screen->display->sn_display,
+                            screen->number,
+                            meta_screen_sn_event,
+                            screen,
+                            NULL);
+  screen->startup_sequences = NULL;
+  screen->startup_sequence_timeout = 0;
+#endif
+
+  /* Switch to the _NET_CURRENT_DESKTOP workspace */
+  {
+    MetaWorkspace *space;
+    
+    space = meta_screen_get_workspace_by_index (screen,
+                                                current_workspace);
+    
+    if (space != NULL)
+      meta_workspace_activate (space, timestamp);
+  }
+
+  meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
+                screen->number, screen->screen_name, screen->xroot);
+  
+  return screen;
+}
+
+void
+meta_screen_free (MetaScreen *screen,
+                  guint32     timestamp)
+{
+  MetaDisplay *display;
+  XGCValues gc_values = { 0 };
+
+  display = screen->display;
+
+  screen->closing += 1;
+  
+  meta_display_grab (display);
+
+  if (screen->display->compositor)
+    {
+      meta_compositor_unmanage_screen (screen->display->compositor,
+				       screen);
+    }
+  
+  meta_display_unmanage_windows_for_screen (display, screen, timestamp);
+  
+  meta_prefs_remove_listener (prefs_changed_callback, screen);
+  
+  meta_screen_ungrab_keys (screen);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  g_slist_foreach (screen->startup_sequences,
+                   (GFunc) sn_startup_sequence_unref, NULL);
+  g_slist_free (screen->startup_sequences);
+  screen->startup_sequences = NULL;
+
+  if (screen->startup_sequence_timeout != 0)
+    {
+      g_source_remove (screen->startup_sequence_timeout);
+      screen->startup_sequence_timeout = 0;
+    }
+  if (screen->sn_context)
+    {
+      sn_monitor_context_unref (screen->sn_context);
+      screen->sn_context = NULL;
+    }
+#endif
+  
+  meta_ui_free (screen->ui);
+
+  meta_stack_free (screen->stack);
+
+  meta_error_trap_push_with_return (screen->display);
+  XSelectInput (screen->display->xdisplay, screen->xroot, 0);
+  if (meta_error_trap_pop_with_return (screen->display, FALSE) != Success)
+    meta_warning (_("Could not release screen %d on display \"%s\"\n"),
+                  screen->number, screen->display->name);
+
+  unset_wm_check_hint (screen);
+
+  XDestroyWindow (screen->display->xdisplay,
+                  screen->wm_sn_selection_window);
+  
+  if (screen->work_area_idle != 0)
+    g_source_remove (screen->work_area_idle);
+
+
+  if (XGetGCValues (screen->display->xdisplay,
+                    screen->root_xor_gc,
+                    GCFont,
+                    &gc_values))
+    {
+      XUnloadFont (screen->display->xdisplay,
+                   gc_values.font);
+    }
+
+  XFreeGC (screen->display->xdisplay,
+           screen->root_xor_gc);
+  
+  if (screen->xinerama_infos)
+    g_free (screen->xinerama_infos);
+  
+  g_free (screen->screen_name);
+  g_free (screen);
+
+  XFlush (display->xdisplay);
+  meta_display_ungrab (display);
+}
+
+typedef struct
+{
+  Window		xwindow;
+  XWindowAttributes	attrs;
+} WindowInfo;
+
+static GList *
+list_windows (MetaScreen *screen)
+{
+  Window ignored1, ignored2;
+  Window *children;
+  guint n_children, i;
+  GList *result;
+
+  XQueryTree (screen->display->xdisplay,
+              screen->xroot,
+              &ignored1, &ignored2, &children, &n_children);
+
+  result = NULL;
+  for (i = 0; i < n_children; ++i)
+    {
+      WindowInfo *info = g_new0 (WindowInfo, 1);
+
+      meta_error_trap_push_with_return (screen->display);
+      
+      XGetWindowAttributes (screen->display->xdisplay,
+                            children[i], &info->attrs);
+
+      if (meta_error_trap_pop_with_return (screen->display, TRUE))
+	{
+          meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        children[i]);
+	  g_free (info);
+        }
+      else
+        {
+	  info->xwindow = children[i];
+	}
+
+      result = g_list_prepend (result, info);
+    }
+
+  if (children)
+    XFree (children);
+
+  return g_list_reverse (result);
+}
+
+void
+meta_screen_manage_all_windows (MetaScreen *screen)
+{
+  GList *windows;
+  GList *list;
+
+  meta_display_grab (screen->display);
+  
+  windows = list_windows (screen);
+
+  meta_stack_freeze (screen->stack);
+  for (list = windows; list != NULL; list = list->next)
+    {
+      WindowInfo *info = list->data;
+      MetaWindow *window;
+
+      window = meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
+                                           &info->attrs);
+      if (info->xwindow == screen->no_focus_window ||
+          info->xwindow == screen->flash_window ||
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+          info->xwindow == screen->wm_cm_selection_window ||
+#endif
+          info->xwindow == screen->wm_sn_selection_window) {
+        meta_verbose ("Not managing our own windows\n");
+        continue;
+      }
+
+      if (screen->display->compositor)
+        meta_compositor_add_window (screen->display->compositor, window,
+                                    info->xwindow, &info->attrs);
+    }
+  meta_stack_thaw (screen->stack);
+
+  g_list_foreach (windows, (GFunc)g_free, NULL);
+  g_list_free (windows);
+
+  meta_display_ungrab (screen->display);
+}
+
+void
+meta_screen_composite_all_windows (MetaScreen *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaDisplay *display;
+  GList *windows, *list;
+
+  display = screen->display;
+  if (!display->compositor)
+    return;
+
+  windows = list_windows (screen);
+
+  meta_stack_freeze (screen->stack);
+
+  for (list = windows; list != NULL; list = list->next)
+    {
+      WindowInfo *info = list->data;
+
+      if (info->xwindow == screen->no_focus_window ||
+          info->xwindow == screen->flash_window ||
+          info->xwindow == screen->wm_sn_selection_window ||
+          info->xwindow == screen->wm_cm_selection_window) {
+        meta_verbose ("Not managing our own windows\n");
+        continue;
+      }
+
+      meta_compositor_add_window (display->compositor,
+                                  meta_display_lookup_x_window (display,
+                                                                info->xwindow),
+				  info->xwindow, &info->attrs);
+    }
+
+  meta_stack_thaw (screen->stack);
+
+  g_list_foreach (windows, (GFunc)g_free, NULL);
+  g_list_free (windows);
+#endif
+}
+
+MetaScreen*
+meta_screen_for_x_screen (Screen *xscreen)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (DisplayOfScreen (xscreen));
+
+  if (display == NULL)
+    return NULL;
+  
+  return meta_display_screen_for_x_screen (display, xscreen);
+}
+
+static void
+prefs_changed_callback (MetaPreference pref,
+                        gpointer       data)
+{
+  MetaScreen *screen = data;
+  
+  if (pref == META_PREF_NUM_WORKSPACES)
+    {
+      /* MateConf doesn't provide timestamps, but luckily update_num_workspaces
+       * often doesn't need it...
+       */
+      guint32 timestamp = 
+        meta_display_get_current_time_roundtrip (screen->display);
+      update_num_workspaces (screen, timestamp);
+    }
+  else if (pref == META_PREF_FOCUS_MODE)
+    {
+      update_focus_mode (screen);
+    }
+  else if (pref == META_PREF_WORKSPACE_NAMES)
+    {
+      set_workspace_names (screen);
+    }
+}
+
+
+static char*
+get_screen_name (MetaDisplay *display,
+                 int          number)
+{
+  char *p;
+  char *dname;
+  char *scr;
+  
+  /* DisplayString gives us a sort of canonical display,
+   * vs. the user-entered name from XDisplayName()
+   */
+  dname = g_strdup (DisplayString (display->xdisplay));
+
+  /* Change display name to specify this screen.
+   */
+  p = strrchr (dname, ':');
+  if (p)
+    {
+      p = strchr (p, '.');
+      if (p)
+        *p = '\0';
+    }
+  
+  scr = g_strdup_printf ("%s.%d", dname, number);
+
+  g_free (dname);
+
+  return scr;
+}
+
+static gint
+ptrcmp (gconstpointer a, gconstpointer b)
+{
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+listify_func (gpointer key, gpointer value, gpointer data)
+{
+  GSList **listp;
+  
+  listp = data;
+
+  *listp = g_slist_prepend (*listp, value);
+}
+
+void
+meta_screen_foreach_window (MetaScreen *screen,
+                            MetaScreenWindowFunc func,
+                            gpointer data)
+{
+  GSList *winlist;
+  GSList *tmp;
+
+  /* If we end up doing this often, just keeping a list
+   * of windows might be sensible.
+   */
+  
+  winlist = NULL;
+  g_hash_table_foreach (screen->display->window_ids,
+                        listify_func,
+                        &winlist);
+  
+  winlist = g_slist_sort (winlist, ptrcmp);
+  
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      /* If the next node doesn't contain this window
+       * a second time, delete the window.
+       */
+      if (tmp->next == NULL ||
+          (tmp->next && tmp->next->data != tmp->data))
+        {
+          MetaWindow *window = tmp->data;
+
+          if (window->screen == screen)
+            (* func) (screen, window, data);
+        }
+      
+      tmp = tmp->next;
+    }
+  g_slist_free (winlist);
+}
+
+static void
+queue_draw (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  if (window->frame)
+    meta_frame_queue_draw (window->frame);
+}
+
+void
+meta_screen_queue_frame_redraws (MetaScreen *screen)
+{
+  meta_screen_foreach_window (screen, queue_draw, NULL);
+}
+
+static void
+queue_resize (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_screen_queue_window_resizes (MetaScreen *screen)
+{
+  meta_screen_foreach_window (screen, queue_resize, NULL);
+}
+
+int
+meta_screen_get_n_workspaces (MetaScreen *screen)
+{
+  return g_list_length (screen->workspaces);
+}
+
+MetaWorkspace*
+meta_screen_get_workspace_by_index (MetaScreen  *screen,
+                                    int          idx)
+{
+  GList *tmp;
+  int i;
+
+  /* should be robust, idx is maybe from an app */
+  if (idx < 0)
+    return NULL;
+  
+  i = 0;
+  tmp = screen->workspaces;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      if (i == idx)
+        return w;
+
+      ++i;
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+static void
+set_number_of_spaces_hint (MetaScreen *screen,
+			   int         n_spaces)
+{
+  unsigned long data[1];
+
+  if (screen->closing > 0)
+    return;
+
+  data[0] = n_spaces;
+
+  meta_verbose ("Setting _NET_NUMBER_OF_DESKTOPS to %lu\n", data[0]);
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_NUMBER_OF_DESKTOPS,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+set_desktop_geometry_hint (MetaScreen *screen)
+{
+  unsigned long data[2];
+
+  if (screen->closing > 0)
+    return;
+
+  data[0] = screen->rect.width;
+  data[1] = screen->rect.height;
+
+  meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %lu, %lu\n", data[0], data[1]);
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_DESKTOP_GEOMETRY,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+set_desktop_viewport_hint (MetaScreen *screen)
+{
+  unsigned long data[2];
+
+  if (screen->closing > 0)
+    return;
+
+  /*
+   * Marco does not implement viewports, so this is a fixed 0,0
+   */
+  data[0] = 0;
+  data[1] = 0;
+
+  meta_verbose ("Setting _NET_DESKTOP_VIEWPORT to 0, 0\n");
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_DESKTOP_VIEWPORT,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+update_num_workspaces (MetaScreen *screen,
+                       guint32     timestamp)
+{
+  int new_num;
+  GList *tmp;
+  int i;
+  GList *extras;
+  MetaWorkspace *last_remaining;
+  gboolean need_change_space;
+  
+  new_num = meta_prefs_get_num_workspaces ();
+
+  g_assert (new_num > 0);
+
+  last_remaining = NULL;
+  extras = NULL;
+  i = 0;
+  tmp = screen->workspaces;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      if (i >= new_num)
+        extras = g_list_prepend (extras, w);
+      else
+        last_remaining = w;
+          
+      ++i;
+      tmp = tmp->next;
+    }
+
+  g_assert (last_remaining);
+  
+  /* Get rid of the extra workspaces by moving all their windows
+   * to last_remaining, then activating last_remaining if
+   * one of the removed workspaces was active. This will be a bit
+   * wacky if the config tool for changing number of workspaces
+   * is on a removed workspace ;-)
+   */
+  need_change_space = FALSE;
+  tmp = extras;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      meta_workspace_relocate_windows (w, last_remaining);      
+
+      if (w == screen->active_workspace)
+        need_change_space = TRUE;
+      
+      tmp = tmp->next;
+    }
+
+  if (need_change_space)
+    meta_workspace_activate (last_remaining, timestamp);
+
+  /* Should now be safe to free the workspaces */
+  tmp = extras;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      g_assert (w->windows == NULL);
+      meta_workspace_free (w);
+      
+      tmp = tmp->next;
+    }
+  
+  g_list_free (extras);
+  
+  while (i < new_num)
+    {
+      meta_workspace_new (screen);
+      ++i;
+    }
+
+  set_number_of_spaces_hint (screen, new_num);
+
+  meta_screen_queue_workarea_recalc (screen);
+}
+
+static void
+update_focus_mode (MetaScreen *screen)
+{
+  /* nothing to do anymore */ ;
+}
+
+void
+meta_screen_set_cursor (MetaScreen *screen,
+                        MetaCursor  cursor)
+{
+  Cursor xcursor;
+
+  if (cursor == screen->current_cursor)
+    return;
+
+  screen->current_cursor = cursor;
+  
+  xcursor = meta_display_create_x_cursor (screen->display, cursor);
+  XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
+  XFreeCursor (screen->display->xdisplay, xcursor);
+}
+
+void
+meta_screen_update_cursor (MetaScreen *screen)
+{
+  Cursor xcursor;
+
+  xcursor = meta_display_create_x_cursor (screen->display, 
+					  screen->current_cursor);
+  XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
+  XFreeCursor (screen->display->xdisplay, xcursor);
+}
+
+#define MAX_PREVIEW_SIZE 150.0
+
+static GdkPixbuf *
+get_window_pixbuf (MetaWindow *window,
+                   int        *width,
+                   int        *height)
+{
+  Pixmap pmap;
+  GdkPixbuf *pixbuf, *scaled;
+  double ratio;
+
+  pmap = meta_compositor_get_window_pixmap (window->display->compositor,
+                                            window);
+  if (pmap == None)
+    return NULL;
+
+  pixbuf = meta_ui_get_pixbuf_from_pixmap (pmap);
+  if (pixbuf == NULL) 
+    return NULL;
+
+  *width = gdk_pixbuf_get_width (pixbuf);
+  *height = gdk_pixbuf_get_height (pixbuf);
+
+  /* Scale pixbuf to max dimension MAX_PREVIEW_SIZE */
+  if (*width > *height)
+    {
+      ratio = ((double) *width) / MAX_PREVIEW_SIZE;
+      *width = (int) MAX_PREVIEW_SIZE;
+      *height = (int) (((double) *height) / ratio);
+    }
+  else
+    {
+      ratio = ((double) *height) / MAX_PREVIEW_SIZE;
+      *height = (int) MAX_PREVIEW_SIZE;
+      *width = (int) (((double) *width) / ratio);
+    }
+
+  scaled = gdk_pixbuf_scale_simple (pixbuf, *width, *height,
+                                    GDK_INTERP_BILINEAR);
+  g_object_unref (pixbuf);
+  return scaled;
+}
+                                         
+void
+meta_screen_ensure_tab_popup (MetaScreen      *screen,
+                              MetaTabList      list_type,
+                              MetaTabShowType  show_type)
+{
+  MetaTabEntry *entries;
+  GList *tab_list;
+  GList *tmp;
+  int len;
+  int i;
+
+  if (screen->tab_popup)
+    return;
+
+  tab_list = meta_display_get_tab_list (screen->display,
+                                        list_type,
+                                        screen,
+                                        screen->active_workspace);
+  
+  len = g_list_length (tab_list);
+
+  entries = g_new (MetaTabEntry, len + 1);
+  entries[len].key = NULL;
+  entries[len].title = NULL;
+  entries[len].icon = NULL;
+  
+  i = 0;
+  tmp = tab_list;
+  while (i < len)
+    {
+      MetaWindow *window;
+      MetaRectangle r;
+      GdkPixbuf *win_pixbuf;
+      int width, height;
+
+      window = tmp->data;
+      
+      entries[i].key = (MetaTabEntryKey) window->xwindow;
+      entries[i].title = window->title;
+
+      win_pixbuf = get_window_pixbuf (window, &width, &height);
+      if (win_pixbuf == NULL)
+        entries[i].icon = g_object_ref (window->icon);
+      else
+        {
+          int icon_width, icon_height, t_width, t_height;
+#define ICON_OFFSET 6
+
+          icon_width = gdk_pixbuf_get_width (window->icon);
+          icon_height = gdk_pixbuf_get_height (window->icon);
+
+          t_width = width + ICON_OFFSET;
+          t_height = height + ICON_OFFSET;
+
+          entries[i].icon = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
+                                            t_width, t_height);
+          gdk_pixbuf_fill (entries[i].icon, 0x00000000);
+          gdk_pixbuf_copy_area (win_pixbuf, 0, 0, width, height,
+                                entries[i].icon, 0, 0);
+          g_object_unref (win_pixbuf);
+          gdk_pixbuf_composite (window->icon, entries[i].icon, 
+                                t_width - icon_width, t_height - icon_height,
+                                icon_width, icon_height,
+                                t_width - icon_width, t_height - icon_height, 
+                                1.0, 1.0, GDK_INTERP_BILINEAR, 255);
+        }
+                                
+      entries[i].blank = FALSE;
+      entries[i].hidden = !meta_window_showing_on_its_workspace (window);
+      entries[i].demands_attention = window->wm_state_demands_attention;
+      
+      if (show_type == META_TAB_SHOW_INSTANTLY ||
+          !entries[i].hidden                   ||
+          !meta_window_get_icon_geometry (window, &r))
+        meta_window_get_outer_rect (window, &r);
+      
+      entries[i].rect = r;
+
+      /* Find inside of highlight rectangle to be used when window is
+       * outlined for tabbing.  This should be the size of the
+       * east/west frame, and the size of the south frame, on those
+       * sides.  On the top it should be the size of the south frame
+       * edge.
+       */
+#define OUTLINE_WIDTH 5
+      /* Top side */
+      if (!entries[i].hidden &&
+          window->frame && window->frame->bottom_height > 0 &&
+          window->frame->child_y >= window->frame->bottom_height)
+        entries[i].inner_rect.y = window->frame->bottom_height;
+      else
+        entries[i].inner_rect.y = OUTLINE_WIDTH;
+
+      /* Bottom side */
+      if (!entries[i].hidden &&
+          window->frame && window->frame->bottom_height != 0)
+        entries[i].inner_rect.height = r.height
+          - entries[i].inner_rect.y - window->frame->bottom_height;
+      else
+        entries[i].inner_rect.height = r.height
+          - entries[i].inner_rect.y - OUTLINE_WIDTH;
+
+      /* Left side */
+      if (!entries[i].hidden && window->frame && window->frame->child_x != 0)
+        entries[i].inner_rect.x = window->frame->child_x;
+      else
+        entries[i].inner_rect.x = OUTLINE_WIDTH;
+
+      /* Right side */
+      if (!entries[i].hidden &&
+          window->frame && window->frame->right_width != 0)
+        entries[i].inner_rect.width = r.width
+          - entries[i].inner_rect.x - window->frame->right_width;
+      else
+        entries[i].inner_rect.width = r.width
+          - entries[i].inner_rect.x - OUTLINE_WIDTH;
+      
+      ++i;
+      tmp = tmp->next;
+    }
+
+  screen->tab_popup = meta_ui_tab_popup_new (entries, 
+                                             screen->number,
+                                             len,
+                                             5, /* FIXME */
+                                             TRUE);
+
+  for (i = 0; i < len; i++) 
+    g_object_unref (entries[i].icon);
+
+  g_free (entries);
+
+  g_list_free (tab_list);
+  
+  /* don't show tab popup, since proper window isn't selected yet */
+}
+
+void
+meta_screen_ensure_workspace_popup (MetaScreen *screen)
+{
+  MetaTabEntry *entries;
+  int len;
+  int i;
+  MetaWorkspaceLayout layout;
+  int n_workspaces;
+  int current_workspace;
+  
+  if (screen->tab_popup)
+    return;
+
+  current_workspace = meta_workspace_index (screen->active_workspace);
+  n_workspaces = meta_screen_get_n_workspaces (screen);
+
+  meta_screen_calc_workspace_layout (screen, n_workspaces,
+                                     current_workspace, &layout);
+
+  len = layout.grid_area;
+  
+  entries = g_new (MetaTabEntry, len + 1);
+  entries[len].key = NULL;
+  entries[len].title = NULL;
+  entries[len].icon = NULL;
+
+  i = 0;
+  while (i < len)
+    {
+      if (layout.grid[i] >= 0)
+        {
+          MetaWorkspace *workspace;
+          
+          workspace = meta_screen_get_workspace_by_index (screen,
+                                                          layout.grid[i]);
+          
+          entries[i].key = (MetaTabEntryKey) workspace;
+          entries[i].title = meta_workspace_get_name (workspace);
+          entries[i].icon = NULL;
+          entries[i].blank = FALSE;
+          
+          g_assert (entries[i].title != NULL);
+        }
+      else
+        {
+          entries[i].key = NULL;
+          entries[i].title = NULL;
+          entries[i].icon = NULL;
+          entries[i].blank = TRUE;
+        }
+      entries[i].hidden = FALSE;
+      entries[i].demands_attention = FALSE;
+
+      ++i;
+    }
+
+  screen->tab_popup = meta_ui_tab_popup_new (entries, 
+                                             screen->number,
+                                             len,
+                                             layout.cols,
+                                             FALSE);      
+
+  g_free (entries);
+  meta_screen_free_workspace_layout (&layout);
+
+  /* don't show tab popup, since proper space isn't selected yet */
+}
+
+MetaWindow*
+meta_screen_get_mouse_window (MetaScreen  *screen,
+                              MetaWindow  *not_this_one)
+{
+  MetaWindow *window;
+  Window root_return, child_return;
+  int root_x_return, root_y_return;
+  int win_x_return, win_y_return;
+  unsigned int mask_return;
+  
+  if (not_this_one)
+    meta_topic (META_DEBUG_FOCUS,
+                "Focusing mouse window excluding %s\n", not_this_one->desc);
+
+  meta_error_trap_push (screen->display);
+  XQueryPointer (screen->display->xdisplay,
+                 screen->xroot,
+                 &root_return,
+                 &child_return,
+                 &root_x_return,
+                 &root_y_return,
+                 &win_x_return,
+                 &win_y_return,
+                 &mask_return);
+  meta_error_trap_pop (screen->display, TRUE);
+
+  window = meta_stack_get_default_focus_window_at_point (screen->stack,
+                                                         screen->active_workspace,
+                                                         not_this_one,
+                                                         root_x_return,
+                                                         root_y_return);
+
+  return window;
+}
+
+const MetaXineramaScreenInfo*
+meta_screen_get_xinerama_for_rect (MetaScreen    *screen,
+				   MetaRectangle *rect)
+{
+  int i;
+  int best_xinerama, xinerama_score;
+
+  if (screen->n_xinerama_infos == 1)
+    return &screen->xinerama_infos[0];
+
+  best_xinerama = 0;
+  xinerama_score = 0;
+
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      MetaRectangle dest;
+      if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect,
+                                    rect,
+                                    &dest))
+        {
+          int cur = meta_rectangle_area (&dest);
+          if (cur > xinerama_score)
+            {
+              xinerama_score = cur;
+              best_xinerama = i;
+            }
+        }
+    }
+
+  return &screen->xinerama_infos[best_xinerama];
+}
+
+const MetaXineramaScreenInfo*
+meta_screen_get_xinerama_for_window (MetaScreen *screen,
+				     MetaWindow *window)
+{
+  MetaRectangle window_rect;
+  
+  meta_window_get_outer_rect (window, &window_rect);
+
+  return meta_screen_get_xinerama_for_rect (screen, &window_rect);
+}
+
+const MetaXineramaScreenInfo* 
+meta_screen_get_xinerama_neighbor (MetaScreen         *screen,
+                                   int                 which_xinerama,
+                                   MetaScreenDirection direction)
+{
+  MetaXineramaScreenInfo* input = screen->xinerama_infos + which_xinerama;
+  MetaXineramaScreenInfo* current;
+  int i;
+
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      current = screen->xinerama_infos + i;
+
+      if ((direction == META_SCREEN_RIGHT && 
+           current->rect.x == input->rect.x + input->rect.width &&
+           meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
+          (direction == META_SCREEN_LEFT && 
+           input->rect.x == current->rect.x + current->rect.width &&
+           meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
+          (direction == META_SCREEN_UP && 
+           input->rect.y == current->rect.y + current->rect.height &&
+           meta_rectangle_horiz_overlap(&current->rect, &input->rect)) ||
+          (direction == META_SCREEN_DOWN && 
+           current->rect.y == input->rect.y + input->rect.height &&
+           meta_rectangle_horiz_overlap(&current->rect, &input->rect)))
+        {
+          return current;
+        }
+    }
+  
+  return NULL;
+}
+
+void
+meta_screen_get_natural_xinerama_list (MetaScreen *screen,
+                                       int**       xineramas_list,
+                                       int*        n_xineramas)
+{
+  const MetaXineramaScreenInfo* current;
+  const MetaXineramaScreenInfo* tmp;
+  GQueue* xinerama_queue;
+  int* visited;
+  int cur = 0;
+  int i;
+
+  *n_xineramas = screen->n_xinerama_infos;
+  *xineramas_list = g_new (int, screen->n_xinerama_infos);
+
+  /* we calculate a natural ordering by which to choose xineramas for
+   * window placement.  We start at the current xinerama, and perform
+   * a breadth-first search of the xineramas starting from that
+   * xinerama.  We choose preferentially left, then right, then down,
+   * then up.  The visitation order produced by this traversal is the
+   * natural xinerama ordering.
+   */
+
+  visited = g_new (int, screen->n_xinerama_infos);
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      visited[i] = FALSE;
+    }
+
+  current = meta_screen_get_current_xinerama (screen);
+  xinerama_queue = g_queue_new ();
+  g_queue_push_tail (xinerama_queue, (gpointer) current);
+  visited[current->number] = TRUE;
+
+  while (!g_queue_is_empty (xinerama_queue))
+    {
+      current = (const MetaXineramaScreenInfo*) 
+        g_queue_pop_head (xinerama_queue);
+
+      (*xineramas_list)[cur++] = current->number;
+
+      /* enqueue each of the directions */
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_LEFT);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_RIGHT);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_UP);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_DOWN);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+    }
+
+  /* in case we somehow missed some set of xineramas, go through the
+   * visited list and add in any xineramas that were missed
+   */
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      if (visited[i] == FALSE)
+        {
+          (*xineramas_list)[cur++] = i;
+        }
+    }
+
+  g_free (visited);
+  g_queue_free (xinerama_queue);
+}
+
+const MetaXineramaScreenInfo*
+meta_screen_get_current_xinerama (MetaScreen *screen)
+{
+  if (screen->n_xinerama_infos == 1)
+    return &screen->xinerama_infos[0];
+  
+  /* Sadly, we have to do it this way. Yuck.
+   */
+  
+  if (screen->display->xinerama_cache_invalidated)
+    {
+      Window root_return, child_return;
+      int win_x_return, win_y_return;
+      unsigned int mask_return;
+      int i;
+      MetaRectangle pointer_position;
+      
+      screen->display->xinerama_cache_invalidated = FALSE;
+      
+      pointer_position.width = pointer_position.height = 1;
+      XQueryPointer (screen->display->xdisplay,
+                     screen->xroot,
+                     &root_return,
+                     &child_return,
+                     &pointer_position.x,
+                     &pointer_position.y,
+                     &win_x_return,
+                     &win_y_return,
+                     &mask_return);
+
+      screen->last_xinerama_index = 0;
+      for (i = 0; i < screen->n_xinerama_infos; i++)
+        {
+          if (meta_rectangle_contains_rect (&screen->xinerama_infos[i].rect,
+                                            &pointer_position))
+            {
+              screen->last_xinerama_index = i;
+              break;
+            }
+        }
+      
+      meta_topic (META_DEBUG_XINERAMA,
+                  "Rechecked current Xinerama, now %d\n",
+                  screen->last_xinerama_index);
+    }
+
+  return &screen->xinerama_infos[screen->last_xinerama_index];
+}
+
+#define _NET_WM_ORIENTATION_HORZ 0
+#define _NET_WM_ORIENTATION_VERT 1
+
+#define _NET_WM_TOPLEFT     0
+#define _NET_WM_TOPRIGHT    1
+#define _NET_WM_BOTTOMRIGHT 2
+#define _NET_WM_BOTTOMLEFT  3
+
+void
+meta_screen_update_workspace_layout (MetaScreen *screen)
+{
+  gulong *list;
+  int n_items;
+  
+  list = NULL;
+  n_items = 0;
+
+  if (meta_prop_get_cardinal_list (screen->display,
+                                   screen->xroot,
+                                   screen->display->atom__NET_DESKTOP_LAYOUT,
+                                   &list, &n_items))
+    {
+      if (n_items == 3 || n_items == 4)
+        {
+          int cols, rows;
+          
+          switch (list[0])
+            {
+            case _NET_WM_ORIENTATION_HORZ:
+              screen->vertical_workspaces = FALSE;
+              break;
+            case _NET_WM_ORIENTATION_VERT:
+              screen->vertical_workspaces = TRUE;
+              break;
+            default:
+              meta_warning ("Someone set a weird orientation in _NET_DESKTOP_LAYOUT\n");
+              break;
+            }
+
+          cols = list[1];
+          rows = list[2];
+
+          if (rows <= 0 && cols <= 0)
+            {
+              meta_warning ("Columns = %d rows = %d in _NET_DESKTOP_LAYOUT makes no sense\n", rows, cols);
+            }
+          else
+            {
+              if (rows > 0)
+                screen->rows_of_workspaces = rows;
+              else
+                screen->rows_of_workspaces = -1;
+              
+              if (cols > 0)
+                screen->columns_of_workspaces = cols;
+              else
+                screen->columns_of_workspaces = -1;
+            }
+
+          if (n_items == 4)
+            {
+              switch (list[3])
+                {
+                  case _NET_WM_TOPLEFT:
+                    screen->starting_corner = META_SCREEN_TOPLEFT;
+                    break;
+                  case _NET_WM_TOPRIGHT:
+                    screen->starting_corner = META_SCREEN_TOPRIGHT;
+                    break;
+                  case _NET_WM_BOTTOMRIGHT:
+                    screen->starting_corner = META_SCREEN_BOTTOMRIGHT;
+                    break;
+                  case _NET_WM_BOTTOMLEFT:
+                    screen->starting_corner = META_SCREEN_BOTTOMLEFT;
+                    break;
+                  default:
+                    meta_warning ("Someone set a weird starting corner in _NET_DESKTOP_LAYOUT\n");
+                    break;
+                }
+            }
+          else
+            screen->starting_corner = META_SCREEN_TOPLEFT;
+        }
+      else
+        {
+          meta_warning ("Someone set _NET_DESKTOP_LAYOUT to %d integers instead of 4 "
+                        "(3 is accepted for backwards compat)\n", n_items);
+        }
+
+      meta_XFree (list);
+    }
+
+  meta_verbose ("Workspace layout rows = %d cols = %d orientation = %d starting corner = %u\n",
+                screen->rows_of_workspaces,
+                screen->columns_of_workspaces,
+                screen->vertical_workspaces,
+                screen->starting_corner);
+}
+
+static void
+set_workspace_names (MetaScreen *screen)
+{
+  /* This updates names on root window when the pref changes,
+   * note we only get prefs change notify if things have
+   * really changed.
+   */
+  GString *flattened;
+  int i;
+  int n_spaces;
+
+  /* flatten to nul-separated list */
+  n_spaces = meta_screen_get_n_workspaces (screen);
+  flattened = g_string_new ("");
+  i = 0;
+  while (i < n_spaces)
+    {
+      const char *name;
+
+      name = meta_prefs_get_workspace_name (i);
+
+      if (name)
+        g_string_append_len (flattened, name,
+                             strlen (name) + 1);
+      else
+        g_string_append_len (flattened, "", 1);
+      
+      ++i;
+    }
+  
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay,
+                   screen->xroot,
+                   screen->display->atom__NET_DESKTOP_NAMES,
+		   screen->display->atom_UTF8_STRING,
+                   8, PropModeReplace,
+		   (unsigned char *)flattened->str, flattened->len);
+  meta_error_trap_pop (screen->display, FALSE);
+  
+  g_string_free (flattened, TRUE);
+}
+
+void
+meta_screen_update_workspace_names (MetaScreen *screen)
+{
+  char **names;
+  int n_names;
+  int i;
+
+  /* this updates names in prefs when the root window property changes,
+   * iff the new property contents don't match what's already in prefs
+   */
+  
+  names = NULL;
+  n_names = 0;
+  if (!meta_prop_get_utf8_list (screen->display,
+                                screen->xroot,
+                                screen->display->atom__NET_DESKTOP_NAMES,
+                                &names, &n_names))
+    {
+      meta_verbose ("Failed to get workspace names from root window %d\n",
+                    screen->number);
+      return;
+    }
+
+  i = 0;
+  while (i < n_names)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Setting workspace %d name to \"%s\" due to _NET_DESKTOP_NAMES change\n",
+                  i, names[i] ? names[i] : "null");
+      meta_prefs_change_workspace_name (i, names[i]);
+      
+      ++i;
+    }
+  
+  g_strfreev (names);
+}
+
+Window
+meta_create_offscreen_window (Display *xdisplay,
+                              Window   parent,
+                              long     valuemask)
+{
+  XSetWindowAttributes attrs;
+
+  /* we want to be override redirect because sometimes we
+   * create a window on a screen we aren't managing.
+   * (but on a display we are managing at least one screen for)
+   */
+  attrs.override_redirect = True;
+  attrs.event_mask = valuemask;
+  
+  return XCreateWindow (xdisplay,
+                        parent,
+                        -100, -100, 1, 1,
+                        0,
+                        CopyFromParent,
+                        CopyFromParent,
+                        (Visual *)CopyFromParent,
+                        CWOverrideRedirect | CWEventMask,
+                        &attrs);
+}
+
+static void
+set_work_area_hint (MetaScreen *screen)
+{
+  int num_workspaces;
+  GList *tmp_list;
+  unsigned long *data, *tmp;
+  MetaRectangle area;
+  
+  num_workspaces = meta_screen_get_n_workspaces (screen);
+  data = g_new (unsigned long, num_workspaces * 4);
+  tmp_list = screen->workspaces;
+  tmp = data;
+  
+  while (tmp_list != NULL)
+    {
+      MetaWorkspace *workspace = tmp_list->data;
+
+      if (workspace->screen == screen)
+        {
+          meta_workspace_get_work_area_all_xineramas (workspace, &area);
+          tmp[0] = area.x;
+          tmp[1] = area.y;
+          tmp[2] = area.width;
+          tmp[3] = area.height;
+
+	  tmp += 4;
+        }
+      
+      tmp_list = tmp_list->next;
+    }
+  
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+		   screen->display->atom__NET_WORKAREA,
+		   XA_CARDINAL, 32, PropModeReplace,
+		   (guchar*) data, num_workspaces*4);
+  g_free (data);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static gboolean
+set_work_area_idle_func (MetaScreen *screen)
+{
+  meta_topic (META_DEBUG_WORKAREA,
+              "Running work area idle function\n");
+  
+  screen->work_area_idle = 0;
+  
+  set_work_area_hint (screen);
+  
+  return FALSE;
+}
+
+void
+meta_screen_queue_workarea_recalc (MetaScreen *screen)
+{
+  /* Recompute work area in an idle */
+  if (screen->work_area_idle == 0)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Adding work area hint idle function\n");
+      screen->work_area_idle =
+        g_idle_add_full (META_PRIORITY_WORK_AREA_HINT,
+                         (GSourceFunc) set_work_area_idle_func,
+                         screen,
+                         NULL);
+    }
+}
+
+
+#ifdef WITH_VERBOSE_MODE
+static char *
+meta_screen_corner_to_string (MetaScreenCorner corner)
+{
+  switch (corner)
+    {
+    case META_SCREEN_TOPLEFT:
+      return "TopLeft";
+    case META_SCREEN_TOPRIGHT:
+      return "TopRight";
+    case META_SCREEN_BOTTOMLEFT:
+      return "BottomLeft";
+    case META_SCREEN_BOTTOMRIGHT:
+      return "BottomRight";
+    }
+
+  return "Unknown";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+void
+meta_screen_calc_workspace_layout (MetaScreen          *screen,
+                                   int                  num_workspaces,
+                                   int                  current_space,
+                                   MetaWorkspaceLayout *layout)
+{
+  int rows, cols;
+  int grid_area;
+  int *grid;
+  int i, r, c;
+  int current_row, current_col;
+  
+  rows = screen->rows_of_workspaces;
+  cols = screen->columns_of_workspaces;
+  if (rows <= 0 && cols <= 0)
+    cols = num_workspaces;
+
+  if (rows <= 0)
+    rows = num_workspaces / cols + ((num_workspaces % cols) > 0 ? 1 : 0);
+  if (cols <= 0)
+    cols = num_workspaces / rows + ((num_workspaces % rows) > 0 ? 1 : 0);
+
+  /* paranoia */
+  if (rows < 1)
+    rows = 1;
+  if (cols < 1)
+    cols = 1;
+
+  g_assert (rows != 0 && cols != 0);
+  
+  grid_area = rows * cols;
+  
+  meta_verbose ("Getting layout rows = %d cols = %d current = %d "
+                "num_spaces = %d vertical = %s corner = %s\n",
+                rows, cols, current_space, num_workspaces,
+                screen->vertical_workspaces ? "(true)" : "(false)",
+                meta_screen_corner_to_string (screen->starting_corner));
+  
+  /* ok, we want to setup the distances in the workspace array to go     
+   * in each direction. Remember, there are many ways that a workspace   
+   * array can be setup.                                                 
+   * see http://www.freedesktop.org/standards/wm-spec/1.2/html/x109.html 
+   * and look at the _NET_DESKTOP_LAYOUT section for details.            
+   * For instance:
+   */
+  /* starting_corner = META_SCREEN_TOPLEFT                         
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       1234                                    1357            
+   *       5678                                    2468            
+   *                                                               
+   * starting_corner = META_SCREEN_TOPRIGHT                        
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       4321                                    7531            
+   *       8765                                    8642            
+   *                                                               
+   * starting_corner = META_SCREEN_BOTTOMLEFT                      
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       5678                                    2468            
+   *       1234                                    1357            
+   *                                                               
+   * starting_corner = META_SCREEN_BOTTOMRIGHT                     
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       8765                                    8642            
+   *       4321                                    7531            
+   *
+   */
+  /* keep in mind that we could have a ragged layout, e.g. the "8"
+   * in the above grids could be missing
+   */
+
+  
+  grid = g_new (int, grid_area);
+
+  current_row = -1;
+  current_col = -1;
+  i = 0;
+  
+  switch (screen->starting_corner) 
+    {
+    case META_SCREEN_TOPLEFT:
+      if (screen->vertical_workspaces) 
+        {
+          c = 0;
+          while (c < cols)
+            {
+              r = 0;
+              while (r < rows)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++r;
+                }
+              ++c;
+            }
+        }
+      else
+        {
+          r = 0;
+          while (r < rows)
+            {
+              c = 0;
+              while (c < cols)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++c;
+                }
+              ++r;
+            }
+        }
+      break;
+    case META_SCREEN_TOPRIGHT:
+      if (screen->vertical_workspaces) 
+        {
+          c = cols - 1;
+          while (c >= 0)
+            {
+              r = 0;
+              while (r < rows)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++r;
+                }
+              --c;
+            }
+        }
+      else
+        {
+          r = 0;
+          while (r < rows)
+            {
+              c = cols - 1;
+              while (c >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --c;
+                }
+              ++r;
+            }
+        }
+      break;
+    case META_SCREEN_BOTTOMLEFT:
+      if (screen->vertical_workspaces) 
+        {
+          c = 0;
+          while (c < cols)
+            {
+              r = rows - 1;
+              while (r >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --r;
+                }
+              ++c;
+            }
+        }
+      else
+        {
+          r = rows - 1;
+          while (r >= 0)
+            {
+              c = 0;
+              while (c < cols)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++c;
+                }
+              --r;
+            }
+        }
+      break;
+    case META_SCREEN_BOTTOMRIGHT:
+      if (screen->vertical_workspaces) 
+        {
+          c = cols - 1;
+          while (c >= 0)
+            {
+              r = rows - 1;
+              while (r >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --r;
+                }
+              --c;
+            }
+        }
+      else
+        {
+          r = rows - 1;
+          while (r >= 0)
+            {
+              c = cols - 1;
+              while (c >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --c;
+                }
+              --r;
+            }
+        }
+      break;
+    }  
+
+  if (i != grid_area)
+    meta_bug ("did not fill in the whole workspace grid in %s (%d filled)\n",
+              G_STRFUNC, i);
+  
+  current_row = 0;
+  current_col = 0;
+  r = 0;
+  while (r < rows)
+    {
+      c = 0;
+      while (c < cols)
+        {
+          if (grid[r*cols+c] == current_space)
+            {
+              current_row = r;
+              current_col = c;
+            }
+          else if (grid[r*cols+c] >= num_workspaces)
+            {
+              /* flag nonexistent spaces with -1 */
+              grid[r*cols+c] = -1;
+            }
+          ++c;
+        }
+      ++r;
+    }
+
+  layout->rows = rows;
+  layout->cols = cols;
+  layout->grid = grid;
+  layout->grid_area = grid_area;
+  layout->current_row = current_row;
+  layout->current_col = current_col;
+
+#ifdef WITH_VERBOSE_MODE
+  if (meta_is_verbose ())
+    {
+      r = 0;
+      while (r < layout->rows)
+        {
+          meta_verbose (" ");
+          meta_push_no_msg_prefix ();
+          c = 0;
+          while (c < layout->cols)
+            {
+              if (r == layout->current_row &&
+                  c == layout->current_col)
+                meta_verbose ("*%2d ", layout->grid[r*layout->cols+c]);
+              else
+                meta_verbose ("%3d ", layout->grid[r*layout->cols+c]);
+              ++c;
+            }
+          meta_verbose ("\n");
+          meta_pop_no_msg_prefix ();
+          ++r;
+        }
+    }
+#endif /* WITH_VERBOSE_MODE */
+}
+
+void
+meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout)
+{
+  g_free (layout->grid);
+}
+
+static void
+meta_screen_resize_func (MetaScreen *screen,
+                         MetaWindow *window,
+                         void       *user_data)
+{
+  if (window->struts)
+    {
+      meta_window_update_struts (window);
+    }
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+
+  meta_window_recalc_features (window);
+}
+
+void
+meta_screen_resize (MetaScreen *screen,
+                    int         width,
+                    int         height)
+{  
+  screen->rect.width = width;
+  screen->rect.height = height;
+
+  reload_xinerama_infos (screen);
+  set_desktop_geometry_hint (screen);
+  
+  /* Queue a resize on all the windows */
+  meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
+}
+
+void
+meta_screen_update_showing_desktop_hint (MetaScreen *screen)
+{
+  unsigned long data[1];
+
+  data[0] = screen->active_workspace->showing_desktop ? 1 : 0;
+      
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_SHOWING_DESKTOP,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+queue_windows_showing (MetaScreen *screen)
+{
+  GSList *windows;
+  GSList *tmp;
+
+  /* Must operate on all windows on display instead of just on the
+   * active_workspace's window list, because the active_workspace's
+   * window list may not contain the on_all_workspace windows.
+   */
+  windows = meta_display_list_windows (screen->display);
+
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (w->screen == screen)
+        meta_window_queue (w, META_QUEUE_CALC_SHOWING);
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+}
+
+void
+meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
+                                                     MetaWindow *keep)
+{
+  GList *windows;
+  GList *tmp;
+
+  windows = screen->active_workspace->windows;
+  
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+      
+      if (w->screen == screen  &&
+          w->has_minimize_func &&
+	  w != keep)
+	meta_window_minimize (w);
+      
+      tmp = tmp->next;
+    }
+}
+
+void
+meta_screen_show_desktop (MetaScreen *screen, 
+                          guint32     timestamp)
+{
+  GList *windows;
+
+  if (screen->active_workspace->showing_desktop)
+    return;
+  
+  screen->active_workspace->showing_desktop = TRUE;
+  
+  queue_windows_showing (screen);
+
+  /* Focus the most recently used META_WINDOW_DESKTOP window, if there is one;
+   * see bug 159257.
+   */
+  windows = screen->active_workspace->mru_list;
+  while (windows != NULL)
+    {
+      MetaWindow *w = windows->data;
+      
+      if (w->screen == screen  && 
+          w->type == META_WINDOW_DESKTOP)
+        {
+          meta_window_focus (w, timestamp);
+          break;
+        }
+      
+      windows = windows->next;
+    }
+
+  
+  meta_screen_update_showing_desktop_hint (screen);
+}
+
+void
+meta_screen_unshow_desktop (MetaScreen *screen)
+{
+  if (!screen->active_workspace->showing_desktop)
+    return;
+
+  screen->active_workspace->showing_desktop = FALSE;
+
+  queue_windows_showing (screen);
+
+  meta_screen_update_showing_desktop_hint (screen);
+}
+
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static gboolean startup_sequence_timeout (void *data);
+
+static void
+update_startup_feedback (MetaScreen *screen)
+{
+  if (screen->startup_sequences != NULL)
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Setting busy cursor\n");
+      meta_screen_set_cursor (screen, META_CURSOR_BUSY);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Setting default cursor\n");
+      meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
+    }
+}
+
+static void
+add_sequence (MetaScreen        *screen,
+              SnStartupSequence *sequence)
+{
+  meta_topic (META_DEBUG_STARTUP,
+              "Adding sequence %s\n",
+              sn_startup_sequence_get_id (sequence));
+  sn_startup_sequence_ref (sequence);
+  screen->startup_sequences = g_slist_prepend (screen->startup_sequences,
+                                               sequence);
+
+  /* our timeout just polls every second, instead of bothering
+   * to compute exactly when we may next time out
+   */
+  if (screen->startup_sequence_timeout == 0)
+    screen->startup_sequence_timeout = g_timeout_add (1000,
+                                                      startup_sequence_timeout,
+                                                      screen);
+
+  update_startup_feedback (screen);
+}
+
+static void
+remove_sequence (MetaScreen        *screen,
+                 SnStartupSequence *sequence)
+{
+  meta_topic (META_DEBUG_STARTUP,
+              "Removing sequence %s\n",
+              sn_startup_sequence_get_id (sequence));
+  
+  screen->startup_sequences = g_slist_remove (screen->startup_sequences,
+                                              sequence);
+  sn_startup_sequence_unref (sequence);
+  
+  if (screen->startup_sequences == NULL &&
+      screen->startup_sequence_timeout != 0)
+    {
+      g_source_remove (screen->startup_sequence_timeout);
+      screen->startup_sequence_timeout = 0;
+    }
+
+  update_startup_feedback (screen);
+}
+
+typedef struct
+{
+  GSList *list;
+  GTimeVal now;
+} CollectTimedOutData;
+
+/* This should be fairly long, as it should never be required unless
+ * apps or .desktop files are buggy, and it's confusing if
+ * OpenOffice or whatever seems to stop launching - people
+ * might decide they need to launch it again.
+ */
+#define STARTUP_TIMEOUT 15000
+
+static void
+collect_timed_out_foreach (void *element,
+                           void *data)
+{
+  CollectTimedOutData *ctod = data;
+  SnStartupSequence *sequence = element;
+  long tv_sec, tv_usec;
+  double elapsed;
+  
+  sn_startup_sequence_get_last_active_time (sequence, &tv_sec, &tv_usec);
+
+  elapsed =
+    ((((double)ctod->now.tv_sec - tv_sec) * G_USEC_PER_SEC +
+      (ctod->now.tv_usec - tv_usec))) / 1000.0;
+
+  meta_topic (META_DEBUG_STARTUP,
+              "Sequence used %g seconds vs. %g max: %s\n",
+              elapsed, (double) STARTUP_TIMEOUT,
+              sn_startup_sequence_get_id (sequence));
+  
+  if (elapsed > STARTUP_TIMEOUT)
+    ctod->list = g_slist_prepend (ctod->list, sequence);
+}
+
+static gboolean
+startup_sequence_timeout (void *data)
+{
+  MetaScreen *screen = data;
+  CollectTimedOutData ctod;
+  GSList *tmp;
+  
+  ctod.list = NULL;
+  g_get_current_time (&ctod.now);
+  g_slist_foreach (screen->startup_sequences,
+                   collect_timed_out_foreach,
+                   &ctod);
+
+  tmp = ctod.list;
+  while (tmp != NULL)
+    {
+      SnStartupSequence *sequence = tmp->data;
+
+      meta_topic (META_DEBUG_STARTUP,
+                  "Timed out sequence %s\n",
+                  sn_startup_sequence_get_id (sequence));
+      
+      sn_startup_sequence_complete (sequence);
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (ctod.list);
+  
+  if (screen->startup_sequences != NULL)
+    {
+      return TRUE;
+    }
+  else
+    {
+      /* remove */
+      screen->startup_sequence_timeout = 0;
+      return FALSE;
+    }
+}
+
+static void
+meta_screen_sn_event (SnMonitorEvent *event,
+                      void           *user_data)
+{
+  MetaScreen *screen;
+  SnStartupSequence *sequence;
+  
+  screen = user_data;
+
+  sequence = sn_monitor_event_get_startup_sequence (event);
+  
+  switch (sn_monitor_event_get_type (event))
+    {
+    case SN_MONITOR_EVENT_INITIATED:
+      {
+        const char *wmclass;
+
+        wmclass = sn_startup_sequence_get_wmclass (sequence);
+        
+        meta_topic (META_DEBUG_STARTUP,
+                    "Received startup initiated for %s wmclass %s\n",
+                    sn_startup_sequence_get_id (sequence),
+                    wmclass ? wmclass : "(unset)");
+        add_sequence (screen, sequence);
+      }
+      break;
+
+    case SN_MONITOR_EVENT_COMPLETED:
+      {
+        meta_topic (META_DEBUG_STARTUP,
+                    "Received startup completed for %s\n",
+                    sn_startup_sequence_get_id (sequence));
+        remove_sequence (screen,
+                         sn_monitor_event_get_startup_sequence (event));
+      }
+      break;
+
+    case SN_MONITOR_EVENT_CHANGED:
+      meta_topic (META_DEBUG_STARTUP,
+                  "Received startup changed for %s\n",
+                  sn_startup_sequence_get_id (sequence));
+      break;
+
+    case SN_MONITOR_EVENT_CANCELED:
+      meta_topic (META_DEBUG_STARTUP,
+                  "Received startup canceled for %s\n",
+                  sn_startup_sequence_get_id (sequence));
+      break;
+    }
+}
+#endif
+
+/* Sets the initial_timestamp and initial_workspace properties
+ * of a window according to information given us by the
+ * startup-notification library.
+ *
+ * Returns TRUE if startup properties have been applied, and
+ * FALSE if they have not (for example, if they had already
+ * been applied.)
+ */
+gboolean
+meta_screen_apply_startup_properties (MetaScreen *screen,
+                                      MetaWindow *window)
+{
+#ifdef HAVE_STARTUP_NOTIFICATION
+  const char *startup_id;
+  GSList *tmp;
+  SnStartupSequence *sequence;
+  
+  /* Does the window have a startup ID stored? */
+  startup_id = meta_window_get_startup_id (window);
+
+  meta_topic (META_DEBUG_STARTUP,
+              "Applying startup props to %s id \"%s\"\n",
+              window->desc,
+              startup_id ? startup_id : "(none)");
+  
+  sequence = NULL;
+  if (startup_id == NULL)
+    {
+      /* No startup ID stored for the window. Let's ask the
+       * startup-notification library whether there's anything
+       * stored for the resource name or resource class hints.
+       */
+      tmp = screen->startup_sequences;
+      while (tmp != NULL)
+        {
+          const char *wmclass;
+
+          wmclass = sn_startup_sequence_get_wmclass (tmp->data);
+
+          if (wmclass != NULL &&
+              ((window->res_class &&
+                strcmp (wmclass, window->res_class) == 0) ||
+               (window->res_name &&
+                strcmp (wmclass, window->res_name) == 0)))
+            {
+              sequence = tmp->data;
+
+              g_assert (window->startup_id == NULL);
+              window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence));
+              startup_id = window->startup_id;
+
+              meta_topic (META_DEBUG_STARTUP,
+                          "Ending legacy sequence %s due to window %s\n",
+                          sn_startup_sequence_get_id (sequence),
+                          window->desc);
+              
+              sn_startup_sequence_complete (sequence);
+              break;
+            }
+          
+          tmp = tmp->next;
+        }
+    }
+
+  /* Still no startup ID? Bail. */
+  if (startup_id == NULL)
+    return FALSE;
+  
+  /* We might get this far and not know the sequence ID (if the window
+   * already had a startup ID stored), so let's look for one if we don't
+   * already know it.
+   */
+  if (sequence == NULL)
+    {
+      tmp = screen->startup_sequences;
+      while (tmp != NULL)
+        {
+          const char *id;
+          
+          id = sn_startup_sequence_get_id (tmp->data);
+          
+          if (strcmp (id, startup_id) == 0)
+            {
+              sequence = tmp->data;
+              break;
+            }
+          
+          tmp = tmp->next;
+        }
+    }
+
+  if (sequence != NULL)
+    {
+      gboolean changed_something = FALSE;
+          
+      meta_topic (META_DEBUG_STARTUP,
+                  "Found startup sequence for window %s ID \"%s\"\n",
+                  window->desc, startup_id);
+
+      if (!window->initial_workspace_set)
+        {
+          int space = sn_startup_sequence_get_workspace (sequence);
+          if (space >= 0)
+            {
+              meta_topic (META_DEBUG_STARTUP,
+                          "Setting initial window workspace to %d based on startup info\n",
+                          space);
+              
+              window->initial_workspace_set = TRUE;
+              window->initial_workspace = space;
+              changed_something = TRUE;
+            }
+        }
+
+      if (!window->initial_timestamp_set)
+        {
+          guint32 timestamp = sn_startup_sequence_get_timestamp (sequence);
+          meta_topic (META_DEBUG_STARTUP,
+                      "Setting initial window timestamp to %u based on startup info\n",
+                      timestamp);
+              
+          window->initial_timestamp_set = TRUE;
+          window->initial_timestamp = timestamp;
+          changed_something = TRUE;
+        }
+
+      return changed_something;
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Did not find startup sequence for window %s ID \"%s\"\n",
+                  window->desc, startup_id);
+    }
+  
+#endif /* HAVE_STARTUP_NOTIFICATION */
+
+  return FALSE;
+}
+
+int
+meta_screen_get_screen_number (MetaScreen *screen)
+{
+  return screen->number;
+}
+
+MetaDisplay *
+meta_screen_get_display (MetaScreen *screen)
+{
+  return screen->display;
+}
+
+Window
+meta_screen_get_xroot (MetaScreen *screen)
+{
+  return screen->xroot;
+}
+
+void 
+meta_screen_get_size (MetaScreen *screen,
+                      int        *width,
+                      int        *height)
+{
+  *width = screen->rect.width;
+  *height = screen->rect.height;
+}
+
+gpointer
+meta_screen_get_compositor_data (MetaScreen *screen)
+{
+  return screen->compositor_data;
+}
+
+void
+meta_screen_set_compositor_data (MetaScreen *screen,
+                                 gpointer    compositor)
+{
+  screen->compositor_data = compositor;
+}
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+void
+meta_screen_set_cm_selection (MetaScreen *screen)
+{
+  char selection[32];
+  Atom a;
+
+  screen->wm_cm_timestamp = meta_display_get_current_time_roundtrip (
+                                                               screen->display);
+
+  g_snprintf (selection, sizeof(selection), "_NET_WM_CM_S%d", screen->number);
+  meta_verbose ("Setting selection: %s\n", selection);
+  a = XInternAtom (screen->display->xdisplay, selection, FALSE);
+  XSetSelectionOwner (screen->display->xdisplay, a, 
+                      screen->wm_cm_selection_window, screen->wm_cm_timestamp);
+}
+
+void
+meta_screen_unset_cm_selection (MetaScreen *screen)
+{
+  char selection[32];
+  Atom a;
+
+  g_snprintf (selection, sizeof(selection), "_NET_WM_CM_S%d", screen->number);
+  a = XInternAtom (screen->display->xdisplay, selection, FALSE);
+  XSetSelectionOwner (screen->display->xdisplay, a,
+                      None, screen->wm_cm_timestamp);
+}
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
diff --git a/src/core/session.c b/src/core/session.c
new file mode 100644
index 00000000..80d22365
--- /dev/null
+++ b/src/core/session.c
@@ -0,0 +1,1831 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Session Management */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington (some code in here from
+ * libmateui, (C) Tom Tromey, Carsten Schaar)
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "session.h"
+#include <X11/Xatom.h>
+
+#include <time.h>
+#include <sys/wait.h>
+
+#ifndef HAVE_SM
+void
+meta_session_init (const char *client_id,
+                   const char *save_file)
+{
+  meta_topic (META_DEBUG_SM, "Compiled without session management support\n");
+}
+
+void
+meta_session_shutdown (void)
+{
+  /* nothing */
+}
+
+const MetaWindowSessionInfo*
+meta_window_lookup_saved_state (MetaWindow *window)
+{
+  return NULL;
+}
+
+void
+meta_window_release_saved_state (const MetaWindowSessionInfo *info)
+{
+  ;
+}
+#else /* HAVE_SM */
+
+#include <X11/ICE/ICElib.h>
+#include <X11/SM/SMlib.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "main.h"
+#include "util.h"
+#include "display-private.h"
+#include "workspace.h"
+
+static void ice_io_error_handler (IceConn connection);
+
+static void new_ice_connection (IceConn connection, IcePointer client_data, 
+				Bool opening, IcePointer *watch_data);
+
+static void        save_state         (void);
+static char*       load_state         (const char *previous_save_file);
+static void        regenerate_save_file (void);
+static const char* full_save_file       (void);
+static void        warn_about_lame_clients_and_finish_interact (gboolean shutdown);
+static void        disconnect         (void);
+
+/* This is called when data is available on an ICE connection.  */
+static gboolean
+process_ice_messages (GIOChannel *channel,
+                      GIOCondition condition,
+                      gpointer client_data)
+{
+  IceConn connection = (IceConn) client_data;
+  IceProcessMessagesStatus status;
+
+  /* This blocks infinitely sometimes. I don't know what
+   * to do about it. Checking "condition" just breaks
+   * session management.
+   */
+  status = IceProcessMessages (connection, NULL, NULL);
+
+  if (status == IceProcessMessagesIOError)
+    {
+#if 0
+      IcePointer context = IceGetConnectionContext (connection);
+#endif
+      
+      /* We were disconnected; close our connection to the
+       * session manager, this will result in the ICE connection
+       * being cleaned up, since it is owned by libSM.
+       */
+      disconnect ();
+      meta_quit (META_EXIT_SUCCESS);
+
+      return FALSE;
+    }
+  
+  return TRUE;
+}
+
+/* This is called when a new ICE connection is made.  It arranges for
+   the ICE connection to be handled via the event loop.  */
+static void
+new_ice_connection (IceConn connection, IcePointer client_data, Bool opening,
+		    IcePointer *watch_data)
+{
+  guint input_id;
+
+  if (opening)
+    {
+      /* Make sure we don't pass on these file descriptors to any
+       * exec'ed children
+       */
+      GIOChannel *channel;
+      
+      fcntl (IceConnectionNumber (connection), F_SETFD,
+             fcntl (IceConnectionNumber (connection), F_GETFD, 0) | FD_CLOEXEC);
+
+      channel = g_io_channel_unix_new (IceConnectionNumber (connection));
+      
+      input_id = g_io_add_watch (channel,
+                                 G_IO_IN | G_IO_ERR,
+                                 process_ice_messages,
+                                 connection);
+
+      g_io_channel_unref (channel);
+      
+      *watch_data = (IcePointer) GUINT_TO_POINTER (input_id);
+    }
+  else 
+    {
+      input_id = GPOINTER_TO_UINT ((gpointer) *watch_data);
+
+      g_source_remove (input_id);
+    }
+}
+
+static IceIOErrorHandler ice_installed_handler;
+
+/* We call any handler installed before (or after) mate_ice_init but 
+   avoid calling the default libICE handler which does an exit() */
+static void
+ice_io_error_handler (IceConn connection)
+{
+    if (ice_installed_handler)
+      (*ice_installed_handler) (connection);
+}    
+
+static void
+ice_init (void)
+{
+  static gboolean ice_initted = FALSE;
+
+  if (! ice_initted)
+    {
+      IceIOErrorHandler default_handler;
+
+      ice_installed_handler = IceSetIOErrorHandler (NULL);
+      default_handler = IceSetIOErrorHandler (ice_io_error_handler);
+
+      if (ice_installed_handler == default_handler)
+	ice_installed_handler = NULL;
+
+      IceAddConnectionWatch (new_ice_connection, NULL);
+
+      ice_initted = TRUE;
+    }
+}
+
+typedef enum
+{
+  STATE_DISCONNECTED,
+  STATE_IDLE,
+  STATE_SAVING_PHASE_1,
+  STATE_WAITING_FOR_PHASE_2,
+  STATE_SAVING_PHASE_2,
+  STATE_WAITING_FOR_INTERACT,
+  STATE_DONE_WITH_INTERACT,
+  STATE_SKIPPING_GLOBAL_SAVE,
+  STATE_FROZEN,
+  STATE_REGISTERING
+} ClientState;
+
+static void save_phase_2_callback       (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void interact_callback           (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void shutdown_cancelled_callback (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void save_complete_callback      (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void die_callback                (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void save_yourself_callback      (SmcConn   smc_conn,
+                                         SmPointer client_data,
+                                         int       save_style,
+                                         Bool      shutdown,
+                                         int       interact_style,
+                                         Bool      fast);
+static void set_clone_restart_commands  (void);
+
+static char *client_id = NULL;
+static gpointer session_connection = NULL;
+static ClientState current_state = STATE_DISCONNECTED;
+static gboolean interaction_allowed = FALSE;
+
+void
+meta_session_init (const char *previous_client_id,
+                   const char *previous_save_file)
+{
+  /* Some code here from twm */
+  char buf[256];
+  unsigned long mask;
+  SmcCallbacks callbacks;
+  char *saved_client_id;
+  
+  meta_topic (META_DEBUG_SM, "Initializing session with save file '%s'\n",
+              previous_save_file ? previous_save_file : "(none)");
+
+  if (previous_save_file)
+    {
+      saved_client_id = load_state (previous_save_file);
+      previous_client_id = saved_client_id;
+    }
+  else if (previous_client_id)
+    {
+      char *save_file = g_strconcat (previous_client_id, ".ms", NULL);
+      saved_client_id = load_state (save_file);
+      g_free (save_file);
+    }
+  else
+    {
+      saved_client_id = NULL;
+    }
+  
+  ice_init ();
+  
+  mask = SmcSaveYourselfProcMask | SmcDieProcMask |
+    SmcSaveCompleteProcMask | SmcShutdownCancelledProcMask;
+  
+  callbacks.save_yourself.callback = save_yourself_callback;
+  callbacks.save_yourself.client_data = NULL;
+  
+  callbacks.die.callback = die_callback;
+  callbacks.die.client_data = NULL;
+  
+  callbacks.save_complete.callback = save_complete_callback;
+  callbacks.save_complete.client_data = NULL;
+  
+  callbacks.shutdown_cancelled.callback = shutdown_cancelled_callback;
+  callbacks.shutdown_cancelled.client_data = NULL;
+  
+  session_connection =
+    SmcOpenConnection (NULL, /* use SESSION_MANAGER env */
+                       NULL, /* means use existing ICE connection */
+                       SmProtoMajor,
+                       SmProtoMinor,
+                       mask,
+                       &callbacks,
+                       (char*) previous_client_id,
+                       &client_id,
+                       255, buf);
+  
+  if (session_connection == NULL)
+    {
+      meta_topic (META_DEBUG_SM, 
+                  "Failed to a open connection to a session manager, so window positions will not be saved: %s\n",
+                  buf);
+
+      goto out;
+    }
+  else
+    {
+      if (client_id == NULL)
+        meta_bug ("Session manager gave us a NULL client ID?");
+      meta_topic (META_DEBUG_SM, "Obtained session ID '%s'\n", client_id);
+    }
+
+  if (previous_client_id && strcmp (previous_client_id, client_id) == 0)
+    current_state = STATE_IDLE;
+  else
+    current_state = STATE_REGISTERING;
+  
+  {
+    SmProp prop1, prop2, prop3, prop4, prop5, prop6, *props[6];
+    SmPropValue prop1val, prop2val, prop3val, prop4val, prop5val, prop6val;
+    char pid[32];
+    char hint = SmRestartImmediately;
+    char priority = 20; /* low to run before other apps */
+    
+    prop1.name = SmProgram;
+    prop1.type = SmARRAY8;
+    prop1.num_vals = 1;
+    prop1.vals = &prop1val;
+    prop1val.value = "marco";
+    prop1val.length = strlen ("marco");
+
+    /* twm sets getuid() for this, but the SM spec plainly
+     * says pw_name, twm is on crack
+     */
+    prop2.name = SmUserID;
+    prop2.type = SmARRAY8;
+    prop2.num_vals = 1;
+    prop2.vals = &prop2val;
+    prop2val.value = (char*) g_get_user_name ();
+    prop2val.length = strlen (prop2val.value);
+	
+    prop3.name = SmRestartStyleHint;
+    prop3.type = SmCARD8;
+    prop3.num_vals = 1;
+    prop3.vals = &prop3val;
+    prop3val.value = &hint;
+    prop3val.length = 1;
+
+    sprintf (pid, "%d", getpid ());
+    prop4.name = SmProcessID;
+    prop4.type = SmARRAY8;
+    prop4.num_vals = 1;
+    prop4.vals = &prop4val;
+    prop4val.value = pid;
+    prop4val.length = strlen (prop4val.value);    
+
+    /* Always start in home directory */
+    prop5.name = SmCurrentDirectory;
+    prop5.type = SmARRAY8;
+    prop5.num_vals = 1;
+    prop5.vals = &prop5val;
+    prop5val.value = (char*) g_get_home_dir ();
+    prop5val.length = strlen (prop5val.value);
+
+    prop6.name = "_GSM_Priority";
+    prop6.type = SmCARD8;
+    prop6.num_vals = 1;
+    prop6.vals = &prop6val;
+    prop6val.value = &priority;
+    prop6val.length = 1;
+    
+    props[0] = &prop1;
+    props[1] = &prop2;
+    props[2] = &prop3;
+    props[3] = &prop4;
+    props[4] = &prop5;
+    props[5] = &prop6;
+    
+    SmcSetProperties (session_connection, 6, props);
+  }
+
+ out:
+  g_free (saved_client_id);
+}
+
+void
+meta_session_shutdown (void)
+{
+  /* Change our restart mode to IfRunning */
+  
+  SmProp prop1;
+  SmPropValue prop1val;
+  SmProp *props[1];
+  char hint = SmRestartIfRunning;
+
+  if (!meta_get_display ())
+    {
+      meta_verbose ("Cannot close session because there is no display");
+      return;
+    }
+
+  warn_about_lame_clients_and_finish_interact (FALSE);
+
+  if (session_connection == NULL)
+    return;
+  
+  prop1.name = SmRestartStyleHint;
+  prop1.type = SmCARD8;
+  prop1.num_vals = 1;
+  prop1.vals = &prop1val;
+  prop1val.value = &hint;
+  prop1val.length = 1;
+    
+  props[0] = &prop1;
+  
+  SmcSetProperties (session_connection, 1, props);
+}
+
+static void
+disconnect (void)
+{
+  SmcCloseConnection (session_connection, 0, NULL);
+  session_connection = NULL;
+  current_state = STATE_DISCONNECTED;
+}
+
+static void
+save_yourself_possibly_done (gboolean shutdown,
+                             gboolean successful)
+{
+  meta_topic (META_DEBUG_SM,
+              "save possibly done shutdown = %d success = %d\n",
+              shutdown, successful);
+  
+  if (current_state == STATE_SAVING_PHASE_1)
+    {
+      Status status;
+      
+      status = SmcRequestSaveYourselfPhase2 (session_connection,
+                                             save_phase_2_callback,
+                                             GINT_TO_POINTER (shutdown));
+
+      if (status)
+        current_state = STATE_WAITING_FOR_PHASE_2;
+
+      meta_topic (META_DEBUG_SM,
+                  "Requested phase 2, status = %d\n", status);
+    }
+
+  if (current_state == STATE_SAVING_PHASE_2 &&
+      interaction_allowed)
+    {
+      Status status;
+
+      status = SmcInteractRequest (session_connection,
+                                   /* ignore this feature of the protocol by always
+                                    * claiming normal
+                                    */
+                                   SmDialogNormal,
+                                   interact_callback,
+                                   GINT_TO_POINTER (shutdown));
+
+      if (status)
+        current_state = STATE_WAITING_FOR_INTERACT;
+
+      meta_topic (META_DEBUG_SM,
+                  "Requested interact, status = %d\n", status);
+    }
+  
+  if (current_state == STATE_SAVING_PHASE_1 ||
+      current_state == STATE_SAVING_PHASE_2 ||
+      current_state == STATE_DONE_WITH_INTERACT ||
+      current_state == STATE_SKIPPING_GLOBAL_SAVE)
+    {
+      meta_topic (META_DEBUG_SM, "Sending SaveYourselfDone\n");
+      
+      SmcSaveYourselfDone (session_connection,
+                           successful);
+      
+      if (shutdown)
+        current_state = STATE_FROZEN;
+      else
+        current_state = STATE_IDLE;
+    }
+}
+
+static void 
+save_phase_2_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  gboolean shutdown;
+
+  meta_topic (META_DEBUG_SM, "Phase 2 save");
+  
+  shutdown = GPOINTER_TO_INT (client_data);
+  
+  current_state = STATE_SAVING_PHASE_2;
+
+  save_state ();
+  
+  save_yourself_possibly_done (shutdown, TRUE);
+}
+
+static void
+save_yourself_callback (SmcConn   smc_conn,
+                        SmPointer client_data,
+                        int       save_style,
+                        Bool      shutdown,
+                        int       interact_style,
+                        Bool      fast)
+{
+  gboolean successful;
+
+  meta_topic (META_DEBUG_SM, "SaveYourself received");
+  
+  successful = TRUE;
+  
+  /* The first SaveYourself after registering for the first time
+   * is a special case (SM specs 7.2).
+   */
+
+#if 0 /* I think the MateClient rationale for this doesn't apply */
+  if (current_state == STATE_REGISTERING)
+    {
+      current_state = STATE_IDLE;
+      /* Double check that this is a section 7.2 SaveYourself: */
+      
+      if (save_style == SmSaveLocal && 
+	  interact_style == SmInteractStyleNone &&
+	  !shutdown && !fast)
+	{
+	  /* The protocol requires this even if xsm ignores it. */
+	  SmcSaveYourselfDone (session_connection, successful);
+	  return;
+	}
+    }
+#endif
+
+  /* ignore Global style saves
+   * 
+   * This interpretaion of the Local/Global/Both styles
+   * was discussed extensively on the xdg-list. See:
+   *
+   * https://listman.redhat.com/pipermail/xdg-list/2002-July/000615.html
+   */
+  if (save_style == SmSaveGlobal)
+    {
+      current_state = STATE_SKIPPING_GLOBAL_SAVE;
+      save_yourself_possibly_done (shutdown, successful);
+      return;
+    }
+
+  interaction_allowed = interact_style != SmInteractStyleNone;
+  
+  current_state = STATE_SAVING_PHASE_1;
+
+  regenerate_save_file ();
+  
+  set_clone_restart_commands ();
+
+  save_yourself_possibly_done (shutdown, successful);
+}
+
+
+static void
+die_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  meta_topic (META_DEBUG_SM, "Exiting at request of session manager\n");
+  disconnect ();
+  meta_quit (META_EXIT_SUCCESS);
+}
+
+static void
+save_complete_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  /* nothing */
+  meta_topic (META_DEBUG_SM, "SaveComplete received\n");
+}
+
+static void
+shutdown_cancelled_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  meta_topic (META_DEBUG_SM, "Shutdown cancelled received\n");
+  
+  if (session_connection != NULL &&
+      (current_state != STATE_IDLE && current_state != STATE_FROZEN))
+    {
+      SmcSaveYourselfDone (session_connection, True);
+      current_state = STATE_IDLE;
+    }
+}
+
+static void 
+interact_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  /* nothing */
+  gboolean shutdown;
+
+  meta_topic (META_DEBUG_SM, "Interaction permission received\n");
+  
+  shutdown = GPOINTER_TO_INT (client_data);
+
+  current_state = STATE_DONE_WITH_INTERACT;
+
+  warn_about_lame_clients_and_finish_interact (shutdown);
+}
+
+static void
+set_clone_restart_commands (void)
+{
+  char *restartv[10];
+  char *clonev[10];
+  char *discardv[10];
+  int i;
+  SmProp prop1, prop2, prop3, *props[3];
+  
+  /* Restart (use same client ID) */
+  
+  prop1.name = SmRestartCommand;
+  prop1.type = SmLISTofARRAY8;
+  
+  g_return_if_fail (client_id);
+  
+  i = 0;
+  restartv[i] = "marco";
+  ++i;
+  restartv[i] = "--sm-client-id";
+  ++i;
+  restartv[i] = client_id;
+  ++i;
+  restartv[i] = NULL;
+
+  prop1.vals = g_new (SmPropValue, i);
+  i = 0;
+  while (restartv[i])
+    {
+      prop1.vals[i].value = restartv[i];
+      prop1.vals[i].length = strlen (restartv[i]);
+      ++i;
+    }
+  prop1.num_vals = i;
+
+  /* Clone (no client ID) */
+  
+  i = 0;
+  clonev[i] = "marco";
+  ++i;
+  clonev[i] = NULL;
+
+  prop2.name = SmCloneCommand;
+  prop2.type = SmLISTofARRAY8;
+  
+  prop2.vals = g_new (SmPropValue, i);
+  i = 0;
+  while (clonev[i])
+    {
+      prop2.vals[i].value = clonev[i];
+      prop2.vals[i].length = strlen (clonev[i]);
+      ++i;
+    }
+  prop2.num_vals = i;
+
+  /* Discard */
+  
+  i = 0;
+  discardv[i] = "rm";
+  ++i;
+  discardv[i] = "-f";
+  ++i;
+  discardv[i] = (char*) full_save_file ();
+  ++i;
+  discardv[i] = NULL;
+  
+  prop3.name = SmDiscardCommand;
+  prop3.type = SmLISTofARRAY8;
+  
+  prop3.vals = g_new (SmPropValue, i);
+  i = 0;
+  while (discardv[i])
+    {
+      prop3.vals[i].value = discardv[i];
+      prop3.vals[i].length = strlen (discardv[i]);
+      ++i;
+    }
+  prop3.num_vals = i;
+
+  
+  props[0] = &prop1;
+  props[1] = &prop2;
+  props[2] = &prop3;
+  
+  SmcSetProperties (session_connection, 3, props);
+
+  g_free (prop1.vals);
+  g_free (prop2.vals);
+  g_free (prop3.vals);
+}
+
+/* The remaining code in this file actually loads/saves the session,
+ * while the code above this comment handles chatting with the
+ * session manager.
+ */
+
+static const char*
+window_type_to_string (MetaWindowType type)
+{
+  switch (type)
+    {
+    case META_WINDOW_NORMAL:
+      return "normal";
+    case META_WINDOW_DESKTOP:
+      return "desktop";
+    case META_WINDOW_DOCK:
+      return "dock";
+    case META_WINDOW_DIALOG:
+      return "dialog";
+    case META_WINDOW_MODAL_DIALOG:
+      return "modal_dialog";
+    case META_WINDOW_TOOLBAR:
+      return "toolbar";
+    case META_WINDOW_MENU:
+      return "menu";
+    case META_WINDOW_SPLASHSCREEN:
+      return "splashscreen";
+    case META_WINDOW_UTILITY:
+      return "utility";
+    }
+
+  return "";
+} 
+
+static MetaWindowType
+window_type_from_string (const char *str)
+{
+  if (strcmp (str, "normal") == 0)
+    return META_WINDOW_NORMAL;
+  else if (strcmp (str, "desktop") == 0)
+    return META_WINDOW_DESKTOP;
+  else if (strcmp (str, "dock") == 0)
+    return META_WINDOW_DOCK;
+  else if (strcmp (str, "dialog") == 0)
+    return META_WINDOW_DIALOG;
+  else if (strcmp (str, "modal_dialog") == 0)
+    return META_WINDOW_MODAL_DIALOG;
+  else if (strcmp (str, "toolbar") == 0)
+    return META_WINDOW_TOOLBAR;
+  else if (strcmp (str, "menu") == 0)
+    return META_WINDOW_MENU;
+  else if (strcmp (str, "utility") == 0)
+    return META_WINDOW_UTILITY;
+  else if (strcmp (str, "splashscreen") == 0)
+    return META_WINDOW_SPLASHSCREEN;
+  else
+    return META_WINDOW_NORMAL;
+}
+
+static int
+window_gravity_from_string (const char *str)
+{
+  if (strcmp (str, "NorthWestGravity") == 0)
+    return NorthWestGravity;
+  else if (strcmp (str, "NorthGravity") == 0)
+    return NorthGravity;
+  else if (strcmp (str, "NorthEastGravity") == 0)
+    return NorthEastGravity;
+  else if (strcmp (str, "WestGravity") == 0)
+    return WestGravity;
+  else if (strcmp (str, "CenterGravity") == 0)
+    return CenterGravity;
+  else if (strcmp (str, "EastGravity") == 0)
+    return EastGravity;
+  else if (strcmp (str, "SouthWestGravity") == 0)
+    return SouthWestGravity;
+  else if (strcmp (str, "SouthGravity") == 0)
+    return SouthGravity;
+  else if (strcmp (str, "SouthEastGravity") == 0)
+    return SouthEastGravity;
+  else if (strcmp (str, "StaticGravity") == 0)
+    return StaticGravity;
+  else
+    return NorthWestGravity;
+}
+
+static char*
+encode_text_as_utf8_markup (const char *text)
+{
+  /* text can be any encoding, and is nul-terminated.
+   * we pretend it's Latin-1 and encode as UTF-8
+   */
+  GString *str;
+  const char *p;
+  char *escaped;
+  
+  str = g_string_new ("");
+
+  p = text;
+  while (*p)
+    {
+      g_string_append_unichar (str, *p);
+      ++p;
+    }
+
+  escaped = g_markup_escape_text (str->str, str->len);
+  g_string_free (str, TRUE);
+  
+  return escaped;
+}
+
+static char*
+decode_text_from_utf8 (const char *text)
+{
+  /* Convert back from the encoded (but not escaped) UTF-8 */
+  GString *str;
+  const char *p;
+
+  str = g_string_new ("");
+  
+  p = text;
+  while (*p)
+    {
+      /* obviously this barfs if the UTF-8 contains chars > 255 */
+      g_string_append_c (str, g_utf8_get_char (p));
+
+      p = g_utf8_next_char (p);
+    }
+
+  return g_string_free (str, FALSE);
+}
+
+static void
+save_state (void)
+{
+  char *marco_dir;
+  char *session_dir;
+  FILE *outfile;
+  GSList *windows;
+  GSList *tmp;
+  int stack_position;
+  
+  g_assert (client_id);
+
+  outfile = NULL;
+  
+  /*
+   * g_get_user_config_dir() is guaranteed to return an existing directory.
+   * Eventually, if SM stays with the WM, I'd like to make this
+   * something like <config>/window_placement in a standard format.
+   * Future optimisers should note also that by the time we get here
+   * we probably already have full_save_path figured out and therefore
+   * can just use the directory name from that.
+   */
+  marco_dir = g_strconcat (g_get_user_config_dir (),
+                              G_DIR_SEPARATOR_S "marco",
+                              NULL);
+  
+  session_dir = g_strconcat (marco_dir,
+                             G_DIR_SEPARATOR_S "sessions",
+                             NULL);
+
+  if (mkdir (marco_dir, 0700) < 0 &&
+      errno != EEXIST)
+    {
+      meta_warning (_("Could not create directory '%s': %s\n"),
+                    marco_dir, g_strerror (errno));
+    }
+
+  if (mkdir (session_dir, 0700) < 0 &&
+      errno != EEXIST)
+    {
+      meta_warning (_("Could not create directory '%s': %s\n"),
+                    session_dir, g_strerror (errno));
+    }
+
+  meta_topic (META_DEBUG_SM, "Saving session to '%s'\n", full_save_file ());
+  
+  outfile = fopen (full_save_file (), "w");
+
+  if (outfile == NULL)
+    {
+      meta_warning (_("Could not open session file '%s' for writing: %s\n"),
+                    full_save_file (), g_strerror (errno));
+      goto out;
+    }
+
+  /* The file format is:
+   * <marco_session id="foo">
+   *   <window id="bar" class="XTerm" name="xterm" title="/foo/bar" role="blah" type="normal" stacking="5">
+   *     <workspace index="2"/>
+   *     <workspace index="4"/>
+   *     <sticky/> <minimized/> <maximized/>
+   *     <geometry x="100" y="100" width="200" height="200" gravity="northwest"/>
+   *   </window>
+   * </marco_session>
+   *
+   * Note that attributes on <window> are the match info we use to
+   * see if the saved state applies to a restored window, and
+   * child elements are the saved state to be applied.
+   * 
+   */
+  
+  fprintf (outfile, "<marco_session id=\"%s\">\n",
+           client_id);
+
+  windows = meta_display_list_windows (meta_get_display ());
+  stack_position = 0;
+
+  windows = g_slist_sort (windows, meta_display_stack_cmp);
+  tmp = windows;
+  stack_position = 0;
+
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      if (window->sm_client_id)
+        {
+          char *sm_client_id;
+          char *res_class;
+          char *res_name;
+          char *role;
+          char *title;
+
+          /* client id, class, name, role are not expected to be
+           * in UTF-8 (I think they are in XPCS which is Latin-1?
+           * in practice they are always ascii though.)
+           */
+              
+          sm_client_id = encode_text_as_utf8_markup (window->sm_client_id);
+          res_class = window->res_class ?
+            encode_text_as_utf8_markup (window->res_class) : NULL;
+          res_name = window->res_name ?
+            encode_text_as_utf8_markup (window->res_name) : NULL;
+          role = window->role ?
+            encode_text_as_utf8_markup (window->role) : NULL;
+          if (window->title)
+            title = g_markup_escape_text (window->title, -1);
+          else
+            title = NULL;
+              
+          meta_topic (META_DEBUG_SM, "Saving session managed window %s, client ID '%s'\n",
+                      window->desc, window->sm_client_id);
+
+          fprintf (outfile,
+                   "  <window id=\"%s\" class=\"%s\" name=\"%s\" title=\"%s\" role=\"%s\" type=\"%s\" stacking=\"%d\">\n",
+                   sm_client_id,
+                   res_class ? res_class : "",
+                   res_name ? res_name : "",
+                   title ? title : "",
+                   role ? role : "",
+                   window_type_to_string (window->type),
+                   stack_position);
+
+          g_free (sm_client_id);
+          g_free (res_class);
+          g_free (res_name);
+          g_free (role);
+          g_free (title);
+              
+          /* Sticky */
+          if (window->on_all_workspaces)
+            fputs ("    <sticky/>\n", outfile);
+
+          /* Minimized */
+          if (window->minimized)
+            fputs ("    <minimized/>\n", outfile);
+
+          /* Maximized */
+          if (META_WINDOW_MAXIMIZED (window))
+            {
+              fprintf (outfile,
+                       "    <maximized saved_x=\"%d\" saved_y=\"%d\" saved_width=\"%d\" saved_height=\"%d\"/>\n", 
+                       window->saved_rect.x,
+                       window->saved_rect.y,
+                       window->saved_rect.width,
+                       window->saved_rect.height);
+            }
+              
+          /* Workspaces we're on */
+          {
+            int n;
+            n = meta_workspace_index (window->workspace);
+            fprintf (outfile,
+                     "    <workspace index=\"%d\"/>\n", n);
+          }
+
+          /* Gravity */
+          {
+            int x, y, w, h;
+            meta_window_get_geometry (window, &x, &y, &w, &h);
+            
+            fprintf (outfile,
+                     "    <geometry x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" gravity=\"%s\"/>\n",
+                     x, y, w, h,
+                     meta_gravity_to_string (window->size_hints.win_gravity));
+          }
+              
+          fputs ("  </window>\n", outfile);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_SM, "Not saving window '%s', not session managed\n",
+                      window->desc);
+        }
+          
+      tmp = tmp->next;
+      ++stack_position;
+    }
+      
+  g_slist_free (windows);
+
+  fputs ("</marco_session>\n", outfile);
+  
+ out:
+  if (outfile)
+    {
+      /* FIXME need a dialog for this */
+      if (ferror (outfile))
+        {
+          meta_warning (_("Error writing session file '%s': %s\n"),
+                        full_save_file (), g_strerror (errno));
+        }
+      if (fclose (outfile))
+        {
+          meta_warning (_("Error closing session file '%s': %s\n"),
+                        full_save_file (), g_strerror (errno));
+        }
+    }
+  
+  g_free (marco_dir);
+  g_free (session_dir);
+}
+
+typedef enum
+{
+  WINDOW_TAG_NONE,
+  WINDOW_TAG_DESKTOP,
+  WINDOW_TAG_STICKY,
+  WINDOW_TAG_MINIMIZED,
+  WINDOW_TAG_MAXIMIZED,
+  WINDOW_TAG_GEOMETRY
+} WindowTag;
+
+typedef struct
+{
+  MetaWindowSessionInfo *info;
+  char *previous_id;
+} ParseData;
+
+static void                   session_info_free (MetaWindowSessionInfo *info);
+static MetaWindowSessionInfo* session_info_new  (void);
+
+static void start_element_handler (GMarkupParseContext  *context,
+                                   const gchar          *element_name,
+                                   const gchar         **attribute_names,
+                                   const gchar         **attribute_values,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void end_element_handler   (GMarkupParseContext  *context,
+                                   const gchar          *element_name,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void text_handler          (GMarkupParseContext  *context,
+                                   const gchar          *text,
+                                   gsize                 text_len,
+                                   gpointer              user_data,
+                                   GError              **error);
+
+static GMarkupParser marco_session_parser = {
+  start_element_handler,
+  end_element_handler,
+  text_handler,
+  NULL,
+  NULL
+};
+
+static GSList *window_info_list = NULL;
+
+static char*
+load_state (const char *previous_save_file)
+{
+  GMarkupParseContext *context;
+  GError *error;
+  ParseData parse_data;
+  char *text;
+  gsize length;
+  char *session_file;
+
+  session_file = g_strconcat (g_get_user_config_dir (),
+                              G_DIR_SEPARATOR_S "marco"
+                              G_DIR_SEPARATOR_S "sessions" G_DIR_SEPARATOR_S,
+                              previous_save_file,
+                              NULL);
+
+  error = NULL;
+  if (!g_file_get_contents (session_file,
+                            &text,
+                            &length,
+                            &error))
+    {
+      char *canonical_session_file = session_file;
+
+      /* Maybe they were doing it the old way, with ~/.marco */
+      session_file = g_strconcat (g_get_home_dir (),
+                                  G_DIR_SEPARATOR_S ".marco"
+                                  G_DIR_SEPARATOR_S "sessions"
+                                  G_DIR_SEPARATOR_S,
+                                  previous_save_file,
+                                  NULL);
+      
+      if (!g_file_get_contents (session_file,
+                                &text,
+                                &length,
+                                NULL))
+        {
+          /* oh, just give up */
+
+          g_error_free (error);
+          g_free (session_file);
+          g_free (canonical_session_file);
+          return NULL;
+        }
+
+      g_free (canonical_session_file);
+    }
+
+  meta_topic (META_DEBUG_SM, "Parsing saved session file %s\n", session_file);
+  g_free (session_file);
+  session_file = NULL;
+  
+  parse_data.info = NULL;
+  parse_data.previous_id = NULL;
+  
+  context = g_markup_parse_context_new (&marco_session_parser,
+                                        0, &parse_data, NULL);
+
+  error = NULL;
+  if (!g_markup_parse_context_parse (context,
+                                     text,
+                                     length,
+                                     &error))
+    goto error;
+  
+  
+  error = NULL;
+  if (!g_markup_parse_context_end_parse (context, &error))
+    goto error;
+
+  g_markup_parse_context_free (context);
+
+  goto out;
+
+ error:
+  
+  meta_warning (_("Failed to parse saved session file: %s\n"),
+                error->message);
+  g_error_free (error);
+
+  if (parse_data.info)
+    session_info_free (parse_data.info);
+
+  g_free (parse_data.previous_id);
+  parse_data.previous_id = NULL;
+  
+ out:
+  
+  g_free (text);
+
+  return parse_data.previous_id;
+}
+
+/* FIXME this isn't very robust against bogus session files */
+static void
+start_element_handler  (GMarkupParseContext *context,
+                        const gchar         *element_name,
+                        const gchar        **attribute_names,
+                        const gchar        **attribute_values,
+                        gpointer             user_data,
+                        GError             **error)
+{
+  ParseData *pd;
+
+  pd = user_data;
+
+  if (strcmp (element_name, "marco_session") == 0)
+    {
+      /* Get previous ID */
+      int i;      
+
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+          
+          name = attribute_names[i];
+          val = attribute_values[i];
+
+          if (pd->previous_id)
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                       G_MARKUP_ERROR_PARSE,
+                           _("<marco_session> attribute seen but we already have the session ID"));
+              return;
+            }
+          
+          if (strcmp (name, "id") == 0)
+            {
+              pd->previous_id = decode_text_from_utf8 (val);
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "marco_session");
+              return;
+            }
+          
+          ++i;
+        }
+    }
+  else if (strcmp (element_name, "window") == 0)
+    {
+      int i;
+      
+      if (pd->info)
+        {
+          g_set_error (error,
+                       G_MARKUP_ERROR,
+                       G_MARKUP_ERROR_PARSE,
+                       _("nested <window> tag"));
+          return;
+        }
+      
+      pd->info = session_info_new ();
+
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+          
+          name = attribute_names[i];
+          val = attribute_values[i];
+          
+          if (strcmp (name, "id") == 0)
+            {
+              if (*val)
+                pd->info->id = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "class") == 0)
+            {
+              if (*val)
+                pd->info->res_class = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "name") == 0)
+            {
+              if (*val)
+                pd->info->res_name = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "title") == 0)
+            {
+              if (*val)
+                pd->info->title = g_strdup (val);
+            }
+          else if (strcmp (name, "role") == 0)
+            {
+              if (*val)
+                pd->info->role = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "type") == 0)
+            {
+              if (*val)
+                pd->info->type = window_type_from_string (val);
+            }
+          else if (strcmp (name, "stacking") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->stack_position = atoi (val);
+                  pd->info->stack_position_set = TRUE;
+                }
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "window");
+              session_info_free (pd->info);
+              pd->info = NULL;
+              return;
+            }
+          
+          ++i;
+        }
+    }
+  else if (strcmp (element_name, "workspace") == 0)
+    {
+      int i;
+
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+
+          name = attribute_names[i];
+          
+          if (strcmp (name, "index") == 0)
+            {
+              pd->info->workspace_indices =
+                g_slist_prepend (pd->info->workspace_indices,
+                                 GINT_TO_POINTER (atoi (attribute_values[i])));
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "window");
+              session_info_free (pd->info);
+              pd->info = NULL;
+              return;
+            }
+          
+          ++i;
+        }
+    }
+  else if (strcmp (element_name, "sticky") == 0)
+    {
+      pd->info->on_all_workspaces = TRUE;
+      pd->info->on_all_workspaces_set = TRUE;
+    }
+  else if (strcmp (element_name, "minimized") == 0)
+    {
+      pd->info->minimized = TRUE;
+      pd->info->minimized_set = TRUE;
+    }
+  else if (strcmp (element_name, "maximized") == 0)
+    {
+      int i;
+
+      i = 0;
+      pd->info->maximized = TRUE;
+      pd->info->maximized_set = TRUE;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+
+          name = attribute_names[i];
+          val = attribute_values[i];
+
+          if (strcmp (name, "saved_x") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.x = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else if (strcmp (name, "saved_y") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.y = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else if (strcmp (name, "saved_width") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.width = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else if (strcmp (name, "saved_height") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.height = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "maximized");
+              return;
+            }
+
+          ++i;
+        }
+
+      if (pd->info->saved_rect_set)
+        meta_topic (META_DEBUG_SM, "Saved unmaximized size %d,%d %dx%d \n",
+                    pd->info->saved_rect.x,
+                    pd->info->saved_rect.y,
+                    pd->info->saved_rect.width,
+                    pd->info->saved_rect.height);
+    }  
+  else if (strcmp (element_name, "geometry") == 0)
+    {
+      int i;
+
+      pd->info->geometry_set = TRUE;
+      
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+          
+          name = attribute_names[i];
+          val = attribute_values[i];
+          
+          if (strcmp (name, "x") == 0)
+            {
+              if (*val)
+                pd->info->rect.x = atoi (val);
+            }
+          else if (strcmp (name, "y") == 0)
+            {
+              if (*val)
+                pd->info->rect.y = atoi (val);
+            }
+          else if (strcmp (name, "width") == 0)
+            {
+              if (*val)
+                pd->info->rect.width = atoi (val);
+            }
+          else if (strcmp (name, "height") == 0)
+            {
+              if (*val)
+                pd->info->rect.height = atoi (val);
+            }
+          else if (strcmp (name, "gravity") == 0)
+            {
+              if (*val)
+                pd->info->gravity = window_gravity_from_string (val);
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "geometry");
+              return;
+            }
+          
+          ++i;
+        }
+
+      meta_topic (META_DEBUG_SM, "Loaded geometry %d,%d %dx%d gravity %s\n",
+                  pd->info->rect.x,
+                  pd->info->rect.y,
+                  pd->info->rect.width,
+                  pd->info->rect.height,
+                  meta_gravity_to_string (pd->info->gravity));
+    }
+  else
+    {
+      g_set_error (error,
+                   G_MARKUP_ERROR,
+                   G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                   _("Unknown element %s"),
+                   element_name);
+      return;
+    }
+}
+
+static void
+end_element_handler    (GMarkupParseContext *context,
+                        const gchar         *element_name,
+                        gpointer             user_data,
+                        GError             **error)
+{
+  ParseData *pd;
+
+  pd = user_data;
+
+  if (strcmp (element_name, "window") == 0)
+    {
+      g_assert (pd->info);
+
+      window_info_list = g_slist_prepend (window_info_list,
+                                          pd->info);
+      
+      meta_topic (META_DEBUG_SM, "Loaded window info from session with class: %s name: %s role: %s\n",
+                  pd->info->res_class ? pd->info->res_class : "(none)",
+                  pd->info->res_name ? pd->info->res_name : "(none)",
+                  pd->info->role ? pd->info->role : "(none)");
+      
+      pd->info = NULL;
+    }
+}
+
+static void
+text_handler           (GMarkupParseContext *context,
+                        const gchar         *text,
+                        gsize                text_len,
+                        gpointer             user_data,
+                        GError             **error)
+{
+  /* Right now we don't have any elements where we care about their
+   * content
+   */
+}
+
+static gboolean
+both_null_or_matching (const char *a,
+                       const char *b)
+{
+  if (a == NULL && b == NULL)
+    return TRUE;
+  else if (a && b && strcmp (a, b) == 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static GSList*
+get_possible_matches (MetaWindow *window)
+{
+  /* Get all windows with this client ID */
+  GSList *retval;
+  GSList *tmp;
+  gboolean ignore_client_id;
+  
+  retval = NULL;
+
+  ignore_client_id = g_getenv ("MARCO_DEBUG_SM") != NULL;
+  
+  tmp = window_info_list;
+  while (tmp != NULL)
+    {
+      MetaWindowSessionInfo *info;
+
+      info = tmp->data;
+      
+      if ((ignore_client_id ||
+           both_null_or_matching (info->id, window->sm_client_id)) && 
+          both_null_or_matching (info->res_class, window->res_class) &&
+          both_null_or_matching (info->res_name, window->res_name) &&
+          both_null_or_matching (info->role, window->role))
+        {
+          meta_topic (META_DEBUG_SM, "Window %s may match saved window with class: %s name: %s role: %s\n",
+                      window->desc,
+                      info->res_class ? info->res_class : "(none)",
+                      info->res_name ? info->res_name : "(none)",
+                      info->role ? info->role : "(none)");
+
+          retval = g_slist_prepend (retval, info);
+        }
+      else
+        {
+          if (meta_is_verbose ())
+            {
+              if (!both_null_or_matching (info->id, window->sm_client_id))
+                meta_topic (META_DEBUG_SM, "Window %s has SM client ID %s, saved state has %s, no match\n",
+                            window->desc,
+                            window->sm_client_id ? window->sm_client_id : "(none)",
+                            info->id ? info->id : "(none)");
+              else if (!both_null_or_matching (info->res_class, window->res_class))
+                meta_topic (META_DEBUG_SM, "Window %s has class %s doesn't match saved class %s, no match\n",
+                            window->desc,
+                            window->res_class ? window->res_class : "(none)",
+                            info->res_class ? info->res_class : "(none)");
+              
+              else if (!both_null_or_matching (info->res_name, window->res_name))
+                meta_topic (META_DEBUG_SM, "Window %s has name %s doesn't match saved name %s, no match\n",
+                            window->desc,
+                            window->res_name ? window->res_name : "(none)",
+                            info->res_name ? info->res_name : "(none)");
+              else if (!both_null_or_matching (info->role, window->role))
+                meta_topic (META_DEBUG_SM, "Window %s has role %s doesn't match saved role %s, no match\n",
+                            window->desc,
+                            window->role ? window->role : "(none)",
+                            info->role ? info->role : "(none)");
+              else
+                meta_topic (META_DEBUG_SM, "???? should not happen - window %s doesn't match saved state %s for no good reason\n",
+                            window->desc, info->id);
+            }
+        }
+      
+      tmp = tmp->next;
+    }
+
+  return retval;
+}
+
+static const MetaWindowSessionInfo*
+find_best_match (GSList     *infos,
+                 MetaWindow *window)
+{
+  GSList *tmp;
+  const MetaWindowSessionInfo *matching_title;
+  const MetaWindowSessionInfo *matching_type;
+  
+  matching_title = NULL;
+  matching_type = NULL;
+  
+  tmp = infos;
+  while (tmp != NULL)
+    {
+      MetaWindowSessionInfo *info;
+
+      info = tmp->data;
+
+      if (matching_title == NULL &&
+          both_null_or_matching (info->title, window->title))
+        matching_title = info;
+
+      if (matching_type == NULL &&
+          info->type == window->type)
+        matching_type = info;
+      
+      tmp = tmp->next;
+    }
+
+  /* Prefer same title, then same type of window, then
+   * just pick something. Eventually we could enhance this
+   * to e.g. break ties by geometry hint similarity,
+   * or other window features.
+   */
+  
+  if (matching_title)
+    return matching_title;
+  else if (matching_type)
+    return matching_type;
+  else
+    return infos->data;
+}
+
+const MetaWindowSessionInfo*
+meta_window_lookup_saved_state (MetaWindow *window)
+{
+  GSList *possibles;
+  const MetaWindowSessionInfo *info;
+  
+  /* Window is not session managed.
+   * I haven't yet figured out how to deal with these
+   * in a way that doesn't cause broken side effects in
+   * situations other than on session restore.
+   */
+  if (window->sm_client_id == NULL)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Window %s is not session managed, not checking for saved state\n",
+                  window->desc);
+      return NULL;
+    }
+
+  possibles = get_possible_matches (window);
+
+  if (possibles == NULL)
+    {
+      meta_topic (META_DEBUG_SM, "Window %s has no possible matches in the list of saved window states\n",
+                  window->desc);
+      return NULL;
+    }
+
+  info = find_best_match (possibles, window);
+  
+  g_slist_free (possibles);
+  
+  return info;
+}
+
+void
+meta_window_release_saved_state (const MetaWindowSessionInfo *info)
+{
+  /* We don't want to use the same saved state again for another
+   * window.
+   */
+  window_info_list = g_slist_remove (window_info_list, info);
+
+  session_info_free ((MetaWindowSessionInfo*) info);
+}
+
+static void
+session_info_free (MetaWindowSessionInfo *info)
+{
+  g_free (info->id);
+  g_free (info->res_class);
+  g_free (info->res_name);
+  g_free (info->title);
+  g_free (info->role);
+
+  g_slist_free (info->workspace_indices);
+  
+  g_free (info);
+}
+
+static MetaWindowSessionInfo*
+session_info_new (void)
+{
+  MetaWindowSessionInfo *info;
+
+  info = g_new0 (MetaWindowSessionInfo, 1);
+
+  info->type = META_WINDOW_NORMAL;
+  info->gravity = NorthWestGravity;
+  
+  return info;
+}
+
+static char* full_save_path = NULL;
+
+static void
+regenerate_save_file (void)
+{
+  g_free (full_save_path);
+
+  if (client_id)
+    full_save_path = g_strconcat (g_get_user_config_dir (),
+                                  G_DIR_SEPARATOR_S "marco"
+                                  G_DIR_SEPARATOR_S "sessions" G_DIR_SEPARATOR_S,
+                                  client_id,
+                                  ".ms",
+                                  NULL);
+  else
+    full_save_path = NULL;
+}
+
+static const char*
+full_save_file (void)
+{
+  return full_save_path;
+}
+
+static int
+windows_cmp_by_title (MetaWindow *a,
+                      MetaWindow *b)
+{
+  return g_utf8_collate (a->title, b->title);
+}
+
+static void
+finish_interact (gboolean shutdown)
+{
+  if (current_state == STATE_DONE_WITH_INTERACT) /* paranoia */
+    {
+      SmcInteractDone (session_connection, False /* don't cancel logout */);
+      
+      save_yourself_possibly_done (shutdown, TRUE);
+    }
+}
+
+static void
+dialog_closed (GPid pid, int status, gpointer user_data)
+{
+  gboolean shutdown = GPOINTER_TO_INT (user_data);
+
+  if (WIFEXITED (status) && WEXITSTATUS (status) == 0) /* pressed "OK" */
+    {
+      finish_interact (shutdown);
+    }
+}
+
+static void
+warn_about_lame_clients_and_finish_interact (gboolean shutdown)
+{
+  GSList *lame = NULL;
+  GSList *windows;
+  GSList *lame_details = NULL;
+  GSList *tmp;
+  GSList *columns = NULL;
+  GPid pid;
+  
+  windows = meta_display_list_windows (meta_get_display ());
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+          
+      window = tmp->data;
+
+      /* only complain about normal windows, the others
+       * are kind of dumb to worry about
+       */
+      if (window->sm_client_id == NULL &&
+          window->type == META_WINDOW_NORMAL)
+        lame = g_slist_prepend (lame, window);
+          
+      tmp = tmp->next;
+    }
+      
+  g_slist_free (windows);
+  
+  if (lame == NULL)
+    {
+      /* No lame apps. */
+      finish_interact (shutdown);
+      return;
+    }
+
+  columns = g_slist_prepend (columns, "Window");
+  columns = g_slist_prepend (columns, "Class");
+
+  lame = g_slist_sort (lame, (GCompareFunc) windows_cmp_by_title);
+
+  tmp = lame;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      lame_details = g_slist_prepend (lame_details,
+                                      w->res_class ? w->res_class : "");
+      lame_details = g_slist_prepend (lame_details,
+                                      w->title);
+
+      tmp = tmp->next;
+    }
+  g_slist_free (lame);
+
+  pid = meta_show_dialog("--list",
+                         _("These windows do not support &quot;save current setup&quot; "
+                           "and will have to be restarted manually next time "
+                           "you log in."),
+                         "240",
+                         meta_screen_get_screen_number (meta_get_display()->active_screen),
+                         NULL, NULL,
+                         None,
+                         columns,
+                         lame_details);
+
+  g_slist_free (lame_details);
+
+  g_child_watch_add (pid, dialog_closed, GINT_TO_POINTER (shutdown));
+}
+
+#endif /* HAVE_SM */
diff --git a/src/core/session.h b/src/core/session.h
new file mode 100644
index 00000000..62a9370d
--- /dev/null
+++ b/src/core/session.h
@@ -0,0 +1,91 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file session.h   Session management
+ *
+ * Maps windows to information about their placing and state on startup.
+ * This is window matching, which we have a policy of leaving in general
+ * to programs such as Devil's Pie, but the session manager specification
+ * requires us to do it here.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_SESSION_H
+#define META_SESSION_H
+
+#include "window-private.h"
+
+typedef struct _MetaWindowSessionInfo MetaWindowSessionInfo;
+
+struct _MetaWindowSessionInfo
+{
+  /* Fields we use to match against */
+
+  char *id;
+  char *res_class;
+  char *res_name;
+  char *title;
+  char *role;
+  MetaWindowType type;
+
+  /* Information we restore */
+  
+  GSList *workspace_indices;  
+
+  int stack_position;
+  
+  /* width/height should be multiplied by resize inc and
+   * added to base size; position should be interpreted in
+   * light of gravity. This preserves semantics of the
+   * window size/pos, even if fonts/themes change, etc.
+   */
+  int gravity;
+  MetaRectangle rect;
+  MetaRectangle saved_rect;
+  guint on_all_workspaces : 1;
+  guint minimized : 1;
+  guint maximized : 1;
+
+  guint stack_position_set : 1;
+  guint geometry_set : 1;
+  guint on_all_workspaces_set : 1;
+  guint minimized_set : 1;
+  guint maximized_set : 1;
+  guint saved_rect_set : 1;
+};
+
+/* If lookup_saved_state returns something, it should be used,
+ * and then released when you're done with it.
+ */
+const MetaWindowSessionInfo* meta_window_lookup_saved_state  (MetaWindow                  *window);
+void                         meta_window_release_saved_state (const MetaWindowSessionInfo *info);
+
+void meta_session_init (const char *client_id,
+                        const char *save_file);
+
+
+void meta_session_shutdown (void);
+
+#endif
+
+
+
+
diff --git a/src/core/stack.c b/src/core/stack.c
new file mode 100644
index 00000000..2e108d20
--- /dev/null
+++ b/src/core/stack.c
@@ -0,0 +1,1661 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file stack.c  Which windows cover which other windows
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2004 Rob Adams
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "stack.h"
+#include "window-private.h"
+#include "errors.h"
+#include "frame-private.h"
+#include "group.h"
+#include "prefs.h"
+#include "workspace.h"
+
+#include <X11/Xatom.h>
+
+#define WINDOW_HAS_TRANSIENT_TYPE(w)                    \
+          (w->type == META_WINDOW_DIALOG ||             \
+	   w->type == META_WINDOW_MODAL_DIALOG ||       \
+           w->type == META_WINDOW_TOOLBAR ||            \
+           w->type == META_WINDOW_MENU ||               \
+           w->type == META_WINDOW_UTILITY)
+
+#define WINDOW_TRANSIENT_FOR_WHOLE_GROUP(w)             \
+         ((w->xtransient_for == None ||                 \
+           w->transient_parent_is_root_window) &&       \
+          WINDOW_HAS_TRANSIENT_TYPE (w))
+
+#define WINDOW_IN_STACK(w) (w->stack_position >= 0)
+
+static void stack_sync_to_server (MetaStack *stack);
+static void meta_window_set_stack_position_no_sync (MetaWindow *window,
+                                                    int         position);
+static void stack_do_window_deletions (MetaStack *stack);
+static void stack_do_window_additions (MetaStack *stack);
+static void stack_do_relayer          (MetaStack *stack);
+static void stack_do_constrain        (MetaStack *stack);
+static void stack_do_resort           (MetaStack *stack);
+
+static void stack_ensure_sorted (MetaStack *stack);
+
+MetaStack*
+meta_stack_new (MetaScreen *screen)
+{
+  MetaStack *stack;
+  
+  stack = g_new (MetaStack, 1);
+
+  stack->screen = screen;
+  stack->windows = g_array_new (FALSE, FALSE, sizeof (Window));
+
+  stack->sorted = NULL;
+  stack->added = NULL;
+  stack->removed = NULL;
+
+  stack->freeze_count = 0;
+  stack->last_root_children_stacked = NULL;
+
+  stack->n_positions = 0;
+
+  stack->need_resort = FALSE;
+  stack->need_relayer = FALSE;
+  stack->need_constrain = FALSE;
+  
+  return stack;
+}
+
+void
+meta_stack_free (MetaStack *stack)
+{
+  g_array_free (stack->windows, TRUE);
+
+  g_list_free (stack->sorted);
+  g_list_free (stack->added);
+  g_list_free (stack->removed);
+
+  if (stack->last_root_children_stacked)
+    g_array_free (stack->last_root_children_stacked, TRUE);
+  
+  g_free (stack);
+}
+
+void
+meta_stack_add (MetaStack  *stack,
+                MetaWindow *window)
+{
+  meta_topic (META_DEBUG_STACK, "Adding window %s to the stack\n", window->desc);
+
+  if (window->stack_position >= 0)
+    meta_bug ("Window %s had stack position already\n", window->desc);
+  
+  stack->added = g_list_prepend (stack->added, window);
+
+  window->stack_position = stack->n_positions;
+  stack->n_positions += 1;
+  meta_topic (META_DEBUG_STACK,
+              "Window %s has stack_position initialized to %d\n",
+              window->desc, window->stack_position);
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_remove (MetaStack  *stack,
+                   MetaWindow *window)
+{
+  meta_topic (META_DEBUG_STACK, "Removing window %s from the stack\n", window->desc);
+
+  if (window->stack_position < 0)
+    meta_bug ("Window %s removed from stack but had no stack position\n",
+              window->desc);
+
+  /* Set window to top position, so removing it will not leave gaps
+   * in the set of positions
+   */
+  meta_window_set_stack_position_no_sync (window,
+                                          stack->n_positions - 1);
+  window->stack_position = -1;
+  stack->n_positions -= 1;  
+
+  /* We don't know if it's been moved from "added" to "stack" yet */
+  stack->added = g_list_remove (stack->added, window);
+  stack->sorted = g_list_remove (stack->sorted, window);
+
+  /* Remember the window ID to remove it from the stack array.
+   * The macro is safe to use: Window is guaranteed to be 32 bits, and
+   * GUINT_TO_POINTER says it only works on 32 bits.
+   */
+  stack->removed = g_list_prepend (stack->removed,
+                                   GUINT_TO_POINTER (window->xwindow));
+  if (window->frame)
+    stack->removed = g_list_prepend (stack->removed,
+                                     GUINT_TO_POINTER (window->frame->xwindow));
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_update_layer (MetaStack  *stack,
+                         MetaWindow *window)
+{
+  stack->need_relayer = TRUE;
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_update_transient (MetaStack  *stack,
+                             MetaWindow *window)
+{
+  stack->need_constrain = TRUE;
+  
+  stack_sync_to_server (stack);
+}
+
+/* raise/lower within a layer */
+void
+meta_stack_raise (MetaStack  *stack,
+                  MetaWindow *window)
+{  
+  meta_window_set_stack_position_no_sync (window,
+                                          stack->n_positions - 1);
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_lower (MetaStack  *stack,
+                  MetaWindow *window)
+{
+  meta_window_set_stack_position_no_sync (window, 0);
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_freeze (MetaStack *stack)
+{
+  stack->freeze_count += 1;
+}
+
+void
+meta_stack_thaw (MetaStack *stack)
+{
+  g_return_if_fail (stack->freeze_count > 0);
+  
+  stack->freeze_count -= 1;
+  stack_sync_to_server (stack);
+}
+
+static gboolean
+is_focused_foreach (MetaWindow *window,
+                    void       *data)
+{
+  if (window == window->display->expected_focus_window)
+    {
+      *((gboolean*) data) = TRUE;
+      return FALSE;
+    }
+  return TRUE;
+}
+
+static gboolean
+windows_on_different_xinerama (MetaWindow *a,
+                               MetaWindow *b)
+{
+  if (a->screen != b->screen)
+    return TRUE;
+
+  return meta_screen_get_xinerama_for_window (a->screen, a) !=
+    meta_screen_get_xinerama_for_window (b->screen, b);
+}
+
+/* Get layer ignoring any transient or group relationships */
+static MetaStackLayer
+get_standalone_layer (MetaWindow *window)
+{
+  MetaStackLayer layer;
+  gboolean focused_transient = FALSE;
+  
+  switch (window->type)
+    {
+    case META_WINDOW_DESKTOP:
+      layer = META_LAYER_DESKTOP;
+      break;
+
+    case META_WINDOW_DOCK:
+      /* still experimenting here */
+      if (window->wm_state_below)
+        layer = META_LAYER_BOTTOM;
+      else
+        layer = META_LAYER_DOCK;
+      break;
+
+    default:       
+      meta_window_foreach_transient (window,
+                                     is_focused_foreach,
+                                     &focused_transient);
+
+      if (window->wm_state_below)
+        layer = META_LAYER_BOTTOM;
+      else if (window->fullscreen &&
+               (focused_transient ||
+                window == window->display->expected_focus_window ||
+                window->display->expected_focus_window == NULL ||
+                (window->display->expected_focus_window != NULL &&
+                 windows_on_different_xinerama (window,
+                                                window->display->expected_focus_window))))
+        layer = META_LAYER_FULLSCREEN;
+      else if (window->wm_state_above)
+        layer = META_LAYER_TOP;
+      else
+        layer = META_LAYER_NORMAL;
+      break;
+    }
+
+  return layer;
+}
+
+/* Note that this function can never use window->layer only
+ * get_standalone_layer, or we'd have issues.
+ */
+static MetaStackLayer
+get_maximum_layer_in_group (MetaWindow *window)
+{
+  GSList *members;
+  MetaGroup *group;
+  GSList *tmp;
+  MetaStackLayer max;
+  MetaStackLayer layer;
+  
+  max = META_LAYER_DESKTOP;
+  
+  group = meta_window_get_group (window);
+
+  if (group != NULL)
+    members = meta_group_list_windows (group);
+  else
+    members = NULL;
+  
+  tmp = members;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      layer = get_standalone_layer (w);
+      if (layer > max)
+        max = layer;
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (members);
+  
+  return max;
+}
+
+static void
+compute_layer (MetaWindow *window)
+{
+  window->layer = get_standalone_layer (window);
+  
+  /* We can only do promotion-due-to-group for dialogs and other
+   * transients, or weird stuff happens like the desktop window and
+   * caja windows getting in the same layer, or all mate-terminal
+   * windows getting in fullscreen layer if any terminal is
+   * fullscreen.
+   */
+  if (WINDOW_HAS_TRANSIENT_TYPE(window) &&
+      (window->xtransient_for == None ||
+       window->transient_parent_is_root_window))
+    {
+      /* We only do the group thing if the dialog is NOT transient for
+       * a particular window. Imagine a group with a normal window, a dock,
+       * and a dialog transient for the normal window; you don't want the dialog
+       * above the dock if it wouldn't normally be.
+       */
+      
+      MetaStackLayer group_max;
+      
+      group_max = get_maximum_layer_in_group (window);
+      
+      if (group_max > window->layer)
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "Promoting window %s from layer %u to %u due to group membership\n",
+                      window->desc, window->layer, group_max);
+          window->layer = group_max;
+        }
+    }
+
+  meta_topic (META_DEBUG_STACK, "Window %s on layer %u type = %u has_focus = %d\n",
+              window->desc, window->layer,
+              window->type, window->has_focus);
+}
+
+/* Front of the layer list is the topmost window,
+ * so the lower stack position is later in the list
+ */
+static int
+compare_window_position (void *a,
+                         void *b)
+{
+  MetaWindow *window_a = a;
+  MetaWindow *window_b = b;
+
+  /* Go by layer, then stack_position */
+  if (window_a->layer < window_b->layer)
+    return 1; /* move window_a later in list */
+  else if (window_a->layer > window_b->layer)
+    return -1;
+  else if (window_a->stack_position < window_b->stack_position)
+    return 1; /* move window_a later in list */
+  else if (window_a->stack_position > window_b->stack_position)
+    return -1;
+  else
+    return 0; /* not reached */
+}
+  
+/*
+ * Stacking constraints
+ * 
+ * Assume constraints of the form "AB" meaning "window A must be
+ * below window B"
+ *
+ * If we have windows stacked from bottom to top
+ * "ABC" then raise A we get "BCA". Say C is
+ * transient for B is transient for A. So
+ * we have constraints AB and BC.
+ *
+ * After raising A, we need to reapply the constraints.
+ * If we do this by raising one window at a time -
+ *
+ *  start:    BCA
+ *  apply AB: CAB
+ *  apply BC: ABC
+ *
+ * but apply constraints in the wrong order and it breaks:
+ * 
+ *  start:    BCA
+ *  apply BC: BCA
+ *  apply AB: CAB
+ *
+ * We make a directed graph of the constraints by linking
+ * from "above windows" to "below windows as follows:
+ * 
+ *   AB -> BC -> CD
+ *          \
+ *           CE
+ *
+ * If we then walk that graph and apply the constraints in the order
+ * that they appear, we will apply them correctly. Note that the
+ * graph MAY have cycles, so we have to guard against that.
+ *
+ */
+
+typedef struct Constraint Constraint;
+
+struct Constraint
+{
+  MetaWindow *above;
+  MetaWindow *below;
+
+  /* used to keep the constraint in the
+   * list of constraints for window "below"
+   */
+  Constraint *next;
+
+  /* used to create the graph. */
+  GSList *next_nodes;
+  
+  /* constraint has been applied, used
+   * to detect cycles.
+   */
+  unsigned int applied : 1;
+
+  /* constraint has a previous node in the graph,
+   * used to find places to start in the graph.
+   * (I think this also has the side effect
+   * of preventing cycles, since cycles will
+   * have no starting point - so maybe
+   * the "applied" flag isn't needed.)
+   */
+  unsigned int has_prev : 1;
+};
+
+/* We index the array of constraints by window
+ * stack positions, just because the stack
+ * positions are a convenient index.
+ */
+static void
+add_constraint (Constraint **constraints,
+                MetaWindow  *above,
+                MetaWindow  *below)
+{
+  Constraint *c;
+
+  g_assert (above->screen == below->screen);
+  
+  /* check if constraint is a duplicate */
+  c = constraints[below->stack_position];
+  while (c != NULL)
+    {
+      if (c->above == above)
+        return;
+      c = c->next;
+    }
+
+  /* if not, add the constraint */
+  c = g_new (Constraint, 1);
+  c->above = above;
+  c->below = below;
+  c->next = constraints[below->stack_position];
+  c->next_nodes = NULL;
+  c->applied = FALSE;
+  c->has_prev = FALSE;
+
+  constraints[below->stack_position] = c;
+}
+
+static void
+create_constraints (Constraint **constraints,
+                    GList       *windows)
+{
+  GList *tmp;
+  
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (!WINDOW_IN_STACK (w))
+        {
+          meta_topic (META_DEBUG_STACK, "Window %s not in the stack, not constraining it\n",
+                      w->desc);
+          tmp = tmp->next;
+          continue;
+        }
+      
+      if (WINDOW_TRANSIENT_FOR_WHOLE_GROUP (w))
+        {
+          GSList *group_windows;
+          GSList *tmp2;
+          MetaGroup *group;
+
+          group = meta_window_get_group (w);
+
+          if (group != NULL)
+            group_windows = meta_group_list_windows (group);
+          else
+            group_windows = NULL;
+          
+          tmp2 = group_windows;
+          
+          while (tmp2 != NULL)
+            {
+              MetaWindow *group_window = tmp2->data;
+
+              if (!WINDOW_IN_STACK (group_window) ||
+                  w->screen != group_window->screen)
+                {
+                  tmp2 = tmp2->next;
+                  continue;
+                }
+              
+#if 0
+              /* old way of doing it */
+              if (!(meta_window_is_ancestor_of_transient (w, group_window)) &&
+                  !WINDOW_TRANSIENT_FOR_WHOLE_GROUP (group_window))  /* note */;/*note*/
+#else
+              /* better way I think, so transient-for-group are constrained
+               * only above non-transient-type windows in their group
+               */
+              if (!WINDOW_HAS_TRANSIENT_TYPE (group_window))
+#endif
+                {
+                  meta_topic (META_DEBUG_STACK, "Constraining %s above %s as it's transient for its group\n",
+                              w->desc, group_window->desc);
+                  add_constraint (constraints, w, group_window);
+                }
+              
+              tmp2 = tmp2->next;
+            }
+
+          g_slist_free (group_windows);
+        }
+      else if (w->xtransient_for != None &&
+               !w->transient_parent_is_root_window)
+        {
+          MetaWindow *parent;
+          
+          parent =
+            meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+          if (parent && WINDOW_IN_STACK (parent) &&
+              parent->screen == w->screen)
+            {
+              meta_topic (META_DEBUG_STACK, "Constraining %s above %s due to transiency\n",
+                          w->desc, parent->desc);
+              add_constraint (constraints, w, parent);
+            }
+        }
+      
+      tmp = tmp->next;
+    }
+}
+
+static void
+graph_constraints (Constraint **constraints,
+                   int          n_constraints)
+{
+  int i;
+
+  i = 0;
+  while (i < n_constraints)
+    {
+      Constraint *c;
+
+      /* If we have "A below B" and "B below C" then AB -> BC so we
+       * add BC to next_nodes in AB.
+       */
+      
+      c = constraints[i];
+      while (c != NULL)
+        {
+          Constraint *n;
+            
+          g_assert (c->below->stack_position == i);
+
+          /* Constraints where ->above is below are our
+           * next_nodes and we are their previous
+           */
+          n = constraints[c->above->stack_position];
+          while (n != NULL)
+            {
+              c->next_nodes = g_slist_prepend (c->next_nodes,
+                                               n);
+              /* c is a previous node of n */
+              n->has_prev = TRUE;
+              
+              n = n->next;
+            }
+          
+          c = c->next;
+        }
+
+      ++i;
+    }
+}
+
+static void
+free_constraints (Constraint **constraints,
+                  int          n_constraints)
+{
+  int i;
+
+  i = 0;
+  while (i < n_constraints)
+    {
+      Constraint *c;
+      
+      c = constraints[i];
+      while (c != NULL)
+        {
+          Constraint *next = c->next;
+          
+          g_slist_free (c->next_nodes);
+
+          g_free (c);
+          
+          c = next;
+        }
+
+      ++i;
+    }
+}
+
+static void
+ensure_above (MetaWindow *above,
+              MetaWindow *below)
+{  
+  if (WINDOW_HAS_TRANSIENT_TYPE(above) &&
+      above->layer < below->layer)
+    {
+      meta_topic (META_DEBUG_STACK,
+		  "Promoting window %s from layer %u to %u due to contraint\n",
+		  above->desc, above->layer, below->layer);
+      above->layer = below->layer;
+    }
+
+  if (above->stack_position < below->stack_position)
+    {
+      /* move above to below->stack_position bumping below down the stack */
+      meta_window_set_stack_position_no_sync (above, below->stack_position);
+      g_assert (below->stack_position + 1 == above->stack_position);
+    }
+  meta_topic (META_DEBUG_STACK, "%s above at %d > %s below at %d\n",
+              above->desc, above->stack_position,
+              below->desc, below->stack_position);
+}
+
+static void
+traverse_constraint (Constraint *c)
+{
+  GSList *tmp;
+
+  if (c->applied)
+    return;
+  
+  ensure_above (c->above, c->below);
+  c->applied = TRUE;
+  
+  tmp = c->next_nodes;
+  while (tmp != NULL)
+    {
+      traverse_constraint (tmp->data);
+
+      tmp = tmp->next;
+    }
+}
+
+static void
+apply_constraints (Constraint **constraints,
+                   int          n_constraints)
+{
+  GSList *heads;
+  GSList *tmp;
+  int i;
+
+  /* List all heads in an ordered constraint chain */
+  heads = NULL;
+  i = 0;
+  while (i < n_constraints)
+    {
+      Constraint *c;
+      
+      c = constraints[i];
+      while (c != NULL)
+        {
+          if (!c->has_prev)
+            heads = g_slist_prepend (heads, c);
+          
+          c = c->next;
+        }
+
+      ++i;
+    }
+
+  /* Now traverse the chain and apply constraints */
+  tmp = heads;
+  while (tmp != NULL)
+    {
+      Constraint *c = tmp->data;
+
+      traverse_constraint (c);
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (heads);
+}
+
+/**
+ * Go through "deleted" and take the matching windows
+ * out of "windows".
+ */
+static void
+stack_do_window_deletions (MetaStack *stack)
+{
+  /* Do removals before adds, with paranoid idea that we might re-add
+   * the same window IDs.
+   */
+  GList *tmp;
+  int i;
+    
+  tmp = stack->removed;
+  while (tmp != NULL)
+    {
+      Window xwindow;
+      xwindow = GPOINTER_TO_UINT (tmp->data);
+
+      /* We go from the end figuring removals are more
+       * likely to be recent.
+       */
+      i = stack->windows->len;
+      while (i > 0)
+        {
+          --i;
+          
+          /* there's no guarantee we'll actually find windows to
+           * remove, e.g. the same xwindow could have been
+           * added/removed before we ever synced, and we put
+           * both the window->xwindow and window->frame->xwindow
+           * in the removal list.
+           */
+          if (xwindow == g_array_index (stack->windows, Window, i))
+            {
+              g_array_remove_index (stack->windows, i);
+              goto next;
+            }
+        }
+
+    next:
+      tmp = tmp->next;
+    }
+
+  g_list_free (stack->removed);
+  stack->removed = NULL;
+}
+
+static void
+stack_do_window_additions (MetaStack *stack)
+{
+  GList *tmp;
+  gint i, n_added;
+
+  n_added = g_list_length (stack->added);
+  if (n_added > 0)
+    {
+      Window *end;
+      int old_size;
+
+      meta_topic (META_DEBUG_STACK,
+                  "Adding %d windows to sorted list\n",
+                  n_added);
+      
+      old_size = stack->windows->len;
+      g_array_set_size (stack->windows, old_size + n_added);
+      
+      end = &g_array_index (stack->windows, Window, old_size);
+
+      /* stack->added has the most recent additions at the
+       * front of the list, so we need to reverse it
+       */
+      stack->added = g_list_reverse (stack->added);
+      
+      i = 0;
+      tmp = stack->added;
+      while (tmp != NULL)
+        {
+          MetaWindow *w;
+          
+          w = tmp->data;
+          
+          end[i] = w->xwindow;
+
+          /* add to the main list */
+          stack->sorted = g_list_prepend (stack->sorted, w);
+          
+          ++i;
+          tmp = tmp->next;
+        }
+      
+      stack->need_resort = TRUE; /* may not be needed as we add to top */
+      stack->need_constrain = TRUE;
+      stack->need_relayer = TRUE;
+    }
+
+  g_list_free (stack->added);
+  stack->added = NULL;
+}
+
+/**
+ * Update the layers that windows are in
+ */
+static void
+stack_do_relayer (MetaStack *stack)
+{
+  GList *tmp;
+    
+  if (!stack->need_relayer)
+      return;
+    
+  meta_topic (META_DEBUG_STACK,
+              "Recomputing layers\n");
+      
+  tmp = stack->sorted;
+
+  while (tmp != NULL)
+    {
+      MetaWindow *w;
+      MetaStackLayer old_layer;
+
+      w = tmp->data;
+      old_layer = w->layer;
+
+      compute_layer (w);
+
+      if (w->layer != old_layer)
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "Window %s moved from layer %u to %u\n",
+                      w->desc, old_layer, w->layer);
+              
+          stack->need_resort = TRUE;
+          stack->need_constrain = TRUE;
+          /* don't need to constrain as constraining
+           * purely operates in terms of stack_position
+           * not layer
+           */
+        }
+          
+      tmp = tmp->next;
+    }
+
+  stack->need_relayer = FALSE;
+}
+
+/**
+ * Update stack_position and layer to reflect transiency
+ * constraints
+ */
+static void
+stack_do_constrain (MetaStack *stack)
+{
+  Constraint **constraints;
+
+  /* It'd be nice if this were all faster, probably */
+  
+  if (!stack->need_constrain)
+    return;
+
+  meta_topic (META_DEBUG_STACK,
+              "Reapplying constraints\n");
+
+  constraints = g_new0 (Constraint*,
+                        stack->n_positions);
+
+  create_constraints (constraints, stack->sorted);
+
+  graph_constraints (constraints, stack->n_positions);
+
+  apply_constraints (constraints, stack->n_positions);
+  
+  free_constraints (constraints, stack->n_positions);
+  g_free (constraints);
+  
+  stack->need_constrain = FALSE;
+}
+
+/**
+ * Sort stack->sorted with layers having priority over stack_position.
+ */
+static void
+stack_do_resort (MetaStack *stack)
+{
+  if (!stack->need_resort)
+    return;
+  
+  meta_topic (META_DEBUG_STACK,
+              "Sorting stack list\n");
+      
+  stack->sorted = g_list_sort (stack->sorted,
+                               (GCompareFunc) compare_window_position);
+
+  stack->need_resort = FALSE;
+}
+
+/**
+ * Puts the stack into canonical form.
+ *
+ * Honour the removed and added lists of the stack, and then recalculate
+ * all the layers (if the flag is set), re-run all the constraint calculations
+ * (if the flag is set), and finally re-sort the stack (if the flag is set,
+ * and if it wasn't already it might have become so during all the previous
+ * activity).
+ */
+static void
+stack_ensure_sorted (MetaStack *stack)
+{
+  stack_do_window_deletions (stack);
+  stack_do_window_additions (stack);
+  stack_do_relayer (stack);
+  stack_do_constrain (stack);
+  stack_do_resort (stack);
+}
+
+/**
+ * This function is used to avoid raising a window above popup
+ * menus and other such things.
+ *
+ * FIXME This is sort of an expensive function, should probably
+ * do something to avoid it. One approach would be to reverse
+ * the stacking algorithm to work by placing each window above
+ * the others, and start by lowering a window to the bottom
+ * (instead of the current way, which works by placing each
+ * window below another and starting with a raise)
+ */
+static void
+raise_window_relative_to_managed_windows (MetaScreen *screen,
+                                          Window      xwindow)
+{
+
+  Window ignored1, ignored2;
+  Window *children;
+  unsigned int n_children;
+  int i;
+
+  /* Normally XQueryTree() means "must grab server" but here
+   * we don't, since we know we won't manage any new windows
+   * or restack any windows before using the XQueryTree results.
+   */
+  
+  meta_error_trap_push_with_return (screen->display);
+  
+  XQueryTree (screen->display->xdisplay,
+              screen->xroot,
+              &ignored1, &ignored2, &children, &n_children);
+
+  if (meta_error_trap_pop_with_return (screen->display, TRUE) != Success)
+    {
+      meta_topic (META_DEBUG_STACK,
+                  "Error querying root children to raise window 0x%lx\n",
+                  xwindow);
+      return;
+    }
+
+  /* Children are in order from bottom to top. We want to
+   * find the topmost managed child, then configure
+   * our window to be above it.
+   */
+  i = n_children - 1;
+  while (i >= 0)
+    {
+      if (children[i] == xwindow)
+        {
+          /* Do nothing. This means we're already the topmost managed
+           * window, but it DOES NOT mean we are already just above
+           * the topmost managed window. This is important because if
+           * an override redirect window is up, and we map a new
+           * managed window, the new window is probably above the old
+           * popup by default, and we want to push it below that
+           * popup. So keep looking for a sibling managed window
+           * to be moved below.
+           */
+        }
+      else if (meta_display_lookup_x_window (screen->display,
+                                             children[i]) != NULL)
+        {
+          XWindowChanges changes;
+          
+          /* children[i] is the topmost managed child */
+          meta_topic (META_DEBUG_STACK,
+                      "Moving 0x%lx above topmost managed child window 0x%lx\n",
+                      xwindow, children[i]);
+
+          changes.sibling = children[i];
+          changes.stack_mode = Above;
+
+          meta_error_trap_push (screen->display);
+          XConfigureWindow (screen->display->xdisplay,
+                            xwindow,
+                            CWSibling | CWStackMode,
+                            &changes);
+          meta_error_trap_pop (screen->display, FALSE);
+
+          break;
+        }
+
+      --i;
+    }
+
+  if (i < 0)
+    {
+      /* No sibling to use, just lower ourselves to the bottom
+       * to be sure we're below any override redirect windows.
+       */
+      meta_error_trap_push (screen->display);
+      XLowerWindow (screen->display->xdisplay,
+                    xwindow);
+      meta_error_trap_pop (screen->display, FALSE);
+    }
+  
+  if (children)
+    XFree (children);
+}
+
+/**
+ * Order the windows on the X server to be the same as in our structure.
+ * We do this using XRestackWindows if we don't know the previous order,
+ * or XConfigureWindow on a few particular windows if we do and can figure
+ * out the minimum set of changes.  After that, we set __NET_CLIENT_LIST
+ * and __NET_CLIENT_LIST_STACKING.
+ */
+static void
+stack_sync_to_server (MetaStack *stack)
+{
+  GArray *stacked;
+  GArray *root_children_stacked;
+  GList *tmp;
+  
+  /* Bail out if frozen */
+  if (stack->freeze_count > 0)
+    return;
+  
+  meta_topic (META_DEBUG_STACK, "Syncing window stack to server\n");  
+
+  stack_ensure_sorted (stack);
+  
+  /* Create stacked xwindow arrays.
+   * Painfully, "stacked" is in bottom-to-top order for the
+   * _NET hints, and "root_children_stacked" is in top-to-bottom
+   * order for XRestackWindows()
+   */
+  stacked = g_array_new (FALSE, FALSE, sizeof (Window));
+  root_children_stacked = g_array_new (FALSE, FALSE, sizeof (Window));
+
+  meta_topic (META_DEBUG_STACK, "Top to bottom: ");
+  meta_push_no_msg_prefix ();
+  
+  tmp = stack->sorted;
+  while (tmp != NULL)
+    {
+      MetaWindow *w;
+      
+      w = tmp->data;
+      
+      /* remember, stacked is in reverse order (bottom to top) */
+      g_array_prepend_val (stacked, w->xwindow);
+      
+      /* build XRestackWindows() array from top to bottom */
+      if (w->frame)
+        g_array_append_val (root_children_stacked, w->frame->xwindow);
+      else
+        g_array_append_val (root_children_stacked, w->xwindow);
+      
+      meta_topic (META_DEBUG_STACK, "%u:%d - %s ", w->layer, w->stack_position, w->desc);
+          
+      tmp = tmp->next;
+    }
+
+  meta_topic (META_DEBUG_STACK, "\n");
+  meta_pop_no_msg_prefix ();
+
+  /* All windows should be in some stacking order */
+  if (stacked->len != stack->windows->len)
+    meta_bug ("%u windows stacked, %u windows exist in stack\n",
+              stacked->len, stack->windows->len);
+  
+  /* Sync to server */
+
+  meta_topic (META_DEBUG_STACK, "Restacking %u windows\n",
+              root_children_stacked->len);
+  
+  meta_error_trap_push (stack->screen->display);
+
+  if (stack->last_root_children_stacked == NULL)
+    {
+      /* Just impose our stack, we don't know the previous state.
+       * This involves a ton of circulate requests and may flicker.
+       */
+      meta_topic (META_DEBUG_STACK, "Don't know last stack state, restacking everything\n");
+
+      if (root_children_stacked->len > 0)
+        XRestackWindows (stack->screen->display->xdisplay,
+                         (Window *) root_children_stacked->data,
+                         root_children_stacked->len);
+    }
+  else if (root_children_stacked->len > 0)
+    {
+      /* Try to do minimal window moves to get the stack in order */
+      /* A point of note: these arrays include frames not client windows,
+       * so if a client window has changed frame since last_root_children_stacked
+       * was saved, then we may have inefficiency, but I don't think things
+       * break...
+       */
+      const Window *old_stack = (Window *) stack->last_root_children_stacked->data;
+      const Window *new_stack = (Window *) root_children_stacked->data;
+      const int old_len = stack->last_root_children_stacked->len;
+      const int new_len = root_children_stacked->len;
+      const Window *oldp = old_stack;
+      const Window *newp = new_stack;
+      const Window *old_end = old_stack + old_len;
+      const Window *new_end = new_stack + new_len;
+      Window last_window = None;
+      
+      while (oldp != old_end &&
+             newp != new_end)
+        {
+          if (*oldp == *newp)
+            {
+              /* Stacks are the same here, move on */
+              ++oldp;
+              last_window = *newp;
+              ++newp;
+            }
+          else if (meta_display_lookup_x_window (stack->screen->display,
+                                                 *oldp) == NULL)
+            {
+              /* *oldp is no longer known to us (probably destroyed),
+               * so we can just skip it
+               */
+              ++oldp;
+            }
+          else
+            {
+              /* Move *newp below last_window */
+              if (last_window == None)
+                {
+                  meta_topic (META_DEBUG_STACK, "Using window 0x%lx as topmost (but leaving it in-place)\n", *newp);
+
+                  raise_window_relative_to_managed_windows (stack->screen,
+                                                            *newp);
+                }
+              else
+                {
+                  /* This means that if last_window is dead, but not
+                   * *newp, then we fail to restack *newp; but on
+                   * unmanaging last_window, we'll fix it up.
+                   */
+                  
+                  XWindowChanges changes;
+
+                  changes.sibling = last_window;
+                  changes.stack_mode = Below;
+
+                  meta_topic (META_DEBUG_STACK, "Placing window 0x%lx below 0x%lx\n",
+                              *newp, last_window);
+                  
+                  XConfigureWindow (stack->screen->display->xdisplay,
+                                    *newp,
+                                    CWSibling | CWStackMode,
+                                    &changes);
+                }
+
+              last_window = *newp;
+              ++newp;
+            }
+        }
+
+      if (newp != new_end)
+        {
+          /* Restack remaining windows */
+          meta_topic (META_DEBUG_STACK, "Restacking remaining %d windows\n",
+                        (int) (new_end - newp));
+          /* We need to include an already-stacked window
+           * in the restack call, so we get in the proper position
+           * with respect to it.
+           */
+          if (newp != new_stack)
+            --newp;
+          XRestackWindows (stack->screen->display->xdisplay,
+                           (Window *) newp, new_end - newp);
+        }
+    }
+
+  meta_error_trap_pop (stack->screen->display, FALSE);
+  /* on error, a window was destroyed; it should eventually
+   * get removed from the stacking list when we unmanage it
+   * and we'll fix stacking at that time.
+   */
+  
+  /* Sync _NET_CLIENT_LIST and _NET_CLIENT_LIST_STACKING */
+
+  XChangeProperty (stack->screen->display->xdisplay,
+                   stack->screen->xroot,
+                   stack->screen->display->atom__NET_CLIENT_LIST,
+                   XA_WINDOW,
+                   32, PropModeReplace,
+                   (unsigned char *)stack->windows->data,
+                   stack->windows->len);
+  XChangeProperty (stack->screen->display->xdisplay,
+                   stack->screen->xroot,
+                   stack->screen->display->atom__NET_CLIENT_LIST_STACKING,
+                   XA_WINDOW,
+                   32, PropModeReplace,
+                   (unsigned char *)stacked->data,
+                   stacked->len);
+
+  g_array_free (stacked, TRUE);
+
+  if (stack->last_root_children_stacked)
+    g_array_free (stack->last_root_children_stacked, TRUE);
+  stack->last_root_children_stacked = root_children_stacked;
+  
+  /* That was scary... */
+}
+
+MetaWindow*
+meta_stack_get_top (MetaStack *stack)
+{
+  stack_ensure_sorted (stack);
+
+  if (stack->sorted)
+    return stack->sorted->data;
+  else
+    return NULL;
+}
+
+MetaWindow*
+meta_stack_get_bottom (MetaStack  *stack)
+{
+  GList *link;
+
+  stack_ensure_sorted (stack);
+
+  link = g_list_last (stack->sorted);
+  if (link != NULL)
+    return link->data;
+  else
+    return NULL;
+}
+
+MetaWindow*
+meta_stack_get_above (MetaStack      *stack,
+                      MetaWindow     *window,
+                      gboolean        only_within_layer)
+{
+  GList *link;
+  MetaWindow *above;
+  
+  stack_ensure_sorted (stack);
+  
+  link = g_list_find (stack->sorted, window);
+  if (link == NULL)
+    return NULL;
+  if (link->prev == NULL)
+    return NULL;
+
+  above = link->prev->data;
+
+  if (only_within_layer &&
+      above->layer != window->layer)
+    return NULL;
+  else
+    return above;
+}
+
+MetaWindow*
+meta_stack_get_below (MetaStack      *stack,
+                      MetaWindow     *window,
+                      gboolean        only_within_layer)
+{
+  GList *link;
+  MetaWindow *below;
+  
+  stack_ensure_sorted (stack);
+
+  link = g_list_find (stack->sorted, window);
+
+  if (link == NULL)
+    return NULL;
+  if (link->next == NULL)
+    return NULL;
+  
+  below = link->next->data;
+
+  if (only_within_layer &&
+      below->layer != window->layer)
+    return NULL;
+  else
+    return below;
+}
+
+static gboolean
+window_contains_point (MetaWindow *window,
+                       int         root_x,
+                       int         root_y)
+{
+  MetaRectangle rect;
+
+  meta_window_get_outer_rect (window, &rect);
+
+  return POINT_IN_RECT (root_x, root_y, rect);
+}
+
+static MetaWindow*
+get_default_focus_window (MetaStack     *stack,
+                          MetaWorkspace *workspace,
+                          MetaWindow    *not_this_one,
+                          gboolean       must_be_at_point,
+                          int            root_x,
+                          int            root_y)
+{
+  /* Find the topmost, focusable, mapped, window.
+   * not_this_one is being unfocused or going away, so exclude it.
+   * Also, prefer to focus transient parent of not_this_one,
+   * or top window in same group as not_this_one.
+   */
+
+  MetaWindow *topmost_dock;
+  MetaWindow *transient_parent;
+  MetaWindow *topmost_in_group;
+  MetaWindow *topmost_overall;
+  MetaGroup *not_this_one_group;
+  GList *link;
+  
+  topmost_dock = NULL;
+  transient_parent = NULL;
+  topmost_in_group = NULL;
+  topmost_overall = NULL;
+  if (not_this_one)
+    not_this_one_group = meta_window_get_group (not_this_one);
+  else
+    not_this_one_group = NULL;
+
+  stack_ensure_sorted (stack);
+
+  /* top of this layer is at the front of the list */
+  link = stack->sorted;
+      
+  while (link)
+    {
+      MetaWindow *window = link->data;
+
+      if (window &&
+          window != not_this_one &&
+          (window->unmaps_pending == 0) &&
+          !window->minimized &&
+          (window->input || window->take_focus) &&
+          (workspace == NULL ||
+           meta_window_located_on_workspace (window, workspace)))
+        {
+          if (topmost_dock == NULL &&
+              window->type == META_WINDOW_DOCK)
+            topmost_dock = window;
+
+          if (not_this_one != NULL)
+            {
+              if (transient_parent == NULL &&
+                  not_this_one->xtransient_for != None &&
+                  not_this_one->xtransient_for == window->xwindow &&
+                  (!must_be_at_point ||
+                   window_contains_point (window, root_x, root_y)))
+                transient_parent = window;
+
+              if (topmost_in_group == NULL &&
+                  not_this_one_group != NULL &&
+                  not_this_one_group == meta_window_get_group (window) &&
+                  (!must_be_at_point ||
+                   window_contains_point (window, root_x, root_y)))
+                topmost_in_group = window;
+            }
+
+          /* Note that DESKTOP windows can be topmost_overall so
+           * we prefer focusing desktop or other windows over
+           * focusing dock, even though docks are stacked higher.
+           */
+          if (topmost_overall == NULL &&
+              window->type != META_WINDOW_DOCK &&
+              (!must_be_at_point ||
+               window_contains_point (window, root_x, root_y)))
+            topmost_overall = window;
+
+          /* We could try to bail out early here for efficiency in
+           * some cases, but it's just not worth the code.
+           */
+        }
+
+      link = link->next;
+    }
+
+  if (transient_parent)
+    return transient_parent;
+  else if (topmost_in_group)
+    return topmost_in_group;
+  else if (topmost_overall)
+    return topmost_overall;
+  else
+    return topmost_dock;
+}
+
+MetaWindow*
+meta_stack_get_default_focus_window_at_point (MetaStack     *stack,
+                                              MetaWorkspace *workspace,
+                                              MetaWindow    *not_this_one,
+                                              int            root_x,
+                                              int            root_y)
+{
+  return get_default_focus_window (stack, workspace, not_this_one,
+                                   TRUE, root_x, root_y);
+}
+
+MetaWindow*
+meta_stack_get_default_focus_window (MetaStack     *stack,
+                                     MetaWorkspace *workspace,
+                                     MetaWindow    *not_this_one)
+{
+  return get_default_focus_window (stack, workspace, not_this_one,
+                                   FALSE, 0, 0);
+}
+
+GList*
+meta_stack_list_windows (MetaStack     *stack,
+                         MetaWorkspace *workspace)
+{
+  GList *workspace_windows = NULL;
+  GList *link;
+  
+  stack_ensure_sorted (stack); /* do adds/removes */
+  
+  link = stack->sorted;
+  
+  while (link)
+    {
+      MetaWindow *window = link->data;
+      
+      if (window &&
+          (workspace == NULL || meta_window_located_on_workspace (window, workspace)))
+        {
+          workspace_windows = g_list_prepend (workspace_windows,
+                                              window);
+        }
+      
+      link = link->next;
+    }
+
+  return workspace_windows;
+}
+
+int
+meta_stack_windows_cmp  (MetaStack  *stack,
+                         MetaWindow *window_a,
+                         MetaWindow *window_b)
+{
+  g_return_val_if_fail (window_a->screen == window_b->screen, 0);
+
+  /* -1 means a below b */
+
+  stack_ensure_sorted (stack); /* update constraints, layers */
+  
+  if (window_a->layer < window_b->layer)
+    return -1;
+  else if (window_a->layer > window_b->layer)
+    return 1;
+  else if (window_a->stack_position < window_b->stack_position)
+    return -1;
+  else if (window_a->stack_position > window_b->stack_position)
+    return 1;
+  else
+    return 0; /* not reached */
+}
+
+static int
+compare_just_window_stack_position (void *a,
+                                    void *b)
+{
+  MetaWindow *window_a = a;
+  MetaWindow *window_b = b;
+
+  if (window_a->stack_position < window_b->stack_position)
+    return -1; /* move window_a earlier in list */
+  else if (window_a->stack_position > window_b->stack_position)
+    return 1;
+  else
+    return 0; /* not reached */
+}
+
+GList*
+meta_stack_get_positions (MetaStack *stack)
+{
+  GList *tmp;
+
+  /* Make sure to handle any adds or removes */
+  stack_ensure_sorted (stack);
+
+  tmp = g_list_copy (stack->sorted);
+  tmp = g_list_sort (tmp, (GCompareFunc) compare_just_window_stack_position);
+
+  return tmp;
+}
+
+static gint
+compare_pointers (gconstpointer a,
+                  gconstpointer b)
+{
+  if (a > b)
+    return 1;
+  else if (a < b)
+    return -1;
+  else 
+    return 0;
+}
+
+static gboolean
+lists_contain_same_windows (GList *a,
+                            GList *b)
+{
+  GList *copy1, *copy2;
+  GList *tmp1, *tmp2;
+
+  if (g_list_length (a) != g_list_length (b))
+    return FALSE;
+
+  tmp1 = copy1 = g_list_sort (g_list_copy (a), compare_pointers);
+  tmp2 = copy2 = g_list_sort (g_list_copy (b), compare_pointers);
+
+  while (tmp1 && tmp1->data == tmp2->data)   /* tmp2 is non-NULL if tmp1 is */
+    {
+      tmp1 = tmp1->next;
+      tmp2 = tmp2->next;
+    }
+
+  g_list_free (copy1);
+  g_list_free (copy2);
+
+  return (tmp1 == NULL);    /* tmp2 is non-NULL if tmp1 is */
+}
+
+void
+meta_stack_set_positions (MetaStack *stack,
+                          GList     *windows)
+{
+  int i;
+  GList *tmp;
+
+  /* Make sure any adds or removes aren't in limbo -- is this needed? */
+  stack_ensure_sorted (stack);
+  
+  if (!lists_contain_same_windows (windows, stack->sorted))
+    {
+      meta_warning ("This list of windows has somehow changed; not resetting "
+                    "positions of the windows.\n");
+      return;
+    }
+
+  g_list_free (stack->sorted);
+  stack->sorted = g_list_copy (windows);
+
+  stack->need_resort = TRUE;
+  stack->need_constrain = TRUE;
+   
+  i = 0;
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+      w->stack_position = i++;
+      tmp = tmp->next;
+    }
+  
+  meta_topic (META_DEBUG_STACK,
+              "Reset the stack positions of (nearly) all windows\n");
+
+  stack_sync_to_server (stack);
+}
+
+void
+meta_window_set_stack_position_no_sync (MetaWindow *window,
+                                        int         position)
+{
+  int low, high, delta;
+  GList *tmp;
+  
+  g_return_if_fail (window->screen->stack != NULL);
+  g_return_if_fail (window->stack_position >= 0);
+  g_return_if_fail (position >= 0);
+  g_return_if_fail (position < window->screen->stack->n_positions);
+
+  if (position == window->stack_position)
+    {
+      meta_topic (META_DEBUG_STACK, "Window %s already has position %d\n",
+                  window->desc, position);
+      return;
+    }
+
+  window->screen->stack->need_resort = TRUE;
+  window->screen->stack->need_constrain = TRUE;
+  
+  if (position < window->stack_position)
+    {
+      low = position;
+      high = window->stack_position - 1;
+      delta = 1;
+    }
+  else
+    {
+      low = window->stack_position + 1;
+      high = position;
+      delta = -1;
+    }
+
+  tmp = window->screen->stack->sorted;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (w->stack_position >= low &&
+          w->stack_position <= high)
+        w->stack_position += delta;
+
+      tmp = tmp->next;
+    }
+  
+  window->stack_position = position;
+
+  meta_topic (META_DEBUG_STACK,
+              "Window %s had stack_position set to %d\n",
+              window->desc, window->stack_position);
+}
+
+void
+meta_window_set_stack_position (MetaWindow *window,
+                                int         position)
+{
+  meta_window_set_stack_position_no_sync (window, position);
+  stack_sync_to_server (window->screen->stack);
+}
diff --git a/src/core/stack.h b/src/core/stack.h
new file mode 100644
index 00000000..f9693897
--- /dev/null
+++ b/src/core/stack.h
@@ -0,0 +1,402 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file stack.h  Which windows cover which other windows
+ *
+ * There are two factors that determine window position.
+ * 
+ * One is window->stack_position, which is a unique integer
+ * indicating how windows are ordered with respect to one
+ * another. The ordering here transcends layers; it isn't changed
+ * as the window is moved among layers. This allows us to move several
+ * windows from one layer to another, while preserving the relative
+ * order of the moved windows. Also, it allows us to restore
+ * the stacking order from a saved session.
+ * 
+ * However when actually stacking windows on the screen, the
+ * layer overrides the stack_position; windows are first sorted
+ * by layer, then by stack_position within each layer.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_STACK_H
+#define META_STACK_H
+
+#include "screen-private.h"
+
+/**
+ * Layers a window can be in.
+ * These MUST be in the order of stacking.
+ */
+typedef enum
+{
+  META_LAYER_DESKTOP        = 0,
+  META_LAYER_BOTTOM         = 1,
+  META_LAYER_NORMAL         = 2,
+  META_LAYER_TOP            = 4, /* Same as DOCK; see EWMH and bug 330717 */
+  META_LAYER_DOCK           = 4,
+  META_LAYER_FULLSCREEN     = 5,
+  META_LAYER_FOCUSED_WINDOW = 6,
+  META_LAYER_LAST           = 7
+} MetaStackLayer;
+
+/**
+ * A sorted list of windows bearing some level of resemblance to the stack of
+ * windows on the X server.
+ *
+ * (This is only used as a field within a MetaScreen; we treat it as a separate
+ * class for simplicity.)
+ */
+struct _MetaStack
+{
+  /** The MetaScreen containing this stack. */
+  MetaScreen *screen;
+
+  /**
+   * A sequence of all the Windows (X handles, not MetaWindows) of the windows
+   * we manage, sorted in order.  Suitable to be passed into _NET_CLIENT_LIST.
+   */
+  GArray *windows;
+
+  /** The MetaWindows of the windows we manage, sorted in order. */
+  GList *sorted;
+
+  /**
+   * MetaWindows waiting to be added to the "sorted" and "windows" list, after
+   * being added by meta_stack_add() and before being assimilated by
+   * stack_ensure_sorted().
+   *
+   * The order of the elements in this list is not important; what is important
+   * is the stack_position element of each window.
+   */
+  GList *added;
+
+  /**
+   * Windows (X handles, not MetaWindows) waiting to be removed from the
+   * "windows" list, after being removed by meta_stack_remove() and before
+   * being assimilated by stack_ensure_sorted().  (We already removed them
+   * from the "sorted" list.)
+   *
+   * The order of the elements in this list is not important.
+   */
+  GList *removed;
+  
+  /**
+   * If this is zero, the local stack oughtn't to be brought up to date with
+   * the X server's stack, because it is in the middle of being updated.
+   * If it is positive, the local stack is said to be "frozen", and will need
+   * to be thawed that many times before the stack can be brought up to date
+   * again.  You may freeze the stack with meta_stack_freeze() and thaw it
+   * with meta_stack_thaw().
+   */
+  int freeze_count;
+
+  /**
+   * The last-known stack of all windows, bottom to top.  We cache it here
+   * so that subsequent times we'll be able to do incremental moves.
+   */
+  GArray *last_root_children_stacked;
+
+  /**
+   * Number of stack positions; same as the length of added, but
+   * kept for quick reference.
+   */
+  gint n_positions;
+
+  /** Is the stack in need of re-sorting? */
+  unsigned int need_resort : 1;
+
+  /**
+   * Are the windows in the stack in need of having their
+   * layers recalculated?
+   */
+  unsigned int need_relayer : 1;
+
+  /**
+   * Are the windows in the stack in need of having their positions
+   * recalculated with respect to transiency (parent and child windows)?
+   */
+  unsigned int need_constrain : 1;
+};
+
+/**
+ * Creates and initialises a MetaStack.
+ *
+ * \param screen  The MetaScreen which will be the parent of this stack.
+ * \return The new screen.
+ */
+MetaStack *meta_stack_new       (MetaScreen     *screen);
+
+/**
+ * Destroys and frees a MetaStack.
+ *
+ * \param stack  The stack to destroy.
+ */
+void       meta_stack_free      (MetaStack      *stack);
+
+/**
+ * Adds a window to the local stack.  It is a fatal error to call this
+ * function on a window which already exists on the stack of any screen.
+ *
+ * \param window  The window to add
+ * \param stack  The stack to add it to
+ */
+void       meta_stack_add       (MetaStack      *stack,
+                                 MetaWindow     *window);
+
+/**
+ * Removes a window from the local stack.  It is a fatal error to call this
+ * function on a window which exists on the stack of any screen.
+ *
+ * \param window  The window to remove
+ * \param stack   The stack to remove it from
+ */
+void       meta_stack_remove    (MetaStack      *stack,
+                                 MetaWindow     *window);
+/**
+ * Recalculates the correct layer for all windows in the stack,
+ * and moves them about accordingly.
+ *
+ * \param window  Dummy parameter
+ * \param stack   The stack to recalculate
+ * \bug What's with the dummy parameter?
+ */
+void       meta_stack_update_layer    (MetaStack      *stack,
+                                       MetaWindow     *window);
+
+/**
+ * Recalculates the correct stacking order for all windows in the stack
+ * according to their transience, and moves them about accordingly.
+ *
+ * \param window  Dummy parameter
+ * \param stack   The stack to recalculate
+ * \bug What's with the dummy parameter?
+ */
+void       meta_stack_update_transient (MetaStack     *stack,
+                                        MetaWindow    *window);
+
+/**
+ * Move a window to the top of its layer.
+ *
+ * \param stack  The stack to modify.
+ * \param window  The window that's making an ascension.
+ *                (Amulet of Yendor not required.)
+ */
+void       meta_stack_raise     (MetaStack      *stack,
+                                 MetaWindow     *window);
+/**
+ * Move a window to the bottom of its layer.
+ *
+ * \param stack  The stack to modify.
+ * \param window  The window that's on the way downwards.
+ */
+void       meta_stack_lower     (MetaStack      *stack,
+                                 MetaWindow     *window);
+
+/**
+ * Prevent syncing to server until the next call of meta_stack_thaw(),
+ * so that we can carry out multiple operations in one go without having
+ * everything halfway reflected on the X server.
+ *
+ * (Calls to meta_stack_freeze() nest, so that multiple calls to
+ * meta_stack_freeze will require multiple calls to meta_stack_thaw().)
+ *
+ * \param stack  The stack to freeze.
+ */
+void       meta_stack_freeze    (MetaStack      *stack);
+
+/**
+ * Undoes a meta_stack_freeze(), and processes anything which has become
+ * necessary during the freeze.  It is an error to call this function if
+ * the stack has not been frozen.
+ *
+ * \param stack  The stack to thaw.
+ */
+void       meta_stack_thaw      (MetaStack      *stack);
+
+/**
+ * Finds the top window on the stack.
+ *
+ * \param stack  The stack to examine.
+ * \return The top window on the stack, or NULL in the vanishingly unlikely
+ *         event that you have no windows on your screen whatsoever.
+ */
+MetaWindow* meta_stack_get_top    (MetaStack  *stack);
+
+/**
+ * Finds the window at the bottom of the stack.  Since that's pretty much
+ * always the desktop, this isn't the most useful of functions, and nobody
+ * actually calls it.  We should probably get rid of it.
+ *
+ * \param stack  The stack to search
+ */
+MetaWindow* meta_stack_get_bottom (MetaStack  *stack);
+
+/**
+ * Finds the window above a given window in the stack.
+ * It is not an error to pass in a window which does not exist in
+ * the stack; the function will merely return NULL.
+ *
+ * \param stack   The stack to search.
+ * \param window  The window to look above.
+ * \param only_within_layer  If true, will return NULL if "window" is the
+ *                           top window in its layer.
+ * \return NULL if there is no such window;
+ *         the window above "window" otherwise.
+ */
+MetaWindow* meta_stack_get_above  (MetaStack  *stack,
+                                   MetaWindow *window,
+                                   gboolean    only_within_layer);
+
+/**
+ * Finds the window below a given window in the stack.
+ * It is not an error to pass in a window which does not exist in
+ * the stack; the function will merely return NULL.
+ *
+ * \param stack   The stack to search.
+ * \param window  The window to look below.
+ * \param only_within_layer  If true, will return NULL if "window" is the
+ *                           bottom window in its layer.
+ * \return NULL if there is no such window;
+ *         the window below "window" otherwise.
+ */
+MetaWindow* meta_stack_get_below  (MetaStack  *stack,
+                                   MetaWindow *window,
+                                   gboolean    only_within_layer);
+
+/**
+ * Find the topmost, focusable, mapped, window in a stack.  If you supply
+ * a window as "not_this_one", we won't return that one (presumably
+ * because it's going to be going away).  But if you do supply "not_this_one"
+ * and we find its parent, we'll return that; and if "not_this_one" is in
+ * a group, we'll return the top window of that group.
+ *
+ * Also, we are prejudiced against dock windows.  Every kind of window, even
+ * the desktop, will be returned in preference to a dock window.
+ *
+ * \param stack  The stack to search.
+ * \param workspace  NULL to search all workspaces; otherwise only windows
+ *                   from that workspace will be returned.
+ * \param not_this_one  Window to ignore because it's being unfocussed or
+ *                      going away.
+ * \return The window matching all these constraints or NULL if none does.
+ * 
+ * \bug Never called!
+  */
+MetaWindow* meta_stack_get_default_focus_window          (MetaStack     *stack,
+                                                          MetaWorkspace *workspace,
+                                                          MetaWindow    *not_this_one);
+
+/**
+ * Find the topmost, focusable, mapped, window in a stack.  If you supply
+ * a window as "not_this_one", we won't return that one (presumably
+ * because it's going to be going away).  But if you do supply "not_this_one"
+ * and we find its parent, we'll return that; and if "not_this_one" is in
+ * a group, we'll return the top window of that group.
+ *
+ * Also, we are prejudiced against dock windows.  Every kind of window, even
+ * the desktop, will be returned in preference to a dock window.
+ *
+ * \param stack  The stack to search.
+ * \param workspace  NULL to search all workspaces; otherwise only windows
+ *                   from that workspace will be returned.
+ * \param not_this_one  Window to ignore because it's being unfocussed or
+ *                      going away.
+ * \param root_x  The returned window must contain this point,
+ *                unless it's a dock.
+ * \param root_y  See root_x.
+ * \return The window matching all these constraints or NULL if none does.
+ */
+MetaWindow* meta_stack_get_default_focus_window_at_point (MetaStack     *stack,
+                                                          MetaWorkspace *workspace,
+                                                          MetaWindow    *not_this_one,
+                                                          int            root_x,
+                                                          int            root_y);
+
+/**
+ * Finds all the windows in the stack, in order.
+ *
+ * \param stack  The stack to examine.
+ * \param workspace  If non-NULL, only windows on this workspace will be
+ *                   returned; otherwise all windows in the stack will be
+ *                   returned.
+ * \return A list of windows, in stacking order, honouring layers.
+ */
+GList*      meta_stack_list_windows (MetaStack *stack,
+                                     MetaWorkspace *workspace);
+
+/**
+ * Comparison function for windows within a stack.  This is not directly
+ * suitable for use within a standard comparison routine, because it takes
+ * an extra parameter; you will need to wrap it.
+ *
+ * (FIXME: We could remove the stack parameter and use the stack of
+ * the screen of window A, and complain if the stack of the screen of
+ * window B differed; then this would be a usable general comparison function.)
+ *
+ * (FIXME: Apparently identical to compare_window_position(). Merge them.)
+ *
+ * \param stack  A stack containing both window_a and window_b
+ * \param window_a  A window
+ * \param window_b  Another window
+ * \return -1 if window_a is below window_b, honouring layers; 1 if it's
+ *         above it; 0 if you passed in the same window twice!
+ */
+int         meta_stack_windows_cmp  (MetaStack  *stack,
+                                     MetaWindow *window_a,
+                                     MetaWindow *window_b);
+
+/**
+ * Sets the position of a window within the stack.  This will only move it
+ * up or down within its layer.  It is an error to attempt to move this
+ * below position zero or above the last position in the stack (however, since
+ * we don't provide a simple way to tell the number of windows in the stack,
+ * this requirement may not be easy to fulfil).
+ *
+ * \param window  The window which is moving.
+ * \param position  Where it should move to (0 is the bottom).
+ */
+void meta_window_set_stack_position (MetaWindow *window,
+                                     int         position);
+
+/**
+ * Returns the current stack state, allowing rudimentary transactions.
+ *
+ * \param stack  The stack to examine.
+ * \return An opaque GList representing the current stack sort order;
+ *         it is the caller's responsibility to free it.
+ *         Pass this to meta_stack_set_positions() later if you want to restore
+ *         the state to where it was when you called this function.
+ */
+GList* meta_stack_get_positions (MetaStack *stack);
+
+/**
+ * Rolls back a transaction, given the list returned from
+ * meta_stack_get_positions().
+ *
+ * \param stack  The stack to roll back.
+ * \param windows  The list returned from meta_stack_get_positions().
+ */
+void   meta_stack_set_positions (MetaStack *stack,
+                                 GList     *windows);
+
+#endif
diff --git a/src/core/testasyncgetprop.c b/src/core/testasyncgetprop.c
new file mode 100644
index 00000000..ed044009
--- /dev/null
+++ b/src/core/testasyncgetprop.c
@@ -0,0 +1,497 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ */
+
+#include "async-getprop.h"
+
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <assert.h>
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef NULL
+#define NULL ((void*) 0)
+#endif
+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+static void
+print_backtrace (void)
+{
+  void *bt[500];
+  int bt_size;
+  int i;
+  char **syms;
+
+  bt_size = backtrace (bt, 500);
+
+  syms = backtrace_symbols (bt, bt_size);
+
+  i = 0;
+  while (i < bt_size)
+    {
+      fprintf (stderr, "  %s\n", syms[i]);
+      ++i;
+    }
+
+  free (syms);
+}
+#else
+static void
+print_backtrace (void)
+{
+  fprintf (stderr, "Not compiled with backtrace support\n");
+}
+#endif
+
+static int error_trap_depth = 0;
+
+static int
+x_error_handler (Display     *xdisplay,
+                 XErrorEvent *error)
+{
+  char buf[64];
+
+  XGetErrorText (xdisplay, error->error_code, buf, 63);
+
+  if (error_trap_depth == 0)
+    {
+      print_backtrace ();
+      
+      fprintf (stderr, "Unexpected X error: %s serial %ld error_code %d request_code %d minor_code %d)\n",
+               buf,
+               error->serial,
+               error->error_code,
+               error->request_code,
+               error->minor_code);
+      
+      exit (1);
+    }
+
+  return 1; /* return value is meaningless */
+}
+
+static void
+error_trap_push (Display   *xdisplay)
+{
+  ++error_trap_depth;
+}
+
+static void
+error_trap_pop (Display   *xdisplay)
+{
+  if (error_trap_depth == 0)
+    {
+      fprintf (stderr, "Error trap underflow!\n");
+      exit (1);
+    }
+  
+  XSync (xdisplay, False); /* get all errors out of the queue */
+  --error_trap_depth;
+}
+
+static char*
+my_strdup (const char *str)
+{
+  char *s;
+
+  s = malloc (strlen (str) + 1);
+  if (s == NULL)
+    {
+      fprintf (stderr, "malloc failed\n");
+      exit (1);
+    }
+  strcpy (s, str);
+
+  return s;
+}
+
+static char*
+atom_name (Display *display,
+           Atom     atom)
+{
+  if (atom == None)
+    {
+      return my_strdup ("None");
+    }
+  else
+    {
+      char *xname;
+      char *ret;
+
+      error_trap_push (display);
+      xname = XGetAtomName (display, atom);
+      error_trap_pop (display);
+      if (xname == NULL)
+        return my_strdup ("[unknown atom]");
+
+      ret = my_strdup (xname);
+      XFree (xname);
+
+      return ret;
+    }
+}
+
+
+#define ELAPSED(start_time, current_time) \
+    (((((double)current_time.tv_sec - start_time.tv_sec) * 1000000 + \
+       (current_time.tv_usec - start_time.tv_usec))) / 1000.0)
+
+static struct timeval program_start_time;
+
+static Bool
+try_get_reply (Display           *xdisplay,
+               AgGetPropertyTask *task)
+{
+  if (ag_task_have_reply (task))
+    {
+      int result;
+      Atom actual_type;
+      int actual_format;
+      unsigned long n_items;
+      unsigned long bytes_after;
+      unsigned char *data;
+      char *name;
+      struct timeval current_time;
+
+      gettimeofday (&current_time, NULL);
+      
+      printf (" %gms (we have a reply for property %ld)\n",
+              ELAPSED (program_start_time, current_time),
+              ag_task_get_property (task));
+      
+      data = NULL;
+
+      name = atom_name (xdisplay,
+                        ag_task_get_property (task));
+      printf (" %s on 0x%lx:\n", name,
+              ag_task_get_window (task));
+      free (name);
+      
+      result = ag_task_get_reply_and_free (task,
+                                           &actual_type,
+                                           &actual_format,
+                                           &n_items,
+                                           &bytes_after,
+                                           &data);
+      task = NULL;
+
+      if (result != Success)
+        {
+          fprintf (stderr, "  error code %d getting reply\n", result);
+        }
+      else
+        {
+          name = atom_name (xdisplay, actual_type);
+          printf ("  actual_type = %s\n", name);
+          free (name);
+          
+          printf ("  actual_format = %d\n", actual_format);
+          
+          printf ("  n_items = %lu\n", n_items);
+          printf ("  bytes_after = %lu\n", bytes_after);
+          
+          printf ("  data = \"%s\"\n", data ? (char*) data : "NULL");
+        }
+
+      return True;
+    }
+
+  return False;
+}
+
+static void run_speed_comparison (Display *xdisplay,
+                                  Window   window);
+
+int
+main (int argc, char **argv)
+{
+  Display *xdisplay;
+  int i;
+  int n_left;
+  int n_props;
+  Window window;
+  const char *window_str;
+  char *end;
+  Atom *props;
+  struct timeval current_time;
+  
+  if (argc < 2)
+    {
+      fprintf (stderr, "specify window ID\n");
+      return 1;
+    }
+  
+  window_str = argv[1];
+
+  end = NULL;
+  window = strtoul (window_str, &end, 0);
+  if (end == NULL || *end != '\0')
+    {
+      fprintf (stderr, "\"%s\" does not parse as a window ID\n", window_str);
+      return 1;
+    }
+
+  xdisplay = XOpenDisplay (NULL);
+  if (xdisplay == NULL)
+    {
+      fprintf (stderr, "Could not open display\n");
+      return 1;
+    }
+
+  if (getenv ("MARCO_SYNC") != NULL)
+    XSynchronize (xdisplay, True);
+
+  XSetErrorHandler (x_error_handler);
+  
+  n_props = 0;
+  props = XListProperties (xdisplay, window, &n_props);
+  if (n_props == 0 || props == NULL)
+    {
+      fprintf (stderr, "Window has no properties\n");
+      return 1;
+    }
+
+  gettimeofday (&program_start_time, NULL);
+  
+  i = 0;
+  while (i < n_props)
+    {
+      gettimeofday (&current_time, NULL);
+      printf (" %gms (sending request for property %ld)\n",
+              ELAPSED (program_start_time, current_time),
+              props[i]);
+      if (ag_task_create (xdisplay,
+                          window, props[i],
+                          0, 0xffffffff,
+                          False,
+                          AnyPropertyType) == NULL)
+        {
+          fprintf (stderr, "Failed to send request\n");
+          return 1;
+        }
+      
+      ++i;
+    }
+
+  XFree (props);
+  props = NULL;
+
+  n_left = n_props;
+  
+  while (TRUE)
+    {
+      XEvent xevent;
+      int connection;
+      fd_set set;
+      AgGetPropertyTask *task;
+      
+      /* Mop up event queue */
+      while (XPending (xdisplay) > 0)
+        {                  
+          XNextEvent (xdisplay, &xevent);
+          gettimeofday (&current_time, NULL);
+          printf (" %gms (processing event type %d)\n",
+                  ELAPSED (program_start_time, current_time),
+                  xevent.xany.type);
+        }
+      
+      while ((task = ag_get_next_completed_task (xdisplay)))
+        {
+          try_get_reply (xdisplay, task);
+          n_left -= 1;
+        }
+
+      if (n_left == 0)
+        {
+          printf ("All %d replies received.\n", n_props);
+          break;
+        }
+
+      /* Wake up if we may have a reply */
+      connection = ConnectionNumber (xdisplay);
+
+      FD_ZERO (&set);
+      FD_SET (connection, &set);
+
+      gettimeofday (&current_time, NULL);
+      printf (" %gms (blocking for data %d left)\n",
+              ELAPSED (program_start_time, current_time), n_left);
+      select (connection + 1, &set, NULL, NULL, NULL);
+    }
+
+  run_speed_comparison (xdisplay, window);
+  
+  return 0;
+}
+
+/* This function doesn't have all the printf's
+ * and other noise, it just compares async to sync
+ */
+static void
+run_speed_comparison (Display *xdisplay,
+                      Window   window)
+{
+  int i;
+  int n_props;
+  struct timeval start, end;
+  int n_left;
+  
+  /* We just use atom values (0 to n_props) % 200, many are probably
+   * BadAtom, that's fine, but the %200 keeps most of them valid. The
+   * async case is about twice as advantageous when using valid atoms
+   * (or the issue may be that it's more advantageous when the
+   * properties are present and data is transmitted).
+   */
+  n_props = 4000;
+  printf ("Timing with %d property requests\n", n_props);
+  
+  gettimeofday (&start, NULL);
+  
+  i = 0;
+  while (i < n_props)
+    {
+      if (ag_task_create (xdisplay,
+                          window, (Atom) i % 200,
+                          0, 0xffffffff,
+                          False,
+                          AnyPropertyType) == NULL)
+        {
+          fprintf (stderr, "Failed to send request\n");
+          exit (1);
+        }
+      
+      ++i;
+    }
+
+  n_left = n_props;
+  
+  while (TRUE)
+    {
+      int connection;
+      fd_set set;
+      XEvent xevent;
+      AgGetPropertyTask *task;
+      
+      /* Mop up event queue */
+      while (XPending (xdisplay) > 0)
+        XNextEvent (xdisplay, &xevent);
+      
+      while ((task = ag_get_next_completed_task (xdisplay)))
+        {
+          int result;
+          Atom actual_type;
+          int actual_format;
+          unsigned long n_items;
+          unsigned long bytes_after;
+          unsigned char *data;
+
+          assert (ag_task_have_reply (task));
+          
+          data = NULL;
+          result = ag_task_get_reply_and_free (task,
+                                               &actual_type,
+                                               &actual_format,
+                                               &n_items,
+                                               &bytes_after,
+                                               &data);
+          
+          if (data)
+            XFree (data);
+          
+          n_left -= 1;
+        }
+      
+      if (n_left == 0)
+        break;
+
+      /* Wake up if we may have a reply */
+      connection = ConnectionNumber (xdisplay);
+
+      FD_ZERO (&set);
+      FD_SET (connection, &set);
+
+      select (connection + 1, &set, NULL, NULL, NULL);
+    }
+  
+  gettimeofday (&end, NULL);
+  
+  printf ("Async time: %gms\n",
+          ELAPSED (start, end));
+  
+  gettimeofday (&start, NULL);
+
+  error_trap_push (xdisplay);
+  
+  i = 0;
+  while (i < n_props)
+    {
+      Atom actual_type;
+      int actual_format;
+      unsigned long n_items;
+      unsigned long bytes_after;
+      unsigned char *data;
+      
+      data = NULL;
+      if (XGetWindowProperty (xdisplay, window,
+                              (Atom) i % 200,
+                              0, 0xffffffff,
+                              False,
+                              AnyPropertyType,
+                              &actual_type,
+                              &actual_format,
+                              &n_items,
+                              &bytes_after,
+                              &data) == Success)
+        {
+          if (data)
+            XFree (data);
+        }
+      
+      ++i;
+    }
+
+  error_trap_pop (xdisplay);
+  
+  gettimeofday (&end, NULL);
+  
+  printf ("Sync time:  %gms\n",
+          ELAPSED (start, end));
+}
diff --git a/src/core/testboxes.c b/src/core/testboxes.c
new file mode 100644
index 00000000..fc81f064
--- /dev/null
+++ b/src/core/testboxes.c
@@ -0,0 +1,1416 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco box operation testing program */
+
+/* 
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "boxes.h"
+#include <glib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <X11/Xutil.h> /* Just for the definition of the various gravities */
+#include <time.h>      /* To initialize random seed */
+
+#define NUM_RANDOM_RUNS 10000
+
+static void
+init_random_ness ()
+{
+  srand(time(NULL));
+}
+
+static void
+get_random_rect (MetaRectangle *rect)
+{
+  rect->x = rand () % 1600;
+  rect->y = rand () % 1200;
+  rect->width  = rand () % 1600 + 1;
+  rect->height = rand () % 1200 + 1;
+}
+
+static MetaRectangle*
+new_meta_rect (int x, int y, int width, int height)
+{
+  MetaRectangle* temporary;
+  temporary = g_new (MetaRectangle, 1);
+  temporary->x = x;
+  temporary->y = y;
+  temporary->width  = width;
+  temporary->height = height;
+
+  return temporary;
+}
+
+static MetaStrut*
+new_meta_strut (int x, int y, int width, int height, int side)
+{
+  MetaStrut* temporary;
+  temporary = g_new (MetaStrut, 1);
+  temporary->rect = meta_rect(x, y, width, height);
+  temporary->side = side;
+
+  return temporary;
+}
+
+static MetaEdge*
+new_screen_edge (int x, int y, int width, int height, int side_type)
+{
+  MetaEdge* temporary;
+  temporary = g_new (MetaEdge, 1);
+  temporary->rect.x = x;
+  temporary->rect.y = y;
+  temporary->rect.width  = width;
+  temporary->rect.height = height;
+  temporary->side_type = side_type;
+  temporary->edge_type = META_EDGE_SCREEN;
+
+  return temporary;
+}
+
+static MetaEdge*
+new_xinerama_edge (int x, int y, int width, int height, int side_type)
+{
+  MetaEdge* temporary;
+  temporary = g_new (MetaEdge, 1);
+  temporary->rect.x = x;
+  temporary->rect.y = y;
+  temporary->rect.width  = width;
+  temporary->rect.height = height;
+  temporary->side_type = side_type;
+  temporary->edge_type = META_EDGE_XINERAMA;
+
+  return temporary;
+}
+
+static void
+test_area ()
+{
+  MetaRectangle temp;
+  int i;
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&temp);
+      g_assert (meta_rectangle_area (&temp) == temp.width * temp.height);
+    }
+
+  temp = meta_rect (0, 0, 5, 7);
+  g_assert (meta_rectangle_area (&temp) == 35);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_intersect ()
+{
+  MetaRectangle a = {100, 200,  50,  40};
+  MetaRectangle b = {  0,  50, 110, 152};
+  MetaRectangle c = {  0,   0,  10,  10};
+  MetaRectangle d = {100, 100,  50,  50};
+  MetaRectangle b_intersect_d = {100, 100, 10, 50};
+  MetaRectangle temp;
+  MetaRectangle temp2;
+
+  meta_rectangle_intersect (&a, &b, &temp);
+  temp2 = meta_rect (100, 200, 10, 2);
+  g_assert (meta_rectangle_equal (&temp, &temp2));
+  g_assert (meta_rectangle_area (&temp) == 20);
+
+  meta_rectangle_intersect (&a, &c, &temp);
+  g_assert (meta_rectangle_area (&temp) == 0);
+
+  meta_rectangle_intersect (&a, &d, &temp);
+  g_assert (meta_rectangle_area (&temp) == 0);
+
+  meta_rectangle_intersect (&b, &d, &b);
+  g_assert (meta_rectangle_equal (&b, &b_intersect_d));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_equal ()
+{
+  MetaRectangle a = {10, 12, 4, 18};
+  MetaRectangle b = a;
+  MetaRectangle c = {10, 12, 4, 19};
+  MetaRectangle d = {10, 12, 7, 18};
+  MetaRectangle e = {10, 62, 4, 18};
+  MetaRectangle f = {27, 12, 4, 18};
+
+  g_assert ( meta_rectangle_equal (&a, &b));
+  g_assert (!meta_rectangle_equal (&a, &c));
+  g_assert (!meta_rectangle_equal (&a, &d));
+  g_assert (!meta_rectangle_equal (&a, &e));
+  g_assert (!meta_rectangle_equal (&a, &f));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_overlap_funcs ()
+{
+  MetaRectangle temp1, temp2;
+  int i;
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&temp1);
+      get_random_rect (&temp2);
+      g_assert (meta_rectangle_overlap (&temp1, &temp2) ==
+                (meta_rectangle_horiz_overlap (&temp1, &temp2) &&
+                 meta_rectangle_vert_overlap (&temp1, &temp2)));
+    }
+
+  temp1 = meta_rect ( 0, 0, 10, 10);
+  temp2 = meta_rect (20, 0, 10,  5);
+  g_assert (!meta_rectangle_overlap (&temp1, &temp2));
+  g_assert (!meta_rectangle_horiz_overlap (&temp1, &temp2));
+  g_assert ( meta_rectangle_vert_overlap (&temp1, &temp2));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_basic_fitting ()
+{
+  MetaRectangle temp1, temp2, temp3;
+  int i;
+  /* Four cases:
+   *   case   temp1 fits temp2    temp1 could fit temp2
+   *     1           Y                      Y
+   *     2           N                      Y
+   *     3           Y                      N
+   *     4           N                      N
+   * Of the four cases, case 3 is impossible.  An alternate way of looking
+   * at this table is that either the middle column must be no, or the last
+   * column must be yes.  So we test that.  Also, we can repeat the test
+   * reversing temp1 and temp2.
+   */
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&temp1);
+      get_random_rect (&temp2);
+      g_assert (meta_rectangle_contains_rect (&temp1, &temp2) == FALSE ||
+                meta_rectangle_could_fit_rect (&temp1, &temp2) == TRUE);
+      g_assert (meta_rectangle_contains_rect (&temp2, &temp1) == FALSE ||
+                meta_rectangle_could_fit_rect (&temp2, &temp1) == TRUE);
+    }
+
+  temp1 = meta_rect ( 0, 0, 10, 10);
+  temp2 = meta_rect ( 5, 5,  5,  5);
+  temp3 = meta_rect ( 8, 2,  3,  7);
+  g_assert ( meta_rectangle_contains_rect (&temp1, &temp2));
+  g_assert (!meta_rectangle_contains_rect (&temp2, &temp1));
+  g_assert (!meta_rectangle_contains_rect (&temp1, &temp3));
+  g_assert ( meta_rectangle_could_fit_rect (&temp1, &temp3));
+  g_assert (!meta_rectangle_could_fit_rect (&temp3, &temp2));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+free_strut_list (GSList *struts)
+{
+  GSList *tmp = struts;
+  while (tmp)
+    {
+      g_free (tmp->data);
+      tmp = tmp->next;
+    }
+  g_slist_free (struts);
+}
+
+static GSList*
+get_strut_list (int which)
+{
+  GSList *ans;
+  MetaDirection wc = 0; /* wc == who cares? ;-) */
+
+  ans = NULL;
+
+  g_assert (which >=0 && which <= 6);
+  switch (which)
+    {
+    case 0:
+      break;
+    case 1:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 400, 1160, 1600,   40, wc));
+      break;
+    case 2:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,  150,   50, wc));
+      break;
+    case 3:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,   80,   50, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 700,  525,  200,  150, wc));
+      break;
+    case 4:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, wc));
+      break;
+    case 5:
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,   10,  800, 1200, wc));
+      break;
+    case 6:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   40, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      break;
+    }
+
+  return ans;
+}
+
+static GList*
+get_screen_region (int which)
+{
+  GList *ret;
+  GSList *struts;
+  MetaRectangle basic_rect;
+
+  basic_rect = meta_rect (0, 0, 1600, 1200);
+  ret = NULL;
+
+  struts = get_strut_list (which);
+  ret = meta_rectangle_get_minimal_spanning_set_for_region (&basic_rect, struts);
+  free_strut_list (struts);
+
+  return ret;
+}
+
+static GList*
+get_screen_edges (int which)
+{
+  GList *ret;
+  GSList *struts;
+  MetaRectangle basic_rect;
+
+  basic_rect = meta_rect (0, 0, 1600, 1200);
+  ret = NULL;
+
+  struts = get_strut_list (which);
+  ret = meta_rectangle_find_onscreen_edges (&basic_rect, struts);
+  free_strut_list (struts);
+
+  return ret;
+}
+
+static GList*
+get_xinerama_edges (int which_xinerama_set, int which_strut_set)
+{
+  GList *ret;
+  GSList *struts;
+  GList *xins;
+
+  xins = NULL;
+  g_assert (which_xinerama_set >=0 && which_xinerama_set <= 3);
+  switch (which_xinerama_set)
+    {
+    case 0:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600, 1200));
+      break;
+    case 1:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0,  800, 1200));
+      xins = g_list_prepend (xins, new_meta_rect (800,   0,  800, 1200));
+      break;
+    case 2:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600,  600));
+      xins = g_list_prepend (xins, new_meta_rect (  0, 600, 1600,  600));
+      break;
+    case 3:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600,  600));
+      xins = g_list_prepend (xins, new_meta_rect (  0, 600,  800,  600));
+      xins = g_list_prepend (xins, new_meta_rect (800, 600,  800,  600));
+      break;
+    }
+
+  ret = NULL;
+
+  struts = get_strut_list (which_strut_set);
+  ret = meta_rectangle_find_nonintersected_xinerama_edges (xins, struts);
+
+  free_strut_list (struts);
+  meta_rectangle_free_list_and_elements (xins);
+
+  return ret;
+}
+
+#if 0
+static void
+test_merge_regions ()
+{
+  /* logarithmically distributed random number of struts (range?)
+   * logarithmically distributed random size of struts (up to screen size???)
+   * uniformly distributed location of center of struts (within screen)
+   * merge all regions that are possible
+   * print stats on problem setup
+   *   number of (non-completely-occluded?) struts 
+   *   percentage of screen covered
+   *   length of resulting non-minimal spanning set
+   *   length of resulting minimal spanning set
+   * print stats on merged regions:
+   *   number boxes merged
+   *   number of those merges that were of the form A contains B
+   *   number of those merges that were of the form A partially contains B
+   *   number of those merges that were of the form A is adjacent to B
+   */
+
+  GList* region;
+  GList* compare;
+  int num_contains, num_merged, num_part_contains, num_adjacent;
+
+  num_contains = num_merged = num_part_contains = num_adjacent = 0;
+  compare = region = get_screen_region (2);
+  g_assert (region);
+
+  printf ("Merging stats:\n");
+  printf ("  Length of initial list: %d\n", g_list_length (region));
+#ifdef PRINT_DEBUG
+  char rect1[RECT_LENGTH], rect2[RECT_LENGTH];
+  char region_list[(RECT_LENGTH + 2) * g_list_length (region)];
+  meta_rectangle_region_to_string (region, ", ", region_list);
+  printf ("  Initial rectangles: %s\n", region_list);
+#endif
+
+  while (compare && compare->next)
+    {
+      MetaRectangle *a = compare->data;
+      GList *other = compare->next;
+
+      g_assert (a->width > 0 && a->height > 0);
+
+      while (other)
+        {
+          MetaRectangle *b = other->data;
+          GList *delete_me = NULL;
+
+          g_assert (b->width > 0 && b->height > 0);
+
+#ifdef PRINT_DEBUG
+          printf ("    -- Comparing %s to %s --\n",
+                  meta_rectangle_to_string (a, rect1),
+                  meta_rectangle_to_string (b, rect2));
+#endif
+
+          /* If a contains b, just remove b */
+          if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = other;
+              num_contains++;
+              num_merged++;
+            }
+          /* If b contains a, just remove a */
+          else if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = compare;
+              num_contains++;
+              num_merged++;
+            }
+          /* If a and b might be mergeable horizontally */
+          else if (a->y == b->y && a->height == b->height)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                  num_part_contains++;
+                  num_merged++;
+                }
+              /* If a and b are adjacent */
+              else if (a->x + a->width == b->x || a->x == b->x + b->width)
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                  num_adjacent++;
+                  num_merged++;
+                }
+            }
+          /* If a and b might be mergeable vertically */
+          else if (a->x == b->x && a->width == b->width)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                  num_part_contains++;
+                  num_merged++;
+                }
+              /* If a and b are adjacent */
+              else if (a->y + a->height == b->y || a->y == b->y + b->height)
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                  num_adjacent++;
+                  num_merged++;
+                }
+            }
+
+          other = other->next;
+
+          /* Delete any rectangle in the list that is no longer wanted */
+          if (delete_me != NULL)
+            {
+#ifdef PRINT_DEBUG
+              MetaRectangle *bla = delete_me->data;
+              printf ("    Deleting rect %s\n",
+                      meta_rectangle_to_string (bla, rect1));
+#endif
+
+              /* Deleting the rect we're compare others to is a little tricker */
+              if (compare == delete_me)
+                {
+                  compare = compare->next;
+                  other = compare->next;
+                  a = compare->data;
+                }
+
+              /* Okay, we can free it now */
+              g_free (delete_me->data);
+              region = g_list_delete_link (region, delete_me);
+            }
+
+#ifdef PRINT_DEBUG
+          char region_list[(RECT_LENGTH + 2) * g_list_length (region)];
+          meta_rectangle_region_to_string (region, ", ", region_list);
+          printf ("      After comparison, new list is: %s\n", region_list);
+#endif
+        }
+
+      compare = compare->next;
+    }
+
+  printf ("  Num rectangles contained in others          : %d\n", 
+          num_contains);
+  printf ("  Num rectangles partially contained in others: %d\n", 
+          num_part_contains);
+  printf ("  Num rectangles adjacent to others           : %d\n", 
+          num_adjacent);
+  printf ("  Num rectangles merged with others           : %d\n",
+          num_merged);
+#ifdef PRINT_DEBUG
+  char region_list2[(RECT_LENGTH + 2) * g_list_length (region)];
+  meta_rectangle_region_to_string (region, ", ", region_list2);
+  printf ("  Final rectangles: %s\n", region_list2);
+#endif
+
+  meta_rectangle_free_spanning_set (region);
+  region = NULL;
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+#endif
+
+static void
+verify_lists_are_equal (GList *code, GList *answer)
+{
+  int which = 0;
+
+  while (code && answer)
+    {
+      MetaRectangle *a = code->data;
+      MetaRectangle *b = answer->data;
+
+      if (a->x      != b->x     ||
+          a->y      != b->y     ||
+          a->width  != b->width ||
+          a->height != b->height)
+        {
+          g_error ("%dth item in code answer answer lists do not match; "
+                   "code rect: %d,%d + %d,%d; answer rect: %d,%d + %d,%d\n",
+                   which,
+                   a->x, a->y, a->width, a->height,
+                   b->x, b->y, b->width, b->height);
+        }
+
+      code = code->next;
+      answer = answer->next;
+
+      which++;
+    }
+
+  /* Ought to be at the end of both lists; check if we aren't */
+  if (code)
+    {
+      MetaRectangle *tmp = code->data;
+      g_error ("code list longer than answer list by %d items; "
+               "first extra item: %d,%d +%d,%d\n",
+               g_list_length (code),
+               tmp->x, tmp->y, tmp->width, tmp->height);
+    }
+
+  if (answer)
+    {
+      MetaRectangle *tmp = answer->data;
+      g_error ("answer list longer than code list by %d items; "
+               "first extra item: %d,%d +%d,%d\n",
+               g_list_length (answer),
+               tmp->x, tmp->y, tmp->width, tmp->height);
+    }
+}
+
+static void
+test_regions_okay ()
+{
+  GList* region;
+  GList* tmp;
+
+  /*************************************************************/  
+  /* Make sure test region 0 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (0);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect (0, 0, 1600, 1200));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/  
+  /* Make sure test region 1 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (1);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect (0, 20,  400, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect (0, 20, 1600, 1140));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 2 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (2);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  300, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect ( 450,   20,  350, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect (1200,   20,  400, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  800, 1130));
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20, 1600, 1080));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 3 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (3);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect ( 380,  675,  420,  525)); /* 220500 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  300, 1180)); /* 354000 */
+  tmp = g_list_prepend (tmp, new_meta_rect ( 380,   20,  320, 1180)); /* 377600 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,  675,  800,  475)); /* 380000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (1200,   20,  400, 1180)); /* 472000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,  675, 1600,  425)); /* 680000 */
+  tmp = g_list_prepend (tmp, new_meta_rect ( 900,   20,  700, 1080)); /* 756000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  700, 1130)); /* 791000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20, 1600,  505)); /* 808000 */
+#if 0
+  printf ("Got to here...\n");
+  char region_list[(RECT_LENGTH+2) * g_list_length (region)];
+  char tmp_list[   (RECT_LENGTH+2) * g_list_length (tmp)];
+  meta_rectangle_region_to_string (region, ", ", region_list);
+  meta_rectangle_region_to_string (region, ", ", tmp_list);
+  printf ("%s vs. %s\n", region_list, tmp_list);
+#endif
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 4 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (4);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect ( 800,   20,  800, 1180));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 5 has the right spanning rectangles */
+  /*************************************************************/  
+  printf ("The next test intentionally causes a warning, "
+          "but it can be ignored.\n");
+  region = get_screen_region (5);
+  verify_lists_are_equal (region, NULL);
+
+  /* FIXME: Still to do:
+   *   - Create random struts and check the regions somehow
+   */
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_region_fitting ()
+{
+  GList* region;
+  MetaRectangle rect;
+
+  /* See test_basic_fitting() for how/why these automated random tests work */
+  int i;
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&rect);
+      g_assert (meta_rectangle_contained_in_region (region, &rect) == FALSE ||
+                meta_rectangle_could_fit_in_region (region, &rect) == TRUE);
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (1);
+
+  rect = meta_rect (50, 50, 400, 400);
+  g_assert (meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (meta_rectangle_contained_in_region (region, &rect));
+
+  rect = meta_rect (250, 0, 500, 1150);
+  g_assert (!meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (!meta_rectangle_contained_in_region (region, &rect));
+
+  rect = meta_rect (250, 0, 400, 400);
+  g_assert (meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (!meta_rectangle_contained_in_region (region, &rect));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  region = get_screen_region (2);
+  rect = meta_rect (1000, 50, 600, 1100);
+  g_assert (meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (!meta_rectangle_contained_in_region (region, &rect));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_clamping_to_region ()
+{
+  GList* region;
+  MetaRectangle rect;
+  MetaRectangle min_size;
+  FixedDirections fixed_directions;
+  int i;
+
+  min_size.height = min_size.width = 1;
+  fixed_directions = 0;
+
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      MetaRectangle temp;
+      get_random_rect (&rect);
+      temp = rect;
+      meta_rectangle_clamp_to_fit_into_region (region,
+                                               fixed_directions,
+                                               &rect,
+                                               &min_size);
+      g_assert (meta_rectangle_could_fit_in_region (region, &rect) == TRUE);
+      g_assert (rect.x == temp.x && rect.y == temp.y);
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (1);
+
+  rect = meta_rect (50, 50, 10000, 10000);
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 1600 && rect.height == 1140);
+
+  rect = meta_rect (275, -50, 410, 10000);
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 400 && rect.height == 1180);
+
+  rect = meta_rect (50, 50, 10000, 10000);
+  min_size.height = 1170;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 400 && rect.height == 1180);
+
+  printf ("The next test intentionally causes a warning, "
+          "but it can be ignored.\n");
+  rect = meta_rect (50, 50, 10000, 10000);
+  min_size.width = 600;  min_size.height = 1170;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 600 && rect.height == 1170);
+
+  rect = meta_rect (350, 50, 100, 1100);
+  min_size.width = 1;  min_size.height = 1;
+  fixed_directions = FIXED_DIRECTION_X;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 100 && rect.height == 1100);
+
+  rect = meta_rect (300, 70, 500, 1100);
+  min_size.width = 1;  min_size.height = 1;
+  fixed_directions = FIXED_DIRECTION_Y;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 400 && rect.height == 1100);
+
+  printf ("The next test intentionally causes a warning, "
+          "but it can be ignored.\n");
+  rect = meta_rect (300, 70, 999999, 999999);
+  min_size.width = 100;  min_size.height = 200;
+  fixed_directions = FIXED_DIRECTION_Y;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 100 && rect.height == 999999);
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static gboolean
+rect_overlaps_region (const GList         *spanning_rects,
+                      const MetaRectangle *rect)
+{
+  /* FIXME: Should I move this to boxes.[ch]? */
+  const GList *temp;
+  gboolean     overlaps;
+
+  temp = spanning_rects;
+  overlaps = FALSE;
+  while (!overlaps && temp != NULL)
+    {
+      overlaps = overlaps || meta_rectangle_overlap (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return overlaps;
+}
+
+gboolean time_to_print = FALSE;
+
+static void
+test_clipping_to_region ()
+{
+  GList* region;
+  MetaRectangle rect, temp;
+  FixedDirections fixed_directions = 0;
+  int i;
+
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&rect);
+      if (rect_overlaps_region (region, &rect))
+        {
+          meta_rectangle_clip_to_region (region, 0, &rect);
+          g_assert (meta_rectangle_contained_in_region (region, &rect) == TRUE);
+        }
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (2);
+
+  rect = meta_rect (-50, -10, 10000, 10000);
+  meta_rectangle_clip_to_region (region,
+                                 fixed_directions,
+                                 &rect);
+  g_assert (meta_rectangle_equal (region->data, &rect));
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (300, 1000, 400, 150);
+  meta_rectangle_clip_to_region (region,
+                                 fixed_directions,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (400, 1000, 300, 200);
+  temp = meta_rect (450, 1000, 250, 200);
+  meta_rectangle_clip_to_region (region,
+                                 fixed_directions,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (400, 1000, 300, 200);
+  temp = meta_rect (400, 1000, 300, 150);
+  meta_rectangle_clip_to_region (region,
+                                 FIXED_DIRECTION_X,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (400, 1000, 300, 200);
+  temp = meta_rect (400, 1000, 300, 150);
+  meta_rectangle_clip_to_region (region,
+                                 FIXED_DIRECTION_X,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_shoving_into_region ()
+{
+  GList* region;
+  MetaRectangle rect, temp;
+  FixedDirections fixed_directions = 0;
+  int i;
+
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&rect);
+      if (meta_rectangle_could_fit_in_region (region, &rect))
+        {
+          meta_rectangle_shove_into_region (region, 0, &rect);
+          g_assert (meta_rectangle_contained_in_region (region, &rect));
+        }
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (2);
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (300,  950, 400, 200);
+  meta_rectangle_shove_into_region (region,
+                                    fixed_directions,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (425, 1000, 300, 200);
+  temp = meta_rect (450, 1000, 300, 200);
+  meta_rectangle_shove_into_region (region,
+                                    fixed_directions,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (425, 1000, 300, 200);
+  temp = meta_rect (425,  950, 300, 200);
+  meta_rectangle_shove_into_region (region,
+                                    FIXED_DIRECTION_X,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 300, 1000, 400, 200);
+  temp = meta_rect (1200, 1000, 400, 200);
+  meta_rectangle_shove_into_region (region,
+                                    FIXED_DIRECTION_Y,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 800, 1150, 400,  50);  /* Completely "offscreen" :) */
+  temp = meta_rect ( 800, 1050, 400,  50);
+  meta_rectangle_shove_into_region (region,
+                                    0,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (-1000,  0, 400, 150);  /* Offscreen in 2 directions */
+  temp = meta_rect (    0, 20, 400, 150);
+  meta_rectangle_shove_into_region (region,
+                                    0,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+verify_edge_lists_are_equal (GList *code, GList *answer)
+{
+  int which = 0;
+
+  while (code && answer)
+    {
+      MetaEdge *a = code->data;
+      MetaEdge *b = answer->data;
+
+      if (!meta_rectangle_equal (&a->rect, &b->rect) ||
+          a->side_type != b->side_type ||
+          a->edge_type != b->edge_type)
+        {
+          g_error ("%dth item in code answer answer lists do not match; "
+                   "code rect: %d,%d + %d,%d; answer rect: %d,%d + %d,%d\n",
+                   which,
+                   a->rect.x, a->rect.y, a->rect.width, a->rect.height,
+                   b->rect.x, b->rect.y, b->rect.width, b->rect.height);
+        }
+
+      code = code->next;
+      answer = answer->next;
+
+      which++;
+    }
+
+  /* Ought to be at the end of both lists; check if we aren't */
+  if (code)
+    {
+      MetaEdge *tmp = code->data;
+      g_error ("code list longer than answer list by %d items; "
+               "first extra item rect: %d,%d +%d,%d\n",
+               g_list_length (code),
+               tmp->rect.x, tmp->rect.y, tmp->rect.width, tmp->rect.height);
+    }
+
+  if (answer)
+    {
+      MetaEdge *tmp = answer->data;
+      g_error ("answer list longer than code list by %d items; "
+               "first extra item rect: %d,%d +%d,%d\n",
+               g_list_length (answer),
+               tmp->rect.x, tmp->rect.y, tmp->rect.width, tmp->rect.height);
+    }
+}
+
+static void
+test_find_onscreen_edges ()
+{
+  GList* edges;
+  GList* tmp;
+
+  int left   = META_DIRECTION_LEFT;
+  int right  = META_DIRECTION_RIGHT;
+  int top    = META_DIRECTION_TOP;
+  int bottom = META_DIRECTION_BOTTOM;
+
+  /*************************************************/  
+  /* Make sure test region 0 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (0);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200, 1600, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,    0, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,    0, 0, 1200, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,    0, 0, 1200, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 1 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (1);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 400, 1160, 1200, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1140, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 400, 1160, 0,   40, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 2 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (2);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 450, 1200,  350, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  300, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150,  150, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100, 0,  100, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150, 0,   50, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1100, 0,  100, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 450, 1150, 0,   50, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 3 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (3);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 380, 1200,  420, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  300, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150,   80, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  525, 200,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  675, 200,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100, 0,  100, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  525, 0,  150, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150, 0,   50, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1100, 0,  100, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 900,  525, 0,  150, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 380, 1150, 0,   50, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
+
+#if 0
+  #define FUDGE 50 /* number of edges */
+  char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE];
+  meta_rectangle_edge_list_to_string (edges, "\n ", big_buffer1);
+  meta_rectangle_edge_list_to_string (tmp,   "\n ", big_buffer2);
+  printf("Generated edge list:\n %s\nComparison edges list:\n %s\n", 
+         big_buffer1, big_buffer2);
+#endif
+
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 4 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (4);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1200, 800,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800,   20, 800,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800,   20, 0, 1180, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 5 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (5);
+  tmp = NULL;
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 6 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (6);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200, 1600,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   40, 1600,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   40, 0,  1160, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   40, 0,  1160, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_find_nonintersected_xinerama_edges ()
+{
+  GList* edges;
+  GList* tmp;
+
+  int left   = META_DIRECTION_LEFT;
+  int right  = META_DIRECTION_RIGHT;
+  int top    = META_DIRECTION_TOP;
+  int bottom = META_DIRECTION_BOTTOM;
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 0 for with region 0 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (0, 0);
+  tmp = NULL;
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 2 for with region 1 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (2, 1);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600, 1600, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600, 1600, 0, top));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 1 for with region 2 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (1, 2);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,   20, 0, 1080, right));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,   20, 0, 1180, left));
+#if 0
+  #define FUDGE 50
+  char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE];
+  meta_rectangle_edge_list_to_string (edges, "\n ", big_buffer1);
+  meta_rectangle_edge_list_to_string (tmp,   "\n ", big_buffer2);
+  printf("Generated edge list:\n %s\nComparison edges list:\n %s\n", 
+         big_buffer1, big_buffer2);
+#endif
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 3 for with region 3 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (3, 3);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 900,  600,  700, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600,  700, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 900,  600,  700, 0, top));
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600,  700, 0, top));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  675, 0,  425, right));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  675, 0,  525, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 3 for with region 4 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (3, 4);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  800, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  800, 0, top));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  0, 600, right));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 3 for with region 5has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (3, 5);
+  tmp = NULL;
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_gravity_resize ()
+{
+  MetaRectangle oldrect, rect, temp;
+
+  rect.x = -500;  /* Some random amount not equal to oldrect.x to ensure that
+                   * the resize is done with respect to oldrect instead of rect
+                   */
+  oldrect = meta_rect ( 50,  300, 250, 400);
+  temp    = meta_rect ( 50,  300,  20,   5);
+  meta_rectangle_resize_with_gravity (&oldrect,
+                                      &rect,
+                                      NorthWestGravity,
+                                      20,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (165,  300,  20,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      NorthGravity,
+                                      20,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (280,  300,  20,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      NorthEastGravity,
+                                      20,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect ( 50,  695,  50,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      SouthWestGravity,
+                                      50,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (150,  695,  50,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      SouthGravity,
+                                      50,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (250,  695,  50,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      SouthEastGravity,
+                                      50,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (167,  738, 237, 843);
+  temp = meta_rect (167, 1113, 832,  93);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      WestGravity,
+                                      832,
+                                      93);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 167,  738, 237, 843);
+  temp = meta_rect (-131, 1113, 833,  93);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      CenterGravity,
+                                      832,
+                                      93);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (270,  994, 430, 212);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      EastGravity,
+                                      430,
+                                      211);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (300, 1000, 430, 211);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      StaticGravity,
+                                      430,
+                                      211);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_find_closest_point_to_line ()
+{
+  double x1, y1, x2, y2, px, py, rx, ry;
+  double answer_x, answer_y;
+
+  x1 =  3.0;  y1 =  49.0;
+  x2 =  2.0;  y2 = - 1.0;
+  px = -2.6;  py =  19.1;
+  answer_x = 2.4; answer_y = 19;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  /* Special test for x1 == x2, so that slop of line is infinite */
+  x1 =  3.0;  y1 =  49.0;
+  x2 =  3.0;  y2 = - 1.0;
+  px = -2.6;  py =  19.1;
+  answer_x = 3.0; answer_y = 19.1;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  /* Special test for y1 == y2, so perp line has slope of infinity */
+  x1 =  3.14;  y1 =   7.0;
+  x2 =  2.718; y2 =   7.0;
+  px = -2.6;   py =  19.1;
+  answer_x = -2.6; answer_y = 7;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  /* Test when we the point we want to be closest to is actually on the line */
+  x1 =  3.0;  y1 =  49.0;
+  x2 =  2.0;  y2 = - 1.0;
+  px =  2.4;  py =  19.0;
+  answer_x = 2.4; answer_y = 19;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+int
+main()
+{
+  init_random_ness ();
+  test_area ();
+  test_intersect ();
+  test_equal ();
+  test_overlap_funcs ();
+  test_basic_fitting ();
+
+  test_regions_okay ();
+  test_region_fitting ();
+
+  test_clamping_to_region ();
+  test_clipping_to_region ();
+  test_shoving_into_region ();
+
+  /* And now the functions dealing with edges more than boxes */
+  test_find_onscreen_edges ();
+  test_find_nonintersected_xinerama_edges ();
+
+  /* And now the misfit functions that don't quite fit in anywhere else... */
+  test_gravity_resize ();
+  test_find_closest_point_to_line ();
+
+  printf ("All tests passed.\n");
+  return 0;
+}
diff --git a/src/core/util.c b/src/core/util.c
new file mode 100644
index 00000000..6dd27f8e
--- /dev/null
+++ b/src/core/util.c
@@ -0,0 +1,641 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco utilities */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _POSIX_C_SOURCE 200112L /* for fdopen() */
+
+#include <config.h>
+#include "util.h"
+#include "main.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <X11/Xlib.h>   /* must explicitly be included for Solaris; #326746 */
+#include <X11/Xutil.h>  /* Just for the definition of the various gravities */
+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+void
+meta_print_backtrace (void)
+{
+  void *bt[500];
+  int bt_size;
+  int i;
+  char **syms;
+  
+  bt_size = backtrace (bt, 500);
+
+  syms = backtrace_symbols (bt, bt_size);
+  
+  i = 0;
+  while (i < bt_size)
+    {
+      meta_verbose ("  %s\n", syms[i]);
+      ++i;
+    }
+
+  free (syms);
+}
+#else
+void
+meta_print_backtrace (void)
+{
+  meta_verbose ("Not compiled with backtrace support\n");
+}
+#endif
+
+static gboolean is_verbose = FALSE;
+static gboolean is_debugging = FALSE;
+static gboolean replace_current = FALSE;
+static int no_prefix = 0;
+
+#ifdef WITH_VERBOSE_MODE
+static FILE* logfile = NULL;
+
+static void
+ensure_logfile (void)
+{
+  if (logfile == NULL && g_getenv ("MARCO_USE_LOGFILE"))
+    {
+      char *filename = NULL;
+      char *tmpl;
+      int fd;
+      GError *err;
+      
+      tmpl = g_strdup_printf ("marco-%d-debug-log-XXXXXX",
+                              (int) getpid ());
+
+      err = NULL;
+      fd = g_file_open_tmp (tmpl,
+                            &filename,
+                            &err);
+
+      g_free (tmpl);
+      
+      if (err != NULL)
+        {
+          meta_warning (_("Failed to open debug log: %s\n"),
+                        err->message);
+          g_error_free (err);
+          return;
+        }
+      
+      logfile = fdopen (fd, "w");
+      
+      if (logfile == NULL)
+        {
+          meta_warning (_("Failed to fdopen() log file %s: %s\n"),
+                        filename, strerror (errno));
+          close (fd);
+        }
+      else
+        {
+          g_printerr (_("Opened log file %s\n"), filename);
+        }
+      
+      g_free (filename);
+    }
+}
+#endif
+
+gboolean
+meta_is_verbose (void)
+{
+  return is_verbose;
+}
+
+void
+meta_set_verbose (gboolean setting)
+{
+#ifndef WITH_VERBOSE_MODE
+  if (setting)
+    meta_fatal (_("Marco was compiled without support for verbose mode\n"));
+#else 
+  if (setting)
+    ensure_logfile ();
+#endif
+  
+  is_verbose = setting;
+}
+
+gboolean
+meta_is_debugging (void)
+{
+  return is_debugging;
+}
+
+void
+meta_set_debugging (gboolean setting)
+{
+#ifdef WITH_VERBOSE_MODE
+  if (setting)
+    ensure_logfile ();
+#endif
+
+  is_debugging = setting;
+}
+
+gboolean
+meta_get_replace_current_wm (void)
+{
+  return replace_current;
+}
+
+void
+meta_set_replace_current_wm (gboolean setting)
+{
+  replace_current = setting;
+}
+
+char *
+meta_g_utf8_strndup (const gchar *src,
+                     gsize        n)
+{
+  const gchar *s = src;
+  while (n && *s)
+    {
+      s = g_utf8_next_char (s);
+      n--;
+    }
+
+  return g_strndup (src, s - src);
+}
+
+static int
+utf8_fputs (const char *str,
+            FILE       *f)
+{
+  char *l;
+  int retval;
+  
+  l = g_locale_from_utf8 (str, -1, NULL, NULL, NULL);
+
+  if (l == NULL)
+    retval = fputs (str, f); /* just print it anyway, better than nothing */
+  else
+    retval = fputs (l, f);
+
+  g_free (l);
+
+  return retval;
+}
+
+void
+meta_free_gslist_and_elements (GSList *list_to_deep_free)
+{
+  g_slist_foreach (list_to_deep_free,
+                   (void (*)(gpointer,gpointer))&g_free, /* ew, for ugly */
+                   NULL);
+  g_slist_free (list_to_deep_free);
+}
+
+#ifdef WITH_VERBOSE_MODE
+void
+meta_debug_spew_real (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+  
+  g_return_if_fail (format != NULL);
+
+  if (!is_debugging)
+    return;
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  out = logfile ? logfile : stderr;
+  
+  if (no_prefix == 0)
+    utf8_fputs (_("Window manager: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+void
+meta_verbose_real (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+
+  g_return_if_fail (format != NULL);
+
+  if (!is_verbose)
+    return;
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  out = logfile ? logfile : stderr;
+  
+  if (no_prefix == 0)
+    utf8_fputs ("Window manager: ", out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+topic_name (MetaDebugTopic topic)
+{
+  switch (topic)
+    {
+    case META_DEBUG_FOCUS:
+      return "FOCUS";
+    case META_DEBUG_WORKAREA:
+      return "WORKAREA";
+    case META_DEBUG_STACK:
+      return "STACK";
+    case META_DEBUG_THEMES:
+      return "THEMES";
+    case META_DEBUG_SM:
+      return "SM";
+    case META_DEBUG_EVENTS:
+      return "EVENTS";
+    case META_DEBUG_WINDOW_STATE:
+      return "WINDOW_STATE";
+    case META_DEBUG_WINDOW_OPS:
+      return "WINDOW_OPS";
+    case META_DEBUG_PLACEMENT:
+      return "PLACEMENT";
+    case META_DEBUG_GEOMETRY:
+      return "GEOMETRY";
+    case META_DEBUG_PING:
+      return "PING";
+    case META_DEBUG_XINERAMA:
+      return "XINERAMA";
+    case META_DEBUG_KEYBINDINGS:
+      return "KEYBINDINGS";
+    case META_DEBUG_SYNC:
+      return "SYNC";
+    case META_DEBUG_ERRORS:
+      return "ERRORS";
+    case META_DEBUG_STARTUP:
+      return "STARTUP";
+    case META_DEBUG_PREFS:
+      return "PREFS";
+    case META_DEBUG_GROUPS:
+      return "GROUPS";
+    case META_DEBUG_RESIZING:
+      return "RESIZING";
+    case META_DEBUG_SHAPES:
+      return "SHAPES";
+    case META_DEBUG_COMPOSITOR:
+      return "COMPOSITOR";
+    case META_DEBUG_EDGE_RESISTANCE:
+      return "EDGE_RESISTANCE";
+    }
+
+  return "WM";
+}
+
+static int sync_count = 0;
+
+void
+meta_topic_real (MetaDebugTopic topic,
+                 const char *format,
+                 ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+
+  g_return_if_fail (format != NULL);
+
+  if (!is_verbose)
+    return;
+  
+  va_start (args, format);  
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  out = logfile ? logfile : stderr;
+
+  if (no_prefix == 0)
+    fprintf (out, "%s: ", topic_name (topic));
+
+  if (topic == META_DEBUG_SYNC)
+    {
+      ++sync_count;
+      fprintf (out, "%d: ", sync_count);
+    }
+  
+  utf8_fputs (str, out);
+  
+  fflush (out);
+  
+  g_free (str);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+void
+meta_bug (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+
+  g_return_if_fail (format != NULL);
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+#ifdef WITH_VERBOSE_MODE
+  out = logfile ? logfile : stderr;
+#else
+  out = stderr;
+#endif
+
+  if (no_prefix == 0)
+    utf8_fputs (_("Bug in window manager: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+
+  meta_print_backtrace ();
+  
+  /* stop us in a debugger */
+  abort ();
+}
+
+void
+meta_warning (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+  
+  g_return_if_fail (format != NULL);
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+#ifdef WITH_VERBOSE_MODE
+  out = logfile ? logfile : stderr;
+#else
+  out = stderr;
+#endif
+
+  if (no_prefix == 0)
+    utf8_fputs (_("Window manager warning: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+}
+
+void
+meta_fatal (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+  
+  g_return_if_fail (format != NULL);
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+#ifdef WITH_VERBOSE_MODE
+  out = logfile ? logfile : stderr;
+#else
+  out = stderr;
+#endif
+
+  if (no_prefix == 0)
+    utf8_fputs (_("Window manager error: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+
+  meta_exit (META_EXIT_ERROR);
+}
+
+void
+meta_push_no_msg_prefix (void)
+{
+  ++no_prefix;
+}
+
+void
+meta_pop_no_msg_prefix (void)
+{
+  g_return_if_fail (no_prefix > 0);
+
+  --no_prefix;
+}
+
+void
+meta_exit (MetaExitCode code)
+{
+  
+  exit (code);
+}
+
+gint
+meta_unsigned_long_equal (gconstpointer v1,
+                          gconstpointer v2)
+{
+  return *((const gulong*) v1) == *((const gulong*) v2);
+}
+
+guint
+meta_unsigned_long_hash  (gconstpointer v)
+{
+  gulong val = * (const gulong *) v;
+
+  /* I'm not sure this works so well. */
+#if GLIB_SIZEOF_LONG > 4
+  return (guint) (val ^ (val >> 32));
+#else
+  return val;
+#endif
+}
+
+const char*
+meta_gravity_to_string (int gravity)
+{
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      return "NorthWestGravity";
+      break;
+    case NorthGravity:
+      return "NorthGravity";
+      break;
+    case NorthEastGravity:
+      return "NorthEastGravity";
+      break;
+    case WestGravity:
+      return "WestGravity";
+      break;
+    case CenterGravity:
+      return "CenterGravity";
+      break;
+    case EastGravity:
+      return "EastGravity";
+      break;
+    case SouthWestGravity:
+      return "SouthWestGravity";
+      break;
+    case SouthGravity:
+      return "SouthGravity";
+      break;
+    case SouthEastGravity:
+      return "SouthEastGravity";
+      break;
+    case StaticGravity:
+      return "StaticGravity";
+      break;
+    default:
+      return "NorthWestGravity";
+      break;
+    }
+}
+
+GPid
+meta_show_dialog (const char *type,
+                  const char *message,
+                  const char *timeout,
+                  const gint screen_number,
+                  const char *ok_text,
+                  const char *cancel_text,
+                  const int transient_for,
+                  GSList *columns,
+                  GSList *entries)
+{
+  GError *error = NULL;
+  char *screen_number_text = g_strdup_printf("%d", screen_number);
+  GSList *tmp;
+  int i=0;
+  GPid child_pid;
+  const char **argvl = g_malloc(sizeof (char*) *
+                                (17 +
+                                 g_slist_length (columns)*2 +
+                                 g_slist_length (entries)));
+
+  argvl[i++] = "matedialog";
+  argvl[i++] = type;
+  argvl[i++] = "--screen";
+  argvl[i++] = screen_number_text;
+  argvl[i++] = "--class";
+  argvl[i++] = "marco-dialog";
+  argvl[i++] = "--title";
+  /* Translators: This is the title used on dialog boxes */
+  argvl[i++] = _("Marco");
+  argvl[i++] = "--text";
+  argvl[i++] = message;
+  
+  if (timeout)
+    {
+      argvl[i++] = "--timeout";
+      argvl[i++] = timeout;
+    }
+
+  if (ok_text)
+    {
+      argvl[i++] = "--ok-label";
+      argvl[i++] = ok_text;
+     }
+
+  if (cancel_text)
+    {
+      argvl[i++] = "--cancel-label";
+      argvl[i++] = cancel_text;
+    }
+  
+  tmp = columns;
+  while (tmp)
+    {
+      argvl[i++] = "--column";
+      argvl[i++] = tmp->data;
+      tmp = tmp->next;
+    }
+
+  tmp = entries;
+  while (tmp)
+    {
+      argvl[i++] = tmp->data;
+      tmp = tmp->next;
+    }
+    
+  argvl[i] = NULL;
+
+  if (transient_for)
+    {
+      gchar *env = g_strdup_printf("%d", transient_for);
+      setenv ("WINDOWID", env, 1);
+      g_free (env);
+    }
+
+  g_spawn_async (
+                 "/",
+                 (gchar**) argvl, /* ugh */
+                 NULL,
+                 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+                 NULL, NULL,
+                 &child_pid,
+                 &error
+                 );
+
+  if (transient_for)
+    unsetenv ("WINDOWID");
+
+  g_free (argvl);
+  g_free (screen_number_text);
+
+  if (error)
+    {
+      meta_warning ("%s\n", error->message);
+      g_error_free (error);
+    }
+
+  return child_pid;
+}
+/* eof util.c */
+
diff --git a/src/core/window-private.h b/src/core/window-private.h
new file mode 100644
index 00000000..1a966275
--- /dev/null
+++ b/src/core/window-private.h
@@ -0,0 +1,640 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file window-private.h  Windows which Marco manages
+ *
+ * Managing X windows.
+ * This file contains methods on this class which are available to
+ * routines in core but not outside it.  (See window.h for the routines
+ * which the rest of the world is allowed to use.)
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WINDOW_PRIVATE_H
+#define META_WINDOW_PRIVATE_H
+
+#include <config.h>
+#include "window.h"
+#include "screen-private.h"
+#include "util.h"
+#include "stack.h"
+#include "iconcache.h"
+#include <X11/Xutil.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+typedef struct _MetaGroup MetaGroup;
+typedef struct _MetaWindowQueue MetaWindowQueue;
+
+typedef gboolean (*MetaWindowForeachFunc) (MetaWindow *window,
+                                           void       *data);
+
+typedef enum
+{
+  META_WINDOW_NORMAL,
+  META_WINDOW_DESKTOP,
+  META_WINDOW_DOCK,
+  META_WINDOW_DIALOG,
+  META_WINDOW_MODAL_DIALOG,
+  META_WINDOW_TOOLBAR,
+  META_WINDOW_MENU,
+  META_WINDOW_UTILITY,
+  META_WINDOW_SPLASHSCREEN
+} MetaWindowType;
+
+typedef enum
+{
+  META_MAXIMIZE_HORIZONTAL = 1 << 0,
+  META_MAXIMIZE_VERTICAL   = 1 << 1
+} MetaMaximizeFlags;
+
+typedef enum {
+  META_CLIENT_TYPE_UNKNOWN = 0,
+  META_CLIENT_TYPE_APPLICATION = 1,
+  META_CLIENT_TYPE_PAGER = 2,
+  META_CLIENT_TYPE_MAX_RECOGNIZED = 2
+} MetaClientType;
+
+typedef enum {
+  META_QUEUE_CALC_SHOWING = 1 << 0,
+  META_QUEUE_MOVE_RESIZE  = 1 << 1,
+  META_QUEUE_UPDATE_ICON  = 1 << 2,
+} MetaQueueType;
+
+#define NUMBER_OF_QUEUES 3
+
+struct _MetaWindow
+{
+  MetaDisplay *display;
+  MetaScreen *screen;
+  MetaWorkspace *workspace;
+  Window xwindow;
+  /* may be NULL! not all windows get decorated */
+  MetaFrame *frame;
+  int depth;
+  Visual *xvisual;
+  Colormap colormap;
+  char *desc; /* used in debug spew */
+  char *title;
+
+  char *icon_name;
+  GdkPixbuf *icon;
+  GdkPixbuf *mini_icon;
+  MetaIconCache icon_cache;
+  Pixmap wm_hints_pixmap;
+  Pixmap wm_hints_mask;
+  
+  MetaWindowType type;
+  Atom type_atom;
+  
+  /* NOTE these five are not in UTF-8, we just treat them as random
+   * binary data
+   */
+  char *res_class;
+  char *res_name;
+  char *role;
+  char *sm_client_id;
+  char *wm_client_machine;
+  char *startup_id;
+
+  int net_wm_pid;
+  
+  Window xtransient_for;
+  Window xgroup_leader;
+  Window xclient_leader;
+
+  /* Initial workspace property */
+  int initial_workspace;  
+  
+  /* Initial timestamp property */
+  guint32 initial_timestamp;  
+  
+  /* Whether we're maximized */
+  guint maximized_horizontally : 1;
+  guint maximized_vertically : 1;
+
+  /* Whether we have to maximize/minimize after placement */
+  guint maximize_horizontally_after_placement : 1;
+  guint maximize_vertically_after_placement : 1;
+  guint minimize_after_placement : 1;
+
+  /* Whether we're shaded */
+  guint shaded : 1;
+
+  /* Whether we're fullscreen */
+  guint fullscreen : 1;
+
+  /* Whether we have to fullscreen after placement */
+  guint fullscreen_after_placement : 1;
+
+  /* Area to cover when in fullscreen mode.  If _NET_WM_FULLSCREEN_MONITORS has
+   * been overridden (via a client message), the window will cover the union of
+   * these monitors.  If not, this is the single monitor which the window's
+   * origin is on. */
+  long fullscreen_monitors[4];
+  
+  /* Whether we're trying to constrain the window to be fully onscreen */
+  guint require_fully_onscreen : 1;
+
+  /* Whether we're trying to constrain the window to be on a single xinerama */
+  guint require_on_single_xinerama : 1;
+
+  /* Whether we're trying to constrain the window's titlebar to be onscreen */
+  guint require_titlebar_visible : 1;
+
+  /* Whether we're sticky in the multi-workspace sense
+   * (vs. the not-scroll-with-viewport sense, we don't
+   * have no stupid viewports)
+   */
+  guint on_all_workspaces : 1;
+
+  /* Minimize is the state controlled by the minimize button */
+  guint minimized : 1;
+  guint was_minimized : 1;
+  guint tab_unminimized : 1;
+
+  /* Whether the window is mapped; actual server-side state
+   * see also unmaps_pending
+   */
+  guint mapped : 1;
+  
+  /* Iconic is the state in WM_STATE; happens for workspaces/shading
+   * in addition to minimize
+   */
+  guint iconic : 1;
+  /* initially_iconic is the WM_HINTS setting when we first manage
+   * the window. It's taken to mean initially minimized.
+   */
+  guint initially_iconic : 1;
+
+  /* whether an initial workspace was explicitly set */
+  guint initial_workspace_set : 1;
+  
+  /* whether an initial timestamp was explicitly set */
+  guint initial_timestamp_set : 1;
+  
+  /* whether net_wm_user_time has been set yet */
+  guint net_wm_user_time_set : 1;
+  
+  /* These are the flags from WM_PROTOCOLS */
+  guint take_focus : 1;
+  guint delete_window : 1;
+  guint net_wm_ping : 1;
+  /* Globally active / No input */
+  guint input : 1;
+  
+  /* MWM hints about features of window */
+  guint mwm_decorated : 1;
+  guint mwm_border_only : 1;
+  guint mwm_has_close_func : 1;
+  guint mwm_has_minimize_func : 1;
+  guint mwm_has_maximize_func : 1;
+  guint mwm_has_move_func : 1;
+  guint mwm_has_resize_func : 1;
+  
+  /* Computed features of window */
+  guint decorated : 1;
+  guint border_only : 1;
+  guint always_sticky : 1;
+  guint has_close_func : 1;
+  guint has_minimize_func : 1;
+  guint has_maximize_func : 1;
+  guint has_shade_func : 1;
+  guint has_move_func : 1;
+  guint has_resize_func : 1;
+  guint has_fullscreen_func : 1;
+  
+  /* Weird "_NET_WM_STATE_MODAL" flag */
+  guint wm_state_modal : 1;
+
+  /* TRUE if the client forced these on */
+  guint wm_state_skip_taskbar : 1;
+  guint wm_state_skip_pager : 1;
+
+  /* Computed whether to skip taskbar or not */
+  guint skip_taskbar : 1;
+  guint skip_pager : 1;
+
+  /* TRUE if client set these */
+  guint wm_state_above : 1;
+  guint wm_state_below : 1;
+
+  /* EWHH demands attention flag */
+  guint wm_state_demands_attention : 1;
+  
+  /* this flag tracks receipt of focus_in focus_out and
+   * determines whether we draw the focus
+   */
+  guint has_focus : 1;
+  
+  /* Have we placed this window? */
+  guint placed : 1;
+
+  /* Must we force_save_user_window_placement? */
+  guint force_save_user_rect : 1;
+
+  /* Is this not a transient of the focus window which is being denied focus? */
+  guint denied_focus_and_not_transient : 1;
+
+  /* Has this window not ever been shown yet? */
+  guint showing_for_first_time : 1;
+
+  /* Are we in meta_window_free()? */
+  guint unmanaging : 1;
+
+  /* Are we in meta_window_new()? */
+  guint constructing : 1;
+  
+  /* Are we in the various queues? (Bitfield: see META_WINDOW_IS_IN_QUEUE) */
+  guint is_in_queues : NUMBER_OF_QUEUES;
+ 
+  /* Used by keybindings.c */
+  guint keys_grabbed : 1;     /* normal keybindings grabbed */
+  guint grab_on_frame : 1;    /* grabs are on the frame */
+  guint all_keys_grabbed : 1; /* AnyKey grabbed */
+  
+  /* Set if the reason for unmanaging the window is that
+   * it was withdrawn
+   */
+  guint withdrawn : 1;
+
+  /* TRUE if constrain_position should calc placement.
+   * only relevant if !window->placed
+   */
+  guint calc_placement : 1;
+
+  /* Transient parent is a root window */
+  guint transient_parent_is_root_window : 1;
+
+  /* Info on which props we got our attributes from */
+  guint using_net_wm_name              : 1; /* vs. plain wm_name */
+  guint using_net_wm_visible_name      : 1; /* tracked so we can clear it */
+  guint using_net_wm_icon_name         : 1; /* vs. plain wm_icon_name */
+  guint using_net_wm_visible_icon_name : 1; /* tracked so we can clear it */
+
+  /* has a shape mask */
+  guint has_shape : 1;
+
+  /* icon props have changed */
+  guint need_reread_icon : 1;
+  
+  /* if TRUE, window was maximized at start of current grab op */
+  guint shaken_loose : 1;
+
+  /* if TRUE we have a grab on the focus click buttons */
+  guint have_focus_click_grab : 1;
+
+  /* if TRUE, application is buggy and SYNC resizing is turned off */
+  guint disable_sync : 1;
+
+  /* Note: can be NULL */
+  GSList *struts;
+
+#ifdef HAVE_XSYNC
+  /* XSync update counter */
+  XSyncCounter sync_request_counter;
+  guint sync_request_serial;
+  GTimeVal sync_request_time;
+#endif
+  
+  /* Number of UnmapNotify that are caused by us, if
+   * we get UnmapNotify with none pending then the client
+   * is withdrawing the window.
+   */
+  int unmaps_pending;
+
+  /* set to the most recent user-interaction event timestamp that we
+     know about for this window */
+  guint32 net_wm_user_time;
+
+  /* window that gets updated net_wm_user_time values */
+  Window user_time_window;
+  
+  /* The size we set the window to last (i.e. what we believe
+   * to be its actual size on the server). The x, y are
+   * the actual server-side x,y so are relative to the frame
+   * (meaning that they just hold the frame width and height) 
+   * or the root window (meaning they specify the location
+   * of the top left of the inner window) as appropriate.
+   */
+  MetaRectangle rect;
+
+  /* The geometry to restore when we unmaximize.  The position is in
+   * root window coords, even if there's a frame, which contrasts with
+   * window->rect above.  Note that this gives the position and size
+   * of the client window (i.e. ignoring the frame).
+   */
+  MetaRectangle saved_rect;
+
+  /* This is the geometry the window had after the last user-initiated
+   * move/resize operations. We use this whenever we are moving the
+   * implicitly (for example, if we move to avoid a panel, we can snap
+   * back to this position if the panel moves again).  Note that this
+   * gives the position and size of the client window (i.e. ignoring
+   * the frame).
+   *
+   * Position valid if user_has_moved, size valid if user_has_resized
+   *
+   * Position always in root coords, unlike window->rect.
+   */
+  MetaRectangle user_rect;
+  
+  /* Requested geometry */
+  int border_width;
+  /* x/y/w/h here get filled with ConfigureRequest values */
+  XSizeHints size_hints;
+
+  /* Managed by stack.c */
+  MetaStackLayer layer;
+  int stack_position; /* see comment in stack.h */
+  
+  /* Current dialog open for this window */
+  int dialog_pid;
+
+  /* maintained by group.c */
+  MetaGroup *group;
+};
+
+/* These differ from window->has_foo_func in that they consider
+ * the dynamic window state such as "maximized", not just the
+ * window's type
+ */
+#define META_WINDOW_MAXIMIZED(w)       ((w)->maximized_horizontally && \
+                                        (w)->maximized_vertically)
+#define META_WINDOW_MAXIMIZED_VERTICALLY(w)    ((w)->maximized_vertically)
+#define META_WINDOW_MAXIMIZED_HORIZONTALLY(w)  ((w)->maximized_horizontally)
+#define META_WINDOW_ALLOWS_MOVE(w)     ((w)->has_move_func && !(w)->fullscreen)
+#define META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS(w)   ((w)->has_resize_func && !META_WINDOW_MAXIMIZED (w) && !(w)->fullscreen && !(w)->shaded)
+#define META_WINDOW_ALLOWS_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) &&                \
+                                        (((w)->size_hints.min_width < (w)->size_hints.max_width) ||  \
+                                         ((w)->size_hints.min_height < (w)->size_hints.max_height)))
+#define META_WINDOW_ALLOWS_HORIZONTAL_RESIZE(w) (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_width < (w)->size_hints.max_width)
+#define META_WINDOW_ALLOWS_VERTICAL_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_height < (w)->size_hints.max_height)
+
+MetaWindow* meta_window_new                (MetaDisplay *display,
+                                            Window       xwindow,
+                                            gboolean     must_be_viewable);
+MetaWindow* meta_window_new_with_attrs     (MetaDisplay *display,
+                                            Window       xwindow,
+                                            gboolean     must_be_viewable,
+                                            XWindowAttributes *attrs);
+void        meta_window_free               (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_calc_showing       (MetaWindow  *window);
+void        meta_window_queue              (MetaWindow  *window,
+                                            guint queuebits);
+void        meta_window_minimize           (MetaWindow  *window);
+void        meta_window_unminimize         (MetaWindow  *window);
+void        meta_window_maximize           (MetaWindow        *window,
+                                            MetaMaximizeFlags  directions);
+void        meta_window_maximize_internal  (MetaWindow        *window,
+                                            MetaMaximizeFlags  directions,
+                                            MetaRectangle     *saved_rect);
+void        meta_window_unmaximize         (MetaWindow        *window,
+                                            MetaMaximizeFlags  directions);
+void        meta_window_make_above         (MetaWindow  *window);
+void        meta_window_unmake_above       (MetaWindow  *window);
+void        meta_window_shade              (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_unshade            (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_change_workspace   (MetaWindow  *window,
+                                            MetaWorkspace *workspace);
+void        meta_window_stick              (MetaWindow  *window);
+void        meta_window_unstick            (MetaWindow  *window);
+
+void        meta_window_activate           (MetaWindow  *window,
+                                            guint32      current_time);
+void        meta_window_activate_with_workspace  (MetaWindow    *window,
+                                                  guint32        current_time,
+                                                  MetaWorkspace *workspace);   
+void        meta_window_make_fullscreen_internal (MetaWindow    *window);
+void        meta_window_make_fullscreen    (MetaWindow  *window);
+void        meta_window_unmake_fullscreen  (MetaWindow  *window);
+void        meta_window_update_fullscreen_monitors (MetaWindow    *window,
+                                                    unsigned long  top,
+                                                    unsigned long  bottom,
+                                                    unsigned long  left,
+                                                    unsigned long  right);
+
+/* args to move are window pos, not frame pos */
+void        meta_window_move               (MetaWindow  *window,
+                                            gboolean     user_op,
+                                            int          root_x_nw,
+                                            int          root_y_nw);
+void        meta_window_resize             (MetaWindow  *window,
+                                            gboolean     user_op,
+                                            int          w,
+                                            int          h);
+void        meta_window_move_resize        (MetaWindow  *window,
+                                            gboolean     user_op,
+                                            int          root_x_nw,
+                                            int          root_y_nw,
+                                            int          w,
+                                            int          h);
+void        meta_window_resize_with_gravity (MetaWindow  *window,
+                                             gboolean     user_op,
+                                             int          w,
+                                             int          h,
+                                             int          gravity);
+
+
+/* Return whether the window would be showing if we were on its workspace */
+gboolean    meta_window_showing_on_its_workspace (MetaWindow *window);
+
+/* Return whether the window should be currently mapped */
+gboolean    meta_window_should_be_showing   (MetaWindow  *window);
+
+/* See warning in window.c about this function */
+gboolean    __window_is_terminal (MetaWindow *window);
+
+void        meta_window_update_struts      (MetaWindow  *window);
+
+/* this gets root coords */
+void        meta_window_get_position       (MetaWindow  *window,
+                                            int         *x,
+                                            int         *y);
+
+/* Gets root coords for x, y, width & height of client window; uses
+ * meta_window_get_position for x & y.
+ */
+void        meta_window_get_client_root_coords (MetaWindow    *window,
+                                                MetaRectangle *rect);
+
+/* gets position we need to set to stay in current position,
+ * assuming position will be gravity-compensated. i.e.
+ * this is the position a client would send in a configure
+ * request.
+ */
+void        meta_window_get_gravity_position (MetaWindow  *window,
+                                              int          gravity,
+                                              int         *x,
+                                              int         *y);
+/* Get geometry for saving in the session; x/y are gravity
+ * position, and w/h are in resize inc above the base size.
+ */
+void        meta_window_get_geometry         (MetaWindow  *window,
+                                              int         *x,
+                                              int         *y,
+                                              int         *width,
+                                              int         *height);
+void        meta_window_get_outer_rect       (const MetaWindow *window,
+                                              MetaRectangle    *rect);
+void        meta_window_get_xor_rect         (MetaWindow          *window,
+                                              const MetaRectangle *grab_wireframe_rect,
+                                              MetaRectangle       *xor_rect);
+void        meta_window_begin_wireframe (MetaWindow *window);
+void        meta_window_update_wireframe (MetaWindow *window,
+                                          int         x,
+                                          int         y,
+                                          int         width,
+                                          int         height);
+void        meta_window_end_wireframe (MetaWindow *window);
+
+void        meta_window_delete             (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_kill               (MetaWindow  *window);
+void        meta_window_focus              (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_raise              (MetaWindow  *window);
+void        meta_window_lower              (MetaWindow  *window);
+
+void        meta_window_update_unfocused_button_grabs (MetaWindow *window);
+
+/* Sends a client message */
+void meta_window_send_icccm_message (MetaWindow *window,
+                                     Atom        atom,
+                                     guint32     timestamp);
+
+
+void     meta_window_move_resize_request(MetaWindow *window,
+                                         guint       value_mask,
+                                         int         gravity,
+                                         int         x,
+                                         int         y,
+                                         int         width,
+                                         int         height);
+gboolean meta_window_configure_request (MetaWindow *window,
+                                        XEvent     *event);
+gboolean meta_window_property_notify   (MetaWindow *window,
+                                        XEvent     *event);
+gboolean meta_window_client_message    (MetaWindow *window,
+                                        XEvent     *event);
+gboolean meta_window_notify_focus      (MetaWindow *window,
+                                        XEvent     *event);
+
+void     meta_window_set_current_workspace_hint (MetaWindow *window);
+
+unsigned long meta_window_get_net_wm_desktop (MetaWindow *window);
+
+void meta_window_show_menu (MetaWindow *window,
+                            int         root_x,
+                            int         root_y,
+                            int         button,
+                            guint32     timestamp);
+
+gboolean meta_window_titlebar_is_onscreen    (MetaWindow *window);
+void     meta_window_shove_titlebar_onscreen (MetaWindow *window);
+
+void meta_window_set_gravity (MetaWindow *window,
+                              int         gravity);
+
+void meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+                                             XEvent     *event);
+
+GList* meta_window_get_workspaces (MetaWindow *window);
+
+gboolean meta_window_located_on_workspace (MetaWindow    *window,
+                                           MetaWorkspace *workspace);
+
+void meta_window_get_work_area_current_xinerama (MetaWindow    *window,
+                                                 MetaRectangle *area);
+void meta_window_get_work_area_for_xinerama     (MetaWindow    *window,
+                                                 int            which_xinerama,
+                                                 MetaRectangle *area);
+void meta_window_get_work_area_all_xineramas    (MetaWindow    *window,
+                                                 MetaRectangle *area);
+
+
+gboolean meta_window_same_application (MetaWindow *window,
+                                       MetaWindow *other_window);
+
+#define META_WINDOW_IN_NORMAL_TAB_CHAIN_TYPE(w) \
+  ((w)->type != META_WINDOW_DOCK && (w)->type != META_WINDOW_DESKTOP)
+#define META_WINDOW_IN_NORMAL_TAB_CHAIN(w) \
+  (((w)->input || (w)->take_focus ) && META_WINDOW_IN_NORMAL_TAB_CHAIN_TYPE (w) && (!(w)->skip_taskbar))
+#define META_WINDOW_IN_DOCK_TAB_CHAIN(w) \
+  (((w)->input || (w)->take_focus) && (! META_WINDOW_IN_NORMAL_TAB_CHAIN_TYPE (w) || (w)->skip_taskbar))
+#define META_WINDOW_IN_GROUP_TAB_CHAIN(w, g) \
+  (((w)->input || (w)->take_focus) && (!g || meta_window_get_group(w)==g))
+
+void meta_window_refresh_resize_popup (MetaWindow *window);
+
+void meta_window_free_delete_dialog (MetaWindow *window);
+
+void     meta_window_foreach_transient        (MetaWindow            *window,
+                                               MetaWindowForeachFunc  func,
+                                               void                  *data);
+gboolean meta_window_is_ancestor_of_transient (MetaWindow            *window,
+                                               MetaWindow            *transient);
+void     meta_window_foreach_ancestor         (MetaWindow            *window,
+                                               MetaWindowForeachFunc  func,
+                                               void                  *data);
+MetaWindow* meta_window_find_root_ancestor    (MetaWindow *window);
+
+
+void meta_window_begin_grab_op (MetaWindow *window,
+                                MetaGrabOp  op,
+                                gboolean    frame_action,
+                                guint32     timestamp);
+
+void meta_window_update_keyboard_resize (MetaWindow *window,
+                                         gboolean    update_cursor);
+void meta_window_update_keyboard_move   (MetaWindow *window);
+
+void meta_window_update_layer (MetaWindow *window);
+
+gboolean meta_window_get_icon_geometry (MetaWindow    *window,
+                                        MetaRectangle *rect);
+
+const char* meta_window_get_startup_id (MetaWindow *window);
+
+void meta_window_recalc_features    (MetaWindow *window);
+void meta_window_recalc_window_type (MetaWindow *window);
+
+void meta_window_stack_just_below (MetaWindow *window,
+                                   MetaWindow *below_this_one);
+
+void meta_window_set_user_time (MetaWindow *window,
+                                guint32     timestamp);
+
+void meta_window_set_demands_attention (MetaWindow *window);
+
+void meta_window_unset_demands_attention (MetaWindow *window);
+
+void meta_window_update_icon_now (MetaWindow *window);
+
+void meta_window_update_role (MetaWindow *window);
+void meta_window_update_net_wm_type (MetaWindow *window);
+
+#endif
diff --git a/src/core/window-props.c b/src/core/window-props.c
new file mode 100644
index 00000000..b7b3e12d
--- /dev/null
+++ b/src/core/window-props.c
@@ -0,0 +1,1553 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file window-props.c    MetaWindow property handling
+ *
+ * A system which can inspect sets of properties of given windows
+ * and take appropriate action given their values.
+ *
+ * Note that all the meta_window_reload_propert* functions require a
+ * round trip to the server.
+ *
+ * The guts of this system are in meta_display_init_window_prop_hooks().
+ * Reading this function will give you insight into how this all fits
+ * together.
+ */
+
+/* 
+ * Copyright (C) 2001, 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * Copyright (C) 2009 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for gethostname() */
+
+#include <config.h>
+#include "window-props.h"
+#include "errors.h"
+#include "xprops.h"
+#include "frame-private.h"
+#include "group.h"
+#include <X11/Xatom.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <pwd.h>
+
+#ifdef HAVE_GTOP
+#include <glibtop/procuid.h>
+#include <errno.h>
+#include <pwd.h>
+#endif /* HAVE_GTOP */
+
+#ifndef HOST_NAME_MAX
+/* Solaris headers apparently don't define this so do so manually; #326745 */
+#define HOST_NAME_MAX 255
+#endif
+
+typedef void (* ReloadValueFunc) (MetaWindow    *window,
+                                  MetaPropValue *value,
+                                  gboolean       initial);
+
+typedef struct MetaWindowPropHooks
+{
+  Atom              property;
+  MetaPropValueType type;
+  ReloadValueFunc   reload_func;
+} MetaWindowPropHooks;
+
+static MetaWindowPropHooks* find_hooks (MetaDisplay *display,
+                                        Atom         property);
+
+
+void
+meta_window_reload_property (MetaWindow *window,
+                             Atom        property,
+                             gboolean    initial)
+{
+  meta_window_reload_properties (window, &property, 1, initial);
+}
+
+void
+meta_window_reload_properties (MetaWindow *window,
+                               const Atom *properties,
+                               int         n_properties,
+                               gboolean    initial)
+{
+  meta_window_reload_properties_from_xwindow (window,
+                                              window->xwindow,
+                                              properties,
+                                              n_properties,
+                                              initial);
+}
+
+void
+meta_window_reload_property_from_xwindow (MetaWindow *window,
+                                          Window      xwindow,
+                                          Atom        property,
+                                          gboolean    initial)
+{
+  meta_window_reload_properties_from_xwindow (window, xwindow, &property, 1,
+                                              initial);
+}
+
+void
+meta_window_reload_properties_from_xwindow (MetaWindow *window,
+                                            Window      xwindow,
+                                            const Atom *properties,
+                                            int         n_properties,
+                                            gboolean    initial)
+{
+  int i;
+  MetaPropValue *values;
+
+  g_return_if_fail (properties != NULL);
+  g_return_if_fail (n_properties > 0);
+  
+  values = g_new0 (MetaPropValue, n_properties);
+
+  for (i=0; i<n_properties; i++)
+    {
+      MetaWindowPropHooks *hooks = find_hooks (window->display,
+                                               properties[i]);
+    
+      if (!hooks || hooks->type == META_PROP_VALUE_INVALID)
+        {
+          values[i].type = META_PROP_VALUE_INVALID;
+          values[i].atom = None;
+        }
+      else
+        {
+          values[i].type = hooks->type;
+          values[i].atom = properties[i];
+        }
+    }
+  
+  meta_prop_get_values (window->display, xwindow,
+                        values, n_properties);
+
+  for (i=0; i<n_properties; i++)
+    {
+      MetaWindowPropHooks *hooks = find_hooks (window->display,
+                                               properties[i]);
+
+      if (hooks && hooks->reload_func != NULL)
+        (* hooks->reload_func) (window, &values[i], initial);
+    }
+
+  meta_prop_free_values (values, n_properties);
+  
+  g_free (values);
+}
+
+static void
+reload_wm_client_machine (MetaWindow    *window,
+                          MetaPropValue *value,
+                          gboolean       initial)
+{
+  g_free (window->wm_client_machine);
+  window->wm_client_machine = NULL;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    window->wm_client_machine = g_strdup (value->v.str);
+
+  meta_verbose ("Window has client machine \"%s\"\n",
+                window->wm_client_machine ? window->wm_client_machine : "unset");
+}
+
+static void
+complain_about_broken_client (MetaWindow    *window,
+                              MetaPropValue *value,
+                              gboolean       initial)
+{
+  meta_warning ("Broken client! Window %s changed client leader window or SM client ID\n",
+                window->desc);
+}
+
+static void
+reload_net_wm_window_type (MetaWindow    *window,
+                           MetaPropValue *value,
+                           gboolean       initial)
+{
+  meta_window_update_net_wm_type (window);
+}
+
+static void
+reload_icon (MetaWindow    *window,
+             Atom           atom)
+{
+  meta_icon_cache_property_changed (&window->icon_cache,
+                                    window->display,
+                                    atom);
+  meta_window_queue(window, META_QUEUE_UPDATE_ICON);
+}
+
+static void
+reload_net_wm_icon (MetaWindow    *window,
+                    MetaPropValue *value,
+                    gboolean       initial)
+{
+  reload_icon (window, window->display->atom__NET_WM_ICON);
+}
+
+static void
+reload_kwm_win_icon (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  reload_icon (window, window->display->atom__KWM_WIN_ICON);
+}
+
+static void
+reload_struts (MetaWindow    *window,
+               MetaPropValue *value,
+               gboolean       initial)
+{
+  meta_window_update_struts (window);
+}
+
+static void
+reload_wm_window_role (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  meta_window_update_role (window);
+}
+
+static void
+reload_net_wm_pid (MetaWindow    *window,
+                   MetaPropValue *value,
+                   gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      gulong cardinal = (int) value->v.cardinal;
+      
+      if (cardinal <= 0)
+        meta_warning (_("Application set a bogus _NET_WM_PID %lu\n"),
+                      cardinal);
+      else
+        {
+          window->net_wm_pid = cardinal;
+          meta_verbose ("Window has _NET_WM_PID %d\n",
+                        window->net_wm_pid);
+        }
+    }
+}
+
+static void
+reload_net_wm_user_time (MetaWindow    *window,
+                         MetaPropValue *value,
+                         gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      gulong cardinal = value->v.cardinal;
+      meta_window_set_user_time (window, cardinal);
+    }
+}
+
+static void
+reload_net_wm_user_time_window (MetaWindow    *window,
+                                MetaPropValue *value,
+                                gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      /* Unregister old NET_WM_USER_TIME_WINDOW */
+      if (window->user_time_window != None)
+        {
+          /* See the comment to the meta_display_register_x_window call below. */
+          meta_display_unregister_x_window (window->display,
+                                            window->user_time_window);
+          /* Don't get events on not-managed windows */
+          XSelectInput (window->display->xdisplay,
+                        window->user_time_window,
+                        NoEventMask);
+        }
+
+
+      /* Obtain the new NET_WM_USER_TIME_WINDOW and register it */
+      window->user_time_window = value->v.xwindow;
+      if (window->user_time_window != None)
+        {
+          /* Kind of a hack; display.c:event_callback() ignores events
+           * for unknown windows.  We make window->user_time_window
+           * known by registering it with window (despite the fact
+           * that window->xwindow is already registered with window).
+           * This basically means that property notifies to either the
+           * window->user_time_window or window->xwindow will be
+           * treated identically and will result in functions for
+           * window being called to update it.  Maybe we should ignore
+           * any property notifies to window->user_time_window other
+           * than atom__NET_WM_USER_TIME ones, but I just don't care
+           * and it's not specified in the spec anyway.
+           */
+          meta_display_register_x_window (window->display,
+                                          &window->user_time_window,
+                                          window);
+          /* Just listen for property notify events */
+          XSelectInput (window->display->xdisplay,
+                        window->user_time_window,
+                        PropertyChangeMask);
+
+          /* Manually load the _NET_WM_USER_TIME field from the given window
+           * at this time as well.  If the user_time_window ever broadens in
+           * scope, we'll probably want to load all relevant properties here.
+           */
+          meta_window_reload_property_from_xwindow (
+            window,
+            window->user_time_window,
+            window->display->atom__NET_WM_USER_TIME,
+            initial);
+        }
+    }
+}
+
+/**
+ * Finds who owns a particular process, if we can.
+ *
+ * \param process  The process's ID.
+ * \result         Set to the ID of the user, if we returned true.
+ *
+ * \result  True if we could tell.
+ */
+static gboolean
+owner_of_process (pid_t process, uid_t *result)
+{
+#ifdef HAVE_GTOP
+  glibtop_proc_uid process_details;
+      
+  glibtop_get_proc_uid (&process_details, process);
+
+  *result = process_details.uid;
+  return TRUE;
+#else
+  /* I don't know, maybe we could do something hairy like see whether
+   * /proc/$PID exists and who owns it, in case they have procfs.
+   */
+  return FALSE;
+#endif /* HAVE_GTOP */
+}
+
+#define MAX_TITLE_LENGTH 512
+
+/**
+ * Called by set_window_title and set_icon_title to set the value of
+ * *target to title. It required and atom is set, it will update the
+ * appropriate property.
+ *
+ * Returns TRUE if a new title was set.
+ */
+static gboolean
+set_title_text (MetaWindow  *window,
+                gboolean     previous_was_modified,
+                const char  *title,
+                Atom         atom,
+                char       **target)
+{
+  char hostname[HOST_NAME_MAX + 1];
+  gboolean modified = FALSE;
+  
+  if (!target)
+    return FALSE;
+  
+  g_free (*target);
+  
+  if (!title)
+    *target = g_strdup ("");
+  else if (g_utf8_strlen (title, MAX_TITLE_LENGTH + 1) > MAX_TITLE_LENGTH)
+    {
+      *target = meta_g_utf8_strndup (title, MAX_TITLE_LENGTH);
+      modified = TRUE;
+    }
+  /* if WM_CLIENT_MACHINE indicates this machine is on a remote host
+   * let's place that hostname in the title */
+  else if (window->wm_client_machine &&
+           !gethostname (hostname, HOST_NAME_MAX + 1) &&
+           strcmp (hostname, window->wm_client_machine))
+    {
+      /* Translators: the title of a window from another machine */
+      *target = g_strdup_printf (_("%s (on %s)"),
+                      title, window->wm_client_machine);
+      modified = TRUE;
+    }
+  else if (window->net_wm_pid != -1)
+    {
+      /* We know the process which owns this window; perhaps we can
+       * find out the name of its owner (if it's not us).
+       */
+
+      char *found_name = NULL;
+
+      uid_t window_owner = 0;
+      gboolean window_owner_known =
+              owner_of_process (window->net_wm_pid, &window_owner);
+
+      /* Assume a window with unknown ownership is ours (call it usufruct!) */
+      gboolean window_owner_is_us =
+              !window_owner_known || window_owner==getuid ();
+      
+      if (window_owner_is_us)
+        {
+          /* we own it, so fall back to the simple case */
+          *target = g_strdup (title);
+        }
+      else
+        {
+          /* it belongs to window_owner.  So what's their name? */
+
+          if (window_owner==0)
+            {
+              /* Simple case-- don't bother to look it up.  It's root. */
+              *target = g_strdup_printf (_("%s (as superuser)"),
+                                         title);
+            }
+          else
+            {
+              /* Okay, let's look up the name. */
+              struct passwd *pwd;
+
+              errno = 0;
+              pwd = getpwuid (window_owner);
+              if (errno==0 && pwd!=NULL)
+                {
+                  found_name = pwd->pw_name;
+                }
+            
+              if (found_name)
+                /* Translators: the title of a window owned by another user
+                 * on this machine */
+                *target = g_strdup_printf (_("%s (as %s)"),
+                                           title,
+                                           found_name);
+              else
+                /* Translators: the title of a window owned by another user
+                 * on this machine, whose name we don't know */
+                *target = g_strdup_printf (_("%s (as another user)"),
+                                           title);
+            }
+          /* either way we changed it */
+          modified = TRUE;
+              
+        }
+    }
+  else
+    *target = g_strdup (title);
+
+  if (modified && atom != None)
+    meta_prop_set_utf8_string_hint (window->display,
+                                    window->xwindow,
+                                    atom, *target);
+
+  /* Bug 330671 -- Don't forget to clear _NET_WM_VISIBLE_(ICON_)NAME */
+  if (!modified && previous_was_modified)
+    {
+      meta_error_trap_push (window->display);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       atom);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+
+  return modified;
+}
+
+static void
+set_window_title (MetaWindow *window,
+                  const char *title)
+{
+  char *str;
+ 
+  gboolean modified =
+    set_title_text (window,
+                    window->using_net_wm_visible_name,
+                    title,
+                    window->display->atom__NET_WM_VISIBLE_NAME,
+                    &window->title);
+  window->using_net_wm_visible_name = modified;
+  
+  /* strndup is a hack since GNU libc has broken %.10s */
+  str = g_strndup (window->title, 10);
+  g_free (window->desc);
+  window->desc = g_strdup_printf ("0x%lx (%s)", window->xwindow, str);
+  g_free (str);
+
+  if (window->frame)
+    meta_ui_set_frame_title (window->screen->ui,
+                             window->frame->xwindow,
+                             window->title);
+}
+
+static void
+reload_net_wm_name (MetaWindow    *window,
+                    MetaPropValue *value,
+                    gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_window_title (window, value->v.str);
+      window->using_net_wm_name = TRUE;
+
+      meta_verbose ("Using _NET_WM_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_window_title (window, NULL);
+      window->using_net_wm_name = FALSE;
+      if (!initial)
+        meta_window_reload_property (window, XA_WM_NAME, FALSE);
+    }
+}
+
+static void
+reload_wm_name (MetaWindow    *window,
+                MetaPropValue *value,
+                gboolean       initial)
+{
+  if (window->using_net_wm_name)
+    {
+      meta_verbose ("Ignoring WM_NAME \"%s\" as _NET_WM_NAME is set\n",
+                    value->v.str);
+      return;
+    }
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_window_title (window, value->v.str);
+
+      meta_verbose ("Using WM_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_window_title (window, NULL);
+    }
+}
+
+static void
+set_icon_title (MetaWindow *window,
+                const char *title)
+{
+  gboolean modified =
+    set_title_text (window,
+                    window->using_net_wm_visible_icon_name,
+                    title,
+                    window->display->atom__NET_WM_VISIBLE_ICON_NAME,
+                    &window->icon_name);
+  window->using_net_wm_visible_icon_name = modified;
+}
+
+static void
+reload_net_wm_icon_name (MetaWindow    *window,
+                         MetaPropValue *value,
+                         gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_icon_title (window, value->v.str);
+      window->using_net_wm_icon_name = TRUE;
+
+      meta_verbose ("Using _NET_WM_ICON_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_icon_title (window, NULL);
+      window->using_net_wm_icon_name = FALSE;
+      if (!initial)
+        meta_window_reload_property (window, XA_WM_ICON_NAME, FALSE);
+    }
+}
+
+static void
+reload_wm_icon_name (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  if (window->using_net_wm_icon_name)
+    {
+      meta_verbose ("Ignoring WM_ICON_NAME \"%s\" as _NET_WM_ICON_NAME is set\n",
+                    value->v.str);
+      return;
+    }
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_icon_title (window, value->v.str);
+      
+      meta_verbose ("Using WM_ICON_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_icon_title (window, NULL);
+    }
+}
+
+static void
+reload_net_wm_state (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  int i;
+
+  /* We know this is only an initial window creation,
+   * clients don't change the property.
+   */
+
+  if (!initial) {
+    /* no, they DON'T change the property */
+    meta_verbose ("Ignoring _NET_WM_STATE: we should be the one who set "
+                  "the property in the first place\n");
+    return;
+  }
+
+  window->shaded = FALSE;
+  window->maximized_horizontally = FALSE;
+  window->maximized_vertically = FALSE;
+  window->fullscreen = FALSE;
+  window->wm_state_modal = FALSE;
+  window->wm_state_skip_taskbar = FALSE;
+  window->wm_state_skip_pager = FALSE;
+  window->wm_state_above = FALSE;
+  window->wm_state_below = FALSE;
+  window->wm_state_demands_attention = FALSE;
+
+  if (value->type == META_PROP_VALUE_INVALID)
+    return;
+
+  i = 0;
+  while (i < value->v.atom_list.n_atoms)
+    {
+      if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SHADED)
+        window->shaded = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_MAXIMIZED_HORZ)
+        window->maximize_horizontally_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_MAXIMIZED_VERT)
+        window->maximize_vertically_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_HIDDEN)
+        window->minimize_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_MODAL)
+        window->wm_state_modal = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SKIP_TASKBAR)
+        window->wm_state_skip_taskbar = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SKIP_PAGER)
+        window->wm_state_skip_pager = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_FULLSCREEN)
+        window->fullscreen_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_ABOVE)
+        window->wm_state_above = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_BELOW)
+        window->wm_state_below = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_DEMANDS_ATTENTION)
+        window->wm_state_demands_attention = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_STICKY)
+        window->on_all_workspaces = TRUE;
+
+      ++i;
+    }
+
+  meta_verbose ("Reloaded _NET_WM_STATE for %s\n",
+                window->desc);
+
+  meta_window_recalc_window_type (window);
+}
+
+static void
+reload_mwm_hints (MetaWindow    *window,
+                  MetaPropValue *value,
+                  gboolean       initial)
+{
+  MotifWmHints *hints;
+
+  window->mwm_decorated = TRUE;
+  window->mwm_border_only = FALSE;
+  window->mwm_has_close_func = TRUE;
+  window->mwm_has_minimize_func = TRUE;
+  window->mwm_has_maximize_func = TRUE;
+  window->mwm_has_move_func = TRUE;
+  window->mwm_has_resize_func = TRUE;
+
+  if (value->type == META_PROP_VALUE_INVALID)
+    {
+      meta_verbose ("Window %s has no MWM hints\n", window->desc);
+      meta_window_recalc_features (window);
+      return;
+    }
+
+  hints = value->v.motif_hints;
+
+  /* We support those MWM hints deemed non-stupid */
+
+  meta_verbose ("Window %s has MWM hints\n",
+                window->desc);
+
+  if (hints->flags & MWM_HINTS_DECORATIONS)
+    {
+      meta_verbose ("Window %s sets MWM_HINTS_DECORATIONS 0x%lx\n",
+          window->desc, hints->decorations);
+
+      if (hints->decorations == 0)
+        window->mwm_decorated = FALSE;
+      /* some input methods use this */
+      else if (hints->decorations == MWM_DECOR_BORDER)
+        window->mwm_border_only = TRUE;
+    }
+  else
+    meta_verbose ("Decorations flag unset\n");
+
+  if (hints->flags & MWM_HINTS_FUNCTIONS)
+    {
+      gboolean toggle_value;
+
+      meta_verbose ("Window %s sets MWM_HINTS_FUNCTIONS 0x%lx\n",
+                    window->desc, hints->functions);
+
+      /* If _ALL is specified, then other flags indicate what to turn off;
+       * if ALL is not specified, flags are what to turn on.
+       * at least, I think so
+       */
+
+      if ((hints->functions & MWM_FUNC_ALL) == 0)
+        {
+          toggle_value = TRUE;
+
+          meta_verbose ("Window %s disables all funcs then reenables some\n",
+                        window->desc);
+          window->mwm_has_close_func = FALSE;
+          window->mwm_has_minimize_func = FALSE;
+          window->mwm_has_maximize_func = FALSE;
+          window->mwm_has_move_func = FALSE;
+          window->mwm_has_resize_func = FALSE;
+        }
+      else
+        {
+          meta_verbose ("Window %s enables all funcs then disables some\n",
+                        window->desc);
+          toggle_value = FALSE;
+        }
+
+      if ((hints->functions & MWM_FUNC_CLOSE) != 0)
+        {
+          meta_verbose ("Window %s toggles close via MWM hints\n",
+                        window->desc);
+          window->mwm_has_close_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_MINIMIZE) != 0)
+        {
+          meta_verbose ("Window %s toggles minimize via MWM hints\n",
+                        window->desc);
+          window->mwm_has_minimize_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_MAXIMIZE) != 0)
+        {
+          meta_verbose ("Window %s toggles maximize via MWM hints\n",
+                        window->desc);
+          window->mwm_has_maximize_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_MOVE) != 0)
+        {
+          meta_verbose ("Window %s toggles move via MWM hints\n",
+                        window->desc);
+          window->mwm_has_move_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_RESIZE) != 0)
+        {
+          meta_verbose ("Window %s toggles resize via MWM hints\n",
+                        window->desc);
+          window->mwm_has_resize_func = toggle_value;
+        }
+    }
+  else
+    meta_verbose ("Functions flag unset\n");
+
+  meta_window_recalc_features (window);
+  
+  /* We do all this anyhow at the end of meta_window_new() */
+  if (!window->constructing)
+    {
+      if (window->decorated)
+        meta_window_ensure_frame (window);
+      else
+        meta_window_destroy_frame (window);
+      
+      meta_window_queue (window,
+                         META_QUEUE_MOVE_RESIZE |
+                         /* because ensure/destroy frame may unmap: */
+                         META_QUEUE_CALC_SHOWING);
+    }
+}
+
+static void
+reload_wm_class (MetaWindow    *window,
+                 MetaPropValue *value,
+                 gboolean       initial)
+{
+  if (window->res_class)
+    g_free (window->res_class);
+  if (window->res_name)
+    g_free (window->res_name);
+
+  window->res_class = NULL;
+  window->res_name = NULL;
+
+  if (value->type != META_PROP_VALUE_INVALID)
+    { 
+      if (value->v.class_hint.res_name)
+        window->res_name = g_strdup (value->v.class_hint.res_name);
+
+      if (value->v.class_hint.res_class)
+        window->res_class = g_strdup (value->v.class_hint.res_class);
+    }
+
+  meta_verbose ("Window %s class: '%s' name: '%s'\n",
+      window->desc,
+      window->res_class ? window->res_class : "none",
+      window->res_name ? window->res_name : "none");
+}
+
+static void
+reload_net_wm_desktop (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      window->initial_workspace_set = TRUE;
+      window->initial_workspace = value->v.cardinal;
+      meta_topic (META_DEBUG_PLACEMENT,
+                  "Read initial workspace prop %d for %s\n",
+                  window->initial_workspace, window->desc);
+    }
+}
+
+static void
+reload_net_startup_id (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  guint32 timestamp = window->net_wm_user_time;
+  MetaWorkspace *workspace = NULL;
+  
+  g_free (window->startup_id);
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    window->startup_id = g_strdup (value->v.str);
+  else
+    window->startup_id = NULL;
+    
+  /* Update timestamp and workspace on a running window */
+  if (!window->constructing)
+  {
+    window->initial_timestamp_set = 0;  
+    window->initial_workspace_set = 0;
+    
+    if (meta_screen_apply_startup_properties (window->screen, window))
+      {
+  
+        if (window->initial_timestamp_set)
+          timestamp = window->initial_timestamp;
+        if (window->initial_workspace_set)
+          workspace = meta_screen_get_workspace_by_index (window->screen, window->initial_workspace);
+    
+        meta_window_activate_with_workspace (window, timestamp, workspace);
+      }
+  }
+  
+  meta_verbose ("New _NET_STARTUP_ID \"%s\" for %s\n",
+                window->startup_id ? window->startup_id : "unset",
+                window->desc);
+}
+
+static void
+reload_update_counter (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+#ifdef HAVE_XSYNC
+      XSyncCounter counter = value->v.xcounter;
+
+      window->sync_request_counter = counter;
+      meta_verbose ("Window has _NET_WM_SYNC_REQUEST_COUNTER 0x%lx\n",
+                    window->sync_request_counter);
+#endif
+    }
+}
+
+#define FLAG_TOGGLED_ON(old,new,flag) \
+ (((old)->flags & (flag)) == 0 &&     \
+  ((new)->flags & (flag)) != 0)
+
+#define FLAG_TOGGLED_OFF(old,new,flag) \
+ (((old)->flags & (flag)) != 0 &&      \
+  ((new)->flags & (flag)) == 0)
+
+#define FLAG_CHANGED(old,new,flag) \
+  (FLAG_TOGGLED_ON(old,new,flag) || FLAG_TOGGLED_OFF(old,new,flag))
+
+static void
+spew_size_hints_differences (const XSizeHints *old,
+                             const XSizeHints *new)
+{
+  if (FLAG_CHANGED (old, new, USPosition))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: USPosition now %s\n",
+                FLAG_TOGGLED_ON (old, new, USPosition) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, USSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: USSize now %s\n",
+                FLAG_TOGGLED_ON (old, new, USSize) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, PPosition))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PPosition now %s\n",
+                FLAG_TOGGLED_ON (old, new, PPosition) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, PSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PSize now %s\n",
+                FLAG_TOGGLED_ON (old, new, PSize) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, PMinSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PMinSize now %s (%d x %d -> %d x %d)\n",
+                FLAG_TOGGLED_ON (old, new, PMinSize) ? "set" : "unset",
+                old->min_width, old->min_height,
+                new->min_width, new->min_height);
+  if (FLAG_CHANGED (old, new, PMaxSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PMaxSize now %s (%d x %d -> %d x %d)\n",
+                FLAG_TOGGLED_ON (old, new, PMaxSize) ? "set" : "unset",
+                old->max_width, old->max_height,
+                new->max_width, new->max_height);
+  if (FLAG_CHANGED (old, new, PResizeInc))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PResizeInc now %s (width_inc %d -> %d height_inc %d -> %d)\n",
+                FLAG_TOGGLED_ON (old, new, PResizeInc) ? "set" : "unset",
+                old->width_inc, new->width_inc,
+                old->height_inc, new->height_inc);
+  if (FLAG_CHANGED (old, new, PAspect))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PAspect now %s (min %d/%d -> %d/%d max %d/%d -> %d/%d)\n",
+                FLAG_TOGGLED_ON (old, new, PAspect) ? "set" : "unset",
+                old->min_aspect.x, old->min_aspect.y,
+                new->min_aspect.x, new->min_aspect.y,
+                old->max_aspect.x, old->max_aspect.y,
+                new->max_aspect.x, new->max_aspect.y);
+  if (FLAG_CHANGED (old, new, PBaseSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PBaseSize now %s (%d x %d -> %d x %d)\n",
+                FLAG_TOGGLED_ON (old, new, PBaseSize) ? "set" : "unset",
+                old->base_width, old->base_height,
+                new->base_width, new->base_height);
+  if (FLAG_CHANGED (old, new, PWinGravity))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PWinGravity now %s  (%d -> %d)\n",
+                FLAG_TOGGLED_ON (old, new, PWinGravity) ? "set" : "unset",
+                old->win_gravity, new->win_gravity);  
+}
+
+void
+meta_set_normal_hints (MetaWindow *window,
+                       XSizeHints *hints)
+{
+  int x, y, w, h;
+  double minr, maxr;
+  /* Some convenience vars */
+  int minw, minh, maxw, maxh;   /* min/max width/height                      */
+  int basew, baseh, winc, hinc; /* base width/height, width/height increment */
+
+  /* Save the last ConfigureRequest, which we put here.
+   * Values here set in the hints are supposed to
+   * be ignored.
+   */
+  x = window->size_hints.x;
+  y = window->size_hints.y;
+  w = window->size_hints.width;
+  h = window->size_hints.height;
+
+  /* as far as I can tell, value->v.size_hints.flags is just to
+   * check whether we had old-style normal hints without gravity,
+   * base size as returned by XGetNormalHints(), so we don't
+   * really use it as we fixup window->size_hints to have those
+   * fields if they're missing.
+   */
+
+  /*
+   * When the window is first created, NULL hints will
+   * be passed in which will initialize all of the fields
+   * as if flags were zero
+   */
+  if (hints)
+    window->size_hints = *hints;
+  else
+    window->size_hints.flags = 0;
+
+  /* Put back saved ConfigureRequest. */
+  window->size_hints.x = x;
+  window->size_hints.y = y;
+  window->size_hints.width = w;
+  window->size_hints.height = h;
+
+  /* Get base size hints */
+  if (window->size_hints.flags & PBaseSize)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets base size %d x %d\n",
+                  window->desc,
+                  window->size_hints.base_width,
+                  window->size_hints.base_height);
+    }
+  else if (window->size_hints.flags & PMinSize)
+    {
+      window->size_hints.base_width = window->size_hints.min_width;
+      window->size_hints.base_height = window->size_hints.min_height;
+    }
+  else
+    {
+      window->size_hints.base_width = 0;
+      window->size_hints.base_height = 0;
+    }
+  window->size_hints.flags |= PBaseSize;
+
+  /* Get min size hints */
+  if (window->size_hints.flags & PMinSize)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets min size %d x %d\n",
+                  window->desc,
+                  window->size_hints.min_width,
+                  window->size_hints.min_height);
+    }
+  else if (window->size_hints.flags & PBaseSize)
+    {
+      window->size_hints.min_width = window->size_hints.base_width;
+      window->size_hints.min_height = window->size_hints.base_height;
+    }
+  else
+    {
+      window->size_hints.min_width = 0;
+      window->size_hints.min_height = 0;
+    }
+  window->size_hints.flags |= PMinSize;
+
+  /* Get max size hints */
+  if (window->size_hints.flags & PMaxSize)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets max size %d x %d\n",
+                  window->desc,
+                  window->size_hints.max_width,
+                  window->size_hints.max_height);
+    }
+  else
+    {
+      window->size_hints.max_width = G_MAXINT;
+      window->size_hints.max_height = G_MAXINT;
+      window->size_hints.flags |= PMaxSize;
+    }
+
+  /* Get resize increment hints */
+  if (window->size_hints.flags & PResizeInc)
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets resize width inc: %d height inc: %d\n",
+                  window->desc,
+                  window->size_hints.width_inc,
+                  window->size_hints.height_inc);
+    }
+  else
+    {
+      window->size_hints.width_inc = 1;
+      window->size_hints.height_inc = 1;
+      window->size_hints.flags |= PResizeInc;
+    }
+
+  /* Get aspect ratio hints */
+  if (window->size_hints.flags & PAspect)
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min_aspect: %d/%d max_aspect: %d/%d\n",
+                  window->desc,
+                  window->size_hints.min_aspect.x,
+                  window->size_hints.min_aspect.y,
+                  window->size_hints.max_aspect.x,
+                  window->size_hints.max_aspect.y);
+    }
+  else
+    {
+      window->size_hints.min_aspect.x = 1;
+      window->size_hints.min_aspect.y = G_MAXINT;
+      window->size_hints.max_aspect.x = G_MAXINT;
+      window->size_hints.max_aspect.y = 1;
+      window->size_hints.flags |= PAspect;
+    }
+
+  /* Get gravity hint */
+  if (window->size_hints.flags & PWinGravity)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets gravity %d\n",
+                  window->desc,
+                  window->size_hints.win_gravity);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s doesn't set gravity, using NW\n",
+                  window->desc);
+      window->size_hints.win_gravity = NorthWestGravity;
+      window->size_hints.flags |= PWinGravity;
+    }
+
+  /*** Lots of sanity checking ***/
+
+  /* Verify all min & max hints are at least 1 pixel */
+  if (window->size_hints.min_width < 1)
+    {
+      /* someone is on crack */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min width to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.min_width = 1;
+    }
+  if (window->size_hints.max_width < 1)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max width to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.max_width = 1;
+    }
+  if (window->size_hints.min_height < 1)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min height to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.min_height = 1;
+    }
+  if (window->size_hints.max_height < 1)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max height to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.max_height = 1;
+    }
+
+  /* Verify size increment hints are at least 1 pixel */
+  if (window->size_hints.width_inc < 1)
+    {
+      /* app authors find so many ways to smoke crack */
+      window->size_hints.width_inc = 1;
+      meta_topic (META_DEBUG_GEOMETRY, "Corrected 0 width_inc to 1\n");
+    }
+  if (window->size_hints.height_inc < 1)
+    {
+      /* another cracksmoker */
+      window->size_hints.height_inc = 1;
+      meta_topic (META_DEBUG_GEOMETRY, "Corrected 0 height_inc to 1\n");
+    }
+  /* divide by 0 cracksmokers; note that x & y in (min|max)_aspect are
+   * numerator & denominator
+   */
+  if (window->size_hints.min_aspect.y < 1)
+    window->size_hints.min_aspect.y = 1;
+  if (window->size_hints.max_aspect.y < 1)
+    window->size_hints.max_aspect.y = 1;
+
+  minw  = window->size_hints.min_width;  minh  = window->size_hints.min_height;
+  maxw  = window->size_hints.max_width;  maxh  = window->size_hints.max_height;
+  basew = window->size_hints.base_width; baseh = window->size_hints.base_height;
+  winc  = window->size_hints.width_inc;  hinc  = window->size_hints.height_inc;
+
+  /* Make sure min and max size hints are consistent with the base + increment
+   * size hints.  If they're not, it's not a real big deal, but it means the
+   * effective min and max size are more restrictive than the application
+   * specified values.
+   */
+  if ((minw - basew) % winc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.min_width = basew + ((minw - basew)/winc + 1)*winc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has width_inc (%d) that does not evenly divide "
+                  "min_width - base_width (%d - %d); thus effective "
+                  "min_width is really %d\n",
+                  window->desc,
+                  winc, minw, basew, window->size_hints.min_width);
+      minw = window->size_hints.min_width;
+    }
+  if (maxw != G_MAXINT && (maxw - basew) % winc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.max_width = basew + ((maxw - basew)/winc)*winc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has width_inc (%d) that does not evenly divide "
+                  "max_width - base_width (%d - %d); thus effective "
+                  "max_width is really %d\n",
+                  window->desc,
+                  winc, maxw, basew, window->size_hints.max_width);
+      maxw = window->size_hints.max_width;
+    }
+  if ((minh - baseh) % hinc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.min_height = baseh + ((minh - baseh)/hinc + 1)*hinc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has height_inc (%d) that does not evenly divide "
+                  "min_height - base_height (%d - %d); thus effective "
+                  "min_height is really %d\n",
+                  window->desc,
+                  hinc, minh, baseh, window->size_hints.min_height);
+      minh = window->size_hints.min_height;
+    }
+  if (maxh != G_MAXINT && (maxh - baseh) % hinc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.max_height = baseh + ((maxh - baseh)/hinc)*hinc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has height_inc (%d) that does not evenly divide "
+                  "max_height - base_height (%d - %d); thus effective "
+                  "max_height is really %d\n",
+                  window->desc,
+                  hinc, maxh, baseh, window->size_hints.max_height);
+      maxh = window->size_hints.max_height;
+    }
+
+  /* make sure maximum size hints are compatible with minimum size hints; min
+   * size hints take precedence.
+   */
+  if (window->size_hints.max_width < window->size_hints.min_width)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max width %d less than min width %d, "
+                  "disabling resize\n",
+                  window->desc,
+                  window->size_hints.max_width,
+                  window->size_hints.min_width);
+      maxw = window->size_hints.max_width = window->size_hints.min_width;
+    }
+  if (window->size_hints.max_height < window->size_hints.min_height)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max height %d less than min height %d, "
+                  "disabling resize\n",
+                  window->desc,
+                  window->size_hints.max_height,
+                  window->size_hints.min_height);
+      maxh = window->size_hints.max_height = window->size_hints.min_height;
+    }
+
+  /* Make sure the aspect ratio hints are sane. */
+  minr =         window->size_hints.min_aspect.x /
+         (double)window->size_hints.min_aspect.y;
+  maxr =         window->size_hints.max_aspect.x /
+         (double)window->size_hints.max_aspect.y;
+  if (minr > maxr)
+    {
+      /* another cracksmoker; not even minimally (self) consistent */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min aspect ratio larger than max aspect "
+                  "ratio; disabling aspect ratio constraints.\n",
+                  window->desc);
+      window->size_hints.min_aspect.x = 1;
+      window->size_hints.min_aspect.y = G_MAXINT;
+      window->size_hints.max_aspect.x = G_MAXINT;
+      window->size_hints.max_aspect.y = 1;
+    }
+  else /* check consistency of aspect ratio hints with other hints */
+    {
+      if (minh > 0 && minr > (maxw / (double)minh))
+        {
+          /* another cracksmoker */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "Window %s sets min aspect ratio larger than largest "
+                      "aspect ratio possible given min/max size constraints; "
+                      "disabling min aspect ratio constraint.\n",
+                      window->desc);
+          window->size_hints.min_aspect.x = 1;
+          window->size_hints.min_aspect.y = G_MAXINT;
+        }
+      if (maxr < (minw / (double)maxh))
+        {
+          /* another cracksmoker */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "Window %s sets max aspect ratio smaller than smallest "
+                      "aspect ratio possible given min/max size constraints; "
+                      "disabling max aspect ratio constraint.\n",
+                      window->desc);
+          window->size_hints.max_aspect.x = G_MAXINT;
+          window->size_hints.max_aspect.y = 1;
+        }
+      /* FIXME: Would be nice to check that aspect ratios are
+       * consistent with base and size increment constraints.
+       */
+    }
+}
+
+static void
+reload_normal_hints (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      XSizeHints old_hints;
+  
+      meta_topic (META_DEBUG_GEOMETRY, "Updating WM_NORMAL_HINTS for %s\n", window->desc);
+
+      old_hints = window->size_hints;
+  
+      meta_set_normal_hints (window, value->v.size_hints.hints);
+      
+      spew_size_hints_differences (&old_hints, &window->size_hints);
+      
+      meta_window_recalc_features (window);
+
+      if (!initial)
+        meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+static void
+reload_wm_protocols (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  int i;
+  
+  window->take_focus = FALSE;
+  window->delete_window = FALSE;
+  window->net_wm_ping = FALSE;
+  
+  if (value->type == META_PROP_VALUE_INVALID)    
+    return;
+
+  i = 0;
+  while (i < value->v.atom_list.n_atoms)
+    {
+      if (value->v.atom_list.atoms[i] ==
+          window->display->atom_WM_TAKE_FOCUS)
+        window->take_focus = TRUE;
+      else if (value->v.atom_list.atoms[i] ==
+               window->display->atom_WM_DELETE_WINDOW)
+        window->delete_window = TRUE;
+      else if (value->v.atom_list.atoms[i] ==
+               window->display->atom__NET_WM_PING)
+        window->net_wm_ping = TRUE;
+      ++i;
+    }
+  
+  meta_verbose ("New _NET_STARTUP_ID \"%s\" for %s\n",
+                window->startup_id ? window->startup_id : "unset",
+                window->desc);
+}
+
+static void
+reload_wm_hints (MetaWindow    *window,
+                 MetaPropValue *value,
+                 gboolean       initial)
+{
+  Window old_group_leader;
+  
+  old_group_leader = window->xgroup_leader;
+  
+  /* Fill in defaults */
+  window->input = TRUE;
+  window->initially_iconic = FALSE;
+  window->xgroup_leader = None;
+  window->wm_hints_pixmap = None;
+  window->wm_hints_mask = None;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      const XWMHints *hints = value->v.wm_hints;
+      
+      if (hints->flags & InputHint)
+        window->input = hints->input;
+
+      if (hints->flags & StateHint)
+        window->initially_iconic = (hints->initial_state == IconicState);
+
+      if (hints->flags & WindowGroupHint)
+        window->xgroup_leader = hints->window_group;
+
+      if (hints->flags & IconPixmapHint)
+        window->wm_hints_pixmap = hints->icon_pixmap;
+
+      if (hints->flags & IconMaskHint)
+        window->wm_hints_mask = hints->icon_mask;
+      
+      meta_verbose ("Read WM_HINTS input: %d iconic: %d group leader: 0x%lx pixmap: 0x%lx mask: 0x%lx\n",
+                    window->input, window->initially_iconic,
+                    window->xgroup_leader,
+                    window->wm_hints_pixmap,
+                    window->wm_hints_mask);
+    }
+
+  if (window->xgroup_leader != old_group_leader)
+    {
+      meta_verbose ("Window %s changed its group leader to 0x%lx\n",
+                    window->desc, window->xgroup_leader);
+      
+      meta_window_group_leader_changed (window);
+    }
+
+  meta_icon_cache_property_changed (&window->icon_cache,
+                                    window->display,
+                                    XA_WM_HINTS);
+
+  meta_window_queue (window, META_QUEUE_UPDATE_ICON | META_QUEUE_MOVE_RESIZE);
+}
+
+static void
+reload_transient_for (MetaWindow    *window,
+                      MetaPropValue *value,
+                      gboolean       initial)
+{
+  window->xtransient_for = None;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    window->xtransient_for = value->v.xwindow;
+
+  /* Make sure transient_for is valid */
+  if (window->xtransient_for != None &&
+      meta_display_lookup_x_window (window->display, 
+                                    window->xtransient_for) == NULL)
+    {
+      meta_warning (_("Invalid WM_TRANSIENT_FOR window 0x%lx specified "
+                      "for %s.\n"),
+                    window->xtransient_for, window->desc);
+      window->xtransient_for = None;
+    }
+
+  window->transient_parent_is_root_window =
+    window->xtransient_for == window->screen->xroot;
+
+  if (window->xtransient_for != None)
+    meta_verbose ("Window %s transient for 0x%lx (root = %d)\n", window->desc,
+        window->xtransient_for, window->transient_parent_is_root_window);
+  else
+    meta_verbose ("Window %s is not transient\n", window->desc);
+
+  /* may now be a dialog */
+  meta_window_recalc_window_type (window);
+
+  /* update stacking constraints */
+  meta_stack_update_transient (window->screen->stack, window);
+
+  /* possibly change its group. We treat being a window's transient as
+   * equivalent to making it your group leader, to work around shortcomings
+   * in programs such as xmms-- see #328211.
+   */
+  if (window->xtransient_for != None &&
+      window->xgroup_leader != None &&
+      window->xtransient_for != window->xgroup_leader)
+    meta_window_group_leader_changed (window);
+
+  if (!window->constructing)
+    meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+/**
+ * Initialises the property hooks system.  Each row in the table named "hooks"
+ * represents an action to take when a property is found on a newly-created
+ * window, or when a property changes its value.
+ *
+ * The first column shows which atom the row concerns.
+ * The second gives the type of the property data.  The property will be
+ * queried for its new value, unless the type is given as
+ * META_PROP_VALUE_INVALID, in which case nothing will be queried.
+ * The third column gives the name of a callback which gets called with the
+ * new value.  (If the new value was not retrieved because the second column
+ * was META_PROP_VALUE_INVALID, the callback still gets called anyway.)
+ * This value may be NULL, in which case no callback will be called.
+ */
+void
+meta_display_init_window_prop_hooks (MetaDisplay *display)
+{
+  MetaWindowPropHooks hooks[] = {
+    { display->atom_WM_STATE,          META_PROP_VALUE_INVALID,  NULL },
+    { display->atom_WM_CLIENT_MACHINE, META_PROP_VALUE_STRING,   reload_wm_client_machine },
+    { display->atom__NET_WM_PID,       META_PROP_VALUE_CARDINAL, reload_net_wm_pid },
+    { display->atom__NET_WM_USER_TIME, META_PROP_VALUE_CARDINAL, reload_net_wm_user_time },
+    { display->atom__NET_WM_NAME,      META_PROP_VALUE_UTF8,     reload_net_wm_name },
+    { XA_WM_NAME,                      META_PROP_VALUE_TEXT_PROPERTY, reload_wm_name },
+    { display->atom__NET_WM_ICON,      META_PROP_VALUE_INVALID,  reload_net_wm_icon },
+    { display->atom__KWM_WIN_ICON,     META_PROP_VALUE_INVALID,  reload_kwm_win_icon },
+    { display->atom__NET_WM_ICON_NAME, META_PROP_VALUE_UTF8,     reload_net_wm_icon_name },
+    { XA_WM_ICON_NAME,                 META_PROP_VALUE_TEXT_PROPERTY, reload_wm_icon_name },
+    { display->atom__NET_WM_STATE,     META_PROP_VALUE_ATOM_LIST, reload_net_wm_state },
+    { display->atom__MOTIF_WM_HINTS,   META_PROP_VALUE_MOTIF_HINTS, reload_mwm_hints },
+    { display->atom__NET_WM_ICON_GEOMETRY, META_PROP_VALUE_INVALID, NULL },
+    { XA_WM_CLASS,                     META_PROP_VALUE_CLASS_HINT, reload_wm_class },
+    { display->atom_WM_CLIENT_LEADER,  META_PROP_VALUE_INVALID, complain_about_broken_client },
+    { display->atom_SM_CLIENT_ID,      META_PROP_VALUE_INVALID, complain_about_broken_client },
+    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role },
+    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type },
+    { display->atom__NET_WM_DESKTOP,   META_PROP_VALUE_CARDINAL, reload_net_wm_desktop },
+    { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts },
+    { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts },
+    { display->atom__NET_STARTUP_ID,  META_PROP_VALUE_UTF8,     reload_net_startup_id },
+    { display->atom__NET_WM_SYNC_REQUEST_COUNTER, META_PROP_VALUE_SYNC_COUNTER, reload_update_counter },
+    { XA_WM_NORMAL_HINTS,              META_PROP_VALUE_SIZE_HINTS, reload_normal_hints },
+    { display->atom_WM_PROTOCOLS,      META_PROP_VALUE_ATOM_LIST, reload_wm_protocols },
+    { XA_WM_HINTS,                     META_PROP_VALUE_WM_HINTS,  reload_wm_hints },
+    { XA_WM_TRANSIENT_FOR,             META_PROP_VALUE_WINDOW,    reload_transient_for },
+    { display->atom__NET_WM_USER_TIME_WINDOW, META_PROP_VALUE_WINDOW, reload_net_wm_user_time_window },
+    { 0 },
+  };
+
+  MetaWindowPropHooks *table = g_memdup (hooks, sizeof (hooks)),
+    *cursor = table;
+
+  g_assert (display->prop_hooks == NULL);
+
+  display->prop_hooks_table = (gpointer) table;
+  display->prop_hooks = g_hash_table_new (NULL, NULL);
+
+  while (cursor->property)
+    {
+      /* Atoms are safe to use with GINT_TO_POINTER because it's safe with
+       * anything 32 bits or less, and atoms are 32 bits with the top three
+       * bits clear.  (Scheifler & Gettys, 2e, p372)
+       */
+      g_hash_table_insert (display->prop_hooks,
+                           GINT_TO_POINTER (cursor->property),
+                           cursor);
+      cursor++;
+    }
+}
+
+void
+meta_display_free_window_prop_hooks (MetaDisplay *display)
+{
+  g_hash_table_unref (display->prop_hooks);
+  display->prop_hooks = NULL;
+
+  g_free (display->prop_hooks_table);
+  display->prop_hooks_table = NULL;
+}
+
+/**
+ * Finds the hooks for a particular property.
+ */
+static MetaWindowPropHooks*
+find_hooks (MetaDisplay *display,
+            Atom         property)
+{
+  return g_hash_table_lookup (display->prop_hooks,
+                              GINT_TO_POINTER (property));
+}
diff --git a/src/core/window-props.h b/src/core/window-props.h
new file mode 100644
index 00000000..1e60eff0
--- /dev/null
+++ b/src/core/window-props.h
@@ -0,0 +1,129 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file window-props.h    MetaWindow property handling
+ *
+ * A system which can inspect sets of properties of given windows
+ * and take appropriate action given their values.
+ *
+ * Note that all the meta_window_reload_propert* functions require a
+ * round trip to the server.
+ */
+
+/* 
+ * Copyright (C) 2001, 2002 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WINDOW_PROPS_H
+#define META_WINDOW_PROPS_H
+
+#include "window-private.h"
+
+/**
+ * Requests the current values of a single property for a given
+ * window from the server, and deals with it appropriately.
+ * Does not return it to the caller (it's been dealt with!)
+ *
+ * \param window     The window.
+ * \param property   A single X atom.
+ */
+void meta_window_reload_property   (MetaWindow *window,
+                                    Atom        property,
+                                    gboolean    initial);
+
+
+/**
+ * Requests the current values of a set of properties for a given
+ * window from the server, and deals with them appropriately.
+ * Does not return them to the caller (they've been dealt with!)
+ *
+ * \param window      The window.
+ * \param properties  A pointer to a list of X atoms, "n_properties" long.
+ * \param n_properties  The length of the properties list.
+ */
+void meta_window_reload_properties (MetaWindow *window,
+                                    const Atom *properties,
+                                    int         n_properties,
+                                    gboolean    initial);
+
+/**
+ * Requests the current values of a single property for a given
+ * window from the server, and deals with it appropriately.
+ * Does not return it to the caller (it's been dealt with!)
+ *
+ * \param window     A window on the same display as the one we're
+ *                   investigating (only used to find the display)
+ * \param xwindow    The X handle for the window.
+ * \param property   A single X atom.
+ */
+void meta_window_reload_property_from_xwindow
+                                   (MetaWindow *window,
+                                    Window      xwindow,
+                                    Atom        property,
+                                    gboolean    initial);
+
+/**
+ * Requests the current values of a set of properties for a given
+ * window from the server, and deals with them appropriately.
+ * Does not return them to the caller (they've been dealt with!)
+ *
+ * \param window     A window on the same display as the one we're
+ *                   investigating (only used to find the display)
+ * \param xwindow     The X handle for the window.
+ * \param properties  A pointer to a list of X atoms, "n_properties" long.
+ * \param n_properties  The length of the properties list.
+ */
+void meta_window_reload_properties_from_xwindow
+                                   (MetaWindow *window,
+                                    Window      xwindow,
+                                    const Atom *properties,
+                                    int         n_properties,
+                                    gboolean    initial);
+
+/**
+ * Initialises the hooks used for the reload_propert* functions
+ * on a particular display, and stores a pointer to them in the
+ * display.
+ *
+ * \param display  The display.
+ */
+void meta_display_init_window_prop_hooks (MetaDisplay *display);
+
+/**
+ * Frees the hooks used for the reload_propert* functions
+ * for a particular display.
+ *
+ * \param display  The display.
+ */
+void meta_display_free_window_prop_hooks (MetaDisplay *display);
+
+/**
+ * Sets the size hints for a window.  This happens when a
+ * WM_NORMAL_HINTS property is set on a window, but it is public
+ * because the size hints are set to defaults when a window is
+ * created.  See
+ * http://tronche.com/gui/x/icccm/sec-4.html#WM_NORMAL_HINTS
+ * for the X details.
+ *
+ * \param window   The window to set the size hints on.
+ * \param hints    Either some X size hints, or NULL for default.
+ */
+void meta_set_normal_hints (MetaWindow *window,
+			    XSizeHints *hints);
+
+#endif /* META_WINDOW_PROPS_H */
diff --git a/src/core/window.c b/src/core/window.c
new file mode 100644
index 00000000..08ab9ec9
--- /dev/null
+++ b/src/core/window.c
@@ -0,0 +1,8178 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X managed windows */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington, Anders Carlsson
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "window-private.h"
+#include "edge-resistance.h"
+#include "util.h"
+#include "frame-private.h"
+#include "errors.h"
+#include "workspace.h"
+#include "stack.h"
+#include "keybindings.h"
+#include "ui.h"
+#include "place.h"
+#include "session.h"
+#include "effects.h"
+#include "prefs.h"
+#include "resizepopup.h"
+#include "xprops.h"
+#include "group.h"
+#include "window-props.h"
+#include "constraints.h"
+#include "compositor.h"
+#include "effects.h"
+
+#include <X11/Xatom.h>
+#include <string.h>
+
+#ifdef HAVE_SHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+static int destroying_windows_disallowed = 0;
+
+
+static void     update_sm_hints           (MetaWindow     *window);
+static void     update_net_frame_extents  (MetaWindow     *window);
+static void     recalc_window_type        (MetaWindow     *window);
+static void     recalc_window_features    (MetaWindow     *window);
+static void     invalidate_work_areas     (MetaWindow     *window);
+static void     recalc_window_type        (MetaWindow     *window);
+static void     set_wm_state              (MetaWindow     *window,
+                                           int             state);
+static void     set_net_wm_state          (MetaWindow     *window);
+
+static void     send_configure_notify     (MetaWindow     *window);
+static gboolean process_property_notify   (MetaWindow     *window,
+                                           XPropertyEvent *event);
+static void     meta_window_show          (MetaWindow     *window);
+static void     meta_window_hide          (MetaWindow     *window);
+
+static void     meta_window_save_rect         (MetaWindow    *window);
+static void     save_user_window_placement    (MetaWindow    *window);
+static void     force_save_user_window_placement (MetaWindow    *window);
+
+static void meta_window_move_resize_internal (MetaWindow         *window,
+                                              MetaMoveResizeFlags flags,
+                                              int                 resize_gravity,
+                                              int                 root_x_nw,
+                                              int                 root_y_nw,
+                                              int                 w,
+                                              int                 h);
+
+static void     ensure_mru_position_after (MetaWindow *window,
+                                           MetaWindow *after_this_one);
+
+
+static void meta_window_move_resize_now (MetaWindow  *window);
+
+static void meta_window_unqueue (MetaWindow *window, guint queuebits);
+
+static void     update_move           (MetaWindow   *window,
+                                       gboolean      snap,
+                                       int           x,
+                                       int           y);
+static gboolean update_move_timeout   (gpointer data);
+static void     update_resize         (MetaWindow   *window,
+                                       gboolean      snap,
+                                       int           x,
+                                       int           y,
+                                       gboolean      force);
+static gboolean update_resize_timeout (gpointer data);
+
+
+static void meta_window_flush_calc_showing   (MetaWindow *window);
+
+static gboolean queue_calc_showing_func (MetaWindow *window,
+                                         void       *data);
+
+static void meta_window_apply_session_info (MetaWindow                  *window,
+                                            const MetaWindowSessionInfo *info);
+
+static void unmaximize_window_before_freeing (MetaWindow        *window);
+static void unminimize_window_and_all_transient_parents (MetaWindow *window);
+
+/* Idle handlers for the three queues. The "data" parameter in each case
+ * will be a GINT_TO_POINTER of the index into the queue arrays to use.
+ *
+ * TODO: Possibly there is still some code duplication among these, which we
+ * need to sort out at some point.
+ */
+static gboolean idle_calc_showing (gpointer data);
+static gboolean idle_move_resize (gpointer data);
+static gboolean idle_update_icon (gpointer data);
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+wm_state_to_string (int state)
+{
+  switch (state)
+    {
+    case NormalState:
+      return "NormalState";
+    case IconicState:
+      return "IconicState";
+    case WithdrawnState:
+      return "WithdrawnState";
+    }
+
+  return "Unknown";
+}
+#endif
+
+static gboolean
+is_desktop_or_dock_foreach (MetaWindow *window,
+                            void       *data)
+{
+  gboolean *result = data;
+
+  *result =
+    window->type == META_WINDOW_DESKTOP ||
+    window->type == META_WINDOW_DOCK;
+  if (*result)
+    return FALSE; /* stop as soon as we find one */
+  else
+    return TRUE;
+}
+
+/* window is the window that's newly mapped provoking
+ * the possible change
+ */
+static void
+maybe_leave_show_desktop_mode (MetaWindow *window)
+{
+  gboolean is_desktop_or_dock;
+
+  if (!window->screen->active_workspace->showing_desktop)
+    return;
+
+  /* If the window is a transient for the dock or desktop, don't
+   * leave show desktop mode when the window opens. That's
+   * so you can e.g. hide all windows, manipulate a file on
+   * the desktop via a dialog, then unshow windows again.
+   */
+  is_desktop_or_dock = FALSE;
+  is_desktop_or_dock_foreach (window,
+                              &is_desktop_or_dock);
+
+  meta_window_foreach_ancestor (window, is_desktop_or_dock_foreach,
+                                &is_desktop_or_dock);
+
+  if (!is_desktop_or_dock)
+    {
+      meta_screen_minimize_all_on_active_workspace_except (window->screen,
+                                                           window);
+      meta_screen_unshow_desktop (window->screen);
+    }
+}
+
+MetaWindow*
+meta_window_new (MetaDisplay *display,
+                 Window       xwindow,
+                 gboolean     must_be_viewable)
+{
+  XWindowAttributes attrs;
+  MetaWindow *window;
+
+  meta_display_grab (display);
+  meta_error_trap_push (display); /* Push a trap over all of window
+                                   * creation, to reduce XSync() calls
+                                   */
+
+  meta_error_trap_push_with_return (display);
+
+  if (XGetWindowAttributes (display->xdisplay,xwindow, &attrs))
+   {
+      if(meta_error_trap_pop_with_return (display, TRUE) != Success)
+       {
+          meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        xwindow);
+          meta_error_trap_pop (display, TRUE);
+          meta_display_ungrab (display);
+          return NULL;
+       }
+      window = meta_window_new_with_attrs (display, xwindow,
+                                       must_be_viewable, &attrs);
+   }
+  else
+   {
+         meta_error_trap_pop_with_return (display, TRUE);
+         meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        xwindow);
+         meta_error_trap_pop (display, TRUE);
+         meta_display_ungrab (display);
+         return NULL;
+   }
+
+
+  meta_error_trap_pop (display, FALSE);
+  meta_display_ungrab (display);
+
+  return window;
+}
+
+MetaWindow*
+meta_window_new_with_attrs (MetaDisplay       *display,
+                            Window             xwindow,
+                            gboolean           must_be_viewable,
+                            XWindowAttributes *attrs)
+{
+  MetaWindow *window;
+  GSList *tmp;
+  MetaWorkspace *space;
+  gulong existing_wm_state;
+  gulong event_mask;
+  MetaMoveResizeFlags flags;
+#define N_INITIAL_PROPS 19
+  Atom initial_props[N_INITIAL_PROPS];
+  int i;
+  gboolean has_shape;
+
+  g_assert (attrs != NULL);
+  g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props));
+
+  meta_verbose ("Attempting to manage 0x%lx\n", xwindow);
+
+  if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
+    {
+      meta_verbose ("Not managing no_focus_window 0x%lx\n",
+                    xwindow);
+      return NULL;
+    }
+
+  if (attrs->override_redirect)
+    {
+      meta_verbose ("Deciding not to manage override_redirect window 0x%lx\n", xwindow);
+      return NULL;
+    }
+
+  /* Grab server */
+  meta_display_grab (display);
+  meta_error_trap_push (display); /* Push a trap over all of window
+                                   * creation, to reduce XSync() calls
+                                   */
+
+  meta_verbose ("must_be_viewable = %d attrs->map_state = %d (%s)\n",
+                must_be_viewable,
+                attrs->map_state,
+                (attrs->map_state == IsUnmapped) ?
+                "IsUnmapped" :
+                (attrs->map_state == IsViewable) ?
+                "IsViewable" :
+                (attrs->map_state == IsUnviewable) ?
+                "IsUnviewable" :
+                "(unknown)");
+
+  existing_wm_state = WithdrawnState;
+  if (must_be_viewable && attrs->map_state != IsViewable)
+    {
+      /* Only manage if WM_STATE is IconicState or NormalState */
+      gulong state;
+
+      /* WM_STATE isn't a cardinal, it's type WM_STATE, but is an int */
+      if (!(meta_prop_get_cardinal_with_atom_type (display, xwindow,
+                                                   display->atom_WM_STATE,
+                                                   display->atom_WM_STATE,
+                                                   &state) &&
+            (state == IconicState || state == NormalState)))
+        {
+          meta_verbose ("Deciding not to manage unmapped or unviewable window 0x%lx\n", xwindow);
+          meta_error_trap_pop (display, TRUE);
+          meta_display_ungrab (display);
+          return NULL;
+        }
+
+      existing_wm_state = state;
+      meta_verbose ("WM_STATE of %lx = %s\n", xwindow,
+                    wm_state_to_string (existing_wm_state));
+    }
+
+  meta_error_trap_push_with_return (display);
+
+  XAddToSaveSet (display->xdisplay, xwindow);
+
+  event_mask =
+    PropertyChangeMask | EnterWindowMask | LeaveWindowMask |
+    FocusChangeMask | ColormapChangeMask;
+
+  XSelectInput (display->xdisplay, xwindow, event_mask);
+
+  has_shape = FALSE;
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display))
+    {
+      int x_bounding, y_bounding, x_clip, y_clip;
+      unsigned w_bounding, h_bounding, w_clip, h_clip;
+      int bounding_shaped, clip_shaped;
+
+      XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
+
+      XShapeQueryExtents (display->xdisplay, xwindow,
+                          &bounding_shaped, &x_bounding, &y_bounding,
+                          &w_bounding, &h_bounding,
+                          &clip_shaped, &x_clip, &y_clip,
+                          &w_clip, &h_clip);
+
+      has_shape = bounding_shaped != FALSE;
+
+      meta_topic (META_DEBUG_SHAPES,
+                  "Window has_shape = %d extents %d,%d %u x %u\n",
+                  has_shape, x_bounding, y_bounding,
+                  w_bounding, h_bounding);
+    }
+#endif
+
+  /* Get rid of any borders */
+  if (attrs->border_width != 0)
+    XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
+
+  /* Get rid of weird gravities */
+  if (attrs->win_gravity != NorthWestGravity)
+    {
+      XSetWindowAttributes set_attrs;
+
+      set_attrs.win_gravity = NorthWestGravity;
+
+      XChangeWindowAttributes (display->xdisplay,
+                               xwindow,
+                               CWWinGravity,
+                               &set_attrs);
+    }
+
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    {
+      meta_verbose ("Window 0x%lx disappeared just as we tried to manage it\n",
+                    xwindow);
+      meta_error_trap_pop (display, FALSE);
+      meta_display_ungrab (display);
+      return NULL;
+    }
+
+  g_assert (!attrs->override_redirect);
+
+  window = g_new (MetaWindow, 1);
+
+  window->constructing = TRUE;
+
+  window->dialog_pid = -1;
+
+  window->xwindow = xwindow;
+
+  /* this is in window->screen->display, but that's too annoying to
+   * type
+   */
+  window->display = display;
+  window->workspace = NULL;
+
+#ifdef HAVE_XSYNC
+  window->sync_request_counter = None;
+  window->sync_request_serial = 0;
+  window->sync_request_time.tv_sec = 0;
+  window->sync_request_time.tv_usec = 0;
+#endif
+
+  window->screen = NULL;
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *scr = tmp->data;
+
+      if (scr->xroot == attrs->root)
+        {
+          window->screen = tmp->data;
+          break;
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_assert (window->screen);
+
+  window->desc = g_strdup_printf ("0x%lx", window->xwindow);
+
+  /* avoid tons of stack updates */
+  meta_stack_freeze (window->screen->stack);
+
+  window->has_shape = has_shape;
+
+  window->rect.x = attrs->x;
+  window->rect.y = attrs->y;
+  window->rect.width = attrs->width;
+  window->rect.height = attrs->height;
+
+  /* And border width, size_hints are the "request" */
+  window->border_width = attrs->border_width;
+  window->size_hints.x = attrs->x;
+  window->size_hints.y = attrs->y;
+  window->size_hints.width = attrs->width;
+  window->size_hints.height = attrs->height;
+  /* initialize the remaining size_hints as if size_hints.flags were zero */
+  meta_set_normal_hints (window, NULL);
+
+  /* And this is our unmaximized size */
+  window->saved_rect = window->rect;
+  window->user_rect = window->rect;
+
+  window->depth = attrs->depth;
+  window->xvisual = attrs->visual;
+  window->colormap = attrs->colormap;
+
+  window->title = NULL;
+  window->icon_name = NULL;
+  window->icon = NULL;
+  window->mini_icon = NULL;
+  meta_icon_cache_init (&window->icon_cache);
+  window->wm_hints_pixmap = None;
+  window->wm_hints_mask = None;
+
+  window->frame = NULL;
+  window->has_focus = FALSE;
+
+  window->maximized_horizontally = FALSE;
+  window->maximized_vertically = FALSE;
+  window->maximize_horizontally_after_placement = FALSE;
+  window->maximize_vertically_after_placement = FALSE;
+  window->minimize_after_placement = FALSE;
+  window->fullscreen_after_placement = FALSE;
+  window->fullscreen_monitors[0] = -1;
+  window->require_fully_onscreen = TRUE;
+  window->require_on_single_xinerama = TRUE;
+  window->require_titlebar_visible = TRUE;
+  window->on_all_workspaces = FALSE;
+  window->shaded = FALSE;
+  window->initially_iconic = FALSE;
+  window->minimized = FALSE;
+  window->was_minimized = FALSE;
+  window->tab_unminimized = FALSE;
+  window->iconic = FALSE;
+  window->mapped = attrs->map_state != IsUnmapped;
+  /* if already mapped, no need to worry about focus-on-first-time-showing */
+  window->showing_for_first_time = !window->mapped;
+  /* if already mapped we don't want to do the placement thing */
+  window->placed = window->mapped;
+  if (window->placed)
+    meta_topic (META_DEBUG_PLACEMENT,
+                "Not placing window 0x%lx since it's already mapped\n",
+                xwindow);
+  window->force_save_user_rect = TRUE;
+  window->denied_focus_and_not_transient = FALSE;
+  window->unmanaging = FALSE;
+  window->is_in_queues = 0;
+  window->keys_grabbed = FALSE;
+  window->grab_on_frame = FALSE;
+  window->all_keys_grabbed = FALSE;
+  window->withdrawn = FALSE;
+  window->initial_workspace_set = FALSE;
+  window->initial_timestamp_set = FALSE;
+  window->net_wm_user_time_set = FALSE;
+  window->user_time_window = None;
+  window->calc_placement = FALSE;
+  window->shaken_loose = FALSE;
+  window->have_focus_click_grab = FALSE;
+  window->disable_sync = FALSE;
+
+  window->unmaps_pending = 0;
+
+  window->mwm_decorated = TRUE;
+  window->mwm_border_only = FALSE;
+  window->mwm_has_close_func = TRUE;
+  window->mwm_has_minimize_func = TRUE;
+  window->mwm_has_maximize_func = TRUE;
+  window->mwm_has_move_func = TRUE;
+  window->mwm_has_resize_func = TRUE;
+
+  window->decorated = TRUE;
+  window->has_close_func = TRUE;
+  window->has_minimize_func = TRUE;
+  window->has_maximize_func = TRUE;
+  window->has_move_func = TRUE;
+  window->has_resize_func = TRUE;
+
+  window->has_shade_func = TRUE;
+
+  window->has_fullscreen_func = TRUE;
+
+  window->always_sticky = FALSE;
+
+  window->wm_state_modal = FALSE;
+  window->skip_taskbar = FALSE;
+  window->skip_pager = FALSE;
+  window->wm_state_skip_taskbar = FALSE;
+  window->wm_state_skip_pager = FALSE;
+  window->wm_state_above = FALSE;
+  window->wm_state_below = FALSE;
+  window->wm_state_demands_attention = FALSE;
+
+  window->res_class = NULL;
+  window->res_name = NULL;
+  window->role = NULL;
+  window->sm_client_id = NULL;
+  window->wm_client_machine = NULL;
+  window->startup_id = NULL;
+
+  window->net_wm_pid = -1;
+
+  window->xtransient_for = None;
+  window->xclient_leader = None;
+  window->transient_parent_is_root_window = FALSE;
+
+  window->type = META_WINDOW_NORMAL;
+  window->type_atom = None;
+
+  window->struts = NULL;
+
+  window->using_net_wm_name              = FALSE;
+  window->using_net_wm_visible_name      = FALSE;
+  window->using_net_wm_icon_name         = FALSE;
+  window->using_net_wm_visible_icon_name = FALSE;
+
+  window->need_reread_icon = TRUE;
+
+  window->layer = META_LAYER_LAST; /* invalid value */
+  window->stack_position = -1;
+  window->initial_workspace = 0; /* not used */
+  window->initial_timestamp = 0; /* not used */
+
+  meta_display_register_x_window (display, &window->xwindow, window);
+
+
+  /* assign the window to its group, or create a new group if needed
+   */
+  window->group = NULL;
+  window->xgroup_leader = None;
+  meta_window_compute_group (window);
+
+  /* Fill these in the order we want them to be gotten.  we want to
+   * get window name and class first so we can use them in error
+   * messages and such.  However, name is modified depending on
+   * wm_client_machine, so push it slightly sooner.
+   */
+  i = 0;
+  initial_props[i++] = display->atom_WM_CLIENT_MACHINE;
+  initial_props[i++] = display->atom__NET_WM_PID;
+  initial_props[i++] = display->atom__NET_WM_NAME;
+  initial_props[i++] = XA_WM_CLASS;
+  initial_props[i++] = XA_WM_NAME;
+  initial_props[i++] = display->atom__NET_WM_ICON_NAME;
+  initial_props[i++] = XA_WM_ICON_NAME;
+  initial_props[i++] = display->atom__NET_WM_DESKTOP;
+  initial_props[i++] = display->atom__NET_STARTUP_ID;
+  initial_props[i++] = display->atom__NET_WM_SYNC_REQUEST_COUNTER;
+  initial_props[i++] = XA_WM_NORMAL_HINTS;
+  initial_props[i++] = display->atom_WM_PROTOCOLS;
+  initial_props[i++] = XA_WM_HINTS;
+  initial_props[i++] = display->atom__NET_WM_USER_TIME;
+  initial_props[i++] = display->atom__NET_WM_STATE;
+  initial_props[i++] = display->atom__MOTIF_WM_HINTS;
+  initial_props[i++] = XA_WM_TRANSIENT_FOR;
+  initial_props[i++] = display->atom__NET_WM_USER_TIME_WINDOW;
+  initial_props[i++] = display->atom__NET_WM_FULLSCREEN_MONITORS;
+  g_assert (N_INITIAL_PROPS == i);
+
+  meta_window_reload_properties (window, initial_props, N_INITIAL_PROPS, TRUE);
+
+  update_sm_hints (window); /* must come after transient_for */
+  meta_window_update_role (window);
+  meta_window_update_net_wm_type (window);
+  meta_window_update_icon_now (window);
+
+  if (window->initially_iconic)
+    {
+      /* WM_HINTS said minimized */
+      window->minimized = TRUE;
+      meta_verbose ("Window %s asked to start out minimized\n", window->desc);
+    }
+
+  if (existing_wm_state == IconicState)
+    {
+      /* WM_STATE said minimized */
+      window->minimized = TRUE;
+      meta_verbose ("Window %s had preexisting WM_STATE = IconicState, minimizing\n",
+                    window->desc);
+
+      /* Assume window was previously placed, though perhaps it's
+       * been iconic its whole life, we have no way of knowing.
+       */
+      window->placed = TRUE;
+    }
+
+  /* Apply any window attributes such as initial workspace
+   * based on startup notification
+   */
+  meta_screen_apply_startup_properties (window->screen, window);
+
+  /* Try to get a "launch timestamp" for the window.  If the window is
+   * a transient, we'd like to be able to get a last-usage timestamp
+   * from the parent window.  If the window has no parent, there isn't
+   * much we can do...except record the current time so that any children
+   * can use this time as a fallback.
+   */
+  if (!window->net_wm_user_time_set) {
+    MetaWindow *parent = NULL;
+    if (window->xtransient_for)
+      parent = meta_display_lookup_x_window (window->display,
+                                             window->xtransient_for);
+
+    /* First, maybe the app was launched with startup notification using an
+     * obsolete version of the spec; use that timestamp if it exists.
+     */
+    if (window->initial_timestamp_set)
+      /* NOTE: Do NOT toggle net_wm_user_time_set to true; this is just
+       * being recorded as a fallback for potential transients
+       */
+      window->net_wm_user_time = window->initial_timestamp;
+    else if (parent != NULL)
+      meta_window_set_user_time(window, parent->net_wm_user_time);
+    else
+      /* NOTE: Do NOT toggle net_wm_user_time_set to true; this is just
+       * being recorded as a fallback for potential transients
+       */
+      window->net_wm_user_time =
+        meta_display_get_current_time_roundtrip (window->display);
+  }
+
+  if (window->decorated)
+    meta_window_ensure_frame (window);
+
+  meta_window_grab_keys (window);
+  if (window->type != META_WINDOW_DOCK)
+    {
+      meta_display_grab_window_buttons (window->display, window->xwindow);
+      meta_display_grab_focus_window_button (window->display, window);
+    }
+
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    {
+      /* Change the default, but don't enforce this if the user
+       * focuses the dock/desktop and unsticks it using key shortcuts.
+       * Need to set this before adding to the workspaces so the MRU
+       * lists will be updated.
+       */
+      window->on_all_workspaces = TRUE;
+    }
+
+  /* For the workspace, first honor hints,
+   * if that fails put transients with parents,
+   * otherwise put window on active space
+   */
+
+  if (window->initial_workspace_set)
+    {
+      if (window->initial_workspace == (int) 0xFFFFFFFF)
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Window %s is initially on all spaces\n",
+                      window->desc);
+
+	  /* need to set on_all_workspaces first so that it will be
+	   * added to all the MRU lists
+	   */
+          window->on_all_workspaces = TRUE;
+          meta_workspace_add_window (window->screen->active_workspace, window);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Window %s is initially on space %d\n",
+                      window->desc, window->initial_workspace);
+
+          space =
+            meta_screen_get_workspace_by_index (window->screen,
+                                                window->initial_workspace);
+
+          if (space)
+            meta_workspace_add_window (space, window);
+        }
+    }
+
+  if (window->workspace == NULL &&
+      window->xtransient_for != None)
+    {
+      /* Try putting dialog on parent's workspace */
+      MetaWindow *parent;
+
+      parent = meta_display_lookup_x_window (window->display,
+                                             window->xtransient_for);
+
+      if (parent && parent->workspace)
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Putting window %s on same workspace as parent %s\n",
+                      window->desc, parent->desc);
+
+          if (parent->on_all_workspaces)
+            window->on_all_workspaces = TRUE;
+
+	  /* this will implicitly add to the appropriate MRU lists
+	   */
+          meta_workspace_add_window (parent->workspace, window);
+        }
+    }
+
+  if (window->workspace == NULL)
+    {
+      meta_topic (META_DEBUG_PLACEMENT,
+                  "Putting window %s on active workspace\n",
+                  window->desc);
+
+      space = window->screen->active_workspace;
+
+      meta_workspace_add_window (space, window);
+    }
+
+  /* for the various on_all_workspaces = TRUE possible above */
+  meta_window_set_current_workspace_hint (window);
+
+  meta_window_update_struts (window);
+
+  /* Must add window to stack before doing move/resize, since the
+   * window might have fullscreen size (i.e. should have been
+   * fullscreen'd; acrobat is one such braindead case; it withdraws
+   * and remaps its window whenever trying to become fullscreen...)
+   * and thus constraints may try to auto-fullscreen it which also
+   * means restacking it.
+   */
+  meta_stack_add (window->screen->stack,
+                  window);
+
+  /* Put our state back where it should be,
+   * passing TRUE for is_configure_request, ICCCM says
+   * initial map is handled same as configure request
+   */
+  flags =
+    META_IS_CONFIGURE_REQUEST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    window->size_hints.win_gravity,
+                                    window->size_hints.x,
+                                    window->size_hints.y,
+                                    window->size_hints.width,
+                                    window->size_hints.height);
+
+  /* Now try applying saved stuff from the session */
+  {
+    const MetaWindowSessionInfo *info;
+
+    info = meta_window_lookup_saved_state (window);
+
+    if (info)
+      {
+        meta_window_apply_session_info (window, info);
+        meta_window_release_saved_state (info);
+      }
+  }
+
+  /* FIXME we have a tendency to set this then immediately
+   * change it again.
+   */
+  set_wm_state (window, window->iconic ? IconicState : NormalState);
+  set_net_wm_state (window);
+
+  /* Sync stack changes */
+  meta_stack_thaw (window->screen->stack);
+
+  /* disable show desktop mode unless we're a desktop component */
+  maybe_leave_show_desktop_mode (window);
+
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+  /* See bug 303284; a transient of the given window can already exist, in which
+   * case we think it should probably be shown.
+   */
+  meta_window_foreach_transient (window,
+                                 queue_calc_showing_func,
+                                 NULL);
+  /* See bug 334899; the window may have minimized ancestors
+   * which need to be shown.
+   *
+   * However, we shouldn't unminimize windows here when opening
+   * a new display because that breaks passing _NET_WM_STATE_HIDDEN
+   * between window managers when replacing them; see bug 358042.
+   *
+   * And we shouldn't unminimize windows if they were initially
+   * iconic.
+   */
+  if (!display->display_opening && !window->initially_iconic)
+    unminimize_window_and_all_transient_parents (window);
+
+  meta_error_trap_pop (display, FALSE); /* pop the XSync()-reducing trap */
+  meta_display_ungrab (display);
+
+  window->constructing = FALSE;
+
+  return window;
+}
+
+/* This function should only be called from the end of meta_window_new_with_attrs () */
+static void
+meta_window_apply_session_info (MetaWindow *window,
+                                const MetaWindowSessionInfo *info)
+{
+  if (info->stack_position_set)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Restoring stack position %d for window %s\n",
+                  info->stack_position, window->desc);
+
+      /* FIXME well, I'm not sure how to do this. */
+    }
+
+  if (info->minimized_set)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Restoring minimized state %d for window %s\n",
+                  info->minimized, window->desc);
+
+      if (window->has_minimize_func && info->minimized)
+        meta_window_minimize (window);
+    }
+
+  if (info->maximized_set)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Restoring maximized state %d for window %s\n",
+                  info->maximized, window->desc);
+
+      if (window->has_maximize_func && info->maximized)
+        {
+          meta_window_maximize (window,
+                                META_MAXIMIZE_HORIZONTAL |
+                                META_MAXIMIZE_VERTICAL);
+
+          if (info->saved_rect_set)
+            {
+              meta_topic (META_DEBUG_SM,
+                          "Restoring saved rect %d,%d %dx%d for window %s\n",
+                          info->saved_rect.x,
+                          info->saved_rect.y,
+                          info->saved_rect.width,
+                          info->saved_rect.height,
+                          window->desc);
+
+              window->saved_rect.x = info->saved_rect.x;
+              window->saved_rect.y = info->saved_rect.y;
+              window->saved_rect.width = info->saved_rect.width;
+              window->saved_rect.height = info->saved_rect.height;
+            }
+	}
+    }
+
+  if (info->on_all_workspaces_set)
+    {
+      window->on_all_workspaces = info->on_all_workspaces;
+      meta_topic (META_DEBUG_SM,
+                  "Restoring sticky state %d for window %s\n",
+                  window->on_all_workspaces, window->desc);
+    }
+
+  if (info->workspace_indices)
+    {
+      GSList *tmp;
+      GSList *spaces;
+
+      spaces = NULL;
+
+      tmp = info->workspace_indices;
+      while (tmp != NULL)
+        {
+          MetaWorkspace *space;
+
+          space =
+            meta_screen_get_workspace_by_index (window->screen,
+                                                GPOINTER_TO_INT (tmp->data));
+
+          if (space)
+            spaces = g_slist_prepend (spaces, space);
+
+          tmp = tmp->next;
+        }
+
+      if (spaces)
+        {
+          /* This briefly breaks the invariant that we are supposed
+           * to always be on some workspace. But we paranoically
+           * ensured that one of the workspaces from the session was
+           * indeed valid, so we know we'll go right back to one.
+           */
+          if (window->workspace)
+            meta_workspace_remove_window (window->workspace, window);
+
+          /* Only restore to the first workspace if the window
+           * happened to be on more than one, since we have replaces
+           * window->workspaces with window->workspace
+           */
+          meta_workspace_add_window (spaces->data, window);
+
+          meta_topic (META_DEBUG_SM,
+                      "Restoring saved window %s to workspace %d\n",
+                      window->desc,
+                      meta_workspace_index (spaces->data));
+
+          g_slist_free (spaces);
+        }
+    }
+
+  if (info->geometry_set)
+    {
+      int x, y, w, h;
+      MetaMoveResizeFlags flags;
+
+      window->placed = TRUE; /* don't do placement algorithms later */
+
+      x = info->rect.x;
+      y = info->rect.y;
+
+      w = window->size_hints.base_width +
+        info->rect.width * window->size_hints.width_inc;
+      h = window->size_hints.base_height +
+        info->rect.height * window->size_hints.height_inc;
+
+      /* Force old gravity, ignoring anything now set */
+      window->size_hints.win_gravity = info->gravity;
+
+      meta_topic (META_DEBUG_SM,
+                  "Restoring pos %d,%d size %d x %d for %s\n",
+                  x, y, w, h, window->desc);
+
+      flags = META_DO_GRAVITY_ADJUST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+      meta_window_move_resize_internal (window,
+                                        flags,
+                                        window->size_hints.win_gravity,
+                                        x, y, w, h);
+    }
+}
+
+void
+meta_window_free (MetaWindow  *window,
+                  guint32      timestamp)
+{
+  GList *tmp;
+
+  meta_verbose ("Unmanaging 0x%lx\n", window->xwindow);
+
+  if (window->display->compositor)
+    meta_compositor_free_window (window->display->compositor, window);
+
+  if (window->display->window_with_menu == window)
+    {
+      meta_ui_window_menu_free (window->display->window_menu);
+      window->display->window_menu = NULL;
+      window->display->window_with_menu = NULL;
+    }
+
+  if (destroying_windows_disallowed > 0)
+    meta_bug ("Tried to destroy window %s while destruction was not allowed\n",
+              window->desc);
+
+  window->unmanaging = TRUE;
+
+  if (window->fullscreen)
+    {
+      MetaGroup *group;
+
+      /* If the window is fullscreen, it may be forcing
+       * other windows in its group to a higher layer
+       */
+
+      meta_stack_freeze (window->screen->stack);
+      group = meta_window_get_group (window);
+      if (group)
+        meta_group_update_layers (group);
+      meta_stack_thaw (window->screen->stack);
+    }
+
+  meta_window_shutdown_group (window); /* safe to do this early as
+                                        * group.c won't re-add to the
+                                        * group if window->unmanaging
+                                        */
+
+  /* If we have the focus, focus some other window.
+   * This is done first, so that if the unmap causes
+   * an EnterNotify the EnterNotify will have final say
+   * on what gets focused, maintaining sloppy focus
+   * invariants.
+   */
+  if (window->has_focus)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window since we're unmanaging %s\n",
+                  window->desc);
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
+  else if (window->display->expected_focus_window == window)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window since expected focus window freed %s\n",
+                  window->desc);
+      window->display->expected_focus_window = NULL;
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Unmanaging window %s which doesn't currently have focus\n",
+                  window->desc);
+    }
+
+  if (window->struts)
+    {
+      meta_free_gslist_and_elements (window->struts);
+      window->struts = NULL;
+
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Unmanaging window %s which has struts, so invalidating work areas\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+
+  if (window->display->grab_window == window)
+    meta_display_end_grab_op (window->display, timestamp);
+
+  g_assert (window->display->grab_window != window);
+
+  if (window->display->focus_window == window)
+    {
+      window->display->focus_window = NULL;
+      meta_compositor_set_active_window (window->display->compositor,
+                                         window->screen, NULL);
+    }
+
+  if (window->maximized_horizontally || window->maximized_vertically)
+    unmaximize_window_before_freeing (window);
+
+  /* The XReparentWindow call in meta_window_destroy_frame() moves the
+   * window so we need to send a configure notify; see bug 399552.  (We
+   * also do this just in case a window got unmaximized.)
+   */
+  send_configure_notify (window);
+
+  meta_window_unqueue (window, META_QUEUE_CALC_SHOWING |
+                               META_QUEUE_MOVE_RESIZE |
+                               META_QUEUE_UPDATE_ICON);
+  meta_window_free_delete_dialog (window);
+
+  if (window->workspace)
+    meta_workspace_remove_window (window->workspace, window);
+
+  g_assert (window->workspace == NULL);
+
+#ifndef G_DISABLE_CHECKS
+  tmp = window->screen->workspaces;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *workspace = tmp->data;
+
+      g_assert (g_list_find (workspace->windows, window) == NULL);
+      g_assert (g_list_find (workspace->mru_list, window) == NULL);
+
+      tmp = tmp->next;
+    }
+#endif
+
+  meta_stack_remove (window->screen->stack, window);
+
+  if (window->frame)
+    meta_window_destroy_frame (window);
+
+  if (window->withdrawn)
+    {
+      /* We need to clean off the window's state so it
+       * won't be restored if the app maps it again.
+       */
+      meta_error_trap_push (window->display);
+      meta_verbose ("Cleaning state from window %s\n", window->desc);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_DESKTOP);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_STATE);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_FULLSCREEN_MONITORS);
+      set_wm_state (window, WithdrawnState);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+  else
+    {
+      /* We need to put WM_STATE so that others will understand it on
+       * restart.
+       */
+      if (!window->minimized)
+        {
+          meta_error_trap_push (window->display);
+          set_wm_state (window, NormalState);
+          meta_error_trap_pop (window->display, FALSE);
+        }
+
+      /* And we need to be sure the window is mapped so other WMs
+       * know that it isn't Withdrawn
+       */
+      meta_error_trap_push (window->display);
+      XMapWindow (window->display->xdisplay,
+                  window->xwindow);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+
+  meta_window_ungrab_keys (window);
+  meta_display_ungrab_window_buttons (window->display, window->xwindow);
+  meta_display_ungrab_focus_window_button (window->display, window);
+
+  meta_display_unregister_x_window (window->display, window->xwindow);
+
+
+  meta_error_trap_push (window->display);
+
+  /* Put back anything we messed up */
+  if (window->border_width != 0)
+    XSetWindowBorderWidth (window->display->xdisplay,
+                           window->xwindow,
+                           window->border_width);
+
+  /* No save set */
+  XRemoveFromSaveSet (window->display->xdisplay,
+                      window->xwindow);
+
+  /* Don't get events on not-managed windows */
+  XSelectInput (window->display->xdisplay,
+                window->xwindow,
+                NoEventMask);
+
+  /* Stop getting events for the window's _NET_WM_USER_TIME_WINDOW too */
+  if (window->user_time_window != None)
+    {
+      meta_display_unregister_x_window (window->display,
+                                        window->user_time_window);
+      XSelectInput (window->display->xdisplay,
+                    window->user_time_window,
+                    NoEventMask);
+      window->user_time_window = None;
+    }
+
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (window->display))
+    XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask);
+#endif
+
+  meta_error_trap_pop (window->display, FALSE);
+
+  if (window->icon)
+    g_object_unref (G_OBJECT (window->icon));
+
+  if (window->mini_icon)
+    g_object_unref (G_OBJECT (window->mini_icon));
+
+  meta_icon_cache_free (&window->icon_cache);
+
+  g_free (window->sm_client_id);
+  g_free (window->wm_client_machine);
+  g_free (window->startup_id);
+  g_free (window->role);
+  g_free (window->res_class);
+  g_free (window->res_name);
+  g_free (window->title);
+  g_free (window->icon_name);
+  g_free (window->desc);
+  g_free (window);
+}
+
+static void
+set_wm_state (MetaWindow *window,
+              int         state)
+{
+  unsigned long data[2];
+
+  meta_verbose ("Setting wm state %s on %s\n",
+                wm_state_to_string (state), window->desc);
+
+  /* Marco doesn't use icon windows, so data[1] should be None
+   * according to the ICCCM 2.0 Section 4.1.3.1.
+   */
+  data[0] = state;
+  data[1] = None;
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom_WM_STATE,
+                   window->display->atom_WM_STATE,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+static void
+set_net_wm_state (MetaWindow *window)
+{
+  int i;
+  unsigned long data[12];
+
+  i = 0;
+  if (window->shaded)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_SHADED;
+      ++i;
+    }
+  if (window->wm_state_modal)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_MODAL;
+      ++i;
+    }
+  if (window->skip_pager)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_SKIP_PAGER;
+      ++i;
+    }
+  if (window->skip_taskbar)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_SKIP_TASKBAR;
+      ++i;
+    }
+  if (window->maximized_horizontally)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_HORZ;
+      ++i;
+    }
+  if (window->maximized_vertically)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_VERT;
+      ++i;
+    }
+  if (window->fullscreen)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_FULLSCREEN;
+      ++i;
+    }
+  if (!meta_window_showing_on_its_workspace (window) || window->shaded)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_HIDDEN;
+      ++i;
+    }
+  if (window->wm_state_above)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_ABOVE;
+      ++i;
+    }
+  if (window->wm_state_below)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_BELOW;
+      ++i;
+    }
+  if (window->wm_state_demands_attention)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_DEMANDS_ATTENTION;
+      ++i;
+    }
+  if (window->on_all_workspaces)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_STICKY;
+      ++i;
+    }
+
+  meta_verbose ("Setting _NET_WM_STATE with %d atoms\n", i);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_WM_STATE,
+                   XA_ATOM,
+                   32, PropModeReplace, (guchar*) data, i);
+  meta_error_trap_pop (window->display, FALSE);
+
+  if (window->fullscreen)
+    {
+      data[0] = window->fullscreen_monitors[0];
+      data[1] = window->fullscreen_monitors[1];
+      data[2] = window->fullscreen_monitors[2];
+      data[3] = window->fullscreen_monitors[3];
+
+      meta_verbose ("Setting _NET_WM_FULLSCREEN_MONITORS\n");
+      meta_error_trap_push (window->display);
+      XChangeProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_FULLSCREEN_MONITORS,
+                       XA_CARDINAL, 32, PropModeReplace,
+                       (guchar*) data, 4);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+}
+
+gboolean
+meta_window_located_on_workspace (MetaWindow    *window,
+                                  MetaWorkspace *workspace)
+{
+  return (window->on_all_workspaces && window->screen == workspace->screen) ||
+    (window->workspace == workspace);
+}
+
+static gboolean
+is_minimized_foreach (MetaWindow *window,
+                      void       *data)
+{
+  gboolean *result = data;
+
+  *result = window->minimized;
+  if (*result)
+    return FALSE; /* stop as soon as we find one */
+  else
+    return TRUE;
+}
+
+static gboolean
+ancestor_is_minimized (MetaWindow *window)
+{
+  gboolean is_minimized;
+
+  is_minimized = FALSE;
+
+  meta_window_foreach_ancestor (window, is_minimized_foreach, &is_minimized);
+
+  return is_minimized;
+}
+
+gboolean
+meta_window_showing_on_its_workspace (MetaWindow *window)
+{
+  gboolean showing;
+  gboolean is_desktop_or_dock;
+  MetaWorkspace* workspace_of_window;
+
+  showing = TRUE;
+
+  /* 1. See if we're minimized */
+  if (window->minimized)
+    showing = FALSE;
+
+  /* 2. See if we're in "show desktop" mode */
+  is_desktop_or_dock = FALSE;
+  is_desktop_or_dock_foreach (window,
+                              &is_desktop_or_dock);
+
+  meta_window_foreach_ancestor (window, is_desktop_or_dock_foreach,
+                                &is_desktop_or_dock);
+
+  if (window->on_all_workspaces)
+    workspace_of_window = window->screen->active_workspace;
+  else if (window->workspace)
+    workspace_of_window = window->workspace;
+  else /* This only seems to be needed for startup */
+    workspace_of_window = NULL;
+
+  if (showing &&
+      workspace_of_window && workspace_of_window->showing_desktop &&
+      !is_desktop_or_dock)
+    {
+      meta_verbose ("We're showing the desktop on the workspace(s) that window %s is on\n",
+                    window->desc);
+      showing = FALSE;
+    }
+
+  /* 3. See if an ancestor is minimized (note that
+   *    ancestor's "mapped" field may not be up to date
+   *    since it's being computed in this same idle queue)
+   */
+
+  if (showing)
+    {
+      if (ancestor_is_minimized (window))
+        showing = FALSE;
+    }
+
+#if 0
+  /* 4. See if we're drawing wireframe
+   */
+  if (window->display->grab_window == window &&
+      window->display->grab_wireframe_active)
+    showing = FALSE;
+#endif
+
+  return showing;
+}
+
+gboolean
+meta_window_should_be_showing (MetaWindow  *window)
+{
+  gboolean on_workspace;
+
+  meta_verbose ("Should be showing for window %s\n", window->desc);
+
+  /* See if we're on the workspace */
+  on_workspace = meta_window_located_on_workspace (window,
+                                                   window->screen->active_workspace);
+
+  if (!on_workspace)
+    meta_verbose ("Window %s is not on workspace %d\n",
+                  window->desc,
+                  meta_workspace_index (window->screen->active_workspace));
+  else
+    meta_verbose ("Window %s is on the active workspace %d\n",
+                  window->desc,
+                  meta_workspace_index (window->screen->active_workspace));
+
+  if (window->on_all_workspaces)
+    meta_verbose ("Window %s is on all workspaces\n", window->desc);
+
+  return on_workspace && meta_window_showing_on_its_workspace (window);
+}
+
+static void
+finish_minimize (gpointer data)
+{
+  MetaWindow *window = data;
+  /* FIXME: It really sucks to put timestamp pinging here; it'd
+   * probably make more sense in implement_showing() so that it's at
+   * least not duplicated in meta_window_show; but since
+   * finish_minimize is a callback making things just slightly icky, I
+   * haven't done that yet.
+   */
+  guint32 timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+  meta_window_hide (window);
+  if (window->has_focus)
+    {
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
+}
+
+static void
+implement_showing (MetaWindow *window,
+                   gboolean    showing)
+{
+  /* Actually show/hide the window */
+  meta_verbose ("Implement showing = %d for window %s\n",
+                showing, window->desc);
+
+  if (!showing)
+    {
+      gboolean on_workspace;
+
+      on_workspace = meta_window_located_on_workspace (window,
+                                                       window->screen->active_workspace);
+
+      /* Really this effects code should probably
+       * be in meta_window_hide so the window->mapped
+       * test isn't duplicated here. Anyhow, we animate
+       * if we are mapped now, we are supposed to
+       * be minimized, and we are on the current workspace.
+       */
+      if (on_workspace && window->minimized && window->mapped &&
+          !meta_prefs_get_reduced_resources ())
+        {
+          MetaRectangle icon_rect, window_rect;
+          gboolean result;
+
+          /* Check if the window has an icon geometry */
+          result = meta_window_get_icon_geometry (window, &icon_rect);
+
+          if (!result)
+            {
+              /* just animate into the corner somehow - maybe
+               * not a good idea...
+               */
+              icon_rect.x = window->screen->rect.width;
+              icon_rect.y = window->screen->rect.height;
+              icon_rect.width = 1;
+              icon_rect.height = 1;
+            }
+
+          meta_window_get_outer_rect (window, &window_rect);
+
+          meta_effect_run_minimize (window,
+                                    &window_rect,
+                                    &icon_rect,
+                                    finish_minimize,
+                                    window);
+        }
+      else
+        {
+          finish_minimize (window);
+        }
+    }
+  else
+    {
+      meta_window_show (window);
+    }
+}
+
+void
+meta_window_calc_showing (MetaWindow  *window)
+{
+  implement_showing (window, meta_window_should_be_showing (window));
+}
+
+static guint queue_idle[NUMBER_OF_QUEUES] = {0, 0, 0};
+static GSList *queue_pending[NUMBER_OF_QUEUES] = {NULL, NULL, NULL};
+
+static int
+stackcmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+
+  if (aw->screen != bw->screen)
+    return 0; /* don't care how they sort with respect to each other */
+  else
+    return meta_stack_windows_cmp (aw->screen->stack,
+                                   aw, bw);
+}
+
+static gboolean
+idle_calc_showing (gpointer data)
+{
+  GSList *tmp;
+  GSList *copy;
+  GSList *should_show;
+  GSList *should_hide;
+  GSList *unplaced;
+  GSList *displays;
+  MetaWindow *first_window;
+  guint queue_index = GPOINTER_TO_INT (data);
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Clearing the calc_showing queue\n");
+
+  /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+   * complete; destroying a window while we're in here would result in
+   * badness. But it's OK to queue/unqueue calc_showings.
+   */
+  copy = g_slist_copy (queue_pending[queue_index]);
+  g_slist_free (queue_pending[queue_index]);
+  queue_pending[queue_index] = NULL;
+  queue_idle[queue_index] = 0;
+
+  destroying_windows_disallowed += 1;
+
+  /* We map windows from top to bottom and unmap from bottom to
+   * top, to avoid extra expose events. The exception is
+   * for unplaced windows, which have to be mapped from bottom to
+   * top so placement works.
+   */
+  should_show = NULL;
+  should_hide = NULL;
+  unplaced = NULL;
+  displays = NULL;
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      if (!window->placed)
+        unplaced = g_slist_prepend (unplaced, window);
+      else if (meta_window_should_be_showing (window))
+        should_show = g_slist_prepend (should_show, window);
+      else
+        should_hide = g_slist_prepend (should_hide, window);
+
+      tmp = tmp->next;
+    }
+
+  /* bottom to top */
+  unplaced = g_slist_sort (unplaced, stackcmp);
+  should_hide = g_slist_sort (should_hide, stackcmp);
+  /* top to bottom */
+  should_show = g_slist_sort (should_show, stackcmp);
+  should_show = g_slist_reverse (should_show);
+
+  first_window = copy->data;
+
+  meta_display_grab (first_window->display);
+
+  tmp = unplaced;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      meta_window_calc_showing (window);
+
+      tmp = tmp->next;
+    }
+
+  tmp = should_show;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      implement_showing (window, TRUE);
+
+      tmp = tmp->next;
+    }
+
+  tmp = should_hide;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      implement_showing (window, FALSE);
+
+      tmp = tmp->next;
+    }
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      /* important to set this here for reentrancy -
+       * if we queue a window again while it's in "copy",
+       * then queue_calc_showing will just return since
+       * we are still in the calc_showing queue
+       */
+      window->is_in_queues &= ~META_QUEUE_CALC_SHOWING;
+
+      tmp = tmp->next;
+    }
+
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK)
+    {
+      /* When display->mouse_mode is false, we want to ignore
+       * EnterNotify events unless they come from mouse motion.  To do
+       * that, we set a sentinel property on the root window if we're
+       * not in mouse_mode.
+       */
+      tmp = should_show;
+      while (tmp != NULL)
+        {
+          MetaWindow *window = tmp->data;
+
+          if (!window->display->mouse_mode)
+            meta_display_increment_focus_sentinel (window->display);
+
+          tmp = tmp->next;
+        }
+    }
+
+  meta_display_ungrab (first_window->display);
+
+  g_slist_free (copy);
+
+  g_slist_free (unplaced);
+  g_slist_free (should_show);
+  g_slist_free (should_hide);
+  g_slist_free (displays);
+
+  destroying_windows_disallowed -= 1;
+
+  return FALSE;
+}
+
+#ifdef WITH_VERBOSE_MODE
+static const gchar* meta_window_queue_names[NUMBER_OF_QUEUES] =
+  {"calc_showing", "move_resize", "update_icon"};
+#endif
+
+static void
+meta_window_unqueue (MetaWindow *window, guint queuebits)
+{
+  gint queuenum;
+
+  for (queuenum=0; queuenum<NUMBER_OF_QUEUES; queuenum++)
+    {
+      if ((queuebits & 1<<queuenum) /* they have asked to unqueue */
+          &&
+          (window->is_in_queues & 1<<queuenum)) /* it's in the queue */
+        {
+
+          meta_topic (META_DEBUG_WINDOW_STATE,
+              "Removing %s from the %s queue\n",
+              window->desc,
+              meta_window_queue_names[queuenum]);
+
+          /* Note that window may not actually be in the queue
+           * because it may have been in "copy" inside the idle handler
+           */
+          queue_pending[queuenum] = g_slist_remove (queue_pending[queuenum], window);
+          window->is_in_queues &= ~(1<<queuenum);
+
+          /* Okay, so maybe we've used up all the entries in the queue.
+           * In that case, we should kill the function that deals with
+           * the queue, because there's nothing left for it to do.
+           */
+          if (queue_pending[queuenum] == NULL && queue_idle[queuenum] != 0)
+            {
+              g_source_remove (queue_idle[queuenum]);
+              queue_idle[queuenum] = 0;
+            }
+        }
+    }
+}
+
+static void
+meta_window_flush_calc_showing (MetaWindow *window)
+{
+  if (window->is_in_queues & META_QUEUE_CALC_SHOWING)
+    {
+      meta_window_unqueue (window, META_QUEUE_CALC_SHOWING);
+      meta_window_calc_showing (window);
+    }
+}
+
+void
+meta_window_queue (MetaWindow *window, guint queuebits)
+{
+  guint queuenum;
+
+  for (queuenum=0; queuenum<NUMBER_OF_QUEUES; queuenum++)
+    {
+      if (queuebits & 1<<queuenum)
+        {
+          /* Data which varies between queues.
+           * Yes, these do look a lot like associative arrays:
+           * I seem to be turning into a Perl programmer.
+           */
+
+          const gint window_queue_idle_priority[NUMBER_OF_QUEUES] =
+            {
+              G_PRIORITY_DEFAULT_IDLE,  /* CALC_SHOWING */
+              META_PRIORITY_RESIZE,     /* MOVE_RESIZE */
+              G_PRIORITY_DEFAULT_IDLE   /* UPDATE_ICON */
+            };
+
+          const GSourceFunc window_queue_idle_handler[NUMBER_OF_QUEUES] =
+            {
+              idle_calc_showing,
+              idle_move_resize,
+              idle_update_icon,
+            };
+
+          /* If we're about to drop the window, there's no point in putting
+           * it on a queue.
+           */
+          if (window->unmanaging)
+            break;
+
+          /* If the window already claims to be in that queue, there's no
+           * point putting it in the queue.
+           */
+          if (window->is_in_queues & 1<<queuenum)
+            break;
+
+          meta_topic (META_DEBUG_WINDOW_STATE,
+              "Putting %s in the %s queue\n",
+              window->desc,
+              meta_window_queue_names[queuenum]);
+
+          /* So, mark it as being in this queue. */
+          window->is_in_queues |= 1<<queuenum;
+
+          /* There's not a lot of point putting things into a queue if
+           * nobody's on the other end pulling them out. Therefore,
+           * let's check to see whether an idle handler exists to do
+           * that. If not, we'll create one.
+           */
+
+          if (queue_idle[queuenum] == 0)
+            queue_idle[queuenum] = g_idle_add_full
+              (
+                window_queue_idle_priority[queuenum],
+                window_queue_idle_handler[queuenum],
+                GUINT_TO_POINTER(queuenum),
+                NULL
+              );
+
+          /* And now we actually put it on the queue. */
+          queue_pending[queuenum] = g_slist_prepend (queue_pending[queuenum],
+                                                     window);
+      }
+  }
+}
+
+static gboolean
+intervening_user_event_occurred (MetaWindow *window)
+{
+  guint32 compare;
+  MetaWindow *focus_window;
+
+  focus_window = window->display->focus_window;
+
+  meta_topic (META_DEBUG_STARTUP,
+              "COMPARISON:\n"
+              "  net_wm_user_time_set : %d\n"
+              "  net_wm_user_time     : %u\n"
+              "  initial_timestamp_set: %d\n"
+              "  initial_timestamp    : %u\n",
+              window->net_wm_user_time_set,
+              window->net_wm_user_time,
+              window->initial_timestamp_set,
+              window->initial_timestamp);
+  if (focus_window != NULL)
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "COMPARISON (continued):\n"
+                  "  focus_window             : %s\n"
+                  "  fw->net_wm_user_time_set : %d\n"
+                  "  fw->net_wm_user_time     : %u\n",
+                  focus_window->desc,
+                  focus_window->net_wm_user_time_set,
+                  focus_window->net_wm_user_time);
+    }
+
+  /* We expect the most common case for not focusing a new window
+   * to be when a hint to not focus it has been set.  Since we can
+   * deal with that case rapidly, we use special case it--this is
+   * merely a preliminary optimization.  :)
+   */
+  if ( ((window->net_wm_user_time_set == TRUE) &&
+       (window->net_wm_user_time == 0))
+      ||
+       ((window->initial_timestamp_set == TRUE) &&
+       (window->initial_timestamp == 0)))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "window %s explicitly requested no focus\n",
+                  window->desc);
+      return TRUE;
+    }
+
+  if (!(window->net_wm_user_time_set) && !(window->initial_timestamp_set))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "no information about window %s found\n",
+                  window->desc);
+      return FALSE;
+    }
+
+  if (focus_window != NULL &&
+      !focus_window->net_wm_user_time_set)
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "focus window, %s, doesn't have a user time set yet!\n",
+                  window->desc);
+      return FALSE;
+    }
+
+  /* To determine the "launch" time of an application,
+   * startup-notification can set the TIMESTAMP and the
+   * application (usually via its toolkit such as gtk or qt) can
+   * set the _NET_WM_USER_TIME.  If both are set, we need to be
+   * using the newer of the two values.
+   *
+   * See http://bugzilla.gnome.org/show_bug.cgi?id=573922
+   */
+  compare = 0;
+  if (window->net_wm_user_time_set &&
+      window->initial_timestamp_set)
+    compare =
+      XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
+                              window->initial_timestamp) ?
+      window->initial_timestamp : window->net_wm_user_time;
+  else if (window->net_wm_user_time_set)
+    compare = window->net_wm_user_time;
+  else if (window->initial_timestamp_set)
+    compare = window->initial_timestamp;
+
+  if ((focus_window != NULL) &&
+      XSERVER_TIME_IS_BEFORE (compare, focus_window->net_wm_user_time))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "window %s focus prevented by other activity; %u < %u\n",
+                  window->desc,
+                  compare,
+                  focus_window->net_wm_user_time);
+      return TRUE;
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "new window %s with no intervening events\n",
+                  window->desc);
+      return FALSE;
+    }
+}
+
+/* This function is an ugly hack.  It's experimental in nature and ought to be
+ * replaced by a real hint from the app to the WM if we decide the experimental
+ * behavior is worthwhile.  The basic idea is to get more feedback about how
+ * usage scenarios of "strict" focus users and what they expect.  See #326159.
+ */
+gboolean
+__window_is_terminal (MetaWindow *window)
+{
+  if (window == NULL || window->res_class == NULL)
+    return FALSE;
+
+  /*
+   * Compare res_class, which is not user-settable, and thus theoretically
+   * a more-reliable indication of term-ness.
+   */
+
+  /* mate-terminal -- if you couldn't guess */
+  if (strcmp (window->res_class, "Mate-terminal") == 0)
+    return TRUE;
+  /* xterm, rxvt, aterm */
+  else if (strcmp (window->res_class, "XTerm") == 0)
+    return TRUE;
+  /* konsole, KDE's terminal program */
+  else if (strcmp (window->res_class, "Konsole") == 0)
+    return TRUE;
+  /* rxvt-unicode */
+  else if (strcmp (window->res_class, "URxvt") == 0)
+    return TRUE;
+  /* eterm */
+  else if (strcmp (window->res_class, "Eterm") == 0)
+    return TRUE;
+  /* KTerm -- some terminal not KDE based; so not like Konsole */
+  else if (strcmp (window->res_class, "KTerm") == 0)
+    return TRUE;
+  /* Multi-mate-terminal */
+  else if (strcmp (window->res_class, "Multi-mate-terminal") == 0)
+    return TRUE;
+  /* mlterm ("multi lingual terminal emulator on X") */
+  else if (strcmp (window->res_class, "mlterm") == 0)
+    return TRUE;
+  /* Terminal -- XFCE Terminal */
+  else if (strcmp (window->res_class, "Terminal") == 0)
+    return TRUE;
+
+  return FALSE;
+}
+
+/* This function determines what state the window should have assuming that it
+ * and the focus_window have no relation
+ */
+static void
+window_state_on_map (MetaWindow *window,
+                     gboolean *takes_focus,
+                     gboolean *places_on_top)
+{
+  gboolean intervening_events;
+
+  intervening_events = intervening_user_event_occurred (window);
+
+  *takes_focus = !intervening_events;
+  *places_on_top = *takes_focus;
+
+  /* don't initially focus windows that are intended to not accept
+   * focus
+   */
+  if (!(window->input || window->take_focus))
+    {
+      *takes_focus = FALSE;
+      return;
+    }
+
+  /* Terminal usage may be different; some users intend to launch
+   * many apps in quick succession or to just view things in the new
+   * window while still interacting with the terminal.  In that case,
+   * apps launched from the terminal should not take focus.  This
+   * isn't quite the same as not allowing focus to transfer from
+   * terminals due to new window map, but the latter is a much easier
+   * approximation to enforce so we do that.
+   */
+  if (*takes_focus &&
+      meta_prefs_get_focus_new_windows () == META_FOCUS_NEW_WINDOWS_STRICT &&
+      !window->display->allow_terminal_deactivation &&
+      __window_is_terminal (window->display->focus_window) &&
+      !meta_window_is_ancestor_of_transient (window->display->focus_window,
+                                             window))
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "focus_window is terminal; not focusing new window.\n");
+      *takes_focus = FALSE;
+      *places_on_top = FALSE;
+    }
+
+  switch (window->type)
+    {
+    case META_WINDOW_UTILITY:
+    case META_WINDOW_TOOLBAR:
+      *takes_focus = FALSE;
+      *places_on_top = FALSE;
+      break;
+    case META_WINDOW_DOCK:
+    case META_WINDOW_DESKTOP:
+    case META_WINDOW_SPLASHSCREEN:
+    case META_WINDOW_MENU:
+      /* don't focus any of these; places_on_top may be irrelevant for some of
+       * these (e.g. dock)--but you never know--the focus window might also be
+       * of the same type in some weird situation...
+       */
+      *takes_focus = FALSE;
+      break;
+    case META_WINDOW_NORMAL:
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+      /* The default is correct for these */
+      break;
+    }
+}
+
+static gboolean
+windows_overlap (const MetaWindow *w1, const MetaWindow *w2)
+{
+  MetaRectangle w1rect, w2rect;
+  meta_window_get_outer_rect (w1, &w1rect);
+  meta_window_get_outer_rect (w2, &w2rect);
+  return meta_rectangle_overlap (&w1rect, &w2rect);
+}
+
+/* Returns whether a new window would be covered by any
+ * existing window on the same workspace that is set
+ * to be "above" ("always on top").  A window that is not
+ * set "above" would be underneath the new window anyway.
+ *
+ * We take "covered" to mean even partially covered, but
+ * some people might prefer entirely covered.  I think it
+ * is more useful to behave this way if any part of the
+ * window is covered, because a partial coverage could be
+ * (say) ninety per cent and almost indistinguishable from total.
+ */
+static gboolean
+window_would_be_covered (const MetaWindow *newbie)
+{
+  MetaWorkspace *workspace = newbie->workspace;
+  GList *tmp, *windows;
+
+  windows = meta_workspace_list_windows (workspace);
+
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (w->wm_state_above && w != newbie)
+        {
+          /* We have found a window that is "above". Perhaps it overlaps. */
+          if (windows_overlap (w, newbie))
+            {
+              g_list_free (windows); /* clean up... */
+              return TRUE; /* yes, it does */
+            }
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_list_free (windows);
+  return FALSE; /* none found */
+}
+
+/* XXX META_EFFECT_*_MAP */
+void
+meta_window_show (MetaWindow *window)
+{
+  gboolean did_show;
+  gboolean takes_focus_on_map;
+  gboolean place_on_top_on_map;
+  gboolean needs_stacking_adjustment;
+  MetaWindow *focus_window;
+  guint32     timestamp;
+
+  /* FIXME: It really sucks to put timestamp pinging here; it'd
+   * probably make more sense in implement_showing() so that it's at
+   * least not duplicated in finish_minimize.  *shrug*
+   */
+  timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Showing window %s, shaded: %d iconic: %d placed: %d\n",
+              window->desc, window->shaded, window->iconic, window->placed);
+
+  focus_window = window->display->focus_window;  /* May be NULL! */
+  did_show = FALSE;
+  window_state_on_map (window, &takes_focus_on_map, &place_on_top_on_map);
+  needs_stacking_adjustment = FALSE;
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Window %s %s focus on map, and %s place on top on map.\n",
+              window->desc,
+              takes_focus_on_map ? "does" : "does not",
+              place_on_top_on_map ? "does" : "does not");
+
+  /* Now, in some rare cases we should *not* put a new window on top.
+   * These cases include certain types of windows showing for the first
+   * time, and any window which would be covered because of another window
+   * being set "above" ("always on top").
+   *
+   * FIXME: Although "place_on_top_on_map" and "takes_focus_on_map" are
+   * generally based on the window type, there is a special case when the
+   * focus window is a terminal for them both to be false; this should
+   * probably rather be a term in the "if" condition below.
+   */
+
+  if ( focus_window != NULL && window->showing_for_first_time &&
+      ( (!place_on_top_on_map && !takes_focus_on_map) ||
+      window_would_be_covered (window) )
+    ) {
+      if (meta_window_is_ancestor_of_transient (focus_window, window))
+        {
+          /* This happens for error dialogs or alerts; these need to remain on
+           * top, but it would be confusing to have its ancestor remain
+           * focused.
+           */
+          meta_topic (META_DEBUG_STARTUP,
+                      "The focus window %s is an ancestor of the newly mapped "
+                      "window %s which isn't being focused.  Unfocusing the "
+                      "ancestor.\n",
+                      focus_window->desc, window->desc);
+
+          meta_display_focus_the_no_focus_window (window->display,
+                                                  window->screen,
+                                                  timestamp);
+        }
+      else
+        {
+          needs_stacking_adjustment = TRUE;
+          if (!window->placed)
+            window->denied_focus_and_not_transient = TRUE;
+        }
+    }
+
+  if (!window->placed)
+    {
+      /* We have to recalc the placement here since other windows may
+       * have been mapped/placed since we last did constrain_position
+       */
+
+      /* calc_placement is an efficiency hack to avoid
+       * multiple placement calculations before we finally
+       * show the window.
+       */
+      window->calc_placement = TRUE;
+      meta_window_move_resize_now (window);
+      window->calc_placement = FALSE;
+
+      /* don't ever do the initial position constraint thing again.
+       * This is toggled here so that initially-iconified windows
+       * still get placed when they are ultimately shown.
+       */
+      window->placed = TRUE;
+
+      /* Don't want to accidentally reuse the fact that we had been denied
+       * focus in any future constraints unless we're denied focus again.
+       */
+      window->denied_focus_and_not_transient = FALSE;
+    }
+
+  if (needs_stacking_adjustment)
+    {
+      gboolean overlap;
+
+      /* This window isn't getting focus on map.  We may need to do some
+       * special handing with it in regards to
+       *   - the stacking of the window
+       *   - the MRU position of the window
+       *   - the demands attention setting of the window
+       *
+       * Firstly, set the flag so we don't give the window focus anyway
+       * and confuse people.
+       */
+
+      takes_focus_on_map = FALSE;
+
+      overlap = windows_overlap (window, focus_window);
+
+      /* We want alt tab to go to the denied-focus window */
+      ensure_mru_position_after (window, focus_window);
+
+      /* We don't want the denied-focus window to obscure the focus
+       * window, and if we're in both click-to-focus mode and
+       * raise-on-click mode then we want to maintain the invariant
+       * that MRU order == stacking order.  The need for this if
+       * comes from the fact that in sloppy/mouse focus the focus
+       * window may not overlap other windows and also can be
+       * considered "below" them; this combination means that
+       * placing the denied-focus window "below" the focus window
+       * in the stack when it doesn't overlap it confusingly places
+       * that new window below a lot of other windows.
+       */
+      if (overlap ||
+          (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+           meta_prefs_get_raise_on_click ()))
+        meta_window_stack_just_below (window, focus_window);
+
+      /* If the window will be obscured by the focus window, then the
+       * user might not notice the window appearing so set the
+       * demands attention hint.
+       *
+       * We set the hint ourselves rather than calling
+       * meta_window_set_demands_attention() because that would cause
+       * a recalculation of overlap, and a call to set_net_wm_state()
+       * which we are going to call ourselves here a few lines down.
+       */
+      if (overlap)
+        window->wm_state_demands_attention = TRUE;
+    }
+
+  /* Shaded means the frame is mapped but the window is not */
+
+  if (window->frame && !window->frame->mapped)
+    {
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Frame actually needs map\n");
+      window->frame->mapped = TRUE;
+      meta_ui_map_frame (window->screen->ui, window->frame->xwindow);
+      did_show = TRUE;
+    }
+
+  if (window->shaded)
+    {
+      if (window->mapped)
+        {
+          meta_topic (META_DEBUG_WINDOW_STATE,
+                      "%s actually needs unmap (shaded)\n", window->desc);
+          meta_topic (META_DEBUG_WINDOW_STATE,
+                      "Incrementing unmaps_pending on %s for shade\n",
+                      window->desc);
+          window->mapped = FALSE;
+          window->unmaps_pending += 1;
+          meta_error_trap_push (window->display);
+          XUnmapWindow (window->display->xdisplay, window->xwindow);
+          meta_error_trap_pop (window->display, FALSE);
+        }
+
+      if (!window->iconic)
+        {
+          window->iconic = TRUE;
+          set_wm_state (window, IconicState);
+        }
+    }
+  else
+    {
+      if (!window->mapped)
+        {
+          meta_topic (META_DEBUG_WINDOW_STATE,
+                      "%s actually needs map\n", window->desc);
+          window->mapped = TRUE;
+          meta_error_trap_push (window->display);
+          XMapWindow (window->display->xdisplay, window->xwindow);
+          meta_error_trap_pop (window->display, FALSE);
+          did_show = TRUE;
+
+          if (window->was_minimized)
+            {
+              MetaRectangle window_rect;
+              MetaRectangle icon_rect;
+
+              window->was_minimized = FALSE;
+
+              if (meta_window_get_icon_geometry (window, &icon_rect))
+                {
+                  meta_window_get_outer_rect (window, &window_rect);
+
+                  meta_effect_run_unminimize (window,
+                                              &window_rect,
+                                              &icon_rect,
+                                              NULL, NULL);
+                }
+            }
+        }
+
+      if (window->iconic)
+        {
+          window->iconic = FALSE;
+          set_wm_state (window, NormalState);
+        }
+    }
+
+  /* We don't want to worry about all cases from inside
+   * implement_showing(); we only want to worry about focus if this
+   * window has not been shown before.
+   */
+  if (window->showing_for_first_time)
+    {
+      window->showing_for_first_time = FALSE;
+      if (takes_focus_on_map)
+        {
+          meta_window_focus (window, timestamp);
+        }
+      else
+        {
+          /* Prevent EnterNotify events in sloppy/mouse focus from
+           * erroneously focusing the window that had been denied
+           * focus.  FIXME: This introduces a race; I have a couple
+           * ideas for a better way to accomplish the same thing, but
+           * they're more involved so do it this way for now.
+           */
+          meta_display_increment_focus_sentinel (window->display);
+        }
+    }
+
+  set_net_wm_state (window);
+
+  if (did_show && window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Mapped window %s with struts, so invalidating work areas\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+
+  /*
+   * Now that we have shown the window, we no longer want to consider the
+   * initial timestamp in any subsequent deliberations whether to focus this
+   * window or not, so clear the flag.
+   *
+   * See http://bugzilla.gnome.org/show_bug.cgi?id=573922
+   */
+  window->initial_timestamp_set = FALSE;
+}
+
+/* XXX META_EFFECT_*_UNMAP */
+static void
+meta_window_hide (MetaWindow *window)
+{
+  gboolean did_hide;
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Hiding window %s\n", window->desc);
+
+  did_hide = FALSE;
+
+  if (window->frame && window->frame->mapped)
+    {
+      meta_topic (META_DEBUG_WINDOW_STATE, "Frame actually needs unmap\n");
+      window->frame->mapped = FALSE;
+      meta_ui_unmap_frame (window->screen->ui, window->frame->xwindow);
+      did_hide = TRUE;
+    }
+
+  if (window->mapped)
+    {
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "%s actually needs unmap\n", window->desc);
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Incrementing unmaps_pending on %s for hide\n",
+                  window->desc);
+      window->mapped = FALSE;
+      window->unmaps_pending += 1;
+      meta_error_trap_push (window->display);
+      XUnmapWindow (window->display->xdisplay, window->xwindow);
+      meta_error_trap_pop (window->display, FALSE);
+      did_hide = TRUE;
+    }
+
+  if (!window->iconic)
+    {
+      window->iconic = TRUE;
+      set_wm_state (window, IconicState);
+    }
+
+  set_net_wm_state (window);
+
+  if (did_hide && window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Unmapped window %s with struts, so invalidating work areas\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+}
+
+static gboolean
+queue_calc_showing_func (MetaWindow *window,
+                         void       *data)
+{
+  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+  return TRUE;
+}
+
+void
+meta_window_minimize (MetaWindow  *window)
+{
+  if (!window->minimized)
+    {
+      window->minimized = TRUE;
+      meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+
+      meta_window_foreach_transient (window,
+                                     queue_calc_showing_func,
+                                     NULL);
+
+      if (window->has_focus)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focusing default window due to minimization of focus window %s\n",
+                      window->desc);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Minimizing window %s which doesn't have the focus\n",
+                      window->desc);
+        }
+    }
+}
+
+void
+meta_window_unminimize (MetaWindow  *window)
+{
+  if (window->minimized)
+    {
+      window->minimized = FALSE;
+      window->was_minimized = TRUE;
+      meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+
+      meta_window_foreach_transient (window,
+                                     queue_calc_showing_func,
+                                     NULL);
+    }
+}
+
+static void
+ensure_size_hints_satisfied (MetaRectangle    *rect,
+                             const XSizeHints *size_hints)
+{
+  int minw, minh, maxw, maxh;   /* min/max width/height                      */
+  int basew, baseh, winc, hinc; /* base width/height, width/height increment */
+  int extra_width, extra_height;
+
+  minw  = size_hints->min_width;  minh  = size_hints->min_height;
+  maxw  = size_hints->max_width;  maxh  = size_hints->max_height;
+  basew = size_hints->base_width; baseh = size_hints->base_height;
+  winc  = size_hints->width_inc;  hinc  = size_hints->height_inc;
+
+  /* First, enforce min/max size constraints */
+  rect->width  = CLAMP (rect->width,  minw, maxw);
+  rect->height = CLAMP (rect->height, minh, maxh);
+
+  /* Now, verify size increment constraints are satisfied, or make them be */
+  extra_width  = (rect->width  - basew) % winc;
+  extra_height = (rect->height - baseh) % hinc;
+
+  rect->width  -= extra_width;
+  rect->height -= extra_height;
+
+  /* Adjusting width/height down, as done above, may violate minimum size
+   * constraints, so one last fix.
+   */
+  if (rect->width  < minw)
+    rect->width  += ((minw - rect->width)/winc  + 1)*winc;
+  if (rect->height < minh)
+    rect->height += ((minh - rect->height)/hinc + 1)*hinc;
+}
+
+static void
+meta_window_save_rect (MetaWindow *window)
+{
+  if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
+    {
+      /* save size/pos as appropriate args for move_resize */
+      if (!window->maximized_horizontally)
+        {
+          window->saved_rect.x      = window->rect.x;
+          window->saved_rect.width  = window->rect.width;
+          if (window->frame)
+            window->saved_rect.x   += window->frame->rect.x;
+        }
+      if (!window->maximized_vertically)
+        {
+          window->saved_rect.y      = window->rect.y;
+          window->saved_rect.height = window->rect.height;
+          if (window->frame)
+            window->saved_rect.y   += window->frame->rect.y;
+        }
+    }
+}
+
+/**
+ * Save the user_rect regardless of whether the window is maximized or
+ * fullscreen. See save_user_window_placement() for most uses.
+ *
+ * \param window  Store current position of this window for future reference
+ */
+static void
+force_save_user_window_placement (MetaWindow *window)
+{
+  meta_window_get_client_root_coords (window, &window->user_rect);
+}
+
+/**
+ * Save the user_rect, but only if the window is neither maximized nor
+ * fullscreen, otherwise the window may snap back to those dimensions
+ * (bug #461927).
+ *
+ * \param window  Store current position of this window for future reference
+ */
+static void
+save_user_window_placement (MetaWindow *window)
+{
+  if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
+    {
+      MetaRectangle user_rect;
+
+      meta_window_get_client_root_coords (window, &user_rect);
+
+      if (!window->maximized_horizontally)
+	{
+	  window->user_rect.x     = user_rect.x;
+	  window->user_rect.width = user_rect.width;
+	}
+      if (!window->maximized_vertically)
+	{
+	  window->user_rect.y      = user_rect.y;
+	  window->user_rect.height = user_rect.height;
+	}
+    }
+}
+
+void
+meta_window_maximize_internal (MetaWindow        *window,
+                               MetaMaximizeFlags  directions,
+                               MetaRectangle     *saved_rect)
+{
+  /* At least one of the two directions ought to be set */
+  gboolean maximize_horizontally, maximize_vertically;
+  maximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+  maximize_vertically   = directions & META_MAXIMIZE_VERTICAL;
+  g_assert (maximize_horizontally || maximize_vertically);
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Maximizing %s%s\n",
+              window->desc,
+              maximize_horizontally && maximize_vertically ? "" :
+                maximize_horizontally ? " horizontally" :
+                  maximize_vertically ? " vertically" : "BUGGGGG");
+
+  if (saved_rect != NULL)
+    window->saved_rect = *saved_rect;
+  else
+    meta_window_save_rect (window);
+
+  window->maximized_horizontally =
+    window->maximized_horizontally || maximize_horizontally;
+  window->maximized_vertically =
+    window->maximized_vertically   || maximize_vertically;
+  if (maximize_horizontally || maximize_vertically)
+    window->force_save_user_rect = FALSE;
+
+  /* Fix for #336850: If the frame shape isn't reapplied, it is
+   * possible that the frame will retains its rounded corners. That
+   * happens if the client's size when maximized equals the unmaximized
+   * size.
+   */
+  if (window->frame)
+    window->frame->need_reapply_frame_shape = TRUE;
+
+  recalc_window_features (window);
+  set_net_wm_state (window);
+}
+
+void
+meta_window_maximize (MetaWindow        *window,
+                      MetaMaximizeFlags  directions)
+{
+  /* At least one of the two directions ought to be set */
+  gboolean maximize_horizontally, maximize_vertically;
+  maximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+  maximize_vertically   = directions & META_MAXIMIZE_VERTICAL;
+  g_assert (maximize_horizontally || maximize_vertically);
+
+  /* Only do something if the window isn't already maximized in the
+   * given direction(s).
+   */
+  if ((maximize_horizontally && !window->maximized_horizontally) ||
+      (maximize_vertically   && !window->maximized_vertically))
+    {
+      if (window->shaded && maximize_vertically)
+        {
+          /* Shading sucks anyway; I'm not adding a timestamp argument
+           * to this function just for this niche usage & corner case.
+           */
+          guint32 timestamp =
+            meta_display_get_current_time_roundtrip (window->display);
+          meta_window_unshade (window, timestamp);
+        }
+
+      /* if the window hasn't been placed yet, we'll maximize it then
+       */
+      if (!window->placed)
+	{
+	  window->maximize_horizontally_after_placement =
+            window->maximize_horizontally_after_placement ||
+            maximize_horizontally;
+	  window->maximize_vertically_after_placement =
+            window->maximize_vertically_after_placement ||
+            maximize_vertically;
+	  return;
+	}
+
+      meta_window_maximize_internal (window,
+                                     directions,
+                                     NULL);
+
+      /* move_resize with new maximization constraints
+       */
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+static void
+unmaximize_window_before_freeing (MetaWindow        *window)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Unmaximizing %s just before freeing\n",
+              window->desc);
+
+  window->maximized_horizontally = FALSE;
+  window->maximized_vertically = FALSE;
+
+  if (window->withdrawn)                /* See bug #137185 */
+    {
+      window->rect = window->saved_rect;
+      set_net_wm_state (window);
+    }
+  else if (window->screen->closing)     /* See bug #358042 */
+    {
+      /* Do NOT update net_wm_state: this screen is closing,
+       * it likely will be managed by another window manager
+       * that will need the current _NET_WM_STATE atoms.
+       * Moreover, it will need to know the unmaximized geometry,
+       * therefore move_resize the window to saved_rect here
+       * before closing it. */
+      meta_window_move_resize (window,
+                               FALSE,
+                               window->saved_rect.x,
+                               window->saved_rect.y,
+                               window->saved_rect.width,
+                               window->saved_rect.height);
+    }
+}
+
+void
+meta_window_unmaximize (MetaWindow        *window,
+                        MetaMaximizeFlags  directions)
+{
+  /* At least one of the two directions ought to be set */
+  gboolean unmaximize_horizontally, unmaximize_vertically;
+  unmaximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+  unmaximize_vertically   = directions & META_MAXIMIZE_VERTICAL;
+  g_assert (unmaximize_horizontally || unmaximize_vertically);
+
+  /* Only do something if the window isn't already maximized in the
+   * given direction(s).
+   */
+  if ((unmaximize_horizontally && window->maximized_horizontally) ||
+      (unmaximize_vertically   && window->maximized_vertically))
+    {
+      MetaRectangle target_rect;
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Unmaximizing %s%s\n",
+                  window->desc,
+                  unmaximize_horizontally && unmaximize_vertically ? "" :
+                    unmaximize_horizontally ? " horizontally" :
+                      unmaximize_vertically ? " vertically" : "BUGGGGG");
+
+      window->maximized_horizontally =
+        window->maximized_horizontally && !unmaximize_horizontally;
+      window->maximized_vertically =
+        window->maximized_vertically   && !unmaximize_vertically;
+
+      /* Unmaximize to the saved_rect position in the direction(s)
+       * being unmaximized.
+       */
+      meta_window_get_client_root_coords (window, &target_rect);
+      if (unmaximize_horizontally)
+        {
+          target_rect.x     = window->saved_rect.x;
+          target_rect.width = window->saved_rect.width;
+        }
+      if (unmaximize_vertically)
+        {
+          target_rect.y      = window->saved_rect.y;
+          target_rect.height = window->saved_rect.height;
+        }
+
+      /* Window's size hints may have changed while maximized, making
+       * saved_rect invalid.  #329152
+       */
+      ensure_size_hints_satisfied (&target_rect, &window->size_hints);
+
+      /* When we unmaximize, if we're doing a mouse move also we could
+       * get the window suddenly jumping to the upper left corner of
+       * the workspace, since that's where it was when the grab op
+       * started.  So we need to update the grab state.
+       */
+      if (meta_grab_op_is_moving (window->display->grab_op) &&
+          window->display->grab_window == window)
+        {
+          window->display->grab_anchor_window_pos = target_rect;
+        }
+
+      meta_window_move_resize (window,
+                               FALSE,
+                               target_rect.x,
+                               target_rect.y,
+                               target_rect.width,
+                               target_rect.height);
+
+      /* Make sure user_rect is current.
+       */
+      force_save_user_window_placement (window);
+
+      if (window->display->grab_wireframe_active)
+        {
+          window->display->grab_wireframe_rect = target_rect;
+        }
+
+      recalc_window_features (window);
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_make_above (MetaWindow  *window)
+{
+  window->wm_state_above = TRUE;
+  meta_window_update_layer (window);
+  meta_window_raise (window);
+  set_net_wm_state (window);
+}
+
+void
+meta_window_unmake_above (MetaWindow  *window)
+{
+  window->wm_state_above = FALSE;
+  meta_window_raise (window);
+  meta_window_update_layer (window);
+  set_net_wm_state (window);
+}
+
+void
+meta_window_make_fullscreen_internal (MetaWindow  *window)
+{
+  if (!window->fullscreen)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Fullscreening %s\n", window->desc);
+
+      if (window->shaded)
+        {
+          /* Shading sucks anyway; I'm not adding a timestamp argument
+           * to this function just for this niche usage & corner case.
+           */
+          guint32 timestamp =
+            meta_display_get_current_time_roundtrip (window->display);
+          meta_window_unshade (window, timestamp);
+        }
+
+      meta_window_save_rect (window);
+
+      window->fullscreen = TRUE;
+      window->force_save_user_rect = FALSE;
+
+      meta_stack_freeze (window->screen->stack);
+      meta_window_update_layer (window);
+
+      meta_window_raise (window);
+      meta_stack_thaw (window->screen->stack);
+
+      recalc_window_features (window);
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_make_fullscreen (MetaWindow  *window)
+{
+  if (!window->fullscreen)
+    {
+      meta_window_make_fullscreen_internal (window);
+      /* move_resize with new constraints
+       */
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+void
+meta_window_unmake_fullscreen (MetaWindow  *window)
+{
+  if (window->fullscreen)
+    {
+      MetaRectangle target_rect;
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Unfullscreening %s\n", window->desc);
+
+      window->fullscreen = FALSE;
+      target_rect = window->saved_rect;
+
+      /* Window's size hints may have changed while maximized, making
+       * saved_rect invalid.  #329152
+       */
+      ensure_size_hints_satisfied (&target_rect, &window->size_hints);
+
+      meta_window_move_resize (window,
+                               FALSE,
+                               target_rect.x,
+                               target_rect.y,
+                               target_rect.width,
+                               target_rect.height);
+
+      /* Make sure user_rect is current.
+       */
+      force_save_user_window_placement (window);
+
+      meta_window_update_layer (window);
+
+      recalc_window_features (window);
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_update_fullscreen_monitors (MetaWindow    *window,
+                                        unsigned long  top,
+                                        unsigned long  bottom,
+                                        unsigned long  left,
+                                        unsigned long  right)
+{
+  if ((int)top < window->screen->n_xinerama_infos &&
+      (int)bottom < window->screen->n_xinerama_infos &&
+      (int)left < window->screen->n_xinerama_infos &&
+      (int)right < window->screen->n_xinerama_infos)
+    {
+      window->fullscreen_monitors[0] = top;
+      window->fullscreen_monitors[1] = bottom;
+      window->fullscreen_monitors[2] = left;
+      window->fullscreen_monitors[3] = right;
+    }
+  else
+    {
+      window->fullscreen_monitors[0] = -1;
+    }
+
+  if (window->fullscreen)
+    {
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+void
+meta_window_shade (MetaWindow  *window,
+                   guint32      timestamp)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Shading %s\n", window->desc);
+  if (!window->shaded)
+    {
+      window->shaded = TRUE;
+
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+
+      /* After queuing the calc showing, since _focus flushes it,
+       * and we need to focus the frame
+       */
+      meta_topic (META_DEBUG_FOCUS,
+                  "Re-focusing window %s after shading it\n",
+                  window->desc);
+      meta_window_focus (window, timestamp);
+
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_unshade (MetaWindow  *window,
+                     guint32      timestamp)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Unshading %s\n", window->desc);
+  if (window->shaded)
+    {
+      window->shaded = FALSE;
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+
+      /* focus the window */
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing window %s after unshading it\n",
+                  window->desc);
+      meta_window_focus (window, timestamp);
+
+      set_net_wm_state (window);
+    }
+}
+
+static gboolean
+unminimize_func (MetaWindow *window,
+                 void       *data)
+{
+  meta_window_unminimize (window);
+  return TRUE;
+}
+
+static void
+unminimize_window_and_all_transient_parents (MetaWindow *window)
+{
+  meta_window_unminimize (window);
+  meta_window_foreach_ancestor (window, unminimize_func, NULL);
+}
+
+static void
+window_activate (MetaWindow     *window,
+                 guint32         timestamp,
+                 MetaClientType  source_indication,
+                 MetaWorkspace  *workspace)
+{
+  gboolean can_ignore_outdated_timestamps;
+  meta_topic (META_DEBUG_FOCUS,
+              "_NET_ACTIVE_WINDOW message sent for %s at time %u "
+              "by client type %u.\n",
+              window->desc, timestamp, source_indication);
+
+  /* Older EWMH spec didn't specify a timestamp; we decide to honor these only
+   * if the app specifies that it is a pager.
+   *
+   * Update: Unconditionally honor 0 timestamps for now; we'll fight
+   * that battle later.  Just remove the "FALSE &&" in order to only
+   * honor 0 timestamps for pagers.
+   */
+  can_ignore_outdated_timestamps =
+    (timestamp != 0 || (FALSE && source_indication != META_CLIENT_TYPE_PAGER));
+  if (XSERVER_TIME_IS_BEFORE (timestamp, window->display->last_user_time) &&
+      can_ignore_outdated_timestamps)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "last_user_time (%u) is more recent; ignoring "
+                  " _NET_ACTIVE_WINDOW message.\n",
+                  window->display->last_user_time);
+      meta_window_set_demands_attention(window);
+      return;
+    }
+
+  /* For those stupid pagers, get a valid timestamp and show a warning */
+  if (timestamp == 0)
+    {
+      meta_warning ("meta_window_activate called by a pager with a 0 timestamp; "
+                    "the pager needs to be fixed.\n");
+      timestamp = meta_display_get_current_time_roundtrip (window->display);
+    }
+
+  meta_window_set_user_time (window, timestamp);
+
+  /* disable show desktop mode unless we're a desktop component */
+  maybe_leave_show_desktop_mode (window);
+
+  /* Get window on current or given workspace */
+  if (workspace == NULL)
+    workspace = window->screen->active_workspace;
+
+  /* For non-transient windows, we just set up a pulsing indicator,
+     rather than move windows or workspaces.
+     See http://bugzilla.gnome.org/show_bug.cgi?id=482354 */
+  if (window->xtransient_for == None &&
+      !meta_window_located_on_workspace (window, workspace))
+    {
+      meta_window_set_demands_attention (window);
+      /* We've marked it as demanding, don't need to do anything else. */
+      return;
+    }
+  else if (window->xtransient_for != None)
+    {
+      /* Move transients to current workspace - preference dialogs should appear over
+         the source window.  */
+      meta_window_change_workspace (window, workspace);
+    }
+
+  if (window->shaded)
+    meta_window_unshade (window, timestamp);
+
+  unminimize_window_and_all_transient_parents (window);
+
+  if (meta_prefs_get_raise_on_click () ||
+      source_indication == META_CLIENT_TYPE_PAGER)
+    meta_window_raise (window);
+
+  meta_topic (META_DEBUG_FOCUS,
+              "Focusing window %s due to activation\n",
+              window->desc);
+  meta_window_focus (window, timestamp);
+}
+
+/* This function exists since most of the functionality in window_activate
+ * is useful for Marco, but Marco shouldn't need to specify a client
+ * type for itself.  ;-)
+ */
+void
+meta_window_activate (MetaWindow     *window,
+                      guint32         timestamp)
+{
+  /* We're not really a pager, but the behavior we want is the same as if
+   * we were such.  If we change the pager behavior later, we could revisit
+   * this and just add extra flags to window_activate.
+   */
+  window_activate (window, timestamp, META_CLIENT_TYPE_PAGER, NULL);
+}
+
+void
+meta_window_activate_with_workspace (MetaWindow     *window,
+                                     guint32         timestamp,
+                                     MetaWorkspace  *workspace)
+{
+  /* We're not really a pager, but the behavior we want is the same as if
+   * we were such.  If we change the pager behavior later, we could revisit
+   * this and just add extra flags to window_activate.
+   */
+  window_activate (window, timestamp, META_CLIENT_TYPE_APPLICATION, workspace);
+}
+
+/* Manually fix all the weirdness explained in the big comment at the
+ * beginning of meta_window_move_resize_internal() giving positions
+ * expected by meta_window_constrain (i.e. positions & sizes of the
+ * internal or client window).
+ */
+static void
+adjust_for_gravity (MetaWindow        *window,
+                    MetaFrameGeometry *fgeom,
+                    gboolean           coords_assume_border,
+                    int                gravity,
+                    MetaRectangle     *rect)
+{
+  int ref_x, ref_y;
+  int bw;
+  int child_x, child_y;
+  int frame_width, frame_height;
+
+  if (coords_assume_border)
+    bw = window->border_width;
+  else
+    bw = 0;
+
+  if (fgeom)
+    {
+      child_x = fgeom->left_width;
+      child_y = fgeom->top_height;
+      frame_width = child_x + rect->width + fgeom->right_width;
+      frame_height = child_y + rect->height + fgeom->bottom_height;
+    }
+  else
+    {
+      child_x = 0;
+      child_y = 0;
+      frame_width = rect->width;
+      frame_height = rect->height;
+    }
+
+  /* We're computing position to pass to window_move, which is
+   * the position of the client window (StaticGravity basically)
+   *
+   * (see WM spec description of gravity computation, but note that
+   * their formulas assume we're honoring the border width, rather
+   * than compensating for having turned it off)
+   */
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      ref_x = rect->x;
+      ref_y = rect->y;
+      break;
+    case NorthGravity:
+      ref_x = rect->x + rect->width / 2 + bw;
+      ref_y = rect->y;
+      break;
+    case NorthEastGravity:
+      ref_x = rect->x + rect->width + bw * 2;
+      ref_y = rect->y;
+      break;
+    case WestGravity:
+      ref_x = rect->x;
+      ref_y = rect->y + rect->height / 2 + bw;
+      break;
+    case CenterGravity:
+      ref_x = rect->x + rect->width / 2 + bw;
+      ref_y = rect->y + rect->height / 2 + bw;
+      break;
+    case EastGravity:
+      ref_x = rect->x + rect->width + bw * 2;
+      ref_y = rect->y + rect->height / 2 + bw;
+      break;
+    case SouthWestGravity:
+      ref_x = rect->x;
+      ref_y = rect->y + rect->height + bw * 2;
+      break;
+    case SouthGravity:
+      ref_x = rect->x + rect->width / 2 + bw;
+      ref_y = rect->y + rect->height + bw * 2;
+      break;
+    case SouthEastGravity:
+      ref_x = rect->x + rect->width + bw * 2;
+      ref_y = rect->y + rect->height + bw * 2;
+      break;
+    case StaticGravity:
+    default:
+      ref_x = rect->x;
+      ref_y = rect->y;
+      break;
+    }
+
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      rect->x = ref_x + child_x;
+      rect->y = ref_y + child_y;
+      break;
+    case NorthGravity:
+      rect->x = ref_x - frame_width / 2 + child_x;
+      rect->y = ref_y + child_y;
+      break;
+    case NorthEastGravity:
+      rect->x = ref_x - frame_width + child_x;
+      rect->y = ref_y + child_y;
+      break;
+    case WestGravity:
+      rect->x = ref_x + child_x;
+      rect->y = ref_y - frame_height / 2 + child_y;
+      break;
+    case CenterGravity:
+      rect->x = ref_x - frame_width / 2 + child_x;
+      rect->y = ref_y - frame_height / 2 + child_y;
+      break;
+    case EastGravity:
+      rect->x = ref_x - frame_width + child_x;
+      rect->y = ref_y - frame_height / 2 + child_y;
+      break;
+    case SouthWestGravity:
+      rect->x = ref_x + child_x;
+      rect->y = ref_y - frame_height + child_y;
+      break;
+    case SouthGravity:
+      rect->x = ref_x - frame_width / 2 + child_x;
+      rect->y = ref_y - frame_height + child_y;
+      break;
+    case SouthEastGravity:
+      rect->x = ref_x - frame_width + child_x;
+      rect->y = ref_y - frame_height + child_y;
+      break;
+    case StaticGravity:
+    default:
+      rect->x = ref_x;
+      rect->y = ref_y;
+      break;
+    }
+}
+
+static gboolean
+static_gravity_works (MetaDisplay *display)
+{
+  return display->static_gravity_works;
+}
+
+#ifdef HAVE_XSYNC
+static void
+send_sync_request (MetaWindow *window)
+{
+  XSyncValue value;
+  XClientMessageEvent ev;
+
+  window->sync_request_serial++;
+
+  XSyncIntToValue (&value, window->sync_request_serial);
+
+  ev.type = ClientMessage;
+  ev.window = window->xwindow;
+  ev.message_type = window->display->atom_WM_PROTOCOLS;
+  ev.format = 32;
+  ev.data.l[0] = window->display->atom__NET_WM_SYNC_REQUEST;
+  /* FIXME: meta_display_get_current_time() is bad, but since calls
+   * come from meta_window_move_resize_internal (which in turn come
+   * from all over), I'm not sure what we can do to fix it.  Do we
+   * want to use _roundtrip, though?
+   */
+  ev.data.l[1] = meta_display_get_current_time (window->display);
+  ev.data.l[2] = XSyncValueLow32 (value);
+  ev.data.l[3] = XSyncValueHigh32 (value);
+
+  /* We don't need to trap errors here as we are already
+   * inside an error_trap_push()/pop() pair.
+   */
+  XSendEvent (window->display->xdisplay,
+	      window->xwindow, False, 0, (XEvent*) &ev);
+
+  g_get_current_time (&window->sync_request_time);
+}
+#endif
+
+static void
+meta_window_move_resize_internal (MetaWindow          *window,
+                                  MetaMoveResizeFlags  flags,
+                                  int                  gravity,
+                                  int                  root_x_nw,
+                                  int                  root_y_nw,
+                                  int                  w,
+                                  int                  h)
+{
+  /* meta_window_move_resize_internal gets called with very different
+   * meanings for root_x_nw and root_y_nw.  w & h are always the area
+   * of the inner or client window (i.e. excluding the frame) and
+   * gravity is the relevant gravity associated with the request (note
+   * that gravity is ignored for move-only operations unless its
+   * e.g. a configure request).  The location is different for
+   * different cases because of how this function gets called; note
+   * that in all cases what we want to find out is the upper left
+   * corner of the position of the inner window:
+   *
+   *   Case | Called from (flags; gravity)
+   *   -----+-----------------------------------------------
+   *    1   | A resize only ConfigureRequest
+   *    1   | meta_window_resize
+   *    1   | meta_window_resize_with_gravity
+   *    2   | New window
+   *    2   | Session restore
+   *    2   | A not-resize-only ConfigureRequest/net_moveresize_window request
+   *    3   | meta_window_move
+   *    3   | meta_window_move_resize
+   *
+   * For each of the cases, root_x_nw and root_y_nw must be treated as follows:
+   *
+   *   (1) They should be entirely ignored; instead the previous position
+   *       and size of the window should be resized according to the given
+   *       gravity in order to determine the new position of the window.
+   *   (2) Needs to be fixed up by adjust_for_gravity() as these
+   *       coordinates are relative to some corner or side of the outer
+   *       window (except for the case of StaticGravity) and we want to
+   *       know the location of the upper left corner of the inner window.
+   *   (3) These values are already the desired positon of the NW corner
+   *       of the inner window
+   */
+  XWindowChanges values;
+  unsigned int mask;
+  gboolean need_configure_notify;
+  MetaFrameGeometry fgeom;
+  gboolean need_move_client = FALSE;
+  gboolean need_move_frame = FALSE;
+  gboolean need_resize_client = FALSE;
+  gboolean need_resize_frame = FALSE;
+  int frame_size_dx;
+  int frame_size_dy;
+  int size_dx;
+  int size_dy;
+  gboolean is_configure_request;
+  gboolean do_gravity_adjust;
+  gboolean is_user_action;
+  gboolean configure_frame_first;
+  gboolean use_static_gravity;
+  /* used for the configure request, but may not be final
+   * destination due to StaticGravity etc.
+   */
+  int client_move_x;
+  int client_move_y;
+  MetaRectangle new_rect;
+  MetaRectangle old_rect;
+
+  is_configure_request = (flags & META_IS_CONFIGURE_REQUEST) != 0;
+  do_gravity_adjust = (flags & META_DO_GRAVITY_ADJUST) != 0;
+  is_user_action = (flags & META_IS_USER_ACTION) != 0;
+
+  /* The action has to be a move or a resize or both... */
+  g_assert (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION));
+
+  /* We don't need it in the idle queue anymore. */
+  meta_window_unqueue (window, META_QUEUE_MOVE_RESIZE);
+
+  meta_window_get_client_root_coords (window, &old_rect);
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Move/resize %s to %d,%d %dx%d%s%s from %d,%d %dx%d\n",
+              window->desc, root_x_nw, root_y_nw, w, h,
+              is_configure_request ? " (configure request)" : "",
+              is_user_action ? " (user move/resize)" : "",
+              old_rect.x, old_rect.y, old_rect.width, old_rect.height);
+
+  if (window->frame)
+    meta_frame_calc_geometry (window->frame,
+                              &fgeom);
+
+  new_rect.x = root_x_nw;
+  new_rect.y = root_y_nw;
+  new_rect.width  = w;
+  new_rect.height = h;
+
+  /* If this is a resize only, the position should be ignored and
+   * instead obtained by resizing the old rectangle according to the
+   * relevant gravity.
+   */
+  if ((flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION)) ==
+      META_IS_RESIZE_ACTION)
+    {
+      meta_rectangle_resize_with_gravity (&old_rect,
+                                          &new_rect,
+                                          gravity,
+                                          new_rect.width,
+                                          new_rect.height);
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Compensated for gravity in resize action; new pos %d,%d\n",
+                  new_rect.x, new_rect.y);
+    }
+  else if (is_configure_request || do_gravity_adjust)
+    {
+      adjust_for_gravity (window,
+                          window->frame ? &fgeom : NULL,
+                          /* configure request coords assume
+                           * the border width existed
+                           */
+                          is_configure_request,
+                          gravity,
+                          &new_rect);
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Compensated for configure_request/do_gravity_adjust needing "
+                  "weird positioning; new pos %d,%d\n",
+                  new_rect.x, new_rect.y);
+    }
+
+  meta_window_constrain (window,
+                         window->frame ? &fgeom : NULL,
+                         flags,
+                         gravity,
+                         &old_rect,
+                         &new_rect);
+
+  w = new_rect.width;
+  h = new_rect.height;
+  root_x_nw = new_rect.x;
+  root_y_nw = new_rect.y;
+
+  if (w != window->rect.width ||
+      h != window->rect.height)
+    need_resize_client = TRUE;
+
+  window->rect.width = w;
+  window->rect.height = h;
+
+  if (window->frame)
+    {
+      int new_w, new_h;
+
+      new_w = window->rect.width + fgeom.left_width + fgeom.right_width;
+
+      if (window->shaded)
+        new_h = fgeom.top_height;
+      else
+        new_h = window->rect.height + fgeom.top_height + fgeom.bottom_height;
+
+      frame_size_dx = new_w - window->frame->rect.width;
+      frame_size_dy = new_h - window->frame->rect.height;
+
+      need_resize_frame = (frame_size_dx != 0 || frame_size_dy != 0);
+
+      window->frame->rect.width = new_w;
+      window->frame->rect.height = new_h;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Calculated frame size %dx%d\n",
+                  window->frame->rect.width,
+                  window->frame->rect.height);
+    }
+  else
+    {
+      frame_size_dx = 0;
+      frame_size_dy = 0;
+    }
+
+  /* For nice effect, when growing the window we want to move/resize
+   * the frame first, when shrinking the window we want to move/resize
+   * the client first. If we grow one way and shrink the other,
+   * see which way we're moving "more"
+   *
+   * Mail from Owen subject "Suggestion: Gravity and resizing from the left"
+   * http://mail.gnome.org/archives/wm-spec-list/1999-November/msg00088.html
+   *
+   * An annoying fact you need to know in this code is that StaticGravity
+   * does nothing if you _only_ resize or _only_ move the frame;
+   * it must move _and_ resize, otherwise you get NorthWestGravity
+   * behavior. The move and resize must actually occur, it is not
+   * enough to set CWX | CWWidth but pass in the current size/pos.
+   */
+
+  if (window->frame)
+    {
+      int new_x, new_y;
+      int frame_pos_dx, frame_pos_dy;
+
+      /* Compute new frame coords */
+      new_x = root_x_nw - fgeom.left_width;
+      new_y = root_y_nw - fgeom.top_height;
+
+      frame_pos_dx = new_x - window->frame->rect.x;
+      frame_pos_dy = new_y - window->frame->rect.y;
+
+      need_move_frame = (frame_pos_dx != 0 || frame_pos_dy != 0);
+
+      window->frame->rect.x = new_x;
+      window->frame->rect.y = new_y;
+
+      /* If frame will both move and resize, then StaticGravity
+       * on the child window will kick in and implicitly move
+       * the child with respect to the frame. The implicit
+       * move will keep the child in the same place with
+       * respect to the root window. If frame only moves
+       * or only resizes, then the child will just move along
+       * with the frame.
+       */
+
+      /* window->rect.x, window->rect.y are relative to frame,
+       * remember they are the server coords
+       */
+
+      new_x = fgeom.left_width;
+      new_y = fgeom.top_height;
+
+      if (need_resize_frame && need_move_frame &&
+          static_gravity_works (window->display))
+        {
+          /* static gravity kicks in because frame
+           * is both moved and resized
+           */
+          /* when we move the frame by frame_pos_dx, frame_pos_dy the
+           * client will implicitly move relative to frame by the
+           * inverse delta.
+           *
+           * When moving client then frame, we move the client by the
+           * frame delta, to be canceled out by the implicit move by
+           * the inverse frame delta, resulting in a client at new_x,
+           * new_y.
+           *
+           * When moving frame then client, we move the client
+           * by the same delta as the frame, because the client
+           * was "left behind" by the frame - resulting in a client
+           * at new_x, new_y.
+           *
+           * In both cases we need to move the client window
+           * in all cases where we had to move the frame window.
+           */
+
+          client_move_x = new_x + frame_pos_dx;
+          client_move_y = new_y + frame_pos_dy;
+
+          if (need_move_frame)
+            need_move_client = TRUE;
+
+          use_static_gravity = TRUE;
+        }
+      else
+        {
+          client_move_x = new_x;
+          client_move_y = new_y;
+
+          if (client_move_x != window->rect.x ||
+              client_move_y != window->rect.y)
+            need_move_client = TRUE;
+
+          use_static_gravity = FALSE;
+        }
+
+      /* This is the final target position, but not necessarily what
+       * we pass to XConfigureWindow, due to StaticGravity implicit
+       * movement.
+       */
+      window->rect.x = new_x;
+      window->rect.y = new_y;
+    }
+  else
+    {
+      if (root_x_nw != window->rect.x ||
+          root_y_nw != window->rect.y)
+        need_move_client = TRUE;
+
+      window->rect.x = root_x_nw;
+      window->rect.y = root_y_nw;
+
+      client_move_x = window->rect.x;
+      client_move_y = window->rect.y;
+
+      use_static_gravity = FALSE;
+    }
+
+  /* If frame extents have changed, fill in other frame fields and
+     change frame's extents property. */
+  if (window->frame &&
+      (window->frame->child_x != fgeom.left_width ||
+       window->frame->child_y != fgeom.top_height ||
+       window->frame->right_width != fgeom.right_width ||
+       window->frame->bottom_height != fgeom.bottom_height))
+    {
+      window->frame->child_x = fgeom.left_width;
+      window->frame->child_y = fgeom.top_height;
+      window->frame->right_width = fgeom.right_width;
+      window->frame->bottom_height = fgeom.bottom_height;
+
+      update_net_frame_extents (window);
+    }
+
+  /* See ICCCM 4.1.5 for when to send ConfigureNotify */
+
+  need_configure_notify = FALSE;
+
+  /* If this is a configure request and we change nothing, then we
+   * must send configure notify.
+   */
+  if  (is_configure_request &&
+       !(need_move_client || need_move_frame ||
+         need_resize_client || need_resize_frame ||
+         window->border_width != 0))
+    need_configure_notify = TRUE;
+
+  /* We must send configure notify if we move but don't resize, since
+   * the client window may not get a real event
+   */
+  if ((need_move_client || need_move_frame) &&
+      !(need_resize_client || need_resize_frame))
+    need_configure_notify = TRUE;
+
+  /* MapRequest events with a PPosition or UPosition hint with a frame
+   * are moved by marco without resizing; send a configure notify
+   * in such cases.  See #322840.  (Note that window->constructing is
+   * only true iff this call is due to a MapRequest, and when
+   * PPosition/UPosition hints aren't set, marco seems to send a
+   * ConfigureNotify anyway due to the above code.)
+   */
+  if (window->constructing && window->frame &&
+      ((window->size_hints.flags & PPosition) ||
+       (window->size_hints.flags & USPosition)))
+    need_configure_notify = TRUE;
+
+  /* The rest of this function syncs our new size/pos with X as
+   * efficiently as possible
+   */
+
+  /* configure frame first if we grow more than we shrink
+   */
+  size_dx = w - window->rect.width;
+  size_dy = h - window->rect.height;
+
+  configure_frame_first = (size_dx + size_dy >= 0);
+
+  if (use_static_gravity)
+    meta_window_set_gravity (window, StaticGravity);
+
+  if (configure_frame_first && window->frame)
+    meta_frame_sync_to_window (window->frame,
+                               gravity,
+                               need_move_frame, need_resize_frame);
+
+  values.border_width = 0;
+  values.x = client_move_x;
+  values.y = client_move_y;
+  values.width = window->rect.width;
+  values.height = window->rect.height;
+
+  mask = 0;
+  if (is_configure_request && window->border_width != 0)
+    mask |= CWBorderWidth; /* must force to 0 */
+  if (need_move_client)
+    mask |= (CWX | CWY);
+  if (need_resize_client)
+    mask |= (CWWidth | CWHeight);
+
+  if (mask != 0)
+    {
+      {
+        int newx, newy;
+        meta_window_get_position (window, &newx, &newy);
+        meta_topic (META_DEBUG_GEOMETRY,
+                    "Syncing new client geometry %d,%d %dx%d, border: %s pos: %s size: %s\n",
+                    newx, newy,
+                    window->rect.width, window->rect.height,
+                    mask & CWBorderWidth ? "true" : "false",
+                    need_move_client ? "true" : "false",
+                    need_resize_client ? "true" : "false");
+      }
+
+      meta_error_trap_push (window->display);
+
+#ifdef HAVE_XSYNC
+      if (window->sync_request_counter != None &&
+	  window->display->grab_sync_request_alarm != None &&
+	  window->sync_request_time.tv_usec == 0 &&
+	  window->sync_request_time.tv_sec == 0)
+	{
+	  /* turn off updating */
+	  if (window->display->compositor)
+	    meta_compositor_set_updates (window->display->compositor, window, FALSE);
+
+	  send_sync_request (window);
+	}
+#endif
+
+      XConfigureWindow (window->display->xdisplay,
+                        window->xwindow,
+                        mask,
+                        &values);
+
+      meta_error_trap_pop (window->display, FALSE);
+    }
+
+  if (!configure_frame_first && window->frame)
+    meta_frame_sync_to_window (window->frame,
+                               gravity,
+                               need_move_frame, need_resize_frame);
+
+  /* Put gravity back to be nice to lesser window managers */
+  if (use_static_gravity)
+    meta_window_set_gravity (window, NorthWestGravity);
+
+  if (need_configure_notify)
+    send_configure_notify (window);
+
+  if (!window->placed && window->force_save_user_rect && !window->fullscreen)
+    force_save_user_window_placement (window);
+  else if (is_user_action)
+    save_user_window_placement (window);
+
+  if (need_move_frame || need_resize_frame ||
+      need_move_client || need_resize_client)
+    {
+      int newx, newy;
+      meta_window_get_position (window, &newx, &newy);
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "New size/position %d,%d %dx%d (user %d,%d %dx%d)\n",
+                  newx, newy, window->rect.width, window->rect.height,
+                  window->user_rect.x, window->user_rect.y,
+                  window->user_rect.width, window->user_rect.height);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Size/position not modified\n");
+    }
+
+  if (window->display->grab_wireframe_active)
+    meta_window_update_wireframe (window, root_x_nw, root_y_nw, w, h);
+  else
+    meta_window_refresh_resize_popup (window);
+
+  /* Invariants leaving this function are:
+   *   a) window->rect and frame->rect reflect the actual
+   *      server-side size/pos of window->xwindow and frame->xwindow
+   *   b) all constraints are obeyed by window->rect and frame->rect
+   */
+}
+
+void
+meta_window_resize (MetaWindow  *window,
+                    gboolean     user_op,
+                    int          w,
+                    int          h)
+{
+  int x, y;
+  MetaMoveResizeFlags flags;
+
+  meta_window_get_position (window, &x, &y);
+
+  flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    NorthWestGravity,
+                                    x, y, w, h);
+}
+
+void
+meta_window_move (MetaWindow  *window,
+                  gboolean     user_op,
+                  int          root_x_nw,
+                  int          root_y_nw)
+{
+  MetaMoveResizeFlags flags =
+    (user_op ? META_IS_USER_ACTION : 0) | META_IS_MOVE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    NorthWestGravity,
+                                    root_x_nw, root_y_nw,
+                                    window->rect.width,
+                                    window->rect.height);
+}
+
+void
+meta_window_move_resize (MetaWindow  *window,
+                         gboolean     user_op,
+                         int          root_x_nw,
+                         int          root_y_nw,
+                         int          w,
+                         int          h)
+{
+  MetaMoveResizeFlags flags =
+    (user_op ? META_IS_USER_ACTION : 0) |
+    META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    NorthWestGravity,
+                                    root_x_nw, root_y_nw,
+                                    w, h);
+}
+
+void
+meta_window_resize_with_gravity (MetaWindow *window,
+                                 gboolean     user_op,
+                                 int          w,
+                                 int          h,
+                                 int          gravity)
+{
+  int x, y;
+  MetaMoveResizeFlags flags;
+
+  meta_window_get_position (window, &x, &y);
+
+  flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    gravity,
+                                    x, y, w, h);
+}
+
+static void
+meta_window_move_resize_now (MetaWindow  *window)
+{
+  /* If constraints have changed then we want to snap back to wherever
+   * the user had the window.  We use user_rect for this reason.  See
+   * also bug 426519 comment 3.
+   */
+  meta_window_move_resize (window, FALSE,
+                           window->user_rect.x,
+                           window->user_rect.y,
+                           window->user_rect.width,
+                           window->user_rect.height);
+}
+
+static gboolean
+idle_move_resize (gpointer data)
+{
+  GSList *tmp;
+  GSList *copy;
+  guint queue_index = GPOINTER_TO_INT (data);
+
+  meta_topic (META_DEBUG_GEOMETRY, "Clearing the move_resize queue\n");
+
+  /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+   * complete; destroying a window while we're in here would result in
+   * badness. But it's OK to queue/unqueue move_resizes.
+   */
+  copy = g_slist_copy (queue_pending[queue_index]);
+  g_slist_free (queue_pending[queue_index]);
+  queue_pending[queue_index] = NULL;
+  queue_idle[queue_index] = 0;
+
+  destroying_windows_disallowed += 1;
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      /* As a side effect, sets window->move_resize_queued = FALSE */
+      meta_window_move_resize_now (window);
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (copy);
+
+  destroying_windows_disallowed -= 1;
+
+  return FALSE;
+}
+
+void
+meta_window_get_position (MetaWindow  *window,
+                          int         *x,
+                          int         *y)
+{
+  if (window->frame)
+    {
+      if (x)
+        *x = window->frame->rect.x + window->frame->child_x;
+      if (y)
+        *y = window->frame->rect.y + window->frame->child_y;
+    }
+  else
+    {
+      if (x)
+        *x = window->rect.x;
+      if (y)
+        *y = window->rect.y;
+    }
+}
+
+void
+meta_window_get_client_root_coords (MetaWindow    *window,
+                                    MetaRectangle *rect)
+{
+  meta_window_get_position (window, &rect->x, &rect->y);
+  rect->width  = window->rect.width;
+  rect->height = window->rect.height;
+}
+
+void
+meta_window_get_gravity_position (MetaWindow  *window,
+                                  int          gravity,
+                                  int         *root_x,
+                                  int         *root_y)
+{
+  MetaRectangle frame_extents;
+  int w, h;
+  int x, y;
+
+  w = window->rect.width;
+  h = window->rect.height;
+
+  if (gravity == StaticGravity)
+    {
+      frame_extents = window->rect;
+      if (window->frame)
+        {
+          frame_extents.x = window->frame->rect.x + window->frame->child_x;
+          frame_extents.y = window->frame->rect.y + window->frame->child_y;
+        }
+    }
+  else
+    {
+      if (window->frame == NULL)
+        frame_extents = window->rect;
+      else
+        frame_extents = window->frame->rect;
+    }
+
+  x = frame_extents.x;
+  y = frame_extents.y;
+
+  switch (gravity)
+    {
+    case NorthGravity:
+    case CenterGravity:
+    case SouthGravity:
+      /* Find center of frame. */
+      x += frame_extents.width / 2;
+      /* Center client window on that point. */
+      x -= w / 2;
+      break;
+
+    case SouthEastGravity:
+    case EastGravity:
+    case NorthEastGravity:
+      /* Find right edge of frame */
+      x += frame_extents.width;
+      /* Align left edge of client at that point. */
+      x -= w;
+      break;
+    default:
+      break;
+    }
+
+  switch (gravity)
+    {
+    case WestGravity:
+    case CenterGravity:
+    case EastGravity:
+      /* Find center of frame. */
+      y += frame_extents.height / 2;
+      /* Center client window there. */
+      y -= h / 2;
+      break;
+    case SouthWestGravity:
+    case SouthGravity:
+    case SouthEastGravity:
+      /* Find south edge of frame */
+      y += frame_extents.height;
+      /* Place bottom edge of client there */
+      y -= h;
+      break;
+    default:
+      break;
+    }
+
+  if (root_x)
+    *root_x = x;
+  if (root_y)
+    *root_y = y;
+}
+
+void
+meta_window_get_geometry (MetaWindow  *window,
+                          int         *x,
+                          int         *y,
+                          int         *width,
+                          int         *height)
+{
+  meta_window_get_gravity_position (window,
+                                    window->size_hints.win_gravity,
+                                    x, y);
+
+  *width = (window->rect.width - window->size_hints.base_width) /
+    window->size_hints.width_inc;
+  *height = (window->rect.height - window->size_hints.base_height) /
+    window->size_hints.height_inc;
+}
+
+void
+meta_window_get_outer_rect (const MetaWindow *window,
+                            MetaRectangle    *rect)
+{
+  if (window->frame)
+    *rect = window->frame->rect;
+  else
+    *rect = window->rect;
+}
+
+void
+meta_window_get_xor_rect (MetaWindow          *window,
+                          const MetaRectangle *grab_wireframe_rect,
+                          MetaRectangle       *xor_rect)
+{
+  if (window->frame)
+    {
+      xor_rect->x = grab_wireframe_rect->x - window->frame->child_x;
+      xor_rect->y = grab_wireframe_rect->y - window->frame->child_y;
+      xor_rect->width = grab_wireframe_rect->width + window->frame->child_x + window->frame->right_width;
+
+      if (window->shaded)
+        xor_rect->height = window->frame->child_y;
+      else
+        xor_rect->height = grab_wireframe_rect->height + window->frame->child_y + window->frame->bottom_height;
+    }
+  else
+    *xor_rect = *grab_wireframe_rect;
+}
+
+/* Figure out the numbers that show up in the
+ * resize popup when in reduced resources mode.
+ */
+static void
+meta_window_get_wireframe_geometry (MetaWindow    *window,
+                                    int           *width,
+                                    int           *height)
+{
+  if (!window->display->grab_wireframe_active)
+    return;
+
+  if ((width == NULL) || (height == NULL))
+    return;
+
+  if ((window->display->grab_window->size_hints.width_inc <= 1) ||
+      (window->display->grab_window->size_hints.height_inc <= 1))
+    {
+      *width = -1;
+      *height = -1;
+      return;
+    }
+
+  *width = window->display->grab_wireframe_rect.width -
+      window->display->grab_window->size_hints.base_width;
+  *width /= window->display->grab_window->size_hints.width_inc;
+
+  *height = window->display->grab_wireframe_rect.height -
+      window->display->grab_window->size_hints.base_height;
+  *height /= window->display->grab_window->size_hints.height_inc;
+}
+
+/* XXX META_EFFECT_ALT_TAB, well, this and others */
+void
+meta_window_begin_wireframe (MetaWindow *window)
+{
+
+  MetaRectangle new_xor;
+  int display_width, display_height;
+
+  meta_window_get_client_root_coords (window,
+                                      &window->display->grab_wireframe_rect);
+
+  meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
+                            &new_xor);
+  meta_window_get_wireframe_geometry (window, &display_width, &display_height);
+
+  meta_effects_begin_wireframe (window->screen,
+                                &new_xor, display_width, display_height);
+
+  window->display->grab_wireframe_last_xor_rect = new_xor;
+  window->display->grab_wireframe_last_display_width = display_width;
+  window->display->grab_wireframe_last_display_height = display_height;
+}
+
+void
+meta_window_update_wireframe (MetaWindow *window,
+                              int         x,
+                              int         y,
+                              int         width,
+                              int         height)
+{
+
+  MetaRectangle new_xor;
+  int display_width, display_height;
+
+  window->display->grab_wireframe_rect.x = x;
+  window->display->grab_wireframe_rect.y = y;
+  window->display->grab_wireframe_rect.width = width;
+  window->display->grab_wireframe_rect.height = height;
+
+  meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
+                            &new_xor);
+  meta_window_get_wireframe_geometry (window, &display_width, &display_height);
+
+  meta_effects_update_wireframe (window->screen,
+                                 &window->display->grab_wireframe_last_xor_rect,
+                                 window->display->grab_wireframe_last_display_width,
+                                 window->display->grab_wireframe_last_display_height,
+                                 &new_xor, display_width, display_height);
+
+  window->display->grab_wireframe_last_xor_rect = new_xor;
+  window->display->grab_wireframe_last_display_width = display_width;
+  window->display->grab_wireframe_last_display_height = display_height;
+}
+
+void
+meta_window_end_wireframe (MetaWindow *window)
+{
+  meta_effects_end_wireframe (window->display->grab_window->screen,
+                              &window->display->grab_wireframe_last_xor_rect,
+                              window->display->grab_wireframe_last_display_width,
+                              window->display->grab_wireframe_last_display_height);
+}
+
+const char*
+meta_window_get_startup_id (MetaWindow *window)
+{
+  if (window->startup_id == NULL)
+    {
+      MetaGroup *group;
+
+      group = meta_window_get_group (window);
+
+      if (group != NULL)
+        return meta_group_get_startup_id (group);
+    }
+
+  return window->startup_id;
+}
+
+static MetaWindow*
+get_modal_transient (MetaWindow *window)
+{
+  GSList *windows;
+  GSList *tmp;
+  MetaWindow *modal_transient;
+
+  /* A window can't be the transient of itself, but this is just for
+   * convenience in the loop below; we manually fix things up at the
+   * end if no real modal transient was found.
+   */
+  modal_transient = window;
+
+  windows = meta_display_list_windows (window->display);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *transient = tmp->data;
+
+      if (transient->xtransient_for == modal_transient->xwindow &&
+          transient->wm_state_modal)
+        {
+          modal_transient = transient;
+          tmp = windows;
+          continue;
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+
+  if (window == modal_transient)
+    modal_transient = NULL;
+
+  return modal_transient;
+}
+
+/* XXX META_EFFECT_FOCUS */
+void
+meta_window_focus (MetaWindow  *window,
+                   guint32      timestamp)
+{
+  MetaWindow *modal_transient;
+
+  meta_topic (META_DEBUG_FOCUS,
+              "Setting input focus to window %s, input: %d take_focus: %d\n",
+              window->desc, window->input, window->take_focus);
+
+  if (window->display->grab_window &&
+      window->display->grab_window->all_keys_grabbed)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Current focus window %s has global keygrab, not focusing window %s after all\n",
+                  window->display->grab_window->desc, window->desc);
+      return;
+    }
+
+  modal_transient = get_modal_transient (window);
+  if (modal_transient != NULL &&
+      !modal_transient->unmanaging)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "%s has %s as a modal transient, so focusing it instead.\n",
+                  window->desc, modal_transient->desc);
+      if (!modal_transient->on_all_workspaces &&
+          modal_transient->workspace != window->screen->active_workspace)
+        meta_window_change_workspace (modal_transient,
+                                      window->screen->active_workspace);
+      window = modal_transient;
+    }
+
+  meta_window_flush_calc_showing (window);
+
+  if (!window->mapped && !window->shaded)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Window %s is not showing, not focusing after all\n",
+                  window->desc);
+      return;
+    }
+
+  /* For output-only or shaded windows, focus the frame.
+   * This seems to result in the client window getting key events
+   * though, so I don't know if it's icccm-compliant.
+   *
+   * Still, we have to do this or keynav breaks for these windows.
+   */
+  if (window->frame &&
+      (window->shaded ||
+       !(window->input || window->take_focus)))
+    {
+      if (window->frame)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focusing frame of %s\n", window->desc);
+          meta_display_set_input_focus_window (window->display,
+                                               window,
+                                               TRUE,
+                                               timestamp);
+        }
+    }
+  else
+    {
+      if (window->input)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Setting input focus on %s since input = true\n",
+                      window->desc);
+          meta_display_set_input_focus_window (window->display,
+                                               window,
+                                               FALSE,
+                                               timestamp);
+        }
+
+      if (window->take_focus)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Sending WM_TAKE_FOCUS to %s since take_focus = true\n",
+                      window->desc);
+          meta_window_send_icccm_message (window,
+                                          window->display->atom_WM_TAKE_FOCUS,
+                                          timestamp);
+          window->display->expected_focus_window = window;
+        }
+    }
+
+  if (window->wm_state_demands_attention)
+    meta_window_unset_demands_attention(window);
+
+  meta_effect_run_focus(window, NULL, NULL);
+}
+
+static void
+meta_window_change_workspace_without_transients (MetaWindow    *window,
+                                                 MetaWorkspace *workspace)
+{
+  meta_verbose ("Changing window %s to workspace %d\n",
+                window->desc, meta_workspace_index (workspace));
+
+  /* unstick if stuck. meta_window_unstick would call
+   * meta_window_change_workspace recursively if the window
+   * is not in the active workspace.
+   */
+  if (window->on_all_workspaces)
+    meta_window_unstick (window);
+
+  /* See if we're already on this space. If not, make sure we are */
+  if (window->workspace != workspace)
+    {
+      meta_workspace_remove_window (window->workspace, window);
+      meta_workspace_add_window (workspace, window);
+    }
+}
+
+static gboolean
+change_workspace_foreach (MetaWindow *window,
+                          void       *data)
+{
+  meta_window_change_workspace_without_transients (window, data);
+  return TRUE;
+}
+
+void
+meta_window_change_workspace (MetaWindow    *window,
+                              MetaWorkspace *workspace)
+{
+  meta_window_change_workspace_without_transients (window, workspace);
+
+  meta_window_foreach_transient (window, change_workspace_foreach,
+                                 workspace);
+  meta_window_foreach_ancestor (window, change_workspace_foreach,
+                                workspace);
+}
+
+static void
+window_stick_impl (MetaWindow  *window)
+{
+  GList *tmp;
+  MetaWorkspace *workspace;
+
+  meta_verbose ("Sticking window %s current on_all_workspaces = %d\n",
+                window->desc, window->on_all_workspaces);
+
+  if (window->on_all_workspaces)
+    return;
+
+  /* We don't change window->workspaces, because we revert
+   * to that original workspace list if on_all_workspaces is
+   * toggled back off.
+   */
+  window->on_all_workspaces = TRUE;
+
+  /* We do, however, change the MRU lists of all the workspaces
+   */
+  tmp = window->screen->workspaces;
+  while (tmp)
+    {
+      workspace = (MetaWorkspace *) tmp->data;
+      if (!g_list_find (workspace->mru_list, window))
+        workspace->mru_list = g_list_prepend (workspace->mru_list, window);
+
+      tmp = tmp->next;
+    }
+
+  meta_window_set_current_workspace_hint (window);
+
+  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+}
+
+static void
+window_unstick_impl (MetaWindow  *window)
+{
+  GList *tmp;
+  MetaWorkspace *workspace;
+
+  if (!window->on_all_workspaces)
+    return;
+
+  /* Revert to window->workspaces */
+
+  window->on_all_workspaces = FALSE;
+
+  /* Remove window from MRU lists that it doesn't belong in */
+  tmp = window->screen->workspaces;
+  while (tmp)
+    {
+      workspace = (MetaWorkspace *) tmp->data;
+      if (window->workspace != workspace)
+        workspace->mru_list = g_list_remove (workspace->mru_list, window);
+      tmp = tmp->next;
+    }
+
+  /* We change ourselves to the active workspace, since otherwise you'd get
+   * a weird window-vaporization effect. Once we have UI for being
+   * on more than one workspace this should probably be add_workspace
+   * not change_workspace.
+   */
+  if (window->screen->active_workspace != window->workspace)
+    meta_window_change_workspace (window, window->screen->active_workspace);
+
+  meta_window_set_current_workspace_hint (window);
+
+  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+}
+
+static gboolean
+stick_foreach_func (MetaWindow *window,
+                    void       *data)
+{
+  gboolean stick;
+
+  stick = *(gboolean*)data;
+  if (stick)
+    window_stick_impl (window);
+  else
+    window_unstick_impl (window);
+  return TRUE;
+}
+
+void
+meta_window_stick (MetaWindow  *window)
+{
+  gboolean stick = TRUE;
+  window_stick_impl (window);
+  meta_window_foreach_transient (window,
+                                 stick_foreach_func,
+                                 &stick);
+}
+
+void
+meta_window_unstick (MetaWindow  *window)
+{
+  gboolean stick = FALSE;
+  window_unstick_impl (window);
+  meta_window_foreach_transient (window,
+                                 stick_foreach_func,
+                                 &stick);
+}
+
+unsigned long
+meta_window_get_net_wm_desktop (MetaWindow *window)
+{
+  if (window->on_all_workspaces)
+    return 0xFFFFFFFF;
+  else
+    return meta_workspace_index (window->workspace);
+}
+
+static void
+update_net_frame_extents (MetaWindow *window)
+{
+  unsigned long data[4] = { 0, 0, 0, 0 };
+
+  if (window->frame)
+    {
+      /* Left */
+      data[0] = window->frame->child_x;
+      /* Right */
+      data[1] = window->frame->right_width;
+      /* Top */
+      data[2] = window->frame->child_y;
+      /* Bottom */
+      data[3] = window->frame->bottom_height;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting _NET_FRAME_EXTENTS on managed window 0x%lx "
+              "to left = %lu, right = %lu, top = %lu, bottom = %lu\n",
+              window->xwindow, data[0], data[1], data[2], data[3]);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_FRAME_EXTENTS,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 4);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_set_current_workspace_hint (MetaWindow *window)
+{
+  /* FIXME if on more than one workspace, we claim to be "sticky",
+   * the WM spec doesn't say what to do here.
+   */
+  unsigned long data[1];
+
+  if (window->workspace == NULL)
+    {
+      /* this happens when unmanaging windows */
+      return;
+    }
+
+  data[0] = meta_window_get_net_wm_desktop (window);
+
+  meta_verbose ("Setting _NET_WM_DESKTOP of %s to %lu\n",
+                window->desc, data[0]);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_WM_DESKTOP,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+static gboolean
+find_root_ancestor (MetaWindow *window,
+                    void       *data)
+{
+  MetaWindow **ancestor = data;
+
+  /* Overwrite the previously "most-root" ancestor with the new one found */
+  *ancestor = window;
+
+  /* We want this to continue until meta_window_foreach_ancestor quits because
+   * there are no more valid ancestors.
+   */
+  return TRUE;
+}
+
+MetaWindow *
+meta_window_find_root_ancestor (MetaWindow *window)
+{
+  MetaWindow *ancestor;
+  ancestor = window;
+  meta_window_foreach_ancestor (window, find_root_ancestor, &ancestor);
+  return ancestor;
+}
+
+void
+meta_window_raise (MetaWindow  *window)
+{
+  MetaWindow *ancestor;
+  ancestor = meta_window_find_root_ancestor (window);
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Raising window %s, ancestor of %s\n",
+              ancestor->desc, window->desc);
+
+  /* Raise the ancestor of the window (if the window has no ancestor,
+   * then ancestor will be set to the window itself); do this because
+   * it's weird to see windows from other apps stacked between a child
+   * and parent window of the currently active app.  The stacking
+   * constraints in stack.c then magically take care of raising all
+   * the child windows appropriately.
+   */
+  if (window->screen->stack == ancestor->screen->stack)
+    meta_stack_raise (window->screen->stack, ancestor);
+  else
+    {
+      meta_warning (
+                    "Either stacks aren't per screen or some window has a weird "
+                    "transient_for hint; window->screen->stack != "
+                    "ancestor->screen->stack.  window = %s, ancestor = %s.\n",
+                    window->desc, ancestor->desc);
+      /* We could raise the window here, but don't want to do that twice and
+       * so we let the case below handle that.
+       */
+    }
+
+  /* Okay, so stacking constraints misses one case: If a window has
+   * two children and we want to raise one of those children, then
+   * raising the ancestor isn't enough; we need to also raise the
+   * correct child.  See bug 307875.
+   */
+  if (window != ancestor)
+    meta_stack_raise (window->screen->stack, window);
+}
+
+void
+meta_window_lower (MetaWindow  *window)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Lowering window %s\n", window->desc);
+
+  meta_stack_lower (window->screen->stack, window);
+}
+
+void
+meta_window_send_icccm_message (MetaWindow *window,
+                                Atom        atom,
+                                guint32     timestamp)
+{
+  /* This comment and code are from twm, copyright
+   * Open Group, Evans & Sutherland, etc.
+   */
+
+  /*
+   * ICCCM Client Messages - Section 4.2.8 of the ICCCM dictates that all
+   * client messages will have the following form:
+   *
+   *     event type	ClientMessage
+   *     message type	_XA_WM_PROTOCOLS
+   *     window		tmp->w
+   *     format		32
+   *     data[0]		message atom
+   *     data[1]		time stamp
+   */
+
+    XClientMessageEvent ev;
+
+    ev.type = ClientMessage;
+    ev.window = window->xwindow;
+    ev.message_type = window->display->atom_WM_PROTOCOLS;
+    ev.format = 32;
+    ev.data.l[0] = atom;
+    ev.data.l[1] = timestamp;
+
+    meta_error_trap_push (window->display);
+    XSendEvent (window->display->xdisplay,
+                window->xwindow, False, 0, (XEvent*) &ev);
+    meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_move_resize_request (MetaWindow *window,
+                                 guint       value_mask,
+                                 int         gravity,
+                                 int         new_x,
+                                 int         new_y,
+                                 int         new_width,
+                                 int         new_height)
+{
+  int x, y, width, height;
+  gboolean allow_position_change;
+  gboolean in_grab_op;
+  MetaMoveResizeFlags flags;
+
+  /* We ignore configure requests while the user is moving/resizing
+   * the window, since these represent the app sucking and fighting
+   * the user, most likely due to a bug in the app (e.g. pfaedit
+   * seemed to do this)
+   *
+   * Still have to do the ConfigureNotify and all, but pretend the
+   * app asked for the current size/position instead of the new one.
+   */
+  in_grab_op = FALSE;
+  if (window->display->grab_op != META_GRAB_OP_NONE &&
+      window == window->display->grab_window)
+    {
+      switch (window->display->grab_op)
+        {
+        case META_GRAB_OP_MOVING:
+        case META_GRAB_OP_RESIZING_SE:
+        case META_GRAB_OP_RESIZING_S:
+        case META_GRAB_OP_RESIZING_SW:
+        case META_GRAB_OP_RESIZING_N:
+        case META_GRAB_OP_RESIZING_NE:
+        case META_GRAB_OP_RESIZING_NW:
+        case META_GRAB_OP_RESIZING_W:
+        case META_GRAB_OP_RESIZING_E:
+          in_grab_op = TRUE;
+          break;
+        default:
+          break;
+        }
+    }
+
+  /* it's essential to use only the explicitly-set fields,
+   * and otherwise use our current up-to-date position.
+   *
+   * Otherwise you get spurious position changes when the app changes
+   * size, for example, if window->rect is not in sync with the
+   * server-side position in effect when the configure request was
+   * generated.
+   */
+  meta_window_get_gravity_position (window,
+                                    gravity,
+                                    &x, &y);
+
+  allow_position_change = FALSE;
+
+  if (meta_prefs_get_disable_workarounds ())
+    {
+      if (window->type == META_WINDOW_DIALOG ||
+          window->type == META_WINDOW_MODAL_DIALOG ||
+          window->type == META_WINDOW_SPLASHSCREEN)
+        ; /* No position change for these */
+      else if ((window->size_hints.flags & PPosition) ||
+               /* USPosition is just stale if window is placed;
+                * no --geometry involved here.
+                */
+               ((window->size_hints.flags & USPosition) &&
+                !window->placed))
+        allow_position_change = TRUE;
+    }
+  else
+    {
+      allow_position_change = TRUE;
+    }
+
+  if (in_grab_op)
+    allow_position_change = FALSE;
+
+  if (allow_position_change)
+    {
+      if (value_mask & CWX)
+        x = new_x;
+      if (value_mask & CWY)
+        y = new_y;
+      if (value_mask & (CWX | CWY))
+        {
+          /* Once manually positioned, windows shouldn't be placed
+           * by the window manager.
+           */
+          window->placed = TRUE;
+        }
+    }
+  else
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+		  "Not allowing position change for window %s PPosition 0x%lx USPosition 0x%lx type %u\n",
+		  window->desc, window->size_hints.flags & PPosition,
+		  window->size_hints.flags & USPosition,
+		  window->type);
+    }
+
+  width = window->rect.width;
+  height = window->rect.height;
+  if (!in_grab_op)
+    {
+      if (value_mask & CWWidth)
+        width = new_width;
+
+      if (value_mask & CWHeight)
+        height = new_height;
+    }
+
+  /* ICCCM 4.1.5 */
+
+  /* We're ignoring the value_mask here, since sizes
+   * not in the mask will be the current window geometry.
+   */
+  window->size_hints.x = x;
+  window->size_hints.y = y;
+  window->size_hints.width = width;
+  window->size_hints.height = height;
+
+  /* NOTE: We consider ConfigureRequests to be "user" actions in one
+   * way, but not in another.  Explanation of the two cases are in the
+   * next two big comments.
+   */
+
+  /* The constraints code allows user actions to move windows
+   * offscreen, etc., and configure request actions would often send
+   * windows offscreen when users don't want it if not constrained
+   * (e.g. hitting a dropdown triangle in a fileselector to show more
+   * options, which makes the window bigger).  Thus we do not set
+   * META_IS_USER_ACTION in flags to the
+   * meta_window_move_resize_internal() call.
+   */
+  flags = META_IS_CONFIGURE_REQUEST;
+  if (value_mask & (CWX | CWY))
+    flags |= META_IS_MOVE_ACTION;
+  if (value_mask & (CWWidth | CWHeight))
+    flags |= META_IS_RESIZE_ACTION;
+
+  if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION))
+    meta_window_move_resize_internal (window,
+                                      flags,
+                                      gravity,
+                                      x,
+                                      y,
+                                      width,
+                                      height);
+
+  /* window->user_rect exists to allow "snapping-back" the window if a
+   * new strut is set (causing the window to move) and then the strut
+   * is later removed without the user moving the window in the
+   * interim.  We'd like to "snap-back" to the position specified by
+   * ConfigureRequest events (at least the constrained version of the
+   * ConfigureRequest, since that is guaranteed to be onscreen) so we
+   * set user_rect here.
+   *
+   * See also bug 426519.
+   */
+  save_user_window_placement (window);
+}
+
+gboolean
+meta_window_configure_request (MetaWindow *window,
+                               XEvent     *event)
+{
+  /* Note that x, y is the corner of the window border,
+   * and width, height is the size of the window inside
+   * its border, but that we always deny border requests
+   * and give windows a border of 0. But we save the
+   * requested border here.
+   */
+  if (event->xconfigurerequest.value_mask & CWBorderWidth)
+    window->border_width = event->xconfigurerequest.border_width;
+
+  meta_window_move_resize_request(window,
+                                  event->xconfigurerequest.value_mask,
+                                  window->size_hints.win_gravity,
+                                  event->xconfigurerequest.x,
+                                  event->xconfigurerequest.y,
+                                  event->xconfigurerequest.width,
+                                  event->xconfigurerequest.height);
+
+  /* Handle stacking. We only handle raises/lowers, mostly because
+   * stack.c really can't deal with anything else.  I guess we'll fix
+   * that if a client turns up that really requires it. Only a very
+   * few clients even require the raise/lower (and in fact all client
+   * attempts to deal with stacking order are essentially broken,
+   * since they have no idea what other clients are involved or how
+   * the stack looks).
+   *
+   * I'm pretty sure no interesting client uses TopIf, BottomIf, or
+   * Opposite anyway, so the only possible missing thing is
+   * Above/Below with a sibling set. For now we just pretend there's
+   * never a sibling set and always do the full raise/lower instead of
+   * the raise-just-above/below-sibling.
+   */
+  if (event->xconfigurerequest.value_mask & CWStackMode)
+    {
+      MetaWindow *active_window;
+      active_window = window->display->expected_focus_window;
+      if (meta_prefs_get_disable_workarounds () ||
+          !meta_prefs_get_raise_on_click ())
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "%s sent an xconfigure stacking request; this is "
+                      "broken behavior and the request is being ignored.\n",
+                      window->desc);
+        }
+      else if (active_window &&
+               !meta_window_same_application (window, active_window) &&
+               XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
+                                       active_window->net_wm_user_time))
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "Ignoring xconfigure stacking request from %s (with "
+                      "user_time %u); currently active application is %s (with "
+                      "user_time %u).\n",
+                      window->desc,
+                      window->net_wm_user_time,
+                      active_window->desc,
+                      active_window->net_wm_user_time);
+          if (event->xconfigurerequest.detail == Above)
+            meta_window_set_demands_attention(window);
+        }
+      else
+        {
+          switch (event->xconfigurerequest.detail)
+            {
+            case Above:
+              meta_window_raise (window);
+              break;
+            case Below:
+              meta_window_lower (window);
+              break;
+            case TopIf:
+            case BottomIf:
+            case Opposite:
+              break;
+            }
+        }
+    }
+
+  return TRUE;
+}
+
+gboolean
+meta_window_property_notify (MetaWindow *window,
+                             XEvent     *event)
+{
+  return process_property_notify (window, &event->xproperty);
+}
+
+#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT      0
+#define _NET_WM_MOVERESIZE_SIZE_TOP          1
+#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT     2
+#define _NET_WM_MOVERESIZE_SIZE_RIGHT        3
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOM       5
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT   6
+#define _NET_WM_MOVERESIZE_SIZE_LEFT         7
+#define _NET_WM_MOVERESIZE_MOVE              8
+#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD     9
+#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD    10
+#define _NET_WM_MOVERESIZE_CANCEL           11
+
+gboolean
+meta_window_client_message (MetaWindow *window,
+                            XEvent     *event)
+{
+  MetaDisplay *display;
+
+  display = window->display;
+
+  if (event->xclient.message_type ==
+      display->atom__NET_CLOSE_WINDOW)
+    {
+      guint32 timestamp;
+
+      if (event->xclient.data.l[0] != 0)
+	timestamp = event->xclient.data.l[0];
+      else
+        {
+          meta_warning ("Receiving a NET_CLOSE_WINDOW message for %s without "
+                        "a timestamp!  This means some buggy (outdated) "
+                        "application is on the loose!\n",
+                        window->desc);
+          timestamp = meta_display_get_current_time (window->display);
+        }
+
+      meta_window_delete (window, timestamp);
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_DESKTOP)
+    {
+      int space;
+      MetaWorkspace *workspace;
+
+      space = event->xclient.data.l[0];
+
+      meta_verbose ("Request to move %s to workspace %d\n",
+                    window->desc, space);
+
+      workspace =
+        meta_screen_get_workspace_by_index (window->screen,
+                                            space);
+
+      if (workspace)
+        {
+          if (window->on_all_workspaces)
+            meta_window_unstick (window);
+          meta_window_change_workspace (window, workspace);
+        }
+      else if (space == (int) 0xFFFFFFFF)
+        {
+          meta_window_stick (window);
+        }
+      else
+        {
+          meta_verbose ("No such workspace %d for screen\n", space);
+        }
+
+      meta_verbose ("Window %s now on_all_workspaces = %d\n",
+                    window->desc, window->on_all_workspaces);
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_STATE)
+    {
+      gulong action;
+      Atom first;
+      Atom second;
+
+      action = event->xclient.data.l[0];
+      first = event->xclient.data.l[1];
+      second = event->xclient.data.l[2];
+
+      if (meta_is_verbose ())
+        {
+          char *str1;
+          char *str2;
+
+          meta_error_trap_push_with_return (display);
+          str1 = XGetAtomName (display->xdisplay, first);
+          if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+            str1 = NULL;
+
+          meta_error_trap_push_with_return (display);
+          str2 = XGetAtomName (display->xdisplay, second);
+          if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+            str2 = NULL;
+
+          meta_verbose ("Request to change _NET_WM_STATE action %lu atom1: %s atom2: %s\n",
+                        action,
+                        str1 ? str1 : "(unknown)",
+                        str2 ? str2 : "(unknown)");
+
+          meta_XFree (str1);
+          meta_XFree (str2);
+        }
+
+      if (first == display->atom__NET_WM_STATE_SHADED ||
+          second == display->atom__NET_WM_STATE_SHADED)
+        {
+          gboolean shade;
+          guint32 timestamp;
+
+          /* Stupid protocol has no timestamp; of course, shading
+           * sucks anyway so who really cares that we're forced to do
+           * a roundtrip here?
+           */
+          timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+          shade = (action == _NET_WM_STATE_ADD ||
+                   (action == _NET_WM_STATE_TOGGLE && !window->shaded));
+          if (shade && window->has_shade_func)
+            meta_window_shade (window, timestamp);
+          else
+            meta_window_unshade (window, timestamp);
+        }
+
+      if (first == display->atom__NET_WM_STATE_FULLSCREEN ||
+          second == display->atom__NET_WM_STATE_FULLSCREEN)
+        {
+          gboolean make_fullscreen;
+
+          make_fullscreen = (action == _NET_WM_STATE_ADD ||
+                             (action == _NET_WM_STATE_TOGGLE && !window->fullscreen));
+          if (make_fullscreen && window->has_fullscreen_func)
+            meta_window_make_fullscreen (window);
+          else
+            meta_window_unmake_fullscreen (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_MAXIMIZED_HORZ ||
+          second == display->atom__NET_WM_STATE_MAXIMIZED_HORZ)
+        {
+          gboolean max;
+
+          max = (action == _NET_WM_STATE_ADD ||
+                 (action == _NET_WM_STATE_TOGGLE &&
+                  !window->maximized_horizontally));
+          if (max && window->has_maximize_func)
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL);
+            }
+          else
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL);
+            }
+        }
+
+      if (first == display->atom__NET_WM_STATE_MAXIMIZED_VERT ||
+          second == display->atom__NET_WM_STATE_MAXIMIZED_VERT)
+        {
+          gboolean max;
+
+          max = (action == _NET_WM_STATE_ADD ||
+                 (action == _NET_WM_STATE_TOGGLE &&
+                  !window->maximized_vertically));
+          if (max && window->has_maximize_func)
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_maximize (window, META_MAXIMIZE_VERTICAL);
+            }
+          else
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL);
+            }
+        }
+
+      if (first == display->atom__NET_WM_STATE_MODAL ||
+          second == display->atom__NET_WM_STATE_MODAL)
+        {
+          window->wm_state_modal =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_modal);
+
+          recalc_window_type (window);
+          meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+        }
+
+      if (first == display->atom__NET_WM_STATE_SKIP_PAGER ||
+          second == display->atom__NET_WM_STATE_SKIP_PAGER)
+        {
+          window->wm_state_skip_pager =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->skip_pager);
+
+          recalc_window_features (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_SKIP_TASKBAR ||
+          second == display->atom__NET_WM_STATE_SKIP_TASKBAR)
+        {
+          window->wm_state_skip_taskbar =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->skip_taskbar);
+
+          recalc_window_features (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_ABOVE ||
+          second == display->atom__NET_WM_STATE_ABOVE)
+        {
+          window->wm_state_above =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_above);
+
+          meta_window_update_layer (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_BELOW ||
+          second == display->atom__NET_WM_STATE_BELOW)
+        {
+          window->wm_state_below =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_below);
+
+          meta_window_update_layer (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_DEMANDS_ATTENTION ||
+          second == display->atom__NET_WM_STATE_DEMANDS_ATTENTION)
+        {
+          if ((action == _NET_WM_STATE_ADD) ||
+              (action == _NET_WM_STATE_TOGGLE && !window->wm_state_demands_attention))
+            meta_window_set_demands_attention (window);
+          else
+            meta_window_unset_demands_attention (window);
+        }
+
+       if (first == display->atom__NET_WM_STATE_STICKY ||
+          second == display->atom__NET_WM_STATE_STICKY)
+        {
+          if ((action == _NET_WM_STATE_ADD) ||
+              (action == _NET_WM_STATE_TOGGLE && !window->on_all_workspaces))
+            meta_window_stick (window);
+          else
+            meta_window_unstick (window);
+        }
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom_WM_CHANGE_STATE)
+    {
+      meta_verbose ("WM_CHANGE_STATE client message, state: %ld\n",
+                    event->xclient.data.l[0]);
+      if (event->xclient.data.l[0] == IconicState &&
+          window->has_minimize_func)
+        meta_window_minimize (window);
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_MOVERESIZE)
+    {
+      int x_root;
+      int y_root;
+      int action;
+      MetaGrabOp op;
+      int button;
+      guint32 timestamp;
+
+      /* _NET_WM_MOVERESIZE messages are almost certainly going to come from
+       * clients when users click on the fake "frame" that the client has,
+       * thus we should also treat such messages as though it were a
+       * "frame action".
+       */
+      gboolean const frame_action = TRUE;
+
+      x_root = event->xclient.data.l[0];
+      y_root = event->xclient.data.l[1];
+      action = event->xclient.data.l[2];
+      button = event->xclient.data.l[3];
+
+      /* FIXME: What a braindead protocol; no timestamp?!? */
+      timestamp = meta_display_get_current_time_roundtrip (display);
+      meta_warning ("Received a _NET_WM_MOVERESIZE message for %s; these "
+                    "messages lack timestamps and therefore suck.\n",
+                    window->desc);
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Received _NET_WM_MOVERESIZE message on %s, %d,%d action = %d, button %d\n",
+                  window->desc,
+                  x_root, y_root, action, button);
+
+      op = META_GRAB_OP_NONE;
+      switch (action)
+        {
+        case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
+          op = META_GRAB_OP_RESIZING_NW;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_TOP:
+          op = META_GRAB_OP_RESIZING_N;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
+          op = META_GRAB_OP_RESIZING_NE;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_RIGHT:
+          op = META_GRAB_OP_RESIZING_E;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
+          op = META_GRAB_OP_RESIZING_SE;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
+          op = META_GRAB_OP_RESIZING_S;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
+          op = META_GRAB_OP_RESIZING_SW;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_LEFT:
+          op = META_GRAB_OP_RESIZING_W;
+          break;
+        case _NET_WM_MOVERESIZE_MOVE:
+          op = META_GRAB_OP_MOVING;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_KEYBOARD:
+          op = META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN;
+          break;
+        case _NET_WM_MOVERESIZE_MOVE_KEYBOARD:
+          op = META_GRAB_OP_KEYBOARD_MOVING;
+          break;
+        case _NET_WM_MOVERESIZE_CANCEL:
+          /* handled below */
+          break;
+        default:
+          break;
+        }
+
+      if (action == _NET_WM_MOVERESIZE_CANCEL)
+        {
+          meta_display_end_grab_op (window->display, timestamp);
+        }
+      else if (op != META_GRAB_OP_NONE &&
+          ((window->has_move_func && op == META_GRAB_OP_KEYBOARD_MOVING) ||
+           (window->has_resize_func && op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)))
+        {
+          meta_window_begin_grab_op (window, op, frame_action, timestamp);
+        }
+      else if (op != META_GRAB_OP_NONE &&
+               ((window->has_move_func && op == META_GRAB_OP_MOVING) ||
+               (window->has_resize_func &&
+                (op != META_GRAB_OP_MOVING &&
+                 op != META_GRAB_OP_KEYBOARD_MOVING))))
+        {
+          /*
+           * the button SHOULD already be included in the message
+           */
+          if (button == 0)
+            {
+              int x, y, query_root_x, query_root_y;
+              Window root, child;
+              guint mask;
+
+              /* The race conditions in this _NET_WM_MOVERESIZE thing
+               * are mind-boggling
+               */
+              mask = 0;
+              meta_error_trap_push (window->display);
+              XQueryPointer (window->display->xdisplay,
+                             window->xwindow,
+                             &root, &child,
+                             &query_root_x, &query_root_y,
+                             &x, &y,
+                             &mask);
+              meta_error_trap_pop (window->display, TRUE);
+
+              if (mask & Button1Mask)
+                button = 1;
+              else if (mask & Button2Mask)
+                button = 2;
+              else if (mask & Button3Mask)
+                button = 3;
+              else
+                button = 0;
+            }
+
+          if (button != 0)
+            {
+              meta_topic (META_DEBUG_WINDOW_OPS,
+                          "Beginning move/resize with button = %d\n", button);
+              meta_display_begin_grab_op (window->display,
+                                          window->screen,
+                                          window,
+                                          op,
+                                          FALSE,
+                                          frame_action,
+                                          button, 0,
+                                          timestamp,
+                                          x_root,
+                                          y_root);
+            }
+        }
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_MOVERESIZE_WINDOW)
+    {
+      int gravity, source;
+      guint value_mask;
+
+      gravity = (event->xclient.data.l[0] & 0xff);
+      value_mask = (event->xclient.data.l[0] & 0xf00) >> 8;
+      source = (event->xclient.data.l[0] & 0xf000) >> 12;
+
+      if (gravity == 0)
+        gravity = window->size_hints.win_gravity;
+
+      meta_window_move_resize_request(window,
+                                      value_mask,
+                                      gravity,
+                                      event->xclient.data.l[1],  /* x */
+                                      event->xclient.data.l[2],  /* y */
+                                      event->xclient.data.l[3],  /* width */
+                                      event->xclient.data.l[4]); /* height */
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_ACTIVE_WINDOW)
+    {
+      MetaClientType source_indication;
+      guint32        timestamp;
+
+      meta_verbose ("_NET_ACTIVE_WINDOW request for window '%s', activating\n",
+                    window->desc);
+
+      source_indication = event->xclient.data.l[0];
+      timestamp = event->xclient.data.l[1];
+
+      if (source_indication > META_CLIENT_TYPE_MAX_RECOGNIZED)
+        source_indication = META_CLIENT_TYPE_UNKNOWN;
+
+      if (timestamp == 0)
+        {
+          /* Client using older EWMH _NET_ACTIVE_WINDOW without a timestamp */
+          meta_warning ("Buggy client sent a _NET_ACTIVE_WINDOW message with a "
+                        "timestamp of 0 for %s\n",
+                        window->desc);
+          timestamp = meta_display_get_current_time (display);
+        }
+
+      window_activate (window, timestamp, source_indication, NULL);
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_FULLSCREEN_MONITORS)
+    {
+      MetaClientType source_indication;
+      gulong top, bottom, left, right;
+
+      meta_verbose ("_NET_WM_FULLSCREEN_MONITORS request for window '%s'\n",
+                    window->desc);
+
+      top = event->xclient.data.l[0];
+      bottom = event->xclient.data.l[1];
+      left = event->xclient.data.l[2];
+      right = event->xclient.data.l[3];
+      source_indication = event->xclient.data.l[4];
+
+      meta_window_update_fullscreen_monitors (window, top, bottom, left, right);
+    }
+
+  return FALSE;
+}
+
+gboolean
+meta_window_notify_focus (MetaWindow *window,
+                          XEvent     *event)
+{
+  /* note the event can be on either the window or the frame,
+   * we focus the frame for shaded windows
+   */
+
+  /* The event can be FocusIn, FocusOut, or UnmapNotify.
+   * On UnmapNotify we have to pretend it's focus out,
+   * because we won't get a focus out if it occurs, apparently.
+   */
+
+  /* We ignore grabs, though this is questionable.
+   * It may be better to increase the intelligence of
+   * the focus window tracking.
+   *
+   * The problem is that keybindings for windows are done with
+   * XGrabKey, which means focus_window disappears and the front of
+   * the MRU list gets confused from what the user expects once a
+   * keybinding is used.
+   */
+  meta_topic (META_DEBUG_FOCUS,
+              "Focus %s event received on %s 0x%lx (%s) "
+              "mode %s detail %s\n",
+              event->type == FocusIn ? "in" :
+              event->type == FocusOut ? "out" :
+              event->type == UnmapNotify ? "unmap" :
+              "???",
+              window->desc, event->xany.window,
+              event->xany.window == window->xwindow ?
+              "client window" :
+              (window->frame && event->xany.window == window->frame->xwindow) ?
+              "frame window" :
+              "unknown window",
+              event->type != UnmapNotify ?
+              meta_event_mode_to_string (event->xfocus.mode) : "n/a",
+              event->type != UnmapNotify ?
+              meta_event_detail_to_string (event->xfocus.detail) : "n/a");
+
+  /* FIXME our pointer tracking is broken; see how
+   * gtk+/gdk/x11/gdkevents-x11.c or XFree86/xc/programs/xterm/misc.c
+   * handle it for the correct way.  In brief you need to track
+   * pointer focus and regular focus, and handle EnterNotify in
+   * PointerRoot mode with no window manager.  However as noted above,
+   * accurate focus tracking will break things because we want to keep
+   * windows "focused" when using keybindings on them, and also we
+   * sometimes "focus" a window by focusing its frame or
+   * no_focus_window; so this all needs rethinking massively.
+   *
+   * My suggestion is to change it so that we clearly separate
+   * actual keyboard focus tracking using the xterm algorithm,
+   * and marco's "pretend" focus window, and go through all
+   * the code and decide which one should be used in each place;
+   * a hard bit is deciding on a policy for that.
+   *
+   * http://bugzilla.gnome.org/show_bug.cgi?id=90382
+   */
+
+  if ((event->type == FocusIn ||
+       event->type == FocusOut) &&
+      (event->xfocus.mode == NotifyGrab ||
+       event->xfocus.mode == NotifyUngrab ||
+       /* From WindowMaker, ignore all funky pointer root events */
+       event->xfocus.detail > NotifyNonlinearVirtual))
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Ignoring focus event generated by a grab or other weirdness\n");
+      return TRUE;
+    }
+
+  if (event->type == FocusIn)
+    {
+      if (window != window->display->focus_window)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "* Focus --> %s\n", window->desc);
+          window->display->focus_window = window;
+          window->has_focus = TRUE;
+          meta_compositor_set_active_window (window->display->compositor,
+                                             window->screen, window);
+
+          /* Move to the front of the focusing workspace's MRU list.
+           * We should only be "removing" it from the MRU list if it's
+           * not already there.  Note that it's possible that we might
+           * be processing this FocusIn after we've changed to a
+           * different workspace; we should therefore update the MRU
+           * list only if the window is actually on the active
+           * workspace.
+           */
+          if (window->screen->active_workspace &&
+              meta_window_located_on_workspace (window,
+                                                window->screen->active_workspace))
+            {
+              GList* link;
+              link = g_list_find (window->screen->active_workspace->mru_list,
+                                  window);
+              g_assert (link);
+
+              window->screen->active_workspace->mru_list =
+                g_list_remove_link (window->screen->active_workspace->mru_list,
+                                    link);
+              g_list_free (link);
+
+              window->screen->active_workspace->mru_list =
+                g_list_prepend (window->screen->active_workspace->mru_list,
+                                window);
+            }
+
+          if (window->frame)
+            meta_frame_queue_draw (window->frame);
+
+          meta_error_trap_push (window->display);
+          XInstallColormap (window->display->xdisplay,
+                            window->colormap);
+          meta_error_trap_pop (window->display, FALSE);
+
+          /* move into FOCUSED_WINDOW layer */
+          meta_window_update_layer (window);
+
+          /* Ungrab click to focus button since the sync grab can interfere
+           * with some things you might do inside the focused window, by
+           * causing the client to get funky enter/leave events.
+           *
+           * The reason we usually have a passive grab on the window is
+           * so that we can intercept clicks and raise the window in
+           * response. For click-to-focus we don't need that since the
+           * focused window is already raised. When raise_on_click is
+           * FALSE we also don't need that since we don't do anything
+           * when the window is clicked.
+           *
+           * There is dicussion in bugs 102209, 115072, and 461577
+           */
+          if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+              !meta_prefs_get_raise_on_click())
+            meta_display_ungrab_focus_window_button (window->display, window);
+        }
+    }
+  else if (event->type == FocusOut ||
+           event->type == UnmapNotify)
+    {
+      if (event->type == FocusOut &&
+          event->xfocus.detail == NotifyInferior)
+        {
+          /* This event means the client moved focus to a subwindow */
+          meta_topic (META_DEBUG_FOCUS,
+                      "Ignoring focus out on %s with NotifyInferior\n",
+                      window->desc);
+          return TRUE;
+        }
+
+      if (window == window->display->focus_window)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "%s is now the previous focus window due to being focused out or unmapped\n",
+                      window->desc);
+
+          meta_topic (META_DEBUG_FOCUS,
+                      "* Focus --> NULL (was %s)\n", window->desc);
+
+          window->display->focus_window = NULL;
+          window->has_focus = FALSE;
+          if (window->frame)
+            meta_frame_queue_draw (window->frame);
+
+          meta_compositor_set_active_window (window->display->compositor,
+                                             window->screen, NULL);
+
+          meta_error_trap_push (window->display);
+          XUninstallColormap (window->display->xdisplay,
+                              window->colormap);
+          meta_error_trap_pop (window->display, FALSE);
+
+          /* move out of FOCUSED_WINDOW layer */
+          meta_window_update_layer (window);
+
+          /* Re-grab for click to focus and raise-on-click, if necessary */
+          if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+              !meta_prefs_get_raise_on_click ())
+            meta_display_grab_focus_window_button (window->display, window);
+       }
+    }
+
+  /* Now set _NET_ACTIVE_WINDOW hint */
+  meta_display_update_active_window_hint (window->display);
+
+  return FALSE;
+}
+
+static gboolean
+process_property_notify (MetaWindow     *window,
+                         XPropertyEvent *event)
+{
+  Window xid = window->xwindow;
+
+  if (meta_is_verbose ()) /* avoid looking up the name if we don't have to */
+    {
+      char *property_name = XGetAtomName (window->display->xdisplay,
+                                          event->atom);
+
+      meta_verbose ("Property notify on %s for %s\n",
+                    window->desc, property_name);
+      XFree (property_name);
+    }
+
+  if (event->atom == window->display->atom__NET_WM_USER_TIME &&
+      window->user_time_window)
+    {
+      xid = window->user_time_window;
+    }
+
+  meta_window_reload_property (window, event->atom, FALSE);
+
+  return TRUE;
+}
+
+static void
+send_configure_notify (MetaWindow *window)
+{
+  XEvent event;
+
+  /* from twm */
+
+  event.type = ConfigureNotify;
+  event.xconfigure.display = window->display->xdisplay;
+  event.xconfigure.event = window->xwindow;
+  event.xconfigure.window = window->xwindow;
+  event.xconfigure.x = window->rect.x - window->border_width;
+  event.xconfigure.y = window->rect.y - window->border_width;
+  if (window->frame)
+    {
+      if (window->withdrawn)
+        {
+          /* WARNING: x & y need to be set to whatever the XReparentWindow
+           * call in meta_window_destroy_frame will use so that the window
+           * has the right coordinates.  Currently, that means no change to
+           * x & y.
+           */
+        }
+      else
+        {
+          /* Need to be in root window coordinates */
+          event.xconfigure.x += window->frame->rect.x;
+          event.xconfigure.y += window->frame->rect.y;
+        }
+    }
+  event.xconfigure.width = window->rect.width;
+  event.xconfigure.height = window->rect.height;
+  event.xconfigure.border_width = window->border_width; /* requested not actual */
+  event.xconfigure.above = None; /* FIXME */
+  event.xconfigure.override_redirect = False;
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Sending synthetic configure notify to %s with x: %d y: %d w: %d h: %d\n",
+              window->desc,
+              event.xconfigure.x, event.xconfigure.y,
+              event.xconfigure.width, event.xconfigure.height);
+
+  meta_error_trap_push (window->display);
+  XSendEvent (window->display->xdisplay,
+              window->xwindow,
+              False, StructureNotifyMask, &event);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+gboolean
+meta_window_get_icon_geometry (MetaWindow    *window,
+                               MetaRectangle *rect)
+{
+  gulong *geometry = NULL;
+  int nitems;
+
+  if (meta_prop_get_cardinal_list (window->display,
+                                   window->xwindow,
+                                   window->display->atom__NET_WM_ICON_GEOMETRY,
+                                   &geometry, &nitems))
+    {
+      if (nitems != 4)
+        {
+          meta_verbose ("_NET_WM_ICON_GEOMETRY on %s has %d values instead of 4\n",
+                        window->desc, nitems);
+          meta_XFree (geometry);
+          return FALSE;
+        }
+
+      if (rect)
+        {
+          rect->x = geometry[0];
+          rect->y = geometry[1];
+          rect->width = geometry[2];
+          rect->height = geometry[3];
+        }
+
+      meta_XFree (geometry);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static Window
+read_client_leader (MetaDisplay *display,
+                    Window       xwindow)
+{
+  Window retval = None;
+
+  meta_prop_get_window (display, xwindow,
+                        display->atom_WM_CLIENT_LEADER,
+                        &retval);
+
+  return retval;
+}
+
+typedef struct
+{
+  Window leader;
+} ClientLeaderData;
+
+static gboolean
+find_client_leader_func (MetaWindow *ancestor,
+                         void       *data)
+{
+  ClientLeaderData *d;
+
+  d = data;
+
+  d->leader = read_client_leader (ancestor->display,
+                                  ancestor->xwindow);
+
+  /* keep going if no client leader found */
+  return d->leader == None;
+}
+
+static void
+update_sm_hints (MetaWindow *window)
+{
+  Window leader;
+
+  window->xclient_leader = None;
+  window->sm_client_id = NULL;
+
+  /* If not on the current window, we can get the client
+   * leader from transient parents. If we find a client
+   * leader, we read the SM_CLIENT_ID from it.
+   */
+  leader = read_client_leader (window->display, window->xwindow);
+  if (leader == None)
+    {
+      ClientLeaderData d;
+      d.leader = None;
+      meta_window_foreach_ancestor (window, find_client_leader_func,
+                                    &d);
+      leader = d.leader;
+    }
+
+  if (leader != None)
+    {
+      char *str;
+
+      window->xclient_leader = leader;
+
+      if (meta_prop_get_latin1_string (window->display, leader,
+                                       window->display->atom_SM_CLIENT_ID,
+                                       &str))
+        {
+          window->sm_client_id = g_strdup (str);
+          meta_XFree (str);
+        }
+    }
+  else
+    {
+      meta_verbose ("Didn't find a client leader for %s\n", window->desc);
+
+      if (!meta_prefs_get_disable_workarounds ())
+        {
+          /* Some broken apps (kdelibs fault?) set SM_CLIENT_ID on the app
+           * instead of the client leader
+           */
+          char *str;
+
+          str = NULL;
+          if (meta_prop_get_latin1_string (window->display, window->xwindow,
+                                           window->display->atom_SM_CLIENT_ID,
+                                           &str))
+            {
+              if (window->sm_client_id == NULL) /* first time through */
+                meta_warning (_("Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER window as specified in the ICCCM.\n"),
+                              window->desc);
+
+              window->sm_client_id = g_strdup (str);
+              meta_XFree (str);
+            }
+        }
+    }
+
+  meta_verbose ("Window %s client leader: 0x%lx SM_CLIENT_ID: '%s'\n",
+                window->desc, window->xclient_leader,
+                window->sm_client_id ? window->sm_client_id : "none");
+}
+
+void
+meta_window_update_role (MetaWindow *window)
+{
+  char *str;
+
+  if (window->role)
+    g_free (window->role);
+  window->role = NULL;
+
+  if (meta_prop_get_latin1_string (window->display, window->xwindow,
+                                   window->display->atom_WM_WINDOW_ROLE,
+                                   &str))
+    {
+      window->role = g_strdup (str);
+      meta_XFree (str);
+    }
+
+  meta_verbose ("Updated role of %s to '%s'\n",
+                window->desc, window->role ? window->role : "null");
+}
+
+void
+meta_window_update_net_wm_type (MetaWindow *window)
+{
+  int n_atoms;
+  Atom *atoms;
+  int i;
+
+  window->type_atom = None;
+  n_atoms = 0;
+  atoms = NULL;
+
+  meta_prop_get_atom_list (window->display, window->xwindow,
+                           window->display->atom__NET_WM_WINDOW_TYPE,
+                           &atoms, &n_atoms);
+
+  i = 0;
+  while (i < n_atoms)
+    {
+      /* We break as soon as we find one we recognize,
+       * supposed to prefer those near the front of the list
+       */
+      if (atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DOCK ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_MENU ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+        {
+          window->type_atom = atoms[i];
+          break;
+        }
+
+      ++i;
+    }
+
+  meta_XFree (atoms);
+
+  if (meta_is_verbose ())
+    {
+      char *str;
+
+      str = NULL;
+      if (window->type_atom != None)
+        {
+          meta_error_trap_push (window->display);
+          str = XGetAtomName (window->display->xdisplay, window->type_atom);
+          meta_error_trap_pop (window->display, TRUE);
+        }
+
+      meta_verbose ("Window %s type atom %s\n", window->desc,
+                    str ? str : "(none)");
+
+      if (str)
+        meta_XFree (str);
+    }
+
+  meta_window_recalc_window_type (window);
+}
+
+static void
+redraw_icon (MetaWindow *window)
+{
+  /* We could probably be smart and just redraw the icon here,
+   * instead of the whole frame.
+   */
+  if (window->frame && (window->mapped || window->frame->mapped))
+    meta_ui_queue_frame_draw (window->screen->ui, window->frame->xwindow);
+}
+
+void
+meta_window_update_icon_now (MetaWindow *window)
+{
+  GdkPixbuf *icon;
+  GdkPixbuf *mini_icon;
+
+  icon = NULL;
+  mini_icon = NULL;
+
+  if (meta_read_icons (window->screen,
+                       window->xwindow,
+                       &window->icon_cache,
+                       window->wm_hints_pixmap,
+                       window->wm_hints_mask,
+                       &icon,
+                       META_ICON_WIDTH, META_ICON_HEIGHT,
+                       &mini_icon,
+                       META_MINI_ICON_WIDTH,
+                       META_MINI_ICON_HEIGHT))
+    {
+      if (window->icon)
+        g_object_unref (G_OBJECT (window->icon));
+
+      if (window->mini_icon)
+        g_object_unref (G_OBJECT (window->mini_icon));
+
+      window->icon = icon;
+      window->mini_icon = mini_icon;
+
+      redraw_icon (window);
+    }
+
+  g_assert (window->icon);
+  g_assert (window->mini_icon);
+}
+
+static gboolean
+idle_update_icon (gpointer data)
+{
+  GSList *tmp;
+  GSList *copy;
+  guint queue_index = GPOINTER_TO_INT (data);
+
+  meta_topic (META_DEBUG_GEOMETRY, "Clearing the update_icon queue\n");
+
+  /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+   * complete; destroying a window while we're in here would result in
+   * badness. But it's OK to queue/unqueue update_icons.
+   */
+  copy = g_slist_copy (queue_pending[queue_index]);
+  g_slist_free (queue_pending[queue_index]);
+  queue_pending[queue_index] = NULL;
+  queue_idle[queue_index] = 0;
+
+  destroying_windows_disallowed += 1;
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      meta_window_update_icon_now (window);
+      window->is_in_queues &= ~META_QUEUE_UPDATE_ICON;
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (copy);
+
+  destroying_windows_disallowed -= 1;
+
+  return FALSE;
+}
+
+GList*
+meta_window_get_workspaces (MetaWindow *window)
+{
+  if (window->on_all_workspaces)
+    return window->screen->workspaces;
+  else
+    return window->workspace->list_containing_self;
+}
+
+static void
+invalidate_work_areas (MetaWindow *window)
+{
+  GList *tmp;
+
+  tmp = meta_window_get_workspaces (window);
+
+  while (tmp != NULL)
+    {
+      meta_workspace_invalidate_work_area (tmp->data);
+      tmp = tmp->next;
+    }
+}
+
+void
+meta_window_update_struts (MetaWindow *window)
+{
+  GSList *old_struts;
+  GSList *new_struts;
+  GSList *old_iter, *new_iter;
+  gulong *struts = NULL;
+  int nitems;
+  gboolean changed;
+
+  meta_verbose ("Updating struts for %s\n", window->desc);
+
+  old_struts = window->struts;
+  new_struts = NULL;
+
+  if (meta_prop_get_cardinal_list (window->display,
+                                   window->xwindow,
+                                   window->display->atom__NET_WM_STRUT_PARTIAL,
+                                   &struts, &nitems))
+    {
+      if (nitems != 12)
+        meta_verbose ("_NET_WM_STRUT_PARTIAL on %s has %d values instead "
+                      "of 12\n",
+                      window->desc, nitems);
+      else
+        {
+          /* Pull out the strut info for each side in the hint */
+          int i;
+          for (i=0; i<4; i++)
+            {
+              MetaStrut *temp;
+              int thickness, strut_begin, strut_end;
+
+              thickness = struts[i];
+              if (thickness == 0)
+                continue;
+              strut_begin = struts[4+(i*2)];
+              strut_end   = struts[4+(i*2)+1];
+
+              temp = g_new (MetaStrut, 1);
+              temp->side = 1 << i; /* See MetaSide def.  Matches nicely, eh? */
+              temp->rect = window->screen->rect;
+              switch (temp->side)
+                {
+                case META_SIDE_RIGHT:
+                  temp->rect.x = BOX_RIGHT(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_LEFT:
+                  temp->rect.width  = thickness;
+                  temp->rect.y      = strut_begin;
+                  temp->rect.height = strut_end - strut_begin + 1;
+                  break;
+                case META_SIDE_BOTTOM:
+                  temp->rect.y = BOX_BOTTOM(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_TOP:
+                  temp->rect.height = thickness;
+                  temp->rect.x      = strut_begin;
+                  temp->rect.width  = strut_end - strut_begin + 1;
+                  break;
+                default:
+                  g_assert_not_reached ();
+                }
+
+              new_struts = g_slist_prepend (new_struts, temp);
+            }
+
+          meta_verbose ("_NET_WM_STRUT_PARTIAL struts %lu %lu %lu %lu for "
+                        "window %s\n",
+                        struts[0], struts[1], struts[2], struts[3],
+                        window->desc);
+        }
+      meta_XFree (struts);
+    }
+  else
+    {
+      meta_verbose ("No _NET_WM_STRUT property for %s\n",
+                    window->desc);
+    }
+
+  if (!new_struts &&
+      meta_prop_get_cardinal_list (window->display,
+                                   window->xwindow,
+                                   window->display->atom__NET_WM_STRUT,
+                                   &struts, &nitems))
+    {
+      if (nitems != 4)
+        meta_verbose ("_NET_WM_STRUT on %s has %d values instead of 4\n",
+                      window->desc, nitems);
+      else
+        {
+          /* Pull out the strut info for each side in the hint */
+          int i;
+          for (i=0; i<4; i++)
+            {
+              MetaStrut *temp;
+              int thickness;
+
+              thickness = struts[i];
+              if (thickness == 0)
+                continue;
+
+              temp = g_new (MetaStrut, 1);
+              temp->side = 1 << i;
+              temp->rect = window->screen->rect;
+              switch (temp->side)
+                {
+                case META_SIDE_RIGHT:
+                  temp->rect.x = BOX_RIGHT(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_LEFT:
+                  temp->rect.width  = thickness;
+                  break;
+                case META_SIDE_BOTTOM:
+                  temp->rect.y = BOX_BOTTOM(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_TOP:
+                  temp->rect.height = thickness;
+                  break;
+                default:
+                  g_assert_not_reached ();
+                }
+
+              new_struts = g_slist_prepend (new_struts, temp);
+            }
+
+          meta_verbose ("_NET_WM_STRUT struts %lu %lu %lu %lu for window %s\n",
+                        struts[0], struts[1], struts[2], struts[3],
+                        window->desc);
+        }
+      meta_XFree (struts);
+    }
+  else if (!new_struts)
+    {
+      meta_verbose ("No _NET_WM_STRUT property for %s\n",
+                    window->desc);
+    }
+
+  /* Determine whether old_struts and new_struts are the same */
+  old_iter = old_struts;
+  new_iter = new_struts;
+  while (old_iter && new_iter)
+    {
+      MetaStrut *old_strut = (MetaStrut*) old_iter->data;
+      MetaStrut *new_strut = (MetaStrut*) new_iter->data;
+
+      if (old_strut->side != new_strut->side ||
+          !meta_rectangle_equal (&old_strut->rect, &new_strut->rect))
+        break;
+
+      old_iter = old_iter->next;
+      new_iter = new_iter->next;
+    }
+  changed = (old_iter != NULL || new_iter != NULL);
+
+  /* Update appropriately */
+  meta_free_gslist_and_elements (old_struts);
+  window->struts = new_struts;
+  if (changed)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Invalidating work areas of window %s due to struts update\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Struts on %s were unchanged\n", window->desc);
+    }
+}
+
+void
+meta_window_recalc_window_type (MetaWindow *window)
+{
+  recalc_window_type (window);
+}
+
+static void
+recalc_window_type (MetaWindow *window)
+{
+  MetaWindowType old_type;
+
+  old_type = window->type;
+
+  if (window->type_atom != None)
+    {
+      if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP)
+        window->type = META_WINDOW_DESKTOP;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DOCK)
+        window->type = META_WINDOW_DOCK;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR)
+        window->type = META_WINDOW_TOOLBAR;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_MENU)
+        window->type = META_WINDOW_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
+        window->type = META_WINDOW_DIALOG;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
+        window->type = META_WINDOW_NORMAL;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY)
+        window->type = META_WINDOW_UTILITY;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+        window->type = META_WINDOW_SPLASHSCREEN;
+      else
+        meta_bug ("Set a type atom for %s that wasn't handled in recalc_window_type\n",
+                  window->desc);
+    }
+  else if (window->xtransient_for != None)
+    {
+      window->type = META_WINDOW_DIALOG;
+    }
+  else
+    {
+      window->type = META_WINDOW_NORMAL;
+    }
+
+  if (window->type == META_WINDOW_DIALOG &&
+      window->wm_state_modal)
+    window->type = META_WINDOW_MODAL_DIALOG;
+
+  meta_verbose ("Calculated type %u for %s, old type %u\n",
+                window->type, window->desc, old_type);
+
+  if (old_type != window->type)
+    {
+      recalc_window_features (window);
+
+      set_net_wm_state (window);
+
+      /* Update frame */
+      if (window->decorated)
+        meta_window_ensure_frame (window);
+      else
+        meta_window_destroy_frame (window);
+
+      /* update stacking constraints */
+      meta_window_update_layer (window);
+
+      meta_window_grab_keys (window);
+    }
+}
+
+static void
+set_allowed_actions_hint (MetaWindow *window)
+{
+#define MAX_N_ACTIONS 12
+  unsigned long data[MAX_N_ACTIONS];
+  int i;
+
+  i = 0;
+  if (window->has_move_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_MOVE;
+      ++i;
+    }
+  if (window->has_resize_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_RESIZE;
+      ++i;
+    }
+  if (window->has_fullscreen_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_FULLSCREEN;
+      ++i;
+    }
+  if (window->has_minimize_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_MINIMIZE;
+      ++i;
+    }
+  if (window->has_shade_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_SHADE;
+      ++i;
+    }
+  /* sticky according to EWMH is different from marco's sticky;
+   * marco doesn't support EWMH sticky
+   */
+  if (window->has_maximize_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_MAXIMIZE_HORZ;
+      ++i;
+      data[i] = window->display->atom__NET_WM_ACTION_MAXIMIZE_VERT;
+      ++i;
+    }
+  /* We always allow this */
+  data[i] = window->display->atom__NET_WM_ACTION_CHANGE_DESKTOP;
+  ++i;
+  if (window->has_close_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_CLOSE;
+      ++i;
+    }
+
+  /* I guess we always allow above/below operations */
+  data[i] = window->display->atom__NET_WM_ACTION_ABOVE;
+  ++i;
+  data[i] = window->display->atom__NET_WM_ACTION_BELOW;
+  ++i;
+
+  g_assert (i <= MAX_N_ACTIONS);
+
+  meta_verbose ("Setting _NET_WM_ALLOWED_ACTIONS with %d atoms\n", i);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_WM_ALLOWED_ACTIONS,
+                   XA_ATOM,
+                   32, PropModeReplace, (guchar*) data, i);
+  meta_error_trap_pop (window->display, FALSE);
+#undef MAX_N_ACTIONS
+}
+
+void
+meta_window_recalc_features (MetaWindow *window)
+{
+  recalc_window_features (window);
+}
+
+static void
+recalc_window_features (MetaWindow *window)
+{
+  gboolean old_has_close_func;
+  gboolean old_has_minimize_func;
+  gboolean old_has_move_func;
+  gboolean old_has_resize_func;
+  gboolean old_has_shade_func;
+  gboolean old_always_sticky;
+
+  old_has_close_func = window->has_close_func;
+  old_has_minimize_func = window->has_minimize_func;
+  old_has_move_func = window->has_move_func;
+  old_has_resize_func = window->has_resize_func;
+  old_has_shade_func = window->has_shade_func;
+  old_always_sticky = window->always_sticky;
+
+  /* Use MWM hints initially */
+  window->decorated = window->mwm_decorated;
+  window->border_only = window->mwm_border_only;
+  window->has_close_func = window->mwm_has_close_func;
+  window->has_minimize_func = window->mwm_has_minimize_func;
+  window->has_maximize_func = window->mwm_has_maximize_func;
+  window->has_move_func = window->mwm_has_move_func;
+
+  window->has_resize_func = TRUE;
+
+  /* If min_size == max_size, then don't allow resize */
+  if (window->size_hints.min_width == window->size_hints.max_width &&
+      window->size_hints.min_height == window->size_hints.max_height)
+    window->has_resize_func = FALSE;
+  else if (!window->mwm_has_resize_func)
+    {
+      /* We ignore mwm_has_resize_func because WM_NORMAL_HINTS is the
+       * authoritative source for that info. Some apps such as mplayer or
+       * xine disable resize via MWM but not WM_NORMAL_HINTS, but that
+       * leads to e.g. us not fullscreening their windows.  Apps that set
+       * MWM but not WM_NORMAL_HINTS are basically broken. We complain
+       * about these apps but make them work.
+       */
+
+      meta_warning (_("Window %s sets an MWM hint indicating it isn't resizable, but sets min size %d x %d and max size %d x %d; this doesn't make much sense.\n"),
+                    window->desc,
+                    window->size_hints.min_width,
+                    window->size_hints.min_height,
+                    window->size_hints.max_width,
+                    window->size_hints.max_height);
+    }
+
+  window->has_shade_func = TRUE;
+  window->has_fullscreen_func = TRUE;
+
+  window->always_sticky = FALSE;
+
+  /* Semantic category overrides the MWM hints */
+  if (window->type == META_WINDOW_TOOLBAR)
+    window->decorated = FALSE;
+
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    window->always_sticky = TRUE;
+
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK ||
+      window->type == META_WINDOW_SPLASHSCREEN)
+    {
+      window->decorated = FALSE;
+      window->has_close_func = FALSE;
+      window->has_shade_func = FALSE;
+
+      /* FIXME this keeps panels and things from using
+       * NET_WM_MOVERESIZE; the problem is that some
+       * panels (edge panels) have fixed possible locations,
+       * and others ("floating panels") do not.
+       *
+       * Perhaps we should require edge panels to explicitly
+       * disable movement?
+       */
+      window->has_move_func = FALSE;
+      window->has_resize_func = FALSE;
+    }
+
+  if (window->type != META_WINDOW_NORMAL)
+    {
+      window->has_minimize_func = FALSE;
+      window->has_maximize_func = FALSE;
+      window->has_fullscreen_func = FALSE;
+    }
+
+  if (!window->has_resize_func)
+    {
+      window->has_maximize_func = FALSE;
+
+      /* don't allow fullscreen if we can't resize, unless the size
+       * is entire screen size (kind of broken, because we
+       * actually fullscreen to xinerama head size not screen size)
+       */
+      if (window->size_hints.min_width == window->screen->rect.width &&
+          window->size_hints.min_height == window->screen->rect.height)
+        ; /* leave fullscreen available */
+      else
+        window->has_fullscreen_func = FALSE;
+    }
+
+  /* We leave fullscreen windows decorated, just push the frame outside
+   * the screen. This avoids flickering to unparent them.
+   *
+   * Note that setting has_resize_func = FALSE here must come after the
+   * above code that may disable fullscreen, because if the window
+   * is not resizable purely due to fullscreen, we don't want to
+   * disable fullscreen mode.
+   */
+  if (window->fullscreen)
+    {
+      window->has_shade_func = FALSE;
+      window->has_move_func = FALSE;
+      window->has_resize_func = FALSE;
+      window->has_maximize_func = FALSE;
+    }
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Window %s fullscreen = %d not resizable, maximizable = %d fullscreenable = %d min size %dx%d max size %dx%d\n",
+              window->desc,
+              window->fullscreen,
+              window->has_maximize_func, window->has_fullscreen_func,
+              window->size_hints.min_width,
+              window->size_hints.min_height,
+              window->size_hints.max_width,
+              window->size_hints.max_height);
+
+  /* no shading if not decorated */
+  if (!window->decorated || window->border_only)
+    window->has_shade_func = FALSE;
+
+  window->skip_taskbar = FALSE;
+  window->skip_pager = FALSE;
+
+  if (window->wm_state_skip_taskbar)
+    window->skip_taskbar = TRUE;
+
+  if (window->wm_state_skip_pager)
+    window->skip_pager = TRUE;
+
+  switch (window->type)
+    {
+      /* Force skip taskbar/pager on these window types */
+    case META_WINDOW_DESKTOP:
+    case META_WINDOW_DOCK:
+    case META_WINDOW_TOOLBAR:
+    case META_WINDOW_MENU:
+    case META_WINDOW_UTILITY:
+    case META_WINDOW_SPLASHSCREEN:
+      window->skip_taskbar = TRUE;
+      window->skip_pager = TRUE;
+      break;
+
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+      /* only skip taskbar if we have a real transient parent */
+      if (window->xtransient_for != None &&
+          window->xtransient_for != window->screen->xroot)
+        window->skip_taskbar = TRUE;
+      break;
+
+    case META_WINDOW_NORMAL:
+      break;
+    }
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Window %s decorated = %d border_only = %d has_close = %d has_minimize = %d has_maximize = %d has_move = %d has_shade = %d skip_taskbar = %d skip_pager = %d\n",
+              window->desc,
+              window->decorated,
+              window->border_only,
+              window->has_close_func,
+              window->has_minimize_func,
+              window->has_maximize_func,
+              window->has_move_func,
+              window->has_shade_func,
+              window->skip_taskbar,
+              window->skip_pager);
+
+  /* FIXME:
+   * Lame workaround for recalc_window_features
+   * being used overzealously. The fix is to
+   * only recalc_window_features when something
+   * has actually changed.
+   */
+  if (window->constructing                               ||
+      old_has_close_func != window->has_close_func       ||
+      old_has_minimize_func != window->has_minimize_func ||
+      old_has_move_func != window->has_move_func         ||
+      old_has_resize_func != window->has_resize_func     ||
+      old_has_shade_func != window->has_shade_func       ||
+      old_always_sticky != window->always_sticky)
+    set_allowed_actions_hint (window);
+
+  /* FIXME perhaps should ensure if we don't have a shade func,
+   * we aren't shaded, etc.
+   */
+}
+
+static void
+menu_callback (MetaWindowMenu *menu,
+               Display        *xdisplay,
+               Window          client_xwindow,
+               guint32         timestamp,
+               MetaMenuOp      op,
+               int             workspace_index,
+               gpointer        data)
+{
+  MetaDisplay *display;
+  MetaWindow *window;
+  MetaWorkspace *workspace;
+
+  display = meta_display_for_x_display (xdisplay);
+  window = meta_display_lookup_x_window (display, client_xwindow);
+  workspace = NULL;
+
+  if (window != NULL) /* window can be NULL */
+    {
+      meta_verbose ("Menu op %u on %s\n", op, window->desc);
+
+      switch (op)
+        {
+        case META_MENU_OP_NONE:
+          /* nothing */
+          break;
+
+        case META_MENU_OP_DELETE:
+          meta_window_delete (window, timestamp);
+          break;
+
+        case META_MENU_OP_MINIMIZE:
+          meta_window_minimize (window);
+          break;
+
+        case META_MENU_OP_UNMAXIMIZE:
+          meta_window_unmaximize (window,
+                                  META_MAXIMIZE_HORIZONTAL |
+                                  META_MAXIMIZE_VERTICAL);
+          break;
+
+        case META_MENU_OP_MAXIMIZE:
+          meta_window_maximize (window,
+                                META_MAXIMIZE_HORIZONTAL |
+                                META_MAXIMIZE_VERTICAL);
+          break;
+
+        case META_MENU_OP_UNSHADE:
+          meta_window_unshade (window, timestamp);
+          break;
+
+        case META_MENU_OP_SHADE:
+          meta_window_shade (window, timestamp);
+          break;
+
+        case META_MENU_OP_MOVE_LEFT:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_LEFT);
+          break;
+
+        case META_MENU_OP_MOVE_RIGHT:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_RIGHT);
+          break;
+
+        case META_MENU_OP_MOVE_UP:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_UP);
+          break;
+
+        case META_MENU_OP_MOVE_DOWN:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_DOWN);
+          break;
+
+        case META_MENU_OP_WORKSPACES:
+          workspace = meta_screen_get_workspace_by_index (window->screen,
+                                                          workspace_index);
+          break;
+
+        case META_MENU_OP_STICK:
+          meta_window_stick (window);
+          break;
+
+        case META_MENU_OP_UNSTICK:
+          meta_window_unstick (window);
+          break;
+
+        case META_MENU_OP_ABOVE:
+        case META_MENU_OP_UNABOVE:
+          if (window->wm_state_above == FALSE)
+            meta_window_make_above (window);
+          else
+            meta_window_unmake_above (window);
+          break;
+
+        case META_MENU_OP_MOVE:
+          meta_window_begin_grab_op (window,
+                                     META_GRAB_OP_KEYBOARD_MOVING,
+                                     TRUE,
+                                     timestamp);
+          break;
+
+        case META_MENU_OP_RESIZE:
+          meta_window_begin_grab_op (window,
+                                     META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+                                     TRUE,
+                                     timestamp);
+          break;
+
+        case META_MENU_OP_RECOVER:
+          meta_window_shove_titlebar_onscreen (window);
+          break;
+
+        default:
+          meta_warning (G_STRLOC": Unknown window op\n");
+          break;
+        }
+
+      if (workspace)
+	{
+	  meta_window_change_workspace (window,
+					workspace);
+#if 0
+	  meta_workspace_activate (workspace);
+	  meta_window_raise (window);
+#endif
+	}
+    }
+  else
+    {
+      meta_verbose ("Menu callback on nonexistent window\n");
+    }
+
+  if (display->window_menu == menu)
+    {
+      display->window_menu = NULL;
+      display->window_with_menu = NULL;
+    }
+
+  meta_ui_window_menu_free (menu);
+}
+
+void
+meta_window_show_menu (MetaWindow *window,
+                       int         root_x,
+                       int         root_y,
+                       int         button,
+                       guint32     timestamp)
+{
+  MetaMenuOp ops;
+  MetaMenuOp insensitive;
+  MetaWindowMenu *menu;
+  MetaWorkspaceLayout layout;
+  int n_workspaces;
+  gboolean ltr;
+
+  if (window->display->window_menu)
+    {
+      meta_ui_window_menu_free (window->display->window_menu);
+      window->display->window_menu = NULL;
+      window->display->window_with_menu = NULL;
+    }
+
+  ops = META_MENU_OP_NONE;
+  insensitive = META_MENU_OP_NONE;
+
+  ops |= (META_MENU_OP_DELETE | META_MENU_OP_MINIMIZE | META_MENU_OP_MOVE | META_MENU_OP_RESIZE);
+
+  if (!meta_window_titlebar_is_onscreen (window) &&
+      window->type != META_WINDOW_DOCK &&
+      window->type != META_WINDOW_DESKTOP)
+    ops |= META_MENU_OP_RECOVER;
+
+  n_workspaces = meta_screen_get_n_workspaces (window->screen);
+
+  if (n_workspaces > 1)
+    ops |= META_MENU_OP_WORKSPACES;
+
+  meta_screen_calc_workspace_layout (window->screen,
+                                     n_workspaces,
+                                     meta_workspace_index ( window->screen->active_workspace),
+                                     &layout);
+
+  if (!window->on_all_workspaces)
+    {
+      ltr = meta_ui_get_direction() == META_UI_DIRECTION_LTR;
+
+      if (layout.current_col > 0)
+        ops |= ltr ? META_MENU_OP_MOVE_LEFT : META_MENU_OP_MOVE_RIGHT;
+      if ((layout.current_col < layout.cols - 1) &&
+          (layout.current_row * layout.cols + (layout.current_col + 1) < n_workspaces))
+        ops |= ltr ? META_MENU_OP_MOVE_RIGHT : META_MENU_OP_MOVE_LEFT;
+      if (layout.current_row > 0)
+        ops |= META_MENU_OP_MOVE_UP;
+      if ((layout.current_row < layout.rows - 1) &&
+          ((layout.current_row + 1) * layout.cols + layout.current_col < n_workspaces))
+        ops |= META_MENU_OP_MOVE_DOWN;
+    }
+
+  meta_screen_free_workspace_layout (&layout);
+
+  if (META_WINDOW_MAXIMIZED (window))
+    ops |= META_MENU_OP_UNMAXIMIZE;
+  else
+    ops |= META_MENU_OP_MAXIMIZE;
+
+#if 0
+  if (window->shaded)
+    ops |= META_MENU_OP_UNSHADE;
+  else
+    ops |= META_MENU_OP_SHADE;
+#endif
+
+  ops |= META_MENU_OP_UNSTICK;
+  ops |= META_MENU_OP_STICK;
+
+  if (window->wm_state_above)
+    ops |= META_MENU_OP_UNABOVE;
+  else
+    ops |= META_MENU_OP_ABOVE;
+
+  if (!window->has_maximize_func)
+    insensitive |= META_MENU_OP_UNMAXIMIZE | META_MENU_OP_MAXIMIZE;
+
+  /*if (!window->has_minimize_func)
+    insensitive |= META_MENU_OP_MINIMIZE;*/
+
+  /*if (!window->has_close_func)
+    insensitive |= META_MENU_OP_DELETE;*/
+
+  if (!window->has_shade_func)
+    insensitive |= META_MENU_OP_SHADE | META_MENU_OP_UNSHADE;
+
+  if (!META_WINDOW_ALLOWS_MOVE (window))
+    insensitive |= META_MENU_OP_MOVE;
+
+  if (!META_WINDOW_ALLOWS_RESIZE (window))
+    insensitive |= META_MENU_OP_RESIZE;
+
+   if (window->always_sticky)
+     insensitive |= META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES;
+
+  if ((window->type == META_WINDOW_DESKTOP) ||
+      (window->type == META_WINDOW_DOCK) ||
+      (window->type == META_WINDOW_SPLASHSCREEN))
+    insensitive |= META_MENU_OP_ABOVE | META_MENU_OP_UNABOVE;
+
+  /* If all operations are disabled, just quit without showing the menu.
+   * This is the case, for example, with META_WINDOW_DESKTOP windows.
+   */
+  if ((ops & ~insensitive) == 0)
+    return;
+
+  menu =
+    meta_ui_window_menu_new (window->screen->ui,
+                             window->xwindow,
+                             ops,
+                             insensitive,
+                             meta_window_get_net_wm_desktop (window),
+                             meta_screen_get_n_workspaces (window->screen),
+                             menu_callback,
+                             NULL);
+
+  window->display->window_menu = menu;
+  window->display->window_with_menu = window;
+
+  meta_verbose ("Popping up window menu for %s\n", window->desc);
+
+  meta_ui_window_menu_popup (menu, root_x, root_y, button, timestamp);
+}
+
+void
+meta_window_shove_titlebar_onscreen (MetaWindow *window)
+{
+  MetaRectangle  outer_rect;
+  GList         *onscreen_region;
+  int            horiz_amount, vert_amount;
+  int            newx, newy;
+
+  /* If there's no titlebar, don't bother */
+  if (!window->frame)
+    return;
+
+  /* Get the basic info we need */
+  meta_window_get_outer_rect (window, &outer_rect);
+  onscreen_region = window->screen->active_workspace->screen_region;
+
+  /* Extend the region (just in case the window is too big to fit on the
+   * screen), then shove the window on screen, then return the region to
+   * normal.
+   */
+  horiz_amount = outer_rect.width;
+  vert_amount  = outer_rect.height;
+  meta_rectangle_expand_region (onscreen_region,
+                                horiz_amount,
+                                horiz_amount,
+                                0,
+                                vert_amount);
+  meta_rectangle_shove_into_region(onscreen_region,
+                                   FIXED_DIRECTION_X,
+                                   &outer_rect);
+  meta_rectangle_expand_region (onscreen_region,
+                                -horiz_amount,
+                                -horiz_amount,
+                                0,
+                                -vert_amount);
+
+  newx = outer_rect.x + window->frame->child_x;
+  newy = outer_rect.y + window->frame->child_y;
+  meta_window_move_resize (window,
+                           FALSE,
+                           newx,
+                           newy,
+                           window->rect.width,
+                           window->rect.height);
+}
+
+gboolean
+meta_window_titlebar_is_onscreen (MetaWindow *window)
+{
+  MetaRectangle  titlebar_rect;
+  GList         *onscreen_region;
+  int            titlebar_size;
+  gboolean       is_onscreen;
+
+  const int min_height_needed  = 8;
+  const int min_width_percent  = 0.5;
+  const int min_width_absolute = 50;
+
+  /* Titlebar can't be offscreen if there is no titlebar... */
+  if (!window->frame)
+    return FALSE;
+
+  /* Get the rectangle corresponding to the titlebar */
+  meta_window_get_outer_rect (window, &titlebar_rect);
+  titlebar_rect.height = window->frame->child_y;
+  titlebar_size = meta_rectangle_area (&titlebar_rect);
+
+  /* Run through the spanning rectangles for the screen and see if one of
+   * them overlaps with the titlebar sufficiently to consider it onscreen.
+   */
+  is_onscreen = FALSE;
+  onscreen_region = window->screen->active_workspace->screen_region;
+  while (onscreen_region)
+    {
+      MetaRectangle *spanning_rect = onscreen_region->data;
+      MetaRectangle overlap;
+
+      meta_rectangle_intersect (&titlebar_rect, spanning_rect, &overlap);
+      if (overlap.height > MIN (titlebar_rect.height, min_height_needed) &&
+          overlap.width  > MIN (titlebar_rect.width * min_width_percent,
+                                min_width_absolute))
+        {
+          is_onscreen = TRUE;
+          break;
+        }
+
+      onscreen_region = onscreen_region->next;
+    }
+
+  return is_onscreen;
+}
+
+static double
+timeval_to_ms (const GTimeVal *timeval)
+{
+  return (timeval->tv_sec * G_USEC_PER_SEC + timeval->tv_usec) / 1000.0;
+}
+
+static double
+time_diff (const GTimeVal *first,
+	   const GTimeVal *second)
+{
+  double first_ms = timeval_to_ms (first);
+  double second_ms = timeval_to_ms (second);
+
+  return first_ms - second_ms;
+}
+
+static gboolean
+check_moveresize_frequency (MetaWindow *window,
+			    gdouble    *remaining)
+{
+  GTimeVal current_time;
+
+  g_get_current_time (&current_time);
+
+#ifdef HAVE_XSYNC
+  if (!window->disable_sync &&
+      window->display->grab_sync_request_alarm != None)
+    {
+      if (window->sync_request_time.tv_sec != 0 ||
+	  window->sync_request_time.tv_usec != 0)
+	{
+	  double elapsed =
+	    time_diff (&current_time, &window->sync_request_time);
+
+	  if (elapsed < 1000.0)
+	    {
+	      /* We want to be sure that the timeout happens at
+	       * a time where elapsed will definitely be
+	       * greater than 1000, so we can disable sync
+	       */
+	      if (remaining)
+		*remaining = 1000.0 - elapsed + 100;
+
+	      return FALSE;
+	    }
+	  else
+	    {
+	      /* We have now waited for more than a second for the
+	       * application to respond to the sync request
+	       */
+	      window->disable_sync = TRUE;
+	      return TRUE;
+	    }
+	}
+      else
+	{
+	  /* No outstanding sync requests. Go ahead and resize
+	   */
+	  return TRUE;
+	}
+    }
+  else
+#endif /* HAVE_XSYNC */
+    {
+      const double max_resizes_per_second = 25.0;
+      const double ms_between_resizes = 1000.0 / max_resizes_per_second;
+      double elapsed;
+
+      elapsed = time_diff (&current_time, &window->display->grab_last_moveresize_time);
+
+      if (elapsed >= 0.0 && elapsed < ms_between_resizes)
+	{
+	  meta_topic (META_DEBUG_RESIZING,
+		      "Delaying move/resize as only %g of %g ms elapsed\n",
+		      elapsed, ms_between_resizes);
+
+	  if (remaining)
+	    *remaining = (ms_between_resizes - elapsed);
+
+	  return FALSE;
+	}
+
+      meta_topic (META_DEBUG_RESIZING,
+		  " Checked moveresize freq, allowing move/resize now (%g of %g seconds elapsed)\n",
+		  elapsed / 1000.0, 1.0 / max_resizes_per_second);
+
+      return TRUE;
+    }
+}
+
+static gboolean
+update_move_timeout (gpointer data)
+{
+  MetaWindow *window = data;
+
+  update_move (window,
+               window->display->grab_last_user_action_was_snap,
+               window->display->grab_latest_motion_x,
+               window->display->grab_latest_motion_y);
+
+  return FALSE;
+}
+
+static void
+update_move (MetaWindow  *window,
+             gboolean     snap,
+             int          x,
+             int          y)
+{
+  int dx, dy;
+  int new_x, new_y;
+  MetaRectangle old;
+  int shake_threshold;
+  MetaDisplay *display = window->display;
+
+  display->grab_latest_motion_x = x;
+  display->grab_latest_motion_y = y;
+
+  dx = x - display->grab_anchor_root_x;
+  dy = y - display->grab_anchor_root_y;
+
+  new_x = display->grab_anchor_window_pos.x + dx;
+  new_y = display->grab_anchor_window_pos.y + dy;
+
+  meta_verbose ("x,y = %d,%d anchor ptr %d,%d anchor pos %d,%d dx,dy %d,%d\n",
+                x, y,
+                display->grab_anchor_root_x,
+                display->grab_anchor_root_y,
+                display->grab_anchor_window_pos.x,
+                display->grab_anchor_window_pos.y,
+                dx, dy);
+
+  /* Don't bother doing anything if no move has been specified.  (This
+   * happens often, even in keyboard moving, due to the warping of the
+   * pointer.
+   */
+  if (dx == 0 && dy == 0)
+    return;
+
+  /* shake loose (unmaximize) maximized window if dragged beyond the threshold
+   * in the Y direction. You can't pull a window loose via X motion.
+   */
+
+#define DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR 6
+  shake_threshold = meta_ui_get_drag_threshold (window->screen->ui) *
+    DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR;
+
+  if (META_WINDOW_MAXIMIZED (window) && ABS (dy) >= shake_threshold)
+    {
+      double prop;
+
+      /* Shake loose */
+      window->shaken_loose = TRUE;
+
+      /* move the unmaximized window to the cursor */
+      prop =
+        ((double)(x - display->grab_initial_window_pos.x)) /
+        ((double)display->grab_initial_window_pos.width);
+
+      display->grab_initial_window_pos.x =
+        x - window->saved_rect.width * prop;
+      display->grab_initial_window_pos.y = y;
+
+      if (window->frame)
+        {
+          display->grab_initial_window_pos.y += window->frame->child_y / 2;
+        }
+
+      window->saved_rect.x = display->grab_initial_window_pos.x;
+      window->saved_rect.y = display->grab_initial_window_pos.y;
+      display->grab_anchor_root_x = x;
+      display->grab_anchor_root_y = y;
+
+      meta_window_unmaximize (window,
+                              META_MAXIMIZE_HORIZONTAL |
+                              META_MAXIMIZE_VERTICAL);
+
+      return;
+    }
+  /* remaximize window on an other xinerama monitor if window has
+   * been shaken loose or it is still maximized (then move straight)
+   */
+  else if (window->shaken_loose || META_WINDOW_MAXIMIZED (window))
+    {
+      const MetaXineramaScreenInfo *wxinerama;
+      MetaRectangle work_area;
+      int monitor;
+
+      wxinerama = meta_screen_get_xinerama_for_window (window->screen, window);
+
+      for (monitor = 0; monitor < window->screen->n_xinerama_infos; monitor++)
+        {
+          meta_window_get_work_area_for_xinerama (window, monitor, &work_area);
+
+          /* check if cursor is near the top of a xinerama work area */
+          if (x >= work_area.x &&
+              x < (work_area.x + work_area.width) &&
+              y >= work_area.y &&
+              y < (work_area.y + shake_threshold))
+            {
+              /* move the saved rect if window will become maximized on an
+               * other monitor so user isn't surprised on a later unmaximize
+               */
+              if (wxinerama->number != monitor)
+                {
+                  window->saved_rect.x = work_area.x;
+                  window->saved_rect.y = work_area.y;
+
+                  if (window->frame)
+                    {
+                      window->saved_rect.x += window->frame->child_x;
+                      window->saved_rect.y += window->frame->child_y;
+                    }
+
+                  window->user_rect.x = window->saved_rect.x;
+                  window->user_rect.y = window->saved_rect.y;
+
+                  meta_window_unmaximize (window,
+                                          META_MAXIMIZE_HORIZONTAL |
+                                          META_MAXIMIZE_VERTICAL);
+                }
+
+              display->grab_initial_window_pos = work_area;
+              display->grab_anchor_root_x = x;
+              display->grab_anchor_root_y = y;
+              window->shaken_loose = FALSE;
+
+              meta_window_maximize (window,
+                                    META_MAXIMIZE_HORIZONTAL |
+                                    META_MAXIMIZE_VERTICAL);
+
+              return;
+            }
+        }
+    }
+
+  if (display->grab_wireframe_active)
+    old = display->grab_wireframe_rect;
+  else
+    meta_window_get_client_root_coords (window, &old);
+
+  /* Don't allow movement in the maximized directions */
+  if (window->maximized_horizontally)
+    new_x = old.x;
+  if (window->maximized_vertically)
+    new_y = old.y;
+
+  /* Do any edge resistance/snapping */
+  meta_window_edge_resistance_for_move (window,
+                                        old.x,
+                                        old.y,
+                                        &new_x,
+                                        &new_y,
+                                        update_move_timeout,
+                                        snap,
+                                        FALSE);
+
+  if (display->compositor)
+    {
+      int root_x = new_x - display->grab_anchor_window_pos.x + display->grab_anchor_root_x;
+      int root_y = new_y - display->grab_anchor_window_pos.y + display->grab_anchor_root_y;
+
+      meta_compositor_update_move (display->compositor,
+				   window, root_x, root_y);
+    }
+
+  if (display->grab_wireframe_active)
+    meta_window_update_wireframe (window, new_x, new_y,
+                                  display->grab_wireframe_rect.width,
+                                  display->grab_wireframe_rect.height);
+  else
+    meta_window_move (window, TRUE, new_x, new_y);
+}
+
+static gboolean
+update_resize_timeout (gpointer data)
+{
+  MetaWindow *window = data;
+
+  update_resize (window,
+                 window->display->grab_last_user_action_was_snap,
+                 window->display->grab_latest_motion_x,
+                 window->display->grab_latest_motion_y,
+                 TRUE);
+  return FALSE;
+}
+
+static void
+update_resize (MetaWindow *window,
+               gboolean    snap,
+               int x, int y,
+               gboolean force)
+{
+  int dx, dy;
+  int new_w, new_h;
+  int gravity;
+  MetaRectangle old;
+  int new_x, new_y;
+  double remaining;
+
+  window->display->grab_latest_motion_x = x;
+  window->display->grab_latest_motion_y = y;
+
+  dx = x - window->display->grab_anchor_root_x;
+  dy = y - window->display->grab_anchor_root_y;
+
+  new_w = window->display->grab_anchor_window_pos.width;
+  new_h = window->display->grab_anchor_window_pos.height;
+
+  /* Don't bother doing anything if no move has been specified.  (This
+   * happens often, even in keyboard resizing, due to the warping of the
+   * pointer.
+   */
+  if (dx == 0 && dy == 0)
+    return;
+
+  /* FIXME this is only used in wireframe mode */
+  new_x = window->display->grab_anchor_window_pos.x;
+  new_y = window->display->grab_anchor_window_pos.y;
+
+  if (window->display->grab_op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)
+    {
+      if ((dx > 0) && (dy > 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SE;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if ((dx < 0) && (dy > 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SW;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if ((dx > 0) && (dy < 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NE;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if ((dx < 0) && (dy < 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NW;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dx < 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dx > 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dy > 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dy < 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+    }
+
+  /* FIXME: This stupidity only needed because of wireframe mode and
+   * the fact that wireframe isn't making use of
+   * meta_rectangle_resize_with_gravity().  If we were to use that, we
+   * could just increment new_w and new_h by dx and dy in all cases.
+   */
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+      new_w += dx;
+      break;
+
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+      new_w -= dx;
+      new_x += dx;
+      break;
+
+    default:
+      break;
+    }
+
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+      new_h += dy;
+      break;
+
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      new_h -= dy;
+      new_y += dy;
+      break;
+    default:
+      break;
+    }
+
+  if (!check_moveresize_frequency (window, &remaining) && !force)
+    {
+      /* we are ignoring an event here, so we schedule a
+       * compensation event when we would otherwise not ignore
+       * an event. Otherwise we can become stuck if the user never
+       * generates another event.
+       */
+      if (!window->display->grab_resize_timeout_id)
+	{
+	  window->display->grab_resize_timeout_id =
+	    g_timeout_add ((int)remaining, update_resize_timeout, window);
+	}
+
+      return;
+    }
+
+  /* If we get here, it means the client should have redrawn itself */
+  if (window->display->compositor)
+    meta_compositor_set_updates (window->display->compositor, window, TRUE);
+
+  /* Remove any scheduled compensation events */
+  if (window->display->grab_resize_timeout_id)
+    {
+      g_source_remove (window->display->grab_resize_timeout_id);
+      window->display->grab_resize_timeout_id = 0;
+    }
+
+  if (window->display->grab_wireframe_active)
+    old = window->display->grab_wireframe_rect;
+  else
+    old = window->rect;  /* Don't actually care about x,y */
+
+  /* One sided resizing ought to actually be one-sided, despite the fact that
+   * aspect ratio windows don't interact nicely with the above stuff.  So,
+   * to avoid some nasty flicker, we enforce that.
+   */
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_RESIZING_N:
+      new_w = old.width;
+      break;
+
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_RESIZING_W:
+      new_h = old.height;
+      break;
+
+    default:
+      break;
+    }
+
+  /* compute gravity of client during operation */
+  gravity = meta_resize_gravity_from_grab_op (window->display->grab_op);
+  g_assert (gravity >= 0);
+
+  /* Do any edge resistance/snapping */
+  meta_window_edge_resistance_for_resize (window,
+                                          old.width,
+                                          old.height,
+                                          &new_w,
+                                          &new_h,
+                                          gravity,
+                                          update_resize_timeout,
+                                          snap,
+                                          FALSE);
+
+  if (window->display->grab_wireframe_active)
+    {
+      if ((new_x + new_w <= new_x) || (new_y + new_h <= new_y))
+        return;
+
+      /* FIXME This is crap. For example, the wireframe isn't
+       * constrained in the way that a real resize would be. An
+       * obvious elegant solution is to unmap the window during
+       * wireframe, but still resize it; however, that probably
+       * confuses broken clients that have problems with opaque
+       * resize, they probably don't track their visibility.
+       */
+      meta_window_update_wireframe (window, new_x, new_y, new_w, new_h);
+    }
+  else
+    {
+      /* We don't need to update unless the specified width and height
+       * are actually different from what we had before.
+       */
+      if (old.width != new_w || old.height != new_h)
+        meta_window_resize_with_gravity (window, TRUE, new_w, new_h, gravity);
+    }
+
+  /* Store the latest resize time, if we actually resized. */
+  if (window->rect.width != old.width || window->rect.height != old.height)
+    g_get_current_time (&window->display->grab_last_moveresize_time);
+}
+
+typedef struct
+{
+  const XEvent *current_event;
+  int           count;
+  guint32       last_time;
+} EventScannerData;
+
+static Bool
+find_last_time_predicate (Display  *display,
+                          XEvent   *xevent,
+                          XPointer  arg)
+{
+  EventScannerData *esd = (void*) arg;
+
+  if (esd->current_event->type == xevent->type &&
+      esd->current_event->xany.window == xevent->xany.window)
+    {
+      esd->count += 1;
+      esd->last_time = xevent->xmotion.time;
+    }
+
+  return False;
+}
+
+static gboolean
+check_use_this_motion_notify (MetaWindow *window,
+                              XEvent     *event)
+{
+  EventScannerData esd;
+  XEvent useless;
+
+  /* This code is copied from Owen's GDK code. */
+
+  if (window->display->grab_motion_notify_time != 0)
+    {
+      /* == is really the right test, but I'm all for paranoia */
+      if (window->display->grab_motion_notify_time <=
+          event->xmotion.time)
+        {
+          meta_topic (META_DEBUG_RESIZING,
+                      "Arrived at event with time %u (waiting for %u), using it\n",
+                      (unsigned int)event->xmotion.time,
+                      window->display->grab_motion_notify_time);
+          window->display->grab_motion_notify_time = 0;
+          return TRUE;
+        }
+      else
+        return FALSE; /* haven't reached the saved timestamp yet */
+    }
+
+  esd.current_event = event;
+  esd.count = 0;
+  esd.last_time = 0;
+
+  /* "useless" isn't filled in because the predicate never returns True */
+  XCheckIfEvent (window->display->xdisplay,
+                 &useless,
+                 find_last_time_predicate,
+                 (XPointer) &esd);
+
+  if (esd.count > 0)
+    meta_topic (META_DEBUG_RESIZING,
+                "Will skip %d motion events and use the event with time %u\n",
+                esd.count, (unsigned int) esd.last_time);
+
+  if (esd.last_time == 0)
+    return TRUE;
+  else
+    {
+      /* Save this timestamp, and ignore all motion notify
+       * until we get to the one with this stamp.
+       */
+      window->display->grab_motion_notify_time = esd.last_time;
+      return FALSE;
+    }
+}
+
+void
+meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+                                        XEvent     *event)
+{
+#ifdef HAVE_XSYNC
+  if (event->type == (window->display->xsync_event_base + XSyncAlarmNotify))
+    {
+      meta_topic (META_DEBUG_RESIZING,
+                  "Alarm event received last motion x = %d y = %d\n",
+                  window->display->grab_latest_motion_x,
+                  window->display->grab_latest_motion_y);
+
+      /* If sync was previously disabled, turn it back on and hope
+       * the application has come to its senses (maybe it was just
+       * busy with a pagefault or a long computation).
+       */
+      window->disable_sync = FALSE;
+      window->sync_request_time.tv_sec = 0;
+      window->sync_request_time.tv_usec = 0;
+
+      /* This means we are ready for another configure. */
+      switch (window->display->grab_op)
+        {
+        case META_GRAB_OP_RESIZING_E:
+        case META_GRAB_OP_RESIZING_W:
+        case META_GRAB_OP_RESIZING_S:
+        case META_GRAB_OP_RESIZING_N:
+        case META_GRAB_OP_RESIZING_SE:
+        case META_GRAB_OP_RESIZING_SW:
+        case META_GRAB_OP_RESIZING_NE:
+        case META_GRAB_OP_RESIZING_NW:
+        case META_GRAB_OP_KEYBOARD_RESIZING_S:
+        case META_GRAB_OP_KEYBOARD_RESIZING_N:
+        case META_GRAB_OP_KEYBOARD_RESIZING_W:
+        case META_GRAB_OP_KEYBOARD_RESIZING_E:
+        case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+        case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+        case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+        case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+          /* no pointer round trip here, to keep in sync */
+          update_resize (window,
+                         window->display->grab_last_user_action_was_snap,
+                         window->display->grab_latest_motion_x,
+                         window->display->grab_latest_motion_y,
+                         TRUE);
+          break;
+
+        default:
+          break;
+        }
+    }
+#endif /* HAVE_XSYNC */
+
+  switch (event->type)
+    {
+    case ButtonRelease:
+      meta_display_check_threshold_reached (window->display,
+                                            event->xbutton.x_root,
+                                            event->xbutton.y_root);
+      /* If the user was snap moving then ignore the button release
+       * because they may have let go of shift before releasing the
+       * mouse button and they almost certainly do not want a
+       * non-snapped movement to occur from the button release.
+       */
+      if (!window->display->grab_last_user_action_was_snap)
+        {
+          if (meta_grab_op_is_moving (window->display->grab_op))
+            {
+              if (event->xbutton.root == window->screen->xroot)
+                update_move (window, event->xbutton.state & ShiftMask,
+                             event->xbutton.x_root, event->xbutton.y_root);
+            }
+          else if (meta_grab_op_is_resizing (window->display->grab_op))
+            {
+              if (event->xbutton.root == window->screen->xroot)
+                update_resize (window,
+                               event->xbutton.state & ShiftMask,
+                               event->xbutton.x_root,
+                               event->xbutton.y_root,
+                               TRUE);
+	      if (window->display->compositor)
+		meta_compositor_set_updates (window->display->compositor, window, TRUE);
+            }
+        }
+
+      meta_display_end_grab_op (window->display, event->xbutton.time);
+      break;
+
+    case MotionNotify:
+      meta_display_check_threshold_reached (window->display,
+                                            event->xmotion.x_root,
+                                            event->xmotion.y_root);
+      if (meta_grab_op_is_moving (window->display->grab_op))
+        {
+          if (event->xmotion.root == window->screen->xroot)
+            {
+              if (check_use_this_motion_notify (window,
+                                                event))
+                update_move (window,
+                             event->xmotion.state & ShiftMask,
+                             event->xmotion.x_root,
+                             event->xmotion.y_root);
+            }
+        }
+      else if (meta_grab_op_is_resizing (window->display->grab_op))
+        {
+          if (event->xmotion.root == window->screen->xroot)
+            {
+              if (check_use_this_motion_notify (window,
+                                                event))
+                update_resize (window,
+                               event->xmotion.state & ShiftMask,
+                               event->xmotion.x_root,
+                               event->xmotion.y_root,
+                               FALSE);
+            }
+        }
+      break;
+
+    default:
+      break;
+    }
+}
+
+void
+meta_window_set_gravity (MetaWindow *window,
+                         int         gravity)
+{
+  XSetWindowAttributes attrs;
+
+  meta_verbose ("Setting gravity of %s to %d\n", window->desc, gravity);
+
+  attrs.win_gravity = gravity;
+
+  meta_error_trap_push (window->display);
+
+  XChangeWindowAttributes (window->display->xdisplay,
+                           window->xwindow,
+                           CWWinGravity,
+                           &attrs);
+
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+static void
+get_work_area_xinerama (MetaWindow    *window,
+                        MetaRectangle *area,
+                        int            which_xinerama)
+{
+  GList *tmp;
+
+  g_assert (which_xinerama >= 0);
+
+  /* Initialize to the whole xinerama */
+  *area = window->screen->xinerama_infos[which_xinerama].rect;
+
+  tmp = meta_window_get_workspaces (window);
+  while (tmp != NULL)
+    {
+      MetaRectangle workspace_work_area;
+      meta_workspace_get_work_area_for_xinerama (tmp->data,
+                                                 which_xinerama,
+                                                 &workspace_work_area);
+      meta_rectangle_intersect (area,
+                                &workspace_work_area,
+                                area);
+      tmp = tmp->next;
+    }
+
+  meta_topic (META_DEBUG_WORKAREA,
+              "Window %s xinerama %d has work area %d,%d %d x %d\n",
+              window->desc, which_xinerama,
+              area->x, area->y, area->width, area->height);
+}
+
+void
+meta_window_get_work_area_current_xinerama (MetaWindow    *window,
+					    MetaRectangle *area)
+{
+  const MetaXineramaScreenInfo *xinerama = NULL;
+  xinerama = meta_screen_get_xinerama_for_window (window->screen,
+						  window);
+
+  meta_window_get_work_area_for_xinerama (window,
+                                          xinerama->number,
+                                          area);
+}
+
+void
+meta_window_get_work_area_for_xinerama (MetaWindow    *window,
+					int            which_xinerama,
+					MetaRectangle *area)
+{
+  g_return_if_fail (which_xinerama >= 0);
+
+  get_work_area_xinerama (window,
+                          area,
+                          which_xinerama);
+}
+
+void
+meta_window_get_work_area_all_xineramas (MetaWindow    *window,
+                                         MetaRectangle *area)
+{
+  GList *tmp;
+
+  /* Initialize to the whole screen */
+  *area = window->screen->rect;
+
+  tmp = meta_window_get_workspaces (window);
+  while (tmp != NULL)
+    {
+      MetaRectangle workspace_work_area;
+      meta_workspace_get_work_area_all_xineramas (tmp->data,
+                                                  &workspace_work_area);
+      meta_rectangle_intersect (area,
+                                &workspace_work_area,
+                                area);
+      tmp = tmp->next;
+    }
+
+  meta_topic (META_DEBUG_WORKAREA,
+              "Window %s has whole-screen work area %d,%d %d x %d\n",
+              window->desc, area->x, area->y, area->width, area->height);
+}
+
+
+gboolean
+meta_window_same_application (MetaWindow *window,
+                              MetaWindow *other_window)
+{
+  MetaGroup *group       = meta_window_get_group (window);
+  MetaGroup *other_group = meta_window_get_group (other_window);
+
+  return
+    group!=NULL &&
+    other_group!=NULL &&
+    group==other_group;
+}
+
+void
+meta_window_refresh_resize_popup (MetaWindow *window)
+{
+  if (window->display->grab_op == META_GRAB_OP_NONE)
+    return;
+
+  if (window->display->grab_window != window)
+    return;
+
+  /* We shouldn't ever get called when the wireframe is active
+   * because that's handled by a different code path in effects.c
+   */
+  if (window->display->grab_wireframe_active)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "refresh_resize_popup called when wireframe active\n");
+      return;
+    }
+
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      break;
+
+    default:
+      /* Not resizing */
+      return;
+    }
+
+  if (window->display->grab_resize_popup == NULL)
+    {
+      if (window->size_hints.width_inc > 1 ||
+          window->size_hints.height_inc > 1)
+        window->display->grab_resize_popup =
+          meta_ui_resize_popup_new (window->display->xdisplay,
+                                    window->screen->number);
+    }
+
+  if (window->display->grab_resize_popup != NULL)
+    {
+      MetaRectangle rect;
+
+      if (window->display->grab_wireframe_active)
+        rect = window->display->grab_wireframe_rect;
+      else
+        meta_window_get_client_root_coords (window, &rect);
+
+      meta_ui_resize_popup_set (window->display->grab_resize_popup,
+                                rect,
+                                window->size_hints.base_width,
+                                window->size_hints.base_height,
+                                window->size_hints.width_inc,
+                                window->size_hints.height_inc);
+
+      meta_ui_resize_popup_set_showing (window->display->grab_resize_popup,
+                                        TRUE);
+    }
+}
+
+void
+meta_window_foreach_transient (MetaWindow            *window,
+                               MetaWindowForeachFunc  func,
+                               void                  *data)
+{
+  GSList *windows;
+  GSList *tmp;
+
+  windows = meta_display_list_windows (window->display);
+
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *transient = tmp->data;
+
+      if (meta_window_is_ancestor_of_transient (window, transient))
+        {
+          if (!(* func) (transient, data))
+            break;
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+}
+
+void
+meta_window_foreach_ancestor (MetaWindow            *window,
+                              MetaWindowForeachFunc  func,
+                              void                  *data)
+{
+  MetaWindow *w;
+  MetaWindow *tortoise;
+
+  w = window;
+  tortoise = window;
+  while (TRUE)
+    {
+      if (w->xtransient_for == None ||
+          w->transient_parent_is_root_window)
+        break;
+
+      w = meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+      if (w == NULL || w == tortoise)
+        break;
+
+      if (!(* func) (w, data))
+        break;
+
+      if (w->xtransient_for == None ||
+          w->transient_parent_is_root_window)
+        break;
+
+      w = meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+      if (w == NULL || w == tortoise)
+        break;
+
+      if (!(* func) (w, data))
+        break;
+
+      tortoise = meta_display_lookup_x_window (tortoise->display,
+                                               tortoise->xtransient_for);
+
+      /* "w" should have already covered all ground covered by the
+       * tortoise, so the following must hold.
+       */
+      g_assert (tortoise != NULL);
+      g_assert (tortoise->xtransient_for != None);
+      g_assert (!tortoise->transient_parent_is_root_window);
+    }
+}
+
+typedef struct
+{
+  MetaWindow *ancestor;
+  gboolean found;
+} FindAncestorData;
+
+static gboolean
+find_ancestor_func (MetaWindow *window,
+                    void       *data)
+{
+  FindAncestorData *d = data;
+
+  if (window == d->ancestor)
+    {
+      d->found = TRUE;
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+meta_window_is_ancestor_of_transient (MetaWindow *window,
+                                      MetaWindow *transient)
+{
+  FindAncestorData d;
+
+  d.ancestor = window;
+  d.found = FALSE;
+
+  meta_window_foreach_ancestor (transient, find_ancestor_func, &d);
+
+  return d.found;
+}
+
+/* Warp pointer to location appropriate for grab,
+ * return root coordinates where pointer ended up.
+ */
+static gboolean
+warp_grab_pointer (MetaWindow          *window,
+                   MetaGrabOp           grab_op,
+                   int                 *x,
+                   int                 *y)
+{
+  MetaRectangle  rect;
+  MetaDisplay   *display;
+
+  display = window->display;
+
+  /* We may not have done begin_grab_op yet, i.e. may not be in a grab
+   */
+
+  if (window == display->grab_window && display->grab_wireframe_active)
+    {
+      meta_window_get_xor_rect (window, &display->grab_wireframe_rect, &rect);
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &rect);
+    }
+
+  switch (grab_op)
+    {
+      case META_GRAB_OP_KEYBOARD_MOVING:
+      case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+        *x = rect.width / 2;
+        *y = rect.height / 2;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_S:
+        *x = rect.width / 2;
+        *y = rect.height - 1;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_N:
+        *x = rect.width / 2;
+        *y = 0;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_W:
+        *x = 0;
+        *y = rect.height / 2;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_E:
+        *x = rect.width - 1;
+        *y = rect.height / 2;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+        *x = rect.width - 1;
+        *y = rect.height - 1;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+        *x = rect.width - 1;
+        *y = 0;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+        *x = 0;
+        *y = rect.height - 1;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+        *x = 0;
+        *y = 0;
+        break;
+
+      default:
+        return FALSE;
+    }
+
+  *x += rect.x;
+  *y += rect.y;
+
+  /* Avoid weird bouncing at the screen edge; see bug 154706 */
+  *x = CLAMP (*x, 0, window->screen->rect.width-1);
+  *y = CLAMP (*y, 0, window->screen->rect.height-1);
+
+  meta_error_trap_push_with_return (display);
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Warping pointer to %d,%d with window at %d,%d\n",
+              *x, *y, rect.x, rect.y);
+
+  /* Need to update the grab positions so that the MotionNotify and other
+   * events generated by the XWarpPointer() call below don't cause complete
+   * funkiness.  See bug 124582 and bug 122670.
+   */
+  display->grab_anchor_root_x = *x;
+  display->grab_anchor_root_y = *y;
+  display->grab_latest_motion_x = *x;
+  display->grab_latest_motion_y = *y;
+  if (display->grab_wireframe_active)
+    display->grab_anchor_window_pos = display->grab_wireframe_rect;
+  else
+    meta_window_get_client_root_coords (window,
+                                        &display->grab_anchor_window_pos);
+
+  XWarpPointer (display->xdisplay,
+                None,
+                window->screen->xroot,
+                0, 0, 0, 0,
+                *x, *y);
+
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    {
+      meta_verbose ("Failed to warp pointer for window %s\n",
+                    window->desc);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+void
+meta_window_begin_grab_op (MetaWindow *window,
+                           MetaGrabOp  op,
+                           gboolean    frame_action,
+                           guint32     timestamp)
+{
+  int x, y;
+
+  warp_grab_pointer (window,
+                     op, &x, &y);
+
+  meta_display_begin_grab_op (window->display,
+                              window->screen,
+                              window,
+                              op,
+                              FALSE,
+                              frame_action,
+                              0 /* button */,
+                              0,
+                              timestamp,
+                              x, y);
+}
+
+void
+meta_window_update_keyboard_resize (MetaWindow *window,
+                                    gboolean    update_cursor)
+{
+  int x, y;
+
+  warp_grab_pointer (window,
+                     window->display->grab_op,
+                     &x, &y);
+
+  if (update_cursor)
+    {
+      guint32 timestamp;
+      /* FIXME: Using CurrentTime is really bad mojo */
+      timestamp = CurrentTime;
+      meta_display_set_grab_op_cursor (window->display,
+                                       NULL,
+                                       window->display->grab_op,
+                                       TRUE,
+                                       window->display->grab_xwindow,
+                                       timestamp);
+    }
+}
+
+void
+meta_window_update_keyboard_move (MetaWindow *window)
+{
+  int x, y;
+
+  warp_grab_pointer (window,
+                     window->display->grab_op,
+                     &x, &y);
+}
+
+void
+meta_window_update_layer (MetaWindow *window)
+{
+  MetaGroup *group;
+
+  meta_stack_freeze (window->screen->stack);
+  group = meta_window_get_group (window);
+  if (group)
+    meta_group_update_layers (group);
+  else
+    meta_stack_update_layer (window->screen->stack, window);
+  meta_stack_thaw (window->screen->stack);
+}
+
+/* ensure_mru_position_after ensures that window appears after
+ * below_this_one in the active_workspace's mru_list (i.e. it treats
+ * window as having been less recently used than below_this_one)
+ */
+static void
+ensure_mru_position_after (MetaWindow *window,
+                           MetaWindow *after_this_one)
+{
+  /* This is sort of slow since it runs through the entire list more
+   * than once (especially considering the fact that we expect the
+   * windows of interest to be the first two elements in the list),
+   * but it doesn't matter while we're only using it on new window
+   * map.
+   */
+
+  GList* active_mru_list;
+  GList* window_position;
+  GList* after_this_one_position;
+
+  active_mru_list         = window->screen->active_workspace->mru_list;
+  window_position         = g_list_find (active_mru_list, window);
+  after_this_one_position = g_list_find (active_mru_list, after_this_one);
+
+  /* after_this_one_position is NULL when we switch workspaces, but in
+   * that case we don't need to do any MRU shuffling so we can simply
+   * return.
+   */
+  if (after_this_one_position == NULL)
+    return;
+
+  if (g_list_length (window_position) > g_list_length (after_this_one_position))
+    {
+      window->screen->active_workspace->mru_list =
+        g_list_delete_link (window->screen->active_workspace->mru_list,
+                            window_position);
+
+      window->screen->active_workspace->mru_list =
+        g_list_insert_before (window->screen->active_workspace->mru_list,
+                              after_this_one_position->next,
+                              window);
+    }
+}
+
+void
+meta_window_stack_just_below (MetaWindow *window,
+                              MetaWindow *below_this_one)
+{
+  g_return_if_fail (window         != NULL);
+  g_return_if_fail (below_this_one != NULL);
+
+  if (window->stack_position > below_this_one->stack_position)
+    {
+      meta_topic (META_DEBUG_STACK,
+                  "Setting stack position of window %s to %d (making it below window %s).\n",
+                  window->desc,
+                  below_this_one->stack_position,
+                  below_this_one->desc);
+      meta_window_set_stack_position (window, below_this_one->stack_position);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STACK,
+                  "Window %s  was already below window %s.\n",
+                  window->desc, below_this_one->desc);
+    }
+}
+
+void
+meta_window_set_user_time (MetaWindow *window,
+                           guint32     timestamp)
+{
+  /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
+   * us to sanity check the timestamp here and ensure it doesn't correspond to
+   * a future time.
+   */
+
+  /* Only update the time if this timestamp is newer... */
+  if (window->net_wm_user_time_set &&
+      XSERVER_TIME_IS_BEFORE (timestamp, window->net_wm_user_time))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Window %s _NET_WM_USER_TIME not updated to %u, because it "
+                  "is less than %u\n",
+                  window->desc, timestamp, window->net_wm_user_time);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Window %s has _NET_WM_USER_TIME of %u\n",
+                  window->desc, timestamp);
+      window->net_wm_user_time_set = TRUE;
+      window->net_wm_user_time = timestamp;
+      if (XSERVER_TIME_IS_BEFORE (window->display->last_user_time, timestamp))
+        window->display->last_user_time = timestamp;
+
+      /* If this is a terminal, user interaction with it means the user likely
+       * doesn't want to have focus transferred for now due to new windows.
+       */
+      if (meta_prefs_get_focus_new_windows () ==
+               META_FOCUS_NEW_WINDOWS_STRICT &&
+          __window_is_terminal (window))
+        window->display->allow_terminal_deactivation = FALSE;
+    }
+}
+
+/* Sets the demands_attention hint on a window, but only
+ * if it's at least partially obscured (see #305882).
+ */
+void
+meta_window_set_demands_attention (MetaWindow *window)
+{
+  MetaRectangle candidate_rect, other_rect;
+  GList *stack = window->screen->stack->sorted;
+  MetaWindow *other_window;
+  gboolean obscured = FALSE;
+
+  MetaWorkspace *workspace = window->screen->active_workspace;
+  if (workspace!=window->workspace)
+    {
+      /* windows on other workspaces are necessarily obscured */
+      obscured = TRUE;
+    }
+  else if (window->minimized)
+    {
+      obscured = TRUE;
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &candidate_rect);
+
+      /* The stack is sorted with the top windows first. */
+
+      while (stack != NULL && stack->data != window)
+        {
+          other_window = stack->data;
+          stack = stack->next;
+
+          if (other_window->on_all_workspaces ||
+              window->on_all_workspaces ||
+              other_window->workspace == window->workspace)
+            {
+              meta_window_get_outer_rect (other_window, &other_rect);
+
+              if (meta_rectangle_overlap (&candidate_rect, &other_rect))
+                {
+                  obscured = TRUE;
+                  break;
+                }
+            }
+        }
+    }
+
+  if (obscured)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Marking %s as needing attention\n",
+                  window->desc);
+
+      window->wm_state_demands_attention = TRUE;
+      set_net_wm_state (window);
+    }
+  else
+    {
+      /* If the window's in full view, there's no point setting the flag. */
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                 "Not marking %s as needing attention because "
+                 "it's in full view\n",
+                 window->desc);
+    }
+}
+
+void
+meta_window_unset_demands_attention (MetaWindow *window)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+      "Marking %s as not needing attention\n", window->desc);
+
+  window->wm_state_demands_attention = FALSE;
+  set_net_wm_state (window);
+}
+
+MetaFrame *
+meta_window_get_frame (MetaWindow *window)
+{
+  return window->frame;
+}
+
+gboolean
+meta_window_has_focus (MetaWindow *window)
+{
+  return window->has_focus;
+}
+
+gboolean
+meta_window_is_shaded (MetaWindow *window)
+{
+  return window->shaded;
+}
+
+MetaRectangle *
+meta_window_get_rect (MetaWindow *window)
+{
+  return &window->rect;
+}
+
+MetaScreen *
+meta_window_get_screen (MetaWindow *window)
+{
+  return window->screen;
+}
+
+MetaDisplay *
+meta_window_get_display (MetaWindow *window)
+{
+  return window->display;
+}
+
+Window
+meta_window_get_xwindow (MetaWindow *window)
+{
+  return window->xwindow;
+}
diff --git a/src/core/workspace.c b/src/core/workspace.c
new file mode 100644
index 00000000..2b28fe0b
--- /dev/null
+++ b/src/core/workspace.c
@@ -0,0 +1,1038 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Workspaces */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "workspace.h"
+#include "errors.h"
+#include "prefs.h"
+#include <X11/Xatom.h>
+#include <string.h>
+#include <canberra-gtk.h>
+
+void meta_workspace_queue_calc_showing   (MetaWorkspace *workspace);
+static void set_active_space_hint        (MetaScreen *screen);
+static void focus_ancestor_or_mru_window (MetaWorkspace *workspace,
+                                          MetaWindow    *not_this_one,
+                                          guint32        timestamp);
+static void free_this                    (gpointer candidate,
+                                          gpointer dummy);
+static void workspace_free_struts        (MetaWorkspace *workspace);
+
+static void
+maybe_add_to_list (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  GList **mru_list = data;
+
+  if (window->on_all_workspaces)
+    *mru_list = g_list_prepend (*mru_list, window);
+}
+
+MetaWorkspace*
+meta_workspace_new (MetaScreen *screen)
+{
+  MetaWorkspace *workspace;
+
+  workspace = g_new (MetaWorkspace, 1);
+
+  workspace->screen = screen;
+  workspace->screen->workspaces =
+    g_list_append (workspace->screen->workspaces, workspace);
+  workspace->windows = NULL;
+  workspace->mru_list = NULL;
+  meta_screen_foreach_window (screen, maybe_add_to_list, &workspace->mru_list);
+
+  workspace->work_areas_invalid = TRUE;
+  workspace->work_area_xinerama = NULL;
+  workspace->work_area_screen.x = 0;
+  workspace->work_area_screen.y = 0;
+  workspace->work_area_screen.width = 0;
+  workspace->work_area_screen.height = 0;
+
+  workspace->screen_region = NULL;
+  workspace->xinerama_region = NULL;
+  workspace->screen_edges = NULL;
+  workspace->xinerama_edges = NULL;
+  workspace->list_containing_self = g_list_prepend (NULL, workspace);
+
+  workspace->all_struts = NULL;
+
+  workspace->showing_desktop = FALSE;
+  
+  return workspace;
+}
+
+/** Foreach function for workspace_free_struts() */
+static void
+free_this (gpointer candidate, gpointer dummy)
+{
+  g_free (candidate);
+}
+
+/**
+ * Frees the struts list of a workspace.
+ *
+ * \param workspace  The workspace.
+ */
+static void
+workspace_free_struts (MetaWorkspace *workspace)
+{
+  if (workspace->all_struts == NULL)
+    return;
+    
+  g_slist_foreach (workspace->all_struts, free_this, NULL);
+  g_slist_free (workspace->all_struts);
+  workspace->all_struts = NULL;
+}
+
+void
+meta_workspace_free (MetaWorkspace *workspace)
+{
+  GList *tmp;
+  MetaScreen *screen;
+  int i;
+
+  g_return_if_fail (workspace != workspace->screen->active_workspace);
+
+  /* Here we assume all the windows are already on another workspace
+   * as well, so they won't be "orphaned"
+   */
+  
+  tmp = workspace->windows;
+  while (tmp != NULL)
+    {
+      GList *next;
+      MetaWindow *window = tmp->data;
+      next = tmp->next;
+
+      /* pop front of list we're iterating over */
+      meta_workspace_remove_window (workspace, window);
+      g_assert (window->workspace != NULL);
+
+      tmp = next;
+    }
+
+  g_assert (workspace->windows == NULL);
+
+  screen = workspace->screen;
+  
+  workspace->screen->workspaces =
+    g_list_remove (workspace->screen->workspaces, workspace);
+  
+  g_free (workspace->work_area_xinerama);
+
+  g_list_free (workspace->mru_list);
+  g_list_free (workspace->list_containing_self);
+
+  /* screen.c:update_num_workspaces(), which calls us, removes windows from
+   * workspaces first, which can cause the workareas on the workspace to be
+   * invalidated (and hence for struts/regions/edges to be freed).
+   * So, no point trying to double free it; that causes a crash
+   * anyway.  #361804.
+   */
+
+  if (!workspace->work_areas_invalid)
+    {
+      workspace_free_struts (workspace);
+      for (i = 0; i < screen->n_xinerama_infos; i++)
+        meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
+      g_free (workspace->xinerama_region);
+      meta_rectangle_free_list_and_elements (workspace->screen_region);
+      meta_rectangle_free_list_and_elements (workspace->screen_edges);
+      meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
+    }
+
+  g_free (workspace);
+
+  /* don't bother to reset names, pagers can just ignore
+   * extra ones
+   */
+}
+
+void
+meta_workspace_add_window (MetaWorkspace *workspace,
+                           MetaWindow    *window)
+{
+  g_return_if_fail (window->workspace == NULL);
+  
+  /* If the window is on all workspaces, we want to add it to all mru
+   * lists, otherwise just add it to this workspaces mru list
+   */
+  if (window->on_all_workspaces) 
+    {
+      if (window->workspace == NULL)
+        {
+          GList* tmp = window->screen->workspaces;
+          while (tmp)
+            {
+              MetaWorkspace* work = (MetaWorkspace*) tmp->data;
+              if (!g_list_find (work->mru_list, window))
+                work->mru_list = g_list_prepend (work->mru_list, window);
+
+              tmp = tmp->next;
+            }
+        }
+    }
+  else
+    {
+      g_assert (g_list_find (workspace->mru_list, window) == NULL);
+      workspace->mru_list = g_list_prepend (workspace->mru_list, window);
+    }
+
+  workspace->windows = g_list_prepend (workspace->windows, window);
+  window->workspace = workspace;
+
+  meta_window_set_current_workspace_hint (window);
+  
+  if (window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Invalidating work area of workspace %d since we're adding window %s to it\n",
+                  meta_workspace_index (workspace), window->desc);
+      meta_workspace_invalidate_work_area (workspace);
+    }
+
+  /* queue a move_resize since changing workspaces may change
+   * the relevant struts
+   */
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING|META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_workspace_remove_window (MetaWorkspace *workspace,
+                              MetaWindow    *window)
+{
+  g_return_if_fail (window->workspace == workspace);
+
+  workspace->windows = g_list_remove (workspace->windows, window);
+  window->workspace = NULL;
+
+  /* If the window is on all workspaces, we don't want to remove it
+   * from the MRU list unless this causes it to be removed from all 
+   * workspaces
+   */
+  if (window->on_all_workspaces) 
+    {
+      GList* tmp = window->screen->workspaces;
+      while (tmp)
+        {
+          MetaWorkspace* work = (MetaWorkspace*) tmp->data;
+          work->mru_list = g_list_remove (work->mru_list, window);
+
+          tmp = tmp->next;
+        }
+    }
+  else
+    {
+      workspace->mru_list = g_list_remove (workspace->mru_list, window);
+      g_assert (g_list_find (workspace->mru_list, window) == NULL);
+    }
+
+  meta_window_set_current_workspace_hint (window);
+  
+  if (window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Invalidating work area of workspace %d since we're removing window %s from it\n",
+                  meta_workspace_index (workspace), window->desc);
+      meta_workspace_invalidate_work_area (workspace);
+    }
+
+  /* queue a move_resize since changing workspaces may change
+   * the relevant struts
+   */
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING|META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_workspace_relocate_windows (MetaWorkspace *workspace,
+                                 MetaWorkspace *new_home)
+{
+  GList *tmp;
+  GList *copy;
+  
+  g_return_if_fail (workspace != new_home);
+
+  /* can't modify list we're iterating over */
+  copy = g_list_copy (workspace->windows);
+  
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      meta_workspace_remove_window (workspace, window);
+      meta_workspace_add_window (new_home, window);
+      
+      tmp = tmp->next;
+    }
+
+  g_list_free (copy);
+  
+  g_assert (workspace->windows == NULL);
+}
+
+void
+meta_workspace_queue_calc_showing  (MetaWorkspace *workspace)
+{
+  GList *tmp;
+
+  tmp = workspace->windows;
+  while (tmp != NULL)
+    {
+      meta_window_queue (tmp->data, META_QUEUE_CALC_SHOWING);
+
+      tmp = tmp->next;
+    }
+}
+
+static void workspace_switch_sound(MetaWorkspace *from,
+                                   MetaWorkspace *to) {
+
+  MetaWorkspaceLayout layout;
+  int i, nw, x, y, fi, ti;
+  const char *e;
+
+  nw = meta_screen_get_n_workspaces(from->screen);
+  fi = meta_workspace_index(from);
+  ti = meta_workspace_index(to);
+
+  meta_screen_calc_workspace_layout(from->screen,
+                                    nw,
+                                    fi,
+                                    &layout);
+
+  for (i = 0; i < nw; i++)
+    if (layout.grid[i] == ti)
+      break;
+
+  if (i >= nw) {
+    meta_bug("Failed to find destination workspace in layout\n");
+    goto finish;
+  }
+
+  y = i / layout.cols;
+  x = i % layout.cols;
+
+  /* We priorize horizontal over vertical movements here. The
+     rationale for this is that horizontal movements are probably more
+     interesting for sound effects because speakers are usually
+     positioned on a horizontal and not a vertical axis. i.e. your
+     spatial "Woosh!" effects will easily be able to encode horizontal
+     movement but not such much vertical movement. */
+
+  if (x < layout.current_col)
+    e = "desktop-switch-left";
+  else if (x > layout.current_col)
+    e = "desktop-switch-right";
+  else if (y < layout.current_row)
+    e = "desktop-switch-up";
+  else if (y > layout.current_row)
+    e = "desktop-switch-down";
+  else {
+    meta_bug("Uh, origin and destination workspace at same logic position!\n");
+    goto finish;
+  }
+
+  ca_context_play(ca_gtk_context_get(), 1,
+                  CA_PROP_EVENT_ID, e,
+                  CA_PROP_EVENT_DESCRIPTION, "Desktop switched",
+                  CA_PROP_CANBERRA_CACHE_CONTROL, "permanent",
+                  NULL);
+
+ finish:
+  meta_screen_free_workspace_layout (&layout);
+}
+
+void
+meta_workspace_activate_with_focus (MetaWorkspace *workspace,
+                                    MetaWindow    *focus_this,
+                                    guint32        timestamp)
+{
+  MetaWorkspace *old;
+  MetaWindow *move_window;
+  
+  meta_verbose ("Activating workspace %d\n",
+                meta_workspace_index (workspace));
+  
+  if (workspace->screen->active_workspace == workspace)
+    return;
+
+  if (workspace->screen->active_workspace)
+    workspace_switch_sound(workspace->screen->active_workspace, workspace);
+
+  /* Note that old can be NULL; e.g. when starting up */
+  old = workspace->screen->active_workspace;
+  
+  workspace->screen->active_workspace = workspace;
+
+  set_active_space_hint (workspace->screen);
+
+  /* If the "show desktop" mode is active for either the old workspace
+   * or the new one *but not both*, then update the
+   * _net_showing_desktop hint
+   */
+  if (old && (old->showing_desktop ^ workspace->showing_desktop))
+    meta_screen_update_showing_desktop_hint (workspace->screen);
+
+  if (old == NULL)
+    return;
+
+  move_window = NULL;
+  if (workspace->screen->display->grab_op == META_GRAB_OP_MOVING ||
+      workspace->screen->display->grab_op == META_GRAB_OP_KEYBOARD_MOVING)
+    move_window = workspace->screen->display->grab_window;
+      
+  if (move_window != NULL)
+    {
+      if (move_window->on_all_workspaces)
+        move_window = NULL; /* don't move it after all */
+
+      /* We put the window on the new workspace, flip spaces,
+       * then remove from old workspace, so the window
+       * never gets unmapped and we maintain the button grab
+       * on it.
+       *
+       * \bug  This comment appears to be the reverse of what happens
+       */
+      if (move_window && (move_window->workspace != workspace))
+        {
+          meta_workspace_remove_window (old, move_window);
+          meta_workspace_add_window (workspace, move_window);
+        }
+    }
+
+  meta_workspace_queue_calc_showing (old);
+  meta_workspace_queue_calc_showing (workspace);
+
+  /* FIXME: Why do we need this?!?  Isn't it handled in the lines above? */
+  if (move_window)
+      /* Removes window from other spaces */
+      meta_window_change_workspace (move_window, workspace);
+
+  if (focus_this)
+    {
+      meta_window_focus (focus_this, timestamp);
+      meta_window_raise (focus_this);
+    }
+  else if (move_window)
+    {
+      meta_window_raise (move_window);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS, "Focusing default window on new workspace\n");
+      meta_workspace_focus_default_window (workspace, NULL, timestamp);
+    }
+}
+
+void
+meta_workspace_activate (MetaWorkspace *workspace,
+                         guint32        timestamp)
+{
+  meta_workspace_activate_with_focus (workspace, NULL, timestamp);
+}
+
+int
+meta_workspace_index (MetaWorkspace *workspace)
+{
+  int ret;
+
+  ret = g_list_index (workspace->screen->workspaces, workspace);
+
+  if (ret < 0)
+    meta_bug ("Workspace does not exist to index!\n");
+
+  return ret;
+}
+
+/* get windows contained on workspace, including workspace->windows
+ * and also sticky windows.
+ */
+GList*
+meta_workspace_list_windows (MetaWorkspace *workspace)
+{
+  GSList *display_windows;
+  GSList *tmp;
+  GList *workspace_windows;
+  
+  display_windows = meta_display_list_windows (workspace->screen->display);
+
+  workspace_windows = NULL;
+  tmp = display_windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (meta_window_located_on_workspace (window, workspace))
+        workspace_windows = g_list_prepend (workspace_windows,
+                                            window);
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (display_windows);
+
+  return workspace_windows;
+}
+
+static void
+set_active_space_hint (MetaScreen *screen)
+{
+  unsigned long data[1];
+
+  /* this is because we destroy the spaces in order,
+   * so we always end up setting a current desktop of
+   * 0 when closing a screen, so lose the current desktop
+   * on restart. By doing this we keep the current
+   * desktop on restart.
+   */
+  if (screen->closing > 0)
+    return;
+  
+  data[0] = meta_workspace_index (screen->active_workspace);
+
+  meta_verbose ("Setting _NET_CURRENT_DESKTOP to %lu\n", data[0]);
+  
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_CURRENT_DESKTOP,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+void
+meta_workspace_invalidate_work_area (MetaWorkspace *workspace)
+{
+  GList *tmp;
+  GList *windows;
+  int i;
+  
+  if (workspace->work_areas_invalid)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Work area for workspace %d is already invalid\n",
+                  meta_workspace_index (workspace));
+      return;
+    }
+
+  meta_topic (META_DEBUG_WORKAREA,
+              "Invalidating work area for workspace %d\n",
+              meta_workspace_index (workspace));
+
+  g_free (workspace->work_area_xinerama);
+  workspace->work_area_xinerama = NULL;
+      
+  workspace_free_struts (workspace);
+
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
+  g_free (workspace->xinerama_region);
+  meta_rectangle_free_list_and_elements (workspace->screen_region);
+  meta_rectangle_free_list_and_elements (workspace->screen_edges);
+  meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
+  workspace->xinerama_region = NULL;
+  workspace->screen_region = NULL;
+  workspace->screen_edges = NULL;
+  workspace->xinerama_edges = NULL;
+  
+  workspace->work_areas_invalid = TRUE;
+
+  /* redo the size/position constraints on all windows */
+  windows = meta_workspace_list_windows (workspace);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      meta_window_queue (w, META_QUEUE_MOVE_RESIZE);
+      
+      tmp = tmp->next;
+    }
+
+  g_list_free (windows);
+
+  meta_screen_queue_workarea_recalc (workspace->screen);
+}
+
+static void
+ensure_work_areas_validated (MetaWorkspace *workspace)
+{
+  GList         *windows;
+  GList         *tmp;
+  MetaRectangle  work_area;
+  int            i;  /* C89 absolutely sucks... */
+
+  if (!workspace->work_areas_invalid)
+    return;
+
+  g_assert (workspace->all_struts == NULL);
+  g_assert (workspace->xinerama_region == NULL);
+  g_assert (workspace->screen_region == NULL);
+  g_assert (workspace->screen_edges == NULL);
+  g_assert (workspace->xinerama_edges == NULL);
+
+  /* STEP 1: Get the list of struts */  
+  windows = meta_workspace_list_windows (workspace);
+  for (tmp = windows; tmp != NULL; tmp = tmp->next)
+    {
+      MetaWindow *win = tmp->data;
+      GSList *s_iter;
+
+      for (s_iter = win->struts; s_iter != NULL; s_iter = s_iter->next) {
+        MetaStrut *cpy = g_new (MetaStrut, 1);
+        *cpy = *((MetaStrut *)s_iter->data);
+        workspace->all_struts = g_slist_prepend (workspace->all_struts,
+                                                 cpy);
+      }
+    }
+  g_list_free (windows);
+
+  /* STEP 2: Get the maximal/spanning rects for the onscreen and
+   *         on-single-xinerama regions
+   */  
+  g_assert (workspace->xinerama_region == NULL);
+  g_assert (workspace->screen_region   == NULL);
+
+  workspace->xinerama_region = g_new (GList*,
+                                      workspace->screen->n_xinerama_infos);
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    {
+      workspace->xinerama_region[i] =
+        meta_rectangle_get_minimal_spanning_set_for_region (
+          &workspace->screen->xinerama_infos[i].rect,
+          workspace->all_struts);
+    }
+  workspace->screen_region =
+    meta_rectangle_get_minimal_spanning_set_for_region (
+      &workspace->screen->rect,
+      workspace->all_struts);
+
+  /* STEP 3: Get the work areas (region-to-maximize-to) for the screen and
+   *         xineramas.
+   */
+  work_area = workspace->screen->rect;  /* start with the screen */
+  if (workspace->screen_region == NULL)
+    work_area = meta_rect (0, 0, -1, -1);
+  else
+    meta_rectangle_clip_to_region (workspace->screen_region,
+                                   FIXED_DIRECTION_NONE,
+                                   &work_area);
+
+  /* Lots of paranoia checks, forcing work_area_screen to be sane */
+#define MIN_SANE_AREA 100
+  if (work_area.width < MIN_SANE_AREA)
+    {
+      meta_warning ("struts occupy an unusually large percentage of the screen; "
+                    "available remaining width = %d < %d",
+                    work_area.width, MIN_SANE_AREA);
+      if (work_area.width < 1)
+        {
+          work_area.x = (workspace->screen->rect.width - MIN_SANE_AREA)/2;
+          work_area.width = MIN_SANE_AREA;
+        }
+      else
+        {
+          int amount = (MIN_SANE_AREA - work_area.width)/2;
+          work_area.x     -=   amount;
+          work_area.width += 2*amount;
+        }
+    }
+  if (work_area.height < MIN_SANE_AREA)
+    {
+      meta_warning ("struts occupy an unusually large percentage of the screen; "
+                    "available remaining height = %d < %d",
+                    work_area.height, MIN_SANE_AREA);
+      if (work_area.height < 1)
+        {
+          work_area.y = (workspace->screen->rect.height - MIN_SANE_AREA)/2;
+          work_area.height = MIN_SANE_AREA;
+        }
+      else
+        {
+          int amount = (MIN_SANE_AREA - work_area.height)/2;
+          work_area.y      -=   amount;
+          work_area.height += 2*amount;
+        }
+    }
+  workspace->work_area_screen = work_area;
+  meta_topic (META_DEBUG_WORKAREA,
+              "Computed work area for workspace %d: %d,%d %d x %d\n",
+              meta_workspace_index (workspace),
+              workspace->work_area_screen.x,
+              workspace->work_area_screen.y,
+              workspace->work_area_screen.width,
+              workspace->work_area_screen.height);    
+
+  /* Now find the work areas for each xinerama */
+  g_free (workspace->work_area_xinerama);
+  workspace->work_area_xinerama = g_new (MetaRectangle,
+                                         workspace->screen->n_xinerama_infos);
+
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    {
+      work_area = workspace->screen->xinerama_infos[i].rect;
+
+      if (workspace->xinerama_region[i] == NULL)
+        /* FIXME: constraints.c untested with this, but it might be nice for
+         * a screen reader or magnifier.
+         */
+        work_area = meta_rect (work_area.x, work_area.y, -1, -1);
+      else
+        meta_rectangle_clip_to_region (workspace->xinerama_region[i],
+                                       FIXED_DIRECTION_NONE,
+                                       &work_area);
+
+      workspace->work_area_xinerama[i] = work_area;
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Computed work area for workspace %d "
+                  "xinerama %d: %d,%d %d x %d\n",
+                  meta_workspace_index (workspace),
+                  i,
+                  workspace->work_area_xinerama[i].x,
+                  workspace->work_area_xinerama[i].y,
+                  workspace->work_area_xinerama[i].width,
+                  workspace->work_area_xinerama[i].height);
+    }
+
+  /* STEP 4: Make sure the screen_region is nonempty (separate from step 2
+   *         since it relies on step 3).
+   */  
+  if (workspace->screen_region == NULL)
+    {
+      MetaRectangle *nonempty_region;
+      nonempty_region = g_new (MetaRectangle, 1);
+      *nonempty_region = workspace->work_area_screen;
+      workspace->screen_region = g_list_prepend (NULL, nonempty_region);
+    }
+
+  /* STEP 5: Cache screen and xinerama edges for edge resistance and snapping */
+  g_assert (workspace->screen_edges    == NULL);
+  g_assert (workspace->xinerama_edges  == NULL);
+  workspace->screen_edges =
+    meta_rectangle_find_onscreen_edges (&workspace->screen->rect,
+                                        workspace->all_struts);
+  tmp = NULL;
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    tmp = g_list_prepend (tmp, &workspace->screen->xinerama_infos[i].rect);
+  workspace->xinerama_edges =
+    meta_rectangle_find_nonintersected_xinerama_edges (tmp,
+                                                       workspace->all_struts);
+  g_list_free (tmp);
+
+  /* We're all done, YAAY!  Record that everything has been validated. */
+  workspace->work_areas_invalid = FALSE;
+}
+
+void
+meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace,
+                                           int            which_xinerama,
+                                           MetaRectangle *area)
+{
+  g_assert (which_xinerama >= 0);
+
+  ensure_work_areas_validated (workspace);
+  g_assert (which_xinerama < workspace->screen->n_xinerama_infos);
+  
+  *area = workspace->work_area_xinerama[which_xinerama];
+}
+
+void
+meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
+                                            MetaRectangle *area)
+{
+  ensure_work_areas_validated (workspace);
+  
+  *area = workspace->work_area_screen;
+}
+
+GList*
+meta_workspace_get_onscreen_region (MetaWorkspace *workspace)
+{
+  ensure_work_areas_validated (workspace);
+
+  return workspace->screen_region;
+}
+
+GList*
+meta_workspace_get_onxinerama_region (MetaWorkspace *workspace,
+                                      int            which_xinerama)
+{
+  ensure_work_areas_validated (workspace);
+
+  return workspace->xinerama_region[which_xinerama];
+}
+
+#ifdef WITH_VERBOSE_MODE
+static char *
+meta_motion_direction_to_string (MetaMotionDirection direction)
+{
+  switch (direction)
+    {
+    case META_MOTION_UP:
+      return "Up";
+    case META_MOTION_DOWN:
+      return "Down";
+    case META_MOTION_LEFT:
+      return "Left";
+    case META_MOTION_RIGHT:
+      return "Right";
+    }
+
+  return "Unknown";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+MetaWorkspace*
+meta_workspace_get_neighbor (MetaWorkspace      *workspace,
+                             MetaMotionDirection direction)
+{
+  MetaWorkspaceLayout layout;  
+  int i, current_space, num_workspaces;
+  gboolean ltr;
+
+  current_space = meta_workspace_index (workspace);
+  num_workspaces = meta_screen_get_n_workspaces (workspace->screen);
+  meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
+                                     current_space, &layout);
+
+  meta_verbose ("Getting neighbor of %d in direction %s\n",
+                current_space, meta_motion_direction_to_string (direction));
+  
+  ltr = meta_ui_get_direction() == META_UI_DIRECTION_LTR;
+
+  switch (direction) 
+    {
+    case META_MOTION_LEFT:
+      layout.current_col -= ltr ? 1 : -1;
+      break;
+    case META_MOTION_RIGHT:
+      layout.current_col += ltr ? 1 : -1;
+      break;
+    case META_MOTION_UP:
+      layout.current_row -= 1;
+      break;
+    case META_MOTION_DOWN:
+      layout.current_row += 1;
+      break;
+    }
+
+  if (layout.current_col < 0)
+    layout.current_col = 0;
+  if (layout.current_col >= layout.cols)
+    layout.current_col = layout.cols - 1;
+  if (layout.current_row < 0)
+    layout.current_row = 0;
+  if (layout.current_row >= layout.rows)
+    layout.current_row = layout.rows - 1;
+
+  i = layout.grid[layout.current_row * layout.cols + layout.current_col];
+
+  if (i < 0)
+    i = current_space;
+
+  if (i >= num_workspaces)
+    meta_bug ("calc_workspace_layout left an invalid (too-high) workspace number %d in the grid\n",
+              i);
+    
+  meta_verbose ("Neighbor workspace is %d at row %d col %d\n",
+                i, layout.current_row, layout.current_col);
+
+  meta_screen_free_workspace_layout (&layout);
+  
+  return meta_screen_get_workspace_by_index (workspace->screen, i);
+}
+
+const char*
+meta_workspace_get_name (MetaWorkspace *workspace)
+{
+  return meta_prefs_get_workspace_name (meta_workspace_index (workspace));
+}
+
+void
+meta_workspace_focus_default_window (MetaWorkspace *workspace,
+                                     MetaWindow    *not_this_one,
+                                     guint32        timestamp)
+{
+  if (timestamp == CurrentTime)
+    {
+      meta_warning ("CurrentTime used to choose focus window; "
+                    "focus window may not be correct.\n");
+    }
+
+
+  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+      !workspace->screen->display->mouse_mode)
+    focus_ancestor_or_mru_window (workspace, not_this_one, timestamp);
+  else
+    {
+      MetaWindow * window;
+      window = meta_screen_get_mouse_window (workspace->screen, not_this_one);
+      if (window &&
+          window->type != META_WINDOW_DOCK &&
+          window->type != META_WINDOW_DESKTOP)
+        {
+          if (timestamp == CurrentTime)
+            {
+
+              /* We would like for this to never happen.  However, if
+               * it does happen then we kludge since using CurrentTime
+               * can mean ugly race conditions--and we can avoid these
+               * by allowing EnterNotify events (which come with
+               * timestamps) to handle focus.
+               */
+
+              meta_topic (META_DEBUG_FOCUS,
+                          "Not focusing mouse window %s because EnterNotify events should handle that\n", window->desc);
+            }
+          else
+            {
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focusing mouse window %s\n", window->desc);
+              meta_window_focus (window, timestamp);
+            }
+
+          if (workspace->screen->display->autoraise_window != window &&
+              meta_prefs_get_auto_raise ()) 
+            {
+              meta_display_queue_autoraise_callback (workspace->screen->display,
+                                                     window);
+            }
+        }
+      else if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_SLOPPY)
+        focus_ancestor_or_mru_window (workspace, not_this_one, timestamp);
+      else if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_MOUSE)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Setting focus to no_focus_window, since no valid "
+                      "window to focus found.\n");
+          meta_display_focus_the_no_focus_window (workspace->screen->display,
+                                                  workspace->screen,
+                                                  timestamp);
+        }
+    }
+}
+
+static gboolean
+record_ancestor (MetaWindow *window,
+                 void       *data)
+{
+  MetaWindow **result = data;
+
+  *result = window;
+  return FALSE; /* quit with the first ancestor we find */
+}
+
+/* Focus ancestor of not_this_one if there is one, otherwise focus the MRU
+ * window on active workspace
+ */
+static void
+focus_ancestor_or_mru_window (MetaWorkspace *workspace,
+                              MetaWindow    *not_this_one,
+                              guint32        timestamp)
+{
+  MetaWindow *window = NULL;
+  MetaWindow *desktop_window = NULL;
+  GList *tmp;
+
+  if (not_this_one)
+    meta_topic (META_DEBUG_FOCUS,
+                "Focusing MRU window excluding %s\n", not_this_one->desc);
+  else
+    meta_topic (META_DEBUG_FOCUS,
+                "Focusing MRU window\n");
+
+  /* First, check to see if we need to focus an ancestor of a window */  
+  if (not_this_one)
+    {
+      MetaWindow *ancestor;
+      ancestor = NULL;
+      meta_window_foreach_ancestor (not_this_one, record_ancestor, &ancestor);
+      if (ancestor != NULL)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focusing %s, ancestor of %s\n", 
+                      ancestor->desc, not_this_one->desc);
+      
+          meta_window_focus (ancestor, timestamp);
+
+          /* Also raise the window if in click-to-focus */
+          if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+            meta_window_raise (ancestor);
+
+          return;
+        }
+    }
+
+  /* No ancestor, look for the MRU window */
+  tmp = workspace->mru_list;  
+
+  while (tmp)
+    {
+      MetaWindow* tmp_window;
+      tmp_window = ((MetaWindow*) tmp->data);
+      if (tmp_window != not_this_one           &&
+          meta_window_showing_on_its_workspace (tmp_window) &&
+          tmp_window->type != META_WINDOW_DOCK &&
+          tmp_window->type != META_WINDOW_DESKTOP)
+        {
+          window = tmp->data;
+          break;
+        }
+      else if (tmp_window != not_this_one      &&
+               desktop_window == NULL          &&
+               meta_window_showing_on_its_workspace (tmp_window) &&
+               tmp_window->type == META_WINDOW_DESKTOP)
+        {
+          /* Found the most recently used desktop window */
+          desktop_window = tmp_window;
+        }
+
+      tmp = tmp->next;
+    }
+
+  /* If no window was found, default to the MRU desktop-window */
+  if (window == NULL)
+    window = desktop_window;
+
+  if (window)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing workspace MRU window %s\n", window->desc);
+      
+      meta_window_focus (window, timestamp);
+
+      /* Also raise the window if in click-to-focus */
+      if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+        meta_window_raise (window);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS, "No MRU window to focus found; focusing no_focus_window.\n");
+      meta_display_focus_the_no_focus_window (workspace->screen->display,
+                                              workspace->screen,
+                                              timestamp);
+    }
+}
diff --git a/src/core/workspace.h b/src/core/workspace.h
new file mode 100644
index 00000000..f4079ebb
--- /dev/null
+++ b/src/core/workspace.h
@@ -0,0 +1,113 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file workspace.h    Workspaces
+ *
+ * A workspace is a set of windows which all live on the same
+ * screen.  (You may also see the name "desktop" around the place,
+ * which is the EWMH's name for the same thing.)  Only one workspace
+ * of a screen may be active at once; all windows on all other workspaces
+ * are unmapped.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WORKSPACE_H
+#define META_WORKSPACE_H
+
+#include "window-private.h"
+
+/* Negative to avoid conflicting with real workspace
+ * numbers
+ */
+typedef enum
+{
+  META_MOTION_UP = -1,
+  META_MOTION_DOWN = -2,
+  META_MOTION_LEFT = -3,
+  META_MOTION_RIGHT = -4
+} MetaMotionDirection;
+
+struct _MetaWorkspace
+{
+  MetaScreen *screen;
+  
+  GList *windows;
+  GList *mru_list;
+
+  GList  *list_containing_self;
+
+  MetaRectangle work_area_screen;
+  MetaRectangle *work_area_xinerama;
+  GList  *screen_region;
+  GList  **xinerama_region;
+  GList  *screen_edges;
+  GList  *xinerama_edges;
+  GSList *all_struts;
+  guint work_areas_invalid : 1;
+
+  guint showing_desktop : 1;
+};
+
+MetaWorkspace* meta_workspace_new           (MetaScreen    *screen);
+void           meta_workspace_free          (MetaWorkspace *workspace);
+void           meta_workspace_add_window    (MetaWorkspace *workspace,
+                                             MetaWindow    *window);
+void           meta_workspace_remove_window (MetaWorkspace *workspace,
+                                             MetaWindow    *window);
+void           meta_workspace_relocate_windows (MetaWorkspace *workspace,
+                                                MetaWorkspace *new_home);
+void           meta_workspace_activate_with_focus (MetaWorkspace *workspace,
+                                                   MetaWindow    *focus_this,
+                                                   guint32        timestamp);
+void           meta_workspace_activate            (MetaWorkspace *workspace,
+                                                   guint32        timestamp);
+int            meta_workspace_index         (MetaWorkspace *workspace);
+GList*         meta_workspace_list_windows  (MetaWorkspace *workspace);
+
+void meta_workspace_invalidate_work_area (MetaWorkspace *workspace);
+
+
+void meta_workspace_get_work_area_for_xinerama  (MetaWorkspace *workspace,
+                                                 int            which_xinerama,
+                                                 MetaRectangle *area);
+void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
+                                                 MetaRectangle *area);
+GList* meta_workspace_get_onscreen_region       (MetaWorkspace *workspace);
+GList* meta_workspace_get_onxinerama_region     (MetaWorkspace *workspace,
+                                                 int            which_xinerama);
+void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
+                                                 MetaRectangle *area);
+
+void meta_workspace_focus_default_window (MetaWorkspace *workspace,
+                                          MetaWindow    *not_this_one,
+                                          guint32        timestamp);
+
+MetaWorkspace* meta_workspace_get_neighbor (MetaWorkspace      *workspace,
+                                            MetaMotionDirection direction);
+
+const char* meta_workspace_get_name (MetaWorkspace *workspace);
+
+#endif
+
+
+
+
diff --git a/src/core/xprops.c b/src/core/xprops.c
new file mode 100644
index 00000000..71e9eeae
--- /dev/null
+++ b/src/core/xprops.c
@@ -0,0 +1,1238 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X property convenience routines */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat Inc.
+ *
+ * Some trivial property-unpacking code from Xlib:
+ *   Copyright 1987, 1988, 1998  The Open Group
+ *   Copyright 1988 by Wyse Technology, Inc., San Jose, Ca,
+ *   Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/***********************************************************
+Copyright 1988 by Wyse Technology, Inc., San Jose, Ca,
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL AND WYSE DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 
+EVENT SHALL DIGITAL OR WYSE BE LIABLE FOR ANY SPECIAL, INDIRECT OR 
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF 
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+
+Copyright 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+
+#include <config.h>
+#include "xprops.h"
+#include "errors.h"
+#include "util.h"
+#include "async-getprop.h"
+#include "ui.h"
+#include "marco-Xatomtype.h"
+#include <X11/Xatom.h>
+#include <string.h>
+#include "window-private.h"
+
+typedef struct
+{
+  MetaDisplay   *display;
+  Window         xwindow;
+  Atom           xatom;
+  Atom           type;
+  int            format;
+  unsigned long  n_items;
+  unsigned long  bytes_after;
+  unsigned char *prop;
+} GetPropertyResults;
+
+static gboolean
+validate_or_free_results (GetPropertyResults *results,
+                          int                 expected_format,
+                          Atom                expected_type,
+                          gboolean            must_have_items)
+{
+  char *type_name;
+  char *expected_name;
+  char *prop_name;
+  const char *title;
+  const char *res_class;
+  const char *res_name;
+  MetaWindow *w;
+  
+  if (expected_format == results->format &&
+      expected_type == results->type &&
+      (!must_have_items || results->n_items > 0))
+    return TRUE;  
+  
+  meta_error_trap_push (results->display);
+  type_name = XGetAtomName (results->display->xdisplay, results->type);
+  expected_name = XGetAtomName (results->display->xdisplay, expected_type);
+  prop_name = XGetAtomName (results->display->xdisplay, results->xatom);
+  meta_error_trap_pop (results->display, TRUE);
+
+  w = meta_display_lookup_x_window (results->display, results->xwindow);
+
+  if (w != NULL)
+    {
+      title = w->title;
+      res_class = w->res_class;
+      res_name = w->res_name;
+    }
+  else
+    {
+      title = NULL;
+      res_class = NULL;
+      res_name = NULL;
+    }
+  
+  if (title == NULL)
+    title = "unknown";
+
+  if (res_class == NULL)
+    res_class = "unknown";
+
+  if (res_name == NULL)
+    res_name = "unknown";
+  
+  meta_warning (_("Window 0x%lx has property %s\nthat was expected to have type %s format %d\nand actually has type %s format %d n_items %d.\nThis is most likely an application bug, not a window manager bug.\nThe window has title=\"%s\" class=\"%s\" name=\"%s\"\n"),
+                results->xwindow,
+                prop_name ? prop_name : "(bad atom)",
+                expected_name ? expected_name : "(bad atom)",
+                expected_format,
+                type_name ? type_name : "(bad atom)",
+                results->format, (int) results->n_items,
+                title, res_class, res_name);
+
+  if (type_name)
+    XFree (type_name);
+  if (expected_name)
+    XFree (expected_name);
+  if (prop_name)
+    XFree (prop_name);
+
+  if (results->prop)
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+    }
+  
+  return FALSE;
+}
+
+static gboolean
+get_property (MetaDisplay        *display,
+              Window              xwindow,
+              Atom                xatom,
+              Atom                req_type,
+              GetPropertyResults *results)
+{
+  results->display = display;
+  results->xwindow = xwindow;
+  results->xatom = xatom;
+  results->prop = NULL;
+  results->n_items = 0;
+  results->type = None;
+  results->bytes_after = 0;
+  results->format = 0;
+  
+  meta_error_trap_push_with_return (display);
+  if (XGetWindowProperty (display->xdisplay, xwindow, xatom,
+                          0, G_MAXLONG,
+                          False, req_type, &results->type, &results->format,
+                          &results->n_items,
+                          &results->bytes_after,
+                          &results->prop) != Success ||
+      results->type == None)
+    {
+      if (results->prop)
+        XFree (results->prop);
+      meta_error_trap_pop_with_return (display, TRUE);
+      return FALSE;
+    }
+
+  if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+    {
+      if (results->prop)
+        XFree (results->prop);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+atom_list_from_results (GetPropertyResults *results,
+                        Atom              **atoms_p,
+                        int                *n_atoms_p)
+{
+  if (!validate_or_free_results (results, 32, XA_ATOM, FALSE))
+    return FALSE;  
+
+  *atoms_p = (Atom*) results->prop;
+  *n_atoms_p = results->n_items;
+  results->prop = NULL;  
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_atom_list (MetaDisplay *display,
+                         Window       xwindow,
+                         Atom         xatom,
+                         Atom       **atoms_p,
+                         int         *n_atoms_p)
+{
+  GetPropertyResults results;
+
+  *atoms_p = NULL;
+  *n_atoms_p = 0;
+
+  if (!get_property (display, xwindow, xatom, XA_ATOM,
+                     &results))
+    return FALSE;
+
+  return atom_list_from_results (&results, atoms_p, n_atoms_p);
+}
+
+static gboolean
+cardinal_list_from_results (GetPropertyResults *results,
+                            gulong            **cardinals_p,
+                            int                *n_cardinals_p)
+{
+  if (!validate_or_free_results (results, 32, XA_CARDINAL, FALSE))
+    return FALSE;  
+
+  *cardinals_p = (gulong*) results->prop;
+  *n_cardinals_p = results->n_items;
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_cardinal_list (MetaDisplay *display,
+                             Window       xwindow,
+                             Atom         xatom,
+                             gulong     **cardinals_p,
+                             int         *n_cardinals_p)
+{
+  GetPropertyResults results;
+
+  *cardinals_p = NULL;
+  *n_cardinals_p = 0;
+
+  if (!get_property (display, xwindow, xatom, XA_CARDINAL,
+                     &results))
+    return FALSE;
+
+  return cardinal_list_from_results (&results, cardinals_p, n_cardinals_p);
+}
+
+static gboolean
+motif_hints_from_results (GetPropertyResults *results,
+                          MotifWmHints      **hints_p)
+{
+  int real_size, max_size;
+#define MAX_ITEMS sizeof (MotifWmHints)/sizeof (gulong)
+  
+  *hints_p = NULL;  
+
+  if (results->type == None || results->n_items <= 0)
+    {
+      meta_verbose ("Motif hints had unexpected type or n_items\n");
+      if (results->prop)
+        {
+          XFree (results->prop);
+          results->prop = NULL;
+        }
+      return FALSE;
+    }
+
+  /* The issue here is that some old crufty code will set a smaller
+   * MotifWmHints than the one we expect, apparently.  I'm not sure of
+   * the history behind it. See bug #89841 for example.
+   */
+  *hints_p = ag_Xmalloc (sizeof (MotifWmHints));
+  if (*hints_p == NULL)
+    {
+      if (results->prop)
+        {
+          XFree (results->prop);
+          results->prop = NULL;
+        }
+      return FALSE;
+    }
+  real_size = results->n_items * sizeof (gulong);
+  max_size = MAX_ITEMS * sizeof (gulong);
+  memcpy (*hints_p, results->prop, MIN (real_size, max_size));
+
+  if (results->prop)
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+    }
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_motif_hints (MetaDisplay   *display,
+                           Window         xwindow,
+                           Atom           xatom,
+                           MotifWmHints **hints_p)
+{
+  GetPropertyResults results;
+  
+  *hints_p = NULL;
+
+  if (!get_property (display, xwindow, xatom, AnyPropertyType,
+                     &results))
+    return FALSE;
+
+  return motif_hints_from_results (&results, hints_p);
+}
+
+static gboolean
+latin1_string_from_results (GetPropertyResults *results,
+                            char              **str_p)
+{
+  *str_p = NULL;
+  
+  if (!validate_or_free_results (results, 8, XA_STRING, FALSE))
+    return FALSE;
+
+  *str_p = (char*) results->prop;
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_latin1_string (MetaDisplay *display,
+                             Window       xwindow,
+                             Atom         xatom,
+                             char       **str_p)
+{
+  GetPropertyResults results;
+
+  *str_p = NULL;
+
+  if (!get_property (display, xwindow, xatom, XA_STRING,
+                     &results))
+    return FALSE;
+  
+  return latin1_string_from_results (&results, str_p);
+}
+
+static gboolean
+utf8_string_from_results (GetPropertyResults *results,
+                          char              **str_p)
+{
+  *str_p = NULL;
+  
+  if (!validate_or_free_results (results, 8,
+                                 results->display->atom_UTF8_STRING, FALSE))
+    return FALSE;
+
+  if (results->n_items > 0 &&
+      !g_utf8_validate ((gchar *)results->prop, results->n_items, NULL))
+    {
+      char *name;
+
+      name = XGetAtomName (results->display->xdisplay, results->xatom);
+      meta_warning (_("Property %s on window 0x%lx contained invalid UTF-8\n"),
+                    name, results->xwindow);
+      meta_XFree (name);
+      XFree (results->prop);
+      results->prop = NULL;
+      
+      return FALSE;
+    }
+  
+  *str_p = (char*) results->prop;
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_utf8_string (MetaDisplay *display,
+                           Window       xwindow,
+                           Atom         xatom,
+                           char       **str_p)
+{
+  GetPropertyResults results;
+
+  *str_p = NULL;
+
+  if (!get_property (display, xwindow, xatom,
+                     display->atom_UTF8_STRING,
+                     &results))
+    return FALSE;
+
+  return utf8_string_from_results (&results, str_p);
+}
+
+/* this one freakishly returns g_malloc memory */
+static gboolean
+utf8_list_from_results (GetPropertyResults *results,
+                        char             ***str_p,
+                        int                *n_str_p)
+{
+  int i;
+  int n_strings;
+  char **retval;
+  const char *p;
+  
+  *str_p = NULL;
+  *n_str_p = 0;
+
+  if (!validate_or_free_results (results, 8,
+                                 results->display->atom_UTF8_STRING, FALSE))
+    return FALSE;
+  
+  /* I'm not sure this is right, but I'm guessing the
+   * property is nul-separated
+   */
+  i = 0;
+  n_strings = 0;
+  while (i < (int) results->n_items)
+    {
+      if (results->prop[i] == '\0')
+        ++n_strings;
+      ++i;
+    }
+
+  if (results->prop[results->n_items - 1] != '\0')
+    ++n_strings;
+ 
+  /* we're guaranteed that results->prop has a nul on the end
+   * by XGetWindowProperty
+   */
+  
+  retval = g_new0 (char*, n_strings + 1);
+
+  p = (char *)results->prop;
+  i = 0;
+  while (i < n_strings)
+    {
+      if (!g_utf8_validate (p, -1, NULL))
+        {
+          char *name;
+
+          meta_error_trap_push (results->display);
+          name = XGetAtomName (results->display->xdisplay, results->xatom);
+          meta_error_trap_pop (results->display, TRUE);
+          meta_warning (_("Property %s on window 0x%lx contained invalid UTF-8 for item %d in the list\n"),
+                        name, results->xwindow, i);
+          meta_XFree (name);
+          meta_XFree (results->prop);
+          results->prop = NULL;
+          
+          g_strfreev (retval);
+          return FALSE;
+        }
+
+      retval[i] = g_strdup (p);
+      
+      p = p + strlen (p) + 1;
+      ++i;
+    }
+  
+  *str_p = retval;
+  *n_str_p = i;
+
+  meta_XFree (results->prop);
+  results->prop = NULL;
+
+  return TRUE;
+}
+
+/* returns g_malloc not Xmalloc memory */
+gboolean
+meta_prop_get_utf8_list (MetaDisplay   *display,
+                         Window         xwindow,
+                         Atom           xatom,
+                         char        ***str_p,
+                         int           *n_str_p)
+{
+  GetPropertyResults results;
+
+  *str_p = NULL;
+
+  if (!get_property (display, xwindow, xatom,
+                     display->atom_UTF8_STRING,
+                     &results))
+    return FALSE;
+
+  return utf8_list_from_results (&results, str_p, n_str_p);
+}
+
+void
+meta_prop_set_utf8_string_hint (MetaDisplay *display,
+                                Window xwindow,
+                                Atom atom,
+                                const char *val)
+{
+  meta_error_trap_push (display);
+  XChangeProperty (display->xdisplay, 
+                   xwindow, atom,
+                   display->atom_UTF8_STRING, 
+                   8, PropModeReplace, (guchar*) val, strlen (val));
+  meta_error_trap_pop (display, FALSE);
+}
+
+static gboolean
+window_from_results (GetPropertyResults *results,
+                     Window             *window_p)
+{
+  if (!validate_or_free_results (results, 32, XA_WINDOW, TRUE))
+    return FALSE;  
+
+  *window_p = *(Window*) results->prop;
+  XFree (results->prop);
+  results->prop = NULL;  
+  
+  return TRUE;
+}
+
+#ifdef HAVE_XSYNC
+static gboolean
+counter_from_results (GetPropertyResults *results,
+                      XSyncCounter       *counter_p)
+{
+  if (!validate_or_free_results (results, 32,
+                                 XA_CARDINAL,
+                                 TRUE))
+    return FALSE;  
+
+  *counter_p = *(XSyncCounter*) results->prop;
+  XFree (results->prop);
+  results->prop = NULL;
+  
+  return TRUE;
+}
+#endif
+
+gboolean
+meta_prop_get_window (MetaDisplay *display,
+                      Window       xwindow,
+                      Atom         xatom,
+                      Window      *window_p)
+{
+  GetPropertyResults results;
+
+  *window_p = None;
+  
+  if (!get_property (display, xwindow, xatom, XA_WINDOW,
+                     &results))
+    return FALSE;
+
+  return window_from_results (&results, window_p);
+}
+
+gboolean
+meta_prop_get_cardinal (MetaDisplay   *display,
+                        Window         xwindow,
+                        Atom           xatom,
+                        gulong        *cardinal_p)
+{
+  return meta_prop_get_cardinal_with_atom_type (display, xwindow, xatom,
+                                                XA_CARDINAL, cardinal_p);
+}
+
+static gboolean
+cardinal_with_atom_type_from_results (GetPropertyResults *results,
+                                      Atom                prop_type,
+                                      gulong             *cardinal_p)
+{
+  if (!validate_or_free_results (results, 32, prop_type, TRUE))
+    return FALSE;  
+
+  *cardinal_p = *(gulong*) results->prop;
+  XFree (results->prop);
+  results->prop = NULL;  
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_cardinal_with_atom_type (MetaDisplay   *display,
+                                       Window         xwindow,
+                                       Atom           xatom,
+                                       Atom           prop_type,
+                                       gulong        *cardinal_p)
+{
+  GetPropertyResults results;
+
+  *cardinal_p = 0;
+
+  if (!get_property (display, xwindow, xatom, prop_type,
+                     &results))
+    return FALSE;
+
+  return cardinal_with_atom_type_from_results (&results, prop_type, cardinal_p);
+}
+
+static gboolean
+text_property_from_results (GetPropertyResults *results,
+                            char              **utf8_str_p)
+{
+  XTextProperty tp;
+
+  *utf8_str_p = NULL;
+  
+  tp.value = results->prop;
+  results->prop = NULL;
+  tp.encoding = results->type;
+  tp.format = results->format;
+  tp.nitems = results->n_items;  
+  
+  *utf8_str_p = meta_text_property_to_utf8 (results->display->xdisplay,
+                                            &tp);
+  
+  if (tp.value != NULL)
+    XFree (tp.value);
+  
+  return *utf8_str_p != NULL;
+}
+
+gboolean
+meta_prop_get_text_property (MetaDisplay   *display,
+                             Window         xwindow,
+                             Atom           xatom,
+                             char         **utf8_str_p)
+{
+  GetPropertyResults results;
+  
+  if (!get_property (display, xwindow, xatom, AnyPropertyType,
+                     &results))
+    return FALSE;
+
+  return text_property_from_results (&results, utf8_str_p);
+}
+
+/* From Xmd.h */
+#ifndef cvtINT32toInt
+#if SIZEOF_VOID_P == 8
+#define cvtINT8toInt(val)   ((((unsigned int)val) & 0x00000080) ? (((unsigned int)val) | 0xffffffffffffff00) : ((unsigned int)val))
+#define cvtINT16toInt(val)  ((((unsigned int)val) & 0x00008000) ? (((unsigned int)val) | 0xffffffffffff0000) : ((unsigned int)val))
+#define cvtINT32toInt(val)  ((((unsigned int)val) & 0x80000000) ? (((unsigned int)val) | 0xffffffff00000000) : ((unsigned int)val))
+#define cvtINT8toShort(val)  cvtINT8toInt(val)
+#define cvtINT16toShort(val) cvtINT16toInt(val)
+#define cvtINT32toShort(val) cvtINT32toInt(val)
+#define cvtINT8toLong(val)  cvtINT8toInt(val)
+#define cvtINT16toLong(val) cvtINT16toInt(val)
+#define cvtINT32toLong(val) cvtINT32toInt(val)
+#else
+#define cvtINT8toInt(val) (val)
+#define cvtINT16toInt(val) (val)
+#define cvtINT32toInt(val) (val)
+#define cvtINT8toShort(val) (val)
+#define cvtINT16toShort(val) (val)
+#define cvtINT32toShort(val) (val)
+#define cvtINT8toLong(val) (val)
+#define cvtINT16toLong(val) (val)
+#define cvtINT32toLong(val) (val)
+#endif /* SIZEOF_VOID_P == 8 */
+#endif /* cvtINT32toInt() */
+
+static gboolean
+wm_hints_from_results (GetPropertyResults *results,
+                       XWMHints          **hints_p)
+{
+  XWMHints *hints;
+  xPropWMHints *raw;
+  
+  *hints_p = NULL;
+  
+  if (!validate_or_free_results (results, 32, XA_WM_HINTS, TRUE))
+    return FALSE;  
+
+  /* pre-R3 bogusly truncated window_group, don't fail on them */  
+  if (results->n_items < (NumPropWMHintsElements - 1))
+    {
+      meta_verbose ("WM_HINTS property too short: %d should be %d\n",
+                    (int) results->n_items, NumPropWMHintsElements - 1);
+      if (results->prop)
+        {
+          XFree (results->prop);
+          results->prop = NULL;
+        }
+      return FALSE;
+    }
+  
+  hints = ag_Xmalloc0 (sizeof (XWMHints));
+
+  raw = (xPropWMHints*) results->prop;
+  
+  hints->flags = raw->flags;
+  hints->input = (raw->input ? True : False);
+  hints->initial_state = cvtINT32toInt (raw->initialState);
+  hints->icon_pixmap = raw->iconPixmap;
+  hints->icon_window = raw->iconWindow;
+  hints->icon_x = cvtINT32toInt (raw->iconX);
+  hints->icon_y = cvtINT32toInt (raw->iconY);
+  hints->icon_mask = raw->iconMask;
+  if (results->n_items >= NumPropWMHintsElements)
+    hints->window_group = raw->windowGroup;
+  else
+    hints->window_group = 0;
+
+  if (results->prop)
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+    }
+
+  *hints_p = hints;
+
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_wm_hints (MetaDisplay   *display,
+                        Window         xwindow,
+                        Atom           xatom,
+                        XWMHints     **hints_p)
+{
+  GetPropertyResults results;
+
+  *hints_p = NULL;
+  
+  if (!get_property (display, xwindow, xatom, XA_WM_HINTS,
+                     &results))
+    return FALSE;
+
+  return wm_hints_from_results (&results, hints_p);
+}
+
+static gboolean
+class_hint_from_results (GetPropertyResults *results,
+                         XClassHint         *class_hint)
+{
+  int len_name, len_class;
+  
+  class_hint->res_class = NULL;
+  class_hint->res_name = NULL;
+  
+  if (!validate_or_free_results (results, 8, XA_STRING, FALSE))
+    return FALSE;
+  
+  len_name = strlen ((char *) results->prop);
+  if (! (class_hint->res_name = ag_Xmalloc (len_name+1)))
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+      return FALSE;
+    }
+  
+  strcpy (class_hint->res_name, (char *)results->prop);
+
+  if (len_name == (int) results->n_items)
+    len_name--;
+  
+  len_class = strlen ((char *)results->prop + len_name + 1);
+  
+  if (! (class_hint->res_class = ag_Xmalloc(len_class+1)))
+    {
+      XFree(class_hint->res_name);
+      class_hint->res_name = NULL;
+      XFree (results->prop);
+      results->prop = NULL;
+      return FALSE;
+    }
+  
+  strcpy (class_hint->res_class, (char *)results->prop + len_name + 1);
+
+  XFree (results->prop);
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_class_hint (MetaDisplay   *display,
+                          Window         xwindow,
+                          Atom           xatom,
+                          XClassHint    *class_hint)
+{
+  GetPropertyResults results;
+  
+  class_hint->res_class = NULL;
+  class_hint->res_name = NULL;
+  
+  if (!get_property (display, xwindow, xatom, XA_STRING,
+                     &results))
+    return FALSE;
+
+  return class_hint_from_results (&results, class_hint);
+}
+
+static gboolean
+size_hints_from_results (GetPropertyResults *results,
+                         XSizeHints        **hints_p,
+                         gulong             *flags_p)
+{
+  xPropSizeHints *raw;
+  XSizeHints *hints;
+  
+  *hints_p = NULL;
+  *flags_p = 0;
+  
+  if (!validate_or_free_results (results, 32, XA_WM_SIZE_HINTS, FALSE))
+    return FALSE;
+
+  if (results->n_items < OldNumPropSizeElements)
+    return FALSE;
+
+  raw = (xPropSizeHints*) results->prop;
+
+  hints = ag_Xmalloc (sizeof (XSizeHints));
+  
+  /* XSizeHints misdeclares these as int instead of long */
+  hints->flags = raw->flags;
+  hints->x = cvtINT32toInt (raw->x);
+  hints->y = cvtINT32toInt (raw->y);
+  hints->width = cvtINT32toInt (raw->width);
+  hints->height = cvtINT32toInt (raw->height);
+  hints->min_width  = cvtINT32toInt (raw->minWidth);
+  hints->min_height = cvtINT32toInt (raw->minHeight);
+  hints->max_width  = cvtINT32toInt (raw->maxWidth);
+  hints->max_height = cvtINT32toInt (raw->maxHeight);
+  hints->width_inc  = cvtINT32toInt (raw->widthInc);
+  hints->height_inc = cvtINT32toInt (raw->heightInc);
+  hints->min_aspect.x = cvtINT32toInt (raw->minAspectX);
+  hints->min_aspect.y = cvtINT32toInt (raw->minAspectY);
+  hints->max_aspect.x = cvtINT32toInt (raw->maxAspectX);
+  hints->max_aspect.y = cvtINT32toInt (raw->maxAspectY);
+
+  *flags_p = (USPosition | USSize | PAllHints);
+  if (results->n_items >= NumPropSizeElements)
+    {
+      hints->base_width= cvtINT32toInt (raw->baseWidth);
+      hints->base_height= cvtINT32toInt (raw->baseHeight);
+      hints->win_gravity= cvtINT32toInt (raw->winGravity);
+      *flags_p |= (PBaseSize | PWinGravity);
+    }
+
+  hints->flags &= (*flags_p);	/* get rid of unwanted bits */
+  
+  XFree (results->prop);
+  results->prop = NULL;
+
+  *hints_p = hints;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_size_hints (MetaDisplay   *display,
+                          Window         xwindow,
+                          Atom           xatom,
+                          XSizeHints   **hints_p,
+                          gulong        *flags_p)
+{
+  GetPropertyResults results;
+
+  *hints_p = NULL;
+  *flags_p = 0;
+  
+  if (!get_property (display, xwindow, xatom, XA_WM_SIZE_HINTS,
+                     &results))
+    return FALSE;
+
+  return size_hints_from_results (&results, hints_p, flags_p);
+}
+
+static AgGetPropertyTask*
+get_task (MetaDisplay        *display,
+          Window              xwindow,
+          Atom                xatom,
+          Atom                req_type)
+{
+  return ag_task_create (display->xdisplay,
+                         xwindow,
+                         xatom, 0, G_MAXLONG,
+                         False, req_type);
+}
+
+static char*
+latin1_to_utf8 (const char *text)
+{
+  GString *str;
+  const char *p;
+  
+  str = g_string_new ("");
+
+  p = text;
+  while (*p)
+    {
+      g_string_append_unichar (str, *p);
+      ++p;
+    }
+
+  return g_string_free (str, FALSE);
+}
+
+void
+meta_prop_get_values (MetaDisplay   *display,
+                      Window         xwindow,
+                      MetaPropValue *values,
+                      int            n_values)
+{
+  int i;
+  AgGetPropertyTask **tasks;
+
+  meta_verbose ("Requesting %d properties of 0x%lx at once\n",
+                n_values, xwindow);
+  
+  if (n_values == 0)
+    return;
+  
+  tasks = g_new0 (AgGetPropertyTask*, n_values);
+
+  /* Start up tasks. The "values" array can have values
+   * with atom == None, which means to ignore that element.
+   */
+  i = 0;
+  while (i < n_values)
+    {
+      if (values[i].required_type == None)
+        {
+          switch (values[i].type)
+            {
+            case META_PROP_VALUE_INVALID:
+              /* This means we don't really want a value, e.g. got
+               * property notify on an atom we don't care about.
+               */
+              if (values[i].atom != None)
+                meta_bug ("META_PROP_VALUE_INVALID requested in %s\n", G_STRFUNC);
+              break;
+            case META_PROP_VALUE_UTF8_LIST:
+            case META_PROP_VALUE_UTF8:
+              values[i].required_type = display->atom_UTF8_STRING;
+              break;
+            case META_PROP_VALUE_STRING:
+            case META_PROP_VALUE_STRING_AS_UTF8:
+              values[i].required_type = XA_STRING;
+              break;
+            case META_PROP_VALUE_MOTIF_HINTS:
+              values[i].required_type = AnyPropertyType;
+              break;
+            case META_PROP_VALUE_CARDINAL_LIST:
+            case META_PROP_VALUE_CARDINAL:
+              values[i].required_type = XA_CARDINAL;
+              break;
+            case META_PROP_VALUE_WINDOW:
+              values[i].required_type = XA_WINDOW;
+              break;
+            case META_PROP_VALUE_ATOM_LIST:
+              values[i].required_type = XA_ATOM;
+              break;
+            case META_PROP_VALUE_TEXT_PROPERTY:
+              values[i].required_type = AnyPropertyType;
+              break;
+            case META_PROP_VALUE_WM_HINTS:
+              values[i].required_type = XA_WM_HINTS;
+              break;
+            case META_PROP_VALUE_CLASS_HINT:
+              values[i].required_type = XA_STRING;
+              break;
+            case META_PROP_VALUE_SIZE_HINTS:
+              values[i].required_type = XA_WM_SIZE_HINTS;
+              break;
+            case META_PROP_VALUE_SYNC_COUNTER:
+	      values[i].required_type = XA_CARDINAL;
+              break;
+            }
+        }
+
+      if (values[i].atom != None)
+        tasks[i] = get_task (display, xwindow,
+                             values[i].atom, values[i].required_type);
+      
+      ++i;
+    }  
+  
+  /* Get replies for all our tasks */
+  meta_topic (META_DEBUG_SYNC, "Syncing to get %d GetProperty replies in %s\n",
+              n_values, G_STRFUNC);
+  XSync (display->xdisplay, False);
+  
+  /* Collect results, should arrive in order requested */
+  i = 0;
+  while (i < n_values)
+    {
+      AgGetPropertyTask *task;
+      GetPropertyResults results;
+      
+      if (tasks[i] == NULL)
+        {
+          /* Probably values[i].type was None, or ag_task_create()
+           * returned NULL.
+           */
+          values[i].type = META_PROP_VALUE_INVALID;
+          goto next;
+        }
+      
+      task = ag_get_next_completed_task (display->xdisplay);
+      g_assert (task != NULL);
+      g_assert (ag_task_have_reply (task));
+
+      results.display = display;
+      results.xwindow = xwindow;
+      results.xatom = values[i].atom;
+      results.prop = NULL;
+      results.n_items = 0;
+      results.type = None;
+      results.bytes_after = 0;
+      results.format = 0;
+      
+      if (ag_task_get_reply_and_free (task,
+                                      &results.type, &results.format,
+                                      &results.n_items,
+                                      &results.bytes_after,
+                                      &results.prop) != Success ||
+          results.type == None)
+        {
+          values[i].type = META_PROP_VALUE_INVALID;
+          if (results.prop)
+            {
+              XFree (results.prop);
+              results.prop = NULL;
+            }
+          goto next;
+        }
+
+      switch (values[i].type)
+        {
+        case META_PROP_VALUE_INVALID:
+          g_assert_not_reached ();
+          break;
+        case META_PROP_VALUE_UTF8_LIST:
+          if (!utf8_list_from_results (&results,
+                                       &values[i].v.string_list.strings,
+                                       &values[i].v.string_list.n_strings))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_UTF8:
+          if (!utf8_string_from_results (&results,
+                                         &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_STRING:
+          if (!latin1_string_from_results (&results,
+                                           &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_STRING_AS_UTF8:
+          if (!latin1_string_from_results (&results,
+                                           &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          else
+            {
+              char *new_str;
+              char *xmalloc_new_str;
+
+              new_str = latin1_to_utf8 (values[i].v.str);
+              xmalloc_new_str = ag_Xmalloc (strlen (new_str) + 1);
+              if (xmalloc_new_str != NULL)
+                {
+                  strcpy (xmalloc_new_str, new_str);
+                  meta_XFree (values[i].v.str);
+                  values[i].v.str = xmalloc_new_str;
+                }
+
+              g_free (new_str);
+            }
+          break;
+        case META_PROP_VALUE_MOTIF_HINTS:
+          if (!motif_hints_from_results (&results,
+                                         &values[i].v.motif_hints))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_CARDINAL_LIST:
+          if (!cardinal_list_from_results (&results,
+                                           &values[i].v.cardinal_list.cardinals,
+                                           &values[i].v.cardinal_list.n_cardinals))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_CARDINAL:
+          if (!cardinal_with_atom_type_from_results (&results,
+                                                     values[i].required_type,
+                                                     &values[i].v.cardinal))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_WINDOW:
+          if (!window_from_results (&results,
+                                    &values[i].v.xwindow))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_ATOM_LIST:
+          if (!atom_list_from_results (&results,
+                                       &values[i].v.atom_list.atoms,
+                                       &values[i].v.atom_list.n_atoms))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_TEXT_PROPERTY:
+          if (!text_property_from_results (&results, &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_WM_HINTS:
+          if (!wm_hints_from_results (&results, &values[i].v.wm_hints))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_CLASS_HINT:
+          if (!class_hint_from_results (&results, &values[i].v.class_hint))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_SIZE_HINTS:
+          if (!size_hints_from_results (&results,
+                                        &values[i].v.size_hints.hints,
+                                        &values[i].v.size_hints.flags))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_SYNC_COUNTER:
+#ifdef HAVE_XSYNC
+          if (!counter_from_results (&results,
+                                     &values[i].v.xcounter))
+            values[i].type = META_PROP_VALUE_INVALID;
+#else
+          values[i].type = META_PROP_VALUE_INVALID;
+          if (results.prop)
+            {
+              XFree (results.prop);
+              results.prop = NULL;
+            }
+#endif
+          break;
+        }
+
+    next:
+      ++i;
+    }
+
+  g_free (tasks);
+}
+
+static void
+free_value (MetaPropValue *value)
+{
+  switch (value->type)
+    {
+    case META_PROP_VALUE_INVALID:          
+      break;
+    case META_PROP_VALUE_UTF8:
+    case META_PROP_VALUE_STRING:
+    case META_PROP_VALUE_STRING_AS_UTF8:
+      meta_XFree (value->v.str);
+      break;
+    case META_PROP_VALUE_MOTIF_HINTS:
+      meta_XFree (value->v.motif_hints);
+      break;          
+    case META_PROP_VALUE_CARDINAL:
+      break;
+    case META_PROP_VALUE_WINDOW:          
+      break;
+    case META_PROP_VALUE_ATOM_LIST:
+      meta_XFree (value->v.atom_list.atoms);
+      break;
+    case META_PROP_VALUE_TEXT_PROPERTY:
+      meta_XFree (value->v.str);
+      break;
+    case META_PROP_VALUE_WM_HINTS:
+      meta_XFree (value->v.wm_hints);
+      break;
+    case META_PROP_VALUE_CLASS_HINT:
+      meta_XFree (value->v.class_hint.res_class);
+      meta_XFree (value->v.class_hint.res_name);
+      break;
+    case META_PROP_VALUE_SIZE_HINTS:
+      meta_XFree (value->v.size_hints.hints);
+      break;
+    case META_PROP_VALUE_UTF8_LIST:
+      g_strfreev (value->v.string_list.strings);
+      break;
+    case META_PROP_VALUE_CARDINAL_LIST:
+      meta_XFree (value->v.cardinal_list.cardinals);
+      break;
+    case META_PROP_VALUE_SYNC_COUNTER:
+      break;
+    }
+}
+
+void
+meta_prop_free_values (MetaPropValue *values,
+                       int            n_values)
+{
+  int i;
+
+  i = 0;
+  while (i < n_values)
+    {
+      free_value (&values[i]);
+      ++i;
+    }
+
+  /* Zero the whole thing to quickly detect breakage */
+  memset (values, '\0', sizeof (MetaPropValue) * n_values);
+}
diff --git a/src/include/all-keybindings.h b/src/include/all-keybindings.h
new file mode 100644
index 00000000..ee9b5d37
--- /dev/null
+++ b/src/include/all-keybindings.h
@@ -0,0 +1,386 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* 
+ * Copyright (C) 2008 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * A list of screen keybinding information.
+ *
+ * Each action which can have a keystroke bound to it is listed below.
+ * To use this file, define keybind() to be a seven-argument macro (you can
+ * throw any of the arguments you please away), include this file,
+ * and then undefine the macro again.
+ *
+ * (If you aren't familiar with this technique, sometimes called "x-macros",
+ * see DDJ of May 2001: <http://www.ddj.com/cpp/184401387>.)
+ *
+ * This makes it possible to keep all information about all the keybindings
+ * in the same place.  The only exception is the code to run when an action
+ * is actually invoked; while we *could* have put that in this file, it would
+ * have made debugging ridiculously difficult.  Instead, each action should
+ * have a corresponding static function named handle_<name>() in
+ * keybindings.c.
+ *
+ * The arguments to keybind() are:
+ *   1) the name of the binding; a bareword identifier
+ *              (it's fine if it happens to clash with a C reserved word)
+ *   2) the name of the function which implements it.
+ *              Clearly we could have guessed this from the binding very often,
+ *              but we choose to write it in full for the benefit of grep.
+ *   3) an integer parameter to pass to the handler
+ *   4) a set of boolean flags, ORed together:
+ *       BINDING_PER_WINDOW  - this is a window-based binding.
+ *                             It is only valid if there is a
+ *                             current window, and will operate in
+ *                             some way on that window.
+ *       BINDING_REVERSES    - the binding can reverse if you hold down Shift
+ *       BINDING_IS_REVERSED - the same, but the senses are reversed from the
+ *                             handler's point of view (let me know if I should
+ *                             explain this better)
+ *      or 0 if no flag applies.
+ *
+ *   5) a string representing the default binding.
+ *          If this is NULL, the action is unbound by default.
+ *          Please use NULL and not "disabled".
+ *   6) a short description.
+ *          It must be marked translatable (i.e. inside "_(...)").
+ *
+ * Don't try to do XML entity escaping anywhere in the strings.
+ */
+
+#ifndef keybind
+#error "keybind () must be defined when you include screen-bindings.h"
+#endif
+
+/***********************************/
+
+#ifndef _BINDINGS_DEFINED_CONSTANTS
+#define _BINDINGS_DEFINED_CONSTANTS 1
+
+#define BINDING_PER_WINDOW    0x01
+#define BINDING_REVERSES      0x02
+#define BINDING_IS_REVERSED   0x04
+
+#endif /* _BINDINGS_DEFINED_CONSTANTS */
+
+/***********************************/
+
+/* convenience, since in this file they must always be set together */
+#define REVERSES_AND_REVERSED (BINDING_REVERSES | BINDING_IS_REVERSED)
+
+keybind (switch_to_workspace_1,  handle_switch_to_workspace, 0, 0, NULL,
+        _("Switch to workspace 1"))
+keybind (switch_to_workspace_2,  handle_switch_to_workspace, 1, 0, NULL,
+        _("Switch to workspace 2"))
+keybind (switch_to_workspace_3,  handle_switch_to_workspace, 2, 0, NULL,
+        _("Switch to workspace 3"))
+keybind (switch_to_workspace_4,  handle_switch_to_workspace, 3, 0, NULL,
+        _("Switch to workspace 4"))
+keybind (switch_to_workspace_5,  handle_switch_to_workspace, 4, 0, NULL,
+        _("Switch to workspace 5"))
+keybind (switch_to_workspace_6,  handle_switch_to_workspace, 5, 0, NULL,
+        _("Switch to workspace 6"))
+keybind (switch_to_workspace_7,  handle_switch_to_workspace, 6, 0, NULL,
+        _("Switch to workspace 7"))
+keybind (switch_to_workspace_8,  handle_switch_to_workspace, 7, 0, NULL,
+        _("Switch to workspace 8"))
+keybind (switch_to_workspace_9,  handle_switch_to_workspace, 8, 0, NULL,
+        _("Switch to workspace 9"))
+keybind (switch_to_workspace_10, handle_switch_to_workspace, 9, 0, NULL,
+        _("Switch to workspace 10"))
+keybind (switch_to_workspace_11, handle_switch_to_workspace, 10, 0, NULL,
+        _("Switch to workspace 11"))
+keybind (switch_to_workspace_12, handle_switch_to_workspace, 11, 0, NULL,
+        _("Switch to workspace 12"))
+
+/* META_MOTION_* are negative, and so distinct from workspace numbers,
+ * which are always zero or positive.
+ * If you make use of these constants, you will need to include workspace.h
+ * (which you're probably using already for other reasons anyway).
+ * If your definition of keybind() throws them away, you don't need to include
+ * workspace.h, of course.
+ */
+
+keybind (switch_to_workspace_left, handle_switch_to_workspace,
+         META_MOTION_LEFT, 0, "<Control><Alt>Left",
+        _("Switch to workspace on the left of the current workspace"))
+
+keybind (switch_to_workspace_right, handle_switch_to_workspace,
+         META_MOTION_RIGHT, 0, "<Control><Alt>Right",
+        _("Switch to workspace on the right of the current workspace"))
+
+keybind (switch_to_workspace_up, handle_switch_to_workspace,
+         META_MOTION_UP, 0, "<Control><Alt>Up",
+        _("Switch to workspace above the current workspace"))
+
+keybind (switch_to_workspace_down, handle_switch_to_workspace,
+         META_MOTION_DOWN, 0, "<Control><Alt>Down",
+        _("Switch to workspace below the current workspace"))
+
+/***********************************/
+
+/* The ones which have inverses.  These can't be bound to any keystroke
+ * containing Shift because Shift will invert their "backward" state.
+ *
+ * TODO: "NORMAL" and "DOCKS" should be renamed to the same name as their
+ * action, for obviousness.
+ *
+ * TODO: handle_switch and handle_cycle should probably really be the
+ * same function checking a bit in the parameter for difference.
+ */
+
+keybind (switch_group,              handle_switch,        META_TAB_LIST_GROUP,
+         BINDING_REVERSES,       NULL,
+        _("Move between windows of an application, using a popup window"))
+keybind (switch_group_backward,    handle_switch,        META_TAB_LIST_GROUP,
+         REVERSES_AND_REVERSED,  NULL,
+        _("Move backward between windows of an application, "
+          "using a popup window"))
+keybind (switch_windows,            handle_switch,        META_TAB_LIST_NORMAL,
+         BINDING_REVERSES,       "<Alt>Tab",
+        _("Move between windows, using a popup window"))
+keybind (switch_windows_backward,  handle_switch,        META_TAB_LIST_NORMAL,
+         REVERSES_AND_REVERSED,  NULL,
+        _("Move backward between windows, using a popup window"))
+keybind (switch_panels,             handle_switch,        META_TAB_LIST_DOCKS,
+         BINDING_REVERSES,       "<Control><Alt>Tab",
+        _("Move between panels and the desktop, using a popup window"))
+keybind (switch_panels_backward,   handle_switch,        META_TAB_LIST_DOCKS,
+         REVERSES_AND_REVERSED,  NULL,
+         _("Move backward between panels and the desktop, "
+          "using a popup window"))
+
+keybind (cycle_group,               handle_cycle,         META_TAB_LIST_GROUP,
+        BINDING_REVERSES,        "<Alt>F6",
+        _("Move between windows of an application immediately"))
+keybind (cycle_group_backward,     handle_cycle,         META_TAB_LIST_GROUP,
+        REVERSES_AND_REVERSED,   NULL,
+        _("Move backward between windows of an application immediately"))
+keybind (cycle_windows,             handle_cycle,         META_TAB_LIST_NORMAL,
+        BINDING_REVERSES,        "<Alt>Escape",
+        _("Move between windows immediately"))
+keybind (cycle_windows_backward,   handle_cycle,         META_TAB_LIST_NORMAL,
+        REVERSES_AND_REVERSED,   NULL,
+        _("Move backward between windows immediately"))
+keybind (cycle_panels,              handle_cycle,         META_TAB_LIST_DOCKS,
+        BINDING_REVERSES,        "<Control><Alt>Escape",
+        _("Move between panels and the desktop immediately"))
+keybind (cycle_panels_backward,    handle_cycle,         META_TAB_LIST_DOCKS,
+        REVERSES_AND_REVERSED,   NULL,
+        _("Move backward between panels and the desktop immediately"))
+
+/***********************************/
+     
+keybind (show_desktop, handle_show_desktop, 0, 0, "<Control><Alt>d",
+      _("Hide all normal windows and set focus to the desktop"))
+keybind (panel_main_menu, handle_panel,
+       META_KEYBINDING_ACTION_PANEL_MAIN_MENU, 0, "<Alt>F1",
+      _("Show the panel's main menu"))
+keybind (panel_run_dialog, handle_panel,
+       META_KEYBINDING_ACTION_PANEL_RUN_DIALOG, 0, "<Alt>F2",
+      _("Show the panel's \"Run Application\" dialog box"))
+
+/* Yes, the param is offset by one.  Historical reasons.  (Maybe worth fixing
+ * at some point.)  The description is NULL here because the stanza is
+ * irregularly shaped in marco.schemas.in.  This will probably be fixed
+ * as well.
+ */
+keybind (run_command_1,  handle_run_command,  0, 0, NULL, NULL)
+keybind (run_command_2,  handle_run_command,  1, 0, NULL, NULL)
+keybind (run_command_3,  handle_run_command,  2, 0, NULL, NULL)
+keybind (run_command_4,  handle_run_command,  3, 0, NULL, NULL)
+keybind (run_command_5,  handle_run_command,  4, 0, NULL, NULL)
+keybind (run_command_6,  handle_run_command,  5, 0, NULL, NULL)
+keybind (run_command_7,  handle_run_command,  6, 0, NULL, NULL)
+keybind (run_command_8,  handle_run_command,  7, 0, NULL, NULL)
+keybind (run_command_9,  handle_run_command,  8, 0, NULL, NULL)
+keybind (run_command_10, handle_run_command,  9, 0, NULL, NULL)
+keybind (run_command_11, handle_run_command, 10, 0, NULL, NULL)
+keybind (run_command_12, handle_run_command, 11, 0, NULL, NULL)
+keybind (run_command_13, handle_run_command, 12, 0, NULL, NULL)
+keybind (run_command_14, handle_run_command, 13, 0, NULL, NULL)
+keybind (run_command_15, handle_run_command, 14, 0, NULL, NULL)
+keybind (run_command_16, handle_run_command, 15, 0, NULL, NULL)
+keybind (run_command_17, handle_run_command, 16, 0, NULL, NULL)
+keybind (run_command_18, handle_run_command, 17, 0, NULL, NULL)
+keybind (run_command_19, handle_run_command, 18, 0, NULL, NULL)
+keybind (run_command_20, handle_run_command, 19, 0, NULL, NULL)
+keybind (run_command_21, handle_run_command, 20, 0, NULL, NULL)
+keybind (run_command_22, handle_run_command, 21, 0, NULL, NULL)
+keybind (run_command_23, handle_run_command, 22, 0, NULL, NULL)
+keybind (run_command_24, handle_run_command, 23, 0, NULL, NULL)
+keybind (run_command_25, handle_run_command, 24, 0, NULL, NULL)
+keybind (run_command_26, handle_run_command, 25, 0, NULL, NULL)
+keybind (run_command_27, handle_run_command, 26, 0, NULL, NULL)
+keybind (run_command_28, handle_run_command, 27, 0, NULL, NULL)
+keybind (run_command_29, handle_run_command, 28, 0, NULL, NULL)
+keybind (run_command_30, handle_run_command, 29, 0, NULL, NULL)
+keybind (run_command_31, handle_run_command, 30, 0, NULL, NULL)
+keybind (run_command_32, handle_run_command, 31, 0, NULL, NULL)
+
+keybind (run_command_screenshot, handle_run_command, 32, 0, "Print",
+      _("Take a screenshot"))
+keybind (run_command_window_screenshot, handle_run_command, 33, 0,"<Alt>Print",
+      _("Take a screenshot of a window"))
+
+keybind (run_command_terminal, handle_run_terminal, 0, 0, NULL, _("Run a terminal"))
+
+/* No description because this is undocumented */
+keybind (set_spew_mark, handle_set_spew_mark, 0, 0, NULL, NULL)
+
+#undef REVERSES_AND_REVERSED
+
+/************************ PER WINDOW BINDINGS ************************/
+
+/* These take a window as an extra parameter; they have no effect
+ * if no window is active.
+ */
+ 
+keybind (activate_window_menu, handle_activate_window_menu, 0,
+        BINDING_PER_WINDOW, "<Alt>space",
+        _("Activate the window menu"))
+keybind (toggle_fullscreen, handle_toggle_fullscreen, 0, BINDING_PER_WINDOW,
+        NULL,
+        _("Toggle fullscreen mode"))
+keybind (toggle_maximized, handle_toggle_maximized, 0, BINDING_PER_WINDOW, "<Alt>F10",
+        _("Toggle maximization state"))
+keybind (toggle_above, handle_toggle_above, 0, BINDING_PER_WINDOW, NULL,
+        _("Toggle whether a window will always be visible over other windows"))
+keybind (maximize, handle_maximize, 0, BINDING_PER_WINDOW, NULL,
+        _("Maximize window"))
+keybind (unmaximize, handle_unmaximize, 0, BINDING_PER_WINDOW, "<Alt>F5",
+        _("Restore window"))
+keybind (toggle_shaded, handle_toggle_shaded, 0, BINDING_PER_WINDOW, NULL,
+        _("Toggle shaded state"))
+keybind (minimize, handle_minimize, 0, BINDING_PER_WINDOW, "<Alt>F9",
+        _("Minimize window"))
+keybind (close, handle_close, 0, BINDING_PER_WINDOW, "<Alt>F4",
+        _("Close window"))
+keybind (begin_move, handle_begin_move, 0, BINDING_PER_WINDOW, "<Alt>F7",
+        _("Move window"))
+keybind (begin_resize, handle_begin_resize, 0, BINDING_PER_WINDOW, "<Alt>F8",
+        _("Resize window"))
+keybind (toggle_on_all_workspaces, handle_toggle_on_all_workspaces, 0,
+         BINDING_PER_WINDOW, NULL,
+        _("Toggle whether window is on all workspaces or just one"))
+
+keybind (move_to_workspace_1, handle_move_to_workspace, 0, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 1"))
+keybind (move_to_workspace_2, handle_move_to_workspace, 1, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 2"))
+keybind (move_to_workspace_3, handle_move_to_workspace, 2, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 3"))
+keybind (move_to_workspace_4, handle_move_to_workspace, 3, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 4"))
+keybind (move_to_workspace_5, handle_move_to_workspace, 4, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 5"))
+keybind (move_to_workspace_6, handle_move_to_workspace, 5, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 6"))
+keybind (move_to_workspace_7, handle_move_to_workspace, 6, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 7"))
+keybind (move_to_workspace_8, handle_move_to_workspace, 7, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 8"))
+keybind (move_to_workspace_9, handle_move_to_workspace, 8, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 9"))
+keybind (move_to_workspace_10, handle_move_to_workspace, 9, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 10"))
+keybind (move_to_workspace_11, handle_move_to_workspace, 10, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 11"))
+keybind (move_to_workspace_12, handle_move_to_workspace, 11, BINDING_PER_WINDOW,
+        NULL,
+        _("Move window to workspace 12"))
+
+/* META_MOTION_* are negative, and so distinct from workspace numbers,
+ * which are always zero or positive.
+ * If you make use of these constants, you will need to include workspace.h
+ * (which you're probably using already for other reasons anyway).
+ * If your definition of keybind() throws them away, you don't need to include
+ * workspace.h, of course.
+ */
+
+keybind (move_to_workspace_left, handle_move_to_workspace,
+         META_MOTION_LEFT, BINDING_PER_WINDOW, "<Control><Shift><Alt>Left",
+        _("Move window one workspace to the left"))
+keybind (move_to_workspace_right, handle_move_to_workspace,
+         META_MOTION_RIGHT, BINDING_PER_WINDOW, "<Control><Shift><Alt>Right",
+        _("Move window one workspace to the right"))
+keybind (move_to_workspace_up, handle_move_to_workspace,
+         META_MOTION_UP, BINDING_PER_WINDOW, "<Control><Shift><Alt>Up",
+        _("Move window one workspace up"))
+keybind (move_to_workspace_down, handle_move_to_workspace,
+         META_MOTION_DOWN, BINDING_PER_WINDOW, "<Control><Shift><Alt>Down",
+        _("Move window one workspace down"))
+
+keybind (raise_or_lower, handle_raise_or_lower, 0, BINDING_PER_WINDOW, NULL,
+        _("Raise window if it's covered by another window, otherwise lower it"))
+keybind (raise, handle_raise, 0, BINDING_PER_WINDOW, NULL,
+        _("Raise window above other windows"))
+keybind (lower, handle_lower, 0, BINDING_PER_WINDOW, NULL,
+        _("Lower window below other windows"))
+
+keybind (maximize_vertically, handle_maximize_vertically, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Maximize window vertically"))
+
+keybind (maximize_horizontally, handle_maximize_horizontally, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Maximize window horizontally"))
+
+keybind (move_to_corner_nw, handle_move_to_corner_nw, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to north-west (top left) corner"))
+keybind (move_to_corner_ne, handle_move_to_corner_ne, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to north-east (top right) corner"))
+keybind (move_to_corner_sw, handle_move_to_corner_sw, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to south-west (bottom left) corner"))
+keybind (move_to_corner_se, handle_move_to_corner_se, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to south-east (bottom right) corner"))
+
+keybind (move_to_side_n, handle_move_to_side_n, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to north (top) side of screen"))
+keybind (move_to_side_s, handle_move_to_side_s, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to south (bottom) side of screen"))
+keybind (move_to_side_e, handle_move_to_side_e, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to east (right) side of screen"))
+keybind (move_to_side_w, handle_move_to_side_w, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to west (left) side of screen"))
+keybind (move_to_center, handle_move_to_center, 0,
+        BINDING_PER_WINDOW, NULL,
+        _("Move window to center of screen"))
+
+/* eof all-keybindings.h */
+
diff --git a/src/include/boxes.h b/src/include/boxes.h
new file mode 100644
index 00000000..5c76ed6b
--- /dev/null
+++ b/src/include/boxes.h
@@ -0,0 +1,290 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Simple box operations */
+
+/* 
+ * Copyright (C) 2005, 2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_BOXES_H
+#define META_BOXES_H
+
+#include <glib.h>
+#include "common.h"
+
+typedef struct _MetaRectangle MetaRectangle;
+struct _MetaRectangle
+{
+  int x;
+  int y;
+  int width;
+  int height;
+};
+
+typedef struct _MetaStrut MetaStrut;
+struct _MetaStrut
+{
+  MetaRectangle rect;
+  MetaSide side;
+};
+
+#define BOX_LEFT(box)    ((box).x)                /* Leftmost pixel of rect */
+#define BOX_RIGHT(box)   ((box).x + (box).width)  /* One pixel past right   */
+#define BOX_TOP(box)     ((box).y)                /* Topmost pixel of rect  */
+#define BOX_BOTTOM(box)  ((box).y + (box).height) /* One pixel past bottom  */
+
+typedef enum
+{
+  FIXED_DIRECTION_NONE = 0,
+  FIXED_DIRECTION_X    = 1 << 0,
+  FIXED_DIRECTION_Y    = 1 << 1,
+} FixedDirections;
+
+typedef enum
+{
+  META_EDGE_WINDOW,
+  META_EDGE_XINERAMA,
+  META_EDGE_SCREEN
+} MetaEdgeType;
+
+typedef struct _MetaEdge MetaEdge;
+struct _MetaEdge
+{
+  MetaRectangle rect;      /* width or height should be 1 */
+  MetaSide side_type;
+  MetaEdgeType  edge_type;
+};
+
+/* Output functions -- note that the output buffer had better be big enough:
+ *   rect_to_string:   RECT_LENGTH
+ *   region_to_string: (RECT_LENGTH+strlen(separator_string)) *
+ *                     g_list_length (region)
+ *   edge_to_string:   EDGE_LENGTH
+ *   edge_list_to_...: (EDGE_LENGTH+strlen(separator_string)) * 
+ *                     g_list_length (edge_list)
+ */
+#define RECT_LENGTH 27
+#define EDGE_LENGTH 37
+char* meta_rectangle_to_string        (const MetaRectangle *rect,
+                                       char                *output);
+char* meta_rectangle_region_to_string (GList               *region,
+                                       const char          *separator_string,
+                                       char                *output);
+char* meta_rectangle_edge_to_string   (const MetaEdge      *edge,
+                                       char                *output);
+char* meta_rectangle_edge_list_to_string (
+                                       GList               *edge_list,
+                                       const char          *separator_string,
+                                       char                *output);
+
+/* Function to make initializing a rect with a single line of code easy */
+MetaRectangle                 meta_rect (int x, int y, int width, int height);
+
+/* Basic comparison functions */
+int      meta_rectangle_area            (const MetaRectangle *rect);
+gboolean meta_rectangle_intersect       (const MetaRectangle *src1,
+                                         const MetaRectangle *src2,
+                                         MetaRectangle       *dest);
+gboolean meta_rectangle_equal           (const MetaRectangle *src1,
+                                         const MetaRectangle *src2);
+
+/* Find the bounding box of the union of two rectangles */
+void     meta_rectangle_union           (const MetaRectangle *rect1,
+                                         const MetaRectangle *rect2,
+                                         MetaRectangle       *dest);
+
+/* overlap is similar to intersect but doesn't provide location of
+ * intersection information.
+ */
+gboolean meta_rectangle_overlap         (const MetaRectangle *rect1,
+                                         const MetaRectangle *rect2);
+
+/* vert_overlap means ignore the horizontal location and ask if the
+ * vertical parts overlap.  An alternate way to think of it is "Does there
+ * exist a way to shift either rect horizontally so that the two rects
+ * overlap?"  horiz_overlap is similar.
+ */
+gboolean meta_rectangle_vert_overlap    (const MetaRectangle *rect1,
+                                         const MetaRectangle *rect2);
+gboolean meta_rectangle_horiz_overlap   (const MetaRectangle *rect1,
+                                         const MetaRectangle *rect2);
+
+/* could_fit_rect determines whether "outer_rect" is big enough to contain
+ * inner_rect.  contains_rect checks whether it actually contains it.
+ */
+gboolean meta_rectangle_could_fit_rect  (const MetaRectangle *outer_rect,
+                                         const MetaRectangle *inner_rect);
+gboolean meta_rectangle_contains_rect   (const MetaRectangle *outer_rect,
+                                         const MetaRectangle *inner_rect);
+
+/* Resize old_rect to the given new_width and new_height, but store the
+ * result in rect.  NOTE THAT THIS IS RESIZE ONLY SO IT CANNOT BE USED FOR
+ * A MOVERESIZE OPERATION (that simplies the routine a little bit as it
+ * means there's no difference between NorthWestGravity and StaticGravity.
+ * Also, I lied a little bit--technically, you could use it in a MoveResize
+ * operation if you muck with old_rect just right).
+ */
+void meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
+                                         MetaRectangle       *rect,
+                                         int                  gravity,
+                                         int                  new_width,
+                                         int                  new_height);
+
+/* find a list of rectangles with the property that a window is contained
+ * in the given region if and only if it is contained in one of the
+ * rectangles in the list.
+ *
+ * In this case, the region is given by taking basic_rect, removing from
+ * it the intersections with all the rectangles in the all_struts list,
+ * then expanding all the rectangles in the resulting list by the given
+ * amounts on each side.
+ *
+ * See boxes.c for more details.
+ */
+GList*   meta_rectangle_get_minimal_spanning_set_for_region (
+                                         const MetaRectangle *basic_rect,
+                                         const GSList        *all_struts);
+
+/* Expand all rectangles in region by the given amount on each side */
+GList*   meta_rectangle_expand_region   (GList               *region,
+                                         const int            left_expand,
+                                         const int            right_expand,
+                                         const int            top_expand,
+                                         const int            bottom_expand);
+/* Same as for meta_rectangle_expand_region except that rectangles not at
+ * least min_x or min_y in size are not expanded in that direction
+ */
+GList*   meta_rectangle_expand_region_conditionally (
+                                         GList                *region,
+                                         const int            left_expand,
+                                         const int            right_expand,
+                                         const int            top_expand,
+                                         const int            bottom_expand,
+                                         const int            min_x,
+                                         const int            min_y);
+
+/* Expand rect in direction to the size of expand_to, and then clip out any
+ * overlapping struts oriented orthognal to the expansion direction.  (Think
+ * horizontal or vertical maximization)
+ */
+void     meta_rectangle_expand_to_avoiding_struts (
+                                         MetaRectangle       *rect,
+                                         const MetaRectangle *expand_to,
+                                         const MetaDirection  direction,
+                                         const GSList        *all_struts);
+
+/* Free the list created by
+ *   meta_rectangle_get_minimal_spanning_set_for_region()
+ * or
+ *   meta_rectangle_find_onscreen_edges ()
+ * or
+ *   meta_rectangle_find_nonintersected_xinerama_edges()
+ */
+void     meta_rectangle_free_list_and_elements (GList *filled_list);
+
+/* could_fit_in_region determines whether one of the spanning_rects is
+ * big enough to contain rect.  contained_in_region checks whether one
+ * actually contains it.
+ */
+gboolean meta_rectangle_could_fit_in_region (
+                                         const GList         *spanning_rects,
+                                         const MetaRectangle *rect);
+gboolean meta_rectangle_contained_in_region (
+                                         const GList         *spanning_rects,
+                                         const MetaRectangle *rect);
+gboolean meta_rectangle_overlaps_with_region (
+                                         const GList         *spanning_rects,
+                                         const MetaRectangle *rect);
+
+/* Make the rectangle small enough to fit into one of the spanning_rects,
+ * but make it no smaller than min_size.
+ */
+void     meta_rectangle_clamp_to_fit_into_region (
+                                         const GList         *spanning_rects,
+                                         FixedDirections      fixed_directions,
+                                         MetaRectangle       *rect,
+                                         const MetaRectangle *min_size);
+
+/* Clip the rectangle so that it fits into one of the spanning_rects, assuming
+ * it overlaps with at least one of them
+ */
+void     meta_rectangle_clip_to_region  (const GList         *spanning_rects,
+                                         FixedDirections      fixed_directions,
+                                         MetaRectangle       *rect);
+
+/* Shove the rectangle into one of the spanning_rects, assuming it fits in
+ * one of them.
+ */
+void     meta_rectangle_shove_into_region(
+                                         const GList         *spanning_rects,
+                                         FixedDirections      fixed_directions,
+                                         MetaRectangle       *rect);
+
+/* Finds the point on the line connecting (x1,y1) to (x2,y2) which is closest
+ * to (px, py).  Useful for finding an optimal rectangle size when given a
+ * range between two sizes that are all candidates.
+ */
+void meta_rectangle_find_linepoint_closest_to_point (double x1,    double y1,
+                                                     double x2,    double y2,
+                                                     double px,    double py,
+                                                     double *valx, double *valy);
+
+/***************************************************************************/
+/*                                                                         */
+/* Switching gears to code for edges instead of just rectangles            */
+/*                                                                         */
+/***************************************************************************/
+
+/* Return whether an edge overlaps or is adjacent to the rectangle in the
+ * nonzero-width dimension of the edge.
+ */
+gboolean meta_rectangle_edge_aligns (const MetaRectangle *rect, 
+                                     const MetaEdge      *edge);
+
+/* Compare two edges, so that sorting functions can put a list of edges in
+ * canonical order.
+ */
+gint   meta_rectangle_edge_cmp (gconstpointer a, gconstpointer b);
+
+/* Compare two edges, so that sorting functions can put a list of edges in
+ * order.  This function doesn't separate left edges first, then right edges,
+ * etc., but rather compares only upon location.
+ */
+gint   meta_rectangle_edge_cmp_ignore_type (gconstpointer a, gconstpointer b);
+
+/* Removes an parts of edges in the given list that intersect any box in the
+ * given rectangle list.  Returns the result.
+ */
+GList* meta_rectangle_remove_intersections_with_boxes_from_edges (
+                                           GList *edges,
+                                           const GSList *rectangles);
+
+/* Finds all the edges of an onscreen region, returning a GList* of
+ * MetaEdgeRect's.
+ */
+GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
+                                           const GSList        *all_struts);
+
+/* Finds edges between adjacent xineramas which are not covered by the given
+ * struts.
+ */
+GList* meta_rectangle_find_nonintersected_xinerama_edges (
+                                           const GList         *xinerama_rects,
+                                           const GSList        *all_struts);
+
+#endif /* META_BOXES_H */
diff --git a/src/include/common.h b/src/include/common.h
new file mode 100644
index 00000000..ccb592f6
--- /dev/null
+++ b/src/include/common.h
@@ -0,0 +1,300 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco common types shared by core.h and ui.h */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_COMMON_H
+#define META_COMMON_H
+
+/* Don't include GTK or core headers here */
+#include <X11/Xlib.h>
+#include <glib.h>
+
+typedef struct _MetaResizePopup MetaResizePopup;
+
+typedef enum
+{
+  META_FRAME_ALLOWS_DELETE            = 1 << 0,
+  META_FRAME_ALLOWS_MENU              = 1 << 1,
+  META_FRAME_ALLOWS_MINIMIZE          = 1 << 2,
+  META_FRAME_ALLOWS_MAXIMIZE          = 1 << 3,
+  META_FRAME_ALLOWS_VERTICAL_RESIZE   = 1 << 4,
+  META_FRAME_ALLOWS_HORIZONTAL_RESIZE = 1 << 5,
+  META_FRAME_HAS_FOCUS                = 1 << 6,
+  META_FRAME_SHADED                   = 1 << 7,
+  META_FRAME_STUCK                    = 1 << 8,
+  META_FRAME_MAXIMIZED                = 1 << 9,
+  META_FRAME_ALLOWS_SHADE             = 1 << 10,
+  META_FRAME_ALLOWS_MOVE              = 1 << 11,
+  META_FRAME_FULLSCREEN               = 1 << 12,
+  META_FRAME_IS_FLASHING              = 1 << 13,
+  META_FRAME_ABOVE                    = 1 << 14
+} MetaFrameFlags;
+
+typedef enum
+{
+  META_MENU_OP_NONE        = 0,
+  META_MENU_OP_DELETE      = 1 << 0,
+  META_MENU_OP_MINIMIZE    = 1 << 1,
+  META_MENU_OP_UNMAXIMIZE  = 1 << 2,
+  META_MENU_OP_MAXIMIZE    = 1 << 3,
+  META_MENU_OP_UNSHADE     = 1 << 4,
+  META_MENU_OP_SHADE       = 1 << 5,
+  META_MENU_OP_UNSTICK     = 1 << 6,
+  META_MENU_OP_STICK       = 1 << 7,
+  META_MENU_OP_WORKSPACES  = 1 << 8,
+  META_MENU_OP_MOVE        = 1 << 9,
+  META_MENU_OP_RESIZE      = 1 << 10,
+  META_MENU_OP_ABOVE       = 1 << 11,
+  META_MENU_OP_UNABOVE     = 1 << 12,
+  META_MENU_OP_MOVE_LEFT   = 1 << 13,
+  META_MENU_OP_MOVE_RIGHT  = 1 << 14,
+  META_MENU_OP_MOVE_UP     = 1 << 15,
+  META_MENU_OP_MOVE_DOWN   = 1 << 16,
+  META_MENU_OP_RECOVER     = 1 << 17
+} MetaMenuOp;
+
+typedef struct _MetaWindowMenu MetaWindowMenu;
+
+typedef void (* MetaWindowMenuFunc) (MetaWindowMenu *menu,
+                                     Display        *xdisplay,
+                                     Window          client_xwindow,
+                                     guint32         timestamp,
+                                     MetaMenuOp      op,
+                                     int             workspace,
+                                     gpointer        data);
+
+/* when changing this enum, there are various switch statements
+ * you have to update
+ */
+typedef enum
+{
+  META_GRAB_OP_NONE,
+
+  /* Mouse ops */
+  META_GRAB_OP_MOVING,
+  META_GRAB_OP_RESIZING_SE,
+  META_GRAB_OP_RESIZING_S,
+  META_GRAB_OP_RESIZING_SW,
+  META_GRAB_OP_RESIZING_N,
+  META_GRAB_OP_RESIZING_NE,
+  META_GRAB_OP_RESIZING_NW,
+  META_GRAB_OP_RESIZING_W,
+  META_GRAB_OP_RESIZING_E,
+
+  /* Keyboard ops */
+  META_GRAB_OP_KEYBOARD_MOVING,
+  META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+  META_GRAB_OP_KEYBOARD_RESIZING_S,
+  META_GRAB_OP_KEYBOARD_RESIZING_N,
+  META_GRAB_OP_KEYBOARD_RESIZING_W,
+  META_GRAB_OP_KEYBOARD_RESIZING_E,
+  META_GRAB_OP_KEYBOARD_RESIZING_SE,
+  META_GRAB_OP_KEYBOARD_RESIZING_NE,
+  META_GRAB_OP_KEYBOARD_RESIZING_SW,
+  META_GRAB_OP_KEYBOARD_RESIZING_NW,
+
+  /* Alt+Tab */
+  META_GRAB_OP_KEYBOARD_TABBING_NORMAL,
+  META_GRAB_OP_KEYBOARD_TABBING_DOCK,
+
+  /* Alt+Esc */
+  META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL,
+  META_GRAB_OP_KEYBOARD_ESCAPING_DOCK,
+
+  META_GRAB_OP_KEYBOARD_ESCAPING_GROUP,
+  
+  /* Alt+F6 */
+  META_GRAB_OP_KEYBOARD_TABBING_GROUP,
+  
+  META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING,
+  
+  /* Frame button ops */
+  META_GRAB_OP_CLICKING_MINIMIZE,
+  META_GRAB_OP_CLICKING_MAXIMIZE,
+  META_GRAB_OP_CLICKING_UNMAXIMIZE,
+  META_GRAB_OP_CLICKING_DELETE,
+  META_GRAB_OP_CLICKING_MENU,
+  META_GRAB_OP_CLICKING_SHADE,
+  META_GRAB_OP_CLICKING_UNSHADE,
+  META_GRAB_OP_CLICKING_ABOVE,
+  META_GRAB_OP_CLICKING_UNABOVE,
+  META_GRAB_OP_CLICKING_STICK,
+  META_GRAB_OP_CLICKING_UNSTICK
+} MetaGrabOp;
+
+typedef enum
+{
+  META_CURSOR_DEFAULT,
+  META_CURSOR_NORTH_RESIZE,
+  META_CURSOR_SOUTH_RESIZE,
+  META_CURSOR_WEST_RESIZE,
+  META_CURSOR_EAST_RESIZE,
+  META_CURSOR_SE_RESIZE,
+  META_CURSOR_SW_RESIZE,
+  META_CURSOR_NE_RESIZE,
+  META_CURSOR_NW_RESIZE,
+  META_CURSOR_MOVE_OR_RESIZE_WINDOW,
+  META_CURSOR_BUSY
+
+} MetaCursor;
+
+typedef enum
+{
+  META_FOCUS_MODE_CLICK,
+  META_FOCUS_MODE_SLOPPY,
+  META_FOCUS_MODE_MOUSE
+} MetaFocusMode;
+
+typedef enum
+{
+  META_FOCUS_NEW_WINDOWS_SMART,
+  META_FOCUS_NEW_WINDOWS_STRICT
+} MetaFocusNewWindows;
+
+typedef enum
+{
+  META_ACTION_TITLEBAR_TOGGLE_SHADE,
+  META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE,
+  META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_HORIZONTALLY,
+  META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_VERTICALLY,
+  META_ACTION_TITLEBAR_MINIMIZE,
+  META_ACTION_TITLEBAR_NONE,
+  META_ACTION_TITLEBAR_LOWER,
+  META_ACTION_TITLEBAR_MENU,
+  META_ACTION_TITLEBAR_LAST
+} MetaActionTitlebar;
+
+typedef enum
+{
+  META_FRAME_TYPE_NORMAL,
+  META_FRAME_TYPE_DIALOG,
+  META_FRAME_TYPE_MODAL_DIALOG,
+  META_FRAME_TYPE_UTILITY,
+  META_FRAME_TYPE_MENU,
+  META_FRAME_TYPE_BORDER,
+  META_FRAME_TYPE_LAST
+} MetaFrameType;
+
+typedef enum
+{
+  /* Create gratuitous divergence from regular
+   * X mod bits, to be sure we find bugs
+   */
+  META_VIRTUAL_SHIFT_MASK    = 1 << 5,
+  META_VIRTUAL_CONTROL_MASK  = 1 << 6,
+  META_VIRTUAL_ALT_MASK      = 1 << 7,  
+  META_VIRTUAL_META_MASK     = 1 << 8,
+  META_VIRTUAL_SUPER_MASK    = 1 << 9,
+  META_VIRTUAL_HYPER_MASK    = 1 << 10,
+  META_VIRTUAL_MOD2_MASK     = 1 << 11,
+  META_VIRTUAL_MOD3_MASK     = 1 << 12,
+  META_VIRTUAL_MOD4_MASK     = 1 << 13,
+  META_VIRTUAL_MOD5_MASK     = 1 << 14
+} MetaVirtualModifier;
+
+/* Relative directions or sides seem to come up all over the place... */
+/* FIXME: Replace
+ *   screen.[ch]:MetaScreenDirection,
+ *   workspace.[ch]:MetaMotionDirection,
+ * with the use of MetaDirection.
+ */
+typedef enum
+{
+  META_DIRECTION_LEFT       = 1 << 0,
+  META_DIRECTION_RIGHT      = 1 << 1,
+  META_DIRECTION_TOP        = 1 << 2,
+  META_DIRECTION_BOTTOM     = 1 << 3,
+
+  /* Some aliases for making code more readable for various circumstances. */
+  META_DIRECTION_UP         = META_DIRECTION_TOP,
+  META_DIRECTION_DOWN       = META_DIRECTION_BOTTOM,
+
+  /* A few more definitions using aliases */
+  META_DIRECTION_HORIZONTAL = META_DIRECTION_LEFT | META_DIRECTION_RIGHT,
+  META_DIRECTION_VERTICAL   = META_DIRECTION_UP   | META_DIRECTION_DOWN,
+} MetaDirection;
+
+/* Sometimes we want to talk about sides instead of directions; note
+ * that the values must be as follows or meta_window_update_struts()
+ * won't work. Using these values also is a safety blanket since
+ * MetaDirection used to be used as a side.
+ */
+typedef enum
+{
+  META_SIDE_LEFT            = META_DIRECTION_LEFT,
+  META_SIDE_RIGHT           = META_DIRECTION_RIGHT,
+  META_SIDE_TOP             = META_DIRECTION_TOP,
+  META_SIDE_BOTTOM          = META_DIRECTION_BOTTOM
+} MetaSide;
+
+/* Function a window button can have.  Note, you can't add stuff here
+ * without extending the theme format to draw a new function and
+ * breaking all existing themes.
+ */
+typedef enum
+{
+  META_BUTTON_FUNCTION_MENU,
+  META_BUTTON_FUNCTION_MINIMIZE,
+  META_BUTTON_FUNCTION_MAXIMIZE,
+  META_BUTTON_FUNCTION_CLOSE,
+  META_BUTTON_FUNCTION_SHADE,
+  META_BUTTON_FUNCTION_ABOVE,
+  META_BUTTON_FUNCTION_STICK,
+  META_BUTTON_FUNCTION_UNSHADE,
+  META_BUTTON_FUNCTION_UNABOVE,
+  META_BUTTON_FUNCTION_UNSTICK,
+  META_BUTTON_FUNCTION_LAST
+} MetaButtonFunction;
+
+#define MAX_BUTTONS_PER_CORNER META_BUTTON_FUNCTION_LAST
+
+typedef struct _MetaButtonLayout MetaButtonLayout;
+struct _MetaButtonLayout
+{
+  /* buttons in the group on the left side */
+  MetaButtonFunction left_buttons[MAX_BUTTONS_PER_CORNER];
+  gboolean left_buttons_has_spacer[MAX_BUTTONS_PER_CORNER];
+
+  /* buttons in the group on the right side */
+  MetaButtonFunction right_buttons[MAX_BUTTONS_PER_CORNER];
+  gboolean right_buttons_has_spacer[MAX_BUTTONS_PER_CORNER];
+};
+
+/* should investigate changing these to whatever most apps use */
+#define META_ICON_WIDTH 32
+#define META_ICON_HEIGHT 32
+#define META_MINI_ICON_WIDTH 16
+#define META_MINI_ICON_HEIGHT 16
+
+#define META_DEFAULT_ICON_NAME "window"
+
+#define META_PRIORITY_PREFS_NOTIFY   (G_PRIORITY_DEFAULT_IDLE + 10)
+#define META_PRIORITY_WORK_AREA_HINT (G_PRIORITY_DEFAULT_IDLE + 15)
+
+#define POINT_IN_RECT(xcoord, ycoord, rect) \
+ ((xcoord) >= (rect).x &&                   \
+  (xcoord) <  ((rect).x + (rect).width) &&  \
+  (ycoord) >= (rect).y &&                   \
+  (ycoord) <  ((rect).y + (rect).height))
+
+#endif
diff --git a/src/include/compositor.h b/src/include/compositor.h
new file mode 100644
index 00000000..a7f9bf1f
--- /dev/null
+++ b/src/include/compositor.h
@@ -0,0 +1,76 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_COMPOSITOR_H
+#define META_COMPOSITOR_H
+
+#include <glib.h>
+#include <X11/Xlib.h>
+
+#include "types.h"
+#include "boxes.h"
+
+MetaCompositor *meta_compositor_new (MetaDisplay *display);
+void meta_compositor_destroy (MetaCompositor *compositor);
+
+void meta_compositor_manage_screen (MetaCompositor *compositor,
+                                    MetaScreen     *screen);
+void meta_compositor_unmanage_screen (MetaCompositor *compositor,
+                                      MetaScreen     *screen);
+
+void meta_compositor_add_window (MetaCompositor    *compositor,
+                                 MetaWindow        *window,
+                                 Window             xwindow,
+                                 XWindowAttributes *attrs);
+void meta_compositor_remove_window (MetaCompositor *compositor,
+                                    Window          xwindow);
+
+void meta_compositor_set_updates (MetaCompositor *compositor,
+                                  MetaWindow     *window,
+                                  gboolean        updates);
+
+void meta_compositor_process_event (MetaCompositor *compositor,
+                                    XEvent         *event,
+                                    MetaWindow     *window);
+Pixmap meta_compositor_get_window_pixmap (MetaCompositor *compositor,
+                                          MetaWindow     *window);
+void meta_compositor_set_active_window (MetaCompositor *compositor,
+                                        MetaScreen     *screen,
+                                        MetaWindow     *window);
+
+void meta_compositor_begin_move (MetaCompositor *compositor,
+                                 MetaWindow *window,
+                                 MetaRectangle *initial,
+                                 int grab_x, int grab_y);
+void meta_compositor_update_move (MetaCompositor *compositor,
+                                  MetaWindow *window,
+                                  int x, int y);
+void meta_compositor_end_move (MetaCompositor *compositor,
+                               MetaWindow *window);
+void meta_compositor_free_window (MetaCompositor *compositor,
+                                  MetaWindow *window);
+
+#endif
+
+
+
+
+
diff --git a/src/include/core.h b/src/include/core.h
new file mode 100644
index 00000000..ded94c4e
--- /dev/null
+++ b/src/include/core.h
@@ -0,0 +1,208 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco interface used by GTK+ UI to talk to core */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_CORE_H
+#define META_CORE_H
+
+/* Don't include core headers here */
+#include <gdk/gdkx.h>
+#include "common.h"
+
+typedef enum
+{
+  META_CORE_GET_END = 0,
+  META_CORE_WINDOW_HAS_FRAME,
+  META_CORE_GET_CLIENT_WIDTH,
+  META_CORE_GET_CLIENT_HEIGHT,
+  META_CORE_IS_TITLEBAR_ONSCREEN,
+  META_CORE_GET_CLIENT_XWINDOW,
+  META_CORE_GET_FRAME_FLAGS,
+  META_CORE_GET_FRAME_TYPE,
+  META_CORE_GET_MINI_ICON,
+  META_CORE_GET_ICON,
+  META_CORE_GET_X,
+  META_CORE_GET_Y,
+  META_CORE_GET_FRAME_WORKSPACE,
+  META_CORE_GET_FRAME_X,
+  META_CORE_GET_FRAME_Y,
+  META_CORE_GET_FRAME_WIDTH,
+  META_CORE_GET_FRAME_HEIGHT,
+  META_CORE_GET_SCREEN_WIDTH,
+  META_CORE_GET_SCREEN_HEIGHT,
+} MetaCoreGetType;
+
+/* General information function about the given window. Pass in a sequence of
+ * pairs of MetaCoreGetTypes and pointers to variables; the variables will be
+ * filled with the requested values. End the list with META_CORE_GET_END.
+ * For example:
+ *
+ *   meta_core_get (my_display, my_window,
+ *                  META_CORE_GET_X, &x,
+ *                  META_CORE_GET_Y, &y,
+ *                  META_CORE_GET_END);
+ *
+ * If the window doesn't have a frame, this will raise a meta_bug. To suppress
+ * this behaviour, ask META_CORE_WINDOW_HAS_FRAME as the *first* question in
+ * the list. If the window has no frame, the answer to this question will be
+ * False, and anything else you asked will be undefined. Otherwise, the answer
+ * will be True. The answer will necessarily be True if you ask the question
+ * in any other position. The positions of all other questions don't matter.
+ *
+ * The reason for this function is that some parts of the program don't know
+ * about MetaWindows. But they *can* see core.h. So we used to have a whole
+ * load of functions which took a display and an X window, looked up the
+ * relevant MetaWindow, and returned information about it. The trouble with
+ * that is that looking up the MetaWindow is a nontrivial operation, and
+ * consolidating the calls in this way makes (for example) frame exposes
+ * 33% faster, according to valgrind.
+ *
+ * This function would perhaps be slightly better if the questions were
+ * represented by pointers, perhaps gchar*s, because then we could take
+ * advantage of gcc's automatic sentinel checking. On the other hand, this
+ * immediately suggests string comparison, and that's slow.
+ *
+ * Another possible improvement is that core.h still has a bunch of
+ * functions which can't be described by the formula "give a display and
+ * an X window, get a single value" (meta_core_user_move, for example), but
+ * which could theoretically be handled by this function if we relaxed the
+ * requirement that all questions should have exactly one argument.
+ */
+void meta_core_get (Display *xdisplay,
+                    Window window,
+                    ...);
+
+void meta_core_queue_frame_resize (Display *xdisplay,
+                                   Window frame_xwindow);
+
+/* Move as a result of user operation */
+void meta_core_user_move    (Display *xdisplay,
+                             Window   frame_xwindow,
+                             int      x,
+                             int      y);
+void meta_core_user_resize  (Display *xdisplay,
+                             Window   frame_xwindow,
+                             int      gravity,
+                             int      width,
+                             int      height);
+
+void meta_core_user_raise   (Display *xdisplay,
+                             Window   frame_xwindow);
+void meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                       Window   frame_xwindow,
+                                       guint32  timestamp);
+
+void meta_core_user_focus   (Display *xdisplay,
+                             Window   frame_xwindow,
+                             guint32  timestamp);
+
+void meta_core_minimize         (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_toggle_maximize  (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_toggle_maximize_horizontally  (Display *xdisplay,
+                                              Window   frame_xwindow);
+void meta_core_toggle_maximize_vertically    (Display *xdisplay,
+                                              Window   frame_xwindow);
+void meta_core_unmaximize       (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_maximize         (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_delete           (Display *xdisplay,
+                                 Window   frame_xwindow,
+                                 guint32  timestamp);
+void meta_core_unshade          (Display *xdisplay,
+                                 Window   frame_xwindow,
+                                 guint32  timestamp);
+void meta_core_shade            (Display *xdisplay,
+                                 Window   frame_xwindow,
+                                 guint32  timestamp);
+void meta_core_unstick          (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_stick            (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_unmake_above     (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_make_above       (Display *xdisplay,
+                                 Window   frame_xwindow);
+void meta_core_change_workspace (Display *xdisplay,
+                                 Window   frame_xwindow,
+                                 int      new_workspace);
+
+int meta_core_get_num_workspaces (Screen  *xscreen);
+int meta_core_get_active_workspace (Screen *xscreen);
+int meta_core_get_frame_workspace (Display *xdisplay,
+                                   Window frame_xwindow);
+const char* meta_core_get_workspace_name_with_index (Display *xdisplay,
+                                                     Window xroot,
+                                                     int    index);
+
+void meta_core_show_window_menu (Display *xdisplay,
+                                 Window   frame_xwindow,
+                                 int      root_x,
+                                 int      root_y,
+                                 int      button,
+                                 guint32  timestamp);
+
+void meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
+                                     int                  workspace,
+                                     unsigned int        *keysym,
+                                     MetaVirtualModifier *modifiers);
+
+gboolean   meta_core_begin_grab_op (Display    *xdisplay,
+                                    Window      frame_xwindow,
+                                    MetaGrabOp  op,
+                                    gboolean    pointer_already_grabbed,
+                                    gboolean    frame_action,
+                                    int         button,
+                                    gulong      modmask,
+                                    guint32     timestamp,
+                                    int         root_x,
+                                    int         root_y);
+void       meta_core_end_grab_op   (Display    *xdisplay,
+                                    guint32     timestamp);
+MetaGrabOp meta_core_get_grab_op     (Display    *xdisplay);
+Window     meta_core_get_grab_frame  (Display   *xdisplay);
+int        meta_core_get_grab_button (Display  *xdisplay);
+
+
+void       meta_core_grab_buttons  (Display *xdisplay,
+                                    Window   frame_xwindow);
+
+void       meta_core_set_screen_cursor (Display *xdisplay,
+                                        Window   frame_on_screen,
+                                        MetaCursor cursor);
+
+/* Used because we ignore EnterNotify when a window is unmapped that
+ * really shouldn't cause focus changes, by comparing the event serial
+ * of the EnterNotify and the UnmapNotify.
+ */
+void meta_core_increment_event_serial (Display *display);
+
+void meta_invalidate_default_icons (void);
+
+#endif
+
+
+
+
diff --git a/src/include/display.h b/src/include/display.h
new file mode 100644
index 00000000..53dd9d75
--- /dev/null
+++ b/src/include/display.h
@@ -0,0 +1,48 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_DISPLAY_H
+#define META_DISPLAY_H
+
+#include <glib.h>
+#include <X11/Xlib.h>
+
+#include "types.h"
+
+#define meta_XFree(p) do { if ((p)) XFree ((p)); } while (0)
+
+void meta_display_get_compositor_version (MetaDisplay *display,
+                                          int         *major,
+                                          int         *minor);
+Display *meta_display_get_xdisplay (MetaDisplay *display);
+MetaCompositor *meta_display_get_compositor (MetaDisplay *display);
+GSList *meta_display_get_screens (MetaDisplay *display);
+
+gboolean meta_display_has_shape (MetaDisplay *display);
+
+MetaScreen *meta_display_screen_for_root (MetaDisplay *display,
+                                          Window       xroot);
+MetaWindow *meta_display_get_focus_window (MetaDisplay *display);
+
+int meta_display_get_damage_event_base (MetaDisplay *display);
+int meta_display_get_shape_event_base (MetaDisplay *display);
+
+#endif
diff --git a/src/include/errors.h b/src/include/errors.h
new file mode 100644
index 00000000..d3fa5a96
--- /dev/null
+++ b/src/include/errors.h
@@ -0,0 +1,51 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X error handling */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_ERRORS_H
+#define META_ERRORS_H
+
+#include <X11/Xlib.h>
+
+#include "util.h"
+#include "display.h"
+
+typedef void (* ErrorHandler) (Display *dpy,
+                               XErrorEvent *error,
+                               gpointer data);
+
+void      meta_errors_init     (void);
+void	  meta_errors_register_foreign_display (Display      *foreign_dpy,
+						ErrorHandler  handler,
+						gpointer      data);
+						
+void      meta_error_trap_push (MetaDisplay *display);
+void      meta_error_trap_pop  (MetaDisplay *display,
+                                gboolean     last_request_was_roundtrip);
+
+void      meta_error_trap_push_with_return (MetaDisplay *display);
+/* returns X error code, or 0 for no error */
+int       meta_error_trap_pop_with_return  (MetaDisplay *display,
+                                            gboolean     last_request_was_roundtrip);
+
+
+#endif
diff --git a/src/include/frame.h b/src/include/frame.h
new file mode 100644
index 00000000..eeb57263
--- /dev/null
+++ b/src/include/frame.h
@@ -0,0 +1,31 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_FRAME_H
+#define META_FRAME_H
+
+#include <X11/Xlib.h>
+
+#include "types.h"
+
+Window meta_frame_get_xwindow (MetaFrame *frame);
+
+#endif
diff --git a/src/include/main.h b/src/include/main.h
new file mode 100644
index 00000000..d5789696
--- /dev/null
+++ b/src/include/main.h
@@ -0,0 +1,43 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco main */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_MAIN_H
+#define META_MAIN_H
+
+#include <glib.h>
+
+typedef enum
+{
+  META_EXIT_SUCCESS,
+  META_EXIT_ERROR
+} MetaExitCode;
+
+/* exit immediately */
+void meta_exit (MetaExitCode code);
+
+/* g_main_loop_quit() then fall out of main() */
+void meta_quit (MetaExitCode code);
+
+void meta_restart (void);
+
+#endif
diff --git a/src/include/prefs.h b/src/include/prefs.h
new file mode 100644
index 00000000..39597f9f
--- /dev/null
+++ b/src/include/prefs.h
@@ -0,0 +1,233 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco preferences */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_PREFS_H
+#define META_PREFS_H
+
+/* This header is a "common" one between the UI and core side */
+#include "common.h"
+#include <pango/pango-font.h>
+
+typedef enum
+{
+  META_PREF_MOUSE_BUTTON_MODS,
+  META_PREF_FOCUS_MODE,
+  META_PREF_FOCUS_NEW_WINDOWS,
+  META_PREF_RAISE_ON_CLICK,
+  META_PREF_ACTION_DOUBLE_CLICK_TITLEBAR,
+  META_PREF_ACTION_MIDDLE_CLICK_TITLEBAR,
+  META_PREF_ACTION_RIGHT_CLICK_TITLEBAR,
+  META_PREF_AUTO_RAISE,
+  META_PREF_AUTO_RAISE_DELAY,
+  META_PREF_THEME,
+  META_PREF_TITLEBAR_FONT,
+  META_PREF_NUM_WORKSPACES,
+  META_PREF_APPLICATION_BASED,
+  META_PREF_KEYBINDINGS,
+  META_PREF_DISABLE_WORKAROUNDS,
+  META_PREF_COMMANDS,
+  META_PREF_TERMINAL_COMMAND,
+  META_PREF_BUTTON_LAYOUT,
+  META_PREF_WORKSPACE_NAMES,
+  META_PREF_VISUAL_BELL,
+  META_PREF_AUDIBLE_BELL,
+  META_PREF_VISUAL_BELL_TYPE,
+  META_PREF_REDUCED_RESOURCES,
+  META_PREF_MATE_ACCESSIBILITY,
+  META_PREF_MATE_ANIMATIONS,
+  META_PREF_CURSOR_THEME,
+  META_PREF_CURSOR_SIZE,
+  META_PREF_COMPOSITING_MANAGER,
+  META_PREF_RESIZE_WITH_RIGHT_BUTTON,
+  META_PREF_FORCE_FULLSCREEN
+} MetaPreference;
+
+typedef void (* MetaPrefsChangedFunc) (MetaPreference pref,
+                                       gpointer       data);
+
+void meta_prefs_add_listener    (MetaPrefsChangedFunc func,
+                                 gpointer             data);
+void meta_prefs_remove_listener (MetaPrefsChangedFunc func,
+                                 gpointer             data);
+
+void meta_prefs_init (void);
+const char* meta_preference_to_string (MetaPreference pref);
+
+MetaVirtualModifier         meta_prefs_get_mouse_button_mods  (void);
+guint                       meta_prefs_get_mouse_button_resize (void);
+guint                       meta_prefs_get_mouse_button_menu  (void);
+MetaFocusMode               meta_prefs_get_focus_mode         (void);
+MetaFocusNewWindows         meta_prefs_get_focus_new_windows  (void);
+gboolean                    meta_prefs_get_raise_on_click     (void);
+const char*                 meta_prefs_get_theme              (void);
+/* returns NULL if GTK default should be used */
+const PangoFontDescription* meta_prefs_get_titlebar_font      (void);
+int                         meta_prefs_get_num_workspaces     (void);
+gboolean                    meta_prefs_get_application_based  (void);
+gboolean                    meta_prefs_get_disable_workarounds (void);
+gboolean                    meta_prefs_get_auto_raise         (void);
+int                         meta_prefs_get_auto_raise_delay   (void);
+gboolean                    meta_prefs_get_reduced_resources  (void);
+gboolean                    meta_prefs_get_mate_accessibility (void);
+gboolean                    meta_prefs_get_mate_animations   (void);
+
+const char*                 meta_prefs_get_command            (int i);
+
+char*                       meta_prefs_get_mateconf_key_for_command (int i);
+
+const char*                 meta_prefs_get_terminal_command   (void);
+const char*                 meta_prefs_get_mateconf_key_for_terminal_command (void);
+
+void                        meta_prefs_get_button_layout (MetaButtonLayout *button_layout);
+
+/* Double, right, middle click can be configured to any titlebar meta-action */
+MetaActionTitlebar          meta_prefs_get_action_double_click_titlebar (void);
+MetaActionTitlebar          meta_prefs_get_action_middle_click_titlebar (void);
+MetaActionTitlebar          meta_prefs_get_action_right_click_titlebar (void);
+
+void meta_prefs_set_num_workspaces (int n_workspaces);
+
+const char* meta_prefs_get_workspace_name    (int         i);
+void        meta_prefs_change_workspace_name (int         i,
+                                              const char *name);
+
+const char* meta_prefs_get_cursor_theme      (void);
+int         meta_prefs_get_cursor_size       (void);
+gboolean    meta_prefs_get_compositing_manager (void);
+gboolean    meta_prefs_get_force_fullscreen  (void);
+
+/**
+ * Sets whether the compositor is turned on.
+ *
+ * \param whether   TRUE to turn on, FALSE to turn off
+ */
+void meta_prefs_set_compositing_manager (gboolean whether);
+
+void meta_prefs_set_force_fullscreen (gboolean whether);
+
+/* XXX FIXME This should be x-macroed, but isn't yet because it would be
+ * difficult (or perhaps impossible) to add the suffixes using the current
+ * system.  It needs some more thought, perhaps after the current system
+ * evolves a little.
+ */
+typedef enum _MetaKeyBindingAction
+{
+  META_KEYBINDING_ACTION_NONE = -1,
+  META_KEYBINDING_ACTION_WORKSPACE_1,
+  META_KEYBINDING_ACTION_WORKSPACE_2,
+  META_KEYBINDING_ACTION_WORKSPACE_3,
+  META_KEYBINDING_ACTION_WORKSPACE_4,
+  META_KEYBINDING_ACTION_WORKSPACE_5,
+  META_KEYBINDING_ACTION_WORKSPACE_6,
+  META_KEYBINDING_ACTION_WORKSPACE_7,
+  META_KEYBINDING_ACTION_WORKSPACE_8,
+  META_KEYBINDING_ACTION_WORKSPACE_9,
+  META_KEYBINDING_ACTION_WORKSPACE_10,
+  META_KEYBINDING_ACTION_WORKSPACE_11,
+  META_KEYBINDING_ACTION_WORKSPACE_12,
+  META_KEYBINDING_ACTION_WORKSPACE_LEFT,
+  META_KEYBINDING_ACTION_WORKSPACE_RIGHT,
+  META_KEYBINDING_ACTION_WORKSPACE_UP,
+  META_KEYBINDING_ACTION_WORKSPACE_DOWN,
+  META_KEYBINDING_ACTION_SWITCH_GROUP,
+  META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD,
+  META_KEYBINDING_ACTION_SWITCH_WINDOWS,
+  META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD,
+  META_KEYBINDING_ACTION_SWITCH_PANELS,
+  META_KEYBINDING_ACTION_SWITCH_PANELS_BACKWARD,
+  META_KEYBINDING_ACTION_CYCLE_GROUP,
+  META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD,
+  META_KEYBINDING_ACTION_CYCLE_WINDOWS,
+  META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD,
+  META_KEYBINDING_ACTION_CYCLE_PANELS,
+  META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD,
+  META_KEYBINDING_ACTION_SHOW_DESKTOP,
+  META_KEYBINDING_ACTION_PANEL_MAIN_MENU,
+  META_KEYBINDING_ACTION_PANEL_RUN_DIALOG,
+  META_KEYBINDING_ACTION_COMMAND_1,
+  META_KEYBINDING_ACTION_COMMAND_2,
+  META_KEYBINDING_ACTION_COMMAND_3,
+  META_KEYBINDING_ACTION_COMMAND_4,
+  META_KEYBINDING_ACTION_COMMAND_5,
+  META_KEYBINDING_ACTION_COMMAND_6,
+  META_KEYBINDING_ACTION_COMMAND_7,
+  META_KEYBINDING_ACTION_COMMAND_8,
+  META_KEYBINDING_ACTION_COMMAND_9,
+  META_KEYBINDING_ACTION_COMMAND_10,
+  META_KEYBINDING_ACTION_COMMAND_11,
+  META_KEYBINDING_ACTION_COMMAND_12
+} MetaKeyBindingAction;
+
+typedef struct
+{
+  unsigned int keysym;
+  unsigned int keycode;
+  MetaVirtualModifier modifiers;
+} MetaKeyCombo;
+
+typedef struct
+{
+  const char   *name;
+  /**
+   * A list of MetaKeyCombos. Each of them is bound to
+   * this keypref. If one has keysym==modifiers==0, it is
+   * ignored. For historical reasons, the first entry is
+   * governed by the pref FOO and the remainder are
+   * governed by the pref FOO_list.
+   */
+  GSList *bindings;
+
+  /** for keybindings that can have shift or not like Alt+Tab */
+  gboolean      add_shift:1;
+
+  /** for keybindings that apply only to a window */
+  gboolean      per_window:1;
+} MetaKeyPref;
+
+void meta_prefs_get_key_bindings (const MetaKeyPref **bindings,
+                                  int                *n_bindings);
+
+MetaKeyBindingAction meta_prefs_get_keybinding_action (const char *name);
+
+void meta_prefs_get_window_binding (const char          *name,
+                                    unsigned int        *keysym,
+                                    MetaVirtualModifier *modifiers);
+
+typedef enum
+{
+  META_VISUAL_BELL_INVALID = 0,
+  META_VISUAL_BELL_FULLSCREEN_FLASH,
+  META_VISUAL_BELL_FRAME_FLASH
+
+} MetaVisualBellType;
+
+gboolean           meta_prefs_get_visual_bell      (void);
+gboolean           meta_prefs_bell_is_audible      (void);
+MetaVisualBellType meta_prefs_get_visual_bell_type (void);
+
+#endif
+
+
+
+
diff --git a/src/include/resizepopup.h b/src/include/resizepopup.h
new file mode 100644
index 00000000..4e03d5d3
--- /dev/null
+++ b/src/include/resizepopup.h
@@ -0,0 +1,47 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco resizing-terminal-window feedback */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_RESIZEPOPUP_H
+#define META_RESIZEPOPUP_H
+
+/* Don't include gtk.h or gdk.h here */
+#include "boxes.h"
+#include "common.h"
+#include <X11/Xlib.h>
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+MetaResizePopup* meta_ui_resize_popup_new          (Display *display,
+                                                    int      screen_number);
+void             meta_ui_resize_popup_free         (MetaResizePopup *popup);
+void             meta_ui_resize_popup_set (MetaResizePopup *popup,
+                                           MetaRectangle    rect,
+                                           int              base_width,
+                                           int              base_height,
+                                           int              width_inc,
+                                           int              height_inc);
+void             meta_ui_resize_popup_set_showing  (MetaResizePopup *popup,
+                                                    gboolean         showing);
+
+#endif
+
diff --git a/src/include/screen.h b/src/include/screen.h
new file mode 100644
index 00000000..9f842317
--- /dev/null
+++ b/src/include/screen.h
@@ -0,0 +1,48 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_SCREEN_H
+#define META_SCREEN_H
+
+#include <X11/Xlib.h>
+#include <glib.h>
+#include "types.h"
+
+int meta_screen_get_screen_number (MetaScreen *screen);
+MetaDisplay *meta_screen_get_display (MetaScreen *screen);
+
+Window meta_screen_get_xroot (MetaScreen *screen);
+void meta_screen_get_size (MetaScreen *screen,
+                           int        *width,
+                           int        *height);
+
+gpointer meta_screen_get_compositor_data (MetaScreen *screen);
+void meta_screen_set_compositor_data (MetaScreen *screen,
+                                      gpointer    info);
+
+MetaScreen *meta_screen_for_x_screen (Screen *xscreen);
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+void meta_screen_set_cm_selection (MetaScreen *screen);
+void meta_screen_unset_cm_selection (MetaScreen *screen);
+#endif
+
+#endif
diff --git a/src/include/tabpopup.h b/src/include/tabpopup.h
new file mode 100644
index 00000000..2bee506e
--- /dev/null
+++ b/src/include/tabpopup.h
@@ -0,0 +1,67 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco tab popup window */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_TABPOPUP_H
+#define META_TABPOPUP_H
+
+/* Don't include gtk.h or gdk.h here */
+#include "common.h"
+#include "boxes.h"
+#include <X11/Xlib.h>
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+typedef struct _MetaTabEntry MetaTabEntry;
+typedef struct _MetaTabPopup MetaTabPopup;
+typedef void *MetaTabEntryKey;
+
+struct _MetaTabEntry
+{
+  MetaTabEntryKey  key;  
+  const char      *title;
+  GdkPixbuf       *icon;
+  MetaRectangle    rect;
+  MetaRectangle    inner_rect;
+  guint            blank : 1;
+  guint            hidden : 1;
+  guint            demands_attention : 1;
+};
+
+MetaTabPopup*   meta_ui_tab_popup_new          (const MetaTabEntry *entries,
+                                                int                 screen_number,
+                                                int                 entry_count,
+                                                int                 width,
+                                                gboolean            outline);
+void            meta_ui_tab_popup_free         (MetaTabPopup       *popup);
+void            meta_ui_tab_popup_set_showing  (MetaTabPopup       *popup,
+                                                gboolean            showing);
+void            meta_ui_tab_popup_forward      (MetaTabPopup       *popup);
+void            meta_ui_tab_popup_backward     (MetaTabPopup       *popup);
+MetaTabEntryKey meta_ui_tab_popup_get_selected (MetaTabPopup      *popup);
+void            meta_ui_tab_popup_select       (MetaTabPopup       *popup,
+                                                MetaTabEntryKey     key);
+
+
+#endif
+
diff --git a/src/include/types.h b/src/include/types.h
new file mode 100644
index 00000000..045b102f
--- /dev/null
+++ b/src/include/types.h
@@ -0,0 +1,31 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_TYPES_H
+#define META_TYPES_H
+
+typedef struct _MetaCompositor  MetaCompositor;
+typedef struct _MetaDisplay     MetaDisplay;
+typedef struct _MetaFrame       MetaFrame;
+typedef struct _MetaScreen      MetaScreen;
+typedef struct _MetaWindow      MetaWindow;
+
+#endif
diff --git a/src/include/ui.h b/src/include/ui.h
new file mode 100644
index 00000000..1fce402c
--- /dev/null
+++ b/src/include/ui.h
@@ -0,0 +1,209 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco interface for talking to GTK+ UI module */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_UI_H
+#define META_UI_H
+
+/* Don't include gtk.h or gdk.h here */
+#include "common.h"
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+/* This is between GTK_PRIORITY_RESIZE (+10) and GDK_PRIORITY_REDRAW (+20) */
+#define META_PRIORITY_RESIZE    (G_PRIORITY_HIGH_IDLE + 15)
+
+typedef struct _MetaUI MetaUI;
+
+typedef struct _MetaImageWindow MetaImageWindow;
+
+typedef gboolean (* MetaEventFunc) (XEvent *xevent, gpointer data);
+
+typedef enum
+{
+  META_UI_DIRECTION_LTR,
+  META_UI_DIRECTION_RTL
+} MetaUIDirection;
+
+void meta_ui_init (int *argc, char ***argv);
+
+Display* meta_ui_get_display (void);
+
+void meta_ui_add_event_func    (Display       *xdisplay,
+                                MetaEventFunc  func,
+                                gpointer       data);
+void meta_ui_remove_event_func (Display       *xdisplay,
+                                MetaEventFunc  func,
+                                gpointer       data);
+
+MetaUI* meta_ui_new (Display *xdisplay,
+                     Screen  *screen);
+void    meta_ui_free (MetaUI *ui);
+
+void meta_ui_theme_get_frame_borders (MetaUI *ui,
+                                      MetaFrameType      type,
+                                      MetaFrameFlags     flags,
+                                      int               *top_height,
+                                      int               *bottom_height,
+                                      int               *left_width,
+                                      int               *right_width);
+void meta_ui_get_frame_geometry (MetaUI *ui,
+                                 Window frame_xwindow,
+                                 int *top_height, int *bottom_height,
+                                 int *left_width, int *right_width);
+Window meta_ui_create_frame_window (MetaUI *ui,
+                                    Display *xdisplay,
+                                    Visual *xvisual,
+				    gint x,
+				    gint y,
+				    gint width,
+				    gint height,
+				    gint screen_no);
+void meta_ui_destroy_frame_window (MetaUI *ui,
+				   Window  xwindow);
+void meta_ui_move_resize_frame (MetaUI *ui,
+				Window frame,
+				int x,
+				int y,
+				int width,
+				int height);
+
+/* GDK insists on tracking map/unmap */
+void meta_ui_map_frame   (MetaUI *ui,
+                          Window  xwindow);
+void meta_ui_unmap_frame (MetaUI *ui,
+                          Window  xwindow);
+
+void meta_ui_unflicker_frame_bg (MetaUI *ui,
+                                 Window  xwindow,
+                                 int     target_width,
+                                 int     target_height);
+void meta_ui_reset_frame_bg     (MetaUI *ui,
+                                 Window  xwindow);
+
+void meta_ui_apply_frame_shape  (MetaUI  *ui,
+                                 Window   xwindow,
+                                 int      new_window_width,
+                                 int      new_window_height,
+                                 gboolean window_has_shape);
+
+void meta_ui_queue_frame_draw (MetaUI *ui,
+                               Window xwindow);
+
+void meta_ui_set_frame_title (MetaUI *ui,
+                              Window xwindow,
+                              const char *title);
+
+void meta_ui_repaint_frame (MetaUI *ui,
+                            Window xwindow);
+
+MetaWindowMenu* meta_ui_window_menu_new   (MetaUI             *ui,
+                                           Window              client_xwindow,
+                                           MetaMenuOp          ops,
+                                           MetaMenuOp          insensitive,
+                                           unsigned long       active_workspace,
+                                           int                 n_workspaces,
+                                           MetaWindowMenuFunc  func,
+                                           gpointer            data);
+void            meta_ui_window_menu_popup (MetaWindowMenu     *menu,
+                                           int                 root_x,
+                                           int                 root_y,
+                                           int                 button,
+                                           guint32             timestamp);
+void            meta_ui_window_menu_free  (MetaWindowMenu     *menu);
+
+
+MetaImageWindow* meta_image_window_new          (Display         *xdisplay,
+                                                 int              screen_number,
+                                                 int              max_width,
+                                                 int              max_height);
+void             meta_image_window_free         (MetaImageWindow *iw);
+void             meta_image_window_set_showing  (MetaImageWindow *iw,
+                                                 gboolean         showing);
+void             meta_image_window_set          (MetaImageWindow *iw,
+                                                 GdkPixbuf       *pixbuf,
+                                                 int              x,
+                                                 int              y);
+
+/* FIXME these lack a display arg */
+GdkPixbuf* meta_gdk_pixbuf_get_from_window (GdkPixbuf   *dest,
+                                            Window       xwindow,
+                                            int          src_x,
+                                            int          src_y,
+                                            int          dest_x,
+                                            int          dest_y,
+                                            int          width,
+                                            int          height);
+
+GdkPixbuf* meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf   *dest,
+                                            Pixmap       xpixmap,
+                                            int          src_x,
+                                            int          src_y,
+                                            int          dest_x,
+                                            int          dest_y,
+                                            int          width,
+                                            int          height);
+
+/* Used when we have a server grab and draw all over everything,
+ * then we need to handle exposes after doing that, instead of
+ * during it
+ */
+void      meta_ui_push_delay_exposes (MetaUI *ui);
+void      meta_ui_pop_delay_exposes  (MetaUI *ui);
+
+GdkPixbuf* meta_ui_get_default_window_icon (MetaUI *ui);
+GdkPixbuf* meta_ui_get_default_mini_icon (MetaUI *ui);
+
+gboolean  meta_ui_window_should_not_cause_focus (Display *xdisplay,
+                                                 Window   xwindow);
+
+char*     meta_text_property_to_utf8 (Display             *xdisplay,
+                                      const XTextProperty *prop);
+
+void     meta_ui_set_current_theme (const char *name,
+                                    gboolean    force_reload);
+gboolean meta_ui_have_a_theme      (void);
+
+gboolean meta_ui_parse_accelerator (const char          *accel,
+                                    unsigned int        *keysym,
+                                    unsigned int        *keycode,
+                                    MetaVirtualModifier *mask);
+gboolean meta_ui_parse_modifier    (const char          *accel,
+                                    MetaVirtualModifier *mask);
+
+/* Caller responsible for freeing return string of meta_ui_accelerator_name! */
+gchar*   meta_ui_accelerator_name  (unsigned int        keysym,
+                                    MetaVirtualModifier mask);
+gboolean meta_ui_window_is_widget (MetaUI *ui,
+                                   Window  xwindow);
+
+int      meta_ui_get_drag_threshold       (MetaUI *ui);
+
+MetaUIDirection meta_ui_get_direction (void);
+
+GdkPixbuf *meta_ui_get_pixbuf_from_pixmap (Pixmap   pmap);
+
+#include "tabpopup.h"
+
+#endif
diff --git a/src/include/util.h b/src/include/util.h
new file mode 100644
index 00000000..0607c568
--- /dev/null
+++ b/src/include/util.h
@@ -0,0 +1,136 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco utilities */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_UTIL_H
+#define META_UTIL_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+gboolean meta_is_verbose  (void);
+void     meta_set_verbose (gboolean setting);
+gboolean meta_is_debugging (void);
+void     meta_set_debugging (gboolean setting);
+gboolean meta_is_syncing (void);
+void     meta_set_syncing (gboolean setting);
+gboolean meta_get_replace_current_wm (void);
+void     meta_set_replace_current_wm (gboolean setting);
+
+void meta_debug_spew_real (const char *format,
+                           ...) G_GNUC_PRINTF (1, 2);
+void meta_verbose_real    (const char *format,
+                           ...) G_GNUC_PRINTF (1, 2);
+
+void meta_bug        (const char *format,
+                      ...) G_GNUC_PRINTF (1, 2);
+void meta_warning    (const char *format,
+                      ...) G_GNUC_PRINTF (1, 2);
+void meta_fatal      (const char *format,
+                      ...) G_GNUC_PRINTF (1, 2);
+
+typedef enum
+{
+  META_DEBUG_FOCUS           = 1 << 0,
+  META_DEBUG_WORKAREA        = 1 << 1,
+  META_DEBUG_STACK           = 1 << 2,
+  META_DEBUG_THEMES          = 1 << 3,
+  META_DEBUG_SM              = 1 << 4,
+  META_DEBUG_EVENTS          = 1 << 5,
+  META_DEBUG_WINDOW_STATE    = 1 << 6,
+  META_DEBUG_WINDOW_OPS      = 1 << 7,
+  META_DEBUG_GEOMETRY        = 1 << 8,
+  META_DEBUG_PLACEMENT       = 1 << 9,
+  META_DEBUG_PING            = 1 << 10,
+  META_DEBUG_XINERAMA        = 1 << 11,
+  META_DEBUG_KEYBINDINGS     = 1 << 12,
+  META_DEBUG_SYNC            = 1 << 13,
+  META_DEBUG_ERRORS          = 1 << 14,
+  META_DEBUG_STARTUP         = 1 << 15,
+  META_DEBUG_PREFS           = 1 << 16,
+  META_DEBUG_GROUPS          = 1 << 17,
+  META_DEBUG_RESIZING        = 1 << 18,
+  META_DEBUG_SHAPES          = 1 << 19,
+  META_DEBUG_COMPOSITOR      = 1 << 20,
+  META_DEBUG_EDGE_RESISTANCE = 1 << 21
+} MetaDebugTopic;
+
+void meta_topic_real      (MetaDebugTopic topic,
+                           const char    *format,
+                           ...) G_GNUC_PRINTF (2, 3);
+
+void meta_push_no_msg_prefix (void);
+void meta_pop_no_msg_prefix  (void);
+
+gint  meta_unsigned_long_equal (gconstpointer v1,
+                                gconstpointer v2);
+guint meta_unsigned_long_hash  (gconstpointer v);
+
+void meta_print_backtrace (void);
+
+const char* meta_gravity_to_string (int gravity);
+
+#include <libintl.h>
+#define _(x) dgettext (GETTEXT_PACKAGE, x)
+#define N_(x) x
+
+char* meta_g_utf8_strndup (const gchar *src, gsize n);
+
+void  meta_free_gslist_and_elements (GSList *list_to_deep_free);
+
+GPid meta_show_dialog (const char *type,
+                       const char *title,
+                       const char *message,
+                       gint timeout,
+                       const char *ok_text,
+                       const char *cancel_text,
+                       const int transient_for,
+                       GSList *columns,
+                       GSList *entries);
+
+/* To disable verbose mode, we make these functions into no-ops */
+#ifdef WITH_VERBOSE_MODE
+
+#define meta_debug_spew meta_debug_spew_real
+#define meta_verbose    meta_verbose_real
+#define meta_topic      meta_topic_real
+
+#else
+
+#  ifdef G_HAVE_ISO_VARARGS
+#    define meta_debug_spew(...)
+#    define meta_verbose(...)
+#    define meta_topic(...)
+#  elif defined(G_HAVE_GNUC_VARARGS)
+#    define meta_debug_spew(format...)
+#    define meta_verbose(format...)
+#    define meta_topic(format...)
+#  else
+#    error "This compiler does not support varargs macros and thus verbose mode can't be disabled meaningfully"
+#  endif
+
+#endif /* !WITH_VERBOSE_MODE */
+
+#endif /* META_UTIL_H */
+
+
diff --git a/src/include/window.h b/src/include/window.h
new file mode 100644
index 00000000..8a338660
--- /dev/null
+++ b/src/include/window.h
@@ -0,0 +1,39 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Iain Holmes
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WINDOW_H
+#define META_WINDOW_H
+
+#include <glib.h>
+#include <X11/Xlib.h>
+
+#include "boxes.h"
+#include "types.h"
+
+MetaFrame *meta_window_get_frame (MetaWindow *window);
+gboolean meta_window_has_focus (MetaWindow *window);
+gboolean meta_window_is_shaded (MetaWindow *window);
+MetaRectangle *meta_window_get_rect (MetaWindow *window);
+MetaScreen *meta_window_get_screen (MetaWindow *window);
+MetaDisplay *meta_window_get_display (MetaWindow *window);
+Window meta_window_get_xwindow (MetaWindow *window);
+
+#endif
diff --git a/src/include/xprops.h b/src/include/xprops.h
new file mode 100644
index 00000000..58ad22c7
--- /dev/null
+++ b/src/include/xprops.h
@@ -0,0 +1,227 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X property convenience routines */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_XPROPS_H
+#define META_XPROPS_H
+
+#include <config.h>
+
+#include "display.h"
+#include <X11/Xutil.h>
+
+#ifdef HAVE_XSYNC
+#include <X11/extensions/sync.h>
+#endif
+
+/* Copied from Lesstif by way of GTK. Rudimentary docs can be
+ * found in some Motif reference guides online.
+ */
+typedef struct {
+    unsigned long flags;
+    unsigned long functions;
+    unsigned long decorations;
+    long input_mode;
+    unsigned long status;
+} MotifWmHints, MwmHints;
+
+#define MWM_HINTS_FUNCTIONS     (1L << 0)
+#define MWM_HINTS_DECORATIONS   (1L << 1)
+#define MWM_HINTS_INPUT_MODE    (1L << 2)
+#define MWM_HINTS_STATUS        (1L << 3)
+
+#define MWM_FUNC_ALL            (1L << 0)
+#define MWM_FUNC_RESIZE         (1L << 1)
+#define MWM_FUNC_MOVE           (1L << 2)
+#define MWM_FUNC_MINIMIZE       (1L << 3)
+#define MWM_FUNC_MAXIMIZE       (1L << 4)
+#define MWM_FUNC_CLOSE          (1L << 5)
+
+#define MWM_DECOR_ALL           (1L << 0)
+#define MWM_DECOR_BORDER        (1L << 1)
+#define MWM_DECOR_RESIZEH       (1L << 2)
+#define MWM_DECOR_TITLE         (1L << 3)
+#define MWM_DECOR_MENU          (1L << 4)
+#define MWM_DECOR_MINIMIZE      (1L << 5)
+#define MWM_DECOR_MAXIMIZE      (1L << 6)
+
+#define MWM_INPUT_MODELESS 0
+#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
+#define MWM_INPUT_SYSTEM_MODAL 2
+#define MWM_INPUT_FULL_APPLICATION_MODAL 3
+#define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
+
+#define MWM_TEAROFF_WINDOW	(1L<<0)
+
+/* These all return the memory from Xlib, so require an XFree()
+ * when they return TRUE. They return TRUE on success.
+ */
+gboolean meta_prop_get_atom_list     (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      Atom         **atoms_p,
+                                      int           *n_atoms_p);
+gboolean meta_prop_get_motif_hints   (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      MotifWmHints **hints_p);
+gboolean meta_prop_get_cardinal_list (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      gulong       **cardinals_p,
+                                      int           *n_cardinals_p);
+gboolean meta_prop_get_latin1_string (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      char         **str_p);
+gboolean meta_prop_get_utf8_string   (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      char         **str_p);
+gboolean meta_prop_get_utf8_list     (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      char        ***str_p,
+                                      int           *n_str_p);
+void     meta_prop_set_utf8_string_hint
+                                     (MetaDisplay *display,
+                                      Window xwindow,
+                                      Atom atom,
+                                      const char *val);
+gboolean meta_prop_get_window        (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      Window        *window_p);
+gboolean meta_prop_get_cardinal      (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      gulong        *cardinal_p);
+gboolean meta_prop_get_cardinal_with_atom_type (MetaDisplay   *display,
+                                                Window         xwindow,
+                                                Atom           xatom,
+                                                Atom           prop_type,
+                                                gulong        *cardinal_p);
+gboolean meta_prop_get_text_property (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      char         **utf8_str_p);
+
+gboolean meta_prop_get_wm_hints      (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      XWMHints     **hints_p);
+
+gboolean meta_prop_get_class_hint    (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      XClassHint    *class_hint);
+
+gboolean meta_prop_get_size_hints    (MetaDisplay   *display,
+                                      Window         xwindow,
+                                      Atom           xatom,
+                                      XSizeHints   **hints_p,
+                                      gulong        *flags_p);
+
+typedef enum
+{
+  META_PROP_VALUE_INVALID,
+  META_PROP_VALUE_UTF8,
+  META_PROP_VALUE_STRING,
+  META_PROP_VALUE_STRING_AS_UTF8,
+  META_PROP_VALUE_MOTIF_HINTS,
+  META_PROP_VALUE_CARDINAL,
+  META_PROP_VALUE_WINDOW,
+  META_PROP_VALUE_CARDINAL_LIST,
+  META_PROP_VALUE_UTF8_LIST,
+  META_PROP_VALUE_ATOM_LIST,
+  META_PROP_VALUE_TEXT_PROPERTY, /* comes back as UTF-8 string */
+  META_PROP_VALUE_WM_HINTS,
+  META_PROP_VALUE_CLASS_HINT,
+  META_PROP_VALUE_SIZE_HINTS,
+  META_PROP_VALUE_SYNC_COUNTER /* comes back as CARDINAL */
+} MetaPropValueType;
+
+/* used to request/return/store property values */
+typedef struct
+{
+  MetaPropValueType type;
+  Atom atom;
+  Atom required_type; /* autofilled if None */
+  
+  union
+  {
+    char *str;
+    MotifWmHints *motif_hints;
+    Window xwindow;
+    gulong cardinal;
+    XWMHints *wm_hints;
+    XClassHint class_hint;
+#ifdef HAVE_XSYNC
+    XSyncCounter xcounter;
+#endif
+    
+    struct
+    {
+      XSizeHints   *hints;
+      unsigned long flags;
+    } size_hints;
+    
+    struct
+    {
+      gulong *cardinals;
+      int     n_cardinals;
+    } cardinal_list;
+
+    struct
+    {
+      char **strings;
+      int    n_strings;
+    } string_list;
+
+    struct
+    {
+      Atom *atoms;
+      int   n_atoms;
+    } atom_list;
+    
+  } v;
+
+} MetaPropValue;
+
+/* Each value has type and atom initialized. If there's an error,
+ * or property is unset, type comes back as INVALID;
+ * else type comes back as it originated, and the data
+ * is filled in.
+ */
+void meta_prop_get_values (MetaDisplay   *display,
+                           Window         xwindow,
+                           MetaPropValue *values,
+                           int            n_values);
+
+void meta_prop_free_values (MetaPropValue *values,
+                            int            n_values);
+
+#endif
+
+
+
+
diff --git a/src/libmarco-private.pc.in b/src/libmarco-private.pc.in
new file mode 100644
index 00000000..8b0a5c83
--- /dev/null
+++ b/src/libmarco-private.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+libmate_serverdir=@libexecdir@
+
+Name: libmarco-private
+Description: Marco internals shared 
+Requires: gtk+-2.0
+Version: @VERSION@
+Libs: -L${libdir} -lmarco-private
+Cflags: -I${includedir}/marco-1
diff --git a/src/marco-wm.desktop.in b/src/marco-wm.desktop.in
new file mode 100644
index 00000000..e1e06575
--- /dev/null
+++ b/src/marco-wm.desktop.in
@@ -0,0 +1,20 @@
+[Desktop Entry]
+Type=Application
+_Name=Marco
+Exec=marco
+# name of loadable control center module
+X-MATE-WMSettingsModule=marco
+# name we put on the WM spec check window
+X-MATE-WMName=Marco
+# back compat only 
+X-MateWMSettingsLibrary=marco
+X-MATE-Bugzilla-Bugzilla=MATE
+X-MATE-Bugzilla-Product=marco
+X-MATE-Bugzilla-Component=general
+X-MATE-Autostart-Phase=WindowManager
+X-MATE-Provides=windowmanager
+X-MATE-Autostart-Notify=true
+
+[Window Manager]
+SessionManaged=true
+
diff --git a/src/marco.desktop.in b/src/marco.desktop.in
new file mode 100644
index 00000000..4167dadf
--- /dev/null
+++ b/src/marco.desktop.in
@@ -0,0 +1,17 @@
+[Desktop Entry]
+Type=Application
+_Name=Marco
+Exec=marco
+NoDisplay=true
+# name of loadable control center module
+X-MATE-WMSettingsModule=marco
+# name we put on the WM spec check window
+X-MATE-WMName=Marco
+# back compat only 
+X-MateWMSettingsLibrary=marco
+X-MATE-Bugzilla-Bugzilla=MATE
+X-MATE-Bugzilla-Product=marco
+X-MATE-Bugzilla-Component=general
+X-MATE-Autostart-Phase=WindowManager
+X-MATE-Provides=windowmanager
+X-MATE-Autostart-Notify=true
diff --git a/src/marco.schemas.in.in b/src/marco.schemas.in.in
new file mode 100644
index 00000000..acd342b4
--- /dev/null
+++ b/src/marco.schemas.in.in
@@ -0,0 +1,573 @@
+<mateconfschemafile>
+  <schemalist>
+
+    <!-- General preferences -->
+
+    <schema>
+      <key>/schemas/apps/marco/general/mouse_button_modifier</key>
+      <applyto>/apps/marco/general/mouse_button_modifier</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>&lt;Alt&gt;</default>
+      <locale name="C">
+         <short>Modifier to use for modified window click actions</short>
+         <long>
+           Clicking a window while holding down this modifier key
+           will move the window (left click), resize the window
+           (middle click), or show the window menu (right click).
+           The middle and right click operations may be swapped
+           using the "resize_with_right_button" key.
+           Modifier is expressed as "&lt;Alt&gt;" or "&lt;Super&gt;"
+           for example.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/resize_with_right_button</key>
+      <applyto>/apps/marco/general/resize_with_right_button</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>true</default>
+      <locale name="C">
+         <short>Whether to resize with the right button</short>
+         <long>
+           Set this to true to resize with the right button and show a menu
+           with the middle button while holding down the key given in
+           "mouse_button_modifier"; set it to false to make it work the
+           opposite way around.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/button_layout</key>
+      <applyto>/apps/marco/general/button_layout</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>menu:minimize,maximize,close</default>
+      <locale name="C">
+         <short>Arrangement of buttons on the titlebar</short>
+         <long>
+           Arrangement of buttons on the titlebar. The
+           value should be a string, such as
+           "menu:minimize,maximize,spacer,close"; the colon separates the
+           left corner of the window from the right corner, and
+           the button names are comma-separated. Duplicate buttons
+           are not allowed. Unknown button names are silently ignored
+           so that buttons can be added in future marco versions
+           without breaking older versions.
+           A special spacer tag can be used to insert some space between
+           two adjacent buttons.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/focus_mode</key>
+      <applyto>/apps/marco/general/focus_mode</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>click</default>
+      <locale name="C">
+        <short>Window focus mode</short>
+        <long>
+          The window focus mode indicates how windows are activated.
+          It has three possible values; "click" means windows must
+          be clicked in order to focus them, "sloppy" means windows
+          are focused when the mouse enters the window, and "mouse" means
+          windows are focused when the mouse enters the window and
+          unfocused when the mouse leaves the window.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/focus_new_windows</key>
+      <applyto>/apps/marco/general/focus_new_windows</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>smart</default>
+      <locale name="C">
+         <short>Control how new windows get focus</short>
+         <long>
+          This option provides additional control over how newly created
+          windows get focus.  It has two possible values; "smart" applies
+          the user's normal focus mode, and "strict" results in windows
+          started from a terminal not being given focus.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/raise_on_click</key>
+      <applyto>/apps/marco/general/raise_on_click</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>true</default>
+      <locale name="C">
+         <short>Whether raising should be a side-effect of other user
+                interactions</short>
+         <long>
+           Setting this option to false can lead to buggy behavior, so
+           users are strongly discouraged from changing it from the default
+           of true.
+
+           Many actions (e.g. clicking in the client area, moving or resizing the window)
+           normally raise the window as a side-effect. Setting this option to false, which
+           is strongly discouraged, will decouple raising from other user actions, and
+           ignore raise requests generated by applications. See
+           http://bugzilla.gnome.org/show_bug.cgi?id=445447#c6.
+           Even when this option is false, windows can
+           still be raised by an alt-left-click anywhere on the window, a
+           normal click on the window decorations, or by special messages
+           from pagers, such as activation requests from tasklist applets.
+           This option is currently disabled in click-to-focus mode.
+
+           Note that the list of ways to raise windows when raise_on_click
+           is false does not include programmatic requests from
+           applications to raise windows; such requests will be ignored
+           regardless of the reason for the request.  If you are an
+           application developer and have a user complaining that your
+           application does not work with this setting disabled, tell them
+           it is _their_ fault for breaking their window manager and that
+           they need to change this option back to true or live with the
+           "bug" they requested.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/action_double_click_titlebar</key>
+      <applyto>/apps/marco/general/action_double_click_titlebar</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>toggle_maximize</default>
+      <locale name="C">
+         <short>Action on title bar double-click</short>
+         <long>
+           This option determines the effects of double-clicking on the
+           title bar.  Current valid options are
+	   'toggle_shade', which will shade/unshade the window,
+	   'toggle_maximize' which will maximize/unmaximize the window,
+	   'toggle_maximize_horizontally' and 'toggle_maximize_vertically'
+	   which will maximize/unmaximize the window in that direction only,
+	   'minimize' which will minimize the window,
+	   'shade' which will roll the window up,
+	   'menu' which will display the window menu,
+	   'lower' which will put the window behind all the others,
+	   and 'none' which will not do anything.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/action_middle_click_titlebar</key>
+      <applyto>/apps/marco/general/action_middle_click_titlebar</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>lower</default>
+      <locale name="C">
+         <short>Action on title bar middle-click</short>
+         <long>
+           This option determines the effects of middle-clicking on the
+           title bar.  Current valid options are
+	   'toggle_shade', which will shade/unshade the window,
+	   'toggle_maximize' which will maximize/unmaximize the window,
+	   'toggle_maximize_horizontally' and 'toggle_maximize_vertically'
+	   which will maximize/unmaximize the window in that direction only,
+	   'minimize' which will minimize the window,
+	   'shade' which will roll the window up,
+	   'menu' which will display the window menu,
+	   'lower' which will put the window behind all the others,
+	   and 'none' which will not do anything.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/action_right_click_titlebar</key>
+      <applyto>/apps/marco/general/action_right_click_titlebar</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>menu</default>
+      <locale name="C">
+         <short>Action on title bar right-click</short>
+         <long>
+           This option determines the effects of right-clicking on the
+           title bar.  Current valid options are
+	   'toggle_shade', which will shade/unshade the window,
+	   'toggle_maximize' which will maximize/unmaximize the window,
+	   'toggle_maximize_horizontally' and 'toggle_maximize_vertically'
+	   which will maximize/unmaximize the window in that direction only,
+	   'minimize' which will minimize the window,
+	   'shade' which will roll the window up,
+	   'menu' which will display the window menu,
+	   'lower' which will put the window behind all the others,
+	   and 'none' which will not do anything.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/auto_raise</key>
+      <applyto>/apps/marco/general/auto_raise</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+        <short>Automatically raises the focused window</short>
+        <long>
+          If set to true, and the focus mode is either "sloppy" or "mouse"
+          then the focused window will be automatically raised after a
+          delay specified by the auto_raise_delay key. This is not related
+          to clicking on a window to raise it, nor to entering a window
+          during drag-and-drop.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/auto_raise_delay</key>
+      <applyto>/apps/marco/general/auto_raise_delay</applyto>
+      <owner>marco</owner>
+      <type>int</type>
+      <default>500</default>
+      <locale name="C">
+        <short>Delay in milliseconds for the auto raise option</short>
+        <long>
+          The time delay before raising a window if auto_raise is set to
+          true. The delay is given in thousandths of a second.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/theme</key>
+      <applyto>/apps/marco/general/theme</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>Spidey-Left</default>
+      <locale name="C">
+         <short>Current theme</short>
+         <long>
+          The theme determines the appearance of window borders,
+          titlebar, and so forth.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/titlebar_uses_system_font</key>
+      <applyto>/apps/marco/general/titlebar_uses_system_font</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+         <short>Use standard system font in window titles</short>
+         <long>
+          If true, ignore the titlebar_font
+          option, and use the standard application font for window
+          titles.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/titlebar_font</key>
+      <applyto>/apps/marco/general/titlebar_font</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>Sans Bold 10</default>
+      <locale name="C">
+        <short>Window title font</short>
+        <long>
+          A font description string describing a font for window
+          titlebars. The size from the description will only be used if the
+          titlebar_font_size option is set to 0. Also, this option is
+          disabled if the titlebar_uses_desktop_font option is set to true.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/num_workspaces</key>
+      <applyto>/apps/marco/general/num_workspaces</applyto>
+      <owner>marco</owner>
+      <type>int</type>
+      <default>4</default>
+      <locale name="C">
+        <short>Number of workspaces</short>
+        <long>
+          Number of workspaces. Must be more than zero, and has a fixed
+          maximum to prevent making the desktop unusable by accidentally
+          asking for too many workspaces.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/visual_bell</key>
+      <applyto>/apps/marco/general/visual_bell</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+        <short>Enable Visual Bell</short>
+        <long>
+          Turns on a visual indication when an application or the system
+          issues a 'bell' or 'beep'; useful for the hard-of-hearing and for
+          use in noisy environments.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/audible_bell</key>
+      <applyto>/apps/marco/general/audible_bell</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>true</default>
+      <locale name="C">
+        <short>System Bell is Audible</short>
+        <long>
+          Determines whether applications or the system can generate
+          audible 'beeps'; may be used in conjunction with 'visual bell' to
+          allow silent 'beeps'.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/visual_bell_type</key>
+      <applyto>/apps/marco/general/visual_bell_type</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>fullscreen</default>
+      <locale name="C">
+        <short>Visual Bell Type</short>
+        <long>
+          Tells Marco how to implement the visual indication that the
+          system bell or another application 'bell' indicator has been
+          rung.  Currently there are two valid values, "fullscreen", which
+          causes a fullscreen white-black flash, and "frame_flash" which
+          causes the titlebar of the application which sent the bell signal
+          to flash.  If the application which sent the bell is unknown (as
+          is usually the case for the default "system beep"), the currently
+          focused window's titlebar is flashed.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/compositing_manager</key>
+      <applyto>/apps/marco/general/compositing_manager</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+        <short>Compositing Manager</short>
+        <long>
+          Determines whether Marco is a compositing manager.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/workspace_names/name</key>
+      <applyto>/apps/marco/workspace_names/name_1</applyto>
+      <applyto>/apps/marco/workspace_names/name_2</applyto>
+      <applyto>/apps/marco/workspace_names/name_3</applyto>
+      <applyto>/apps/marco/workspace_names/name_4</applyto>
+      <applyto>/apps/marco/workspace_names/name_5</applyto>
+      <applyto>/apps/marco/workspace_names/name_6</applyto>
+      <applyto>/apps/marco/workspace_names/name_7</applyto>
+      <applyto>/apps/marco/workspace_names/name_8</applyto>
+      <applyto>/apps/marco/workspace_names/name_9</applyto>
+      <applyto>/apps/marco/workspace_names/name_10</applyto>
+      <applyto>/apps/marco/workspace_names/name_11</applyto>
+      <applyto>/apps/marco/workspace_names/name_12</applyto>
+      <applyto>/apps/marco/workspace_names/name_13</applyto>
+      <applyto>/apps/marco/workspace_names/name_14</applyto>
+      <applyto>/apps/marco/workspace_names/name_15</applyto>
+      <applyto>/apps/marco/workspace_names/name_16</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default></default>
+      <locale name="C">
+         <short>Name of workspace</short>
+         <long>
+          The name of a workspace.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/reduced_resources</key>
+      <applyto>/apps/marco/general/reduced_resources</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+         <short>If true, trade off usability for less resource usage</short>
+         <long>
+           If true, marco will give the user less feedback by using
+           wireframes, avoiding animations, or other means.  This is a
+           significant reduction in usability for many users, but may allow
+           legacy applications to continue working, and may also be a
+           useful tradeoff for terminal servers.  However, the wireframe
+           feature is disabled when accessibility is on.
+         </long>
+      </locale>
+    </schema>
+
+    <!-- Keybindings -->
+
+    <schema>
+      <key>/schemas/apps/marco/global_keybindings/run_command</key>
+      <applyto>/apps/marco/global_keybindings/run_command_1</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_2</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_3</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_4</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_5</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_6</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_7</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_8</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_9</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_10</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_11</applyto>
+      <applyto>/apps/marco/global_keybindings/run_command_12</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>disabled</default>
+      <locale name="C">
+         <short>Run a defined command</short>
+         <long>
+          The keybinding that runs the correspondingly-numbered
+          command in /apps/marco/keybinding_commands
+
+          The format looks like "&lt;Control&gt;a" or
+          "&lt;Shift&gt;&lt;Alt&gt;F1".
+
+          The parser is fairly liberal and allows lower or upper case,
+          and also abbreviations such as "&lt;Ctl&gt;" and
+          "&lt;Ctrl&gt;". If you set the option to the special string
+          "disabled", then there will be no keybinding for this
+          action.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/keybinding_commands/command</key>
+      <applyto>/apps/marco/keybinding_commands/command_1</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_2</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_3</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_4</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_5</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_6</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_7</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_8</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_9</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_10</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_11</applyto>
+      <applyto>/apps/marco/keybinding_commands/command_12</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default> </default>
+      <locale name="C">
+         <short>Commands to run in response to keybindings</short>
+         <long>
+         The /apps/marco/global_keybindings/run_command_N
+         keys define keybindings that correspond to these commands.
+         Pressing the keybinding for run_command_N will
+         execute command_N.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/keybinding_commands/command_screenshot</key>
+      <applyto>/apps/marco/keybinding_commands/command_screenshot</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>mate-screenshot</default>
+      <locale name="C">
+         <short>The screenshot command</short>
+         <long>
+         The /apps/marco/global_keybindings/run_command_screenshot
+         key defines a keybinding which causes the command specified
+         by this setting to be invoked.
+         </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/keybinding_commands/command_window_screenshot</key>
+      <applyto>/apps/marco/keybinding_commands/command_window_screenshot</applyto>
+      <owner>marco</owner>
+      <type>string</type>
+      <default>mate-screenshot --window</default>
+      <locale name="C">
+         <short>The window screenshot command</short>
+         <long>
+         The /apps/marco/global_keybindings/run_command_window_screenshot
+         key defines a keybinding which causes the command specified
+         by this setting to be invoked.
+         </long>
+      </locale>
+    </schema>
+
+    <!-- Schemas below are generated by schema-bindings.c when this file
+         becomes marco.schemas.in
+    -->
+    <!-- GENERATED -->
+
+    <!-- Not used and/or crackrock -->
+
+    <schema>
+      <key>/schemas/apps/marco/general/application_based</key>
+      <applyto>/apps/marco/general/application_based</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+        <short>(Not implemented) Navigation works in terms of applications not windows</short>
+        <long>
+          If true, then Marco works in terms of applications rather than
+          windows. The concept is a bit abstract, but in general an
+          application-based setup is more like the Mac and less like
+          Windows. When you focus a window in application-based mode, all
+          the windows in the application will be raised. Also, in
+          application-based mode, focus clicks are not passed through to
+          windows in other applications. Application-based mode is,
+          however, largely unimplemented at the moment.
+        </long>
+      </locale>
+    </schema>
+
+    <schema>
+      <key>/schemas/apps/marco/general/disable_workarounds</key>
+      <applyto>/apps/marco/general/disable_workarounds</applyto>
+      <owner>marco</owner>
+      <type>bool</type>
+      <default>false</default>
+      <locale name="C">
+        <short>Disable misfeatures that are required by old or broken
+               applications</short>
+        <long>
+          Some applications disregard specifications in ways that result in
+          window manager misfeatures. This option puts Marco in a
+          rigorously correct mode, which gives a more consistent user
+          interface, provided one does not need to run any misbehaving
+          applications.
+        </long>
+      </locale>
+    </schema>
+
+  </schemalist>
+</mateconfschemafile>
+
+
+
+
diff --git a/src/themes/ClearlooksRe/metacity-theme-1.xml b/src/themes/ClearlooksRe/metacity-theme-1.xml
new file mode 100644
index 00000000..fbc5a174
--- /dev/null
+++ b/src/themes/ClearlooksRe/metacity-theme-1.xml
@@ -0,0 +1,1013 @@
+<?xml version="1.0"?>
+<!-- 	$Id$	 -->
+<metacity_theme>
+<info>
+	<name>ClearlooksRe</name>
+	<author>Daniel Borgmann &lt;[email protected]&gt;, Andrea Cimitan &lt;[email protected]&gt;, Germán Augusto Perugorria &lt;[email protected]&gt;</author>
+	<copyright>&#194; 2005-2007 Daniel Borgmann, Andrea Cimitan. 2010 Perberos</copyright>
+	<date>December, 2010</date>
+	<description>The Clearlooks "Gummy" Metacity Theme</description>
+</info>
+
+<!-- ::: GEOMETRY ::: -->
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true" rounded_bottom_left="false" rounded_bottom_right="false">
+	<distance name="left_width" value="4"/>
+	<distance name="right_width" value="4"/>
+	<distance name="bottom_height" value="4"/>
+	<distance name="left_titlebar_edge" value="4"/>
+	<distance name="right_titlebar_edge" value="4"/>
+	<aspect_ratio name="button" value="1.0"/>
+	<distance name="title_vertical_pad" value="0"/>
+	<border name="title_border" left="2" right="2" top="4" bottom="3"/>
+	<border name="button_border" left="1" right="1" top="2" bottom="2"/>
+</frame_geometry>
+
+<frame_geometry name="shaded" parent="normal" rounded_top_left="true" rounded_top_right="true" rounded_bottom_left="true" rounded_bottom_right="true"/>
+
+<frame_geometry name="normal_maximized" parent="normal" rounded_top_left="false" rounded_top_right="false" rounded_bottom_left="false" rounded_bottom_right="false">
+	<!-- strip frame spacing off the normal geometry when maximised -->
+	<distance name="left_width" value="0"/>
+	<distance name="right_width" value="0"/>
+	<distance name="bottom_height" value="1"/>
+	<distance name="left_titlebar_edge" value="1"/>
+	<distance name="right_titlebar_edge" value="1"/>
+</frame_geometry>
+
+<frame_geometry name="utility" title_scale="small" rounded_top_left="false" rounded_top_right="false" rounded_bottom_left="false" rounded_bottom_right="false">
+	<distance name="left_width" value="4"/>
+	<distance name="right_width" value="4"/>
+	<distance name="bottom_height" value="4"/>
+	<distance name="left_titlebar_edge" value="4"/>
+	<distance name="right_titlebar_edge" value="4"/>
+	<distance name="title_vertical_pad" value="0"/>
+	<border name="title_border" left="2" right="2" top="4" bottom="3"/>
+	<border name="button_border" left="0" right="0" top="2" bottom="2"/>
+	<aspect_ratio name="button" value="1"/>
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false">
+	<distance name="left_width" value="4"/>
+	<distance name="right_width" value="4"/>
+	<distance name="bottom_height" value="4"/>
+	<distance name="left_titlebar_edge" value="0"/>
+	<distance name="right_titlebar_edge" value="0"/>
+	<distance name="button_width" value="0"/>
+	<distance name="button_height" value="0"/>
+	<distance name="title_vertical_pad" value="4"/>
+	<border name="title_border" left="0" right="0" top="0" bottom="0"/>
+	<border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- button minimum size -->
+<constant name="Bmin" value="7"/>
+<!-- button inside padding -->
+<constant name="Bpad" value="6"/>
+
+<!-- ::: CORNERS ::: -->
+<draw_ops name="corners_outline_selected_top">
+	<!-- top left -->
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="1" y1="3" x2="1" y2="3"/>
+	<line color="shade/gtk:bg[SELECTED]/0.73" x1="1" y1="4" x2="1" y2="4"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="2" y1="2" x2="2" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="3" y1="1" x2="3" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.73" x1="4" y1="1" x2="4" y2="1"/>
+
+	<!-- top right -->
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-2" y1="3" x2="width-2" y2="3"/>
+	<line color="shade/gtk:bg[SELECTED]/0.73" x1="width-2" y1="4" x2="width-2" y2="4"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-3" y1="2" x2="width-3" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-4" y1="1" x2="width-4" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.73" x1="width-5" y1="1" x2="width-5" y2="1"/>
+</draw_ops>
+
+<draw_ops name="corners_outline_top">
+	<!-- top left -->
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="1" y1="3" x2="1" y2="3"/>
+	<line color="shade/gtk:bg[NORMAL]/0.68" x1="1" y1="4" x2="1" y2="4"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="2" y1="2" x2="2" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="3" y1="1" x2="3" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.68" x1="4" y1="1" x2="4" y2="1"/>
+
+	<!-- top right -->
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-2" y1="3" x2="width-2" y2="3"/>
+	<line color="shade/gtk:bg[NORMAL]/0.68" x1="width-2" y1="4" x2="width-2" y2="4"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-3" y1="2" x2="width-3" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-4" y1="1" x2="width-4" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.68" x1="width-5" y1="1" x2="width-5" y2="1"/>
+</draw_ops>
+
+<draw_ops name="corners_outline_selected_bottom">
+	<!-- bottom left -->
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="1" y1="height-4" x2="1" y2="height-5"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="2" y1="height-3" x2="2" y2="height-3"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="2" y1="height-2" x2="4" y2="height-2"/>
+
+	<!-- bottom right -->
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-2" y1="height-4" x2="width-2" y2="height-5"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-3" y1="height-3" x2="width-3" y2="height-3"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-4" y1="height-2" x2="width-5" y2="height-2"/>
+</draw_ops>
+
+<draw_ops name="corners_outline_bottom">
+	<!-- bottom left -->
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="1" y1="height-4" x2="1" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="2" y1="height-3" x2="2" y2="height-3"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="2" y1="height-2" x2="4" y2="height-2"/>
+
+	<!-- bottom right -->
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-2" y1="height-4" x2="width-2" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-3" y1="height-3" x2="width-3" y2="height-3"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-4" y1="height-2" x2="width-5" y2="height-2"/>
+</draw_ops>
+
+<draw_ops name="corners_highlight">
+	<!-- ** corner highlight for left top ** -->
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="2" y1="3" x2="2" y2="4"/>
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="3" y1="2" x2="4" y2="2"/>
+
+	<!-- ** corner highlight for right top ** -->
+	<line color="shade/gtk:bg[SELECTED]/0.98" x1="width-3" y1="3" x2="width-3" y2="4"/>
+	<line color="shade/gtk:bg[SELECTED]/1.16" x1="width-5" y1="2" x2="width-4" y2="2"/>
+
+	<!-- ** corner highlight for left bottom ** -->
+	<!--<line color="shade/gtk:bg[NORMAL]/1.3" x1="2" y1="height-4" x2="2" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="3" y1="height-3" x2="4" y2="height-3"/>-->
+
+	<!-- ** corner highlight for right bottom ** -->
+	<!--<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-3" y1="height-4" x2="width-3" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-4" y1="height-3" x2="width-5" y2="height-3"/>-->
+</draw_ops>
+
+<draw_ops name="corners_highlight_unfocused">
+	<!-- ** corner highlight for left top ** -->
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="2" y1="3" x2="2" y2="4"/>
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="3" y1="2" x2="4" y2="2"/>
+
+	<!-- ** corner highlight for right top ** -->
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-3" y1="3" x2="width-3" y2="4"/>
+	<line color="shade/gtk:bg[NORMAL]/1.04" x1="width-5" y1="2" x2="width-4" y2="2"/>
+
+	<!-- ** corner highlight for left bottom ** -->
+	<!--<line color="shade/gtk:bg[NORMAL]/1.3" x1="2" y1="height-4" x2="2" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="3" y1="height-3" x2="4" y2="height-3"/>-->
+
+	<!-- ** corner highlight for right bottom ** -->
+	<!--<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-3" y1="height-4" x2="width-3" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-4" y1="height-3" x2="width-5" y2="height-3"/>-->
+</draw_ops>
+
+<draw_ops name="corners_highlight_shaded">
+	<!-- ** corner highlight for left top ** -->
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="2" y1="3" x2="2" y2="4"/>
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="3" y1="2" x2="4" y2="2"/>
+
+	<!-- ** corner highlight for right top ** -->
+	<line color="shade/gtk:bg[SELECTED]/0.98" x1="width-3" y1="3" x2="width-3" y2="4"/>
+	<line color="shade/gtk:bg[SELECTED]/1.16" x1="width-5" y1="2" x2="width-4" y2="2"/>
+
+	<!-- ** corner highlight for left bottom ** -->
+	<line color="shade/gtk:bg[SELECTED]/1.08" x1="2" y1="height-4" x2="2" y2="height-5"/>
+	<line color="shade/gtk:bg[SELECTED]/0.98" x1="3" y1="height-3" x2="4" y2="height-3"/>
+
+	<!-- ** corner highlight for right bottom ** -->
+	<line color="shade/gtk:bg[SELECTED]/0.98" x1="width-3" y1="height-4" x2="width-3" y2="height-5"/>
+	<line color="shade/gtk:bg[SELECTED]/0.98" x1="width-4" y1="height-3" x2="width-5" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="corners_highlight_shaded_unfocused">
+	<!-- ** corner highlight for left top ** -->
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="2" y1="3" x2="2" y2="4"/>
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="3" y1="2" x2="4" y2="2"/>
+
+	<!-- ** corner highlight for right top ** -->
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-3" y1="3" x2="width-3" y2="4"/>
+	<line color="shade/gtk:bg[NORMAL]/1.04" x1="width-5" y1="2" x2="width-4" y2="2"/>
+
+	<!-- ** corner highlight for left bottom ** -->
+	<line color="shade/gtk:bg[NORMAL]/1.02" x1="2" y1="height-4" x2="2" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="3" y1="height-3" x2="4" y2="height-3"/>
+
+	<!-- ** corner highlight for right bottom ** -->
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-3" y1="height-4" x2="width-3" y2="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width-4" y1="height-3" x2="width-5" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="window_bg">
+	<rectangle color="gtk:bg[NORMAL]" filled="true" x="0" y="0" width="width" height="height"/>
+</draw_ops>
+
+<!-- ::: BEVEL FOCUSED ::: -->
+<draw_ops name="bevel">
+	<include name="window_bg"/>
+	<!-- ** titlebar outline ** -->
+	<rectangle color="shade/gtk:bg[SELECTED]/0.55" filled="false" x="0" y="0" width="width - 1" height="((title_height + 6) `max` (top_height - 2))"/>
+
+	<!-- ** 3d beveled frame ** -->
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="1" y1="height - 2" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width - 2" y1="3" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.2" x1="3" y1="1" x2="width - 4" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="3" x2="1" y2="height - 2"/>
+
+	<line color="shade/gtk:bg[SELECTED]/0.94" x1="2" y1="((title_height + 5) `max` (top_height - 3))" x2="width - 3" y2="((title_height + 5) `max` (top_height - 3))"/>
+	<line color="shade/gtk:bg[SELECTED]/0.95" x1="width - 2" y1="2" x2="width - 2" y2="((title_height + 6) `max` (top_height - 2))"/>
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="1" y1="1" x2="width - 2" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/1.1" x1="1" y1="2" x2="1" y2="((title_height + 5) `max` (top_height - 3))"/>
+
+	<!-- ** fancy gradient ** -->
+	<gradient type="vertical" x="2" y="top_height/2" width="width-4" height="top_height/2-1">
+		<color value="shade/gtk:bg[SELECTED]/1.0"/>
+		<color value="shade/gtk:bg[SELECTED]/0.94"/>
+	</gradient>
+	<gradient type="vertical" x="2" y="2" width="width-4" height="top_height/2-2">
+		<color value="shade/gtk:bg[SELECTED]/1.08"/>
+		<color value="shade/gtk:bg[SELECTED]/1.02"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="((title_height + 6) `max` (top_height - 2))" x2="width - 2" y2="((title_height + 6) `max` (top_height - 2))"/>
+
+	<!-- ** border outline ** -->
+	<line color="shade/gtk:bg[NORMAL]/0.45" x1="0" y1="((title_height + 6) `max` (top_height - 2))" x2="0" y2="height"/>
+	<line color="shade/gtk:bg[NORMAL]/0.45" x1="width - 1" y1="((title_height + 6) `max` (top_height - 2))" x2="width - 1" y2="height"/>
+	<line color="shade/gtk:bg[NORMAL]/0.45" x1="1" y1="height - 1" x2="width - 2" y2="height - 1"/>
+</draw_ops>
+
+<draw_ops name="bevel_maximized">
+	<!-- ** 3d beveled frame ** -->
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="0" y1="0" x2="width" y2="0"/>
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="0" y1="1" x2="width" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.94" x1="0" y1="((title_height + 5) `max` (top_height - 3))" x2="width" y2="((title_height + 5) `max` (top_height - 3))"/>
+
+	<!-- ** fancy gradient ** -->
+	<gradient type="vertical" x="0" y="top_height/2" width="width" height="top_height/2-1">
+		<color value="shade/gtk:bg[SELECTED]/1.0"/>
+		<color value="shade/gtk:bg[SELECTED]/0.94"/>
+	</gradient>
+	<gradient type="vertical" x="0" y="1" width="width" height="top_height/2-1">
+		<color value="shade/gtk:bg[SELECTED]/1.08"/>
+		<color value="shade/gtk:bg[SELECTED]/1.02"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[SELECTED]/0.7" x1="0" y1="((title_height + 6) `max` (top_height - 2))" x2="width" y2="((title_height + 6) `max` (top_height - 2))"/>
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="0" y1="height-1" x2="width" y2="height-1"/>
+</draw_ops>
+
+<draw_ops name="round_bevel">
+	<include name="bevel"/>
+	<include name="corners_outline_selected_top"/>
+	<!--<include name="corners_outline_bottom"/>-->
+	<include name="corners_highlight"/>
+</draw_ops>
+
+<draw_ops name="bevel_shaded">
+	<include name="bevel"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="0" y1="height-1" x2="width" y2="height-1"/>
+</draw_ops>
+
+<draw_ops name="round_bevel_shaded">
+	<include name="bevel"/>
+	<include name="corners_outline_selected_top"/>
+	<include name="corners_outline_selected_bottom"/>
+	<include name="corners_highlight_shaded"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="5" y1="height-1" x2="width-6" y2="height-1"/>
+</draw_ops>
+
+<!-- ::: BEVEL UNFOCUSED ::: -->
+<draw_ops name="bevel_unfocused">
+	<include name="window_bg"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="1" y1="height - 2" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width - 2" y1="2" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="1" y1="1" x2="width - 2" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/1.03" x1="1" y1="2" x2="1" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.89" x1="2" y1="((title_height + 5) `max` (top_height - 3))" x2="width - 3" y2="((title_height + 5) `max` (top_height - 3))"/>
+
+	<!-- ** fancy gradient ** -->
+	<gradient type="vertical" x="2" y="top_height/2" width="width-4" height="top_height/2-1">
+		<color value="shade/gtk:bg[NORMAL]/0.93"/>
+		<color value="shade/gtk:bg[NORMAL]/0.89"/>
+	</gradient>
+	<gradient type="vertical" x="2" y="2" width="width-4" height="top_height/2-2">
+		<color value="shade/gtk:bg[NORMAL]/0.99"/>
+		<color value="shade/gtk:bg[NORMAL]/0.95"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[NORMAL]/0.65" x1="1" y1="((title_height + 6) `max` (top_height - 2))" x2="width - 2" y2="((title_height + 6) `max` (top_height - 2))"/>
+	<rectangle color="shade/gtk:bg[NORMAL]/0.55" filled="false" x="0" y="0" width="width - 1" height="height - 1"/>
+</draw_ops>
+
+<draw_ops name="bevel_maximized_unfocused">
+	<!-- ** 3d beveled frame ** -->
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="0" y1="0" x2="width" y2="0"/>
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="0" y1="1" x2="width" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.89" x1="0" y1="((title_height + 5) `max` (top_height - 3))" x2="width" y2="((title_height + 5) `max` (top_height - 3))"/>
+
+	<!-- ** fancy gradient ** -->
+	<gradient type="vertical" x="0" y="top_height/2" width="width" height="top_height/2-1">
+		<color value="shade/gtk:bg[NORMAL]/0.93"/>
+		<color value="shade/gtk:bg[NORMAL]/0.89"/>
+	</gradient>
+	<gradient type="vertical" x="0" y="2" width="width" height="top_height/2-2">
+		<color value="shade/gtk:bg[NORMAL]/0.99"/>
+		<color value="shade/gtk:bg[NORMAL]/0.95"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[NORMAL]/0.65" x1="0" y1="((title_height + 6) `max` (top_height - 2))" x2="width" y2="((title_height + 6) `max` (top_height - 2))"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="0" y1="height-1" x2="width" y2="height-1"/>
+</draw_ops>
+
+<draw_ops name="round_bevel_unfocused">
+	<include name="bevel_unfocused"/>
+	<include name="corners_outline_top"/>
+	<!--<include name="corners_outline_bottom"/>-->
+	<include name="corners_highlight_unfocused"/>
+</draw_ops>
+
+<draw_ops name="round_bevel_unfocused_shaded">
+	<include name="bevel_unfocused"/>
+	<include name="corners_outline_top"/>
+	<include name="corners_outline_bottom"/>
+	<include name="corners_highlight_shaded_unfocused"/>
+</draw_ops>
+
+<!-- ::: BORDER ::: -->
+<draw_ops name="border">
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="1" y1="height - 2" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width - 2" y1="1" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="width - 2" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="1" y2="height - 2"/>
+
+	<rectangle color="shade/gtk:bg[NORMAL]/0.55" filled="false" x="0" y="0" width="width - 1" height="height - 1"/>
+</draw_ops>
+
+<!-- ::: TITLES ::: -->
+<draw_ops name="title_text">
+	<title color="shade/gtk:bg[SELECTED]/0.7" x="((3 `max` (width-title_width)) / 2)" y="(((height - title_height) / 2) `max` 0) + 1"/>
+	<title color="shade/gtk:bg[SELECTED]/0.7" x="((3 `max` (width-title_width)) / 2)+1" y="(((height - title_height) / 2) `max` 0)"/>
+	<title color="shade/gtk:bg[SELECTED]/0.7" x="((3 `max` (width-title_width)) / 2)-1" y="(((height - title_height) / 2) `max` 0)"/>
+	<title color="shade/gtk:bg[SELECTED]/0.7" x="((3 `max` (width-title_width)) / 2)" y="(((height - title_height) / 2) `max` 0)-1"/>
+	<title color="#FFFFFF" x="(3 `max` (width-title_width)) / 2" y="(((height - title_height) / 2) `max` 0)"/>
+</draw_ops>
+
+<draw_ops name="title_text_unfocused">
+	<!--<title color="shade/gtk:bg[NORMAL]/1.07" x="5 `max` (width-title_width)/2+1" y="1 `max` ((height-title_height)/2)+1"/>-->
+	<title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" x="4 `max` (width-title_width)/2" y="0 `max` ((height-title_height)/2)"/>
+</draw_ops>
+
+<draw_ops name="title">
+	<include name="title_text"/>
+</draw_ops>
+
+<draw_ops name="title_unfocused">
+	<include name="title_text_unfocused"/>
+</draw_ops>
+
+<!-- ::: BUTTONS ::: -->
+<draw_ops name="button_bg">
+	<!-- inset -->
+	<gradient type="vertical" x="0" y="3" width="width" height="height-6">
+		<color value="shade/gtk:bg[SELECTED]/0.96"/>
+		<color value="shade/gtk:bg[SELECTED]/1.05"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[SELECTED]/1.00" x1="2" y1="0" x2="width-3" y2="0"/>
+	<line color="shade/gtk:bg[SELECTED]/0.99" x1="1" y1="1" x2="width-2" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.99" x1="0" y1="2" x2="width-1" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.98" x1="3" y1="0" x2="width-4" y2="0"/>
+
+	<line color="shade/gtk:bg[SELECTED]/0.91" x1="2" y1="1" x2="width-3" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.90" x1="1" y1="2" x2="width-2" y2="2"/>
+
+	<line color="shade/gtk:bg[SELECTED]/1.03" x1="2" y1="height-1" x2="width-3" y2="height-1"/>
+	<line color="shade/gtk:bg[SELECTED]/1.00" x1="1" y1="height-2" x2="width-2" y2="height-2"/>
+	<line color="shade/gtk:bg[SELECTED]/1.01" x1="0" y1="height-3" x2="width-1" y2="height-3"/>
+	<line color="shade/gtk:bg[SELECTED]/1.06" x1="3" y1="height-1" x2="width-4" y2="height-1"/>
+
+	<line color="shade/gtk:bg[SELECTED]/1.02" x1="2" y1="height-2" x2="width-3" y2="height-2"/>
+	<line color="shade/gtk:bg[SELECTED]/1.03" x1="1" y1="height-3" x2="width-2" y2="height-3"/>
+
+	<!-- border outline -->
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="3" y1="1" x2="width-4" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="3" y1="height-2" x2="width-4" y2="height-2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="1" y1="3" x2="1" y2="height-4"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-2" y1="3" x2="width-2" y2="height-4"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="2" y1="2" x2="width-3" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+
+	<!-- border smooth effect -->
+	<line color="shade/gtk:bg[SELECTED]/1.02" x1="3" y1="2" x2="width-4" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/1.00" x1="2" y1="3" x2="2" y2="height-4"/>
+	<line color="shade/gtk:bg[SELECTED]/0.90" x1="width-3" y1="3" x2="width-3" y2="height-4"/>
+
+	<!-- inside highlight -->
+	<line color="shade/gtk:bg[SELECTED]/1.18" x1="4" y1="2" x2="width-5" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/1.1" x1="2" y1="4" x2="2" y2="height-5"/>
+	<!-- inside shadow -->
+	<line color="shade/gtk:bg[SELECTED]/1.0" x1="width-3" y1="4" x2="width-3" y2="height-5"/>
+
+	<!-- fill gradient -->
+	<gradient type="vertical" x="3" y="3" width="width-6" height="(height)/2-1">
+		<color value="shade/gtk:bg[SELECTED]/1.1"/>
+		<color value="shade/gtk:bg[SELECTED]/1.02"/>
+	</gradient>
+	<gradient type="vertical" x="3" y="(height)/2" width="width-6" height="(height)/2-2">
+		<color value="shade/gtk:bg[SELECTED]/1.0"/>
+		<color value="shade/gtk:bg[SELECTED]/0.92"/>
+	</gradient>
+
+	<!-- bottom border smooth effect -->
+	<line color="shade/gtk:bg[SELECTED]/0.84" x1="3" y1="height-3" x2="width-4" y2="height-3"/>
+	<line color="shade/gtk:bg[SELECTED]/0.92" x1="4" y1="height-3" x2="width-5" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="button_bg_unfocused">
+	<!-- inset -->
+	<gradient type="vertical" x="0" y="3" width="width" height="height-6">
+		<color value="shade/gtk:bg[NORMAL]/0.92"/>
+		<color value="shade/gtk:bg[NORMAL]/0.96"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[NORMAL]/0.93" x1="2" y1="0" x2="width-3" y2="0"/>
+	<line color="shade/gtk:bg[NORMAL]/0.92" x1="1" y1="1" x2="width-2" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.92" x1="0" y1="2" x2="width-1" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.91" x1="3" y1="0" x2="width-4" y2="0"/>
+
+	<line color="shade/gtk:bg[NORMAL]/0.87" x1="2" y1="1" x2="width-3" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.86" x1="1" y1="2" x2="width-2" y2="2"/>
+
+	<line color="shade/gtk:bg[NORMAL]/0.945" x1="2" y1="height-1" x2="width-3" y2="height-1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.93" x1="1" y1="height-2" x2="width-2" y2="height-2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.935" x1="0" y1="height-3" x2="width-1" y2="height-3"/>
+	<line color="shade/gtk:bg[NORMAL]/0.96" x1="3" y1="height-1" x2="width-4" y2="height-1"/>
+
+	<line color="shade/gtk:bg[NORMAL]/0.94" x1="2" y1="height-2" x2="width-3" y2="height-2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.95" x1="1" y1="height-3" x2="width-2" y2="height-3"/>
+
+	<!-- border outline -->
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="3" y1="1" x2="width-4" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="3" y1="height-2" x2="width-4" y2="height-2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="1" y1="3" x2="1" y2="height-4"/>
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="width-2" y1="3" x2="width-2" y2="height-4"/>
+
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="2" y1="2" x2="width-3" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+
+	<!-- border smooth effect -->
+	<line color="shade/gtk:bg[NORMAL]/1.02" x1="3" y1="2" x2="width-4" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.00" x1="2" y1="3" x2="2" y2="height-4"/>
+	<line color="shade/gtk:bg[NORMAL]/0.95" x1="width-3" y1="3" x2="width-3" y2="height-4"/>
+
+	<!-- inside highlight -->
+	<line color="shade/gtk:bg[NORMAL]/1.2" x1="4" y1="2" x2="width-5" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.1" x1="2" y1="4" x2="2" y2="height-5"/>
+	<!-- inside shadow -->
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="width-3" y1="4" x2="width-3" y2="height-5"/>
+
+	<!-- fill gradient -->
+	<gradient type="vertical" x="3" y="3" width="width-6" height="(height)/2-1">
+		<color value="shade/gtk:bg[NORMAL]/1.15"/>
+		<color value="shade/gtk:bg[NORMAL]/1.07"/>
+	</gradient>
+	<gradient type="vertical" x="3" y="(height)/2" width="width-6" height="(height)/2-2">
+		<color value="shade/gtk:bg[NORMAL]/1.05"/>
+		<color value="shade/gtk:bg[NORMAL]/0.97"/>
+	</gradient>
+
+	<!-- bottom border smooth effect -->
+	<line color="shade/gtk:bg[NORMAL]/0.89" x1="3" y1="height-3" x2="width-4" y2="height-3"/>
+	<line color="shade/gtk:bg[NORMAL]/0.97" x1="4" y1="height-3" x2="width-5" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+	<include name="button_bg"/>
+	<tint color="shade/gtk:bg[SELECTED]/1.5" alpha="0.2" x="3" y="3" width="width-5" height="height-5"/>
+	<line color="shade/gtk:bg[SELECTED]/0.6" x1="width-3" y1="height-3" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="button_bg_pressed">
+	<!-- outside highlight -->
+	<gradient type="vertical" x="width-2" y="2" width="1" height="height-4">
+		<color value="shade/gtk:bg[SELECTED]/1.2"/>
+		<color value="shade/gtk:bg[SELECTED]/1.0"/>
+	</gradient>
+	<gradient type="vertical" x="width-1" y="3" width="1" height="height-6">
+		<color value="shade/gtk:bg[SELECTED]/1.2"/>
+		<color value="shade/gtk:bg[SELECTED]/1.0"/>
+	</gradient>
+	<line color="shade/gtk:bg[SELECTED]/1.0" x1="2" y1="height-2" x2="width-3" y2="height-2"/>
+	<line color="shade/gtk:bg[SELECTED]/1.0" x1="3" y1="height-1" x2="width-4" y2="height-1"/>
+
+	<!-- border outline -->
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="3" y1="1" x2="width-4" y2="1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="3" y1="height-2" x2="width-4" y2="height-2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="1" y1="3" x2="1" y2="height-4"/>
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="width-2" y1="3" x2="width-2" y2="height-4"/>
+
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="2" y1="2" x2="width-3" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.55" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+
+	<!-- inside shadow -->
+	<line color="shade/gtk:bg[SELECTED]/0.9" x1="3" y1="2" x2="width-4" y2="2"/>
+	<line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="3" x2="2" y2="height-4"/>
+
+	<!-- fill gradient -->
+	<gradient type="vertical" x="3" y="3" width="width-5" height="height-6">
+		<color value="shade/gtk:bg[SELECTED]/0.95"/>
+		<color value="shade/gtk:bg[SELECTED]/0.9"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[SELECTED]/0.9" x1="3" y1="height-3" x2="width-4" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="button_bg_unfocused_prelight">
+	<include name="button_bg_unfocused"/>
+	<tint color="shade/gtk:bg[NORMAL]/1.5" alpha="0.3" x="3" y="3" width="width-5" height="height-5"/>
+	<line color="shade/gtk:bg[NORMAL]/0.6" x1="width-3" y1="height-3" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="button_bg_unfocused_pressed">
+	<!-- outside highlight -->
+	<gradient type="vertical" x="width-2" y="2" width="1" height="height-4">
+		<color value="shade/gtk:bg[NORMAL]/1.25"/>
+		<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	</gradient>
+	<gradient type="vertical" x="width-1" y="3" width="1" height="height-6">
+		<color value="shade/gtk:bg[NORMAL]/1.25"/>
+		<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	</gradient>
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="2" y1="height-2" x2="width-3" y2="height-2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.05" x1="3" y1="height-1" x2="width-4" y2="height-1"/>
+
+	<!-- border outline -->
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="3" y1="1" x2="width-4" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="3" y1="height-2" x2="width-4" y2="height-2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="1" y1="3" x2="1" y2="height-4"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="width-2" y1="3" x2="width-2" y2="height-4"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="2" y1="2" x2="width-3" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.55" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+
+	<!-- inside shadow -->
+	<line color="shade/gtk:bg[NORMAL]/0.8" x1="3" y1="2" x2="width-4" y2="2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="2" y2="height-4"/>
+
+	<!-- fill gradient -->
+	<gradient type="vertical" x="3" y="3" width="width-5" height="height-6">
+		<color value="shade/gtk:bg[NORMAL]/0.9"/>
+		<color value="shade/gtk:bg[NORMAL]/0.85"/>
+	</gradient>
+
+	<line color="shade/gtk:bg[NORMAL]/0.85" x1="3" y1="height-3" x2="width-4" y2="height-3"/>
+</draw_ops>
+
+<!-- ::: ICONS ::: -->
+<!--
+	using a minimum icon size until there is a proper way to specify relative sizes
+	unfortunately it's logically impossible to always center the icons on non-square
+	buttons (utility windows) without distortion.
+
+	icon_size = (Bmin`max`height-Bpad*2)
+	hpadding = (width - icon_size) / 2 = ((width-(Bmin`max`height-Bpad*2))/2)
+	vpadding = (height - icon_size) / 2 = ((height-(Bmin`max`height-Bpad*2))/2)
+-->
+
+<!-- menu icon -->
+<draw_ops name="menu_button_icon">
+	<!--<icon  x="0" y="0" width="width" height="height"/>-->
+	<icon  x="(width-mini_icon_width)/2" y="(height-mini_icon_height)/2" width="mini_icon_width" height="mini_icon_height"/>
+</draw_ops>
+
+<draw_ops name="menu_button_icon_unfocused">
+	<!--<icon  x="0" y="0" width="width" height="height" alpha="0.5"/>-->
+	<icon  x="(width-mini_icon_width)/2" y="(height-mini_icon_height)/2" width="mini_icon_width" height="mini_icon_height"/>
+</draw_ops>
+
+<draw_ops name="menu_button_normal">
+	<include name="menu_button_icon"/>
+</draw_ops>
+<draw_ops name="menu_button_pressed">
+	<include name="menu_button_icon"/>
+</draw_ops>
+<draw_ops name="menu_button_unfocused">
+	<include name="menu_button_icon_unfocused"/>
+</draw_ops>
+
+<!-- close icon -->
+<draw_ops name="close_button_icon">
+	<!-- outside border -->
+
+	<!-- main cross  -->
+	<line color="shade/gtk:bg[SELECTED]/0.7" width="4"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="((height-(Bmin`max`height-Bpad*2))/2)"
+		x2="width - ((width-(Bmin`max`height-Bpad*2))/2) - 1" y2="height - ((height-(Bmin`max`height-Bpad*2))/2) - 1"/>
+	<line color="shade/gtk:bg[SELECTED]/0.7" width="4"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="height - ((height-(Bmin`max`height-Bpad*2))/2) - 1"
+		x2="width - ((width-(Bmin`max`height-Bpad*2))/2) - 1" y2="((height-(Bmin`max`height-Bpad*2))/2)"/>
+	<!-- top-left -->
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="((width-(Bmin`max`height-Bpad*2))/2)" y="((height-(Bmin`max`height-Bpad*2))/2)-1"
+		width="2" height="1"/>
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="((width-(Bmin`max`height-Bpad*2))/2)-1" y="((height-(Bmin`max`height-Bpad*2))/2)/1"
+		width="1" height="2"/>
+	<!-- top-right -->
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="width - ((width-(Bmin`max`height-Bpad*2))/2) -2" y="((height-(Bmin`max`height-Bpad*2))/2)-1"
+		width="2" height="1"/>
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="width - ((width-(Bmin`max`height-Bpad*2))/2)" y="((height-(Bmin`max`height-Bpad*2))/2)"
+		width="1" height="2"/>
+	<!-- bottom-left -->
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="((width-(Bmin`max`height-Bpad*2))/2)" y="height - ((height-(Bmin`max`height-Bpad*2))/2)"
+		width="2" height="1"/>
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="((width-(Bmin`max`height-Bpad*2))/2)-1" y="height - ((height-(Bmin`max`height-Bpad*2))/2)-2"
+		width="1" height="2"/>
+	<!-- bottom-right -->
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="width - ((width-(Bmin`max`height-Bpad*2))/2) -2" y="height - ((height-(Bmin`max`height-Bpad*2))/2)"
+		width="2" height="1"/>
+	<tint color="shade/gtk:bg[SELECTED]/0.7" alpha="1.0"
+		x="width - ((width-(Bmin`max`height-Bpad*2))/2)" y="height - ((height-(Bmin`max`height-Bpad*2))/2)-2"
+		width="1" height="2"/>
+
+	<!-- icon -->
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="2"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="((height-(Bmin`max`height-Bpad*2))/2)"
+		x2="width - ((width-(Bmin`max`height-Bpad*2))/2) - 1" y2="height - ((height-(Bmin`max`height-Bpad*2))/2) - 1"/>
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="((height-(Bmin`max`height-Bpad*2))/2)"
+		x2="width- ((width-(Bmin`max`height-Bpad*2))/2)" y2="height - ((height-(Bmin`max`height-Bpad*2))/2)"/>
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="2"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="height - ((height-(Bmin`max`height-Bpad*2))/2) - 1"
+		x2="width - ((width-(Bmin`max`height-Bpad*2))/2) - 1" y2="((height-(Bmin`max`height-Bpad*2))/2)"/>
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="height - ((height-(Bmin`max`height-Bpad*2))/2) - 1"
+		x2="width - ((width-(Bmin`max`height-Bpad*2))/2)" y2="((height-(Bmin`max`height-Bpad*2))/2) - 1"/>
+</draw_ops>
+
+<draw_ops name="close_button_icon_unfocused">
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="2"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="((height-(Bmin`max`height-Bpad*2))/2)"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2)-1" y2="height - ((height-(Bmin`max`height-Bpad*2))/2)-1"/>
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="((height-(Bmin`max`height-Bpad*2))/2)"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2)" y2="height - ((height-(Bmin`max`height-Bpad*2))/2)"/>
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="2"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="height - ((height-(Bmin`max`height-Bpad*2))/2)-1"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2)-1" y2="((height-(Bmin`max`height-Bpad*2))/2)"/>
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2)" y1="height - ((height-(Bmin`max`height-Bpad*2))/2)-1"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2)" y2="((height-(Bmin`max`height-Bpad*2))/2) - 1"/>
+</draw_ops>
+
+<draw_ops name="close_button_normal">
+	<include name="button_bg"/>
+	<include name="close_button_icon"/>
+</draw_ops>
+<draw_ops name="close_button_prelight">
+	<include name="button_bg_prelight"/>
+	<include name="close_button_icon"/>
+</draw_ops>
+<draw_ops name="close_button_pressed">
+	<include name="button_bg_pressed"/>
+	<include name="close_button_icon"/>
+</draw_ops>
+<draw_ops name="close_button_unfocused">
+	<include name="button_bg_unfocused"/>
+	<include name="close_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="close_button_unfocused_prelight">
+	<include name="button_bg_unfocused_prelight"/>
+	<include name="close_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="close_button_unfocused_pressed">
+	<include name="button_bg_unfocused_pressed"/>
+	<include name="close_button_icon_unfocused"/>
+</draw_ops>
+
+<!-- maximize icon -->
+<draw_ops name="maximize_button_icon">
+	<!-- outside border -->
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)-1" y="((height-(Bmin`max`height-Bpad*2))/2)-1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2+1" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2+1"/>
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)+1" y="((height-(Bmin`max`height-Bpad*2))/2)+2"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-3" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-4"/>
+
+	<!-- icon -->
+	<rectangle color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)" y="((height-(Bmin`max`height-Bpad*2))/2)"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-1" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-1"/>
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 1" y1="((height-(Bmin`max`height-Bpad*2))/2) + 1"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2)" y2="((height-(Bmin`max`height-Bpad*2))/2) + 1"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_icon_unfocused">
+	<rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)" y="((height-(Bmin`max`height-Bpad*2))/2)"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-1" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-1"/>
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 1" y1="((height-(Bmin`max`height-Bpad*2))/2) + 1"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2)" y2="((height-(Bmin`max`height-Bpad*2))/2) + 1"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_normal">
+	<include name="button_bg"/>
+	<include name="maximize_button_icon"/>
+</draw_ops>
+<draw_ops name="maximize_button_prelight">
+	<include name="button_bg_prelight"/>
+	<include name="maximize_button_icon"/>
+</draw_ops>
+<draw_ops name="maximize_button_pressed">
+	<include name="button_bg_pressed"/>
+	<include name="maximize_button_icon"/>
+</draw_ops>
+<draw_ops name="maximize_button_unfocused">
+	<include name="button_bg_unfocused"/>
+	<include name="maximize_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="maximize_button_unfocused_prelight">
+	<include name="button_bg_unfocused_prelight"/>
+	<include name="maximize_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="maximize_button_unfocused_pressed">
+	<include name="button_bg_unfocused_pressed"/>
+	<include name="maximize_button_icon_unfocused"/>
+</draw_ops>
+
+<!-- restore icon -->
+<draw_ops name="restore_button_icon">
+	<!-- outside border -->
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)-1" y="((height-(Bmin`max`height-Bpad*2))/2)-1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-1" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-1"/>
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)+2-1" y="((height-(Bmin`max`height-Bpad*2))/2)+3-1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-5" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-6"/>
+
+	
+	<!-- icon -->
+	<rectangle color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2) + 1" y="((height-(Bmin`max`height-Bpad*2))/2) + 1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-3" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-3"/>
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 2" y1="((height-(Bmin`max`height-Bpad*2))/2) + 2"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2) - 2" y2="((height-(Bmin`max`height-Bpad*2))/2) + 2"/>
+
+
+	<!-- second window (perberos was here!) -->
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2) +1"
+		y="((height-(Bmin`max`height-Bpad*2))/2) +1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-1"
+		height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-1"/>
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)+2+1"
+		y="((height-(Bmin`max`height-Bpad*2))/2)+3+1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-5"
+		height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-6"/>
+	<rectangle color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2) + 1+1"
+		y="((height-(Bmin`max`height-Bpad*2))/2) + 1+1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-3"
+		height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-3"/>
+	<line color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 2+1"
+		y1="((height-(Bmin`max`height-Bpad*2))/2) + 2+1"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2) - 2+1"
+		y2="((height-(Bmin`max`height-Bpad*2))/2) + 2+1"/>
+	<!-- / second window at the icon button (perberos was here!) -->
+</draw_ops>
+
+<draw_ops name="restore_button_icon_unfocused">
+	<rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2) + 1+1" y="((height-(Bmin`max`height-Bpad*2))/2) + 1+1"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2-3" height="height-((height-(Bmin`max`height-Bpad*2))/2)*2-3"/>
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 2+1" y1="((height-(Bmin`max`height-Bpad*2))/2) + 2+1"
+		x2="width-((width-(Bmin`max`height-Bpad*2))/2) - 2+1" y2="((height-(Bmin`max`height-Bpad*2))/2) + 2+1"/>
+	
+	<!-- second window at the icon button (perberos was here!) -->
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1"
+		y1="((height-(Bmin`max`height-Bpad*2))/2) +1 - 1"
+		x2="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1 +
+			width-((width-(Bmin`max`height-Bpad*2))/2)*2-3"
+		y2="((height-(Bmin`max`height-Bpad*2))/2) +1 - 1"/>
+	
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1 +
+			width-((width-(Bmin`max`height-Bpad*2))/2)*2-3"
+		y1="((height-(Bmin`max`height-Bpad*2))/2) +1- 1"
+		x2="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1 +
+			width-((width-(Bmin`max`height-Bpad*2))/2)*2-3"
+		y2="((height-(Bmin`max`height-Bpad*2))/2) +1- 1 +
+			(height-((height-(Bmin`max`height-Bpad*2))/2)*2-3) / 2"/>
+	
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 1-  1"
+		y1="((height-(Bmin`max`height-Bpad*2))/2) +1 - 1"
+		x2="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1"
+		y2="((height-(Bmin`max`height-Bpad*2))/2) +1 - 1 +
+			height-((height-(Bmin`max`height-Bpad*2))/2)*2-3"/>
+		
+	<line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" width="1"
+		x1="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1"
+		y1="((height-(Bmin`max`height-Bpad*2))/2) +1 - 1 +
+			height-((height-(Bmin`max`height-Bpad*2))/2)*2-3"
+		x2="((width-(Bmin`max`height-Bpad*2))/2) + 1 - 1 +
+			(width-((width-(Bmin`max`height-Bpad*2))/2)*2-3) / 2"
+		y2="((height-(Bmin`max`height-Bpad*2))/2) +1 - 1 +
+			height-((height-(Bmin`max`height-Bpad*2))/2)*2-3"/>
+	<!-- / second window at the icon button (perberos was here!) -->
+</draw_ops>
+
+<draw_ops name="restore_button_normal">
+	<include name="button_bg"/>
+	<include name="restore_button_icon"/>
+</draw_ops>
+<draw_ops name="restore_button_prelight">
+	<include name="button_bg_prelight"/>
+	<include name="restore_button_icon"/>
+</draw_ops>
+<draw_ops name="restore_button_pressed">
+	<include name="button_bg_pressed"/>
+	<include name="restore_button_icon"/>
+</draw_ops>
+<draw_ops name="restore_button_unfocused">
+	<include name="button_bg_unfocused"/>
+	<include name="restore_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="restore_button_unfocused_prelight">
+	<include name="button_bg_unfocused_prelight"/>
+	<include name="restore_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="restore_button_unfocused_pressed">
+	<include name="button_bg_unfocused_pressed"/>
+	<include name="restore_button_icon_unfocused"/>
+</draw_ops>
+
+<!-- minimize icon -->
+<draw_ops name="minimize_button_icon">
+	<!-- outside border -->
+	<rectangle color="shade/gtk:bg[SELECTED]/0.7" filled="false"
+		x="((width-(Bmin`max`height-Bpad*2))/2)-1" y="height - ((height-(Bmin`max`height-Bpad*2))/2) - 3"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2+1" height="3"/>
+	<!-- icon -->
+	<rectangle color="blend/gtk:bg[SELECTED]/#FFFFFF/0.75" filled="true"
+		x="((width-(Bmin`max`height-Bpad*2))/2)" y="height - ((height-(Bmin`max`height-Bpad*2))/2) - 2"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2" height="2"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_icon_unfocused">
+	<rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.45" filled="true"
+		x="((width-(Bmin`max`height-Bpad*2))/2)" y="height - ((height-(Bmin`max`height-Bpad*2))/2) - 2"
+		width="width-((width-(Bmin`max`height-Bpad*2))/2)*2" height="2"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_normal">
+	<include name="button_bg"/>
+	<include name="minimize_button_icon"/>
+</draw_ops>
+<draw_ops name="minimize_button_prelight">
+	<include name="button_bg_prelight"/>
+	<include name="minimize_button_icon"/>
+</draw_ops>
+<draw_ops name="minimize_button_pressed">
+	<include name="button_bg_pressed"/>
+	<include name="minimize_button_icon"/>
+</draw_ops>
+<draw_ops name="minimize_button_unfocused">
+	<include name="button_bg_unfocused"/>
+	<include name="minimize_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="minimize_button_unfocused_prelight">
+	<include name="button_bg_unfocused_prelight"/>
+	<include name="minimize_button_icon_unfocused"/>
+</draw_ops>
+<draw_ops name="minimize_button_unfocused_pressed">
+	<include name="button_bg_unfocused_pressed"/>
+	<include name="minimize_button_icon_unfocused"/>
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<!-- ::: FRAME STYLES ::: -->
+<frame_style name="normal" geometry="normal">
+	<piece position="entire_background" draw_ops="round_bevel_unfocused"/>
+	<piece position="title" draw_ops="title_unfocused"/>
+	<button function="close" state="normal" draw_ops="close_button_unfocused"/>
+	<button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+	<button function="close" state="prelight" draw_ops="close_button_unfocused_prelight"/>
+	<button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+	<button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+	<button function="maximize" state="prelight" draw_ops="maximize_button_unfocused_prelight"/>
+	<button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+	<button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+	<button function="minimize" state="prelight" draw_ops="minimize_button_unfocused_prelight"/>
+	<button function="menu" state="normal" draw_ops="menu_button_normal"/>
+	<button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+</frame_style>
+
+<frame_style name="normal_shaded" geometry="shaded" parent="normal">
+	<piece position="entire_background" draw_ops="round_bevel_unfocused_shaded"/>
+</frame_style>
+
+<frame_style name="focused" geometry="normal" parent="normal">
+	<piece position="entire_background" draw_ops="round_bevel"/>
+	<piece position="title" draw_ops="title"/>
+	<button function="close" state="normal" draw_ops="close_button_normal"/>
+	<button function="close" state="pressed" draw_ops="close_button_pressed"/>
+	<button function="close" state="prelight" draw_ops="close_button_prelight"/>
+	<button function="maximize" state="normal" draw_ops="maximize_button_normal"/>
+	<button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+	<button function="maximize" state="prelight" draw_ops="maximize_button_prelight"/>
+	<button function="minimize" state="normal" draw_ops="minimize_button_normal"/>
+	<button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+	<button function="minimize" state="prelight" draw_ops="minimize_button_prelight"/>
+</frame_style>
+
+<frame_style name="focused_shaded" geometry="shaded" parent="focused">
+	<piece position="entire_background" draw_ops="round_bevel_shaded"/>
+</frame_style>
+
+<frame_style name="normal_maximized" geometry="normal_maximized" parent="normal">
+	<piece position="entire_background" draw_ops="bevel_maximized_unfocused"/>
+	<button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+	<button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+	<button function="maximize" state="prelight" draw_ops="restore_button_unfocused_prelight"/>
+</frame_style>
+
+<frame_style name="focused_maximized" geometry="normal_maximized" parent="focused">
+	<piece position="entire_background" draw_ops="bevel_maximized"/>
+	<button function="maximize" state="normal" draw_ops="restore_button_normal"/>
+	<button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+	<button function="maximize" state="prelight" draw_ops="restore_button_prelight"/>
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal">
+	<piece position="entire_background" draw_ops="border"/>
+	<piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style name="utility_normal" geometry="utility" parent="normal">
+	<piece position="entire_background" draw_ops="bevel_unfocused"/>
+</frame_style>
+<frame_style name="utility_focused" geometry="utility" parent="focused">
+	<piece position="entire_background" draw_ops="bevel"/>
+</frame_style>
+<frame_style name="utility_focused_shaded" geometry="utility" parent="focused_shaded">
+	<piece position="entire_background" draw_ops="bevel_shaded"/>
+</frame_style>
+
+<frame_style_set name="normal">
+	<frame focus="yes" state="normal" resize="both" style="focused"/>
+	<frame focus="no" state="normal" resize="both" style="normal"/>
+	<frame focus="yes" state="maximized" style="focused_maximized"/>
+	<frame focus="no" state="maximized" style="normal_maximized"/>
+	<frame focus="yes" state="shaded" style="focused_shaded"/>
+	<frame focus="no" state="shaded" style="normal_shaded"/>
+	<frame focus="yes" state="maximized_and_shaded" style="focused_maximized"/>
+	<frame focus="no" state="maximized_and_shaded" style="normal_maximized"/>
+</frame_style_set>
+
+<frame_style_set name="utility" parent="normal">
+	<frame focus="yes" state="normal" resize="both" style="utility_focused"/>
+	<frame focus="no" state="normal" resize="both" style="utility_normal"/>
+	<!-- this is a bunch of crack since utility windows shouldn't be maximized -->
+	<frame focus="yes" state="maximized" style="focused"/>
+	<frame focus="no" state="maximized" style="normal"/>
+	<frame focus="yes" state="shaded" style="utility_focused_shaded"/>
+	<frame focus="no" state="shaded" style="utility_normal"/>
+	<frame focus="yes" state="maximized_and_shaded" style="focused_shaded"/>
+	<frame focus="no" state="maximized_and_shaded" style="normal"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+	<frame focus="yes" state="normal" resize="both" style="border"/>
+	<frame focus="no" state="normal" resize="both" style="border"/>
+	<frame focus="yes" state="maximized" style="border"/>
+	<frame focus="no" state="maximized" style="border"/>
+	<frame focus="yes" state="shaded" style="border"/>
+	<frame focus="no" state="shaded" style="border"/>
+	<frame focus="yes" state="maximized_and_shaded" style="border"/>
+	<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="utility"/>
+<window type="border" style_set="border"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button_icon_unfocused"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button_icon_unfocused"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button_icon_unfocused"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button_icon_unfocused"/>
+
+</metacity_theme>
diff --git a/src/themes/Dopple-Left/metacity-theme-1.xml b/src/themes/Dopple-Left/metacity-theme-1.xml
new file mode 100644
index 00000000..ec933ca9
--- /dev/null
+++ b/src/themes/Dopple-Left/metacity-theme-1.xml
@@ -0,0 +1,1135 @@
+<?xml version="1.0"?>
+<metacity_theme>
+
+<info>
+  <name>Dopple</name>
+  <author>Brandon Wright</author>
+  <copyright>2009</copyright>
+  <date>January 21, 2009</date>
+  <description>A Clearlooks-styled theme with Tango basics.</description>
+</info>
+
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true">
+  <distance name="left_width" value="3"/>
+  <distance name="right_width" value="3"/>
+  <distance name="bottom_height" value="3"/>
+  <distance name="left_titlebar_edge" value="4"/>
+  <distance name="right_titlebar_edge" value="4"/>
+  <aspect_ratio name="button" value="1"/>
+  <distance name="title_vertical_pad" value="2"/>
+  <border name="title_border" left="3" right="4" top="2" bottom="2"/>
+  <border name="button_border" left="1" right="1" top="3" bottom="3"/>
+</frame_geometry>
+
+<frame_geometry name="normal_small_borders" parent="normal" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_titlebar_edge" value="1" />
+  <distance name="right_titlebar_edge" value="1" />
+  <distance name="left_width" value="0" />
+  <distance name="right_width" value="0" />
+  <distance name="bottom_height" value="0" />
+</frame_geometry>
+
+<frame_geometry name="utility" parent="normal">
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="0"/>
+  <distance name="right_titlebar_edge" value="0"/>
+  <distance name="button_width" value="0"/>
+  <distance name="button_height" value="0"/>
+  <distance name="title_vertical_pad" value="4"/>
+  <border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  <border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Buttons -->
+<draw_ops name="button_bg_unfocused">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.90" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.15" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" /> -->
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+<!--    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient> -->
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.00" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<!-- Buttons -->
+<draw_ops name="button_bg">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" /> -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/0.8" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" /> -->
+
+    <gradient type="vertical" x="width-1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/0.8" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+    
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.22" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.07" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.22" />
+        <color value="shade/gtk:bg[SELECTED]/1.07" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.22" />
+        <color value="shade/gtk:bg[SELECTED]/1.07" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/0.975" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/0.975" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[SELECTED]/1.15" />
+        <color value="shade/gtk:bg[SELECTED]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.25" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.25" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[SELECTED]/0.95" />
+        <color value="shade/gtk:bg[SELECTED]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" /> -->
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+<!--    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.25" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient> -->
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.00" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="menu_glyph">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" />
+</draw_ops>
+
+<draw_ops name="menu_glyph_unfocused">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" alpha="0.5"/>
+</draw_ops>
+
+<draw_ops name="close_glyph">
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="white" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow">
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow_dark">
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused_lighter">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph">
+    <rectangle color="white" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="white" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="white" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+<draw_ops name="maximize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_unfocused">
+  <rectangle color="gtk:fg[NORMAL]" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+<draw_ops name="maximize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+
+
+</draw_ops>
+
+<draw_ops name="minimize_glyph">
+    <rectangle color="white" x="2" y="height * 2 / 3" width="width-4" height="height - height * 2 / 3 - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused">
+    <rectangle color="gtk:fg[NORMAL]" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="menu_button">
+    <include name="menu_glyph" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="menu_button_unfocused">
+    <include name="menu_glyph_unfocused" x="0" y="0" />
+</draw_ops>
+
+<draw_ops name="menu_button_pressed">
+    <include name="menu_glyph_unfocused" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="minimize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4" />
+</draw_ops>
+
+<draw_ops name="minimize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+
+<draw_ops name="maximize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="mini_window_icon">
+  <rectangle color="gtk:bg[NORMAL]" filled="true"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <rectangle color="gtk:fg[NORMAL]" filled="false"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <line color="gtk:fg[NORMAL]" width="2"
+        x1="0" y1="1" x2="width" y2="1"/>
+</draw_ops>
+
+<draw_ops name="restore_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+	<include name="maximize_glyph_shadow" x="3" y="5" width="width-6" height="height-6" />
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_prelight">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="3" y="5" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="close_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow" x="2" y="4" width="width-4" height="height-4" />
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel">
+  <rectangle color="shade/gtk:bg[NORMAL]/0.5"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel_unfocused">  
+  <rectangle color="shade/gtk:bg[NORMAL]/0.7"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="title_background">
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+<!--
+    <rectangle color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+-->
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+
+    <gradient type="vertical" x="2" y="2" width="width-4" height="height-3">
+        <color value="shade/gtk:bg[SELECTED]/1.1"/>
+	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient> 
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="3" y1="height-1"
+        x2="width-4" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.975"
+        x1="2" y1="height-2"
+        x2="width-3" y2="height-2" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="4" y1="1" x2="4" y2="1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+<!--
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="2" y1="3" x2="2" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-5" y1="2" x2="width-4" y2="2" />
+-->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+  <!--  <gradient type="vertical" x="1" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="1" y1="height-1" x2="1" y2="height-1" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="height-1" x2="width-2" y2="height-1" />
+</draw_ops>
+
+<draw_ops name="title_background_maximized">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-2" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-1" y1="1" x2="width-1" y2="height-2"/>
+    
+    <gradient type="vertical" x="1" y="2" width="width-2" height="height-3">
+    	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient>
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-1" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="0" y1="height-1"
+        x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.95"
+        x1="0" y1="height-2"
+        x2="width-1" y2="height-2" />
+
+<!--    <gradient type="vertical" x="0" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-1" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+</draw_ops>
+
+<draw_ops name="title_unfocused_background">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="1" y1="height-2" x2="width-3" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="width-2" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="1" y2="height-1"/>
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-2" y1="1" x2="width-2" y2="height" />
+
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="4" y1="1" x2="4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="3" y1="2" x2="4" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+
+</draw_ops>
+
+<draw_ops name="title_unfocused_background_maximized">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="0" y="1" width="width" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="0" y1="height-2" x2="width-1" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="0" y1="1" x2="width-1" y2="1"/>
+
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<draw_ops name="focus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[SELECTED]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[SELECTED]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[SELECTED]/0.7" />
+</draw_ops>
+
+<draw_ops name="unfocus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[NORMAL]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[NORMAL]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[NORMAL]/0.7" />
+</draw_ops>
+
+<draw_ops name="focus_background">
+  <include name="focus_outline"/>
+</draw_ops>
+
+<draw_ops name="unfocus_background">
+  <include name="unfocus_outline" />
+</draw_ops>
+
+<draw_ops name="title_text_focused_with_icon">
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) - 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+
+     
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) - 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) + 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) + 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+        
+    <title color="#ffffff"
+           x="0"
+           y="(((height - title_height) / 2) `max` 0)"/>
+ 
+</draw_ops>
+
+<draw_ops name="title_text_with_icon">
+    <title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.4"
+           x="(0)"
+           y="((height - title_height) / 2) `max` 0"/> 
+</draw_ops>
+
+<draw_ops name="title_normal">
+  <include name="title_text_with_icon"/>
+</draw_ops>
+
+<draw_ops name="title_focused">
+  <include name="title_text_focused_with_icon"/>
+</draw_ops>
+
+<frame_style name="normal_unfocused" geometry="normal">
+    <piece position="entire_background" draw_ops="unfocus_background"/>
+    <piece position="titlebar" draw_ops="title_unfocused_background"/>
+    <piece position="title" draw_ops="title_normal"/>
+
+  <button function="close" state="normal" draw_ops="close_button_unfocused"/>
+  <button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+  <button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+  <button function="menu" state="normal" draw_ops="menu_button_unfocused"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_unfocused"/>
+</frame_style>
+
+<frame_style name="normal_focused" geometry="normal">
+  <piece position="entire_background" draw_ops="focus_background"/>
+  <piece position="titlebar" draw_ops="title_background"/>  
+  <piece position="title" draw_ops="title_focused"/>
+  <button function="close" state="normal" draw_ops="close_button"/>
+  <button function="close" state="pressed" draw_ops="close_button_pressed"/>
+  <button function="close" state="prelight" draw_ops="close_button_focus"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+  <button function="minimize" state="prelight" draw_ops="minimize_button_focus" />
+  <button function="maximize" state="normal" draw_ops="maximize_button"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="maximize_button_focus"/>
+  <button function="menu" state="normal" draw_ops="menu_button"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="normal_small_borders" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="blank"/>
+  <piece position="titlebar" draw_ops="title_unfocused_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="normal_small_borders" parent="normal_focused">
+  <piece position="entire_background" draw_ops="focus_outline"/>
+  <piece position="titlebar" draw_ops="title_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="restore_button_prelight" />
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="outer_bevel"/>
+  <piece position="titlebar" draw_ops="blank"/>
+  <piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style_set name="normal">
+<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+<frame focus="yes" state="maximized" style="maximized_focused"/>
+<frame focus="no" state="maximized" style="maximized_unfocused"/>
+<frame focus="yes" state="shaded" style="normal_focused"/>
+<frame focus="no" state="shaded" style="normal_unfocused"/>
+<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/>
+<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+<frame focus="yes" state="normal" resize="both" style="border"/>
+<frame focus="no" state="normal" resize="both" style="border"/>
+<frame focus="yes" state="maximized" style="border"/>
+<frame focus="no" state="maximized" style="border"/>
+<frame focus="yes" state="shaded" style="border"/>
+<frame focus="no" state="shaded" style="border"/>
+<frame focus="yes" state="maximized_and_shaded" style="border"/>
+<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="normal"/>
+<window type="border" style_set="normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button"/>
+
+</metacity_theme>
diff --git a/src/themes/Dopple/metacity-theme-1.xml b/src/themes/Dopple/metacity-theme-1.xml
new file mode 100644
index 00000000..ef3299ae
--- /dev/null
+++ b/src/themes/Dopple/metacity-theme-1.xml
@@ -0,0 +1,1135 @@
+<?xml version="1.0"?>
+<metacity_theme>
+
+<info>
+  <name>Dopple</name>
+  <author>Brandon Wright</author>
+  <copyright>2009</copyright>
+  <date>January 21, 2009</date>
+  <description>A Clearlooks-styled theme with Tango basics.</description>
+</info>
+
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true">
+  <distance name="left_width" value="3"/>
+  <distance name="right_width" value="3"/>
+  <distance name="bottom_height" value="3"/>
+  <distance name="left_titlebar_edge" value="4"/>
+  <distance name="right_titlebar_edge" value="4"/>
+  <aspect_ratio name="button" value="1"/>
+  <distance name="title_vertical_pad" value="2"/>
+  <border name="title_border" left="3" right="4" top="2" bottom="2"/>
+  <border name="button_border" left="1" right="1" top="3" bottom="3"/>
+</frame_geometry>
+
+<frame_geometry name="normal_small_borders" parent="normal" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_titlebar_edge" value="1" />
+  <distance name="right_titlebar_edge" value="1" />
+  <distance name="left_width" value="0" />
+  <distance name="right_width" value="0" />
+  <distance name="bottom_height" value="0" />
+</frame_geometry>
+
+<frame_geometry name="utility" parent="normal">
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="0"/>
+  <distance name="right_titlebar_edge" value="0"/>
+  <distance name="button_width" value="0"/>
+  <distance name="button_height" value="0"/>
+  <distance name="title_vertical_pad" value="4"/>
+  <border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  <border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Buttons -->
+<draw_ops name="button_bg_unfocused">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.90" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.15" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" /> -->
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+<!--    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient> -->
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.00" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<!-- Buttons -->
+<draw_ops name="button_bg">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" /> -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/0.8" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" /> -->
+
+    <gradient type="vertical" x="width-1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/0.8" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+    
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.22" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.07" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.22" />
+        <color value="shade/gtk:bg[SELECTED]/1.07" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.22" />
+        <color value="shade/gtk:bg[SELECTED]/1.07" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/0.975" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/0.975" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[SELECTED]/1.15" />
+        <color value="shade/gtk:bg[SELECTED]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.25" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient>
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.25" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[SELECTED]/0.95" />
+        <color value="shade/gtk:bg[SELECTED]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" /> -->
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[SELECTED]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+<!--    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.25" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient> -->
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[SELECTED]/1.00" />
+        <color value="shade/gtk:bg[SELECTED]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="menu_glyph">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" />
+</draw_ops>
+
+<draw_ops name="menu_glyph_unfocused">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" alpha="0.5"/>
+</draw_ops>
+
+<draw_ops name="close_glyph">
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="white" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow">
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow_dark">
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused_lighter">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph">
+    <rectangle color="white" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="white" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="white" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+<draw_ops name="maximize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_unfocused">
+  <rectangle color="gtk:fg[NORMAL]" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+<draw_ops name="maximize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+
+
+</draw_ops>
+
+<draw_ops name="minimize_glyph">
+    <rectangle color="white" x="2" y="height * 2 / 3" width="width-4" height="height - height * 2 / 3 - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused">
+    <rectangle color="gtk:fg[NORMAL]" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="menu_button">
+    <include name="menu_glyph" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="menu_button_unfocused">
+    <include name="menu_glyph_unfocused" x="0" y="0" />
+</draw_ops>
+
+<draw_ops name="menu_button_pressed">
+    <include name="menu_glyph_unfocused" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="minimize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4" />
+</draw_ops>
+
+<draw_ops name="minimize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+
+<draw_ops name="maximize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="mini_window_icon">
+  <rectangle color="gtk:bg[NORMAL]" filled="true"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <rectangle color="gtk:fg[NORMAL]" filled="false"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <line color="gtk:fg[NORMAL]" width="2"
+        x1="0" y1="1" x2="width" y2="1"/>
+</draw_ops>
+
+<draw_ops name="restore_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+	<include name="maximize_glyph_shadow" x="3" y="5" width="width-6" height="height-6" />
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_prelight">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="3" y="5" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="close_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow" x="2" y="4" width="width-4" height="height-4" />
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel">
+  <rectangle color="shade/gtk:bg[NORMAL]/0.5"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel_unfocused">  
+  <rectangle color="shade/gtk:bg[NORMAL]/0.7"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="title_background">
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+<!--
+    <rectangle color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+-->
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+
+    <gradient type="vertical" x="2" y="2" width="width-4" height="height-3">
+        <color value="shade/gtk:bg[SELECTED]/1.1"/>
+	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient> 
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="3" y1="height-1"
+        x2="width-4" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.975"
+        x1="2" y1="height-2"
+        x2="width-3" y2="height-2" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="4" y1="1" x2="4" y2="1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+<!--
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="2" y1="3" x2="2" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-5" y1="2" x2="width-4" y2="2" />
+-->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+  <!--  <gradient type="vertical" x="1" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="1" y1="height-1" x2="1" y2="height-1" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="height-1" x2="width-2" y2="height-1" />
+</draw_ops>
+
+<draw_ops name="title_background_maximized">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-2" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-1" y1="1" x2="width-1" y2="height-2"/>
+    
+    <gradient type="vertical" x="1" y="2" width="width-2" height="height-3">
+    	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient>
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-1" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="0" y1="height-1"
+        x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.95"
+        x1="0" y1="height-2"
+        x2="width-1" y2="height-2" />
+
+<!--    <gradient type="vertical" x="0" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-1" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+</draw_ops>
+
+<draw_ops name="title_unfocused_background">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="1" y1="height-2" x2="width-3" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="width-2" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="1" y2="height-1"/>
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-2" y1="1" x2="width-2" y2="height" />
+
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="4" y1="1" x2="4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="3" y1="2" x2="4" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+
+</draw_ops>
+
+<draw_ops name="title_unfocused_background_maximized">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="0" y="1" width="width" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="0" y1="height-2" x2="width-1" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="0" y1="1" x2="width-1" y2="1"/>
+
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<draw_ops name="focus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[SELECTED]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[SELECTED]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[SELECTED]/0.7" />
+</draw_ops>
+
+<draw_ops name="unfocus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[NORMAL]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[NORMAL]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[NORMAL]/0.7" />
+</draw_ops>
+
+<draw_ops name="focus_background">
+  <include name="focus_outline"/>
+</draw_ops>
+
+<draw_ops name="unfocus_background">
+  <include name="unfocus_outline" />
+</draw_ops>
+
+<draw_ops name="title_text_focused_with_icon">
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) - 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+
+     
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) - 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) + 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) + 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+        
+    <title color="#ffffff"
+           x="(((width  - title_width)  / 2) `max` 0)"
+           y="(((height - title_height) / 2) `max` 0)"/>
+ 
+</draw_ops>
+
+<draw_ops name="title_text_with_icon">
+    <title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.4"
+           x="(((width - title_width)  / 2) `max` 0)"
+           y="((height - title_height) / 2) `max` 0"/> 
+</draw_ops>
+
+<draw_ops name="title_normal">
+  <include name="title_text_with_icon"/>
+</draw_ops>
+
+<draw_ops name="title_focused">
+  <include name="title_text_focused_with_icon"/>
+</draw_ops>
+
+<frame_style name="normal_unfocused" geometry="normal">
+    <piece position="entire_background" draw_ops="unfocus_background"/>
+    <piece position="titlebar" draw_ops="title_unfocused_background"/>
+    <piece position="title" draw_ops="title_normal"/>
+
+  <button function="close" state="normal" draw_ops="close_button_unfocused"/>
+  <button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+  <button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+  <button function="menu" state="normal" draw_ops="menu_button_unfocused"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_unfocused"/>
+</frame_style>
+
+<frame_style name="normal_focused" geometry="normal">
+  <piece position="entire_background" draw_ops="focus_background"/>
+  <piece position="titlebar" draw_ops="title_background"/>  
+  <piece position="title" draw_ops="title_focused"/>
+  <button function="close" state="normal" draw_ops="close_button"/>
+  <button function="close" state="pressed" draw_ops="close_button_pressed"/>
+  <button function="close" state="prelight" draw_ops="close_button_focus"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+  <button function="minimize" state="prelight" draw_ops="minimize_button_focus" />
+  <button function="maximize" state="normal" draw_ops="maximize_button"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="maximize_button_focus"/>
+  <button function="menu" state="normal" draw_ops="menu_button"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="normal_small_borders" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="blank"/>
+  <piece position="titlebar" draw_ops="title_unfocused_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="normal_small_borders" parent="normal_focused">
+  <piece position="entire_background" draw_ops="focus_outline"/>
+  <piece position="titlebar" draw_ops="title_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="restore_button_prelight" />
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="outer_bevel"/>
+  <piece position="titlebar" draw_ops="blank"/>
+  <piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style_set name="normal">
+<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+<frame focus="yes" state="maximized" style="maximized_focused"/>
+<frame focus="no" state="maximized" style="maximized_unfocused"/>
+<frame focus="yes" state="shaded" style="normal_focused"/>
+<frame focus="no" state="shaded" style="normal_unfocused"/>
+<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/>
+<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+<frame focus="yes" state="normal" resize="both" style="border"/>
+<frame focus="no" state="normal" resize="both" style="border"/>
+<frame focus="yes" state="maximized" style="border"/>
+<frame focus="no" state="maximized" style="border"/>
+<frame focus="yes" state="shaded" style="border"/>
+<frame focus="no" state="shaded" style="border"/>
+<frame focus="yes" state="maximized_and_shaded" style="border"/>
+<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="normal"/>
+<window type="border" style_set="normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button"/>
+
+</metacity_theme>
diff --git a/src/themes/DustBlue/button_close_normal.png b/src/themes/DustBlue/button_close_normal.png
new file mode 100644
index 00000000..3dbfb0e2
--- /dev/null
+++ b/src/themes/DustBlue/button_close_normal.png
diff --git a/src/themes/DustBlue/button_close_prelight.png b/src/themes/DustBlue/button_close_prelight.png
new file mode 100644
index 00000000..704de834
--- /dev/null
+++ b/src/themes/DustBlue/button_close_prelight.png
diff --git a/src/themes/DustBlue/button_close_pressed.png b/src/themes/DustBlue/button_close_pressed.png
new file mode 100644
index 00000000..4f2263fb
--- /dev/null
+++ b/src/themes/DustBlue/button_close_pressed.png
diff --git a/src/themes/DustBlue/button_max_normal.png b/src/themes/DustBlue/button_max_normal.png
new file mode 100644
index 00000000..8bf2f347
--- /dev/null
+++ b/src/themes/DustBlue/button_max_normal.png
diff --git a/src/themes/DustBlue/button_max_prelight.png b/src/themes/DustBlue/button_max_prelight.png
new file mode 100644
index 00000000..c549bb79
--- /dev/null
+++ b/src/themes/DustBlue/button_max_prelight.png
diff --git a/src/themes/DustBlue/button_max_pressed.png b/src/themes/DustBlue/button_max_pressed.png
new file mode 100644
index 00000000..4fe6439c
--- /dev/null
+++ b/src/themes/DustBlue/button_max_pressed.png
diff --git a/src/themes/DustBlue/button_menu_normal.png b/src/themes/DustBlue/button_menu_normal.png
new file mode 100644
index 00000000..28600199
--- /dev/null
+++ b/src/themes/DustBlue/button_menu_normal.png
diff --git a/src/themes/DustBlue/button_menu_prelight.png b/src/themes/DustBlue/button_menu_prelight.png
new file mode 100644
index 00000000..d16d92dc
--- /dev/null
+++ b/src/themes/DustBlue/button_menu_prelight.png
diff --git a/src/themes/DustBlue/button_menu_pressed.png b/src/themes/DustBlue/button_menu_pressed.png
new file mode 100644
index 00000000..e7dfc357
--- /dev/null
+++ b/src/themes/DustBlue/button_menu_pressed.png
diff --git a/src/themes/DustBlue/button_min_normal.png b/src/themes/DustBlue/button_min_normal.png
new file mode 100644
index 00000000..114ed3a5
--- /dev/null
+++ b/src/themes/DustBlue/button_min_normal.png
diff --git a/src/themes/DustBlue/button_min_prelight.png b/src/themes/DustBlue/button_min_prelight.png
new file mode 100644
index 00000000..be44d1a8
--- /dev/null
+++ b/src/themes/DustBlue/button_min_prelight.png
diff --git a/src/themes/DustBlue/button_min_pressed.png b/src/themes/DustBlue/button_min_pressed.png
new file mode 100644
index 00000000..045ab77c
--- /dev/null
+++ b/src/themes/DustBlue/button_min_pressed.png
diff --git a/src/themes/DustBlue/menu.png b/src/themes/DustBlue/menu.png
new file mode 100644
index 00000000..4610e233
--- /dev/null
+++ b/src/themes/DustBlue/menu.png
diff --git a/src/themes/DustBlue/metacity-theme-1.xml b/src/themes/DustBlue/metacity-theme-1.xml
new file mode 100644
index 00000000..69ad46f4
--- /dev/null
+++ b/src/themes/DustBlue/metacity-theme-1.xml
@@ -0,0 +1,409 @@
+<?xml version="1.0"?>
+
+<metacity_theme>
+<info>
+    <name>Dust-Blue</name>
+    <author>Kido Mariano, Rico Sta. Cruz and Modded by DarkAenima</author>
+    <copyright>GPL</copyright>
+    <date>Jul 28, 2008</date>
+    <description>Metacity theme</description>
+    <!-- Based on the Elegant Brit theme (though now really far away from it :P) -->
+</info>
+
+
+<!--
+    General window layout (geometric stuff)
+-->
+<frame_geometry name="frame_geometry_normal" title_scale="medium" rounded_top_left="true" rounded_top_right="true">
+    <distance name="left_width" value="1"/>
+    <distance name="right_width" value="1"/>
+    <distance name="bottom_height" value="4"/>
+    <distance name="left_titlebar_edge" value="2"/>
+    <distance name="right_titlebar_edge" value="1"/>
+    <distance name="button_width" value="28"/>
+    <distance name="button_height" value="20"/>
+    <distance name="title_vertical_pad" value="1"/>
+    <border name="title_border" left="2" right="2" top="3" bottom="0"/>
+    <border name="button_border" left="0" right="0" top="2" bottom="1"/>
+</frame_geometry>
+
+<frame_geometry name="frame_geometry_abnormal" title_scale="medium" rounded_top_left="false" rounded_top_right="false">
+    <distance name="left_width" value="0"/>
+    <distance name="right_width" value="0"/>
+    <distance name="bottom_height" value="0"/>
+    <distance name="left_titlebar_edge" value="1"/>
+    <distance name="right_titlebar_edge" value="2"/>
+    <distance name="button_width" value="28"/>
+    <distance name="button_height" value="20"/>
+    <distance name="title_vertical_pad" value="0"/>
+    <border name="title_border" left="0" right="0" top="3" bottom="0"/>
+    <border name="button_border" left="0" right="0" top="2" bottom="1"/>
+</frame_geometry>
+
+
+
+<!--
+    Window Title
+-->
+
+<draw_ops name="draw_title_text_normal">
+    <title x="1" y="(height - title_height) / 2 + 1" color="#2F2E2B"/>
+    <title x="0" y="(height - title_height) / 2" color="#FFFFFF"/>
+</draw_ops>
+
+<draw_ops name="draw_title_text_inactive">
+    <title x="0" y="(height - title_height) / 2" color="#727262"/>
+</draw_ops>
+
+<!--
+    Construct titlebar from rectangles instead so we can pick up the GTK theme
+-->
+
+<draw_ops name="draw_title">
+    <!-- Background gradient -->
+    <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        <!--<color value="#80594D"/>-->
+        <color value="shade/gtk:bg[SELECTED]/0.6"/>
+        <color value="shade/gtk:bg[NORMAL]/0.29" />
+        <color value="shade/gtk:bg[NORMAL]/0.27" />
+        <color value="shade/gtk:bg[NORMAL]/0.25" />
+        <color value="shade/gtk:bg[NORMAL]/0.24" />
+    </gradient>
+    
+    <!-- Topmost dark line -->
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="width" y1="0" y2="0"/>
+    
+    <!-- Darkening of the left arch -->
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="4" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="2" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="1" y1="3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="1" y1="4" y2="4"/>
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="0" y1="5" y2="20"/>
+    
+    <!-- Top highlight -->
+    <!-- This uses <tint> (which supports alpha) instead of <line> (which doesn't) -->
+    <tint color="#ffffff" alpha="0.35" x="5" y="1" width="width - 10" height="1"/> 
+    
+    <!-- Upper-left highlight -->
+    <!-- Draw each pixel one by one. Again, using <tint> for alpha support. -->
+    <tint color="#ffffff" alpha="0.30" x="3" y="2"  width="2" height="1"/> 
+    <tint color="#ffffff" alpha="0.27" x="2" y="3"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.24" x="2" y="4"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.21" x="1" y="5"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.18" x="1" y="6"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.15" x="1" y="7"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.12" x="1" y="8"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.09" x="1" y="9"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.06" x="1" y="10" width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.03" x="1" y="11" width="1" height="1"/> 
+    
+    <!-- Upper-right highlight -->
+    <!-- Same as above. -->
+    <tint color="#ffffff" alpha="0.30" x="width-5" y="2"  width="2" height="1"/> 
+    <tint color="#ffffff" alpha="0.27" x="width-3" y="3"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.24" x="width-3" y="4"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.21" x="width-2" y="5"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.18" x="width-2" y="6"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.15" x="width-2" y="7"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.12" x="width-2" y="8"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.09" x="width-2" y="9"  width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.06" x="width-2" y="10" width="1" height="1"/> 
+    <tint color="#ffffff" alpha="0.03" x="width-2" y="11" width="1" height="1"/> 
+    
+</draw_ops>
+
+<draw_ops name="draw_title_inactive">
+    <!-- Background gradient -->
+    <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        <color value="shade/gtk:bg[NORMAL]/0.27" />
+        <color value="shade/gtk:bg[NORMAL]/0.24" />
+    </gradient>
+        
+    <!-- Topmost dark line -->
+    <line color="shade/gtk:bg[NORMAL]/0.25" x1="1" x2="width-2" y1="0" y2="0"/>
+    <!-- Top highlight -->
+    <tint color="#ffffff" alpha="0.2" x="5" y="1" width="width - 10" height="1"/> 
+    
+    <!-- Lower-left highlight -->
+    <line color="shade/gtk:bg[NORMAL]/0.33" x1="3" x2 ="4" y1="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/0.32" x1="2" x2 ="2" y1="3" y2="4" />
+    
+    <!-- Lower-left higlight fade -->
+    <gradient type="vertical" x="1" y="5" width="1" height="title_height - 4">
+        <color value="shade/gtk:bg[NORMAL]/0.30"/>
+        <color value="shade/gtk:bg[NORMAL]/0.25"/>
+    </gradient> 
+    
+    <!-- Upper right highlight -->
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="width-5" x2 ="width-4" y1="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="width-3" x2 ="width-3" y1="3" y2="4" />
+    
+    <!-- Lower-left higlight fade -->
+    <gradient type="vertical" x="width-2" y="5" width="1" height="title_height - 4">
+        <color value="shade/gtk:bg[NORMAL]/0.30"/>
+        <color value="shade/gtk:bg[NORMAL]/0.25"/>
+    </gradient> 
+</draw_ops>
+
+<draw_ops name="draw_title_maximized">
+    <!-- Background gradient -->
+    <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        <!--<color value="#80594D"/>-->
+        <color value="shade/gtk:bg[SELECTED]/0.6"/>
+        <color value="shade/gtk:bg[NORMAL]/0.29" />
+        <color value="shade/gtk:bg[NORMAL]/0.27" />
+        <color value="shade/gtk:bg[NORMAL]/0.25" />
+        <color value="shade/gtk:bg[NORMAL]/0.24" />
+    </gradient>
+    
+    <!-- Topmost dark line -->
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="width" y1="0" y2="0"/>
+    
+    <!-- Top highlight -->
+    <!-- This uses <tint> (which supports alpha) instead of <line> (which doesn't) -->
+    <tint color="#ffffff" alpha="0.35" x="1" y="1" width="width - 2" height="1"/> 
+    
+</draw_ops>
+
+<draw_ops name="draw_title_maximized_inactive">
+    <!-- Background gradient -->
+    <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        <!--<color value="#80594D"/>-->
+        <color value="shade/gtk:bg[NORMAL]/0.27" />
+        <color value="shade/gtk:bg[NORMAL]/0.24" />
+    </gradient>
+    
+    <!-- Topmost dark line -->
+    <line color="shade/gtk:bg[NORMAL]/0.30" x1="0" x2="width" y1="0" y2="0"/>
+    
+    <!-- Top highlight -->
+    <!-- This uses <tint> (which supports alpha) instead of <line> (which doesn't) -->
+    <tint color="#ffffff" alpha="0.35" x="1" y="1" width="width - 2" height="1"/> 
+    
+</draw_ops>
+
+<!--
+    The frame around windows
+-->
+
+<draw_ops name="draw_frame">
+	<rectangle color="shade/gtk:bg[NORMAL]/0.25" x="0" y="0" width="width" height="height" filled="true"/>
+	<!-- RSC: Subtle gradient on left/right edges to match the menubar -->
+    <gradient type="vertical" x="0" y="0" width="width" height="100">
+        <color value="shade/gtk:bg[NORMAL]/0.25"/>
+        <color value="shade/gtk:bg[NORMAL]/0.15"/>
+        <color value="shade/gtk:bg[NORMAL]/0.25"/>
+    </gradient> 
+</draw_ops>
+
+<!--Borderless only: make bottom border less apparent. We can do this now since our statusbars are light.-->
+<draw_ops name="bottom_edge">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.25" x="0" y="0" width="width" height="height" filled="true"/>
+    <gradient type="vertical" x="1" y="height-6" width="width-2" height="5">
+        <color value="shade/gtk:bg[NORMAL]/0.85"/>
+        <color value="shade/gtk:bg[NORMAL]/0.5"/>
+    </gradient>
+</draw_ops>
+
+
+<!--
+    Buttons
+-->
+<!-- close button-->
+<draw_ops name="button_close_normal">
+    <image filename="button_close_normal.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_close_prelight">
+    <image filename="button_close_prelight.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_close_inactive_prelight">
+    <image filename="button_close_prelight.png" x="0" y="1" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+<draw_ops name="button_close_pressed">
+    <image filename="button_close_pressed.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_close_inactive">
+    <image filename="button_close_normal.png" x="0" y="1" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+
+<!-- maximize button-->
+<draw_ops name="button_max_normal">
+    <image filename="button_max_normal.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_max_prelight">
+    <image filename="button_max_prelight.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_max_inactive_prelight">
+    <image filename="button_max_prelight.png" x="0" y="1" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+<draw_ops name="button_max_pressed">
+    <image filename="button_max_pressed.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_max_inactive">
+    <image filename="button_max_normal.png" x="0" y="1" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+
+<!-- minimize button-->
+<draw_ops name="button_min_normal">
+    <image filename="button_min_normal.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_min_prelight">
+    <image filename="button_min_prelight.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_min_inactive_prelight">
+    <image filename="button_min_prelight.png" x="0" y="1" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+<draw_ops name="button_min_pressed">
+    <image filename="button_min_pressed.png" x="0" y="1" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_min_inactive">
+    <image filename="button_min_normal.png" x="0" y="1" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+
+<!-- menu button -->
+<!--
+<draw_ops name="button_menu_normal">
+<image filename="button_menu_normal.png" x="0" y="2" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_menu_prelight">
+<image filename="button_menu_prelight.png" x="0" y="2" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_menu_inactive_prelight">
+<image filename="button_menu_prelight.png" x="0" y="2" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>
+<draw_ops name="button_menu_pressed">
+<image filename="button_menu_pressed.png" x="0" y="2" width="object_width" height="object_height"/>
+</draw_ops>
+<draw_ops name="button_menu_inactive">
+<image filename="button_menu_normal.png" x="0" y="2" width="object_width" height="object_height" alpha="0.3"/>
+</draw_ops>-->
+
+<!-- menu icon -->
+<draw_ops name="button_menu_normal">
+<icon x="6" y="2" width="mini_icon_width" height="mini_icon_height"/>
+</draw_ops>
+<draw_ops name="button_menu_prelight">
+<icon x="6" y="2" width="mini_icon_width" height="mini_icon_height"/>
+</draw_ops>
+<draw_ops name="button_menu_inactive_prelight">
+<icon x="6" y="2" width="mini_icon_width" height="mini_icon_height" alpha="0.3"/>
+</draw_ops>
+<draw_ops name="button_menu_pressed">
+<icon x="6" y="2" width="mini_icon_width" height="mini_icon_height"/>
+</draw_ops>
+<draw_ops name="button_menu_inactive">
+<icon x="6" y="2" width="mini_icon_width" height="mini_icon_height" alpha="0.3"/>
+</draw_ops>
+
+
+
+<!--
+    Frame styles
+-->
+
+<!-- normal -->
+<frame_style name="frame_style_normal_focused" geometry="frame_geometry_normal">
+   <piece position="title" draw_ops="draw_title_text_normal"/>
+   <piece position="titlebar" draw_ops="draw_title"/>
+   <piece position="left_edge" draw_ops="draw_frame"/>
+   <piece position="right_edge" draw_ops="draw_frame"/>
+   <piece position="bottom_edge" draw_ops="bottom_edge"/>
+   <button function="close" state="normal" draw_ops="button_close_normal"/>
+   <button function="close" state="prelight" draw_ops="button_close_prelight"/>
+   <button function="close" state="pressed" draw_ops="button_close_pressed"/>
+   <button function="minimize" state="normal" draw_ops="button_min_normal"/>
+   <button function="minimize" state="prelight" draw_ops="button_min_prelight"/>
+   <button function="minimize" state="pressed" draw_ops="button_min_pressed"/>
+   <button function="maximize" state="normal" draw_ops="button_max_normal"/>
+   <button function="maximize" state="prelight" draw_ops="button_max_prelight"/>
+   <button function="maximize" state="pressed" draw_ops="button_max_pressed"/>
+   <button function="menu" state="normal" draw_ops="button_menu_normal"/>
+   <button function="menu" state="prelight" draw_ops="button_menu_prelight"/>
+   <button function="menu" state="pressed" draw_ops="button_menu_pressed"/>
+</frame_style>
+
+<frame_style name="frame_style_normal_unfocused" geometry="frame_geometry_normal">
+   <piece position="title" draw_ops="draw_title_text_inactive"/>
+   <piece position="titlebar" draw_ops="draw_title_inactive"/>
+   <piece position="left_edge" draw_ops="draw_frame"/>
+   <piece position="right_edge" draw_ops="draw_frame"/>
+   <piece position="bottom_edge" draw_ops="bottom_edge"/>
+   <button function="close" state="normal" draw_ops="button_close_inactive"/>
+   <button function="close" state="prelight" draw_ops="button_close_inactive_prelight"/>
+   <button function="close" state="pressed" draw_ops="button_close_inactive"/>
+   <button function="minimize" state="normal" draw_ops="button_min_inactive"/>
+   <button function="minimize" state="prelight" draw_ops="button_min_inactive_prelight"/>
+   <button function="minimize" state="pressed" draw_ops="button_min_inactive"/>
+   <button function="maximize" state="normal" draw_ops="button_max_inactive"/>
+   <button function="maximize" state="prelight" draw_ops="button_max_inactive_prelight"/>
+   <button function="maximize" state="pressed" draw_ops="button_max_inactive"/>
+   <button function="menu" state="normal" draw_ops="button_menu_inactive"/>
+   <button function="menu" state="prelight" draw_ops="button_menu_inactive_prelight"/>
+   <button function="menu" state="pressed" draw_ops="button_menu_inactive"/>
+</frame_style>
+
+<frame_style name="frame_style_maximized_focused" geometry="frame_geometry_abnormal">
+   <piece position="title" draw_ops="draw_title_text_normal"/>
+   <piece position="titlebar" draw_ops="draw_title_maximized"/>
+   <piece position="left_edge" draw_ops="draw_frame"/>
+   <piece position="right_edge" draw_ops="draw_frame"/>
+   <piece position="bottom_edge" draw_ops="bottom_edge"/>
+   <button function="close" state="normal" draw_ops="button_close_normal"/>
+   <button function="close" state="prelight" draw_ops="button_close_prelight"/>
+   <button function="close" state="pressed" draw_ops="button_close_pressed"/>
+   <button function="minimize" state="normal" draw_ops="button_min_normal"/>
+   <button function="minimize" state="prelight" draw_ops="button_min_prelight"/>
+   <button function="minimize" state="pressed" draw_ops="button_min_pressed"/>
+   <button function="maximize" state="normal" draw_ops="button_max_normal"/>
+   <button function="maximize" state="prelight" draw_ops="button_max_prelight"/>
+   <button function="maximize" state="pressed" draw_ops="button_max_pressed"/>
+   <button function="menu" state="normal" draw_ops="button_menu_normal"/>
+   <button function="menu" state="prelight" draw_ops="button_menu_prelight"/>
+   <button function="menu" state="pressed" draw_ops="button_menu_normal"/>
+</frame_style>
+
+<frame_style name="frame_style_maximized_unfocused" geometry="frame_geometry_abnormal">
+   <piece position="title" draw_ops="draw_title_text_inactive"/>
+   <piece position="titlebar" draw_ops="draw_title_maximized_inactive"/>
+   <piece position="left_edge" draw_ops="draw_frame"/>
+   <piece position="right_edge" draw_ops="draw_frame"/>
+   <piece position="bottom_edge" draw_ops="bottom_edge"/>
+   <button function="close" state="normal" draw_ops="button_close_inactive"/>
+   <button function="close" state="prelight" draw_ops="button_close_prelight"/>
+   <button function="close" state="pressed" draw_ops="button_close_inactive"/>
+   <button function="minimize" state="normal" draw_ops="button_min_inactive"/>
+   <button function="minimize" state="prelight" draw_ops="button_min_prelight"/>
+   <button function="minimize" state="pressed" draw_ops="button_min_inactive"/>
+   <button function="maximize" state="normal" draw_ops="button_max_inactive"/>
+   <button function="maximize" state="prelight" draw_ops="button_max_prelight"/>
+   <button function="maximize" state="pressed" draw_ops="button_max_inactive"/>
+   <button function="menu" state="normal" draw_ops="button_menu_inactive"/>
+   <button function="menu" state="prelight" draw_ops="button_menu_inactive"/>
+   <button function="menu" state="pressed" draw_ops="button_menu_inactive"/>
+</frame_style>
+
+<frame_style_set name="frame_style_set_normal">
+  <frame focus="yes" state="normal" resize="both" style="frame_style_normal_focused"/>
+  <frame focus="no" state="normal" resize="both" style="frame_style_normal_unfocused"/>
+  <frame focus="yes" state="maximized" style="frame_style_maximized_focused"/>
+  <frame focus="no" state="maximized" style="frame_style_maximized_unfocused"/>
+  <frame focus="yes" state="shaded" style="frame_style_normal_focused"/>
+  <frame focus="no" state="shaded" style="frame_style_normal_unfocused"/>
+  <frame focus="yes" state="maximized_and_shaded" style="frame_style_maximized_focused"/>
+  <frame focus="no" state="maximized_and_shaded" style="frame_style_maximized_unfocused"/>
+</frame_style_set>
+
+<window type="normal" style_set="frame_style_set_normal"/>
+<window type="dialog" style_set="frame_style_set_normal"/>
+<window type="modal_dialog" style_set="frame_style_set_normal"/>
+<window type="menu" style_set="frame_style_set_normal"/>
+<window type="utility" style_set="frame_style_set_normal"/>
+<window type="border" style_set="frame_style_set_normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="button_close_normal"/>
+<menu_icon function="maximize" state="normal" draw_ops="button_max_normal"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="button_max_normal"/>
+<menu_icon function="minimize" state="normal" draw_ops="button_min_normal"/>
+
+
+</metacity_theme>
diff --git a/src/themes/Makefile.am b/src/themes/Makefile.am
new file mode 100644
index 00000000..a040a804
--- /dev/null
+++ b/src/themes/Makefile.am
@@ -0,0 +1,53 @@
+THEMES= \
+	ClearlooksRe \
+	eOS \
+	DustBlue \
+	WinMe \
+	Splint-Left \
+	Dopple \
+	Spidey-Left \
+	Splint \
+	Dopple-Left \
+	Spidey
+
+THEME_DIR=$(datadir)/themes
+THEME_SUBDIR=metacity-1
+
+install-data-local:
+	$(mkinstalldirs) $(DESTDIR)$(THEME_DIR); \
+	for THEME in $(THEMES); do \
+		echo '-- Installing theme '$$THEME; \
+		$(mkinstalldirs) $(DESTDIR)$(THEME_DIR)/$$THEME; \
+		$(mkinstalldirs) $(DESTDIR)$(THEME_DIR)/$$THEME/$(THEME_SUBDIR); \
+		(installfiles=`find $(srcdir)/$$THEME -name "*.png" -o -name "*.xml"`; \
+		 for i in $$installfiles; do \
+			echo '-- Installing '$$i ; \
+		    	$(INSTALL_DATA) $$i $(DESTDIR)$(THEME_DIR)/$$THEME/$(THEME_SUBDIR) ; \
+	  	 done) \
+	done
+
+uninstall-local:
+	for THEME in $(THEMES); do \
+		echo '-- Uninstalling theme '$$THEME; \
+		(uninstallfiles=`find $(srcdir)/$$THEME -name "*.png" -o -name "*.xml"`; \
+		 for i in $$uninstallfiles; do \
+					i=`basename $$i`; \
+			echo '-- Removing '$$i ; \
+				rm -f $(DESTDIR)$(THEME_DIR)/$$THEME/$(THEME_SUBDIR)/$$i ; \
+		done); \
+		rmdir $(DESTDIR)$(THEME_DIR)/$$THEME/$(THEME_SUBDIR) || :; \
+		rmdir $(DESTDIR)$(THEME_DIR)/$$THEME || :; \
+	done
+	-rmdir $(DESTDIR)$(THEME_DIR)
+
+dist-hook:
+	mkdir $(distdir)/themes; \
+	for THEME in $(THEMES); do \
+		echo '-- Disting theme '$$THEME; \
+		mkdir $(distdir)/$$THEME; \
+		(installfiles=`find $(srcdir)/$$THEME -name "*.png" -o -name "*.xml"`; \
+		 for i in $$installfiles; do \
+			echo '-- Disting '$$i ; \
+				cp $$i $(distdir)/$$THEME; \
+		done) \
+	done
diff --git a/src/themes/Spidey-Left/metacity-theme-1.xml b/src/themes/Spidey-Left/metacity-theme-1.xml
new file mode 100644
index 00000000..0244d458
--- /dev/null
+++ b/src/themes/Spidey-Left/metacity-theme-1.xml
@@ -0,0 +1,1086 @@
+<?xml version="1.0"?>
+<metacity_theme>
+
+<info>
+  <name>Spidey</name>
+  <author>Brandon Wright</author>
+  <copyright>2009</copyright>
+  <date>January 21, 2009</date>
+  <description>A Clearlooks-styled theme with Tango basics.</description>
+</info>
+
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true">
+  <distance name="left_width" value="3"/>
+  <distance name="right_width" value="3"/>
+  <distance name="bottom_height" value="3"/>
+  <distance name="left_titlebar_edge" value="4"/>
+  <distance name="right_titlebar_edge" value="4"/>
+  <aspect_ratio name="button" value="1"/>
+  <distance name="title_vertical_pad" value="2"/>
+  <border name="title_border" left="3" right="4" top="2" bottom="2"/>
+  <border name="button_border" left="1" right="1" top="3" bottom="3"/>
+</frame_geometry>
+
+<frame_geometry name="normal_small_borders" parent="normal" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_titlebar_edge" value="1" />
+  <distance name="right_titlebar_edge" value="1" />
+  <distance name="left_width" value="0" />
+  <distance name="right_width" value="0" />
+  <distance name="bottom_height" value="0" />
+</frame_geometry>
+
+<frame_geometry name="utility" parent="normal">
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="0"/>
+  <distance name="right_titlebar_edge" value="0"/>
+  <distance name="button_width" value="0"/>
+  <distance name="button_height" value="0"/>
+  <distance name="title_vertical_pad" value="4"/>
+  <border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  <border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Buttons -->
+<draw_ops name="button_bg">
+
+<!-- Background -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+    </gradient>
+
+<!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="0" y1="1"
+          x2="1" y2="0" /> -->
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="width-1" y1="1"
+          x2="width-2" y2="0" /> -->
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="0" y1="height-2"
+          x2="1" y2="height-1" /> -->
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="width-1" y1="height-2"
+          x2="width-2" y2="height-1" /> -->
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.4" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.4" />
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.4" />
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+    </gradient>
+
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+
+<!-- Background -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.1" />
+        <color value="shade/gtk:bg[NORMAL]/0.9" />
+    </gradient>
+
+<!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="0" y1="1"
+          x2="1" y2="0" /> -->
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="width-1" y1="1"
+          x2="width-2" y2="0" /> -->
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="0" y1="height-2"
+          x2="1" y2="height-1" /> -->
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="width-1" y1="height-2"
+          x2="width-2" y2="height-1" /> -->
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.5" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.5" />
+        <color value="shade/gtk:bg[NORMAL]/1.1" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.5" />
+        <color value="shade/gtk:bg[NORMAL]/1.1" />
+    </gradient>
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg">
+
+<!-- Background -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/0.9" />
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+    </gradient>
+
+<!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="0" y1="1"
+          x2="1" y2="0" /> -->
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="width-1" y1="1"
+          x2="width-2" y2="0" /> -->
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="0" y1="height-2"
+          x2="1" y2="height-1" /> -->
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="width-1" y1="height-2"
+          x2="width-2" y2="height-1" /> -->
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+    </gradient>
+
+</draw_ops>
+<!-- Buttons -->
+<draw_ops name="button_bg_unfocused">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.90" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.15" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" /> -->
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+<!--    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient> -->
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.00" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="menu_glyph">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" />
+</draw_ops>
+
+<draw_ops name="menu_glyph_unfocused">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" alpha="0.5"/>
+</draw_ops>
+
+<draw_ops name="close_glyph">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.1" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.1" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_lighter">
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused_lighter">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph">
+  <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+
+<draw_ops name="maximize_glyph_lighter">
+  <rectangle color="shade/gtk:bg[NORMAL]/1.2" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+
+<draw_ops name="maximize_glyph_unfocused">
+  <rectangle color="gtk:fg[NORMAL]" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+<draw_ops name="maximize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+
+<draw_ops name="minimize_glyph">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_lighter">
+    <rectangle color="shade/gtk:bg[NORMAL]/1.2" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused">
+    <rectangle color="gtk:fg[NORMAL]" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="menu_button">
+    <include name="menu_glyph" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="menu_button_unfocused">
+    <include name="menu_glyph_unfocused" x="0" y="0" />
+</draw_ops>
+
+<draw_ops name="menu_button_pressed">
+    <include name="menu_glyph_unfocused" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="minimize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_lighter" x="2" y="3" width="width-4" height="height-4" />
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_lighter" x="2" y="3" width="width-4" height="height-4" />
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4" />
+</draw_ops>
+
+<draw_ops name="minimize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+
+<draw_ops name="maximize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="2" y="3" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="2" y="3" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="mini_window_icon">
+  <rectangle color="gtk:bg[NORMAL]" filled="true"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <rectangle color="gtk:fg[NORMAL]" filled="false"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <line color="gtk:fg[NORMAL]" width="2"
+        x1="0" y1="1" x2="width" y2="1"/>
+</draw_ops>
+
+<draw_ops name="restore_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="3" y="4" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_prelight">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="3" y="4" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="close_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_lighter" x="2" y="3" width="width-4" height="width-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_lighter" x="2" y="3" width="width-4" height="width-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel">
+  <rectangle color="shade/gtk:bg[NORMAL]/0.5"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel_unfocused">  
+  <rectangle color="shade/gtk:bg[NORMAL]/0.7"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="title_background">
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+<!--
+    <rectangle color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+-->
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+
+    <gradient type="vertical" x="2" y="2" width="width-4" height="height-3">
+        <color value="shade/gtk:bg[SELECTED]/1.1"/>
+	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient> 
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="3" y1="height-1"
+        x2="width-4" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.975"
+        x1="2" y1="height-2"
+        x2="width-3" y2="height-2" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="4" y1="1" x2="4" y2="1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+<!--
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="2" y1="3" x2="2" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-5" y1="2" x2="width-4" y2="2" />
+-->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+  <!--  <gradient type="vertical" x="1" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="1" y1="height-1" x2="1" y2="height-1" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="height-1" x2="width-2" y2="height-1" />
+</draw_ops>
+
+<draw_ops name="title_background_maximized">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-2" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-1" y1="1" x2="width-1" y2="height-2"/>
+    
+    <gradient type="vertical" x="1" y="2" width="width-2" height="height-3">
+    	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient>
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-1" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="0" y1="height-1"
+        x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.95"
+        x1="0" y1="height-2"
+        x2="width-1" y2="height-2" />
+
+<!--    <gradient type="vertical" x="0" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-1" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+</draw_ops>
+
+<draw_ops name="title_unfocused_background">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="1" y1="height-2" x2="width-3" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="width-2" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="1" y2="height-1"/>
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-2" y1="1" x2="width-2" y2="height" />
+
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="4" y1="1" x2="4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="3" y1="2" x2="4" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+
+</draw_ops>
+
+<draw_ops name="title_unfocused_background_maximized">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="0" y="1" width="width" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="0" y1="height-2" x2="width-1" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="0" y1="1" x2="width-1" y2="1"/>
+
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<draw_ops name="focus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[SELECTED]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[SELECTED]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[SELECTED]/0.7" />
+</draw_ops>
+
+<draw_ops name="unfocus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[NORMAL]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[NORMAL]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[NORMAL]/0.7" />
+</draw_ops>
+
+<draw_ops name="focus_background">
+  <include name="focus_outline"/>
+</draw_ops>
+
+<draw_ops name="unfocus_background">
+  <include name="unfocus_outline" />
+</draw_ops>
+
+<draw_ops name="title_text_focused_with_icon">
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) - 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+
+     
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) - 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) + 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) + 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+        
+    <title color="#ffffff"
+           x="(0)"
+           y="(((height - title_height) / 2) `max` 0)"/>
+ 
+</draw_ops>
+
+<draw_ops name="title_text_with_icon">
+    <title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.4"
+           x="(0)"
+           y="((height - title_height) / 2) `max` 0"/> 
+</draw_ops>
+
+<draw_ops name="title_normal">
+  <include name="title_text_with_icon"/>
+</draw_ops>
+
+<draw_ops name="title_focused">
+  <include name="title_text_focused_with_icon"/>
+</draw_ops>
+
+<frame_style name="normal_unfocused" geometry="normal">
+    <piece position="entire_background" draw_ops="unfocus_background"/>
+    <piece position="titlebar" draw_ops="title_unfocused_background"/>
+    <piece position="title" draw_ops="title_normal"/>
+
+  <button function="close" state="normal" draw_ops="close_button_unfocused"/>
+  <button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+  <button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+  <button function="menu" state="normal" draw_ops="menu_button_unfocused"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_unfocused"/>
+</frame_style>
+
+<frame_style name="normal_focused" geometry="normal">
+  <piece position="entire_background" draw_ops="focus_background"/>
+  <piece position="titlebar" draw_ops="title_background"/>  
+  <piece position="title" draw_ops="title_focused"/>
+  <button function="close" state="normal" draw_ops="close_button"/>
+  <button function="close" state="pressed" draw_ops="close_button_pressed"/>
+  <button function="close" state="prelight" draw_ops="close_button_focus"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+  <button function="minimize" state="prelight" draw_ops="minimize_button_focus" />
+  <button function="maximize" state="normal" draw_ops="maximize_button"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="maximize_button_focus"/>
+  <button function="menu" state="normal" draw_ops="menu_button"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="normal_small_borders" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="blank"/>
+  <piece position="titlebar" draw_ops="title_unfocused_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="normal_small_borders" parent="normal_focused">
+  <piece position="entire_background" draw_ops="focus_outline"/>
+  <piece position="titlebar" draw_ops="title_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="restore_button_prelight" />
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="outer_bevel"/>
+  <piece position="titlebar" draw_ops="blank"/>
+  <piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style_set name="normal">
+<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+<frame focus="yes" state="maximized" style="maximized_focused"/>
+<frame focus="no" state="maximized" style="maximized_unfocused"/>
+<frame focus="yes" state="shaded" style="normal_focused"/>
+<frame focus="no" state="shaded" style="normal_unfocused"/>
+<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/>
+<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+<frame focus="yes" state="normal" resize="both" style="border"/>
+<frame focus="no" state="normal" resize="both" style="border"/>
+<frame focus="yes" state="maximized" style="border"/>
+<frame focus="no" state="maximized" style="border"/>
+<frame focus="yes" state="shaded" style="border"/>
+<frame focus="no" state="shaded" style="border"/>
+<frame focus="yes" state="maximized_and_shaded" style="border"/>
+<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="normal"/>
+<window type="border" style_set="normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button"/>
+
+</metacity_theme>
diff --git a/src/themes/Spidey/metacity-theme-1.xml b/src/themes/Spidey/metacity-theme-1.xml
new file mode 100644
index 00000000..5472f9da
--- /dev/null
+++ b/src/themes/Spidey/metacity-theme-1.xml
@@ -0,0 +1,1086 @@
+<?xml version="1.0"?>
+<metacity_theme>
+
+<info>
+  <name>Spidey</name>
+  <author>Brandon Wright</author>
+  <copyright>2009</copyright>
+  <date>January 21, 2009</date>
+  <description>A Clearlooks-styled theme with Tango basics.</description>
+</info>
+
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true">
+  <distance name="left_width" value="3"/>
+  <distance name="right_width" value="3"/>
+  <distance name="bottom_height" value="3"/>
+  <distance name="left_titlebar_edge" value="4"/>
+  <distance name="right_titlebar_edge" value="4"/>
+  <aspect_ratio name="button" value="1"/>
+  <distance name="title_vertical_pad" value="2"/>
+  <border name="title_border" left="3" right="4" top="2" bottom="2"/>
+  <border name="button_border" left="1" right="1" top="3" bottom="3"/>
+</frame_geometry>
+
+<frame_geometry name="normal_small_borders" parent="normal" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_titlebar_edge" value="1" />
+  <distance name="right_titlebar_edge" value="1" />
+  <distance name="left_width" value="0" />
+  <distance name="right_width" value="0" />
+  <distance name="bottom_height" value="0" />
+</frame_geometry>
+
+<frame_geometry name="utility" parent="normal">
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="0"/>
+  <distance name="right_titlebar_edge" value="0"/>
+  <distance name="button_width" value="0"/>
+  <distance name="button_height" value="0"/>
+  <distance name="title_vertical_pad" value="4"/>
+  <border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  <border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Buttons -->
+<draw_ops name="button_bg">
+
+<!-- Background -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+    </gradient>
+
+<!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="0" y1="1"
+          x2="1" y2="0" /> -->
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="width-1" y1="1"
+          x2="width-2" y2="0" /> -->
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="0" y1="height-2"
+          x2="1" y2="height-1" /> -->
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="width-1" y1="height-2"
+          x2="width-2" y2="height-1" /> -->
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.4" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.4" />
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.4" />
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+    </gradient>
+
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+
+<!-- Background -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.1" />
+        <color value="shade/gtk:bg[NORMAL]/0.9" />
+    </gradient>
+
+<!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="0" y1="1"
+          x2="1" y2="0" /> -->
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="width-1" y1="1"
+          x2="width-2" y2="0" /> -->
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="0" y1="height-2"
+          x2="1" y2="height-1" /> -->
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="width-1" y1="height-2"
+          x2="width-2" y2="height-1" /> -->
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.5" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.5" />
+        <color value="shade/gtk:bg[NORMAL]/1.1" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.5" />
+        <color value="shade/gtk:bg[NORMAL]/1.1" />
+    </gradient>
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg">
+
+<!-- Background -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/0.9" />
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+    </gradient>
+
+<!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[SELECTED]/0.5" />
+        <color value="shade/gtk:bg[SELECTED]/0.7" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="0" y1="1"
+          x2="1" y2="0" /> -->
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.5" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.9"
+          x1="width-1" y1="1"
+          x2="width-2" y2="0" /> -->
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="0" y1="height-2"
+          x2="1" y2="height-1" /> -->
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.7" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+<!--    <line color="blend/gtk:bg[SELECTED]/gtk:bg[SELECTED]/0.95"
+          x1="width-1" y1="height-2"
+          x2="width-2" y2="height-1" /> -->
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.0" />
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+    </gradient>
+
+</draw_ops>
+<!-- Buttons -->
+<draw_ops name="button_bg_unfocused">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <gradient type="vertical" x="0" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Right line -->
+    <gradient type="vertical" x="width - 1" y="2" width="1" height="(height-4)">
+        <color value="shade/gtk:bg[NORMAL]/0.8" />
+        <color value="shade/gtk:bg[NORMAL]/0.675" />
+    </gradient>
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.675" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.90" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.2" />
+        <color value="shade/gtk:bg[NORMAL]/0.90" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/0.9" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/1.15" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg_unfocused">
+
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+        <color value="shade/gtk:bg[NORMAL]/0.95" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[NORMAL]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/1.25" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" /> -->
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[NORMAL]/1.05" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+<!--    <line color="shade/gtk:bg[NORMAL]/" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+<!--    <gradient type="vertical" x="1" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.25" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient> -->
+
+    <!-- Right line -->
+<!--    <line color="blend/gtk:bg[NORMAL]/#ffffff/0.18" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+    <gradient type="vertical" x="width-2" y="2" width="1" height="(height-3)-1">
+        <color value="shade/gtk:bg[NORMAL]/1.00" />
+        <color value="shade/gtk:bg[NORMAL]/1.05" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[NORMAL]/1.0" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="menu_glyph">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" />
+</draw_ops>
+
+<draw_ops name="menu_glyph_unfocused">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" alpha="0.5"/>
+</draw_ops>
+
+<draw_ops name="close_glyph">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.1" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.1" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_lighter">
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/1.1" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused_lighter">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph">
+  <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+
+<draw_ops name="maximize_glyph_lighter">
+  <rectangle color="shade/gtk:bg[NORMAL]/1.2" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+
+<draw_ops name="maximize_glyph_unfocused">
+  <rectangle color="gtk:fg[NORMAL]" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+<draw_ops name="maximize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+
+<draw_ops name="minimize_glyph">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.2" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_lighter">
+    <rectangle color="shade/gtk:bg[NORMAL]/1.2" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused">
+    <rectangle color="gtk:fg[NORMAL]" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="menu_button">
+    <include name="menu_glyph" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="menu_button_unfocused">
+    <include name="menu_glyph_unfocused" x="0" y="0" />
+</draw_ops>
+
+<draw_ops name="menu_button_pressed">
+    <include name="menu_glyph_unfocused" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="minimize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_lighter" x="2" y="3" width="width-4" height="height-4" />
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_lighter" x="2" y="3" width="width-4" height="height-4" />
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4" />
+</draw_ops>
+
+<draw_ops name="minimize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+
+<draw_ops name="maximize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="2" y="3" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="2" y="3" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="mini_window_icon">
+  <rectangle color="gtk:bg[NORMAL]" filled="true"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <rectangle color="gtk:fg[NORMAL]" filled="false"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <line color="gtk:fg[NORMAL]" width="2"
+        x1="0" y1="1" x2="width" y2="1"/>
+</draw_ops>
+
+<draw_ops name="restore_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="3" y="4" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_prelight">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_lighter" x="3" y="4" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="close_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_lighter" x="2" y="3" width="width-4" height="width-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_lighter" x="2" y="3" width="width-4" height="width-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused">
+    <include name="button_bg_unfocused" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused_pressed">
+    <include name="button_pressed_bg_unfocused"/>
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel">
+  <rectangle color="shade/gtk:bg[NORMAL]/0.5"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel_unfocused">  
+  <rectangle color="shade/gtk:bg[NORMAL]/0.7"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="title_background">
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+<!--
+    <rectangle color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+-->
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="1" y="1" width="width-3" height="height-3"/> 
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+
+    <gradient type="vertical" x="2" y="2" width="width-4" height="height-3">
+        <color value="shade/gtk:bg[SELECTED]/1.1"/>
+	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient> 
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="3" y1="height-1"
+        x2="width-4" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.975"
+        x1="2" y1="height-2"
+        x2="width-3" y2="height-2" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="4" y1="1" x2="4" y2="1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+<!--
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="2" y1="3" x2="2" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="blend/gtk:bg[SELECTED]/#ffffff/0.27" x1="width-5" y1="2" x2="width-4" y2="2" />
+-->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+  <!--  <gradient type="vertical" x="1" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-2" y="5" width="1" height="height-6">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="1" y1="height-1" x2="1" y2="height-1" />
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-2" y1="height-1" x2="width-2" y2="height-1" />
+</draw_ops>
+
+<draw_ops name="title_background_maximized">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-2" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.2" x1="width-1" y1="1" x2="width-1" y2="height-2"/>
+    
+    <gradient type="vertical" x="1" y="2" width="width-2" height="height-3">
+    	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    </gradient>
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/1.2" x="0" y="1" width="width-1" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/0.7"
+        x1="0" y1="height-1"
+        x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.95"
+        x1="0" y1="height-2"
+        x2="width-1" y2="height-2" />
+
+<!--    <gradient type="vertical" x="0" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient>
+
+    <gradient type="vertical" x="width-1" y="1" width="1" height="height-2">
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.27" />
+        <color value="blend/gtk:bg[SELECTED]/#ffffff/0.09" />
+    </gradient> -->
+</draw_ops>
+
+<draw_ops name="title_unfocused_background">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="1" y1="height-2" x2="width-3" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="width-2" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="1" y1="1" x2="1" y2="height-1"/>
+
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-2" y1="1" x2="width-2" y2="height" />
+
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="4" y1="1" x2="4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="3" y1="2" x2="4" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+
+</draw_ops>
+
+<draw_ops name="title_unfocused_background_maximized">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="0" y="1" width="width" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.05"/>
+	<color value="shade/gtk:bg[NORMAL]/0.85"/>
+    </gradient>
+    <line color="shade/gtk:bg[NORMAL]/0.945" x1="0" y1="height-2" x2="width-1" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="0" y1="height-1" x2="width-1" y2="height-1" />
+    <line color="shade/gtk:bg[NORMAL]/1.2" x1="0" y1="1" x2="width-1" y2="1"/>
+
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<draw_ops name="focus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[SELECTED]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[SELECTED]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[SELECTED]/0.7" />
+</draw_ops>
+
+<draw_ops name="unfocus_outline">
+    <rectangle x="0" y="0" width="width-1" height="height-1" color="shade/gtk:bg[NORMAL]/0.7" />
+    <rectangle x="1" y="1" width="width-3" height="height-3" color="shade/gtk:bg[NORMAL]/1.2" />
+    <rectangle x="2" y="2" width="width-5" height="height-5" color="shade/gtk:bg[NORMAL]/0.7" />
+</draw_ops>
+
+<draw_ops name="focus_background">
+  <include name="focus_outline"/>
+</draw_ops>
+
+<draw_ops name="unfocus_background">
+  <include name="unfocus_outline" />
+</draw_ops>
+
+<draw_ops name="title_text_focused_with_icon">
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) - 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+
+     
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) - 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) + 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) + 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+        
+    <title color="#ffffff"
+           x="(((width  - title_width)  / 2) `max` 0)"
+           y="(((height - title_height) / 2) `max` 0)"/>
+ 
+</draw_ops>
+
+<draw_ops name="title_text_with_icon">
+    <title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.4"
+           x="(((width - title_width)  / 2) `max` 0)"
+           y="((height - title_height) / 2) `max` 0"/> 
+</draw_ops>
+
+<draw_ops name="title_normal">
+  <include name="title_text_with_icon"/>
+</draw_ops>
+
+<draw_ops name="title_focused">
+  <include name="title_text_focused_with_icon"/>
+</draw_ops>
+
+<frame_style name="normal_unfocused" geometry="normal">
+    <piece position="entire_background" draw_ops="unfocus_background"/>
+    <piece position="titlebar" draw_ops="title_unfocused_background"/>
+    <piece position="title" draw_ops="title_normal"/>
+
+  <button function="close" state="normal" draw_ops="close_button_unfocused"/>
+  <button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+  <button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+  <button function="menu" state="normal" draw_ops="menu_button_unfocused"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_unfocused"/>
+</frame_style>
+
+<frame_style name="normal_focused" geometry="normal">
+  <piece position="entire_background" draw_ops="focus_background"/>
+  <piece position="titlebar" draw_ops="title_background"/>  
+  <piece position="title" draw_ops="title_focused"/>
+  <button function="close" state="normal" draw_ops="close_button"/>
+  <button function="close" state="pressed" draw_ops="close_button_pressed"/>
+  <button function="close" state="prelight" draw_ops="close_button_focus"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+  <button function="minimize" state="prelight" draw_ops="minimize_button_focus" />
+  <button function="maximize" state="normal" draw_ops="maximize_button"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="maximize_button_focus"/>
+  <button function="menu" state="normal" draw_ops="menu_button"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="normal_small_borders" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="blank"/>
+  <piece position="titlebar" draw_ops="title_unfocused_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="normal_small_borders" parent="normal_focused">
+  <piece position="entire_background" draw_ops="focus_outline"/>
+  <piece position="titlebar" draw_ops="title_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="restore_button_prelight" />
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="outer_bevel"/>
+  <piece position="titlebar" draw_ops="blank"/>
+  <piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style_set name="normal">
+<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+<frame focus="yes" state="maximized" style="maximized_focused"/>
+<frame focus="no" state="maximized" style="maximized_unfocused"/>
+<frame focus="yes" state="shaded" style="normal_focused"/>
+<frame focus="no" state="shaded" style="normal_unfocused"/>
+<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/>
+<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+<frame focus="yes" state="normal" resize="both" style="border"/>
+<frame focus="no" state="normal" resize="both" style="border"/>
+<frame focus="yes" state="maximized" style="border"/>
+<frame focus="no" state="maximized" style="border"/>
+<frame focus="yes" state="shaded" style="border"/>
+<frame focus="no" state="shaded" style="border"/>
+<frame focus="yes" state="maximized_and_shaded" style="border"/>
+<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="normal"/>
+<window type="border" style_set="normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button"/>
+
+</metacity_theme>
diff --git a/src/themes/Splint-Left/metacity-theme-1.xml b/src/themes/Splint-Left/metacity-theme-1.xml
new file mode 100644
index 00000000..f81ad5a3
--- /dev/null
+++ b/src/themes/Splint-Left/metacity-theme-1.xml
@@ -0,0 +1,802 @@
+<?xml version="1.0"?>
+<metacity_theme>
+
+<info>
+  <name>Splint-Left</name>
+  <author>Brandon Wright</author>
+  <copyright>2009</copyright>
+  <date>January 21, 2009</date>
+  <description>A theme designed around the Tango style.</description>
+</info>
+
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="4"/>
+  <distance name="right_titlebar_edge" value="4"/>
+  <aspect_ratio name="button" value="1"/>
+  <distance name="title_vertical_pad" value="2"/>
+  <border name="title_border" left="3" right="4" top="2" bottom="2"/>
+  <border name="button_border" left="1" right="1" top="3" bottom="3"/>
+</frame_geometry>
+
+<frame_geometry name="normal_small_borders" parent="normal" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_titlebar_edge" value="1" />
+  <distance name="right_titlebar_edge" value="1" />
+  <distance name="left_width" value="0" />
+  <distance name="right_width" value="0" />
+  <distance name="bottom_height" value="0" />
+</frame_geometry>
+
+<frame_geometry name="utility" parent="normal">
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="0"/>
+  <distance name="right_titlebar_edge" value="0"/>
+  <distance name="button_width" value="0"/>
+  <distance name="button_height" value="0"/>
+  <distance name="title_vertical_pad" value="4"/>
+  <border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  <border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Buttons -->
+<draw_ops name="button_bg">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" />
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+
+    <!-- Do a fill -->
+    <rectangle color="shade/gtk:bg[SELECTED]/1.0" x="1" y="1" width="width-2" height = "height-2" filled="true" />
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" />
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="height-3"           
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg">
+
+    <!-- Do a fill -->
+<!--    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="1" y="1" width="width-2" height = "height-2" filled="true" /> -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[SELECTED]/0.9" />
+        <color value="shade/gtk:bg[SELECTED]/1.2" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+ 
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <!-- <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+
+    <gradient type="vertical" x="1" y="2" width="1" height="height-4">
+        <color value="shade/gtk:bg[SELECTED]/1.1" />
+        <color value="shade/gtk:bg[SELECTED]/1.2" />
+    </gradient>
+
+    <!-- Left line -->
+    <!-- <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+
+
+    <gradient type="vertical" x="width-2" y="2" width="1" height="height-4">
+        <color value="shade/gtk:bg[SELECTED]/1.1" />
+        <color value="shade/gtk:bg[SELECTED]/1.2" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="menu_glyph">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" />
+</draw_ops>
+
+<draw_ops name="menu_glyph_unfocused">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" alpha="0.5"/>
+</draw_ops>
+
+<draw_ops name="close_glyph">
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="white" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow">
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow_dark">
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused_lighter">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph">
+    <rectangle color="white" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="white" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="white" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+<draw_ops name="maximize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_unfocused">
+  <rectangle color="gtk:fg[NORMAL]" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+<draw_ops name="maximize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+
+
+</draw_ops>
+
+<draw_ops name="minimize_glyph">
+    <rectangle color="white" x="2" y="height * 2 / 3" width="width-4" height="height - height * 2 / 3 - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused">
+    <rectangle color="gtk:fg[NORMAL]" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="menu_button">
+    <include name="menu_glyph" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="menu_button_unfocused">
+    <include name="menu_glyph_unfocused" x="0" y="0" />
+</draw_ops>
+
+<draw_ops name="menu_button_pressed">
+    <include name="menu_glyph_unfocused" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="minimize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused">
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4" />
+</draw_ops>
+
+<draw_ops name="minimize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused_pressed">
+    <include name="minimize_glyph_unfocused" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+
+<draw_ops name="maximize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused">
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused_pressed">
+    <include name="maximize_glyph_unfocused" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="mini_window_icon">
+  <rectangle color="gtk:bg[NORMAL]" filled="true"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <rectangle color="gtk:fg[NORMAL]" filled="false"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <line color="gtk:fg[NORMAL]" width="2"
+        x1="0" y1="1" x2="width" y2="1"/>
+</draw_ops>
+
+<draw_ops name="restore_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+	<include name="maximize_glyph_shadow" x="3" y="5" width="width-6" height="height-6" />
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_prelight">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="3" y="5" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused">
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused_pressed">
+    <include name="maximize_glyph_unfocused" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="close_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow" x="2" y="4" width="width-4" height="height-4" />
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused">
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused_pressed">
+    <include name="close_glyph_unfocused" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel">
+  <rectangle color="shade/gtk:bg[NORMAL]/0.5"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel_unfocused">  
+  <rectangle color="shade/gtk:bg[NORMAL]/0.7"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="title_background">
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.3" x="1" y="1" width="width-3" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+
+    <gradient type="vertical" x="2" y="2" width="width-4" height="height-3">
+        <color value="shade/gtk:bg[SELECTED]/0.9"/>
+	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    </gradient> 
+    
+    <line color="shade/gtk:bg[SELECTED]/0.8"
+        x1="1" y1="height-1"
+        x2="width-2" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.25"
+        x1="1" y1="height-2"
+        x2="width-2" y2="height-2" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="4" y1="1" x2="4" y2="1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+</draw_ops>
+
+<draw_ops name="title_background_maximized">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.3" x="0" y="1" width="width-2" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-1" y1="1" x2="width-1" y2="height-2"/>
+    
+    <gradient type="vertical" x="1" y="2" width="width-2" height="height-3">
+    	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    </gradient>
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/1.3" x="0" y="1" width="width-1" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/0.8"
+        x1="0" y1="height-1"
+        x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.25"
+        x1="0" y1="height-2"
+        x2="width-1" y2="height-2" />
+</draw_ops>
+
+<draw_ops name="title_unfocused_background">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="1" y1="1" x2="width-2" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="1" y1="1" x2="1" y2="height-1"/>
+
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="width-2" y1="1" x2="width-2" y2="height" />
+
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="4" y1="1" x2="4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="3" y1="2" x2="4" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+</draw_ops>
+
+<draw_ops name="title_unfocused_background_maximized">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="0" y="1" width="width" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="0" y1="1" x2="width-1" y2="1"/>
+
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<draw_ops name="focus_outline">
+    <line color="shade/gtk:bg[NORMAL]/1.5"
+    	  x1="1" y1="title_height" x2="1" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/1.5"
+	  x1="width-2" y1="title_height" x2="width-2" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/1.5"
+	  x1="2" y1="height-2" x2="width-2" y2="height-2" />
+</draw_ops>
+
+<draw_ops name="focus_background">
+  <include name="outer_bevel"/>
+  <include name="focus_outline"/>
+</draw_ops>
+
+<draw_ops name="unfocus_background">
+    <include name="outer_bevel_unfocused" />
+    <include name="focus_outline" />
+</draw_ops>
+
+<draw_ops name="title_text_focused_with_icon">
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) - 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+
+     
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) - 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) + 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(0) + 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+        
+    <title color="#ffffff"
+           x="(0)"
+           y="(((height - title_height) / 2) `max` 0)"/>
+ 
+</draw_ops>
+
+<draw_ops name="title_text_with_icon">
+    <title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5"
+           x="(0)"
+           y="((height - title_height) / 2) `max` 0"/> 
+</draw_ops>
+
+<draw_ops name="title_normal">
+  <include name="title_text_with_icon"/>
+</draw_ops>
+
+<draw_ops name="title_focused">
+  <include name="title_text_focused_with_icon"/>
+</draw_ops>
+
+<frame_style name="normal_unfocused" geometry="normal">
+    <piece position="entire_background" draw_ops="unfocus_background"/>
+    <piece position="titlebar" draw_ops="title_unfocused_background"/>
+    <piece position="title" draw_ops="title_normal"/>
+
+  <button function="close" state="normal" draw_ops="close_button_unfocused"/>
+  <button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+  <button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+  <button function="menu" state="normal" draw_ops="menu_button_unfocused"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_unfocused"/>
+</frame_style>
+
+<frame_style name="normal_focused" geometry="normal">
+  <piece position="entire_background" draw_ops="focus_background"/>
+  <piece position="titlebar" draw_ops="title_background"/>  
+  <piece position="title" draw_ops="title_focused"/>
+  <button function="close" state="normal" draw_ops="close_button"/>
+  <button function="close" state="pressed" draw_ops="close_button_pressed"/>
+  <button function="close" state="prelight" draw_ops="close_button_focus"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+  <button function="minimize" state="prelight" draw_ops="minimize_button_focus" />
+  <button function="maximize" state="normal" draw_ops="maximize_button"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="maximize_button_focus"/>
+  <button function="menu" state="normal" draw_ops="menu_button"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="normal_small_borders" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="blank"/>
+  <piece position="titlebar" draw_ops="title_unfocused_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="normal_small_borders" parent="normal_focused">
+  <piece position="entire_background" draw_ops="focus_outline"/>
+  <piece position="titlebar" draw_ops="title_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="restore_button_prelight" />
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="outer_bevel"/>
+  <piece position="titlebar" draw_ops="blank"/>
+  <piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style_set name="normal">
+<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+<frame focus="yes" state="maximized" style="maximized_focused"/>
+<frame focus="no" state="maximized" style="maximized_unfocused"/>
+<frame focus="yes" state="shaded" style="normal_focused"/>
+<frame focus="no" state="shaded" style="normal_unfocused"/>
+<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/>
+<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+<frame focus="yes" state="normal" resize="both" style="border"/>
+<frame focus="no" state="normal" resize="both" style="border"/>
+<frame focus="yes" state="maximized" style="border"/>
+<frame focus="no" state="maximized" style="border"/>
+<frame focus="yes" state="shaded" style="border"/>
+<frame focus="no" state="shaded" style="border"/>
+<frame focus="yes" state="maximized_and_shaded" style="border"/>
+<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="normal"/>
+<window type="border" style_set="normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button"/>
+
+</metacity_theme>
diff --git a/src/themes/Splint/metacity-theme-1.xml b/src/themes/Splint/metacity-theme-1.xml
new file mode 100644
index 00000000..d10865bb
--- /dev/null
+++ b/src/themes/Splint/metacity-theme-1.xml
@@ -0,0 +1,802 @@
+<?xml version="1.0"?>
+<metacity_theme>
+
+<info>
+  <name>Splint</name>
+  <author>Brandon Wright</author>
+  <copyright>2009</copyright>
+  <date>January 21, 2009</date>
+  <description>A theme designed around the Tango style.</description>
+</info>
+
+<frame_geometry name="normal" rounded_top_left="true" rounded_top_right="true">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="4"/>
+  <distance name="right_titlebar_edge" value="4"/>
+  <aspect_ratio name="button" value="1"/>
+  <distance name="title_vertical_pad" value="2"/>
+  <border name="title_border" left="3" right="4" top="2" bottom="2"/>
+  <border name="button_border" left="1" right="1" top="3" bottom="3"/>
+</frame_geometry>
+
+<frame_geometry name="normal_small_borders" parent="normal" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_titlebar_edge" value="1" />
+  <distance name="right_titlebar_edge" value="1" />
+  <distance name="left_width" value="0" />
+  <distance name="right_width" value="0" />
+  <distance name="bottom_height" value="0" />
+</frame_geometry>
+
+<frame_geometry name="utility" parent="normal">
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false" rounded_top_left="false" rounded_top_right="false">
+  <distance name="left_width" value="4"/>
+  <distance name="right_width" value="4"/>
+  <distance name="bottom_height" value="4"/>
+  <distance name="left_titlebar_edge" value="0"/>
+  <distance name="right_titlebar_edge" value="0"/>
+  <distance name="button_width" value="0"/>
+  <distance name="button_height" value="0"/>
+  <distance name="title_vertical_pad" value="4"/>
+  <border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  <border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Buttons -->
+<draw_ops name="button_bg">
+ 
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" />
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+</draw_ops>
+
+<draw_ops name="button_bg_prelight">
+
+    <!-- Do a fill -->
+    <rectangle color="shade/gtk:bg[SELECTED]/1.0" x="1" y="1" width="width-2" height = "height-2" filled="true" />
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" />
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="height-3"           
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="button_pressed_bg">
+
+    <!-- Do a fill -->
+<!--    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="1" y="1" width="width-2" height = "height-2" filled="true" /> -->
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-2">
+        <color value="shade/gtk:bg[SELECTED]/0.9" />
+        <color value="shade/gtk:bg[SELECTED]/1.2" />
+    </gradient>
+
+    <!-- Dark lines -->
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="0" 
+          x2="width-3" y2="0" />
+
+    <!-- Left line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="0" y1="2" 
+          x2="0" y2="height-3" />
+ 
+    <!-- Right line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-1" y1="2" 
+          x2="width-1" y2="height-3" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="2"       y1="height-1" 
+          x2="width-3" y2="height-1" />
+
+    <!-- TL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="1" 
+          x2="1" y2="1" />
+
+    <!-- TR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="1" 
+          x2="width-2" y2="1" />
+
+    <!-- LL Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="1" y1="height-2" 
+          x2="1" y2="height-2" />
+
+    <!-- LR Corner -->
+    <line color="shade/gtk:bg[SELECTED]/0.8" 
+          x1="width-2" y1="height-2" 
+          x2="width-2" y2="height-2" />
+
+    <!-- Lighter Inside -->
+    
+    <!-- Top line -->
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2"       y1="1" 
+          x2="width-3" y2="1" />
+
+    <!-- Bottom line -->
+    <line color="shade/gtk:bg[SELECTED]/1.2" 
+          x1="2"       y1="height-2" 
+          x2="width-3" y2="height-2" />
+
+    <!-- Left line -->
+    <!-- <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="1" y1="2" 
+          x2="1" y2="height-3" /> -->
+
+    <gradient type="vertical" x="1" y="2" width="1" height="height-4">
+        <color value="shade/gtk:bg[SELECTED]/1.1" />
+        <color value="shade/gtk:bg[SELECTED]/1.2" />
+    </gradient>
+
+    <!-- Left line -->
+    <!-- <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-2" y1="2" 
+          x2="width-2" y2="height-3" /> -->
+
+
+    <gradient type="vertical" x="width-2" y="2" width="1" height="height-4">
+        <color value="shade/gtk:bg[SELECTED]/1.1" />
+        <color value="shade/gtk:bg[SELECTED]/1.2" />
+    </gradient>
+
+    <!-- Corners -->
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="2" y1="2" 
+          x2="2" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.0" 
+          x1="width-3" y1="2" 
+          x2="width-3" y2="2" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="2" y1="height-3" 
+          x2="2" y2="height-3" />
+    <line color="shade/gtk:bg[SELECTED]/1.1" 
+          x1="width-3" y1="height-3" 
+          x2="width-3" y2="height-3" />
+
+</draw_ops>
+
+<draw_ops name="menu_glyph">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" />
+</draw_ops>
+
+<draw_ops name="menu_glyph_unfocused">
+    <icon x="(width-mini_icon_width)/2"
+          y="(height-mini_icon_height)/2"
+          width="mini_icon_width" height="mini_icon_height" alpha="0.5"/>
+</draw_ops>
+
+<draw_ops name="close_glyph">
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/white/gtk:bg[SELECTED]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="white" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow">
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_shadow_dark">
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="close_glyph_unfocused_lighter">
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="2" x2="width-3" y2="height-4"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="3" x2="width-4" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="2" y1="height-4" x2="width-4" y2="2"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.75" x1="3" y1="height-3" x2="width-3" y2="3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="2"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph">
+    <rectangle color="white" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="white" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="white" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="white" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+<draw_ops name="maximize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.85" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="shade/gtk:bg[SELECTED]/0.8" x1="width-3" y1="2" x2="width-3" y2="height-3"/>
+</draw_ops>
+
+<draw_ops name="maximize_glyph_unfocused">
+  <rectangle color="gtk:fg[NORMAL]" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="gtk:fg[NORMAL]" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+</draw_ops>
+<draw_ops name="maximize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="2" width="width-4" height="height/4" filled="true"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="2" x2="2" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="2" y1="height-3" x2="width-3" y2="height-3"/>
+    <line color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x1="width-3" y1="2" x2="width-3" y2="height-3"/> 
+
+
+</draw_ops>
+
+<draw_ops name="minimize_glyph">
+    <rectangle color="white" x="2" y="height * 2 / 3" width="width-4" height="height - height * 2 / 3 - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.85" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_shadow_dark">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.8" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused">
+    <rectangle color="gtk:fg[NORMAL]" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="minimize_glyph_unfocused_lighter">
+    <rectangle color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5" x="2" y="height * 2 / 3" width="width-4" height="height - (height * 2 / 3) - 2" filled="true" />
+</draw_ops>
+
+<draw_ops name="menu_button">
+    <include name="menu_glyph" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="menu_button_unfocused">
+    <include name="menu_glyph_unfocused" x="0" y="0" />
+</draw_ops>
+
+<draw_ops name="menu_button_pressed">
+    <include name="menu_glyph_unfocused" x="0" y="0"/>
+</draw_ops>
+
+<draw_ops name="minimize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="minimize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused">
+    <include name="minimize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4" />
+</draw_ops>
+
+<draw_ops name="minimize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="minimize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="minimize_button_unfocused_pressed">
+    <include name="minimize_glyph_unfocused" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+
+<draw_ops name="maximize_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused">
+    <include name="maximize_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_unfocused_pressed">
+    <include name="maximize_glyph_unfocused" x="2" y="2" width="width-4" height="height-4"/> 
+</draw_ops>
+
+<draw_ops name="maximize_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="mini_window_icon">
+  <rectangle color="gtk:bg[NORMAL]" filled="true"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <rectangle color="gtk:fg[NORMAL]" filled="false"
+             x="0" y="0" width="width-1" height="height-1"/>
+  <line color="gtk:fg[NORMAL]" width="2"
+        x1="0" y1="1" x2="width" y2="1"/>
+</draw_ops>
+
+<draw_ops name="restore_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+	<include name="maximize_glyph_shadow" x="3" y="5" width="width-6" height="height-6" />
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_prelight">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="maximize_glyph_shadow_dark" x="3" y="5" width="width-6" height="height-6"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused">
+    <include name="maximize_glyph_unfocused_lighter" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="maximize_glyph" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="restore_button_unfocused_pressed">
+    <include name="maximize_glyph_unfocused" x="3" y="3" width="width-6" height="height-6"/>
+</draw_ops>
+
+<draw_ops name="close_button">
+    <include name="button_bg" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow" x="2" y="4" width="width-4" height="height-4" />
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_focus">
+    <include name="button_bg_prelight" x="0" y="0" width="width" height="height" />
+    <include name="close_glyph_shadow_dark" x="2" y="4" width="width-4" height="height-4"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused">
+    <include name="close_glyph_unfocused_lighter" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_unfocused_pressed">
+    <include name="close_glyph_unfocused" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="close_button_pressed">
+    <include name="button_pressed_bg"/>
+    <include name="close_glyph" x="2" y="2" width="width-4" height="height-4"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel">
+  <rectangle color="shade/gtk:bg[NORMAL]/0.5"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="outer_bevel_unfocused">  
+  <rectangle color="shade/gtk:bg[NORMAL]/0.7"
+      x="0" y="0" width="width-1" height="height-1"/>
+</draw_ops>
+
+<draw_ops name="title_background">
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.3" x="1" y="1" width="width-3" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-2" y1="1" x2="width-2" y2="height-2"/>
+
+    <gradient type="vertical" x="2" y="2" width="width-4" height="height-3">
+        <color value="shade/gtk:bg[SELECTED]/0.9"/>
+	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    </gradient> 
+    
+    <line color="shade/gtk:bg[SELECTED]/0.8"
+        x1="1" y1="height-1"
+        x2="width-2" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.25"
+        x1="1" y1="height-2"
+        x2="width-2" y2="height-2" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="4" y1="1" x2="4" y2="1" />
+
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[SELECTED]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="3" y1="2" x2="4" y2="2" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+</draw_ops>
+
+<draw_ops name="title_background_maximized">
+    <rectangle color="shade/gtk:bg[SELECTED]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+    <rectangle color="shade/gtk:bg[SELECTED]/1.3" x="0" y="1" width="width-2" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/1.3" x1="width-1" y1="1" x2="width-1" y2="height-2"/>
+    
+    <gradient type="vertical" x="1" y="2" width="width-2" height="height-3">
+    	<color value="shade/gtk:bg[SELECTED]/0.9"/>
+    	<color value="shade/gtk:bg[SELECTED]/1.1"/>
+    </gradient>
+    
+    <rectangle color="shade/gtk:bg[SELECTED]/1.3" x="0" y="1" width="width-1" height="height-3"/>
+    
+    <line color="shade/gtk:bg[SELECTED]/0.8"
+        x1="0" y1="height-1"
+        x2="width-1" y2="height-1" />
+
+    <line color="shade/gtk:bg[SELECTED]/1.25"
+        x1="0" y1="height-2"
+        x2="width-1" y2="height-2" />
+</draw_ops>
+
+<draw_ops name="title_unfocused_background">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="1" y="1" width="width-2" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="1" y1="1" x2="width-2" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="1" y1="1" x2="1" y2="height-1"/>
+
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="width-2" y1="1" x2="width-2" y2="height" />
+
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="3" x2="3" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="1" y1="4" x2="1" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="4" y1="1" x2="4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-4" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-5" y1="1" x2="width-5" y2="1" />
+    <line color="shade/gtk:bg[NORMAL]/0.7" x1="width-2" y1="3" x2="width-2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="2" y1="3" x2="2" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="3" y1="2" x2="4" y2="2" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="width-3" y1="3" x2="width-3" y2="4" />
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="width-5" y1="2" x2="width-4" y2="2" />
+
+</draw_ops>
+
+<draw_ops name="title_unfocused_background_maximized">
+    <rectangle color="shade/gtk:bg[NORMAL]/0.7" x="0" y="0" width="width" height="height" filled="true"/>
+   
+    <gradient type="vertical" x="0" y="1" width="width" height="height-1">
+   	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+	<color value="shade/gtk:bg[NORMAL]/1.0"/>
+    </gradient>
+
+    <line color="shade/gtk:bg[NORMAL]/1.5" x1="0" y1="1" x2="width-1" y2="1"/>
+
+</draw_ops>
+
+<draw_ops name="blank">
+<!-- nothing -->
+</draw_ops>
+
+<draw_ops name="focus_outline">
+    <line color="shade/gtk:bg[NORMAL]/1.5"
+    	  x1="1" y1="title_height" x2="1" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/1.5"
+	  x1="width-2" y1="title_height" x2="width-2" y2="height-2" />
+    <line color="shade/gtk:bg[NORMAL]/1.5"
+	  x1="2" y1="height-2" x2="width-2" y2="height-2" />
+</draw_ops>
+
+<draw_ops name="focus_background">
+  <include name="outer_bevel"/>
+  <include name="focus_outline"/>
+</draw_ops>
+
+<draw_ops name="unfocus_background">
+    <include name="outer_bevel_unfocused" />
+    <include name="focus_outline" />
+</draw_ops>
+
+<draw_ops name="title_text_focused_with_icon">
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) - 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+
+     
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) - 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) + 1"
+           y="(((height - title_height) / 2) `max` 0) + 1"/> 
+
+    <title color="shade/gtk:bg[SELECTED]/0.8"
+           x="(((width  - title_width)  / 2) `max` 0) + 1"
+           y="(((height - title_height) / 2) `max` 0) - 1"/>
+        
+    <title color="#ffffff"
+           x="(((width  - title_width)  / 2) `max` 0)"
+           y="(((height - title_height) / 2) `max` 0)"/>
+ 
+</draw_ops>
+
+<draw_ops name="title_text_with_icon">
+    <title color="blend/gtk:fg[NORMAL]/gtk:bg[NORMAL]/0.5"
+           x="(((width - title_width)  / 2) `max` 0)"
+           y="((height - title_height) / 2) `max` 0"/> 
+</draw_ops>
+
+<draw_ops name="title_normal">
+  <include name="title_text_with_icon"/>
+</draw_ops>
+
+<draw_ops name="title_focused">
+  <include name="title_text_focused_with_icon"/>
+</draw_ops>
+
+<frame_style name="normal_unfocused" geometry="normal">
+    <piece position="entire_background" draw_ops="unfocus_background"/>
+    <piece position="titlebar" draw_ops="title_unfocused_background"/>
+    <piece position="title" draw_ops="title_normal"/>
+
+  <button function="close" state="normal" draw_ops="close_button_unfocused"/>
+  <button function="close" state="pressed" draw_ops="close_button_unfocused_pressed"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button_unfocused"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_unfocused_pressed"/>
+  <button function="maximize" state="normal" draw_ops="maximize_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_unfocused_pressed"/>
+  <button function="menu" state="normal" draw_ops="menu_button_unfocused"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_unfocused"/>
+</frame_style>
+
+<frame_style name="normal_focused" geometry="normal">
+  <piece position="entire_background" draw_ops="focus_background"/>
+  <piece position="titlebar" draw_ops="title_background"/>  
+  <piece position="title" draw_ops="title_focused"/>
+  <button function="close" state="normal" draw_ops="close_button"/>
+  <button function="close" state="pressed" draw_ops="close_button_pressed"/>
+  <button function="close" state="prelight" draw_ops="close_button_focus"/>
+  <button function="minimize" state="normal" draw_ops="minimize_button"/>
+  <button function="minimize" state="pressed" draw_ops="minimize_button_pressed"/>
+  <button function="minimize" state="prelight" draw_ops="minimize_button_focus" />
+  <button function="maximize" state="normal" draw_ops="maximize_button"/>
+  <button function="maximize" state="pressed" draw_ops="maximize_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="maximize_button_focus"/>
+  <button function="menu" state="normal" draw_ops="menu_button"/>
+  <button function="menu" state="pressed" draw_ops="menu_button_pressed"/>
+
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="normal_small_borders" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="blank"/>
+  <piece position="titlebar" draw_ops="title_unfocused_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button_unfocused"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="normal_small_borders" parent="normal_focused">
+  <piece position="entire_background" draw_ops="focus_outline"/>
+  <piece position="titlebar" draw_ops="title_background_maximized"/>
+  <button function="maximize" state="normal" draw_ops="restore_button"/>
+  <button function="maximize" state="pressed" draw_ops="restore_button_pressed"/>
+  <button function="maximize" state="prelight" draw_ops="restore_button_prelight" />
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_unfocused">
+  <piece position="entire_background" draw_ops="outer_bevel"/>
+  <piece position="titlebar" draw_ops="blank"/>
+  <piece position="title" draw_ops="blank"/>
+</frame_style>
+
+<frame_style_set name="normal">
+<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+<frame focus="yes" state="maximized" style="maximized_focused"/>
+<frame focus="no" state="maximized" style="maximized_unfocused"/>
+<frame focus="yes" state="shaded" style="normal_focused"/>
+<frame focus="no" state="shaded" style="normal_unfocused"/>
+<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/>
+<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/>
+</frame_style_set>
+
+<frame_style_set name="border">
+<frame focus="yes" state="normal" resize="both" style="border"/>
+<frame focus="no" state="normal" resize="both" style="border"/>
+<frame focus="yes" state="maximized" style="border"/>
+<frame focus="no" state="maximized" style="border"/>
+<frame focus="yes" state="shaded" style="border"/>
+<frame focus="no" state="shaded" style="border"/>
+<frame focus="yes" state="maximized_and_shaded" style="border"/>
+<frame focus="no" state="maximized_and_shaded" style="border"/>
+</frame_style_set>
+
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="normal"/>
+<window type="modal_dialog" style_set="normal"/>
+<window type="menu" style_set="normal"/>
+<window type="utility" style_set="normal"/>
+<window type="border" style_set="normal"/>
+
+<menu_icon function="close" state="normal" draw_ops="close_button"/>
+<menu_icon function="maximize" state="normal" draw_ops="maximize_button"/>
+<menu_icon function="unmaximize" state="normal" draw_ops="restore_button"/>
+<menu_icon function="minimize" state="normal" draw_ops="minimize_button"/>
+
+</metacity_theme>
diff --git a/src/themes/WinMe/close_normal.png b/src/themes/WinMe/close_normal.png
new file mode 100644
index 00000000..644378f9
--- /dev/null
+++ b/src/themes/WinMe/close_normal.png
diff --git a/src/themes/WinMe/close_normal_small.png b/src/themes/WinMe/close_normal_small.png
new file mode 100644
index 00000000..bd7495c8
--- /dev/null
+++ b/src/themes/WinMe/close_normal_small.png
diff --git a/src/themes/WinMe/close_pressed.png b/src/themes/WinMe/close_pressed.png
new file mode 100644
index 00000000..42970c2d
--- /dev/null
+++ b/src/themes/WinMe/close_pressed.png
diff --git a/src/themes/WinMe/close_pressed_small.png b/src/themes/WinMe/close_pressed_small.png
new file mode 100644
index 00000000..c7c98a1e
--- /dev/null
+++ b/src/themes/WinMe/close_pressed_small.png
diff --git a/src/themes/WinMe/maximize_normal.png b/src/themes/WinMe/maximize_normal.png
new file mode 100644
index 00000000..41b7694a
--- /dev/null
+++ b/src/themes/WinMe/maximize_normal.png
diff --git a/src/themes/WinMe/maximize_pressed.png b/src/themes/WinMe/maximize_pressed.png
new file mode 100644
index 00000000..68137306
--- /dev/null
+++ b/src/themes/WinMe/maximize_pressed.png
diff --git a/src/themes/WinMe/metacity-theme-1.xml b/src/themes/WinMe/metacity-theme-1.xml
new file mode 100644
index 00000000..29d3aef0
--- /dev/null
+++ b/src/themes/WinMe/metacity-theme-1.xml
@@ -0,0 +1,375 @@
+<?xml version="1.0"?>
+<!--
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
+Notes
+	#d4d0c8 was replaced with gtk:bg[NORMAL]
+
+-->
+<metacity_theme>
+	<info>
+		<name>WinMe</name>
+		<author>Perberos</author>
+		<copyright>&#194; 2007 Srivatsa Kanchi &lt;[email protected]&gt;, 2010 Perberos</copyright>
+		<date>April 22, 2010</date>
+		<description>Windows NT serie style theme</description>
+	</info>
+
+	<frame_geometry name="normal_geometry" has_title="true" rounded_top_left="false" rounded_top_right="false" title_scale="medium" rounded_bottom_left="false" rounded_bottom_right="false">
+		<distance name="left_width" value="4"/>
+		<distance name="right_width" value="4"/>
+		<distance name="bottom_height" value="4"/>
+		<distance name="left_titlebar_edge" value="5"/>
+		<distance name="right_titlebar_edge" value="6"/>
+		<distance name="title_vertical_pad" value="5"/>
+		<distance name="button_width" value="17"/>
+		<distance name="button_height" value="16"/>
+		<border name="title_border" left="0" right="0" top="4" bottom="0"/>
+		<border name="button_border" left="0" right="0" top="3" bottom="0"/>
+	</frame_geometry>
+
+	<frame_geometry name="borderless_geometry" has_title="true" rounded_top_left="false" rounded_top_right="false" title_scale="medium" rounded_bottom_left="false" rounded_bottom_right="false">
+		<distance name="left_width" value="0"/>
+		<distance name="right_width" value="0"/>
+		<distance name="bottom_height" value="0"/>
+		<distance name="left_titlebar_edge" value="1"/>
+		<distance name="right_titlebar_edge" value="2"/>
+		<distance name="title_vertical_pad" value="2"/>
+		<distance name="button_width" value="17"/>
+		<distance name="button_height" value="16"/>
+		<border name="title_border" left="0" right="0" top="0" bottom="0"/>
+		<border name="button_border" left="0" right="0" top="1" bottom="1"/>
+	</frame_geometry>
+
+	<frame_geometry name="utility_geometry" has_title="true" rounded_top_left="false" rounded_top_right="false" title_scale="small" rounded_bottom_left="false" rounded_bottom_right="false">
+		<distance name="left_width" value="3"/>
+		<distance name="right_width" value="3"/>
+		<distance name="bottom_height" value="3"/>
+		<distance name="left_titlebar_edge" value="4"/>
+		<distance name="right_titlebar_edge" value="4"/>
+		<distance name="title_vertical_pad" value="4"/>
+		<distance name="button_width" value="10"/>
+		<distance name="button_height" value="11"/>
+		<border name="title_border" left="0" right="0" top="4" bottom="2"/>
+		<border name="button_border" left="0" right="0" top="2" bottom="0"/>
+	</frame_geometry>
+
+	<frame_geometry name="border_geometry" has_title="false">
+		<distance name="left_width" value="0" />
+		<distance name="right_width" value="0" />
+		<distance name="bottom_height" value="0" />
+		<distance name="left_titlebar_edge" value="0" />
+		<distance name="right_titlebar_edge" value="0" />
+		<distance name="button_width" value="0"/>
+		<distance name="button_height" value="0"/>
+		<distance name="title_vertical_pad" value="0" />
+		<border name="title_border" left="0" right="0" top="0" bottom="0" />
+		<border name="button_border" left="0" right="0" top="0" bottom="0" />
+	</frame_geometry>
+
+	<frame_style name="normal_focused_style" geometry="normal_geometry">
+		<piece position="left_edge">
+			<draw_ops>
+				<rectangle color="gtk:bg[NORMAL]" x="0" y="0" width="width" height="height" filled="true"/>
+				<line color="#ffffff" x1="1" y1="0" x2="1" y2="height" width="1"/>
+			</draw_ops>
+		</piece>
+		<piece position="right_edge">
+			<draw_ops>
+				<rectangle color="gtk:bg[NORMAL]" x="0" y="0" width="width" height="height" filled="true"/>
+				<line color="#808080" x1="width-2" y1="0" x2="width-2" y2="height" width="1"/>
+				<line color="#404040" x1="width-1" y1="0" x2="width-1" y2="height" width="1"/>
+			</draw_ops>
+		</piece>
+		<piece position="bottom_edge">
+			<draw_ops>
+				<rectangle color="gtk:bg[NORMAL]" x="0" y="0" width="width" height="height" filled="true"/>
+				<line color="#808080" x1="1" y1="height-2" x2="width" y2="height-2" width="1"/>
+				<line color="#404040" x1="0" y1="height-1" x2="width" y2="height-1" width="1"/>
+				<line color="#ffffff" x1="1" y1="0" x2="1" y2="height-2" width="1"/>
+				<line color="#404040" x1="width-1" y1="0" x2="width-1" y2="height" width="1"/>
+				<line color="#808080" x1="width-2" y1="0" x2="width-2" y2="height-2" width="1"/>
+			</draw_ops>
+		</piece>
+		<piece position="titlebar">
+			<draw_ops>
+				<rectangle color="gtk:bg[NORMAL]" x="0" y="0" width="width" height="height" filled="true"/>
+				<line color="#ffffff" x1="1" y1="1" x2="1" y2="height" width="1"/>
+				<line color="#ffffff" x1="1" y1="1" x2="width-2" y2="1" width="1"/>
+				<line color="#404040" x1="width-1" y1="0" x2="width-1" y2="height" width="1"/>
+				<line color="#808080" x1="width-2" y1="1" x2="width-2" y2="height" width="1"/>
+				<gradient type="horizontal" x="4" y="4" width="width-8" height="height-5">
+					<color value="#0a246a"/> <!-- #0a246a (10, 36, 106)-->
+					<color value="#526bad"/> <!-- #526bad (82, 107, 173) is a cute color -->
+					<color value="#94b5dc"/> <!-- #94b5dc (148, 181, 220)-->
+					<color value="#a6caf0"/> <!-- #a6caf0 (166, 202, 240) -->
+				</gradient>
+			</draw_ops>
+		</piece>
+
+		<button function="close" state="normal">
+			<draw_ops>
+				<image filename="close_normal.png" x="0" y="0" width="object_width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="close" state="pressed">
+			<draw_ops>
+				<image filename="close_pressed.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="maximize" state="normal">
+			<draw_ops>
+				<image filename="maximize_normal.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="maximize" state="pressed">
+			<draw_ops>
+				<image filename="maximize_pressed.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="minimize" state="normal">
+			<draw_ops>
+				<image filename="minimize_normal.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="minimize" state="pressed">
+			<draw_ops>
+				<image filename="minimize_pressed.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="menu" state="normal">
+			<draw_ops>
+			  <icon x="1" y="0" width="16" height="16"/>
+			</draw_ops>
+		</button>
+		<button function="menu" state="pressed">
+			<draw_ops>
+			  <icon x="1" y="0" width="16" height="16"/>
+			</draw_ops>
+		</button>
+		<piece position="title">
+			<draw_ops>
+				<title x="3" y="2" color="#ffffff"/>
+			</draw_ops>
+		</piece>
+	</frame_style>
+
+	<frame_style name="normal(maximized)_focused_style" geometry="borderless_geometry" parent="normal_focused_style">
+		<piece position="titlebar">
+			<draw_ops>
+				<gradient type="horizontal" x="0" y="0" width="width-0"
+					height="height-0">
+					<color value="#0a246a"/>
+					<color value="#526bad"/>
+					<color value="#94b5dc"/>
+					<color value="#a6caf0"/>
+				</gradient>
+			</draw_ops>
+		</piece>
+		<button function="maximize" state="normal">
+
+			<draw_ops>
+				<image filename="restore_normal.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="maximize" state="pressed">
+			<draw_ops>
+				<image filename="restore_pressed.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+	</frame_style>
+
+	<frame_style name="normal_unfocused_style" geometry="normal_geometry" parent="normal_focused_style">
+		<piece position="titlebar">
+			<draw_ops>
+				<rectangle color="gtk:bg[NORMAL]" x="0" y="0" width="width" height="height" filled="true"/>
+				<line color="#ffffff" x1="1" y1="1" x2="1" y2="height" width="1"/>
+				<line color="#ffffff" x1="1" y1="1" x2="width-2" y2="1" width="1"/>
+				<line color="#404040" x1="width-1" y1="0" x2="width-1" y2="height" width="1"/>
+				<line color="#808080" x1="width-2" y1="1" x2="width-2" y2="height" width="1"/>
+				<gradient type="horizontal" x="4" y="4" width="width-8" height="height-5">
+					<color value="#808080"/>
+					<color value="#8c8c8c"/>
+					<color value="#a5a5a5"/>
+					<color value="#c6bdc6"/>
+					<color value="#c0c0c0"/>
+				</gradient>
+			</draw_ops>
+		</piece>
+		<piece position="title">
+			<draw_ops>
+				<title x="3" y="2" color="gtk:bg[NORMAL]"/>
+			</draw_ops>
+		</piece>
+	</frame_style>
+
+	<frame_style name="normal(maximized)_unfocused_style" geometry="borderless_geometry" parent="normal_unfocused_style">
+		<piece position="titlebar">
+			<draw_ops>
+				<gradient type="horizontal" x="0" y="0" width="width-0" height="height-0">
+					<color value="#808080"/>
+					<color value="#8c8c8c"/>
+					<color value="#a5a5a5"/>
+					<color value="#c6bdc6"/>
+					<color value="#c0c0c0"/>
+				</gradient>
+			</draw_ops>
+		</piece>
+		<button function="maximize" state="normal">
+			<draw_ops>
+				<image filename="restore_normal.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+	</frame_style>
+
+	<frame_style name="utility_focused_style" geometry="utility_geometry">
+		<piece position="entire_background">
+			<draw_ops>
+				<rectangle color="gtk:bg[NORMAL]" x="0" y="0" width="width" height="height" filled="true"/>
+				<rectangle color="#ffffff" x="1" y="1" width="width-3" height="height-3" filled="false"/>
+				<line color="#808080" x1="width-2" y1="1" x2="width-2" y2="height-3"/>
+				<line color="#808080" x1="1" y1="height-2" x2="width-2" y2="height-2"/>
+				<line color="#404040" x1="width-1" y1="0" x2="width-1" y2="height-1"/>
+				<line color="#404040" x1="0" y1="height-1" x2="width-1" y2="height-1"/>
+			</draw_ops>
+		</piece>
+
+		<piece position="titlebar">
+			<draw_ops>
+				<gradient type="horizontal" x="3" y="3" width="width-6" height="height-4">
+					<color value="#0a246a"/>
+					<color value="#526bad"/>
+					<color value="#94b5dc"/>
+					<color value="#a6caf0"/>
+				</gradient>
+			</draw_ops>
+		</piece>
+		<button function="menu" state="normal"><draw_ops/></button>
+		<button function="menu" state="pressed"><draw_ops/></button>
+
+		<piece position="title">
+			<draw_ops>
+				<title x="3" y="2" color="#ffffff"/>
+			</draw_ops>
+		</piece>
+
+		<button function="close" state="normal">
+			<draw_ops>
+				<image filename="close_normal_small.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="close" state="pressed">
+			<draw_ops>
+				<image filename="close_pressed_small.png" x="0" y="0" width="width" height="height"/>
+			</draw_ops>
+		</button>
+		<button function="maximize" state="normal"><draw_ops/></button>
+		<button function="maximize" state="pressed"><draw_ops/></button>
+		<button function="minimize" state="normal"><draw_ops/></button>
+		<button function="minimize" state="pressed"><draw_ops/></button>
+	</frame_style>
+
+	<frame_style name="utility_unfocused_style" geometry="utility_geometry" parent="utility_focused_style">
+		<piece position="titlebar">
+			<draw_ops>
+				<gradient type="horizontal" x="3" y="3" width="width-6" height="height-4">
+					<color value="#808080"/>
+					<color value="#8c8c8c"/>
+					<color value="#a5a5a5"/>
+					<color value="#c6bdc6"/>
+					<color value="#c0c0c0"/>
+				</gradient>
+			</draw_ops>
+		</piece>
+		<piece position="title">
+			<draw_ops>
+				<title x="3" y="2" color="gtk:bg[NORMAL]"/>
+			</draw_ops>
+		</piece>
+	</frame_style>
+
+
+	<frame_style name="border_style" geometry="border_geometry">
+		<button function="close" state="normal"><draw_ops/></button>
+		<button function="close" state="pressed"><draw_ops/></button>
+		<button function="maximize" state="normal"><draw_ops/></button>
+		<button function="maximize" state="pressed"><draw_ops/></button>
+		<button function="minimize" state="normal"><draw_ops/></button>
+		<button function="minimize" state="pressed"><draw_ops/></button>
+		<button function="menu" state="normal"><draw_ops/></button>
+		<button function="menu" state="pressed"><draw_ops/></button>
+	</frame_style>
+
+	<!-- system menu icon : default drawn by metacity -->
+	<menu_icon function="close" state="normal">
+		<draw_ops/>
+	</menu_icon>
+
+	<menu_icon function="maximize" state="normal">
+		<draw_ops/>
+	</menu_icon>
+
+	<menu_icon function="minimize" state="normal">
+		<draw_ops/>
+	</menu_icon>
+
+	<menu_icon function="unmaximize" state="normal">
+		<draw_ops/>
+	</menu_icon>
+
+	<frame_style_set name="normal_set">
+		<frame focus="yes" state="normal" resize="both" style="normal_focused_style"/>
+		<frame focus="no" state="normal" resize="both" style="normal_unfocused_style"/>
+		<frame focus="yes" state="normal" resize="none" style="normal_focused_style"/>
+		<frame focus="no" state="normal" resize="none" style="normal_unfocused_style"/>
+		<frame focus="yes" state="maximized" style="normal(maximized)_focused_style"/>
+		<frame focus="no" state="maximized" style="normal(maximized)_unfocused_style"/>
+		<frame focus="yes" state="shaded" style="normal_focused_style"/>
+		<frame focus="no" state="shaded" style="normal_unfocused_style"/>
+		<frame focus="yes" state="maximized_and_shaded" style="normal(maximized)_focused_style"/>
+		<frame focus="no" state="maximized_and_shaded" style="normal_unfocused_style"/>
+	</frame_style_set>
+
+
+	<frame_style_set name="border_set">
+		<frame focus="yes" state="normal" resize="both" style="border_style" />
+		<frame focus="no"  state="normal" resize="both" style="border_style" />
+		<frame focus="yes" state="normal" resize="none" style="border_style" />
+		<frame focus="no"  state="normal" resize="none" style="border_style" />
+		<frame focus="yes" state="maximized" style="border_style" />
+		<frame focus="no"  state="maximized" style="border_style" />
+		<frame focus="yes" state="shaded" style="border_style" />
+		<frame focus="no"  state="shaded" style="border_style" />
+		<frame focus="yes" state="maximized_and_shaded" style="border_style" />
+		<frame focus="no"  state="maximized_and_shaded" style="border_style" />
+	</frame_style_set>
+
+	<frame_style_set name="utility_set" parent="border_set">
+		<frame focus="yes" state="normal" resize="both" style="utility_focused_style" />
+		<frame focus="no"  state="normal" resize="both" style="utility_unfocused_style" />
+		<frame focus="yes" state="normal" resize="none" style="utility_focused_style" />
+		<frame focus="no"  state="normal" resize="none" style="utility_unfocused_style" />
+	</frame_style_set>
+
+
+	<window type="normal" style_set="normal_set"/>
+	<window type="dialog" style_set="normal_set"/>
+	<window type="modal_dialog" style_set="normal_set"/>
+	<window type="menu" style_set="utility_set"/>
+	<window type="utility" style_set="utility_set"/>
+	<window type="border" style_set="border_set"/>
+
+</metacity_theme>
diff --git a/src/themes/WinMe/minimize_normal.png b/src/themes/WinMe/minimize_normal.png
new file mode 100644
index 00000000..cfa36387
--- /dev/null
+++ b/src/themes/WinMe/minimize_normal.png
diff --git a/src/themes/WinMe/minimize_pressed.png b/src/themes/WinMe/minimize_pressed.png
new file mode 100644
index 00000000..4b873d15
--- /dev/null
+++ b/src/themes/WinMe/minimize_pressed.png
diff --git a/src/themes/WinMe/restore_normal.png b/src/themes/WinMe/restore_normal.png
new file mode 100644
index 00000000..95ab85ec
--- /dev/null
+++ b/src/themes/WinMe/restore_normal.png
diff --git a/src/themes/WinMe/restore_pressed.png b/src/themes/WinMe/restore_pressed.png
new file mode 100644
index 00000000..2b117058
--- /dev/null
+++ b/src/themes/WinMe/restore_pressed.png
diff --git a/src/themes/eOS/close.png b/src/themes/eOS/close.png
new file mode 100644
index 00000000..6ba9495e
--- /dev/null
+++ b/src/themes/eOS/close.png
diff --git a/src/themes/eOS/close_unfocused.png b/src/themes/eOS/close_unfocused.png
new file mode 100644
index 00000000..bdff535c
--- /dev/null
+++ b/src/themes/eOS/close_unfocused.png
diff --git a/src/themes/eOS/close_unfocused_over.png b/src/themes/eOS/close_unfocused_over.png
new file mode 100644
index 00000000..6ba9495e
--- /dev/null
+++ b/src/themes/eOS/close_unfocused_over.png
diff --git a/src/themes/eOS/maximize.png b/src/themes/eOS/maximize.png
new file mode 100644
index 00000000..785aa133
--- /dev/null
+++ b/src/themes/eOS/maximize.png
diff --git a/src/themes/eOS/maximize_unfocused.png b/src/themes/eOS/maximize_unfocused.png
new file mode 100644
index 00000000..4c76ed67
--- /dev/null
+++ b/src/themes/eOS/maximize_unfocused.png
diff --git a/src/themes/eOS/maximize_unfocused_over.png b/src/themes/eOS/maximize_unfocused_over.png
new file mode 100644
index 00000000..785aa133
--- /dev/null
+++ b/src/themes/eOS/maximize_unfocused_over.png
diff --git a/src/themes/eOS/menu.png b/src/themes/eOS/menu.png
new file mode 100644
index 00000000..1e02701c
--- /dev/null
+++ b/src/themes/eOS/menu.png
diff --git a/src/themes/eOS/menu_prelight.png b/src/themes/eOS/menu_prelight.png
new file mode 100644
index 00000000..c7dbd0a2
--- /dev/null
+++ b/src/themes/eOS/menu_prelight.png
diff --git a/src/themes/eOS/metacity-theme-1.xml b/src/themes/eOS/metacity-theme-1.xml
new file mode 100644
index 00000000..62463cc9
--- /dev/null
+++ b/src/themes/eOS/metacity-theme-1.xml
@@ -0,0 +1,537 @@
+<?xml version="1.0"?>
+
+<metacity_theme>
+<info>
+ 	<name>eOS based on radiance</name>
+  	<author>original authors: Kenneth Wimer, James Schriver, edited by Uhave2pay4</author>
+  	<copyright>Canonical Ltd.</copyright>
+  	<date>Mar 19, 2010</date>
+ 	<description>Metacity theme</description>
+</info>
+
+<!-- General window layout -->
+<frame_geometry name="frame_geometry_normal" title_scale="medium" rounded_top_left="true" rounded_top_right="true"  rounded_bottom_left="false" rounded_bottom_right="false">
+ 	<distance name="left_width" value="1"/>
+	<distance name="right_width" value="1"/>
+	<distance name="bottom_height" value="1"/>
+	<distance name="left_titlebar_edge" value="10"/>
+	<distance name="right_titlebar_edge" value="10"/>
+	<distance name="button_width" value="20"/>
+	<distance name="button_height" value="20"/>
+	<distance name="title_vertical_pad" value="8"/>
+	<border name="title_border" left="2" right="2" top="2" bottom="0"/>
+	<border name="button_border" left="0" right="0" top="2" bottom="1"/>
+</frame_geometry>
+
+<frame_geometry name="geometry_maximized" rounded_top_left="false" rounded_top_right="false" rounded_bottom_left="false" rounded_bottom_right="false">
+	<distance name="left_width" value="0"/>
+	<distance name="right_width" value="0"/>
+	<distance name="bottom_height" value="0"/>
+	<distance name="left_titlebar_edge" value="10"/>
+  	<distance name="right_titlebar_edge" value="10"/>
+  	<distance name="button_width" value="20"/>
+  	<distance name="button_height" value="20"/>
+  	<distance name="title_vertical_pad" value="8"/>
+  	<border name="title_border" left="2" right="2" top="2" bottom="0"/>
+ 	<border name="button_border" left="0" right="0" top="2" bottom="1"/>
+</frame_geometry>
+
+<frame_geometry name="border" has_title="false">
+  	<distance name="left_width" value="3"/>
+  	<distance name="right_width" value="3"/>
+  	<distance name="bottom_height" value="3"/>
+  	<distance name="left_titlebar_edge" value="0"/>
+  	<distance name="right_titlebar_edge" value="0"/>
+  	<distance name="button_width" value="0"/>
+  	<distance name="button_height" value="0"/>
+  	<distance name="title_vertical_pad" value="3"/>
+  	<border name="title_border" left="0" right="0" top="0" bottom="0"/>
+  	<border name="button_border" left="0" right="0" top="0" bottom="0"/>
+</frame_geometry>
+
+<!-- Window Title -->
+
+<draw_ops name="draw_title_text_normal">
+  <title color="#f7f9fa"
+         x="((3 `max` (width-title_width)) / 2)"
+         y="(((height - title_height) / 2) `max` 0)+1"/>
+  <title color="#f7f9fa"
+         x="((3 `max` (width-title_width)) / 2)"
+         y="(((height - title_height) / 2) `max` 0)-1"/>
+  <title color="#f7f9fa"
+         x="((3 `max` (width-title_width)) / 2)-1"
+         y="(((height - title_height) / 2) `max` 0)"/>
+  <title color="#f7f9fa"
+         x="((3 `max` (width-title_width)) / 2)+1"
+         y="(((height - title_height) / 2) `max` 0)"/>
+  <title color="#3c3c3c"
+         x="((3 `max` (width-title_width)) / 2)"
+         y="(((height - title_height) / 2) `max` 0)"/>
+</draw_ops>
+
+<draw_ops name="draw_title_text_inactive">
+  <title color="#e8e5dd"
+         x="((3 `max` (width-title_width)) / 2)"
+         y="(((height - title_height) / 2) `max` 0)+1"/>
+  <title color="#e8e5dd"
+         x="((3 `max` (width-title_width)) / 2)"
+         y="(((height - title_height) / 2) `max` 0)-1"/>
+  <title color="#e8e5dd"
+         x="((3 `max` (width-title_width)) / 2)-1"
+         y="(((height - title_height) / 2) `max` 0)"/>
+  <title color="#e8e5dd"
+         x="((3 `max` (width-title_width)) / 2)+1"
+         y="(((height - title_height) / 2) `max` 0)"/>
+  <title color="#666"
+         x="((3 `max` (width-title_width)) / 2)"
+         y="(((height - title_height) / 2) `max` 0)"/>
+</draw_ops>
+
+<draw_ops name="draw_title">
+    <!-- Background gradient -->
+    <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        <color value="#f4f4f4" />
+        <color value="#d6d6d6" />
+        <color value="#d6d6d6" />
+    </gradient>
+    
+    <!-- Topmost dark line -->
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="width" y1="0" y2="0"/>
+    
+    <!-- Darkening of the left arch -->
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="4" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="2" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="1" y1="3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="1" y1="4" y2="4"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="0" y1="5" y2="40"/>
+    
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-5" x2="width" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-3" x2="width" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-2" x2="width" y1="3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-2" x2="width" y1="4" y2="4"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-1" x2="width" y1="5" y2="90"/>
+    
+    <!-- Top highlight -->
+    <!-- This uses <tint> (which supports alpha) instead of <line> (which doesn't) -->
+    <tint color="#ffffff" alpha="0.55" x="5" y="1" width="width - 10" height="1"/> 
+    <tint color="#ffffff" alpha="0.15" x="5" y="2" width="width - 10" height="1"/> 
+    
+</draw_ops>
+
+<draw_ops name="draw_title_inactive">
+    <!-- Background gradient -->
+    <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        <color value="#f4f4f4" />
+        <color value="#d6d6d6" />
+    </gradient>
+    
+    <!-- Topmost dark line -->
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="width" y1="0" y2="0"/>
+    
+    <!-- Darkening of the left arch -->
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="4" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="2" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="1" y1="3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="1" y1="4" y2="4"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="0" y1="5" y2="40"/>
+    
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-5" x2="width" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-3" x2="width" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-2" x2="width" y1="3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-2" x2="width" y1="4" y2="4"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-1" x2="width" y1="5" y2="90"/>
+    
+    <!-- Top highlight -->
+    <tint color="#ffffff" alpha="0.55" x="5" y="1" width="width - 10" height="1"/> 
+    <tint color="#ffffff" alpha="0.15" x="5" y="2" width="width - 10" height="1"/> 
+</draw_ops>
+
+
+<draw_ops name="draw_title_maximized">
+    	<!-- Background gradient -->
+   	 <gradient type="vertical" x="0" y="0" width="width+9" height="height">
+        	<color value="#f4f4f4" />
+        	<color value="#d6d6d6" />
+        	<color value="#d6d6d6" />
+    	</gradient>
+    
+    	<!-- Topmost dark line -->
+    	<line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="width" y1="0" y2="0"/>
+    
+    	<!-- Top highlight -->
+    	<tint color="#ffffff" alpha="0.55" x="0" y="1" width="width" height="1"/> 
+    	<tint color="#ffffff" alpha="0.15" x="0" y="2" width="width" height="1"/> 
+</draw_ops>
+
+<draw_ops name="draw_title_maximized_inactive">
+	<include name="draw_title_maximized" />
+
+	<!-- Background gradient -->
+    	<gradient type="vertical" x="0" y="0" width="width+9" height="height">
+       	 	<color value="#f4f4f4" />
+        	<color value="#d6d6d6" />
+   	 </gradient>
+</draw_ops>
+
+<!-- Window Frames -->
+
+<draw_ops name="draw_frame">
+	<rectangle color="shade/gtk:bg[NORMAL]/0.74" x="0" y="0" width="width" height="height" filled="true"/>
+</draw_ops>
+
+<!--bottom border-->
+<draw_ops name="bottom_edge">
+<line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="width" y1="height-1" y2="height-1"/>
+<!--bottom left rounding-->
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="1" y1="0" y2="0"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="1" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="2" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="4" y1="3" y2="3"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="0" x2="10" y1="4" y2="4"/>
+<!--bottom right rounding-->
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-2" x2="width-1" y1="0" y2="0"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-2" x2="width-1" y1="1" y2="1"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-3" x2="width-2" y1="2" y2="2"/>
+    <line color="shade/gtk:bg[NORMAL]/0.74" x1="width-5" x2="width-3" y1="3" y2="3"/>
+</draw_ops>
+
+<draw_ops name="border">
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="1" y1="height - 2" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/0.88" x1="width - 2" y1="1" x2="width - 2" y2="height - 2"/>
+	<line color="shade/gtk:bg[NORMAL]/1.4" x1="1" y1="1" x2="width - 2" y2="1"/>
+	<line color="shade/gtk:bg[NORMAL]/1.4" x1="1" y1="1" x2="1" y2="height - 2"/>
+	
+	<rectangle color="shade/gtk:bg[NORMAL]/0.25" filled="false"
+	           x="0" y="0"
+	           width="width - 1"
+	           height="height - 1"/>
+</draw_ops>
+
+<!-- BUTTONS -->
+
+<!-- Button trough -->
+	<draw_ops name="left_left_background_focused_normal">
+		<image filename="trough_left.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_left_background_focused_pressed">
+		<image filename="trough_left.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_middle_background_focused_normal">
+		<image filename="trough_middle.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_middle_background_focused_pressed">
+		<image filename="trough_middle.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_right_background_focused_normal">
+		<image filename="trough_right.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_right_background_focused_pressed">
+		<image filename="trough_right.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_left_background_unfocused_normal">
+		<image filename="trough_left_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_left_background_unfocused_pressed">
+		<image filename="trough_left_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_middle_background_unfocused_normal">
+		<image filename="trough_middle_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_middle_background_unfocused_pressed">
+		<image filename="trough_middle_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_right_background_unfocused_normal">
+		<image filename="trough_right_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="left_right_background_unfocused_pressed">
+		<image filename="trough_right_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+
+	
+<!-- Button Trough Right -->
+	<draw_ops name="right_left_background_focused_normal">
+		<image filename="trough_left.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_left_background_focused_pressed">
+		<image filename="trough_left.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_middle_background_focused_normal">
+		<image filename="trough_middle.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_middle_background_focused_pressed">
+		<image filename="trough_middle.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_right_background_focused_normal">
+		<image filename="trough_right.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_right_background_focused_pressed">
+		<image filename="trough_right.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_left_background_unfocused_normal">
+		<image filename="trough_left_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_left_background_unfocused_pressed">
+		<image filename="trough_left_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_middle_background_unfocused_normal">
+		<image filename="trough_middle_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_middle_background_unfocused_pressed">
+		<image filename="trough_middle_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_right_background_unfocused_normal">
+		<image filename="trough_right_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="right_right_background_unfocused_pressed">
+		<image filename="trough_right_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	
+<!-- Button Overlays -->
+	<draw_ops name="menu_focused_normal">
+   	<image filename="menu.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+		<draw_ops name="menu_focused_prelight">
+  	 <image filename="menu_prelight.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="menu_unfocused_normal">
+  	 	<image filename="menu.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="menu_unfocused_prelight">
+   		<image filename="menu_prelight.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="minimize_focused_normal">
+		<image filename="minimize.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="minimize_focused_prelight">
+		<image filename="minimize.png" x="0" y="1" width="object_width" height="object_height" colorize="shade/gtk:bg[SELECTED]/.7"/>
+	</draw_ops>
+	<draw_ops name="minimize_focused_pressed">
+		<image filename="minimize.png" x="0" y="1" width="object_width" height="object_height" alpha=".2"/>
+	</draw_ops>
+	<draw_ops name="minimize_unfocused_normal">
+		<image filename="minimize_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="minimize_unfocused_prelight">
+		<image filename="minimize_unfocused_over.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="minimize_unfocused_pressed">
+		<image filename="minimize.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="maximize_focused_normal">
+		<image filename="maximize.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="maximize_focused_prelight">
+		<image filename="maximize.png" x="0" y="1" width="object_width" height="object_height" colorize="shade/gtk:bg[SELECTED]/.7"/>
+	</draw_ops>
+	<draw_ops name="maximize_focused_pressed">
+		<image filename="maximize.png" x="0" y="1" width="object_width" height="object_height" alpha=".2"/>
+	</draw_ops>
+	<draw_ops name="maximize_unfocused_normal">
+		<image filename="maximize_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="maximize_unfocused_prelight">
+		<image filename="maximize_unfocused_over.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="maximize_unfocused_pressed">
+		<image filename="maximize.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="unmaximize_focused_normal">
+		<image filename="unmaximize.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="unmaximize_focused_prelight">
+		<image filename="unmaximize.png" x="0" y="1" width="object_width" height="object_height" colorize="shade/gtk:bg[SELECTED]/.7"/>
+	</draw_ops>
+	<draw_ops name="unmaximize_focused_pressed">
+		<image filename="unmaximize.png" x="0" y="1" width="object_width" height="object_height" alpha=".2"/>
+	</draw_ops>
+	<draw_ops name="unmaximize_unfocused_normal">
+		<image filename="unmaximize_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="unmaximize_unfocused_prelight">
+		<image filename="unmaximize_unfocused_over.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="unmaximize_unfocused_pressed">
+		<image filename="unmaximize.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="close_focused_normal">
+		<image filename="close.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="close_focused_prelight">
+		<image filename="close.png" x="0" y="1" width="object_width" height="object_height"  alpha=".7"/>
+	</draw_ops>
+	<draw_ops name="close_focused_pressed">
+		<image filename="close.png" x="0" y="1" width="object_width" height="object_height" alpha=".9"/>
+	</draw_ops>
+	<draw_ops name="close_unfocused_normal">
+		<image filename="close_unfocused.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="close_unfocused_prelight">
+		<image filename="close_unfocused_over.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+	<draw_ops name="close_unfocused_pressed">
+		<image filename="close.png" x="0" y="1" width="object_width" height="object_height"/>
+	</draw_ops>
+
+<!-- FRAME STYLE -->
+<frame_style name="normal_focused" geometry="frame_geometry_normal">
+	<piece position="title" draw_ops="draw_title_text_normal"/>
+   	<piece position="titlebar" draw_ops="draw_title"/>
+   	<piece position="left_edge" draw_ops="draw_frame"/>
+   	<piece position="right_edge" draw_ops="draw_frame"/>
+   	<piece position="bottom_edge" draw_ops="bottom_edge"/>
+	<button function="left_left_background" state="normal" draw_ops="left_left_background_focused_normal"/>
+	<button function="left_middle_background" state="normal" draw_ops="left_middle_background_focused_normal"/>
+	<button function="left_right_background" state="normal" draw_ops="left_right_background_focused_normal"/>
+	<button function="left_left_background" state="prelight" draw_ops="left_left_background_focused_normal"/>
+	<button function="left_middle_background" state="prelight" draw_ops="left_middle_background_focused_normal"/>
+	<button function="left_right_background" state="prelight" draw_ops="left_right_background_focused_normal"/>
+	<button function="left_left_background" state="pressed" draw_ops="left_left_background_focused_pressed"/>
+	<button function="left_middle_background" state="pressed" draw_ops="left_middle_background_focused_pressed"/>
+	<button function="left_right_background" state="pressed" draw_ops="left_right_background_focused_pressed"/>
+	<button function="right_left_background" state="normal" draw_ops="right_left_background_focused_normal"/>
+	<button function="right_middle_background" state="normal" draw_ops="right_middle_background_focused_normal"/>
+	<button function="right_right_background" state="normal" draw_ops="right_right_background_focused_normal"/>
+	<button function="right_left_background" state="prelight" draw_ops="right_left_background_focused_normal"/>
+	<button function="right_middle_background" state="prelight" draw_ops="right_middle_background_focused_normal"/>
+	<button function="right_right_background" state="prelight" draw_ops="right_right_background_focused_normal"/>
+	<button function="right_left_background" state="pressed" draw_ops="right_left_background_focused_pressed"/>
+	<button function="right_middle_background" state="pressed" draw_ops="right_middle_background_focused_pressed"/>
+	<button function="right_right_background" state="pressed" draw_ops="right_right_background_focused_pressed"/>
+	<button function="menu" state="normal" draw_ops="menu_focused_normal"/>
+	<button function="menu" state="prelight" draw_ops="menu_focused_prelight"/>
+	<button function="menu" state="pressed" draw_ops="menu_focused_normal"/> 
+	<button function="minimize" state="normal" draw_ops="minimize_focused_normal"/>
+	<button function="minimize" state="prelight" draw_ops="minimize_focused_prelight"/>
+	<button function="minimize" state="pressed" draw_ops="minimize_focused_pressed"/>
+	<button function="maximize" state="normal" draw_ops="maximize_focused_normal"/>
+	<button function="maximize" state="prelight" draw_ops="maximize_focused_prelight"/>
+	<button function="maximize" state="pressed" draw_ops="maximize_focused_pressed"/>
+	<button function="close" state="normal" draw_ops="close_focused_normal"/>
+	<button function="close" state="prelight" draw_ops="close_focused_prelight"/>
+	<button function="close" state="pressed" draw_ops="close_focused_pressed"/>
+</frame_style>
+
+<frame_style name="normal_unfocused" geometry="frame_geometry_normal">
+	<piece position="title" draw_ops="draw_title_text_inactive"/>
+   	<piece position="titlebar" draw_ops="draw_title_inactive"/>
+   	<piece position="left_edge" draw_ops="draw_frame"/>
+   	<piece position="right_edge" draw_ops="draw_frame"/>
+   	<piece position="bottom_edge" draw_ops="bottom_edge"/>
+	<button function="left_left_background" state="normal" draw_ops="left_left_background_unfocused_normal"/>
+	<button function="left_middle_background" state="normal" draw_ops="left_middle_background_unfocused_normal"/>
+	<button function="left_right_background" state="normal" draw_ops="left_right_background_unfocused_normal"/>
+	<button function="left_left_background" state="prelight" draw_ops="left_left_background_unfocused_normal"/>
+	<button function="left_middle_background" state="prelight" draw_ops="left_middle_background_unfocused_normal"/>
+	<button function="left_right_background" state="prelight" draw_ops="left_right_background_unfocused_normal"/>
+	<button function="left_left_background" state="pressed" draw_ops="left_left_background_unfocused_pressed"/>
+	<button function="left_middle_background" state="pressed" draw_ops="left_middle_background_unfocused_pressed"/>
+	<button function="left_right_background" state="pressed" draw_ops="left_right_background_unfocused_pressed"/>
+	<button function="right_left_background" state="normal" draw_ops="right_left_background_unfocused_normal"/>
+	<button function="right_middle_background" state="normal" draw_ops="right_middle_background_unfocused_normal"/>
+	<button function="right_right_background" state="normal" draw_ops="right_right_background_unfocused_normal"/>
+	<button function="right_left_background" state="prelight" draw_ops="right_left_background_unfocused_normal"/>
+	<button function="right_middle_background" state="prelight" draw_ops="right_middle_background_unfocused_normal"/>
+	<button function="right_right_background" state="prelight" draw_ops="right_right_background_unfocused_normal"/>
+	<button function="right_left_background" state="pressed" draw_ops="right_left_background_unfocused_pressed"/>
+	<button function="right_middle_background" state="pressed" draw_ops="right_middle_background_unfocused_pressed"/>
+	<button function="right_right_background" state="pressed" draw_ops="right_right_background_unfocused_pressed"/>
+	<button function="menu" state="normal" draw_ops="menu_unfocused_normal"/>
+	<button function="menu" state="prelight" draw_ops="menu_unfocused_prelight"/>
+	<button function="menu" state="pressed" draw_ops="menu_focused_normal"/>
+	<button function="minimize" state="normal" draw_ops="minimize_unfocused_normal"/>
+	<button function="minimize" state="prelight" draw_ops="minimize_unfocused_prelight"/>
+	<button function="minimize" state="pressed" draw_ops="minimize_unfocused_pressed"/>
+	<button function="maximize" state="normal" draw_ops="maximize_unfocused_normal"/>
+	<button function="maximize" state="prelight" draw_ops="maximize_unfocused_prelight"/>
+	<button function="maximize" state="pressed" draw_ops="maximize_unfocused_pressed"/>
+	<button function="close" state="normal" draw_ops="close_unfocused_normal"/>
+	<button function="close" state="prelight" draw_ops="close_unfocused_prelight"/>
+	<button function="close" state="pressed" draw_ops="close_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_focused" geometry="geometry_maximized" parent="normal_focused">
+	<piece position="title" draw_ops="draw_title_text_normal"/>
+   	<piece position="titlebar" draw_ops="draw_title_maximized"/>
+	<button function="maximize" state="normal" draw_ops="unmaximize_focused_normal"/>
+	<button function="maximize" state="prelight" draw_ops="unmaximize_focused_prelight"/>
+	<button function="maximize" state="pressed" draw_ops="unmaximize_focused_pressed"/>
+</frame_style>
+
+<frame_style name="maximized_unfocused" geometry="geometry_maximized" parent="normal_unfocused">
+	<piece position="title" draw_ops="draw_title_text_inactive"/>
+   	<piece position="titlebar" draw_ops="draw_title_maximized_inactive"/>
+	<button function="maximize" state="normal" draw_ops="unmaximize_unfocused_normal"/>
+	<button function="maximize" state="prelight" draw_ops="unmaximize_unfocused_prelight"/>
+	<button function="maximize" state="pressed" draw_ops="unmaximize_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="utility_focused" parent="normal_focused">
+	<piece position="title" draw_ops="draw_title_text_normal"/>
+	<piece position="titlebar" draw_ops="draw_title"/>
+	<button function="menu" state="normal" draw_ops="menu_focused_normal"/>
+	<button function="menu" state="prelight" draw_ops="menu_focused_prelight"/>
+	<button function="menu" state="pressed" draw_ops="menu_focused_normal"/>
+	<button function="close" state="normal" draw_ops="close_focused_normal"/>
+	<button function="close" state="prelight" draw_ops="close_focused_prelight"/>
+	<button function="close" state="pressed" draw_ops="close_focused_pressed"/>
+</frame_style>
+
+<frame_style name="utility_unfocused" parent="normal_unfocused">
+	<piece position="title" draw_ops="draw_title_text_inactive"/>
+	<piece position="titlebar" draw_ops="draw_title_inactive"/>
+	<button function="menu" state="normal" draw_ops="menu_unfocused_normal"/>
+	<button function="menu" state="prelight" draw_ops="menu_unfocused_prelight"/>
+	<button function="menu" state="pressed" draw_ops="menu_focused_normal"/>
+	<button function="close" state="normal" draw_ops="close_unfocused_normal"/>
+	<button function="close" state="prelight" draw_ops="close_unfocused_prelight"/>
+	<button function="close" state="pressed" draw_ops="close_unfocused_pressed"/>
+</frame_style>
+
+<frame_style name="border" geometry="border" parent="normal_focused">
+  <piece position="title" draw_ops="draw_title"/>
+	<piece position="titlebar" draw_ops="draw_title_inactive"/>
+</frame_style>
+
+<!-- STYLE SET -->
+<frame_style_set name="normal">
+	<frame focus="yes" state="normal" resize="both" style="normal_focused"/>
+	<frame focus="no" state="normal" resize="both" style="normal_unfocused"/>
+	<frame focus="yes" state="maximized" style="maximized_focused"/>
+	<frame focus="no" state="maximized" style="maximized_unfocused"/>
+	<frame focus="yes" state="shaded" style="normal_focused"/><!-- todo -->
+	<frame focus="no" state="shaded" style="normal_unfocused"/><!-- todo -->
+	<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/><!-- todo -->
+	<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/><!-- todo -->
+</frame_style_set>
+
+<frame_style_set name="utility">
+	<frame focus="yes" state="normal" resize="both" style="utility_focused"/>
+	<frame focus="no" state="normal" resize="both" style="utility_unfocused"/>
+	<frame focus="yes" state="maximized" style="maximized_focused"/>
+	<frame focus="no" state="maximized" style="normal_focused"/>
+	<frame focus="yes" state="shaded" style="normal_focused"/><!-- todo -->
+	<frame focus="no" state="shaded" style="normal_unfocused"/><!-- todo -->
+	<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/><!-- todo -->
+	<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/><!-- todo -->
+</frame_style_set>
+
+<frame_style_set name="border">
+	<frame focus="yes" state="normal" resize="both" style="border"/>
+	<frame focus="no" state="normal" resize="both" style="border"/>
+	<frame focus="yes" state="maximized" style="maximized_focused"/>
+	<frame focus="no" state="maximized" style="normal_focused"/>
+	<frame focus="yes" state="shaded" style="normal_focused"/><!-- todo -->
+	<frame focus="no" state="shaded" style="normal_unfocused"/><!-- todo -->
+	<frame focus="yes" state="maximized_and_shaded" style="maximized_focused"/><!-- todo -->
+	<frame focus="no" state="maximized_and_shaded" style="maximized_unfocused"/><!-- todo -->
+</frame_style_set>
+
+<!-- WINDOW -->
+<window type="normal" style_set="normal"/>
+<window type="dialog" style_set="utility"/>
+<window type="modal_dialog" style_set="utility"/>
+<window type="menu" style_set="utility"/>
+<window type="utility" style_set="utility"/>
+<window type="border" style_set="border"/>
+
+</metacity_theme> 
diff --git a/src/themes/eOS/minimize.png b/src/themes/eOS/minimize.png
new file mode 100644
index 00000000..5083d1e2
--- /dev/null
+++ b/src/themes/eOS/minimize.png
diff --git a/src/themes/eOS/minimize_unfocused.png b/src/themes/eOS/minimize_unfocused.png
new file mode 100644
index 00000000..9bd4d273
--- /dev/null
+++ b/src/themes/eOS/minimize_unfocused.png
diff --git a/src/themes/eOS/minimize_unfocused_over.png b/src/themes/eOS/minimize_unfocused_over.png
new file mode 100644
index 00000000..5083d1e2
--- /dev/null
+++ b/src/themes/eOS/minimize_unfocused_over.png
diff --git a/src/themes/eOS/trough_left.png b/src/themes/eOS/trough_left.png
new file mode 100644
index 00000000..070d3da0
--- /dev/null
+++ b/src/themes/eOS/trough_left.png
diff --git a/src/themes/eOS/trough_left_unfocused.png b/src/themes/eOS/trough_left_unfocused.png
new file mode 100644
index 00000000..51ed9ab1
--- /dev/null
+++ b/src/themes/eOS/trough_left_unfocused.png
diff --git a/src/themes/eOS/trough_middle.png b/src/themes/eOS/trough_middle.png
new file mode 100644
index 00000000..28238835
--- /dev/null
+++ b/src/themes/eOS/trough_middle.png
diff --git a/src/themes/eOS/trough_middle_unfocused.png b/src/themes/eOS/trough_middle_unfocused.png
new file mode 100644
index 00000000..961e4f48
--- /dev/null
+++ b/src/themes/eOS/trough_middle_unfocused.png
diff --git a/src/themes/eOS/trough_right.png b/src/themes/eOS/trough_right.png
new file mode 100644
index 00000000..84bfad11
--- /dev/null
+++ b/src/themes/eOS/trough_right.png
diff --git a/src/themes/eOS/trough_right_unfocused.png b/src/themes/eOS/trough_right_unfocused.png
new file mode 100644
index 00000000..acab4faf
--- /dev/null
+++ b/src/themes/eOS/trough_right_unfocused.png
diff --git a/src/themes/eOS/unmaximize.png b/src/themes/eOS/unmaximize.png
new file mode 100644
index 00000000..785aa133
--- /dev/null
+++ b/src/themes/eOS/unmaximize.png
diff --git a/src/themes/eOS/unmaximize_unfocused.png b/src/themes/eOS/unmaximize_unfocused.png
new file mode 100644
index 00000000..d7c35fc1
--- /dev/null
+++ b/src/themes/eOS/unmaximize_unfocused.png
diff --git a/src/themes/eOS/unmaximize_unfocused_over.png b/src/themes/eOS/unmaximize_unfocused_over.png
new file mode 100644
index 00000000..785aa133
--- /dev/null
+++ b/src/themes/eOS/unmaximize_unfocused_over.png
diff --git a/src/tools/Makefile.am b/src/tools/Makefile.am
new file mode 100644
index 00000000..031ef961
--- /dev/null
+++ b/src/tools/Makefile.am
@@ -0,0 +1,33 @@
+@INTLTOOL_DESKTOP_RULE@
+
+icondir=$(pkgdatadir)/icons
+icon_DATA=marco-window-demo.png
+
+INCLUDES=@MARCO_WINDOW_DEMO_CFLAGS@ @MARCO_MESSAGE_CFLAGS@ \
+	-DMARCO_ICON_DIR=\"$(pkgdatadir)/icons\" \
+	-DMARCO_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\"
+
+marco_message_SOURCES= 				\
+	marco-message.c
+
+marco_window_demo_SOURCES=				\
+	marco-window-demo.c
+
+marco_mag_SOURCES=					\
+	marco-mag.c
+
+marco_grayscale_SOURCES=				\
+	marco-grayscale.c
+
+bin_PROGRAMS=marco-message marco-window-demo
+
+## cheesy hacks I use, don't really have any business existing. ;-)
+noinst_PROGRAMS=marco-mag marco-grayscale
+
+marco_message_LDADD= @MARCO_MESSAGE_LIBS@
+marco_window_demo_LDADD= @MARCO_WINDOW_DEMO_LIBS@
+marco_mag_LDADD= @MARCO_WINDOW_DEMO_LIBS@ -lm
+marco_grayscale_LDADD = @MARCO_WINDOW_DEMO_LIBS@
+
+EXTRA_DIST=$(icon_DATA)
+
diff --git a/src/tools/marco-grayscale.c b/src/tools/marco-grayscale.c
new file mode 100644
index 00000000..8d0cd68c
--- /dev/null
+++ b/src/tools/marco-grayscale.c
@@ -0,0 +1,109 @@
+/* Hack for grayscaling an image */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <math.h>
+
+#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
+
+static GdkPixbuf*
+grayscale_pixbuf (GdkPixbuf *pixbuf)
+{
+  GdkPixbuf *gray;
+  guchar *pixels;
+  int rowstride;
+  int pixstride;
+  int row;
+  int n_rows;
+  int width;
+  
+  gray = gdk_pixbuf_copy (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (gray);
+  pixstride = gdk_pixbuf_get_has_alpha (gray) ? 4 : 3;
+  
+  pixels = gdk_pixbuf_get_pixels (gray);
+  n_rows = gdk_pixbuf_get_height (gray);
+  width = gdk_pixbuf_get_width (gray);
+  
+  row = 0;
+  while (row < n_rows)
+    {
+      guchar *p = pixels + row * rowstride;
+      guchar *end = p + (pixstride * width);
+
+      while (p != end)
+        {
+          double v = INTENSITY (p[0], p[1], p[2]);
+
+          p[0] = (guchar) v;
+          p[1] = (guchar) v;
+          p[2] = (guchar) v;
+          
+          p += pixstride;
+        }
+      
+      ++row;
+    }
+  
+  return gray;
+}
+
+int
+main (int argc, char **argv)
+{
+  GdkPixbuf *pixbuf;
+  GdkPixbuf *gray;
+  GError *err;
+  
+  if (argc != 2)
+    {
+      g_printerr ("specify a single image on the command line\n");
+      return 1;
+    }
+
+  g_type_init ();
+  
+  err = NULL;
+  pixbuf = gdk_pixbuf_new_from_file (argv[1], &err);
+  if (err != NULL)
+    {
+      g_printerr ("failed to load image: %s\n", err->message);
+      g_error_free (err);
+      return 1;
+    }
+
+  gray = grayscale_pixbuf (pixbuf);
+  
+  err = NULL;
+  gdk_pixbuf_save (gray, "grayscale.png", "png", &err, NULL);
+  if (err != NULL)
+    {
+      g_printerr ("failed to save image: %s\n", err->message);
+      g_error_free (err);
+      return 1;
+    }
+
+  g_print ("wrote grayscale.png\n");
+  
+  return 0;
+}
diff --git a/src/tools/marco-mag.c b/src/tools/marco-mag.c
new file mode 100644
index 00000000..22c7cc3d
--- /dev/null
+++ b/src/tools/marco-mag.c
@@ -0,0 +1,278 @@
+/* Hack for use instead of xmag */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE 600 /* C99 -- for rint() */
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <gdk/gdkkeysyms.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <math.h>
+
+static GtkWidget *grab_widget = NULL;
+static GtkWidget *display_window = NULL;
+static int last_grab_x = 0;
+static int last_grab_y = 0;
+static int last_grab_width = 150;
+static int last_grab_height = 150;
+static GtkAllocation last_grab_allocation;
+static double width_factor = 4.0;
+static double height_factor = 4.0;
+static GdkInterpType interp_mode = GDK_INTERP_NEAREST;
+static guint regrab_idle_id = 0;
+
+static GdkPixbuf*
+get_pixbuf (void)
+{
+  GdkPixbuf *screenshot;
+  GdkPixbuf *magnified;
+
+#if 0
+  g_print ("Size %d x %d\n",
+           last_grab_width, last_grab_height);
+#endif
+  
+  screenshot = gdk_pixbuf_get_from_drawable (NULL, gdk_get_default_root_window (),
+                                             NULL,
+                                             last_grab_x, last_grab_y, 0, 0,
+                                             last_grab_width, last_grab_height);
+
+  if (screenshot == NULL)
+    {
+      g_printerr ("Screenshot failed\n");
+      exit (1);
+    }
+
+  magnified = gdk_pixbuf_scale_simple (screenshot, last_grab_width * width_factor,
+                                       last_grab_height * height_factor,
+                                       interp_mode);
+
+
+  g_object_unref (G_OBJECT (screenshot));
+
+  return magnified;
+}
+
+static gboolean
+regrab_idle (GtkWidget *image)
+{
+  GdkPixbuf *magnified;
+  GtkAllocation allocation;
+
+  gtk_widget_get_allocation (image, &allocation);
+  
+  if (allocation.width != last_grab_allocation.width ||
+      allocation.height != last_grab_allocation.height)
+    {
+      last_grab_width = rint (allocation.width / width_factor);
+      last_grab_height = rint (allocation.height / height_factor);
+      last_grab_allocation = allocation;
+      
+      magnified = get_pixbuf ();
+
+      gtk_image_set_from_pixbuf (GTK_IMAGE (image), magnified);
+
+      g_object_unref (G_OBJECT (magnified));
+    }
+
+  regrab_idle_id = 0;
+  
+  return FALSE;
+}
+
+static void
+image_resized (GtkWidget *image)
+{
+  if (regrab_idle_id == 0)
+    regrab_idle_id = g_idle_add_full (G_PRIORITY_LOW + 100, (GSourceFunc) regrab_idle,
+                                      image, NULL);
+}
+
+static void
+grab_area_at_mouse (GtkWidget *invisible,
+                    int        x_root,
+                    int        y_root)
+{
+  GdkPixbuf *magnified;
+  int width, height;
+  GtkWidget *widget;
+  
+  width = last_grab_width;
+  height = last_grab_height;
+
+  last_grab_x = x_root;
+  last_grab_y = y_root;
+  last_grab_width = width;
+  last_grab_height = height;
+  
+  magnified = get_pixbuf ();
+  
+  display_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_default_size (GTK_WINDOW (display_window),
+                               last_grab_width, last_grab_height);
+  widget = gtk_image_new_from_pixbuf (magnified);
+  gtk_widget_set_size_request (widget, 40, 40);
+  gtk_container_add (GTK_CONTAINER (display_window), widget);
+  g_object_unref (G_OBJECT (magnified));
+
+  g_object_add_weak_pointer (G_OBJECT (display_window),
+                             (gpointer) &display_window);
+
+  g_signal_connect (G_OBJECT (display_window), "destroy",
+                    G_CALLBACK (gtk_main_quit), NULL);
+
+  g_signal_connect_after (G_OBJECT (widget), "size_allocate", G_CALLBACK (image_resized), NULL);
+  
+  gtk_widget_show_all (display_window);
+}
+
+static void
+shutdown_grab (void)
+{
+  gdk_keyboard_ungrab (gtk_get_current_event_time ());
+  gdk_pointer_ungrab (gtk_get_current_event_time ());
+  gtk_grab_remove (grab_widget);
+}
+
+static void
+mouse_motion (GtkWidget      *invisible,
+	      GdkEventMotion *event,
+	      gpointer        data)
+{
+  
+}
+
+static gboolean
+mouse_release (GtkWidget      *invisible,
+	       GdkEventButton *event,
+	       gpointer        data)
+{
+  if (event->button != 1)
+    return FALSE;
+
+  grab_area_at_mouse (invisible, event->x_root, event->y_root);
+
+  shutdown_grab ();
+  
+  g_signal_handlers_disconnect_by_func (invisible, mouse_motion, NULL);
+  g_signal_handlers_disconnect_by_func (invisible, mouse_release, NULL);
+
+  return TRUE;
+}
+
+/* Helper Functions */
+
+static gboolean mouse_press (GtkWidget      *invisible,
+                             GdkEventButton *event,
+                             gpointer        data);
+
+static gboolean
+key_press (GtkWidget   *invisible,
+           GdkEventKey *event,
+           gpointer     data)
+{  
+  if (event->keyval == GDK_Escape)
+    {
+      shutdown_grab ();
+
+      g_signal_handlers_disconnect_by_func (invisible, mouse_press, NULL);
+      g_signal_handlers_disconnect_by_func (invisible, key_press, NULL);
+      
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+mouse_press (GtkWidget      *invisible,
+	     GdkEventButton *event,
+	     gpointer        data)
+{  
+  if (event->type == GDK_BUTTON_PRESS &&
+      event->button == 1)
+    {
+      g_signal_connect (invisible, "motion_notify_event",
+                        G_CALLBACK (mouse_motion), NULL);
+      g_signal_connect (invisible, "button_release_event",
+                        G_CALLBACK (mouse_release), NULL);
+      g_signal_handlers_disconnect_by_func (invisible, mouse_press, NULL);
+      g_signal_handlers_disconnect_by_func (invisible, key_press, NULL);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+begin_area_grab (void)
+{
+  if (grab_widget == NULL)
+    {
+      grab_widget = gtk_invisible_new ();
+
+      gtk_widget_add_events (grab_widget,
+                             GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
+      
+      gtk_widget_show (grab_widget);
+    }
+
+  if (gdk_keyboard_grab (gtk_widget_get_window (grab_widget),
+                         FALSE,
+                         gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
+    {
+      g_warning ("Failed to grab keyboard to do eyedropper");
+      return;
+    }
+  
+  if (gdk_pointer_grab (gtk_widget_get_window (grab_widget),
+                        FALSE,
+                        GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
+                        NULL,
+                        NULL,
+                        gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
+    {
+      gdk_keyboard_ungrab (GDK_CURRENT_TIME);
+      g_warning ("Failed to grab pointer to do eyedropper");
+      return;
+    }
+
+  gtk_grab_add (grab_widget);
+  
+  g_signal_connect (grab_widget, "button_press_event",
+                    G_CALLBACK (mouse_press), NULL);
+  g_signal_connect (grab_widget, "key_press_event",
+                    G_CALLBACK (key_press), NULL);
+}
+
+int
+main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+
+  begin_area_grab ();
+  
+  gtk_main ();
+  
+  return 0;
+}
diff --git a/src/tools/marco-message.c b/src/tools/marco-message.c
new file mode 100644
index 00000000..78bebeb2
--- /dev/null
+++ b/src/tools/marco-message.c
@@ -0,0 +1,187 @@
+/* Marco send-magic-messages app */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libintl.h>
+#define _(x) dgettext (GETTEXT_PACKAGE, x)
+#define N_(x) x
+
+
+static void
+send_restart (void)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.serial = 0;
+  xev.xclient.send_event = True;
+  xev.xclient.display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+  xev.xclient.window = gdk_x11_get_default_root_xwindow ();
+  xev.xclient.message_type = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                          "_MARCO_RESTART_MESSAGE",
+                                          False);
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = 0;
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = 0;
+
+  XSendEvent (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+              gdk_x11_get_default_root_xwindow (),
+              False,
+	      SubstructureRedirectMask | SubstructureNotifyMask,
+	      &xev);
+
+  XFlush (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), False);
+}
+
+static void
+send_reload_theme (void)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.serial = 0;
+  xev.xclient.send_event = True;
+  xev.xclient.display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+  xev.xclient.window = gdk_x11_get_default_root_xwindow ();
+  xev.xclient.message_type = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                          "_MARCO_RELOAD_THEME_MESSAGE",
+                                          False);
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = 0;
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = 0;
+
+  XSendEvent (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+              gdk_x11_get_default_root_xwindow (),
+              False,
+	      SubstructureRedirectMask | SubstructureNotifyMask,
+	      &xev);
+
+  XFlush (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), False);
+}
+
+static void
+send_set_keybindings (gboolean enabled)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.serial = 0;
+  xev.xclient.send_event = True;
+  xev.xclient.display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+  xev.xclient.window = gdk_x11_get_default_root_xwindow ();
+  xev.xclient.message_type = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                          "_MARCO_SET_KEYBINDINGS_MESSAGE",
+                                          False);
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = enabled;
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = 0;
+
+  XSendEvent (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+              gdk_x11_get_default_root_xwindow (),
+              False,
+	      SubstructureRedirectMask | SubstructureNotifyMask,
+	      &xev);
+
+  XFlush (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), False);
+}
+
+#ifdef WITH_VERBOSE_MODE
+static void
+send_toggle_verbose (void)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.serial = 0;
+  xev.xclient.send_event = True;
+  xev.xclient.display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
+  xev.xclient.window = gdk_x11_get_default_root_xwindow ();
+  xev.xclient.message_type = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                          "_MARCO_TOGGLE_VERBOSE",
+                                          False);
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = 0;
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = 0;
+
+  XSendEvent (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+              gdk_x11_get_default_root_xwindow (),
+              False,
+	      SubstructureRedirectMask | SubstructureNotifyMask,
+	      &xev);
+
+  XFlush (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), False);
+}
+#endif
+
+static void
+usage (void)
+{
+  g_printerr (_("Usage: %s\n"),
+              "marco-message (restart|reload-theme|enable-keybindings|disable-keybindings|toggle-verbose)");
+  exit (1);
+}
+
+int
+main (int argc, char **argv)
+{
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  
+  gtk_init (&argc, &argv);
+
+  if (argc < 2)
+    usage ();
+
+  if (strcmp (argv[1], "restart") == 0)
+    send_restart ();
+  else if (strcmp (argv[1], "reload-theme") == 0)
+    send_reload_theme ();
+  else if (strcmp (argv[1], "enable-keybindings") == 0)
+    send_set_keybindings (TRUE);
+  else if (strcmp (argv[1], "disable-keybindings") == 0)
+    send_set_keybindings (FALSE);
+  else if (strcmp (argv[1], "toggle-verbose") == 0)
+    {
+#ifndef WITH_VERBOSE_MODE
+      g_printerr (_("Marco was compiled without support for verbose mode\n"));
+      return 1;
+#else      
+      send_toggle_verbose ();
+#endif
+    }
+  else
+    usage ();
+  
+  return 0;
+}
+
diff --git a/src/tools/marco-window-demo.c b/src/tools/marco-window-demo.c
new file mode 100644
index 00000000..876a2585
--- /dev/null
+++ b/src/tools/marco-window-demo.c
@@ -0,0 +1,1016 @@
+/* Marco window types/properties demo app */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+#include <unistd.h>
+
+static GtkWidget* do_appwindow (void);
+
+static gboolean aspect_on;
+
+static void
+set_gdk_window_struts (GdkWindow *window,
+                       int        left,
+                       int        right,
+                       int        top,
+                       int        bottom)
+{
+  long vals[12];
+  
+  vals[0] = left;
+  vals[1] = right;
+  vals[2] = top;
+  vals[3] = bottom;
+  vals[4] = 000;
+  vals[5] = 400;
+  vals[6] = 200;
+  vals[7] = 600;
+  vals[8] = 76;
+  vals[9] = 676;
+  vals[10] = 200;
+  vals[11] = 800;
+
+  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
+                   GDK_WINDOW_XWINDOW (window),
+                   XInternAtom (GDK_WINDOW_XDISPLAY (window),
+                                "_NET_WM_STRUT_PARTIAL", False),
+                   XA_CARDINAL, 32, PropModeReplace,
+                   (guchar *)vals, 12);
+}
+
+static void
+on_realize_set_struts (GtkWindow *window,
+                       gpointer   data)
+{
+  int left;
+  int right;
+  int top;
+  int bottom;
+
+  g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (window)));
+
+  left = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-left"));
+  right = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-right"));
+  top = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-top"));
+  bottom = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-bottom"));
+  
+  set_gdk_window_struts (gtk_widget_get_window (GTK_WIDGET (window)),
+                         left, right, top, bottom);
+}
+
+static void
+set_gtk_window_struts (GtkWidget  *window,
+                       int         left,
+                       int         right,
+                       int         top,
+                       int         bottom)
+{
+  g_object_set_data (G_OBJECT (window), "meta-strut-left",
+                     GINT_TO_POINTER (left));
+  g_object_set_data (G_OBJECT (window), "meta-strut-right",
+                     GINT_TO_POINTER (right));
+  g_object_set_data (G_OBJECT (window), "meta-strut-top",
+                     GINT_TO_POINTER (top));
+  g_object_set_data (G_OBJECT (window), "meta-strut-bottom",
+                     GINT_TO_POINTER (bottom));
+  
+  g_signal_handlers_disconnect_by_func (G_OBJECT (window),
+                                        on_realize_set_struts,
+                                        NULL);
+                                
+  g_signal_connect_after (G_OBJECT (window),
+                          "realize",
+                          G_CALLBACK (on_realize_set_struts),
+                          NULL);
+
+  if (gtk_widget_get_realized (GTK_WIDGET (window)))
+    set_gdk_window_struts (gtk_widget_get_window (GTK_WIDGET (window)),
+                           left, right, top, bottom);
+}
+
+static void
+set_gdk_window_type (GdkWindow  *window,
+                     const char *type)
+{
+  Atom atoms[2] = { None, None };
+  
+  atoms[0] = XInternAtom (GDK_WINDOW_XDISPLAY (window),
+                          type, False);
+  
+  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
+                   GDK_WINDOW_XWINDOW (window),
+                   XInternAtom (GDK_WINDOW_XDISPLAY (window), "_NET_WM_WINDOW_TYPE", False),
+                   XA_ATOM, 32, PropModeReplace,
+                   (guchar *)atoms, 
+                   1);
+}
+
+static void
+on_realize_set_type (GtkWindow *window,
+                     gpointer   data)
+{
+  const char *type;
+
+  g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (window)));
+
+  type = g_object_get_data (G_OBJECT (window), "meta-window-type");
+
+  g_return_if_fail (type != NULL);
+  
+  set_gdk_window_type (gtk_widget_get_window (GTK_WIDGET (window)),
+                       type);
+}
+
+static void
+set_gtk_window_type (GtkWindow  *window,
+                     const char *type)
+{
+  g_object_set_data (G_OBJECT (window), "meta-window-type", (char*) type);
+
+  g_signal_handlers_disconnect_by_func (G_OBJECT (window),
+                                        on_realize_set_type,
+                                        NULL);
+                                
+  g_signal_connect_after (G_OBJECT (window),
+                          "realize",
+                          G_CALLBACK (on_realize_set_type),
+                          NULL);
+
+  if (gtk_widget_get_realized (GTK_WIDGET (window)))
+    set_gdk_window_type (gtk_widget_get_window (GTK_WIDGET (window)),
+                         type);
+}
+
+static void
+set_gdk_window_border_only (GdkWindow *window)
+{
+  gdk_window_set_decorations (window, GDK_DECOR_BORDER);
+}
+
+static void
+on_realize_set_border_only (GtkWindow *window,
+                            gpointer   data)
+{
+  g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (window)));
+  
+  set_gdk_window_border_only (gtk_widget_get_window (GTK_WIDGET (window)));
+}
+
+static void
+set_gtk_window_border_only (GtkWindow  *window)
+{
+  g_signal_handlers_disconnect_by_func (G_OBJECT (window),
+                                        on_realize_set_border_only,
+                                        NULL);
+                                
+  g_signal_connect_after (G_OBJECT (window),
+                          "realize",
+                          G_CALLBACK (on_realize_set_border_only),
+                          NULL);
+
+  if (gtk_widget_get_realized (GTK_WIDGET (window)))
+    set_gdk_window_border_only (gtk_widget_get_window (GTK_WIDGET (window)));
+}
+
+int
+main (int argc, char **argv)
+{
+  GList *list;
+  GdkPixbuf *pixbuf;
+  GError *err;
+  
+  gtk_init (&argc, &argv);
+
+  err = NULL;
+  pixbuf = gdk_pixbuf_new_from_file (MARCO_ICON_DIR"/marco-window-demo.png",
+                                     &err);
+  if (pixbuf)
+    {
+      list = g_list_prepend (NULL, pixbuf);
+      
+      gtk_window_set_default_icon_list (list);
+      g_list_free (list);
+      g_object_unref (G_OBJECT (pixbuf));
+    }
+  else
+    {
+      g_printerr ("Could not load icon: %s\n", err->message);
+      g_error_free (err);
+    }
+  
+  do_appwindow ();
+
+  gtk_main ();
+  
+  return 0;
+}
+
+static void
+response_cb (GtkDialog *dialog,
+             int        response_id,
+             void      *data);
+
+static void
+make_dialog (GtkWidget *parent,
+             int        depth)
+{
+  GtkWidget *dialog;
+  char *str;
+  
+  dialog = gtk_message_dialog_new (parent ? GTK_WINDOW (parent) : NULL,
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   GTK_MESSAGE_INFO,
+                                   GTK_BUTTONS_CLOSE,
+                                   parent ? "Here is a dialog %d" :
+                                   "Here is a dialog %d with no transient parent",
+                                   depth);
+
+  str = g_strdup_printf ("%d dialog", depth);
+  gtk_window_set_title (GTK_WINDOW (dialog), str);
+  g_free (str);
+  
+  gtk_dialog_add_button (GTK_DIALOG (dialog),
+                         "Open child dialog",
+                         GTK_RESPONSE_ACCEPT);
+  
+  /* Close dialog on user response */
+  g_signal_connect (G_OBJECT (dialog),
+                    "response",
+                    G_CALLBACK (response_cb),
+                    NULL);
+
+  g_object_set_data (G_OBJECT (dialog), "depth",
+                     GINT_TO_POINTER (depth));
+  
+  gtk_widget_show (dialog);
+}
+
+static void
+response_cb (GtkDialog *dialog,
+             int        response_id,
+             void      *data)
+{
+  switch (response_id)
+    {
+    case GTK_RESPONSE_ACCEPT:
+      make_dialog (GTK_WIDGET (dialog),
+                   GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog),
+                                                       "depth")) + 1);
+      break;
+
+    default:
+      gtk_widget_destroy (GTK_WIDGET (dialog));
+      break;
+    }
+}
+
+static void
+dialog_cb (gpointer             callback_data,
+           guint                callback_action,
+           GtkWidget           *widget)
+{
+  make_dialog (GTK_WIDGET (callback_data), 1);
+}
+
+static void
+modal_dialog_cb (gpointer             callback_data,
+                 guint                callback_action,
+                 GtkWidget           *widget)
+{
+  GtkWidget *dialog;
+  
+  dialog = gtk_message_dialog_new (GTK_WINDOW (callback_data),
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   GTK_MESSAGE_INFO,
+                                   GTK_BUTTONS_CLOSE,
+                                   "Here is a MODAL dialog");
+
+  set_gtk_window_type (GTK_WINDOW (dialog), "_NET_WM_WINDOW_TYPE_MODAL_DIALOG");
+  
+  gtk_dialog_run (GTK_DIALOG (dialog));
+
+  gtk_widget_destroy (dialog);
+}
+
+static void
+no_parent_dialog_cb (gpointer             callback_data,
+                     guint                callback_action,
+                     GtkWidget           *widget)
+{
+  make_dialog (NULL, 1);
+}
+
+static void
+utility_cb (gpointer             callback_data,
+            guint                callback_action,
+            GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *vbox;
+  GtkWidget *button;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_UTILITY");
+  gtk_window_set_title (GTK_WINDOW (window), "Utility");
+  
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  button = gtk_button_new_with_mnemonic ("_A button");
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_mnemonic ("_B button");
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_mnemonic ("_C button");
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_mnemonic ("_D button");
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (window);
+}
+
+static void
+toolbar_cb (gpointer             callback_data,
+            guint                callback_action,
+            GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_TOOLBAR");
+  gtk_window_set_title (GTK_WINDOW (window), "Toolbar");
+  
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  label = gtk_label_new ("FIXME this needs a resize grip, etc.");
+  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (window);
+}
+
+static void
+menu_cb (gpointer             callback_data,
+         guint                callback_action,
+         GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_MENU");
+  gtk_window_set_title (GTK_WINDOW (window), "Menu");
+  
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  label = gtk_label_new ("FIXME this isn't a menu.");
+  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (window);
+}
+
+static void
+override_redirect_cb (gpointer             callback_data,
+                      guint                callback_action,
+                      GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  
+  window = gtk_window_new (GTK_WINDOW_POPUP);
+  gtk_window_set_title (GTK_WINDOW (window), "Override Redirect");
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  label = gtk_label_new ("This is an override\nredirect window\nand should not be managed");
+  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (window);
+}
+
+static void
+border_only_cb (gpointer             callback_data,
+                guint                callback_action,
+                GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_border_only (GTK_WINDOW (window));
+  gtk_window_set_title (GTK_WINDOW (window), "Border only");
+  
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  label = gtk_label_new ("This window is supposed to have a border but no titlebar.");
+  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (window);
+}
+
+#if 0
+static void
+changing_icon_cb (gpointer             callback_data,
+                  guint                callback_action,
+                  GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Changing Icon");
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+
+  label = gtk_label_new ("This window has an icon that changes over time");
+  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (window);
+}
+#endif
+
+static gboolean
+focus_in_event_cb (GtkWidget *window,
+                   GdkEvent  *event,
+                   gpointer   data)
+{
+  GtkWidget *widget;
+
+  widget = GTK_WIDGET (data);
+
+  gtk_label_set_text (GTK_LABEL (widget), "Has focus");
+
+  return TRUE;
+}
+
+
+static gboolean
+focus_out_event_cb (GtkWidget *window,
+                    GdkEvent  *event,
+                    gpointer   data)
+{
+  GtkWidget *widget;
+
+  widget = GTK_WIDGET (data);
+
+  gtk_label_set_text (GTK_LABEL (widget), "Not focused");
+  
+  return TRUE;
+}
+
+static GtkWidget*
+focus_label (GtkWidget *window)
+{
+  GtkWidget *label;
+  
+  label = gtk_label_new ("Not focused");
+
+  g_signal_connect (G_OBJECT (window), "focus_in_event",
+                    G_CALLBACK (focus_in_event_cb), label);
+
+  g_signal_connect (G_OBJECT (window), "focus_out_event",
+                    G_CALLBACK (focus_out_event_cb), label);
+  
+  return label;
+}
+
+static void
+splashscreen_cb (gpointer             callback_data,
+                 guint                callback_action,
+                 GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *image;
+  GtkWidget *vbox;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_SPLASHSCREEN");
+  gtk_window_set_title (GTK_WINDOW (window), "Splashscreen");
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+  
+  image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
+  gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
+
+  gtk_box_pack_start (GTK_BOX (vbox), focus_label (window), FALSE, FALSE, 0);  
+  
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+  
+  gtk_widget_show_all (window);
+}
+
+enum
+{
+  DOCK_TOP = 1,
+  DOCK_BOTTOM = 2,
+  DOCK_LEFT = 3,
+  DOCK_RIGHT = 4,
+  DOCK_ALL = 5
+};
+
+static void
+make_dock (int type)
+{
+  GtkWidget *window;
+  GtkWidget *image;
+  GtkWidget *box;
+  GtkWidget *button;
+
+  g_return_if_fail (type != DOCK_ALL);
+
+  box = NULL;
+  switch (type)
+    {
+    case DOCK_LEFT:
+    case DOCK_RIGHT:      
+      box = gtk_vbox_new (FALSE, 0);
+      break;
+    case DOCK_TOP:
+    case DOCK_BOTTOM:
+      box = gtk_hbox_new (FALSE, 0);
+      break;
+    case DOCK_ALL:
+      break;
+    }
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_DOCK");
+  
+  image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
+  gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0);  
+  
+  gtk_box_pack_start (GTK_BOX (box), focus_label (window), FALSE, FALSE, 0);  
+
+  button = gtk_button_new_with_label ("Close");
+  gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
+
+  g_signal_connect_swapped (G_OBJECT (button), "clicked",
+                            G_CALLBACK (gtk_widget_destroy), window);
+  
+  gtk_container_add (GTK_CONTAINER (window), box);
+
+#define DOCK_SIZE 48
+  switch (type)
+    {
+    case DOCK_LEFT:
+      gtk_widget_set_size_request (window, DOCK_SIZE, 400);
+      gtk_window_move (GTK_WINDOW (window), 0, 000);
+      set_gtk_window_struts (window, DOCK_SIZE, 0, 0, 0);
+      gtk_window_set_title (GTK_WINDOW (window), "LeftDock");
+      break;
+    case DOCK_RIGHT:      
+      gtk_widget_set_size_request (window, DOCK_SIZE, 400);
+      gtk_window_move (GTK_WINDOW (window), gdk_screen_width () - DOCK_SIZE, 200);
+      set_gtk_window_struts (window, 0, DOCK_SIZE, 0, 0);
+      gtk_window_set_title (GTK_WINDOW (window), "RightDock");
+      break;
+    case DOCK_TOP:
+      gtk_widget_set_size_request (window, 600, DOCK_SIZE);
+      gtk_window_move (GTK_WINDOW (window), 76, 0);
+      set_gtk_window_struts (window, 0, 0, DOCK_SIZE, 0);
+      gtk_window_set_title (GTK_WINDOW (window), "TopDock");
+      break;
+    case DOCK_BOTTOM:
+      gtk_widget_set_size_request (window, 600, DOCK_SIZE);
+      gtk_window_move (GTK_WINDOW (window), 200, gdk_screen_height () - DOCK_SIZE);
+      set_gtk_window_struts (window, 0, 0, 0, DOCK_SIZE);
+      gtk_window_set_title (GTK_WINDOW (window), "BottomDock");
+      break;
+    case DOCK_ALL:
+      break;
+    }
+  
+  gtk_widget_show_all (window);
+}
+
+static void
+dock_cb (gpointer             callback_data,
+         guint                callback_action,
+         GtkWidget           *widget)
+{
+  if (callback_action == DOCK_ALL)
+    {
+      make_dock (DOCK_TOP);
+      make_dock (DOCK_BOTTOM);
+      make_dock (DOCK_LEFT);
+      make_dock (DOCK_RIGHT);
+    }
+  else
+    {
+      make_dock (callback_action);
+    }
+}
+
+static void
+desktop_cb (gpointer             callback_data,
+            guint                callback_action,
+            GtkWidget           *widget)
+{
+  GtkWidget *window;
+  GtkWidget *label;
+  GdkColor desktop_color;
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_DESKTOP");
+  gtk_window_set_title (GTK_WINDOW (window), "Desktop");
+  gtk_widget_set_size_request (window,
+                               gdk_screen_width (), gdk_screen_height ());
+  gtk_window_move (GTK_WINDOW (window), 0, 0);
+  
+  desktop_color.red = 0x5144;
+  desktop_color.green = 0x75D6;
+  desktop_color.blue = 0xA699;
+
+  gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &desktop_color);
+  
+  label = focus_label (window);
+  
+  gtk_container_add (GTK_CONTAINER (window), label);
+  
+  gtk_widget_show_all (window);
+}
+
+static GtkItemFactoryEntry menu_items[] =
+{
+  { "/_Windows",              NULL,         NULL,                     0, "<Branch>" },
+  { "/Windows/tearoff",       NULL,         NULL,                     0, "<Tearoff>" },
+  { "/Windows/_Dialog",       "<control>d",  dialog_cb,               0, NULL },
+  { "/Windows/_Modal dialog", NULL,          modal_dialog_cb,         0, NULL },
+  { "/Windows/_Parentless dialog", NULL,     no_parent_dialog_cb,     0, NULL },
+  { "/Windows/_Utility",      "<control>u",  utility_cb,              0, NULL },
+  { "/Windows/_Splashscreen", "<control>s",  splashscreen_cb,         0, NULL },
+  { "/Windows/_Top dock",     NULL,          dock_cb,                 DOCK_TOP, NULL },
+  { "/Windows/_Bottom dock",  NULL,          dock_cb,                 DOCK_BOTTOM, NULL },
+  { "/Windows/_Left dock",    NULL,          dock_cb,                 DOCK_LEFT, NULL },
+  { "/Windows/_Right dock",   NULL,          dock_cb,                 DOCK_RIGHT, NULL },
+  { "/Windows/_All docks",    NULL,          dock_cb,                 DOCK_ALL, NULL },
+  { "/Windows/Des_ktop",      NULL,          desktop_cb,              0, NULL },
+  { "/Windows/Me_nu",         NULL,          menu_cb,                 0, NULL },
+  { "/Windows/Tool_bar",      NULL,          toolbar_cb,              0, NULL },
+  { "/Windows/Override Redirect",      NULL,          override_redirect_cb,              0, NULL },
+  { "/Windows/Border Only",      NULL,          border_only_cb,              0, NULL }
+};
+
+static void
+sleep_cb (GtkWidget *button,
+          gpointer   data)
+{
+  sleep (1000);
+}
+
+static void
+toggle_aspect_ratio (GtkWidget *button,
+                     gpointer   data)
+{
+  GtkWidget *window;
+  GdkGeometry geom;
+
+  if (aspect_on)
+    {
+      geom.min_aspect = 0;
+      geom.max_aspect = 65535;
+    }
+  else
+    {
+      geom.min_aspect = 1.777778;
+      geom.max_aspect = 1.777778;
+    }
+
+  aspect_on = !aspect_on;
+
+  window = gtk_widget_get_ancestor (button, GTK_TYPE_WINDOW);
+  if (window)
+    gtk_window_set_geometry_hints (GTK_WINDOW (window),
+				   GTK_WIDGET (data),
+				   &geom,
+				   GDK_HINT_ASPECT);
+				   
+}
+
+static void
+toggle_decorated_cb (GtkWidget *button,
+                     gpointer   data)
+{
+  GtkWidget *window;
+  window = gtk_widget_get_ancestor (button, GTK_TYPE_WINDOW);
+  if (window)
+    gtk_window_set_decorated (GTK_WINDOW (window),
+                              !gtk_window_get_decorated (GTK_WINDOW (window)));
+}
+
+static void
+clicked_toolbar_cb (GtkWidget *button,
+                    gpointer   data)
+{
+  GtkWidget *dialog;
+  
+  dialog = gtk_message_dialog_new (GTK_WINDOW (data),
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   GTK_MESSAGE_INFO,
+                                   GTK_BUTTONS_CLOSE,
+                                   "Clicking the toolbar buttons doesn't do anything");
+
+  /* Close dialog on user response */
+  g_signal_connect (G_OBJECT (dialog),
+                    "response",
+                    G_CALLBACK (gtk_widget_destroy),
+                    NULL);
+  
+  gtk_widget_show (dialog);
+}
+
+static void
+update_statusbar (GtkTextBuffer *buffer,
+                  GtkStatusbar  *statusbar)
+{
+  gchar *msg;
+  gint row, col;
+  gint count;
+  GtkTextIter iter;
+  
+  gtk_statusbar_pop (statusbar, 0); /* clear any previous message, underflow is allowed */
+
+  count = gtk_text_buffer_get_char_count (buffer);
+
+  gtk_text_buffer_get_iter_at_mark (buffer,
+                                    &iter,
+                                    gtk_text_buffer_get_insert (buffer));
+
+  row = gtk_text_iter_get_line (&iter);
+  col = gtk_text_iter_get_line_offset (&iter);
+
+  msg = g_strdup_printf ("Cursor at row %d column %d - %d chars in document",
+                         row, col, count);
+
+  gtk_statusbar_push (statusbar, 0, msg);
+
+  g_free (msg);
+}
+
+static void
+mark_set_callback (GtkTextBuffer     *buffer,
+                   const GtkTextIter *new_location,
+                   GtkTextMark       *mark,
+                   gpointer           data)
+{
+  update_statusbar (buffer, GTK_STATUSBAR (data));
+}
+
+static int window_count = 0;
+
+static void
+destroy_cb (GtkWidget *w, gpointer data)
+{
+  --window_count;
+  if (window_count == 0)
+    gtk_main_quit ();
+}
+
+static GtkWidget *
+do_appwindow (void)
+{
+  GtkWidget *window;
+  GtkWidget *table;
+  GtkWidget *toolbar;
+  GtkWidget *handlebox;
+  GtkWidget *statusbar;
+  GtkWidget *contents;
+  GtkWidget *sw;
+  GtkTextBuffer *buffer;
+  GtkAccelGroup *accel_group;      
+  GtkItemFactory *item_factory;
+
+      
+  /* Create the toplevel window
+   */
+
+  ++window_count;
+
+  aspect_on = FALSE;
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Application Window");
+  
+  g_signal_connect (G_OBJECT (window), "destroy",
+                    G_CALLBACK (destroy_cb), NULL);
+      
+  table = gtk_table_new (1, 4, FALSE);
+      
+  gtk_container_add (GTK_CONTAINER (window), table);
+      
+  /* Create the menubar
+   */
+      
+  accel_group = gtk_accel_group_new ();
+  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
+  g_object_unref (accel_group);
+      
+  item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
+
+  /* Set up item factory to go away with the window */
+  g_object_ref (item_factory);
+  g_object_ref_sink (item_factory);
+  g_object_unref (item_factory);
+  g_object_set_data_full (G_OBJECT (window),
+                          "<main>",
+                          item_factory,
+                          (GDestroyNotify) g_object_unref);
+
+  /* create menu items */
+  gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items),
+                                 menu_items, window);
+
+  gtk_table_attach (GTK_TABLE (table),
+                    gtk_item_factory_get_widget (item_factory, "<main>"),
+                    /* X direction */          /* Y direction */
+                    0, 1,                      0, 1,
+                    GTK_EXPAND | GTK_FILL,     0,
+                    0,                         0);
+
+  /* Create document
+   */
+
+  sw = gtk_scrolled_window_new (NULL, NULL);
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+
+  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                       GTK_SHADOW_IN);
+      
+  gtk_table_attach (GTK_TABLE (table),
+                    sw,
+                    /* X direction */       /* Y direction */
+                    0, 1,                   2, 3,
+                    GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
+                    0,                      0);
+
+  gtk_window_set_default_size (GTK_WINDOW (window),
+                               200, 200);
+      
+  contents = gtk_text_view_new ();
+  gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
+                               PANGO_WRAP_WORD);
+      
+  gtk_container_add (GTK_CONTAINER (sw),
+                     contents);
+
+  /* Create the toolbar
+   */
+  toolbar = gtk_toolbar_new ();
+
+  GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
+  gtk_tool_item_set_tooltip_text(newButton,
+				 "Open another one of these windows");
+  g_signal_connect(G_OBJECT(newButton),
+		   "clicked",
+		   G_CALLBACK(do_appwindow),
+		   window);
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     newButton,
+		     -1); /*-1 means append to end of toolbar*/
+  
+			    
+  GtkToolItem *lockButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
+  gtk_tool_item_set_tooltip_text(lockButton,
+				 "This is a demo button that locks up the demo");
+  g_signal_connect(G_OBJECT(lockButton),
+		   "clicked",
+		   G_CALLBACK(sleep_cb),
+		   window);
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     lockButton,
+		     -1); /*-1 means append to end of toolbar*/
+  
+
+  GtkToolItem *decoButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
+  gtk_tool_item_set_tooltip_text(decoButton,
+				 "This is a demo button that toggles window decorations");
+  g_signal_connect(G_OBJECT(decoButton),
+		   "clicked",
+		   G_CALLBACK(toggle_decorated_cb),
+		   window);
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     decoButton,
+		     -1); /*-1 means append to end of toolbar*/
+
+  GtkToolItem *lockRatioButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
+  gtk_tool_item_set_tooltip_text(lockRatioButton,
+				 "This is a demo button that locks the aspect ratio using a hint");
+  g_signal_connect(G_OBJECT(lockRatioButton),
+		   "clicked",
+		   G_CALLBACK(toggle_aspect_ratio),
+		   window);
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     lockRatioButton,
+		     -1); /*-1 means append to end of toolbar*/
+
+  GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
+  gtk_tool_item_set_tooltip_text(quitButton,
+				 "This is a demo button with a 'quit' icon");
+  g_signal_connect(G_OBJECT(quitButton),
+		   "clicked",
+		   G_CALLBACK(clicked_toolbar_cb),
+		   window);
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     quitButton,
+		     -1); /*-1 means append to end of toolbar*/
+
+  handlebox = gtk_handle_box_new ();
+
+  gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
+      
+  gtk_table_attach (GTK_TABLE (table),
+                    handlebox,
+                    /* X direction */       /* Y direction */
+                    0, 1,                   1, 2,
+                    GTK_EXPAND | GTK_FILL,  0,
+                    0,                      0);
+
+  /* Create statusbar */
+
+  statusbar = gtk_statusbar_new ();
+  gtk_table_attach (GTK_TABLE (table),
+                    statusbar,
+                    /* X direction */       /* Y direction */
+                    0, 1,                   3, 4,
+                    GTK_EXPAND | GTK_FILL,  0,
+                    0,                      0);
+
+  /* Show text widget info in the statusbar */
+  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
+
+  gtk_text_buffer_set_text (buffer,
+                            "This demo demonstrates various kinds of windows that "
+                            "window managers and window manager themes should handle. "
+                            "Be sure to tear off the menu and toolbar, those are also "
+                            "a special kind of window.",
+                            -1);
+      
+  g_signal_connect_object (buffer,
+                           "changed",
+                           G_CALLBACK (update_statusbar),
+                           statusbar,
+                           0);
+
+  g_signal_connect_object (buffer,
+                           "mark_set", /* cursor moved */
+                           G_CALLBACK (mark_set_callback),
+                           statusbar,
+                           0);
+      
+  update_statusbar (buffer, GTK_STATUSBAR (statusbar));
+
+  gtk_widget_show_all (window);
+
+  return window;
+}
+
+
diff --git a/src/tools/marco-window-demo.png b/src/tools/marco-window-demo.png
new file mode 100644
index 00000000..d87f8296
--- /dev/null
+++ b/src/tools/marco-window-demo.png
diff --git a/src/ui/draw-workspace.c b/src/ui/draw-workspace.c
new file mode 100644
index 00000000..b1a7c733
--- /dev/null
+++ b/src/ui/draw-workspace.c
@@ -0,0 +1,229 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Draw a workspace */
+
+/* This file should not be modified to depend on other files in
+ * libwnck or marco, since it's used in both of them
+ */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "draw-workspace.h"
+
+
+static void
+get_window_rect (const WnckWindowDisplayInfo *win,
+                 int                    screen_width,
+                 int                    screen_height,
+                 const GdkRectangle    *workspace_rect,
+                 GdkRectangle          *rect)
+{
+  double width_ratio, height_ratio;
+  int x, y, width, height;
+  
+  width_ratio = (double) workspace_rect->width / (double) screen_width;
+  height_ratio = (double) workspace_rect->height / (double) screen_height;
+  
+  x = win->x;
+  y = win->y;
+  width = win->width;
+  height = win->height;
+  
+  x *= width_ratio;
+  y *= height_ratio;
+  width *= width_ratio;
+  height *= height_ratio;
+  
+  x += workspace_rect->x;
+  y += workspace_rect->y;
+  
+  if (width < 3)
+    width = 3;
+  if (height < 3)
+    height = 3;
+
+  rect->x = x;
+  rect->y = y;
+  rect->width = width;
+  rect->height = height;
+}
+
+static void
+draw_window (GtkWidget                   *widget,
+             GdkDrawable                 *drawable,
+             const WnckWindowDisplayInfo *win,
+             const GdkRectangle          *winrect,
+             GtkStateType                state)
+{
+  cairo_t *cr;
+  GdkPixbuf *icon;
+  int icon_x, icon_y, icon_w, icon_h;
+  gboolean is_active;
+  GdkColor *color;
+  GtkStyle *style;
+
+  is_active = win->is_active;
+  
+  cr = gdk_cairo_create (drawable);
+  cairo_rectangle (cr, winrect->x, winrect->y, winrect->width, winrect->height);
+  cairo_clip (cr);
+
+  style = gtk_widget_get_style (widget);
+  if (is_active)
+    color = &style->light[state];
+  else
+    color = &style->bg[state];
+  cairo_set_source_rgb (cr,
+                        color->red / 65535.,
+                        color->green / 65535.,
+                        color->blue / 65535.);
+
+  cairo_rectangle (cr,
+                   winrect->x + 1, winrect->y + 1,
+                   MAX (0, winrect->width - 2), MAX (0, winrect->height - 2));
+  cairo_fill (cr);
+
+
+  icon = win->icon;
+
+  icon_w = icon_h = 0;
+          
+  if (icon)
+    {              
+      icon_w = gdk_pixbuf_get_width (icon);
+      icon_h = gdk_pixbuf_get_height (icon);
+
+      /* If the icon is too big, fall back to mini icon.
+       * We don't arbitrarily scale the icon, because it's
+       * just too slow on my Athlon 850.
+       */
+      if (icon_w > (winrect->width - 2) ||
+          icon_h > (winrect->height - 2))
+        {
+          icon = win->mini_icon;
+          if (icon)
+            {
+              icon_w = gdk_pixbuf_get_width (icon);
+              icon_h = gdk_pixbuf_get_height (icon);
+        
+              /* Give up. */
+              if (icon_w > (winrect->width - 2) ||
+                  icon_h > (winrect->height - 2))
+                icon = NULL;
+            }
+        }
+    }
+
+  if (icon)
+    {
+      icon_x = winrect->x + (winrect->width - icon_w) / 2;
+      icon_y = winrect->y + (winrect->height - icon_h) / 2;
+      
+      cairo_save (cr);
+      gdk_cairo_set_source_pixbuf (cr, icon, icon_x, icon_y);
+      cairo_rectangle (cr, icon_x, icon_y, icon_w, icon_h);
+      cairo_clip (cr);
+      cairo_paint (cr);
+      cairo_restore (cr);
+    }
+          
+  if (is_active)
+    color = &style->fg[state];
+  else
+    color = &style->fg[state];
+
+  cairo_set_source_rgb (cr,
+                        color->red / 65535.,
+                        color->green / 65535.,
+                        color->blue / 65535.);
+  cairo_set_line_width (cr, 1.0);
+  cairo_rectangle (cr,
+                   winrect->x + 0.5, winrect->y + 0.5,
+                   MAX (0, winrect->width - 1), MAX (0, winrect->height - 1));
+  cairo_stroke (cr);
+  
+  cairo_destroy (cr);
+}
+
+void
+wnck_draw_workspace (GtkWidget                   *widget,
+                     GdkDrawable                 *drawable,
+                     int                          x,
+                     int                          y,
+                     int                          width,
+                     int                          height,
+                     int                          screen_width,
+                     int                          screen_height,
+                     GdkPixbuf                   *workspace_background,
+                     gboolean                     is_active,
+                     const WnckWindowDisplayInfo *windows,
+                     int                          n_windows)
+{
+  int i;
+  GdkRectangle workspace_rect;
+  GtkStateType state;
+  cairo_t *cr;
+
+  workspace_rect.x = x;
+  workspace_rect.y = y;
+  workspace_rect.width = width;
+  workspace_rect.height = height;
+
+  if (is_active)
+    state = GTK_STATE_SELECTED;
+  else if (workspace_background) 
+    state = GTK_STATE_PRELIGHT;
+  else
+    state = GTK_STATE_NORMAL;
+
+  cr = gdk_cairo_create (drawable);
+  
+  if (workspace_background)
+    {
+      gdk_cairo_set_source_pixbuf (cr, workspace_background, x, y);
+      cairo_paint (cr);
+    }
+  else
+    {
+      gdk_cairo_set_source_color (cr, &gtk_widget_get_style (widget)->dark[state]);
+      cairo_rectangle (cr, x, y, width, height);
+      cairo_fill (cr);
+    }
+
+  cairo_destroy (cr);
+  
+  i = 0;
+  while (i < n_windows)
+    {
+      const WnckWindowDisplayInfo *win = &windows[i];
+      GdkRectangle winrect;
+      
+      get_window_rect (win, screen_width,
+                       screen_height, &workspace_rect, &winrect);
+      
+      draw_window (widget,
+                   drawable,
+                   win,
+                   &winrect,
+                   state);
+      
+      ++i;
+    }
+}
diff --git a/src/ui/draw-workspace.h b/src/ui/draw-workspace.h
new file mode 100644
index 00000000..a8b77cab
--- /dev/null
+++ b/src/ui/draw-workspace.h
@@ -0,0 +1,61 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Draw a workspace */
+
+/* This file should not be modified to depend on other files in
+ * libwnck or marco, since it's used in both of them
+ */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef WNCK_DRAW_WORKSPACE_H
+#define WNCK_DRAW_WORKSPACE_H
+
+#include <gdk/gdk.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gtk/gtk.h>
+
+typedef struct
+{
+  GdkPixbuf *icon;
+  GdkPixbuf *mini_icon;
+  int x;
+  int y;
+  int width;
+  int height;
+
+  guint is_active : 1;
+  
+} WnckWindowDisplayInfo;
+
+void wnck_draw_workspace (GtkWidget                   *widget,
+                          GdkDrawable                 *drawable,
+                          int                          x,
+                          int                          y,
+                          int                          width,
+                          int                          height,
+                          int                          screen_width,
+                          int                          screen_height,
+                          GdkPixbuf                   *workspace_background,
+                          gboolean                     is_active,
+                          const WnckWindowDisplayInfo *windows,
+                          int                          n_windows);
+
+#endif
diff --git a/src/ui/fixedtip.c b/src/ui/fixedtip.c
new file mode 100644
index 00000000..93370636
--- /dev/null
+++ b/src/ui/fixedtip.c
@@ -0,0 +1,133 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco fixed tooltip routine */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "fixedtip.h"
+#include "ui.h"
+
+/**
+ * The floating rectangle.  This is a GtkWindow, and it contains
+ * the "label" widget, below.
+ */
+static GtkWidget *tip = NULL;
+
+/**
+ * The actual text that gets displayed.
+ */
+static GtkWidget *label = NULL;
+/*
+ * X coordinate of the right-hand edge of the screen.
+ *
+ * \bug  This appears to be a bug; screen_right_edge is calculated only when
+ *       the window is redrawn.  Actually we should never cache it because
+ *       different windows are different sizes.
+ */
+static int screen_right_edge = 0;
+/*
+ * Y coordinate of the bottom edge of the screen.
+ *
+ * \bug  As with screen_right_edge.
+ */
+static int screen_bottom_edge = 0;
+
+static gint
+expose_handler (GtkTooltips *tooltips)
+{
+  gtk_paint_flat_box (gtk_widget_get_style (tip), gtk_widget_get_window (tip),
+                      GTK_STATE_NORMAL, GTK_SHADOW_OUT, 
+                      NULL, tip, "tooltip",
+                      0, 0, -1, -1);
+
+  return FALSE;
+}
+
+void
+meta_fixed_tip_show (Display *xdisplay, int screen_number,
+                     int root_x, int root_y,
+                     const char *markup_text)
+{
+  int w, h;
+  
+  if (tip == NULL)
+    {      
+      tip = gtk_window_new (GTK_WINDOW_POPUP);
+      gtk_window_set_type_hint (GTK_WINDOW(tip), GDK_WINDOW_TYPE_HINT_TOOLTIP);
+
+      {
+        GdkScreen *gdk_screen;
+	GdkRectangle monitor;
+	gint mon_num;
+
+        gdk_screen = gdk_display_get_screen (gdk_display_get_default (),
+                                             screen_number);
+        gtk_window_set_screen (GTK_WINDOW (tip),
+                               gdk_screen);
+	mon_num = gdk_screen_get_monitor_at_point (gdk_screen, root_x, root_y);
+	gdk_screen_get_monitor_geometry (gdk_screen, mon_num, &monitor);
+	screen_right_edge = monitor.x + monitor.width;
+	screen_bottom_edge = monitor.y + monitor.height;
+      }
+      
+      gtk_widget_set_app_paintable (tip, TRUE);
+      gtk_window_set_resizable (GTK_WINDOW (tip), FALSE);
+      gtk_widget_set_name (tip, "gtk-tooltips");
+      gtk_container_set_border_width (GTK_CONTAINER (tip), 4);
+
+      g_signal_connect_swapped (tip, "expose_event",
+				 G_CALLBACK (expose_handler), NULL);
+
+      label = gtk_label_new (NULL);
+      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+      gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
+      gtk_widget_show (label);
+      
+      gtk_container_add (GTK_CONTAINER (tip), label);
+
+      g_signal_connect (tip, "destroy",
+			G_CALLBACK (gtk_widget_destroyed), &tip);
+    }
+
+  gtk_label_set_markup (GTK_LABEL (label), markup_text);
+  
+  gtk_window_get_size (GTK_WINDOW (tip), &w, &h);
+
+  if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+      root_x = MAX(0, root_x - w);
+
+  if ((root_x + w) > screen_right_edge)
+    root_x -= (root_x + w) - screen_right_edge;
+  
+  gtk_window_move (GTK_WINDOW (tip), root_x, root_y);
+
+  gtk_widget_show (tip);
+}
+
+void
+meta_fixed_tip_hide (void)
+{
+  if (tip)
+    {
+      gtk_widget_destroy (tip);
+      tip = NULL;
+    }
+}
diff --git a/src/ui/fixedtip.h b/src/ui/fixedtip.h
new file mode 100644
index 00000000..28a618d9
--- /dev/null
+++ b/src/ui/fixedtip.h
@@ -0,0 +1,69 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file fixedtip.h  Marco fixed tooltip routine
+ * 
+ * Sometimes we want to display a small floating rectangle with helpful
+ * text near the pointer.  For example, if the user holds the mouse over
+ * the maximise button, we can display a tooltip saying "Maximize".
+ * The text is localised, of course.
+ *
+ * This file contains the functions to create and delete these tooltips.
+ *
+ * \todo  Since we now consider MetaDisplay a singleton, there can be
+ *        only one tooltip per display; this might quite simply live in
+ *        display.c.  Alternatively, it could move to frames.c, which
+ *        is the only place this business is called anyway.
+ *
+ * \todo  Apparently some UI needs changing (check bugzilla)
+ */
+
+#ifndef META_FIXED_TIP_H
+#define META_FIXED_TIP_H
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+
+/**
+ * Displays a tooltip.  There can be only one across the entire system.
+ * This function behaves identically whether or not a tooltip is already
+ * displayed, but if it is the window will be reused rather than destroyed
+ * and recreated.
+ *
+ * \param  xdisplay       An X display.
+ * \param  screen_number  The number of the screen.
+ * \param  root_x         The X coordinate where the tooltip should appear
+ * \param  root_y         The Y coordinate where the tooltip should appear
+ * \param  markup_text    Text to display in the tooltip; can contain markup
+ */
+void meta_fixed_tip_show (Display *xdisplay, int screen_number,
+                          int root_x, int root_y,
+                          const char *markup_text);
+
+/**
+ * Removes the tooltip that was created by meta_fixed_tip_show().  If there
+ * is no tooltip currently visible, this is a no-op.
+ */
+void meta_fixed_tip_hide (void);
+
+
+#endif
diff --git a/src/ui/frames.c b/src/ui/frames.c
new file mode 100644
index 00000000..bb4c863c
--- /dev/null
+++ b/src/ui/frames.c
@@ -0,0 +1,2940 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window frame manager widget */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Red Hat, Inc.
+ * Copyright (C) 2005, 2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <math.h>
+#include "boxes.h"
+#include "frames.h"
+#include "util.h"
+#include "core.h"
+#include "menu.h"
+#include "fixedtip.h"
+#include "theme.h"
+#include "prefs.h"
+#include "ui.h"
+
+#ifdef HAVE_SHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+#define DEFAULT_INNER_BUTTON_BORDER 3
+
+static void meta_frames_class_init (MetaFramesClass *klass);
+static void meta_frames_init       (MetaFrames      *frames);
+static void meta_frames_destroy    (GtkObject       *object);
+static void meta_frames_finalize   (GObject         *object);
+static void meta_frames_style_set  (GtkWidget       *widget,
+                                    GtkStyle        *prev_style);
+static void meta_frames_realize    (GtkWidget       *widget);
+static void meta_frames_unrealize  (GtkWidget       *widget);
+
+static void meta_frames_update_prelit_control (MetaFrames      *frames,
+                                               MetaUIFrame     *frame,
+                                               MetaFrameControl control);
+static gboolean meta_frames_button_press_event    (GtkWidget           *widget,
+                                                   GdkEventButton      *event);
+static gboolean meta_frames_button_release_event  (GtkWidget           *widget,
+                                                   GdkEventButton      *event);
+static gboolean meta_frames_motion_notify_event   (GtkWidget           *widget,
+                                                   GdkEventMotion      *event);
+static gboolean meta_frames_destroy_event         (GtkWidget           *widget,
+                                                   GdkEventAny         *event);
+static gboolean meta_frames_expose_event          (GtkWidget           *widget,
+                                                   GdkEventExpose      *event);
+static gboolean meta_frames_enter_notify_event    (GtkWidget           *widget,
+                                                   GdkEventCrossing    *event);
+static gboolean meta_frames_leave_notify_event    (GtkWidget           *widget,
+                                                   GdkEventCrossing    *event);
+
+static void meta_frames_attach_style (MetaFrames  *frames,
+                                      MetaUIFrame *frame);
+
+static void meta_frames_paint_to_drawable (MetaFrames   *frames,
+                                           MetaUIFrame  *frame,
+                                           GdkDrawable  *drawable,
+                                           GdkRegion    *region,
+                                           int           x_offset,
+                                           int           y_offset);
+
+static void meta_frames_set_window_background (MetaFrames   *frames,
+                                               MetaUIFrame  *frame);
+
+static void meta_frames_calc_geometry (MetaFrames        *frames,
+                                       MetaUIFrame         *frame,
+                                       MetaFrameGeometry *fgeom);
+
+static void meta_frames_ensure_layout (MetaFrames      *frames,
+                                       MetaUIFrame     *frame);
+
+static MetaUIFrame* meta_frames_lookup_window (MetaFrames *frames,
+                                               Window      xwindow);
+
+static void meta_frames_font_changed          (MetaFrames *frames);
+static void meta_frames_button_layout_changed (MetaFrames *frames);
+
+
+static GdkRectangle*    control_rect (MetaFrameControl   control,
+                                      MetaFrameGeometry *fgeom);
+static MetaFrameControl get_control  (MetaFrames        *frames,
+                                      MetaUIFrame       *frame,
+                                      int                x,
+                                      int                y);
+static void clear_tip (MetaFrames *frames);
+static void invalidate_all_caches (MetaFrames *frames);
+static void invalidate_whole_window (MetaFrames *frames,
+                                     MetaUIFrame *frame);
+
+static GtkWidgetClass *parent_class = NULL;
+
+GType
+meta_frames_get_type (void)
+{
+  static GType frames_type = 0;
+
+  if (!frames_type)
+    {
+      static const GtkTypeInfo frames_info =
+      {
+        "MetaFrames",
+        sizeof (MetaFrames),
+        sizeof (MetaFramesClass),
+        (GtkClassInitFunc) meta_frames_class_init,
+        (GtkObjectInitFunc) meta_frames_init,
+        /* reserved_1 */ NULL,
+        /* reserved_2 */ NULL,
+        (GtkClassInitFunc) NULL,
+      };
+
+      frames_type = gtk_type_unique (GTK_TYPE_WINDOW, &frames_info);
+    }
+
+  return frames_type;
+}
+
+static void
+meta_frames_class_init (MetaFramesClass *class)
+{
+  GObjectClass   *gobject_class;
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+
+  gobject_class = G_OBJECT_CLASS (class);
+  object_class = (GtkObjectClass*) class;
+  widget_class = (GtkWidgetClass*) class;
+
+  parent_class = g_type_class_peek_parent (class);
+
+  gobject_class->finalize = meta_frames_finalize;
+  object_class->destroy = meta_frames_destroy;
+
+  widget_class->style_set = meta_frames_style_set;
+
+  widget_class->realize = meta_frames_realize;
+  widget_class->unrealize = meta_frames_unrealize;
+
+  widget_class->expose_event = meta_frames_expose_event;
+  widget_class->destroy_event = meta_frames_destroy_event;
+  widget_class->button_press_event = meta_frames_button_press_event;
+  widget_class->button_release_event = meta_frames_button_release_event;
+  widget_class->motion_notify_event = meta_frames_motion_notify_event;
+  widget_class->enter_notify_event = meta_frames_enter_notify_event;
+  widget_class->leave_notify_event = meta_frames_leave_notify_event;
+}
+
+static gint
+unsigned_long_equal (gconstpointer v1,
+                     gconstpointer v2)
+{
+  return *((const gulong*) v1) == *((const gulong*) v2);
+}
+
+static guint
+unsigned_long_hash (gconstpointer v)
+{
+  gulong val = * (const gulong *) v;
+
+  /* I'm not sure this works so well. */
+#if GLIB_SIZEOF_LONG > 4
+  return (guint) (val ^ (val >> 32));
+#else
+  return val;
+#endif
+}
+
+static void
+prefs_changed_callback (MetaPreference pref,
+                        void          *data)
+{
+  switch (pref)
+    {
+    case META_PREF_TITLEBAR_FONT:
+      meta_frames_font_changed (META_FRAMES (data));
+      break;
+    case META_PREF_BUTTON_LAYOUT:
+      meta_frames_button_layout_changed (META_FRAMES (data));
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+meta_frames_init (MetaFrames *frames)
+{
+  GTK_WINDOW (frames)->type = GTK_WINDOW_POPUP;
+
+  frames->text_heights = g_hash_table_new (NULL, NULL);
+
+  frames->frames = g_hash_table_new (unsigned_long_hash, unsigned_long_equal);
+
+  frames->tooltip_timeout = 0;
+
+  frames->expose_delay_count = 0;
+
+  frames->invalidate_cache_timeout_id = 0;
+  frames->invalidate_frames = NULL;
+  frames->cache = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+  gtk_widget_set_double_buffered (GTK_WIDGET (frames), FALSE);
+
+  meta_prefs_add_listener (prefs_changed_callback, frames);
+}
+
+static void
+listify_func (gpointer key, gpointer value, gpointer data)
+{
+  GSList **listp;
+
+  listp = data;
+  *listp = g_slist_prepend (*listp, value);
+}
+
+static void
+meta_frames_destroy (GtkObject *object)
+{
+  GSList *winlist;
+  GSList *tmp;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (object);
+
+  clear_tip (frames);
+
+  winlist = NULL;
+  g_hash_table_foreach (frames->frames, listify_func, &winlist);
+
+  /* Unmanage all frames */
+  for (tmp = winlist; tmp != NULL; tmp = tmp->next)
+    {
+      MetaUIFrame *frame;
+
+      frame = tmp->data;
+
+      meta_frames_unmanage_window (frames, frame->xwindow);
+    }
+  g_slist_free (winlist);
+
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
+}
+
+static void
+meta_frames_finalize (GObject *object)
+{
+  MetaFrames *frames;
+
+  frames = META_FRAMES (object);
+
+  meta_prefs_remove_listener (prefs_changed_callback, frames);
+
+  g_hash_table_destroy (frames->text_heights);
+
+  invalidate_all_caches (frames);
+  if (frames->invalidate_cache_timeout_id)
+    g_source_remove (frames->invalidate_cache_timeout_id);
+
+  g_assert (g_hash_table_size (frames->frames) == 0);
+  g_hash_table_destroy (frames->frames);
+  g_hash_table_destroy (frames->cache);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+typedef struct
+{
+  MetaRectangle rect;
+  GdkPixmap *pixmap;
+} CachedFramePiece;
+
+typedef struct
+{
+  /* Caches of the four rendered sides in a MetaFrame.
+   * Order: top (titlebar), left, right, bottom.
+   */
+  CachedFramePiece piece[4];
+} CachedPixels;
+
+static CachedPixels *
+get_cache (MetaFrames *frames,
+           MetaUIFrame *frame)
+{
+  CachedPixels *pixels;
+
+  pixels = g_hash_table_lookup (frames->cache, frame);
+
+  if (!pixels)
+    {
+      pixels = g_new0 (CachedPixels, 1);
+      g_hash_table_insert (frames->cache, frame, pixels);
+    }
+
+  return pixels;
+}
+
+static void
+invalidate_cache (MetaFrames *frames,
+                  MetaUIFrame *frame)
+{
+  CachedPixels *pixels = get_cache (frames, frame);
+  int i;
+
+  for (i = 0; i < 4; i++)
+    if (pixels->piece[i].pixmap)
+      g_object_unref (pixels->piece[i].pixmap);
+
+  g_free (pixels);
+  g_hash_table_remove (frames->cache, frame);
+}
+
+static void
+invalidate_all_caches (MetaFrames *frames)
+{
+  GList *l;
+
+  for (l = frames->invalidate_frames; l; l = l->next)
+    {
+      MetaUIFrame *frame = l->data;
+
+      invalidate_cache (frames, frame);
+    }
+
+  g_list_free (frames->invalidate_frames);
+  frames->invalidate_frames = NULL;
+}
+
+static gboolean
+invalidate_cache_timeout (gpointer data)
+{
+  MetaFrames *frames = data;
+
+  invalidate_all_caches (frames);
+  frames->invalidate_cache_timeout_id = 0;
+  return FALSE;
+}
+
+static void
+queue_recalc_func (gpointer key, gpointer value, gpointer data)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (data);
+  frame = value;
+
+  /* If a resize occurs it will cause a redraw, but the
+   * resize may not actually be needed so we always redraw
+   * in case of color change.
+   */
+  meta_frames_set_window_background (frames, frame);
+
+  invalidate_whole_window (frames, frame);
+  meta_core_queue_frame_resize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                frame->xwindow);
+  if (frame->layout)
+    {
+      /* save title to recreate layout */
+      g_free (frame->title);
+
+      frame->title = g_strdup (pango_layout_get_text (frame->layout));
+
+      g_object_unref (G_OBJECT (frame->layout));
+      frame->layout = NULL;
+    }
+}
+
+static void
+meta_frames_font_changed (MetaFrames *frames)
+{
+  if (g_hash_table_size (frames->text_heights) > 0)
+    {
+      g_hash_table_destroy (frames->text_heights);
+      frames->text_heights = g_hash_table_new (NULL, NULL);
+    }
+
+  /* Queue a draw/resize on all frames */
+  g_hash_table_foreach (frames->frames,
+                        queue_recalc_func, frames);
+
+}
+
+static void
+queue_draw_func (gpointer key, gpointer value, gpointer data)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (data);
+  frame = value;
+
+  /* If a resize occurs it will cause a redraw, but the
+   * resize may not actually be needed so we always redraw
+   * in case of color change.
+   */
+  meta_frames_set_window_background (frames, frame);
+
+  invalidate_whole_window (frames, frame);
+}
+
+static void
+meta_frames_button_layout_changed (MetaFrames *frames)
+{
+  g_hash_table_foreach (frames->frames,
+                        queue_draw_func, frames);
+}
+
+static void
+reattach_style_func (gpointer key, gpointer value, gpointer data)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (data);
+  frame = value;
+
+  meta_frames_attach_style (frames, frame);
+}
+
+static void
+meta_frames_style_set  (GtkWidget *widget,
+                        GtkStyle  *prev_style)
+{
+  MetaFrames *frames;
+
+  frames = META_FRAMES (widget);
+
+  meta_frames_font_changed (frames);
+
+  g_hash_table_foreach (frames->frames,
+                        reattach_style_func, frames);
+
+  GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
+}
+
+static void
+meta_frames_ensure_layout (MetaFrames  *frames,
+                           MetaUIFrame *frame)
+{
+  GtkWidget *widget;
+  MetaFrameFlags flags;
+  MetaFrameType type;
+  MetaFrameStyle *style;
+
+  g_return_if_fail (GTK_WIDGET_REALIZED (frames));
+
+  widget = GTK_WIDGET (frames);
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_FRAME_FLAGS, &flags,
+                 META_CORE_GET_FRAME_TYPE, &type,
+                 META_CORE_GET_END);
+
+  style = meta_theme_get_frame_style (meta_theme_get_current (),
+                                      type, flags);
+
+  if (style != frame->cache_style)
+    {
+      if (frame->layout)
+        {
+          /* save title to recreate layout */
+          g_free (frame->title);
+
+          frame->title = g_strdup (pango_layout_get_text (frame->layout));
+
+          g_object_unref (G_OBJECT (frame->layout));
+          frame->layout = NULL;
+        }
+    }
+
+  frame->cache_style = style;
+
+  if (frame->layout == NULL)
+    {
+      gpointer key, value;
+      PangoFontDescription *font_desc;
+      double scale;
+      int size;
+
+      scale = meta_theme_get_title_scale (meta_theme_get_current (),
+                                          type,
+                                          flags);
+
+      frame->layout = gtk_widget_create_pango_layout (widget, frame->title);
+
+      pango_layout_set_auto_dir (frame->layout, FALSE);
+
+      font_desc = meta_gtk_widget_get_font_desc (widget, scale,
+                                                 meta_prefs_get_titlebar_font ());
+
+      size = pango_font_description_get_size (font_desc);
+
+      if (g_hash_table_lookup_extended (frames->text_heights,
+                                        GINT_TO_POINTER (size),
+                                        &key, &value))
+        {
+          frame->text_height = GPOINTER_TO_INT (value);
+        }
+      else
+        {
+          frame->text_height =
+            meta_pango_font_desc_get_text_height (font_desc,
+                                                  gtk_widget_get_pango_context (widget));
+
+          g_hash_table_replace (frames->text_heights,
+                                GINT_TO_POINTER (size),
+                                GINT_TO_POINTER (frame->text_height));
+        }
+
+      pango_layout_set_font_description (frame->layout,
+                                         font_desc);
+
+      pango_font_description_free (font_desc);
+
+      /* Save some RAM */
+      g_free (frame->title);
+      frame->title = NULL;
+    }
+}
+
+static void
+meta_frames_calc_geometry (MetaFrames        *frames,
+                           MetaUIFrame       *frame,
+                           MetaFrameGeometry *fgeom)
+{
+  int width, height;
+  MetaFrameFlags flags;
+  MetaFrameType type;
+  MetaButtonLayout button_layout;
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_CLIENT_WIDTH, &width,
+                 META_CORE_GET_CLIENT_HEIGHT, &height,
+                 META_CORE_GET_FRAME_FLAGS, &flags,
+                 META_CORE_GET_FRAME_TYPE, &type,
+                 META_CORE_GET_END);
+
+  meta_frames_ensure_layout (frames, frame);
+
+  meta_prefs_get_button_layout (&button_layout);
+
+  meta_theme_calc_geometry (meta_theme_get_current (),
+                            type,
+                            frame->text_height,
+                            flags,
+                            width, height,
+                            &button_layout,
+                            fgeom);
+}
+
+MetaFrames*
+meta_frames_new (int screen_number)
+{
+  GdkScreen *screen;
+
+  screen = gdk_display_get_screen (gdk_display_get_default (),
+                                   screen_number);
+
+  return g_object_new (META_TYPE_FRAMES,
+                       "screen", screen,
+                       NULL);
+}
+
+/* In order to use a style with a window it has to be attached to that
+ * window. Actually, the colormaps just have to match, but since GTK+
+ * already takes care of making sure that its cheap to attach a style
+ * to multiple windows with the same colormap, we can just go ahead
+ * and attach separately for each window.
+ */
+static void
+meta_frames_attach_style (MetaFrames  *frames,
+                          MetaUIFrame *frame)
+{
+  if (frame->style != NULL)
+    gtk_style_detach (frame->style);
+
+  /* Weirdly, gtk_style_attach() steals a reference count from the style passed in */
+  g_object_ref (GTK_WIDGET (frames)->style);
+  frame->style = gtk_style_attach (GTK_WIDGET (frames)->style, frame->window);
+}
+
+void
+meta_frames_manage_window (MetaFrames *frames,
+                           Window      xwindow,
+                           GdkWindow  *window)
+{
+  MetaUIFrame *frame;
+
+  g_assert (window);
+
+  frame = g_new (MetaUIFrame, 1);
+
+  frame->window = window;
+
+  gdk_window_set_user_data (frame->window, frames);
+
+  frame->style = NULL;
+  meta_frames_attach_style (frames, frame);
+
+  /* Don't set event mask here, it's in frame.c */
+
+  frame->xwindow = xwindow;
+  frame->cache_style = NULL;
+  frame->layout = NULL;
+  frame->text_height = -1;
+  frame->title = NULL;
+  frame->expose_delayed = FALSE;
+  frame->shape_applied = FALSE;
+  frame->prelit_control = META_FRAME_CONTROL_NONE;
+
+  /* Don't set the window background yet; we need frame->xwindow to be
+   * registered with its MetaWindow, which happens after this function
+   * and meta_ui_create_frame_window() return to meta_window_ensure_frame().
+   */
+
+  meta_core_grab_buttons (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+  g_hash_table_replace (frames->frames, &frame->xwindow, frame);
+}
+
+void
+meta_frames_unmanage_window (MetaFrames *frames,
+                             Window      xwindow)
+{
+  MetaUIFrame *frame;
+
+  clear_tip (frames);
+
+  frame = g_hash_table_lookup (frames->frames, &xwindow);
+
+  if (frame)
+    {
+      /* invalidating all caches ensures the frame
+       * is not actually referenced anymore
+       */
+      invalidate_all_caches (frames);
+
+      /* restore the cursor */
+      meta_core_set_screen_cursor (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                   frame->xwindow,
+                                   META_CURSOR_DEFAULT);
+
+      gdk_window_set_user_data (frame->window, NULL);
+
+      if (frames->last_motion_frame == frame)
+        frames->last_motion_frame = NULL;
+
+      g_hash_table_remove (frames->frames, &frame->xwindow);
+
+      gtk_style_detach (frame->style);
+
+      gdk_window_destroy (frame->window);
+
+      if (frame->layout)
+        g_object_unref (G_OBJECT (frame->layout));
+
+      if (frame->title)
+        g_free (frame->title);
+
+      g_free (frame);
+    }
+  else
+    meta_warning ("Frame 0x%lx not managed, can't unmanage\n", xwindow);
+}
+
+static void
+meta_frames_realize (GtkWidget *widget)
+{
+  if (GTK_WIDGET_CLASS (parent_class)->realize)
+    GTK_WIDGET_CLASS (parent_class)->realize (widget);
+}
+
+static void
+meta_frames_unrealize (GtkWidget *widget)
+{
+  if (GTK_WIDGET_CLASS (parent_class)->unrealize)
+    GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
+}
+
+static MetaUIFrame*
+meta_frames_lookup_window (MetaFrames *frames,
+                           Window      xwindow)
+{
+  MetaUIFrame *frame;
+
+  frame = g_hash_table_lookup (frames->frames, &xwindow);
+
+  return frame;
+}
+
+void
+meta_frames_get_geometry (MetaFrames *frames,
+                          Window xwindow,
+                          int *top_height, int *bottom_height,
+                          int *left_width, int *right_width)
+{
+  MetaFrameFlags flags;
+  MetaUIFrame *frame;
+  MetaFrameType type;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+
+  if (frame == NULL)
+    meta_bug ("No such frame 0x%lx\n", xwindow);
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_FRAME_FLAGS, &flags,
+                 META_CORE_GET_FRAME_TYPE, &type,
+                 META_CORE_GET_END);
+
+  g_return_if_fail (type < META_FRAME_TYPE_LAST);
+
+  meta_frames_ensure_layout (frames, frame);
+
+  /* We can't get the full geometry, because that depends on
+   * the client window size and probably we're being called
+   * by the core move/resize code to decide on the client
+   * window size
+   */
+  meta_theme_get_frame_borders (meta_theme_get_current (),
+                                type,
+                                frame->text_height,
+                                flags,
+                                top_height, bottom_height,
+                                left_width, right_width);
+}
+
+void
+meta_frames_reset_bg (MetaFrames *frames,
+                      Window  xwindow)
+{
+  MetaUIFrame *frame;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+
+  meta_frames_set_window_background (frames, frame);
+}
+
+static void
+set_background_none (Display *xdisplay,
+                     Window   xwindow)
+{
+  XSetWindowAttributes attrs;
+
+  attrs.background_pixmap = None;
+  XChangeWindowAttributes (xdisplay, xwindow,
+                           CWBackPixmap, &attrs);
+}
+
+void
+meta_frames_unflicker_bg (MetaFrames *frames,
+                          Window      xwindow,
+                          int         target_width,
+                          int         target_height)
+{
+  MetaUIFrame *frame;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+  g_return_if_fail (frame != NULL);
+
+#if 0
+  pixmap = gdk_pixmap_new (frame->window,
+                           width, height,
+                           -1);
+
+  /* Oops, no way to get the background here */
+
+  meta_frames_paint_to_drawable (frames, frame, pixmap);
+#endif
+
+  set_background_none (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+}
+
+void
+meta_frames_apply_shapes (MetaFrames *frames,
+                          Window      xwindow,
+                          int         new_window_width,
+                          int         new_window_height,
+                          gboolean    window_has_shape)
+{
+#ifdef HAVE_SHAPE
+  /* Apply shapes as if window had new_window_width, new_window_height */
+  MetaUIFrame *frame;
+  MetaFrameGeometry fgeom;
+  XRectangle xrect;
+  Region corners_xregion;
+  Region window_xregion;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+  g_return_if_fail (frame != NULL);
+
+  meta_frames_calc_geometry (frames, frame, &fgeom);
+
+  if (!(fgeom.top_left_corner_rounded_radius != 0 ||
+        fgeom.top_right_corner_rounded_radius != 0 ||
+        fgeom.bottom_left_corner_rounded_radius != 0 ||
+        fgeom.bottom_right_corner_rounded_radius != 0 ||
+        window_has_shape))
+    {
+      if (frame->shape_applied)
+        {
+          meta_topic (META_DEBUG_SHAPES,
+                      "Unsetting shape mask on frame 0x%lx\n",
+                      frame->xwindow);
+
+          XShapeCombineMask (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                             ShapeBounding, 0, 0, None, ShapeSet);
+          frame->shape_applied = FALSE;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_SHAPES,
+                      "Frame 0x%lx still doesn't need a shape mask\n",
+                      frame->xwindow);
+        }
+
+      return; /* nothing to do */
+    }
+
+  corners_xregion = XCreateRegion ();
+
+  if (fgeom.top_left_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom.top_left_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = 0;
+          xrect.y = i;
+          xrect.width = width;
+          xrect.height = 1;
+
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
+    }
+
+  if (fgeom.top_right_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom.top_right_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = new_window_width - width;
+          xrect.y = i;
+          xrect.width = width;
+          xrect.height = 1;
+
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
+    }
+
+  if (fgeom.bottom_left_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom.bottom_left_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = 0;
+          xrect.y = new_window_height - i - 1;
+          xrect.width = width;
+          xrect.height = 1;
+
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
+    }
+
+  if (fgeom.bottom_right_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom.bottom_right_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = new_window_width - width;
+          xrect.y = new_window_height - i - 1;
+          xrect.width = width;
+          xrect.height = 1;
+
+          XUnionRectWithRegion (&xrect, corners_xregion, corners_xregion);
+        }
+    }
+
+  window_xregion = XCreateRegion ();
+
+  xrect.x = 0;
+  xrect.y = 0;
+  xrect.width = new_window_width;
+  xrect.height = new_window_height;
+
+  XUnionRectWithRegion (&xrect, window_xregion, window_xregion);
+
+  XSubtractRegion (window_xregion, corners_xregion, window_xregion);
+
+  XDestroyRegion (corners_xregion);
+
+  if (window_has_shape)
+    {
+      /* The client window is oclock or something and has a shape
+       * mask. To avoid a round trip to get its shape region, we
+       * create a fake window that's never mapped, build up our shape
+       * on that, then combine. Wasting the window is assumed cheaper
+       * than a round trip, but who really knows for sure.
+       */
+      XSetWindowAttributes attrs;
+      Window shape_window;
+      Window client_window;
+      Region client_xregion;
+      GdkScreen *screen;
+      int screen_number;
+
+      meta_topic (META_DEBUG_SHAPES,
+                  "Frame 0x%lx needs to incorporate client shape\n",
+                  frame->xwindow);
+
+      screen = gtk_widget_get_screen (GTK_WIDGET (frames));
+      screen_number = gdk_x11_screen_get_screen_number (screen);
+
+      attrs.override_redirect = True;
+
+      shape_window = XCreateWindow (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                    RootWindow (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), screen_number),
+                                    -5000, -5000,
+                                    new_window_width,
+                                    new_window_height,
+                                    0,
+                                    CopyFromParent,
+                                    CopyFromParent,
+                                    (Visual *)CopyFromParent,
+                                    CWOverrideRedirect,
+                                    &attrs);
+
+      /* Copy the client's shape to the temporary shape_window */
+      meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                     META_CORE_GET_CLIENT_XWINDOW, &client_window,
+                     META_CORE_GET_END);
+
+      XShapeCombineShape (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), shape_window, ShapeBounding,
+                          fgeom.left_width,
+                          fgeom.top_height,
+                          client_window,
+                          ShapeBounding,
+                          ShapeSet);
+
+      /* Punch the client area out of the normal frame shape,
+       * then union it with the shape_window's existing shape
+       */
+      client_xregion = XCreateRegion ();
+
+      xrect.x = fgeom.left_width;
+      xrect.y = fgeom.top_height;
+      xrect.width = new_window_width - fgeom.right_width - xrect.x;
+      xrect.height = new_window_height - fgeom.bottom_height - xrect.y;
+
+      XUnionRectWithRegion (&xrect, client_xregion, client_xregion);
+
+      XSubtractRegion (window_xregion, client_xregion, window_xregion);
+
+      XDestroyRegion (client_xregion);
+
+      XShapeCombineRegion (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), shape_window,
+                           ShapeBounding, 0, 0, window_xregion, ShapeUnion);
+
+      /* Now copy shape_window shape to the real frame */
+      XShapeCombineShape (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow, ShapeBounding,
+                          0, 0,
+                          shape_window,
+                          ShapeBounding,
+                          ShapeSet);
+
+      XDestroyWindow (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), shape_window);
+    }
+  else
+    {
+      /* No shape on the client, so just do simple stuff */
+
+      meta_topic (META_DEBUG_SHAPES,
+                  "Frame 0x%lx has shaped corners\n",
+                  frame->xwindow);
+
+      XShapeCombineRegion (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                           ShapeBounding, 0, 0, window_xregion, ShapeSet);
+    }
+
+  frame->shape_applied = TRUE;
+
+  XDestroyRegion (window_xregion);
+#endif /* HAVE_SHAPE */
+}
+
+void
+meta_frames_move_resize_frame (MetaFrames *frames,
+                               Window      xwindow,
+                               int         x,
+                               int         y,
+                               int         width,
+                               int         height)
+{
+  MetaUIFrame *frame = meta_frames_lookup_window (frames, xwindow);
+  int old_x, old_y, old_width, old_height;
+
+	#if GTK_CHECK_VERSION(3, 0, 0)
+		old_width = gdk_window_get_width(GDK_WINDOW(frame->window));
+		old_height = gdk_window_get_height(GDK_WINDOW(frame->window));
+	#else
+		gdk_drawable_get_size(frame->window, &old_width, &old_height);
+	#endif
+
+  gdk_window_get_position (frame->window, &old_x, &old_y);
+
+  gdk_window_move_resize (frame->window, x, y, width, height);
+
+  if (old_width != width || old_height != height)
+    invalidate_whole_window (frames, frame);
+}
+
+void
+meta_frames_queue_draw (MetaFrames *frames,
+                        Window      xwindow)
+{
+  MetaUIFrame *frame;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+
+  invalidate_whole_window (frames, frame);
+}
+
+void
+meta_frames_set_title (MetaFrames *frames,
+                       Window      xwindow,
+                       const char *title)
+{
+  MetaUIFrame *frame;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+
+  g_assert (frame);
+
+  g_free (frame->title);
+  frame->title = g_strdup (title);
+
+  if (frame->layout)
+    {
+      g_object_unref (frame->layout);
+      frame->layout = NULL;
+    }
+
+  invalidate_whole_window (frames, frame);
+}
+
+void
+meta_frames_repaint_frame (MetaFrames *frames,
+                           Window      xwindow)
+{
+  MetaUIFrame *frame;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+
+  g_assert (frame);
+
+  /* repaint everything, so the other frame don't
+   * lag behind if they are exposed
+   */
+  gdk_window_process_all_updates ();
+}
+
+static void
+show_tip_now (MetaFrames *frames)
+{
+  const char *tiptext;
+  MetaUIFrame *frame;
+  int x, y, root_x, root_y;
+  Window root, child;
+  guint mask;
+  MetaFrameControl control;
+
+  frame = frames->last_motion_frame;
+  if (frame == NULL)
+    return;
+
+  XQueryPointer (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                 frame->xwindow,
+                 &root, &child,
+                 &root_x, &root_y,
+                 &x, &y,
+                 &mask);
+
+  control = get_control (frames, frame, x, y);
+
+  tiptext = NULL;
+  switch (control)
+    {
+    case META_FRAME_CONTROL_TITLE:
+      break;
+    case META_FRAME_CONTROL_DELETE:
+      tiptext = _("Close Window");
+      break;
+    case META_FRAME_CONTROL_MENU:
+      tiptext = _("Window Menu");
+      break;
+    case META_FRAME_CONTROL_MINIMIZE:
+      tiptext = _("Minimize Window");
+      break;
+    case META_FRAME_CONTROL_MAXIMIZE:
+      tiptext = _("Maximize Window");
+      break;
+    case META_FRAME_CONTROL_UNMAXIMIZE:
+      tiptext = _("Restore Window");
+      break;
+    case META_FRAME_CONTROL_SHADE:
+      tiptext = _("Roll Up Window");
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      tiptext = _("Unroll Window");
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      tiptext = _("Keep Window On Top");
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      tiptext = _("Remove Window From Top");
+      break;
+    case META_FRAME_CONTROL_STICK:
+      tiptext = _("Always On Visible Workspace");
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      tiptext = _("Put Window On Only One Workspace");
+      break;
+    case META_FRAME_CONTROL_RESIZE_SE:
+      break;
+    case META_FRAME_CONTROL_RESIZE_S:
+      break;
+    case META_FRAME_CONTROL_RESIZE_SW:
+      break;
+    case META_FRAME_CONTROL_RESIZE_N:
+      break;
+    case META_FRAME_CONTROL_RESIZE_NE:
+      break;
+    case META_FRAME_CONTROL_RESIZE_NW:
+      break;
+    case META_FRAME_CONTROL_RESIZE_W:
+      break;
+    case META_FRAME_CONTROL_RESIZE_E:
+      break;
+    case META_FRAME_CONTROL_NONE:
+      break;
+    case META_FRAME_CONTROL_CLIENT_AREA:
+      break;
+    }
+
+  if (tiptext)
+    {
+      MetaFrameGeometry fgeom;
+      GdkRectangle *rect;
+      int dx, dy;
+      int screen_number;
+
+      meta_frames_calc_geometry (frames, frame, &fgeom);
+
+      rect = control_rect (control, &fgeom);
+
+      /* get conversion delta for root-to-frame coords */
+      dx = root_x - x;
+      dy = root_y - y;
+
+      /* Align the tooltip to the button right end if RTL */
+      if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+        dx += rect->width;
+
+      screen_number = gdk_screen_get_number (gtk_widget_get_screen (GTK_WIDGET (frames)));
+
+      meta_fixed_tip_show (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                           screen_number,
+                           rect->x + dx,
+                           rect->y + rect->height + 2 + dy,
+                           tiptext);
+    }
+}
+
+static gboolean
+tip_timeout_func (gpointer data)
+{
+  MetaFrames *frames;
+
+  frames = data;
+
+  show_tip_now (frames);
+
+  return FALSE;
+}
+
+#define TIP_DELAY 450
+static void
+queue_tip (MetaFrames *frames)
+{
+  clear_tip (frames);
+
+  frames->tooltip_timeout = g_timeout_add (TIP_DELAY,
+                                           tip_timeout_func,
+                                           frames);
+}
+
+static void
+clear_tip (MetaFrames *frames)
+{
+  if (frames->tooltip_timeout)
+    {
+      g_source_remove (frames->tooltip_timeout);
+      frames->tooltip_timeout = 0;
+    }
+  meta_fixed_tip_hide ();
+}
+
+static void
+redraw_control (MetaFrames *frames,
+                MetaUIFrame *frame,
+                MetaFrameControl control)
+{
+  MetaFrameGeometry fgeom;
+  GdkRectangle *rect;
+
+  meta_frames_calc_geometry (frames, frame, &fgeom);
+
+  rect = control_rect (control, &fgeom);
+
+  gdk_window_invalidate_rect (frame->window, rect, FALSE);
+  invalidate_cache (frames, frame);
+}
+
+static gboolean
+meta_frame_titlebar_event (MetaUIFrame    *frame,
+                           GdkEventButton *event,
+                           int            action)
+{
+  MetaFrameFlags flags;
+
+  switch (action)
+    {
+    case META_ACTION_TITLEBAR_TOGGLE_SHADE:
+      {
+        meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                       META_CORE_GET_FRAME_FLAGS, &flags,
+                       META_CORE_GET_END);
+
+        if (flags & META_FRAME_ALLOWS_SHADE)
+          {
+            if (flags & META_FRAME_SHADED)
+              meta_core_unshade (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                 frame->xwindow,
+                                 event->time);
+            else
+              meta_core_shade (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                               frame->xwindow,
+                               event->time);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE:
+      {
+        meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                       META_CORE_GET_FRAME_FLAGS, &flags,
+                       META_CORE_GET_END);
+
+        if (flags & META_FRAME_ALLOWS_MAXIMIZE)
+          {
+            meta_core_toggle_maximize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_HORIZONTALLY:
+      {
+        meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                       META_CORE_GET_FRAME_FLAGS, &flags,
+                       META_CORE_GET_END);
+
+        if (flags & META_FRAME_ALLOWS_MAXIMIZE)
+          {
+            meta_core_toggle_maximize_horizontally (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_VERTICALLY:
+      {
+        meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                       META_CORE_GET_FRAME_FLAGS, &flags,
+                       META_CORE_GET_END);
+
+        if (flags & META_FRAME_ALLOWS_MAXIMIZE)
+          {
+            meta_core_toggle_maximize_vertically (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_MINIMIZE:
+      {
+        meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                       META_CORE_GET_FRAME_FLAGS, &flags,
+                       META_CORE_GET_END);
+
+        if (flags & META_FRAME_ALLOWS_MINIMIZE)
+          {
+            meta_core_minimize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+          }
+      }
+      break;
+
+    case META_ACTION_TITLEBAR_NONE:
+      /* Yaay, a sane user that doesn't use that other weird crap! */
+      break;
+
+    case META_ACTION_TITLEBAR_LOWER:
+      meta_core_user_lower_and_unfocus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                        frame->xwindow,
+                                        event->time);
+      break;
+
+    case META_ACTION_TITLEBAR_MENU:
+      meta_core_show_window_menu (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                  frame->xwindow,
+                                  event->x_root,
+                                  event->y_root,
+                                  event->button,
+                                  event->time);
+      break;
+
+    case META_ACTION_TITLEBAR_LAST:
+      break;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+meta_frame_double_click_event (MetaUIFrame    *frame,
+                               GdkEventButton *event)
+{
+  int action = meta_prefs_get_action_double_click_titlebar ();
+
+  return meta_frame_titlebar_event (frame, event, action);
+}
+
+static gboolean
+meta_frame_middle_click_event (MetaUIFrame    *frame,
+                               GdkEventButton *event)
+{
+  int action = meta_prefs_get_action_middle_click_titlebar();
+
+  return meta_frame_titlebar_event (frame, event, action);
+}
+
+static gboolean
+meta_frame_right_click_event(MetaUIFrame     *frame,
+                             GdkEventButton  *event)
+{
+  int action = meta_prefs_get_action_right_click_titlebar();
+
+  return meta_frame_titlebar_event (frame, event, action);
+}
+
+static gboolean
+meta_frames_button_press_event (GtkWidget      *widget,
+                                GdkEventButton *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+  MetaFrameControl control;
+
+  frames = META_FRAMES (widget);
+
+  /* Remember that the display may have already done something with this event.
+   * If so there's probably a GrabOp in effect.
+   */
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  clear_tip (frames);
+
+  control = get_control (frames, frame, event->x, event->y);
+
+  /* focus on click, even if click was on client area */
+  if (event->button == 1 &&
+      !(control == META_FRAME_CONTROL_MINIMIZE ||
+        control == META_FRAME_CONTROL_DELETE ||
+        control == META_FRAME_CONTROL_MAXIMIZE))
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing window with frame 0x%lx due to button 1 press\n",
+                  frame->xwindow);
+      meta_core_user_focus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                            frame->xwindow,
+                            event->time);
+    }
+
+  /* don't do the rest of this if on client area */
+  if (control == META_FRAME_CONTROL_CLIENT_AREA)
+    return FALSE; /* not on the frame, just passed through from client */
+
+  /* We want to shade even if we have a GrabOp, since we'll have a move grab
+   * if we double click the titlebar.
+   */
+  if (control == META_FRAME_CONTROL_TITLE &&
+      event->button == 1 &&
+      event->type == GDK_2BUTTON_PRESS)
+    {
+      meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+      return meta_frame_double_click_event (frame, event);
+    }
+
+  if (meta_core_get_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())) !=
+      META_GRAB_OP_NONE)
+    return FALSE; /* already up to something */
+
+  if (event->button == 1 &&
+      (control == META_FRAME_CONTROL_MAXIMIZE ||
+       control == META_FRAME_CONTROL_UNMAXIMIZE ||
+       control == META_FRAME_CONTROL_MINIMIZE ||
+       control == META_FRAME_CONTROL_DELETE ||
+       control == META_FRAME_CONTROL_SHADE ||
+       control == META_FRAME_CONTROL_UNSHADE ||
+       control == META_FRAME_CONTROL_ABOVE ||
+       control == META_FRAME_CONTROL_UNABOVE ||
+       control == META_FRAME_CONTROL_STICK ||
+       control == META_FRAME_CONTROL_UNSTICK ||
+       control == META_FRAME_CONTROL_MENU))
+    {
+      MetaGrabOp op = META_GRAB_OP_NONE;
+
+      switch (control)
+        {
+        case META_FRAME_CONTROL_MINIMIZE:
+          op = META_GRAB_OP_CLICKING_MINIMIZE;
+          break;
+        case META_FRAME_CONTROL_MAXIMIZE:
+          op = META_GRAB_OP_CLICKING_MAXIMIZE;
+          break;
+        case META_FRAME_CONTROL_UNMAXIMIZE:
+          op = META_GRAB_OP_CLICKING_UNMAXIMIZE;
+          break;
+        case META_FRAME_CONTROL_DELETE:
+          op = META_GRAB_OP_CLICKING_DELETE;
+          break;
+        case META_FRAME_CONTROL_MENU:
+          op = META_GRAB_OP_CLICKING_MENU;
+          break;
+        case META_FRAME_CONTROL_SHADE:
+          op = META_GRAB_OP_CLICKING_SHADE;
+          break;
+        case META_FRAME_CONTROL_UNSHADE:
+          op = META_GRAB_OP_CLICKING_UNSHADE;
+          break;
+        case META_FRAME_CONTROL_ABOVE:
+          op = META_GRAB_OP_CLICKING_ABOVE;
+          break;
+        case META_FRAME_CONTROL_UNABOVE:
+          op = META_GRAB_OP_CLICKING_UNABOVE;
+          break;
+        case META_FRAME_CONTROL_STICK:
+          op = META_GRAB_OP_CLICKING_STICK;
+          break;
+        case META_FRAME_CONTROL_UNSTICK:
+          op = META_GRAB_OP_CLICKING_UNSTICK;
+          break;
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+
+      meta_core_begin_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                               frame->xwindow,
+                               op,
+                               TRUE,
+                               TRUE,
+                               event->button,
+                               0,
+                               event->time,
+                               event->x_root,
+                               event->y_root);
+
+      frame->prelit_control = control;
+      redraw_control (frames, frame, control);
+
+      if (op == META_GRAB_OP_CLICKING_MENU)
+        {
+          MetaFrameGeometry fgeom;
+          GdkRectangle *rect;
+          int dx, dy;
+
+          meta_frames_calc_geometry (frames, frame, &fgeom);
+
+          rect = control_rect (META_FRAME_CONTROL_MENU, &fgeom);
+
+          /* get delta to convert to root coords */
+          dx = event->x_root - event->x;
+          dy = event->y_root - event->y;
+
+          /* Align to the right end of the menu rectangle if RTL */
+          if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+            dx += rect->width;
+
+          meta_core_show_window_menu (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                      frame->xwindow,
+                                      rect->x + dx,
+                                      rect->y + rect->height + dy,
+                                      event->button,
+                                      event->time);
+        }
+    }
+  else if (event->button == 1 &&
+           (control == META_FRAME_CONTROL_RESIZE_SE ||
+            control == META_FRAME_CONTROL_RESIZE_S ||
+            control == META_FRAME_CONTROL_RESIZE_SW ||
+            control == META_FRAME_CONTROL_RESIZE_NE ||
+            control == META_FRAME_CONTROL_RESIZE_N ||
+            control == META_FRAME_CONTROL_RESIZE_NW ||
+            control == META_FRAME_CONTROL_RESIZE_E ||
+            control == META_FRAME_CONTROL_RESIZE_W))
+    {
+      MetaGrabOp op;
+      gboolean titlebar_is_onscreen;
+
+      op = META_GRAB_OP_NONE;
+
+      switch (control)
+        {
+        case META_FRAME_CONTROL_RESIZE_SE:
+          op = META_GRAB_OP_RESIZING_SE;
+          break;
+        case META_FRAME_CONTROL_RESIZE_S:
+          op = META_GRAB_OP_RESIZING_S;
+          break;
+        case META_FRAME_CONTROL_RESIZE_SW:
+          op = META_GRAB_OP_RESIZING_SW;
+          break;
+        case META_FRAME_CONTROL_RESIZE_NE:
+          op = META_GRAB_OP_RESIZING_NE;
+          break;
+        case META_FRAME_CONTROL_RESIZE_N:
+          op = META_GRAB_OP_RESIZING_N;
+          break;
+        case META_FRAME_CONTROL_RESIZE_NW:
+          op = META_GRAB_OP_RESIZING_NW;
+          break;
+        case META_FRAME_CONTROL_RESIZE_E:
+          op = META_GRAB_OP_RESIZING_E;
+          break;
+        case META_FRAME_CONTROL_RESIZE_W:
+          op = META_GRAB_OP_RESIZING_W;
+          break;
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+
+      meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                     META_CORE_IS_TITLEBAR_ONSCREEN, &titlebar_is_onscreen,
+                     META_CORE_GET_END);
+
+      if (!titlebar_is_onscreen)
+        meta_core_show_window_menu (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                    frame->xwindow,
+                                    event->x_root,
+                                    event->y_root,
+                                    event->button,
+                                    event->time);
+      else
+        meta_core_begin_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                 frame->xwindow,
+                                 op,
+                                 TRUE,
+                                 TRUE,
+                                 event->button,
+                                 0,
+                                 event->time,
+                                 event->x_root,
+                                 event->y_root);
+    }
+  else if (control == META_FRAME_CONTROL_TITLE &&
+           event->button == 1)
+    {
+      MetaFrameFlags flags;
+
+      meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                     META_CORE_GET_FRAME_FLAGS, &flags,
+                     META_CORE_GET_END);
+
+      if (flags & META_FRAME_ALLOWS_MOVE)
+        {
+          meta_core_begin_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                                   frame->xwindow,
+                                   META_GRAB_OP_MOVING,
+                                   TRUE,
+                                   TRUE,
+                                   event->button,
+                                   0,
+                                   event->time,
+                                   event->x_root,
+                                   event->y_root);
+        }
+    }
+  else if (event->button == 2)
+    {
+      return meta_frame_middle_click_event (frame, event);
+    }
+  else if (event->button == 3)
+    {
+      return meta_frame_right_click_event (frame, event);
+    }
+
+  return TRUE;
+}
+
+void
+meta_frames_notify_menu_hide (MetaFrames *frames)
+{
+  if (meta_core_get_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())) ==
+      META_GRAB_OP_CLICKING_MENU)
+    {
+      Window grab_frame;
+
+      grab_frame = meta_core_get_grab_frame (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+
+      if (grab_frame != None)
+        {
+          MetaUIFrame *frame;
+
+          frame = meta_frames_lookup_window (frames, grab_frame);
+
+          if (frame)
+            {
+              redraw_control (frames, frame,
+                              META_FRAME_CONTROL_MENU);
+              meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), CurrentTime);
+            }
+        }
+    }
+}
+
+static gboolean
+meta_frames_button_release_event    (GtkWidget           *widget,
+                                     GdkEventButton      *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+  MetaGrabOp op;
+
+  frames = META_FRAMES (widget);
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  clear_tip (frames);
+
+  op = meta_core_get_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+
+  if (op == META_GRAB_OP_NONE)
+    return FALSE;
+
+  /* We only handle the releases we handled the presses for (things
+   * involving frame controls). Window ops that don't require a
+   * frame are handled in the Xlib part of the code, display.c/window.c
+   */
+  if (frame->xwindow == meta_core_get_grab_frame (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())) &&
+      ((int) event->button) == meta_core_get_grab_button (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())))
+    {
+      MetaFrameControl control;
+
+      control = get_control (frames, frame, event->x, event->y);
+
+      switch (op)
+        {
+        case META_GRAB_OP_CLICKING_MINIMIZE:
+          if (control == META_FRAME_CONTROL_MINIMIZE)
+            meta_core_minimize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_MAXIMIZE:
+          if (control == META_FRAME_CONTROL_MAXIMIZE)
+          {
+            /* Focus the window on the maximize */
+            meta_core_user_focus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                            frame->xwindow,
+                            event->time);
+            meta_core_maximize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+          }
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_UNMAXIMIZE:
+          if (control == META_FRAME_CONTROL_UNMAXIMIZE)
+            meta_core_unmaximize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_DELETE:
+          if (control == META_FRAME_CONTROL_DELETE)
+            meta_core_delete (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow, event->time);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_MENU:
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_SHADE:
+          if (control == META_FRAME_CONTROL_SHADE)
+            meta_core_shade (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow, event->time);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_UNSHADE:
+          if (control == META_FRAME_CONTROL_UNSHADE)
+            meta_core_unshade (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow, event->time);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_ABOVE:
+          if (control == META_FRAME_CONTROL_ABOVE)
+            meta_core_make_above (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_UNABOVE:
+          if (control == META_FRAME_CONTROL_UNABOVE)
+            meta_core_unmake_above (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_STICK:
+          if (control == META_FRAME_CONTROL_STICK)
+            meta_core_stick (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        case META_GRAB_OP_CLICKING_UNSTICK:
+          if (control == META_FRAME_CONTROL_UNSTICK)
+            meta_core_unstick (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow);
+
+          meta_core_end_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), event->time);
+          break;
+
+        default:
+          break;
+        }
+
+      /* Update the prelit control regardless of what button the mouse
+       * was released over; needed so that the new button can become
+       * prelit so to let the user know that it can now be pressed.
+       * :)
+       */
+      meta_frames_update_prelit_control (frames, frame, control);
+    }
+
+  return TRUE;
+}
+
+static void
+meta_frames_update_prelit_control (MetaFrames      *frames,
+                                   MetaUIFrame     *frame,
+                                   MetaFrameControl control)
+{
+  MetaFrameControl old_control;
+  MetaCursor cursor;
+
+
+  meta_verbose ("Updating prelit control from %u to %u\n",
+                frame->prelit_control, control);
+
+  cursor = META_CURSOR_DEFAULT;
+
+  switch (control)
+    {
+    case META_FRAME_CONTROL_CLIENT_AREA:
+      break;
+    case META_FRAME_CONTROL_NONE:
+      break;
+    case META_FRAME_CONTROL_TITLE:
+      break;
+    case META_FRAME_CONTROL_DELETE:
+      break;
+    case META_FRAME_CONTROL_MENU:
+      break;
+    case META_FRAME_CONTROL_MINIMIZE:
+      break;
+    case META_FRAME_CONTROL_MAXIMIZE:
+      break;
+    case META_FRAME_CONTROL_UNMAXIMIZE:
+      break;
+    case META_FRAME_CONTROL_SHADE:
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      break;
+    case META_FRAME_CONTROL_STICK:
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      break;
+    case META_FRAME_CONTROL_RESIZE_SE:
+      cursor = META_CURSOR_SE_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_S:
+      cursor = META_CURSOR_SOUTH_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_SW:
+      cursor = META_CURSOR_SW_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_N:
+      cursor = META_CURSOR_NORTH_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_NE:
+      cursor = META_CURSOR_NE_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_NW:
+      cursor = META_CURSOR_NW_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_W:
+      cursor = META_CURSOR_WEST_RESIZE;
+      break;
+    case META_FRAME_CONTROL_RESIZE_E:
+      cursor = META_CURSOR_EAST_RESIZE;
+      break;
+    }
+
+  /* set/unset the prelight cursor */
+  meta_core_set_screen_cursor (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                               frame->xwindow,
+                               cursor);
+
+  switch (control)
+    {
+    case META_FRAME_CONTROL_MENU:
+    case META_FRAME_CONTROL_MINIMIZE:
+    case META_FRAME_CONTROL_MAXIMIZE:
+    case META_FRAME_CONTROL_DELETE:
+    case META_FRAME_CONTROL_SHADE:
+    case META_FRAME_CONTROL_UNSHADE:
+    case META_FRAME_CONTROL_ABOVE:
+    case META_FRAME_CONTROL_UNABOVE:
+    case META_FRAME_CONTROL_STICK:
+    case META_FRAME_CONTROL_UNSTICK:
+    case META_FRAME_CONTROL_UNMAXIMIZE:
+      /* leave control set */
+      break;
+    default:
+      /* Only prelight buttons */
+      control = META_FRAME_CONTROL_NONE;
+      break;
+    }
+
+  if (control == frame->prelit_control)
+    return;
+
+  /* Save the old control so we can unprelight it */
+  old_control = frame->prelit_control;
+
+  frame->prelit_control = control;
+
+  redraw_control (frames, frame, old_control);
+  redraw_control (frames, frame, control);
+}
+
+static gboolean
+meta_frames_motion_notify_event     (GtkWidget           *widget,
+                                     GdkEventMotion      *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+  MetaGrabOp grab_op;
+
+  frames = META_FRAMES (widget);
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  clear_tip (frames);
+
+  frames->last_motion_frame = frame;
+
+  grab_op = meta_core_get_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+
+  switch (grab_op)
+    {
+    case META_GRAB_OP_CLICKING_MENU:
+    case META_GRAB_OP_CLICKING_DELETE:
+    case META_GRAB_OP_CLICKING_MINIMIZE:
+    case META_GRAB_OP_CLICKING_MAXIMIZE:
+    case META_GRAB_OP_CLICKING_UNMAXIMIZE:
+    case META_GRAB_OP_CLICKING_SHADE:
+    case META_GRAB_OP_CLICKING_UNSHADE:
+    case META_GRAB_OP_CLICKING_ABOVE:
+    case META_GRAB_OP_CLICKING_UNABOVE:
+    case META_GRAB_OP_CLICKING_STICK:
+    case META_GRAB_OP_CLICKING_UNSTICK:
+      {
+        MetaFrameControl control;
+        int x, y;
+
+        gdk_window_get_pointer (frame->window, &x, &y, NULL);
+
+        /* Control is set to none unless it matches
+         * the current grab
+         */
+        control = get_control (frames, frame, x, y);
+        if (! ((control == META_FRAME_CONTROL_MENU &&
+                grab_op == META_GRAB_OP_CLICKING_MENU) ||
+               (control == META_FRAME_CONTROL_DELETE &&
+                grab_op == META_GRAB_OP_CLICKING_DELETE) ||
+               (control == META_FRAME_CONTROL_MINIMIZE &&
+                grab_op == META_GRAB_OP_CLICKING_MINIMIZE) ||
+               ((control == META_FRAME_CONTROL_MAXIMIZE ||
+                 control == META_FRAME_CONTROL_UNMAXIMIZE) &&
+                (grab_op == META_GRAB_OP_CLICKING_MAXIMIZE ||
+                 grab_op == META_GRAB_OP_CLICKING_UNMAXIMIZE)) ||
+               (control == META_FRAME_CONTROL_SHADE &&
+                grab_op == META_GRAB_OP_CLICKING_SHADE) ||
+               (control == META_FRAME_CONTROL_UNSHADE &&
+                grab_op == META_GRAB_OP_CLICKING_UNSHADE) ||
+               (control == META_FRAME_CONTROL_ABOVE &&
+                grab_op == META_GRAB_OP_CLICKING_ABOVE) ||
+               (control == META_FRAME_CONTROL_UNABOVE &&
+                grab_op == META_GRAB_OP_CLICKING_UNABOVE) ||
+               (control == META_FRAME_CONTROL_STICK &&
+                grab_op == META_GRAB_OP_CLICKING_STICK) ||
+               (control == META_FRAME_CONTROL_UNSTICK &&
+                grab_op == META_GRAB_OP_CLICKING_UNSTICK)))
+           control = META_FRAME_CONTROL_NONE;
+
+        /* Update prelit control and cursor */
+        meta_frames_update_prelit_control (frames, frame, control);
+
+        /* No tooltip while in the process of clicking */
+      }
+      break;
+    case META_GRAB_OP_NONE:
+      {
+        MetaFrameControl control;
+        int x, y;
+
+        gdk_window_get_pointer (frame->window, &x, &y, NULL);
+
+        control = get_control (frames, frame, x, y);
+
+        /* Update prelit control and cursor */
+        meta_frames_update_prelit_control (frames, frame, control);
+
+        queue_tip (frames);
+      }
+      break;
+
+    default:
+      break;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+meta_frames_destroy_event           (GtkWidget           *widget,
+                                     GdkEventAny         *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (widget);
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  return TRUE;
+}
+
+#if !GTK_CHECK_VERSION(2,21,6)
+/* Copied from GDK */
+static cairo_surface_t *
+_gdk_drawable_ref_cairo_surface (GdkDrawable *drawable)
+{
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+
+  return GDK_DRAWABLE_GET_CLASS (drawable)->ref_cairo_surface (drawable);
+}
+
+static cairo_pattern_t *
+gdk_window_get_background_pattern (GdkWindow *window)
+{
+  GdkWindowObject *private = (GdkWindowObject *) window;
+  cairo_pattern_t *pattern;
+
+  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+  if (private->bg_pixmap == GDK_PARENT_RELATIVE_BG)
+    pattern = NULL;
+  else if (private->bg_pixmap != GDK_NO_BG &&
+           private->bg_pixmap != NULL)
+    {
+      static cairo_user_data_key_t key;
+      cairo_surface_t *surface;
+
+      surface = _gdk_drawable_ref_cairo_surface (private->bg_pixmap);
+      pattern = cairo_pattern_create_for_surface (surface);
+      cairo_surface_destroy (surface);
+
+      cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+      cairo_pattern_set_user_data (pattern,
+                                   &key,
+                                   g_object_ref (private->bg_pixmap),
+                                   g_object_unref);
+    }
+  else
+    {
+      pattern =
+        cairo_pattern_create_rgb (private->bg_color.red   / 65535.,
+                                  private->bg_color.green / 65535.,
+                                  private->bg_color.blue / 65535.);
+    }
+
+  return pattern;
+}
+#endif
+
+static void
+setup_bg_cr (cairo_t *cr, GdkWindow *window, int x_offset, int y_offset)
+{
+  GdkWindow *parent = gdk_window_get_parent (window);
+  cairo_pattern_t *bg_pattern;
+
+  bg_pattern = gdk_window_get_background_pattern (window);
+  if (bg_pattern == NULL && parent)
+    {
+      gint window_x, window_y;
+
+      gdk_window_get_position (window, &window_x, &window_y);
+      setup_bg_cr (cr, parent, x_offset + window_x, y_offset + window_y);
+    }
+  else if (bg_pattern)
+    {
+      cairo_translate (cr, - x_offset, - y_offset);
+      cairo_set_source (cr, bg_pattern);
+      cairo_translate (cr, x_offset, y_offset);
+    }
+}
+
+static void
+clear_backing (GdkPixmap *pixmap,
+               GdkWindow *window,
+               int xoffset, int yoffset)
+{
+  int width, height;
+  cairo_t *cr = gdk_cairo_create (pixmap);
+
+  setup_bg_cr (cr, window, xoffset, yoffset);
+
+	#if GTK_CHECK_VERSION(3, 0, 0)
+		width = gdk_window_get_width(GDK_WINDOW(pixmap));
+		height = gdk_window_get_height(GDK_WINDOW(pixmap));
+	#else
+		gdk_drawable_get_size(GDK_DRAWABLE(pixmap), &width, &height);
+	#endif
+
+  cairo_rectangle (cr, 0, 0, width, height);
+  cairo_fill (cr);
+
+  cairo_destroy (cr);
+}
+
+/* Returns a pixmap with a piece of the windows frame painted on it.
+*/
+
+static GdkPixmap *
+generate_pixmap (MetaFrames *frames,
+                 MetaUIFrame *frame,
+                 MetaRectangle rect)
+{
+  GdkRectangle rectangle;
+  GdkRegion *region;
+  GdkPixmap *result;
+
+  rectangle.x = rect.x;
+  rectangle.y = rect.y;
+  rectangle.width = MAX (rect.width, 1);
+  rectangle.height = MAX (rect.height, 1);
+
+  result = gdk_pixmap_new (frame->window,
+                           rectangle.width, rectangle.height, -1);
+
+  clear_backing (result, frame->window, rectangle.x, rectangle.y);
+
+  region = gdk_region_rectangle (&rectangle);
+
+  meta_frames_paint_to_drawable (frames, frame, result, region,
+                                 -rectangle.x, -rectangle.y);
+
+  gdk_region_destroy (region);
+
+  return result;
+}
+
+
+static void
+populate_cache (MetaFrames *frames,
+                MetaUIFrame *frame)
+{
+  int top, bottom, left, right;
+  int width, height;
+  int frame_width, frame_height, screen_width, screen_height;
+  CachedPixels *pixels;
+  MetaFrameType frame_type;
+  MetaFrameFlags frame_flags;
+  int i;
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_FRAME_WIDTH, &frame_width,
+                 META_CORE_GET_FRAME_HEIGHT, &frame_height,
+                 META_CORE_GET_SCREEN_WIDTH, &screen_width,
+                 META_CORE_GET_SCREEN_HEIGHT, &screen_height,
+                 META_CORE_GET_CLIENT_WIDTH, &width,
+                 META_CORE_GET_CLIENT_HEIGHT, &height,
+                 META_CORE_GET_FRAME_TYPE, &frame_type,
+                 META_CORE_GET_FRAME_FLAGS, &frame_flags,
+                 META_CORE_GET_END);
+
+  /* don't cache extremely large windows */
+  if (frame_width > 2 * screen_width ||
+      frame_height > 2 * screen_height)
+    {
+      return;
+    }
+
+  meta_theme_get_frame_borders (meta_theme_get_current (),
+                                frame_type,
+                                frame->text_height,
+                                frame_flags,
+                                &top, &bottom, &left, &right);
+
+  pixels = get_cache (frames, frame);
+
+  /* Setup the rectangles for the four frame borders. First top, then
+     left, right and bottom. */
+  pixels->piece[0].rect.x = 0;
+  pixels->piece[0].rect.y = 0;
+  pixels->piece[0].rect.width = left + width + right;
+  pixels->piece[0].rect.height = top;
+
+  pixels->piece[1].rect.x = 0;
+  pixels->piece[1].rect.y = top;
+  pixels->piece[1].rect.width = left;
+  pixels->piece[1].rect.height = height;
+
+  pixels->piece[2].rect.x = left + width;
+  pixels->piece[2].rect.y = top;
+  pixels->piece[2].rect.width = right;
+  pixels->piece[2].rect.height = height;
+
+  pixels->piece[3].rect.x = 0;
+  pixels->piece[3].rect.y = top + height;
+  pixels->piece[3].rect.width = left + width + right;
+  pixels->piece[3].rect.height = bottom;
+
+  for (i = 0; i < 4; i++)
+    {
+      CachedFramePiece *piece = &pixels->piece[i];
+      if (!piece->pixmap)
+        piece->pixmap = generate_pixmap (frames, frame, piece->rect);
+    }
+
+  if (frames->invalidate_cache_timeout_id)
+    g_source_remove (frames->invalidate_cache_timeout_id);
+
+  frames->invalidate_cache_timeout_id = g_timeout_add (1000, invalidate_cache_timeout, frames);
+
+  if (!g_list_find (frames->invalidate_frames, frame))
+    frames->invalidate_frames =
+      g_list_prepend (frames->invalidate_frames, frame);
+}
+
+static void
+clip_to_screen (GdkRegion *region, MetaUIFrame *frame)
+{
+  GdkRectangle frame_area;
+  GdkRectangle screen_area = { 0, 0, 0, 0 };
+  GdkRegion *tmp_region;
+
+  /* Chop off stuff outside the screen; this optimization
+   * is crucial to handle huge client windows,
+   * like "xterm -geometry 1000x1000"
+   */
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_FRAME_X, &frame_area.x,
+                 META_CORE_GET_FRAME_Y, &frame_area.y,
+                 META_CORE_GET_FRAME_WIDTH, &frame_area.width,
+                 META_CORE_GET_FRAME_HEIGHT, &frame_area.height,
+                 META_CORE_GET_SCREEN_WIDTH, &screen_area.height,
+                 META_CORE_GET_SCREEN_HEIGHT, &screen_area.height,
+                 META_CORE_GET_END);
+
+  gdk_region_offset (region, frame_area.x, frame_area.y);
+
+  tmp_region = gdk_region_rectangle (&frame_area);
+  gdk_region_intersect (region, tmp_region);
+  gdk_region_destroy (tmp_region);
+
+  gdk_region_offset (region, - frame_area.x, - frame_area.y);
+}
+
+static void
+subtract_from_region (GdkRegion *region, GdkDrawable *drawable,
+                      gint x, gint y)
+{
+  GdkRectangle rect;
+  GdkRegion *reg_rect;
+
+	#if GTK_CHECK_VERSION(3, 0, 0)
+		rect.width = gdk_window_get_width(GDK_WINDOW(drawable));
+		rect.height = gdk_window_get_height(GDK_WINDOW(drawable));
+	#else
+		gdk_drawable_get_size (drawable, &rect.width, &rect.height);
+	#endif
+
+  rect.x = x;
+  rect.y = y;
+
+  reg_rect = gdk_region_rectangle (&rect);
+  gdk_region_subtract (region, reg_rect);
+  gdk_region_destroy (reg_rect);
+}
+
+static void
+cached_pixels_draw (CachedPixels *pixels,
+                    GdkWindow *window,
+                    GdkRegion *region)
+{
+  cairo_t *cr;
+  int i;
+
+  cr = gdk_cairo_create (window);
+
+  for (i = 0; i < 4; i++)
+    {
+      CachedFramePiece *piece;
+      piece = &pixels->piece[i];
+
+      if (piece->pixmap)
+        {
+          gdk_cairo_set_source_pixmap (cr, piece->pixmap,
+                                       piece->rect.x, piece->rect.y);
+          cairo_paint (cr);
+          subtract_from_region (region, piece->pixmap,
+          piece->rect.x, piece->rect.y);
+        }
+    }
+
+  cairo_destroy (cr);
+}
+
+static gboolean
+meta_frames_expose_event (GtkWidget           *widget,
+                          GdkEventExpose      *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+  GdkRegion *region;
+  CachedPixels *pixels;
+
+  frames = META_FRAMES (widget);
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  if (frames->expose_delay_count > 0)
+    {
+      /* Redraw this entire frame later */
+      frame->expose_delayed = TRUE;
+      return TRUE;
+    }
+
+  populate_cache (frames, frame);
+
+  region = gdk_region_copy (event->region);
+
+  pixels = get_cache (frames, frame);
+
+  cached_pixels_draw (pixels, frame->window, region);
+
+  clip_to_screen (region, frame);
+  meta_frames_paint_to_drawable (frames, frame, frame->window, region, 0, 0);
+
+  gdk_region_destroy (region);
+
+  return TRUE;
+}
+
+/* How far off the screen edge the window decorations should
+ * be drawn. Used only in meta_frames_paint_to_drawable, below.
+ */
+#define DECORATING_BORDER 100
+
+static void
+meta_frames_paint_to_drawable (MetaFrames   *frames,
+                               MetaUIFrame  *frame,
+                               GdkDrawable  *drawable,
+                               GdkRegion    *region,
+                               int           x_offset,
+                               int           y_offset)
+{
+  GtkWidget *widget;
+  MetaFrameFlags flags;
+  MetaFrameType type;
+  GdkPixbuf *mini_icon;
+  GdkPixbuf *icon;
+  int w, h;
+  MetaButtonState button_states[META_BUTTON_TYPE_LAST];
+  Window grab_frame;
+  int i;
+  MetaButtonLayout button_layout;
+  MetaGrabOp grab_op;
+
+  widget = GTK_WIDGET (frames);
+
+  for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
+    button_states[i] = META_BUTTON_STATE_NORMAL;
+
+  grab_frame = meta_core_get_grab_frame (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  grab_op = meta_core_get_grab_op (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  if (grab_frame != frame->xwindow)
+    grab_op = META_GRAB_OP_NONE;
+
+  /* Set prelight state */
+  switch (frame->prelit_control)
+    {
+    case META_FRAME_CONTROL_MENU:
+      if (grab_op == META_GRAB_OP_CLICKING_MENU)
+        button_states[META_BUTTON_TYPE_MENU] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MENU] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_MINIMIZE:
+      if (grab_op == META_GRAB_OP_CLICKING_MINIMIZE)
+        button_states[META_BUTTON_TYPE_MINIMIZE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MINIMIZE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_MAXIMIZE:
+      if (grab_op == META_GRAB_OP_CLICKING_MAXIMIZE)
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNMAXIMIZE:
+      if (grab_op == META_GRAB_OP_CLICKING_UNMAXIMIZE)
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_MAXIMIZE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_SHADE:
+      if (grab_op == META_GRAB_OP_CLICKING_SHADE)
+        button_states[META_BUTTON_TYPE_SHADE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_SHADE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      if (grab_op == META_GRAB_OP_CLICKING_UNSHADE)
+        button_states[META_BUTTON_TYPE_UNSHADE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_UNSHADE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      if (grab_op == META_GRAB_OP_CLICKING_ABOVE)
+        button_states[META_BUTTON_TYPE_ABOVE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_ABOVE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      if (grab_op == META_GRAB_OP_CLICKING_UNABOVE)
+        button_states[META_BUTTON_TYPE_UNABOVE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_UNABOVE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_STICK:
+      if (grab_op == META_GRAB_OP_CLICKING_STICK)
+        button_states[META_BUTTON_TYPE_STICK] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_STICK] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      if (grab_op == META_GRAB_OP_CLICKING_UNSTICK)
+        button_states[META_BUTTON_TYPE_UNSTICK] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_UNSTICK] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    case META_FRAME_CONTROL_DELETE:
+      if (grab_op == META_GRAB_OP_CLICKING_DELETE)
+        button_states[META_BUTTON_TYPE_CLOSE] = META_BUTTON_STATE_PRESSED;
+      else
+        button_states[META_BUTTON_TYPE_CLOSE] = META_BUTTON_STATE_PRELIGHT;
+      break;
+    default:
+      break;
+    }
+
+  /* Map button function states to button position states */
+  button_states[META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND] =
+    button_states[META_BUTTON_TYPE_MENU];
+  button_states[META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND] =
+    META_BUTTON_STATE_NORMAL;
+  button_states[META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND] =
+    META_BUTTON_STATE_NORMAL;
+  button_states[META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND] =
+    button_states[META_BUTTON_TYPE_MINIMIZE];
+  button_states[META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND] =
+    button_states[META_BUTTON_TYPE_MAXIMIZE];
+  button_states[META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND] =
+    button_states[META_BUTTON_TYPE_CLOSE];
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_FRAME_FLAGS, &flags,
+                 META_CORE_GET_FRAME_TYPE, &type,
+                 META_CORE_GET_MINI_ICON, &mini_icon,
+                 META_CORE_GET_ICON, &icon,
+                 META_CORE_GET_CLIENT_WIDTH, &w,
+                 META_CORE_GET_CLIENT_HEIGHT, &h,
+                 META_CORE_GET_END);
+
+  meta_frames_ensure_layout (frames, frame);
+
+  meta_prefs_get_button_layout (&button_layout);
+
+  if (G_LIKELY (GDK_IS_WINDOW (drawable)))
+    {
+      /* A window; happens about 2/3 of the time */
+
+      GdkRectangle area, *areas;
+      int n_areas;
+      int screen_width, screen_height;
+      GdkRegion *edges, *tmp_region;
+      int top, bottom, left, right;
+
+      /* Repaint each side of the frame */
+
+      meta_theme_get_frame_borders (meta_theme_get_current (),
+                             type, frame->text_height, flags,
+                             &top, &bottom, &left, &right);
+
+      meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                     META_CORE_GET_SCREEN_WIDTH, &screen_width,
+                     META_CORE_GET_SCREEN_HEIGHT, &screen_height,
+                     META_CORE_GET_END);
+
+      edges = gdk_region_copy (region);
+
+      /* Punch out the client area */
+
+      area.x = left;
+      area.y = top;
+      area.width = w;
+      area.height = h;
+      tmp_region = gdk_region_rectangle (&area);
+      gdk_region_subtract (edges, tmp_region);
+      gdk_region_destroy (tmp_region);
+
+      /* Now draw remaining portion of region */
+
+      gdk_region_get_rectangles (edges, &areas, &n_areas);
+
+      for (i = 0; i < n_areas; i++)
+        {
+          /* Bug 399529: clamp areas[i] so that it doesn't go too far
+           * off the edge of the screen. This works around a GDK bug
+           * which makes gdk_window_begin_paint_rect cause an X error
+           * if the window is insanely huge. If the client is a GDK program
+           * and does this, it will still probably cause an X error in that
+           * program, but the last thing we want is for Marco to crash
+           * because it attempted to decorate the silly window.
+           */
+
+          areas[i].x = MAX (areas[i].x, -DECORATING_BORDER);
+          areas[i].y = MAX (areas[i].y, -DECORATING_BORDER);
+          if (areas[i].x+areas[i].width  > screen_width  + DECORATING_BORDER)
+            areas[i].width  = MIN (0, screen_width  - areas[i].x);
+          if (areas[i].y+areas[i].height > screen_height + DECORATING_BORDER)
+            areas[i].height = MIN (0, screen_height - areas[i].y);
+
+          /* Okay, so let's start painting. */
+
+          gdk_window_begin_paint_rect (drawable, &areas[i]);
+
+          meta_theme_draw_frame_with_style (meta_theme_get_current (),
+            frame->style,
+            widget,
+            drawable,
+            NULL, /* &areas[i], */
+            x_offset, y_offset,
+            type,
+            flags,
+            w, h,
+            frame->layout,
+            frame->text_height,
+            &button_layout,
+            button_states,
+            mini_icon, icon);
+
+          gdk_window_end_paint (drawable);
+        }
+
+      g_free (areas);
+      gdk_region_destroy (edges);
+
+    }
+  else
+    {
+      /* Not a window; happens about 1/3 of the time */
+
+      meta_theme_draw_frame_with_style (meta_theme_get_current (),
+                                        frame->style,
+                                        widget,
+                                        drawable,
+                                        NULL,
+                                        x_offset, y_offset,
+                                        type,
+                                        flags,
+                                        w, h,
+                                        frame->layout,
+                                        frame->text_height,
+                                        &button_layout,
+                                        button_states,
+                                        mini_icon, icon);
+    }
+
+}
+
+static void
+meta_frames_set_window_background (MetaFrames   *frames,
+                                   MetaUIFrame  *frame)
+{
+  MetaFrameFlags flags;
+  MetaFrameType type;
+  MetaFrameStyle *style;
+  gboolean frame_exists;
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_WINDOW_HAS_FRAME, &frame_exists,
+                 META_CORE_GET_FRAME_FLAGS, &flags,
+                 META_CORE_GET_FRAME_TYPE, &type,
+                 META_CORE_GET_END);
+
+  if (frame_exists)
+    {
+      style = meta_theme_get_frame_style (meta_theme_get_current (),
+                                          type, flags);
+    }
+
+  if (frame_exists && style->window_background_color != NULL)
+    {
+      GdkColor color;
+      GdkVisual *visual;
+
+      meta_color_spec_render (style->window_background_color,
+                              GTK_WIDGET (frames),
+                              &color);
+
+      /* Set A in ARGB to window_background_alpha, if we have ARGB */
+
+      visual = gtk_widget_get_visual (GTK_WIDGET (frames));
+      if (visual->depth == 32) /* we have ARGB */
+        {
+          color.pixel = (color.pixel & 0xffffff) &
+            style->window_background_alpha << 24;
+        }
+
+      gdk_window_set_background (frame->window, &color);
+    }
+  else
+    {
+      gtk_style_set_background (frame->style,
+                                frame->window, GTK_STATE_NORMAL);
+    }
+ }
+
+static gboolean
+meta_frames_enter_notify_event      (GtkWidget           *widget,
+                                     GdkEventCrossing    *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+  MetaFrameControl control;
+
+  frames = META_FRAMES (widget);
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  control = get_control (frames, frame, event->x, event->y);
+  meta_frames_update_prelit_control (frames, frame, control);
+
+  return TRUE;
+}
+
+static gboolean
+meta_frames_leave_notify_event      (GtkWidget           *widget,
+                                     GdkEventCrossing    *event)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (widget);
+
+  frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window));
+  if (frame == NULL)
+    return FALSE;
+
+  meta_frames_update_prelit_control (frames, frame, META_FRAME_CONTROL_NONE);
+
+  clear_tip (frames);
+
+  return TRUE;
+}
+
+static GdkRectangle*
+control_rect (MetaFrameControl control,
+              MetaFrameGeometry *fgeom)
+{
+  GdkRectangle *rect;
+
+  rect = NULL;
+  switch (control)
+    {
+    case META_FRAME_CONTROL_TITLE:
+      rect = &fgeom->title_rect;
+      break;
+    case META_FRAME_CONTROL_DELETE:
+      rect = &fgeom->close_rect.visible;
+      break;
+    case META_FRAME_CONTROL_MENU:
+      rect = &fgeom->menu_rect.visible;
+      break;
+    case META_FRAME_CONTROL_MINIMIZE:
+      rect = &fgeom->min_rect.visible;
+      break;
+    case META_FRAME_CONTROL_MAXIMIZE:
+    case META_FRAME_CONTROL_UNMAXIMIZE:
+      rect = &fgeom->max_rect.visible;
+      break;
+    case META_FRAME_CONTROL_SHADE:
+      rect = &fgeom->shade_rect.visible;
+      break;
+    case META_FRAME_CONTROL_UNSHADE:
+      rect = &fgeom->unshade_rect.visible;
+      break;
+    case META_FRAME_CONTROL_ABOVE:
+      rect = &fgeom->above_rect.visible;
+      break;
+    case META_FRAME_CONTROL_UNABOVE:
+      rect = &fgeom->unabove_rect.visible;
+      break;
+    case META_FRAME_CONTROL_STICK:
+      rect = &fgeom->stick_rect.visible;
+      break;
+    case META_FRAME_CONTROL_UNSTICK:
+      rect = &fgeom->unstick_rect.visible;
+      break;
+    case META_FRAME_CONTROL_RESIZE_SE:
+      break;
+    case META_FRAME_CONTROL_RESIZE_S:
+      break;
+    case META_FRAME_CONTROL_RESIZE_SW:
+      break;
+    case META_FRAME_CONTROL_RESIZE_N:
+      break;
+    case META_FRAME_CONTROL_RESIZE_NE:
+      break;
+    case META_FRAME_CONTROL_RESIZE_NW:
+      break;
+    case META_FRAME_CONTROL_RESIZE_W:
+      break;
+    case META_FRAME_CONTROL_RESIZE_E:
+      break;
+    case META_FRAME_CONTROL_NONE:
+      break;
+    case META_FRAME_CONTROL_CLIENT_AREA:
+      break;
+    }
+
+  return rect;
+}
+
+#define RESIZE_EXTENDS 15
+#define TOP_RESIZE_HEIGHT 2
+static MetaFrameControl
+get_control (MetaFrames *frames,
+             MetaUIFrame *frame,
+             int x, int y)
+{
+  MetaFrameGeometry fgeom;
+  MetaFrameFlags flags;
+  gboolean has_vert, has_horiz;
+  GdkRectangle client;
+
+  meta_frames_calc_geometry (frames, frame, &fgeom);
+
+  client.x = fgeom.left_width;
+  client.y = fgeom.top_height;
+  client.width = fgeom.width - fgeom.left_width - fgeom.right_width;
+  client.height = fgeom.height - fgeom.top_height - fgeom.bottom_height;
+
+  if (POINT_IN_RECT (x, y, client))
+    return META_FRAME_CONTROL_CLIENT_AREA;
+
+  if (POINT_IN_RECT (x, y, fgeom.close_rect.clickable))
+    return META_FRAME_CONTROL_DELETE;
+
+  if (POINT_IN_RECT (x, y, fgeom.min_rect.clickable))
+    return META_FRAME_CONTROL_MINIMIZE;
+
+  if (POINT_IN_RECT (x, y, fgeom.menu_rect.clickable))
+    return META_FRAME_CONTROL_MENU;
+
+  meta_core_get (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), frame->xwindow,
+                 META_CORE_GET_FRAME_FLAGS, &flags,
+                 META_CORE_GET_END);
+
+  has_vert = (flags & META_FRAME_ALLOWS_VERTICAL_RESIZE) != 0;
+  has_horiz = (flags & META_FRAME_ALLOWS_HORIZONTAL_RESIZE) != 0;
+
+  if (POINT_IN_RECT (x, y, fgeom.title_rect))
+    {
+      if (has_vert && y <= TOP_RESIZE_HEIGHT)
+        return META_FRAME_CONTROL_RESIZE_N;
+      else
+        return META_FRAME_CONTROL_TITLE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.max_rect.clickable))
+    {
+      if (flags & META_FRAME_MAXIMIZED)
+        return META_FRAME_CONTROL_UNMAXIMIZE;
+      else
+        return META_FRAME_CONTROL_MAXIMIZE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.shade_rect.clickable))
+    {
+      return META_FRAME_CONTROL_SHADE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.unshade_rect.clickable))
+    {
+      return META_FRAME_CONTROL_UNSHADE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.above_rect.clickable))
+    {
+      return META_FRAME_CONTROL_ABOVE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.unabove_rect.clickable))
+    {
+      return META_FRAME_CONTROL_UNABOVE;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.stick_rect.clickable))
+    {
+      return META_FRAME_CONTROL_STICK;
+    }
+
+  if (POINT_IN_RECT (x, y, fgeom.unstick_rect.clickable))
+    {
+      return META_FRAME_CONTROL_UNSTICK;
+    }
+
+  /* South resize always has priority over north resize,
+   * in case of overlap.
+   */
+
+  if (y >= (fgeom.height - fgeom.bottom_height - RESIZE_EXTENDS) &&
+      x >= (fgeom.width - fgeom.right_width - RESIZE_EXTENDS))
+    {
+      if (has_vert && has_horiz)
+        return META_FRAME_CONTROL_RESIZE_SE;
+      else if (has_vert)
+        return META_FRAME_CONTROL_RESIZE_S;
+      else if (has_horiz)
+        return META_FRAME_CONTROL_RESIZE_E;
+    }
+  else if (y >= (fgeom.height - fgeom.bottom_height - RESIZE_EXTENDS) &&
+           x <= (fgeom.left_width + RESIZE_EXTENDS))
+    {
+      if (has_vert && has_horiz)
+        return META_FRAME_CONTROL_RESIZE_SW;
+      else if (has_vert)
+        return META_FRAME_CONTROL_RESIZE_S;
+      else if (has_horiz)
+        return META_FRAME_CONTROL_RESIZE_W;
+    }
+  else if (y < (fgeom.top_height + RESIZE_EXTENDS) &&
+           x < RESIZE_EXTENDS)
+    {
+      if (has_vert && has_horiz)
+        return META_FRAME_CONTROL_RESIZE_NW;
+      else if (has_vert)
+        return META_FRAME_CONTROL_RESIZE_N;
+      else if (has_horiz)
+        return META_FRAME_CONTROL_RESIZE_W;
+    }
+  else if (y < (fgeom.top_height + RESIZE_EXTENDS) &&
+           x >= (fgeom.width - RESIZE_EXTENDS))
+    {
+      if (has_vert && has_horiz)
+        return META_FRAME_CONTROL_RESIZE_NE;
+      else if (has_vert)
+        return META_FRAME_CONTROL_RESIZE_N;
+      else if (has_horiz)
+        return META_FRAME_CONTROL_RESIZE_E;
+    }
+  else if (y >= (fgeom.height - fgeom.bottom_height - RESIZE_EXTENDS))
+    {
+      if (has_vert)
+        return META_FRAME_CONTROL_RESIZE_S;
+    }
+  else if (y <= TOP_RESIZE_HEIGHT)
+    {
+      if (has_vert)
+        return META_FRAME_CONTROL_RESIZE_N;
+      else if (has_horiz)
+        return META_FRAME_CONTROL_TITLE;
+    }
+  else if (x <= fgeom.left_width)
+    {
+      if (has_horiz)
+        return META_FRAME_CONTROL_RESIZE_W;
+    }
+  else if (x >= (fgeom.width - fgeom.right_width))
+    {
+      if (has_horiz)
+        return META_FRAME_CONTROL_RESIZE_E;
+    }
+
+  if (y >= fgeom.top_height)
+    return META_FRAME_CONTROL_NONE;
+  else
+    return META_FRAME_CONTROL_TITLE;
+}
+
+void
+meta_frames_push_delay_exposes (MetaFrames *frames)
+{
+  if (frames->expose_delay_count == 0)
+    {
+      /* Make sure we've repainted things */
+      gdk_window_process_all_updates ();
+      XFlush (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+    }
+
+  frames->expose_delay_count += 1;
+}
+
+static void
+queue_pending_exposes_func (gpointer key, gpointer value, gpointer data)
+{
+  MetaUIFrame *frame;
+  MetaFrames *frames;
+
+  frames = META_FRAMES (data);
+  frame = value;
+
+  if (frame->expose_delayed)
+    {
+      invalidate_whole_window (frames, frame);
+      frame->expose_delayed = FALSE;
+    }
+}
+
+void
+meta_frames_pop_delay_exposes  (MetaFrames *frames)
+{
+  g_return_if_fail (frames->expose_delay_count > 0);
+
+  frames->expose_delay_count -= 1;
+
+  if (frames->expose_delay_count == 0)
+    {
+      g_hash_table_foreach (frames->frames,
+                            queue_pending_exposes_func,
+                            frames);
+    }
+}
+
+static void
+invalidate_whole_window (MetaFrames *frames,
+                         MetaUIFrame *frame)
+{
+  gdk_window_invalidate_rect (frame->window, NULL, FALSE);
+  invalidate_cache (frames, frame);
+}
diff --git a/src/ui/frames.h b/src/ui/frames.h
new file mode 100644
index 00000000..e9da4714
--- /dev/null
+++ b/src/ui/frames.h
@@ -0,0 +1,163 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window frame manager widget */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_FRAMES_H
+#define META_FRAMES_H
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include "common.h"
+#include "theme.h"
+
+typedef enum
+{
+  META_FRAME_CONTROL_NONE,
+  META_FRAME_CONTROL_TITLE,
+  META_FRAME_CONTROL_DELETE,
+  META_FRAME_CONTROL_MENU,
+  META_FRAME_CONTROL_MINIMIZE,
+  META_FRAME_CONTROL_MAXIMIZE,
+  META_FRAME_CONTROL_UNMAXIMIZE,
+  META_FRAME_CONTROL_SHADE,
+  META_FRAME_CONTROL_UNSHADE,
+  META_FRAME_CONTROL_ABOVE,
+  META_FRAME_CONTROL_UNABOVE,
+  META_FRAME_CONTROL_STICK,
+  META_FRAME_CONTROL_UNSTICK,
+  META_FRAME_CONTROL_RESIZE_SE,
+  META_FRAME_CONTROL_RESIZE_S,
+  META_FRAME_CONTROL_RESIZE_SW,
+  META_FRAME_CONTROL_RESIZE_N,
+  META_FRAME_CONTROL_RESIZE_NE,
+  META_FRAME_CONTROL_RESIZE_NW,
+  META_FRAME_CONTROL_RESIZE_W,
+  META_FRAME_CONTROL_RESIZE_E,
+  META_FRAME_CONTROL_CLIENT_AREA
+} MetaFrameControl;
+
+/* This is one widget that manages all the window frames
+ * as subwindows.
+ */
+
+#define META_TYPE_FRAMES            (meta_frames_get_type ())
+#define META_FRAMES(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_FRAMES, MetaFrames))
+#define META_FRAMES_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_FRAMES, MetaFramesClass))
+#define META_IS_FRAMES(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_FRAMES))
+#define META_IS_FRAMES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_FRAMES))
+#define META_FRAMES_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_FRAMES, MetaFramesClass))
+
+typedef struct _MetaFrames        MetaFrames;
+typedef struct _MetaFramesClass   MetaFramesClass;
+
+typedef struct _MetaUIFrame         MetaUIFrame;
+
+struct _MetaUIFrame
+{
+  Window xwindow;
+  GdkWindow *window;
+  GtkStyle *style;
+  MetaFrameStyle *cache_style;
+  PangoLayout *layout;
+  int text_height;
+  char *title; /* NULL once we have a layout */
+  guint expose_delayed : 1;
+  guint shape_applied : 1;
+  
+  /* FIXME get rid of this, it can just be in the MetaFrames struct */
+  MetaFrameControl prelit_control;
+};
+
+struct _MetaFrames
+{
+  GtkWindow parent_instance;
+  
+  GHashTable *text_heights;
+
+  GHashTable *frames;
+
+  guint tooltip_timeout;
+  MetaUIFrame *last_motion_frame;
+
+  int expose_delay_count;
+
+  int invalidate_cache_timeout_id;
+  GList *invalidate_frames;
+  GHashTable *cache;
+};
+
+struct _MetaFramesClass
+{
+  GtkWindowClass parent_class;
+
+};
+
+GType        meta_frames_get_type               (void) G_GNUC_CONST;
+
+MetaFrames *meta_frames_new (int screen_number);
+
+void meta_frames_manage_window (MetaFrames *frames,
+                                Window      xwindow,
+				GdkWindow  *window);
+void meta_frames_unmanage_window (MetaFrames *frames,
+                                  Window      xwindow);
+void meta_frames_set_title (MetaFrames *frames,
+                            Window      xwindow,
+                            const char *title);
+
+void meta_frames_repaint_frame (MetaFrames *frames,
+                                Window      xwindow);
+
+void meta_frames_get_geometry (MetaFrames *frames,
+                               Window xwindow,
+                               int *top_height, int *bottom_height,
+                               int *left_width, int *right_width);
+
+void meta_frames_reset_bg     (MetaFrames *frames,
+                               Window      xwindow);
+void meta_frames_unflicker_bg (MetaFrames *frames,
+                               Window      xwindow,
+                               int         target_width,
+                               int         target_height);
+
+void meta_frames_apply_shapes (MetaFrames *frames,
+                               Window      xwindow,
+                               int         new_window_width,
+                               int         new_window_height,
+                               gboolean    window_has_shape);
+void meta_frames_move_resize_frame (MetaFrames *frames,
+				    Window      xwindow,
+				    int         x,
+				    int         y,
+				    int         width,
+				    int         height);
+void meta_frames_queue_draw (MetaFrames *frames,
+                             Window      xwindow);
+
+void meta_frames_notify_menu_hide (MetaFrames *frames);
+
+Window meta_frames_get_moving_frame (MetaFrames *frames);
+
+void meta_frames_push_delay_exposes (MetaFrames *frames);
+void meta_frames_pop_delay_exposes  (MetaFrames *frames);
+
+#endif
diff --git a/src/ui/gradient.c b/src/ui/gradient.c
new file mode 100644
index 00000000..0e739817
--- /dev/null
+++ b/src/ui/gradient.c
@@ -0,0 +1,842 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco gradient rendering */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington, 99% copied from wrlib in
+ * WindowMaker, Copyright (C) 1997-2000 Dan Pascu and Alfredo Kojima
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  */
+
+#include "gradient.h"
+#include "util.h"
+#include <string.h>
+
+/* This is all Alfredo's and Dan's usual very nice WindowMaker code,
+ * slightly GTK-ized
+ */
+static GdkPixbuf* meta_gradient_create_horizontal       (int             width,
+                                                         int             height,
+                                                         const GdkColor *from,
+                                                         const GdkColor *to);
+static GdkPixbuf* meta_gradient_create_vertical         (int             width,
+                                                         int             height,
+                                                         const GdkColor *from,
+                                                         const GdkColor *to);
+static GdkPixbuf* meta_gradient_create_diagonal         (int             width,
+                                                         int             height,
+                                                         const GdkColor *from,
+                                                         const GdkColor *to);
+static GdkPixbuf* meta_gradient_create_multi_horizontal (int             width,
+                                                         int             height,
+                                                         const GdkColor *colors,
+                                                         int             count);
+static GdkPixbuf* meta_gradient_create_multi_vertical   (int             width,
+                                                         int             height,
+                                                         const GdkColor *colors,
+                                                         int             count);
+static GdkPixbuf* meta_gradient_create_multi_diagonal   (int             width,
+                                                         int             height,
+                                                         const GdkColor *colors,
+                                                         int             count);
+
+
+/* Used as the destroy notification function for gdk_pixbuf_new() */
+static void
+free_buffer (guchar *pixels, gpointer data)
+{
+  g_free (pixels);
+}
+
+static GdkPixbuf*
+blank_pixbuf (int width, int height, gboolean no_padding)
+{
+  guchar *buf;
+  int rowstride;
+
+  g_return_val_if_fail (width > 0, NULL);
+  g_return_val_if_fail (height > 0, NULL);
+
+  if (no_padding)
+    rowstride = width * 3;
+  else
+    /* Always align rows to 32-bit boundaries */  
+    rowstride = 4 * ((3 * width + 3) / 4);
+
+  buf = g_try_malloc (height * rowstride);
+  if (!buf)
+    return NULL;
+
+  return gdk_pixbuf_new_from_data (buf, GDK_COLORSPACE_RGB,
+                                   FALSE, 8,
+                                   width, height, rowstride,
+                                   free_buffer, NULL);
+}
+
+GdkPixbuf*
+meta_gradient_create_simple (int              width,
+                             int              height,
+                             const GdkColor  *from,
+                             const GdkColor  *to,
+                             MetaGradientType style)
+{
+  switch (style)
+    {
+    case META_GRADIENT_HORIZONTAL:
+      return meta_gradient_create_horizontal (width, height,
+                                              from, to);
+    case META_GRADIENT_VERTICAL:
+      return meta_gradient_create_vertical (width, height,
+                                            from, to);
+
+    case META_GRADIENT_DIAGONAL:
+      return meta_gradient_create_diagonal (width, height,
+                                            from, to);
+    case META_GRADIENT_LAST:
+      break;
+    }
+  g_assert_not_reached ();
+  return NULL;
+}
+
+GdkPixbuf*
+meta_gradient_create_multi (int              width,
+                            int              height,
+                            const GdkColor  *colors,
+                            int              n_colors,
+                            MetaGradientType style)
+{
+
+  if (n_colors > 2)
+    {
+      switch (style)
+        {
+        case META_GRADIENT_HORIZONTAL:
+          return meta_gradient_create_multi_horizontal (width, height, colors, n_colors);
+        case META_GRADIENT_VERTICAL:
+          return meta_gradient_create_multi_vertical (width, height, colors, n_colors);
+        case META_GRADIENT_DIAGONAL:
+          return meta_gradient_create_multi_diagonal (width, height, colors, n_colors);
+        case META_GRADIENT_LAST:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+  else if (n_colors > 1)
+    {
+      return meta_gradient_create_simple (width, height, &colors[0], &colors[1],
+                                          style);
+    }
+  else if (n_colors > 0)
+    {
+      return meta_gradient_create_simple (width, height, &colors[0], &colors[0],
+                                          style);
+    }
+  g_assert_not_reached ();
+  return NULL;
+}
+
+/* Interwoven essentially means we have two vertical gradients,
+ * cut into horizontal strips of the given thickness, and then the strips
+ * are alternated. I'm not sure what it's good for, just copied since
+ * WindowMaker had it.
+ */
+GdkPixbuf*
+meta_gradient_create_interwoven (int            width,
+                                 int            height,
+                                 const GdkColor colors1[2],
+                                 int            thickness1,
+                                 const GdkColor colors2[2],
+                                 int            thickness2)
+{
+  
+  int i, j, k, l, ll;
+  long r1, g1, b1, dr1, dg1, db1;
+  long r2, g2, b2, dr2, dg2, db2;
+  GdkPixbuf *pixbuf;
+  unsigned char *ptr;
+  unsigned char *pixels;
+  int rowstride;
+  
+  pixbuf = blank_pixbuf (width, height, FALSE);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  
+  r1 = colors1[0].red<<8;
+  g1 = colors1[0].green<<8;
+  b1 = colors1[0].blue<<8;
+
+  r2 = colors2[0].red<<8;
+  g2 = colors2[0].green<<8;
+  b2 = colors2[0].blue<<8;
+
+  dr1 = ((colors1[1].red-colors1[0].red)<<8)/(int)height;
+  dg1 = ((colors1[1].green-colors1[0].green)<<8)/(int)height;
+  db1 = ((colors1[1].blue-colors1[0].blue)<<8)/(int)height;
+
+  dr2 = ((colors2[1].red-colors2[0].red)<<8)/(int)height;
+  dg2 = ((colors2[1].green-colors2[0].green)<<8)/(int)height;
+  db2 = ((colors2[1].blue-colors2[0].blue)<<8)/(int)height;
+
+  for (i=0,k=0,l=0,ll=thickness1; i<height; i++)
+    {
+      ptr = pixels + i * rowstride;
+      
+      if (k == 0)
+        {
+          ptr[0] = (unsigned char) (r1>>16);
+          ptr[1] = (unsigned char) (g1>>16);
+          ptr[2] = (unsigned char) (b1>>16);
+        }
+      else
+        {
+          ptr[0] = (unsigned char) (r2>>16);
+          ptr[1] = (unsigned char) (g2>>16);
+          ptr[2] = (unsigned char) (b2>>16);
+        }
+
+      for (j=1; j <= width/2; j *= 2)
+        memcpy (&(ptr[j*3]), ptr, j*3);
+      memcpy (&(ptr[j*3]), ptr, (width - j)*3);
+
+      if (++l == ll)
+        {
+          if (k == 0)
+            {
+              k = 1;
+              ll = thickness2;
+            }
+          else
+            {
+              k = 0;
+              ll = thickness1;
+            }
+          l = 0;
+        }
+      r1+=dr1;
+      g1+=dg1;
+      b1+=db1;
+	
+      r2+=dr2;
+      g2+=dg2;
+      b2+=db2;
+    }
+
+  return pixbuf;
+}
+
+/*
+ *----------------------------------------------------------------------
+ * meta_gradient_create_horizontal--
+ * 	Renders a horizontal linear gradient of the specified size in the
+ * GdkPixbuf format with a border of the specified type. 
+ * 
+ * Returns:
+ * 	A 24bit GdkPixbuf with the gradient (no alpha channel).
+ * 
+ * Side effects:
+ * 	None
+ *---------------------------------------------------------------------- 
+ */
+static GdkPixbuf*
+meta_gradient_create_horizontal (int width, int height,
+                                 const GdkColor *from,
+                                 const GdkColor *to)
+{    
+  int i;
+  long r, g, b, dr, dg, db;
+  GdkPixbuf *pixbuf;
+  unsigned char *ptr;
+  unsigned char *pixels;
+  int r0, g0, b0;
+  int rf, gf, bf;
+  int rowstride;
+
+  pixbuf = blank_pixbuf (width, height, FALSE);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  ptr = pixels;
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  
+  r0 = (guchar) (from->red / 256.0);
+  g0 = (guchar) (from->green / 256.0);
+  b0 = (guchar) (from->blue / 256.0);
+  rf = (guchar) (to->red / 256.0);
+  gf = (guchar) (to->green / 256.0);
+  bf = (guchar) (to->blue / 256.0);  
+  
+  r = r0 << 16;
+  g = g0 << 16;
+  b = b0 << 16;
+    
+  dr = ((rf-r0)<<16)/(int)width;
+  dg = ((gf-g0)<<16)/(int)width;
+  db = ((bf-b0)<<16)/(int)width;
+  /* render the first line */
+  for (i=0; i<width; i++)
+    {
+      *(ptr++) = (unsigned char)(r>>16);
+      *(ptr++) = (unsigned char)(g>>16);
+      *(ptr++) = (unsigned char)(b>>16);
+      r += dr;
+      g += dg;
+      b += db;
+    }
+
+  /* copy the first line to the other lines */
+  for (i=1; i<height; i++)
+    {
+      memcpy (&(pixels[i*rowstride]), pixels, rowstride);
+    }
+  return pixbuf;
+}
+
+/*
+ *----------------------------------------------------------------------
+ * meta_gradient_create_vertical--
+ *      Renders a vertical linear gradient of the specified size in the
+ * GdkPixbuf format with a border of the specified type.
+ *
+ * Returns:
+ *      A 24bit GdkPixbuf with the gradient (no alpha channel).
+ *
+ * Side effects:
+ *      None
+ *----------------------------------------------------------------------
+ */
+static GdkPixbuf*
+meta_gradient_create_vertical (int width, int height,
+                               const GdkColor *from,
+                               const GdkColor *to)
+{
+  int i, j;
+  long r, g, b, dr, dg, db;
+  GdkPixbuf *pixbuf;
+  unsigned char *ptr;
+  int r0, g0, b0;
+  int rf, gf, bf;
+  int rowstride;
+  unsigned char *pixels;
+  
+  pixbuf = blank_pixbuf (width, height, FALSE);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  
+  r0 = (guchar) (from->red / 256.0);
+  g0 = (guchar) (from->green / 256.0);
+  b0 = (guchar) (from->blue / 256.0);
+  rf = (guchar) (to->red / 256.0);
+  gf = (guchar) (to->green / 256.0);
+  bf = (guchar) (to->blue / 256.0);
+  
+  r = r0<<16;
+  g = g0<<16;
+  b = b0<<16;
+
+  dr = ((rf-r0)<<16)/(int)height;
+  dg = ((gf-g0)<<16)/(int)height;
+  db = ((bf-b0)<<16)/(int)height;
+
+  for (i=0; i<height; i++)
+    {
+      ptr = pixels + i * rowstride;
+      
+      ptr[0] = (unsigned char)(r>>16);
+      ptr[1] = (unsigned char)(g>>16);
+      ptr[2] = (unsigned char)(b>>16);
+
+      for (j=1; j <= width/2; j *= 2)
+        memcpy (&(ptr[j*3]), ptr, j*3);
+      memcpy (&(ptr[j*3]), ptr, (width - j)*3);
+
+      r+=dr;
+      g+=dg;
+      b+=db;
+    }
+  return pixbuf;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ * meta_gradient_create_diagonal--
+ *      Renders a diagonal linear gradient of the specified size in the
+ * GdkPixbuf format with a border of the specified type.
+ *
+ * Returns:
+ *      A 24bit GdkPixbuf with the gradient (no alpha channel).
+ *
+ * Side effects:
+ *      None
+ *----------------------------------------------------------------------
+ */
+
+
+static GdkPixbuf*
+meta_gradient_create_diagonal (int width, int height,
+                               const GdkColor *from,
+                               const GdkColor *to)
+{
+  GdkPixbuf *pixbuf, *tmp;
+  int j;
+  float a, offset;
+  unsigned char *ptr;
+  unsigned char *pixels;
+  int rowstride;
+  
+  if (width == 1)
+    return meta_gradient_create_vertical (width, height, from, to);
+  else if (height == 1)
+    return meta_gradient_create_horizontal (width, height, from, to);
+
+  pixbuf = blank_pixbuf (width, height, FALSE);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+
+  tmp = meta_gradient_create_horizontal (2*width-1, 1, from, to);
+  if (!tmp)
+    {
+      g_object_unref (G_OBJECT (pixbuf));
+      return NULL;
+    }
+
+  ptr = gdk_pixbuf_get_pixels (tmp);
+
+  a = ((float)(width - 1))/((float)(height - 1));
+  width = width * 3;
+
+  /* copy the first line to the other lines with corresponding offset */
+  for (j=0, offset=0.0; j<rowstride*height; j += rowstride)
+    {
+      memcpy (&(pixels[j]), &ptr[3*(int)offset], width);
+      offset += a;
+    }
+
+  g_object_unref (G_OBJECT (tmp));
+  return pixbuf;
+}
+
+
+static GdkPixbuf*
+meta_gradient_create_multi_horizontal (int width, int height,
+                                       const GdkColor *colors,
+                                       int count)
+{
+  int i, j, k;
+  long r, g, b, dr, dg, db;
+  GdkPixbuf *pixbuf;
+  unsigned char *ptr;
+  unsigned char *pixels;
+  int width2;  
+  int rowstride;
+  
+  g_return_val_if_fail (count > 2, NULL);
+
+  pixbuf = blank_pixbuf (width, height, FALSE);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  ptr = pixels;
+    
+  if (count > width)
+    count = width;
+    
+  if (count > 1)
+    width2 = width/(count-1);
+  else
+    width2 = width;
+    
+  k = 0;
+
+  r = colors[0].red << 8;
+  g = colors[0].green << 8;
+  b = colors[0].blue << 8;
+
+  /* render the first line */
+  for (i=1; i<count; i++)
+    {
+      dr = ((int)(colors[i].red   - colors[i-1].red)  <<8)/(int)width2;
+      dg = ((int)(colors[i].green - colors[i-1].green)<<8)/(int)width2;
+      db = ((int)(colors[i].blue  - colors[i-1].blue) <<8)/(int)width2;
+      for (j=0; j<width2; j++)
+        {
+          *ptr++ = (unsigned char)(r>>16);
+          *ptr++ = (unsigned char)(g>>16);
+          *ptr++ = (unsigned char)(b>>16);
+          r += dr;
+          g += dg;
+          b += db;
+          k++;
+	}
+      r = colors[i].red << 8;
+      g = colors[i].green << 8;
+      b = colors[i].blue << 8;
+    }
+  for (j=k; j<width; j++)
+    {
+      *ptr++ = (unsigned char)(r>>16);
+      *ptr++ = (unsigned char)(g>>16);
+      *ptr++ = (unsigned char)(b>>16);
+    }
+    
+  /* copy the first line to the other lines */
+  for (i=1; i<height; i++)
+    {
+      memcpy (&(pixels[i*rowstride]), pixels, rowstride);
+    }
+  return pixbuf;
+}
+
+static GdkPixbuf*
+meta_gradient_create_multi_vertical (int width, int height,
+                                     const GdkColor *colors,
+                                     int count)
+{
+  int i, j, k;
+  long r, g, b, dr, dg, db;
+  GdkPixbuf *pixbuf;
+  unsigned char *ptr, *tmp, *pixels;
+  int height2;
+  int x;
+  int rowstride;
+  
+  g_return_val_if_fail (count > 2, NULL);
+
+  pixbuf = blank_pixbuf (width, height, FALSE);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  ptr = pixels;
+    
+  if (count > height)
+    count = height;
+    
+  if (count > 1)
+    height2 = height/(count-1);
+  else
+    height2 = height;
+    
+  k = 0;
+
+  r = colors[0].red << 8;
+  g = colors[0].green << 8;
+  b = colors[0].blue << 8;
+
+  for (i=1; i<count; i++)
+    {
+      dr = ((int)(colors[i].red   - colors[i-1].red)  <<8)/(int)height2;
+      dg = ((int)(colors[i].green - colors[i-1].green)<<8)/(int)height2;
+      db = ((int)(colors[i].blue  - colors[i-1].blue) <<8)/(int)height2;
+
+      for (j=0; j<height2; j++)
+        {
+          ptr[0] = (unsigned char)(r>>16);
+          ptr[1] = (unsigned char)(g>>16);
+          ptr[2] = (unsigned char)(b>>16);
+
+          for (x=1; x <= width/2; x *= 2)
+            memcpy (&(ptr[x*3]), ptr, x*3);
+          memcpy (&(ptr[x*3]), ptr, (width - x)*3);
+
+          ptr += rowstride;
+          
+          r += dr;
+          g += dg;
+          b += db;
+          k++;
+	}
+      r = colors[i].red << 8;
+      g = colors[i].green << 8;
+      b = colors[i].blue << 8;
+    }
+
+  if (k<height)
+    {
+      tmp = ptr;
+
+      ptr[0] = (unsigned char) (r>>16);
+      ptr[1] = (unsigned char) (g>>16);
+      ptr[2] = (unsigned char) (b>>16);
+
+      for (x=1; x <= width/2; x *= 2)
+        memcpy (&(ptr[x*3]), ptr, x*3);
+      memcpy (&(ptr[x*3]), ptr, (width - x)*3);
+
+      ptr += rowstride;
+      
+      for (j=k+1; j<height; j++)
+        {
+          memcpy (ptr, tmp, rowstride);
+          ptr += rowstride;
+        }
+    }
+    
+  return pixbuf;
+}
+
+
+static GdkPixbuf*
+meta_gradient_create_multi_diagonal (int width, int height,
+                                     const GdkColor *colors,
+                                     int count)
+{
+  GdkPixbuf *pixbuf, *tmp;
+  float a, offset;
+  int j;
+  unsigned char *ptr;
+  unsigned char *pixels;
+  int rowstride;
+  
+  g_return_val_if_fail (count > 2, NULL);
+
+  if (width == 1)
+    return meta_gradient_create_multi_vertical (width, height, colors, count);
+  else if (height == 1)
+    return meta_gradient_create_multi_horizontal (width, height, colors, count);
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
+                           width, height);
+  if (pixbuf == NULL)
+    return NULL;
+    
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  
+  if (count > width)
+    count = width;
+  if (count > height)
+    count = height;
+
+  if (count > 2)
+    tmp = meta_gradient_create_multi_horizontal (2*width-1, 1, colors, count);
+  else
+    /* wrlib multiplies these colors by 256 before passing them in, but
+     * I think it's a bug in wrlib, so changed here. I could be wrong
+     * though, if we notice two-color multi diagonals not working.
+     */
+    tmp = meta_gradient_create_horizontal (2*width-1, 1,
+                                           &colors[0], &colors[1]);
+
+  if (!tmp)
+    {
+      g_object_unref (G_OBJECT (pixbuf));
+      return NULL;
+    }
+  ptr = gdk_pixbuf_get_pixels (tmp);
+
+  a = ((float)(width - 1))/((float)(height - 1));
+  width = width * 3;
+
+  /* copy the first line to the other lines with corresponding offset */
+  for (j=0, offset=0; j<rowstride*height; j += rowstride)
+    {
+      memcpy (&(pixels[j]), &ptr[3*(int)offset], width);
+      offset += a;
+    }
+
+  g_object_unref (G_OBJECT (tmp));
+  return pixbuf;
+}
+
+static void
+simple_multiply_alpha (GdkPixbuf *pixbuf,
+                       guchar     alpha)
+{
+  guchar *pixels;
+  int rowstride;
+  int height;
+  int row;
+
+  g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
+  
+  if (alpha == 255)
+    return;
+  
+  g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
+  
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  height = gdk_pixbuf_get_height (pixbuf);
+
+  row = 0;
+  while (row < height)
+    {
+      guchar *p;
+      guchar *end;
+
+      p = pixels + row * rowstride;
+      end = p + rowstride;
+
+      while (p != end)
+        {
+          p += 3; /* skip RGB */
+
+          /* multiply the two alpha channels. not sure this is right.
+           * but some end cases are that if the pixbuf contains 255,
+           * then it should be modified to contain "alpha"; if the
+           * pixbuf contains 0, it should remain 0.
+           */
+          /* ((*p / 255.0) * (alpha / 255.0)) * 255; */
+          *p = (guchar) (((int) *p * (int) alpha) / (int) 255);
+          
+          ++p; /* skip A */
+        }
+
+      ++row;
+    }
+}
+
+static void
+meta_gradient_add_alpha_horizontal (GdkPixbuf           *pixbuf,
+                                    const unsigned char *alphas,
+                                    int                  n_alphas)
+{
+  int i, j;
+  long a, da;
+  unsigned char *p;
+  unsigned char *pixels;
+  int width2;  
+  int rowstride;
+  int width, height;
+  unsigned char *gradient;
+  unsigned char *gradient_p;
+  unsigned char *gradient_end;
+  
+  g_return_if_fail (n_alphas > 0);
+
+  if (n_alphas == 1)
+    {
+      /* Optimize this */
+      simple_multiply_alpha (pixbuf, alphas[0]);
+      return;
+    }
+  
+  width = gdk_pixbuf_get_width (pixbuf);
+  height = gdk_pixbuf_get_height (pixbuf);
+
+  gradient = g_new (unsigned char, width);
+  gradient_end = gradient + width;
+  
+  if (n_alphas > width)
+    n_alphas = width;
+    
+  if (n_alphas > 1)
+    width2 = width / (n_alphas - 1);
+  else
+    width2 = width;
+    
+  a = alphas[0] << 8;
+  gradient_p = gradient;
+  
+  /* render the gradient into an array */
+  for (i = 1; i < n_alphas; i++)
+    {
+      da = (((int)(alphas[i] - (int) alphas[i-1])) << 8) / (int) width2;
+
+      for (j = 0; j < width2; j++)
+        {
+          *gradient_p++ = (a >> 8);
+          
+          a += da;
+	}
+
+      a = alphas[i] << 8;
+    }
+
+  /* get leftover pixels */
+  while (gradient_p != gradient_end)
+    {
+      *gradient_p++ = a >> 8;
+    }
+    
+  /* Now for each line of the pixbuf, fill in with the gradient */
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  
+  p = pixels;
+  i = 0;
+  while (i < height)
+    {
+      unsigned char *row_end = p + rowstride;
+      gradient_p = gradient;
+
+      p += 3;
+      while (gradient_p != gradient_end)
+        {
+          /* multiply the two alpha channels. not sure this is right.
+           * but some end cases are that if the pixbuf contains 255,
+           * then it should be modified to contain "alpha"; if the
+           * pixbuf contains 0, it should remain 0.
+           */
+          /* ((*p / 255.0) * (alpha / 255.0)) * 255; */
+          *p = (guchar) (((int) *p * (int) *gradient_p) / (int) 255);
+
+          p += 4;
+          ++gradient_p;
+        }
+
+      p = row_end;
+      ++i;
+    }
+  
+  g_free (gradient);
+}
+
+void
+meta_gradient_add_alpha (GdkPixbuf       *pixbuf,
+                         const guchar    *alphas,
+                         int              n_alphas,
+                         MetaGradientType type)
+{
+  g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
+  g_return_if_fail (gdk_pixbuf_get_has_alpha (pixbuf));
+  g_return_if_fail (n_alphas > 0);
+  
+  switch (type)
+    {
+    case META_GRADIENT_HORIZONTAL:
+      meta_gradient_add_alpha_horizontal (pixbuf, alphas, n_alphas);
+      break;
+      
+    case META_GRADIENT_VERTICAL:
+      g_printerr ("marco: vertical alpha channel gradient not implemented yet\n");
+      break;
+      
+    case META_GRADIENT_DIAGONAL:
+      g_printerr ("marco: diagonal alpha channel gradient not implemented yet\n");
+      break;
+      
+    case META_GRADIENT_LAST:
+      g_assert_not_reached ();
+      break;
+    }
+}
diff --git a/src/ui/gradient.h b/src/ui/gradient.h
new file mode 100644
index 00000000..196fd6a0
--- /dev/null
+++ b/src/ui/gradient.h
@@ -0,0 +1,65 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco gradient rendering */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington, 99% copied from wrlib in
+ * WindowMaker, Copyright (C) 1997-2000 Dan Pascu and Alfredo Kojima
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  */
+
+#ifndef META_GRADIENT_H
+#define META_GRADIENT_H
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk/gdk.h>
+
+typedef enum
+{
+  META_GRADIENT_VERTICAL,
+  META_GRADIENT_HORIZONTAL,
+  META_GRADIENT_DIAGONAL,
+  META_GRADIENT_LAST
+} MetaGradientType;
+
+GdkPixbuf* meta_gradient_create_simple     (int               width,
+                                            int               height,
+                                            const GdkColor   *from,
+                                            const GdkColor   *to,
+                                            MetaGradientType  style);
+GdkPixbuf* meta_gradient_create_multi      (int               width,
+                                            int               height,
+                                            const GdkColor   *colors,
+                                            int               n_colors,
+                                            MetaGradientType  style);
+GdkPixbuf* meta_gradient_create_interwoven (int               width,
+                                            int               height,
+                                            const GdkColor    colors1[2],
+                                            int               thickness1,
+                                            const GdkColor    colors2[2],
+                                            int               thickness2);
+
+
+/* Generate an alpha gradient and multiply it with the existing alpha
+ * channel of the given pixbuf
+ */
+void meta_gradient_add_alpha (GdkPixbuf       *pixbuf,
+                              const guchar    *alphas,
+                              int              n_alphas,
+                              MetaGradientType type);
+
+
+#endif
diff --git a/src/ui/menu.c b/src/ui/menu.c
new file mode 100644
index 00000000..5207876f
--- /dev/null
+++ b/src/ui/menu.c
@@ -0,0 +1,509 @@
+/* Marco window menu */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2004 Rob Adams
+ * Copyright (C) 2005 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <string.h>
+#include "menu.h"
+#include "main.h"
+#include "util.h"
+#include "core.h"
+#include "themewidget.h"
+#include "metaaccellabel.h"
+#include "ui.h"
+
+typedef struct _MenuItem MenuItem;
+typedef struct _MenuData MenuData;
+
+typedef enum {
+	MENU_ITEM_SEPARATOR = 0,
+	MENU_ITEM_NORMAL,
+	MENU_ITEM_IMAGE,
+	MENU_ITEM_CHECKBOX,
+	MENU_ITEM_RADIOBUTTON,
+	MENU_ITEM_WORKSPACE_LIST,
+} MetaMenuItemType;
+
+struct _MenuItem {
+	MetaMenuOp op;
+	MetaMenuItemType type;
+	const char* stock_id;
+	const gboolean checked;
+	const char* label;
+};
+
+
+struct _MenuData {
+	MetaWindowMenu* menu;
+	MetaMenuOp op;
+};
+
+static void activate_cb(GtkWidget* menuitem, gpointer data);
+
+static MenuItem menuitems[] = {
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MINIMIZE, MENU_ITEM_IMAGE, MARCO_STOCK_MINIMIZE, FALSE, N_("Mi_nimize")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MAXIMIZE, MENU_ITEM_IMAGE, MARCO_STOCK_MAXIMIZE, FALSE, N_("Ma_ximize")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_UNMAXIMIZE, MENU_ITEM_IMAGE, MARCO_STOCK_RESTORE, FALSE, N_("Unma_ximize")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_SHADE, MENU_ITEM_NORMAL, NULL, FALSE, N_("Roll _Up")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_UNSHADE, MENU_ITEM_NORMAL, NULL, FALSE, N_("_Unroll")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MOVE, MENU_ITEM_NORMAL, NULL, FALSE, N_("_Move") },
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_RESIZE, MENU_ITEM_NORMAL, NULL, FALSE, N_("_Resize")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_RECOVER, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move Titlebar On_screen")},
+	{META_MENU_OP_WORKSPACES, MENU_ITEM_SEPARATOR, NULL, FALSE, NULL}, /* separator */
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_ABOVE, MENU_ITEM_CHECKBOX, NULL, FALSE, N_("Always on _Top")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_UNABOVE, MENU_ITEM_CHECKBOX, NULL, TRUE, N_("Always on _Top")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_STICK, MENU_ITEM_RADIOBUTTON, NULL, FALSE, N_("_Always on Visible Workspace")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_UNSTICK, MENU_ITEM_RADIOBUTTON, NULL, FALSE,  N_("_Only on This Workspace")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MOVE_LEFT, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move to Workspace _Left")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MOVE_RIGHT, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move to Workspace R_ight")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MOVE_UP, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move to Workspace _Up")},
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_MOVE_DOWN, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move to Workspace _Down")},
+	{0, MENU_ITEM_WORKSPACE_LIST, NULL, FALSE, NULL},
+	{0, MENU_ITEM_SEPARATOR, NULL, FALSE, NULL}, /* separator */
+	/* Translators: Translate this string the same way as you do in libwnck! */
+	{META_MENU_OP_DELETE, MENU_ITEM_IMAGE, MARCO_STOCK_DELETE, FALSE, N_("_Close")}
+};
+
+static void popup_position_func(GtkMenu* menu, gint* x, gint* y, gboolean* push_in, gpointer user_data)
+{
+	GtkRequisition req;
+	GdkPoint* pos;
+
+	pos = user_data;
+
+	gtk_widget_size_request(GTK_WIDGET(menu), &req);
+
+	*x = pos->x;
+	*y = pos->y;
+
+	if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+	{
+		*x = MAX (0, *x - req.width);
+	}
+
+	/* Ensure onscreen */
+	*x = CLAMP (*x, 0, MAX(0, gdk_screen_width() - req.width));
+	*y = CLAMP (*y, 0, MAX(0, gdk_screen_height() - req.height));
+}
+
+static void menu_closed(GtkMenu* widget, gpointer data)
+{
+	MetaWindowMenu *menu;
+
+	menu = data;
+
+	meta_frames_notify_menu_hide (menu->frames);
+
+	(*menu->func)(
+		menu,
+		GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
+		menu->client_xwindow,
+		gtk_get_current_event_time (),
+		0, 0,
+		menu->data);
+
+	/* menu may now be freed */
+}
+
+static void activate_cb(GtkWidget* menuitem, gpointer data)
+{
+  MenuData* md;
+
+  g_return_if_fail (GTK_IS_WIDGET (menuitem));
+
+  md = data;
+
+	meta_frames_notify_menu_hide(md->menu->frames);
+
+	(*md->menu->func)(
+		md->menu,
+		GDK_DISPLAY_XDISPLAY (gdk_display_get_default()),
+		md->menu->client_xwindow,
+		gtk_get_current_event_time(),
+		md->op,
+		GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), "workspace")),
+		md->menu->data);
+
+	/* menu may now be freed */
+}
+
+/*
+ * Given a Display and an index, get the workspace name and add any
+ * accelerators. At the moment this means adding a _ if the name is of
+ * the form "Workspace n" where n is less than 10, and escaping any
+ * other '_'s so they do not create inadvertant accelerators.
+ *
+ * The calling code owns the string, and is reponsible to free the
+ * memory after use.
+ *
+ * See also http://mail.gnome.org/archives/mate-i18n/2008-March/msg00380.html
+ * which discusses possible i18n concerns.
+ */
+static char*
+get_workspace_name_with_accel (Display *display,
+                               Window   xroot,
+                               int      index)
+{
+  const char *name;
+  int number;
+  int charcount=0;
+
+  name = meta_core_get_workspace_name_with_index (display, xroot, index);
+
+  g_assert (name != NULL);
+
+  /*
+   * If the name is of the form "Workspace x" where x is an unsigned
+   * integer, insert a '_' before the number if it is less than 10 and
+   * return it
+   */
+  number = 0;
+  if (sscanf (name, _("Workspace %d%n"), &number, &charcount) != 0 &&
+      *(name + charcount)=='\0')
+    {
+      char *new_name;
+
+      /*
+       * Above name is a pointer into the Workspace struct. Here we make
+       * a copy copy so we can have our wicked way with it.
+       */
+      if (number == 10)
+        new_name = g_strdup_printf (_("Workspace 1_0"));
+      else
+        new_name = g_strdup_printf (_("Workspace %s%d"),
+                                    number < 10 ? "_" : "",
+                                    number);
+      return new_name;
+    }
+  else
+    {
+      /*
+       * Otherwise this is just a normal name. Escape any _ characters so that
+       * the user's workspace names do not get mangled.  If the number is less
+       * than 10 we provide an accelerator.
+       */
+      char *new_name;
+      const char *source;
+      char *dest;
+
+      /*
+       * Assume the worst case, that every character is a _.  We also
+       * provide memory for " (_#)"
+       */
+      new_name = g_malloc0 (strlen (name) * 2 + 6 + 1);
+
+      /*
+       * Now iterate down the strings, adding '_' to escape as we go
+       */
+      dest = new_name;
+      source = name;
+      while (*source != '\0')
+        {
+          if (*source == '_')
+            *dest++ = '_';
+          *dest++ = *source++;
+        }
+
+      /* People don't start at workspace 0, but workspace 1 */
+      if (index < 9)
+        {
+          g_snprintf (dest, 6, " (_%d)", index + 1);
+        }
+      else if (index == 9)
+        {
+          g_snprintf (dest, 6, " (_0)");
+        }
+
+      return new_name;
+    }
+}
+
+static GtkWidget* menu_item_new(MenuItem* menuitem, int workspace_id)
+{
+	unsigned int key;
+	MetaVirtualModifier mods;
+	const char* i18n_label;
+	GtkWidget* mi;
+	GtkWidget* accel_label;
+
+	if (menuitem->type == MENU_ITEM_NORMAL)
+	{
+		mi = gtk_menu_item_new ();
+	}
+	else if (menuitem->type == MENU_ITEM_IMAGE)
+	{
+		GtkWidget* image = gtk_image_new_from_icon_name(menuitem->stock_id, GTK_ICON_SIZE_MENU);
+
+		mi = gtk_image_menu_item_new();
+
+		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), image);
+		gtk_widget_show(image);
+	}
+	else if (menuitem->type == MENU_ITEM_CHECKBOX)
+	{
+		mi = gtk_check_menu_item_new ();
+
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), menuitem->checked);
+    }
+	else if (menuitem->type == MENU_ITEM_RADIOBUTTON)
+	{
+		mi = gtk_check_menu_item_new ();
+
+		gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi), TRUE);
+		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), menuitem->checked);
+	}
+	else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST)
+	{
+		return NULL;
+	}
+	else
+	{
+		return gtk_separator_menu_item_new();
+	}
+
+	i18n_label = _(menuitem->label);
+	meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);
+
+	accel_label = meta_accel_label_new_with_mnemonic (i18n_label);
+	gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
+
+	gtk_container_add (GTK_CONTAINER (mi), accel_label);
+	gtk_widget_show (accel_label);
+
+	meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label), key, mods);
+
+	return mi;
+}
+
+MetaWindowMenu*
+meta_window_menu_new   (MetaFrames         *frames,
+                        MetaMenuOp          ops,
+                        MetaMenuOp          insensitive,
+                        Window              client_xwindow,
+                        unsigned long       active_workspace,
+                        int                 n_workspaces,
+                        MetaWindowMenuFunc  func,
+                        gpointer            data)
+{
+  int i;
+  MetaWindowMenu *menu;
+
+  /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */
+  if (n_workspaces < 2)
+    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);
+  else if (n_workspaces == 2)
+    /* #151183: If we only have two workspaces, disable the menu listing them. */
+    ops &= ~(META_MENU_OP_WORKSPACES);
+
+  menu = g_new (MetaWindowMenu, 1);
+  menu->frames = frames;
+  menu->client_xwindow = client_xwindow;
+  menu->func = func;
+  menu->data = data;
+  menu->ops = ops;
+  menu->insensitive = insensitive;
+
+  menu->menu = gtk_menu_new ();
+
+  gtk_menu_set_screen (GTK_MENU (menu->menu),
+                       gtk_widget_get_screen (GTK_WIDGET (frames)));
+
+  for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)
+    {
+      MenuItem menuitem = menuitems[i];
+      if (ops & menuitem.op || menuitem.op == 0)
+        {
+          GtkWidget *mi;
+          MenuData *md;
+          unsigned int key;
+          MetaVirtualModifier mods;
+
+          mi = menu_item_new (&menuitem, -1);
+
+          /* Set the activeness of radiobuttons. */
+          switch (menuitem.op)
+            {
+            case META_MENU_OP_STICK:
+              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
+                                              active_workspace == 0xFFFFFFFF);
+              break;
+            case META_MENU_OP_UNSTICK:
+              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
+                                              active_workspace != 0xFFFFFFFF);
+              break;
+            default:
+              break;
+            }
+
+          if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)
+            {
+              if (ops & META_MENU_OP_WORKSPACES)
+                {
+                  Display *display;
+                  Window xroot;
+                  GdkScreen *screen;
+                  GtkWidget *submenu;
+                  int j;
+
+                  MenuItem to_another_workspace = {
+                    0, MENU_ITEM_NORMAL,
+                    NULL, FALSE,
+                    N_("Move to Another _Workspace")
+                  };
+
+                  meta_verbose ("Creating %d-workspace menu current space %lu\n",
+                      n_workspaces, active_workspace);
+
+                  display = gdk_x11_drawable_get_xdisplay (GTK_WIDGET (frames)->window);
+
+                  screen = gdk_drawable_get_screen (GTK_WIDGET (frames)->window);
+                  xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen));
+
+                  submenu = gtk_menu_new ();
+
+                  g_assert (mi==NULL);
+                  mi = menu_item_new (&to_another_workspace, -1);
+                  gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);
+
+                  for (j = 0; j < n_workspaces; j++)
+                    {
+                      char *label;
+                      MenuData *md;
+                      unsigned int key;
+                      MetaVirtualModifier mods;
+                      MenuItem moveitem;
+                      GtkWidget *submi;
+
+                      meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,
+                          j + 1,
+                          &key, &mods);
+
+                      label = get_workspace_name_with_accel (display, xroot, j);
+
+                      moveitem.type = MENU_ITEM_NORMAL;
+                      moveitem.op = META_MENU_OP_WORKSPACES;
+                      moveitem.label = label;
+                      submi = menu_item_new (&moveitem, j + 1);
+
+                      g_free (label);
+
+                      if ((active_workspace == (unsigned)j) && (ops & META_MENU_OP_UNSTICK))
+                        gtk_widget_set_sensitive (submi, FALSE);
+
+                      md = g_new (MenuData, 1);
+
+                      md->menu = menu;
+                      md->op = META_MENU_OP_WORKSPACES;
+
+                      g_object_set_data (G_OBJECT (submi),
+                          "workspace",
+                          GINT_TO_POINTER (j));
+
+                      gtk_signal_connect_full (GTK_OBJECT (submi),
+                          "activate",
+                          G_CALLBACK (activate_cb),
+                          NULL,
+                          md,
+                          g_free, FALSE, FALSE);
+
+                      gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi);
+
+                      gtk_widget_show (submi);
+                    }
+                  }
+                else
+                  meta_verbose ("not creating workspace menu\n");
+            }
+          else if (menuitem.type != MENU_ITEM_SEPARATOR)
+            {
+              meta_core_get_menu_accelerator (menuitems[i].op, -1,
+                                              &key, &mods);
+
+              if (insensitive & menuitem.op)
+                gtk_widget_set_sensitive (mi, FALSE);
+
+              md = g_new (MenuData, 1);
+
+              md->menu = menu;
+              md->op = menuitem.op;
+
+              gtk_signal_connect_full (GTK_OBJECT (mi),
+                                       "activate",
+                                       G_CALLBACK (activate_cb),
+                                       NULL,
+                                       md,
+                                       g_free, FALSE, FALSE);
+            }
+
+          if (mi)
+            {
+              gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu), mi);
+
+              gtk_widget_show (mi);
+            }
+        }
+    }
+
+	g_signal_connect (menu->menu, "selection_done", G_CALLBACK(menu_closed), menu);
+
+	return menu;
+}
+
+void meta_window_menu_popup(MetaWindowMenu* menu, int root_x, int root_y, int button, guint32 timestamp)
+{
+	GdkPoint* pt = g_new(GdkPoint, 1);
+
+	g_object_set_data_full(G_OBJECT(menu->menu), "destroy-point", pt, g_free);
+
+	pt->x = root_x;
+	pt->y = root_y;
+
+	gtk_menu_popup(GTK_MENU (menu->menu), NULL, NULL, popup_position_func, pt, button, timestamp);
+
+	if (!GTK_MENU_SHELL(menu->menu)->have_xgrab)
+	{
+		meta_warning("GtkMenu failed to grab the pointer\n");
+	}
+}
+
+void meta_window_menu_free(MetaWindowMenu* menu)
+{
+	gtk_widget_destroy(menu->menu);
+	g_free(menu);
+}
diff --git a/src/ui/menu.h b/src/ui/menu.h
new file mode 100644
index 00000000..29e85a5b
--- /dev/null
+++ b/src/ui/menu.h
@@ -0,0 +1,51 @@
+/* Marco window menu */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_MENU_H
+#define META_MENU_H
+
+#include <gtk/gtk.h>
+#include "frames.h"
+
+/* Stock icons */
+#define MARCO_STOCK_DELETE   "window-close"
+#define MARCO_STOCK_RESTORE  "view-restore"
+#define MARCO_STOCK_MINIMIZE "go-down"
+#define MARCO_STOCK_MAXIMIZE "view-fullscreen"
+
+
+
+struct _MetaWindowMenu {
+	MetaFrames* frames;
+	Window client_xwindow;
+	GtkWidget* menu;
+	MetaWindowMenuFunc func;
+	gpointer data;
+	MetaMenuOp ops;
+	MetaMenuOp insensitive;
+};
+
+MetaWindowMenu* meta_window_menu_new(MetaFrames* frames, MetaMenuOp ops, MetaMenuOp insensitive, Window client_xwindow, unsigned long active_workspace, int n_workspaces, MetaWindowMenuFunc func, gpointer data);
+void meta_window_menu_popup(MetaWindowMenu* menu, int root_x, int root_y, int button, guint32 timestamp);
+void meta_window_menu_free(MetaWindowMenu* menu);
+
+
+#endif
diff --git a/src/ui/metaaccellabel.c b/src/ui/metaaccellabel.c
new file mode 100644
index 00000000..5efd7d2e
--- /dev/null
+++ b/src/ui/metaaccellabel.c
@@ -0,0 +1,456 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco hacked-up GtkAccelLabel */
+/* Copyright (C) 2002 Red Hat, Inc. */
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * MetaAccelLabel: GtkLabel with accelerator monitoring facilities.
+ * Copyright (C) 1998 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include <config.h>
+#include "metaaccellabel.h"
+#include <gtk/gtk.h>
+#include <string.h>
+#include "util.h"
+
+static void     meta_accel_label_class_init   (MetaAccelLabelClass *klass);
+static void     meta_accel_label_init         (MetaAccelLabel      *accel_label);
+static void     meta_accel_label_destroy      (GtkObject           *object);
+static void     meta_accel_label_finalize     (GObject             *object);
+static void     meta_accel_label_size_request (GtkWidget           *widget,
+                                               GtkRequisition      *requisition);
+static gboolean meta_accel_label_expose_event (GtkWidget           *widget,
+                                               GdkEventExpose      *event);
+
+static void  meta_accel_label_update          (MetaAccelLabel *accel_label);
+static int   meta_accel_label_get_accel_width (MetaAccelLabel *accel_label);
+
+
+static GtkLabelClass *parent_class = NULL;
+
+
+GType
+meta_accel_label_get_type (void)
+{
+  static GType accel_label_type = 0;
+
+  if (!accel_label_type)
+    {
+      static const GtkTypeInfo accel_label_info =
+      {
+	"MetaAccelLabel",
+	sizeof (MetaAccelLabel),
+	sizeof (MetaAccelLabelClass),
+	(GtkClassInitFunc) meta_accel_label_class_init,
+	(GtkObjectInitFunc) meta_accel_label_init,
+        /* reserved_1 */ NULL,
+	/* reserved_2 */ NULL,
+	(GtkClassInitFunc) NULL,
+      };
+
+      accel_label_type = gtk_type_unique (GTK_TYPE_LABEL, &accel_label_info);
+    }
+
+  return accel_label_type;
+}
+
+static void
+meta_accel_label_class_init (MetaAccelLabelClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+  GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  parent_class = g_type_class_peek_parent (class);
+
+  gobject_class->finalize = meta_accel_label_finalize;
+
+  object_class->destroy = meta_accel_label_destroy;
+
+  widget_class->size_request = meta_accel_label_size_request;
+  widget_class->expose_event = meta_accel_label_expose_event;
+
+  class->signal_quote1 = g_strdup ("<:");
+  class->signal_quote2 = g_strdup (":>");
+  /* This is the text that should appear next to menu accelerators
+   * that use the shift key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_shift = g_strdup (_("Shift"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the control key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_control = g_strdup (_("Ctrl"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the alt key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_alt = g_strdup (_("Alt"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the meta key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_meta = g_strdup (_("Meta"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the super key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_super = g_strdup (_("Super"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the hyper key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_hyper = g_strdup (_("Hyper"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the mod2 key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_mod2 = g_strdup (_("Mod2"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the mod3 key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_mod3 = g_strdup (_("Mod3"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the mod4 key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_mod4 = g_strdup (_("Mod4"));
+  /* This is the text that should appear next to menu accelerators
+   * that use the mod5 key. If the text on this key isn't typically
+   * translated on keyboards used for your language, don't translate
+   * this.
+   */
+  class->mod_name_mod5 = g_strdup (_("Mod5"));
+
+  class->mod_separator = g_strdup ("+");
+  class->accel_seperator = g_strdup (" / ");
+  class->latin1_to_char = TRUE;
+}
+
+static void
+meta_accel_label_init (MetaAccelLabel *accel_label)
+{
+  accel_label->accel_padding = 3;
+  accel_label->accel_string = NULL;
+
+  meta_accel_label_update (accel_label);
+}
+
+GtkWidget*
+meta_accel_label_new_with_mnemonic (const gchar *string)
+{
+  MetaAccelLabel *accel_label;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  accel_label = g_object_new (META_TYPE_ACCEL_LABEL, NULL);
+
+  gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), string);
+
+  return GTK_WIDGET (accel_label);
+}
+
+static void
+meta_accel_label_destroy (GtkObject *object)
+{
+  MetaAccelLabel *accel_label = META_ACCEL_LABEL (object);
+
+
+  g_free (accel_label->accel_string);
+  accel_label->accel_string = NULL;
+
+  accel_label->accel_mods = 0;
+  accel_label->accel_key = 0;
+
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
+}
+
+static void
+meta_accel_label_finalize (GObject *object)
+{
+  MetaAccelLabel *accel_label = META_ACCEL_LABEL (object);
+
+  g_free (accel_label->accel_string);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+void
+meta_accel_label_set_accelerator (MetaAccelLabel         *accel_label,
+                                  guint                   accelerator_key,
+                                  MetaVirtualModifier     accelerator_mods)
+{
+  g_return_if_fail (META_IS_ACCEL_LABEL (accel_label));
+
+  if (accelerator_key != accel_label->accel_key ||
+      accelerator_mods != accel_label->accel_mods)
+    {
+      accel_label->accel_mods = accelerator_mods;
+      accel_label->accel_key = accelerator_key;
+
+      meta_accel_label_update (accel_label);
+    }
+}
+
+static int
+meta_accel_label_get_accel_width (MetaAccelLabel *accel_label)
+{
+  g_return_val_if_fail (META_IS_ACCEL_LABEL (accel_label), 0);
+
+  return (accel_label->accel_string_width +
+	  (accel_label->accel_string_width ? accel_label->accel_padding : 0));
+}
+
+static void
+meta_accel_label_size_request (GtkWidget	     *widget,
+			      GtkRequisition *requisition)
+{
+  MetaAccelLabel *accel_label = META_ACCEL_LABEL (widget);
+  PangoLayout *layout;
+  gint width;
+
+  if (GTK_WIDGET_CLASS (parent_class)->size_request)
+    GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
+
+  layout = gtk_widget_create_pango_layout (widget, accel_label->accel_string);
+  pango_layout_get_pixel_size (layout, &width, NULL);
+  accel_label->accel_string_width = width;
+
+  g_object_unref (G_OBJECT (layout));
+}
+
+static gboolean
+meta_accel_label_expose_event (GtkWidget      *widget,
+			      GdkEventExpose *event)
+{
+  MetaAccelLabel *accel_label = META_ACCEL_LABEL (widget);
+  GtkMisc *misc = GTK_MISC (accel_label);
+  PangoLayout *layout;
+
+  if (GTK_WIDGET_DRAWABLE (accel_label))
+    {
+      int ac_width;
+
+      ac_width = meta_accel_label_get_accel_width (accel_label);
+
+      if (widget->allocation.width >= widget->requisition.width + ac_width)
+	{
+          GtkTextDirection direction = gtk_widget_get_direction (widget);
+	  gint x;
+	  gint y;
+
+          if (direction == GTK_TEXT_DIR_RTL)
+            {
+              widget->allocation.x += ac_width;
+            }
+	  widget->allocation.width -= ac_width;
+
+	  if (GTK_WIDGET_CLASS (parent_class)->expose_event)
+	    GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+
+          if (direction == GTK_TEXT_DIR_RTL)
+            {
+              widget->allocation.x -= ac_width;
+            }
+          widget->allocation.width += ac_width;
+
+          if (direction == GTK_TEXT_DIR_RTL)
+            {
+              x = widget->allocation.x + misc->xpad;
+            }
+          else
+            {
+              x = widget->allocation.x + widget->allocation.width - misc->xpad - ac_width;
+            }
+
+	  y = (widget->allocation.y * (1.0 - misc->yalign) +
+	       (widget->allocation.y + widget->allocation.height -
+		(widget->requisition.height - misc->ypad * 2)) *
+	       misc->yalign) + 1.5;
+
+	  layout = gtk_widget_create_pango_layout (widget, accel_label->accel_string);
+
+          gtk_paint_layout (widget->style,
+                            widget->window,
+                            GTK_WIDGET_STATE (widget),
+			    FALSE,
+                            &event->area,
+                            widget,
+                            "accellabel",
+                            x, y,
+                            layout);
+
+          g_object_unref (G_OBJECT (layout));
+	}
+      else
+	{
+	  if (GTK_WIDGET_CLASS (parent_class)->expose_event)
+	    GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+	}
+    }
+
+  return FALSE;
+}
+
+static void
+meta_accel_label_update (MetaAccelLabel *accel_label)
+{
+  MetaAccelLabelClass *class;
+  GString *gstring;
+  gboolean seen_mod = FALSE;
+  gunichar ch;
+
+  g_return_if_fail (META_IS_ACCEL_LABEL (accel_label));
+
+  class = META_ACCEL_LABEL_GET_CLASS (accel_label);
+
+  g_free (accel_label->accel_string);
+  accel_label->accel_string = NULL;
+
+  gstring = g_string_new (accel_label->accel_string);
+  g_string_append (gstring, gstring->len ? class->accel_seperator : "   ");
+
+  if (accel_label->accel_mods & META_VIRTUAL_SHIFT_MASK)
+    {
+      g_string_append (gstring, class->mod_name_shift);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_CONTROL_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_control);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_ALT_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_alt);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_META_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_meta);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_SUPER_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_super);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_HYPER_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_hyper);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_MOD2_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_mod2);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_MOD3_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_mod3);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_MOD4_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_mod4);
+      seen_mod = TRUE;
+    }
+  if (accel_label->accel_mods & META_VIRTUAL_MOD5_MASK)
+    {
+      if (seen_mod)
+        g_string_append (gstring, class->mod_separator);
+      g_string_append (gstring, class->mod_name_mod5);
+      seen_mod = TRUE;
+    }
+
+  if (seen_mod)
+    g_string_append (gstring, class->mod_separator);
+
+  ch = gdk_keyval_to_unicode (accel_label->accel_key);
+  if (ch && (g_unichar_isgraph (ch) || ch == ' ') &&
+      (ch < 0x80 || class->latin1_to_char))
+    {
+      switch (ch)
+        {
+        case ' ':
+          g_string_append (gstring, "Space");
+          break;
+        case '\\':
+          g_string_append (gstring, "Backslash");
+          break;
+        default:
+          g_string_append_unichar (gstring, g_unichar_toupper (ch));
+          break;
+        }
+    }
+  else
+    {
+      gchar *tmp;
+
+      tmp = gtk_accelerator_name (accel_label->accel_key, 0);
+      if (tmp[0] != 0 && tmp[1] == 0)
+        tmp[0] = g_ascii_toupper (tmp[0]);
+      g_string_append (gstring, tmp);
+      g_free (tmp);
+    }
+
+  g_free (accel_label->accel_string);
+  accel_label->accel_string = gstring->str;
+  g_string_free (gstring, FALSE);
+
+  g_assert (accel_label->accel_string);
+  /* accel_label->accel_string = g_strdup ("-/-"); */
+
+  gtk_widget_queue_resize (GTK_WIDGET (accel_label));
+}
diff --git a/src/ui/metaaccellabel.h b/src/ui/metaaccellabel.h
new file mode 100644
index 00000000..34914c92
--- /dev/null
+++ b/src/ui/metaaccellabel.h
@@ -0,0 +1,106 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco hacked-up GtkAccelLabel */
+/* Copyright (C) 2002 Red Hat, Inc. */
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * MetaAccelLabel: GtkLabel with accelerator monitoring facilities.
+ * Copyright (C) 1998 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __META_ACCEL_LABEL_H__
+#define __META_ACCEL_LABEL_H__
+
+#include <gtk/gtk.h>
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define META_TYPE_ACCEL_LABEL		(meta_accel_label_get_type ())
+#define META_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_ACCEL_LABEL, MetaAccelLabel))
+#define META_ACCEL_LABEL_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_ACCEL_LABEL, MetaAccelLabelClass))
+#define META_IS_ACCEL_LABEL(obj)	 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_ACCEL_LABEL))
+#define META_IS_ACCEL_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_ACCEL_LABEL))
+#define META_ACCEL_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_ACCEL_LABEL, MetaAccelLabelClass))
+
+
+typedef struct _MetaAccelLabel	    MetaAccelLabel;
+typedef struct _MetaAccelLabelClass  MetaAccelLabelClass;
+
+struct _MetaAccelLabel
+{
+  GtkLabel label;
+
+  MetaVirtualModifier accel_mods;
+  guint accel_key;
+  guint accel_padding;
+  gchar *accel_string;
+  guint16 accel_string_width;
+};
+
+struct _MetaAccelLabelClass
+{
+  GtkLabelClass	 parent_class;
+
+  gchar		*signal_quote1;
+  gchar		*signal_quote2;
+  gchar		*mod_name_shift;
+  gchar		*mod_name_control;
+  gchar		*mod_name_alt;
+  gchar		*mod_name_meta;
+  gchar		*mod_name_super;
+  gchar		*mod_name_hyper;
+  gchar		*mod_name_mod2;
+  gchar		*mod_name_mod3;
+  gchar		*mod_name_mod4;
+  gchar		*mod_name_mod5;
+  gchar		*mod_separator;
+  gchar		*accel_seperator;
+  guint		 latin1_to_char : 1;
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GType	   meta_accel_label_get_type          (void) G_GNUC_CONST;
+GtkWidget* meta_accel_label_new_with_mnemonic (const gchar            *string);
+void       meta_accel_label_set_accelerator   (MetaAccelLabel         *accel_label,
+                                               guint                   accelerator_key,
+                                               MetaVirtualModifier     accelerator_mods);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __META_ACCEL_LABEL_H__ */
diff --git a/src/ui/preview-widget.c b/src/ui/preview-widget.c
new file mode 100644
index 00000000..8fcd2517
--- /dev/null
+++ b/src/ui/preview-widget.c
@@ -0,0 +1,601 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme preview widget */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE 600 /* for the maths routines over floats */
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include "preview-widget.h"
+
+static void     meta_preview_class_init    (MetaPreviewClass *klass);
+static void     meta_preview_init          (MetaPreview      *preview);
+static void     meta_preview_size_request  (GtkWidget        *widget,
+                                            GtkRequisition   *req);
+static void     meta_preview_size_allocate (GtkWidget        *widget,
+                                            GtkAllocation    *allocation);
+static gboolean meta_preview_expose        (GtkWidget        *widget,
+                                            GdkEventExpose   *event);
+static void     meta_preview_finalize      (GObject          *object);
+
+static GtkWidgetClass *parent_class;
+
+GType
+meta_preview_get_type (void)
+{
+  static GType preview_type = 0;
+
+  if (!preview_type)
+    {
+      static const GtkTypeInfo preview_info =
+      {
+	"MetaPreview",
+	sizeof (MetaPreview),
+	sizeof (MetaPreviewClass),
+	(GtkClassInitFunc) meta_preview_class_init,
+	(GtkObjectInitFunc) meta_preview_init,
+	/* reserved_1 */ NULL,
+        /* reserved_2 */ NULL,
+        (GtkClassInitFunc) NULL,
+      };
+
+      preview_type = gtk_type_unique (GTK_TYPE_BIN, &preview_info);
+    }
+
+  return preview_type;
+}
+
+static void
+meta_preview_class_init (MetaPreviewClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class;
+
+  widget_class = (GtkWidgetClass*) class;
+  parent_class = g_type_class_peek (GTK_TYPE_BIN);
+
+  gobject_class->finalize = meta_preview_finalize;
+
+  widget_class->expose_event = meta_preview_expose;
+  widget_class->size_request = meta_preview_size_request;
+  widget_class->size_allocate = meta_preview_size_allocate;
+}
+
+static void
+meta_preview_init (MetaPreview *preview)
+{
+  int i;
+  
+  gtk_widget_set_has_window (GTK_WIDGET (preview), FALSE);
+
+  i = 0;
+  while (i < MAX_BUTTONS_PER_CORNER)
+    {
+      preview->button_layout.left_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      preview->button_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      ++i;
+    }
+  
+  preview->button_layout.left_buttons[0] = META_BUTTON_FUNCTION_MENU;
+
+  preview->button_layout.right_buttons[0] = META_BUTTON_FUNCTION_MINIMIZE;
+  preview->button_layout.right_buttons[1] = META_BUTTON_FUNCTION_MAXIMIZE;
+  preview->button_layout.right_buttons[2] = META_BUTTON_FUNCTION_CLOSE;
+  
+  preview->type = META_FRAME_TYPE_NORMAL;
+  preview->flags =
+    META_FRAME_ALLOWS_DELETE |
+    META_FRAME_ALLOWS_MENU |
+    META_FRAME_ALLOWS_MINIMIZE |
+    META_FRAME_ALLOWS_MAXIMIZE |
+    META_FRAME_ALLOWS_VERTICAL_RESIZE |
+    META_FRAME_ALLOWS_HORIZONTAL_RESIZE |
+    META_FRAME_HAS_FOCUS |
+    META_FRAME_ALLOWS_SHADE |
+    META_FRAME_ALLOWS_MOVE;
+  
+  preview->left_width = -1;
+  preview->right_width = -1;
+  preview->top_height = -1;
+  preview->bottom_height = -1;
+}
+
+GtkWidget*
+meta_preview_new (void)
+{
+  MetaPreview *preview;
+  
+  preview = gtk_type_new (META_TYPE_PREVIEW);
+  
+  return GTK_WIDGET (preview);
+}
+
+static void
+meta_preview_finalize (GObject *object)
+{
+  MetaPreview *preview;
+
+  preview = META_PREVIEW (object);
+
+  g_free (preview->title);
+  preview->title = NULL;
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+ensure_info (MetaPreview *preview)
+{
+  GtkWidget *widget;
+
+  widget = GTK_WIDGET (preview);
+  
+  if (preview->layout == NULL)
+    {
+      PangoFontDescription *font_desc;
+      double scale;
+      PangoAttrList *attrs;
+      PangoAttribute *attr;
+
+      if (preview->theme)        
+        scale = meta_theme_get_title_scale (preview->theme,
+                                            preview->type,
+                                            preview->flags);
+      else
+        scale = 1.0;
+      
+      preview->layout = gtk_widget_create_pango_layout (widget,
+                                                        preview->title);
+      
+      font_desc = meta_gtk_widget_get_font_desc (widget, scale, NULL);
+      
+      preview->text_height =
+        meta_pango_font_desc_get_text_height (font_desc,
+                                              gtk_widget_get_pango_context (widget));
+          
+      attrs = pango_attr_list_new ();
+      
+      attr = pango_attr_size_new (pango_font_description_get_size (font_desc));
+      attr->start_index = 0;
+      attr->end_index = G_MAXINT;
+      
+      pango_attr_list_insert (attrs, attr);
+      
+      pango_layout_set_attributes (preview->layout, attrs);
+      
+      pango_attr_list_unref (attrs);      
+  
+      pango_font_description_free (font_desc);
+    }
+
+  if (preview->top_height < 0)
+    {
+      if (preview->theme)
+        {
+          meta_theme_get_frame_borders (preview->theme,
+                                        preview->type,
+                                        preview->text_height,
+                                        preview->flags,
+                                        &preview->top_height,
+                                        &preview->bottom_height,
+                                        &preview->left_width,
+                                        &preview->right_width);
+        }
+      else
+        {
+          preview->top_height = 0;
+          preview->bottom_height = 0;
+          preview->left_width = 0;
+          preview->right_width = 0;
+        }
+    }
+}
+
+static gboolean
+meta_preview_expose (GtkWidget      *widget,
+                     GdkEventExpose *event)
+{
+  MetaPreview *preview;
+  GtkAllocation allocation;
+  int border_width;
+  int client_width;
+  int client_height;
+  MetaButtonState button_states[META_BUTTON_TYPE_LAST] =
+  {
+    META_BUTTON_STATE_NORMAL,
+    META_BUTTON_STATE_NORMAL,
+    META_BUTTON_STATE_NORMAL,
+    META_BUTTON_STATE_NORMAL
+  };
+  
+  g_return_val_if_fail (META_IS_PREVIEW (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  preview = META_PREVIEW (widget);
+
+  ensure_info (preview);
+
+  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+  
+  gtk_widget_get_allocation (widget, &allocation);
+  client_width = allocation.width - preview->left_width - preview->right_width - border_width * 2;
+  client_height = allocation.height - preview->top_height - preview->bottom_height - border_width * 2;
+
+  if (client_width < 0)
+    client_width = 1;
+  if (client_height < 0)
+    client_height = 1;  
+  
+  if (preview->theme)
+    {
+      border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+      
+      meta_theme_draw_frame (preview->theme,
+                             widget,
+                             gtk_widget_get_window (widget),
+                             &event->area,
+                             allocation.x + border_width,
+                             allocation.y + border_width,
+                             preview->type,
+                             preview->flags,
+                             client_width, client_height,
+                             preview->layout,
+                             preview->text_height,
+                             &preview->button_layout,
+                             button_states,
+                             meta_preview_get_mini_icon (),
+                             meta_preview_get_icon ());
+    }
+
+  /* draw child */
+  return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+}
+
+static void
+meta_preview_size_request (GtkWidget      *widget,
+                           GtkRequisition *req)
+{
+  MetaPreview *preview;
+  GtkWidget *child;
+  guint border_width;
+
+  preview = META_PREVIEW (widget);
+
+  ensure_info (preview);
+
+  req->width = preview->left_width + preview->right_width;
+  req->height = preview->top_height + preview->bottom_height;
+  
+  child = gtk_bin_get_child (GTK_BIN (preview));
+  if (child &&
+      gtk_widget_get_visible (child))
+    {
+      GtkRequisition child_requisition;
+
+      gtk_widget_size_request (child, &child_requisition);
+
+      req->width += child_requisition.width;
+      req->height += child_requisition.height;
+    }
+  else
+    {
+#define NO_CHILD_WIDTH 80
+#define NO_CHILD_HEIGHT 20
+      req->width += NO_CHILD_WIDTH;
+      req->height += NO_CHILD_HEIGHT;
+    }
+
+  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+  req->width += border_width * 2;
+  req->height += border_width * 2;
+}
+
+static void
+meta_preview_size_allocate (GtkWidget         *widget,
+                            GtkAllocation     *allocation)
+{
+  MetaPreview *preview;
+  int border_width;
+  GtkAllocation child_allocation;
+  GtkWidget *child;
+  
+  preview = META_PREVIEW (widget);
+
+  ensure_info (preview);
+  
+  widget->allocation = *allocation;
+
+  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+  
+  child = gtk_bin_get_child (GTK_BIN (widget));
+  if (child &&
+      gtk_widget_get_visible (child))
+    {
+      child_allocation.x = widget->allocation.x + border_width + preview->left_width;
+      child_allocation.y = widget->allocation.y + border_width + preview->top_height;
+      
+      child_allocation.width = MAX (1, widget->allocation.width - border_width * 2 - preview->left_width - preview->right_width);
+      child_allocation.height = MAX (1, widget->allocation.height - border_width * 2 - preview->top_height - preview->bottom_height);
+
+      gtk_widget_size_allocate (gtk_bin_get_child (GTK_BIN (widget)), &child_allocation);
+    }
+}
+
+static void
+clear_cache (MetaPreview *preview)
+{
+  if (preview->layout)
+    {
+      g_object_unref (G_OBJECT (preview->layout));
+      preview->layout = NULL;
+    }
+
+  preview->left_width = -1;
+  preview->right_width = -1;
+  preview->top_height = -1;
+  preview->bottom_height = -1;
+}
+
+void
+meta_preview_set_theme (MetaPreview    *preview,
+                        MetaTheme      *theme)
+{
+  g_return_if_fail (META_IS_PREVIEW (preview));
+
+  preview->theme = theme;
+  
+  clear_cache (preview);
+
+  gtk_widget_queue_resize (GTK_WIDGET (preview));
+}
+
+void
+meta_preview_set_title (MetaPreview    *preview,
+                        const char     *title)
+{
+  g_return_if_fail (META_IS_PREVIEW (preview));
+
+  g_free (preview->title);
+  preview->title = g_strdup (title);
+  
+  clear_cache (preview);
+
+  gtk_widget_queue_resize (GTK_WIDGET (preview));
+}
+
+void
+meta_preview_set_frame_type (MetaPreview    *preview,
+                             MetaFrameType   type)
+{
+  g_return_if_fail (META_IS_PREVIEW (preview));
+
+  preview->type = type;
+
+  clear_cache (preview);
+
+  gtk_widget_queue_resize (GTK_WIDGET (preview));
+}
+
+void
+meta_preview_set_frame_flags (MetaPreview    *preview,
+                              MetaFrameFlags  flags)
+{
+  g_return_if_fail (META_IS_PREVIEW (preview));
+
+  preview->flags = flags;
+
+  clear_cache (preview);
+
+  gtk_widget_queue_resize (GTK_WIDGET (preview));
+}
+
+void
+meta_preview_set_button_layout (MetaPreview            *preview,
+                                const MetaButtonLayout *button_layout)
+{
+  g_return_if_fail (META_IS_PREVIEW (preview));
+  
+  preview->button_layout = *button_layout;  
+  
+  gtk_widget_queue_draw (GTK_WIDGET (preview));
+}
+
+GdkPixbuf*
+meta_preview_get_icon (void)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "gtk-missing-image",
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+  
+  return default_icon;
+}
+
+GdkPixbuf*
+meta_preview_get_mini_icon (void)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "gtk-missing-image",
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+  
+  return default_icon;
+}
+
+GdkRegion *
+meta_preview_get_clip_region (MetaPreview *preview, gint new_window_width, gint new_window_height)
+{
+  GdkRectangle xrect;
+  GdkRegion *corners_xregion, *window_xregion;
+  gint flags;
+  MetaFrameLayout *fgeom;
+  MetaFrameStyle *frame_style;
+
+  g_return_val_if_fail (META_IS_PREVIEW (preview), NULL);
+
+  flags = (META_PREVIEW (preview)->flags);
+
+  window_xregion = gdk_region_new ();
+
+  xrect.x = 0;
+  xrect.y = 0;
+  xrect.width = new_window_width;
+  xrect.height = new_window_height;
+
+  gdk_region_union_with_rect (window_xregion, &xrect);
+
+  if (preview->theme == NULL)
+    return window_xregion;
+
+  /* Otherwise, we do have a theme, so calculate the corners */
+  frame_style = meta_theme_get_frame_style (preview->theme,
+      META_FRAME_TYPE_NORMAL, flags);
+
+  fgeom = frame_style->layout;
+
+  corners_xregion = gdk_region_new ();
+
+  if (fgeom->top_left_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom->top_left_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = 0;
+          xrect.y = i;
+          xrect.width = width;
+          xrect.height = 1;
+
+          gdk_region_union_with_rect (corners_xregion, &xrect);
+        }
+    }
+
+  if (fgeom->top_right_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom->top_right_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = new_window_width - width;
+          xrect.y = i;
+          xrect.width = width;
+          xrect.height = 1;
+
+          gdk_region_union_with_rect (corners_xregion, &xrect);
+        }
+    }
+
+  if (fgeom->bottom_left_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom->bottom_left_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = 0;
+          xrect.y = new_window_height - i - 1;
+          xrect.width = width;
+          xrect.height = 1;
+
+          gdk_region_union_with_rect (corners_xregion, &xrect);
+        }
+    }
+
+  if (fgeom->bottom_right_corner_rounded_radius != 0)
+    {
+      const int corner = fgeom->bottom_right_corner_rounded_radius;
+      const float radius = sqrt(corner) + corner;
+      int i;
+
+      for (i=0; i<corner; i++)
+        {
+          const int width = floor(0.5 + radius - sqrt(radius*radius - (radius-(i+0.5))*(radius-(i+0.5))));
+          xrect.x = new_window_width - width;
+          xrect.y = new_window_height - i - 1;
+          xrect.width = width;
+          xrect.height = 1;
+
+          gdk_region_union_with_rect (corners_xregion, &xrect);
+        }
+    }
+
+  gdk_region_subtract (window_xregion, corners_xregion);
+  gdk_region_destroy (corners_xregion);
+
+  return window_xregion;
+}
+
+
diff --git a/src/ui/preview-widget.h b/src/ui/preview-widget.h
new file mode 100644
index 00000000..4b213714
--- /dev/null
+++ b/src/ui/preview-widget.h
@@ -0,0 +1,87 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme preview widget */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "theme.h"
+#include <gtk/gtk.h>
+
+#ifndef META_PREVIEW_WIDGET_H
+#define META_PREVIEW_WIDGET_H
+
+#define META_TYPE_PREVIEW			 (meta_preview_get_type ())
+#define META_PREVIEW(obj)			 (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_PREVIEW, MetaPreview))
+#define META_PREVIEW_CLASS(klass)		 (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_PREVIEW, MetaPreviewClass))
+#define META_IS_PREVIEW(obj)		 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_PREVIEW))
+#define META_IS_PREVIEW_CLASS(klass)	 (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_PREVIEW))
+#define META_PREVIEW_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_PREVIEW, MetaPreviewClass))
+
+typedef struct _MetaPreview	MetaPreview;
+typedef struct _MetaPreviewClass	MetaPreviewClass;
+
+struct _MetaPreview
+{
+  GtkBin bin;
+
+  MetaTheme *theme;
+  char *title;
+  MetaFrameType type;
+  MetaFrameFlags flags;  
+
+  PangoLayout *layout;
+  int text_height;
+
+  int left_width;
+  int right_width;
+  int top_height;
+  int bottom_height;
+
+  MetaButtonLayout button_layout;
+};
+
+struct _MetaPreviewClass
+{
+  GtkBinClass parent_class;
+};
+
+
+GType    meta_preview_get_type (void) G_GNUC_CONST;
+GtkWidget* meta_preview_new	 (void);
+
+void meta_preview_set_theme         (MetaPreview            *preview,
+                                     MetaTheme              *theme);
+void meta_preview_set_title         (MetaPreview            *preview,
+                                     const char             *title);
+void meta_preview_set_frame_type    (MetaPreview            *preview,
+                                     MetaFrameType           type);
+void meta_preview_set_frame_flags   (MetaPreview            *preview,
+                                     MetaFrameFlags          flags);
+void meta_preview_set_button_layout (MetaPreview            *preview,
+                                     const MetaButtonLayout *button_layout);
+
+GdkRegion * meta_preview_get_clip_region (MetaPreview *preview,
+                                          gint new_window_width,
+                                          gint new_window_height);
+
+GdkPixbuf* meta_preview_get_icon (void);
+GdkPixbuf* meta_preview_get_mini_icon (void);
+
+#endif
diff --git a/src/ui/resizepopup.c b/src/ui/resizepopup.c
new file mode 100644
index 00000000..67f39505
--- /dev/null
+++ b/src/ui/resizepopup.c
@@ -0,0 +1,217 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco resizing-terminal-window feedback */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "resizepopup.h"
+#include "util.h"
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+
+struct _MetaResizePopup
+{
+  GtkWidget *size_window;
+  GtkWidget *size_label;
+  Display *display;
+  int screen_number;  
+
+  int vertical_size;
+  int horizontal_size;
+  
+  gboolean showing;
+  
+  MetaRectangle rect;
+};
+
+MetaResizePopup*
+meta_ui_resize_popup_new (Display *display,
+                          int      screen_number)
+{
+  MetaResizePopup *popup;
+
+  popup = g_new0 (MetaResizePopup, 1);
+
+  popup->display = display;
+  popup->screen_number = screen_number;
+  
+  return popup;
+}
+
+void
+meta_ui_resize_popup_free (MetaResizePopup *popup)
+{
+  g_return_if_fail (popup != NULL);
+  
+  if (popup->size_window)
+    gtk_widget_destroy (popup->size_window);
+  
+  g_free (popup);
+}
+
+static void
+ensure_size_window (MetaResizePopup *popup)
+{
+  GtkWidget *frame;
+  
+  if (popup->size_window)
+    return;
+  
+  popup->size_window = gtk_window_new (GTK_WINDOW_POPUP);
+
+  gtk_window_set_screen (GTK_WINDOW (popup->size_window),
+			 gdk_display_get_screen (gdk_x11_lookup_xdisplay (popup->display),
+						 popup->screen_number));
+  
+  /* never shrink the size window */
+  gtk_window_set_resizable (GTK_WINDOW (popup->size_window),
+                            TRUE);
+  
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
+
+  gtk_container_add (GTK_CONTAINER (popup->size_window), frame);
+
+  popup->size_label = gtk_label_new ("");
+  gtk_misc_set_padding (GTK_MISC (popup->size_label), 3, 3);
+
+  gtk_container_add (GTK_CONTAINER (frame), popup->size_label);
+
+  gtk_widget_show_all (frame);
+}
+
+static void
+update_size_window (MetaResizePopup *popup)
+{
+  char *str;
+  int x, y;
+  int width, height;
+  
+  g_return_if_fail (popup->size_window != NULL);
+  
+  /* Translators: This represents the size of a window.  The first number is
+   * the width of the window and the second is the height.
+   */
+  str = g_strdup_printf (_("%d x %d"),
+                         popup->horizontal_size,
+                         popup->vertical_size);
+
+  gtk_label_set_text (GTK_LABEL (popup->size_label), str);
+
+  g_free (str);
+
+  gtk_window_get_size (GTK_WINDOW (popup->size_window), &width, &height);
+
+  x = popup->rect.x + (popup->rect.width - width) / 2;
+  y = popup->rect.y + (popup->rect.height - height) / 2;
+  
+  if (GTK_WIDGET_REALIZED (popup->size_window))
+    {
+      /* using move_resize to avoid jumpiness */
+      gdk_window_move_resize (popup->size_window->window,
+                              x, y,
+                              width, height);
+    }
+  else
+    {
+      gtk_window_move   (GTK_WINDOW (popup->size_window),
+                         x, y);
+    }
+}
+
+static void
+sync_showing (MetaResizePopup *popup)
+{
+  if (popup->showing)
+    {
+      if (popup->size_window)
+        gtk_widget_show (popup->size_window);
+      
+      if (popup->size_window && GTK_WIDGET_REALIZED (popup->size_window))
+        gdk_window_raise (popup->size_window->window);
+    }
+  else
+    {
+      if (popup->size_window)
+        gtk_widget_hide (popup->size_window);
+    }
+}
+
+void
+meta_ui_resize_popup_set (MetaResizePopup *popup,
+                          MetaRectangle    rect,
+                          int              base_width,
+                          int              base_height,
+                          int              width_inc,
+                          int              height_inc)
+{
+  gboolean need_update_size;
+  int display_w, display_h;
+  
+  g_return_if_fail (popup != NULL);
+
+  need_update_size = FALSE;
+  
+  display_w = rect.width - base_width;
+  if (width_inc > 0)
+    display_w /= width_inc;
+
+  display_h = rect.height - base_height;
+  if (height_inc > 0)
+    display_h /= height_inc;
+
+  if (!meta_rectangle_equal(&popup->rect, &rect) ||
+      display_w != popup->horizontal_size ||
+      display_h != popup->vertical_size)
+    need_update_size = TRUE;
+  
+  popup->rect = rect;
+  popup->vertical_size = display_h;
+  popup->horizontal_size = display_w;
+  
+  if (need_update_size)
+    {
+      ensure_size_window (popup);
+      update_size_window (popup);
+    }
+      
+  sync_showing (popup);
+}
+
+void
+meta_ui_resize_popup_set_showing  (MetaResizePopup *popup,
+                                   gboolean         showing)
+{
+  g_return_if_fail (popup != NULL);
+  
+  if (showing == popup->showing)
+    return;
+
+  popup->showing = !!showing;
+
+  if (popup->showing)
+    {
+      ensure_size_window (popup);
+      update_size_window (popup);
+    }
+  
+  sync_showing (popup);
+}
diff --git a/src/ui/tabpopup.c b/src/ui/tabpopup.c
new file mode 100644
index 00000000..e0a55447
--- /dev/null
+++ b/src/ui/tabpopup.c
@@ -0,0 +1,967 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco popup window thing showing windows you can tab to */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "util.h"
+#include "core.h"
+#include "tabpopup.h"
+/* FIXME these two includes are 100% broken ...
+ */
+#include "../core/workspace.h"
+#include "../core/frame-private.h"
+#include "draw-workspace.h"
+#include <gtk/gtk.h>
+#include <math.h>
+
+#define OUTSIDE_SELECT_RECT 2
+#define INSIDE_SELECT_RECT 2
+
+typedef struct _TabEntry TabEntry;
+
+struct _TabEntry
+{
+  MetaTabEntryKey  key;
+  char            *title;
+  GdkPixbuf       *icon, *dimmed_icon;
+  GtkWidget       *widget;
+  GdkRectangle     rect;
+  GdkRectangle     inner_rect;
+  guint blank : 1;
+};
+
+struct _MetaTabPopup
+{
+  GtkWidget *window;
+  GtkWidget *label;
+  GList *current;
+  GList *entries;
+  TabEntry *current_selected_entry;
+  GtkWidget *outline_window;
+  gboolean outline;
+};
+
+static GtkWidget* selectable_image_new (GdkPixbuf *pixbuf);
+static void       select_image         (GtkWidget *widget);
+static void       unselect_image       (GtkWidget *widget);
+
+static GtkWidget* selectable_workspace_new (MetaWorkspace *workspace);
+static void       select_workspace         (GtkWidget *widget);
+static void       unselect_workspace       (GtkWidget *widget);
+
+static gboolean
+outline_window_expose (GtkWidget      *widget,
+                       GdkEventExpose *event,
+                       gpointer        data)
+{
+  MetaTabPopup *popup;
+  TabEntry *te;  
+  GtkStyle *style;
+  GdkWindow *window;
+  cairo_t *cr;
+  
+  popup = data;
+
+  if (!popup->outline || popup->current_selected_entry == NULL)
+    return FALSE;
+
+  te = popup->current_selected_entry;
+  window = gtk_widget_get_window (widget);
+  style = gtk_widget_get_style (widget);
+  cr = gdk_cairo_create (window);
+  
+  cairo_set_line_width (cr, 1.0);
+  gdk_cairo_set_source_color (cr, &style->white);
+
+  cairo_rectangle (cr,
+                   0.5, 0.5,
+                   te->rect.width - 1,
+                   te->rect.height - 1);
+  cairo_stroke (cr);
+
+  cairo_rectangle (cr,
+                   te->inner_rect.x - 0.5, te->inner_rect.y - 0.5,
+                   te->inner_rect.width + 1,
+                   te->inner_rect.height + 1);
+  cairo_stroke (cr);
+
+  cairo_destroy (cr);
+
+  return FALSE;
+}
+
+static GdkPixbuf*
+dimm_icon (GdkPixbuf *pixbuf)
+{
+  int x, y, pixel_stride, row_stride;
+  guchar *row, *pixels;
+  int w, h;
+  GdkPixbuf *dimmed_pixbuf;
+
+  if (gdk_pixbuf_get_has_alpha (pixbuf))
+    {
+      dimmed_pixbuf = gdk_pixbuf_copy (pixbuf);
+    }
+  else
+    {
+      dimmed_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+    }
+
+  w = gdk_pixbuf_get_width (dimmed_pixbuf);
+  h = gdk_pixbuf_get_height (dimmed_pixbuf);      
+
+  pixel_stride = 4;
+
+  row = gdk_pixbuf_get_pixels (dimmed_pixbuf);
+  row_stride = gdk_pixbuf_get_rowstride (dimmed_pixbuf);
+
+  for (y = 0; y < h; y++)
+    {
+      pixels = row;                     
+      for (x = 0; x < w; x++) 
+        {
+          pixels[3] /= 2;                               
+          pixels += pixel_stride;
+        }                       
+      row += row_stride;
+    }
+  return dimmed_pixbuf;
+}
+
+static TabEntry*  
+tab_entry_new (const MetaTabEntry *entry, 
+               gint                screen_width,
+               gboolean            outline)
+{
+  TabEntry *te;
+  
+  te = g_new (TabEntry, 1);
+  te->key = entry->key;
+  te->title = NULL;
+  if (entry->title)
+    {
+      gchar *str;
+      gchar *tmp;
+      gchar *formatter = "%s";
+
+      str = meta_g_utf8_strndup (entry->title, 4096);
+
+      if (entry->hidden)
+        {
+          formatter = "[%s]";
+        }
+
+      tmp = g_markup_printf_escaped (formatter, str);
+      g_free (str);
+      str = tmp;
+
+      if (entry->demands_attention) 
+        {         
+          /* Escape the whole line of text then markup the text and 
+           * copy it back into the original buffer.
+           */
+          tmp = g_strdup_printf ("<b>%s</b>", str);
+          g_free (str);
+          str = tmp;
+        }
+
+        te->title=g_strdup(str);
+
+      g_free (str);
+    }
+  te->widget = NULL;
+  te->icon = entry->icon;
+  te->blank = entry->blank;
+  te->dimmed_icon = NULL;
+  if (te->icon)
+    {
+      g_object_ref (G_OBJECT (te->icon));
+      if (entry->hidden)
+        te->dimmed_icon = dimm_icon (entry->icon);
+    }
+  
+  if (outline)
+    {
+      te->rect.x = entry->rect.x;
+      te->rect.y = entry->rect.y;
+      te->rect.width = entry->rect.width;
+      te->rect.height = entry->rect.height;
+
+      te->inner_rect.x = entry->inner_rect.x;
+      te->inner_rect.y = entry->inner_rect.y;
+      te->inner_rect.width = entry->inner_rect.width;
+      te->inner_rect.height = entry->inner_rect.height;
+    }
+  return te;
+}
+
+MetaTabPopup*
+meta_ui_tab_popup_new (const MetaTabEntry *entries,
+                       int                 screen_number,
+                       int                 entry_count,
+                       int                 width,
+                       gboolean            outline)
+{
+  MetaTabPopup *popup;
+  int i, left, right, top, bottom;
+  int height;
+  GtkWidget *table;
+  GtkWidget *vbox;
+  GtkWidget *align;
+  GList *tmp;
+  GtkWidget *frame;
+  int max_label_width; /* the actual max width of the labels we create */
+  AtkObject *obj;
+  GdkScreen *screen;
+  int screen_width;
+  
+  popup = g_new (MetaTabPopup, 1);
+
+  popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);
+
+  screen = gdk_display_get_screen (gdk_display_get_default (),
+                                   screen_number);
+  gtk_window_set_screen (GTK_WINDOW (popup->outline_window),
+                         screen);
+
+  gtk_widget_set_app_paintable (popup->outline_window, TRUE);
+  gtk_widget_realize (popup->outline_window);
+
+  g_signal_connect (G_OBJECT (popup->outline_window), "expose_event",
+                    G_CALLBACK (outline_window_expose), popup);
+  
+  popup->window = gtk_window_new (GTK_WINDOW_POPUP);
+
+  gtk_window_set_screen (GTK_WINDOW (popup->window),
+                         screen);
+
+  gtk_window_set_position (GTK_WINDOW (popup->window),
+                           GTK_WIN_POS_CENTER_ALWAYS);
+  /* enable resizing, to get never-shrink behavior */
+  gtk_window_set_resizable (GTK_WINDOW (popup->window),
+                            TRUE);
+  popup->current = NULL;
+  popup->entries = NULL;
+  popup->current_selected_entry = NULL;
+  popup->outline = outline;
+
+  screen_width = gdk_screen_get_width (screen);
+  for (i = 0; i < entry_count; ++i)
+    {
+      TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline);
+      popup->entries = g_list_prepend (popup->entries, new_entry);
+    }
+
+  popup->entries = g_list_reverse (popup->entries);
+    
+  g_assert (width > 0);
+  height = i / width;
+  if (i % width)
+    height += 1;
+
+  table = gtk_table_new (height, width, FALSE);
+  vbox = gtk_vbox_new (FALSE, 0);
+  
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
+  gtk_container_set_border_width (GTK_CONTAINER (table), 1);
+  gtk_container_add (GTK_CONTAINER (popup->window),
+                     frame);
+  gtk_container_add (GTK_CONTAINER (frame),
+                     vbox);
+
+  align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
+
+  gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
+
+  gtk_container_add (GTK_CONTAINER (align),
+                     table);
+
+  popup->label = gtk_label_new ("");
+
+  /* Set the accessible role of the label to a status bar so it
+   * will emit name changed events that can be used by screen
+   * readers.
+   */
+  obj = gtk_widget_get_accessible (popup->label);
+  atk_object_set_role (obj, ATK_ROLE_STATUSBAR);
+
+  gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3);
+
+  gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0);
+
+  max_label_width = 0;
+  top = 0;
+  bottom = 1;
+  tmp = popup->entries;
+
+  while (tmp && top < height)
+    {      
+      left = 0;
+      right = 1;
+
+      while (tmp && left < width)
+        {
+          GtkWidget *image;
+          GtkRequisition req;
+
+          TabEntry *te;
+
+          te = tmp->data;
+
+          if (te->blank)
+            {
+              /* just stick a widget here to avoid special cases */
+              image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
+            }
+          else if (outline)
+            {
+              if (te->dimmed_icon)
+                {
+                  image = selectable_image_new (te->dimmed_icon);
+                }
+              else 
+                {
+                  image = selectable_image_new (te->icon);
+                }
+
+              gtk_misc_set_padding (GTK_MISC (image),
+                                    INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,
+                                    INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);
+              gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
+            }   
+          else
+            {
+              image = selectable_workspace_new ((MetaWorkspace *) te->key);
+            }
+
+          te->widget = image;
+
+          gtk_table_attach (GTK_TABLE (table),
+                            te->widget,
+                            left, right,           top, bottom,
+                            0,                     0,
+                            0,                     0);
+
+          /* Efficiency rules! */
+          gtk_label_set_markup (GTK_LABEL (popup->label),
+                              te->title);
+          gtk_widget_size_request (popup->label, &req);
+          max_label_width = MAX (max_label_width, req.width);
+          
+          tmp = tmp->next;
+          
+          ++left;
+          ++right;
+        }
+      
+      ++top;
+      ++bottom;
+    }
+
+  /* remove all the temporary text */
+  gtk_label_set_text (GTK_LABEL (popup->label), "");
+  /* Make it so that we ellipsize if the text is too long */
+  gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);
+
+  /* Limit the window size to no bigger than screen_width/4 */
+  if (max_label_width>(screen_width/4)) 
+    {
+      max_label_width = screen_width/4;
+    }
+
+  max_label_width += 20; /* add random padding */
+  
+  gtk_window_set_default_size (GTK_WINDOW (popup->window),
+                               max_label_width,
+                               -1);
+  
+  return popup;
+}
+
+static void
+free_tab_entry (gpointer data, gpointer user_data)
+{
+  TabEntry *te;
+
+  te = data;
+  
+  g_free (te->title);
+  if (te->icon)
+    g_object_unref (G_OBJECT (te->icon));
+  if (te->dimmed_icon)
+    g_object_unref (G_OBJECT (te->dimmed_icon));
+
+  g_free (te);
+}
+
+void
+meta_ui_tab_popup_free (MetaTabPopup *popup)
+{
+  meta_verbose ("Destroying tab popup window\n");
+  
+  gtk_widget_destroy (popup->outline_window);
+  gtk_widget_destroy (popup->window);
+  
+  g_list_foreach (popup->entries, free_tab_entry, NULL);
+
+  g_list_free (popup->entries);
+  
+  g_free (popup);
+}
+
+void
+meta_ui_tab_popup_set_showing (MetaTabPopup *popup,
+                               gboolean      showing)
+{
+  if (showing)
+    {
+      gtk_widget_show_all (popup->window);
+    }
+  else
+    {
+      if (GTK_WIDGET_VISIBLE (popup->window))
+        {
+          meta_verbose ("Hiding tab popup window\n");
+          gtk_widget_hide (popup->window);
+          meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+        }
+    }
+}
+
+static void
+display_entry (MetaTabPopup *popup,
+               TabEntry     *te)
+{
+  GdkRectangle rect;
+  GdkRegion *region;
+  GdkRegion *inner_region;
+
+  
+  if (popup->current_selected_entry)
+  {
+    if (popup->outline)
+      unselect_image (popup->current_selected_entry->widget);
+    else
+      unselect_workspace (popup->current_selected_entry->widget);
+  }
+  
+  gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
+
+  if (popup->outline)
+    select_image (te->widget);
+  else
+    select_workspace (te->widget);
+
+  if (popup->outline)
+    {
+      /* Do stuff behind gtk's back */
+      gdk_window_hide (popup->outline_window->window);
+      meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  
+      rect = te->rect;
+      rect.x = 0;
+      rect.y = 0;
+
+      gdk_window_move_resize (popup->outline_window->window,
+                              te->rect.x, te->rect.y,
+                              te->rect.width, te->rect.height);
+  
+      gdk_window_set_background (popup->outline_window->window,
+                                 &popup->outline_window->style->black);
+  
+      region = gdk_region_rectangle (&rect);
+      inner_region = gdk_region_rectangle (&te->inner_rect);
+      gdk_region_subtract (region, inner_region);
+      gdk_region_destroy (inner_region);
+  
+      gdk_window_shape_combine_region (popup->outline_window->window,
+                                       region,
+                                       0, 0);
+
+      gdk_region_destroy (region);
+  
+      /* This should piss off gtk a bit, but we don't want to raise
+       * above the tab popup.  So, instead of calling gtk_widget_show,
+       * we manually set the window as mapped and then manually map it
+       * with gdk functions.
+       */
+      GTK_WIDGET_SET_FLAGS (popup->outline_window, GTK_MAPPED);
+      gdk_window_show_unraised (popup->outline_window->window);
+    }
+
+  /* Must be before we handle an expose for the outline window */
+  popup->current_selected_entry = te;
+}
+
+void
+meta_ui_tab_popup_forward (MetaTabPopup *popup)
+{
+  if (popup->current != NULL)
+    popup->current = popup->current->next;
+
+  if (popup->current == NULL)
+    popup->current = popup->entries;
+  
+  if (popup->current != NULL)
+    {
+      TabEntry *te;
+
+      te = popup->current->data;
+
+      display_entry (popup, te);
+    }
+}
+
+void
+meta_ui_tab_popup_backward (MetaTabPopup *popup)
+{
+  if (popup->current != NULL)
+    popup->current = popup->current->prev;
+
+  if (popup->current == NULL)
+    popup->current = g_list_last (popup->entries);
+  
+  if (popup->current != NULL)
+    {
+      TabEntry *te;
+
+      te = popup->current->data;
+
+      display_entry (popup, te);
+    }
+}
+
+MetaTabEntryKey
+meta_ui_tab_popup_get_selected (MetaTabPopup *popup)
+{
+  if (popup->current)
+    {
+      TabEntry *te;
+
+      te = popup->current->data;
+
+      return te->key;
+    }
+  else
+    return (MetaTabEntryKey)None;
+}
+
+void
+meta_ui_tab_popup_select (MetaTabPopup *popup,
+                          MetaTabEntryKey key)
+{
+  GList *tmp;
+
+  /* Note, "key" may not be in the list of entries; other code assumes
+   * it's OK to pass in a key that isn't.
+   */
+  
+  tmp = popup->entries;
+  while (tmp != NULL)
+    {
+      TabEntry *te;
+
+      te = tmp->data;
+
+      if (te->key == key)
+        {
+          popup->current = tmp;
+          
+          display_entry (popup, te);
+
+          return;
+        }
+      
+      tmp = tmp->next;
+    }
+}
+
+#define META_TYPE_SELECT_IMAGE            (meta_select_image_get_type ())
+#define META_SELECT_IMAGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SELECT_IMAGE, MetaSelectImage))
+
+typedef struct _MetaSelectImage       MetaSelectImage;
+typedef struct _MetaSelectImageClass  MetaSelectImageClass;
+
+struct _MetaSelectImage
+{
+  GtkImage parent_instance;
+  guint selected : 1;
+};
+
+struct _MetaSelectImageClass
+{
+  GtkImageClass parent_class;
+};
+
+
+static GType meta_select_image_get_type (void) G_GNUC_CONST;
+
+static GtkWidget*
+selectable_image_new (GdkPixbuf *pixbuf)
+{
+  GtkWidget *w;
+
+  w = g_object_new (meta_select_image_get_type (), NULL);
+  gtk_image_set_from_pixbuf (GTK_IMAGE (w), pixbuf); 
+
+  return w;
+}
+
+static void
+select_image (GtkWidget *widget)
+{
+  META_SELECT_IMAGE (widget)->selected = TRUE;
+  gtk_widget_queue_draw (widget);
+}
+
+static void
+unselect_image (GtkWidget *widget)
+{
+  META_SELECT_IMAGE (widget)->selected = FALSE;
+  gtk_widget_queue_draw (widget);
+}
+
+static void     meta_select_image_class_init   (MetaSelectImageClass *klass);
+static gboolean meta_select_image_expose_event (GtkWidget            *widget,
+                                                GdkEventExpose       *event);
+
+static GtkImageClass *parent_class;
+
+GType
+meta_select_image_get_type (void)
+{
+  static GType image_type = 0;
+
+  if (!image_type)
+    {
+      static const GTypeInfo image_info =
+      {
+        sizeof (MetaSelectImageClass),
+        NULL,           /* base_init */
+        NULL,           /* base_finalize */
+        (GClassInitFunc) meta_select_image_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (MetaSelectImage),
+        16,             /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+
+      image_type = g_type_register_static (GTK_TYPE_IMAGE, "MetaSelectImage", &image_info, 0);
+    }
+
+  return image_type;
+}
+
+static void
+meta_select_image_class_init (MetaSelectImageClass *klass)
+{
+  GtkWidgetClass *widget_class;
+  
+  parent_class = g_type_class_peek (gtk_image_get_type ());
+
+  widget_class = GTK_WIDGET_CLASS (klass);
+  
+  widget_class->expose_event = meta_select_image_expose_event;
+}
+
+static gboolean
+meta_select_image_expose_event (GtkWidget      *widget,
+                                GdkEventExpose *event)
+{
+  if (META_SELECT_IMAGE (widget)->selected)
+    {
+      int x, y, w, h;
+      GtkMisc *misc;
+      GtkStyle *style;
+      GtkStateType state;
+      cairo_t *cr;
+
+      misc = GTK_MISC (widget);
+      
+      x = (widget->allocation.x * (1.0 - misc->xalign) +
+           (widget->allocation.x + widget->allocation.width
+            - (widget->requisition.width - misc->xpad * 2)) *
+           misc->xalign) + 0.5;
+      y = (widget->allocation.y * (1.0 - misc->yalign) +
+           (widget->allocation.y + widget->allocation.height
+            - (widget->requisition.height - misc->ypad * 2)) *
+           misc->yalign) + 0.5;
+
+      x -= INSIDE_SELECT_RECT + 1;
+      y -= INSIDE_SELECT_RECT + 1;      
+      
+      w = widget->requisition.width - OUTSIDE_SELECT_RECT * 2 - 1;
+      h = widget->requisition.height - OUTSIDE_SELECT_RECT * 2 - 1;
+
+      style = gtk_widget_get_style (widget);
+      state = gtk_widget_get_state (widget);
+      cr = gdk_cairo_create (widget->window);
+
+      cairo_set_line_width (cr, 2.0);
+      gdk_cairo_set_source_color (cr, &style->fg[state]);
+
+      cairo_rectangle (cr, x, y, w + 1, h + 1);
+      cairo_stroke (cr);
+
+      cairo_set_line_width (cr, 1.0);
+#if 0
+      gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_SELECTED]);
+      cairo_rectangle (cr, x, y, w, h);
+      cairo_fill (cr);
+#endif
+
+#if 0      
+      gtk_paint_focus (widget->style, widget->window,
+                       &event->area, widget, "meta-tab-image",
+                       x, y, w, h);
+#endif
+
+      cairo_destroy (cr);
+    }
+
+  return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+}
+
+#define META_TYPE_SELECT_WORKSPACE   (meta_select_workspace_get_type ())
+#define META_SELECT_WORKSPACE(obj)   (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SELECT_WORKSPACE, MetaSelectWorkspace))
+
+typedef struct _MetaSelectWorkspace       MetaSelectWorkspace;
+typedef struct _MetaSelectWorkspaceClass  MetaSelectWorkspaceClass;
+
+struct _MetaSelectWorkspace
+{
+  GtkDrawingArea parent_instance;
+  MetaWorkspace *workspace;
+  guint selected : 1;
+};
+
+struct _MetaSelectWorkspaceClass
+{
+  GtkDrawingAreaClass parent_class;
+};
+
+
+static GType meta_select_workspace_get_type (void) G_GNUC_CONST;
+
+#define SELECT_OUTLINE_WIDTH 2
+#define MINI_WORKSPACE_WIDTH 48
+
+static GtkWidget*
+selectable_workspace_new (MetaWorkspace *workspace)
+{
+  GtkWidget *widget;
+  double screen_aspect;
+  
+  widget = g_object_new (meta_select_workspace_get_type (), NULL);
+
+  screen_aspect = (double) workspace->screen->rect.height /
+                  (double) workspace->screen->rect.width;
+  
+  /* account for select rect */ 
+  gtk_widget_set_size_request (widget,
+                               MINI_WORKSPACE_WIDTH + SELECT_OUTLINE_WIDTH * 2,
+                               MINI_WORKSPACE_WIDTH * screen_aspect + SELECT_OUTLINE_WIDTH * 2);
+
+  META_SELECT_WORKSPACE (widget)->workspace = workspace;
+
+  return widget;
+}
+
+static void
+select_workspace (GtkWidget *widget)
+{
+  META_SELECT_WORKSPACE(widget)->selected = TRUE;
+  gtk_widget_queue_draw (widget);
+}
+
+static void
+unselect_workspace (GtkWidget *widget)
+{
+  META_SELECT_WORKSPACE (widget)->selected = FALSE;
+  gtk_widget_queue_draw (widget);
+}
+
+static void meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass);
+
+static gboolean meta_select_workspace_expose_event (GtkWidget      *widget,
+                                                    GdkEventExpose *event);
+
+GType
+meta_select_workspace_get_type (void)
+{
+  static GType workspace_type = 0;
+
+  if (!workspace_type)
+    {
+      static const GTypeInfo workspace_info =
+      {
+        sizeof (MetaSelectWorkspaceClass),
+        NULL,           /* base_init */
+        NULL,           /* base_finalize */
+        (GClassInitFunc) meta_select_workspace_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (MetaSelectWorkspace),
+        16,             /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+
+      workspace_type = g_type_register_static (GTK_TYPE_DRAWING_AREA, 
+                                               "MetaSelectWorkspace", 
+                                               &workspace_info, 
+                                               0);
+    }
+
+  return workspace_type;
+}
+
+static void
+meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass)
+{
+  GtkWidgetClass *widget_class;
+  
+  widget_class = GTK_WIDGET_CLASS (klass);
+  
+  widget_class->expose_event = meta_select_workspace_expose_event;
+}
+
+/**
+ * meta_convert_meta_to_wnck() converts a MetaWindow to a
+ * WnckWindowDisplayInfo window that is used to build a thumbnail of a
+ * workspace.
+ **/
+static WnckWindowDisplayInfo
+meta_convert_meta_to_wnck (MetaWindow *window, MetaScreen *screen)
+{
+  WnckWindowDisplayInfo wnck_window;
+  wnck_window.icon = window->icon;
+  wnck_window.mini_icon = window->mini_icon;
+  
+  wnck_window.is_active = FALSE;
+  if (window == window->display->expected_focus_window)
+    wnck_window.is_active = TRUE;
+
+  if (window->frame)
+    {
+      wnck_window.x = window->frame->rect.x;
+      wnck_window.y = window->frame->rect.y;
+      wnck_window.width = window->frame->rect.width;
+      wnck_window.height = window->frame->rect.height;
+    }
+  else
+    {
+      wnck_window.x = window->rect.x;
+      wnck_window.y = window->rect.y;
+      wnck_window.width = window->rect.width;
+      wnck_window.height = window->rect.height;
+    }
+  return wnck_window;
+}
+
+
+static gboolean
+meta_select_workspace_expose_event (GtkWidget      *widget,
+                                    GdkEventExpose *event)
+{
+  MetaWorkspace *workspace;
+  WnckWindowDisplayInfo *windows;
+  GtkStyle *style;
+  cairo_t *cr;
+  int i, n_windows;
+  GList *tmp, *list;
+
+  workspace = META_SELECT_WORKSPACE (widget)->workspace;
+              
+  list = meta_stack_list_windows (workspace->screen->stack, workspace);
+  n_windows = g_list_length (list);
+  windows = g_new (WnckWindowDisplayInfo, n_windows);
+
+  tmp = list;
+  i = 0;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+      gboolean ignoreable_sticky;
+
+      window = tmp->data;
+
+      ignoreable_sticky = window->on_all_workspaces &&
+                          workspace != workspace->screen->active_workspace;
+
+      if (window->skip_pager || 
+          !meta_window_showing_on_its_workspace (window) ||
+          window->unmaps_pending ||
+          ignoreable_sticky)
+        {
+          --n_windows;
+        }
+      else
+        {
+          windows[i] = meta_convert_meta_to_wnck (window, workspace->screen);
+          i++;
+        }
+      tmp = tmp->next;
+    }
+
+  g_list_free (list);
+
+  wnck_draw_workspace (widget,
+                       widget->window,
+                       SELECT_OUTLINE_WIDTH,
+                       SELECT_OUTLINE_WIDTH,
+                       widget->allocation.width - SELECT_OUTLINE_WIDTH * 2,
+                       widget->allocation.height - SELECT_OUTLINE_WIDTH * 2,
+                       workspace->screen->rect.width,
+                       workspace->screen->rect.height,
+                       NULL,
+                       (workspace->screen->active_workspace == workspace),
+                       windows,
+                       n_windows);
+
+  g_free (windows);
+  
+  if (META_SELECT_WORKSPACE (widget)->selected)
+    {
+      style = gtk_widget_get_style (widget);
+      cr = gdk_cairo_create (widget->window);
+
+      gdk_cairo_set_source_color (cr,
+                                  &style->fg[gtk_widget_get_state (widget)]);
+      cairo_set_line_width (cr, SELECT_OUTLINE_WIDTH);
+
+      cairo_rectangle (cr,
+                       SELECT_OUTLINE_WIDTH / 2.0, SELECT_OUTLINE_WIDTH / 2.0,
+                       widget->allocation.width - SELECT_OUTLINE_WIDTH,
+                       widget->allocation.height - SELECT_OUTLINE_WIDTH);
+      cairo_stroke (cr);
+
+      cairo_destroy (cr);
+    }
+
+  return TRUE;
+}
+
diff --git a/src/ui/testgradient.c b/src/ui/testgradient.c
new file mode 100644
index 00000000..fd1b09c7
--- /dev/null
+++ b/src/ui/testgradient.c
@@ -0,0 +1,336 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco gradient test program */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  */
+
+#include "gradient.h"
+#include <gtk/gtk.h>
+
+typedef void (* RenderGradientFunc) (GdkDrawable *drawable,
+                                     cairo_t     *cr,
+                                     int          width,
+                                     int          height);
+
+static void
+draw_checkerboard (GdkDrawable *drawable,
+                   int          width,
+                   int          height)
+{
+  gint i, j, xcount, ycount;
+  GdkColor color1, color2;
+  cairo_t *cr;
+  
+#define CHECK_SIZE 10
+#define SPACING 2  
+  
+  color1.red = 30000;
+  color1.green = 30000;
+  color1.blue = 30000;
+
+  color2.red = 50000;
+  color2.green = 50000;
+  color2.blue = 50000;
+
+  cr = gdk_cairo_create (drawable);
+
+  xcount = 0;
+  i = SPACING;
+  while (i < width)
+    {
+      j = SPACING;
+      ycount = xcount % 2; /* start with even/odd depending on row */
+      while (j < height)
+	{
+	  if (ycount % 2)
+	    gdk_cairo_set_source_color (cr, &color1);
+	  else
+	    gdk_cairo_set_source_color (cr, &color2);
+
+	  /* If we're outside event->area, this will do nothing.
+	   * It might be mildly more efficient if we handled
+	   * the clipping ourselves, but again we're feeling lazy.
+	   */
+          cairo_rectangle (cr, i, j, CHECK_SIZE, CHECK_SIZE);
+          cairo_fill (cr);
+
+	  j += CHECK_SIZE + SPACING;
+	  ++ycount;
+	}
+
+      i += CHECK_SIZE + SPACING;
+      ++xcount;
+    }
+  
+  cairo_destroy (cr);
+}
+
+static void
+render_simple (GdkDrawable *drawable,
+               cairo_t     *cr,
+               int width, int height,
+               MetaGradientType type,
+               gboolean    with_alpha)
+{
+  GdkPixbuf *pixbuf;
+  GdkColor from, to;
+  
+  gdk_color_parse ("blue", &from);
+  gdk_color_parse ("green", &to);
+
+  pixbuf = meta_gradient_create_simple (width, height,
+                                        &from, &to,
+                                        type);
+
+  if (with_alpha)
+    {
+      const unsigned char alphas[] = { 0xff, 0xaa, 0x2f, 0x0, 0xcc, 0xff, 0xff };
+      
+      if (!gdk_pixbuf_get_has_alpha (pixbuf))
+        {
+          GdkPixbuf *new_pixbuf;
+          
+          new_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+          g_object_unref (G_OBJECT (pixbuf));
+          pixbuf = new_pixbuf;
+        }
+      
+      meta_gradient_add_alpha (pixbuf,
+                               alphas, G_N_ELEMENTS (alphas),
+                               META_GRADIENT_HORIZONTAL);
+      
+      draw_checkerboard (drawable, width, height);
+    }
+    
+  gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+  cairo_rectangle (cr, 0, 0, width, height);
+  cairo_fill (cr);
+
+  g_object_unref (G_OBJECT (pixbuf));
+}
+
+static void
+render_vertical_func (GdkDrawable *drawable,
+                      cairo_t *cr,
+                      int width, int height)
+{
+  render_simple (drawable, cr, width, height, META_GRADIENT_VERTICAL, FALSE);
+}
+
+static void
+render_horizontal_func (GdkDrawable *drawable,
+                        cairo_t *cr,
+                        int width, int height)
+{
+  render_simple (drawable, cr, width, height, META_GRADIENT_HORIZONTAL, FALSE);
+}
+
+static void
+render_diagonal_func (GdkDrawable *drawable,
+                      cairo_t *cr,
+                      int width, int height)
+{
+  render_simple (drawable, cr, width, height, META_GRADIENT_DIAGONAL, FALSE);
+}
+
+static void
+render_diagonal_alpha_func (GdkDrawable *drawable,
+                            cairo_t *cr,
+                            int width, int height)
+{
+  render_simple (drawable, cr, width, height, META_GRADIENT_DIAGONAL, TRUE);
+}
+
+static void
+render_multi (GdkDrawable *drawable,
+              cairo_t     *cr,
+              int width, int height,
+              MetaGradientType type)
+{
+  GdkPixbuf *pixbuf;
+#define N_COLORS 5
+  GdkColor colors[N_COLORS];
+
+  gdk_color_parse ("red", &colors[0]);
+  gdk_color_parse ("blue", &colors[1]);
+  gdk_color_parse ("orange", &colors[2]);
+  gdk_color_parse ("pink", &colors[3]);
+  gdk_color_parse ("green", &colors[4]);
+
+  pixbuf = meta_gradient_create_multi (width, height,
+                                       colors, N_COLORS,
+                                       type);
+
+  gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+  cairo_rectangle (cr, 0, 0, width, height);
+  cairo_fill (cr);
+
+  g_object_unref (G_OBJECT (pixbuf));
+#undef N_COLORS
+}
+
+static void
+render_vertical_multi_func (GdkDrawable *drawable,
+                            cairo_t *cr,
+                            int width, int height)
+{
+  render_multi (drawable, cr, width, height, META_GRADIENT_VERTICAL);
+}
+
+static void
+render_horizontal_multi_func (GdkDrawable *drawable,
+                              cairo_t *cr,
+                              int width, int height)
+{
+  render_multi (drawable, cr, width, height, META_GRADIENT_HORIZONTAL);
+}
+
+static void
+render_diagonal_multi_func (GdkDrawable *drawable,
+                            cairo_t *cr,
+                            int width, int height)
+{
+  render_multi (drawable, cr, width, height, META_GRADIENT_DIAGONAL);
+}
+
+static void
+render_interwoven_func (GdkDrawable *drawable,
+                        cairo_t     *cr,
+                        int width, int height)
+{
+  GdkPixbuf *pixbuf;
+#define N_COLORS 4
+  GdkColor colors[N_COLORS];
+
+  gdk_color_parse ("red", &colors[0]);
+  gdk_color_parse ("blue", &colors[1]);
+  gdk_color_parse ("pink", &colors[2]);
+  gdk_color_parse ("green", &colors[3]);
+
+  pixbuf = meta_gradient_create_interwoven (width, height,
+                                            colors, height / 10,
+                                            colors + 2, height / 14);
+
+  gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+  cairo_rectangle (cr, 0, 0, width, height);
+  cairo_fill (cr);
+
+  g_object_unref (G_OBJECT (pixbuf));
+}
+
+static gboolean
+expose_callback (GtkWidget *widget,
+                 GdkEventExpose *event,
+                 gpointer data)
+{
+  RenderGradientFunc func = data;
+  GdkWindow *window;
+  GtkAllocation allocation;
+  GtkStyle *style;
+  cairo_t *cr;
+
+  style = gtk_widget_get_style (widget);
+  gtk_widget_get_allocation (widget, &allocation);
+
+  window = gtk_widget_get_window (widget);
+  cr = gdk_cairo_create (window);
+  gdk_cairo_set_source_color (cr, &style->fg[gtk_widget_get_state (widget)]);
+
+  (* func) (window,
+            cr,
+            allocation.width,
+            allocation.height);
+
+  cairo_destroy (cr);
+
+  return TRUE;
+}
+
+static GtkWidget*
+create_gradient_window (const char *title,
+                        RenderGradientFunc func)
+{
+  GtkWidget *window;
+  GtkWidget *drawing_area;
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+  gtk_window_set_title (GTK_WINDOW (window), title);
+  
+  drawing_area = gtk_drawing_area_new ();
+
+  gtk_widget_set_size_request (drawing_area, 1, 1);
+
+  gtk_window_set_default_size (GTK_WINDOW (window), 175, 175);
+  
+  g_signal_connect (G_OBJECT (drawing_area),
+                    "expose_event",
+                    G_CALLBACK (expose_callback),
+                    func);
+
+  gtk_container_add (GTK_CONTAINER (window), drawing_area);
+
+  gtk_widget_show_all (window);
+  
+  return window;
+}
+
+static void
+meta_gradient_test (void)
+{
+  GtkWidget *window;
+
+  window = create_gradient_window ("Simple vertical",
+                                   render_vertical_func);
+  
+  window = create_gradient_window ("Simple horizontal",
+                                   render_horizontal_func);
+
+  window = create_gradient_window ("Simple diagonal",
+                                   render_diagonal_func);
+
+  window = create_gradient_window ("Multi vertical",
+                                   render_vertical_multi_func);
+  
+  window = create_gradient_window ("Multi horizontal",
+                                   render_horizontal_multi_func);
+
+  window = create_gradient_window ("Multi diagonal",
+                                   render_diagonal_multi_func);
+
+  window = create_gradient_window ("Interwoven",
+                                   render_interwoven_func);
+
+  window = create_gradient_window ("Simple diagonal with horizontal multi alpha",
+                                   render_diagonal_alpha_func);
+
+}
+
+int
+main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+
+  meta_gradient_test ();
+
+  gtk_main ();
+
+  return 0;
+}
+
diff --git a/src/ui/theme-parser.c b/src/ui/theme-parser.c
new file mode 100644
index 00000000..12f01061
--- /dev/null
+++ b/src/ui/theme-parser.c
@@ -0,0 +1,4212 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme parsing */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "theme-parser.h"
+#include "util.h"
+#include <string.h>
+#include <stdlib.h>
+
+/* This is a hack for Ubuntu's metacity themes
+ * Its safe for unable or not.
+ * I am using this define to know what code was added */
+#define USE_UBUNTU_CODE 1
+
+typedef enum
+{
+  STATE_START,
+  STATE_THEME,
+  /* info section */
+  STATE_INFO,
+  STATE_NAME,
+  STATE_AUTHOR,
+  STATE_COPYRIGHT,
+  STATE_DATE,
+  STATE_DESCRIPTION,
+  /* constants */
+  STATE_CONSTANT,
+  /* geometry */
+  STATE_FRAME_GEOMETRY,
+  STATE_DISTANCE,
+  STATE_BORDER,
+  STATE_ASPECT_RATIO,
+  /* draw ops */
+  STATE_DRAW_OPS,
+  STATE_LINE,
+  STATE_RECTANGLE,
+  STATE_ARC,
+  STATE_CLIP,
+  STATE_TINT,
+  STATE_GRADIENT,
+  STATE_IMAGE,
+  STATE_GTK_ARROW,
+  STATE_GTK_BOX,
+  STATE_GTK_VLINE,
+  STATE_ICON,
+  STATE_TITLE,
+  STATE_INCLUDE, /* include another draw op list */
+  STATE_TILE,    /* tile another draw op list */
+  /* sub-parts of gradient */
+  STATE_COLOR,
+  /* frame style */
+  STATE_FRAME_STYLE,
+  STATE_PIECE,
+  STATE_BUTTON,
+#ifdef USE_UBUNTU_CODE
+  STATE_SHADOW,
+  STATE_PADDING,
+#endif
+  /* style set */
+  STATE_FRAME_STYLE_SET,
+  STATE_FRAME,
+  /* assigning style sets to windows */
+  STATE_WINDOW,
+  /* things we don't use any more but we can still parse: */
+  STATE_MENU_ICON,
+  STATE_FALLBACK
+} ParseState;
+
+typedef struct
+{
+  GSList *states;
+
+  const char *theme_name;       /* name of theme (directory it's in) */
+  char *theme_file;             /* theme filename */
+  char *theme_dir;              /* dir the theme is inside */
+  MetaTheme *theme;             /* theme being parsed */
+  guint format_version;         /* version of format of theme file */
+  char *name;                   /* name of named thing being parsed */
+  MetaFrameLayout *layout;      /* layout being parsed if any */
+  MetaDrawOpList *op_list;      /* op list being parsed if any */
+  MetaDrawOp *op;               /* op being parsed if any */
+  MetaFrameStyle *style;        /* frame style being parsed if any */
+  MetaFrameStyleSet *style_set; /* frame style set being parsed if any */
+  MetaFramePiece piece;         /* position of piece being parsed */
+  MetaButtonType button_type;   /* type of button/menuitem being parsed */
+  MetaButtonState button_state; /* state of button being parsed */
+} ParseInfo;
+
+static void set_error (GError             **err,
+                       GMarkupParseContext *context,
+                       int                  error_domain,
+                       int                  error_code,
+                       const char          *format,
+                       ...) G_GNUC_PRINTF (5, 6);
+
+static void add_context_to_error (GError             **err,
+                                  GMarkupParseContext *context);
+
+static void       parse_info_init (ParseInfo *info);
+static void       parse_info_free (ParseInfo *info);
+
+static void       push_state (ParseInfo  *info,
+                              ParseState  state);
+static void       pop_state  (ParseInfo  *info);
+static ParseState peek_state (ParseInfo  *info);
+
+
+static void parse_toplevel_element  (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+static void parse_info_element      (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+static void parse_geometry_element  (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+static void parse_draw_op_element   (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+static void parse_gradient_element  (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+static void parse_style_element     (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+static void parse_style_set_element (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+
+static void parse_piece_element     (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+
+static void parse_button_element    (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+
+#ifdef USE_UBUNTU_CODE
+static void parse_shadow_element    (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+
+static void parse_padding_element    (GMarkupParseContext  *context,
+                                      const gchar          *element_name,
+                                      const gchar         **attribute_names,
+                                      const gchar         **attribute_values,
+                                      ParseInfo            *info,
+                                      GError              **error);
+#endif
+static void parse_menu_icon_element (GMarkupParseContext  *context,
+                                     const gchar          *element_name,
+                                     const gchar         **attribute_names,
+                                     const gchar         **attribute_values,
+                                     ParseInfo            *info,
+                                     GError              **error);
+
+static void start_element_handler (GMarkupParseContext  *context,
+                                   const gchar          *element_name,
+                                   const gchar         **attribute_names,
+                                   const gchar         **attribute_values,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void end_element_handler   (GMarkupParseContext  *context,
+                                   const gchar          *element_name,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void text_handler          (GMarkupParseContext  *context,
+                                   const gchar          *text,
+                                   gsize                 text_len,
+                                   gpointer              user_data,
+                                   GError              **error);
+
+/* Translators: This means that an attribute which should have been found
+ * on an XML element was not in fact found.
+ */
+#define ATTRIBUTE_NOT_FOUND _("No \"%s\" attribute on element <%s>")
+
+static GMarkupParser marco_theme_parser = {
+  start_element_handler,
+  end_element_handler,
+  text_handler,
+  NULL,
+  NULL
+};
+
+static void
+set_error (GError             **err,
+           GMarkupParseContext *context,
+           int                  error_domain,
+           int                  error_code,
+           const char          *format,
+           ...)
+{
+  int line, ch;
+  va_list args;
+  char *str;
+
+  g_markup_parse_context_get_position (context, &line, &ch);
+
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  g_set_error (err, error_domain, error_code,
+               _("Line %d character %d: %s"),
+               line, ch, str);
+
+  g_free (str);
+}
+
+static void
+add_context_to_error (GError             **err,
+                      GMarkupParseContext *context)
+{
+  int line, ch;
+  char *str;
+
+  if (err == NULL || *err == NULL)
+    return;
+
+  g_markup_parse_context_get_position (context, &line, &ch);
+
+  str = g_strdup_printf (_("Line %d character %d: %s"),
+                         line, ch, (*err)->message);
+  g_free ((*err)->message);
+  (*err)->message = str;
+}
+
+static void
+parse_info_init (ParseInfo *info)
+{
+  info->theme_file = NULL;
+  info->states = g_slist_prepend (NULL, GINT_TO_POINTER (STATE_START));
+  info->theme = NULL;
+  info->name = NULL;
+  info->layout = NULL;
+  info->op_list = NULL;
+  info->op = NULL;
+  info->style = NULL;
+  info->style_set = NULL;
+  info->piece = META_FRAME_PIECE_LAST;
+  info->button_type = META_BUTTON_TYPE_LAST;
+  info->button_state = META_BUTTON_STATE_LAST;
+}
+
+static void
+parse_info_free (ParseInfo *info)
+{
+  g_free (info->theme_file);
+  g_free (info->theme_dir);
+
+  g_slist_free (info->states);
+
+  if (info->theme)
+    meta_theme_free (info->theme);
+
+  if (info->layout)
+    meta_frame_layout_unref (info->layout);
+
+  if (info->op_list)
+    meta_draw_op_list_unref (info->op_list);
+
+  if (info->op)
+    meta_draw_op_free (info->op);
+
+  if (info->style)
+    meta_frame_style_unref (info->style);
+
+  if (info->style_set)
+    meta_frame_style_set_unref (info->style_set);
+}
+
+static void
+push_state (ParseInfo  *info,
+            ParseState  state)
+{
+  info->states = g_slist_prepend (info->states, GINT_TO_POINTER (state));
+}
+
+static void
+pop_state (ParseInfo *info)
+{
+  g_return_if_fail (info->states != NULL);
+
+  info->states = g_slist_remove (info->states, info->states->data);
+}
+
+static ParseState
+peek_state (ParseInfo *info)
+{
+  g_return_val_if_fail (info->states != NULL, STATE_START);
+
+  return GPOINTER_TO_INT (info->states->data);
+}
+
+#define ELEMENT_IS(name) (strcmp (element_name, (name)) == 0)
+
+typedef struct
+{
+  const char  *name;
+  const char **retloc;
+  gboolean required;
+} LocateAttr;
+
+/* Attribute names can have a leading '!' to indicate that they are
+ * required.
+ */
+static gboolean
+locate_attributes (GMarkupParseContext *context,
+                   const char  *element_name,
+                   const char **attribute_names,
+                   const char **attribute_values,
+                   GError     **error,
+                   const char  *first_attribute_name,
+                   const char **first_attribute_retloc,
+                   ...)
+{
+  va_list args;
+  const char *name;
+  const char **retloc;
+  int n_attrs;
+#define MAX_ATTRS 24
+  LocateAttr attrs[MAX_ATTRS];
+  gboolean retval;
+  int i;
+
+  g_return_val_if_fail (first_attribute_name != NULL, FALSE);
+  g_return_val_if_fail (first_attribute_retloc != NULL, FALSE);
+
+  retval = TRUE;
+
+  /* FIXME: duplicated code; refactor loop */
+  n_attrs = 1;
+  attrs[0].name = first_attribute_name;
+  attrs[0].retloc = first_attribute_retloc;
+  attrs[0].required = attrs[0].name[0]=='!';
+  if (attrs[0].required)
+    attrs[0].name++; /* skip past it */
+  *first_attribute_retloc = NULL;
+
+  va_start (args, first_attribute_retloc);
+
+  name = va_arg (args, const char*);
+  retloc = va_arg (args, const char**);
+
+  while (name != NULL)
+    {
+      g_return_val_if_fail (retloc != NULL, FALSE);
+
+      g_assert (n_attrs < MAX_ATTRS);
+
+      attrs[n_attrs].name = name;
+      attrs[n_attrs].retloc = retloc;
+      attrs[n_attrs].required = attrs[n_attrs].name[0]=='!';
+      if (attrs[n_attrs].required)
+        attrs[n_attrs].name++; /* skip past it */
+
+      n_attrs += 1;
+      *retloc = NULL;
+
+      name = va_arg (args, const char*);
+      retloc = va_arg (args, const char**);
+    }
+
+  va_end (args);
+
+  i = 0;
+  while (attribute_names[i])
+    {
+      int j;
+      gboolean found;
+
+      found = FALSE;
+      j = 0;
+      while (j < n_attrs)
+        {
+          if (strcmp (attrs[j].name, attribute_names[i]) == 0)
+            {
+              retloc = attrs[j].retloc;
+
+              if (*retloc != NULL)
+                {
+
+                  set_error (error, context,
+                             G_MARKUP_ERROR,
+                             G_MARKUP_ERROR_PARSE,
+                             _("Attribute \"%s\" repeated twice on the same <%s> element"),
+                             attrs[j].name, element_name);
+                  retval = FALSE;
+                  goto out;
+                }
+
+              *retloc = attribute_values[i];
+              found = TRUE;
+            }
+
+          ++j;
+        }
+
+      if (!found)
+        {
+      j = 0;
+      while (j < n_attrs)
+        {
+          g_warning ("It could have been %s.\n", attrs[j++].name);
+        }
+
+          set_error (error, context,
+                     G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Attribute \"%s\" is invalid on <%s> element in this context"),
+                     attribute_names[i], element_name);
+          retval = FALSE;
+          goto out;
+        }
+
+      ++i;
+    }
+
+    /* Did we catch them all? */
+    i = 0;
+    while (i < n_attrs)
+      {
+        if (attrs[i].required && *(attrs[i].retloc)==NULL)
+          {
+            set_error (error, context,
+                       G_MARKUP_ERROR,
+                       G_MARKUP_ERROR_PARSE,
+                       ATTRIBUTE_NOT_FOUND,
+                       attrs[i].name, element_name);
+            retval = FALSE;
+            goto out;
+          }
+
+        ++i;
+      }
+
+ out:
+  return retval;
+}
+
+static gboolean
+check_no_attributes (GMarkupParseContext *context,
+                     const char  *element_name,
+                     const char **attribute_names,
+                     const char **attribute_values,
+                     GError     **error)
+{
+  if (attribute_names[0] != NULL)
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR,
+                 G_MARKUP_ERROR_PARSE,
+                 _("Attribute \"%s\" is invalid on <%s> element in this context"),
+                 attribute_names[0], element_name);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+#define MAX_REASONABLE 4096
+static gboolean
+parse_positive_integer (const char          *str,
+                        int                 *val,
+                        GMarkupParseContext *context,
+                        MetaTheme           *theme,
+                        GError             **error)
+{
+  char *end;
+  long l;
+  int j;
+
+  *val = 0;
+
+  end = NULL;
+
+  /* Is str a constant? */
+
+  if (META_THEME_ALLOWS (theme, META_THEME_UBIQUITOUS_CONSTANTS) &&
+      meta_theme_lookup_int_constant (theme, str, &j))
+    {
+      /* Yes. */
+      l = j;
+    }
+  else
+    {
+      /* No. Let's try parsing it instead. */
+
+      l = strtol (str, &end, 10);
+
+      if (end == NULL || end == str)
+      {
+        set_error (error, context, G_MARKUP_ERROR,
+                   G_MARKUP_ERROR_PARSE,
+                   _("Could not parse \"%s\" as an integer"),
+                   str);
+        return FALSE;
+      }
+
+    if (*end != '\0')
+      {
+        set_error (error, context, G_MARKUP_ERROR,
+                   G_MARKUP_ERROR_PARSE,
+                   _("Did not understand trailing characters \"%s\" in string \"%s\""),
+                   end, str);
+        return FALSE;
+      }
+    }
+
+  if (l < 0)
+    {
+      set_error (error, context, G_MARKUP_ERROR,
+                 G_MARKUP_ERROR_PARSE,
+                 _("Integer %ld must be positive"), l);
+      return FALSE;
+    }
+
+  if (l > MAX_REASONABLE)
+    {
+      set_error (error, context, G_MARKUP_ERROR,
+                 G_MARKUP_ERROR_PARSE,
+                 _("Integer %ld is too large, current max is %d"),
+                 l, MAX_REASONABLE);
+      return FALSE;
+    }
+
+  *val = (int) l;
+
+  return TRUE;
+}
+
+static gboolean
+parse_double (const char          *str,
+              double              *val,
+              GMarkupParseContext *context,
+              GError             **error)
+{
+  char *end;
+
+  *val = 0;
+
+  end = NULL;
+
+  *val = g_ascii_strtod (str, &end);
+
+  if (end == NULL || end == str)
+    {
+      set_error (error, context, G_MARKUP_ERROR,
+                 G_MARKUP_ERROR_PARSE,
+                 _("Could not parse \"%s\" as a floating point number"),
+                 str);
+      return FALSE;
+    }
+
+  if (*end != '\0')
+    {
+      set_error (error, context, G_MARKUP_ERROR,
+                 G_MARKUP_ERROR_PARSE,
+                 _("Did not understand trailing characters \"%s\" in string \"%s\""),
+                 end, str);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+parse_boolean (const char          *str,
+               gboolean            *val,
+               GMarkupParseContext *context,
+               GError             **error)
+{
+  if (strcmp ("true", str) == 0)
+    *val = TRUE;
+  else if (strcmp ("false", str) == 0)
+    *val = FALSE;
+  else
+    {
+      set_error (error, context, G_MARKUP_ERROR,
+                 G_MARKUP_ERROR_PARSE,
+                 _("Boolean values must be \"true\" or \"false\" not \"%s\""),
+                 str);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+parse_rounding (const char          *str,
+                guint               *val,
+                GMarkupParseContext *context,
+                MetaTheme           *theme,
+                GError             **error)
+{
+  if (strcmp ("true", str) == 0)
+    *val = 5; /* historical "true" value */
+  else if (strcmp ("false", str) == 0)
+    *val = 0;
+  else
+    {
+      int tmp;
+      gboolean result;
+       if (!META_THEME_ALLOWS (theme, META_THEME_VARIED_ROUND_CORNERS))
+         {
+           /* Not known in this version, so bail. */
+           set_error (error, context, G_MARKUP_ERROR,
+                      G_MARKUP_ERROR_PARSE,
+                      _("Boolean values must be \"true\" or \"false\" not \"%s\""),
+                      str);
+           return FALSE;
+         }
+
+      result = parse_positive_integer (str, &tmp, context, theme, error);
+
+      *val = tmp;
+
+      return result;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+parse_angle (const char          *str,
+             double              *val,
+             GMarkupParseContext *context,
+             GError             **error)
+{
+  if (!parse_double (str, val, context, error))
+    return FALSE;
+
+  if (*val < (0.0 - 1e6) || *val > (360.0 + 1e6))
+    {
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Angle must be between 0.0 and 360.0, was %g\n"),
+                 *val);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+parse_alpha (const char             *str,
+             MetaAlphaGradientSpec **spec_ret,
+             GMarkupParseContext    *context,
+             GError                **error)
+{
+  char **split;
+  int i;
+  int n_alphas;
+  MetaAlphaGradientSpec *spec;
+
+  *spec_ret = NULL;
+
+  split = g_strsplit (str, ":", -1);
+
+  i = 0;
+  while (split[i])
+    ++i;
+
+  if (i == 0)
+    {
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Could not parse \"%s\" as a floating point number"),
+                 str);
+
+      g_strfreev (split);
+
+      return FALSE;
+    }
+
+  n_alphas = i;
+
+  /* FIXME allow specifying horizontal/vertical/diagonal in theme format,
+   * once we implement vertical/diagonal in gradient.c
+   */
+  spec = meta_alpha_gradient_spec_new (META_GRADIENT_HORIZONTAL,
+                                       n_alphas);
+
+  i = 0;
+  while (i < n_alphas)
+    {
+      double v;
+
+      if (!parse_double (split[i], &v, context, error))
+        {
+          /* clear up, but don't set error: it was set by parse_double */
+          g_strfreev (split);
+          meta_alpha_gradient_spec_free (spec);
+
+          return FALSE;
+        }
+
+      if (v < (0.0 - 1e-6) || v > (1.0 + 1e-6))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Alpha must be between 0.0 (invisible) and 1.0 (fully opaque), was %g\n"),
+                     v);
+
+          g_strfreev (split);
+          meta_alpha_gradient_spec_free (spec);
+
+          return FALSE;
+        }
+
+      spec->alphas[i] = (unsigned char) (v * 255);
+
+      ++i;
+    }
+
+  g_strfreev (split);
+
+  *spec_ret = spec;
+
+  return TRUE;
+}
+
+static MetaColorSpec*
+parse_color (MetaTheme *theme,
+             const char        *str,
+             GError           **err)
+{
+  char* referent;
+
+  if (META_THEME_ALLOWS (theme, META_THEME_COLOR_CONSTANTS) &&
+      meta_theme_lookup_color_constant (theme, str, &referent))
+    {
+      if (referent)
+        return meta_color_spec_new_from_string (referent, err);
+
+      /* no need to free referent: it's a pointer into the actual hash table */
+    }
+
+  return meta_color_spec_new_from_string (str, err);
+}
+
+static gboolean
+parse_title_scale (const char          *str,
+                   double              *val,
+                   GMarkupParseContext *context,
+                   GError             **error)
+{
+  double factor;
+
+  if (strcmp (str, "xx-small") == 0)
+    factor = PANGO_SCALE_XX_SMALL;
+  else if (strcmp (str, "x-small") == 0)
+    factor = PANGO_SCALE_X_SMALL;
+  else if (strcmp (str, "small") == 0)
+    factor = PANGO_SCALE_SMALL;
+  else if (strcmp (str, "medium") == 0)
+    factor = PANGO_SCALE_MEDIUM;
+  else if (strcmp (str, "large") == 0)
+    factor = PANGO_SCALE_LARGE;
+  else if (strcmp (str, "x-large") == 0)
+    factor = PANGO_SCALE_X_LARGE;
+  else if (strcmp (str, "xx-large") == 0)
+    factor = PANGO_SCALE_XX_LARGE;
+  else
+    {
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Invalid title scale \"%s\" (must be one of xx-small,x-small,small,medium,large,x-large,xx-large)\n"),
+                 str);
+      return FALSE;
+    }
+
+  *val = factor;
+
+  return TRUE;
+}
+
+static void
+parse_toplevel_element (GMarkupParseContext  *context,
+                        const gchar          *element_name,
+                        const gchar         **attribute_names,
+                        const gchar         **attribute_values,
+                        ParseInfo            *info,
+                        GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_THEME);
+
+  if (ELEMENT_IS ("info"))
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      push_state (info, STATE_INFO);
+    }
+  else if (ELEMENT_IS ("constant"))
+    {
+      const char *name;
+      const char *value;
+      int ival = 0;
+      double dval = 0.0;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!name", &name, "!value", &value,
+                              NULL))
+        return;
+
+      /* We don't know how a a constant is going to be used, so we have guess its
+       * type from its contents:
+       *
+       *  - Starts like a number and contains a '.': float constant
+       *  - Starts like a number and doesn't contain a '.': int constant
+       *  - Starts with anything else: a color constant.
+       *    (colors always start with # or a letter)
+       */
+      if (value[0] == '.' || value[0] == '+' || value[0] == '-' || (value[0] >= '0' && value[0] <= '9'))
+        {
+          if (strchr (value, '.'))
+            {
+              if (!parse_double (value, &dval, context, error))
+                return;
+
+              if (!meta_theme_define_float_constant (info->theme,
+                                                     name,
+                                                     dval,
+                                                     error))
+                {
+                  add_context_to_error (error, context);
+                  return;
+                }
+            }
+          else
+            {
+              if (!parse_positive_integer (value, &ival, context, info->theme, error))
+                return;
+
+              if (!meta_theme_define_int_constant (info->theme,
+                                                   name,
+                                                   ival,
+                                                   error))
+                {
+                  add_context_to_error (error, context);
+                  return;
+                }
+            }
+        }
+      else
+        {
+          if (!meta_theme_define_color_constant (info->theme,
+                                                 name,
+                                                 value,
+                                                 error))
+            {
+              add_context_to_error (error, context);
+              return;
+            }
+        }
+
+      push_state (info, STATE_CONSTANT);
+    }
+  else if (ELEMENT_IS ("frame_geometry"))
+    {
+      const char *name = NULL;
+      const char *parent = NULL;
+      const char *has_title = NULL;
+      const char *title_scale = NULL;
+      const char *rounded_top_left = NULL;
+      const char *rounded_top_right = NULL;
+      const char *rounded_bottom_left = NULL;
+      const char *rounded_bottom_right = NULL;
+      const char *hide_buttons = NULL;
+      gboolean has_title_val;
+      guint rounded_top_left_val;
+      guint rounded_top_right_val;
+      guint rounded_bottom_left_val;
+      guint rounded_bottom_right_val;
+      gboolean hide_buttons_val;
+      double title_scale_val;
+      MetaFrameLayout *parent_layout;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!name", &name, "parent", &parent,
+                              "has_title", &has_title, "title_scale", &title_scale,
+                              "rounded_top_left", &rounded_top_left,
+                              "rounded_top_right", &rounded_top_right,
+                              "rounded_bottom_left", &rounded_bottom_left,
+                              "rounded_bottom_right", &rounded_bottom_right,
+                              "hide_buttons", &hide_buttons,
+                              NULL))
+        return;
+
+      has_title_val = TRUE;
+      if (has_title && !parse_boolean (has_title, &has_title_val, context, error))
+        return;
+
+      hide_buttons_val = FALSE;
+      if (hide_buttons && !parse_boolean (hide_buttons, &hide_buttons_val, context, error))
+        return;
+
+      rounded_top_left_val = 0;
+      rounded_top_right_val = 0;
+      rounded_bottom_left_val = 0;
+      rounded_bottom_right_val = 0;
+
+      if (rounded_top_left && !parse_rounding (rounded_top_left, &rounded_top_left_val, context, info->theme, error))
+        return;
+      if (rounded_top_right && !parse_rounding (rounded_top_right, &rounded_top_right_val, context, info->theme, error))
+        return;
+      if (rounded_bottom_left && !parse_rounding (rounded_bottom_left, &rounded_bottom_left_val, context, info->theme, error))
+        return;
+      if (rounded_bottom_right && !parse_rounding (rounded_bottom_right, &rounded_bottom_right_val, context, info->theme, error))
+        return;
+
+      title_scale_val = 1.0;
+      if (title_scale && !parse_title_scale (title_scale, &title_scale_val, context, error))
+        return;
+
+      if (meta_theme_lookup_layout (info->theme, name))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("<%s> name \"%s\" used a second time"),
+                     element_name, name);
+          return;
+        }
+
+      parent_layout = NULL;
+      if (parent)
+        {
+          parent_layout = meta_theme_lookup_layout (info->theme, parent);
+          if (parent_layout == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("<%s> parent \"%s\" has not been defined"),
+                         element_name, parent);
+              return;
+            }
+        }
+
+      g_assert (info->layout == NULL);
+
+      if (parent_layout)
+        info->layout = meta_frame_layout_copy (parent_layout);
+      else
+        info->layout = meta_frame_layout_new ();
+
+      if (has_title) /* only if explicit, otherwise inherit */
+        info->layout->has_title = has_title_val;
+
+      if (META_THEME_ALLOWS (info->theme, META_THEME_HIDDEN_BUTTONS) && hide_buttons_val)
+          info->layout->hide_buttons = hide_buttons_val;
+
+      if (title_scale)
+	info->layout->title_scale = title_scale_val;
+
+      if (rounded_top_left)
+        info->layout->top_left_corner_rounded_radius = rounded_top_left_val;
+
+      if (rounded_top_right)
+        info->layout->top_right_corner_rounded_radius = rounded_top_right_val;
+
+      if (rounded_bottom_left)
+        info->layout->bottom_left_corner_rounded_radius = rounded_bottom_left_val;
+
+      if (rounded_bottom_right)
+        info->layout->bottom_right_corner_rounded_radius = rounded_bottom_right_val;
+
+      meta_theme_insert_layout (info->theme, name, info->layout);
+
+      push_state (info, STATE_FRAME_GEOMETRY);
+    }
+  else if (ELEMENT_IS ("draw_ops"))
+    {
+      const char *name = NULL;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!name", &name,
+                              NULL))
+        return;
+
+      if (meta_theme_lookup_draw_op_list (info->theme, name))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("<%s> name \"%s\" used a second time"),
+                     element_name, name);
+          return;
+        }
+
+      g_assert (info->op_list == NULL);
+      info->op_list = meta_draw_op_list_new (2);
+
+      meta_theme_insert_draw_op_list (info->theme, name, info->op_list);
+
+      push_state (info, STATE_DRAW_OPS);
+    }
+  else if (ELEMENT_IS ("frame_style"))
+    {
+      const char *name = NULL;
+      const char *parent = NULL;
+      const char *geometry = NULL;
+      const char *background = NULL;
+      const char *alpha = NULL;
+      MetaFrameStyle *parent_style;
+      MetaFrameLayout *layout;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!name", &name, "parent", &parent,
+                              "geometry", &geometry,
+                              "background", &background,
+                              "alpha", &alpha,
+                              NULL))
+        return;
+
+      if (meta_theme_lookup_style (info->theme, name))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("<%s> name \"%s\" used a second time"),
+                     element_name, name);
+          return;
+        }
+
+      parent_style = NULL;
+      if (parent)
+        {
+          parent_style = meta_theme_lookup_style (info->theme, parent);
+          if (parent_style == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("<%s> parent \"%s\" has not been defined"),
+                         element_name, parent);
+              return;
+            }
+        }
+
+      layout = NULL;
+      if (geometry)
+        {
+          layout = meta_theme_lookup_layout (info->theme, geometry);
+          if (layout == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("<%s> geometry \"%s\" has not been defined"),
+                         element_name, geometry);
+              return;
+            }
+        }
+      else if (parent_style)
+        {
+          layout = parent_style->layout;
+        }
+
+      if (layout == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("<%s> must specify either a geometry or a parent that has a geometry"),
+                     element_name);
+          return;
+        }
+
+      g_assert (info->style == NULL);
+
+      info->style = meta_frame_style_new (parent_style);
+      g_assert (info->style->layout == NULL);
+      meta_frame_layout_ref (layout);
+      info->style->layout = layout;
+
+      if (background != NULL && META_THEME_ALLOWS (info->theme, META_THEME_FRAME_BACKGROUNDS))
+        {
+          info->style->window_background_color = meta_color_spec_new_from_string (background, error);
+          if (!info->style->window_background_color)
+            return;
+
+          if (alpha != NULL)
+            {
+
+               gboolean success;
+               MetaAlphaGradientSpec *alpha_vector;
+
+               g_clear_error (error);
+               /* fortunately, we already have a routine to parse alpha values,
+                * though it produces a vector of them, which is a superset of
+                * what we want.
+                */
+               success = parse_alpha (alpha, &alpha_vector, context, error);
+               if (!success)
+                 return;
+
+               /* alpha_vector->alphas must contain at least one element */
+               info->style->window_background_alpha = alpha_vector->alphas[0];
+
+               meta_alpha_gradient_spec_free (alpha_vector);
+            }
+        }
+      else if (alpha != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("You must specify a background for an alpha value to be meaningful"));
+          return;
+        }
+
+      meta_theme_insert_style (info->theme, name, info->style);
+
+      push_state (info, STATE_FRAME_STYLE);
+    }
+  else if (ELEMENT_IS ("frame_style_set"))
+    {
+      const char *name = NULL;
+      const char *parent = NULL;
+      MetaFrameStyleSet *parent_set;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!name", &name, "parent", &parent,
+                              NULL))
+        return;
+
+      if (meta_theme_lookup_style_set (info->theme, name))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("<%s> name \"%s\" used a second time"),
+                     element_name, name);
+          return;
+        }
+
+      parent_set = NULL;
+      if (parent)
+        {
+          parent_set = meta_theme_lookup_style_set (info->theme, parent);
+          if (parent_set == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("<%s> parent \"%s\" has not been defined"),
+                         element_name, parent);
+              return;
+            }
+        }
+
+      g_assert (info->style_set == NULL);
+
+      info->style_set = meta_frame_style_set_new (parent_set);
+
+      meta_theme_insert_style_set (info->theme, name, info->style_set);
+
+      push_state (info, STATE_FRAME_STYLE_SET);
+    }
+  else if (ELEMENT_IS ("window"))
+    {
+      const char *type_name = NULL;
+      const char *style_set_name = NULL;
+      MetaFrameStyleSet *style_set;
+      MetaFrameType type;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!type", &type_name, "!style_set", &style_set_name,
+                              NULL))
+        return;
+
+      type = meta_frame_type_from_string (type_name);
+
+      if (type == META_FRAME_TYPE_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Unknown type \"%s\" on <%s> element"),
+                     type_name, element_name);
+          return;
+        }
+
+      style_set = meta_theme_lookup_style_set (info->theme,
+                                               style_set_name);
+
+      if (style_set == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Unknown style_set \"%s\" on <%s> element"),
+                     style_set_name, element_name);
+          return;
+        }
+
+      if (info->theme->style_sets_by_type[type] != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Window type \"%s\" has already been assigned a style set"),
+                     type_name);
+          return;
+        }
+
+      meta_frame_style_set_ref (style_set);
+      info->theme->style_sets_by_type[type] = style_set;
+
+      push_state (info, STATE_WINDOW);
+    }
+  else if (ELEMENT_IS ("menu_icon"))
+    {
+      /* Not supported any more, but we have to parse it if they include it,
+       * for backwards compatibility.
+       */
+      g_assert (info->op_list == NULL);
+
+      push_state (info, STATE_MENU_ICON);
+    }
+  else if (ELEMENT_IS ("fallback"))
+    {
+      /* Not supported any more, but we have to parse it if they include it,
+       * for backwards compatibility.
+       */
+      push_state (info, STATE_FALLBACK);
+    }
+   else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "metacity_theme");
+    }
+}
+
+static void
+parse_info_element (GMarkupParseContext  *context,
+                    const gchar          *element_name,
+                    const gchar         **attribute_names,
+                    const gchar         **attribute_values,
+                    ParseInfo            *info,
+                    GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_INFO);
+
+  if (ELEMENT_IS ("name"))
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      push_state (info, STATE_NAME);
+    }
+  else if (ELEMENT_IS ("author"))
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      push_state (info, STATE_AUTHOR);
+    }
+  else if (ELEMENT_IS ("copyright"))
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      push_state (info, STATE_COPYRIGHT);
+    }
+  else if (ELEMENT_IS ("description"))
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      push_state (info, STATE_DESCRIPTION);
+    }
+  else if (ELEMENT_IS ("date"))
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      push_state (info, STATE_DATE);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "info");
+    }
+}
+
+static void
+parse_distance (GMarkupParseContext  *context,
+                const gchar          *element_name,
+                const gchar         **attribute_names,
+                const gchar         **attribute_values,
+                ParseInfo            *info,
+                GError              **error)
+{
+  const char *name;
+  const char *value;
+  int val;
+
+  if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                          error,
+                          "!name", &name, "!value", &value,
+                          NULL))
+    return;
+
+  val = 0;
+  if (!parse_positive_integer (value, &val, context, info->theme, error))
+    return;
+
+  g_assert (val >= 0); /* yeah, "non-negative" not "positive" get over it */
+  g_assert (info->layout);
+
+  if (strcmp (name, "left_width") == 0)
+    info->layout->left_width = val;
+  else if (strcmp (name, "right_width") == 0)
+    info->layout->right_width = val;
+  else if (strcmp (name, "bottom_height") == 0)
+    info->layout->bottom_height = val;
+  else if (strcmp (name, "title_vertical_pad") == 0)
+    info->layout->title_vertical_pad = val;
+  else if (strcmp (name, "right_titlebar_edge") == 0)
+    info->layout->right_titlebar_edge = val;
+  else if (strcmp (name, "left_titlebar_edge") == 0)
+    info->layout->left_titlebar_edge = val;
+  else if (strcmp (name, "button_width") == 0)
+    {
+      info->layout->button_width = val;
+
+      if (!(info->layout->button_sizing == META_BUTTON_SIZING_LAST ||
+            info->layout->button_sizing == META_BUTTON_SIZING_FIXED))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Cannot specify both \"button_width\"/\"button_height\" and \"aspect_ratio\" for buttons"));
+          return;
+        }
+
+      info->layout->button_sizing = META_BUTTON_SIZING_FIXED;
+    }
+  else if (strcmp (name, "button_height") == 0)
+    {
+      info->layout->button_height = val;
+
+      if (!(info->layout->button_sizing == META_BUTTON_SIZING_LAST ||
+            info->layout->button_sizing == META_BUTTON_SIZING_FIXED))
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Cannot specify both \"button_width\"/\"button_height\" and \"aspect_ratio\" for buttons"));
+          return;
+        }
+
+      info->layout->button_sizing = META_BUTTON_SIZING_FIXED;
+    }
+  else
+    {
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Distance \"%s\" is unknown"), name);
+      return;
+    }
+}
+
+static void
+parse_aspect_ratio (GMarkupParseContext  *context,
+                    const gchar          *element_name,
+                    const gchar         **attribute_names,
+                    const gchar         **attribute_values,
+                    ParseInfo            *info,
+                    GError              **error)
+{
+  const char *name;
+  const char *value;
+  double val;
+
+  if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                          error,
+                          "!name", &name, "!value", &value,
+                          NULL))
+    return;
+
+  val = 0;
+  if (!parse_double (value, &val, context, error))
+    return;
+
+  g_assert (info->layout);
+
+  if (strcmp (name, "button") == 0)
+    {
+      info->layout->button_aspect = val;
+
+      if (info->layout->button_sizing != META_BUTTON_SIZING_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Cannot specify both \"button_width\"/\"button_height\" and \"aspect_ratio\" for buttons"));
+          return;
+        }
+
+      info->layout->button_sizing = META_BUTTON_SIZING_ASPECT;
+    }
+  else
+    {
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Aspect ratio \"%s\" is unknown"), name);
+      return;
+    }
+}
+
+static void
+parse_border (GMarkupParseContext  *context,
+              const gchar          *element_name,
+              const gchar         **attribute_names,
+              const gchar         **attribute_values,
+              ParseInfo            *info,
+              GError              **error)
+{
+  const char *name;
+  const char *top;
+  const char *bottom;
+  const char *left;
+  const char *right;
+  int top_val;
+  int bottom_val;
+  int left_val;
+  int right_val;
+  GtkBorder *border;
+
+  if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                          error,
+                          "!name", &name,
+                          "!top", &top,
+                          "!bottom", &bottom,
+                          "!left", &left,
+                          "!right", &right,
+                          NULL))
+    return;
+
+  top_val = 0;
+  if (!parse_positive_integer (top, &top_val, context, info->theme, error))
+    return;
+
+  bottom_val = 0;
+  if (!parse_positive_integer (bottom, &bottom_val, context, info->theme, error))
+    return;
+
+  left_val = 0;
+  if (!parse_positive_integer (left, &left_val, context, info->theme, error))
+    return;
+
+  right_val = 0;
+  if (!parse_positive_integer (right, &right_val, context, info->theme, error))
+    return;
+
+  g_assert (info->layout);
+
+  border = NULL;
+
+  if (strcmp (name, "title_border") == 0)
+    border = &info->layout->title_border;
+  else if (strcmp (name, "button_border") == 0)
+    border = &info->layout->button_border;
+
+  if (border == NULL)
+    {
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Border \"%s\" is unknown"), name);
+      return;
+    }
+
+  border->top = top_val;
+  border->bottom = bottom_val;
+  border->left = left_val;
+  border->right = right_val;
+}
+
+static void
+parse_geometry_element (GMarkupParseContext  *context,
+                        const gchar          *element_name,
+                        const gchar         **attribute_names,
+                        const gchar         **attribute_values,
+                        ParseInfo            *info,
+                        GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_FRAME_GEOMETRY);
+
+  if (ELEMENT_IS ("distance"))
+    {
+      parse_distance (context, element_name,
+                      attribute_names, attribute_values,
+                      info, error);
+      push_state (info, STATE_DISTANCE);
+    }
+  else if (ELEMENT_IS ("border"))
+    {
+      parse_border (context, element_name,
+                    attribute_names, attribute_values,
+                    info, error);
+      push_state (info, STATE_BORDER);
+    }
+  else if (ELEMENT_IS ("aspect_ratio"))
+    {
+      parse_aspect_ratio (context, element_name,
+                          attribute_names, attribute_values,
+                          info, error);
+
+      push_state (info, STATE_ASPECT_RATIO);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "frame_geometry");
+    }
+}
+
+#if 0
+static gboolean
+check_expression (PosToken            *tokens,
+                  int                  n_tokens,
+                  gboolean             has_object,
+                  MetaTheme           *theme,
+                  GMarkupParseContext *context,
+                  GError             **error)
+{
+  MetaPositionExprEnv env;
+  int x, y;
+
+  /* We set it all to 0 to try and catch divide-by-zero screwups.
+   * it's possible we should instead guarantee that widths and heights
+   * are at least 1.
+   */
+
+  env.rect = meta_rect (0, 0, 0, 0);
+  if (has_object)
+    {
+      env.object_width = 0;
+      env.object_height = 0;
+    }
+  else
+    {
+      env.object_width = -1;
+      env.object_height = -1;
+    }
+
+  env.left_width = 0;
+  env.right_width = 0;
+  env.top_height = 0;
+  env.bottom_height = 0;
+  env.title_width = 0;
+  env.title_height = 0;
+
+  env.icon_width = 0;
+  env.icon_height = 0;
+  env.mini_icon_width = 0;
+  env.mini_icon_height = 0;
+  env.theme = theme;
+
+  if (!meta_parse_position_expression (tokens, n_tokens,
+                                       &env,
+                                       &x, &y,
+                                       error))
+    {
+      add_context_to_error (error, context);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+#endif
+
+static void
+parse_draw_op_element (GMarkupParseContext  *context,
+                       const gchar          *element_name,
+                       const gchar         **attribute_names,
+                       const gchar         **attribute_values,
+                       ParseInfo            *info,
+                       GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_DRAW_OPS);
+
+  if (ELEMENT_IS ("line"))
+    {
+      MetaDrawOp *op;
+      const char *color;
+      const char *x1;
+      const char *y1;
+      const char *x2;
+      const char *y2;
+      const char *dash_on_length;
+      const char *dash_off_length;
+      const char *width;
+      MetaColorSpec *color_spec;
+      int dash_on_val;
+      int dash_off_val;
+      int width_val;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!color", &color,
+                              "!x1", &x1, "!y1", &y1,
+                              "!x2", &x2, "!y2", &y2,
+                              "dash_on_length", &dash_on_length,
+                              "dash_off_length", &dash_off_length,
+                              "width", &width,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x1, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y1, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (x2, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y2, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      dash_on_val = 0;
+      if (dash_on_length &&
+          !parse_positive_integer (dash_on_length, &dash_on_val, context, info->theme, error))
+        return;
+
+      dash_off_val = 0;
+      if (dash_off_length &&
+          !parse_positive_integer (dash_off_length, &dash_off_val, context, info->theme, error))
+        return;
+
+      width_val = 0;
+      if (width &&
+          !parse_positive_integer (width, &width_val, context, info->theme, error))
+        return;
+
+      /* Check last so we don't have to free it when other
+       * stuff fails
+       */
+      color_spec = parse_color (info->theme, color, error);
+      if (color_spec == NULL)
+        {
+          add_context_to_error (error, context);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_LINE);
+
+      op->data.line.color_spec = color_spec;
+
+      op->data.line.x1 = meta_draw_spec_new (info->theme, x1, NULL);
+      op->data.line.y1 = meta_draw_spec_new (info->theme, y1, NULL);
+
+      if (strcmp(x1, x2)==0)
+        op->data.line.x2 = NULL;
+      else
+        op->data.line.x2 = meta_draw_spec_new (info->theme, x2, NULL);
+
+      if (strcmp(y1, y2)==0)
+        op->data.line.y2 = NULL;
+      else
+        op->data.line.y2 = meta_draw_spec_new (info->theme, y2, NULL);
+
+      op->data.line.width = width_val;
+      op->data.line.dash_on_length = dash_on_val;
+      op->data.line.dash_off_length = dash_off_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_LINE);
+    }
+  else if (ELEMENT_IS ("rectangle"))
+    {
+      MetaDrawOp *op;
+      const char *color;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *filled;
+      gboolean filled_val;
+      MetaColorSpec *color_spec;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!color", &color,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "filled", &filled,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      filled_val = FALSE;
+      if (filled && !parse_boolean (filled, &filled_val, context, error))
+        return;
+
+      /* Check last so we don't have to free it when other
+       * stuff fails
+       */
+      color_spec = parse_color (info->theme, color, error);
+      if (color_spec == NULL)
+        {
+          add_context_to_error (error, context);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_RECTANGLE);
+
+      op->data.rectangle.color_spec = color_spec;
+      op->data.rectangle.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.rectangle.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.rectangle.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.rectangle.height = meta_draw_spec_new (info->theme,
+                                                      height, NULL);
+
+      op->data.rectangle.filled = filled_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_RECTANGLE);
+    }
+  else if (ELEMENT_IS ("arc"))
+    {
+      MetaDrawOp *op;
+      const char *color;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *filled;
+      const char *start_angle;
+      const char *extent_angle;
+      const char *from;
+      const char *to;
+      gboolean filled_val;
+      double start_angle_val;
+      double extent_angle_val;
+      MetaColorSpec *color_spec;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!color", &color,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "filled", &filled,
+                              "start_angle", &start_angle,
+                              "extent_angle", &extent_angle,
+                              "from", &from,
+                              "to", &to,
+                              NULL))
+        return;
+
+      if (META_THEME_ALLOWS (info->theme, META_THEME_DEGREES_IN_ARCS) )
+        {
+          if (start_angle == NULL && from == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("No \"start_angle\" or \"from\" attribute on element <%s>"), element_name);
+              return;
+            }
+
+          if (extent_angle == NULL && to == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("No \"extent_angle\" or \"to\" attribute on element <%s>"), element_name);
+              return;
+            }
+        }
+      else
+        {
+          if (start_angle == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         ATTRIBUTE_NOT_FOUND, "start_angle", element_name);
+              return;
+            }
+
+          if (extent_angle == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         ATTRIBUTE_NOT_FOUND, "extent_angle", element_name);
+              return;
+            }
+        }
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      if (start_angle == NULL)
+        {
+          if (!parse_angle (from, &start_angle_val, context, error))
+            return;
+
+          start_angle_val = (180-start_angle_val)/360.0;
+        }
+      else
+        {
+          if (!parse_angle (start_angle, &start_angle_val, context, error))
+            return;
+        }
+
+      if (extent_angle == NULL)
+        {
+          if (!parse_angle (to, &extent_angle_val, context, error))
+            return;
+
+          extent_angle_val = ((180-extent_angle_val)/360.0) - start_angle_val;
+        }
+      else
+        {
+           if (!parse_angle (extent_angle, &extent_angle_val, context, error))
+             return;
+        }
+
+      filled_val = FALSE;
+      if (filled && !parse_boolean (filled, &filled_val, context, error))
+        return;
+
+      /* Check last so we don't have to free it when other
+       * stuff fails
+       */
+      color_spec = parse_color (info->theme, color, error);
+      if (color_spec == NULL)
+        {
+          add_context_to_error (error, context);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_ARC);
+
+      op->data.arc.color_spec = color_spec;
+
+      op->data.arc.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.arc.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.arc.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.arc.height = meta_draw_spec_new (info->theme, height, NULL);
+
+      op->data.arc.filled = filled_val;
+      op->data.arc.start_angle = start_angle_val;
+      op->data.arc.extent_angle = extent_angle_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_ARC);
+    }
+  else if (ELEMENT_IS ("clip"))
+    {
+      MetaDrawOp *op;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+      op = meta_draw_op_new (META_DRAW_CLIP);
+
+      op->data.clip.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.clip.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.clip.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.clip.height = meta_draw_spec_new (info->theme, height, NULL);
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_CLIP);
+    }
+  else if (ELEMENT_IS ("tint"))
+    {
+      MetaDrawOp *op;
+      const char *color;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *alpha;
+      MetaAlphaGradientSpec *alpha_spec;
+      MetaColorSpec *color_spec;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!color", &color,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "!alpha", &alpha,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+      alpha_spec = NULL;
+      if (!parse_alpha (alpha, &alpha_spec, context, error))
+        return;
+
+      /* Check last so we don't have to free it when other
+       * stuff fails
+       */
+      color_spec = parse_color (info->theme, color, error);
+      if (color_spec == NULL)
+        {
+          if (alpha_spec)
+            meta_alpha_gradient_spec_free (alpha_spec);
+
+          add_context_to_error (error, context);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_TINT);
+
+      op->data.tint.color_spec = color_spec;
+      op->data.tint.alpha_spec = alpha_spec;
+
+      op->data.tint.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.tint.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.tint.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.tint.height = meta_draw_spec_new (info->theme, height, NULL);
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_TINT);
+    }
+  else if (ELEMENT_IS ("gradient"))
+    {
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *type;
+      const char *alpha;
+      MetaAlphaGradientSpec *alpha_spec;
+      MetaGradientType type_val;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!type", &type,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "alpha", &alpha,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      type_val = meta_gradient_type_from_string (type);
+      if (type_val == META_GRADIENT_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Did not understand value \"%s\" for type of gradient"),
+                     type);
+          return;
+        }
+
+      alpha_spec = NULL;
+      if (alpha && !parse_alpha (alpha, &alpha_spec, context, error))
+        return;
+
+      g_assert (info->op == NULL);
+      info->op = meta_draw_op_new (META_DRAW_GRADIENT);
+
+      info->op->data.gradient.x = meta_draw_spec_new (info->theme, x, NULL);
+      info->op->data.gradient.y = meta_draw_spec_new (info->theme, y, NULL);
+      info->op->data.gradient.width = meta_draw_spec_new (info->theme,
+                                                        width, NULL);
+      info->op->data.gradient.height = meta_draw_spec_new (info->theme,
+                                                         height, NULL);
+
+      info->op->data.gradient.gradient_spec = meta_gradient_spec_new (type_val);
+
+      info->op->data.gradient.alpha_spec = alpha_spec;
+
+      push_state (info, STATE_GRADIENT);
+
+      /* op gets appended on close tag */
+    }
+  else if (ELEMENT_IS ("image"))
+    {
+      MetaDrawOp *op;
+      const char *filename;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *alpha;
+      const char *colorize;
+      const char *fill_type;
+      MetaAlphaGradientSpec *alpha_spec;
+      GdkPixbuf *pixbuf;
+      MetaColorSpec *colorize_spec = NULL;
+      MetaImageFillType fill_type_val;
+      int h, w, c;
+      int pixbuf_width, pixbuf_height, pixbuf_n_channels, pixbuf_rowstride;
+      guchar *pixbuf_pixels;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "alpha", &alpha, "!filename", &filename,
+                              "colorize", &colorize,
+                              "fill_type", &fill_type,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, TRUE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, TRUE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, TRUE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, TRUE, info->theme, context, error))
+        return;
+#endif
+      fill_type_val = META_IMAGE_FILL_SCALE;
+      if (fill_type)
+        {
+          fill_type_val = meta_image_fill_type_from_string (fill_type);
+
+          if (((int) fill_type_val) == -1)
+            {
+              set_error (error, context, G_MARKUP_ERROR,
+                         G_MARKUP_ERROR_PARSE,
+                         _("Did not understand fill type \"%s\" for <%s> element"),
+                         fill_type, element_name);
+            }
+        }
+
+      /* Check last so we don't have to free it when other
+       * stuff fails.
+       *
+       * If it's a theme image, ask for it at 64px, which is
+       * the largest possible. We scale it anyway.
+       */
+      pixbuf = meta_theme_load_image (info->theme, filename, 64, error);
+
+      if (pixbuf == NULL)
+        {
+          add_context_to_error (error, context);
+          return;
+        }
+
+      if (colorize)
+        {
+          colorize_spec = parse_color (info->theme, colorize, error);
+
+          if (colorize_spec == NULL)
+            {
+              add_context_to_error (error, context);
+              g_object_unref (G_OBJECT (pixbuf));
+              return;
+            }
+        }
+
+      alpha_spec = NULL;
+      if (alpha && !parse_alpha (alpha, &alpha_spec, context, error))
+        {
+          g_object_unref (G_OBJECT (pixbuf));
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_IMAGE);
+
+      op->data.image.pixbuf = pixbuf;
+      op->data.image.colorize_spec = colorize_spec;
+
+      op->data.image.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.image.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.image.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.image.height = meta_draw_spec_new (info->theme, height, NULL);
+
+      op->data.image.alpha_spec = alpha_spec;
+      op->data.image.fill_type = fill_type_val;
+
+      /* Check for vertical & horizontal stripes */
+      pixbuf_n_channels = gdk_pixbuf_get_n_channels(pixbuf);
+      pixbuf_width = gdk_pixbuf_get_width(pixbuf);
+      pixbuf_height = gdk_pixbuf_get_height(pixbuf);
+      pixbuf_rowstride = gdk_pixbuf_get_rowstride(pixbuf);
+      pixbuf_pixels = gdk_pixbuf_get_pixels(pixbuf);
+
+      /* Check for horizontal stripes */
+      for (h = 0; h < pixbuf_height; h++)
+        {
+          for (w = 1; w < pixbuf_width; w++)
+            {
+              for (c = 0; c < pixbuf_n_channels; c++)
+                {
+                  if (pixbuf_pixels[(h * pixbuf_rowstride) + c] !=
+                      pixbuf_pixels[(h * pixbuf_rowstride) + w + c])
+                    break;
+                }
+              if (c < pixbuf_n_channels)
+                break;
+            }
+          if (w < pixbuf_width)
+            break;
+        }
+
+      if (h >= pixbuf_height)
+        {
+          op->data.image.horizontal_stripes = TRUE;
+        }
+      else
+        {
+          op->data.image.horizontal_stripes = FALSE;
+        }
+
+      /* Check for vertical stripes */
+      for (w = 0; w < pixbuf_width; w++)
+        {
+          for (h = 1; h < pixbuf_height; h++)
+            {
+              for (c = 0; c < pixbuf_n_channels; c++)
+                {
+                  if (pixbuf_pixels[w + c] !=
+                      pixbuf_pixels[(h * pixbuf_rowstride) + w + c])
+                    break;
+                }
+              if (c < pixbuf_n_channels)
+                break;
+            }
+          if (h < pixbuf_height)
+            break;
+        }
+
+      if (w >= pixbuf_width)
+        {
+          op->data.image.vertical_stripes = TRUE;
+        }
+      else
+        {
+          op->data.image.vertical_stripes = FALSE;
+        }
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_IMAGE);
+    }
+  else if (ELEMENT_IS ("gtk_arrow"))
+    {
+      MetaDrawOp *op;
+      const char *state;
+      const char *shadow;
+      const char *arrow;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *filled;
+      gboolean filled_val;
+      GtkStateType state_val;
+      GtkShadowType shadow_val;
+      GtkArrowType arrow_val;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!state", &state,
+                              "!shadow", &shadow,
+                              "!arrow", &arrow,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "filled", &filled,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+      filled_val = TRUE;
+      if (filled && !parse_boolean (filled, &filled_val, context, error))
+        return;
+
+      state_val = meta_gtk_state_from_string (state);
+      if (((int) state_val) == -1)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Did not understand state \"%s\" for <%s> element"),
+                     state, element_name);
+          return;
+        }
+
+      shadow_val = meta_gtk_shadow_from_string (shadow);
+      if (((int) shadow_val) == -1)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Did not understand shadow \"%s\" for <%s> element"),
+                     shadow, element_name);
+          return;
+        }
+
+      arrow_val = meta_gtk_arrow_from_string (arrow);
+      if (((int) arrow_val) == -1)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Did not understand arrow \"%s\" for <%s> element"),
+                     arrow, element_name);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_GTK_ARROW);
+
+      op->data.gtk_arrow.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.gtk_arrow.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.gtk_arrow.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.gtk_arrow.height = meta_draw_spec_new (info->theme,
+                                                      height, NULL);
+
+      op->data.gtk_arrow.filled = filled_val;
+      op->data.gtk_arrow.state = state_val;
+      op->data.gtk_arrow.shadow = shadow_val;
+      op->data.gtk_arrow.arrow = arrow_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_GTK_ARROW);
+    }
+  else if (ELEMENT_IS ("gtk_box"))
+    {
+      MetaDrawOp *op;
+      const char *state;
+      const char *shadow;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      GtkStateType state_val;
+      GtkShadowType shadow_val;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!state", &state,
+                              "!shadow", &shadow,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+      state_val = meta_gtk_state_from_string (state);
+      if (((int) state_val) == -1)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Did not understand state \"%s\" for <%s> element"),
+                     state, element_name);
+          return;
+        }
+
+      shadow_val = meta_gtk_shadow_from_string (shadow);
+      if (((int) shadow_val) == -1)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Did not understand shadow \"%s\" for <%s> element"),
+                     shadow, element_name);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_GTK_BOX);
+
+      op->data.gtk_box.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.gtk_box.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.gtk_box.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.gtk_box.height = meta_draw_spec_new (info->theme, height, NULL);
+
+      op->data.gtk_box.state = state_val;
+      op->data.gtk_box.shadow = shadow_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_GTK_BOX);
+    }
+  else if (ELEMENT_IS ("gtk_vline"))
+    {
+      MetaDrawOp *op;
+      const char *state;
+      const char *x;
+      const char *y1;
+      const char *y2;
+      GtkStateType state_val;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!state", &state,
+                              "!x", &x, "!y1", &y1, "!y2", &y2,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y1, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y2, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      state_val = meta_gtk_state_from_string (state);
+      if (((int) state_val) == -1)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Did not understand state \"%s\" for <%s> element"),
+                     state, element_name);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_GTK_VLINE);
+
+      op->data.gtk_vline.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.gtk_vline.y1 = meta_draw_spec_new (info->theme, y1, NULL);
+      op->data.gtk_vline.y2 = meta_draw_spec_new (info->theme, y2, NULL);
+
+      op->data.gtk_vline.state = state_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_GTK_VLINE);
+    }
+  else if (ELEMENT_IS ("icon"))
+    {
+      MetaDrawOp *op;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *alpha;
+      const char *fill_type;
+      MetaAlphaGradientSpec *alpha_spec;
+      MetaImageFillType fill_type_val;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!x", &x, "!y", &y,
+                              "!width", &width, "!height", &height,
+                              "alpha", &alpha,
+                              "fill_type", &fill_type,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+      fill_type_val = META_IMAGE_FILL_SCALE;
+      if (fill_type)
+        {
+          fill_type_val = meta_image_fill_type_from_string (fill_type);
+
+          if (((int) fill_type_val) == -1)
+            {
+              set_error (error, context, G_MARKUP_ERROR,
+                         G_MARKUP_ERROR_PARSE,
+                         _("Did not understand fill type \"%s\" for <%s> element"),
+                         fill_type, element_name);
+            }
+        }
+
+      alpha_spec = NULL;
+      if (alpha && !parse_alpha (alpha, &alpha_spec, context, error))
+        return;
+
+      op = meta_draw_op_new (META_DRAW_ICON);
+
+      op->data.icon.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.icon.y = meta_draw_spec_new (info->theme, y, NULL);
+      op->data.icon.width = meta_draw_spec_new (info->theme, width, NULL);
+      op->data.icon.height = meta_draw_spec_new (info->theme, height, NULL);
+
+      op->data.icon.alpha_spec = alpha_spec;
+      op->data.icon.fill_type = fill_type_val;
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_ICON);
+    }
+  else if (ELEMENT_IS ("title"))
+    {
+      MetaDrawOp *op;
+      const char *color;
+      const char *x;
+      const char *y;
+      MetaColorSpec *color_spec;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!color", &color,
+                              "!x", &x, "!y", &y,
+                              NULL))
+        return;
+
+#if 0
+      if (!check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (y, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      /* Check last so we don't have to free it when other
+       * stuff fails
+       */
+      color_spec = parse_color (info->theme, color, error);
+      if (color_spec == NULL)
+        {
+          add_context_to_error (error, context);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_TITLE);
+
+      op->data.title.color_spec = color_spec;
+
+      op->data.title.x = meta_draw_spec_new (info->theme, x, NULL);
+      op->data.title.y = meta_draw_spec_new (info->theme, y, NULL);
+
+      g_assert (info->op_list);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_TITLE);
+    }
+  else if (ELEMENT_IS ("include"))
+    {
+      MetaDrawOp *op;
+      const char *name;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      MetaDrawOpList *op_list;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "x", &x, "y", &y,
+                              "width", &width, "height", &height,
+                              "!name", &name,
+                              NULL))
+        return;
+
+      /* x/y/width/height default to 0,0,width,height - should
+       * probably do this for all the draw ops
+       */
+#if 0
+      if (x && !check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (y && !check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (width && !check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (height && !check_expression (height, FALSE, info->theme, context, error))
+        return;
+#endif
+
+      op_list = meta_theme_lookup_draw_op_list (info->theme,
+                                                name);
+      if (op_list == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("No <draw_ops> called \"%s\" has been defined"),
+                     name);
+          return;
+        }
+
+      g_assert (info->op_list);
+
+      if (op_list == info->op_list ||
+          meta_draw_op_list_contains (op_list, info->op_list))
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Including draw_ops \"%s\" here would create a circular reference"),
+                     name);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_OP_LIST);
+
+      meta_draw_op_list_ref (op_list);
+      op->data.op_list.op_list = op_list;
+
+      op->data.op_list.x = meta_draw_spec_new (info->theme, x ? x : "0", NULL);
+      op->data.op_list.y = meta_draw_spec_new (info->theme, y ? y : "0", NULL);
+      op->data.op_list.width = meta_draw_spec_new (info->theme,
+                                                   width ? width : "width",
+                                                   NULL);
+      op->data.op_list.height = meta_draw_spec_new (info->theme,
+                                                    height ? height : "height",
+                                                    NULL);
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_INCLUDE);
+    }
+  else if (ELEMENT_IS ("tile"))
+    {
+      MetaDrawOp *op;
+      const char *name;
+      const char *x;
+      const char *y;
+      const char *width;
+      const char *height;
+      const char *tile_xoffset;
+      const char *tile_yoffset;
+      const char *tile_width;
+      const char *tile_height;
+      MetaDrawOpList *op_list;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "x", &x, "y", &y,
+                              "width", &width, "height", &height,
+                              "!name", &name,
+                              "tile_xoffset", &tile_xoffset,
+                              "tile_yoffset", &tile_yoffset,
+                              "!tile_width", &tile_width,
+                              "!tile_height", &tile_height,
+                              NULL))
+        return;
+
+      /* These default to 0 */
+#if 0
+      if (tile_xoffset && !check_expression (tile_xoffset, FALSE, info->theme, context, error))
+        return;
+
+      if (tile_yoffset && !check_expression (tile_yoffset, FALSE, info->theme, context, error))
+        return;
+
+      /* x/y/width/height default to 0,0,width,height - should
+       * probably do this for all the draw ops
+       */
+      if (x && !check_expression (x, FALSE, info->theme, context, error))
+        return;
+
+      if (y && !check_expression (y, FALSE, info->theme, context, error))
+        return;
+
+      if (width && !check_expression (width, FALSE, info->theme, context, error))
+        return;
+
+      if (height && !check_expression (height, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (tile_width, FALSE, info->theme, context, error))
+        return;
+
+      if (!check_expression (tile_height, FALSE, info->theme, context, error))
+        return;
+#endif
+      op_list = meta_theme_lookup_draw_op_list (info->theme,
+                                                name);
+      if (op_list == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("No <draw_ops> called \"%s\" has been defined"),
+                     name);
+          return;
+        }
+
+      g_assert (info->op_list);
+
+      if (op_list == info->op_list ||
+          meta_draw_op_list_contains (op_list, info->op_list))
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("Including draw_ops \"%s\" here would create a circular reference"),
+                     name);
+          return;
+        }
+
+      op = meta_draw_op_new (META_DRAW_TILE);
+
+      meta_draw_op_list_ref (op_list);
+
+      op->data.tile.x = meta_draw_spec_new (info->theme, x ? x : "0", NULL);
+      op->data.tile.y = meta_draw_spec_new (info->theme, y ? y : "0", NULL);
+      op->data.tile.width = meta_draw_spec_new (info->theme,
+                                                width ? width : "width",
+                                                NULL);
+      op->data.tile.height = meta_draw_spec_new (info->theme,
+                                                 height ? height : "height",
+                                                 NULL);
+      op->data.tile.tile_xoffset = meta_draw_spec_new (info->theme,
+                                                       tile_xoffset ? tile_xoffset : "0",
+                                                       NULL);
+      op->data.tile.tile_yoffset = meta_draw_spec_new (info->theme,
+                                                       tile_yoffset ? tile_yoffset : "0",
+                                                       NULL);
+      op->data.tile.tile_width = meta_draw_spec_new (info->theme, tile_width, NULL);
+      op->data.tile.tile_height = meta_draw_spec_new (info->theme, tile_height, NULL);
+
+      op->data.tile.op_list = op_list;
+
+      meta_draw_op_list_append (info->op_list, op);
+
+      push_state (info, STATE_TILE);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "draw_ops");
+    }
+}
+
+static void
+parse_gradient_element (GMarkupParseContext  *context,
+                        const gchar          *element_name,
+                        const gchar         **attribute_names,
+                        const gchar         **attribute_values,
+                        ParseInfo            *info,
+                        GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_GRADIENT);
+
+  if (ELEMENT_IS ("color"))
+    {
+      const char *value = NULL;
+      MetaColorSpec *color_spec;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!value", &value,
+                              NULL))
+        return;
+
+      color_spec = parse_color (info->theme, value, error);
+      if (color_spec == NULL)
+        {
+          add_context_to_error (error, context);
+          return;
+        }
+
+      g_assert (info->op);
+      g_assert (info->op->type == META_DRAW_GRADIENT);
+      g_assert (info->op->data.gradient.gradient_spec != NULL);
+      info->op->data.gradient.gradient_spec->color_specs =
+        g_slist_append (info->op->data.gradient.gradient_spec->color_specs,
+                        color_spec);
+
+      push_state (info, STATE_COLOR);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "gradient");
+    }
+}
+
+static void
+parse_style_element (GMarkupParseContext  *context,
+                     const gchar          *element_name,
+                     const gchar         **attribute_names,
+                     const gchar         **attribute_values,
+                     ParseInfo            *info,
+                     GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_FRAME_STYLE);
+
+  g_assert (info->style);
+
+  if (ELEMENT_IS ("piece"))
+    {
+      const char *position = NULL;
+      const char *draw_ops = NULL;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!position", &position,
+                              "draw_ops", &draw_ops,
+                              NULL))
+        return;
+
+      info->piece = meta_frame_piece_from_string (position);
+      if (info->piece == META_FRAME_PIECE_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Unknown position \"%s\" for frame piece"),
+                     position);
+          return;
+        }
+
+      if (info->style->pieces[info->piece] != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Frame style already has a piece at position %s"),
+                     position);
+          return;
+        }
+
+      g_assert (info->op_list == NULL);
+
+      if (draw_ops)
+        {
+          MetaDrawOpList *op_list;
+
+          op_list = meta_theme_lookup_draw_op_list (info->theme,
+                                                    draw_ops);
+
+          if (op_list == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("No <draw_ops> with the name \"%s\" has been defined"),
+                         draw_ops);
+              return;
+            }
+
+          meta_draw_op_list_ref (op_list);
+          info->op_list = op_list;
+        }
+
+      push_state (info, STATE_PIECE);
+    }
+  else if (ELEMENT_IS ("button"))
+    {
+      const char *function = NULL;
+      const char *state = NULL;
+      const char *draw_ops = NULL;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!function", &function,
+                              "!state", &state,
+                              "draw_ops", &draw_ops,
+                              NULL))
+        return;
+
+      info->button_type = meta_button_type_from_string (function, info->theme);
+      if (info->button_type == META_BUTTON_TYPE_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Unknown function \"%s\" for button"),
+                     function);
+          return;
+        }
+
+      if (meta_theme_earliest_version_with_button (info->button_type) >
+          info->theme->format_version)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Button function \"%s\" does not exist in this version (%d, need %d)"),
+                     function,
+                     info->theme->format_version,
+                     meta_theme_earliest_version_with_button (info->button_type)
+                     );
+          return;
+        }
+
+      info->button_state = meta_button_state_from_string (state);
+      if (info->button_state == META_BUTTON_STATE_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Unknown state \"%s\" for button"),
+                     state);
+          return;
+        }
+
+      if (info->style->buttons[info->button_type][info->button_state] != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Frame style already has a button for function %s state %s"),
+                     function, state);
+          return;
+        }
+
+      g_assert (info->op_list == NULL);
+
+      if (draw_ops)
+        {
+          MetaDrawOpList *op_list;
+
+          op_list = meta_theme_lookup_draw_op_list (info->theme,
+                                                    draw_ops);
+
+          if (op_list == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("No <draw_ops> with the name \"%s\" has been defined"),
+                         draw_ops);
+              return;
+            }
+
+          meta_draw_op_list_ref (op_list);
+          info->op_list = op_list;
+        }
+
+      push_state (info, STATE_BUTTON);
+    }
+#ifdef USE_UBUNTU_CODE
+  else if (ELEMENT_IS ("shadow"))
+    {
+      push_state (info, STATE_SHADOW);
+    }
+  else if (ELEMENT_IS ("padding"))
+    {
+      push_state (info, STATE_PADDING);
+    }
+#endif
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "frame_style");
+    }
+}
+
+static void
+parse_style_set_element (GMarkupParseContext  *context,
+                         const gchar          *element_name,
+                         const gchar         **attribute_names,
+                         const gchar         **attribute_values,
+                         ParseInfo            *info,
+                         GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_FRAME_STYLE_SET);
+
+  if (ELEMENT_IS ("frame"))
+    {
+      const char *focus = NULL;
+      const char *state = NULL;
+      const char *resize = NULL;
+      const char *style = NULL;
+      MetaFrameFocus frame_focus;
+      MetaFrameState frame_state;
+      MetaFrameResize frame_resize;
+      MetaFrameStyle *frame_style;
+
+      if (!locate_attributes (context, element_name, attribute_names, attribute_values,
+                              error,
+                              "!focus", &focus,
+                              "!state", &state,
+                              "resize", &resize,
+                              "!style", &style,
+                              NULL))
+        return;
+
+      frame_focus = meta_frame_focus_from_string (focus);
+      if (frame_focus == META_FRAME_FOCUS_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("\"%s\" is not a valid value for focus attribute"),
+                     focus);
+          return;
+        }
+
+      frame_state = meta_frame_state_from_string (state);
+      if (frame_state == META_FRAME_STATE_LAST)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("\"%s\" is not a valid value for state attribute"),
+                     focus);
+          return;
+        }
+
+      frame_style = meta_theme_lookup_style (info->theme, style);
+
+      if (frame_style == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("A style called \"%s\" has not been defined"),
+                     style);
+          return;
+        }
+
+      switch (frame_state)
+        {
+        case META_FRAME_STATE_NORMAL:
+          if (resize == NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         ATTRIBUTE_NOT_FOUND,
+                         "resize", element_name);
+              return;
+            }
+
+
+          frame_resize = meta_frame_resize_from_string (resize);
+          if (frame_resize == META_FRAME_RESIZE_LAST)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("\"%s\" is not a valid value for resize attribute"),
+                         focus);
+              return;
+            }
+
+          break;
+
+        case META_FRAME_STATE_SHADED:
+          if (META_THEME_ALLOWS (info->theme, META_THEME_UNRESIZABLE_SHADED_STYLES))
+            {
+              if (resize == NULL)
+                /* In state="normal" we would complain here. But instead we accept
+                 * not having a resize attribute and default to resize="both", since
+                 * that most closely mimics what we did in v1, and thus people can
+                 * upgrade a theme to v2 without as much hassle.
+                 */
+                frame_resize = META_FRAME_RESIZE_BOTH;
+              else
+                {
+                  frame_resize = meta_frame_resize_from_string (resize);
+                  if (frame_resize == META_FRAME_RESIZE_LAST)
+                    {
+                      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                                 _("\"%s\" is not a valid value for resize attribute"),
+                                 focus);
+                      return;
+                    }
+                }
+            }
+          else /* v1 theme */
+            {
+              if (resize != NULL)
+                {
+                  set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                       _("Should not have \"resize\" attribute on <%s> element for maximized/shaded states"),
+                      element_name);
+                  return;
+                }
+
+              /* resize="both" is equivalent to the old behaviour */
+              frame_resize = META_FRAME_RESIZE_BOTH;
+            }
+          break;
+
+        default:
+          if (resize != NULL)
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("Should not have \"resize\" attribute on <%s> element for maximized states"),
+                         element_name);
+              return;
+            }
+
+          frame_resize = META_FRAME_RESIZE_LAST;
+        }
+
+      switch (frame_state)
+        {
+        case META_FRAME_STATE_NORMAL:
+          if (info->style_set->normal_styles[frame_resize][frame_focus])
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("Style has already been specified for state %s resize %s focus %s"),
+                         state, resize, focus);
+              return;
+            }
+          meta_frame_style_ref (frame_style);
+          info->style_set->normal_styles[frame_resize][frame_focus] = frame_style;
+          break;
+        case META_FRAME_STATE_MAXIMIZED:
+          if (info->style_set->maximized_styles[frame_focus])
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("Style has already been specified for state %s focus %s"),
+                         state, focus);
+              return;
+            }
+          meta_frame_style_ref (frame_style);
+          info->style_set->maximized_styles[frame_focus] = frame_style;
+          break;
+        case META_FRAME_STATE_SHADED:
+          if (info->style_set->shaded_styles[frame_resize][frame_focus])
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("Style has already been specified for state %s resize %s focus %s"),
+                         state, resize, focus);
+              return;
+            }
+          meta_frame_style_ref (frame_style);
+          info->style_set->shaded_styles[frame_resize][frame_focus] = frame_style;
+          break;
+        case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
+          if (info->style_set->maximized_and_shaded_styles[frame_focus])
+            {
+              set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         _("Style has already been specified for state %s focus %s"),
+                         state, focus);
+              return;
+            }
+          meta_frame_style_ref (frame_style);
+          info->style_set->maximized_and_shaded_styles[frame_focus] = frame_style;
+          break;
+        case META_FRAME_STATE_LAST:
+          g_assert_not_reached ();
+          break;
+        }
+
+      push_state (info, STATE_FRAME);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "frame_style_set");
+    }
+}
+
+static void
+parse_piece_element (GMarkupParseContext  *context,
+                     const gchar          *element_name,
+                     const gchar         **attribute_names,
+                     const gchar         **attribute_values,
+                     ParseInfo            *info,
+                     GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_PIECE);
+
+  if (ELEMENT_IS ("draw_ops"))
+    {
+      if (info->op_list)
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Can't have a two draw_ops for a <piece> element (theme specified a draw_ops attribute and also a <draw_ops> element, or specified two elements)"));
+          return;
+        }
+
+      if (!check_no_attributes (context, element_name, attribute_names, attribute_values,
+                                error))
+        return;
+
+      g_assert (info->op_list == NULL);
+      info->op_list = meta_draw_op_list_new (2);
+
+      push_state (info, STATE_DRAW_OPS);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "piece");
+    }
+}
+
+static void
+parse_button_element (GMarkupParseContext  *context,
+                      const gchar          *element_name,
+                      const gchar         **attribute_names,
+                      const gchar         **attribute_values,
+                      ParseInfo            *info,
+                      GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_BUTTON);
+
+  if (ELEMENT_IS ("draw_ops"))
+    {
+      if (info->op_list)
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Can't have a two draw_ops for a <button> element (theme specified a draw_ops attribute and also a <draw_ops> element, or specified two elements)"));
+          return;
+        }
+
+      if (!check_no_attributes (context, element_name, attribute_names, attribute_values,
+                                error))
+        return;
+
+      g_assert (info->op_list == NULL);
+      info->op_list = meta_draw_op_list_new (2);
+
+      push_state (info, STATE_DRAW_OPS);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "button");
+    }
+}
+
+#ifdef USE_UBUNTU_CODE
+static void
+parse_shadow_element (GMarkupParseContext  *context,
+                      const gchar          *element_name,
+                      const gchar         **attribute_names,
+                      const gchar         **attribute_values,
+                      ParseInfo            *info,
+                      GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_SHADOW);
+
+  set_error (error, context,
+             G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+             _("Element <%s> is not allowed below <%s>"),
+             element_name, "shadow");
+}
+
+static void
+parse_padding_element (GMarkupParseContext  *context,
+                      const gchar          *element_name,
+                      const gchar         **attribute_names,
+                      const gchar         **attribute_values,
+                      ParseInfo            *info,
+                      GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_PADDING);
+
+  set_error (error, context,
+             G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+             _("Element <%s> is not allowed below <%s>"),
+             element_name, "padding");
+}
+#endif
+
+static void
+parse_menu_icon_element (GMarkupParseContext  *context,
+                         const gchar          *element_name,
+                         const gchar         **attribute_names,
+                         const gchar         **attribute_values,
+                         ParseInfo            *info,
+                         GError              **error)
+{
+  g_return_if_fail (peek_state (info) == STATE_MENU_ICON);
+
+  if (ELEMENT_IS ("draw_ops"))
+    {
+      if (info->op_list)
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("Can't have a two draw_ops for a <menu_icon> element (theme specified a draw_ops attribute and also a <draw_ops> element, or specified two elements)"));
+          return;
+        }
+
+      if (!check_no_attributes (context, element_name, attribute_names, attribute_values,
+                                error))
+        return;
+
+      g_assert (info->op_list == NULL);
+      info->op_list = meta_draw_op_list_new (2);
+
+      push_state (info, STATE_DRAW_OPS);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed below <%s>"),
+                 element_name, "menu_icon");
+    }
+}
+
+
+static void
+start_element_handler (GMarkupParseContext *context,
+                       const gchar         *element_name,
+                       const gchar        **attribute_names,
+                       const gchar        **attribute_values,
+                       gpointer             user_data,
+                       GError             **error)
+{
+  ParseInfo *info = user_data;
+
+  switch (peek_state (info))
+    {
+    case STATE_START:
+      if (strcmp (element_name, "metacity_theme") == 0)
+        {
+          info->theme = meta_theme_new ();
+          info->theme->name = g_strdup (info->theme_name);
+          info->theme->filename = g_strdup (info->theme_file);
+          info->theme->dirname = g_strdup (info->theme_dir);
+          info->theme->format_version = info->format_version;
+
+          push_state (info, STATE_THEME);
+        }
+      else
+        set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                   _("Outermost element in theme must be <metacity_theme> not <%s>"),
+                   element_name);
+      break;
+
+    case STATE_THEME:
+      parse_toplevel_element (context, element_name,
+                              attribute_names, attribute_values,
+                              info, error);
+      break;
+    case STATE_INFO:
+      parse_info_element (context, element_name,
+                          attribute_names, attribute_values,
+                          info, error);
+      break;
+    case STATE_NAME:
+    case STATE_AUTHOR:
+    case STATE_COPYRIGHT:
+    case STATE_DATE:
+    case STATE_DESCRIPTION:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a name/author/date/description element"),
+                 element_name);
+      break;
+    case STATE_CONSTANT:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a <constant> element"),
+                 element_name);
+      break;
+    case STATE_FRAME_GEOMETRY:
+      parse_geometry_element (context, element_name,
+                              attribute_names, attribute_values,
+                              info, error);
+      break;
+    case STATE_DISTANCE:
+    case STATE_BORDER:
+    case STATE_ASPECT_RATIO:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a distance/border/aspect_ratio element"),
+                 element_name);
+      break;
+    case STATE_DRAW_OPS:
+      parse_draw_op_element (context, element_name,
+                             attribute_names, attribute_values,
+                             info, error);
+      break;
+    case STATE_LINE:
+    case STATE_RECTANGLE:
+    case STATE_ARC:
+    case STATE_CLIP:
+    case STATE_TINT:
+    case STATE_IMAGE:
+    case STATE_GTK_ARROW:
+    case STATE_GTK_BOX:
+    case STATE_GTK_VLINE:
+    case STATE_ICON:
+    case STATE_TITLE:
+    case STATE_INCLUDE:
+    case STATE_TILE:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a draw operation element"),
+                 element_name);
+      break;
+    case STATE_GRADIENT:
+      parse_gradient_element (context, element_name,
+                              attribute_names, attribute_values,
+                              info, error);
+      break;
+    case STATE_COLOR:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a <%s> element"),
+                 element_name, "color");
+      break;
+    case STATE_FRAME_STYLE:
+      parse_style_element (context, element_name,
+                           attribute_names, attribute_values,
+                           info, error);
+      break;
+    case STATE_PIECE:
+      parse_piece_element (context, element_name,
+                           attribute_names, attribute_values,
+                           info, error);
+      break;
+    case STATE_BUTTON:
+      parse_button_element (context, element_name,
+                            attribute_names, attribute_values,
+                            info, error);
+      break;
+#ifdef USE_UBUNTU_CODE
+    case STATE_SHADOW:
+       parse_shadow_element (context, element_name,
+                             attribute_names, attribute_values,
+                             info, error);
+       break;
+    case STATE_PADDING:
+       parse_padding_element (context, element_name,
+                              attribute_names, attribute_values,
+                              info, error);
+       break;
+#endif
+    case STATE_MENU_ICON:
+      parse_menu_icon_element (context, element_name,
+                               attribute_names, attribute_values,
+                               info, error);
+      break;
+    case STATE_FRAME_STYLE_SET:
+      parse_style_set_element (context, element_name,
+                               attribute_names, attribute_values,
+                               info, error);
+      break;
+    case STATE_FRAME:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a <%s> element"),
+                 element_name, "frame");
+      break;
+    case STATE_WINDOW:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a <%s> element"),
+                 element_name, "window");
+      break;
+    case STATE_FALLBACK:
+      set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 _("Element <%s> is not allowed inside a <%s> element"),
+                 element_name, "fallback");
+      break;
+    }
+}
+
+static void
+end_element_handler (GMarkupParseContext *context,
+                     const gchar         *element_name,
+                     gpointer             user_data,
+                     GError             **error)
+{
+  ParseInfo *info = user_data;
+
+  switch (peek_state (info))
+    {
+    case STATE_START:
+      break;
+    case STATE_THEME:
+      g_assert (info->theme);
+
+      if (!meta_theme_validate (info->theme, error))
+        {
+          add_context_to_error (error, context);
+          meta_theme_free (info->theme);
+          info->theme = NULL;
+        }
+
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_START);
+      break;
+    case STATE_INFO:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_NAME:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_INFO);
+      break;
+    case STATE_AUTHOR:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_INFO);
+      break;
+    case STATE_COPYRIGHT:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_INFO);
+      break;
+    case STATE_DATE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_INFO);
+      break;
+    case STATE_DESCRIPTION:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_INFO);
+      break;
+    case STATE_CONSTANT:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_FRAME_GEOMETRY:
+      g_assert (info->layout);
+
+      if (!meta_frame_layout_validate (info->layout,
+                                       error))
+        {
+          add_context_to_error (error, context);
+        }
+
+      /* layout will already be stored in the theme under
+       * its name
+       */
+      meta_frame_layout_unref (info->layout);
+      info->layout = NULL;
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_DISTANCE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_FRAME_GEOMETRY);
+      break;
+    case STATE_BORDER:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_FRAME_GEOMETRY);
+      break;
+    case STATE_ASPECT_RATIO:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_FRAME_GEOMETRY);
+      break;
+    case STATE_DRAW_OPS:
+      {
+        g_assert (info->op_list);
+
+        if (!meta_draw_op_list_validate (info->op_list,
+                                         error))
+          {
+            add_context_to_error (error, context);
+            meta_draw_op_list_unref (info->op_list);
+            info->op_list = NULL;
+          }
+
+        pop_state (info);
+
+        switch (peek_state (info))
+          {
+          case STATE_BUTTON:
+          case STATE_PIECE:
+          case STATE_MENU_ICON:
+            /* Leave info->op_list to be picked up
+             * when these elements are closed
+             */
+            g_assert (info->op_list);
+            break;
+          case STATE_THEME:
+            g_assert (info->op_list);
+            meta_draw_op_list_unref (info->op_list);
+            info->op_list = NULL;
+            break;
+          default:
+            /* Op list can't occur in other contexts */
+            g_assert_not_reached ();
+            break;
+          }
+      }
+      break;
+    case STATE_LINE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_RECTANGLE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_ARC:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_CLIP:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_TINT:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_GRADIENT:
+      g_assert (info->op);
+      g_assert (info->op->type == META_DRAW_GRADIENT);
+      if (!meta_gradient_spec_validate (info->op->data.gradient.gradient_spec,
+                                        error))
+        {
+          add_context_to_error (error, context);
+          meta_draw_op_free (info->op);
+          info->op = NULL;
+        }
+      else
+        {
+          g_assert (info->op_list);
+          meta_draw_op_list_append (info->op_list, info->op);
+          info->op = NULL;
+        }
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_IMAGE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_GTK_ARROW:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_GTK_BOX:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_GTK_VLINE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_ICON:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_TITLE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_INCLUDE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_TILE:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_DRAW_OPS);
+      break;
+    case STATE_COLOR:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_GRADIENT);
+      break;
+    case STATE_FRAME_STYLE:
+      g_assert (info->style);
+
+      if (!meta_frame_style_validate (info->style,
+                                      info->theme->format_version,
+                                      error))
+        {
+          add_context_to_error (error, context);
+        }
+
+      /* Frame style is in the theme hash table and a ref
+       * is held there
+       */
+      meta_frame_style_unref (info->style);
+      info->style = NULL;
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_PIECE:
+      g_assert (info->style);
+      if (info->op_list == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("No draw_ops provided for frame piece"));
+        }
+      else
+        {
+          info->style->pieces[info->piece] = info->op_list;
+          info->op_list = NULL;
+        }
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_FRAME_STYLE);
+      break;
+    case STATE_BUTTON:
+      g_assert (info->style);
+      if (info->op_list == NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     _("No draw_ops provided for button"));
+        }
+      else
+        {
+          info->style->buttons[info->button_type][info->button_state] =
+            info->op_list;
+          info->op_list = NULL;
+        }
+      pop_state (info);
+      break;
+#ifdef USE_UBUNTU_CODE
+    case STATE_SHADOW:
+      g_assert (info->style);
+      pop_state (info);
+      break;
+    case STATE_PADDING:
+      g_assert (info->style);
+      pop_state (info);
+      break;
+#endif
+    case STATE_MENU_ICON:
+      g_assert (info->theme);
+      if (info->op_list != NULL)
+        {
+          meta_draw_op_list_unref (info->op_list);
+          info->op_list = NULL;
+        }
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_FRAME_STYLE_SET:
+      g_assert (info->style_set);
+
+      if (!meta_frame_style_set_validate (info->style_set,
+                                          error))
+        {
+          add_context_to_error (error, context);
+        }
+
+      /* Style set is in the theme hash table and a reference
+       * is held there.
+       */
+      meta_frame_style_set_unref (info->style_set);
+      info->style_set = NULL;
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_FRAME:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_FRAME_STYLE_SET);
+      break;
+    case STATE_WINDOW:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    case STATE_FALLBACK:
+      pop_state (info);
+      g_assert (peek_state (info) == STATE_THEME);
+      break;
+    }
+}
+
+#define NO_TEXT(element_name) set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE, _("No text is allowed inside element <%s>"), element_name)
+
+static gboolean
+all_whitespace (const char *text,
+                int         text_len)
+{
+  const char *p;
+  const char *end;
+
+  p = text;
+  end = text + text_len;
+
+  while (p != end)
+    {
+      if (!g_ascii_isspace (*p))
+        return FALSE;
+
+      p = g_utf8_next_char (p);
+    }
+
+  return TRUE;
+}
+
+static void
+text_handler (GMarkupParseContext *context,
+              const gchar         *text,
+              gsize                text_len,
+              gpointer             user_data,
+              GError             **error)
+{
+  ParseInfo *info = user_data;
+
+  if (all_whitespace (text, text_len))
+    return;
+
+  /* FIXME http://bugzilla.gnome.org/show_bug.cgi?id=70448 would
+   * allow a nice cleanup here.
+   */
+
+  switch (peek_state (info))
+    {
+    case STATE_START:
+      g_assert_not_reached (); /* gmarkup shouldn't do this */
+      break;
+    case STATE_THEME:
+      NO_TEXT ("metacity_theme");
+      break;
+    case STATE_INFO:
+      NO_TEXT ("info");
+      break;
+    case STATE_NAME:
+      if (info->theme->readable_name != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("<%s> specified twice for this theme"),
+                     "name");
+          return;
+        }
+
+      info->theme->readable_name = g_strndup (text, text_len);
+      break;
+    case STATE_AUTHOR:
+      if (info->theme->author != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("<%s> specified twice for this theme"),
+                     "author");
+          return;
+        }
+
+      info->theme->author = g_strndup (text, text_len);
+      break;
+    case STATE_COPYRIGHT:
+      if (info->theme->copyright != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("<%s> specified twice for this theme"),
+                     "copyright");
+          return;
+        }
+
+      info->theme->copyright = g_strndup (text, text_len);
+      break;
+    case STATE_DATE:
+      if (info->theme->date != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("<%s> specified twice for this theme"),
+                     "date");
+          return;
+        }
+
+      info->theme->date = g_strndup (text, text_len);
+      break;
+    case STATE_DESCRIPTION:
+      if (info->theme->description != NULL)
+        {
+          set_error (error, context, G_MARKUP_ERROR,
+                     G_MARKUP_ERROR_PARSE,
+                     _("<%s> specified twice for this theme"),
+                     "description");
+          return;
+        }
+
+      info->theme->description = g_strndup (text, text_len);
+      break;
+    case STATE_CONSTANT:
+      NO_TEXT ("constant");
+      break;
+    case STATE_FRAME_GEOMETRY:
+      NO_TEXT ("frame_geometry");
+      break;
+    case STATE_DISTANCE:
+      NO_TEXT ("distance");
+      break;
+    case STATE_BORDER:
+      NO_TEXT ("border");
+      break;
+    case STATE_ASPECT_RATIO:
+      NO_TEXT ("aspect_ratio");
+      break;
+    case STATE_DRAW_OPS:
+      NO_TEXT ("draw_ops");
+      break;
+    case STATE_LINE:
+      NO_TEXT ("line");
+      break;
+    case STATE_RECTANGLE:
+      NO_TEXT ("rectangle");
+      break;
+    case STATE_ARC:
+      NO_TEXT ("arc");
+      break;
+    case STATE_CLIP:
+      NO_TEXT ("clip");
+      break;
+    case STATE_TINT:
+      NO_TEXT ("tint");
+      break;
+    case STATE_GRADIENT:
+      NO_TEXT ("gradient");
+      break;
+    case STATE_IMAGE:
+      NO_TEXT ("image");
+      break;
+    case STATE_GTK_ARROW:
+      NO_TEXT ("gtk_arrow");
+      break;
+    case STATE_GTK_BOX:
+      NO_TEXT ("gtk_box");
+      break;
+    case STATE_GTK_VLINE:
+      NO_TEXT ("gtk_vline");
+      break;
+    case STATE_ICON:
+      NO_TEXT ("icon");
+      break;
+    case STATE_TITLE:
+      NO_TEXT ("title");
+      break;
+    case STATE_INCLUDE:
+      NO_TEXT ("include");
+      break;
+    case STATE_TILE:
+      NO_TEXT ("tile");
+      break;
+    case STATE_COLOR:
+      NO_TEXT ("color");
+      break;
+    case STATE_FRAME_STYLE:
+      NO_TEXT ("frame_style");
+      break;
+    case STATE_PIECE:
+      NO_TEXT ("piece");
+      break;
+    case STATE_BUTTON:
+      NO_TEXT ("button");
+      break;
+#ifdef USE_UBUNTU_CODE
+    case STATE_SHADOW:
+      NO_TEXT ("shadow");
+      break;
+    case STATE_PADDING:
+      NO_TEXT ("padding");
+      break;
+#endif
+    case STATE_MENU_ICON:
+      NO_TEXT ("menu_icon");
+      break;
+    case STATE_FRAME_STYLE_SET:
+      NO_TEXT ("frame_style_set");
+      break;
+    case STATE_FRAME:
+      NO_TEXT ("frame");
+      break;
+    case STATE_WINDOW:
+      NO_TEXT ("window");
+      break;
+    case STATE_FALLBACK:
+      NO_TEXT ("fallback");
+      break;
+    }
+}
+
+/* We were intending to put the version number
+ * in the subdirectory name, but we ended up
+ * using the filename instead.  The "-1" survives
+ * as a fossil.
+ */
+#define THEME_SUBDIR "metacity-1"
+
+/* Highest version of the theme format to
+ * look out for.
+ */
+#define THEME_VERSION 2
+
+#define MARCO_THEME_FILENAME_FORMAT "metacity-theme-%d.xml"
+
+MetaTheme*
+meta_theme_load (const char *theme_name,
+                 GError    **err)
+{
+  GMarkupParseContext *context;
+  GError *error;
+  ParseInfo info;
+  char *text;
+  gsize length;
+  char *theme_file;
+  char *theme_dir;
+  MetaTheme *retval;
+  guint version;
+  const gchar* const* xdg_data_dirs;
+  int i;
+
+  text = NULL;
+  length = 0;
+  retval = NULL;
+  context = NULL;
+
+  theme_dir = NULL;
+  theme_file = NULL;
+
+  if (meta_is_debugging ())
+    {
+      gchar *theme_filename = g_strdup_printf (MARCO_THEME_FILENAME_FORMAT,
+                                               THEME_VERSION);
+
+      /* Try in themes in our source tree */
+      theme_dir = g_build_filename ("./themes", theme_name, NULL);
+
+      theme_file = g_build_filename (theme_dir,
+                                     theme_filename,
+                                     NULL);
+
+      error = NULL;
+      if (!g_file_get_contents (theme_file,
+                                &text,
+                                &length,
+                                &error))
+        {
+          meta_topic (META_DEBUG_THEMES, "Failed to read theme from file %s: %s\n",
+                      theme_file, error->message);
+          g_error_free (error);
+          g_free (theme_dir);
+          g_free (theme_file);
+          theme_file = NULL;
+        }
+      version = THEME_VERSION;
+
+      g_free (theme_filename);
+    }
+
+  /* We try all supported versions from current to oldest */
+  for (version = THEME_VERSION; (version > 0) && (text == NULL); version--)
+    {
+      gchar *theme_filename = g_strdup_printf (MARCO_THEME_FILENAME_FORMAT,
+                                               version);
+
+      /* We try first in home dir, XDG_DATA_DIRS, then system dir for themes */
+
+      /* Try home dir for themes */
+      theme_dir = g_build_filename (g_get_home_dir (),
+                                    ".themes",
+                                    theme_name,
+                                    THEME_SUBDIR,
+                                    NULL);
+
+      theme_file = g_build_filename (theme_dir,
+                                     theme_filename,
+                                     NULL);
+
+      error = NULL;
+      if (!g_file_get_contents (theme_file,
+                                &text,
+                                &length,
+                                &error))
+        {
+          meta_topic (META_DEBUG_THEMES, "Failed to read theme from file %s: %s\n",
+                      theme_file, error->message);
+          g_error_free (error);
+          g_free (theme_dir);
+          g_free (theme_file);
+          theme_file = NULL;
+        }
+
+      /* Try each XDG_DATA_DIRS for theme */
+      xdg_data_dirs = g_get_system_data_dirs();
+      for(i = 0; xdg_data_dirs[i] != NULL; i++)
+        {
+          if (text == NULL)
+            {
+              theme_dir = g_build_filename (xdg_data_dirs[i],
+                                            "themes",
+                                            theme_name,
+                                            THEME_SUBDIR,
+                                            NULL);
+
+              theme_file = g_build_filename (theme_dir,
+                                             theme_filename,
+                                             NULL);
+
+              error = NULL;
+              if (!g_file_get_contents (theme_file,
+                                        &text,
+                                        &length,
+                                        &error))
+                {
+                  meta_topic (META_DEBUG_THEMES, "Failed to read theme from file %s: %s\n",
+                              theme_file, error->message);
+                  g_error_free (error);
+                  g_free (theme_dir);
+                  g_free (theme_file);
+                  theme_file = NULL;
+                }
+              else
+                {
+                  break;
+                }
+            }
+        }
+
+      /* Look for themes in MARCO_DATADIR */
+      if (text == NULL)
+        {
+          theme_dir = g_build_filename (MARCO_DATADIR,
+                                        "themes",
+                                        theme_name,
+                                        THEME_SUBDIR,
+                                        NULL);
+
+          theme_file = g_build_filename (theme_dir,
+                                         theme_filename,
+                                         NULL);
+
+          error = NULL;
+          if (!g_file_get_contents (theme_file,
+                                    &text,
+                                    &length,
+                                    &error))
+            {
+              meta_topic (META_DEBUG_THEMES, "Failed to read theme from file %s: %s\n",
+                            theme_file, error->message);
+              g_error_free (error);
+              g_free (theme_dir);
+              g_free (theme_file);
+              theme_file = NULL;
+            }
+        }
+
+      g_free (theme_filename);
+    }
+
+  if (text == NULL)
+    {
+      g_set_error (err, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+          _("Failed to find a valid file for theme %s\n"),
+          theme_name);
+
+      return NULL; /* all fallbacks failed */
+    }
+
+  meta_topic (META_DEBUG_THEMES, "Parsing theme file %s\n", theme_file);
+
+
+  parse_info_init (&info);
+  info.theme_name = theme_name;
+
+  /* pass ownership to info so we free it with the info */
+  info.theme_file = theme_file;
+  info.theme_dir = theme_dir;
+
+  info.format_version = version + 1;
+
+  context = g_markup_parse_context_new (&marco_theme_parser,
+                                        0, &info, NULL);
+
+  error = NULL;
+  if (!g_markup_parse_context_parse (context,
+                                     text,
+                                     length,
+                                     &error))
+    goto out;
+
+  error = NULL;
+  if (!g_markup_parse_context_end_parse (context, &error))
+    goto out;
+
+  goto out;
+
+ out:
+
+  if (context)
+    g_markup_parse_context_free (context);
+  g_free (text);
+
+  if (info.theme)
+    info.theme->format_version = info.format_version;
+
+  if (error)
+    {
+      g_propagate_error (err, error);
+    }
+  else if (info.theme)
+    {
+      /* Steal theme from info */
+      retval = info.theme;
+      info.theme = NULL;
+    }
+  else
+    {
+      g_set_error (err, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                   _("Theme file %s did not contain a root <metacity_theme> element"),
+                   info.theme_file);
+    }
+
+  parse_info_free (&info);
+
+  return retval;
+}
diff --git a/src/ui/theme-parser.h b/src/ui/theme-parser.h
new file mode 100644
index 00000000..ff090ee9
--- /dev/null
+++ b/src/ui/theme-parser.h
@@ -0,0 +1,32 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme parsing */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "theme.h"
+
+#ifndef META_THEME_PARSER_H
+#define META_THEME_PARSER_H
+
+MetaTheme* meta_theme_load (const char *theme_name,
+                            GError    **err);
+
+#endif
diff --git a/src/ui/theme-viewer.c b/src/ui/theme-viewer.c
new file mode 100644
index 00000000..c4a1fcd6
--- /dev/null
+++ b/src/ui/theme-viewer.c
@@ -0,0 +1,1338 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme viewer and test app main() */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "util.h"
+#include "theme.h"
+#include "theme-parser.h"
+#include "preview-widget.h"
+#include <gtk/gtk.h>
+#include <time.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libintl.h>
+#define _(x) dgettext (GETTEXT_PACKAGE, x)
+#define N_(x) x
+
+/* We need to compute all different button arrangements
+ * in terms of button location. We don't care about
+ * different arrangements in terms of button function.
+ *
+ * So if dups are allowed, from 0-4 buttons on the left, from 0-4 on
+ * the right, 5x5=25 combinations.
+ *
+ * If no dups, 0-4 on left determines the number on the right plus
+ * we have a special case for the "no buttons on either side" case.
+ */
+#ifndef ALLOW_DUPLICATE_BUTTONS
+#define BUTTON_LAYOUT_COMBINATIONS (MAX_BUTTONS_PER_CORNER + 1 + 1)
+#else
+#define BUTTON_LAYOUT_COMBINATIONS ((MAX_BUTTONS_PER_CORNER+1)*(MAX_BUTTONS_PER_CORNER+1))
+#endif
+
+enum
+{
+  FONT_SIZE_SMALL,
+  FONT_SIZE_NORMAL,
+  FONT_SIZE_LARGE,
+  FONT_SIZE_LAST
+};
+
+static MetaTheme *global_theme = NULL;
+static GtkWidget *previews[META_FRAME_TYPE_LAST*FONT_SIZE_LAST + BUTTON_LAYOUT_COMBINATIONS] = { NULL, };
+static double milliseconds_to_draw_frame = 0.0;
+
+static void run_position_expression_tests (void);
+#if 0
+static void run_position_expression_timings (void);
+#endif
+static void run_theme_benchmark (void);
+
+
+static GtkItemFactoryEntry menu_items[] =
+{
+  { N_("/_Windows"),              NULL,         NULL,                     0, "<Branch>" },
+  { N_("/Windows/tearoff"),       NULL,         NULL,                     0, "<Tearoff>" },
+  { N_("/Windows/_Dialog"),       "<control>d",  NULL,               0, NULL },
+  { N_("/Windows/_Modal dialog"), NULL,          NULL,         0, NULL },
+  { N_("/Windows/_Utility"),      "<control>u",  NULL,              0, NULL },
+  { N_("/Windows/_Splashscreen"), "<control>s",  NULL,         0, NULL },
+  { N_("/Windows/_Top dock"),     NULL,          NULL,                 0, NULL },
+  { N_("/Windows/_Bottom dock"),  NULL,          NULL,                 0, NULL },
+  { N_("/Windows/_Left dock"),    NULL,          NULL,                 0, NULL },
+  { N_("/Windows/_Right dock"),   NULL,          NULL,                 0, NULL },
+  { N_("/Windows/_All docks"),    NULL,          NULL,                 0, NULL },
+  { N_("/Windows/Des_ktop"),      NULL,          NULL,              0, NULL }
+};
+
+static GtkWidget *
+normal_contents (void)
+{
+  GtkWidget *table;
+  GtkWidget *toolbar;
+  GtkWidget *handlebox;
+  GtkWidget *statusbar;
+  GtkWidget *contents;
+  GtkWidget *sw;
+  GtkItemFactory *item_factory;
+      
+  table = gtk_table_new (1, 4, FALSE);
+  
+  /* Create the menubar
+   */
+      
+  item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", NULL);
+
+  gtk_item_factory_set_translate_func(item_factory,
+				      (GtkTranslateFunc)gettext, NULL, NULL);
+
+  /* Set up item factory to go away */
+  g_object_ref (item_factory);
+  g_object_ref_sink (item_factory);
+  g_object_unref (item_factory);
+  g_object_set_data_full (G_OBJECT (table),
+                          "<main>",
+                          item_factory,
+                          (GDestroyNotify) g_object_unref);
+
+  /* create menu items */
+  gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items),
+                                 menu_items, NULL);
+
+  gtk_table_attach (GTK_TABLE (table),
+                    gtk_item_factory_get_widget (item_factory, "<main>"),
+                    /* X direction */          /* Y direction */
+                    0, 1,                      0, 1,
+                    GTK_EXPAND | GTK_FILL,     0,
+                    0,                         0);
+
+  /* Create the toolbar
+   */
+  toolbar = gtk_toolbar_new ();
+
+  GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
+  gtk_tool_item_set_tooltip_text(newButton,
+				 "Open another one of these windows");
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     newButton,
+		     -1); /*-1 means append to end of toolbar*/
+
+  GtkToolItem *openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
+  gtk_tool_item_set_tooltip_text(openButton,
+				 "This is a demo button with an \'open\' icon");
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     openButton,
+		     -1); /*-1 means append to end of toolbar*/
+
+  GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
+  gtk_tool_item_set_tooltip_text(quitButton,
+				 "This is a demo button with a \'quit\' icon");
+  gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
+		     quitButton,
+		     -1); /*-1 means append to end of toolbar*/
+
+
+  handlebox = gtk_handle_box_new ();
+
+  gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
+      
+  gtk_table_attach (GTK_TABLE (table),
+                    handlebox,
+                    /* X direction */       /* Y direction */
+                    0, 1,                   1, 2,
+                    GTK_EXPAND | GTK_FILL,  0,
+                    0,                      0);
+
+  /* Create document
+   */
+
+  sw = gtk_scrolled_window_new (NULL, NULL);
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+
+  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                       GTK_SHADOW_IN);
+      
+  gtk_table_attach (GTK_TABLE (table),
+                    sw,
+                    /* X direction */       /* Y direction */
+                    0, 1,                   2, 3,
+                    GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
+                    0,                      0);
+      
+  contents = gtk_text_view_new ();
+  gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
+                               PANGO_WRAP_WORD);
+      
+  gtk_container_add (GTK_CONTAINER (sw),
+                     contents);
+
+  /* Create statusbar */
+
+  statusbar = gtk_statusbar_new ();
+  gtk_table_attach (GTK_TABLE (table),
+                    statusbar,
+                    /* X direction */       /* Y direction */
+                    0, 1,                   3, 4,
+                    GTK_EXPAND | GTK_FILL,  0,
+                    0,                      0);
+
+  gtk_widget_show_all (table);
+
+  return table;
+}
+
+static void
+update_spacings (GtkWidget *vbox,
+                 GtkWidget *action_area)
+{
+  gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
+  gtk_box_set_spacing (GTK_BOX (action_area), 10);
+  gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
+}
+
+static GtkWidget*
+dialog_contents (void)
+{
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *action_area;
+  GtkWidget *label;
+  GtkWidget *image;
+  GtkWidget *button;
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  action_area = gtk_hbutton_box_new ();
+
+  gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),
+                             GTK_BUTTONBOX_END);  
+
+  button = gtk_button_new_from_stock (GTK_STOCK_OK);
+  gtk_box_pack_end (GTK_BOX (action_area),
+                    button,
+                    FALSE, TRUE, 0);
+  
+  gtk_box_pack_end (GTK_BOX (vbox), action_area,
+                    FALSE, TRUE, 0);
+
+  update_spacings (vbox, action_area);
+
+  label = gtk_label_new (_("This is a sample message in a sample dialog"));
+  image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO,
+                                    GTK_ICON_SIZE_DIALOG);
+  gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
+  
+  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+  gtk_label_set_selectable (GTK_LABEL (label), TRUE);
+  
+  hbox = gtk_hbox_new (FALSE, 6);
+
+  gtk_box_pack_start (GTK_BOX (hbox), image,
+                      FALSE, FALSE, 0);
+
+  gtk_box_pack_start (GTK_BOX (hbox), label,
+                      TRUE, TRUE, 0);
+
+  gtk_box_pack_start (GTK_BOX (vbox),
+                      hbox,
+                      FALSE, FALSE, 0);
+
+  gtk_widget_show_all (vbox);
+
+  return vbox;
+}
+
+static GtkWidget*
+utility_contents (void)
+{
+  GtkWidget *table;
+  GtkWidget *button;
+  int i, j;
+
+  table = gtk_table_new (3, 4, FALSE);
+
+  i = 0;
+  while (i < 3)
+    {
+      j = 0;
+      while (j < 4)
+        {
+          char *str;
+
+          str = g_strdup_printf ("_%c", (char) ('A' + 4*i + j));
+          
+          button = gtk_button_new_with_mnemonic (str);
+
+          g_free (str);
+          
+          gtk_table_attach (GTK_TABLE (table),
+                            button,
+                            /* X direction */       /* Y direction */
+                            i, i+1,                   j, j+1,
+                            GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
+                            0,                      0);
+
+          ++j;
+        }
+
+      ++i;
+    }
+
+  gtk_widget_show_all (table);
+  
+  return table;
+}
+
+static GtkWidget*
+menu_contents (void)
+{
+  GtkWidget *vbox;
+  GtkWidget *mi;  
+  int i;
+  GtkWidget *frame;
+
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame),
+                             GTK_SHADOW_OUT);
+
+  vbox = gtk_vbox_new (FALSE, 0);
+
+  i = 0;
+  while (i < 10)
+    {
+      char *str = g_strdup_printf (_("Fake menu item %d\n"), i + 1);
+      mi = gtk_label_new (str);
+      gtk_misc_set_alignment (GTK_MISC (mi), 0.0, 0.5);
+      g_free (str);
+      gtk_box_pack_start (GTK_BOX (vbox), mi, FALSE, FALSE, 0);
+      
+      ++i;
+    }
+
+  gtk_container_add (GTK_CONTAINER (frame), vbox);
+  
+  gtk_widget_show_all (frame);
+  
+  return frame;
+}
+
+static GtkWidget*
+border_only_contents (void)
+{
+  GtkWidget *event_box;
+  GtkWidget *vbox;
+  GtkWidget *w;
+  GdkColor color;
+
+  event_box = gtk_event_box_new ();
+
+  color.red = 40000;
+  color.green = 0;
+  color.blue = 40000;
+  gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &color);
+  
+  vbox = gtk_vbox_new (FALSE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
+  
+  w = gtk_label_new (_("Border-only window"));
+  gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
+  w = gtk_button_new_with_label (_("Bar"));
+  gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
+
+  gtk_container_add (GTK_CONTAINER (event_box), vbox);
+  
+  gtk_widget_show_all (event_box);
+  
+  return event_box;
+}
+
+static GtkWidget*
+get_window_contents (MetaFrameType  type,
+                     const char   **title)
+{
+  switch (type)
+    {
+    case META_FRAME_TYPE_NORMAL:
+      *title = _("Normal Application Window");
+      return normal_contents ();
+
+    case META_FRAME_TYPE_DIALOG:
+      *title = _("Dialog Box");
+      return dialog_contents ();
+
+    case META_FRAME_TYPE_MODAL_DIALOG:
+      *title = _("Modal Dialog Box");
+      return dialog_contents ();
+
+    case META_FRAME_TYPE_UTILITY:
+      *title = _("Utility Palette");
+      return utility_contents ();
+
+    case META_FRAME_TYPE_MENU:
+      *title = _("Torn-off Menu");
+      return menu_contents ();
+
+    case META_FRAME_TYPE_BORDER:
+      *title = _("Border");
+      return border_only_contents ();
+      
+    case META_FRAME_TYPE_LAST:
+      g_assert_not_reached ();
+      break;
+    }
+
+  return NULL;
+}
+
+static MetaFrameFlags
+get_window_flags (MetaFrameType type)
+{
+  MetaFrameFlags flags;
+
+  flags = META_FRAME_ALLOWS_DELETE |
+    META_FRAME_ALLOWS_MENU |
+    META_FRAME_ALLOWS_MINIMIZE |
+    META_FRAME_ALLOWS_MAXIMIZE |
+    META_FRAME_ALLOWS_VERTICAL_RESIZE |
+    META_FRAME_ALLOWS_HORIZONTAL_RESIZE |
+    META_FRAME_HAS_FOCUS |
+    META_FRAME_ALLOWS_SHADE |
+    META_FRAME_ALLOWS_MOVE;
+  
+  switch (type)
+    {
+    case META_FRAME_TYPE_NORMAL:
+      break;
+
+    case META_FRAME_TYPE_DIALOG:
+    case META_FRAME_TYPE_MODAL_DIALOG:
+      flags &= ~(META_FRAME_ALLOWS_MINIMIZE |
+                 META_FRAME_ALLOWS_MAXIMIZE);
+      break;
+
+    case META_FRAME_TYPE_UTILITY:
+      flags &= ~(META_FRAME_ALLOWS_MINIMIZE |
+                 META_FRAME_ALLOWS_MAXIMIZE);
+      break;
+
+    case META_FRAME_TYPE_MENU:
+      flags &= ~(META_FRAME_ALLOWS_MINIMIZE |
+                 META_FRAME_ALLOWS_MAXIMIZE);
+      break;
+
+    case META_FRAME_TYPE_BORDER:
+      break;
+      
+    case META_FRAME_TYPE_LAST:
+      g_assert_not_reached ();
+      break;
+    }  
+  
+  return flags;
+}
+
+static GtkWidget*
+preview_collection (int font_size,
+                    PangoFontDescription *base_desc)
+{
+  GtkWidget *box;
+  GtkWidget *sw;
+  GdkColor desktop_color;
+  int i;
+  GtkWidget *eventbox;
+
+  sw = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+
+  box = gtk_vbox_new (FALSE, 0);
+  gtk_box_set_spacing (GTK_BOX (box), 20);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 20);
+
+  eventbox = gtk_event_box_new ();
+  gtk_container_add (GTK_CONTAINER (eventbox), box);
+  
+  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox);
+
+  desktop_color.red = 0x5144;
+  desktop_color.green = 0x75D6;
+  desktop_color.blue = 0xA699;
+
+  gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, &desktop_color);
+
+  i = 0;
+  while (i < META_FRAME_TYPE_LAST)
+    {
+      const char *title = NULL;
+      GtkWidget *contents;
+      GtkWidget *align;
+      double xalign, yalign;
+      GtkWidget *eventbox2;
+      GtkWidget *preview;
+      PangoFontDescription *font_desc;
+      double scale;
+      
+      eventbox2 = gtk_event_box_new ();
+      
+      preview = meta_preview_new ();
+      
+      gtk_container_add (GTK_CONTAINER (eventbox2), preview);
+      
+      meta_preview_set_frame_type (META_PREVIEW (preview), i);
+      meta_preview_set_frame_flags (META_PREVIEW (preview),
+                                    get_window_flags (i));
+            
+      meta_preview_set_theme (META_PREVIEW (preview), global_theme);
+      
+      contents = get_window_contents (i, &title);
+      
+      meta_preview_set_title (META_PREVIEW (preview), title);
+      
+      gtk_container_add (GTK_CONTAINER (preview), contents);
+
+      if (i == META_FRAME_TYPE_MENU)
+        {
+          xalign = 0.0;
+          yalign = 0.0;
+        }
+      else
+        {
+          xalign = 0.5;
+          yalign = 0.5;
+        }
+      
+      align = gtk_alignment_new (0.0, 0.0, xalign, yalign);
+      gtk_container_add (GTK_CONTAINER (align), eventbox2);
+      
+      gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0);
+
+      switch (font_size)
+        {
+        case FONT_SIZE_SMALL:
+          scale = PANGO_SCALE_XX_SMALL;
+          break;
+        case FONT_SIZE_LARGE:
+          scale = PANGO_SCALE_XX_LARGE;
+          break;
+        default:
+          scale = 1.0;
+          break;
+        }
+
+      if (scale != 1.0)
+        {
+          font_desc = pango_font_description_new ();
+          
+          pango_font_description_set_size (font_desc,
+                                           MAX (pango_font_description_get_size (base_desc) * scale, 1));
+          
+          gtk_widget_modify_font (preview, font_desc);
+
+          pango_font_description_free (font_desc);
+        }
+      
+      previews[font_size*META_FRAME_TYPE_LAST + i] = preview;
+      
+      ++i;
+    }
+
+  return sw;
+}
+
+static MetaButtonLayout different_layouts[BUTTON_LAYOUT_COMBINATIONS];
+
+static void
+init_layouts (void)
+{
+  int i;
+
+  /* Blank out all the layouts */
+  i = 0;
+  while (i < (int) G_N_ELEMENTS (different_layouts))
+    {
+      int j;
+
+      j = 0;
+      while (j < MAX_BUTTONS_PER_CORNER)
+        {
+          different_layouts[i].left_buttons[j] = META_BUTTON_FUNCTION_LAST;
+          different_layouts[i].right_buttons[j] = META_BUTTON_FUNCTION_LAST;
+          ++j;
+        }
+      ++i;
+    }
+  
+#ifndef ALLOW_DUPLICATE_BUTTONS
+  i = 0;
+  while (i <= MAX_BUTTONS_PER_CORNER)
+    {
+      int j;
+      
+      j = 0;
+      while (j < i)
+        {
+          different_layouts[i].right_buttons[j] = (MetaButtonFunction) j;
+          ++j;
+        }
+      while (j < MAX_BUTTONS_PER_CORNER)
+        {
+          different_layouts[i].left_buttons[j-i] = (MetaButtonFunction) j;
+          ++j;
+        }
+      
+      ++i;
+    }
+
+  /* Special extra case for no buttons on either side */
+  different_layouts[i].left_buttons[0] = META_BUTTON_FUNCTION_LAST;
+  different_layouts[i].right_buttons[0] = META_BUTTON_FUNCTION_LAST;
+  
+#else
+  /* FIXME this code is if we allow duplicate buttons,
+   * which we currently do not
+   */
+  int left;
+  int i;
+  
+  left = 0;
+  i = 0;
+
+  while (left < MAX_BUTTONS_PER_CORNER)
+    {
+      int right;
+      
+      right = 0;
+      
+      while (right < MAX_BUTTONS_PER_CORNER)
+        {
+          int j;
+          
+          static MetaButtonFunction left_functions[MAX_BUTTONS_PER_CORNER] = {
+            META_BUTTON_FUNCTION_MENU,
+            META_BUTTON_FUNCTION_MINIMIZE,
+            META_BUTTON_FUNCTION_MAXIMIZE,
+            META_BUTTON_FUNCTION_CLOSE
+          };
+          static MetaButtonFunction right_functions[MAX_BUTTONS_PER_CORNER] = {
+            META_BUTTON_FUNCTION_MINIMIZE,
+            META_BUTTON_FUNCTION_MAXIMIZE,
+            META_BUTTON_FUNCTION_CLOSE,
+            META_BUTTON_FUNCTION_MENU
+          };
+
+          g_assert (i < BUTTON_LAYOUT_COMBINATIONS);
+          
+          j = 0;
+          while (j <= left)
+            {
+              different_layouts[i].left_buttons[j] = left_functions[j];
+              ++j;
+            }
+
+          j = 0;
+          while (j <= right)
+            {
+              different_layouts[i].right_buttons[j] = right_functions[j];
+              ++j;
+            }
+          
+          ++i;
+          
+          ++right;
+        }
+      
+      ++left;
+    }
+#endif
+}
+
+
+static GtkWidget*
+previews_of_button_layouts (void)
+{
+  static gboolean initted = FALSE;
+  GtkWidget *box;
+  GtkWidget *sw;
+  GdkColor desktop_color;
+  int i;
+  GtkWidget *eventbox;
+  
+  if (!initted)
+    {
+      init_layouts ();
+      initted = TRUE;
+    }
+  
+  sw = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+
+  box = gtk_vbox_new (FALSE, 0);
+  gtk_box_set_spacing (GTK_BOX (box), 20);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 20);
+
+  eventbox = gtk_event_box_new ();
+  gtk_container_add (GTK_CONTAINER (eventbox), box);
+  
+  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox);
+
+  desktop_color.red = 0x5144;
+  desktop_color.green = 0x75D6;
+  desktop_color.blue = 0xA699;
+
+  gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, &desktop_color);
+
+  i = 0;
+  while (i < BUTTON_LAYOUT_COMBINATIONS)
+    {
+      GtkWidget *align;
+      double xalign, yalign;
+      GtkWidget *eventbox2;
+      GtkWidget *preview;
+      char *title;
+
+      eventbox2 = gtk_event_box_new ();
+  
+      preview = meta_preview_new ();
+  
+      gtk_container_add (GTK_CONTAINER (eventbox2), preview);  
+  
+      meta_preview_set_theme (META_PREVIEW (preview), global_theme);
+
+      title = g_strdup_printf (_("Button layout test %d"), i+1);
+      meta_preview_set_title (META_PREVIEW (preview), title);
+      g_free (title);
+
+      meta_preview_set_button_layout (META_PREVIEW (preview),
+                                      &different_layouts[i]);
+  
+      xalign = 0.5;
+      yalign = 0.5;
+      
+      align = gtk_alignment_new (0.0, 0.0, xalign, yalign);
+      gtk_container_add (GTK_CONTAINER (align), eventbox2);
+  
+      gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0);
+
+      previews[META_FRAME_TYPE_LAST*FONT_SIZE_LAST + i] = preview;
+      
+      ++i;
+    }
+  
+  return sw;
+}
+
+static GtkWidget*
+benchmark_summary (void)
+{
+  char *msg;
+  GtkWidget *label;
+  
+  msg = g_strdup_printf (_("%g milliseconds to draw one window frame"),
+                         milliseconds_to_draw_frame);
+  label = gtk_label_new (msg);
+  g_free (msg);
+
+  return label;
+}
+
+int
+main (int argc, char **argv)
+{
+  GtkWidget *window;
+  GtkWidget *collection;
+  GError *err;
+  clock_t start, end;
+  GtkWidget *notebook;
+  int i;
+  
+  bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR);
+  textdomain(GETTEXT_PACKAGE);
+  bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+
+  run_position_expression_tests ();
+#if 0
+  run_position_expression_timings ();
+#endif
+
+  gtk_init (&argc, &argv);
+
+  if (g_getenv ("MARCO_DEBUG") != NULL)
+    {
+      meta_set_debugging (TRUE);
+      meta_set_verbose (TRUE);
+    }
+  
+  start = clock ();
+  err = NULL;
+  if (argc == 1)
+    global_theme = meta_theme_load ("ClearlooksRe", &err);
+  else if (argc == 2)
+    global_theme = meta_theme_load (argv[1], &err);
+  else
+    {
+      g_printerr (_("Usage: marco-theme-viewer [THEMENAME]\n"));
+      exit (1);
+    }
+  end = clock ();
+
+  if (global_theme == NULL)
+    {
+      g_printerr (_("Error loading theme: %s\n"),
+                  err->message);
+      g_error_free (err);
+      exit (1);
+    }
+
+  g_print (_("Loaded theme \"%s\" in %g seconds\n"),
+           global_theme->name,
+           (end - start) / (double) CLOCKS_PER_SEC);
+
+  run_theme_benchmark ();
+  
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_default_size (GTK_WINDOW (window), 350, 350);
+
+  if (strcmp (global_theme->name, global_theme->readable_name)==0)
+    gtk_window_set_title (GTK_WINDOW (window),
+                          global_theme->readable_name);
+  else
+    {
+      /* The theme directory name is different from the name the theme
+       * gives itself within its file.  Display both, directory name first.
+       */
+      gchar *title =  g_strconcat (global_theme->name, " - ",
+                                   global_theme->readable_name,
+                                   NULL);
+
+      gtk_window_set_title (GTK_WINDOW (window),
+                            title);
+
+      g_free (title);
+    }       
+
+  g_signal_connect (G_OBJECT (window), "destroy",
+                    G_CALLBACK (gtk_main_quit), NULL);
+
+  gtk_widget_realize (window);
+  g_assert (window->style);
+  g_assert (window->style->font_desc);
+  
+  notebook = gtk_notebook_new ();
+  gtk_container_add (GTK_CONTAINER (window), notebook);
+
+  collection = preview_collection (FONT_SIZE_NORMAL,
+                                   window->style->font_desc);
+  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
+                            collection,
+                            gtk_label_new (_("Normal Title Font")));
+  
+  collection = preview_collection (FONT_SIZE_SMALL,
+                                   window->style->font_desc);
+  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
+                            collection,
+                            gtk_label_new (_("Small Title Font")));
+  
+  collection = preview_collection (FONT_SIZE_LARGE,
+                                   window->style->font_desc);
+  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
+                            collection,
+                            gtk_label_new (_("Large Title Font")));
+
+  collection = previews_of_button_layouts ();
+  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
+                            collection,
+                            gtk_label_new (_("Button Layouts")));
+
+  collection = benchmark_summary ();
+  gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
+                            collection,
+                            gtk_label_new (_("Benchmark")));
+  
+  i = 0;
+  while (i < (int) G_N_ELEMENTS (previews))
+    {
+      /* preview widget likes to be realized before its size request.
+       * it's lame that way.
+       */
+      gtk_widget_realize (previews[i]);
+
+      ++i;
+    }
+  
+  gtk_widget_show_all (window);
+
+  gtk_main ();
+
+  return 0;
+}
+
+
+static MetaFrameFlags
+get_flags (GtkWidget *widget)
+{
+  return META_FRAME_ALLOWS_DELETE |
+    META_FRAME_ALLOWS_MENU |
+    META_FRAME_ALLOWS_MINIMIZE |
+    META_FRAME_ALLOWS_MAXIMIZE |
+    META_FRAME_ALLOWS_VERTICAL_RESIZE |
+    META_FRAME_ALLOWS_HORIZONTAL_RESIZE |
+    META_FRAME_HAS_FOCUS |
+    META_FRAME_ALLOWS_SHADE |
+    META_FRAME_ALLOWS_MOVE;
+}
+
+static int
+get_text_height (GtkWidget *widget)
+{
+  return meta_pango_font_desc_get_text_height (widget->style->font_desc,
+                                               gtk_widget_get_pango_context (widget));
+}
+
+static PangoLayout*
+create_title_layout (GtkWidget *widget)
+{
+  PangoLayout *layout;
+
+  layout = gtk_widget_create_pango_layout (widget, _("Window Title Goes Here"));
+
+  return layout;
+}
+
+static void
+run_theme_benchmark (void)
+{
+  GtkWidget* widget;
+  GdkPixmap *pixmap;
+  int top_height, bottom_height, left_width, right_width;
+  MetaButtonState button_states[META_BUTTON_TYPE_LAST] =
+  {
+    META_BUTTON_STATE_NORMAL,
+    META_BUTTON_STATE_NORMAL,
+    META_BUTTON_STATE_NORMAL,
+    META_BUTTON_STATE_NORMAL
+  };
+  PangoLayout *layout;
+  clock_t start;
+  clock_t end;
+  GTimer *timer;
+  int i;
+  MetaButtonLayout button_layout;
+#define ITERATIONS 100
+  int client_width;
+  int client_height;
+  int inc;
+  
+  widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_realize (widget);
+  
+  meta_theme_get_frame_borders (global_theme,
+                                META_FRAME_TYPE_NORMAL,
+                                get_text_height (widget),
+                                get_flags (widget),
+                                &top_height,
+                                &bottom_height,
+                                &left_width,
+                                &right_width);
+  
+  layout = create_title_layout (widget);
+  
+  i = 0;
+  while (i < MAX_BUTTONS_PER_CORNER)
+    {
+      button_layout.left_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      button_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      ++i;
+    }
+  
+  button_layout.left_buttons[0] = META_BUTTON_FUNCTION_MENU;
+
+  button_layout.right_buttons[0] = META_BUTTON_FUNCTION_MINIMIZE;
+  button_layout.right_buttons[1] = META_BUTTON_FUNCTION_MAXIMIZE;
+  button_layout.right_buttons[2] = META_BUTTON_FUNCTION_CLOSE;
+
+  timer = g_timer_new ();
+  start = clock ();
+
+  client_width = 50;
+  client_height = 50;
+  inc = 1000 / ITERATIONS; /* Increment to grow width/height,
+                            * eliminates caching effects.
+                            */
+  
+  i = 0;
+  while (i < ITERATIONS)
+    {
+      /* Creating the pixmap in the loop is right, since
+       * GDK does the same with its double buffering.
+       */
+      pixmap = gdk_pixmap_new (widget->window,
+                               client_width + left_width + right_width,
+                               client_height + top_height + bottom_height,
+                               -1);
+
+      meta_theme_draw_frame (global_theme,
+                             widget,
+                             pixmap,
+                             NULL,
+                             0, 0,
+                             META_FRAME_TYPE_NORMAL,
+                             get_flags (widget),
+                             client_width, client_height,
+                             layout,
+                             get_text_height (widget),
+                             &button_layout,
+                             button_states,
+                             meta_preview_get_mini_icon (),
+                             meta_preview_get_icon ());
+
+      g_object_unref (G_OBJECT (pixmap));
+      
+      ++i;
+      client_width += inc;
+      client_height += inc;
+    }
+
+  end = clock ();
+  g_timer_stop (timer);
+
+  milliseconds_to_draw_frame = (g_timer_elapsed (timer, NULL) / (double) ITERATIONS) * 1000;
+  
+  g_print (_("Drew %d frames in %g client-side seconds (%g milliseconds per frame) and %g seconds wall clock time including X server resources (%g milliseconds per frame)\n"),
+           ITERATIONS,
+           ((double)end - (double)start) / CLOCKS_PER_SEC,
+           (((double)end - (double)start) / CLOCKS_PER_SEC / (double) ITERATIONS) * 1000,
+           g_timer_elapsed (timer, NULL),
+           milliseconds_to_draw_frame);
+
+  g_timer_destroy (timer);
+  g_object_unref (G_OBJECT (layout));
+  gtk_widget_destroy (widget);
+
+#undef ITERATIONS
+}
+
+typedef struct
+{
+  GdkRectangle rect;
+  const char *expr;
+  int expected_x;
+  int expected_y;
+  MetaThemeError expected_error;
+} PositionExpressionTest;
+
+#define NO_ERROR -1
+
+static const PositionExpressionTest position_expression_tests[] = {
+  /* Just numbers */
+  { { 10, 20, 40, 50 },
+    "10", 20, 30, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14.37", 24, 34, NO_ERROR },
+  /* Binary expressions with 2 ints */
+  { { 10, 20, 40, 50 },
+    "14 * 10", 150, 160, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14 + 10", 34, 44, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14 - 10", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 / 2", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 % 3", 12, 22, NO_ERROR },
+  /* Binary expressions with floats and mixed float/ints */
+  { { 10, 20, 40, 50 },
+    "7.0 / 3.5", 12, 22, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12.1 / 3", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12 / 2.95", 14, 24, NO_ERROR },
+  /* Binary expressions without whitespace after first number */
+  { { 10, 20, 40, 50 },
+    "14* 10", 150, 160, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14+ 10", 34, 44, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14- 10", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8/ 2", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "7.0/ 3.5", 12, 22, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12.1/ 3", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12/ 2.95", 14, 24, NO_ERROR },
+  /* Binary expressions without whitespace before second number */
+  { { 10, 20, 40, 50 },
+    "14 *10", 150, 160, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14 +10", 34, 44, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14 -10", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 /2", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "7.0 /3.5", 12, 22, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12.1 /3", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12 /2.95", 14, 24, NO_ERROR },
+  /* Binary expressions without any whitespace */
+  { { 10, 20, 40, 50 },
+    "14*10", 150, 160, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14+10", 34, 44, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14-10", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8/2", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "7.0/3.5", 12, 22, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12.1/3", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "12/2.95", 14, 24, NO_ERROR },
+  /* Binary expressions with parentheses */
+  { { 10, 20, 40, 50 },
+    "(14) * (10)", 150, 160, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(14) + (10)", 34, 44, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(14) - (10)", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(8) / (2)", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(7.0) / (3.5)", 12, 22, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(12.1) / (3)", 14, 24, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(12) / (2.95)", 14, 24, NO_ERROR },
+  /* Lots of extra parentheses */
+  { { 10, 20, 40, 50 },
+    "(((14)) * ((10)))", 150, 160, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "((((14)))) + ((((((((10))))))))", 34, 44, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "((((((((((14 - 10))))))))))", 14, 24, NO_ERROR },
+  /* Binary expressions with variables */
+  { { 10, 20, 40, 50 },
+    "2 * width", 90, 100, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "2 * height", 110, 120, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "width - 10", 40, 50, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "height / 2", 35, 45, NO_ERROR },
+  /* More than two operands */
+  { { 10, 20, 40, 50 },
+    "8 / 2 + 5", 19, 29, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 * 2 + 5", 31, 41, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 + 2 * 5", 28, 38, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 + 8 / 2", 22, 32, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "14 / (2 + 5)", 12, 22, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "8 * (2 + 5)", 66, 76, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(8 + 2) * 5", 60, 70, NO_ERROR },
+  { { 10, 20, 40, 50 },
+    "(8 + 8) / 2", 18, 28, NO_ERROR },
+  /* Errors */
+  { { 10, 20, 40, 50 },
+    "2 * foo", 0, 0, META_THEME_ERROR_UNKNOWN_VARIABLE },
+  { { 10, 20, 40, 50 },
+    "2 *", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "- width", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "5 % 1.0", 0, 0, META_THEME_ERROR_MOD_ON_FLOAT },
+  { { 10, 20, 40, 50 },
+    "1.0 % 5", 0, 0, META_THEME_ERROR_MOD_ON_FLOAT },
+  { { 10, 20, 40, 50 },
+    "! * 2", 0, 0, META_THEME_ERROR_BAD_CHARACTER },
+  { { 10, 20, 40, 50 },
+    "   ", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "() () (( ) ()) ((()))", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "(*) () ((/) ()) ((()))", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "2 * 5 /", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "+ 2 * 5", 0, 0, META_THEME_ERROR_FAILED },
+  { { 10, 20, 40, 50 },
+    "+ 2 * 5", 0, 0, META_THEME_ERROR_FAILED }
+};
+
+static void
+run_position_expression_tests (void)
+{
+#if 0
+  int i;
+  MetaPositionExprEnv env;
+
+  i = 0;
+  while (i < (int) G_N_ELEMENTS (position_expression_tests))
+    {
+      GError *err;
+      gboolean retval;
+      const PositionExpressionTest *test;
+      PosToken *tokens;
+      int n_tokens;
+      int x, y;
+
+      test = &position_expression_tests[i];
+
+      if (g_getenv ("META_PRINT_TESTS") != NULL)
+        g_print ("Test expression: \"%s\" expecting x = %d y = %d",
+                 test->expr, test->expected_x, test->expected_y);
+
+      err = NULL;
+      
+      env.rect = meta_rect (test->rect.x, test->rect.y,
+                            test->rect.width, test->rect.height);
+      env.object_width = -1;
+      env.object_height = -1;
+      env.left_width = 0;
+      env.right_width = 0;
+      env.top_height = 0;
+      env.bottom_height = 0;
+      env.title_width = 5;
+      env.title_height = 5;
+      env.icon_width = 32;
+      env.icon_height = 32;
+      env.mini_icon_width = 16;
+      env.mini_icon_height = 16;
+      env.theme = NULL;
+
+      if (err == NULL)
+        {
+          retval = meta_parse_position_expression (tokens, n_tokens,
+                                                   &env,
+                                                   &x, &y,
+                                                   &err);
+        }
+
+      if (retval && err)
+        g_error (_("position expression test returned TRUE but set error"));
+      if (!retval && err == NULL)
+        g_error (_("position expression test returned FALSE but didn't set error"));
+      if (((int) test->expected_error) != NO_ERROR)
+        {
+          if (err == NULL)
+            g_error (_("Error was expected but none given"));
+          if (err->code != (int) test->expected_error)
+            g_error (_("Error %d was expected but %d given"),
+                     test->expected_error, err->code);
+        }
+      else
+        {
+          if (err)
+            g_error (_("Error not expected but one was returned: %s"),
+                     err->message);
+
+          if (x != test->expected_x)
+            g_error (_("x value was %d, %d was expected"), x, test->expected_x);
+
+          if (y != test->expected_y)
+            g_error (_("y value was %d, %d was expected"), y, test->expected_y);
+        }
+
+      if (err)
+        g_error_free (err);
+
+      meta_pos_tokens_free (tokens, n_tokens);
+      ++i;
+    }
+#endif
+}
+
+#if 0
+static void
+run_position_expression_timings (void)
+{
+  int i;
+  int iters;
+  clock_t start;
+  clock_t end;
+  MetaPositionExprEnv env;
+
+#define ITERATIONS 100000
+
+  start = clock ();
+
+  iters = 0;
+  i = 0;
+  while (iters < ITERATIONS)
+    {
+      const PositionExpressionTest *test;
+      int x, y;
+
+      test = &position_expression_tests[i];
+
+      env.x = test->rect.x;
+      env.y = test->rect.y;
+      env.width = test->rect.width;
+      env.height = test->rect.height;
+      env.object_width = -1;
+      env.object_height = -1;
+      env.left_width = 0;
+      env.right_width = 0;
+      env.top_height = 0;
+      env.bottom_height = 0;
+      env.title_width = 5;
+      env.title_height = 5;
+      env.icon_width = 32;
+      env.icon_height = 32;
+      env.mini_icon_width = 16;
+      env.mini_icon_height = 16;
+      env.theme = NULL;
+
+      meta_parse_position_expression (test->expr,
+                                      &env,
+                                      &x, &y, NULL);
+
+      ++iters;
+      ++i;
+      if (i == G_N_ELEMENTS (position_expression_tests))
+        i = 0;
+    }
+
+  end = clock ();
+
+  g_print (_("%d coordinate expressions parsed in %g seconds (%g seconds average)\n"),
+           ITERATIONS,
+           ((double)end - (double)start) / CLOCKS_PER_SEC,
+           ((double)end - (double)start) / CLOCKS_PER_SEC / (double) ITERATIONS);
+
+}
+#endif
diff --git a/src/ui/theme.c b/src/ui/theme.c
new file mode 100644
index 00000000..63103960
--- /dev/null
+++ b/src/ui/theme.c
@@ -0,0 +1,6652 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Theme Rendering */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file theme.c    Making Marco look pretty
+ *
+ * The window decorations drawn by Marco are described by files on disk
+ * known internally as "themes" (externally as "window border themes" on
+ * http://art.gnome.org/themes/marco/ or "Marco themes"). This file
+ * contains most of the code necessary to support themes; it does not
+ * contain the XML parser, which is in theme-parser.c.
+ *
+ * \bug This is a big file with lots of different subsystems, which might
+ * be better split out into separate files.
+ */
+
+/**
+ * \defgroup tokenizer   The theme expression tokenizer
+ *
+ * Themes can use a simple expression language to represent the values of
+ * things. This is the tokeniser used for that language.
+ *
+ * \bug We could remove almost all this code by using GScanner instead,
+ * but we would also have to find every expression in every existing theme
+ * we could and make sure the parse trees were the same.
+ */
+
+/**
+ * \defgroup parser  The theme expression parser
+ *
+ * Themes can use a simple expression language to represent the values of
+ * things. This is the parser used for that language.
+ */
+
+#include <config.h>
+#include "theme.h"
+#include "theme-parser.h"
+#include "util.h"
+#include "gradient.h"
+#include <gtk/gtk.h>
+#include <string.h>
+#include <stdlib.h>
+#define __USE_XOPEN
+#include <math.h>
+
+#define GDK_COLOR_RGBA(color)                                           \
+                         ((guint32) (0xff                         |     \
+                                     (((color).red / 256) << 24)   |    \
+                                     (((color).green / 256) << 16) |    \
+                                     (((color).blue / 256) << 8)))
+
+#define GDK_COLOR_RGB(color)                                            \
+                         ((guint32) ((((color).red / 256) << 16)   |    \
+                                     (((color).green / 256) << 8)  |    \
+                                     (((color).blue / 256))))
+
+#define ALPHA_TO_UCHAR(d) ((unsigned char) ((d) * 255))
+
+#define DEBUG_FILL_STRUCT(s) memset ((s), 0xef, sizeof (*(s)))
+#define CLAMP_UCHAR(v) ((guchar) (CLAMP (((int)v), (int)0, (int)255)))
+#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
+
+static void gtk_style_shade		(GdkColor	 *a,
+					 GdkColor	 *b,
+					 gdouble	  k);
+static void rgb_to_hls			(gdouble	 *r,
+					 gdouble	 *g,
+					 gdouble	 *b);
+static void hls_to_rgb			(gdouble	 *h,
+					 gdouble	 *l,
+					 gdouble	 *s);
+
+/**
+ * The current theme. (Themes are singleton.)
+ */
+static MetaTheme *meta_current_theme = NULL;
+
+static GdkPixbuf *
+colorize_pixbuf (GdkPixbuf *orig,
+                 GdkColor  *new_color)
+{
+  GdkPixbuf *pixbuf;
+  double intensity;
+  int x, y;
+  const guchar *src;
+  guchar *dest;
+  int orig_rowstride;
+  int dest_rowstride;
+  int width, height;
+  gboolean has_alpha;
+  const guchar *src_pixels;
+  guchar *dest_pixels;
+
+  pixbuf = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (orig), gdk_pixbuf_get_has_alpha (orig),
+			   gdk_pixbuf_get_bits_per_sample (orig),
+			   gdk_pixbuf_get_width (orig), gdk_pixbuf_get_height (orig));
+
+  if (pixbuf == NULL)
+    return NULL;
+
+  orig_rowstride = gdk_pixbuf_get_rowstride (orig);
+  dest_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  width = gdk_pixbuf_get_width (pixbuf);
+  height = gdk_pixbuf_get_height (pixbuf);
+  has_alpha = gdk_pixbuf_get_has_alpha (orig);
+  src_pixels = gdk_pixbuf_get_pixels (orig);
+  dest_pixels = gdk_pixbuf_get_pixels (pixbuf);
+
+  for (y = 0; y < height; y++)
+    {
+      src = src_pixels + y * orig_rowstride;
+      dest = dest_pixels + y * dest_rowstride;
+
+      for (x = 0; x < width; x++)
+        {
+          double dr, dg, db;
+
+          intensity = INTENSITY (src[0], src[1], src[2]) / 255.0;
+
+          if (intensity <= 0.5)
+            {
+              /* Go from black at intensity = 0.0 to new_color at intensity = 0.5 */
+              dr = (new_color->red * intensity * 2.0) / 65535.0;
+              dg = (new_color->green * intensity * 2.0) / 65535.0;
+              db = (new_color->blue * intensity * 2.0) / 65535.0;
+            }
+          else
+            {
+              /* Go from new_color at intensity = 0.5 to white at intensity = 1.0 */
+              dr = (new_color->red + (65535 - new_color->red) * (intensity - 0.5) * 2.0) / 65535.0;
+              dg = (new_color->green + (65535 - new_color->green) * (intensity - 0.5) * 2.0) / 65535.0;
+              db = (new_color->blue + (65535 - new_color->blue) * (intensity - 0.5) * 2.0) / 65535.0;
+            }
+
+          dest[0] = CLAMP_UCHAR (255 * dr);
+          dest[1] = CLAMP_UCHAR (255 * dg);
+          dest[2] = CLAMP_UCHAR (255 * db);
+
+          if (has_alpha)
+            {
+              dest[3] = src[3];
+              src += 4;
+              dest += 4;
+            }
+          else
+            {
+              src += 3;
+              dest += 3;
+            }
+        }
+    }
+
+  return pixbuf;
+}
+
+static void
+color_composite (const GdkColor *bg,
+                 const GdkColor *fg,
+                 double          alpha_d,
+                 GdkColor       *color)
+{
+  guint16 alpha;
+
+  *color = *bg;
+  alpha = alpha_d * 0xffff;
+  color->red = color->red + (((fg->red - color->red) * alpha + 0x8000) >> 16);
+  color->green = color->green + (((fg->green - color->green) * alpha + 0x8000) >> 16);
+  color->blue = color->blue + (((fg->blue - color->blue) * alpha + 0x8000) >> 16);
+}
+
+/**
+ * Sets all the fields of a border to dummy values.
+ *
+ * \param border The border whose fields should be reset.
+ */
+static void
+init_border (GtkBorder *border)
+{
+  border->top = -1;
+  border->bottom = -1;
+  border->left = -1;
+  border->right = -1;
+}
+
+/**
+ * Creates a new, empty MetaFrameLayout. The fields will be set to dummy
+ * values.
+ *
+ * \return The newly created MetaFrameLayout.
+ */
+MetaFrameLayout*
+meta_frame_layout_new  (void)
+{
+  MetaFrameLayout *layout;
+
+  layout = g_new0 (MetaFrameLayout, 1);
+
+  layout->refcount = 1;
+
+  /* Fill with -1 values to detect invalid themes */
+  layout->left_width = -1;
+  layout->right_width = -1;
+  layout->bottom_height = -1;
+
+  init_border (&layout->title_border);
+
+  layout->title_vertical_pad = -1;
+
+  layout->right_titlebar_edge = -1;
+  layout->left_titlebar_edge = -1;
+
+  layout->button_sizing = META_BUTTON_SIZING_LAST;
+  layout->button_aspect = 1.0;
+  layout->button_width = -1;
+  layout->button_height = -1;
+
+  layout->has_title = TRUE;
+  layout->title_scale = 1.0;
+
+  init_border (&layout->button_border);
+
+  return layout;
+}
+
+/**
+ *
+ */
+static gboolean
+validate_border (const GtkBorder *border,
+                 const char     **bad)
+{
+  *bad = NULL;
+
+  if (border->top < 0)
+    *bad = _("top");
+  else if (border->bottom < 0)
+    *bad = _("bottom");
+  else if (border->left < 0)
+    *bad = _("left");
+  else if (border->right < 0)
+    *bad = _("right");
+
+  return *bad == NULL;
+}
+
+/**
+ * Ensures that the theme supplied a particular dimension. When a
+ * MetaFrameLayout is created, all its integer fields are set to -1
+ * by meta_frame_layout_new(). After an instance of this type
+ * should have been initialised, this function checks that
+ * a given field is not still at -1. It is never called directly, but
+ * rather via the CHECK_GEOMETRY_VALUE and CHECK_GEOMETRY_BORDER
+ * macros.
+ *
+ * \param      val    The value to check
+ * \param      name   The name to use in the error message
+ * \param[out] error  Set to an error if val was not initialised
+ */
+static gboolean
+validate_geometry_value (int         val,
+                         const char *name,
+                         GError    **error)
+{
+  if (val < 0)
+    {
+      g_set_error (error, META_THEME_ERROR,
+                   META_THEME_ERROR_FRAME_GEOMETRY,
+                   _("frame geometry does not specify \"%s\" dimension"),
+                   name);
+      return FALSE;
+    }
+  else
+    return TRUE;
+}
+
+static gboolean
+validate_geometry_border (const GtkBorder *border,
+                          const char      *name,
+                          GError         **error)
+{
+  const char *bad;
+
+  if (!validate_border (border, &bad))
+    {
+      g_set_error (error, META_THEME_ERROR,
+                   META_THEME_ERROR_FRAME_GEOMETRY,
+                   _("frame geometry does not specify dimension \"%s\" for border \"%s\""),
+                   bad, name);
+      return FALSE;
+    }
+  else
+    return TRUE;
+}
+
+gboolean
+meta_frame_layout_validate (const MetaFrameLayout *layout,
+                            GError               **error)
+{
+  g_return_val_if_fail (layout != NULL, FALSE);
+
+#define CHECK_GEOMETRY_VALUE(vname) if (!validate_geometry_value (layout->vname, #vname, error)) return FALSE
+
+#define CHECK_GEOMETRY_BORDER(bname) if (!validate_geometry_border (&layout->bname, #bname, error)) return FALSE
+
+  CHECK_GEOMETRY_VALUE (left_width);
+  CHECK_GEOMETRY_VALUE (right_width);
+  CHECK_GEOMETRY_VALUE (bottom_height);
+
+  CHECK_GEOMETRY_BORDER (title_border);
+
+  CHECK_GEOMETRY_VALUE (title_vertical_pad);
+
+  CHECK_GEOMETRY_VALUE (right_titlebar_edge);
+  CHECK_GEOMETRY_VALUE (left_titlebar_edge);
+
+  switch (layout->button_sizing)
+    {
+    case META_BUTTON_SIZING_ASPECT:
+      if (layout->button_aspect < (0.1) ||
+          layout->button_aspect > (15.0))
+        {
+          g_set_error (error, META_THEME_ERROR,
+                       META_THEME_ERROR_FRAME_GEOMETRY,
+                       _("Button aspect ratio %g is not reasonable"),
+                       layout->button_aspect);
+          return FALSE;
+        }
+      break;
+    case META_BUTTON_SIZING_FIXED:
+      CHECK_GEOMETRY_VALUE (button_width);
+      CHECK_GEOMETRY_VALUE (button_height);
+      break;
+    case META_BUTTON_SIZING_LAST:
+      g_set_error (error, META_THEME_ERROR,
+                   META_THEME_ERROR_FRAME_GEOMETRY,
+                   _("Frame geometry does not specify size of buttons"));
+      return FALSE;
+    }
+
+  CHECK_GEOMETRY_BORDER (button_border);
+
+  return TRUE;
+}
+
+MetaFrameLayout*
+meta_frame_layout_copy (const MetaFrameLayout *src)
+{
+  MetaFrameLayout *layout;
+
+  layout = g_new0 (MetaFrameLayout, 1);
+
+  *layout = *src;
+
+  layout->refcount = 1;
+
+  return layout;
+}
+
+void
+meta_frame_layout_ref (MetaFrameLayout *layout)
+{
+  g_return_if_fail (layout != NULL);
+
+  layout->refcount += 1;
+}
+
+void
+meta_frame_layout_unref (MetaFrameLayout *layout)
+{
+  g_return_if_fail (layout != NULL);
+  g_return_if_fail (layout->refcount > 0);
+
+  layout->refcount -= 1;
+
+  if (layout->refcount == 0)
+    {
+      DEBUG_FILL_STRUCT (layout);
+      g_free (layout);
+    }
+}
+
+void
+meta_frame_layout_get_borders (const MetaFrameLayout *layout,
+                               int                    text_height,
+                               MetaFrameFlags         flags,
+                               int                   *top_height,
+                               int                   *bottom_height,
+                               int                   *left_width,
+                               int                   *right_width)
+{
+  int buttons_height, title_height;
+
+  g_return_if_fail (top_height != NULL);
+  g_return_if_fail (bottom_height != NULL);
+  g_return_if_fail (left_width != NULL);
+  g_return_if_fail (right_width != NULL);
+
+  if (!layout->has_title)
+    text_height = 0;
+
+  buttons_height = layout->button_height +
+    layout->button_border.top + layout->button_border.bottom;
+  title_height = text_height +
+    layout->title_vertical_pad +
+    layout->title_border.top + layout->title_border.bottom;
+
+  if (top_height)
+    {
+      *top_height = MAX (buttons_height, title_height);
+    }
+
+  if (left_width)
+    *left_width = layout->left_width;
+  if (right_width)
+    *right_width = layout->right_width;
+
+  if (bottom_height)
+    {
+      if (flags & META_FRAME_SHADED)
+        *bottom_height = 0;
+      else
+        *bottom_height = layout->bottom_height;
+    }
+
+  if (flags & META_FRAME_FULLSCREEN)
+    {
+      if (top_height)
+        *top_height = 0;
+      if (bottom_height)
+        *bottom_height = 0;
+      if (left_width)
+        *left_width = 0;
+      if (right_width)
+        *right_width = 0;
+    }
+}
+
+static MetaButtonSpace*
+rect_for_function (MetaFrameGeometry *fgeom,
+                   MetaFrameFlags     flags,
+                   MetaButtonFunction function,
+                   MetaTheme         *theme)
+{
+
+  /* Firstly, check version-specific things. */
+
+  if (META_THEME_ALLOWS(theme, META_THEME_SHADE_STICK_ABOVE_BUTTONS))
+    {
+      switch (function)
+        {
+        case META_BUTTON_FUNCTION_SHADE:
+          if ((flags & META_FRAME_ALLOWS_SHADE) && !(flags & META_FRAME_SHADED))
+            return &fgeom->shade_rect;
+          else
+            return NULL;
+        case META_BUTTON_FUNCTION_ABOVE:
+          if (!(flags & META_FRAME_ABOVE))
+            return &fgeom->above_rect;
+          else
+            return NULL;
+        case META_BUTTON_FUNCTION_STICK:
+          if (!(flags & META_FRAME_STUCK))
+            return &fgeom->stick_rect;
+          else
+            return NULL;
+        case META_BUTTON_FUNCTION_UNSHADE:
+          if ((flags & META_FRAME_ALLOWS_SHADE) && (flags & META_FRAME_SHADED))
+            return &fgeom->unshade_rect;
+          else
+            return NULL;
+        case META_BUTTON_FUNCTION_UNABOVE:
+          if (flags & META_FRAME_ABOVE)
+            return &fgeom->unabove_rect;
+          else
+            return NULL;
+        case META_BUTTON_FUNCTION_UNSTICK:
+          if (flags & META_FRAME_STUCK)
+            return &fgeom->unstick_rect;
+        default:
+          /* just go on to the next switch block */;
+        }
+    }
+
+  /* now consider the buttons which exist in all versions */
+
+  switch (function)
+    {
+    case META_BUTTON_FUNCTION_MENU:
+      if (flags & META_FRAME_ALLOWS_MENU)
+        return &fgeom->menu_rect;
+      else
+        return NULL;
+    case META_BUTTON_FUNCTION_MINIMIZE:
+      if (flags & META_FRAME_ALLOWS_MINIMIZE)
+        return &fgeom->min_rect;
+      else
+        return NULL;
+    case META_BUTTON_FUNCTION_MAXIMIZE:
+      if (flags & META_FRAME_ALLOWS_MAXIMIZE)
+        return &fgeom->max_rect;
+      else
+        return NULL;
+    case META_BUTTON_FUNCTION_CLOSE:
+      if (flags & META_FRAME_ALLOWS_DELETE)
+        return &fgeom->close_rect;
+      else
+        return NULL;
+    case META_BUTTON_FUNCTION_STICK:
+    case META_BUTTON_FUNCTION_SHADE:
+    case META_BUTTON_FUNCTION_ABOVE:
+    case META_BUTTON_FUNCTION_UNSTICK:
+    case META_BUTTON_FUNCTION_UNSHADE:
+    case META_BUTTON_FUNCTION_UNABOVE:
+      /* we are being asked for a >v1 button which hasn't been handled yet,
+       * so obviously we're not in a theme which supports that version.
+       * therefore, we don't show the button. return NULL and all will
+       * be well.
+       */
+      return NULL;
+
+    case META_BUTTON_FUNCTION_LAST:
+      return NULL;
+    }
+
+  return NULL;
+}
+
+static gboolean
+strip_button (MetaButtonSpace *func_rects[MAX_BUTTONS_PER_CORNER],
+              GdkRectangle    *bg_rects[MAX_BUTTONS_PER_CORNER],
+              int             *n_rects,
+              MetaButtonSpace *to_strip)
+{
+  int i;
+
+  i = 0;
+  while (i < *n_rects)
+    {
+      if (func_rects[i] == to_strip)
+        {
+          *n_rects -= 1;
+
+          /* shift the other rects back in the array */
+          while (i < *n_rects)
+            {
+              func_rects[i] = func_rects[i+1];
+              bg_rects[i] = bg_rects[i+1];
+
+              ++i;
+            }
+
+          func_rects[i] = NULL;
+          bg_rects[i] = NULL;
+
+          return TRUE;
+        }
+
+      ++i;
+    }
+
+  return FALSE; /* did not strip anything */
+}
+
+void
+meta_frame_layout_calc_geometry (const MetaFrameLayout  *layout,
+                                 int                     text_height,
+                                 MetaFrameFlags          flags,
+                                 int                     client_width,
+                                 int                     client_height,
+                                 const MetaButtonLayout *button_layout,
+                                 MetaFrameGeometry      *fgeom,
+                                 MetaTheme              *theme)
+{
+  int i, n_left, n_right, n_left_spacers, n_right_spacers;
+  int x;
+  int button_y;
+  int title_right_edge;
+  int width, height;
+  int button_width, button_height;
+  int min_size_for_rounding;
+
+  /* the left/right rects in order; the max # of rects
+   * is the number of button functions
+   */
+  MetaButtonSpace *left_func_rects[MAX_BUTTONS_PER_CORNER];
+  MetaButtonSpace *right_func_rects[MAX_BUTTONS_PER_CORNER];
+  GdkRectangle *left_bg_rects[MAX_BUTTONS_PER_CORNER];
+  gboolean left_buttons_has_spacer[MAX_BUTTONS_PER_CORNER];
+  GdkRectangle *right_bg_rects[MAX_BUTTONS_PER_CORNER];
+  gboolean right_buttons_has_spacer[MAX_BUTTONS_PER_CORNER];
+
+  meta_frame_layout_get_borders (layout, text_height,
+                                 flags,
+                                 &fgeom->top_height,
+                                 &fgeom->bottom_height,
+                                 &fgeom->left_width,
+                                 &fgeom->right_width);
+
+  width = client_width + fgeom->left_width + fgeom->right_width;
+
+  height = ((flags & META_FRAME_SHADED) ? 0: client_height) +
+    fgeom->top_height + fgeom->bottom_height;
+
+  fgeom->width = width;
+  fgeom->height = height;
+
+  fgeom->top_titlebar_edge = layout->title_border.top;
+  fgeom->bottom_titlebar_edge = layout->title_border.bottom;
+  fgeom->left_titlebar_edge = layout->left_titlebar_edge;
+  fgeom->right_titlebar_edge = layout->right_titlebar_edge;
+
+  /* gcc warnings */
+  button_width = -1;
+  button_height = -1;
+
+  switch (layout->button_sizing)
+    {
+    case META_BUTTON_SIZING_ASPECT:
+      button_height = fgeom->top_height - layout->button_border.top - layout->button_border.bottom;
+      button_width = button_height / layout->button_aspect;
+      break;
+    case META_BUTTON_SIZING_FIXED:
+      button_width = layout->button_width;
+      button_height = layout->button_height;
+      break;
+    case META_BUTTON_SIZING_LAST:
+      g_assert_not_reached ();
+      break;
+    }
+
+  /* FIXME all this code sort of pretends that duplicate buttons
+   * with the same function are allowed, but that breaks the
+   * code in frames.c, so isn't really allowed right now.
+   * Would need left_close_rect, right_close_rect, etc.
+   */
+
+  /* Init all button rects to 0, lame hack */
+  memset (ADDRESS_OF_BUTTON_RECTS (fgeom), '\0',
+          LENGTH_OF_BUTTON_RECTS);
+
+  n_left = 0;
+  n_right = 0;
+  n_left_spacers = 0;
+  n_right_spacers = 0;
+
+  if (!layout->hide_buttons)
+    {
+      /* Try to fill in rects */
+      for (i = 0; i < MAX_BUTTONS_PER_CORNER && button_layout->left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++)
+        {
+          left_func_rects[n_left] = rect_for_function (fgeom, flags,
+                                                       button_layout->left_buttons[i],
+                                                       theme);
+          if (left_func_rects[n_left] != NULL)
+            {
+              left_buttons_has_spacer[n_left] = button_layout->left_buttons_has_spacer[i];
+              if (button_layout->left_buttons_has_spacer[i])
+                ++n_left_spacers;
+
+              ++n_left;
+            }
+        }
+
+      for (i = 0; i < MAX_BUTTONS_PER_CORNER && button_layout->right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++)
+        {
+          right_func_rects[n_right] = rect_for_function (fgeom, flags,
+                                                         button_layout->right_buttons[i],
+                                                         theme);
+          if (right_func_rects[n_right] != NULL)
+            {
+              right_buttons_has_spacer[n_right] = button_layout->right_buttons_has_spacer[i];
+              if (button_layout->right_buttons_has_spacer[i])
+                ++n_right_spacers;
+
+              ++n_right;
+            }
+        }
+    }
+
+  for (i = 0; i < MAX_BUTTONS_PER_CORNER; i++)
+    {
+      left_bg_rects[i] = NULL;
+      right_bg_rects[i] = NULL;
+    }
+
+  for (i = 0; i < n_left; i++)
+    {
+      if (i == 0) /* prefer left background if only one button */
+        left_bg_rects[i] = &fgeom->left_left_background;
+      else if (i == (n_left - 1))
+        left_bg_rects[i] = &fgeom->left_right_background;
+      else
+        left_bg_rects[i] = &fgeom->left_middle_backgrounds[i - 1];
+    }
+
+  for (i = 0; i < n_right; i++)
+    {
+      /* prefer right background if only one button */
+      if (i == (n_right - 1))
+        right_bg_rects[i] = &fgeom->right_right_background;
+      else if (i == 0)
+        right_bg_rects[i] = &fgeom->right_left_background;
+      else
+        right_bg_rects[i] = &fgeom->right_middle_backgrounds[i - 1];
+    }
+
+  /* Be sure buttons fit */
+  while (n_left > 0 || n_right > 0)
+    {
+      int space_used_by_buttons;
+      int space_available;
+
+      space_available = fgeom->width - layout->left_titlebar_edge - layout->right_titlebar_edge;
+
+      space_used_by_buttons = 0;
+
+      space_used_by_buttons += button_width * n_left;
+      space_used_by_buttons += (button_width * 0.75) * n_left_spacers;
+      space_used_by_buttons += layout->button_border.left * n_left;
+      space_used_by_buttons += layout->button_border.right * n_left;
+
+      space_used_by_buttons += button_width * n_right;
+      space_used_by_buttons += (button_width * 0.75) * n_right_spacers;
+      space_used_by_buttons += layout->button_border.left * n_right;
+      space_used_by_buttons += layout->button_border.right * n_right;
+
+      if (space_used_by_buttons <= space_available)
+        break; /* Everything fits, bail out */
+
+      /* First try to remove separators */
+      if (n_left_spacers > 0)
+        {
+          left_buttons_has_spacer[--n_left_spacers] = FALSE;
+          continue;
+        }
+      else if (n_right_spacers > 0)
+        {
+          right_buttons_has_spacer[--n_right_spacers] = FALSE;
+          continue;
+        }
+
+      /* Otherwise we need to shave out a button. Shave
+       * above, stick, shade, min, max, close, then menu (menu is most useful);
+       * prefer the default button locations.
+       */
+      if (strip_button (left_func_rects, left_bg_rects,
+                        &n_left, &fgeom->above_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->above_rect))
+        continue;
+      else if (strip_button (left_func_rects, left_bg_rects,
+                        &n_left, &fgeom->stick_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->stick_rect))
+        continue;
+      else if (strip_button (left_func_rects, left_bg_rects,
+                        &n_left, &fgeom->shade_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->shade_rect))
+        continue;
+      else if (strip_button (left_func_rects, left_bg_rects,
+                        &n_left, &fgeom->min_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->min_rect))
+        continue;
+      else if (strip_button (left_func_rects, left_bg_rects,
+                             &n_left, &fgeom->max_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->max_rect))
+        continue;
+      else if (strip_button (left_func_rects, left_bg_rects,
+                             &n_left, &fgeom->close_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->close_rect))
+        continue;
+      else if (strip_button (right_func_rects, right_bg_rects,
+                             &n_right, &fgeom->menu_rect))
+        continue;
+      else if (strip_button (left_func_rects, left_bg_rects,
+                             &n_left, &fgeom->menu_rect))
+        continue;
+      else
+        {
+          meta_bug ("Could not find a button to strip. n_left = %d n_right = %d\n",
+                    n_left, n_right);
+        }
+    }
+
+  /* center buttons vertically */
+  button_y = (fgeom->top_height -
+              (button_height + layout->button_border.top + layout->button_border.bottom)) / 2 + layout->button_border.top;
+
+  /* right edge of farthest-right button */
+  x = width - layout->right_titlebar_edge;
+
+  i = n_right - 1;
+  while (i >= 0)
+    {
+      MetaButtonSpace *rect;
+
+      if (x < 0) /* if we go negative, leave the buttons we don't get to as 0-width */
+        break;
+
+      rect = right_func_rects[i];
+      rect->visible.x = x - layout->button_border.right - button_width;
+      if (right_buttons_has_spacer[i])
+        rect->visible.x -= (button_width * 0.75);
+
+      rect->visible.y = button_y;
+      rect->visible.width = button_width;
+      rect->visible.height = button_height;
+
+      if (flags & META_FRAME_MAXIMIZED)
+        {
+          rect->clickable.x = rect->visible.x;
+          rect->clickable.y = 0;
+          rect->clickable.width = rect->visible.width;
+          rect->clickable.height = button_height + button_y;
+
+          if (i == n_right - 1)
+            rect->clickable.width += layout->right_titlebar_edge + layout->right_width + layout->button_border.right;
+
+        }
+      else
+        g_memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable));
+
+      *(right_bg_rects[i]) = rect->visible;
+
+      x = rect->visible.x - layout->button_border.left;
+
+      --i;
+    }
+
+  /* save right edge of titlebar for later use */
+  title_right_edge = x - layout->title_border.right;
+
+  /* Now x changes to be position from the left and we go through
+   * the left-side buttons
+   */
+  x = layout->left_titlebar_edge;
+  for (i = 0; i < n_left; i++)
+    {
+      MetaButtonSpace *rect;
+
+      rect = left_func_rects[i];
+
+      rect->visible.x = x + layout->button_border.left;
+      rect->visible.y = button_y;
+      rect->visible.width = button_width;
+      rect->visible.height = button_height;
+
+      if (flags & META_FRAME_MAXIMIZED)
+        {
+          if (i==0)
+            {
+              rect->clickable.x = 0;
+              rect->clickable.width = button_width + x;
+            }
+          else
+            {
+              rect->clickable.x = rect->visible.x;
+              rect->clickable.width = button_width;
+            }
+
+            rect->clickable.y = 0;
+            rect->clickable.height = button_height + button_y;
+          }
+        else
+          g_memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable));
+
+
+      x = rect->visible.x + rect->visible.width + layout->button_border.right;
+      if (left_buttons_has_spacer[i])
+        x += (button_width * 0.75);
+
+      *(left_bg_rects[i]) = rect->visible;
+    }
+
+  /* We always fill as much vertical space as possible with title rect,
+   * rather than centering it like the buttons
+   */
+  fgeom->title_rect.x = x + layout->title_border.left;
+  fgeom->title_rect.y = layout->title_border.top;
+  fgeom->title_rect.width = title_right_edge - fgeom->title_rect.x;
+  fgeom->title_rect.height = fgeom->top_height - layout->title_border.top - layout->title_border.bottom;
+
+  /* Nuke title if it won't fit */
+  if (fgeom->title_rect.width < 0 ||
+      fgeom->title_rect.height < 0)
+    {
+      fgeom->title_rect.width = 0;
+      fgeom->title_rect.height = 0;
+    }
+
+  if (flags & META_FRAME_SHADED)
+    min_size_for_rounding = 0;
+  else
+    min_size_for_rounding = 5;
+
+  fgeom->top_left_corner_rounded_radius = 0;
+  fgeom->top_right_corner_rounded_radius = 0;
+  fgeom->bottom_left_corner_rounded_radius = 0;
+  fgeom->bottom_right_corner_rounded_radius = 0;
+
+  if (fgeom->top_height + fgeom->left_width >= min_size_for_rounding)
+    fgeom->top_left_corner_rounded_radius = layout->top_left_corner_rounded_radius;
+  if (fgeom->top_height + fgeom->right_width >= min_size_for_rounding)
+    fgeom->top_right_corner_rounded_radius = layout->top_right_corner_rounded_radius;
+
+  if (fgeom->bottom_height + fgeom->left_width >= min_size_for_rounding)
+    fgeom->bottom_left_corner_rounded_radius = layout->bottom_left_corner_rounded_radius;
+  if (fgeom->bottom_height + fgeom->right_width >= min_size_for_rounding)
+    fgeom->bottom_right_corner_rounded_radius = layout->bottom_right_corner_rounded_radius;
+}
+
+MetaGradientSpec*
+meta_gradient_spec_new (MetaGradientType type)
+{
+  MetaGradientSpec *spec;
+
+  spec = g_new (MetaGradientSpec, 1);
+
+  spec->type = type;
+  spec->color_specs = NULL;
+
+  return spec;
+}
+
+static void
+free_color_spec (gpointer spec, gpointer user_data)
+{
+  meta_color_spec_free (spec);
+}
+
+void
+meta_gradient_spec_free (MetaGradientSpec *spec)
+{
+  g_return_if_fail (spec != NULL);
+
+  g_slist_foreach (spec->color_specs, free_color_spec, NULL);
+  g_slist_free (spec->color_specs);
+
+  DEBUG_FILL_STRUCT (spec);
+  g_free (spec);
+}
+
+GdkPixbuf*
+meta_gradient_spec_render (const MetaGradientSpec *spec,
+                           GtkWidget              *widget,
+                           int                     width,
+                           int                     height)
+{
+  int n_colors;
+  GdkColor *colors;
+  GSList *tmp;
+  int i;
+  GdkPixbuf *pixbuf;
+
+  n_colors = g_slist_length (spec->color_specs);
+
+  if (n_colors == 0)
+    return NULL;
+
+  colors = g_new (GdkColor, n_colors);
+
+  i = 0;
+  tmp = spec->color_specs;
+  while (tmp != NULL)
+    {
+      meta_color_spec_render (tmp->data, widget, &colors[i]);
+
+      tmp = tmp->next;
+      ++i;
+    }
+
+  pixbuf = meta_gradient_create_multi (width, height,
+                                       colors, n_colors,
+                                       spec->type);
+
+  g_free (colors);
+
+  return pixbuf;
+}
+
+gboolean
+meta_gradient_spec_validate (MetaGradientSpec *spec,
+                             GError          **error)
+{
+  g_return_val_if_fail (spec != NULL, FALSE);
+
+  if (g_slist_length (spec->color_specs) < 2)
+    {
+      g_set_error (error, META_THEME_ERROR,
+                   META_THEME_ERROR_FAILED,
+                   _("Gradients should have at least two colors"));
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+MetaAlphaGradientSpec*
+meta_alpha_gradient_spec_new (MetaGradientType       type,
+                              int                    n_alphas)
+{
+  MetaAlphaGradientSpec *spec;
+
+  g_return_val_if_fail (n_alphas > 0, NULL);
+
+  spec = g_new0 (MetaAlphaGradientSpec, 1);
+
+  spec->type = type;
+  spec->alphas = g_new0 (unsigned char, n_alphas);
+  spec->n_alphas = n_alphas;
+
+  return spec;
+}
+
+void
+meta_alpha_gradient_spec_free (MetaAlphaGradientSpec *spec)
+{
+  g_return_if_fail (spec != NULL);
+
+  g_free (spec->alphas);
+  g_free (spec);
+}
+
+MetaColorSpec*
+meta_color_spec_new (MetaColorSpecType type)
+{
+  MetaColorSpec *spec;
+  MetaColorSpec dummy;
+  int size;
+
+  size = G_STRUCT_OFFSET (MetaColorSpec, data);
+
+  switch (type)
+    {
+    case META_COLOR_SPEC_BASIC:
+      size += sizeof (dummy.data.basic);
+      break;
+
+    case META_COLOR_SPEC_GTK:
+      size += sizeof (dummy.data.gtk);
+      break;
+
+    case META_COLOR_SPEC_BLEND:
+      size += sizeof (dummy.data.blend);
+      break;
+
+    case META_COLOR_SPEC_SHADE:
+      size += sizeof (dummy.data.shade);
+      break;
+    }
+
+  spec = g_malloc0 (size);
+
+  spec->type = type;
+
+  return spec;
+}
+
+void
+meta_color_spec_free (MetaColorSpec *spec)
+{
+  g_return_if_fail (spec != NULL);
+
+  switch (spec->type)
+    {
+    case META_COLOR_SPEC_BASIC:
+      DEBUG_FILL_STRUCT (&spec->data.basic);
+      break;
+
+    case META_COLOR_SPEC_GTK:
+      DEBUG_FILL_STRUCT (&spec->data.gtk);
+      break;
+
+    case META_COLOR_SPEC_BLEND:
+      if (spec->data.blend.foreground)
+        meta_color_spec_free (spec->data.blend.foreground);
+      if (spec->data.blend.background)
+        meta_color_spec_free (spec->data.blend.background);
+      DEBUG_FILL_STRUCT (&spec->data.blend);
+      break;
+
+    case META_COLOR_SPEC_SHADE:
+      if (spec->data.shade.base)
+        meta_color_spec_free (spec->data.shade.base);
+      DEBUG_FILL_STRUCT (&spec->data.shade);
+      break;
+    }
+
+  g_free (spec);
+}
+
+MetaColorSpec*
+meta_color_spec_new_from_string (const char *str,
+                                 GError    **err)
+{
+  MetaColorSpec *spec;
+
+  spec = NULL;
+
+  if (str[0] == 'g' && str[1] == 't' && str[2] == 'k' && str[3] == ':')
+    {
+      /* GTK color */
+      const char *bracket;
+      const char *end_bracket;
+      char *tmp;
+      GtkStateType state;
+      MetaGtkColorComponent component;
+
+      bracket = str;
+      while (*bracket && *bracket != '[')
+        ++bracket;
+
+      if (*bracket == '\0')
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("GTK color specification must have the state in brackets, e.g. gtk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\""),
+                       str);
+          return NULL;
+        }
+
+      end_bracket = bracket;
+      ++end_bracket;
+      while (*end_bracket && *end_bracket != ']')
+        ++end_bracket;
+
+      if (*end_bracket == '\0')
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("GTK color specification must have a close bracket after the state, e.g. gtk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\""),
+                       str);
+          return NULL;
+        }
+
+      tmp = g_strndup (bracket + 1, end_bracket - bracket - 1);
+      state = meta_gtk_state_from_string (tmp);
+      if (((int) state) == -1)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Did not understand state \"%s\" in color specification"),
+                       tmp);
+          g_free (tmp);
+          return NULL;
+        }
+      g_free (tmp);
+
+      tmp = g_strndup (str + 4, bracket - str - 4);
+      component = meta_color_component_from_string (tmp);
+      if (component == META_GTK_COLOR_LAST)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Did not understand color component \"%s\" in color specification"),
+                       tmp);
+          g_free (tmp);
+          return NULL;
+        }
+      g_free (tmp);
+
+      spec = meta_color_spec_new (META_COLOR_SPEC_GTK);
+      spec->data.gtk.state = state;
+      spec->data.gtk.component = component;
+      g_assert (spec->data.gtk.state < N_GTK_STATES);
+      g_assert (spec->data.gtk.component < META_GTK_COLOR_LAST);
+    }
+  else if (str[0] == 'b' && str[1] == 'l' && str[2] == 'e' && str[3] == 'n' &&
+           str[4] == 'd' && str[5] == '/')
+    {
+      /* blend */
+      char **split;
+      double alpha;
+      char *end;
+      MetaColorSpec *fg;
+      MetaColorSpec *bg;
+
+      split = g_strsplit (str, "/", 4);
+
+      if (split[0] == NULL || split[1] == NULL ||
+          split[2] == NULL || split[3] == NULL)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the format"),
+                       str);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      alpha = g_ascii_strtod (split[3], &end);
+      if (end == split[3])
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Could not parse alpha value \"%s\" in blended color"),
+                       split[3]);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      if (alpha < (0.0 - 1e6) || alpha > (1.0 + 1e6))
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Alpha value \"%s\" in blended color is not between 0.0 and 1.0"),
+                       split[3]);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      fg = NULL;
+      bg = NULL;
+
+      bg = meta_color_spec_new_from_string (split[1], err);
+      if (bg == NULL)
+        {
+          g_strfreev (split);
+          return NULL;
+        }
+
+      fg = meta_color_spec_new_from_string (split[2], err);
+      if (fg == NULL)
+        {
+          meta_color_spec_free (bg);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      g_strfreev (split);
+
+      spec = meta_color_spec_new (META_COLOR_SPEC_BLEND);
+      spec->data.blend.alpha = alpha;
+      spec->data.blend.background = bg;
+      spec->data.blend.foreground = fg;
+    }
+  else if (str[0] == 's' && str[1] == 'h' && str[2] == 'a' && str[3] == 'd' &&
+           str[4] == 'e' && str[5] == '/')
+    {
+      /* shade */
+      char **split;
+      double factor;
+      char *end;
+      MetaColorSpec *base;
+
+      split = g_strsplit (str, "/", 3);
+
+      if (split[0] == NULL || split[1] == NULL ||
+          split[2] == NULL)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format"),
+                       str);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      factor = g_ascii_strtod (split[2], &end);
+      if (end == split[2])
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Could not parse shade factor \"%s\" in shaded color"),
+                       split[2]);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      if (factor < (0.0 - 1e6))
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Shade factor \"%s\" in shaded color is negative"),
+                       split[2]);
+          g_strfreev (split);
+          return NULL;
+        }
+
+      base = NULL;
+
+      base = meta_color_spec_new_from_string (split[1], err);
+      if (base == NULL)
+        {
+          g_strfreev (split);
+          return NULL;
+        }
+
+      g_strfreev (split);
+
+      spec = meta_color_spec_new (META_COLOR_SPEC_SHADE);
+      spec->data.shade.factor = factor;
+      spec->data.shade.base = base;
+    }
+  else
+    {
+      spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);
+
+      if (!gdk_color_parse (str, &spec->data.basic.color))
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Could not parse color \"%s\""),
+                       str);
+          meta_color_spec_free (spec);
+          return NULL;
+        }
+    }
+
+  g_assert (spec);
+
+  return spec;
+}
+
+MetaColorSpec*
+meta_color_spec_new_gtk (MetaGtkColorComponent component,
+                         GtkStateType          state)
+{
+  MetaColorSpec *spec;
+
+  spec = meta_color_spec_new (META_COLOR_SPEC_GTK);
+
+  spec->data.gtk.component = component;
+  spec->data.gtk.state = state;
+
+  return spec;
+}
+
+void
+meta_color_spec_render (MetaColorSpec *spec,
+                        GtkWidget     *widget,
+                        GdkColor      *color)
+{
+  GtkStyle *widget_style;
+
+  g_return_if_fail (spec != NULL);
+  g_return_if_fail (GTK_IS_WIDGET (widget));
+
+  widget_style = gtk_widget_get_style (widget);
+  g_return_if_fail (widget_style != NULL);
+
+  switch (spec->type)
+    {
+    case META_COLOR_SPEC_BASIC:
+      *color = spec->data.basic.color;
+      break;
+
+    case META_COLOR_SPEC_GTK:
+      switch (spec->data.gtk.component)
+        {
+        case META_GTK_COLOR_BG:
+          *color = widget_style->bg[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_FG:
+          *color = widget_style->fg[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_BASE:
+          *color = widget_style->base[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_TEXT:
+          *color = widget_style->text[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_LIGHT:
+          *color = widget_style->light[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_DARK:
+          *color = widget_style->dark[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_MID:
+          *color = widget_style->mid[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_TEXT_AA:
+          *color = widget_style->text_aa[spec->data.gtk.state];
+          break;
+        case META_GTK_COLOR_LAST:
+          g_assert_not_reached ();
+          break;
+        }
+      break;
+
+    case META_COLOR_SPEC_BLEND:
+      {
+        GdkColor bg, fg;
+
+        meta_color_spec_render (spec->data.blend.background, widget, &bg);
+        meta_color_spec_render (spec->data.blend.foreground, widget, &fg);
+
+        color_composite (&bg, &fg, spec->data.blend.alpha,
+                         &spec->data.blend.color);
+
+        *color = spec->data.blend.color;
+      }
+      break;
+
+    case META_COLOR_SPEC_SHADE:
+      {
+        meta_color_spec_render (spec->data.shade.base, widget,
+                                &spec->data.shade.color);
+
+        gtk_style_shade (&spec->data.shade.color,
+                         &spec->data.shade.color, spec->data.shade.factor);
+
+        *color = spec->data.shade.color;
+      }
+      break;
+    }
+}
+
+/**
+ * Represents an operation as a string.
+ *
+ * \param type  an operation, such as addition
+ * \return  a string, such as "+"
+ */
+static const char*
+op_name (PosOperatorType type)
+{
+  switch (type)
+    {
+    case POS_OP_ADD:
+      return "+";
+    case POS_OP_SUBTRACT:
+      return "-";
+    case POS_OP_MULTIPLY:
+      return "*";
+    case POS_OP_DIVIDE:
+      return "/";
+    case POS_OP_MOD:
+      return "%";
+    case POS_OP_MAX:
+      return "`max`";
+    case POS_OP_MIN:
+      return "`min`";
+    case POS_OP_NONE:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+/**
+ * Parses a string and returns an operation.
+ *
+ * \param p  a pointer into a string representing an operation; part of an
+ *           expression somewhere, so not null-terminated
+ * \param len  set to the length of the string found. Set to 0 if none is.
+ * \return  the operation found. If none was, returns POS_OP_NONE.
+ */
+static PosOperatorType
+op_from_string (const char *p,
+                int        *len)
+{
+  *len = 0;
+
+  switch (*p)
+    {
+    case '+':
+      *len = 1;
+      return POS_OP_ADD;
+    case '-':
+      *len = 1;
+      return POS_OP_SUBTRACT;
+    case '*':
+      *len = 1;
+      return POS_OP_MULTIPLY;
+    case '/':
+      *len = 1;
+      return POS_OP_DIVIDE;
+    case '%':
+      *len = 1;
+      return POS_OP_MOD;
+
+    case '`':
+      if (p[0] == '`' &&
+          p[1] == 'm' &&
+          p[2] == 'a' &&
+          p[3] == 'x' &&
+          p[4] == '`')
+        {
+          *len = 5;
+          return POS_OP_MAX;
+        }
+      else if (p[0] == '`' &&
+               p[1] == 'm' &&
+               p[2] == 'i' &&
+               p[3] == 'n' &&
+               p[4] == '`')
+        {
+          *len = 5;
+          return POS_OP_MIN;
+        }
+    }
+
+  return POS_OP_NONE;
+}
+
+/**
+ * Frees an array of tokens. All the tokens and their associated memory
+ * will be freed.
+ *
+ * \param tokens  an array of tokens to be freed
+ * \param n_tokens  how many tokens are in the array.
+ */
+static void
+free_tokens (PosToken *tokens,
+             int       n_tokens)
+{
+  int i;
+
+  /* n_tokens can be 0 since tokens may have been allocated more than
+   * it was initialized
+   */
+
+  for (i = 0; i < n_tokens; i++)
+    if (tokens[i].type == POS_TOKEN_VARIABLE)
+      g_free (tokens[i].d.v.name);
+
+  g_free (tokens);
+}
+
+/**
+ * Tokenises a number in an expression.
+ *
+ * \param p  a pointer into a string representing an operation; part of an
+ *           expression somewhere, so not null-terminated
+ * \param end_return  set to a pointer to the end of the number found; but
+ *                    not updated if no number was found at all
+ * \param next  set to either an integer or a float token
+ * \param[out] err  set to the problem if there was a problem
+ * \return TRUE if a valid number was found, FALSE otherwise (and "err" will
+ *         have been set)
+ *
+ * \bug The "while (*start)..." part: what's wrong with strchr-ish things?
+ * \bug The name is wrong: it doesn't parse anything.
+ * \ingroup tokenizer
+ */
+static gboolean
+parse_number (const char  *p,
+              const char **end_return,
+              PosToken    *next,
+              GError     **err)
+{
+  const char *start = p;
+  char *end;
+  gboolean is_float;
+  char *num_str;
+
+  while (*p && (*p == '.' || g_ascii_isdigit (*p)))
+    ++p;
+
+  if (p == start)
+    {
+      char buf[7] = { '\0' };
+      buf[g_unichar_to_utf8 (g_utf8_get_char (p), buf)] = '\0';
+      g_set_error (err, META_THEME_ERROR,
+                   META_THEME_ERROR_BAD_CHARACTER,
+                   _("Coordinate expression contains character '%s' which is not allowed"),
+                   buf);
+      return FALSE;
+    }
+
+  *end_return = p;
+
+  /* we need this to exclude floats like "1e6" */
+  num_str = g_strndup (start, p - start);
+  start = num_str;
+  is_float = FALSE;
+  while (*start)
+    {
+      if (*start == '.')
+        is_float = TRUE;
+      ++start;
+    }
+
+  if (is_float)
+    {
+      next->type = POS_TOKEN_DOUBLE;
+      next->d.d.val = g_ascii_strtod (num_str, &end);
+
+      if (end == num_str)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression contains floating point number '%s' which could not be parsed"),
+                       num_str);
+          g_free (num_str);
+          return FALSE;
+        }
+    }
+  else
+    {
+      next->type = POS_TOKEN_INT;
+      next->d.i.val = strtol (num_str, &end, 10);
+      if (end == num_str)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression contains integer '%s' which could not be parsed"),
+                       num_str);
+          g_free (num_str);
+          return FALSE;
+        }
+    }
+
+  g_free (num_str);
+
+  g_assert (next->type == POS_TOKEN_INT || next->type == POS_TOKEN_DOUBLE);
+
+  return TRUE;
+}
+
+/**
+ * Whether a variable can validly appear as part of the name of a variable.
+ */
+#define IS_VARIABLE_CHAR(c) (g_ascii_isalpha ((c)) || (c) == '_')
+
+#if 0
+static void
+debug_print_tokens (PosToken *tokens,
+                    int       n_tokens)
+{
+  int i;
+
+  for (i = 0; i < n_tokens; i++)
+    {
+      PosToken *t = &tokens[i];
+
+      g_print (" ");
+
+      switch (t->type)
+        {
+        case POS_TOKEN_INT:
+          g_print ("\"%d\"", t->d.i.val);
+          break;
+        case POS_TOKEN_DOUBLE:
+          g_print ("\"%g\"", t->d.d.val);
+          break;
+        case POS_TOKEN_OPEN_PAREN:
+          g_print ("\"(\"");
+          break;
+        case POS_TOKEN_CLOSE_PAREN:
+          g_print ("\")\"");
+          break;
+        case POS_TOKEN_VARIABLE:
+          g_print ("\"%s\"", t->d.v.name);
+          break;
+        case POS_TOKEN_OPERATOR:
+          g_print ("\"%s\"", op_name (t->d.o.op));
+          break;
+        }
+    }
+
+  g_print ("\n");
+}
+#endif
+
+/**
+ * Tokenises an expression.
+ *
+ * \param      expr        The expression
+ * \param[out] tokens_p    The resulting tokens
+ * \param[out] n_tokens_p  The number of resulting tokens
+ * \param[out] err  set to the problem if there was a problem
+ *
+ * \return  True if the expression was successfully tokenised; false otherwise.
+ *
+ * \ingroup tokenizer
+ */
+static gboolean
+pos_tokenize (const char  *expr,
+              PosToken   **tokens_p,
+              int         *n_tokens_p,
+              GError     **err)
+{
+  PosToken *tokens;
+  int n_tokens;
+  int allocated;
+  const char *p;
+
+  *tokens_p = NULL;
+  *n_tokens_p = 0;
+
+  allocated = 3;
+  n_tokens = 0;
+  tokens = g_new (PosToken, allocated);
+
+  p = expr;
+  while (*p)
+    {
+      PosToken *next;
+      int len;
+
+      if (n_tokens == allocated)
+        {
+          allocated *= 2;
+          tokens = g_renew (PosToken, tokens, allocated);
+        }
+
+      next = &tokens[n_tokens];
+
+      switch (*p)
+        {
+        case '*':
+        case '/':
+        case '+':
+        case '-': /* negative numbers aren't allowed so this is easy */
+        case '%':
+        case '`':
+          next->type = POS_TOKEN_OPERATOR;
+          next->d.o.op = op_from_string (p, &len);
+          if (next->d.o.op != POS_OP_NONE)
+            {
+              ++n_tokens;
+              p = p + (len - 1); /* -1 since we ++p later */
+            }
+          else
+            {
+              g_set_error (err, META_THEME_ERROR,
+                           META_THEME_ERROR_FAILED,
+                           _("Coordinate expression contained unknown operator at the start of this text: \"%s\""),
+                           p);
+
+              goto error;
+            }
+          break;
+
+        case '(':
+          next->type = POS_TOKEN_OPEN_PAREN;
+          ++n_tokens;
+          break;
+
+        case ')':
+          next->type = POS_TOKEN_CLOSE_PAREN;
+          ++n_tokens;
+          break;
+
+        case ' ':
+        case '\t':
+        case '\n':
+          break;
+
+        default:
+          if (IS_VARIABLE_CHAR (*p))
+            {
+              /* Assume variable */
+              const char *start = p;
+              while (*p && IS_VARIABLE_CHAR (*p))
+                ++p;
+              g_assert (p != start);
+              next->type = POS_TOKEN_VARIABLE;
+              next->d.v.name = g_strndup (start, p - start);
+              ++n_tokens;
+              --p; /* since we ++p again at the end of while loop */
+            }
+          else
+            {
+              /* Assume number */
+              const char *end;
+
+              if (!parse_number (p, &end, next, err))
+                goto error;
+
+              ++n_tokens;
+              p = end - 1; /* -1 since we ++p again at the end of while loop */
+            }
+
+          break;
+        }
+
+      ++p;
+    }
+
+  if (n_tokens == 0)
+    {
+      g_set_error (err, META_THEME_ERROR,
+                   META_THEME_ERROR_FAILED,
+                   _("Coordinate expression was empty or not understood"));
+
+      goto error;
+    }
+
+  *tokens_p = tokens;
+  *n_tokens_p = n_tokens;
+
+  return TRUE;
+
+ error:
+  g_assert (err == NULL || *err != NULL);
+
+  free_tokens (tokens, n_tokens);
+  return FALSE;
+}
+
+/**
+ * The type of a PosExpr: either integer, double, or an operation.
+ * \ingroup parser
+ */
+typedef enum
+{
+  POS_EXPR_INT,
+  POS_EXPR_DOUBLE,
+  POS_EXPR_OPERATOR
+} PosExprType;
+
+/**
+ * Type and value of an expression in a parsed sequence. We don't
+ * keep expressions in a tree; if this is of type POS_EXPR_OPERATOR,
+ * the arguments of the operator will be in the array positions
+ * immediately preceding and following this operator; they cannot
+ * themselves be operators.
+ *
+ * \bug operator is char; it should really be of PosOperatorType.
+ * \ingroup parser
+ */
+typedef struct
+{
+  PosExprType type;
+  union
+  {
+    double double_val;
+    int int_val;
+    char operator;
+  } d;
+} PosExpr;
+
+#if 0
+static void
+debug_print_exprs (PosExpr *exprs,
+                   int      n_exprs)
+{
+  int i;
+
+  for (i = 0; i < n_exprs; i++)
+    {
+      switch (exprs[i].type)
+        {
+        case POS_EXPR_INT:
+          g_print (" %d", exprs[i].d.int_val);
+          break;
+        case POS_EXPR_DOUBLE:
+          g_print (" %g", exprs[i].d.double_val);
+          break;
+        case POS_EXPR_OPERATOR:
+          g_print (" %s", op_name (exprs[i].d.operator));
+          break;
+        }
+    }
+  g_print ("\n");
+}
+#endif
+
+static gboolean
+do_operation (PosExpr *a,
+              PosExpr *b,
+              PosOperatorType op,
+              GError **err)
+{
+  /* Promote types to double if required */
+  if (a->type == POS_EXPR_DOUBLE ||
+      b->type == POS_EXPR_DOUBLE)
+    {
+      if (a->type != POS_EXPR_DOUBLE)
+        {
+          a->type = POS_EXPR_DOUBLE;
+          a->d.double_val = a->d.int_val;
+        }
+      if (b->type != POS_EXPR_DOUBLE)
+        {
+          b->type = POS_EXPR_DOUBLE;
+          b->d.double_val = b->d.int_val;
+        }
+    }
+
+  g_assert (a->type == b->type);
+
+  if (a->type == POS_EXPR_INT)
+    {
+      switch (op)
+        {
+        case POS_OP_MULTIPLY:
+          a->d.int_val = a->d.int_val * b->d.int_val;
+          break;
+        case POS_OP_DIVIDE:
+          if (b->d.int_val == 0)
+            {
+              g_set_error (err, META_THEME_ERROR,
+                           META_THEME_ERROR_DIVIDE_BY_ZERO,
+                           _("Coordinate expression results in division by zero"));
+              return FALSE;
+            }
+          a->d.int_val = a->d.int_val / b->d.int_val;
+          break;
+        case POS_OP_MOD:
+          if (b->d.int_val == 0)
+            {
+              g_set_error (err, META_THEME_ERROR,
+                           META_THEME_ERROR_DIVIDE_BY_ZERO,
+                           _("Coordinate expression results in division by zero"));
+              return FALSE;
+            }
+          a->d.int_val = a->d.int_val % b->d.int_val;
+          break;
+        case POS_OP_ADD:
+          a->d.int_val = a->d.int_val + b->d.int_val;
+          break;
+        case POS_OP_SUBTRACT:
+          a->d.int_val = a->d.int_val - b->d.int_val;
+          break;
+        case POS_OP_MAX:
+          a->d.int_val = MAX (a->d.int_val, b->d.int_val);
+          break;
+        case POS_OP_MIN:
+          a->d.int_val = MIN (a->d.int_val, b->d.int_val);
+          break;
+        case POS_OP_NONE:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+  else if (a->type == POS_EXPR_DOUBLE)
+    {
+      switch (op)
+        {
+        case POS_OP_MULTIPLY:
+          a->d.double_val = a->d.double_val * b->d.double_val;
+          break;
+        case POS_OP_DIVIDE:
+          if (b->d.double_val == 0.0)
+            {
+              g_set_error (err, META_THEME_ERROR,
+                           META_THEME_ERROR_DIVIDE_BY_ZERO,
+                           _("Coordinate expression results in division by zero"));
+              return FALSE;
+            }
+          a->d.double_val = a->d.double_val / b->d.double_val;
+          break;
+        case POS_OP_MOD:
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_MOD_ON_FLOAT,
+                       _("Coordinate expression tries to use mod operator on a floating-point number"));
+          return FALSE;
+        case POS_OP_ADD:
+          a->d.double_val = a->d.double_val + b->d.double_val;
+          break;
+        case POS_OP_SUBTRACT:
+          a->d.double_val = a->d.double_val - b->d.double_val;
+          break;
+        case POS_OP_MAX:
+          a->d.double_val = MAX (a->d.double_val, b->d.double_val);
+          break;
+        case POS_OP_MIN:
+          a->d.double_val = MIN (a->d.double_val, b->d.double_val);
+          break;
+        case POS_OP_NONE:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+  else
+    g_assert_not_reached ();
+
+  return TRUE;
+}
+
+static gboolean
+do_operations (PosExpr *exprs,
+               int     *n_exprs,
+               int      precedence,
+               GError **err)
+{
+  int i;
+
+#if 0
+  g_print ("Doing prec %d ops on %d exprs\n", precedence, *n_exprs);
+  debug_print_exprs (exprs, *n_exprs);
+#endif
+
+  i = 1;
+  while (i < *n_exprs)
+    {
+      gboolean compress;
+
+      /* exprs[i-1] first operand
+       * exprs[i]   operator
+       * exprs[i+1] second operand
+       *
+       * we replace first operand with result of mul/div/mod,
+       * or skip over operator and second operand if we have
+       * an add/subtract
+       */
+
+      if (exprs[i-1].type == POS_EXPR_OPERATOR)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression has an operator \"%s\" where an operand was expected"),
+                       op_name (exprs[i-1].d.operator));
+          return FALSE;
+        }
+
+      if (exprs[i].type != POS_EXPR_OPERATOR)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression had an operand where an operator was expected"));
+          return FALSE;
+        }
+
+      if (i == (*n_exprs - 1))
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression ended with an operator instead of an operand"));
+          return FALSE;
+        }
+
+      g_assert ((i+1) < *n_exprs);
+
+      if (exprs[i+1].type == POS_EXPR_OPERATOR)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression has operator \"%c\" following operator \"%c\" with no operand in between"),
+                       exprs[i+1].d.operator,
+                       exprs[i].d.operator);
+          return FALSE;
+        }
+
+      compress = FALSE;
+
+      switch (precedence)
+        {
+        case 2:
+          switch (exprs[i].d.operator)
+            {
+            case POS_OP_DIVIDE:
+            case POS_OP_MOD:
+            case POS_OP_MULTIPLY:
+              compress = TRUE;
+              if (!do_operation (&exprs[i-1], &exprs[i+1],
+                                 exprs[i].d.operator,
+                                 err))
+                return FALSE;
+              break;
+            }
+          break;
+        case 1:
+          switch (exprs[i].d.operator)
+            {
+            case POS_OP_ADD:
+            case POS_OP_SUBTRACT:
+              compress = TRUE;
+              if (!do_operation (&exprs[i-1], &exprs[i+1],
+                                 exprs[i].d.operator,
+                                 err))
+                return FALSE;
+              break;
+            }
+          break;
+          /* I have no rationale at all for making these low-precedence */
+        case 0:
+          switch (exprs[i].d.operator)
+            {
+            case POS_OP_MAX:
+            case POS_OP_MIN:
+              compress = TRUE;
+              if (!do_operation (&exprs[i-1], &exprs[i+1],
+                                 exprs[i].d.operator,
+                                 err))
+                return FALSE;
+              break;
+            }
+          break;
+        }
+
+      if (compress)
+        {
+          /* exprs[i-1] first operand (now result)
+           * exprs[i]   operator
+           * exprs[i+1] second operand
+           * exprs[i+2] new operator
+           *
+           * we move new operator just after first operand
+           */
+          if ((i+2) < *n_exprs)
+            {
+              g_memmove (&exprs[i], &exprs[i+2],
+                         sizeof (PosExpr) * (*n_exprs - i - 2));
+            }
+
+          *n_exprs -= 2;
+        }
+      else
+        {
+          /* Skip operator and next operand */
+          i += 2;
+        }
+    }
+
+  return TRUE;
+}
+
+/**
+ * There is a predefined set of variables which can appear in an expression.
+ * Here we take a token representing a variable, and return the current value
+ * of that variable in a particular environment.
+ * (The value is always an integer.)
+ *
+ * There are supposedly some circumstances in which this function can be
+ * called from outside Marco, in which case env->theme will be NULL, and
+ * therefore we can't use it to find out quark values, so we do the comparison
+ * using strcmp, which is slower.
+ *
+ * \param t  The token representing a variable
+ * \param[out] result  The value of that variable; not set if the token did
+ *                     not represent a known variable
+ * \param env  The environment within which t should be evaluated
+ * \param[out] err  set to the problem if there was a problem
+ *
+ * \return true if we found the variable asked for, false if we didn't
+ *
+ * \bug shouldn't t be const?
+ * \bug we should perhaps consider some sort of lookup arrangement into an
+ *      array; also, the duplication of code is unlovely; perhaps using glib
+ *      string hashes instead of quarks would fix both problems?
+ * \ingroup parser
+ */
+static gboolean
+pos_eval_get_variable (PosToken                  *t,
+                       int                       *result,
+                       const MetaPositionExprEnv *env,
+                       GError                   **err)
+{
+  if (env->theme)
+    {
+      if (t->d.v.name_quark == env->theme->quark_width)
+        *result = env->rect.width;
+      else if (t->d.v.name_quark == env->theme->quark_height)
+        *result = env->rect.height;
+      else if (env->object_width >= 0 &&
+               t->d.v.name_quark == env->theme->quark_object_width)
+        *result = env->object_width;
+      else if (env->object_height >= 0 &&
+               t->d.v.name_quark == env->theme->quark_object_height)
+        *result = env->object_height;
+      else if (t->d.v.name_quark == env->theme->quark_left_width)
+        *result = env->left_width;
+      else if (t->d.v.name_quark == env->theme->quark_right_width)
+        *result = env->right_width;
+      else if (t->d.v.name_quark == env->theme->quark_top_height)
+        *result = env->top_height;
+      else if (t->d.v.name_quark == env->theme->quark_bottom_height)
+        *result = env->bottom_height;
+      else if (t->d.v.name_quark == env->theme->quark_mini_icon_width)
+        *result = env->mini_icon_width;
+      else if (t->d.v.name_quark == env->theme->quark_mini_icon_height)
+        *result = env->mini_icon_height;
+      else if (t->d.v.name_quark == env->theme->quark_icon_width)
+        *result = env->icon_width;
+      else if (t->d.v.name_quark == env->theme->quark_icon_height)
+        *result = env->icon_height;
+      else if (t->d.v.name_quark == env->theme->quark_title_width)
+        *result = env->title_width;
+      else if (t->d.v.name_quark == env->theme->quark_title_height)
+        *result = env->title_height;
+      else
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_UNKNOWN_VARIABLE,
+                       _("Coordinate expression had unknown variable or constant \"%s\""),
+                       t->d.v.name);
+          return FALSE;
+        }
+    }
+  else
+    {
+      if (strcmp (t->d.v.name, "width") == 0)
+        *result = env->rect.width;
+      else if (strcmp (t->d.v.name, "height") == 0)
+        *result = env->rect.height;
+      else if (env->object_width >= 0 &&
+               strcmp (t->d.v.name, "object_width") == 0)
+        *result = env->object_width;
+      else if (env->object_height >= 0 &&
+               strcmp (t->d.v.name, "object_height") == 0)
+        *result = env->object_height;
+      else if (strcmp (t->d.v.name, "left_width") == 0)
+        *result = env->left_width;
+      else if (strcmp (t->d.v.name, "right_width") == 0)
+        *result = env->right_width;
+      else if (strcmp (t->d.v.name, "top_height") == 0)
+        *result = env->top_height;
+      else if (strcmp (t->d.v.name, "bottom_height") == 0)
+        *result = env->bottom_height;
+      else if (strcmp (t->d.v.name, "mini_icon_width") == 0)
+        *result = env->mini_icon_width;
+      else if (strcmp (t->d.v.name, "mini_icon_height") == 0)
+        *result = env->mini_icon_height;
+      else if (strcmp (t->d.v.name, "icon_width") == 0)
+        *result = env->icon_width;
+      else if (strcmp (t->d.v.name, "icon_height") == 0)
+        *result = env->icon_height;
+      else if (strcmp (t->d.v.name, "title_width") == 0)
+        *result = env->title_width;
+      else if (strcmp (t->d.v.name, "title_height") == 0)
+        *result = env->title_height;
+      else
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_UNKNOWN_VARIABLE,
+                       _("Coordinate expression had unknown variable or constant \"%s\""),
+                       t->d.v.name);
+          return FALSE;
+        }
+    }
+
+  return TRUE;
+}
+
+/**
+ * Evaluates a sequence of tokens within a particular environment context,
+ * and returns the current value. May recur if parantheses are found.
+ *
+ * \param tokens  A list of tokens to evaluate.
+ * \param n_tokens  How many tokens are in the list.
+ * \param env  The environment context in which to evaluate the expression.
+ * \param[out] result  The current value of the expression
+ *
+ * \bug Yes, we really do reparse the expression every time it's evaluated.
+ *      We should keep the parse tree around all the time and just
+ *      run the new values through it.
+ * \ingroup parser
+ */
+static gboolean
+pos_eval_helper (PosToken                   *tokens,
+                 int                         n_tokens,
+                 const MetaPositionExprEnv  *env,
+                 PosExpr                    *result,
+                 GError                    **err)
+{
+  /* Lazy-ass hardcoded limit on number of terms in expression */
+#define MAX_EXPRS 32
+  int paren_level;
+  int first_paren;
+  int i;
+  PosExpr exprs[MAX_EXPRS];
+  int n_exprs;
+  int precedence;
+
+  /* Our first goal is to get a list of PosExpr, essentially
+   * substituting variables and handling parentheses.
+   */
+
+  first_paren = 0;
+  paren_level = 0;
+  n_exprs = 0;
+  for (i = 0; i < n_tokens; i++)
+    {
+      PosToken *t = &tokens[i];
+
+      if (n_exprs >= MAX_EXPRS)
+        {
+          g_set_error (err, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Coordinate expression parser overflowed its buffer."));
+          return FALSE;
+        }
+
+      if (paren_level == 0)
+        {
+          switch (t->type)
+            {
+            case POS_TOKEN_INT:
+              exprs[n_exprs].type = POS_EXPR_INT;
+              exprs[n_exprs].d.int_val = t->d.i.val;
+              ++n_exprs;
+              break;
+
+            case POS_TOKEN_DOUBLE:
+              exprs[n_exprs].type = POS_EXPR_DOUBLE;
+              exprs[n_exprs].d.double_val = t->d.d.val;
+              ++n_exprs;
+              break;
+
+            case POS_TOKEN_OPEN_PAREN:
+              ++paren_level;
+              if (paren_level == 1)
+                first_paren = i;
+              break;
+
+            case POS_TOKEN_CLOSE_PAREN:
+              g_set_error (err, META_THEME_ERROR,
+                           META_THEME_ERROR_BAD_PARENS,
+                           _("Coordinate expression had a close parenthesis with no open parenthesis"));
+              return FALSE;
+
+            case POS_TOKEN_VARIABLE:
+              exprs[n_exprs].type = POS_EXPR_INT;
+
+              /* FIXME we should just dump all this crap
+               * in a hash, maybe keep width/height out
+               * for optimization purposes
+               */
+              if (!pos_eval_get_variable (t, &exprs[n_exprs].d.int_val, env, err))
+                return FALSE;
+
+              ++n_exprs;
+              break;
+
+            case POS_TOKEN_OPERATOR:
+              exprs[n_exprs].type = POS_EXPR_OPERATOR;
+              exprs[n_exprs].d.operator = t->d.o.op;
+              ++n_exprs;
+              break;
+            }
+        }
+      else
+        {
+          g_assert (paren_level > 0);
+
+          switch (t->type)
+            {
+            case POS_TOKEN_INT:
+            case POS_TOKEN_DOUBLE:
+            case POS_TOKEN_VARIABLE:
+            case POS_TOKEN_OPERATOR:
+              break;
+
+            case POS_TOKEN_OPEN_PAREN:
+              ++paren_level;
+              break;
+
+            case POS_TOKEN_CLOSE_PAREN:
+              if (paren_level == 1)
+                {
+                  /* We closed a toplevel paren group, so recurse */
+                  if (!pos_eval_helper (&tokens[first_paren+1],
+                                        i - first_paren - 1,
+                                        env,
+                                        &exprs[n_exprs],
+                                        err))
+                    return FALSE;
+
+                  ++n_exprs;
+                }
+
+              --paren_level;
+              break;
+
+            }
+        }
+    }
+
+  if (paren_level > 0)
+    {
+      g_set_error (err, META_THEME_ERROR,
+                   META_THEME_ERROR_BAD_PARENS,
+                   _("Coordinate expression had an open parenthesis with no close parenthesis"));
+      return FALSE;
+    }
+
+  /* Now we have no parens and no vars; so we just do all the multiplies
+   * and divides, then all the add and subtract.
+   */
+  if (n_exprs == 0)
+    {
+      g_set_error (err, META_THEME_ERROR,
+                   META_THEME_ERROR_FAILED,
+                   _("Coordinate expression doesn't seem to have any operators or operands"));
+      return FALSE;
+    }
+
+  /* precedence 1 ops */
+  precedence = 2;
+  while (precedence >= 0)
+    {
+      if (!do_operations (exprs, &n_exprs, precedence, err))
+        return FALSE;
+      --precedence;
+    }
+
+  g_assert (n_exprs == 1);
+
+  *result = *exprs;
+
+  return TRUE;
+}
+
+/*
+ *   expr = int | double | expr * expr | expr / expr |
+ *          expr + expr | expr - expr | (expr)
+ *
+ *   so very not worth fooling with bison, yet so very painful by hand.
+ */
+/**
+ * Evaluates an expression.
+ *
+ * \param spec  The expression to evaluate.
+ * \param env   The environment context to evaluate the expression in.
+ * \param[out] val_p  The integer value of the expression; if the expression
+ *                    is of type float, this will be rounded. If we return
+ *                    FALSE because the expression is invalid, this will be
+ *                    zero.
+ * \param[out] err    The error, if anything went wrong.
+ *
+ * \return  True if we evaluated the expression successfully; false otherwise.
+ *
+ * \bug Shouldn't spec be const?
+ * \ingroup parser
+ */
+static gboolean
+pos_eval (MetaDrawSpec              *spec,
+          const MetaPositionExprEnv *env,
+          int                       *val_p,
+          GError                   **err)
+{
+  PosExpr expr;
+
+  *val_p = 0;
+
+  if (pos_eval_helper (spec->tokens, spec->n_tokens, env, &expr, err))
+    {
+      switch (expr.type)
+        {
+        case POS_EXPR_INT:
+          *val_p = expr.d.int_val;
+          break;
+        case POS_EXPR_DOUBLE:
+          *val_p = expr.d.double_val;
+          break;
+        case POS_EXPR_OPERATOR:
+          g_assert_not_reached ();
+          break;
+        }
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+/* We always return both X and Y, but only one will be meaningful in
+ * most contexts.
+ */
+
+gboolean
+meta_parse_position_expression (MetaDrawSpec              *spec,
+                                const MetaPositionExprEnv *env,
+                                int                       *x_return,
+                                int                       *y_return,
+                                GError                   **err)
+{
+  /* All positions are in a coordinate system with x, y at the origin.
+   * The expression can have -, +, *, / as operators, floating point
+   * or integer constants, and the variables "width" and "height" and
+   * optionally "object_width" and object_height". Negative numbers
+   * aren't allowed.
+   */
+  int val;
+
+  if (spec->constant)
+    val = spec->value;
+  else
+    {
+      if (pos_eval (spec, env, &spec->value, err) == FALSE)
+        {
+          g_assert (err == NULL || *err != NULL);
+          return FALSE;
+        }
+
+      val = spec->value;
+    }
+
+  if (x_return)
+    *x_return = env->rect.x + val;
+  if (y_return)
+    *y_return = env->rect.y + val;
+
+  return TRUE;
+}
+
+
+gboolean
+meta_parse_size_expression (MetaDrawSpec              *spec,
+                            const MetaPositionExprEnv *env,
+                            int                       *val_return,
+                            GError                   **err)
+{
+  int val;
+
+  if (spec->constant)
+    val = spec->value;
+  else
+    {
+      if (pos_eval (spec, env, &spec->value, err) == FALSE)
+        {
+          g_assert (err == NULL || *err != NULL);
+          return FALSE;
+        }
+
+      val = spec->value;
+    }
+
+  if (val_return)
+    *val_return = MAX (val, 1); /* require that sizes be at least 1x1 */
+
+  return TRUE;
+}
+
+/* To do this we tokenize, replace variable tokens
+ * that are constants, then reassemble. The purpose
+ * here is to optimize expressions so we don't do hash
+ * lookups to eval them. Obviously it's a tradeoff that
+ * slows down theme load times.
+ */
+gboolean
+meta_theme_replace_constants (MetaTheme   *theme,
+                              PosToken    *tokens,
+                              int          n_tokens,
+                              GError     **err)
+{
+  int i;
+  double dval;
+  int ival;
+  gboolean is_constant = TRUE;
+
+  /* Loop through tokenized string looking for variables to replace */
+  for (i = 0; i < n_tokens; i++)
+    {
+      PosToken *t = &tokens[i];
+
+      if (t->type == POS_TOKEN_VARIABLE)
+        {
+          if (meta_theme_lookup_int_constant (theme, t->d.v.name, &ival))
+            {
+              g_free (t->d.v.name);
+              t->type = POS_TOKEN_INT;
+              t->d.i.val = ival;
+            }
+          else if (meta_theme_lookup_float_constant (theme, t->d.v.name, &dval))
+            {
+              g_free (t->d.v.name);
+              t->type = POS_TOKEN_DOUBLE;
+              t->d.d.val = dval;
+            }
+          else
+            {
+              /* If we've found a variable that cannot be replaced then the
+                 expression is not a constant expression and we want to
+                 replace it with a GQuark */
+
+              t->d.v.name_quark = g_quark_from_string (t->d.v.name);
+              is_constant = FALSE;
+            }
+        }
+    }
+
+  return is_constant;
+}
+
+static int
+parse_x_position_unchecked (MetaDrawSpec              *spec,
+                            const MetaPositionExprEnv *env)
+{
+  int retval;
+  GError *error;
+
+  retval = 0;
+  error = NULL;
+  if (!meta_parse_position_expression (spec, env, &retval, NULL, &error))
+    {
+      meta_warning (_("Theme contained an expression that resulted in an error: %s\n"),
+                    error->message);
+
+      g_error_free (error);
+    }
+
+  return retval;
+}
+
+static int
+parse_y_position_unchecked (MetaDrawSpec              *spec,
+                            const MetaPositionExprEnv *env)
+{
+  int retval;
+  GError *error;
+
+  retval = 0;
+  error = NULL;
+  if (!meta_parse_position_expression (spec, env, NULL, &retval, &error))
+    {
+      meta_warning (_("Theme contained an expression that resulted in an error: %s\n"),
+                    error->message);
+
+      g_error_free (error);
+    }
+
+  return retval;
+}
+
+static int
+parse_size_unchecked (MetaDrawSpec        *spec,
+                      MetaPositionExprEnv *env)
+{
+  int retval;
+  GError *error;
+
+  retval = 0;
+  error = NULL;
+  if (!meta_parse_size_expression (spec, env, &retval, &error))
+    {
+      meta_warning (_("Theme contained an expression that resulted in an error: %s\n"),
+                    error->message);
+
+      g_error_free (error);
+    }
+
+  return retval;
+}
+
+void
+meta_draw_spec_free (MetaDrawSpec *spec)
+{
+  if (!spec) return;
+  free_tokens (spec->tokens, spec->n_tokens);
+  g_slice_free (MetaDrawSpec, spec);
+}
+
+MetaDrawSpec *
+meta_draw_spec_new (MetaTheme  *theme,
+                    const char *expr,
+                    GError    **error)
+{
+  MetaDrawSpec *spec;
+
+  spec = g_slice_new0 (MetaDrawSpec);
+
+  pos_tokenize (expr, &spec->tokens, &spec->n_tokens, NULL);
+
+  spec->constant = meta_theme_replace_constants (theme, spec->tokens,
+                                                 spec->n_tokens, NULL);
+  if (spec->constant)
+    {
+      gboolean result;
+
+      result = pos_eval (spec, NULL, &spec->value, error);
+      if (result == FALSE)
+        {
+          meta_draw_spec_free (spec);
+          return NULL;
+        }
+    }
+
+  return spec;
+}
+
+MetaDrawOp*
+meta_draw_op_new (MetaDrawType type)
+{
+  MetaDrawOp *op;
+  MetaDrawOp dummy;
+  int size;
+
+  size = G_STRUCT_OFFSET (MetaDrawOp, data);
+
+  switch (type)
+    {
+    case META_DRAW_LINE:
+      size += sizeof (dummy.data.line);
+      break;
+
+    case META_DRAW_RECTANGLE:
+      size += sizeof (dummy.data.rectangle);
+      break;
+
+    case META_DRAW_ARC:
+      size += sizeof (dummy.data.arc);
+      break;
+
+    case META_DRAW_CLIP:
+      size += sizeof (dummy.data.clip);
+      break;
+
+    case META_DRAW_TINT:
+      size += sizeof (dummy.data.tint);
+      break;
+
+    case META_DRAW_GRADIENT:
+      size += sizeof (dummy.data.gradient);
+      break;
+
+    case META_DRAW_IMAGE:
+      size += sizeof (dummy.data.image);
+      break;
+
+    case META_DRAW_GTK_ARROW:
+      size += sizeof (dummy.data.gtk_arrow);
+      break;
+
+    case META_DRAW_GTK_BOX:
+      size += sizeof (dummy.data.gtk_box);
+      break;
+
+    case META_DRAW_GTK_VLINE:
+      size += sizeof (dummy.data.gtk_vline);
+      break;
+
+    case META_DRAW_ICON:
+      size += sizeof (dummy.data.icon);
+      break;
+
+    case META_DRAW_TITLE:
+      size += sizeof (dummy.data.title);
+      break;
+    case META_DRAW_OP_LIST:
+      size += sizeof (dummy.data.op_list);
+      break;
+    case META_DRAW_TILE:
+      size += sizeof (dummy.data.tile);
+      break;
+    }
+
+  op = g_malloc0 (size);
+
+  op->type = type;
+
+  return op;
+}
+
+void
+meta_draw_op_free (MetaDrawOp *op)
+{
+  g_return_if_fail (op != NULL);
+
+  switch (op->type)
+    {
+    case META_DRAW_LINE:
+      if (op->data.line.color_spec)
+        meta_color_spec_free (op->data.line.color_spec);
+
+      meta_draw_spec_free (op->data.line.x1);
+      meta_draw_spec_free (op->data.line.y1);
+      meta_draw_spec_free (op->data.line.x2);
+      meta_draw_spec_free (op->data.line.y2);
+      break;
+
+    case META_DRAW_RECTANGLE:
+      if (op->data.rectangle.color_spec)
+        g_free (op->data.rectangle.color_spec);
+
+      meta_draw_spec_free (op->data.rectangle.x);
+      meta_draw_spec_free (op->data.rectangle.y);
+      meta_draw_spec_free (op->data.rectangle.width);
+      meta_draw_spec_free (op->data.rectangle.height);
+      break;
+
+    case META_DRAW_ARC:
+      if (op->data.arc.color_spec)
+        g_free (op->data.arc.color_spec);
+
+      meta_draw_spec_free (op->data.arc.x);
+      meta_draw_spec_free (op->data.arc.y);
+      meta_draw_spec_free (op->data.arc.width);
+      meta_draw_spec_free (op->data.arc.height);
+      break;
+
+    case META_DRAW_CLIP:
+      meta_draw_spec_free (op->data.clip.x);
+      meta_draw_spec_free (op->data.clip.y);
+      meta_draw_spec_free (op->data.clip.width);
+      meta_draw_spec_free (op->data.clip.height);
+      break;
+
+    case META_DRAW_TINT:
+      if (op->data.tint.color_spec)
+        meta_color_spec_free (op->data.tint.color_spec);
+
+      if (op->data.tint.alpha_spec)
+        meta_alpha_gradient_spec_free (op->data.tint.alpha_spec);
+
+      meta_draw_spec_free (op->data.tint.x);
+      meta_draw_spec_free (op->data.tint.y);
+      meta_draw_spec_free (op->data.tint.width);
+      meta_draw_spec_free (op->data.tint.height);
+      break;
+
+    case META_DRAW_GRADIENT:
+      if (op->data.gradient.gradient_spec)
+        meta_gradient_spec_free (op->data.gradient.gradient_spec);
+
+      if (op->data.gradient.alpha_spec)
+        meta_alpha_gradient_spec_free (op->data.gradient.alpha_spec);
+
+      meta_draw_spec_free (op->data.gradient.x);
+      meta_draw_spec_free (op->data.gradient.y);
+      meta_draw_spec_free (op->data.gradient.width);
+      meta_draw_spec_free (op->data.gradient.height);
+      break;
+
+    case META_DRAW_IMAGE:
+      if (op->data.image.alpha_spec)
+        meta_alpha_gradient_spec_free (op->data.image.alpha_spec);
+
+      if (op->data.image.pixbuf)
+        g_object_unref (G_OBJECT (op->data.image.pixbuf));
+
+      if (op->data.image.colorize_spec)
+	meta_color_spec_free (op->data.image.colorize_spec);
+
+      if (op->data.image.colorize_cache_pixbuf)
+        g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf));
+
+      meta_draw_spec_free (op->data.image.x);
+      meta_draw_spec_free (op->data.image.y);
+      meta_draw_spec_free (op->data.image.width);
+      meta_draw_spec_free (op->data.image.height);
+      break;
+
+    case META_DRAW_GTK_ARROW:
+      meta_draw_spec_free (op->data.gtk_arrow.x);
+      meta_draw_spec_free (op->data.gtk_arrow.y);
+      meta_draw_spec_free (op->data.gtk_arrow.width);
+      meta_draw_spec_free (op->data.gtk_arrow.height);
+      break;
+
+    case META_DRAW_GTK_BOX:
+      meta_draw_spec_free (op->data.gtk_box.x);
+      meta_draw_spec_free (op->data.gtk_box.y);
+      meta_draw_spec_free (op->data.gtk_box.width);
+      meta_draw_spec_free (op->data.gtk_box.height);
+      break;
+
+    case META_DRAW_GTK_VLINE:
+      meta_draw_spec_free (op->data.gtk_vline.x);
+      meta_draw_spec_free (op->data.gtk_vline.y1);
+      meta_draw_spec_free (op->data.gtk_vline.y2);
+      break;
+
+    case META_DRAW_ICON:
+      if (op->data.icon.alpha_spec)
+        meta_alpha_gradient_spec_free (op->data.icon.alpha_spec);
+
+      meta_draw_spec_free (op->data.icon.x);
+      meta_draw_spec_free (op->data.icon.y);
+      meta_draw_spec_free (op->data.icon.width);
+      meta_draw_spec_free (op->data.icon.height);
+      break;
+
+    case META_DRAW_TITLE:
+      if (op->data.title.color_spec)
+        meta_color_spec_free (op->data.title.color_spec);
+
+      meta_draw_spec_free (op->data.title.x);
+      meta_draw_spec_free (op->data.title.y);
+      break;
+
+    case META_DRAW_OP_LIST:
+      if (op->data.op_list.op_list)
+        meta_draw_op_list_unref (op->data.op_list.op_list);
+
+      meta_draw_spec_free (op->data.op_list.x);
+      meta_draw_spec_free (op->data.op_list.y);
+      meta_draw_spec_free (op->data.op_list.width);
+      meta_draw_spec_free (op->data.op_list.height);
+      break;
+
+    case META_DRAW_TILE:
+      if (op->data.tile.op_list)
+        meta_draw_op_list_unref (op->data.tile.op_list);
+
+      meta_draw_spec_free (op->data.tile.x);
+      meta_draw_spec_free (op->data.tile.y);
+      meta_draw_spec_free (op->data.tile.width);
+      meta_draw_spec_free (op->data.tile.height);
+      meta_draw_spec_free (op->data.tile.tile_xoffset);
+      meta_draw_spec_free (op->data.tile.tile_yoffset);
+      meta_draw_spec_free (op->data.tile.tile_width);
+      meta_draw_spec_free (op->data.tile.tile_height);
+      break;
+    }
+
+  g_free (op);
+}
+
+static GdkPixbuf*
+apply_alpha (GdkPixbuf             *pixbuf,
+             MetaAlphaGradientSpec *spec,
+             gboolean               force_copy)
+{
+  GdkPixbuf *new_pixbuf;
+  gboolean needs_alpha;
+
+  g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
+
+  needs_alpha = spec && (spec->n_alphas > 1 ||
+                         spec->alphas[0] != 0xff);
+
+  if (!needs_alpha)
+    return pixbuf;
+
+  if (!gdk_pixbuf_get_has_alpha (pixbuf))
+    {
+      new_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+      g_object_unref (G_OBJECT (pixbuf));
+      pixbuf = new_pixbuf;
+    }
+  else if (force_copy)
+    {
+      new_pixbuf = gdk_pixbuf_copy (pixbuf);
+      g_object_unref (G_OBJECT (pixbuf));
+      pixbuf = new_pixbuf;
+    }
+
+  g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
+
+  meta_gradient_add_alpha (pixbuf, spec->alphas, spec->n_alphas, spec->type);
+
+  return pixbuf;
+}
+
+static GdkPixbuf*
+pixbuf_tile (GdkPixbuf *tile,
+             int        width,
+             int        height)
+{
+  GdkPixbuf *pixbuf;
+  int tile_width;
+  int tile_height;
+  int i, j;
+
+  tile_width = gdk_pixbuf_get_width (tile);
+  tile_height = gdk_pixbuf_get_height (tile);
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+                           gdk_pixbuf_get_has_alpha (tile),
+                           8, width, height);
+
+  i = 0;
+  while (i < width)
+    {
+      j = 0;
+      while (j < height)
+        {
+          int w, h;
+
+          w = MIN (tile_width, width - i);
+          h = MIN (tile_height, height - j);
+
+          gdk_pixbuf_copy_area (tile,
+                                0, 0,
+                                w, h,
+                                pixbuf,
+                                i, j);
+
+          j += tile_height;
+        }
+
+      i += tile_width;
+    }
+
+  return pixbuf;
+}
+
+static GdkPixbuf *
+replicate_rows (GdkPixbuf  *src,
+                int         src_x,
+                int         src_y,
+                int         width,
+                int         height)
+{
+  unsigned int n_channels = gdk_pixbuf_get_n_channels (src);
+  unsigned int src_rowstride = gdk_pixbuf_get_rowstride (src);
+  unsigned char *pixels = (gdk_pixbuf_get_pixels (src) + src_y * src_rowstride + src_x
+                           * n_channels);
+  unsigned char *dest_pixels;
+  GdkPixbuf *result;
+  unsigned int dest_rowstride;
+  int i;
+
+  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,
+                           width, height);
+  dest_rowstride = gdk_pixbuf_get_rowstride (result);
+  dest_pixels = gdk_pixbuf_get_pixels (result);
+
+  for (i = 0; i < height; i++)
+    memcpy (dest_pixels + dest_rowstride * i, pixels, n_channels * width);
+
+  return result;
+}
+
+static GdkPixbuf *
+replicate_cols (GdkPixbuf  *src,
+                int         src_x,
+                int         src_y,
+                int         width,
+                int         height)
+{
+  unsigned int n_channels = gdk_pixbuf_get_n_channels (src);
+  unsigned int src_rowstride = gdk_pixbuf_get_rowstride (src);
+  unsigned char *pixels = (gdk_pixbuf_get_pixels (src) + src_y * src_rowstride + src_x
+                           * n_channels);
+  unsigned char *dest_pixels;
+  GdkPixbuf *result;
+  unsigned int dest_rowstride;
+  int i, j;
+
+  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,
+                           width, height);
+  dest_rowstride = gdk_pixbuf_get_rowstride (result);
+  dest_pixels = gdk_pixbuf_get_pixels (result);
+
+  for (i = 0; i < height; i++)
+    {
+      unsigned char *p = dest_pixels + dest_rowstride * i;
+      unsigned char *q = pixels + src_rowstride * i;
+
+      unsigned char r = *(q++);
+      unsigned char g = *(q++);
+      unsigned char b = *(q++);
+
+      if (n_channels == 4)
+        {
+          unsigned char a;
+
+          a = *(q++);
+
+          for (j = 0; j < width; j++)
+            {
+              *(p++) = r;
+              *(p++) = g;
+              *(p++) = b;
+              *(p++) = a;
+            }
+        }
+      else
+        {
+          for (j = 0; j < width; j++)
+            {
+              *(p++) = r;
+              *(p++) = g;
+              *(p++) = b;
+            }
+        }
+    }
+
+  return result;
+}
+
+static GdkPixbuf*
+scale_and_alpha_pixbuf (GdkPixbuf             *src,
+                        MetaAlphaGradientSpec *alpha_spec,
+                        MetaImageFillType      fill_type,
+                        int                    width,
+                        int                    height,
+                        gboolean               vertical_stripes,
+                        gboolean               horizontal_stripes)
+{
+  GdkPixbuf *pixbuf;
+  GdkPixbuf *temp_pixbuf;
+
+  pixbuf = NULL;
+
+  pixbuf = src;
+
+  if (gdk_pixbuf_get_width (pixbuf) == width &&
+      gdk_pixbuf_get_height (pixbuf) == height)
+    {
+      g_object_ref (G_OBJECT (pixbuf));
+    }
+  else
+    {
+      if (fill_type == META_IMAGE_FILL_TILE)
+        {
+          pixbuf = pixbuf_tile (pixbuf, width, height);
+        }
+      else
+        {
+    	  int src_h, src_w, dest_h, dest_w;
+          src_h = gdk_pixbuf_get_height (src);
+          src_w = gdk_pixbuf_get_width (src);
+
+          /* prefer to replicate_cols if possible, as that
+           * is faster (no memory reads)
+           */
+          if (horizontal_stripes)
+            {
+              dest_w = gdk_pixbuf_get_width (src);
+              dest_h = height;
+            }
+          else if (vertical_stripes)
+            {
+              dest_w = width;
+              dest_h = gdk_pixbuf_get_height (src);
+            }
+
+          else
+            {
+              dest_w = width;
+              dest_h = height;
+            }
+
+          if (dest_w == src_w && dest_h == src_h)
+            {
+              temp_pixbuf = src;
+              g_object_ref (G_OBJECT (temp_pixbuf));
+            }
+          else
+            {
+              temp_pixbuf = gdk_pixbuf_scale_simple (src,
+                                                     dest_w, dest_h,
+                                                     GDK_INTERP_BILINEAR);
+            }
+
+          /* prefer to replicate_cols if possible, as that
+           * is faster (no memory reads)
+           */
+          if (horizontal_stripes)
+            {
+              pixbuf = replicate_cols (temp_pixbuf, 0, 0, width, height);
+              g_object_unref (G_OBJECT (temp_pixbuf));
+            }
+          else if (vertical_stripes)
+            {
+              pixbuf = replicate_rows (temp_pixbuf, 0, 0, width, height);
+              g_object_unref (G_OBJECT (temp_pixbuf));
+            }
+          else
+            {
+              pixbuf = temp_pixbuf;
+            }
+        }
+    }
+
+  if (pixbuf)
+    pixbuf = apply_alpha (pixbuf, alpha_spec, pixbuf == src);
+
+  return pixbuf;
+}
+
+static GdkPixbuf*
+draw_op_as_pixbuf (const MetaDrawOp    *op,
+                   GtkWidget           *widget,
+                   const MetaDrawInfo  *info,
+                   int                  width,
+                   int                  height)
+{
+  /* Try to get the op as a pixbuf, assuming w/h in the op
+   * matches the width/height passed in. return NULL
+   * if the op can't be converted to an equivalent pixbuf.
+   */
+  GdkPixbuf *pixbuf;
+
+  pixbuf = NULL;
+
+  switch (op->type)
+    {
+    case META_DRAW_LINE:
+      break;
+
+    case META_DRAW_RECTANGLE:
+      if (op->data.rectangle.filled)
+        {
+          GdkColor color;
+
+          meta_color_spec_render (op->data.rectangle.color_spec,
+                                  widget,
+                                  &color);
+
+          pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+                                   FALSE,
+                                   8, width, height);
+
+          gdk_pixbuf_fill (pixbuf, GDK_COLOR_RGBA (color));
+        }
+      break;
+
+    case META_DRAW_ARC:
+      break;
+
+    case META_DRAW_CLIP:
+      break;
+
+    case META_DRAW_TINT:
+      {
+        GdkColor color;
+        guint32 rgba;
+        gboolean has_alpha;
+
+        meta_color_spec_render (op->data.rectangle.color_spec,
+                                widget,
+                                &color);
+
+        has_alpha =
+          op->data.tint.alpha_spec &&
+          (op->data.tint.alpha_spec->n_alphas > 1 ||
+           op->data.tint.alpha_spec->alphas[0] != 0xff);
+
+        pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+                                 has_alpha,
+                                 8, width, height);
+
+        if (!has_alpha)
+          {
+            rgba = GDK_COLOR_RGBA (color);
+
+            gdk_pixbuf_fill (pixbuf, rgba);
+          }
+        else if (op->data.tint.alpha_spec->n_alphas == 1)
+          {
+            rgba = GDK_COLOR_RGBA (color);
+            rgba &= ~0xff;
+            rgba |= op->data.tint.alpha_spec->alphas[0];
+
+            gdk_pixbuf_fill (pixbuf, rgba);
+          }
+        else
+          {
+            rgba = GDK_COLOR_RGBA (color);
+
+            gdk_pixbuf_fill (pixbuf, rgba);
+
+            meta_gradient_add_alpha (pixbuf,
+                                     op->data.tint.alpha_spec->alphas,
+                                     op->data.tint.alpha_spec->n_alphas,
+                                     op->data.tint.alpha_spec->type);
+          }
+      }
+      break;
+
+    case META_DRAW_GRADIENT:
+      {
+        pixbuf = meta_gradient_spec_render (op->data.gradient.gradient_spec,
+                                            widget, width, height);
+
+        pixbuf = apply_alpha (pixbuf,
+                              op->data.gradient.alpha_spec,
+                              FALSE);
+      }
+      break;
+
+
+    case META_DRAW_IMAGE:
+      {
+	if (op->data.image.colorize_spec)
+	  {
+	    GdkColor color;
+
+            meta_color_spec_render (op->data.image.colorize_spec,
+                                    widget, &color);
+
+            if (op->data.image.colorize_cache_pixbuf == NULL ||
+                op->data.image.colorize_cache_pixel != GDK_COLOR_RGB (color))
+              {
+                if (op->data.image.colorize_cache_pixbuf)
+                  g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf));
+
+                /* const cast here */
+                ((MetaDrawOp*)op)->data.image.colorize_cache_pixbuf =
+                  colorize_pixbuf (op->data.image.pixbuf,
+                                   &color);
+                ((MetaDrawOp*)op)->data.image.colorize_cache_pixel =
+                  GDK_COLOR_RGB (color);
+              }
+
+            if (op->data.image.colorize_cache_pixbuf)
+              {
+                pixbuf = scale_and_alpha_pixbuf (op->data.image.colorize_cache_pixbuf,
+                                                 op->data.image.alpha_spec,
+                                                 op->data.image.fill_type,
+                                                 width, height,
+                                                 op->data.image.vertical_stripes,
+                                                 op->data.image.horizontal_stripes);
+              }
+	  }
+	else
+	  {
+	    pixbuf = scale_and_alpha_pixbuf (op->data.image.pixbuf,
+                                             op->data.image.alpha_spec,
+                                             op->data.image.fill_type,
+                                             width, height,
+                                             op->data.image.vertical_stripes,
+                                             op->data.image.horizontal_stripes);
+	  }
+        break;
+      }
+
+    case META_DRAW_GTK_ARROW:
+    case META_DRAW_GTK_BOX:
+    case META_DRAW_GTK_VLINE:
+      break;
+
+    case META_DRAW_ICON:
+      if (info->mini_icon &&
+          width <= gdk_pixbuf_get_width (info->mini_icon) &&
+          height <= gdk_pixbuf_get_height (info->mini_icon))
+        pixbuf = scale_and_alpha_pixbuf (info->mini_icon,
+                                         op->data.icon.alpha_spec,
+                                         op->data.icon.fill_type,
+                                         width, height,
+                                         FALSE, FALSE);
+      else if (info->icon)
+        pixbuf = scale_and_alpha_pixbuf (info->icon,
+                                         op->data.icon.alpha_spec,
+                                         op->data.icon.fill_type,
+                                         width, height,
+                                         FALSE, FALSE);
+      break;
+
+    case META_DRAW_TITLE:
+      break;
+
+    case META_DRAW_OP_LIST:
+      break;
+
+    case META_DRAW_TILE:
+      break;
+    }
+
+  return pixbuf;
+}
+
+static void
+fill_env (MetaPositionExprEnv *env,
+          const MetaDrawInfo  *info,
+          MetaRectangle        logical_region)
+{
+  /* FIXME this stuff could be raised into draw_op_list_draw() probably
+   */
+  env->rect = logical_region;
+  env->object_width = -1;
+  env->object_height = -1;
+  if (info->fgeom)
+    {
+      env->left_width = info->fgeom->left_width;
+      env->right_width = info->fgeom->right_width;
+      env->top_height = info->fgeom->top_height;
+      env->bottom_height = info->fgeom->bottom_height;
+    }
+  else
+    {
+      env->left_width = 0;
+      env->right_width = 0;
+      env->top_height = 0;
+      env->bottom_height = 0;
+    }
+
+  env->mini_icon_width = info->mini_icon ? gdk_pixbuf_get_width (info->mini_icon) : 0;
+  env->mini_icon_height = info->mini_icon ? gdk_pixbuf_get_height (info->mini_icon) : 0;
+  env->icon_width = info->icon ? gdk_pixbuf_get_width (info->icon) : 0;
+  env->icon_height = info->icon ? gdk_pixbuf_get_height (info->icon) : 0;
+
+  env->title_width = info->title_layout_width;
+  env->title_height = info->title_layout_height;
+  env->theme = meta_current_theme;
+}
+
+/* This code was originally rendering anti-aliased using X primitives, and
+ * now has been switched to draw anti-aliased using cairo. In general, the
+ * closest correspondence between X rendering and cairo rendering is given
+ * by offsetting the geometry by 0.5 pixels in both directions before rendering
+ * with cairo. This is because X samples at the upper left corner of the
+ * pixel while cairo averages over the entire pixel. However, in the cases
+ * where the X rendering was an exact rectangle with no "jaggies"
+ * we need to be a bit careful about applying the offset. We want to produce
+ * the exact same pixel-aligned rectangle, rather than a rectangle with
+ * fuzz around the edges.
+ */
+static void
+meta_draw_op_draw_with_env (const MetaDrawOp    *op,
+                            GtkStyle            *style_gtk,
+                            GtkWidget           *widget,
+                            GdkDrawable         *drawable,
+                            const GdkRectangle  *clip,
+                            const MetaDrawInfo  *info,
+                            MetaRectangle        rect,
+                            MetaPositionExprEnv *env)
+{
+  GdkColor color;
+  cairo_t *cr;
+
+  cr = gdk_cairo_create (drawable);
+
+  cairo_set_line_width (cr, 1.0);
+
+  if (clip)
+    {
+      gdk_cairo_rectangle (cr, clip);
+      cairo_clip (cr);
+    }
+
+  switch (op->type)
+    {
+    case META_DRAW_LINE:
+      {
+        int x1, x2, y1, y2;
+
+        meta_color_spec_render (op->data.line.color_spec, widget, &color);
+        gdk_cairo_set_source_color (cr, &color);
+
+        if (op->data.line.width > 0)
+          cairo_set_line_width (cr, op->data.line.width);
+
+        if (op->data.line.dash_on_length > 0 &&
+            op->data.line.dash_off_length > 0)
+          {
+            double dash_list[2];
+            dash_list[0] = op->data.line.dash_on_length;
+            dash_list[1] = op->data.line.dash_off_length;
+            cairo_set_dash (cr, dash_list, 2, 0);
+          }
+
+        x1 = parse_x_position_unchecked (op->data.line.x1, env);
+        y1 = parse_y_position_unchecked (op->data.line.y1, env);
+
+        if (!op->data.line.x2 &&
+            !op->data.line.y2 &&
+            op->data.line.width==0)
+          {
+            cairo_rectangle (cr, x1, y1, 1, 1);
+            cairo_fill (cr);
+          }
+        else
+          {
+            if (op->data.line.x2)
+              x2 = parse_x_position_unchecked (op->data.line.x2, env);
+            else
+              x2 = x1;
+
+            if (op->data.line.y2)
+              y2 = parse_y_position_unchecked (op->data.line.y2, env);
+            else
+              y2 = y1;
+
+            /* This is one of the cases where we are matching the exact
+             * pixel aligned rectangle produced by X.
+             */
+            if (y1 == y2 || x1 == x2)
+              {
+                double offset = (op->data.line.width == 0 ||
+                                 op->data.line.width % 2) ? .5 : 0;
+                /* X includes end points for lines of width 0 */
+                double line_extend = op->data.line.width == 0 ? 1. : 0.;
+
+                if (y1 == y2)
+                  {
+                    if (x2 < x1)
+                    {
+                       x1 ^= x2;
+                       x2 ^= x1;
+                       x1 ^= x2;
+                    }
+                    cairo_move_to (cr, x1, y1 + offset);
+                    cairo_line_to (cr, x2 + line_extend, y2 + offset);
+                  }
+                else
+                  {
+                    if (y2 < y1)
+                    {
+                      y1 ^= y2;
+                      y2 ^= y1;
+                      y1 ^= y2;
+                    }
+                    cairo_move_to (cr, x1 + offset, y1);
+                    cairo_line_to (cr, x2 + offset, y2 + line_extend);
+                  }
+              }
+            else
+              {
+                if (op->data.line.width <= 0)
+                  {
+                    cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+                  }
+                cairo_move_to (cr, x1 + .5, y1 + .5);
+                cairo_line_to (cr, x2 + .5, y2 + .5);
+              }
+            cairo_stroke (cr);
+          }
+      }
+      break;
+
+    case META_DRAW_RECTANGLE:
+      {
+        int rx, ry, rwidth, rheight;
+
+        meta_color_spec_render (op->data.rectangle.color_spec, widget, &color);
+        gdk_cairo_set_source_color (cr, &color);
+
+        rx = parse_x_position_unchecked (op->data.rectangle.x, env);
+        ry = parse_y_position_unchecked (op->data.rectangle.y, env);
+        rwidth = parse_size_unchecked (op->data.rectangle.width, env);
+        rheight = parse_size_unchecked (op->data.rectangle.height, env);
+
+        /* Filled and stroked rectangles are the other cases
+         * we pixel-align to X rasterization
+         */
+        if (op->data.rectangle.filled)
+          {
+            cairo_rectangle (cr, rx, ry, rwidth, rheight);
+            cairo_fill (cr);
+          }
+        else
+          {
+            cairo_rectangle (cr, rx + .5, ry + .5, rwidth, rheight);
+            cairo_stroke (cr);
+          }
+      }
+      break;
+
+    case META_DRAW_ARC:
+      {
+        int rx, ry, rwidth, rheight;
+        double start_angle, end_angle;
+        double center_x, center_y;
+
+        meta_color_spec_render (op->data.arc.color_spec, widget, &color);
+        gdk_cairo_set_source_color (cr, &color);
+
+        rx = parse_x_position_unchecked (op->data.arc.x, env);
+        ry = parse_y_position_unchecked (op->data.arc.y, env);
+        rwidth = parse_size_unchecked (op->data.arc.width, env);
+        rheight = parse_size_unchecked (op->data.arc.height, env);
+
+        start_angle = op->data.arc.start_angle * (M_PI / 180.)
+                      - (.25 * M_PI); /* start at 12 instead of 3 oclock */
+        end_angle = start_angle + op->data.arc.extent_angle * (M_PI / 180.);
+        center_x = rx + (double)rwidth / 2. + .5;
+        center_y = ry + (double)rheight / 2. + .5;
+
+        cairo_save (cr);
+
+        cairo_translate (cr, center_x, center_y);
+        cairo_scale (cr, (double)rwidth / 2., (double)rheight / 2.);
+
+        if (op->data.arc.extent_angle >= 0)
+          cairo_arc (cr, 0, 0, 1, start_angle, end_angle);
+        else
+          cairo_arc_negative (cr, 0, 0, 1, start_angle, end_angle);
+
+        cairo_restore (cr);
+
+        if (op->data.arc.filled)
+          {
+            cairo_line_to (cr, center_x, center_y);
+            cairo_fill (cr);
+          }
+        else
+          cairo_stroke (cr);
+      }
+      break;
+
+    case META_DRAW_CLIP:
+      break;
+
+    case META_DRAW_TINT:
+      {
+        int rx, ry, rwidth, rheight;
+        gboolean needs_alpha;
+
+        needs_alpha = op->data.tint.alpha_spec &&
+          (op->data.tint.alpha_spec->n_alphas > 1 ||
+           op->data.tint.alpha_spec->alphas[0] != 0xff);
+
+        rx = parse_x_position_unchecked (op->data.tint.x, env);
+        ry = parse_y_position_unchecked (op->data.tint.y, env);
+        rwidth = parse_size_unchecked (op->data.tint.width, env);
+        rheight = parse_size_unchecked (op->data.tint.height, env);
+
+        if (!needs_alpha)
+          {
+            meta_color_spec_render (op->data.tint.color_spec, widget, &color);
+            gdk_cairo_set_source_color (cr, &color);
+
+            cairo_rectangle (cr, rx, ry, rwidth, rheight);
+            cairo_fill (cr);
+          }
+        else
+          {
+            GdkPixbuf *pixbuf;
+
+            pixbuf = draw_op_as_pixbuf (op, widget, info,
+                                        rwidth, rheight);
+
+            if (pixbuf)
+              {
+                gdk_cairo_set_source_pixbuf (cr, pixbuf, rx, ry);
+                cairo_paint (cr);
+
+                g_object_unref (G_OBJECT (pixbuf));
+              }
+          }
+      }
+      break;
+
+    case META_DRAW_GRADIENT:
+      {
+        int rx, ry, rwidth, rheight;
+        GdkPixbuf *pixbuf;
+
+        rx = parse_x_position_unchecked (op->data.gradient.x, env);
+        ry = parse_y_position_unchecked (op->data.gradient.y, env);
+        rwidth = parse_size_unchecked (op->data.gradient.width, env);
+        rheight = parse_size_unchecked (op->data.gradient.height, env);
+
+        pixbuf = draw_op_as_pixbuf (op, widget, info,
+                                    rwidth, rheight);
+
+        if (pixbuf)
+          {
+            gdk_cairo_set_source_pixbuf (cr, pixbuf, rx, ry);
+            cairo_paint (cr);
+
+            g_object_unref (G_OBJECT (pixbuf));
+          }
+      }
+      break;
+
+    case META_DRAW_IMAGE:
+      {
+        int rx, ry, rwidth, rheight;
+        GdkPixbuf *pixbuf;
+
+        if (op->data.image.pixbuf)
+          {
+            env->object_width = gdk_pixbuf_get_width (op->data.image.pixbuf);
+            env->object_height = gdk_pixbuf_get_height (op->data.image.pixbuf);
+          }
+
+        rwidth = parse_size_unchecked (op->data.image.width, env);
+        rheight = parse_size_unchecked (op->data.image.height, env);
+
+        pixbuf = draw_op_as_pixbuf (op, widget, info,
+                                    rwidth, rheight);
+
+        if (pixbuf)
+          {
+            rx = parse_x_position_unchecked (op->data.image.x, env);
+            ry = parse_y_position_unchecked (op->data.image.y, env);
+
+            gdk_cairo_set_source_pixbuf (cr, pixbuf, rx, ry);
+            cairo_paint (cr);
+
+            g_object_unref (G_OBJECT (pixbuf));
+          }
+      }
+      break;
+
+    case META_DRAW_GTK_ARROW:
+      {
+        int rx, ry, rwidth, rheight;
+
+        rx = parse_x_position_unchecked (op->data.gtk_arrow.x, env);
+        ry = parse_y_position_unchecked (op->data.gtk_arrow.y, env);
+        rwidth = parse_size_unchecked (op->data.gtk_arrow.width, env);
+        rheight = parse_size_unchecked (op->data.gtk_arrow.height, env);
+
+        gtk_paint_arrow (style_gtk,
+                         drawable,
+                         op->data.gtk_arrow.state,
+                         op->data.gtk_arrow.shadow,
+                         (GdkRectangle*) clip,
+                         widget,
+                         "marco",
+                         op->data.gtk_arrow.arrow,
+                         op->data.gtk_arrow.filled,
+                         rx, ry, rwidth, rheight);
+      }
+      break;
+
+    case META_DRAW_GTK_BOX:
+      {
+        int rx, ry, rwidth, rheight;
+
+        rx = parse_x_position_unchecked (op->data.gtk_box.x, env);
+        ry = parse_y_position_unchecked (op->data.gtk_box.y, env);
+        rwidth = parse_size_unchecked (op->data.gtk_box.width, env);
+        rheight = parse_size_unchecked (op->data.gtk_box.height, env);
+
+        gtk_paint_box (style_gtk,
+                       drawable,
+                       op->data.gtk_box.state,
+                       op->data.gtk_box.shadow,
+                       (GdkRectangle*) clip,
+                       widget,
+                       "marco",
+                       rx, ry, rwidth, rheight);
+      }
+      break;
+
+    case META_DRAW_GTK_VLINE:
+      {
+        int rx, ry1, ry2;
+
+        rx = parse_x_position_unchecked (op->data.gtk_vline.x, env);
+        ry1 = parse_y_position_unchecked (op->data.gtk_vline.y1, env);
+        ry2 = parse_y_position_unchecked (op->data.gtk_vline.y2, env);
+
+        gtk_paint_vline (style_gtk,
+                         drawable,
+                         op->data.gtk_vline.state,
+                         (GdkRectangle*) clip,
+                         widget,
+                         "marco",
+                         ry1, ry2, rx);
+      }
+      break;
+
+    case META_DRAW_ICON:
+      {
+        int rx, ry, rwidth, rheight;
+        GdkPixbuf *pixbuf;
+
+        rwidth = parse_size_unchecked (op->data.icon.width, env);
+        rheight = parse_size_unchecked (op->data.icon.height, env);
+
+        pixbuf = draw_op_as_pixbuf (op, widget, info,
+                                    rwidth, rheight);
+
+        if (pixbuf)
+          {
+            rx = parse_x_position_unchecked (op->data.icon.x, env);
+            ry = parse_y_position_unchecked (op->data.icon.y, env);
+
+            gdk_cairo_set_source_pixbuf (cr, pixbuf, rx, ry);
+            cairo_paint (cr);
+
+            g_object_unref (G_OBJECT (pixbuf));
+          }
+      }
+      break;
+
+    case META_DRAW_TITLE:
+      if (info->title_layout)
+        {
+          int rx, ry;
+
+          meta_color_spec_render (op->data.title.color_spec, widget, &color);
+          gdk_cairo_set_source_color (cr, &color);
+
+          rx = parse_x_position_unchecked (op->data.title.x, env);
+          ry = parse_y_position_unchecked (op->data.title.y, env);
+
+          cairo_move_to (cr, rx, ry);
+          pango_cairo_show_layout (cr, info->title_layout);
+        }
+      break;
+
+    case META_DRAW_OP_LIST:
+      {
+        MetaRectangle d_rect;
+
+        d_rect.x = parse_x_position_unchecked (op->data.op_list.x, env);
+        d_rect.y = parse_y_position_unchecked (op->data.op_list.y, env);
+        d_rect.width = parse_size_unchecked (op->data.op_list.width, env);
+        d_rect.height = parse_size_unchecked (op->data.op_list.height, env);
+
+        meta_draw_op_list_draw_with_style (op->data.op_list.op_list,
+                                           style_gtk, widget, drawable, clip, info,
+                                           d_rect);
+      }
+      break;
+
+    case META_DRAW_TILE:
+      {
+        int rx, ry, rwidth, rheight;
+        int tile_xoffset, tile_yoffset;
+        GdkRectangle new_clip;
+        MetaRectangle tile;
+
+        rx = parse_x_position_unchecked (op->data.tile.x, env);
+        ry = parse_y_position_unchecked (op->data.tile.y, env);
+        rwidth = parse_size_unchecked (op->data.tile.width, env);
+        rheight = parse_size_unchecked (op->data.tile.height, env);
+
+        new_clip.x = rx;
+        new_clip.y = ry;
+        new_clip.width = rwidth;
+        new_clip.height = rheight;
+
+        if (clip == NULL || gdk_rectangle_intersect ((GdkRectangle*)clip, &new_clip,
+                                                     &new_clip))
+          {
+            tile_xoffset = parse_x_position_unchecked (op->data.tile.tile_xoffset, env);
+            tile_yoffset = parse_y_position_unchecked (op->data.tile.tile_yoffset, env);
+            /* tile offset should not include x/y */
+            tile_xoffset -= rect.x;
+            tile_yoffset -= rect.y;
+
+            tile.width = parse_size_unchecked (op->data.tile.tile_width, env);
+            tile.height = parse_size_unchecked (op->data.tile.tile_height, env);
+
+            tile.x = rx - tile_xoffset;
+
+            while (tile.x < (rx + rwidth))
+              {
+                tile.y = ry - tile_yoffset;
+                while (tile.y < (ry + rheight))
+                  {
+                    meta_draw_op_list_draw_with_style (op->data.tile.op_list,
+                                                       style_gtk, widget, drawable, &new_clip, info,
+                                                       tile);
+
+                    tile.y += tile.height;
+                  }
+
+                tile.x += tile.width;
+              }
+          }
+      }
+      break;
+    }
+
+  cairo_destroy (cr);
+}
+
+void
+meta_draw_op_draw_with_style (const MetaDrawOp    *op,
+                              GtkStyle            *style_gtk,
+                              GtkWidget           *widget,
+                              GdkDrawable         *drawable,
+                              const GdkRectangle  *clip,
+                              const MetaDrawInfo  *info,
+                              MetaRectangle        logical_region)
+{
+  MetaPositionExprEnv env;
+
+  g_return_if_fail (style_gtk->colormap == gdk_drawable_get_colormap (drawable));
+
+  fill_env (&env, info, logical_region);
+
+  meta_draw_op_draw_with_env (op, style_gtk, widget, drawable, clip,
+                              info, logical_region,
+                              &env);
+
+}
+
+void
+meta_draw_op_draw (const MetaDrawOp    *op,
+                   GtkWidget           *widget,
+                   GdkDrawable         *drawable,
+                   const GdkRectangle  *clip,
+                   const MetaDrawInfo  *info,
+                   MetaRectangle        logical_region)
+{
+  meta_draw_op_draw_with_style (op, gtk_widget_get_style (widget), widget,
+                                drawable, clip, info, logical_region);
+}
+
+MetaDrawOpList*
+meta_draw_op_list_new (int n_preallocs)
+{
+  MetaDrawOpList *op_list;
+
+  g_return_val_if_fail (n_preallocs >= 0, NULL);
+
+  op_list = g_new (MetaDrawOpList, 1);
+
+  op_list->refcount = 1;
+  op_list->n_allocated = n_preallocs;
+  op_list->ops = g_new (MetaDrawOp*, op_list->n_allocated);
+  op_list->n_ops = 0;
+
+  return op_list;
+}
+
+void
+meta_draw_op_list_ref (MetaDrawOpList *op_list)
+{
+  g_return_if_fail (op_list != NULL);
+
+  op_list->refcount += 1;
+}
+
+void
+meta_draw_op_list_unref (MetaDrawOpList *op_list)
+{
+  g_return_if_fail (op_list != NULL);
+  g_return_if_fail (op_list->refcount > 0);
+
+  op_list->refcount -= 1;
+
+  if (op_list->refcount == 0)
+    {
+      int i;
+
+      for (i = 0; i < op_list->n_ops; i++)
+        meta_draw_op_free (op_list->ops[i]);
+
+      g_free (op_list->ops);
+
+      DEBUG_FILL_STRUCT (op_list);
+      g_free (op_list);
+    }
+}
+
+void
+meta_draw_op_list_draw_with_style  (const MetaDrawOpList *op_list,
+                                    GtkStyle             *style_gtk,
+                                    GtkWidget            *widget,
+                                    GdkDrawable          *drawable,
+                                    const GdkRectangle   *clip,
+                                    const MetaDrawInfo   *info,
+                                    MetaRectangle         rect)
+{
+  int i;
+  GdkRectangle active_clip;
+  GdkRectangle orig_clip;
+  MetaPositionExprEnv env;
+
+  g_return_if_fail (style_gtk->colormap == gdk_drawable_get_colormap (drawable));
+
+  if (op_list->n_ops == 0)
+    return;
+
+  fill_env (&env, info, rect);
+
+  /* FIXME this can be optimized, potentially a lot, by
+   * compressing multiple ops when possible. For example,
+   * anything convertible to a pixbuf can be composited
+   * client-side, and putting a color tint over a pixbuf
+   * can be done without creating the solid-color pixbuf.
+   *
+   * To implement this my plan is to have the idea of a
+   * compiled draw op (with the string expressions already
+   * evaluated), we make an array of those, and then fold
+   * adjacent items when possible.
+   */
+  if (clip)
+    {
+      orig_clip = *clip;
+    }
+  else
+    {
+      orig_clip.x = rect.x;
+      orig_clip.y = rect.y;
+      orig_clip.width = rect.width;
+      orig_clip.height = rect.height;
+    }
+
+  active_clip = orig_clip;
+
+  for (i = 0; i < op_list->n_ops; i++)
+    {
+      MetaDrawOp *op = op_list->ops[i];
+
+      if (op->type == META_DRAW_CLIP)
+        {
+          active_clip.x = parse_x_position_unchecked (op->data.clip.x, &env);
+          active_clip.y = parse_y_position_unchecked (op->data.clip.y, &env);
+          active_clip.width = parse_size_unchecked (op->data.clip.width, &env);
+          active_clip.height = parse_size_unchecked (op->data.clip.height, &env);
+
+          gdk_rectangle_intersect (&orig_clip, &active_clip, &active_clip);
+        }
+      else if (active_clip.width > 0 &&
+               active_clip.height > 0)
+        {
+          meta_draw_op_draw_with_env (op,
+                                      style_gtk, widget, drawable, &active_clip, info,
+                                      rect,
+                                      &env);
+        }
+    }
+}
+
+void
+meta_draw_op_list_draw  (const MetaDrawOpList *op_list,
+                         GtkWidget            *widget,
+                         GdkDrawable          *drawable,
+                         const GdkRectangle   *clip,
+                         const MetaDrawInfo   *info,
+                         MetaRectangle         rect)
+
+{
+  meta_draw_op_list_draw_with_style (op_list, gtk_widget_get_style (widget), widget,
+                                     drawable, clip, info, rect);
+}
+
+void
+meta_draw_op_list_append (MetaDrawOpList       *op_list,
+                          MetaDrawOp           *op)
+{
+  if (op_list->n_ops == op_list->n_allocated)
+    {
+      op_list->n_allocated *= 2;
+      op_list->ops = g_renew (MetaDrawOp*, op_list->ops, op_list->n_allocated);
+    }
+
+  op_list->ops[op_list->n_ops] = op;
+  op_list->n_ops += 1;
+}
+
+gboolean
+meta_draw_op_list_validate (MetaDrawOpList    *op_list,
+                            GError           **error)
+{
+  g_return_val_if_fail (op_list != NULL, FALSE);
+
+  /* empty lists are OK, nothing else to check really */
+
+  return TRUE;
+}
+
+/* This is not done in validate, since we wouldn't know the name
+ * of the list to report the error. It might be nice to
+ * store names inside the list sometime.
+ */
+gboolean
+meta_draw_op_list_contains (MetaDrawOpList    *op_list,
+                            MetaDrawOpList    *child)
+{
+  int i;
+
+  /* mmm, huge tree recursion */
+
+  for (i = 0; i < op_list->n_ops; i++)
+    {
+      if (op_list->ops[i]->type == META_DRAW_OP_LIST)
+        {
+          if (op_list->ops[i]->data.op_list.op_list == child)
+            return TRUE;
+
+          if (meta_draw_op_list_contains (op_list->ops[i]->data.op_list.op_list,
+                                          child))
+            return TRUE;
+        }
+      else if (op_list->ops[i]->type == META_DRAW_TILE)
+        {
+          if (op_list->ops[i]->data.tile.op_list == child)
+            return TRUE;
+
+          if (meta_draw_op_list_contains (op_list->ops[i]->data.tile.op_list,
+                                          child))
+            return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
+/**
+ * Constructor for a MetaFrameStyle.
+ *
+ * \param parent  The parent style. Data not filled in here will be
+ *                looked for in the parent style, and in its parent
+ *                style, and so on.
+ *
+ * \return The newly-constructed style.
+ */
+MetaFrameStyle*
+meta_frame_style_new (MetaFrameStyle *parent)
+{
+  MetaFrameStyle *style;
+
+  style = g_new0 (MetaFrameStyle, 1);
+
+  style->refcount = 1;
+
+  /* Default alpha is fully opaque */
+  style->window_background_alpha = 255;
+
+  style->parent = parent;
+  if (parent)
+    meta_frame_style_ref (parent);
+
+  return style;
+}
+
+/**
+ * Increases the reference count of a frame style.
+ * If the style is NULL, this is a no-op.
+ *
+ * \param style  The style.
+ */
+void
+meta_frame_style_ref (MetaFrameStyle *style)
+{
+  g_return_if_fail (style != NULL);
+
+  style->refcount += 1;
+}
+
+static void
+free_button_ops (MetaDrawOpList *op_lists[META_BUTTON_TYPE_LAST][META_BUTTON_STATE_LAST])
+{
+  int i, j;
+
+  for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
+    for (j = 0; j < META_BUTTON_STATE_LAST; j++)
+      if (op_lists[i][j])
+        meta_draw_op_list_unref (op_lists[i][j]);
+}
+
+void
+meta_frame_style_unref (MetaFrameStyle *style)
+{
+  g_return_if_fail (style != NULL);
+  g_return_if_fail (style->refcount > 0);
+
+  style->refcount -= 1;
+
+  if (style->refcount == 0)
+    {
+      int i;
+
+      free_button_ops (style->buttons);
+
+      for (i = 0; i < META_FRAME_PIECE_LAST; i++)
+        if (style->pieces[i])
+          meta_draw_op_list_unref (style->pieces[i]);
+
+      if (style->layout)
+        meta_frame_layout_unref (style->layout);
+
+      if (style->window_background_color)
+        meta_color_spec_free (style->window_background_color);
+
+      /* we hold a reference to any parent style */
+      if (style->parent)
+        meta_frame_style_unref (style->parent);
+
+      DEBUG_FILL_STRUCT (style);
+      g_free (style);
+    }
+}
+
+static MetaDrawOpList*
+get_button (MetaFrameStyle *style,
+            MetaButtonType  type,
+            MetaButtonState state)
+{
+  MetaDrawOpList *op_list;
+  MetaFrameStyle *parent;
+
+  parent = style;
+  op_list = NULL;
+  while (parent && op_list == NULL)
+    {
+      op_list = parent->buttons[type][state];
+      parent = parent->parent;
+    }
+
+  /* We fall back to middle button backgrounds if we don't
+   * have the ones on the sides
+   */
+
+  if (op_list == NULL &&
+      (type == META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND ||
+       type == META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND))
+    return get_button (style, META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND,
+                       state);
+
+  if (op_list == NULL &&
+      (type == META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND ||
+       type == META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND))
+    return get_button (style, META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND,
+                       state);
+
+  /* We fall back to normal if no prelight */
+  if (op_list == NULL &&
+      state == META_BUTTON_STATE_PRELIGHT)
+    return get_button (style, type, META_BUTTON_STATE_NORMAL);
+
+  return op_list;
+}
+
+gboolean
+meta_frame_style_validate (MetaFrameStyle    *style,
+                           guint              current_theme_version,
+                           GError           **error)
+{
+  int i, j;
+
+  g_return_val_if_fail (style != NULL, FALSE);
+  g_return_val_if_fail (style->layout != NULL, FALSE);
+
+  for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
+    {
+      /* for now the "positional" buttons are optional */
+      if (i >= META_BUTTON_TYPE_CLOSE)
+        {
+          for (j = 0; j < META_BUTTON_STATE_LAST; j++)
+            {
+              if (get_button (style, i, j) == NULL &&
+                  meta_theme_earliest_version_with_button (i) <= current_theme_version
+                  )
+                {
+                  g_set_error (error, META_THEME_ERROR,
+                               META_THEME_ERROR_FAILED,
+                               _("<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be specified for this frame style"),
+                               meta_button_type_to_string (i),
+                               meta_button_state_to_string (j));
+                  return FALSE;
+                }
+            }
+        }
+    }
+
+  return TRUE;
+}
+
+static void
+button_rect (MetaButtonType           type,
+             const MetaFrameGeometry *fgeom,
+             int                      middle_background_offset,
+             GdkRectangle            *rect)
+{
+  switch (type)
+    {
+    case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
+      *rect = fgeom->left_left_background;
+      break;
+
+    case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
+      *rect = fgeom->left_middle_backgrounds[middle_background_offset];
+      break;
+
+    case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
+      *rect = fgeom->left_right_background;
+      break;
+
+    case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
+      *rect = fgeom->right_left_background;
+      break;
+
+    case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
+      *rect = fgeom->right_middle_backgrounds[middle_background_offset];
+      break;
+
+    case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
+      *rect = fgeom->right_right_background;
+      break;
+
+    case META_BUTTON_TYPE_CLOSE:
+      *rect = fgeom->close_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_SHADE:
+      *rect = fgeom->shade_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_UNSHADE:
+      *rect = fgeom->unshade_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_ABOVE:
+      *rect = fgeom->above_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_UNABOVE:
+      *rect = fgeom->unabove_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_STICK:
+      *rect = fgeom->stick_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_UNSTICK:
+      *rect = fgeom->unstick_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_MAXIMIZE:
+      *rect = fgeom->max_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_MINIMIZE:
+      *rect = fgeom->min_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_MENU:
+      *rect = fgeom->menu_rect.visible;
+      break;
+
+    case META_BUTTON_TYPE_LAST:
+      g_assert_not_reached ();
+      break;
+    }
+}
+
+void
+meta_frame_style_draw_with_style (MetaFrameStyle          *style,
+                                  GtkStyle                *style_gtk,
+                                  GtkWidget               *widget,
+                                  GdkDrawable             *drawable,
+                                  int                      x_offset,
+                                  int                      y_offset,
+                                  const GdkRectangle      *clip,
+                                  const MetaFrameGeometry *fgeom,
+                                  int                      client_width,
+                                  int                      client_height,
+                                  PangoLayout             *title_layout,
+                                  int                      text_height,
+                                  MetaButtonState          button_states[META_BUTTON_TYPE_LAST],
+                                  GdkPixbuf               *mini_icon,
+                                  GdkPixbuf               *icon)
+{
+  int i, j;
+  GdkRectangle titlebar_rect;
+  GdkRectangle left_titlebar_edge;
+  GdkRectangle right_titlebar_edge;
+  GdkRectangle bottom_titlebar_edge;
+  GdkRectangle top_titlebar_edge;
+  GdkRectangle left_edge, right_edge, bottom_edge;
+  PangoRectangle extents;
+  MetaDrawInfo draw_info;
+
+  g_return_if_fail (style_gtk->colormap == gdk_drawable_get_colormap (drawable));
+
+  titlebar_rect.x = 0;
+  titlebar_rect.y = 0;
+  titlebar_rect.width = fgeom->width;
+  titlebar_rect.height = fgeom->top_height;
+
+  left_titlebar_edge.x = titlebar_rect.x;
+  left_titlebar_edge.y = titlebar_rect.y + fgeom->top_titlebar_edge;
+  left_titlebar_edge.width = fgeom->left_titlebar_edge;
+  left_titlebar_edge.height = titlebar_rect.height - fgeom->top_titlebar_edge - fgeom->bottom_titlebar_edge;
+
+  right_titlebar_edge.y = left_titlebar_edge.y;
+  right_titlebar_edge.height = left_titlebar_edge.height;
+  right_titlebar_edge.width = fgeom->right_titlebar_edge;
+  right_titlebar_edge.x = titlebar_rect.x + titlebar_rect.width - right_titlebar_edge.width;
+
+  top_titlebar_edge.x = titlebar_rect.x;
+  top_titlebar_edge.y = titlebar_rect.y;
+  top_titlebar_edge.width = titlebar_rect.width;
+  top_titlebar_edge.height = fgeom->top_titlebar_edge;
+
+  bottom_titlebar_edge.x = titlebar_rect.x;
+  bottom_titlebar_edge.width = titlebar_rect.width;
+  bottom_titlebar_edge.height = fgeom->bottom_titlebar_edge;
+  bottom_titlebar_edge.y = titlebar_rect.y + titlebar_rect.height - bottom_titlebar_edge.height;
+
+  left_edge.x = 0;
+  left_edge.y = fgeom->top_height;
+  left_edge.width = fgeom->left_width;
+  left_edge.height = fgeom->height - fgeom->top_height - fgeom->bottom_height;
+
+  right_edge.x = fgeom->width - fgeom->right_width;
+  right_edge.y = fgeom->top_height;
+  right_edge.width = fgeom->right_width;
+  right_edge.height = fgeom->height - fgeom->top_height - fgeom->bottom_height;
+
+  bottom_edge.x = 0;
+  bottom_edge.y = fgeom->height - fgeom->bottom_height;
+  bottom_edge.width = fgeom->width;
+  bottom_edge.height = fgeom->bottom_height;
+
+  if (title_layout)
+    pango_layout_get_pixel_extents (title_layout,
+                                    NULL, &extents);
+
+  draw_info.mini_icon = mini_icon;
+  draw_info.icon = icon;
+  draw_info.title_layout = title_layout;
+  draw_info.title_layout_width = title_layout ? extents.width : 0;
+  draw_info.title_layout_height = title_layout ? extents.height : 0;
+  draw_info.fgeom = fgeom;
+
+  /* The enum is in the order the pieces should be rendered. */
+  i = 0;
+  while (i < META_FRAME_PIECE_LAST)
+    {
+      GdkRectangle rect;
+      GdkRectangle combined_clip;
+
+      switch ((MetaFramePiece) i)
+        {
+        case META_FRAME_PIECE_ENTIRE_BACKGROUND:
+          rect.x = 0;
+          rect.y = 0;
+          rect.width = fgeom->width;
+          rect.height = fgeom->height;
+          break;
+
+        case META_FRAME_PIECE_TITLEBAR:
+          rect = titlebar_rect;
+          break;
+
+        case META_FRAME_PIECE_LEFT_TITLEBAR_EDGE:
+          rect = left_titlebar_edge;
+          break;
+
+        case META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE:
+          rect = right_titlebar_edge;
+          break;
+
+        case META_FRAME_PIECE_TOP_TITLEBAR_EDGE:
+          rect = top_titlebar_edge;
+          break;
+
+        case META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE:
+          rect = bottom_titlebar_edge;
+          break;
+
+        case META_FRAME_PIECE_TITLEBAR_MIDDLE:
+          rect.x = left_titlebar_edge.x + left_titlebar_edge.width;
+          rect.y = top_titlebar_edge.y + top_titlebar_edge.height;
+          rect.width = titlebar_rect.width - left_titlebar_edge.width -
+            right_titlebar_edge.width;
+          rect.height = titlebar_rect.height - top_titlebar_edge.height - bottom_titlebar_edge.height;
+          break;
+
+        case META_FRAME_PIECE_TITLE:
+          rect = fgeom->title_rect;
+          break;
+
+        case META_FRAME_PIECE_LEFT_EDGE:
+          rect = left_edge;
+          break;
+
+        case META_FRAME_PIECE_RIGHT_EDGE:
+          rect = right_edge;
+          break;
+
+        case META_FRAME_PIECE_BOTTOM_EDGE:
+          rect = bottom_edge;
+          break;
+
+        case META_FRAME_PIECE_OVERLAY:
+          rect.x = 0;
+          rect.y = 0;
+          rect.width = fgeom->width;
+          rect.height = fgeom->height;
+          break;
+
+        case META_FRAME_PIECE_LAST:
+          g_assert_not_reached ();
+          break;
+        }
+
+      rect.x += x_offset;
+      rect.y += y_offset;
+
+      if (clip == NULL)
+        combined_clip = rect;
+      else
+        gdk_rectangle_intersect ((GdkRectangle*) clip, /* const cast */
+                                 &rect,
+                                 &combined_clip);
+
+      if (combined_clip.width > 0 && combined_clip.height > 0)
+        {
+          MetaDrawOpList *op_list;
+          MetaFrameStyle *parent;
+
+          parent = style;
+          op_list = NULL;
+          while (parent && op_list == NULL)
+            {
+              op_list = parent->pieces[i];
+              parent = parent->parent;
+            }
+
+          if (op_list)
+            {
+              MetaRectangle m_rect;
+              m_rect = meta_rect (rect.x, rect.y, rect.width, rect.height);
+              meta_draw_op_list_draw_with_style (op_list,
+                                                 style_gtk,
+                                                 widget,
+                                                 drawable,
+                                                 &combined_clip,
+                                                 &draw_info,
+                                                 m_rect);
+            }
+        }
+
+
+      /* Draw buttons just before overlay */
+      if ((i + 1) == META_FRAME_PIECE_OVERLAY)
+        {
+          int middle_bg_offset;
+
+          middle_bg_offset = 0;
+          j = 0;
+          while (j < META_BUTTON_TYPE_LAST)
+            {
+              button_rect (j, fgeom, middle_bg_offset, &rect);
+
+              rect.x += x_offset;
+              rect.y += y_offset;
+
+              if (clip == NULL)
+                combined_clip = rect;
+              else
+                gdk_rectangle_intersect ((GdkRectangle*) clip, /* const cast */
+                                         &rect,
+                                         &combined_clip);
+
+              if (combined_clip.width > 0 && combined_clip.height > 0)
+                {
+                  MetaDrawOpList *op_list;
+
+                  op_list = get_button (style, j, button_states[j]);
+
+                  if (op_list)
+                    {
+                      MetaRectangle m_rect;
+                      m_rect = meta_rect (rect.x, rect.y,
+                                          rect.width, rect.height);
+                      meta_draw_op_list_draw_with_style (op_list,
+                                                         style_gtk,
+                                                         widget,
+                                                         drawable,
+                                                         &combined_clip,
+                                                         &draw_info,
+                                                         m_rect);
+                    }
+                }
+
+              /* MIDDLE_BACKGROUND type may get drawn more than once */
+              if ((j == META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND ||
+                   j == META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND) &&
+                  middle_bg_offset < MAX_MIDDLE_BACKGROUNDS)
+                {
+                  ++middle_bg_offset;
+                }
+              else
+                {
+                  middle_bg_offset = 0;
+                  ++j;
+                }
+            }
+        }
+
+      ++i;
+    }
+}
+
+void
+meta_frame_style_draw (MetaFrameStyle          *style,
+                       GtkWidget               *widget,
+                       GdkDrawable             *drawable,
+                       int                      x_offset,
+                       int                      y_offset,
+                       const GdkRectangle      *clip,
+                       const MetaFrameGeometry *fgeom,
+                       int                      client_width,
+                       int                      client_height,
+                       PangoLayout             *title_layout,
+                       int                      text_height,
+                       MetaButtonState          button_states[META_BUTTON_TYPE_LAST],
+                       GdkPixbuf               *mini_icon,
+                       GdkPixbuf               *icon)
+{
+  meta_frame_style_draw_with_style (style, gtk_widget_get_style (widget), widget,
+                                    drawable, x_offset, y_offset,
+                                    clip, fgeom, client_width, client_height,
+                                    title_layout, text_height,
+                                    button_states, mini_icon, icon);
+}
+
+MetaFrameStyleSet*
+meta_frame_style_set_new (MetaFrameStyleSet *parent)
+{
+  MetaFrameStyleSet *style_set;
+
+  style_set = g_new0 (MetaFrameStyleSet, 1);
+
+  style_set->parent = parent;
+  if (parent)
+    meta_frame_style_set_ref (parent);
+
+  style_set->refcount = 1;
+
+  return style_set;
+}
+
+static void
+free_focus_styles (MetaFrameStyle *focus_styles[META_FRAME_FOCUS_LAST])
+{
+  int i;
+
+  for (i = 0; i < META_FRAME_FOCUS_LAST; i++)
+    if (focus_styles[i])
+      meta_frame_style_unref (focus_styles[i]);
+}
+
+void
+meta_frame_style_set_ref (MetaFrameStyleSet *style_set)
+{
+  g_return_if_fail (style_set != NULL);
+
+  style_set->refcount += 1;
+}
+
+void
+meta_frame_style_set_unref (MetaFrameStyleSet *style_set)
+{
+  g_return_if_fail (style_set != NULL);
+  g_return_if_fail (style_set->refcount > 0);
+
+  style_set->refcount -= 1;
+
+  if (style_set->refcount == 0)
+    {
+      int i;
+
+      for (i = 0; i < META_FRAME_RESIZE_LAST; i++)
+        {
+          free_focus_styles (style_set->normal_styles[i]);
+          free_focus_styles (style_set->shaded_styles[i]);
+        }
+
+      free_focus_styles (style_set->maximized_styles);
+      free_focus_styles (style_set->maximized_and_shaded_styles);
+
+      if (style_set->parent)
+        meta_frame_style_set_unref (style_set->parent);
+
+      DEBUG_FILL_STRUCT (style_set);
+      g_free (style_set);
+    }
+}
+
+
+static MetaFrameStyle*
+get_style (MetaFrameStyleSet *style_set,
+           MetaFrameState     state,
+           MetaFrameResize    resize,
+           MetaFrameFocus     focus)
+{
+  MetaFrameStyle *style;
+
+  style = NULL;
+
+  switch (state)
+    {
+    case META_FRAME_STATE_NORMAL:
+    case META_FRAME_STATE_SHADED:
+      {
+        if (state == META_FRAME_STATE_SHADED)
+          style = style_set->shaded_styles[resize][focus];
+        else
+          style = style_set->normal_styles[resize][focus];
+
+        /* Try parent if we failed here */
+        if (style == NULL && style_set->parent)
+          style = get_style (style_set->parent, state, resize, focus);
+
+        /* Allow people to omit the vert/horz/none resize modes */
+        if (style == NULL &&
+            resize != META_FRAME_RESIZE_BOTH)
+          style = get_style (style_set, state, META_FRAME_RESIZE_BOTH, focus);
+      }
+      break;
+    default:
+      {
+        MetaFrameStyle **styles;
+
+        styles = NULL;
+
+        switch (state)
+          {
+          case META_FRAME_STATE_MAXIMIZED:
+            styles = style_set->maximized_styles;
+            break;
+          case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
+            styles = style_set->maximized_and_shaded_styles;
+            break;
+          case META_FRAME_STATE_NORMAL:
+          case META_FRAME_STATE_SHADED:
+          case META_FRAME_STATE_LAST:
+            g_assert_not_reached ();
+            break;
+          }
+
+        style = styles[focus];
+
+        /* Try parent if we failed here */
+        if (style == NULL && style_set->parent)
+          style = get_style (style_set->parent, state, resize, focus);
+      }
+    }
+
+  return style;
+}
+
+static gboolean
+check_state  (MetaFrameStyleSet *style_set,
+              MetaFrameState     state,
+              GError           **error)
+{
+  int i;
+
+  for (i = 0; i < META_FRAME_FOCUS_LAST; i++)
+    {
+      if (get_style (style_set, state,
+                     META_FRAME_RESIZE_NONE, i) == NULL)
+        {
+          /* Translators: This error occurs when a <frame> tag is missing
+           * in theme XML.  The "<frame ...>" is intended as a noun phrase,
+           * and the "missing" qualifies it.  You should translate "whatever".
+           */
+          g_set_error (error, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"),
+                       meta_frame_state_to_string (state),
+                       meta_frame_resize_to_string (META_FRAME_RESIZE_NONE),
+                       meta_frame_focus_to_string (i));
+          return FALSE;
+        }
+    }
+
+  return TRUE;
+}
+
+gboolean
+meta_frame_style_set_validate  (MetaFrameStyleSet *style_set,
+                                GError           **error)
+{
+  int i, j;
+
+  g_return_val_if_fail (style_set != NULL, FALSE);
+
+  for (i = 0; i < META_FRAME_RESIZE_LAST; i++)
+    for (j = 0; j < META_FRAME_FOCUS_LAST; j++)
+      if (get_style (style_set, META_FRAME_STATE_NORMAL, i, j) == NULL)
+        {
+          g_set_error (error, META_THEME_ERROR,
+                       META_THEME_ERROR_FAILED,
+                       _("Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"),
+                       meta_frame_state_to_string (META_FRAME_STATE_NORMAL),
+                       meta_frame_resize_to_string (i),
+                       meta_frame_focus_to_string (j));
+          return FALSE;
+        }
+
+  if (!check_state (style_set, META_FRAME_STATE_SHADED, error))
+    return FALSE;
+
+  if (!check_state (style_set, META_FRAME_STATE_MAXIMIZED, error))
+    return FALSE;
+
+  if (!check_state (style_set, META_FRAME_STATE_MAXIMIZED_AND_SHADED, error))
+    return FALSE;
+
+  return TRUE;
+}
+
+MetaTheme*
+meta_theme_get_current (void)
+{
+  return meta_current_theme;
+}
+
+void
+meta_theme_set_current (const char *name,
+                        gboolean    force_reload)
+{
+  MetaTheme *new_theme;
+  GError *err;
+
+  meta_topic (META_DEBUG_THEMES, "Setting current theme to \"%s\"\n", name);
+
+  if (!force_reload &&
+      meta_current_theme &&
+      strcmp (name, meta_current_theme->name) == 0)
+    return;
+
+  err = NULL;
+  new_theme = meta_theme_load (name, &err);
+
+  if (new_theme == NULL)
+    {
+      meta_warning (_("Failed to load theme \"%s\": %s\n"),
+                    name, err->message);
+      g_error_free (err);
+    }
+  else
+    {
+      if (meta_current_theme)
+        meta_theme_free (meta_current_theme);
+
+      meta_current_theme = new_theme;
+
+      meta_topic (META_DEBUG_THEMES, "New theme is \"%s\"\n", meta_current_theme->name);
+    }
+}
+
+MetaTheme*
+meta_theme_new (void)
+{
+  MetaTheme *theme;
+
+  theme = g_new0 (MetaTheme, 1);
+
+  theme->images_by_filename =
+    g_hash_table_new_full (g_str_hash,
+                           g_str_equal,
+                           g_free,
+                           (GDestroyNotify) g_object_unref);
+
+  theme->layouts_by_name =
+    g_hash_table_new_full (g_str_hash,
+                           g_str_equal,
+                           g_free,
+                           (GDestroyNotify) meta_frame_layout_unref);
+
+  theme->draw_op_lists_by_name =
+    g_hash_table_new_full (g_str_hash,
+                           g_str_equal,
+                           g_free,
+                           (GDestroyNotify) meta_draw_op_list_unref);
+
+  theme->styles_by_name =
+    g_hash_table_new_full (g_str_hash,
+                           g_str_equal,
+                           g_free,
+                           (GDestroyNotify) meta_frame_style_unref);
+
+  theme->style_sets_by_name =
+    g_hash_table_new_full (g_str_hash,
+                           g_str_equal,
+                           g_free,
+                           (GDestroyNotify) meta_frame_style_set_unref);
+
+  /* Create our variable quarks so we can look up variables without
+     having to strcmp for the names */
+  theme->quark_width = g_quark_from_static_string ("width");
+  theme->quark_height = g_quark_from_static_string ("height");
+  theme->quark_object_width = g_quark_from_static_string ("object_width");
+  theme->quark_object_height = g_quark_from_static_string ("object_height");
+  theme->quark_left_width = g_quark_from_static_string ("left_width");
+  theme->quark_right_width = g_quark_from_static_string ("right_width");
+  theme->quark_top_height = g_quark_from_static_string ("top_height");
+  theme->quark_bottom_height = g_quark_from_static_string ("bottom_height");
+  theme->quark_mini_icon_width = g_quark_from_static_string ("mini_icon_width");
+  theme->quark_mini_icon_height = g_quark_from_static_string ("mini_icon_height");
+  theme->quark_icon_width = g_quark_from_static_string ("icon_width");
+  theme->quark_icon_height = g_quark_from_static_string ("icon_height");
+  theme->quark_title_width = g_quark_from_static_string ("title_width");
+  theme->quark_title_height = g_quark_from_static_string ("title_height");
+  return theme;
+}
+
+
+void
+meta_theme_free (MetaTheme *theme)
+{
+  int i;
+
+  g_return_if_fail (theme != NULL);
+
+  g_free (theme->name);
+  g_free (theme->dirname);
+  g_free (theme->filename);
+  g_free (theme->readable_name);
+  g_free (theme->date);
+  g_free (theme->description);
+  g_free (theme->author);
+  g_free (theme->copyright);
+
+  /* be more careful when destroying the theme hash tables,
+     since they are only constructed as needed, and may be NULL. */
+  if (theme->integer_constants)
+    g_hash_table_destroy (theme->integer_constants);
+  if (theme->images_by_filename)
+    g_hash_table_destroy (theme->images_by_filename);
+  if (theme->layouts_by_name)
+    g_hash_table_destroy (theme->layouts_by_name);
+  if (theme->draw_op_lists_by_name)
+    g_hash_table_destroy (theme->draw_op_lists_by_name);
+  if (theme->styles_by_name)
+    g_hash_table_destroy (theme->styles_by_name);
+  if (theme->style_sets_by_name)
+    g_hash_table_destroy (theme->style_sets_by_name);
+
+  for (i = 0; i < META_FRAME_TYPE_LAST; i++)
+    if (theme->style_sets_by_type[i])
+      meta_frame_style_set_unref (theme->style_sets_by_type[i]);
+
+  DEBUG_FILL_STRUCT (theme);
+  g_free (theme);
+}
+
+gboolean
+meta_theme_validate (MetaTheme *theme,
+                     GError   **error)
+{
+  int i;
+
+  g_return_val_if_fail (theme != NULL, FALSE);
+
+  /* FIXME what else should be checked? */
+
+  g_assert (theme->name);
+
+  if (theme->readable_name == NULL)
+    {
+      /* Translators: This error means that a necessary XML tag (whose name
+       * is given in angle brackets) was not found in a given theme (whose
+       * name is given second, in quotation marks).
+       */
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("No <%s> set for theme \"%s\""), "name", theme->name);
+      return FALSE;
+    }
+
+  if (theme->author == NULL)
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("No <%s> set for theme \"%s\""), "author", theme->name);
+      return FALSE;
+    }
+
+  if (theme->date == NULL)
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("No <%s> set for theme \"%s\""), "date", theme->name);
+      return FALSE;
+    }
+
+  if (theme->description == NULL)
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("No <%s> set for theme \"%s\""), "description", theme->name);
+      return FALSE;
+    }
+
+  if (theme->copyright == NULL)
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("No <%s> set for theme \"%s\""), "copyright", theme->name);
+      return FALSE;
+    }
+
+  for (i = 0; i < (int)META_FRAME_TYPE_LAST; i++)
+    if (theme->style_sets_by_type[i] == NULL)
+      {
+        g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                     _("No frame style set for window type \"%s\" in theme \"%s\", add a <window type=\"%s\" style_set=\"whatever\"/> element"),
+                     meta_frame_type_to_string (i),
+                     theme->name,
+                     meta_frame_type_to_string (i));
+
+        return FALSE;
+      }
+
+  return TRUE;
+}
+
+GdkPixbuf*
+meta_theme_load_image (MetaTheme  *theme,
+                       const char *filename,
+                       guint size_of_theme_icons,
+                       GError    **error)
+{
+  GdkPixbuf *pixbuf;
+
+  pixbuf = g_hash_table_lookup (theme->images_by_filename,
+                                filename);
+
+  if (pixbuf == NULL)
+    {
+
+      if (g_str_has_prefix (filename, "theme:") &&
+          META_THEME_ALLOWS (theme, META_THEME_IMAGES_FROM_ICON_THEMES))
+        {
+          pixbuf = gtk_icon_theme_load_icon (
+              gtk_icon_theme_get_default (),
+              filename+6,
+              size_of_theme_icons,
+              0,
+              error);
+          if (pixbuf == NULL) return NULL;
+         }
+      else
+        {
+          char *full_path;
+          full_path = g_build_filename (theme->dirname, filename, NULL);
+
+          pixbuf = gdk_pixbuf_new_from_file (full_path, error);
+          if (pixbuf == NULL)
+            {
+              g_free (full_path);
+              return NULL;
+            }
+
+          g_free (full_path);
+        }
+      g_hash_table_replace (theme->images_by_filename,
+                            g_strdup (filename),
+                            pixbuf);
+    }
+
+  g_assert (pixbuf);
+
+  g_object_ref (G_OBJECT (pixbuf));
+
+  return pixbuf;
+}
+
+static MetaFrameStyle*
+theme_get_style (MetaTheme     *theme,
+                 MetaFrameType  type,
+                 MetaFrameFlags flags)
+{
+  MetaFrameState state;
+  MetaFrameResize resize;
+  MetaFrameFocus focus;
+  MetaFrameStyle *style;
+  MetaFrameStyleSet *style_set;
+
+  style_set = theme->style_sets_by_type[type];
+
+  /* Right now the parser forces a style set for all types,
+   * but this fallback code is here in case I take that out.
+   */
+  if (style_set == NULL)
+    style_set = theme->style_sets_by_type[META_FRAME_TYPE_NORMAL];
+  if (style_set == NULL)
+    return NULL;
+
+  switch (flags & (META_FRAME_MAXIMIZED | META_FRAME_SHADED))
+    {
+    case 0:
+      state = META_FRAME_STATE_NORMAL;
+      break;
+    case META_FRAME_MAXIMIZED:
+      state = META_FRAME_STATE_MAXIMIZED;
+      break;
+    case META_FRAME_SHADED:
+      state = META_FRAME_STATE_SHADED;
+      break;
+    case (META_FRAME_MAXIMIZED | META_FRAME_SHADED):
+      state = META_FRAME_STATE_MAXIMIZED_AND_SHADED;
+      break;
+    default:
+      g_assert_not_reached ();
+      state = META_FRAME_STATE_LAST; /* compiler */
+      break;
+    }
+
+  switch (flags & (META_FRAME_ALLOWS_VERTICAL_RESIZE | META_FRAME_ALLOWS_HORIZONTAL_RESIZE))
+    {
+    case 0:
+      resize = META_FRAME_RESIZE_NONE;
+      break;
+    case META_FRAME_ALLOWS_VERTICAL_RESIZE:
+      resize = META_FRAME_RESIZE_VERTICAL;
+      break;
+    case META_FRAME_ALLOWS_HORIZONTAL_RESIZE:
+      resize = META_FRAME_RESIZE_HORIZONTAL;
+      break;
+    case (META_FRAME_ALLOWS_VERTICAL_RESIZE | META_FRAME_ALLOWS_HORIZONTAL_RESIZE):
+      resize = META_FRAME_RESIZE_BOTH;
+      break;
+    default:
+      g_assert_not_reached ();
+      resize = META_FRAME_RESIZE_LAST; /* compiler */
+      break;
+    }
+
+  /* re invert the styles used for focus/unfocussed while flashing a frame */
+  if (((flags & META_FRAME_HAS_FOCUS) && !(flags & META_FRAME_IS_FLASHING))
+      || (!(flags & META_FRAME_HAS_FOCUS) && (flags & META_FRAME_IS_FLASHING)))
+    focus = META_FRAME_FOCUS_YES;
+  else
+    focus = META_FRAME_FOCUS_NO;
+
+  style = get_style (style_set, state, resize, focus);
+
+  return style;
+}
+
+MetaFrameStyle*
+meta_theme_get_frame_style (MetaTheme     *theme,
+                            MetaFrameType  type,
+                            MetaFrameFlags flags)
+{
+  MetaFrameStyle *style;
+
+  g_return_val_if_fail (type < META_FRAME_TYPE_LAST, NULL);
+
+  style = theme_get_style (theme, type, flags);
+
+  return style;
+}
+
+double
+meta_theme_get_title_scale (MetaTheme     *theme,
+                            MetaFrameType  type,
+                            MetaFrameFlags flags)
+{
+  MetaFrameStyle *style;
+
+  g_return_val_if_fail (type < META_FRAME_TYPE_LAST, 1.0);
+
+  style = theme_get_style (theme, type, flags);
+
+  /* Parser is not supposed to allow this currently */
+  if (style == NULL)
+    return 1.0;
+
+  return style->layout->title_scale;
+}
+
+void
+meta_theme_draw_frame_with_style (MetaTheme              *theme,
+                                  GtkStyle               *style_gtk,
+                                  GtkWidget              *widget,
+                                  GdkDrawable            *drawable,
+                                  const GdkRectangle     *clip,
+                                  int                     x_offset,
+                                  int                     y_offset,
+                                  MetaFrameType           type,
+                                  MetaFrameFlags          flags,
+                                  int                     client_width,
+                                  int                     client_height,
+                                  PangoLayout            *title_layout,
+                                  int                     text_height,
+                                  const MetaButtonLayout *button_layout,
+                                  MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
+                                  GdkPixbuf              *mini_icon,
+                                  GdkPixbuf              *icon)
+{
+  MetaFrameGeometry fgeom;
+  MetaFrameStyle *style;
+
+  g_return_if_fail (type < META_FRAME_TYPE_LAST);
+
+  style = theme_get_style (theme, type, flags);
+
+  /* Parser is not supposed to allow this currently */
+  if (style == NULL)
+    return;
+
+  meta_frame_layout_calc_geometry (style->layout,
+                                   text_height,
+                                   flags,
+                                   client_width, client_height,
+                                   button_layout,
+                                   &fgeom,
+                                   theme);
+
+  meta_frame_style_draw_with_style (style,
+                                    style_gtk,
+                                    widget,
+                                    drawable,
+                                    x_offset, y_offset,
+                                    clip,
+                                    &fgeom,
+                                    client_width, client_height,
+                                    title_layout,
+                                    text_height,
+                                    button_states,
+                                    mini_icon, icon);
+}
+
+void
+meta_theme_draw_frame (MetaTheme              *theme,
+                       GtkWidget              *widget,
+                       GdkDrawable            *drawable,
+                       const GdkRectangle     *clip,
+                       int                     x_offset,
+                       int                     y_offset,
+                       MetaFrameType           type,
+                       MetaFrameFlags          flags,
+                       int                     client_width,
+                       int                     client_height,
+                       PangoLayout            *title_layout,
+                       int                     text_height,
+                       const MetaButtonLayout *button_layout,
+                       MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
+                       GdkPixbuf              *mini_icon,
+                       GdkPixbuf              *icon)
+{
+  meta_theme_draw_frame_with_style (theme, gtk_widget_get_style (widget), widget,
+                                    drawable, clip, x_offset, y_offset, type,flags,
+                                    client_width, client_height,
+                                    title_layout, text_height,
+                                    button_layout, button_states,
+                                    mini_icon, icon);
+}
+
+void
+meta_theme_draw_frame_by_name (MetaTheme              *theme,
+                               GtkWidget              *widget,
+                               GdkDrawable            *drawable,
+                               const GdkRectangle     *clip,
+                               int                     x_offset,
+                               int                     y_offset,
+                               const gchar             *style_name,
+                               MetaFrameFlags          flags,
+                               int                     client_width,
+                               int                     client_height,
+                               PangoLayout            *title_layout,
+                               int                     text_height,
+                               const MetaButtonLayout *button_layout,
+                               MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
+                               GdkPixbuf              *mini_icon,
+                               GdkPixbuf              *icon)
+{
+  MetaFrameGeometry fgeom;
+  MetaFrameStyle *style;
+
+  style = meta_theme_lookup_style (theme, style_name);
+
+  /* Parser is not supposed to allow this currently */
+  if (style == NULL)
+    return;
+
+  meta_frame_layout_calc_geometry (style->layout,
+                                   text_height,
+                                   flags,
+                                   client_width, client_height,
+                                   button_layout,
+                                   &fgeom,
+                                   theme);
+
+  meta_frame_style_draw (style,
+                         widget,
+                         drawable,
+                         x_offset, y_offset,
+                         clip,
+                         &fgeom,
+                         client_width, client_height,
+                         title_layout,
+                         text_height,
+                         button_states,
+                         mini_icon, icon);
+}
+
+void
+meta_theme_get_frame_borders (MetaTheme      *theme,
+                              MetaFrameType   type,
+                              int             text_height,
+                              MetaFrameFlags  flags,
+                              int            *top_height,
+                              int            *bottom_height,
+                              int            *left_width,
+                              int            *right_width)
+{
+  MetaFrameStyle *style;
+
+  g_return_if_fail (type < META_FRAME_TYPE_LAST);
+
+  if (top_height)
+    *top_height = 0;
+  if (bottom_height)
+    *bottom_height = 0;
+  if (left_width)
+    *left_width = 0;
+  if (right_width)
+    *right_width = 0;
+
+  style = theme_get_style (theme, type, flags);
+
+  /* Parser is not supposed to allow this currently */
+  if (style == NULL)
+    return;
+
+  meta_frame_layout_get_borders (style->layout,
+                                 text_height,
+                                 flags,
+                                 top_height, bottom_height,
+                                 left_width, right_width);
+}
+
+void
+meta_theme_calc_geometry (MetaTheme              *theme,
+                          MetaFrameType           type,
+                          int                     text_height,
+                          MetaFrameFlags          flags,
+                          int                     client_width,
+                          int                     client_height,
+                          const MetaButtonLayout *button_layout,
+                          MetaFrameGeometry      *fgeom)
+{
+  MetaFrameStyle *style;
+
+  g_return_if_fail (type < META_FRAME_TYPE_LAST);
+
+  style = theme_get_style (theme, type, flags);
+
+  /* Parser is not supposed to allow this currently */
+  if (style == NULL)
+    return;
+
+  meta_frame_layout_calc_geometry (style->layout,
+                                   text_height,
+                                   flags,
+                                   client_width, client_height,
+                                   button_layout,
+                                   fgeom,
+                                   theme);
+}
+
+MetaFrameLayout*
+meta_theme_lookup_layout (MetaTheme         *theme,
+                          const char        *name)
+{
+  return g_hash_table_lookup (theme->layouts_by_name, name);
+}
+
+void
+meta_theme_insert_layout (MetaTheme         *theme,
+                          const char        *name,
+                          MetaFrameLayout   *layout)
+{
+  meta_frame_layout_ref (layout);
+  g_hash_table_replace (theme->layouts_by_name, g_strdup (name), layout);
+}
+
+MetaDrawOpList*
+meta_theme_lookup_draw_op_list (MetaTheme         *theme,
+                                const char        *name)
+{
+  return g_hash_table_lookup (theme->draw_op_lists_by_name, name);
+}
+
+void
+meta_theme_insert_draw_op_list (MetaTheme         *theme,
+                                const char        *name,
+                                MetaDrawOpList    *op_list)
+{
+  meta_draw_op_list_ref (op_list);
+  g_hash_table_replace (theme->draw_op_lists_by_name, g_strdup (name), op_list);
+}
+
+MetaFrameStyle*
+meta_theme_lookup_style (MetaTheme         *theme,
+                         const char        *name)
+{
+  return g_hash_table_lookup (theme->styles_by_name, name);
+}
+
+void
+meta_theme_insert_style (MetaTheme         *theme,
+                         const char        *name,
+                         MetaFrameStyle    *style)
+{
+  meta_frame_style_ref (style);
+  g_hash_table_replace (theme->styles_by_name, g_strdup (name), style);
+}
+
+MetaFrameStyleSet*
+meta_theme_lookup_style_set (MetaTheme         *theme,
+                             const char        *name)
+{
+  return g_hash_table_lookup (theme->style_sets_by_name, name);
+}
+
+void
+meta_theme_insert_style_set    (MetaTheme         *theme,
+                                const char        *name,
+                                MetaFrameStyleSet *style_set)
+{
+  meta_frame_style_set_ref (style_set);
+  g_hash_table_replace (theme->style_sets_by_name, g_strdup (name), style_set);
+}
+
+static gboolean
+first_uppercase (const char *str)
+{
+  return g_ascii_isupper (*str);
+}
+
+gboolean
+meta_theme_define_int_constant (MetaTheme   *theme,
+                                const char  *name,
+                                int          value,
+                                GError     **error)
+{
+  if (theme->integer_constants == NULL)
+    theme->integer_constants = g_hash_table_new_full (g_str_hash,
+                                                      g_str_equal,
+                                                      g_free,
+                                                      NULL);
+
+  if (!first_uppercase (name))
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("User-defined constants must begin with a capital letter; \"%s\" does not"),
+                   name);
+      return FALSE;
+    }
+
+  if (g_hash_table_lookup_extended (theme->integer_constants, name, NULL, NULL))
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("Constant \"%s\" has already been defined"),
+                   name);
+
+      return FALSE;
+    }
+
+  g_hash_table_insert (theme->integer_constants,
+                       g_strdup (name),
+                       GINT_TO_POINTER (value));
+
+  return TRUE;
+}
+
+gboolean
+meta_theme_lookup_int_constant (MetaTheme   *theme,
+                                const char  *name,
+                                int         *value)
+{
+  gpointer old_value;
+
+  *value = 0;
+
+  if (theme->integer_constants == NULL)
+    return FALSE;
+
+  if (g_hash_table_lookup_extended (theme->integer_constants,
+                                    name, NULL, &old_value))
+    {
+      *value = GPOINTER_TO_INT (old_value);
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+gboolean
+meta_theme_define_float_constant (MetaTheme   *theme,
+                                  const char  *name,
+                                  double       value,
+                                  GError     **error)
+{
+  double *d;
+
+  if (theme->float_constants == NULL)
+    theme->float_constants = g_hash_table_new_full (g_str_hash,
+                                                    g_str_equal,
+                                                    g_free,
+                                                    g_free);
+
+  if (!first_uppercase (name))
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("User-defined constants must begin with a capital letter; \"%s\" does not"),
+                   name);
+      return FALSE;
+    }
+
+  if (g_hash_table_lookup_extended (theme->float_constants, name, NULL, NULL))
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("Constant \"%s\" has already been defined"),
+                   name);
+
+      return FALSE;
+    }
+
+  d = g_new (double, 1);
+  *d = value;
+
+  g_hash_table_insert (theme->float_constants,
+                       g_strdup (name), d);
+
+  return TRUE;
+}
+
+gboolean
+meta_theme_lookup_float_constant (MetaTheme   *theme,
+                                  const char  *name,
+                                  double      *value)
+{
+  double *d;
+
+  *value = 0.0;
+
+  if (theme->float_constants == NULL)
+    return FALSE;
+
+  d = g_hash_table_lookup (theme->float_constants, name);
+
+  if (d)
+    {
+      *value = *d;
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+gboolean
+meta_theme_define_color_constant (MetaTheme   *theme,
+                                  const char  *name,
+                                  const char  *value,
+                                  GError     **error)
+{
+  if (theme->color_constants == NULL)
+    theme->color_constants = g_hash_table_new_full (g_str_hash,
+                                                    g_str_equal,
+                                                    g_free,
+                                                    NULL);
+
+  if (!first_uppercase (name))
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("User-defined constants must begin with a capital letter; \"%s\" does not"),
+                   name);
+      return FALSE;
+    }
+
+  if (g_hash_table_lookup_extended (theme->color_constants, name, NULL, NULL))
+    {
+      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
+                   _("Constant \"%s\" has already been defined"),
+                   name);
+
+      return FALSE;
+    }
+
+  g_hash_table_insert (theme->color_constants,
+                       g_strdup (name),
+                       g_strdup (value));
+
+  return TRUE;
+}
+
+/**
+ * Looks up a colour constant.
+ *
+ * \param theme  the theme containing the constant
+ * \param name  the name of the constant
+ * \param value  [out] the string representation of the colour, or NULL if it
+ *               doesn't exist
+ * \return  TRUE if it exists, FALSE otherwise
+ */
+gboolean
+meta_theme_lookup_color_constant (MetaTheme   *theme,
+                                  const char  *name,
+                                  char       **value)
+{
+  char *result;
+
+  *value = NULL;
+
+  if (theme->color_constants == NULL)
+    return FALSE;
+
+  result = g_hash_table_lookup (theme->color_constants, name);
+
+  if (result)
+    {
+      *value = result;
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+
+PangoFontDescription*
+meta_gtk_widget_get_font_desc (GtkWidget *widget,
+                               double     scale,
+			       const PangoFontDescription *override)
+{
+  PangoFontDescription *font_desc;
+
+  g_return_val_if_fail (gtk_widget_get_realized (widget), NULL);
+
+  font_desc = pango_font_description_copy (gtk_widget_get_style (widget)->font_desc);
+
+  if (override)
+    pango_font_description_merge (font_desc, override, TRUE);
+
+  pango_font_description_set_size (font_desc,
+                                   MAX (pango_font_description_get_size (font_desc) * scale, 1));
+
+  return font_desc;
+}
+
+/**
+ * Returns the height of the letters in a particular font.
+ *
+ * \param font_desc  the font
+ * \param context  the context of the font
+ * \return  the height of the letters
+ */
+int
+meta_pango_font_desc_get_text_height (const PangoFontDescription *font_desc,
+                                      PangoContext         *context)
+{
+  PangoFontMetrics *metrics;
+  PangoLanguage *lang;
+  int retval;
+
+  lang = pango_context_get_language (context);
+  metrics = pango_context_get_metrics (context, font_desc, lang);
+
+  retval = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
+                         pango_font_metrics_get_descent (metrics));
+
+  pango_font_metrics_unref (metrics);
+
+  return retval;
+}
+
+MetaGtkColorComponent
+meta_color_component_from_string (const char *str)
+{
+  if (strcmp ("fg", str) == 0)
+    return META_GTK_COLOR_FG;
+  else if (strcmp ("bg", str) == 0)
+    return META_GTK_COLOR_BG;
+  else if (strcmp ("light", str) == 0)
+    return META_GTK_COLOR_LIGHT;
+  else if (strcmp ("dark", str) == 0)
+    return META_GTK_COLOR_DARK;
+  else if (strcmp ("mid", str) == 0)
+    return META_GTK_COLOR_MID;
+  else if (strcmp ("text", str) == 0)
+    return META_GTK_COLOR_TEXT;
+  else if (strcmp ("base", str) == 0)
+    return META_GTK_COLOR_BASE;
+  else if (strcmp ("text_aa", str) == 0)
+    return META_GTK_COLOR_TEXT_AA;
+  else
+    return META_GTK_COLOR_LAST;
+}
+
+const char*
+meta_color_component_to_string (MetaGtkColorComponent component)
+{
+  switch (component)
+    {
+    case META_GTK_COLOR_FG:
+      return "fg";
+    case META_GTK_COLOR_BG:
+      return "bg";
+    case META_GTK_COLOR_LIGHT:
+      return "light";
+    case META_GTK_COLOR_DARK:
+      return "dark";
+    case META_GTK_COLOR_MID:
+      return "mid";
+    case META_GTK_COLOR_TEXT:
+      return "text";
+    case META_GTK_COLOR_BASE:
+      return "base";
+    case META_GTK_COLOR_TEXT_AA:
+      return "text_aa";
+    case META_GTK_COLOR_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaButtonState
+meta_button_state_from_string (const char *str)
+{
+  if (strcmp ("normal", str) == 0)
+    return META_BUTTON_STATE_NORMAL;
+  else if (strcmp ("pressed", str) == 0)
+    return META_BUTTON_STATE_PRESSED;
+  else if (strcmp ("prelight", str) == 0)
+    return META_BUTTON_STATE_PRELIGHT;
+  else
+    return META_BUTTON_STATE_LAST;
+}
+
+const char*
+meta_button_state_to_string (MetaButtonState state)
+{
+  switch (state)
+    {
+    case META_BUTTON_STATE_NORMAL:
+      return "normal";
+    case META_BUTTON_STATE_PRESSED:
+      return "pressed";
+    case META_BUTTON_STATE_PRELIGHT:
+      return "prelight";
+    case META_BUTTON_STATE_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaButtonType
+meta_button_type_from_string (const char *str, MetaTheme *theme)
+{
+  if (META_THEME_ALLOWS(theme, META_THEME_SHADE_STICK_ABOVE_BUTTONS))
+    {
+      if (strcmp ("shade", str) == 0)
+        return META_BUTTON_TYPE_SHADE;
+      else if (strcmp ("above", str) == 0)
+        return META_BUTTON_TYPE_ABOVE;
+      else if (strcmp ("stick", str) == 0)
+        return META_BUTTON_TYPE_STICK;
+      else if (strcmp ("unshade", str) == 0)
+        return META_BUTTON_TYPE_UNSHADE;
+      else if (strcmp ("unabove", str) == 0)
+        return META_BUTTON_TYPE_UNABOVE;
+      else if (strcmp ("unstick", str) == 0)
+        return META_BUTTON_TYPE_UNSTICK;
+     }
+
+  if (strcmp ("close", str) == 0)
+    return META_BUTTON_TYPE_CLOSE;
+  else if (strcmp ("maximize", str) == 0)
+    return META_BUTTON_TYPE_MAXIMIZE;
+  else if (strcmp ("minimize", str) == 0)
+    return META_BUTTON_TYPE_MINIMIZE;
+  else if (strcmp ("menu", str) == 0)
+    return META_BUTTON_TYPE_MENU;
+  else if (strcmp ("left_left_background", str) == 0)
+    return META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND;
+  else if (strcmp ("left_middle_background", str) == 0)
+    return META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND;
+  else if (strcmp ("left_right_background", str) == 0)
+    return META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND;
+  else if (strcmp ("right_left_background", str) == 0)
+    return META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND;
+  else if (strcmp ("right_middle_background", str) == 0)
+    return META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND;
+  else if (strcmp ("right_right_background", str) == 0)
+    return META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND;
+  else
+    return META_BUTTON_TYPE_LAST;
+}
+
+const char*
+meta_button_type_to_string (MetaButtonType type)
+{
+  switch (type)
+    {
+    case META_BUTTON_TYPE_CLOSE:
+      return "close";
+    case META_BUTTON_TYPE_MAXIMIZE:
+      return "maximize";
+    case META_BUTTON_TYPE_MINIMIZE:
+      return "minimize";
+    case META_BUTTON_TYPE_SHADE:
+     return "shade";
+    case META_BUTTON_TYPE_ABOVE:
+      return "above";
+    case META_BUTTON_TYPE_STICK:
+      return "stick";
+    case META_BUTTON_TYPE_UNSHADE:
+      return "unshade";
+    case META_BUTTON_TYPE_UNABOVE:
+      return "unabove";
+    case META_BUTTON_TYPE_UNSTICK:
+      return "unstick";
+     case META_BUTTON_TYPE_MENU:
+      return "menu";
+    case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
+      return "left_left_background";
+    case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
+      return "left_middle_background";
+    case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
+      return "left_right_background";
+    case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
+      return "right_left_background";
+    case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
+      return "right_middle_background";
+    case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
+      return "right_right_background";
+    case META_BUTTON_TYPE_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaFramePiece
+meta_frame_piece_from_string (const char *str)
+{
+  if (strcmp ("entire_background", str) == 0)
+    return META_FRAME_PIECE_ENTIRE_BACKGROUND;
+  else if (strcmp ("titlebar", str) == 0)
+    return META_FRAME_PIECE_TITLEBAR;
+  else if (strcmp ("titlebar_middle", str) == 0)
+    return META_FRAME_PIECE_TITLEBAR_MIDDLE;
+  else if (strcmp ("left_titlebar_edge", str) == 0)
+    return META_FRAME_PIECE_LEFT_TITLEBAR_EDGE;
+  else if (strcmp ("right_titlebar_edge", str) == 0)
+    return META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE;
+  else if (strcmp ("top_titlebar_edge", str) == 0)
+    return META_FRAME_PIECE_TOP_TITLEBAR_EDGE;
+  else if (strcmp ("bottom_titlebar_edge", str) == 0)
+    return META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE;
+  else if (strcmp ("title", str) == 0)
+    return META_FRAME_PIECE_TITLE;
+  else if (strcmp ("left_edge", str) == 0)
+    return META_FRAME_PIECE_LEFT_EDGE;
+  else if (strcmp ("right_edge", str) == 0)
+    return META_FRAME_PIECE_RIGHT_EDGE;
+  else if (strcmp ("bottom_edge", str) == 0)
+    return META_FRAME_PIECE_BOTTOM_EDGE;
+  else if (strcmp ("overlay", str) == 0)
+    return META_FRAME_PIECE_OVERLAY;
+  else
+    return META_FRAME_PIECE_LAST;
+}
+
+const char*
+meta_frame_piece_to_string (MetaFramePiece piece)
+{
+  switch (piece)
+    {
+    case META_FRAME_PIECE_ENTIRE_BACKGROUND:
+      return "entire_background";
+    case META_FRAME_PIECE_TITLEBAR:
+      return "titlebar";
+    case META_FRAME_PIECE_TITLEBAR_MIDDLE:
+      return "titlebar_middle";
+    case META_FRAME_PIECE_LEFT_TITLEBAR_EDGE:
+      return "left_titlebar_edge";
+    case META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE:
+      return "right_titlebar_edge";
+    case META_FRAME_PIECE_TOP_TITLEBAR_EDGE:
+      return "top_titlebar_edge";
+    case META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE:
+      return "bottom_titlebar_edge";
+    case META_FRAME_PIECE_TITLE:
+      return "title";
+    case META_FRAME_PIECE_LEFT_EDGE:
+      return "left_edge";
+    case META_FRAME_PIECE_RIGHT_EDGE:
+      return "right_edge";
+    case META_FRAME_PIECE_BOTTOM_EDGE:
+      return "bottom_edge";
+    case META_FRAME_PIECE_OVERLAY:
+      return "overlay";
+    case META_FRAME_PIECE_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaFrameState
+meta_frame_state_from_string (const char *str)
+{
+  if (strcmp ("normal", str) == 0)
+    return META_FRAME_STATE_NORMAL;
+  else if (strcmp ("maximized", str) == 0)
+    return META_FRAME_STATE_MAXIMIZED;
+  else if (strcmp ("shaded", str) == 0)
+    return META_FRAME_STATE_SHADED;
+  else if (strcmp ("maximized_and_shaded", str) == 0)
+    return META_FRAME_STATE_MAXIMIZED_AND_SHADED;
+  else
+    return META_FRAME_STATE_LAST;
+}
+
+const char*
+meta_frame_state_to_string (MetaFrameState state)
+{
+  switch (state)
+    {
+    case META_FRAME_STATE_NORMAL:
+      return "normal";
+    case META_FRAME_STATE_MAXIMIZED:
+      return "maximized";
+    case META_FRAME_STATE_SHADED:
+      return "shaded";
+    case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
+      return "maximized_and_shaded";
+    case META_FRAME_STATE_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaFrameResize
+meta_frame_resize_from_string (const char *str)
+{
+  if (strcmp ("none", str) == 0)
+    return META_FRAME_RESIZE_NONE;
+  else if (strcmp ("vertical", str) == 0)
+    return META_FRAME_RESIZE_VERTICAL;
+  else if (strcmp ("horizontal", str) == 0)
+    return META_FRAME_RESIZE_HORIZONTAL;
+  else if (strcmp ("both", str) == 0)
+    return META_FRAME_RESIZE_BOTH;
+  else
+    return META_FRAME_RESIZE_LAST;
+}
+
+const char*
+meta_frame_resize_to_string (MetaFrameResize resize)
+{
+  switch (resize)
+    {
+    case META_FRAME_RESIZE_NONE:
+      return "none";
+    case META_FRAME_RESIZE_VERTICAL:
+      return "vertical";
+    case META_FRAME_RESIZE_HORIZONTAL:
+      return "horizontal";
+    case META_FRAME_RESIZE_BOTH:
+      return "both";
+    case META_FRAME_RESIZE_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaFrameFocus
+meta_frame_focus_from_string (const char *str)
+{
+  if (strcmp ("no", str) == 0)
+    return META_FRAME_FOCUS_NO;
+  else if (strcmp ("yes", str) == 0)
+    return META_FRAME_FOCUS_YES;
+  else
+    return META_FRAME_FOCUS_LAST;
+}
+
+const char*
+meta_frame_focus_to_string (MetaFrameFocus focus)
+{
+  switch (focus)
+    {
+    case META_FRAME_FOCUS_NO:
+      return "no";
+    case META_FRAME_FOCUS_YES:
+      return "yes";
+    case META_FRAME_FOCUS_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaFrameType
+meta_frame_type_from_string (const char *str)
+{
+  if (strcmp ("normal", str) == 0)
+    return META_FRAME_TYPE_NORMAL;
+  else if (strcmp ("dialog", str) == 0)
+    return META_FRAME_TYPE_DIALOG;
+  else if (strcmp ("modal_dialog", str) == 0)
+    return META_FRAME_TYPE_MODAL_DIALOG;
+  else if (strcmp ("utility", str) == 0)
+    return META_FRAME_TYPE_UTILITY;
+  else if (strcmp ("menu", str) == 0)
+    return META_FRAME_TYPE_MENU;
+  else if (strcmp ("border", str) == 0)
+    return META_FRAME_TYPE_BORDER;
+#if 0
+  else if (strcmp ("toolbar", str) == 0)
+    return META_FRAME_TYPE_TOOLBAR;
+#endif
+  else
+    return META_FRAME_TYPE_LAST;
+}
+
+const char*
+meta_frame_type_to_string (MetaFrameType type)
+{
+  switch (type)
+    {
+    case META_FRAME_TYPE_NORMAL:
+      return "normal";
+    case META_FRAME_TYPE_DIALOG:
+      return "dialog";
+    case META_FRAME_TYPE_MODAL_DIALOG:
+      return "modal_dialog";
+    case META_FRAME_TYPE_UTILITY:
+      return "utility";
+    case META_FRAME_TYPE_MENU:
+      return "menu";
+    case META_FRAME_TYPE_BORDER:
+      return "border";
+#if 0
+    case META_FRAME_TYPE_TOOLBAR:
+      return "toolbar";
+#endif
+    case  META_FRAME_TYPE_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+MetaGradientType
+meta_gradient_type_from_string (const char *str)
+{
+  if (strcmp ("vertical", str) == 0)
+    return META_GRADIENT_VERTICAL;
+  else if (strcmp ("horizontal", str) == 0)
+    return META_GRADIENT_HORIZONTAL;
+  else if (strcmp ("diagonal", str) == 0)
+    return META_GRADIENT_DIAGONAL;
+  else
+    return META_GRADIENT_LAST;
+}
+
+const char*
+meta_gradient_type_to_string (MetaGradientType type)
+{
+  switch (type)
+    {
+    case META_GRADIENT_VERTICAL:
+      return "vertical";
+    case META_GRADIENT_HORIZONTAL:
+      return "horizontal";
+    case META_GRADIENT_DIAGONAL:
+      return "diagonal";
+    case META_GRADIENT_LAST:
+      break;
+    }
+
+  return "<unknown>";
+}
+
+GtkStateType
+meta_gtk_state_from_string (const char *str)
+{
+  if (strcmp ("normal", str) == 0 || strcmp ("NORMAL", str) == 0)
+    return GTK_STATE_NORMAL;
+  else if (strcmp ("prelight", str) == 0 || strcmp ("PRELIGHT", str) == 0)
+    return GTK_STATE_PRELIGHT;
+  else if (strcmp ("active", str) == 0 || strcmp ("ACTIVE", str) == 0)
+    return GTK_STATE_ACTIVE;
+  else if (strcmp ("selected", str) == 0 || strcmp ("SELECTED", str) == 0)
+    return GTK_STATE_SELECTED;
+  else if (strcmp ("insensitive", str) == 0 || strcmp ("INSENSITIVE", str) == 0)
+    return GTK_STATE_INSENSITIVE;
+  else
+    return -1; /* hack */
+}
+
+const char*
+meta_gtk_state_to_string (GtkStateType state)
+{
+  switch (state)
+    {
+    case GTK_STATE_NORMAL:
+      return "NORMAL";
+    case GTK_STATE_PRELIGHT:
+      return "PRELIGHT";
+    case GTK_STATE_ACTIVE:
+      return "ACTIVE";
+    case GTK_STATE_SELECTED:
+      return "SELECTED";
+    case GTK_STATE_INSENSITIVE:
+      return "INSENSITIVE";
+    }
+
+  return "<unknown>";
+}
+
+GtkShadowType
+meta_gtk_shadow_from_string (const char *str)
+{
+  if (strcmp ("none", str) == 0)
+    return GTK_SHADOW_NONE;
+  else if (strcmp ("in", str) == 0)
+    return GTK_SHADOW_IN;
+  else if (strcmp ("out", str) == 0)
+    return GTK_SHADOW_OUT;
+  else if (strcmp ("etched_in", str) == 0)
+    return GTK_SHADOW_ETCHED_IN;
+  else if (strcmp ("etched_out", str) == 0)
+    return GTK_SHADOW_ETCHED_OUT;
+  else
+    return -1;
+}
+
+const char*
+meta_gtk_shadow_to_string (GtkShadowType shadow)
+{
+  switch (shadow)
+    {
+    case GTK_SHADOW_NONE:
+      return "none";
+    case GTK_SHADOW_IN:
+      return "in";
+    case GTK_SHADOW_OUT:
+      return "out";
+    case GTK_SHADOW_ETCHED_IN:
+      return "etched_in";
+    case GTK_SHADOW_ETCHED_OUT:
+      return "etched_out";
+    }
+
+  return "<unknown>";
+}
+
+GtkArrowType
+meta_gtk_arrow_from_string (const char *str)
+{
+  if (strcmp ("up", str) == 0)
+    return GTK_ARROW_UP;
+  else if (strcmp ("down", str) == 0)
+    return GTK_ARROW_DOWN;
+  else if (strcmp ("left", str) == 0)
+    return GTK_ARROW_LEFT;
+  else if (strcmp ("right", str) == 0)
+    return GTK_ARROW_RIGHT;
+  else if (strcmp ("none", str) == 0)
+    return GTK_ARROW_NONE;
+  else
+    return -1;
+}
+
+const char*
+meta_gtk_arrow_to_string (GtkArrowType arrow)
+{
+  switch (arrow)
+    {
+    case GTK_ARROW_UP:
+      return "up";
+    case GTK_ARROW_DOWN:
+      return "down";
+    case GTK_ARROW_LEFT:
+      return "left";
+    case GTK_ARROW_RIGHT:
+      return "right";
+    case GTK_ARROW_NONE:
+      return "none";
+    }
+
+  return "<unknown>";
+}
+
+/**
+ * Returns a fill_type from a string.  The inverse of
+ * meta_image_fill_type_to_string().
+ *
+ * \param str  a string representing a fill_type
+ * \result  the fill_type, or -1 if it represents no fill_type.
+ */
+MetaImageFillType
+meta_image_fill_type_from_string (const char *str)
+{
+  if (strcmp ("tile", str) == 0)
+    return META_IMAGE_FILL_TILE;
+  else if (strcmp ("scale", str) == 0)
+    return META_IMAGE_FILL_SCALE;
+  else
+    return -1;
+}
+
+/**
+ * Returns a string representation of a fill_type.  The inverse of
+ * meta_image_fill_type_from_string().
+ *
+ * \param fill_type  the fill type
+ * \result  a string representing that type
+ */
+const char*
+meta_image_fill_type_to_string (MetaImageFillType fill_type)
+{
+  switch (fill_type)
+    {
+    case META_IMAGE_FILL_TILE:
+      return "tile";
+    case META_IMAGE_FILL_SCALE:
+      return "scale";
+    }
+
+  return "<unknown>";
+}
+
+/**
+ * Takes a colour "a", scales the lightness and saturation by a certain amount,
+ * and sets "b" to the resulting colour.
+ * gtkstyle.c cut-and-pastage.
+ *
+ * \param a  the starting colour
+ * \param b  [out] the resulting colour
+ * \param k  amount to scale lightness and saturation by
+ */
+static void
+gtk_style_shade (GdkColor *a,
+                 GdkColor *b,
+                 gdouble   k)
+{
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+
+  red = (gdouble) a->red / 65535.0;
+  green = (gdouble) a->green / 65535.0;
+  blue = (gdouble) a->blue / 65535.0;
+
+  rgb_to_hls (&red, &green, &blue);
+
+  green *= k;
+  if (green > 1.0)
+    green = 1.0;
+  else if (green < 0.0)
+    green = 0.0;
+
+  blue *= k;
+  if (blue > 1.0)
+    blue = 1.0;
+  else if (blue < 0.0)
+    blue = 0.0;
+
+  hls_to_rgb (&red, &green, &blue);
+
+  b->red = red * 65535.0;
+  b->green = green * 65535.0;
+  b->blue = blue * 65535.0;
+}
+
+/**
+ * Converts a red/green/blue triplet to a hue/lightness/saturation triplet.
+ *
+ * \param r  on input, red; on output, hue
+ * \param g  on input, green; on output, lightness
+ * \param b  on input, blue; on output, saturation
+ */
+static void
+rgb_to_hls (gdouble *r,
+            gdouble *g,
+            gdouble *b)
+{
+  gdouble min;
+  gdouble max;
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  gdouble h, l, s;
+  gdouble delta;
+
+  red = *r;
+  green = *g;
+  blue = *b;
+
+  if (red > green)
+    {
+      if (red > blue)
+        max = red;
+      else
+        max = blue;
+
+      if (green < blue)
+        min = green;
+      else
+        min = blue;
+    }
+  else
+    {
+      if (green > blue)
+        max = green;
+      else
+        max = blue;
+
+      if (red < blue)
+        min = red;
+      else
+        min = blue;
+    }
+
+  l = (max + min) / 2;
+  s = 0;
+  h = 0;
+
+  if (max != min)
+    {
+      if (l <= 0.5)
+        s = (max - min) / (max + min);
+      else
+        s = (max - min) / (2 - max - min);
+
+      delta = max -min;
+      if (red == max)
+        h = (green - blue) / delta;
+      else if (green == max)
+        h = 2 + (blue - red) / delta;
+      else if (blue == max)
+        h = 4 + (red - green) / delta;
+
+      h *= 60;
+      if (h < 0.0)
+        h += 360;
+    }
+
+  *r = h;
+  *g = l;
+  *b = s;
+}
+
+/**
+ * Converts a hue/lightness/saturation triplet to a red/green/blue triplet.
+ *
+ * \param h  on input, hue; on output, red
+ * \param l  on input, lightness; on output, green
+ * \param s  on input, saturation; on output, blue
+ */
+static void
+hls_to_rgb (gdouble *h,
+            gdouble *l,
+            gdouble *s)
+{
+  gdouble hue;
+  gdouble lightness;
+  gdouble saturation;
+  gdouble m1, m2;
+  gdouble r, g, b;
+
+  lightness = *l;
+  saturation = *s;
+
+  if (lightness <= 0.5)
+    m2 = lightness * (1 + saturation);
+  else
+    m2 = lightness + saturation - lightness * saturation;
+  m1 = 2 * lightness - m2;
+
+  if (saturation == 0)
+    {
+      *h = lightness;
+      *l = lightness;
+      *s = lightness;
+    }
+  else
+    {
+      hue = *h + 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+
+      if (hue < 60)
+        r = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        r = m2;
+      else if (hue < 240)
+        r = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        r = m1;
+
+      hue = *h;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+
+      if (hue < 60)
+        g = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        g = m2;
+      else if (hue < 240)
+        g = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        g = m1;
+
+      hue = *h - 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+
+      if (hue < 60)
+        b = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        b = m2;
+      else if (hue < 240)
+        b = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        b = m1;
+
+      *h = r;
+      *l = g;
+      *s = b;
+    }
+}
+
+#if 0
+/* These are some functions I'm saving to use in optimizing
+ * MetaDrawOpList, namely to pre-composite pixbufs on client side
+ * prior to rendering to the server
+ */
+static void
+draw_bg_solid_composite (const MetaTextureSpec *bg,
+                         const MetaTextureSpec *fg,
+                         double                 alpha,
+                         GtkWidget             *widget,
+                         GdkDrawable           *drawable,
+                         const GdkRectangle    *clip,
+                         MetaTextureDrawMode    mode,
+                         double                 xalign,
+                         double                 yalign,
+                         int                    x,
+                         int                    y,
+                         int                    width,
+                         int                    height)
+{
+  GdkColor bg_color;
+
+  g_assert (bg->type == META_TEXTURE_SOLID);
+  g_assert (fg->type != META_TEXTURE_COMPOSITE);
+  g_assert (fg->type != META_TEXTURE_SHAPE_LIST);
+
+  meta_color_spec_render (bg->data.solid.color_spec,
+                          widget,
+                          &bg_color);
+
+  switch (fg->type)
+    {
+    case META_TEXTURE_SOLID:
+      {
+        GdkColor fg_color;
+
+        meta_color_spec_render (fg->data.solid.color_spec,
+                                widget,
+                                &fg_color);
+
+        color_composite (&bg_color, &fg_color,
+                         alpha, &fg_color);
+
+        draw_color_rectangle (widget, drawable, &fg_color, clip,
+                              x, y, width, height);
+      }
+      break;
+
+    case META_TEXTURE_GRADIENT:
+      /* FIXME I think we could just composite all the colors in
+       * the gradient prior to generating the gradient?
+       */
+      /* FALL THRU */
+    case META_TEXTURE_IMAGE:
+      {
+        GdkPixbuf *pixbuf;
+        GdkPixbuf *composited;
+
+        pixbuf = meta_texture_spec_render (fg, widget, mode, 255,
+                                           width, height);
+
+        if (pixbuf == NULL)
+          return;
+
+        composited = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+                                     gdk_pixbuf_get_has_alpha (pixbuf), 8,
+                                     gdk_pixbuf_get_width (pixbuf),
+                                     gdk_pixbuf_get_height (pixbuf));
+
+        if (composited == NULL)
+          {
+            g_object_unref (G_OBJECT (pixbuf));
+            return;
+          }
+
+        gdk_pixbuf_composite_color (pixbuf,
+                                    composited,
+                                    0, 0,
+                                    gdk_pixbuf_get_width (pixbuf),
+                                    gdk_pixbuf_get_height (pixbuf),
+                                    0.0, 0.0, /* offsets */
+                                    1.0, 1.0, /* scale */
+                                    GDK_INTERP_BILINEAR,
+                                    255 * alpha,
+                                    0, 0,     /* check offsets */
+                                    0,        /* check size */
+                                    GDK_COLOR_RGB (bg_color),
+                                    GDK_COLOR_RGB (bg_color));
+
+        /* Need to draw background since pixbuf is not
+         * necessarily covering the whole thing
+         */
+        draw_color_rectangle (widget, drawable, &bg_color, clip,
+                              x, y, width, height);
+
+        render_pixbuf_aligned (drawable, clip, composited,
+                               xalign, yalign,
+                               x, y, width, height);
+
+        g_object_unref (G_OBJECT (pixbuf));
+        g_object_unref (G_OBJECT (composited));
+      }
+      break;
+
+    case META_TEXTURE_BLANK:
+    case META_TEXTURE_COMPOSITE:
+    case META_TEXTURE_SHAPE_LIST:
+      g_assert_not_reached ();
+      break;
+    }
+}
+
+static void
+draw_bg_gradient_composite (const MetaTextureSpec *bg,
+                            const MetaTextureSpec *fg,
+                            double                 alpha,
+                            GtkWidget             *widget,
+                            GdkDrawable           *drawable,
+                            const GdkRectangle    *clip,
+                            MetaTextureDrawMode    mode,
+                            double                 xalign,
+                            double                 yalign,
+                            int                    x,
+                            int                    y,
+                            int                    width,
+                            int                    height)
+{
+  g_assert (bg->type == META_TEXTURE_GRADIENT);
+  g_assert (fg->type != META_TEXTURE_COMPOSITE);
+  g_assert (fg->type != META_TEXTURE_SHAPE_LIST);
+
+  switch (fg->type)
+    {
+    case META_TEXTURE_SOLID:
+    case META_TEXTURE_GRADIENT:
+    case META_TEXTURE_IMAGE:
+      {
+        GdkPixbuf *bg_pixbuf;
+        GdkPixbuf *fg_pixbuf;
+        GdkPixbuf *composited;
+        int fg_width, fg_height;
+
+        bg_pixbuf = meta_texture_spec_render (bg, widget, mode, 255,
+                                              width, height);
+
+        if (bg_pixbuf == NULL)
+          return;
+
+        fg_pixbuf = meta_texture_spec_render (fg, widget, mode, 255,
+                                              width, height);
+
+        if (fg_pixbuf == NULL)
+          {
+            g_object_unref (G_OBJECT (bg_pixbuf));
+            return;
+          }
+
+        /* gradients always fill the entire target area */
+        g_assert (gdk_pixbuf_get_width (bg_pixbuf) == width);
+        g_assert (gdk_pixbuf_get_height (bg_pixbuf) == height);
+
+        composited = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+                                     gdk_pixbuf_get_has_alpha (bg_pixbuf), 8,
+                                     gdk_pixbuf_get_width (bg_pixbuf),
+                                     gdk_pixbuf_get_height (bg_pixbuf));
+
+        if (composited == NULL)
+          {
+            g_object_unref (G_OBJECT (bg_pixbuf));
+            g_object_unref (G_OBJECT (fg_pixbuf));
+            return;
+          }
+
+        fg_width = gdk_pixbuf_get_width (fg_pixbuf);
+        fg_height = gdk_pixbuf_get_height (fg_pixbuf);
+
+        /* If we wanted to be all cool we could deal with the
+         * offsets and try to composite only in the clip rectangle,
+         * but I just don't care enough to figure it out.
+         */
+
+        gdk_pixbuf_composite (fg_pixbuf,
+                              composited,
+                              x + (width - fg_width) * xalign,
+                              y + (height - fg_height) * yalign,
+                              gdk_pixbuf_get_width (fg_pixbuf),
+                              gdk_pixbuf_get_height (fg_pixbuf),
+                              0.0, 0.0, /* offsets */
+                              1.0, 1.0, /* scale */
+                              GDK_INTERP_BILINEAR,
+                              255 * alpha);
+
+        gdk_cairo_set_source_pixbuf (cr, composited, x, y);
+        cairo_paint (cr);
+
+        g_object_unref (G_OBJECT (bg_pixbuf));
+        g_object_unref (G_OBJECT (fg_pixbuf));
+        g_object_unref (G_OBJECT (composited));
+      }
+      break;
+
+    case META_TEXTURE_BLANK:
+    case META_TEXTURE_SHAPE_LIST:
+    case META_TEXTURE_COMPOSITE:
+      g_assert_not_reached ();
+      break;
+    }
+}
+#endif
+
+/**
+ * Returns the earliest version of the theme format which required support
+ * for a particular button.  (For example, "shade" first appeared in v2, and
+ * "close" in v1.)
+ *
+ * \param type  the button type
+ * \return  the number of the theme format
+ */
+guint
+meta_theme_earliest_version_with_button (MetaButtonType type)
+{
+  switch (type)
+    {
+    case META_BUTTON_TYPE_CLOSE:
+    case META_BUTTON_TYPE_MAXIMIZE:
+    case META_BUTTON_TYPE_MINIMIZE:
+    case META_BUTTON_TYPE_MENU:
+    case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
+    case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
+    case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
+    case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
+    case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
+    case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
+      return 1;
+
+    case META_BUTTON_TYPE_SHADE:
+    case META_BUTTON_TYPE_ABOVE:
+    case META_BUTTON_TYPE_STICK:
+    case META_BUTTON_TYPE_UNSHADE:
+    case META_BUTTON_TYPE_UNABOVE:
+    case META_BUTTON_TYPE_UNSTICK:
+      return 2;
+
+    default:
+      meta_warning("Unknown button %d\n", type);
+      return 1;
+    }
+}
diff --git a/src/ui/theme.h b/src/ui/theme.h
new file mode 100644
index 00000000..4df8b00e
--- /dev/null
+++ b/src/ui/theme.h
@@ -0,0 +1,1190 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Theme Rendering */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_THEME_H
+#define META_THEME_H
+
+#include "boxes.h"
+#include "gradient.h"
+#include "common.h"
+#include <gtk/gtk.h>
+
+typedef struct _MetaFrameStyle MetaFrameStyle;
+typedef struct _MetaFrameStyleSet MetaFrameStyleSet;
+typedef struct _MetaDrawOp MetaDrawOp;
+typedef struct _MetaDrawOpList MetaDrawOpList;
+typedef struct _MetaGradientSpec MetaGradientSpec;
+typedef struct _MetaAlphaGradientSpec MetaAlphaGradientSpec; 
+typedef struct _MetaColorSpec MetaColorSpec;
+typedef struct _MetaFrameLayout MetaFrameLayout;
+typedef struct _MetaButtonSpace MetaButtonSpace;
+typedef struct _MetaFrameGeometry MetaFrameGeometry;
+typedef struct _MetaTheme MetaTheme;
+typedef struct _MetaPositionExprEnv MetaPositionExprEnv;
+typedef struct _MetaDrawInfo MetaDrawInfo;
+
+#define META_THEME_ERROR (g_quark_from_static_string ("meta-theme-error"))
+
+typedef enum
+{
+  META_THEME_ERROR_FRAME_GEOMETRY,
+  META_THEME_ERROR_BAD_CHARACTER,
+  META_THEME_ERROR_BAD_PARENS,
+  META_THEME_ERROR_UNKNOWN_VARIABLE,
+  META_THEME_ERROR_DIVIDE_BY_ZERO,
+  META_THEME_ERROR_MOD_ON_FLOAT,
+  META_THEME_ERROR_FAILED
+} MetaThemeError;
+
+/**
+ * Whether a button's size is calculated from the area around it (aspect
+ * sizing) or is given as a fixed height and width in pixels (fixed sizing).
+ *
+ * \bug This could be done away with; see the comment at the top of
+ * MetaFrameLayout.
+ */
+typedef enum
+{
+  META_BUTTON_SIZING_ASPECT,
+  META_BUTTON_SIZING_FIXED,
+  META_BUTTON_SIZING_LAST
+} MetaButtonSizing;
+
+/**
+ * Various parameters used to calculate the geometry of a frame.
+ * They are used inside a MetaFrameStyle.
+ * This corresponds closely to the <frame_geometry> tag in a theme file.
+ *
+ * \bug button_sizing isn't really necessary, because we could easily say
+ * that if button_aspect is zero, the height and width are fixed values.
+ * This would also mean that MetaButtonSizing didn't need to exist, and
+ * save code.
+ **/
+struct _MetaFrameLayout
+{
+  /** Reference count. */
+  int refcount;
+  
+  /** Size of left side */
+  int left_width;
+  /** Size of right side */
+  int right_width;
+  /** Size of bottom side */
+  int bottom_height;
+  
+  /** Border of blue title region
+   * \bug (blue?!)
+   **/
+  GtkBorder title_border;
+
+  /** Extra height for inside of title region, above the font height */
+  int title_vertical_pad;
+  
+  /** Right indent of buttons from edges of frame */
+  int right_titlebar_edge;
+  /** Left indent of buttons from edges of frame */
+  int left_titlebar_edge;
+  
+  /**
+   * Sizing rule of buttons, either META_BUTTON_SIZING_ASPECT
+   * (in which case button_aspect will be honoured, and
+   * button_width and button_height set from it), or
+   * META_BUTTON_SIZING_FIXED (in which case we read the width
+   * and height directly).
+   */
+  MetaButtonSizing button_sizing;
+
+  /**
+   * Ratio of height/width. Honoured only if
+   * button_sizing==META_BUTTON_SIZING_ASPECT.
+   * Otherwise we figure out the height from the button_border.
+   */
+  double button_aspect;
+  
+  /** Width of a button; set even when we are using aspect sizing */
+  int button_width;
+
+  /** Height of a button; set even when we are using aspect sizing */
+  int button_height;
+
+  /** Space around buttons */
+  GtkBorder button_border;
+
+  /** scale factor for title text */
+  double title_scale;
+  
+  /** Whether title text will be displayed */
+  guint has_title : 1;
+
+  /** Whether we should hide the buttons */
+  guint hide_buttons : 1;
+
+  /** Radius of the top left-hand corner; 0 if not rounded */
+  guint top_left_corner_rounded_radius;
+  /** Radius of the top right-hand corner; 0 if not rounded */
+  guint top_right_corner_rounded_radius;
+  /** Radius of the bottom left-hand corner; 0 if not rounded */
+  guint bottom_left_corner_rounded_radius;
+  /** Radius of the bottom right-hand corner; 0 if not rounded */
+  guint bottom_right_corner_rounded_radius;
+};
+
+/**
+ * The computed size of a button (really just a way of tying its
+ * visible and clickable areas together).
+ * The reason for two different rectangles here is Fitts' law & maximized
+ * windows; see bug #97703 for more details.
+ */
+struct _MetaButtonSpace
+{
+  /** The screen area where the button's image is drawn */
+  GdkRectangle visible;
+  /** The screen area where the button can be activated by clicking */
+  GdkRectangle clickable;
+};
+
+/**
+ * Calculated actual geometry of the frame
+ */
+struct _MetaFrameGeometry
+{
+  int left_width;
+  int right_width;
+  int top_height;
+  int bottom_height;
+
+  int width;
+  int height;  
+
+  GdkRectangle title_rect;
+
+  int left_titlebar_edge;
+  int right_titlebar_edge;
+  int top_titlebar_edge;
+  int bottom_titlebar_edge;
+
+  /* used for a memset hack */
+#define ADDRESS_OF_BUTTON_RECTS(fgeom) (((char*)(fgeom)) + G_STRUCT_OFFSET (MetaFrameGeometry, close_rect))
+#define LENGTH_OF_BUTTON_RECTS (G_STRUCT_OFFSET (MetaFrameGeometry, right_right_background) + sizeof (GdkRectangle) - G_STRUCT_OFFSET (MetaFrameGeometry, close_rect))
+  
+  /* The button rects (if changed adjust memset hack) */
+  MetaButtonSpace close_rect;
+  MetaButtonSpace max_rect;
+  MetaButtonSpace min_rect;
+  MetaButtonSpace menu_rect;
+  MetaButtonSpace shade_rect;
+  MetaButtonSpace above_rect;
+  MetaButtonSpace stick_rect;
+  MetaButtonSpace unshade_rect;
+  MetaButtonSpace unabove_rect;
+  MetaButtonSpace unstick_rect;
+
+#define MAX_MIDDLE_BACKGROUNDS (MAX_BUTTONS_PER_CORNER - 2)
+  GdkRectangle left_left_background;
+  GdkRectangle left_middle_backgrounds[MAX_MIDDLE_BACKGROUNDS];
+  GdkRectangle left_right_background;
+  GdkRectangle right_left_background;
+  GdkRectangle right_middle_backgrounds[MAX_MIDDLE_BACKGROUNDS];
+  GdkRectangle right_right_background;
+  /* End of button rects (if changed adjust memset hack) */
+  
+  /* Round corners */
+  guint top_left_corner_rounded_radius;
+  guint top_right_corner_rounded_radius;
+  guint bottom_left_corner_rounded_radius;
+  guint bottom_right_corner_rounded_radius;
+};
+
+typedef enum
+{
+  META_IMAGE_FILL_SCALE, /* default, needs to be all-bits-zero for g_new0 */
+  META_IMAGE_FILL_TILE
+} MetaImageFillType;
+
+typedef enum
+{
+  META_COLOR_SPEC_BASIC,
+  META_COLOR_SPEC_GTK,
+  META_COLOR_SPEC_BLEND,
+  META_COLOR_SPEC_SHADE
+} MetaColorSpecType;
+
+typedef enum
+{
+  META_GTK_COLOR_FG,
+  META_GTK_COLOR_BG,
+  META_GTK_COLOR_LIGHT,
+  META_GTK_COLOR_DARK,
+  META_GTK_COLOR_MID,
+  META_GTK_COLOR_TEXT,
+  META_GTK_COLOR_BASE,
+  META_GTK_COLOR_TEXT_AA,
+  META_GTK_COLOR_LAST
+} MetaGtkColorComponent;
+
+struct _MetaColorSpec
+{
+  MetaColorSpecType type;
+  union
+  {
+    struct {
+      GdkColor color;
+    } basic;
+    struct {
+      MetaGtkColorComponent component;
+      GtkStateType state;
+    } gtk;
+    struct {
+      MetaColorSpec *foreground;
+      MetaColorSpec *background;
+      double alpha;
+
+      GdkColor color;
+    } blend;
+    struct {
+      MetaColorSpec *base;
+      double factor;
+
+      GdkColor color;
+    } shade;
+  } data;
+};
+
+struct _MetaGradientSpec
+{
+  MetaGradientType type;
+  GSList *color_specs;
+};
+
+struct _MetaAlphaGradientSpec
+{
+  MetaGradientType type;
+  unsigned char *alphas;
+  int n_alphas;
+};
+
+struct _MetaDrawInfo
+{
+  GdkPixbuf   *mini_icon;
+  GdkPixbuf   *icon;
+  PangoLayout *title_layout;
+  int title_layout_width;
+  int title_layout_height;
+  const MetaFrameGeometry *fgeom;
+};
+
+/**
+ * A drawing operation in our simple vector drawing language.
+ */
+typedef enum
+{
+  /** Basic drawing-- line */
+  META_DRAW_LINE,
+  /** Basic drawing-- rectangle */
+  META_DRAW_RECTANGLE,
+  /** Basic drawing-- arc */
+  META_DRAW_ARC,
+
+  /** Clip to a rectangle */
+  META_DRAW_CLIP,
+  
+  /* Texture thingies */
+
+  /** Just a filled rectangle with alpha */
+  META_DRAW_TINT,
+  META_DRAW_GRADIENT,
+  META_DRAW_IMAGE,
+  
+  /** GTK theme engine stuff */
+  META_DRAW_GTK_ARROW,
+  META_DRAW_GTK_BOX,
+  META_DRAW_GTK_VLINE,
+
+  /** App's window icon */
+  META_DRAW_ICON,
+  /** App's window title */
+  META_DRAW_TITLE,
+  /** a draw op list */
+  META_DRAW_OP_LIST,
+  /** tiled draw op list */
+  META_DRAW_TILE
+} MetaDrawType;
+
+typedef enum
+{
+  POS_TOKEN_INT,
+  POS_TOKEN_DOUBLE,
+  POS_TOKEN_OPERATOR,
+  POS_TOKEN_VARIABLE,
+  POS_TOKEN_OPEN_PAREN,
+  POS_TOKEN_CLOSE_PAREN
+} PosTokenType;
+
+typedef enum
+{
+  POS_OP_NONE,
+  POS_OP_ADD,
+  POS_OP_SUBTRACT,
+  POS_OP_MULTIPLY,
+  POS_OP_DIVIDE,
+  POS_OP_MOD,
+  POS_OP_MAX,
+  POS_OP_MIN
+} PosOperatorType;
+
+/**
+ * A token, as output by the tokeniser.
+ *
+ * \ingroup tokenizer
+ */
+typedef struct
+{
+  PosTokenType type;
+
+  union
+  {
+    struct {
+      int val;
+    } i;
+
+    struct {
+      double val;
+    } d;
+
+    struct {
+      PosOperatorType op;
+    } o;
+
+    struct {
+      char *name;
+      GQuark name_quark;
+    } v;
+
+  } d;
+} PosToken;
+
+/**
+ * A computed expression in our simple vector drawing language.
+ * While it appears to take the form of a tree, this is actually
+ * merely a list; concerns such as precedence of operators are
+ * currently recomputed on every recalculation.
+ *
+ * Created by meta_draw_spec_new(), destroyed by meta_draw_spec_free().
+ * pos_eval() fills this with ...FIXME. Are tokens a tree or a list?
+ * \ingroup parser
+ */
+typedef struct _MetaDrawSpec
+{
+  /**
+   * If this spec is constant, this is the value of the constant;
+   * otherwise it is zero.
+   */
+  int value;
+  
+  /** A list of tokens in the expression. */
+  PosToken *tokens;
+
+  /** How many tokens are in the tokens list. */
+  int n_tokens;
+
+  /** Does the expression contain any variables? */
+  gboolean constant : 1;
+} MetaDrawSpec;
+
+/**
+ * A single drawing operation in our simple vector drawing language.
+ */
+struct _MetaDrawOp
+{
+  MetaDrawType type;
+
+  /* Positions are strings because they can be expressions */
+  union
+  {
+    struct {
+      MetaColorSpec *color_spec;
+      int dash_on_length;
+      int dash_off_length;
+      int width;
+      MetaDrawSpec *x1;
+      MetaDrawSpec *y1;
+      MetaDrawSpec *x2;
+      MetaDrawSpec *y2;
+    } line;
+
+    struct {
+      MetaColorSpec *color_spec;
+      gboolean filled;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } rectangle;
+
+    struct {
+      MetaColorSpec *color_spec;
+      gboolean filled;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+      double start_angle;
+      double extent_angle;
+    } arc;
+
+    struct {
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } clip;
+    
+    struct {
+      MetaColorSpec *color_spec;
+      MetaAlphaGradientSpec *alpha_spec;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } tint;
+
+    struct {
+      MetaGradientSpec *gradient_spec;
+      MetaAlphaGradientSpec *alpha_spec;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } gradient;
+
+    struct {
+      MetaColorSpec *colorize_spec;
+      MetaAlphaGradientSpec *alpha_spec;
+      GdkPixbuf *pixbuf;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+
+      guint32 colorize_cache_pixel;
+      GdkPixbuf *colorize_cache_pixbuf;
+      MetaImageFillType fill_type;
+      unsigned int vertical_stripes : 1;
+      unsigned int horizontal_stripes : 1;
+    } image;
+    
+    struct {
+      GtkStateType state;
+      GtkShadowType shadow;
+      GtkArrowType arrow;
+      gboolean filled;
+
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } gtk_arrow;
+
+    struct {
+      GtkStateType state;
+      GtkShadowType shadow;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } gtk_box;
+
+    struct {
+      GtkStateType state;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y1;
+      MetaDrawSpec *y2;  
+    } gtk_vline;
+
+    struct {
+      MetaAlphaGradientSpec *alpha_spec;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+      MetaImageFillType fill_type;
+    } icon;
+
+    struct {
+      MetaColorSpec *color_spec;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+    } title;
+
+    struct {
+      MetaDrawOpList *op_list;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+    } op_list;
+
+    struct {
+      MetaDrawOpList *op_list;
+      MetaDrawSpec *x;
+      MetaDrawSpec *y;
+      MetaDrawSpec *width;
+      MetaDrawSpec *height;
+      MetaDrawSpec *tile_xoffset;
+      MetaDrawSpec *tile_yoffset;
+      MetaDrawSpec *tile_width;
+      MetaDrawSpec *tile_height;
+    } tile;
+    
+  } data;
+};
+
+/**
+ * A list of MetaDrawOp objects. Maintains a reference count.
+ * Grows as necessary and allows the allocation of unused spaces
+ * to keep reallocations to a minimum.
+ *
+ * \bug Do we really win anything from not using the equivalent
+ * GLib structures?
+ */
+struct _MetaDrawOpList
+{
+  int refcount;
+  MetaDrawOp **ops;
+  int n_ops;
+  int n_allocated;
+};
+
+typedef enum
+{
+  META_BUTTON_STATE_NORMAL,
+  META_BUTTON_STATE_PRESSED,
+  META_BUTTON_STATE_PRELIGHT,
+  META_BUTTON_STATE_LAST
+} MetaButtonState;
+
+typedef enum
+{
+  /* Ordered so that background is drawn first */
+  META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND,
+  META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND,
+  META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND,
+  META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND,
+  META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND,
+  META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND,
+  META_BUTTON_TYPE_CLOSE,
+  META_BUTTON_TYPE_MAXIMIZE,
+  META_BUTTON_TYPE_MINIMIZE,
+  META_BUTTON_TYPE_MENU,
+  META_BUTTON_TYPE_SHADE,
+  META_BUTTON_TYPE_ABOVE,
+  META_BUTTON_TYPE_STICK,
+  META_BUTTON_TYPE_UNSHADE,
+  META_BUTTON_TYPE_UNABOVE,
+  META_BUTTON_TYPE_UNSTICK,
+  META_BUTTON_TYPE_LAST
+} MetaButtonType;
+
+typedef enum
+{
+  META_MENU_ICON_TYPE_CLOSE,
+  META_MENU_ICON_TYPE_MAXIMIZE,
+  META_MENU_ICON_TYPE_UNMAXIMIZE,
+  META_MENU_ICON_TYPE_MINIMIZE,
+  META_MENU_ICON_TYPE_LAST
+} MetaMenuIconType;
+
+typedef enum
+{
+  /* Listed in the order in which the textures are drawn.
+   * (though this only matters for overlaps of course.)
+   * Buttons are drawn after the frame textures.
+   *
+   * On the corners, horizontal pieces are arbitrarily given the
+   * corner area:
+   *
+   *   =====                 |====
+   *   |                     |
+   *   |       rather than   |
+   *
+   */
+  
+  /* entire frame */
+  META_FRAME_PIECE_ENTIRE_BACKGROUND,
+  /* entire titlebar background */
+  META_FRAME_PIECE_TITLEBAR,
+  /* portion of the titlebar background inside the titlebar
+   * background edges
+   */
+  META_FRAME_PIECE_TITLEBAR_MIDDLE,
+  /* left end of titlebar */
+  META_FRAME_PIECE_LEFT_TITLEBAR_EDGE,
+  /* right end of titlebar */
+  META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE,
+  /* top edge of titlebar */
+  META_FRAME_PIECE_TOP_TITLEBAR_EDGE,
+  /* bottom edge of titlebar */
+  META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE,
+  /* render over title background (text area) */
+  META_FRAME_PIECE_TITLE,
+  /* left edge of the frame */
+  META_FRAME_PIECE_LEFT_EDGE,
+  /* right edge of the frame */
+  META_FRAME_PIECE_RIGHT_EDGE,
+  /* bottom edge of the frame */
+  META_FRAME_PIECE_BOTTOM_EDGE,
+  /* place over entire frame, after drawing everything else */
+  META_FRAME_PIECE_OVERLAY,
+  /* Used to get size of the enum */
+  META_FRAME_PIECE_LAST
+} MetaFramePiece;
+
+#define N_GTK_STATES 5
+
+/**
+ * How to draw a frame in a particular state (say, a focussed, non-maximised,
+ * resizable frame). This corresponds closely to the <frame_style> tag
+ * in a theme file.
+ */
+struct _MetaFrameStyle
+{
+  /** Reference count. */
+  int refcount;
+  /**
+   * Parent style.
+   * Settings which are unspecified here will be taken from there.
+   */
+  MetaFrameStyle *parent;
+  /** Operations for drawing each kind of button in each state. */
+  MetaDrawOpList *buttons[META_BUTTON_TYPE_LAST][META_BUTTON_STATE_LAST];
+  /** Operations for drawing each piece of the frame. */
+  MetaDrawOpList *pieces[META_FRAME_PIECE_LAST];
+  /**
+   * Details such as the height and width of each edge, the corner rounding,
+   * and the aspect ratio of the buttons.
+   */
+  MetaFrameLayout *layout;
+  /**
+   * Background colour of the window. Only present in theme formats
+   * 2 and above. Can be NULL to use the standard GTK theme engine.
+   */
+  MetaColorSpec *window_background_color;
+  /**
+   * Transparency of the window background. 0=transparent; 255=opaque.
+   */
+  guint8 window_background_alpha;
+};
+
+/* Kinds of frame...
+ * 
+ *  normal ->   noresize / vert only / horz only / both
+ *              focused / unfocused
+ *  max    ->   focused / unfocused
+ *  shaded ->   focused / unfocused
+ *  max/shaded -> focused / unfocused
+ *
+ *  so 4 states with 8 sub-states in one, 2 sub-states in the other 3,
+ *  meaning 14 total
+ *
+ * 14 window states times 7 or 8 window types. Except some
+ * window types never get a frame so that narrows it down a bit.
+ * 
+ */
+typedef enum
+{
+  META_FRAME_STATE_NORMAL,
+  META_FRAME_STATE_MAXIMIZED,
+  META_FRAME_STATE_SHADED,
+  META_FRAME_STATE_MAXIMIZED_AND_SHADED,
+  META_FRAME_STATE_LAST
+} MetaFrameState;
+
+typedef enum
+{
+  META_FRAME_RESIZE_NONE,
+  META_FRAME_RESIZE_VERTICAL,
+  META_FRAME_RESIZE_HORIZONTAL,
+  META_FRAME_RESIZE_BOTH,
+  META_FRAME_RESIZE_LAST
+} MetaFrameResize;
+
+typedef enum
+{
+  META_FRAME_FOCUS_NO,
+  META_FRAME_FOCUS_YES,
+  META_FRAME_FOCUS_LAST
+} MetaFrameFocus;
+
+/**
+ * How to draw frames at different times: when it's maximised or not, shaded
+ * or not, when it's focussed or not, and (for non-maximised windows), when
+ * it can be horizontally or vertically resized, both, or neither.
+ * Not all window types actually get a frame.
+ *
+ * A theme contains one of these objects for each type of window (each
+ * MetaFrameType), that is, normal, dialogue (modal and non-modal), etc.
+ *
+ * This corresponds closely to the <frame_style_set> tag in a theme file.
+ */
+struct _MetaFrameStyleSet
+{
+  int refcount;
+  MetaFrameStyleSet *parent;
+  MetaFrameStyle *normal_styles[META_FRAME_RESIZE_LAST][META_FRAME_FOCUS_LAST];
+  MetaFrameStyle *maximized_styles[META_FRAME_FOCUS_LAST];
+  MetaFrameStyle *shaded_styles[META_FRAME_RESIZE_LAST][META_FRAME_FOCUS_LAST];
+  MetaFrameStyle *maximized_and_shaded_styles[META_FRAME_FOCUS_LAST];
+};
+
+/**
+ * A theme. This is a singleton class which groups all settings from a theme
+ * on disk together.
+ *
+ * \bug It is rather useless to keep the metadata fields in core, I think.
+ */
+struct _MetaTheme
+{
+  /** Name of the theme (on disk), e.g. "Crux" */
+  char *name;
+  /** Path to the files associated with the theme */
+  char *dirname;
+  /**
+   * Filename of the XML theme file.
+   * \bug Kept lying around for no discernable reason.
+   */
+  char *filename;
+  /** Metadata: Human-readable name of the theme. */
+  char *readable_name;
+  /** Metadata: Author of the theme. */
+  char *author;
+  /** Metadata: Copyright holder. */
+  char *copyright;
+  /** Metadata: Date of the theme. */
+  char *date;
+  /** Metadata: Description of the theme. */
+  char *description;
+  /** Version of the theme format. Older versions cannot use the features
+   * of newer versions even if they think they can (this is to allow forward
+   * and backward compatibility.
+   */
+  guint format_version;
+
+  /** Symbol table of integer constants. */
+  GHashTable *integer_constants;
+  /** Symbol table of float constants. */
+  GHashTable *float_constants;
+  /**
+   * Symbol table of colour constants (hex triples, and triples
+   * plus alpha).
+   * */
+  GHashTable *color_constants;
+  GHashTable *images_by_filename;
+  GHashTable *layouts_by_name;
+  GHashTable *draw_op_lists_by_name;
+  GHashTable *styles_by_name;
+  GHashTable *style_sets_by_name;
+  MetaFrameStyleSet *style_sets_by_type[META_FRAME_TYPE_LAST];
+
+  GQuark quark_width;
+  GQuark quark_height;
+  GQuark quark_object_width;
+  GQuark quark_object_height;
+  GQuark quark_left_width;
+  GQuark quark_right_width;
+  GQuark quark_top_height;
+  GQuark quark_bottom_height;
+  GQuark quark_mini_icon_width;
+  GQuark quark_mini_icon_height;
+  GQuark quark_icon_width;
+  GQuark quark_icon_height;
+  GQuark quark_title_width;
+  GQuark quark_title_height;
+};
+
+struct _MetaPositionExprEnv
+{
+  MetaRectangle rect;
+  /* size of an object being drawn, if it has a natural size */
+  int object_width;
+  int object_height;
+  /* global object sizes, always available */
+  int left_width;
+  int right_width;
+  int top_height;
+  int bottom_height;
+  int title_width;
+  int title_height;
+  int mini_icon_width;
+  int mini_icon_height;
+  int icon_width;
+  int icon_height;
+  /* Theme so we can look up constants */
+  MetaTheme *theme;
+};
+
+MetaFrameLayout* meta_frame_layout_new           (void);
+MetaFrameLayout* meta_frame_layout_copy          (const MetaFrameLayout *src);
+void             meta_frame_layout_ref           (MetaFrameLayout       *layout);
+void             meta_frame_layout_unref         (MetaFrameLayout       *layout);
+void             meta_frame_layout_get_borders   (const MetaFrameLayout *layout,
+                                                  int                    text_height,
+                                                  MetaFrameFlags         flags,
+                                                  int                   *top_height,
+                                                  int                   *bottom_height,
+                                                  int                   *left_width,
+                                                  int                   *right_width);
+void             meta_frame_layout_calc_geometry (const MetaFrameLayout  *layout,
+                                                  int                     text_height,
+                                                  MetaFrameFlags          flags,
+                                                  int                     client_width,
+                                                  int                     client_height,
+                                                  const MetaButtonLayout *button_layout,
+                                                  MetaFrameGeometry      *fgeom,
+                                                  MetaTheme              *theme);
+
+gboolean         meta_frame_layout_validate      (const MetaFrameLayout *layout,
+                                                  GError               **error);
+
+gboolean meta_parse_position_expression (MetaDrawSpec               *spec,
+                                         const MetaPositionExprEnv  *env,
+                                         int                        *x_return,
+                                         int                        *y_return,
+                                         GError                    **err);
+gboolean meta_parse_size_expression     (MetaDrawSpec               *spec,
+                                         const MetaPositionExprEnv  *env,
+                                         int                        *val_return,
+                                         GError                    **err);
+
+MetaDrawSpec* meta_draw_spec_new (MetaTheme  *theme,
+                                  const char *expr,
+                                  GError    **error);
+void          meta_draw_spec_free (MetaDrawSpec *spec);
+
+MetaColorSpec* meta_color_spec_new             (MetaColorSpecType  type);
+MetaColorSpec* meta_color_spec_new_from_string (const char        *str,
+                                                GError           **err);
+MetaColorSpec* meta_color_spec_new_gtk         (MetaGtkColorComponent component,
+                                                GtkStateType          state);
+void           meta_color_spec_free            (MetaColorSpec     *spec);
+void           meta_color_spec_render          (MetaColorSpec     *spec,
+                                                GtkWidget         *widget,
+                                                GdkColor          *color);
+
+
+MetaDrawOp*    meta_draw_op_new  (MetaDrawType        type);
+void           meta_draw_op_free (MetaDrawOp          *op);
+void           meta_draw_op_draw (const MetaDrawOp    *op,
+                                  GtkWidget           *widget,
+                                  GdkDrawable         *drawable,
+                                  const GdkRectangle  *clip,
+                                  const MetaDrawInfo  *info,
+                                  /* logical region being drawn */
+                                  MetaRectangle        logical_region);
+
+void           meta_draw_op_draw_with_style (const MetaDrawOp    *op,
+                                             GtkStyle            *style_gtk,
+                                             GtkWidget           *widget,
+                                             GdkDrawable         *drawable,
+                                             const GdkRectangle  *clip,
+                                             const MetaDrawInfo  *info,
+                                             /* logical region being drawn */
+                                             MetaRectangle        logical_region);
+
+MetaDrawOpList* meta_draw_op_list_new   (int                   n_preallocs);
+void            meta_draw_op_list_ref   (MetaDrawOpList       *op_list);
+void            meta_draw_op_list_unref (MetaDrawOpList       *op_list);
+void            meta_draw_op_list_draw  (const MetaDrawOpList *op_list,
+                                         GtkWidget            *widget,
+                                         GdkDrawable          *drawable,
+                                         const GdkRectangle   *clip,
+                                         const MetaDrawInfo   *info,
+                                         MetaRectangle         rect);
+void            meta_draw_op_list_draw_with_style  (const MetaDrawOpList *op_list,
+                                                    GtkStyle             *style_gtk,
+                                                    GtkWidget            *widget,
+                                                    GdkDrawable          *drawable,
+                                                    const GdkRectangle   *clip,
+                                                    const MetaDrawInfo   *info,
+                                                    MetaRectangle         rect);
+void           meta_draw_op_list_append (MetaDrawOpList       *op_list,
+                                         MetaDrawOp           *op);
+gboolean       meta_draw_op_list_validate (MetaDrawOpList    *op_list,
+                                           GError           **error);
+gboolean       meta_draw_op_list_contains (MetaDrawOpList    *op_list,
+                                           MetaDrawOpList    *child);
+
+MetaGradientSpec* meta_gradient_spec_new    (MetaGradientType        type);
+void              meta_gradient_spec_free   (MetaGradientSpec       *desc);
+GdkPixbuf*        meta_gradient_spec_render (const MetaGradientSpec *desc,
+                                             GtkWidget              *widget,
+                                             int                     width,
+                                             int                     height);
+gboolean          meta_gradient_spec_validate (MetaGradientSpec     *spec,
+                                               GError              **error);
+
+MetaAlphaGradientSpec* meta_alpha_gradient_spec_new  (MetaGradientType       type,
+                                                      int                    n_alphas);
+void                   meta_alpha_gradient_spec_free (MetaAlphaGradientSpec *spec);
+
+
+MetaFrameStyle* meta_frame_style_new   (MetaFrameStyle *parent);
+void            meta_frame_style_ref   (MetaFrameStyle *style);
+void            meta_frame_style_unref (MetaFrameStyle *style);
+
+void meta_frame_style_draw (MetaFrameStyle          *style,
+                            GtkWidget               *widget,
+                            GdkDrawable             *drawable,
+                            int                      x_offset,
+                            int                      y_offset,
+                            const GdkRectangle      *clip,
+                            const MetaFrameGeometry *fgeom,
+                            int                      client_width,
+                            int                      client_height,
+                            PangoLayout             *title_layout,
+                            int                      text_height,
+                            MetaButtonState          button_states[META_BUTTON_TYPE_LAST],
+                            GdkPixbuf               *mini_icon,
+                            GdkPixbuf               *icon);
+
+
+void meta_frame_style_draw_with_style (MetaFrameStyle          *style,
+                                       GtkStyle                *style_gtk,
+                                       GtkWidget               *widget,
+                                       GdkDrawable             *drawable,
+                                       int                      x_offset,
+                                       int                      y_offset,
+                                       const GdkRectangle      *clip,
+                                       const MetaFrameGeometry *fgeom,
+                                       int                      client_width,
+                                       int                      client_height,
+                                       PangoLayout             *title_layout,
+                                       int                      text_height,
+                                       MetaButtonState          button_states[META_BUTTON_TYPE_LAST],
+                                       GdkPixbuf               *mini_icon,
+                                       GdkPixbuf               *icon);
+
+
+gboolean       meta_frame_style_validate (MetaFrameStyle    *style,
+                                          guint              current_theme_version,
+                                          GError           **error);
+
+MetaFrameStyleSet* meta_frame_style_set_new   (MetaFrameStyleSet *parent);
+void               meta_frame_style_set_ref   (MetaFrameStyleSet *style_set);
+void               meta_frame_style_set_unref (MetaFrameStyleSet *style_set);
+
+gboolean       meta_frame_style_set_validate  (MetaFrameStyleSet *style_set,
+                                               GError           **error);
+
+MetaTheme* meta_theme_get_current (void);
+void       meta_theme_set_current (const char *name,
+                                   gboolean    force_reload);
+
+MetaTheme* meta_theme_new      (void);
+void       meta_theme_free     (MetaTheme *theme);
+gboolean   meta_theme_validate (MetaTheme *theme,
+                                GError   **error);
+GdkPixbuf* meta_theme_load_image (MetaTheme  *theme,
+                                  const char *filename,
+                                  guint       size_of_theme_icons,
+                                  GError    **error);
+
+MetaFrameStyle* meta_theme_get_frame_style (MetaTheme     *theme,
+                                            MetaFrameType  type,
+                                            MetaFrameFlags flags);
+
+double meta_theme_get_title_scale (MetaTheme     *theme,
+                                   MetaFrameType  type,
+                                   MetaFrameFlags flags);
+
+void meta_theme_draw_frame (MetaTheme              *theme,
+                            GtkWidget              *widget,
+                            GdkDrawable            *drawable,
+                            const GdkRectangle     *clip,
+                            int                     x_offset,
+                            int                     y_offset,
+                            MetaFrameType           type,
+                            MetaFrameFlags          flags,
+                            int                     client_width,
+                            int                     client_height,
+                            PangoLayout            *title_layout,
+                            int                     text_height,
+                            const MetaButtonLayout *button_layout,
+                            MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
+                            GdkPixbuf              *mini_icon,
+                            GdkPixbuf              *icon);
+
+void meta_theme_draw_frame_by_name (MetaTheme              *theme,
+                                    GtkWidget              *widget,
+                                    GdkDrawable            *drawable,
+                                    const GdkRectangle     *clip,
+                                    int                     x_offset,
+                                    int                     y_offset,
+                                    const gchar             *style_name,
+                                    MetaFrameFlags          flags,
+                                    int                     client_width,
+                                    int                     client_height,
+                                    PangoLayout            *title_layout,
+                                    int                     text_height,
+                                    const MetaButtonLayout *button_layout,
+                                    MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
+                                    GdkPixbuf              *mini_icon,
+                                    GdkPixbuf              *icon);
+
+void meta_theme_draw_frame_with_style (MetaTheme              *theme,
+                                       GtkStyle               *style_gtk,
+                                       GtkWidget              *widget,
+                                       GdkDrawable            *drawable,
+                                       const GdkRectangle     *clip,
+                                       int                     x_offset,
+                                       int                     y_offset,
+                                       MetaFrameType           type,
+                                       MetaFrameFlags          flags,
+                                       int                     client_width,
+                                       int                     client_height,
+                                       PangoLayout            *title_layout,
+                                       int                     text_height,
+                                       const MetaButtonLayout *button_layout,
+                                       MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
+                                       GdkPixbuf              *mini_icon,
+                                       GdkPixbuf              *icon);
+
+void meta_theme_get_frame_borders (MetaTheme         *theme,
+                                   MetaFrameType      type,
+                                   int                text_height,
+                                   MetaFrameFlags     flags,
+                                   int               *top_height,
+                                   int               *bottom_height,
+                                   int               *left_width,
+                                   int               *right_width);
+void meta_theme_calc_geometry (MetaTheme              *theme,
+                               MetaFrameType           type,
+                               int                     text_height,
+                               MetaFrameFlags          flags,
+                               int                     client_width,
+                               int                     client_height,
+                               const MetaButtonLayout *button_layout,
+                               MetaFrameGeometry      *fgeom);
+                                   
+MetaFrameLayout*   meta_theme_lookup_layout       (MetaTheme         *theme,
+                                                   const char        *name);
+void               meta_theme_insert_layout       (MetaTheme         *theme,
+                                                   const char        *name,
+                                                   MetaFrameLayout   *layout);
+MetaDrawOpList*    meta_theme_lookup_draw_op_list (MetaTheme         *theme,
+                                                   const char        *name);
+void               meta_theme_insert_draw_op_list (MetaTheme         *theme,
+                                                   const char        *name,
+                                                   MetaDrawOpList    *op_list);
+MetaFrameStyle*    meta_theme_lookup_style        (MetaTheme         *theme,
+                                                   const char        *name);
+void               meta_theme_insert_style        (MetaTheme         *theme,
+                                                   const char        *name,
+                                                   MetaFrameStyle    *style);
+MetaFrameStyleSet* meta_theme_lookup_style_set    (MetaTheme         *theme,
+                                                   const char        *name);
+void               meta_theme_insert_style_set    (MetaTheme         *theme,
+                                                   const char        *name,
+                                                   MetaFrameStyleSet *style_set);
+gboolean meta_theme_define_int_constant   (MetaTheme   *theme,
+                                           const char  *name,
+                                           int          value,
+                                           GError     **error);
+gboolean meta_theme_lookup_int_constant   (MetaTheme   *theme,
+                                           const char  *name,
+                                           int         *value);
+gboolean meta_theme_define_float_constant (MetaTheme   *theme,
+                                           const char  *name,
+                                           double       value,
+                                           GError     **error);
+gboolean meta_theme_lookup_float_constant (MetaTheme   *theme,
+                                           const char  *name,
+                                           double      *value);
+
+gboolean meta_theme_define_color_constant (MetaTheme   *theme,
+                                           const char  *name,
+                                           const char  *value,
+                                           GError     **error);
+gboolean meta_theme_lookup_color_constant (MetaTheme   *theme,
+                                           const char  *name,
+                                           char       **value);
+
+gboolean     meta_theme_replace_constants     (MetaTheme    *theme,
+                                               PosToken     *tokens,
+                                               int           n_tokens,
+                                               GError      **err);
+
+/* random stuff */
+
+PangoFontDescription* meta_gtk_widget_get_font_desc        (GtkWidget            *widget,
+                                                            double                scale,
+							    const PangoFontDescription *override);
+int                   meta_pango_font_desc_get_text_height (const PangoFontDescription *font_desc,
+                                                            PangoContext         *context);
+
+
+/* Enum converters */
+MetaGtkColorComponent meta_color_component_from_string (const char            *str);
+const char*           meta_color_component_to_string   (MetaGtkColorComponent  component);
+MetaButtonState       meta_button_state_from_string    (const char            *str);
+const char*           meta_button_state_to_string      (MetaButtonState        state);
+MetaButtonType        meta_button_type_from_string     (const char            *str,
+                                                        MetaTheme             *theme);
+const char*           meta_button_type_to_string       (MetaButtonType         type);
+MetaFramePiece        meta_frame_piece_from_string     (const char            *str);
+const char*           meta_frame_piece_to_string       (MetaFramePiece         piece);
+MetaFrameState        meta_frame_state_from_string     (const char            *str);
+const char*           meta_frame_state_to_string       (MetaFrameState         state);
+MetaFrameResize       meta_frame_resize_from_string    (const char            *str);
+const char*           meta_frame_resize_to_string      (MetaFrameResize        resize);
+MetaFrameFocus        meta_frame_focus_from_string     (const char            *str);
+const char*           meta_frame_focus_to_string       (MetaFrameFocus         focus);
+MetaFrameType         meta_frame_type_from_string      (const char            *str);
+const char*           meta_frame_type_to_string        (MetaFrameType          type);
+MetaGradientType      meta_gradient_type_from_string   (const char            *str);
+const char*           meta_gradient_type_to_string     (MetaGradientType       type);
+GtkStateType          meta_gtk_state_from_string       (const char            *str);
+const char*           meta_gtk_state_to_string         (GtkStateType           state);
+GtkShadowType         meta_gtk_shadow_from_string      (const char            *str);
+const char*           meta_gtk_shadow_to_string        (GtkShadowType          shadow);
+GtkArrowType          meta_gtk_arrow_from_string       (const char            *str);
+const char*           meta_gtk_arrow_to_string         (GtkArrowType           arrow);
+MetaImageFillType     meta_image_fill_type_from_string (const char            *str);
+const char*           meta_image_fill_type_to_string   (MetaImageFillType      fill_type);
+
+guint meta_theme_earliest_version_with_button (MetaButtonType type);
+
+
+#define META_THEME_ALLOWS(theme, feature) (theme->format_version >= feature)
+
+/* What version of the theme file format were various features introduced in? */
+#define META_THEME_SHADE_STICK_ABOVE_BUTTONS 2
+#define META_THEME_UBIQUITOUS_CONSTANTS 2
+#define META_THEME_VARIED_ROUND_CORNERS 2
+#define META_THEME_IMAGES_FROM_ICON_THEMES 2
+#define META_THEME_UNRESIZABLE_SHADED_STYLES 2
+#define META_THEME_DEGREES_IN_ARCS 2
+#define META_THEME_HIDDEN_BUTTONS 2
+#define META_THEME_COLOR_CONSTANTS 2
+#define META_THEME_FRAME_BACKGROUNDS 2
+
+#endif
diff --git a/src/ui/themewidget.c b/src/ui/themewidget.c
new file mode 100644
index 00000000..2d4e99fe
--- /dev/null
+++ b/src/ui/themewidget.c
@@ -0,0 +1,183 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme widget (displays themed draw operations) */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "themewidget.h"
+#include <math.h>
+
+static void meta_area_class_init   (MetaAreaClass  *klass);
+static void meta_area_init         (MetaArea       *area);
+static void meta_area_size_request (GtkWidget      *widget,
+                                    GtkRequisition *req);
+static gint meta_area_expose       (GtkWidget      *widget,
+                                    GdkEventExpose *event);
+static void meta_area_finalize     (GObject        *object);
+
+
+static GtkMiscClass *parent_class;
+
+GType
+meta_area_get_type (void)
+{
+  static GType area_type = 0;
+
+  if (!area_type)
+    {
+      static const GtkTypeInfo area_info =
+      {
+	"MetaArea",
+	sizeof (MetaArea),
+	sizeof (MetaAreaClass),
+	(GtkClassInitFunc) meta_area_class_init,
+	(GtkObjectInitFunc) meta_area_init,
+	/* reserved_1 */ NULL,
+        /* reserved_2 */ NULL,
+        (GtkClassInitFunc) NULL,
+      };
+
+      area_type = gtk_type_unique (GTK_TYPE_MISC, &area_info);
+    }
+
+  return area_type;
+}
+
+static void
+meta_area_class_init (MetaAreaClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+
+  object_class = (GtkObjectClass*) class;
+  widget_class = (GtkWidgetClass*) class;
+  parent_class = g_type_class_peek (gtk_misc_get_type ());
+
+  gobject_class->finalize = meta_area_finalize;
+
+  widget_class->expose_event = meta_area_expose;
+  widget_class->size_request = meta_area_size_request;
+}
+
+static void
+meta_area_init (MetaArea *area)
+{
+  GTK_WIDGET_SET_FLAGS (area, GTK_NO_WINDOW);
+}
+
+GtkWidget*
+meta_area_new (void)
+{
+  MetaArea *area;
+  
+  area = gtk_type_new (META_TYPE_AREA);
+  
+  return GTK_WIDGET (area);
+}
+
+static void
+meta_area_finalize (GObject *object)
+{
+  MetaArea *area;
+
+  area = META_AREA (object);
+  
+  if (area->dnotify)
+    (* area->dnotify) (area->user_data);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static gint
+meta_area_expose (GtkWidget      *widget,
+                  GdkEventExpose *event)
+{
+  MetaArea *area;
+  GtkMisc *misc;
+  gint x, y;
+  gfloat xalign;
+
+  g_return_val_if_fail (META_IS_AREA (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  if (GTK_WIDGET_DRAWABLE (widget))
+    {
+      area = META_AREA (widget);
+      misc = GTK_MISC (widget);
+
+      if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
+	xalign = misc->xalign;
+      else
+	xalign = 1.0 - misc->xalign;
+  
+      x = floor (widget->allocation.x + misc->xpad
+		 + ((widget->allocation.width - widget->requisition.width) * xalign)
+		 + 0.5);
+      y = floor (widget->allocation.y + misc->ypad 
+		 + ((widget->allocation.height - widget->requisition.height) * misc->yalign)
+		 + 0.5);
+      
+      if (area->expose_func)
+        {
+          (* area->expose_func) (area, event, x, y,
+                                 area->user_data);
+        }
+    }
+  
+  return FALSE;
+}
+
+static void
+meta_area_size_request (GtkWidget      *widget,
+                        GtkRequisition *req)
+{
+  MetaArea *area;
+
+  area = META_AREA (widget);
+  
+  req->width = 0;
+  req->height = 0;
+  
+  if (area->size_func)
+    {
+      (* area->size_func) (area, &req->width, &req->height,
+                           area->user_data);
+    }
+}
+
+void
+meta_area_setup (MetaArea           *area,
+                 MetaAreaSizeFunc    size_func,
+                 MetaAreaExposeFunc  expose_func,
+                 void               *user_data,
+                 GDestroyNotify      dnotify)
+{
+  if (area->dnotify)
+    (* area->dnotify) (area->user_data);
+  
+  area->size_func = size_func;
+  area->expose_func = expose_func;
+  area->user_data = user_data;
+  area->dnotify = dnotify;
+
+  gtk_widget_queue_resize (GTK_WIDGET (area));
+}
+
diff --git a/src/ui/themewidget.h b/src/ui/themewidget.h
new file mode 100644
index 00000000..5679d7ab
--- /dev/null
+++ b/src/ui/themewidget.h
@@ -0,0 +1,78 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco theme widget (displays themed draw operations) */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "theme.h"
+#include <gtk/gtk.h>
+
+#ifndef META_THEME_WIDGET_H
+#define META_THEME_WIDGET_H
+
+#define META_TYPE_AREA			 (meta_area_get_type ())
+#define META_AREA(obj)			 (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_AREA, MetaArea))
+#define META_AREA_CLASS(klass)		 (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_AREA, MetaAreaClass))
+#define META_IS_AREA(obj)		 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_AREA))
+#define META_IS_AREA_CLASS(klass)	 (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_AREA))
+#define META_AREA_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_AREA, MetaAreaClass))
+
+typedef struct _MetaArea	MetaArea;
+typedef struct _MetaAreaClass	MetaAreaClass;
+
+
+typedef void (* MetaAreaSizeFunc)   (MetaArea *area,
+                                     int      *width,
+                                     int      *height,
+                                     void     *user_data);
+
+typedef void (* MetaAreaExposeFunc) (MetaArea       *area,
+                                     GdkEventExpose *event,
+                                     int             x_offset,
+                                     int             y_offset,
+                                     void           *user_data);
+
+struct _MetaArea
+{
+  GtkMisc misc;
+
+  MetaAreaSizeFunc size_func;
+  MetaAreaExposeFunc expose_func;
+  void *user_data;
+  GDestroyNotify dnotify;
+};
+
+struct _MetaAreaClass
+{
+  GtkMiscClass parent_class;
+};
+
+
+GType    meta_area_get_type	 (void) G_GNUC_CONST;
+GtkWidget* meta_area_new	 (void);
+
+void meta_area_setup (MetaArea           *area,
+                      MetaAreaSizeFunc    size_func,
+                      MetaAreaExposeFunc  expose_func,
+                      void               *user_data,
+                      GDestroyNotify      dnotify);
+
+
+#endif
diff --git a/src/ui/ui.c b/src/ui/ui.c
new file mode 100644
index 00000000..c41bc891
--- /dev/null
+++ b/src/ui/ui.c
@@ -0,0 +1,1117 @@
+/* Marco interface for talking to GTK+ UI module */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ * stock icon code Copyright (C) 2002 Jorn Baayen <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "prefs.h"
+#include "ui.h"
+#include "frames.h"
+#include "util.h"
+#include "menu.h"
+#include "core.h"
+#include "theme.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+static void meta_ui_accelerator_parse(const char* accel, guint* keysym, guint* keycode, GdkModifierType* keymask);
+
+struct _MetaUI {
+	Display* xdisplay;
+	Screen* xscreen;
+	MetaFrames* frames;
+
+	/* For double-click tracking */
+	guint button_click_number;
+	Window button_click_window;
+	int button_click_x;
+	int button_click_y;
+	guint32 button_click_time;
+};
+
+void meta_ui_init(int* argc, char*** argv)
+{
+	if (!gtk_init_check (argc, argv))
+	{
+		meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL));
+	}
+}
+
+Display* meta_ui_get_display(void)
+{
+	return GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+}
+
+/* We do some of our event handling in frames.c, which expects
+ * GDK events delivered by GTK+.  However, since the transition to
+ * client side windows, we can't let GDK see button events, since the
+ * client-side tracking of implicit and explicit grabs it does will
+ * get confused by our direct use of X grabs in the core code.
+ *
+ * So we do a very minimal GDK => GTK event conversion here and send on the
+ * events we care about, and then filter them out so they don't go
+ * through the normal GDK event handling.
+ *
+ * To reduce the amount of code, the only events fields filled out
+ * below are the ones that frames.c uses. If frames.c is modified to
+ * use more fields, more fields need to be filled out below.
+ */
+
+static gboolean
+maybe_redirect_mouse_event (XEvent *xevent)
+{
+  GdkDisplay *gdisplay;
+  MetaUI *ui;
+  GdkEvent gevent;
+  GdkWindow *gdk_window;
+  Window window;
+
+  switch (xevent->type)
+    {
+    case ButtonPress:
+    case ButtonRelease:
+      window = xevent->xbutton.window;
+      break;
+    case MotionNotify:
+      window = xevent->xmotion.window;
+      break;
+    case EnterNotify:
+    case LeaveNotify:
+      window = xevent->xcrossing.window;
+      break;
+    default:
+      return FALSE;
+    }
+
+  gdisplay = gdk_x11_lookup_xdisplay (xevent->xany.display);
+  ui = g_object_get_data (G_OBJECT (gdisplay), "meta-ui");
+  if (!ui)
+    return FALSE;
+
+  gdk_window = gdk_window_lookup_for_display (gdisplay, window);
+  if (gdk_window == NULL)
+    return FALSE;
+
+  /* If GDK already thinks it has a grab, we better let it see events; this
+   * is the menu-navigation case and events need to get sent to the appropriate
+   * (client-side) subwindow for individual menu items.
+   */
+  if (gdk_display_pointer_is_grabbed (gdisplay))
+    return FALSE;
+
+  memset (&gevent, 0, sizeof (gevent));
+
+  switch (xevent->type)
+    {
+    case ButtonPress:
+    case ButtonRelease:
+      if (xevent->type == ButtonPress)
+        {
+          GtkSettings *settings = gtk_settings_get_default ();
+          int double_click_time;
+          int double_click_distance;
+
+          g_object_get (settings,
+                        "gtk-double-click-time", &double_click_time,
+                        "gtk-double-click-distance", &double_click_distance,
+                        NULL);
+
+          if (xevent->xbutton.button == ui->button_click_number &&
+              xevent->xbutton.window == ui->button_click_window &&
+              xevent->xbutton.time < ui->button_click_time + double_click_time &&
+              ABS (xevent->xbutton.x - ui->button_click_x) <= double_click_distance &&
+              ABS (xevent->xbutton.y - ui->button_click_y) <= double_click_distance)
+            {
+              gevent.button.type = GDK_2BUTTON_PRESS;
+
+              ui->button_click_number = 0;
+            }
+          else
+            {
+              gevent.button.type = GDK_BUTTON_PRESS;
+              ui->button_click_number = xevent->xbutton.button;
+              ui->button_click_window = xevent->xbutton.window;
+              ui->button_click_time = xevent->xbutton.time;
+              ui->button_click_x = xevent->xbutton.x;
+              ui->button_click_y = xevent->xbutton.y;
+            }
+        }
+      else
+        {
+          gevent.button.type = GDK_BUTTON_RELEASE;
+        }
+
+      gevent.button.window = gdk_window;
+      gevent.button.button = xevent->xbutton.button;
+      gevent.button.time = xevent->xbutton.time;
+      gevent.button.x = xevent->xbutton.x;
+      gevent.button.y = xevent->xbutton.y;
+      gevent.button.x_root = xevent->xbutton.x_root;
+      gevent.button.y_root = xevent->xbutton.y_root;
+
+      break;
+    case MotionNotify:
+      gevent.motion.type = GDK_MOTION_NOTIFY;
+      gevent.motion.window = gdk_window;
+      break;
+    case EnterNotify:
+    case LeaveNotify:
+      gevent.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
+      gevent.crossing.window = gdk_window;
+      gevent.crossing.x = xevent->xcrossing.x;
+      gevent.crossing.y = xevent->xcrossing.y;
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  /* If we've gotten here, we've filled in the gdk_event and should send it on */
+  gtk_main_do_event (&gevent);
+
+  return TRUE;
+}
+
+typedef struct _EventFunc EventFunc;
+
+struct _EventFunc
+{
+  MetaEventFunc func;
+  gpointer data;
+};
+
+static EventFunc *ef = NULL;
+
+static GdkFilterReturn
+filter_func (GdkXEvent *xevent,
+             GdkEvent *event,
+             gpointer data)
+{
+  g_return_val_if_fail (ef != NULL, GDK_FILTER_CONTINUE);
+
+  if ((* ef->func) (xevent, ef->data) ||
+      maybe_redirect_mouse_event (xevent))
+    return GDK_FILTER_REMOVE;
+  else
+    return GDK_FILTER_CONTINUE;
+}
+
+void
+meta_ui_add_event_func (Display       *xdisplay,
+                        MetaEventFunc  func,
+                        gpointer       data)
+{
+  g_return_if_fail (ef == NULL);
+
+  ef = g_new (EventFunc, 1);
+  ef->func = func;
+  ef->data = data;
+
+  gdk_window_add_filter (NULL, filter_func, ef);
+}
+
+/* removal is by data due to proxy function */
+void
+meta_ui_remove_event_func (Display       *xdisplay,
+                           MetaEventFunc  func,
+                           gpointer       data)
+{
+  g_return_if_fail (ef != NULL);
+
+  gdk_window_remove_filter (NULL, filter_func, ef);
+
+  g_free (ef);
+  ef = NULL;
+}
+
+MetaUI*
+meta_ui_new (Display *xdisplay,
+             Screen  *screen)
+{
+  GdkDisplay *gdisplay;
+  MetaUI *ui;
+
+  ui = g_new0 (MetaUI, 1);
+  ui->xdisplay = xdisplay;
+  ui->xscreen = screen;
+
+  gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
+  g_assert (gdisplay == gdk_display_get_default ());
+
+  g_assert (xdisplay == GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+  ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
+  gtk_widget_realize (GTK_WIDGET (ui->frames));
+
+  g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
+
+  return ui;
+}
+
+void
+meta_ui_free (MetaUI *ui)
+{
+  GdkDisplay *gdisplay;
+
+  gtk_widget_destroy (GTK_WIDGET (ui->frames));
+
+  gdisplay = gdk_x11_lookup_xdisplay (ui->xdisplay);
+  g_object_set_data (G_OBJECT (gdisplay), "meta-ui", NULL);
+
+  g_free (ui);
+}
+
+void
+meta_ui_get_frame_geometry (MetaUI *ui,
+                            Window frame_xwindow,
+                            int *top_height, int *bottom_height,
+                            int *left_width, int *right_width)
+{
+  meta_frames_get_geometry (ui->frames, frame_xwindow,
+                            top_height, bottom_height,
+                            left_width, right_width);
+}
+
+Window
+meta_ui_create_frame_window (MetaUI *ui,
+                             Display *xdisplay,
+                             Visual *xvisual,
+			     gint x,
+			     gint y,
+			     gint width,
+			     gint height,
+			     gint screen_no)
+{
+  GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
+  GdkScreen *screen = gdk_display_get_screen (display, screen_no);
+  GdkWindowAttr attrs;
+  gint attributes_mask;
+  GdkWindow *window;
+  GdkVisual *visual;
+  GdkColormap *cmap = gdk_screen_get_default_colormap (screen);
+
+  /* Default depth/visual handles clients with weird visuals; they can
+   * always be children of the root depth/visual obviously, but
+   * e.g. DRI games can't be children of a parent that has the same
+   * visual as the client.
+   */
+  if (!xvisual)
+    visual = gdk_screen_get_system_visual (screen);
+  else
+    {
+      visual = gdk_x11_screen_lookup_visual (screen,
+                                             XVisualIDFromVisual (xvisual));
+      cmap = gdk_colormap_new (visual, FALSE);
+    }
+
+  attrs.title = NULL;
+
+  /* frame.c is going to replace the event mask immediately, but
+   * we still have to set it here to let GDK know what it is.
+   */
+  attrs.event_mask =
+    GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+    GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
+    GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK;
+  attrs.x = x;
+  attrs.y = y;
+  attrs.wclass = GDK_INPUT_OUTPUT;
+  attrs.visual = visual;
+  attrs.colormap = cmap;
+  attrs.window_type = GDK_WINDOW_CHILD;
+  attrs.cursor = NULL;
+  attrs.wmclass_name = NULL;
+  attrs.wmclass_class = NULL;
+  attrs.override_redirect = FALSE;
+
+  attrs.width  = width;
+  attrs.height = height;
+
+  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+  window =
+    gdk_window_new (gdk_screen_get_root_window(screen),
+		    &attrs, attributes_mask);
+
+  gdk_window_resize (window, width, height);
+
+  meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window);
+
+  return GDK_WINDOW_XID (window);
+}
+
+void
+meta_ui_destroy_frame_window (MetaUI *ui,
+			      Window  xwindow)
+{
+  meta_frames_unmanage_window (ui->frames, xwindow);
+}
+
+void
+meta_ui_move_resize_frame (MetaUI *ui,
+			   Window frame,
+			   int x,
+			   int y,
+			   int width,
+			   int height)
+{
+  meta_frames_move_resize_frame (ui->frames, frame, x, y, width, height);
+}
+
+void
+meta_ui_map_frame   (MetaUI *ui,
+                     Window  xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  if (window)
+    gdk_window_show_unraised (window);
+}
+
+void
+meta_ui_unmap_frame (MetaUI *ui,
+                     Window  xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  if (window)
+    gdk_window_hide (window);
+}
+
+void
+meta_ui_unflicker_frame_bg (MetaUI *ui,
+                            Window  xwindow,
+                            int     target_width,
+                            int     target_height)
+{
+  meta_frames_unflicker_bg (ui->frames, xwindow,
+                            target_width, target_height);
+}
+
+void
+meta_ui_repaint_frame (MetaUI *ui,
+                       Window xwindow)
+{
+  meta_frames_repaint_frame (ui->frames, xwindow);
+}
+
+void
+meta_ui_reset_frame_bg (MetaUI *ui,
+                        Window xwindow)
+{
+  meta_frames_reset_bg (ui->frames, xwindow);
+}
+
+void
+meta_ui_apply_frame_shape  (MetaUI  *ui,
+                            Window   xwindow,
+                            int      new_window_width,
+                            int      new_window_height,
+                            gboolean window_has_shape)
+{
+  meta_frames_apply_shapes (ui->frames, xwindow,
+                            new_window_width, new_window_height,
+                            window_has_shape);
+}
+
+void
+meta_ui_queue_frame_draw (MetaUI *ui,
+                          Window xwindow)
+{
+  meta_frames_queue_draw (ui->frames, xwindow);
+}
+
+
+void
+meta_ui_set_frame_title (MetaUI     *ui,
+                         Window      xwindow,
+                         const char *title)
+{
+  meta_frames_set_title (ui->frames, xwindow, title);
+}
+
+MetaWindowMenu*
+meta_ui_window_menu_new  (MetaUI             *ui,
+                          Window              client_xwindow,
+                          MetaMenuOp          ops,
+                          MetaMenuOp          insensitive,
+                          unsigned long       active_workspace,
+                          int                 n_workspaces,
+                          MetaWindowMenuFunc  func,
+                          gpointer            data)
+{
+  return meta_window_menu_new (ui->frames,
+                               ops, insensitive,
+                               client_xwindow,
+                               active_workspace,
+                               n_workspaces,
+                               func, data);
+}
+
+void
+meta_ui_window_menu_popup (MetaWindowMenu     *menu,
+                           int                 root_x,
+                           int                 root_y,
+                           int                 button,
+                           guint32             timestamp)
+{
+  meta_window_menu_popup (menu, root_x, root_y, button, timestamp);
+}
+
+void
+meta_ui_window_menu_free (MetaWindowMenu *menu)
+{
+  meta_window_menu_free (menu);
+}
+
+struct _MetaImageWindow
+{
+  GtkWidget *window;
+  GdkPixmap *pixmap;
+};
+
+MetaImageWindow*
+meta_image_window_new (Display *xdisplay,
+                       int      screen_number,
+                       int      max_width,
+                       int      max_height)
+{
+  MetaImageWindow *iw;
+  GdkDisplay *gdisplay;
+  GdkScreen *gscreen;
+
+  iw = g_new (MetaImageWindow, 1);
+  iw->window = gtk_window_new (GTK_WINDOW_POPUP);
+
+  gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
+  gscreen = gdk_display_get_screen (gdisplay, screen_number);
+
+  gtk_window_set_screen (GTK_WINDOW (iw->window), gscreen);
+
+  gtk_widget_realize (iw->window);
+  iw->pixmap = gdk_pixmap_new (iw->window->window,
+                               max_width, max_height,
+                               -1);
+
+  gtk_widget_set_size_request (iw->window, 1, 1);
+  gtk_widget_set_double_buffered (iw->window, FALSE);
+  gtk_widget_set_app_paintable (iw->window, TRUE);
+
+  return iw;
+}
+
+void
+meta_image_window_free (MetaImageWindow *iw)
+{
+  gtk_widget_destroy (iw->window);
+  g_object_unref (G_OBJECT (iw->pixmap));
+  g_free (iw);
+}
+
+void
+meta_image_window_set_showing  (MetaImageWindow *iw,
+                                gboolean         showing)
+{
+  if (showing)
+    gtk_widget_show_all (iw->window);
+  else
+    {
+      gtk_widget_hide (iw->window);
+      meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
+    }
+}
+
+void
+meta_image_window_set (MetaImageWindow *iw,
+                       GdkPixbuf       *pixbuf,
+                       int              x,
+                       int              y)
+{
+  cairo_t *cr;
+
+  /* We use a back pixmap to avoid having to handle exposes, because
+   * it's really too slow for large clients being minimized, etc.
+   * and this way flicker is genuinely zero.
+   */
+
+  gdk_draw_pixbuf (iw->pixmap,
+                   iw->window->style->black_gc,
+		   pixbuf,
+                   0, 0,
+                   0, 0,
+                   gdk_pixbuf_get_width (pixbuf),
+                   gdk_pixbuf_get_height (pixbuf),
+                   GDK_RGB_DITHER_NORMAL,
+                   0, 0);
+  cr = gdk_cairo_create (iw->pixmap);
+  gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+  gdk_window_set_back_pixmap (iw->window->window,
+                              iw->pixmap,
+                              FALSE);
+
+  gdk_window_move_resize (iw->window->window,
+                          x, y,
+                          gdk_pixbuf_get_width (pixbuf),
+                          gdk_pixbuf_get_height (pixbuf));
+
+  gdk_window_clear (iw->window->window);
+}
+
+static GdkColormap*
+get_cmap (GdkPixmap *pixmap)
+{
+  GdkColormap *cmap;
+
+  cmap = gdk_drawable_get_colormap (pixmap);
+  if (cmap)
+    g_object_ref (G_OBJECT (cmap));
+
+  if (cmap == NULL)
+    {
+      if (gdk_drawable_get_depth (pixmap) == 1)
+        {
+          meta_verbose ("Using NULL colormap for snapshotting bitmap\n");
+          cmap = NULL;
+        }
+      else
+        {
+          meta_verbose ("Using system cmap to snapshot pixmap\n");
+          cmap = gdk_screen_get_system_colormap (gdk_drawable_get_screen (pixmap));
+
+          g_object_ref (G_OBJECT (cmap));
+        }
+    }
+
+  /* Be sure we aren't going to blow up due to visual mismatch */
+  if (cmap &&
+      (gdk_colormap_get_visual (cmap)->depth !=
+       gdk_drawable_get_depth (pixmap)))
+    {
+      cmap = NULL;
+      meta_verbose ("Switching back to NULL cmap because of depth mismatch\n");
+    }
+
+  return cmap;
+}
+
+GdkPixbuf*
+meta_gdk_pixbuf_get_from_window (GdkPixbuf   *dest,
+                                 Window       xwindow,
+                                 int          src_x,
+                                 int          src_y,
+                                 int          dest_x,
+                                 int          dest_y,
+                                 int          width,
+                                 int          height)
+{
+  GdkDrawable *drawable;
+  GdkPixbuf *retval;
+  GdkColormap *cmap;
+
+  retval = NULL;
+
+  drawable = gdk_xid_table_lookup (xwindow);
+
+  if (drawable)
+    g_object_ref (G_OBJECT (drawable));
+  else
+    drawable = gdk_window_foreign_new (xwindow);
+
+  cmap = get_cmap (drawable);
+
+  retval = gdk_pixbuf_get_from_drawable (dest,
+                                         drawable,
+                                         cmap,
+                                         src_x, src_y,
+                                         dest_x, dest_y,
+                                         width, height);
+
+  if (cmap)
+    g_object_unref (G_OBJECT (cmap));
+  g_object_unref (G_OBJECT (drawable));
+
+  return retval;
+}
+
+GdkPixbuf*
+meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf   *dest,
+                                 Pixmap       xpixmap,
+                                 int          src_x,
+                                 int          src_y,
+                                 int          dest_x,
+                                 int          dest_y,
+                                 int          width,
+                                 int          height)
+{
+  GdkDrawable *drawable;
+  GdkPixbuf *retval;
+  GdkColormap *cmap;
+
+  retval = NULL;
+  cmap = NULL;
+
+  drawable = gdk_xid_table_lookup (xpixmap);
+
+  if (drawable)
+    g_object_ref (G_OBJECT (drawable));
+  else
+    drawable = gdk_pixmap_foreign_new (xpixmap);
+
+  if (drawable)
+    {
+      cmap = get_cmap (drawable);
+
+      retval = gdk_pixbuf_get_from_drawable (dest,
+                                             drawable,
+                                             cmap,
+                                             src_x, src_y,
+                                             dest_x, dest_y,
+                                             width, height);
+    }
+  if (cmap)
+    g_object_unref (G_OBJECT (cmap));
+  if (drawable)
+    g_object_unref (G_OBJECT (drawable));
+
+  return retval;
+}
+
+void
+meta_ui_push_delay_exposes (MetaUI *ui)
+{
+  meta_frames_push_delay_exposes (ui->frames);
+}
+
+void
+meta_ui_pop_delay_exposes  (MetaUI *ui)
+{
+  meta_frames_pop_delay_exposes (ui->frames);
+}
+
+GdkPixbuf*
+meta_ui_get_default_window_icon (MetaUI *ui)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "gtk-missing-image",
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+
+  g_object_ref (G_OBJECT (default_icon));
+
+  return default_icon;
+}
+
+GdkPixbuf*
+meta_ui_get_default_mini_icon (MetaUI *ui)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "gtk-missing-image",
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+
+  g_object_ref (G_OBJECT (default_icon));
+
+  return default_icon;
+}
+
+gboolean
+meta_ui_window_should_not_cause_focus (Display *xdisplay,
+                                       Window   xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  /* we shouldn't cause focus if we're an override redirect
+   * toplevel which is not foreign
+   */
+  if (window && gdk_window_get_window_type (window) == GDK_WINDOW_TEMP)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+char*
+meta_text_property_to_utf8 (Display             *xdisplay,
+                            const XTextProperty *prop)
+{
+  char **list;
+  int count;
+  char *retval;
+
+  list = NULL;
+
+  count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (prop->encoding),
+                                          prop->format,
+                                          prop->value,
+                                          prop->nitems,
+                                          &list);
+
+  if (count == 0)
+    retval = NULL;
+  else
+    {
+      retval = list[0];
+      list[0] = g_strdup (""); /* something to free */
+    }
+
+  g_strfreev (list);
+
+  return retval;
+}
+
+void
+meta_ui_theme_get_frame_borders (MetaUI *ui,
+                                 MetaFrameType      type,
+                                 MetaFrameFlags     flags,
+                                 int               *top_height,
+                                 int               *bottom_height,
+                                 int               *left_width,
+                                 int               *right_width)
+{
+  int text_height;
+  PangoContext *context;
+  const PangoFontDescription *font_desc;
+  GtkStyle *default_style;
+
+  if (meta_ui_have_a_theme ())
+    {
+      context = gtk_widget_get_pango_context (GTK_WIDGET (ui->frames));
+      font_desc = meta_prefs_get_titlebar_font ();
+
+      if (!font_desc)
+        {
+          default_style = gtk_widget_get_default_style ();
+          font_desc = default_style->font_desc;
+        }
+
+      text_height = meta_pango_font_desc_get_text_height (font_desc, context);
+
+      meta_theme_get_frame_borders (meta_theme_get_current (),
+                                    type, text_height, flags,
+                                    top_height, bottom_height,
+                                    left_width, right_width);
+    }
+  else
+    {
+      *top_height = *bottom_height = *left_width = *right_width = 0;
+    }
+}
+
+void
+meta_ui_set_current_theme (const char *name,
+                           gboolean    force_reload)
+{
+  meta_theme_set_current (name, force_reload);
+  meta_invalidate_default_icons ();
+}
+
+gboolean
+meta_ui_have_a_theme (void)
+{
+  return meta_theme_get_current () != NULL;
+}
+
+static void
+meta_ui_accelerator_parse (const char      *accel,
+                           guint           *keysym,
+                           guint           *keycode,
+                           GdkModifierType *keymask)
+{
+  if (accel[0] == '0' && accel[1] == 'x')
+    {
+      *keysym = 0;
+      *keycode = (guint) strtoul (accel, NULL, 16);
+      *keymask = 0;
+    }
+  else
+    gtk_accelerator_parse (accel, keysym, keymask);
+}
+
+gboolean
+meta_ui_parse_accelerator (const char          *accel,
+                           unsigned int        *keysym,
+                           unsigned int        *keycode,
+                           MetaVirtualModifier *mask)
+{
+  GdkModifierType gdk_mask = 0;
+  guint gdk_sym = 0;
+  guint gdk_code = 0;
+
+  *keysym = 0;
+  *keycode = 0;
+  *mask = 0;
+
+  if (strcmp (accel, "disabled") == 0)
+    return TRUE;
+
+  meta_ui_accelerator_parse (accel, &gdk_sym, &gdk_code, &gdk_mask);
+  if (gdk_mask == 0 && gdk_sym == 0 && gdk_code == 0)
+    return FALSE;
+
+  if (gdk_sym == None && gdk_code == 0)
+    return FALSE;
+
+  if (gdk_mask & GDK_RELEASE_MASK) /* we don't allow this */
+    return FALSE;
+
+  *keysym = gdk_sym;
+  *keycode = gdk_code;
+
+  if (gdk_mask & GDK_SHIFT_MASK)
+    *mask |= META_VIRTUAL_SHIFT_MASK;
+  if (gdk_mask & GDK_CONTROL_MASK)
+    *mask |= META_VIRTUAL_CONTROL_MASK;
+  if (gdk_mask & GDK_MOD1_MASK)
+    *mask |= META_VIRTUAL_ALT_MASK;
+  if (gdk_mask & GDK_MOD2_MASK)
+    *mask |= META_VIRTUAL_MOD2_MASK;
+  if (gdk_mask & GDK_MOD3_MASK)
+    *mask |= META_VIRTUAL_MOD3_MASK;
+  if (gdk_mask & GDK_MOD4_MASK)
+    *mask |= META_VIRTUAL_MOD4_MASK;
+  if (gdk_mask & GDK_MOD5_MASK)
+    *mask |= META_VIRTUAL_MOD5_MASK;
+  if (gdk_mask & GDK_SUPER_MASK)
+    *mask |= META_VIRTUAL_SUPER_MASK;
+  if (gdk_mask & GDK_HYPER_MASK)
+    *mask |= META_VIRTUAL_HYPER_MASK;
+  if (gdk_mask & GDK_META_MASK)
+    *mask |= META_VIRTUAL_META_MASK;
+
+  return TRUE;
+}
+
+/* Caller responsible for freeing return string of meta_ui_accelerator_name! */
+gchar*
+meta_ui_accelerator_name  (unsigned int        keysym,
+                           MetaVirtualModifier mask)
+{
+  GdkModifierType mods = 0;
+
+  if (keysym == 0 && mask == 0)
+    {
+      return g_strdup ("disabled");
+    }
+
+  if (mask & META_VIRTUAL_SHIFT_MASK)
+    mods |= GDK_SHIFT_MASK;
+  if (mask & META_VIRTUAL_CONTROL_MASK)
+    mods |= GDK_CONTROL_MASK;
+  if (mask & META_VIRTUAL_ALT_MASK)
+    mods |= GDK_MOD1_MASK;
+  if (mask & META_VIRTUAL_MOD2_MASK)
+    mods |= GDK_MOD2_MASK;
+  if (mask & META_VIRTUAL_MOD3_MASK)
+    mods |= GDK_MOD3_MASK;
+  if (mask & META_VIRTUAL_MOD4_MASK)
+    mods |= GDK_MOD4_MASK;
+  if (mask & META_VIRTUAL_MOD5_MASK)
+    mods |= GDK_MOD5_MASK;
+  if (mask & META_VIRTUAL_SUPER_MASK)
+    mods |= GDK_SUPER_MASK;
+  if (mask & META_VIRTUAL_HYPER_MASK)
+    mods |= GDK_HYPER_MASK;
+  if (mask & META_VIRTUAL_META_MASK)
+    mods |= GDK_META_MASK;
+
+  return gtk_accelerator_name (keysym, mods);
+
+}
+
+gboolean
+meta_ui_parse_modifier (const char          *accel,
+                        MetaVirtualModifier *mask)
+{
+  GdkModifierType gdk_mask = 0;
+  guint gdk_sym = 0;
+  guint gdk_code = 0;
+
+  *mask = 0;
+
+  if (accel == NULL || strcmp (accel, "disabled") == 0)
+    return TRUE;
+
+  meta_ui_accelerator_parse (accel, &gdk_sym, &gdk_code, &gdk_mask);
+  if (gdk_mask == 0 && gdk_sym == 0 && gdk_code == 0)
+    return FALSE;
+
+  if (gdk_sym != None || gdk_code != 0)
+    return FALSE;
+
+  if (gdk_mask & GDK_RELEASE_MASK) /* we don't allow this */
+    return FALSE;
+
+  if (gdk_mask & GDK_SHIFT_MASK)
+    *mask |= META_VIRTUAL_SHIFT_MASK;
+  if (gdk_mask & GDK_CONTROL_MASK)
+    *mask |= META_VIRTUAL_CONTROL_MASK;
+  if (gdk_mask & GDK_MOD1_MASK)
+    *mask |= META_VIRTUAL_ALT_MASK;
+  if (gdk_mask & GDK_MOD2_MASK)
+    *mask |= META_VIRTUAL_MOD2_MASK;
+  if (gdk_mask & GDK_MOD3_MASK)
+    *mask |= META_VIRTUAL_MOD3_MASK;
+  if (gdk_mask & GDK_MOD4_MASK)
+    *mask |= META_VIRTUAL_MOD4_MASK;
+  if (gdk_mask & GDK_MOD5_MASK)
+    *mask |= META_VIRTUAL_MOD5_MASK;
+  if (gdk_mask & GDK_SUPER_MASK)
+    *mask |= META_VIRTUAL_SUPER_MASK;
+  if (gdk_mask & GDK_HYPER_MASK)
+    *mask |= META_VIRTUAL_HYPER_MASK;
+  if (gdk_mask & GDK_META_MASK)
+    *mask |= META_VIRTUAL_META_MASK;
+
+  return TRUE;
+}
+
+gboolean
+meta_ui_window_is_widget (MetaUI *ui,
+                          Window  xwindow)
+{
+  GdkWindow *window;
+
+  window = gdk_xid_table_lookup (xwindow);
+
+  if (window)
+    {
+      void *user_data = NULL;
+      gdk_window_get_user_data (window, &user_data);
+      return user_data != NULL && user_data != ui->frames;
+    }
+  else
+    return FALSE;
+}
+
+/* stock icon code Copyright (C) 2002 Jorn Baayen <[email protected]> */
+
+typedef struct {
+	char* stock_id;
+	const guint8* icon_data;
+} MetaStockIcon;
+
+int meta_ui_get_drag_threshold(MetaUI* ui)
+{
+	int threshold = 8;
+	GtkSettings* settings = gtk_widget_get_settings(GTK_WIDGET(ui->frames));
+
+	g_object_get(G_OBJECT(settings), "gtk-dnd-drag-threshold", &threshold, NULL);
+
+	return threshold;
+}
+
+MetaUIDirection meta_ui_get_direction(void)
+{
+	if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL)
+	{
+		return META_UI_DIRECTION_RTL;
+	}
+
+	return META_UI_DIRECTION_LTR;
+}
+
+GdkPixbuf* meta_ui_get_pixbuf_from_pixmap(Pixmap pmap)
+{
+	GdkPixmap* gpmap;
+	GdkScreen* screen;
+	GdkPixbuf* pixbuf;
+	GdkColormap* cmap;
+	int width;
+	int height;
+	int depth;
+
+	gpmap = gdk_pixmap_foreign_new(pmap);
+	screen = gdk_drawable_get_screen(gpmap);
+
+	#if GTK_CHECK_VERSION(3, 0, 0)
+		width = gdk_window_get_width(GDK_WINDOW(gpmap));
+		height = gdk_window_get_height(GDK_WINDOW(gpmap));
+	#else
+		gdk_drawable_get_size(GDK_DRAWABLE(gpmap), &width, &height);
+	#endif
+
+	depth = gdk_drawable_get_depth(GDK_DRAWABLE(gpmap));
+
+	if (depth <= 24)
+	{
+		cmap = gdk_screen_get_system_colormap(screen);
+	}
+	else
+	{
+		cmap = gdk_screen_get_rgba_colormap(screen);
+	}
+
+	pixbuf = gdk_pixbuf_get_from_drawable(NULL, gpmap, cmap, 0, 0, 0, 0, width, height);
+
+	g_object_unref(gpmap);
+
+	return pixbuf;
+}
diff --git a/src/wm-tester/Makefile.am b/src/wm-tester/Makefile.am
new file mode 100644
index 00000000..3d35c741
--- /dev/null
+++ b/src/wm-tester/Makefile.am
@@ -0,0 +1,25 @@
+
+INCLUDES=@MARCO_CFLAGS@
+
+wm_tester_SOURCES= 				\
+	main.c
+
+test_gravity_SOURCES=				\
+	test-gravity.c
+
+focus_window_SOURCES=				\
+	focus-window.c
+
+test_resizing_SOURCES=				\
+	test-resizing.c
+
+test_size_hints_SOURCES=			\
+	test-size-hints.c
+
+noinst_PROGRAMS=wm-tester test-gravity test-resizing focus-window test-size-hints
+
+wm_tester_LDADD= @MARCO_LIBS@
+test_gravity_LDADD= @MARCO_LIBS@
+test_resizing_LDADD= @MARCO_LIBS@
+test_size_hints_LDADD= @MARCO_LIBS@
+focus_window_LDADD= @MARCO_LIBS@
\ No newline at end of file
diff --git a/src/wm-tester/Makefile.in b/src/wm-tester/Makefile.in
new file mode 100644
index 00000000..a23fe7f8
--- /dev/null
+++ b/src/wm-tester/Makefile.in
@@ -0,0 +1,574 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+noinst_PROGRAMS = wm-tester$(EXEEXT) test-gravity$(EXEEXT) \
+	test-resizing$(EXEEXT) focus-window$(EXEEXT) \
+	test-size-hints$(EXEEXT)
+subdir = src/wm-tester
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.in
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+PROGRAMS = $(noinst_PROGRAMS)
+am_focus_window_OBJECTS = focus-window.$(OBJEXT)
+focus_window_OBJECTS = $(am_focus_window_OBJECTS)
+focus_window_DEPENDENCIES =
+am_test_gravity_OBJECTS = test-gravity.$(OBJEXT)
+test_gravity_OBJECTS = $(am_test_gravity_OBJECTS)
+test_gravity_DEPENDENCIES =
+am_test_resizing_OBJECTS = test-resizing.$(OBJEXT)
+test_resizing_OBJECTS = $(am_test_resizing_OBJECTS)
+test_resizing_DEPENDENCIES =
+am_test_size_hints_OBJECTS = test-size-hints.$(OBJEXT)
+test_size_hints_OBJECTS = $(am_test_size_hints_OBJECTS)
+test_size_hints_DEPENDENCIES =
+am_wm_tester_OBJECTS = main.$(OBJEXT)
+wm_tester_OBJECTS = $(am_wm_tester_OBJECTS)
+wm_tester_DEPENDENCIES =
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+SOURCES = $(focus_window_SOURCES) $(test_gravity_SOURCES) \
+	$(test_resizing_SOURCES) $(test_size_hints_SOURCES) \
+	$(wm_tester_SOURCES)
+DIST_SOURCES = $(focus_window_SOURCES) $(test_gravity_SOURCES) \
+	$(test_resizing_SOURCES) $(test_size_hints_SOURCES) \
+	$(wm_tester_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
+ALL_CFLAGS = @ALL_CFLAGS@
+ALL_LIBS = @ALL_LIBS@
+ALL_LINGUAS = @ALL_LINGUAS@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CATALOGS = @CATALOGS@
+CATOBJEXT = @CATOBJEXT@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DATADIRNAME = @DATADIRNAME@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DISTCHECK_CONFIGURE_FLAGS = @DISTCHECK_CONFIGURE_FLAGS@
+DLLTOOL = @DLLTOOL@
+DOC_USER_FORMATS = @DOC_USER_FORMATS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GDK_PIXBUF_CSOURCE = @GDK_PIXBUF_CSOURCE@
+GETTEXT_PACKAGE = @GETTEXT_PACKAGE@
+GMOFILES = @GMOFILES@
+GMSGFMT = @GMSGFMT@
+GREP = @GREP@
+GTK_API_VERSION = @GTK_API_VERSION@
+HELP_DIR = @HELP_DIR@
+HOST_ALIAS = @HOST_ALIAS@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INSTOBJEXT = @INSTOBJEXT@
+INTLLIBS = @INTLLIBS@
+INTLTOOL_EXTRACT = @INTLTOOL_EXTRACT@
+INTLTOOL_MERGE = @INTLTOOL_MERGE@
+INTLTOOL_PERL = @INTLTOOL_PERL@
+INTLTOOL_UPDATE = @INTLTOOL_UPDATE@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MARCO_CFLAGS = @MARCO_CFLAGS@
+MARCO_LIBS = @MARCO_LIBS@
+MARCO_MESSAGE_CFLAGS = @MARCO_MESSAGE_CFLAGS@
+MARCO_MESSAGE_LIBS = @MARCO_MESSAGE_LIBS@
+MARCO_WINDOW_DEMO_CFLAGS = @MARCO_WINDOW_DEMO_CFLAGS@
+MARCO_WINDOW_DEMO_LIBS = @MARCO_WINDOW_DEMO_LIBS@
+MATECONFTOOL = @MATECONFTOOL@
+MATECONF_SCHEMA_CONFIG_SOURCE = @MATECONF_SCHEMA_CONFIG_SOURCE@
+MATECONF_SCHEMA_FILE_DIR = @MATECONF_SCHEMA_FILE_DIR@
+MATEDIALOG = @MATEDIALOG@
+MATE_KEYBINDINGS_KEYSDIR = @MATE_KEYBINDINGS_KEYSDIR@
+MKDIR_P = @MKDIR_P@
+MKINSTALLDIRS = @MKINSTALLDIRS@
+MSGFMT = @MSGFMT@
+MSGFMT_OPTS = @MSGFMT_OPTS@
+MSGMERGE = @MSGMERGE@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OMF_DIR = @OMF_DIR@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+POFILES = @POFILES@
+POSUB = @POSUB@
+PO_IN_DATADIR_FALSE = @PO_IN_DATADIR_FALSE@
+PO_IN_DATADIR_TRUE = @PO_IN_DATADIR_TRUE@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+USE_NLS = @USE_NLS@
+VERSION = @VERSION@
+XGETTEXT = @XGETTEXT@
+XMKMF = @XMKMF@
+X_CFLAGS = @X_CFLAGS@
+X_EXTRA_LIBS = @X_EXTRA_LIBS@
+X_LIBS = @X_LIBS@
+X_PRE_LIBS = @X_PRE_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+INCLUDES = @MARCO_CFLAGS@
+wm_tester_SOURCES = \
+	main.c
+
+test_gravity_SOURCES = \
+	test-gravity.c
+
+focus_window_SOURCES = \
+	focus-window.c
+
+test_resizing_SOURCES = \
+	test-resizing.c
+
+test_size_hints_SOURCES = \
+	test-size-hints.c
+
+wm_tester_LDADD = @MARCO_LIBS@
+test_gravity_LDADD = @MARCO_LIBS@
+test_resizing_LDADD = @MARCO_LIBS@
+test_size_hints_LDADD = @MARCO_LIBS@
+focus_window_LDADD = @MARCO_LIBS@
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/wm-tester/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu src/wm-tester/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+clean-noinstPROGRAMS:
+	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+focus-window$(EXEEXT): $(focus_window_OBJECTS) $(focus_window_DEPENDENCIES) 
+	@rm -f focus-window$(EXEEXT)
+	$(LINK) $(focus_window_OBJECTS) $(focus_window_LDADD) $(LIBS)
+test-gravity$(EXEEXT): $(test_gravity_OBJECTS) $(test_gravity_DEPENDENCIES) 
+	@rm -f test-gravity$(EXEEXT)
+	$(LINK) $(test_gravity_OBJECTS) $(test_gravity_LDADD) $(LIBS)
+test-resizing$(EXEEXT): $(test_resizing_OBJECTS) $(test_resizing_DEPENDENCIES) 
+	@rm -f test-resizing$(EXEEXT)
+	$(LINK) $(test_resizing_OBJECTS) $(test_resizing_LDADD) $(LIBS)
+test-size-hints$(EXEEXT): $(test_size_hints_OBJECTS) $(test_size_hints_DEPENDENCIES) 
+	@rm -f test-size-hints$(EXEEXT)
+	$(LINK) $(test_size_hints_OBJECTS) $(test_size_hints_LDADD) $(LIBS)
+wm-tester$(EXEEXT): $(wm_tester_OBJECTS) $(wm_tester_DEPENDENCIES) 
+	@rm -f wm-tester$(EXEEXT)
+	$(LINK) $(wm_tester_OBJECTS) $(wm_tester_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/focus-window.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test-gravity.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test-resizing.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test-size-hints.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-noinstPROGRAMS ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags uninstall uninstall-am
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/wm-tester/focus-window.c b/src/wm-tester/focus-window.c
new file mode 100644
index 00000000..dc33bd25
--- /dev/null
+++ b/src/wm-tester/focus-window.c
@@ -0,0 +1,37 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (int argc, char **argv)
+{
+  Display *d;
+  Window w;
+  const char *w_str;
+  char *end;
+  
+  if (argc != 2)
+    {
+      fprintf (stderr, "Usage: focus-window WINDOWID\n");
+      exit (1);
+    }
+  
+  d = XOpenDisplay (NULL);
+
+  w_str = argv[1];
+  end = NULL;
+  
+  w = strtoul (w_str, &end, 16);
+  if (end == w_str)
+    {
+      fprintf (stderr, "Usage: focus-window WINDOWID\n");
+      exit (1);
+    }
+
+  printf ("Setting input focus to 0x%lx\n", w);
+  XSetInputFocus (d, w, RevertToPointerRoot, CurrentTime);
+  XFlush (d);
+  
+  return 0;
+}
+
diff --git a/src/wm-tester/main.c b/src/wm-tester/main.c
new file mode 100644
index 00000000..e56d6606
--- /dev/null
+++ b/src/wm-tester/main.c
@@ -0,0 +1,245 @@
+/* WM tester main() */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <gtk/gtk.h>
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+static void set_up_the_evil (void);
+static void set_up_icon_windows (void);
+
+static void
+usage (void)
+{
+  g_print ("wm-tester [--evil] [--icon-windows]\n");
+  exit (0);
+}
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  gboolean do_evil;
+  gboolean do_icon_windows;
+  
+  gtk_init (&argc, &argv);  
+  
+  do_evil = FALSE;
+  do_icon_windows = FALSE;
+  
+  i = 1;
+  while (i < argc)
+    {
+      const char *arg = argv[i];
+      
+      if (strcmp (arg, "--help") == 0 ||
+          strcmp (arg, "-h") == 0 ||
+          strcmp (arg, "-?") == 0)
+        usage ();
+      else if (strcmp (arg, "--evil") == 0)
+        do_evil = TRUE;
+      else if (strcmp (arg, "--icon-windows") == 0)
+        do_icon_windows = TRUE;
+      else
+        usage ();
+      
+      ++i;
+    }
+
+  /* Be sure some option was provided */
+  if (! (do_evil || do_icon_windows))
+    return 1;
+  
+  if (do_evil)
+    set_up_the_evil ();
+
+  if (do_icon_windows)
+    set_up_icon_windows ();
+  
+  gtk_main ();
+
+  return 0;
+}
+
+static GSList *evil_windows = NULL;
+
+static gint
+evil_timeout (gpointer data)
+{
+  int i;
+  int n_windows;
+  int len;
+  int create_count;
+  int destroy_count;
+  
+  len = g_slist_length (evil_windows);  
+  
+  if (len > 35)
+    {
+      create_count = 2;
+      destroy_count = 5;
+    }
+  else
+    {
+      create_count = 5;
+      destroy_count = 5;
+    }
+
+  /* Create some windows */
+  n_windows = g_random_int_range (0, create_count);
+  
+  i = 0;
+  while (i < n_windows)
+    {
+      GtkWidget *w;
+      GtkWidget *c;
+      int t;
+      GtkWidget *parent;
+      
+      w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+      gtk_widget_set_uposition (w,
+                                g_random_int_range (0,
+                                                    gdk_screen_width ()),
+                                g_random_int_range (0,
+                                                    gdk_screen_height ()));
+
+      parent = NULL;
+      
+      /* set transient for random window (may create all kinds of weird cycles) */
+      if (len > 0)
+        {
+          t = g_random_int_range (- (len / 3), len);
+          if (t >= 0)
+            {
+              parent = g_slist_nth_data (evil_windows, t);
+              
+              if (parent != NULL)
+                gtk_window_set_transient_for (GTK_WINDOW (w), GTK_WINDOW (parent));
+            }
+        }
+      
+      if (parent != NULL)
+        c = gtk_button_new_with_label ("Evil Transient!");
+      else
+        c = gtk_button_new_with_label ("Evil Window!");
+      gtk_container_add (GTK_CONTAINER (w), c);
+      
+      gtk_widget_show_all (w);
+      
+      evil_windows = g_slist_prepend (evil_windows, w);
+      
+      ++i;
+    }
+
+  /* Destroy some windows */
+  if (len > destroy_count)
+    {
+      n_windows = g_random_int_range (0, destroy_count);
+      i = 0;
+      while (i < n_windows)
+        {
+          GtkWidget *w;
+          
+          w = g_slist_nth_data (evil_windows,
+                                g_random_int_range (0, len));
+          if (w)
+            {
+              --len;
+              evil_windows = g_slist_remove (evil_windows, w);
+              gtk_widget_destroy (w);
+            }
+          
+          ++i;
+        }
+    }
+  
+  return TRUE;
+}
+
+static void
+set_up_the_evil (void)
+{
+  g_timeout_add (400, evil_timeout, NULL);
+}
+
+static void
+set_up_icon_windows (void)
+{
+  int i;
+  int n_windows;
+
+  /* Create some windows */
+  n_windows = 9;
+  
+  i = 0;
+  while (i < n_windows)
+    {
+      GtkWidget *w;
+      GtkWidget *c;
+      GList *icons;
+      GdkPixbuf *pix;
+      
+      w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      c = gtk_button_new_with_label ("Icon window");
+      gtk_container_add (GTK_CONTAINER (w), c);
+
+      icons = NULL;
+
+      pix = gtk_widget_render_icon (w,
+                                    GTK_STOCK_SAVE,
+                                    GTK_ICON_SIZE_LARGE_TOOLBAR,
+                                    NULL);
+      
+      icons = g_list_append (icons, pix);
+
+      if (i % 2)
+        {
+          pix = gtk_widget_render_icon (w,
+                                        GTK_STOCK_SAVE,
+                                        GTK_ICON_SIZE_DIALOG,
+                                        NULL);
+          icons = g_list_append (icons, pix);
+        }
+
+      if (i % 3)
+        {
+          pix = gtk_widget_render_icon (w,
+                                        GTK_STOCK_SAVE,
+                                        GTK_ICON_SIZE_MENU,
+                                        NULL);
+          icons = g_list_append (icons, pix);
+        }
+
+      gtk_window_set_icon_list (GTK_WINDOW (w), icons);
+
+      g_list_foreach (icons, (GFunc) g_object_unref, NULL);
+      g_list_free (icons);
+      
+      gtk_widget_show_all (w);
+      
+      ++i;
+    }
+}
diff --git a/src/wm-tester/test-gravity.c b/src/wm-tester/test-gravity.c
new file mode 100644
index 00000000..8e5b581c
--- /dev/null
+++ b/src/wm-tester/test-gravity.c
@@ -0,0 +1,308 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdio.h>
+#include <string.h>
+
+static int gravities[10] = {
+  NorthWestGravity, 
+  NorthGravity,  
+  NorthEastGravity,
+  WestGravity,      
+  CenterGravity, 
+  EastGravity,
+  SouthWestGravity,
+  SouthGravity,
+  SouthEastGravity,
+  StaticGravity
+};
+
+typedef struct
+{
+  int x, y, width, height;
+} Rectangle;
+
+static Window windows[10];
+static int doubled[10] = { 0, };
+static Rectangle window_rects[10];
+
+#define WINDOW_WIDTH 100
+#define WINDOW_HEIGHT 100
+
+static int x_offset[3] = { 0, - WINDOW_WIDTH/2,  -WINDOW_WIDTH };
+static int y_offset[3] = { 0, - WINDOW_HEIGHT/2,  -WINDOW_HEIGHT };
+static double screen_x_fraction[3] = { 0, 0.5, 1.0 };
+static double screen_y_fraction[3] = { 0, 0.5, 1.0 };
+static int screen_width;
+static int screen_height;
+
+static const char*
+window_gravity_to_string (int gravity)
+{
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      return "NorthWestGravity";
+    case NorthGravity:
+      return "NorthGravity";
+    case NorthEastGravity:
+      return "NorthEastGravity";
+    case WestGravity:
+      return "WestGravity";
+    case CenterGravity:
+      return "CenterGravity";
+    case EastGravity:
+      return "EastGravity";
+    case SouthWestGravity:
+      return "SouthWestGravity";
+    case SouthGravity:
+      return "SouthGravity";
+    case SouthEastGravity:
+      return "SouthEastGravity";
+    case StaticGravity:
+      return "StaticGravity";
+    default:
+      return "NorthWestGravity";
+    }
+}
+
+static void
+calculate_position (int i, int doubled, int *x, int *y)
+{
+  if (i == 9)
+    {
+      *x = 150;
+      *y = 150;
+    }
+  else 
+    {
+      int xoff = x_offset[i % 3];
+      int yoff = y_offset[i / 3];
+      if (doubled)
+        {
+          xoff *= 2;
+          yoff *= 2;
+        }
+      
+      *x = screen_x_fraction[i % 3] * screen_width + xoff;
+      *y = screen_y_fraction[i / 3] * screen_height + yoff;
+    }
+}
+
+static int
+find_window (Window window)
+{
+  int i;
+  for (i=0; i<10; i++)
+    {
+      if (windows[i] == window)
+        return i;
+    }
+
+  return -1;
+}
+
+typedef struct {
+    unsigned long flags;
+    unsigned long functions;
+    unsigned long decorations;
+    long input_mode;
+    unsigned long status;
+} MotifWmHints, MwmHints;
+
+#define MWM_HINTS_FUNCTIONS     (1L << 0)
+#define MWM_HINTS_DECORATIONS   (1L << 1)
+#define MWM_HINTS_INPUT_MODE    (1L << 2)
+#define MWM_HINTS_STATUS        (1L << 3)
+
+int main (int argc, char **argv)
+{
+  Display *d;
+  Window w;
+  XSizeHints hints;
+  int i;
+  int screen;
+  XEvent ev;
+  int noframes;
+  
+  if (argc > 1 && strcmp (argv[1], "--noframes") == 0)
+    noframes = 1;
+  else
+    noframes = 0;
+  
+  d = XOpenDisplay (NULL);
+
+  screen = DefaultScreen (d);
+  screen_width = DisplayWidth (d, screen);
+  screen_height = DisplayHeight (d, screen);
+
+  for (i=0; i<10; i++)
+    {
+      int x, y;
+      
+      calculate_position (i, doubled[i], &x, &y);
+
+      w = XCreateSimpleWindow (d, RootWindow (d, screen), 
+                               x, y, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 
+                               WhitePixel (d, screen), WhitePixel (d, screen));
+
+      windows[i] = w;
+      window_rects[i].x = x;
+      window_rects[i].y = y;
+      window_rects[i].width = WINDOW_WIDTH;
+      window_rects[i].height = WINDOW_HEIGHT;
+      
+      XSelectInput (d, w, ButtonPressMask | ExposureMask | StructureNotifyMask);
+      
+      hints.flags = USPosition | PMinSize | PMaxSize | PWinGravity;
+      
+      hints.min_width = WINDOW_WIDTH / 2;
+      hints.min_height = WINDOW_HEIGHT / 2;
+
+#if 1
+      /* we constrain max size below the "doubled" size so that
+       * the WM will have to deal with constraints
+       * at the same time it's dealing with configure request
+       */
+      hints.max_width = WINDOW_WIDTH * 2 - WINDOW_WIDTH / 2;
+      hints.max_height = WINDOW_HEIGHT * 2 - WINDOW_HEIGHT / 2;
+#else
+      hints.max_width = WINDOW_WIDTH * 2 + WINDOW_WIDTH / 2;
+      hints.max_height = WINDOW_HEIGHT * 2 + WINDOW_HEIGHT / 2;
+#endif
+      hints.win_gravity = gravities[i];
+      
+      XSetWMNormalHints (d, w, &hints);
+
+      XStoreName (d, w, window_gravity_to_string (hints.win_gravity));
+
+      if (noframes)
+        {
+          MotifWmHints mwm;
+          Atom mwm_atom;
+          
+          mwm.decorations = 0;
+          mwm.flags = MWM_HINTS_DECORATIONS;
+          
+          mwm_atom = XInternAtom (d, "_MOTIF_WM_HINTS", False);
+
+          XChangeProperty (d, w, mwm_atom, mwm_atom,
+                           32, PropModeReplace,
+                           (unsigned char *)&mwm,
+                           sizeof (MotifWmHints)/sizeof (long));
+        }
+      
+      XMapWindow (d, w);
+    }
+
+  while (1)
+    {
+      XNextEvent (d, &ev);
+
+      if (ev.xany.type == ConfigureNotify)
+        {
+          i = find_window (ev.xconfigure.window);
+          
+          if (i >= 0)
+            {
+              Window ignored;
+              
+              window_rects[i].width = ev.xconfigure.width;
+              window_rects[i].height = ev.xconfigure.height;
+              
+              XClearArea (d, windows[i], 0, 0,
+                          ev.xconfigure.width,
+                          ev.xconfigure.height,
+                          True);
+
+              if (!ev.xconfigure.send_event)
+                XTranslateCoordinates (d, windows[i], DefaultRootWindow (d),
+                                       0, 0,
+                                       &window_rects[i].x, &window_rects[i].y,
+                                       &ignored);
+              else
+                {
+                  window_rects[i].x = ev.xconfigure.x;
+                  window_rects[i].y = ev.xconfigure.y;
+                }
+            }
+        }
+      else if (ev.xany.type == Expose)
+        {          
+          i = find_window (ev.xexpose.window);
+          
+          if (i >= 0)
+            {
+              GC gc;
+              XGCValues values;
+              char buf[256];
+              
+              values.foreground = BlackPixel (d, screen);
+              
+              gc = XCreateGC (d, windows[i],
+                              GCForeground, &values);
+
+              sprintf (buf,
+                       "%d,%d",
+                       window_rects[i].x,
+                       window_rects[i].y);
+              
+              XDrawString (d, windows[i], gc, 10, 15,
+                           buf, strlen (buf));
+
+              sprintf (buf,
+                       "%dx%d",
+                       window_rects[i].width,
+                       window_rects[i].height);
+              
+              XDrawString (d, windows[i], gc, 10, 35,
+                           buf, strlen (buf));
+              
+              XFreeGC (d, gc);
+            }
+        }
+      else if (ev.xany.type == ButtonPress)
+	{
+          i = find_window (ev.xbutton.window);
+
+          if (i >= 0)
+            {
+              /* Button 1 = move, 2 = resize, 3 = both at once */
+                  
+              if (ev.xbutton.button == Button1) 
+                { 
+                  int x, y;
+		      
+                  calculate_position (i, doubled[i], &x, &y);
+                  XMoveWindow (d, windows[i], x, y); 
+                }
+              else if (ev.xbutton.button == Button2)
+                {
+                  if (doubled[i])
+                    XResizeWindow (d, windows[i], WINDOW_WIDTH, WINDOW_HEIGHT);
+                  else
+                    XResizeWindow (d, windows[i], WINDOW_WIDTH*2, WINDOW_HEIGHT*2);
+
+                  doubled[i] = !doubled[i];
+                }
+              else if (ev.xbutton.button == Button3)
+                {
+                  int x, y;
+		      
+                  calculate_position (i, !doubled[i], &x, &y);
+
+                  if (doubled[i])
+                    XMoveResizeWindow (d, windows[i], x, y, WINDOW_WIDTH, WINDOW_HEIGHT);
+                  else
+                    XMoveResizeWindow (d, windows[i], x, y, WINDOW_WIDTH*2, WINDOW_HEIGHT*2);
+
+                  doubled[i] = !doubled[i];
+                }
+            }
+	}
+    }
+
+  /* This program has an infinite loop above so a return statement would
+   * just cause compiler warnings.
+   */
+}
+
diff --git a/src/wm-tester/test-resizing.c b/src/wm-tester/test-resizing.c
new file mode 100644
index 00000000..f9481004
--- /dev/null
+++ b/src/wm-tester/test-resizing.c
@@ -0,0 +1,257 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdlib.h>
+#include <glib.h>
+
+static void
+calc_rects (XRectangle *rects, int width, int height)
+{
+  int w = (width - 21) / 3;
+  int h = (height - 21) / 3;
+  int i;
+
+  i = 0;
+  while (i < 9)
+    {
+      rects[i].width = w;
+      rects[i].height = h;
+      ++i;
+    }
+  
+  /* NW */
+  rects[0].x = 0;
+  rects[0].y = 0;
+
+  /* N */
+  rects[1].x = width / 2 - w / 2;
+  rects[1].y = 0;
+
+  /* NE */
+  rects[2].x = width - w;
+  rects[2].y = 0;
+
+  /* E */
+  rects[3].x = width - w;
+  rects[3].y = height / 2 - h / 2;
+
+  /* SE */
+  rects[4].x = width - w;
+  rects[4].y = height - h;
+
+  /* S */
+  rects[5].x = width / 2 - w / 2;
+  rects[5].y = height - h;
+
+  /* SW */
+  rects[6].x = 0;
+  rects[6].y = height - h;
+
+  /* W */
+  rects[7].x = 0;
+  rects[7].y = height / 2 - h / 2;
+
+  /* Center */
+  rects[8].x = width / 2 - w / 2;
+  rects[8].y = height / 2 - h / 2;
+}
+
+static Bool
+all_events (Display  *display,
+            XEvent   *event,
+            XPointer  arg)
+{
+  return True;
+}
+
+static void
+get_size (Display *d, Drawable draw,
+          int *xp, int *yp, int *widthp, int *heightp)
+{
+  int x, y;
+  unsigned int width=0, height=0, border=0, depth=0;
+  Window root;
+  
+  XGetGeometry (d, draw, &root, &x, &y, &width, &height, &border, &depth);
+
+  if (xp)
+    *xp = x;
+  if (yp)
+    *yp = y;
+  if (widthp)
+    *widthp = width;
+  if (*heightp)
+    *heightp = height;
+}
+
+int
+main (int argc, char **argv)
+{
+  Display *d;
+  Window w, cw;
+  XSizeHints hints;
+  int screen;
+  XEvent ev;
+  int x, y, width, height;
+  Pixmap pix;
+  GC gc;  
+  XGCValues gc_vals;
+  XSetWindowAttributes set_attrs;
+  XWindowChanges changes;
+  XRectangle rects[9];
+  gboolean redraw_pending;
+  unsigned int mask;
+  
+  d = XOpenDisplay (NULL);
+
+  screen = DefaultScreen (d);
+
+  /* Print some debug spew to show how StaticGravity works */     
+  w = XCreateSimpleWindow (d, RootWindow (d, screen), 
+                           0, 0, 100, 100, 0,
+                           WhitePixel (d, screen),
+                           WhitePixel (d, screen));
+  cw = XCreateSimpleWindow (d, w,
+                            0, 0, 100, 100, 0,
+                            WhitePixel (d, screen),
+                            WhitePixel (d, screen));
+  set_attrs.win_gravity = StaticGravity;
+      
+  XChangeWindowAttributes (d, cw,
+                           CWWinGravity,
+                           &set_attrs);
+  
+  get_size (d, w, &x, &y, &width, &height);
+  
+  g_print ("Parent is %d,%d  %d x %d before configuring parent\n",
+           x, y, width, height);
+  
+  get_size (d, cw, &x, &y, &width, &height);
+
+  g_print ("Child is %d,%d  %d x %d before configuring parent\n",
+           x, y, width, height);
+  
+  changes.x = 10;
+  changes.y = 10;
+  changes.width = 110;
+  changes.height = 110;
+  /* last mask wins */
+  mask = CWX | CWY;
+  mask = CWWidth | CWHeight;
+  mask = CWX | CWY | CWWidth | CWHeight;
+  
+  XConfigureWindow (d, w, mask, &changes);
+  XSync (d, False);
+
+  get_size (d, w, &x, &y, &width, &height);
+
+  g_print ("Parent is %d,%d  %d x %d after configuring parent\n",
+           x, y, width, height);
+  
+  get_size (d, cw, &x, &y, &width, &height);
+
+  g_print ("Child is %d,%d  %d x %d after configuring parent\n",
+           x, y, width, height);  
+
+  XDestroyWindow (d, w);
+  
+  /* The window that gets displayed */
+  
+  x = 20;
+  y = 20;
+  width = 100;
+  height = 100;
+
+  calc_rects (rects, width, height);
+  
+  w = XCreateSimpleWindow (d, RootWindow (d, screen), 
+                           x, y, width, height, 0,
+                           WhitePixel (d, screen),
+                           WhitePixel (d, screen));
+  
+  set_attrs.bit_gravity = StaticGravity;
+      
+  XChangeWindowAttributes (d, w,
+                           CWBitGravity,
+                           &set_attrs);
+  
+  XSelectInput (d, w,
+                ButtonPressMask | ExposureMask | StructureNotifyMask);
+  
+  hints.flags = PMinSize;
+  
+  hints.min_width = 100;
+  hints.min_height = 100;
+  
+  XSetWMNormalHints (d, w, &hints);
+  XMapWindow (d, w);
+
+  redraw_pending = FALSE;
+  while (1)
+    {
+      XNextEvent (d, &ev);
+      
+      switch (ev.xany.type)
+        {
+        case ButtonPress:
+          if (ev.xbutton.button == 3)
+            {
+              g_print ("Exiting on button 3 press\n");
+              exit (0);
+            }
+          break;
+
+        case ConfigureNotify:
+          x = ev.xconfigure.x;
+          y = ev.xconfigure.y;
+          width = ev.xconfigure.width;
+          height = ev.xconfigure.height;
+
+          redraw_pending = TRUE;
+          break;
+          
+        case Expose:
+          redraw_pending = TRUE;
+          break;
+          
+        default:
+          break;
+        }
+
+      /* Primitive event compression */
+      if (XCheckIfEvent (d, &ev, all_events, NULL))
+        {
+          XPutBackEvent (d, &ev);
+        }
+      else if (redraw_pending)
+        {
+          calc_rects (rects, width, height);
+          
+          pix = XCreatePixmap (d, w, width, height,
+                               DefaultDepth (d, screen));
+          
+          gc_vals.foreground = WhitePixel (d, screen);
+          
+          gc = XCreateGC (d, pix, GCForeground, &gc_vals);
+          
+          XFillRectangle (d, pix, gc, 0, 0, width, height);
+              
+          /* Draw rectangles at each gravity point */
+          gc_vals.foreground = BlackPixel (d, screen);
+          XChangeGC (d, gc, GCForeground, &gc_vals);
+          
+          XFillRectangles (d, pix, gc, rects, G_N_ELEMENTS (rects));
+          
+          XCopyArea (d, pix, w, gc, 0, 0, width, height, 0, 0);
+          
+          XFreePixmap (d, pix);
+          XFreeGC (d, gc);
+
+          redraw_pending = FALSE;
+        }
+    }
+
+  /* This program has an infinite loop above so a return statement would
+   * just cause compiler warnings.
+   */
+}
+
diff --git a/src/wm-tester/test-size-hints.c b/src/wm-tester/test-size-hints.c
new file mode 100644
index 00000000..72f1b486
--- /dev/null
+++ b/src/wm-tester/test-size-hints.c
@@ -0,0 +1,136 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdlib.h>
+#include <glib.h>
+
+static Bool
+all_events (Display  *display,
+            XEvent   *event,
+            XPointer  arg)
+{
+  return True;
+}
+
+#if 0
+static void
+get_size (Display *d, Drawable draw,
+          int *xp, int *yp, int *widthp, int *heightp)
+{
+  int x, y;
+  unsigned int width, height, border, depth;
+  Window root;
+  
+  XGetGeometry (d, draw, &root, &x, &y, &width, &height, &border, &depth);
+
+  if (xp)
+    *xp = x;
+  if (yp)
+    *yp = y;
+  if (widthp)
+    *widthp = width;
+  if (*heightp)
+    *heightp = height;
+}
+#endif
+
+int
+main (int argc, char **argv)
+{
+  Display *d;
+  Window zero_min_size;
+  XSizeHints hints;
+  int screen;
+  XEvent ev;
+  int x, y, width, height;
+  Pixmap pix;
+  GC gc;  
+  XGCValues gc_vals;
+  gboolean redraw_pending;
+  
+  d = XOpenDisplay (NULL);
+
+  screen = DefaultScreen (d);
+
+  x = 0;
+  y = 0;
+  width = 100;
+  height = 100;
+  
+  zero_min_size = XCreateSimpleWindow (d, RootWindow (d, screen), 
+                                       x, y, width, height, 0,
+                                       WhitePixel (d, screen),
+                                       WhitePixel (d, screen));  
+  
+  XSelectInput (d, zero_min_size,
+                ButtonPressMask | ExposureMask | StructureNotifyMask);
+  
+  hints.flags = PMinSize;
+  
+  hints.min_width = 0;
+  hints.min_height = 0;
+  
+  XSetWMNormalHints (d, zero_min_size, &hints);
+  XMapWindow (d, zero_min_size);
+
+  redraw_pending = FALSE;
+  while (1)
+    {
+      XNextEvent (d, &ev);
+      
+      switch (ev.xany.type)
+        {
+        case ButtonPress:
+          if (ev.xbutton.button == 1)
+            {
+              g_print ("Exiting on button 1 press\n");
+              exit (0);
+            }
+          break;
+
+        case ConfigureNotify:
+          x = ev.xconfigure.x;
+          y = ev.xconfigure.y;
+          width = ev.xconfigure.width;
+          height = ev.xconfigure.height;
+
+          redraw_pending = TRUE;
+          break;
+          
+        case Expose:
+          redraw_pending = TRUE;
+          break;
+          
+        default:
+          break;
+        }
+
+      /* Primitive event compression */
+      if (XCheckIfEvent (d, &ev, all_events, NULL))
+        {
+          XPutBackEvent (d, &ev);
+        }
+      else if (redraw_pending)
+        {
+          pix = XCreatePixmap (d, zero_min_size, width, height,
+                               DefaultDepth (d, screen));
+          
+          gc_vals.foreground = WhitePixel (d, screen);
+          
+          gc = XCreateGC (d, pix, GCForeground, &gc_vals);
+          
+          XFillRectangle (d, pix, gc, 0, 0, width, height);
+          
+          XCopyArea (d, pix, zero_min_size, gc, 0, 0, width, height, 0, 0);
+          
+          XFreePixmap (d, pix);
+          XFreeGC (d, gc);
+
+          redraw_pending = FALSE;
+        }
+    }
+
+  /* This program has an infinite loop above so a return statement would
+   * just cause compiler warnings.
+   */
+}
+