Bump version to 2.91.6

Add ability to override workspace layout
A plugin that does workspace management on its on may want to set the workspace layout without having to deal with putting a property on the root window to be read back and parsed. Add meta_screen_override_window_layout() that allows the same types of layouts as _NET_DESKTOP_LAYOUT but without setting a property. https://bugzilla.gnome.org/show_bug.cgi?id=640552
2011-02-01 12:25:14 -05:00 · 2011-02-01 11:34:56 -05:00 · 2011-01-29 07:49:59 +05:30 · 2011-01-28 20:36:04 +01:00 · 2011-01-27 03:18:07 +01:00 · 2011-01-26 17:02:17 -05:00
123 changed files with 16424 additions and 14718 deletions
--- a/configure.in
+++ b/configure.in
@@ -2,7 +2,7 @@ AC_PREREQ(2.50)

 m4_define([mutter_major_version], [2])
 m4_define([mutter_minor_version], [91])
-m4_define([mutter_micro_version], [0])
+m4_define([mutter_micro_version], [6])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -61,99 +61,11 @@ AC_CHECK_SIZEOF(__int64)
 ## byte order
 AC_C_BIGENDIAN

-#### Warnings
+GTK_MIN_VERSION=2.91.7
+CANBERRA_GTK=libcanberra-gtk3
+CANBERRA_GTK_VERSION=0.26

-# Stay command-line compatible with the gnome-common configure option. Here
-# minimum/yes/maximum are the same, however.
-AC_ARG_ENABLE(compile_warnings,
-  AS_HELP_STRING([--enable-compile-warnings=@<:@no/minimum/yes/maximum/error@:>@],[Turn on compiler warnings]),,
-  enable_compile_warnings=error)
-
-changequote(,)dnl
-if test "$enable_compile_warnings" != no ; then
-  if test "x$GCC" = "xyes"; then
-    case " $CFLAGS " in
-    *[\ \	]-Wall[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wall" ;;
-    esac
-
-#   case " $CFLAGS " in
-#   *[\ \	]-Wshadow[\ \	]*) ;;
-#   *) CFLAGS="$CFLAGS -Wshadow" ;;
-#   esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wchar-subscripts[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wchar-subscripts" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wmissing-declarations[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wmissing-declarations" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wmissing-prototypes[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wmissing-prototypes" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wnested-externs[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wnested-externs" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wpointer-arith[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wpointer-arith" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wcast-align[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wcast-align" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wsign-compare[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wsign-compare" ;;
-    esac
-
-    if test "$enable_compile_warnings" = error; then
-      case " $CFLAGS " in
-      *[\ \	]-Werror[\ \	]*) ;;
-      *) CFLAGS="$CFLAGS -Werror" ;;
-      esac
-    fi
-  fi
-fi
-changequote([,])dnl
-
-AC_MSG_CHECKING([which gtk+ version to compile against])
-AC_ARG_WITH([gtk],
-  AC_HELP_STRING([--with-gtk=2.0|3.0],
-                 [which gtk+ version to compile against (default: 2)]),
-  [case "$with_gtk" in
-      2.0|3.0) ;;
-      *) AC_MSG_ERROR([invalid gtk+ version specified]);;
-  esac],
-  [with_gtk=2.0])
-AC_MSG_RESULT([$with_gtk])
-
-case "$with_gtk" in
-  2.0) GTK_API_VERSION=2.0
-       GTK_MIN_VERSION=2.18
-       CANBERRA_GTK=libcanberra-gtk
-       ;;
-  3.0) GTK_API_VERSION=3.0
-       GTK_MIN_VERSION=2.90
-       CANBERRA_GTK=libcanberra-gtk3
-       AC_DEFINE(USE_CAIRO_REGION, 1, [Use cairo_region_t instead of GdkRegion])
-       ;;
-esac
-
-AM_CONDITIONAL(INSTALL_LIBMUTTER_PRIVATE, test "$with_gtk" = "3.0")
-
-MUTTER_PC_MODULES="gtk+-$GTK_API_VERSION >= $GTK_MIN_VERSION pango >= 1.2.0"
-AC_SUBST(GTK_API_VERSION)
+MUTTER_PC_MODULES="gtk+-3.0 >= $GTK_MIN_VERSION pango >= 1.2.0 cairo >= 1.10.0"

 AC_ARG_ENABLE(gconf,
  AC_HELP_STRING([--disable-gconf],
@@ -213,8 +125,8 @@ AM_GLIB_GNU_GETTEXT
 # GRegex requires Glib-2.14.0
 PKG_CHECK_MODULES(ALL, glib-2.0 >= 2.14.0)
 # gtk_window_set_icon_name requires gtk2+-2.6.0
-PKG_CHECK_MODULES(MUTTER_MESSAGE, gtk+-$GTK_API_VERSION >= $GTK_MIN_VERSION)
-PKG_CHECK_MODULES(MUTTER_WINDOW_DEMO, gtk+-$GTK_API_VERSION >= $GTK_MIN_VERSION)
+PKG_CHECK_MODULES(MUTTER_MESSAGE, gtk+-3.0 >= $GTK_MIN_VERSION)
+PKG_CHECK_MODULES(MUTTER_WINDOW_DEMO, gtk+-3.0 >= $GTK_MIN_VERSION)

 # Unconditionally use this dir to avoid a circular dep with gnomecc
 GNOME_KEYBINDINGS_KEYSDIR="${datadir}/gnome-control-center/keybindings"
@@ -251,7 +163,7 @@ AC_MSG_CHECKING([libcanberra-gtk])
 if test x$with_libcanberra = xno ; then
  AC_MSG_RESULT([disabled])
 else
-  if $PKG_CONFIG --exists $CANBERRA_GTK; then
+  if $PKG_CONFIG --exists $CANBERRA_GTK '>=' $CANBERRA_GTK_VERSION; then
    have_libcanberra=yes
    AC_MSG_RESULT(yes)
    MUTTER_PC_MODULES="$MUTTER_PC_MODULES $CANBERRA_GTK"
@@ -540,6 +452,72 @@ AM_PATH_PYTHON([2.5])
 # Use gnome-doc-utils:
 GNOME_DOC_INIT([0.8.0])

+#### Warnings (last since -Werror can disturb other tests)
+
+# Stay command-line compatible with the gnome-common configure option. Here
+# minimum/yes/maximum are the same, however.
+AC_ARG_ENABLE(compile_warnings,
+  AS_HELP_STRING([--enable-compile-warnings=@<:@no/minimum/yes/maximum/error@:>@],[Turn on compiler warnings]),,
+  enable_compile_warnings=error)
+
+changequote(,)dnl
+if test "$enable_compile_warnings" != no ; then
+  if test "x$GCC" = "xyes"; then
+    case " $CFLAGS " in
+    *[\ \	]-Wall[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wall" ;;
+    esac
+
+#   case " $CFLAGS " in
+#   *[\ \	]-Wshadow[\ \	]*) ;;
+#   *) CFLAGS="$CFLAGS -Wshadow" ;;
+#   esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wchar-subscripts[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wchar-subscripts" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wmissing-declarations[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wmissing-declarations" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wmissing-prototypes[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wmissing-prototypes" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wnested-externs[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wnested-externs" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wpointer-arith[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wpointer-arith" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wcast-align[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wcast-align" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wsign-compare[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wsign-compare" ;;
+    esac
+
+    if test "$enable_compile_warnings" = error; then
+      case " $CFLAGS " in
+      *[\ \	]-Werror[\ \	]*) ;;
+      *) CFLAGS="$CFLAGS -Werror" ;;
+      esac
+    fi
+  fi
+fi
+changequote([,])dnl
+
 AC_CONFIG_FILES([
 Makefile
 doc/Makefile
@@ -572,7 +550,7 @@ fi

 dnl ==========================================================================
 echo "
-mutter-$VERSION (using gtk+-${GTK_API_VERSION}):
+mutter-$VERSION

 	prefix:                   ${prefix}
 	source code location:	  ${srcdir}
@@ -596,7 +574,7 @@ if expr $MUTTER_MINOR_VERSION % 2 > /dev/null ; then
   stable_version=`expr $MUTTER_MINOR_VERSION - 1`
   echo "This is the UNSTABLE branch of mutter"
   echo -n "Use 2.$stable_version.x for stable "
-   echo    "(gnome-2-$stable_version branch in Subversion)"
+   echo    "(gnome-2-$stable_version branch in git)"
 else
   echo "This is the stable branch of mutter"
 fi
--- a/doc/theme-format.txt
+++ b/doc/theme-format.txt
@@ -22,6 +22,24 @@ This document has separate sections for each format version. You may
 want to read the document in reverse order, since the base features
 are discussed under version 1.

+New Features in Theme Format Version 3.3
+========================================
+
+Add two additional button background functions - left_single_background and
+right_single_background - for button groups with just a single button.
+
+There are now additional frame states to style left/right tiled windows
+differently ("tiled_left", "tiled_right", "tiled_left_and_shaded",
+"tiled_right_and_shaded").
+
+New Features in Theme Format Version 3.2
+========================================
+
+A new window type 'attached' is added for modal dialogs which are
+attached to their parent window. (When the attach_modal_dialogs preference
+is turned on.) If no style is defined for the 'attached' window type,
+the 'border' window type will be used instead.
+
 New Features in Theme Format Version 3.1
 ========================================

--- a/po/LINGUAS
+++ b/po/LINGUAS
@@ -82,6 +82,7 @@ te
 th
 tk
 tr
+ug 
 uk
 vi
 wa
--- a/po/ar.po
+++ b/po/ar.po
--- a/po/bg.po
+++ b/po/bg.po
--- a/po/cs.po
+++ b/po/cs.po
--- a/po/el.po
+++ b/po/el.po
--- a/po/es.po
+++ b/po/es.po
--- a/po/et.po
+++ b/po/et.po
--- a/po/gl.po
+++ b/po/gl.po
--- a/po/he.po
+++ b/po/he.po
--- a/po/hu.po
+++ b/po/hu.po
--- a/po/nb.po
+++ b/po/nb.po
--- a/po/pa.po
+++ b/po/pa.po
--- a/po/sl.po
+++ b/po/sl.po
--- a/po/sv.po
+++ b/po/sv.po
--- a/po/ug.po
+++ b/po/ug.po
--- a/po/vi.po
+++ b/po/vi.po
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
--- a/po/zh_HK.po
+++ b/po/zh_HK.po
--- a/po/zh_TW.po
+++ b/po/zh_TW.po
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,11 +1,7 @@
 # Flag build for parallelism; see https://savannah.gnu.org/patch/?6905
 .AUTOPARALLEL:

-if INSTALL_LIBMUTTER_PRIVATE
 lib_LTLIBRARIES = libmutter-private.la
-else
-noinst_LTLIBRARIES = libmutter-private.la
-endif

 SUBDIRS=wm-tester tools compositor/plugins

@@ -23,35 +19,39 @@ mutter_SOURCES= 				\
 	core/bell.c				\
 	core/bell.h				\
 	core/boxes.c				\
+	core/boxes-private.h			\
 	include/boxes.h				\
+	compositor/cogl-utils.c			\
+	compositor/cogl-utils.h			\
 	compositor/compositor.c			\
 	compositor/compositor-private.h		\
-	compositor/mutter-module.c		\
-	compositor/mutter-module.h		\
-	compositor/mutter-plugin.c		\
-	compositor/mutter-plugin-manager.c	\
-	compositor/mutter-plugin-manager.h	\
-	compositor/mutter-shaped-texture.c	\
-	compositor/mutter-texture-tower.c	\
-	compositor/mutter-texture-tower.h	\
-	compositor/mutter-window.c		\
-	compositor/mutter-window-private.h	\
-	compositor/mutter-window-group.c	\
-	compositor/mutter-window-group.h	\
-	compositor/shadow.c			\
-	compositor/shadow.h			\
-	compositor/mutter-shaped-texture.h	\
-	compositor/tidy/tidy-texture-frame.c	\
-	compositor/tidy/tidy-texture-frame.h	\
-	gdk-compat.h				\
-	gtk-compat.h				\
-	gdk2-drawing-utils.c			\
-	gdk2-drawing-utils.h			\
+	compositor/meta-background-actor.c	\
+	compositor/meta-background-actor.h	\
+	compositor/meta-module.c		\
+	compositor/meta-module.h		\
+	compositor/meta-plugin.c		\
+	compositor/meta-plugin-manager.c	\
+	compositor/meta-plugin-manager.h	\
+	compositor/meta-shadow-factory.c	\
+	compositor/meta-shadow-factory-private.h	\
+	compositor/meta-shaped-texture.c	\
+	compositor/meta-shaped-texture.h	\
+	compositor/meta-texture-tower.c		\
+	compositor/meta-texture-tower.h		\
+	compositor/meta-window-actor.c		\
+	compositor/meta-window-actor-private.h	\
+	compositor/meta-window-group.c		\
+	compositor/meta-window-group.h		\
+	compositor/meta-window-shape.c		\
+	compositor/meta-window-shape.h		\
+	compositor/region-utils.c		\
+	compositor/region-utils.h		\
 	include/compositor.h			\
-	include/mutter-plugin.h			\
-	include/mutter-window.h			\
-	include/region.h			\
+	include/meta-plugin.h			\
+	include/meta-shadow-factory.h		\
+	include/meta-window-actor.h		\
 	include/compositor-mutter.h 		\
+	core/above-tab-keycode.c		\
 	core/constraints.c			\
 	core/constraints.h			\
 	core/core.c				\
@@ -82,7 +82,7 @@ mutter_SOURCES= 				\
 	core/keybindings.c			\
 	core/keybindings-private.h		\
 	core/main.c				\
-	core/mutter-Xatomtype.h		\
+	core/mutter-Xatomtype.h			\
 	core/place.c				\
 	core/place.h				\
 	core/prefs.c				\
@@ -127,9 +127,9 @@ mutter_SOURCES= 				\
 	ui/tile-preview.c			\
 	include/tile-preview.h			\
 	ui/theme-parser.c			\
-	ui/theme-parser.h			\
 	ui/theme.c				\
 	ui/theme.h				\
+	ui/theme-private.h			\
 	ui/ui.c					\
 	include/all-keybindings.h               \
 	$(mutter_built_sources)
@@ -147,11 +147,7 @@ libmutter_private_la_SOURCES=			\
 	include/common.h			\
 	ui/preview-widget.c			\
 	ui/preview-widget.h			\
-	include/region.h			\
-	gdk2-drawing-utils.c			\
-	gdk2-drawing-utils.h			\
 	ui/theme-parser.c			\
-	ui/theme-parser.h			\
 	ui/theme.c				\
 	ui/theme.h

@@ -166,7 +162,6 @@ libmutterinclude_base_headers =		\
 	include/main.h				\
 	include/util.h				\
 	include/common.h			\
-	ui/theme-parser.h			\
 	ui/theme.h				\
 	include/prefs.h				\
 	include/window.h			\
@@ -179,28 +174,22 @@ libmutterinclude_base_headers =		\
 	include/display.h			\
 	include/group.h				\
 	include/keybindings.h			\
-	include/mutter-plugin.h			\
-	include/mutter-window.h
+	include/meta-plugin.h			\
+	include/meta-shadow-factory.h		\
+	include/meta-window-actor.h

 # Excluded from scanning for introspection but installed
 # preview-widget.h: only part of libmutter-private
 # atomnames.h: macros cause problems for scanning process
 libmutterinclude_extra_headers =		\
 	ui/preview-widget.h			\
-	include/atomnames.h			\
-	include/region.h
+	include/atomnames.h

-if INSTALL_LIBMUTTER_PRIVATE
 libmutterincludedir = $(includedir)/mutter/mutter-private

 libmutterinclude_HEADERS =			\
 	$(libmutterinclude_base_headers)	\
 	$(libmutterinclude_extra_headers)
-else
-noinst_HEADERS =				\
-	$(libmutterinclude_base_headers)	\
-	$(libmutterinclude_extra_headers)
-endif

 mutter_theme_viewer_SOURCES=  \
 	ui/theme-viewer.c
@@ -229,13 +218,12 @@ Meta-$(api_version).gir: $(G_IR_SCANNER) mutter $(libmutterinclude_HEADERS) $(mu
 		--nsversion=$(api_version)		\
 		--warn-all				\
 		--warn-error				\
-		--accept-unprefixed			\
 		--include=GObject-2.0			\
-		--include=Gdk-@GTK_API_VERSION@		\
-		--include=Gtk-@GTK_API_VERSION@		\
+		--include=Gdk-3.0			\
+		--include=Gtk-3.0			\
 		--include=Clutter-1.0			\
 		--pkg=clutter-1.0			\
-		--pkg=gtk+-@GTK_API_VERSION@		\
+		--pkg=gtk+-3.0				\
 		--include=xlib-2.0			\
 		--include=xfixes-4.0			\
 		--program=$$pwd/mutter			\
@@ -310,11 +298,9 @@ CLEANFILES =					\
 inlinepixbufs.h: $(IMAGES)
 	$(GDK_PIXBUF_CSOURCE) --raw --build-list $(VARIABLES) >$(srcdir)/inlinepixbufs.h

-if INSTALL_LIBMUTTER_PRIVATE
 pkgconfigdir = $(libdir)/pkgconfig

 pkgconfig_DATA = libmutter-private.pc mutter-plugins.pc
-endif

 EXTRA_DIST=$(desktopfiles_files) 	\
 	$(wmproperties_files)		\
--- a/src/compositor/cogl-utils.c
+++ b/src/compositor/cogl-utils.c
@@ -0,0 +1,104 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * Utilities for use with Cogl
+ *
+ * Copyright 2010 Red Hat, Inc.
+ * Copyright 2010 Intel Corporation
+ *
+ * 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 "cogl-utils.h"
+
+/**
+ * meta_create_color_texture_4ub:
+ * @red:
+ * @green:
+ * @blue:
+ * @alpha:
+ *
+ * Creates a texture that is a single pixel with the specified
+ * unpremultiplied color components.
+ *
+ * Return value: (transfer full): a newly created Cogl texture
+ */
+CoglHandle
+meta_create_color_texture_4ub (guint8 red,
+                               guint8 green,
+                               guint8 blue,
+                               guint8 alpha)
+{
+  CoglColor color;
+  guint8 pixel[4];
+
+  cogl_color_set_from_4ub (&color, red, green, blue, alpha);
+  cogl_color_premultiply (&color);
+
+  pixel[0] = cogl_color_get_red_byte (&color);
+  pixel[1] = cogl_color_get_green_byte (&color);
+  pixel[2] = cogl_color_get_blue_byte (&color);
+  pixel[3] = cogl_color_get_alpha_byte (&color);
+
+  return cogl_texture_new_from_data (1, 1,
+                                     COGL_TEXTURE_NONE,
+                                     COGL_PIXEL_FORMAT_RGBA_8888_PRE,
+                                     COGL_PIXEL_FORMAT_ANY,
+                                     4, pixel);
+}
+
+
+/* Based on gnome-shell/src/st/st-private.c:_st_create_texture_material.c */
+
+/**
+ * meta_create_texture_material:
+ * @src_texture: (allow-none): texture to use initially for the layer
+ *
+ * Creates a material with a single layer. Using a common template
+ * allows sharing a shader for different uses in Mutter. To share the same
+ * shader with all other materials that are just texture plus opacity
+ * would require Cogl fixes.
+ * (See http://bugzilla.clutter-project.org/show_bug.cgi?id=2425)
+ *
+ * Return value: (transfer full): a newly created Cogl material
+ */
+CoglHandle
+meta_create_texture_material (CoglHandle src_texture)
+{
+  static CoglHandle texture_material_template = COGL_INVALID_HANDLE;
+  CoglHandle material;
+
+  /* We use a material that has a dummy texture as a base for all
+     texture materials. The idea is that only the Cogl texture object
+     would be different in the children so it is likely that Cogl will
+     be able to share GL programs between all the textures. */
+  if (G_UNLIKELY (texture_material_template == COGL_INVALID_HANDLE))
+    {
+      CoglHandle dummy_texture;
+
+      dummy_texture = meta_create_color_texture_4ub (0xff, 0xff, 0xff, 0xff);
+
+      texture_material_template = cogl_material_new ();
+      cogl_material_set_layer (texture_material_template, 0, dummy_texture);
+      cogl_handle_unref (dummy_texture);
+    }
+
+  material = cogl_material_copy (texture_material_template);
+
+  if (src_texture != COGL_INVALID_HANDLE)
+    cogl_material_set_layer (material, 0, src_texture);
+
+  return material;
+}
--- a/src/compositor/cogl-utils.h
+++ b/src/compositor/cogl-utils.h
@@ -1,10 +1,9 @@
 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity theme parsing */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * 
+/*
+ * Utilities for use with Cogl
+ *
+ * Copyright 2010 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
@@ -14,19 +13,22 @@
 * 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_COGL_UTILS_H__
+#define __META_COGL_UTILS_H__

-#ifndef META_THEME_PARSER_H
-#define META_THEME_PARSER_H
+#include <cogl/cogl.h>

-MetaTheme* meta_theme_load (const char *theme_name,
-                            GError    **err);
+CoglHandle meta_create_color_texture_4ub (guint8     red,
+                                          guint8     green,
+                                          guint8     blue,
+                                          guint8     alpha);
+CoglHandle meta_create_texture_material  (CoglHandle src_texture);

-#endif
+#endif /* __META_COGL_UTILS_H__ */
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -7,7 +7,7 @@

 #include "compositor.h"
 #include "display.h"
-#include "mutter-plugin-manager.h"
+#include "meta-plugin-manager.h"
 #include <clutter/clutter.h>

 typedef struct _MetaCompScreen MetaCompScreen;
@@ -23,7 +23,7 @@ struct _MetaCompositor

  ClutterActor   *shadow_src;

-  MutterPlugin   *modal_plugin;
+  MetaPlugin     *modal_plugin;

  gboolean        show_redraw : 1;
  gboolean        debug       : 1;
@@ -35,6 +35,7 @@ struct _MetaCompScreen
  MetaScreen            *screen;

  ClutterActor          *stage, *window_group, *overlay_group;
+  ClutterActor          *background_actor;
  ClutterActor		*hidden_group;
  GList                 *windows;
  GHashTable            *windows_by_xid;
@@ -45,24 +46,24 @@ struct _MetaCompScreen

  gint                   switch_workspace_in_progress;

-  MutterPluginManager *plugin_mgr;
+  MetaPluginManager *plugin_mgr;
 };

-void mutter_switch_workspace_completed (MetaScreen    *screen);
-void mutter_set_stage_input_region     (MetaScreen    *screen,
-                                        XserverRegion  region);
-void mutter_empty_stage_input_region   (MetaScreen    *screen);
+void meta_switch_workspace_completed (MetaScreen    *screen);
+void meta_set_stage_input_region     (MetaScreen    *screen,
+                                      XserverRegion  region);
+void meta_empty_stage_input_region   (MetaScreen    *screen);

-gboolean mutter_begin_modal_for_plugin (MetaScreen       *screen,
-                                        MutterPlugin     *plugin,
-                                        Window            grab_window,
-                                        Cursor            cursor,
-                                        MetaModalOptions  options,
-                                        guint32           timestamp);
-void     mutter_end_modal_for_plugin   (MetaScreen       *screen,
-                                        MutterPlugin     *plugin,
-                                        guint32           timestamp);
+gboolean meta_begin_modal_for_plugin (MetaScreen       *screen,
+                                      MetaPlugin       *plugin,
+                                      Window            grab_window,
+                                      Cursor            cursor,
+                                      MetaModalOptions  options,
+                                      guint32           timestamp);
+void     meta_end_modal_for_plugin   (MetaScreen       *screen,
+                                      MetaPlugin       *plugin,
+                                      guint32           timestamp);

-void mutter_check_end_modal (MetaScreen *screen);
+void meta_check_end_modal (MetaScreen *screen);

 #endif /* META_COMPOSITOR_PRIVATE_H */
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -11,8 +11,10 @@
 #include "compositor-mutter.h"
 #include "xprops.h"
 #include "prefs.h"
-#include "mutter-window-private.h"
-#include "mutter-window-group.h"
+#include "meta-shadow-factory.h"
+#include "meta-window-actor-private.h"
+#include "meta-window-group.h"
+#include "meta-background-actor.h"
 #include "../core/window-private.h" /* to check window->hidden */
 #include "../core/display-private.h" /* for meta_display_lookup_x_window() */
 #include <X11/extensions/shape.h>
@@ -33,28 +35,28 @@ composite_at_least_version (MetaDisplay *display, int maj, int min)
  return (major > maj || (major == maj && minor >= min));
 }

-static void sync_actor_stacking (GList *windows);
+static void sync_actor_stacking (MetaCompScreen *info);

 static void
-mutter_finish_workspace_switch (MetaCompScreen *info)
+meta_finish_workspace_switch (MetaCompScreen *info)
 {
  GList *l;

  /* Finish hiding and showing actors for the new workspace */
  for (l = info->windows; l; l = l->next)
-    mutter_window_sync_visibility (l->data);
+    meta_window_actor_sync_visibility (l->data);

  /*
   * Fix up stacking order in case the plugin messed it up.
   */
-  sync_actor_stacking (info->windows);
+  sync_actor_stacking (info);

 /*   printf ("... FINISHED DESKTOP SWITCH\n"); */

 }

 void
-mutter_switch_workspace_completed (MetaScreen *screen)
+meta_switch_workspace_completed (MetaScreen *screen)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);

@@ -67,7 +69,7 @@ mutter_switch_workspace_completed (MetaScreen *screen)
    }

  if (!info->switch_workspace_in_progress)
-    mutter_finish_workspace_switch (info);
+    meta_finish_workspace_switch (info);
 }

 void
@@ -84,9 +86,9 @@ add_win (MetaWindow *window)

  g_return_if_fail (info != NULL);

-  mutter_window_new (window);
+  meta_window_actor_new (window);

-  sync_actor_stacking (info->windows);
+  sync_actor_stacking (info);
 }

 static void
@@ -94,16 +96,16 @@ process_damage (MetaCompositor     *compositor,
                XDamageNotifyEvent *event,
                MetaWindow         *window)
 {
-  MutterWindow *cw;
+  MetaWindowActor *window_actor;

  if (window == NULL)
    return;

-  cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
-  if (cw == NULL)
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (window_actor == NULL)
    return;

-  mutter_window_process_damage (cw, event);
+  meta_window_actor_process_damage (window_actor, event);
 }

 #ifdef HAVE_SHAPE
@@ -112,18 +114,18 @@ process_shape (MetaCompositor *compositor,
               XShapeEvent    *event,
               MetaWindow     *window)
 {
-  MutterWindow *cw;
+  MetaWindowActor *window_actor;

  if (window == NULL)
    return;

-  cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
-  if (cw == NULL)
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (window_actor == NULL)
    return;

  if (event->kind == ShapeBounding)
    {
-      mutter_window_update_shape (cw, event->shaped);
+      meta_window_actor_update_shape (window_actor, event->shaped);
    }
 }
 #endif
@@ -133,19 +135,35 @@ process_property_notify (MetaCompositor	*compositor,
                         XPropertyEvent *event,
                         MetaWindow     *window)
 {
-  MutterWindow *cw;
+  MetaWindowActor *window_actor;
+
+  if (event->atom == compositor->atom_x_root_pixmap)
+    {
+      GSList *l;
+
+      for (l = meta_display_get_screens (compositor->display); l; l = l->next)
+        {
+	  MetaScreen  *screen = l->data;
+          if (event->window == meta_screen_get_xroot (screen))
+            {
+              MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+              meta_background_actor_update (META_BACKGROUND_ACTOR (info->background_actor));
+              return;
+            }
+        }
+    }

  if (window == NULL)
    return;

-  cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
-  if (cw == NULL)
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (window_actor == NULL)
    return;

  /* Check for the opacity changing */
  if (event->atom == compositor->atom_net_wm_window_opacity)
    {
-      mutter_window_update_opacity (cw);
+      meta_window_actor_update_opacity (window_actor);
      DEBUG_TRACE ("process_property_notify: net_wm_window_opacity\n");
      return;
    }
@@ -185,13 +203,13 @@ get_output_window (MetaScreen *screen)
 }

 /**
- * mutter_get_stage_for_screen:
+ * meta_get_stage_for_screen:
 * @screen: a #MetaScreen
 *
 * Returns: (transfer none): The #ClutterStage for the screen
 */
 ClutterActor *
-mutter_get_stage_for_screen (MetaScreen *screen)
+meta_get_stage_for_screen (MetaScreen *screen)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);

@@ -202,13 +220,13 @@ mutter_get_stage_for_screen (MetaScreen *screen)
 }

 /**
- * mutter_get_overlay_group_for_screen:
+ * meta_get_overlay_group_for_screen:
 * @screen: a #MetaScreen
 *
 * Returns: (transfer none): The overlay group corresponding to @screen
 */
 ClutterActor *
-mutter_get_overlay_group_for_screen (MetaScreen *screen)
+meta_get_overlay_group_for_screen (MetaScreen *screen)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);

@@ -219,13 +237,13 @@ mutter_get_overlay_group_for_screen (MetaScreen *screen)
 }

 /**
- * mutter_get_window_group_for_screen:
+ * meta_get_window_group_for_screen:
 * @screen: a #MetaScreen
 *
 * Returns: (transfer none): The window group corresponding to @screen
 */
 ClutterActor *
-mutter_get_window_group_for_screen (MetaScreen *screen)
+meta_get_window_group_for_screen (MetaScreen *screen)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);

@@ -236,13 +254,34 @@ mutter_get_window_group_for_screen (MetaScreen *screen)
 }

 /**
- * mutter_get_windows:
+ * meta_get_background_actor_for_screen:
 * @screen: a #MetaScreen
 *
- * Returns: (transfer none) (element-type Clutter.Actor): The windows on @screen
+ * Gets the actor that draws the root window background under the windows.
+ * The root window background automatically tracks the image or color set
+ * by the environment.
+ *
+ * Returns: (transfer none): The background actor corresponding to @screen
+ */
+ClutterActor *
+meta_get_background_actor_for_screen (MetaScreen *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (!info)
+    return NULL;
+
+  return info->background_actor;
+}
+
+/**
+ * meta_get_window_actors:
+ * @screen: a #MetaScreen
+ *
+ * Returns: (transfer none) (element-type Clutter.Actor): The set of #MetaWindowActor on @screen
 */
 GList *
-mutter_get_windows (MetaScreen *screen)
+meta_get_window_actors (MetaScreen *screen)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);

@@ -253,7 +292,7 @@ mutter_get_windows (MetaScreen *screen)
 }

 static void
-do_set_stage_input_region (MetaScreen *screen,
+do_set_stage_input_region (MetaScreen   *screen,
                           XserverRegion region)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
@@ -266,8 +305,8 @@ do_set_stage_input_region (MetaScreen *screen,
 }

 void
-mutter_set_stage_input_region (MetaScreen *screen,
-                               XserverRegion region)
+meta_set_stage_input_region (MetaScreen   *screen,
+                             XserverRegion region)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
  MetaDisplay  *display = meta_screen_get_display (screen);
@@ -295,7 +334,7 @@ mutter_set_stage_input_region (MetaScreen *screen,
 }

 void
-mutter_empty_stage_input_region (MetaScreen *screen)
+meta_empty_stage_input_region (MetaScreen *screen)
 {
  /* Using a static region here is a bit hacky, but Metacity never opens more than
   * one XDisplay, so it works fine. */
@@ -308,16 +347,16 @@ mutter_empty_stage_input_region (MetaScreen *screen)
      region = XFixesCreateRegion (xdpy, NULL, 0);
    }

-  mutter_set_stage_input_region (screen, region);
+  meta_set_stage_input_region (screen, region);
 }

 gboolean
-mutter_begin_modal_for_plugin (MetaScreen       *screen,
-                               MutterPlugin     *plugin,
-                               Window            grab_window,
-                               Cursor            cursor,
-                               MetaModalOptions  options,
-                               guint32           timestamp)
+meta_begin_modal_for_plugin (MetaScreen       *screen,
+                             MetaPlugin       *plugin,
+                             Window            grab_window,
+                             Cursor            cursor,
+                             MetaModalOptions  options,
+                             guint32           timestamp)
 {
  /* To some extent this duplicates code in meta_display_begin_grab_op(), but there
   * are significant differences in how we handle grabs that make it difficult to
@@ -382,9 +421,9 @@ mutter_begin_modal_for_plugin (MetaScreen       *screen,
 }

 void
-mutter_end_modal_for_plugin (MetaScreen       *screen,
-                             MutterPlugin     *plugin,
-                             guint32           timestamp)
+meta_end_modal_for_plugin (MetaScreen     *screen,
+                           MetaPlugin     *plugin,
+                           guint32         timestamp)
 {
  MetaDisplay    *display    = meta_screen_get_display (screen);
  Display        *xdpy = meta_display_get_xdisplay (display);
@@ -408,15 +447,15 @@ mutter_end_modal_for_plugin (MetaScreen       *screen,
 * a left-over modal grab for this screen.
 */
 void
-mutter_check_end_modal (MetaScreen *screen)
+meta_check_end_modal (MetaScreen *screen)
 {
  MetaDisplay    *display    = meta_screen_get_display (screen);
  MetaCompositor *compositor = display->compositor;

  if (compositor->modal_plugin &&
-      mutter_plugin_get_screen (compositor->modal_plugin) == screen)
+      meta_plugin_get_screen (compositor->modal_plugin) == screen)
    {
-      mutter_end_modal_for_plugin (screen,
+      meta_end_modal_for_plugin (screen,
                                   compositor->modal_plugin,
                                   CurrentTime);
    }
@@ -444,7 +483,7 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
  XCompositeRedirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
  XSync (xdisplay, FALSE);

-  if (meta_error_trap_pop_with_return (display, FALSE))
+  if (meta_error_trap_pop_with_return (display))
    {
      g_warning ("Another compositing manager is running on screen %i",
                 screen_number);
@@ -492,10 +531,15 @@ meta_compositor_manage_screen (MetaCompositor *compositor,

  XSelectInput (xdisplay, xwin, event_mask);

-  info->window_group = mutter_window_group_new (screen);
+  info->window_group = meta_window_group_new (screen);
+  info->background_actor = meta_background_actor_new (screen);
  info->overlay_group = clutter_group_new ();
  info->hidden_group = clutter_group_new ();

+  clutter_container_add (CLUTTER_CONTAINER (info->window_group),
+                         info->background_actor,
+                         NULL);
+
  clutter_container_add (CLUTTER_CONTAINER (info->stage),
                         info->window_group,
                         info->overlay_group,
@@ -505,18 +549,18 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
  clutter_actor_hide (info->hidden_group);

  info->plugin_mgr =
-    mutter_plugin_manager_get (screen);
+    meta_plugin_manager_get (screen);

-  if (info->plugin_mgr != mutter_plugin_manager_get_default ())
+  if (info->plugin_mgr != meta_plugin_manager_get_default ())
    {
      /* The default plugin manager has been initialized during
       * global preferences load.
       */
-      if (!mutter_plugin_manager_load (info->plugin_mgr))
+      if (!meta_plugin_manager_load (info->plugin_mgr))
        g_critical ("failed to load plugins");
    }

-  if (!mutter_plugin_manager_initialize (info->plugin_mgr))
+  if (!meta_plugin_manager_initialize (info->plugin_mgr))
    g_critical ("failed to initialize plugins");

  /*
@@ -568,21 +612,21 @@ meta_compositor_add_window (MetaCompositor    *compositor,

  add_win (window);

-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 void
 meta_compositor_remove_window (MetaCompositor *compositor,
                               MetaWindow     *window)
 {
-  MutterWindow         *cw     = NULL;
+  MetaWindowActor         *window_actor     = NULL;

  DEBUG_TRACE ("meta_compositor_remove_window\n");
-  cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
-  if (!cw)
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (!window_actor)
    return;

-  mutter_window_destroy (cw);
+  meta_window_actor_destroy (window_actor);
 }

 void
@@ -620,7 +664,7 @@ meta_compositor_process_event (MetaCompositor *compositor,
 {
  if (compositor->modal_plugin && is_grabbed_event (event))
    {
-      MutterPluginClass *klass = MUTTER_PLUGIN_GET_CLASS (compositor->modal_plugin);
+      MetaPluginClass *klass = META_PLUGIN_GET_CLASS (compositor->modal_plugin);

      if (klass->xevent_filter)
        klass->xevent_filter (compositor->modal_plugin, event);
@@ -638,7 +682,7 @@ meta_compositor_process_event (MetaCompositor *compositor,
      screen = meta_window_get_screen (window);
      info = meta_screen_get_compositor_data (screen);

-      if (mutter_plugin_manager_xevent_filter (info->plugin_mgr, event))
+      if (meta_plugin_manager_xevent_filter (info->plugin_mgr, event))
 	{
 	  DEBUG_TRACE ("meta_compositor_process_event (filtered,window==NULL)\n");
 	  return TRUE;
@@ -657,7 +701,7 @@ meta_compositor_process_event (MetaCompositor *compositor,

 	  info = meta_screen_get_compositor_data (screen);

-	  if (mutter_plugin_manager_xevent_filter (info->plugin_mgr, event))
+	  if (meta_plugin_manager_xevent_filter (info->plugin_mgr, event))
 	    {
 	      DEBUG_TRACE ("meta_compositor_process_event (filtered,window==NULL)\n");
 	      return TRUE;
@@ -715,12 +759,12 @@ meta_compositor_show_window (MetaCompositor *compositor,
 			     MetaWindow	    *window,
                             MetaCompEffect  effect)
 {
-  MutterWindow *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  DEBUG_TRACE ("meta_compositor_show_window\n");
-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_show (cw, effect);
+  meta_window_actor_show (window_actor, effect);
 }

 void
@@ -728,12 +772,12 @@ meta_compositor_hide_window (MetaCompositor *compositor,
                             MetaWindow     *window,
                             MetaCompEffect  effect)
 {
-  MutterWindow *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  DEBUG_TRACE ("meta_compositor_hide_window\n");
-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_hide (cw, effect);
+  meta_window_actor_hide (window_actor, effect);
 }

 void
@@ -742,12 +786,12 @@ meta_compositor_maximize_window (MetaCompositor    *compositor,
 				 MetaRectangle	   *old_rect,
 				 MetaRectangle	   *new_rect)
 {
-  MutterWindow	 *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  DEBUG_TRACE ("meta_compositor_maximize_window\n");
-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_maximize (cw, old_rect, new_rect);
+  meta_window_actor_maximize (window_actor, old_rect, new_rect);
 }

 void
@@ -756,12 +800,12 @@ meta_compositor_unmaximize_window (MetaCompositor    *compositor,
 				   MetaRectangle     *old_rect,
 				   MetaRectangle     *new_rect)
 {
-  MutterWindow	 *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  DEBUG_TRACE ("meta_compositor_unmaximize_window\n");
-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_unmaximize (cw, old_rect, new_rect);
+  meta_window_actor_unmaximize (window_actor, old_rect, new_rect);
 }

 void
@@ -774,7 +818,7 @@ meta_compositor_update_workspace_geometry (MetaCompositor *compositor,
   */
  MetaScreen     *screen = meta_workspace_get_screen (workspace);
  MetaCompScreen *info;
-  MutterPluginManager *mgr;
+  MetaPluginManager *mgr;

  DEBUG_TRACE ("meta_compositor_update_workspace_geometry\n");
  info = meta_screen_get_compositor_data (screen);
@@ -783,7 +827,7 @@ meta_compositor_update_workspace_geometry (MetaCompositor *compositor,
  if (!mgr || !workspace)
    return;

-  mutter_plugin_manager_update_workspace (mgr, workspace);
+  meta_plugin_manager_update_workspace (mgr, workspace);
 #endif
 }

@@ -809,7 +853,7 @@ meta_compositor_switch_workspace (MetaCompositor     *compositor,
  info->switch_workspace_in_progress++;

  if (!info->plugin_mgr ||
-      !mutter_plugin_manager_switch_workspace (info->plugin_mgr,
+      !meta_plugin_manager_switch_workspace (info->plugin_mgr,
 					       from_indx,
 					       to_indx,
 					       direction))
@@ -821,23 +865,78 @@ meta_compositor_switch_workspace (MetaCompositor     *compositor,
       * necessarily change during the window hiding/unhiding, only their
       * relative position toward the destkop window.
       */
-      mutter_finish_workspace_switch (info);
+      meta_finish_workspace_switch (info);
    }
 }

 static void
-sync_actor_stacking (GList *windows)
+sync_actor_stacking (MetaCompScreen *info)
 {
+  GList *children;
  GList *tmp;
+  GList *old;
+  gboolean reordered;

-  /* NB: The first entry in the list is stacked the lowest */
+  /* NB: The first entries in the lists are stacked the lowest */

-  for (tmp = g_list_last (windows); tmp != NULL; tmp = tmp->prev)
+  /* Restacking will trigger full screen redraws, so it's worth a
+   * little effort to make sure we actually need to restack before
+   * we go ahead and do it */
+
+  children = clutter_container_get_children (CLUTTER_CONTAINER (info->window_group));
+  reordered = FALSE;
+
+  old = children;
+
+  /* We allow for actors in the window group other than the actors we
+   * know about, but it's up to a plugin to try and keep them stacked correctly
+   * (we really need extra API to make that reliable.)
+   */
+
+  /* Of the actors we know, the bottom actor should be the background actor */
+
+  while (old && old->data != info->background_actor && !META_IS_WINDOW_ACTOR (old->data))
+    old = old->next;
+  if (old == NULL || old->data != info->background_actor)
    {
-      MutterWindow *cw = tmp->data;
-
-      clutter_actor_lower_bottom (CLUTTER_ACTOR (cw));
+      reordered = TRUE;
+      goto done_with_check;
    }
+
+  /* Then the window actors should follow in sequence */
+
+  old = old->next;
+  for (tmp = info->windows; tmp != NULL; tmp = tmp->next)
+    {
+      while (old && !META_IS_WINDOW_ACTOR (old->data))
+        old = old->next;
+
+      /* old == NULL: someone reparented a window out of the window group,
+       * order undefined, always restack */
+      if (old == NULL || old->data != tmp->data)
+        {
+          reordered = TRUE;
+          goto done_with_check;
+        }
+
+      old = old->next;
+    }
+
+ done_with_check:
+
+  g_list_free (children);
+
+  if (!reordered)
+    return;
+
+  for (tmp = g_list_last (info->windows); tmp != NULL; tmp = tmp->prev)
+    {
+      MetaWindowActor *window_actor = tmp->data;
+
+      clutter_actor_lower_bottom (CLUTTER_ACTOR (window_actor));
+    }
+
+  clutter_actor_lower_bottom (info->background_actor);
 }

 void
@@ -858,12 +957,12 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,

  /* Sources: first window is the highest */
  stack = g_list_copy (stack); /* The new stack of MetaWindow */
-  old_stack = g_list_reverse (info->windows); /* The old stack of MutterWindow */
+  old_stack = g_list_reverse (info->windows); /* The old stack of MetaWindowActor */
  info->windows = NULL;

  while (TRUE)
    {
-      MutterWindow *old_actor = NULL, *stack_actor = NULL, *actor;
+      MetaWindowActor *old_actor = NULL, *stack_actor = NULL, *actor;
      MetaWindow *old_window = NULL, *stack_window = NULL, *window;

      /* Find the remaining top actor in our existing stack (ignoring
@@ -871,11 +970,14 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
      while (old_stack)
        {
          old_actor = old_stack->data;
-          old_window = mutter_window_get_meta_window (old_actor);
+          old_window = meta_window_actor_get_meta_window (old_actor);

          if (old_window->hidden &&
-              !mutter_window_effect_in_progress (old_actor))
-            old_stack = g_list_delete_link (old_stack, old_stack);
+              !meta_window_actor_effect_in_progress (old_actor))
+            {
+              old_stack = g_list_delete_link (old_stack, old_stack);
+              old_actor = NULL;
+            }
          else
            break;
        }
@@ -884,10 +986,10 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
      while (stack)
        {
          stack_window = stack->data;
-          stack_actor = MUTTER_WINDOW (meta_window_get_compositor_private (stack_window));
+          stack_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (stack_window));
          if (!stack_actor)
            {
-              meta_verbose ("Failed to find corresponding MutterWindow "
+              meta_verbose ("Failed to find corresponding MetaWindowActor "
                            "for window %s\n", meta_window_get_description (stack_window));
              stack = g_list_delete_link (stack, stack);
            }
@@ -926,48 +1028,48 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
      old_stack = g_list_remove (old_stack, actor);
    }

-  sync_actor_stacking (info->windows);
+  sync_actor_stacking (info);
 }

 void
 meta_compositor_window_mapped (MetaCompositor *compositor,
                               MetaWindow     *window)
 {
-  MutterWindow *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  DEBUG_TRACE ("meta_compositor_window_mapped\n");
-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_mapped (cw);
+  meta_window_actor_mapped (window_actor);
 }

 void
 meta_compositor_window_unmapped (MetaCompositor *compositor,
                                 MetaWindow     *window)
 {
-  MutterWindow *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  DEBUG_TRACE ("meta_compositor_window_unmapped\n");
-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_unmapped (cw);
+  meta_window_actor_unmapped (window_actor);
 }

 void
 meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window)
 {
-  MutterWindow	 *cw = MUTTER_WINDOW (meta_window_get_compositor_private (window));
-  MetaScreen	 *screen = meta_window_get_screen (window);
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  MetaScreen      *screen = meta_window_get_screen (window);
+  MetaCompScreen  *info = meta_screen_get_compositor_data (screen);

  DEBUG_TRACE ("meta_compositor_sync_window_geometry\n");
  g_return_if_fail (info);

-  if (!cw)
+  if (!window_actor)
    return;

-  mutter_window_sync_actor_position (cw);
+  meta_window_actor_sync_actor_position (window_actor);
 }

 void
@@ -983,6 +1085,8 @@ meta_compositor_sync_screen_size (MetaCompositor  *compositor,

  clutter_actor_set_size (info->stage, width, height);

+  meta_background_actor_screen_size_changed (META_BACKGROUND_ACTOR (info->background_actor));
+
  meta_verbose ("Changed size for stage on screen %d to %dx%d\n",
 		meta_screen_get_screen_number (screen),
 		width, height);
@@ -994,11 +1098,11 @@ pre_paint_windows (MetaCompScreen *info)
  GList *l;

  for (l = info->windows; l; l = l->next)
-    mutter_window_pre_paint (l->data);
+    meta_window_actor_pre_paint (l->data);
 }

 static gboolean
-mutter_repaint_func (gpointer data)
+meta_repaint_func (gpointer data)
 {
  MetaCompositor *compositor = data;
  GSList *screens = meta_display_get_screens (compositor->display);
@@ -1017,6 +1121,26 @@ mutter_repaint_func (gpointer data)
  return TRUE;
 }

+static void
+on_shadow_factory_changed (MetaShadowFactory *factory,
+                           MetaCompositor    *compositor)
+{
+  GSList *screens = meta_display_get_screens (compositor->display);
+  GList *l;
+  GSList *sl;
+
+  for (sl = screens; sl; sl = sl->next)
+    {
+      MetaScreen *screen = sl->data;
+      MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+      if (!info)
+        continue;
+
+      for (l = info->windows; l; l = l->next)
+        meta_window_actor_invalidate_shadow (l->data);
+    }
+}
+
 /**
 * meta_compositor_new: (skip)
 *
@@ -1040,18 +1164,23 @@ meta_compositor_new (MetaDisplay *display)

  compositor->display = display;

-  if (g_getenv("MUTTER_DISABLE_MIPMAPS"))
+  if (g_getenv("META_DISABLE_MIPMAPS"))
    compositor->no_mipmaps = TRUE;

  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
  XInternAtoms (xdisplay, atom_names, G_N_ELEMENTS (atom_names),
                False, atoms);

+  g_signal_connect (meta_shadow_factory_get_default (),
+                    "changed",
+                    G_CALLBACK (on_shadow_factory_changed),
+                    compositor);
+
  compositor->atom_x_root_pixmap = atoms[0];
  compositor->atom_x_set_root = atoms[1];
  compositor->atom_net_wm_window_opacity = atoms[2];

-  compositor->repaint_func_id = clutter_threads_add_repaint_func (mutter_repaint_func,
+  compositor->repaint_func_id = clutter_threads_add_repaint_func (meta_repaint_func,
                                                                  compositor,
                                                                  NULL);

@@ -1059,11 +1188,11 @@ meta_compositor_new (MetaDisplay *display)
 }

 /**
- * mutter_get_overlay_window: (skip)
+ * meta_get_overlay_window: (skip)
 *
 */
 Window
-mutter_get_overlay_window (MetaScreen *screen)
+meta_get_overlay_window (MetaScreen *screen)
 {
  MetaCompScreen *info = meta_screen_get_compositor_data (screen);

--- a/src/compositor/meta-background-actor.c
+++ b/src/compositor/meta-background-actor.c
@@ -0,0 +1,414 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * meta-background-actor.c: Actor for painting the root window background
+ *
+ * Copyright 2009 Sander Dijkhuis
+ * Copyright 2010 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.
+ *
+ * Portions adapted from gnome-shell/src/shell-global.c
+ */
+
+#include <config.h>
+
+#define COGL_ENABLE_EXPERIMENTAL_API
+#include <cogl/cogl-texture-pixmap-x11.h>
+
+#include <X11/Xatom.h>
+
+#include "cogl-utils.h"
+#include "compositor-private.h"
+#include "errors.h"
+#include "meta-background-actor.h"
+
+struct _MetaBackgroundActorClass
+{
+  ClutterActorClass parent_class;
+};
+
+struct _MetaBackgroundActor
+{
+  ClutterActor parent;
+
+  CoglHandle material;
+  MetaScreen *screen;
+  cairo_region_t *visible_region;
+  float texture_width;
+  float texture_height;
+
+  guint have_pixmap : 1;
+};
+
+G_DEFINE_TYPE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR);
+
+static void
+update_wrap_mode (MetaBackgroundActor *self)
+{
+  int width, height;
+  CoglMaterialWrapMode wrap_mode;
+
+  meta_screen_get_size (self->screen, &width, &height);
+
+  /* We turn off repeating when we have a full-screen pixmap to keep from
+   * getting artifacts from one side of the image sneaking into the other
+   * side of the image via bilinear filtering.
+   */
+  if (width == self->texture_width && height == self->texture_height)
+    wrap_mode = COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE;
+  else
+    wrap_mode = COGL_MATERIAL_WRAP_MODE_REPEAT;
+
+  cogl_material_set_layer_wrap_mode (self->material, 0, wrap_mode);
+}
+
+static void
+set_texture (MetaBackgroundActor *self,
+             CoglHandle           texture)
+{
+  MetaDisplay *display;
+
+  display = meta_screen_get_display (self->screen);
+
+  /* This may trigger destruction of an old texture pixmap, which, if
+   * the underlying X pixmap is already gone has the tendency to trigger
+   * X errors inside DRI. For safety, trap errors */
+  meta_error_trap_push (display);
+  cogl_material_set_layer (self->material, 0, texture);
+  meta_error_trap_pop (display);
+
+  self->texture_width = cogl_texture_get_width (texture);
+  self->texture_height = cogl_texture_get_height (texture);
+
+  update_wrap_mode (self);
+
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
+}
+
+/* Sets our material to paint with a 1x1 texture of the stage's background
+ * color; doing this when we have no pixmap allows the application to turn
+ * off painting the stage. There might be a performance benefit to
+ * painting in this case with a solid color, but the normal solid color
+ * case is a 1x1 root pixmap, so we'd have to reverse-engineer that to
+ * actually pick up the (small?) performance win. This is just a fallback.
+ */
+static void
+set_texture_to_stage_color (MetaBackgroundActor *self)
+{
+  ClutterActor *stage = meta_get_stage_for_screen (self->screen);
+  ClutterColor color;
+  CoglHandle texture;
+
+  clutter_stage_get_color (CLUTTER_STAGE (stage), &color);
+  texture = meta_create_color_texture_4ub (color.red, color.green,
+                                           color.blue, 0xff);
+  set_texture (self, texture);
+  cogl_handle_unref (texture);
+}
+
+static void
+on_notify_stage_color (GObject             *stage,
+                       GParamSpec          *pspec,
+                       MetaBackgroundActor *self)
+{
+  if (!self->have_pixmap)
+    set_texture_to_stage_color (self);
+}
+
+static void
+meta_background_actor_dispose (GObject *object)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
+
+  meta_background_actor_set_visible_region (self, NULL);
+
+  if (self->material != COGL_INVALID_HANDLE)
+    {
+      cogl_handle_unref (self->material);
+      self->material = COGL_INVALID_HANDLE;
+    }
+
+  if (self->screen != NULL)
+    {
+      ClutterActor *stage = meta_get_stage_for_screen (self->screen);
+      g_signal_handlers_disconnect_by_func (stage,
+                                            (gpointer) on_notify_stage_color,
+                                            self);
+      self->screen = NULL;
+    }
+}
+
+static void
+meta_background_actor_get_preferred_width (ClutterActor *actor,
+                                           gfloat        for_height,
+                                           gfloat       *min_width_p,
+                                           gfloat       *natural_width_p)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  int width, height;
+
+  meta_screen_get_size (self->screen, &width, &height);
+
+  if (min_width_p)
+    *min_width_p = width;
+  if (natural_width_p)
+    *natural_width_p = height;
+}
+
+static void
+meta_background_actor_get_preferred_height (ClutterActor *actor,
+                                            gfloat        for_width,
+                                            gfloat       *min_height_p,
+                                            gfloat       *natural_height_p)
+
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  int width, height;
+
+  meta_screen_get_size (self->screen, &width, &height);
+
+  if (min_height_p)
+    *min_height_p = height;
+  if (natural_height_p)
+    *natural_height_p = height;
+}
+
+static void
+meta_background_actor_paint (ClutterActor *actor)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  int width, height;
+
+  meta_screen_get_size (self->screen, &width, &height);
+
+  cogl_set_source (self->material);
+
+  if (self->visible_region)
+    {
+      int n_rectangles = cairo_region_num_rectangles (self->visible_region);
+      int i;
+
+      for (i = 0; i < n_rectangles; i++)
+        {
+          cairo_rectangle_int_t rect;
+          cairo_region_get_rectangle (self->visible_region, i, &rect);
+
+          cogl_rectangle_with_texture_coords (rect.x, rect.y,
+                                              rect.x + rect.width, rect.y + rect.height,
+                                              rect.x / self->texture_width,
+                                              rect.y / self->texture_height,
+                                              (rect.x + rect.width) / self->texture_width,
+                                              (rect.y + rect.height) / self->texture_height);
+        }
+    }
+  else
+    {
+      cogl_rectangle_with_texture_coords (0.0f, 0.0f,
+                                          width, height,
+                                          0.0f, 0.0f,
+                                          width / self->texture_width,
+                                          height / self->texture_height);
+    }
+}
+
+#if CLUTTER_CHECK_VERSION(1, 5, 2)
+static gboolean
+meta_background_actor_get_paint_volume (ClutterActor       *actor,
+                                        ClutterPaintVolume *volume)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  int width, height;
+
+  meta_screen_get_size (self->screen, &width, &height);
+
+  clutter_paint_volume_set_width (volume, width);
+  clutter_paint_volume_set_height (volume, height);
+
+  return TRUE;
+}
+#endif
+
+static void
+meta_background_actor_class_init (MetaBackgroundActorClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+
+  object_class->dispose = meta_background_actor_dispose;
+
+  actor_class->get_preferred_width = meta_background_actor_get_preferred_width;
+  actor_class->get_preferred_height = meta_background_actor_get_preferred_height;
+  actor_class->paint = meta_background_actor_paint;
+#if CLUTTER_CHECK_VERSION(1, 5, 2)
+  actor_class->get_paint_volume = meta_background_actor_get_paint_volume;
+#endif
+}
+
+static void
+meta_background_actor_init (MetaBackgroundActor *background_actor)
+{
+}
+
+/**
+ * @screen: the #MetaScreen
+ * meta_background_actor_new:
+ *
+ * Creates a new actor to draw the background for the given screen.
+ *
+ * Return value: (transfer none): the newly created background actor
+ */
+ClutterActor *
+meta_background_actor_new (MetaScreen *screen)
+{
+  MetaBackgroundActor *self;
+  ClutterActor *stage;
+
+  g_return_val_if_fail (META_IS_SCREEN (screen), NULL);
+
+  self = g_object_new (META_TYPE_BACKGROUND_ACTOR, NULL);
+
+  self->screen = screen;
+
+  self->material = meta_create_texture_material (NULL);
+  cogl_material_set_layer_wrap_mode (self->material, 0,
+                                     COGL_MATERIAL_WRAP_MODE_REPEAT);
+
+  stage = meta_get_stage_for_screen (self->screen);
+  g_signal_connect (stage, "notify::color",
+                    G_CALLBACK (on_notify_stage_color), self);
+
+  meta_background_actor_update (self);
+
+  return CLUTTER_ACTOR (self);
+}
+
+/**
+ * meta_background_actor_update:
+ * @self: a #MetaBackgroundActor
+ *
+ * Refetches the _XROOTPMAP_ID property for the root window and updates
+ * the contents of the background actor based on that. There's no attempt
+ * to optimize out pixmap values that don't change (since a root pixmap
+ * could be replaced by with another pixmap with the same ID under some
+ * circumstances), so this should only be called when we actually receive
+ * a PropertyNotify event for the property.
+ */
+void
+meta_background_actor_update (MetaBackgroundActor *self)
+{
+  MetaDisplay *display;
+  MetaCompositor *compositor;
+  Atom type;
+  int format;
+  gulong nitems;
+  gulong bytes_after;
+  guchar *data;
+  Pixmap root_pixmap_id;
+
+  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
+
+  display = meta_screen_get_display (self->screen);
+  compositor = meta_display_get_compositor (display);
+
+  root_pixmap_id = None;
+  if (!XGetWindowProperty (meta_display_get_xdisplay (display),
+                           meta_screen_get_xroot  (self->screen),
+                           compositor->atom_x_root_pixmap,
+                           0, LONG_MAX,
+                           False,
+                           AnyPropertyType,
+                           &type, &format, &nitems, &bytes_after, &data) &&
+      type != None)
+  {
+     /* Got a property. */
+     if (type == XA_PIXMAP && format == 32 && nitems == 1)
+       {
+         /* Was what we expected. */
+         root_pixmap_id = *(Pixmap *)data;
+       }
+
+     XFree(data);
+  }
+
+  if (root_pixmap_id != None)
+    {
+      CoglHandle texture;
+
+      meta_error_trap_push (display);
+      texture = cogl_texture_pixmap_x11_new (root_pixmap_id, FALSE);
+      meta_error_trap_pop (display);
+
+      if (texture != COGL_INVALID_HANDLE)
+        {
+          set_texture (self, texture);
+          cogl_handle_unref (texture);
+
+          self->have_pixmap = True;
+          return;
+        }
+    }
+
+  self->have_pixmap = False;
+  set_texture_to_stage_color (self);
+}
+
+/**
+ * meta_background_actor_set_visible_region:
+ * @self: a #MetaBackgroundActor
+ * @visible_region: (allow-none): the area of the actor (in allocate-relative
+ *   coordinates) that is visible.
+ *
+ * Sets the area of the background that is unobscured by overlapping windows.
+ * This is used to optimize and only paint the visible portions.
+ */
+void
+meta_background_actor_set_visible_region (MetaBackgroundActor *self,
+                                          cairo_region_t      *visible_region)
+{
+  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
+
+  if (self->visible_region)
+    {
+      cairo_region_destroy (self->visible_region);
+      self->visible_region = NULL;
+    }
+
+  if (visible_region)
+    {
+      cairo_rectangle_int_t screen_rect = { 0 };
+      meta_screen_get_size (self->screen, &screen_rect.width, &screen_rect.height);
+
+      /* Doing the intersection here is probably unnecessary - MetaWindowGroup
+       * should never compute a visible area that's larger than the root screen!
+       * but it's not that expensive and adds some extra robustness.
+       */
+      self->visible_region = cairo_region_create_rectangle (&screen_rect);
+      cairo_region_intersect (self->visible_region, visible_region);
+    }
+}
+
+/**
+ * meta_background_actor_screen_size_changed:
+ * @self: a #MetaBackgroundActor
+ *
+ * Called by the compositor when the size of the #MetaScreen changes
+ */
+void
+meta_background_actor_screen_size_changed (MetaBackgroundActor *self)
+{
+  update_wrap_mode (self);
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+}
--- a/src/compositor/meta-background-actor.h
+++ b/src/compositor/meta-background-actor.h
@@ -0,0 +1,58 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * meta-background-actor.h: Actor for painting the root window background
+ *
+ * Copyright 2010 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_BACKGROUND_ACTOR_H
+#define META_BACKGROUND_ACTOR_H
+
+#include <clutter/clutter.h>
+
+#include "screen.h"
+
+/**
+ * MetaBackgroundActor:
+ *
+ * This class handles tracking and painting the root window background.
+ * By integrating with #MetaWindowGroup we can avoid painting parts of
+ * the background that are obscured by other windows.
+ */
+
+#define META_TYPE_BACKGROUND_ACTOR            (meta_background_actor_get_type ())
+#define META_BACKGROUND_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActor))
+#define META_BACKGROUND_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActorClass))
+#define META_IS_BACKGROUND_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_BACKGROUND_ACTOR))
+#define META_IS_BACKGROUND_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_BACKGROUND_ACTOR))
+#define META_BACKGROUND_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActorClass))
+
+typedef struct _MetaBackgroundActor        MetaBackgroundActor;
+typedef struct _MetaBackgroundActorClass   MetaBackgroundActorClass;
+typedef struct _MetaBackgroundActorPrivate MetaBackgroundActorPrivate;
+
+GType meta_background_actor_get_type (void);
+
+ClutterActor *meta_background_actor_new (MetaScreen *screen);
+
+void meta_background_actor_update              (MetaBackgroundActor *actor);
+void meta_background_actor_set_visible_region  (MetaBackgroundActor *self,
+                                                cairo_region_t      *visible_region);
+void meta_background_actor_screen_size_changed (MetaBackgroundActor *self);
+
+#endif /* META_BACKGROUND_ACTOR_H */
--- a/src/compositor/mutter-module.c
+++ b/src/compositor/mutter-module.c
@@ -21,8 +21,8 @@
 * 02111-1307, USA.
 */

-#include "mutter-plugin.h"
-#include "mutter-module.h"
+#include "meta-plugin.h"
+#include "meta-module.h"

 #include <gmodule.h>

@@ -32,23 +32,23 @@ enum
  PROP_PATH,
 };

-struct _MutterModulePrivate
+struct _MetaModulePrivate
 {
  GModule      *lib;
  gchar        *path;
  GType         plugin_type;
 };

-#define MUTTER_MODULE_GET_PRIVATE(obj) \
-(G_TYPE_INSTANCE_GET_PRIVATE ((obj), MUTTER_TYPE_MODULE, MutterModulePrivate))
+#define META_MODULE_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_MODULE, MetaModulePrivate))

-G_DEFINE_TYPE (MutterModule, mutter_module, G_TYPE_TYPE_MODULE);
+G_DEFINE_TYPE (MetaModule, meta_module, G_TYPE_TYPE_MODULE);

 static gboolean
-mutter_module_load (GTypeModule *gmodule)
+meta_module_load (GTypeModule *gmodule)
 {
-  MutterModulePrivate  *priv = MUTTER_MODULE (gmodule)->priv;
-  MutterPluginVersion  *info = NULL;
+  MetaModulePrivate  *priv = META_MODULE (gmodule)->priv;
+  MetaPluginVersion  *info = NULL;
  GType                (*register_type) (GTypeModule *) = NULL;

  if (priv->lib && priv->plugin_type)
@@ -64,9 +64,9 @@ mutter_module_load (GTypeModule *gmodule)
      return FALSE;
    }

-  if (g_module_symbol (priv->lib, "mutter_plugin_version",
+  if (g_module_symbol (priv->lib, "meta_plugin_version",
                       (gpointer *)(void *)&info) &&
-      g_module_symbol (priv->lib, "mutter_plugin_register_type",
+      g_module_symbol (priv->lib, "meta_plugin_register_type",
 		       (gpointer *)(void *)&register_type) &&
      info && register_type)
    {
@@ -97,9 +97,9 @@ mutter_module_load (GTypeModule *gmodule)
 }

 static void
-mutter_module_unload (GTypeModule *gmodule)
+meta_module_unload (GTypeModule *gmodule)
 {
-  MutterModulePrivate *priv = MUTTER_MODULE (gmodule)->priv;
+  MetaModulePrivate *priv = META_MODULE (gmodule)->priv;

  g_module_close (priv->lib);

@@ -108,29 +108,29 @@ mutter_module_unload (GTypeModule *gmodule)
 }

 static void
-mutter_module_dispose (GObject *object)
+meta_module_dispose (GObject *object)
 {
-  G_OBJECT_CLASS (mutter_module_parent_class)->dispose (object);
+  G_OBJECT_CLASS (meta_module_parent_class)->dispose (object);
 }

 static void
-mutter_module_finalize (GObject *object)
+meta_module_finalize (GObject *object)
 {
-  MutterModulePrivate *priv = MUTTER_MODULE (object)->priv;
+  MetaModulePrivate *priv = META_MODULE (object)->priv;

  g_free (priv->path);
  priv->path = NULL;

-  G_OBJECT_CLASS (mutter_module_parent_class)->finalize (object);
+  G_OBJECT_CLASS (meta_module_parent_class)->finalize (object);
 }

 static void
-mutter_module_set_property (GObject      *object,
-			    guint         prop_id,
-			    const GValue *value,
-			    GParamSpec   *pspec)
+meta_module_set_property (GObject      *object,
+                          guint         prop_id,
+                          const GValue *value,
+                          GParamSpec   *pspec)
 {
-  MutterModulePrivate *priv = MUTTER_MODULE (object)->priv;
+  MetaModulePrivate *priv = META_MODULE (object)->priv;

  switch (prop_id)
    {
@@ -145,12 +145,12 @@ mutter_module_set_property (GObject      *object,
 }

 static void
-mutter_module_get_property (GObject    *object,
-			    guint       prop_id,
-			    GValue     *value,
-			    GParamSpec *pspec)
+meta_module_get_property (GObject    *object,
+                          guint       prop_id,
+                          GValue     *value,
+                          GParamSpec *pspec)
 {
-  MutterModulePrivate *priv = MUTTER_MODULE (object)->priv;
+  MetaModulePrivate *priv = META_MODULE (object)->priv;

  switch (prop_id)
    {
@@ -164,18 +164,18 @@ mutter_module_get_property (GObject    *object,
 }

 static void
-mutter_module_class_init (MutterModuleClass *klass)
+meta_module_class_init (MetaModuleClass *klass)
 {
  GObjectClass     *gobject_class = G_OBJECT_CLASS (klass);
  GTypeModuleClass *gmodule_class = G_TYPE_MODULE_CLASS (klass);

-  gobject_class->finalize     = mutter_module_finalize;
-  gobject_class->dispose      = mutter_module_dispose;
-  gobject_class->set_property = mutter_module_set_property;
-  gobject_class->get_property = mutter_module_get_property;
+  gobject_class->finalize     = meta_module_finalize;
+  gobject_class->dispose      = meta_module_dispose;
+  gobject_class->set_property = meta_module_set_property;
+  gobject_class->get_property = meta_module_get_property;

-  gmodule_class->load         = mutter_module_load;
-  gmodule_class->unload       = mutter_module_unload;
+  gmodule_class->load         = meta_module_load;
+  gmodule_class->unload       = meta_module_unload;

  g_object_class_install_property (gobject_class,
 				   PROP_PATH,
@@ -186,22 +186,22 @@ mutter_module_class_init (MutterModuleClass *klass)
 							G_PARAM_READWRITE |
 						      G_PARAM_CONSTRUCT_ONLY));

-  g_type_class_add_private (gobject_class, sizeof (MutterModulePrivate));
+  g_type_class_add_private (gobject_class, sizeof (MetaModulePrivate));
 }

 static void
-mutter_module_init (MutterModule *self)
+meta_module_init (MetaModule *self)
 {
-  MutterModulePrivate *priv;
+  MetaModulePrivate *priv;

-  self->priv = priv = MUTTER_MODULE_GET_PRIVATE (self);
+  self->priv = priv = META_MODULE_GET_PRIVATE (self);

 }

 GType
-mutter_module_get_plugin_type (MutterModule *module)
+meta_module_get_plugin_type (MetaModule *module)
 {
-  MutterModulePrivate *priv = MUTTER_MODULE (module)->priv;
+  MetaModulePrivate *priv = META_MODULE (module)->priv;

  return priv->plugin_type;
 }
--- a/src/compositor/mutter-module.h
+++ b/src/compositor/mutter-module.h
@@ -21,37 +21,37 @@
 * 02111-1307, USA.
 */

-#ifndef MUTTER_MODULE_H_
-#define MUTTER_MODULE_H_
+#ifndef META_MODULE_H_
+#define META_MODULE_H_

 #include <glib-object.h>

-#define MUTTER_TYPE_MODULE            (mutter_module_get_type ())
-#define MUTTER_MODULE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_MODULE, MutterModule))
-#define MUTTER_MODULE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  MUTTER_TYPE_MODULE, MutterModuleClass))
-#define MUTTER_IS_MODULE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_MODULE_TYPE))
-#define MUTTER_IS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  MUTTER_TYPE_MODULE))
-#define MUTTER_MODULE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  MUTTER_TYPE_MODULE, MutterModuleClass))
+#define META_TYPE_MODULE            (meta_module_get_type ())
+#define META_MODULE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_MODULE, MetaModule))
+#define META_MODULE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_MODULE, MetaModuleClass))
+#define META_IS_MODULE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_MODULE_TYPE))
+#define META_IS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_MODULE))
+#define META_MODULE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_MODULE, MetaModuleClass))

-typedef struct _MutterModule        MutterModule;
-typedef struct _MutterModuleClass   MutterModuleClass;
-typedef struct _MutterModulePrivate MutterModulePrivate;
+typedef struct _MetaModule        MetaModule;
+typedef struct _MetaModuleClass   MetaModuleClass;
+typedef struct _MetaModulePrivate MetaModulePrivate;

-struct _MutterModule
+struct _MetaModule
 {
  GTypeModule parent;

-  MutterModulePrivate *priv;
+  MetaModulePrivate *priv;
 };

-struct _MutterModuleClass
+struct _MetaModuleClass
 {
  GTypeModuleClass parent_class;
 };


-GType mutter_module_get_type (void);
+GType meta_module_get_type (void);

-GType mutter_module_get_plugin_type (MutterModule *module);
+GType meta_module_get_plugin_type (MetaModule *module);

 #endif
--- a/src/compositor/mutter-plugin-manager.c
+++ b/src/compositor/mutter-plugin-manager.c
@@ -23,11 +23,11 @@

 #include "config.h"
 #include "compositor-private.h"
-#include "mutter-plugin-manager.h"
+#include "meta-plugin-manager.h"
 #include "prefs.h"
 #include "errors.h"
 #include "workspace.h"
-#include "mutter-module.h"
+#include "meta-module.h"
 #include "../core/window-private.h"

 #include <string.h>
@@ -46,16 +46,16 @@ static GHashTable *plugin_modules = NULL;
 * have one plugin manager and only make the plugins per-screen.)
 */

-static MutterPluginManager *default_plugin_manager;
+static MetaPluginManager *default_plugin_manager;

-static gboolean mutter_plugin_manager_reload (MutterPluginManager *plugin_mgr);
+static gboolean meta_plugin_manager_reload (MetaPluginManager *plugin_mgr);

-struct MutterPluginManager
+struct MetaPluginManager
 {
  MetaScreen   *screen;

-  GList /* MutterPlugin */       *plugins;  /* TODO -- maybe use hash table */
-  GList                          *unload;  /* Plugins that are disabled and pending unload */
+  GList /* MetaPlugin */       *plugins;  /* TODO -- maybe use hash table */
+  GList                        *unload;  /* Plugins that are disabled and pending unload */

  guint         idle_unload_id;
 };
@@ -64,13 +64,13 @@ struct MutterPluginManager
 * Checks that the plugin is compatible with the WM and sets up the plugin
 * struct.
 */
-static MutterPlugin *
-mutter_plugin_load (MutterPluginManager *mgr,
-                    MutterModule        *module,
-                    const gchar         *params)
+static MetaPlugin *
+meta_plugin_load (MetaPluginManager *mgr,
+                  MetaModule        *module,
+                  const gchar       *params)
 {
-  MutterPlugin *plugin = NULL;
-  GType         plugin_type = mutter_module_get_plugin_type (module);
+  MetaPlugin *plugin = NULL;
+  GType         plugin_type = meta_module_get_plugin_type (module);

  if (!plugin_type)
    {
@@ -91,9 +91,9 @@ mutter_plugin_load (MutterPluginManager *mgr,
 * removal later.
 */
 static gboolean
-mutter_plugin_unload (MutterPlugin *plugin)
+meta_plugin_unload (MetaPlugin *plugin)
 {
-  if (mutter_plugin_running (plugin))
+  if (meta_plugin_running (plugin))
    {
      g_object_set (plugin, "disabled", TRUE, NULL);
      return FALSE;
@@ -109,16 +109,16 @@ mutter_plugin_unload (MutterPlugin *plugin)
 * pending for removal.
 */
 static gboolean
-mutter_plugin_manager_idle_unload (MutterPluginManager *plugin_mgr)
+meta_plugin_manager_idle_unload (MetaPluginManager *plugin_mgr)
 {
  GList *l = plugin_mgr->unload;
  gboolean dont_remove = TRUE;

  while (l)
    {
-      MutterPlugin *plugin = l->data;
+      MetaPlugin *plugin = l->data;

-      if (mutter_plugin_unload (plugin))
+      if (meta_plugin_unload (plugin))
        {
          /* Remove from list */
          GList *p = l->prev;
@@ -154,23 +154,23 @@ mutter_plugin_manager_idle_unload (MutterPluginManager *plugin_mgr)
 * Unloads all plugins
 */
 static void
-mutter_plugin_manager_unload (MutterPluginManager *plugin_mgr)
+meta_plugin_manager_unload (MetaPluginManager *plugin_mgr)
 {
  GList *plugins = plugin_mgr->plugins;

  while (plugins)
    {
-      MutterPlugin *plugin = plugins->data;
+      MetaPlugin *plugin = plugins->data;

      /* If the plugin could not be removed, move it to the unload list */
-      if (!mutter_plugin_unload (plugin))
+      if (!meta_plugin_unload (plugin))
        {
          plugin_mgr->unload = g_list_prepend (plugin_mgr->unload, plugin);

          if (!plugin_mgr->idle_unload_id)
            {
              plugin_mgr->idle_unload_id = g_idle_add ((GSourceFunc)
-                            mutter_plugin_manager_idle_unload,
+                            meta_plugin_manager_idle_unload,
                            plugin_mgr);
            }
        }
@@ -186,21 +186,21 @@ static void
 prefs_changed_callback (MetaPreference pref,
                        void          *data)
 {
-  MutterPluginManager *plugin_mgr = data;
+  MetaPluginManager *plugin_mgr = data;

  if (pref == META_PREF_CLUTTER_PLUGINS)
    {
-      mutter_plugin_manager_reload (plugin_mgr);
+      meta_plugin_manager_reload (plugin_mgr);
    }
 }

-static MutterModule *
-mutter_plugin_manager_get_module (const gchar *path)
+static MetaModule *
+meta_plugin_manager_get_module (const gchar *path)
 {
-  MutterModule *module = g_hash_table_lookup (plugin_modules, path);
+  MetaModule *module = g_hash_table_lookup (plugin_modules, path);

  if (!module &&
-      (module = g_object_new (MUTTER_TYPE_MODULE, "path", path, NULL)))
+      (module = g_object_new (META_TYPE_MODULE, "path", path, NULL)))
    {
      g_hash_table_insert (plugin_modules, g_strdup (path), module);
    }
@@ -212,7 +212,7 @@ mutter_plugin_manager_get_module (const gchar *path)
 * Loads all plugins listed in gconf registry.
 */
 gboolean
-mutter_plugin_manager_load (MutterPluginManager *plugin_mgr)
+meta_plugin_manager_load (MetaPluginManager *plugin_mgr)
 {
  const gchar *dpath = MUTTER_PLUGIN_DIR "/";
  GSList      *plugins, *fallback = NULL;
@@ -237,7 +237,7 @@ mutter_plugin_manager_load (MutterPluginManager *plugin_mgr)

      if (plugin_string)
        {
-          MutterModule *module;
+          MetaModule *module;
          gchar        *path;

          params = strchr (plugin_string, ':');
@@ -253,7 +253,7 @@ mutter_plugin_manager_load (MutterPluginManager *plugin_mgr)
          else
            path = g_strconcat (dpath, plugin_string, ".so", NULL);

-          module = mutter_plugin_manager_get_module (path);
+          module = meta_plugin_manager_get_module (path);

          if (module)
            {
@@ -270,7 +270,7 @@ mutter_plugin_manager_load (MutterPluginManager *plugin_mgr)

              if (use_succeeded)
                {
-                  MutterPlugin *plugin = mutter_plugin_load (plugin_mgr, module, params);
+                  MetaPlugin *plugin = meta_plugin_load (plugin_mgr, module, params);

                  if (plugin)
                    plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
@@ -305,14 +305,14 @@ mutter_plugin_manager_load (MutterPluginManager *plugin_mgr)
 }

 gboolean
-mutter_plugin_manager_initialize (MutterPluginManager *plugin_mgr)
+meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr)
 {
  GList *iter;

  for (iter = plugin_mgr->plugins; iter; iter = iter->next)
    {
-      MutterPlugin *plugin = (MutterPlugin*) iter->data;
-      MutterPluginClass *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin *plugin = (MetaPlugin*) iter->data;
+      MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);

      g_object_set (plugin,
                    "screen", plugin_mgr->screen,
@@ -329,7 +329,7 @@ mutter_plugin_manager_initialize (MutterPluginManager *plugin_mgr)
 * Reloads all plugins
 */
 static gboolean
-mutter_plugin_manager_reload (MutterPluginManager *plugin_mgr)
+meta_plugin_manager_reload (MetaPluginManager *plugin_mgr)
 {
  /* TODO -- brute force; should we build a list of plugins to load and list of
   * plugins to unload? We are probably not going to have large numbers of
@@ -337,16 +337,16 @@ mutter_plugin_manager_reload (MutterPluginManager *plugin_mgr)
   */

  /* Prevent stale grabs on unloaded plugins */
-  mutter_check_end_modal (plugin_mgr->screen);
+  meta_check_end_modal (plugin_mgr->screen);

-  mutter_plugin_manager_unload (plugin_mgr);
-  return mutter_plugin_manager_load (plugin_mgr);
+  meta_plugin_manager_unload (plugin_mgr);
+  return meta_plugin_manager_load (plugin_mgr);
 }

-static MutterPluginManager *
-mutter_plugin_manager_new (MetaScreen *screen)
+static MetaPluginManager *
+meta_plugin_manager_new (MetaScreen *screen)
 {
-  MutterPluginManager *plugin_mgr;
+  MetaPluginManager *plugin_mgr;

  if (!plugin_modules)
    {
@@ -354,65 +354,65 @@ mutter_plugin_manager_new (MetaScreen *screen)
                                              NULL);
    }

-  plugin_mgr = g_new0 (MutterPluginManager, 1);
+  plugin_mgr = g_new0 (MetaPluginManager, 1);

  plugin_mgr->screen        = screen;

  if (screen)
-    g_object_set_data (G_OBJECT (screen), "mutter-plugin-manager", plugin_mgr);
+    g_object_set_data (G_OBJECT (screen), "meta-plugin-manager", plugin_mgr);

  return plugin_mgr;
 }

-MutterPluginManager *
-mutter_plugin_manager_get_default (void)
+MetaPluginManager *
+meta_plugin_manager_get_default (void)
 {
  if (!default_plugin_manager)
    {
-      default_plugin_manager = mutter_plugin_manager_new (NULL);
+      default_plugin_manager = meta_plugin_manager_new (NULL);
    }

  return default_plugin_manager;
 }

-MutterPluginManager *
-mutter_plugin_manager_get (MetaScreen *screen)
+MetaPluginManager *
+meta_plugin_manager_get (MetaScreen *screen)
 {
-  MutterPluginManager *plugin_mgr;
+  MetaPluginManager *plugin_mgr;

-  plugin_mgr = g_object_get_data (G_OBJECT (screen), "mutter-plugin-manager");
+  plugin_mgr = g_object_get_data (G_OBJECT (screen), "meta-plugin-manager");
  if (plugin_mgr)
    return plugin_mgr;

  if (!default_plugin_manager)
-    mutter_plugin_manager_get_default ();
+    meta_plugin_manager_get_default ();

  if (!default_plugin_manager->screen)
    {
      /* The default plugin manager is so far unused, we can recycle it */
      default_plugin_manager->screen = screen;
-      g_object_set_data (G_OBJECT (screen), "mutter-plugin-manager", default_plugin_manager);
+      g_object_set_data (G_OBJECT (screen), "meta-plugin-manager", default_plugin_manager);

      return default_plugin_manager;
    }
  else
    {
-      return mutter_plugin_manager_new (screen);
+      return meta_plugin_manager_new (screen);
    }
 }

 static void
-mutter_plugin_manager_kill_window_effects (MutterPluginManager *plugin_mgr,
-                                           MutterWindow        *actor)
+meta_plugin_manager_kill_window_effects (MetaPluginManager *plugin_mgr,
+                                         MetaWindowActor   *actor)
 {
  GList *l = plugin_mgr->plugins;

  while (l)
    {
-      MutterPlugin        *plugin = l->data;
-      MutterPluginClass   *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin        *plugin = l->data;
+      MetaPluginClass   *klass = META_PLUGIN_GET_CLASS (plugin);

-      if (!mutter_plugin_disabled (plugin)
+      if (!meta_plugin_disabled (plugin)
 	  && klass->kill_window_effects)
        klass->kill_window_effects (plugin, actor);

@@ -421,17 +421,17 @@ mutter_plugin_manager_kill_window_effects (MutterPluginManager *plugin_mgr,
 }

 static void
-mutter_plugin_manager_kill_switch_workspace (MutterPluginManager *plugin_mgr)
+meta_plugin_manager_kill_switch_workspace (MetaPluginManager *plugin_mgr)
 {
  GList *l = plugin_mgr->plugins;

  while (l)
    {
-      MutterPlugin        *plugin = l->data;
-      MutterPluginClass   *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin        *plugin = l->data;
+      MetaPluginClass   *klass = META_PLUGIN_GET_CLASS (plugin);

-      if (!mutter_plugin_disabled (plugin)
-          && (mutter_plugin_features (plugin) & MUTTER_PLUGIN_SWITCH_WORKSPACE)
+      if (!meta_plugin_disabled (plugin)
+          && (meta_plugin_features (plugin) & META_PLUGIN_SWITCH_WORKSPACE)
 	  && klass->kill_switch_workspace)
        klass->kill_switch_workspace (plugin);

@@ -449,9 +449,9 @@ mutter_plugin_manager_kill_switch_workspace (MutterPluginManager *plugin_mgr)
 * appropriate post-effect cleanup is carried out.
 */
 gboolean
-mutter_plugin_manager_event_simple (MutterPluginManager *plugin_mgr,
-                                    MutterWindow        *actor,
-                                    unsigned long        event)
+meta_plugin_manager_event_simple (MetaPluginManager *plugin_mgr,
+                                  MetaWindowActor   *actor,
+                                  unsigned long      event)
 {
  GList *l = plugin_mgr->plugins;
  gboolean retval = FALSE;
@@ -462,42 +462,42 @@ mutter_plugin_manager_event_simple (MutterPluginManager *plugin_mgr,

  while (l)
    {
-      MutterPlugin        *plugin = l->data;
-      MutterPluginClass   *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin        *plugin = l->data;
+      MetaPluginClass   *klass = META_PLUGIN_GET_CLASS (plugin);

-      if (!mutter_plugin_disabled (plugin) &&
-          (mutter_plugin_features (plugin) & event))
+      if (!meta_plugin_disabled (plugin) &&
+          (meta_plugin_features (plugin) & event))
        {
          retval = TRUE;

          switch (event)
            {
-            case MUTTER_PLUGIN_MINIMIZE:
+            case META_PLUGIN_MINIMIZE:
              if (klass->minimize)
                {
-                  mutter_plugin_manager_kill_window_effects (
+                  meta_plugin_manager_kill_window_effects (
 		      plugin_mgr,
 		      actor);

-                  _mutter_plugin_effect_started (plugin);
+                  _meta_plugin_effect_started (plugin);
                  klass->minimize (plugin, actor);
                }
              break;
-            case MUTTER_PLUGIN_MAP:
+            case META_PLUGIN_MAP:
              if (klass->map)
                {
-                  mutter_plugin_manager_kill_window_effects (
+                  meta_plugin_manager_kill_window_effects (
 		      plugin_mgr,
 		      actor);

-                  _mutter_plugin_effect_started (plugin);
+                  _meta_plugin_effect_started (plugin);
                  klass->map (plugin, actor);
                }
              break;
-            case MUTTER_PLUGIN_DESTROY:
+            case META_PLUGIN_DESTROY:
              if (klass->destroy)
                {
-                  _mutter_plugin_effect_started (plugin);
+                  _meta_plugin_effect_started (plugin);
                  klass->destroy (plugin, actor);
                }
              break;
@@ -522,13 +522,13 @@ mutter_plugin_manager_event_simple (MutterPluginManager *plugin_mgr,
 * appropriate post-effect cleanup is carried out.
 */
 gboolean
-mutter_plugin_manager_event_maximize (MutterPluginManager *plugin_mgr,
-                                      MutterWindow        *actor,
-                                      unsigned long        event,
-                                      gint                 target_x,
-                                      gint                 target_y,
-                                      gint                 target_width,
-                                      gint                 target_height)
+meta_plugin_manager_event_maximize (MetaPluginManager *plugin_mgr,
+                                    MetaWindowActor   *actor,
+                                    unsigned long      event,
+                                    gint               target_x,
+                                    gint               target_y,
+                                    gint               target_width,
+                                    gint               target_height)
 {
  GList *l = plugin_mgr->plugins;
  gboolean retval = FALSE;
@@ -539,37 +539,37 @@ mutter_plugin_manager_event_maximize (MutterPluginManager *plugin_mgr,

  while (l)
    {
-      MutterPlugin        *plugin = l->data;
-      MutterPluginClass   *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin        *plugin = l->data;
+      MetaPluginClass   *klass = META_PLUGIN_GET_CLASS (plugin);

-      if (!mutter_plugin_disabled (plugin) &&
-          (mutter_plugin_features (plugin) & event))
+      if (!meta_plugin_disabled (plugin) &&
+          (meta_plugin_features (plugin) & event))
        {
          retval = TRUE;

          switch (event)
            {
-            case MUTTER_PLUGIN_MAXIMIZE:
+            case META_PLUGIN_MAXIMIZE:
              if (klass->maximize)
                {
-                  mutter_plugin_manager_kill_window_effects (
+                  meta_plugin_manager_kill_window_effects (
 		      plugin_mgr,
 		      actor);

-                  _mutter_plugin_effect_started (plugin);
+                  _meta_plugin_effect_started (plugin);
                  klass->maximize (plugin, actor,
                                   target_x, target_y,
                                   target_width, target_height);
                }
              break;
-            case MUTTER_PLUGIN_UNMAXIMIZE:
+            case META_PLUGIN_UNMAXIMIZE:
              if (klass->unmaximize)
                {
-                  mutter_plugin_manager_kill_window_effects (
+                  meta_plugin_manager_kill_window_effects (
 		      plugin_mgr,
 		      actor);

-                  _mutter_plugin_effect_started (plugin);
+                  _meta_plugin_effect_started (plugin);
                  klass->unmaximize (plugin, actor,
                                     target_x, target_y,
                                     target_width, target_height);
@@ -595,10 +595,10 @@ mutter_plugin_manager_event_maximize (MutterPluginManager *plugin_mgr,
 * appropriate post-effect cleanup is carried out.
 */
 gboolean
-mutter_plugin_manager_switch_workspace (MutterPluginManager *plugin_mgr,
-                                        gint                 from,
-                                        gint                 to,
-                                        MetaMotionDirection  direction)
+meta_plugin_manager_switch_workspace (MetaPluginManager   *plugin_mgr,
+                                      gint                 from,
+                                      gint                 to,
+                                      MetaMotionDirection  direction)
 {
  GList *l = plugin_mgr->plugins;
  gboolean retval = FALSE;
@@ -609,18 +609,18 @@ mutter_plugin_manager_switch_workspace (MutterPluginManager *plugin_mgr,

  while (l)
    {
-      MutterPlugin        *plugin = l->data;
-      MutterPluginClass   *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin        *plugin = l->data;
+      MetaPluginClass   *klass = META_PLUGIN_GET_CLASS (plugin);

-      if (!mutter_plugin_disabled (plugin) &&
-          (mutter_plugin_features (plugin) & MUTTER_PLUGIN_SWITCH_WORKSPACE))
+      if (!meta_plugin_disabled (plugin) &&
+          (meta_plugin_features (plugin) & META_PLUGIN_SWITCH_WORKSPACE))
        {
          if (klass->switch_workspace)
            {
              retval = TRUE;
-              mutter_plugin_manager_kill_switch_workspace (plugin_mgr);
+              meta_plugin_manager_kill_switch_workspace (plugin_mgr);

-              _mutter_plugin_effect_started (plugin);
+              _meta_plugin_effect_started (plugin);
              klass->switch_workspace (plugin, from, to, direction);
            }
        }
@@ -640,8 +640,8 @@ mutter_plugin_manager_switch_workspace (MutterPluginManager *plugin_mgr,
 * appropriate post-effect cleanup is carried out.
 */
 gboolean
-mutter_plugin_manager_xevent_filter (MutterPluginManager *plugin_mgr,
-                                     XEvent              *xev)
+meta_plugin_manager_xevent_filter (MetaPluginManager *plugin_mgr,
+                                   XEvent            *xev)
 {
  GList *l;
  gboolean have_plugin_xevent_func;
@@ -671,8 +671,8 @@ mutter_plugin_manager_xevent_filter (MutterPluginManager *plugin_mgr,

  while (l)
    {
-      MutterPlugin      *plugin = l->data;
-      MutterPluginClass *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+      MetaPlugin      *plugin = l->data;
+      MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);

      if (klass->xevent_filter)
        {
--- a/src/compositor/meta-plugin-manager.h
+++ b/src/compositor/meta-plugin-manager.h
@@ -0,0 +1,78 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (c) 2008 Intel Corp.
+ *
+ * Author: Tomas Frydrych <tf@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 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_PLUGIN_MANAGER_H_
+#define META_PLUGIN_MANAGER_H_
+
+#include "types.h"
+#include "screen.h"
+
+#define  META_PLUGIN_FROM_MANAGER_
+#include "meta-plugin.h"
+#undef   META_PLUGIN_FROM_MANAGER_
+
+#define META_PLUGIN_MINIMIZE         (1<<0)
+#define META_PLUGIN_MAXIMIZE         (1<<1)
+#define META_PLUGIN_UNMAXIMIZE       (1<<2)
+#define META_PLUGIN_MAP              (1<<3)
+#define META_PLUGIN_DESTROY          (1<<4)
+#define META_PLUGIN_SWITCH_WORKSPACE (1<<5)
+
+#define META_PLUGIN_ALL_EFFECTS      (~0)
+
+/**
+ * MetaPluginManager: (skip)
+ *
+ */
+typedef struct MetaPluginManager MetaPluginManager;
+
+MetaPluginManager * meta_plugin_manager_get         (MetaScreen *screen);
+MetaPluginManager * meta_plugin_manager_get_default (void);
+
+gboolean meta_plugin_manager_load         (MetaPluginManager *mgr);
+gboolean meta_plugin_manager_initialize   (MetaPluginManager *plugin_mgr);
+gboolean meta_plugin_manager_event_simple (MetaPluginManager *mgr,
+                                           MetaWindowActor   *actor,
+                                           unsigned long      event);
+
+gboolean meta_plugin_manager_event_maximize    (MetaPluginManager *mgr,
+                                                MetaWindowActor   *actor,
+                                                unsigned long      event,
+                                                gint               target_x,
+                                                gint               target_y,
+                                                gint               target_width,
+                                                gint               target_height);
+void     meta_plugin_manager_update_workspaces (MetaPluginManager *mgr);
+
+void meta_plugin_manager_update_workspace (MetaPluginManager *mgr,
+                                           MetaWorkspace     *w);
+
+gboolean meta_plugin_manager_switch_workspace (MetaPluginManager   *mgr,
+                                               gint                 from,
+                                               gint                 to,
+                                               MetaMotionDirection  direction);
+
+gboolean meta_plugin_manager_xevent_filter (MetaPluginManager *mgr,
+                                            XEvent            *xev);
+
+#endif
--- a/src/compositor/mutter-plugin.c
+++ b/src/compositor/mutter-plugin.c
@@ -21,7 +21,7 @@
 * 02111-1307, USA.
 */

-#include "mutter-plugin.h"
+#include "meta-plugin.h"
 #include "screen.h"
 #include "display.h"

@@ -32,12 +32,12 @@
 #include <clutter/x11/clutter-x11.h>

 #include "compositor-private.h"
-#include "mutter-window-private.h"
+#include "meta-window-actor-private.h"

-G_DEFINE_ABSTRACT_TYPE (MutterPlugin, mutter_plugin, G_TYPE_OBJECT);
+G_DEFINE_ABSTRACT_TYPE (MetaPlugin, meta_plugin, G_TYPE_OBJECT);

-#define MUTTER_PLUGIN_GET_PRIVATE(obj) \
-(G_TYPE_INSTANCE_GET_PRIVATE ((obj), MUTTER_TYPE_PLUGIN, MutterPluginPrivate))
+#define META_PLUGIN_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_PLUGIN, MetaPluginPrivate))

 enum
 {
@@ -49,7 +49,7 @@ enum
  PROP_DEBUG_MODE,
 };

-struct _MutterPluginPrivate
+struct _MetaPluginPrivate
 {
  MetaScreen   *screen;
  gchar        *params;
@@ -62,51 +62,51 @@ struct _MutterPluginPrivate
 };

 static void
-mutter_plugin_dispose (GObject *object)
+meta_plugin_dispose (GObject *object)
 {
-  G_OBJECT_CLASS (mutter_plugin_parent_class)->dispose (object);
+  G_OBJECT_CLASS (meta_plugin_parent_class)->dispose (object);
 }

 static void
-mutter_plugin_finalize (GObject *object)
+meta_plugin_finalize (GObject *object)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (object)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (object)->priv;

  g_free (priv->params);
  priv->params = NULL;

-  G_OBJECT_CLASS (mutter_plugin_parent_class)->finalize (object);
+  G_OBJECT_CLASS (meta_plugin_parent_class)->finalize (object);
 }

 static void
-mutter_plugin_parse_params (MutterPlugin *plugin)
+meta_plugin_parse_params (MetaPlugin *plugin)
 {
  char                  *p;
  gulong                features = 0;
-  MutterPluginPrivate  *priv     = plugin->priv;
-  MutterPluginClass    *klass    = MUTTER_PLUGIN_GET_CLASS (plugin);
+  MetaPluginPrivate  *priv     = plugin->priv;
+  MetaPluginClass    *klass    = META_PLUGIN_GET_CLASS (plugin);

 /*
 * Feature flags: identify events that the plugin can handle; a plugin can
 * handle one or more events.
 */
  if (klass->minimize)
-    features |= MUTTER_PLUGIN_MINIMIZE;
+    features |= META_PLUGIN_MINIMIZE;

  if (klass->maximize)
-    features |= MUTTER_PLUGIN_MAXIMIZE;
+    features |= META_PLUGIN_MAXIMIZE;

  if (klass->unmaximize)
-    features |= MUTTER_PLUGIN_UNMAXIMIZE;
+    features |= META_PLUGIN_UNMAXIMIZE;

  if (klass->map)
-    features |= MUTTER_PLUGIN_MAP;
+    features |= META_PLUGIN_MAP;

  if (klass->destroy)
-    features |= MUTTER_PLUGIN_DESTROY;
+    features |= META_PLUGIN_DESTROY;

  if (klass->switch_workspace)
-    features |= MUTTER_PLUGIN_SWITCH_WORKSPACE;
+    features |= META_PLUGIN_SWITCH_WORKSPACE;

  if (priv->params)
    {
@@ -122,22 +122,22 @@ mutter_plugin_parse_params (MutterPlugin *plugin)
            *p = 0;

          if (strstr (d, "minimize"))
-            features &= ~ MUTTER_PLUGIN_MINIMIZE;
+            features &= ~ META_PLUGIN_MINIMIZE;

          if (strstr (d, "maximize"))
-            features &= ~ MUTTER_PLUGIN_MAXIMIZE;
+            features &= ~ META_PLUGIN_MAXIMIZE;

          if (strstr (d, "unmaximize"))
-            features &= ~ MUTTER_PLUGIN_UNMAXIMIZE;
+            features &= ~ META_PLUGIN_UNMAXIMIZE;

          if (strstr (d, "map"))
-            features &= ~ MUTTER_PLUGIN_MAP;
+            features &= ~ META_PLUGIN_MAP;

          if (strstr (d, "destroy"))
-            features &= ~ MUTTER_PLUGIN_DESTROY;
+            features &= ~ META_PLUGIN_DESTROY;

          if (strstr (d, "switch-workspace"))
-            features &= ~MUTTER_PLUGIN_SWITCH_WORKSPACE;
+            features &= ~META_PLUGIN_SWITCH_WORKSPACE;

          g_free (d);
        }
@@ -162,12 +162,12 @@ mutter_plugin_parse_params (MutterPlugin *plugin)
 }

 static void
-mutter_plugin_set_property (GObject      *object,
-			    guint         prop_id,
-			    const GValue *value,
-			    GParamSpec   *pspec)
+meta_plugin_set_property (GObject      *object,
+                          guint         prop_id,
+                          const GValue *value,
+                          GParamSpec   *pspec)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (object)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (object)->priv;

  switch (prop_id)
    {
@@ -176,7 +176,7 @@ mutter_plugin_set_property (GObject      *object,
      break;
    case PROP_PARAMS:
      priv->params = g_value_dup_string (value);
-      mutter_plugin_parse_params (MUTTER_PLUGIN (object));
+      meta_plugin_parse_params (META_PLUGIN (object));
      break;
    case PROP_DISABLED:
      priv->disabled = g_value_get_boolean (value);
@@ -191,12 +191,12 @@ mutter_plugin_set_property (GObject      *object,
 }

 static void
-mutter_plugin_get_property (GObject    *object,
-			    guint       prop_id,
-			    GValue     *value,
-			    GParamSpec *pspec)
+meta_plugin_get_property (GObject    *object,
+                          guint       prop_id,
+                          GValue     *value,
+                          GParamSpec *pspec)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (object)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (object)->priv;

  switch (prop_id)
    {
@@ -223,14 +223,14 @@ mutter_plugin_get_property (GObject    *object,


 static void
-mutter_plugin_class_init (MutterPluginClass *klass)
+meta_plugin_class_init (MetaPluginClass *klass)
 {
  GObjectClass      *gobject_class = G_OBJECT_CLASS (klass);

-  gobject_class->finalize        = mutter_plugin_finalize;
-  gobject_class->dispose         = mutter_plugin_dispose;
-  gobject_class->set_property    = mutter_plugin_set_property;
-  gobject_class->get_property    = mutter_plugin_get_property;
+  gobject_class->finalize        = meta_plugin_finalize;
+  gobject_class->dispose         = meta_plugin_dispose;
+  gobject_class->set_property    = meta_plugin_set_property;
+  gobject_class->get_property    = meta_plugin_get_property;

  g_object_class_install_property (gobject_class,
                                   PROP_SCREEN,
@@ -273,53 +273,53 @@ mutter_plugin_class_init (MutterPluginClass *klass)
                                                      FALSE,
                                                      G_PARAM_READABLE));

-  g_type_class_add_private (gobject_class, sizeof (MutterPluginPrivate));
+  g_type_class_add_private (gobject_class, sizeof (MetaPluginPrivate));
 }

 static void
-mutter_plugin_init (MutterPlugin *self)
+meta_plugin_init (MetaPlugin *self)
 {
-  MutterPluginPrivate *priv;
+  MetaPluginPrivate *priv;

-  self->priv = priv = MUTTER_PLUGIN_GET_PRIVATE (self);
+  self->priv = priv = META_PLUGIN_GET_PRIVATE (self);
 }

 gulong
-mutter_plugin_features (MutterPlugin *plugin)
+meta_plugin_features (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  return priv->features;
 }

 gboolean
-mutter_plugin_disabled (MutterPlugin *plugin)
+meta_plugin_disabled (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  return priv->disabled;
 }

 gboolean
-mutter_plugin_running  (MutterPlugin *plugin)
+meta_plugin_running  (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  return (priv->running > 0);
 }

 gboolean
-mutter_plugin_debug_mode (MutterPlugin *plugin)
+meta_plugin_debug_mode (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  return priv->debug;
 }

-const MutterPluginInfo *
-mutter_plugin_get_info (MutterPlugin *plugin)
+const MetaPluginInfo *
+meta_plugin_get_info (MetaPlugin *plugin)
 {
-  MutterPluginClass  *klass = MUTTER_PLUGIN_GET_CLASS (plugin);
+  MetaPluginClass  *klass = META_PLUGIN_GET_CLASS (plugin);

  if (klass && klass->plugin_info)
    return klass->plugin_info (plugin);
@@ -328,50 +328,58 @@ mutter_plugin_get_info (MutterPlugin *plugin)
 }

 ClutterActor *
-mutter_plugin_get_overlay_group (MutterPlugin *plugin)
+meta_plugin_get_overlay_group (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  return mutter_get_overlay_group_for_screen (priv->screen);
+  return meta_get_overlay_group_for_screen (priv->screen);
 }

 ClutterActor *
-mutter_plugin_get_stage (MutterPlugin *plugin)
+meta_plugin_get_stage (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  return mutter_get_stage_for_screen (priv->screen);
+  return meta_get_stage_for_screen (priv->screen);
 }

 ClutterActor *
-mutter_plugin_get_window_group (MutterPlugin *plugin)
+meta_plugin_get_window_group (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  return mutter_get_window_group_for_screen (priv->screen);
+  return meta_get_window_group_for_screen (priv->screen);
+}
+
+ClutterActor *
+meta_plugin_get_background_actor (MetaPlugin *plugin)
+{
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;
+
+  return meta_get_background_actor_for_screen (priv->screen);
 }

 /**
- * _mutter_plugin_effect_started:
+ * _meta_plugin_effect_started:
 * @plugin: the plugin
 *
 * Mark that an effect has started for the plugin. This is called
- * internally by MutterPluginManager.
+ * internally by MetaPluginManager.
 */
 void
-_mutter_plugin_effect_started (MutterPlugin *plugin)
+_meta_plugin_effect_started (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  priv->running++;
 }

 void
-mutter_plugin_switch_workspace_completed (MutterPlugin *plugin)
+meta_plugin_switch_workspace_completed (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  MetaScreen *screen = mutter_plugin_get_screen (plugin);
+  MetaScreen *screen = meta_plugin_get_screen (plugin);

  if (priv->running-- < 0)
    {
@@ -379,15 +387,15 @@ mutter_plugin_switch_workspace_completed (MutterPlugin *plugin)
      priv->running = 0;
    }

-  mutter_switch_workspace_completed (screen);
+  meta_switch_workspace_completed (screen);
 }

 static void
-mutter_plugin_window_effect_completed (MutterPlugin *plugin,
-                                       MutterWindow *actor,
-                                       unsigned long event)
+meta_plugin_window_effect_completed (MetaPlugin      *plugin,
+                                     MetaWindowActor *actor,
+                                     unsigned long    event)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  if (priv->running-- < 0)
    {
@@ -397,82 +405,82 @@ mutter_plugin_window_effect_completed (MutterPlugin *plugin,

  if (!actor)
    {
-      const MutterPluginInfo *info;
+      const MetaPluginInfo *info;
      const gchar            *name = NULL;

-      if (plugin && (info = mutter_plugin_get_info (plugin)))
+      if (plugin && (info = meta_plugin_get_info (plugin)))
        name = info->name;

      g_warning ("Plugin [%s] passed NULL for actor!",
                 name ? name : "unknown");
    }

-  mutter_window_effect_completed (actor, event);
+  meta_window_actor_effect_completed (actor, event);
 }

 void
-mutter_plugin_minimize_completed (MutterPlugin *plugin,
-                                  MutterWindow *actor)
+meta_plugin_minimize_completed (MetaPlugin      *plugin,
+                                MetaWindowActor *actor)
 {
-  mutter_plugin_window_effect_completed (plugin, actor, MUTTER_PLUGIN_MINIMIZE);
+  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_MINIMIZE);
 }

 void
-mutter_plugin_maximize_completed (MutterPlugin *plugin,
-                                  MutterWindow *actor)
+meta_plugin_maximize_completed (MetaPlugin      *plugin,
+                                MetaWindowActor *actor)
 {
-  mutter_plugin_window_effect_completed (plugin, actor, MUTTER_PLUGIN_MAXIMIZE);
+  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_MAXIMIZE);
 }

 void
-mutter_plugin_unmaximize_completed (MutterPlugin *plugin,
-                                    MutterWindow *actor)
+meta_plugin_unmaximize_completed (MetaPlugin      *plugin,
+                                  MetaWindowActor *actor)
 {
-  mutter_plugin_window_effect_completed (plugin, actor, MUTTER_PLUGIN_UNMAXIMIZE);
+  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_UNMAXIMIZE);
 }

 void
-mutter_plugin_map_completed (MutterPlugin *plugin,
-                             MutterWindow *actor)
+meta_plugin_map_completed (MetaPlugin      *plugin,
+                           MetaWindowActor *actor)
 {
-  mutter_plugin_window_effect_completed (plugin, actor, MUTTER_PLUGIN_MAP);
+  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_MAP);
 }

 void
-mutter_plugin_destroy_completed (MutterPlugin *plugin,
-                                 MutterWindow *actor)
+meta_plugin_destroy_completed (MetaPlugin      *plugin,
+                               MetaWindowActor *actor)
 {
-  mutter_plugin_window_effect_completed (plugin, actor, MUTTER_PLUGIN_DESTROY);
+  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_DESTROY);
 }

 void
-mutter_plugin_query_screen_size (MutterPlugin *plugin,
-                                 int          *width,
-                                 int          *height)
+meta_plugin_query_screen_size (MetaPlugin *plugin,
+                               int        *width,
+                               int        *height)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  meta_screen_get_size (priv->screen, width, height);
 }

 void
-mutter_plugin_set_stage_reactive (MutterPlugin *plugin,
-                                  gboolean      reactive)
+meta_plugin_set_stage_reactive (MetaPlugin *plugin,
+                                gboolean    reactive)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;
  MetaScreen  *screen  = priv->screen;

  if (reactive)
-    mutter_set_stage_input_region (screen, None);
+    meta_set_stage_input_region (screen, None);
  else
-    mutter_empty_stage_input_region (screen);
+    meta_empty_stage_input_region (screen);
 }

 void
-mutter_plugin_set_stage_input_area (MutterPlugin *plugin,
-                                    gint x, gint y, gint width, gint height)
+meta_plugin_set_stage_input_area (MetaPlugin *plugin,
+                                  gint x, gint y, gint width, gint height)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;
  MetaScreen   *screen  = priv->screen;
  MetaDisplay  *display = meta_screen_get_display (screen);
  Display      *xdpy    = meta_display_get_xdisplay (display);
@@ -485,43 +493,43 @@ mutter_plugin_set_stage_input_area (MutterPlugin *plugin,
  rect.height = height;

  region = XFixesCreateRegion (xdpy, &rect, 1);
-  mutter_set_stage_input_region (screen, region);
+  meta_set_stage_input_region (screen, region);
  XFixesDestroyRegion (xdpy, region);
 }

 void
-mutter_plugin_set_stage_input_region (MutterPlugin *plugin,
-                                      XserverRegion region)
+meta_plugin_set_stage_input_region (MetaPlugin   *plugin,
+                                    XserverRegion region)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;
  MetaScreen  *screen  = priv->screen;

-  mutter_set_stage_input_region (screen, region);
+  meta_set_stage_input_region (screen, region);
 }

 /**
- * mutter_plugin_get_windows:
- * @plugin: A #MutterPlugin
+ * meta_plugin_get_window_actors:
+ * @plugin: A #MetaPlugin
 *
- * This function returns all of the #MutterWindow objects referenced by Mutter, including
+ * This function returns all of the #MetaWindowActor objects referenced by Mutter, including
 * override-redirect windows.  The returned list is a snapshot of Mutter's current
 * stacking order, with the topmost window last.
 *
 * The 'restacked' signal of #MetaScreen signals when this value has changed.
 *
- * Returns: (transfer none) (element-type MutterWindow): Windows in stacking order, topmost last
+ * Returns: (transfer none) (element-type MetaWindowActor): Windows in stacking order, topmost last
 */
 GList *
-mutter_plugin_get_windows (MutterPlugin *plugin)
+meta_plugin_get_window_actors (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  return mutter_get_windows (priv->screen);
+  return meta_get_window_actors (priv->screen);
 }

 /**
- * mutter_plugin_begin_modal:
- * @plugin: a #MutterPlugin
+ * meta_plugin_begin_modal:
+ * @plugin: a #MetaPlugin
 * @grab_window: the X window to grab the keyboard and mouse on
 * @cursor: the cursor to use for the pointer grab, or None,
 *          to use the normal cursor for the grab window and
@@ -532,7 +540,7 @@ mutter_plugin_get_windows (MutterPlugin *plugin)
 * This function is used to grab the keyboard and mouse for the exclusive
 * use of the plugin. Correct operation requires that both the keyboard
 * and mouse are grabbed, or thing will break. (In particular, other
- * passive X grabs in Mutter can trigger but not be handled by the normal
+ * passive X grabs in Meta can trigger but not be handled by the normal
 * keybinding handling code.) However, the plugin can establish the keyboard
 * and/or mouse grabs ahead of time and pass in the
 * %META_MODAL_POINTER_ALREADY_GRABBED and/or %META_MODAL_KEYBOARD_ALREADY_GRABBED
@@ -545,21 +553,21 @@ mutter_plugin_get_windows (MutterPlugin *plugin)
 *  mouse and made the plugin modal.
 */
 gboolean
-mutter_plugin_begin_modal (MutterPlugin      *plugin,
-                           Window             grab_window,
-                           Cursor             cursor,
-                           MetaModalOptions   options,
-                           guint32            timestamp)
+meta_plugin_begin_modal (MetaPlugin       *plugin,
+                         Window            grab_window,
+                         Cursor            cursor,
+                         MetaModalOptions  options,
+                         guint32           timestamp)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  return mutter_begin_modal_for_plugin (priv->screen, plugin,
-                                        grab_window, cursor, options, timestamp);
+  return meta_begin_modal_for_plugin (priv->screen, plugin,
+                                      grab_window, cursor, options, timestamp);
 }

 /**
- * mutter_plugin_end_modal
- * @plugin: a #MutterPlugin
+ * meta_plugin_end_modal
+ * @plugin: a #MetaPlugin
 * @timestamp: the time used for releasing grabs
 *
 * Ends the modal operation begun with meta_plugin_begin_modal(). This
@@ -569,27 +577,27 @@ mutter_plugin_begin_modal (MutterPlugin      *plugin,
 * when beginnning the modal operation.
 */
 void
-mutter_plugin_end_modal (MutterPlugin *plugin,
-                         guint32       timestamp)
+meta_plugin_end_modal (MetaPlugin *plugin,
+                       guint32     timestamp)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

-  mutter_end_modal_for_plugin (priv->screen, plugin, timestamp);
+  meta_end_modal_for_plugin (priv->screen, plugin, timestamp);
 }

 Display *
-mutter_plugin_get_xdisplay (MutterPlugin *plugin)
+meta_plugin_get_xdisplay (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv    = MUTTER_PLUGIN (plugin)->priv;
-  MetaDisplay         *display = meta_screen_get_display (priv->screen);
-  Display             *xdpy    = meta_display_get_xdisplay (display);
+  MetaPluginPrivate *priv    = META_PLUGIN (plugin)->priv;
+  MetaDisplay       *display = meta_screen_get_display (priv->screen);
+  Display           *xdpy    = meta_display_get_xdisplay (display);

  return xdpy;
 }

 /**
- * mutter_plugin_get_screen:
- * @plugin: a #MutterPlugin
+ * meta_plugin_get_screen:
+ * @plugin: a #MetaPlugin
 *
 * Gets the #MetaScreen corresponding to a plugin. Each plugin instance
 * is associated with exactly one screen; if Metacity is managing
@@ -598,9 +606,9 @@ mutter_plugin_get_xdisplay (MutterPlugin *plugin)
 * Return value: (transfer none): the #MetaScreen for the plugin
 */
 MetaScreen *
-mutter_plugin_get_screen (MutterPlugin *plugin)
+meta_plugin_get_screen (MetaPlugin *plugin)
 {
-  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;

  return priv->screen;
 }
--- a/src/compositor/meta-shadow-factory-private.h
+++ b/src/compositor/meta-shadow-factory-private.h
@@ -0,0 +1,67 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MetaShadowFactory:
+ *
+ * Create and cache shadow textures for arbitrary window shapes
+ *
+ * Copyright (C) 2010 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_SHADOW_FACTORY_PRIVATE_H__
+#define __META_SHADOW_FACTORY_PRIVATE_H__
+
+#include <cairo.h>
+#include <clutter/clutter.h>
+#include "meta-window-shape.h"
+#include "meta-shadow-factory.h"
+
+/**
+ * MetaShadow:
+ * #MetaShadow holds a shadow texture along with information about how to
+ * apply that texture to draw a window texture. (E.g., it knows how big the
+ * unscaled borders are on each side of the shadow texture.)
+ */
+typedef struct _MetaShadow MetaShadow;
+
+MetaShadow *meta_shadow_ref         (MetaShadow            *shadow);
+void        meta_shadow_unref       (MetaShadow            *shadow);
+CoglHandle  meta_shadow_get_texture (MetaShadow            *shadow);
+void        meta_shadow_paint       (MetaShadow            *shadow,
+                                     int                    window_x,
+                                     int                    window_y,
+                                     int                    window_width,
+                                     int                    window_height,
+                                     guint8                 opacity,
+                                     cairo_region_t        *clip);
+void        meta_shadow_get_bounds  (MetaShadow            *shadow,
+                                     int                    window_x,
+                                     int                    window_y,
+                                     int                    window_width,
+                                     int                    window_height,
+                                     cairo_rectangle_int_t *bounds);
+
+MetaShadowFactory *meta_shadow_factory_new (void);
+
+MetaShadow *meta_shadow_factory_get_shadow (MetaShadowFactory *factory,
+                                            MetaWindowShape   *shape,
+                                            int                width,
+                                            int                height,
+                                            const char        *class_name,
+                                            gboolean           focused);
+
+#endif /* __META_SHADOW_FACTORY_PRIVATE_H__ */
--- a/src/compositor/meta-shadow-factory.c
+++ b/src/compositor/meta-shadow-factory.c
@@ -0,0 +1,989 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MetaShadowFactory:
+ *
+ * Create and cache shadow textures for abritrary window shapes
+ *
+ * Copyright 2010 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 <math.h>
+#include <string.h>
+
+#include "cogl-utils.h"
+#include "meta-shadow-factory-private.h"
+#include "region-utils.h"
+
+/* This file implements blurring the shape of a window to produce a
+ * shadow texture. The details are discussed below; a quick summary
+ * of the optimizations we use:
+ *
+ * - If the window shape is along the lines of a rounded rectangle -
+ *   a rectangular center portion with stuff at the corners - then
+ *   the blur of this - the shadow - can also be represented as a
+ *   9-sliced texture and the same texture can be used for different
+ *   size.
+ *
+ * - We use the fact that a Gaussian blur is separable to do a
+ *   2D blur as 1D blur of the rows followed by a 1D blur of the
+ *   columns.
+ *
+ * - For better cache efficiency, we blur rows, transpose the image
+ *   in blocks, blur rows again, and then transpose back.
+ *
+ * - We approximate the 1D gaussian blur as 3 successive box filters.
+ */
+
+typedef struct _MetaShadowCacheKey  MetaShadowCacheKey;
+typedef struct _MetaShadowClassInfo MetaShadowClassInfo;
+
+struct _MetaShadowCacheKey
+{
+  MetaWindowShape *shape;
+  int radius;
+  int top_fade;
+};
+
+struct _MetaShadow
+{
+  int ref_count;
+
+  MetaShadowFactory *factory;
+  MetaShadowCacheKey key;
+  CoglHandle texture;
+  CoglHandle material;
+
+  /* The outer order is the distance the shadow extends outside the window
+   * shape; the inner border is the unscaled portion inside the window
+   * shape */
+  int outer_border_top;
+  int inner_border_top;
+  int outer_border_right;
+  int inner_border_right;
+  int outer_border_bottom;
+  int inner_border_bottom;
+  int outer_border_left;
+  int inner_border_left;
+
+  guint scale_width : 1;
+  guint scale_height : 1;
+};
+
+struct _MetaShadowClassInfo
+{
+  const char *name; /* const so we can reuse for static definitions */
+  MetaShadowParams focused;
+  MetaShadowParams unfocused;
+};
+
+struct _MetaShadowFactory
+{
+  GObject parent_instance;
+
+  /* MetaShadowCacheKey => MetaShadow; the shadows are not referenced
+   * by the factory, they are simply removed from the table when freed */
+  GHashTable *shadows;
+
+  /* class name => MetaShadowClassInfo */
+  GHashTable *shadow_classes;
+};
+
+struct _MetaShadowFactoryClass
+{
+  GObjectClass parent_class;
+};
+
+enum
+{
+  CHANGED,
+
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+/* The first element in this array also defines the default parameters
+ * for newly created classes */
+MetaShadowClassInfo default_shadow_classes[] = {
+  { "normal",       { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+  { "dialog",       { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+  { "modal_dialog", { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+  { "utility",      { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+  { "border",       { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+  { "menu",         { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+
+  { "popup-menu",    { 6, -1, 0, 4, 255 }, { 6, -1, 0, 4, 255 } },
+
+  { "dropdown-menu", { 6, 25, 0, 4, 255 }, { 6, 100, 0, 4, 255 } },
+  { "attached",      { 6, 25, 0, 4, 255 }, { 6, 100, 0, 4, 255 } }
+};
+
+G_DEFINE_TYPE (MetaShadowFactory, meta_shadow_factory, G_TYPE_OBJECT);
+
+static guint
+meta_shadow_cache_key_hash (gconstpointer val)
+{
+  const MetaShadowCacheKey *key = val;
+
+  return 59 * key->radius + 67 * key->top_fade + 73 * meta_window_shape_hash (key->shape);
+}
+
+static gboolean
+meta_shadow_cache_key_equal (gconstpointer a,
+                             gconstpointer b)
+{
+  const MetaShadowCacheKey *key_a = a;
+  const MetaShadowCacheKey *key_b = b;
+
+  return (key_a->radius == key_b->radius && key_a->top_fade == key_b->top_fade &&
+          meta_window_shape_equal (key_a->shape, key_b->shape));
+}
+
+MetaShadow *
+meta_shadow_ref (MetaShadow *shadow)
+{
+  shadow->ref_count++;
+
+  return shadow;
+}
+
+void
+meta_shadow_unref (MetaShadow *shadow)
+{
+  shadow->ref_count--;
+  if (shadow->ref_count == 0)
+    {
+      if (shadow->factory)
+        {
+          g_hash_table_remove (shadow->factory->shadows,
+                               &shadow->key);
+        }
+
+      meta_window_shape_unref (shadow->key.shape);
+      cogl_handle_unref (shadow->texture);
+      cogl_handle_unref (shadow->material);
+
+      g_slice_free (MetaShadow, shadow);
+    }
+}
+
+/**
+ * meta_shadow_paint:
+ * @window_x: x position of the region to paint a shadow for
+ * @window_y: y position of the region to paint a shadow for
+ * @window_width: actual width of the region to paint a shadow for
+ * @window_height: actual height of the region to paint a shadow for
+ * @clip: (allow-none): if non-%NULL specifies the visible portion
+ *   of the shadow. Drawing won't be strictly clipped to this region
+ *   but it will be used to optimize what is drawn.
+ *
+ * Paints the shadow at the given position, for the specified actual
+ * size of the region. (Since a #MetaShadow can be shared between
+ * different sizes with the same extracted #MetaWindowShape the
+ * size needs to be passed in here.)
+ */
+void
+meta_shadow_paint (MetaShadow     *shadow,
+                   int             window_x,
+                   int             window_y,
+                   int             window_width,
+                   int             window_height,
+                   guint8          opacity,
+                   cairo_region_t *clip)
+{
+  float texture_width = cogl_texture_get_width (shadow->texture);
+  float texture_height = cogl_texture_get_height (shadow->texture);
+  int i, j;
+  float src_x[4];
+  float src_y[4];
+  int dest_x[4];
+  int dest_y[4];
+  int n_x, n_y;
+
+  cogl_material_set_color4ub (shadow->material,
+                              opacity, opacity, opacity, opacity);
+
+  cogl_set_source (shadow->material);
+
+  if (shadow->scale_width)
+    {
+      n_x = 3;
+
+      src_x[0] = 0.0;
+      src_x[1] = (shadow->inner_border_left + shadow->outer_border_left) / texture_width;
+      src_x[2] = (texture_width - (shadow->inner_border_right + shadow->outer_border_right)) / texture_width;
+      src_x[3] = 1.0;
+
+      dest_x[0] = window_x - shadow->outer_border_left;
+      dest_x[1] = window_x + shadow->inner_border_left;
+      dest_x[2] = window_x + window_width - shadow->inner_border_right;
+      dest_x[3] = window_x + window_width + shadow->outer_border_right;
+    }
+  else
+    {
+      n_x = 1;
+
+      src_x[0] = 0.0;
+      src_x[1] = 1.0;
+
+      dest_x[0] = window_x - shadow->outer_border_left;
+      dest_x[1] = window_x + window_width + shadow->outer_border_right;
+    }
+
+  if (shadow->scale_height)
+    {
+      n_y = 3;
+
+      src_y[0] = 0.0;
+      src_y[1] = (shadow->inner_border_top + shadow->outer_border_top) / texture_height;
+      src_y[2] = (texture_height - (shadow->inner_border_bottom + shadow->outer_border_bottom)) / texture_height;
+      src_y[3] = 1.0;
+
+      dest_y[0] = window_y - shadow->outer_border_top;
+      dest_y[1] = window_y + shadow->inner_border_top;
+      dest_y[2] = window_y + window_height - shadow->inner_border_bottom;
+      dest_y[3] = window_y + window_height + shadow->outer_border_bottom;
+    }
+  else
+    {
+      n_y = 1;
+
+      src_y[0] = 0.0;
+      src_y[1] = 1.0;
+
+      dest_y[0] = window_y - shadow->outer_border_top;
+      dest_y[1] = window_y + window_height + shadow->outer_border_bottom;
+    }
+
+  for (j = 0; j < n_y; j++)
+    {
+      cairo_rectangle_int_t dest_rect;
+      dest_rect.y = dest_y[j];
+      dest_rect.height = dest_y[j + 1] - dest_y[j];
+
+      for (i = 0; i < n_x; i++)
+        {
+          cairo_region_overlap_t overlap;
+
+          dest_rect.x = dest_x[i];
+          dest_rect.width = dest_x[i + 1] - dest_x[i];
+
+          if (clip)
+            overlap = cairo_region_contains_rectangle (clip, &dest_rect);
+          else
+            overlap = CAIRO_REGION_OVERLAP_PART;
+
+          if (overlap != CAIRO_REGION_OVERLAP_OUT)
+            cogl_rectangle_with_texture_coords (dest_x[i], dest_y[j],
+                                                dest_x[i + 1], dest_y[j + 1],
+                                                src_x[i], src_y[j],
+                                                src_x[i + 1], src_y[j + 1]);
+        }
+    }
+}
+
+/**
+ * meta_shadow_get_bounds:
+ * @shadow: a #MetaShadow
+ * @window_x: x position of the region to paint a shadow for
+ * @window_y: y position of the region to paint a shadow for
+ * @window_width: actual width of the region to paint a shadow for
+ * @window_height: actual height of the region to paint a shadow for
+ *
+ * Computes the bounds of the pixels that will be affected by
+ * meta_shadow_paints()
+ */
+void
+meta_shadow_get_bounds  (MetaShadow            *shadow,
+                         int                    window_x,
+                         int                    window_y,
+                         int                    window_width,
+                         int                    window_height,
+                         cairo_rectangle_int_t *bounds)
+{
+  bounds->x = window_x - shadow->outer_border_left;
+  bounds->y = window_x - shadow->outer_border_top;
+  bounds->width = window_width + shadow->outer_border_left + shadow->outer_border_right;
+  bounds->height = window_height + shadow->outer_border_top + shadow->outer_border_bottom;
+}
+
+static void
+meta_shadow_class_info_free (MetaShadowClassInfo *class_info)
+{
+  g_free ((char *)class_info->name);
+  g_slice_free (MetaShadowClassInfo, class_info);
+}
+
+static void
+meta_shadow_factory_init (MetaShadowFactory *factory)
+{
+  guint i;
+
+  factory->shadows = g_hash_table_new (meta_shadow_cache_key_hash,
+                                       meta_shadow_cache_key_equal);
+
+  factory->shadow_classes = g_hash_table_new_full (g_str_hash,
+                                                   g_str_equal,
+                                                   NULL,
+                                                   (GDestroyNotify)meta_shadow_class_info_free);
+
+  for (i = 0; i < G_N_ELEMENTS (default_shadow_classes); i++)
+    {
+      MetaShadowClassInfo *class_info = g_slice_new (MetaShadowClassInfo);
+
+      *class_info = default_shadow_classes[i];
+      class_info->name = g_strdup (class_info->name);
+
+      g_hash_table_insert (factory->shadow_classes,
+                           (char *)class_info->name, class_info);
+    }
+}
+
+static void
+meta_shadow_factory_finalize (GObject *object)
+{
+  MetaShadowFactory *factory = META_SHADOW_FACTORY (object);
+  GHashTableIter iter;
+  gpointer key, value;
+
+  /* Detach from the shadows in the table so we won't try to
+   * remove them when they're freed. */
+  g_hash_table_iter_init (&iter, factory->shadows);
+  while (g_hash_table_iter_next (&iter, &key, &value))
+    {
+      MetaShadow *shadow = key;
+      shadow->factory = NULL;
+    }
+
+  g_hash_table_destroy (factory->shadows);
+  g_hash_table_destroy (factory->shadow_classes);
+
+  G_OBJECT_CLASS (meta_shadow_factory_parent_class)->finalize (object);
+}
+
+static void
+meta_shadow_factory_class_init (MetaShadowFactoryClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = meta_shadow_factory_finalize;
+
+  signals[CHANGED] =
+    g_signal_new ("changed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+}
+
+MetaShadowFactory *
+meta_shadow_factory_new (void)
+{
+  return g_object_new (META_TYPE_SHADOW_FACTORY, NULL);
+}
+
+/**
+ * meta_shadow_factory_get_default:
+ *
+ * Return value: (transfer none): the global singleton shadow factory
+ */
+MetaShadowFactory *
+meta_shadow_factory_get_default (void)
+{
+  static MetaShadowFactory *factory;
+
+  if (factory == NULL)
+    factory = meta_shadow_factory_new ();
+
+  return factory;
+}
+
+/* We emulate a 1D Gaussian blur by using 3 consecutive box blurs;
+ * this produces a result that's within 3% of the original and can be
+ * implemented much faster for large filter sizes because of the
+ * efficiency of implementation of a box blur. Idea and formula
+ * for choosing the box blur size come from:
+ *
+ * http://www.w3.org/TR/SVG/filters.html#feGaussianBlurElement
+ *
+ * The 2D blur is then done by blurring the rows, flipping the
+ * image and blurring the columns. (This is possible because the
+ * Gaussian kernel is separable - it's the product of a horizontal
+ * blur and a vertical blur.)
+ */
+static int
+get_box_filter_size (int radius)
+{
+  return (int)(0.5 + radius * (0.75 * sqrt(2*M_PI)));
+}
+
+/* The "spread" of the filter is the number of pixels from an original
+ * pixel that it's blurred image extends. (A no-op blur that doesn't
+ * blur would have a spread of 0.) See comment in blur_rows() for why the
+ * odd and even cases are different
+ */
+static int
+get_shadow_spread (int radius)
+{
+  int d = get_box_filter_size (radius);
+
+  if (d % 2 == 1)
+    return 3 * (d / 2);
+  else
+    return 3 * (d / 2) - 1;
+}
+
+/* This applies a single box blur pass to a horizontal range of pixels;
+ * since the box blur has the same weight for all pixels, we can
+ * implement an efficient sliding window algorithm where we add
+ * in pixels coming into the window from the right and remove
+ * them when they leave the windw to the left.
+ *
+ * d is the filter width; for even d shift indicates how the blurred
+ * result is aligned with the original - does ' x ' go to ' yy' (shift=1)
+ * or 'yy ' (shift=-1)
+ */
+static void
+blur_xspan (guchar *row,
+            guchar *tmp_buffer,
+            int     row_width,
+            int     x0,
+            int     x1,
+            int     d,
+            int     shift)
+{
+  int offset;
+  int sum = 0;
+  int i;
+
+  if (d % 2 == 1)
+    offset = d / 2;
+  else
+    offset = (d - shift) / 2;
+
+  /* All the conditionals in here look slow, but the branches will
+   * be well predicted and there are enough different possibilities
+   * that trying to write this as a series of unconditional loops
+   * is hard and not an obvious win. The main slow down here seems
+   * to be the integer division for pixel; one possible optimization
+   * would be to accumulate into two 16-bit integer buffers and
+   * only divide down after all three passes. (SSE parallel implementation
+   * of the divide step is possible.)
+   */
+  for (i = x0 - d + offset; i < x1 + offset; i++)
+    {
+      if (i >= 0 && i < row_width)
+	sum += row[i];
+
+      if (i >= x0 + offset)
+	{
+	  if (i >= d)
+	    sum -= row[i - d];
+
+	  tmp_buffer[i - offset] = (sum + d / 2) / d;
+	}
+    }
+
+  memcpy(row + x0, tmp_buffer + x0, x1 - x0);
+}
+
+static void
+blur_rows (cairo_region_t   *convolve_region,
+           int               x_offset,
+           int               y_offset,
+	   guchar           *buffer,
+	   int               buffer_width,
+	   int               buffer_height,
+           int               d)
+{
+  int i, j;
+  int n_rectangles;
+  guchar *tmp_buffer;
+
+  tmp_buffer = g_malloc (buffer_width);
+
+  n_rectangles = cairo_region_num_rectangles (convolve_region);
+  for (i = 0; i < n_rectangles; i++)
+    {
+      cairo_rectangle_int_t rect;
+
+      cairo_region_get_rectangle (convolve_region, i, &rect);
+
+      for (j = y_offset + rect.y; j < y_offset + rect.y + rect.height; j++)
+	{
+	  guchar *row = buffer + j * buffer_width;
+	  int x0 = x_offset + rect.x;
+	  int x1 = x0 + rect.width;
+
+          /* We want to produce a symmetric blur that spreads a pixel
+           * equally far to the left and right. If d is odd that happens
+           * naturally, but for d even, we approximate by using a blur
+           * on either side and then a centered blur of size d + 1.
+           * (techique also from the SVG specification)
+           */
+	  if (d % 2 == 1)
+	    {
+	      blur_xspan (row, tmp_buffer, buffer_width, x0, x1, d, 0);
+	      blur_xspan (row, tmp_buffer, buffer_width, x0, x1, d, 0);
+	      blur_xspan (row, tmp_buffer, buffer_width, x0, x1, d, 0);
+	    }
+	  else
+	    {
+	      blur_xspan (row, tmp_buffer, buffer_width, x0, x1, d, 1);
+	      blur_xspan (row, tmp_buffer, buffer_width, x0, x1, d, -1);
+	      blur_xspan (row, tmp_buffer, buffer_width, x0, x1, d + 1, 0);
+	    }
+	}
+    }
+
+  g_free (tmp_buffer);
+}
+
+static void
+fade_bytes (guchar *bytes,
+            int     width,
+            int     distance,
+            int     total)
+{
+  guint32 multiplier = (distance * 0x10000 + 0x8000) / total;
+  int i;
+
+  for (i = 0; i < width; i++)
+    bytes[i] = (bytes[i] * multiplier) >> 16;
+}
+
+/* Swaps width and height. Either swaps in-place and returns the original
+ * buffer or allocates a new buffer, frees the original buffer and returns
+ * the new buffer.
+ */
+static guchar *
+flip_buffer (guchar *buffer,
+	     int     width,
+             int     height)
+{
+  /* Working in blocks increases cache efficiency, compared to reading
+   * or writing an entire column at once */
+#define BLOCK_SIZE 16
+
+  if (width == height)
+    {
+      int i0, j0;
+
+      for (j0 = 0; j0 < height; j0 += BLOCK_SIZE)
+	for (i0 = 0; i0 <= j0; i0 += BLOCK_SIZE)
+	  {
+	    int max_j = MIN(j0 + BLOCK_SIZE, height);
+	    int max_i = MIN(i0 + BLOCK_SIZE, width);
+	    int i, j;
+
+	    if (i0 == j0)
+	      {
+		for (j = j0; j < max_j; j++)
+		  for (i = i0; i < j; i++)
+		    {
+		      guchar tmp = buffer[j * width + i];
+		      buffer[j * width + i] = buffer[i * width + j];
+		      buffer[i * width + j] = tmp;
+		    }
+	      }
+	    else
+	      {
+		for (j = j0; j < max_j; j++)
+		  for (i = i0; i < max_i; i++)
+		    {
+		      guchar tmp = buffer[j * width + i];
+		      buffer[j * width + i] = buffer[i * width + j];
+		      buffer[i * width + j] = tmp;
+		    }
+	      }
+	  }
+
+      return buffer;
+    }
+  else
+    {
+      guchar *new_buffer = g_malloc (height * width);
+      int i0, j0;
+
+      for (i0 = 0; i0 < width; i0 += BLOCK_SIZE)
+        for (j0 = 0; j0 < height; j0 += BLOCK_SIZE)
+	  {
+	    int max_j = MIN(j0 + BLOCK_SIZE, height);
+	    int max_i = MIN(i0 + BLOCK_SIZE, width);
+	    int i, j;
+
+            for (i = i0; i < max_i; i++)
+              for (j = j0; j < max_j; j++)
+		new_buffer[i * height + j] = buffer[j * width + i];
+	  }
+
+      g_free (buffer);
+
+      return new_buffer;
+    }
+#undef BLOCK_SIZE
+}
+
+static void
+make_shadow (MetaShadow     *shadow,
+             cairo_region_t *region)
+{
+  int d = get_box_filter_size (shadow->key.radius);
+  int spread = get_shadow_spread (shadow->key.radius);
+  cairo_rectangle_int_t extents;
+  cairo_region_t *row_convolve_region;
+  cairo_region_t *column_convolve_region;
+  guchar *buffer;
+  int buffer_width;
+  int buffer_height;
+  int x_offset;
+  int y_offset;
+  int n_rectangles, j, k;
+
+  cairo_region_get_extents (region, &extents);
+
+  /* In the case where top_fade >= 0 and the portion above the top
+   * edge of the shape will be cropped, it seems like we could create
+   * a smaller buffer and omit the top portion, but actually, in our
+   * multi-pass blur algorithm, the blur into the area above the window
+   * in the first pass will contribute back to the final pixel values
+   * for the top pixels, so we create a buffer as if we weren't cropping
+   * and only crop when creating the CoglTexture.
+   */
+
+  buffer_width = extents.width + 2 * spread;
+  buffer_height = extents.height + 2 * spread;
+
+  /* Round up so we have aligned rows/columns */
+  buffer_width = (buffer_width + 3) & ~3;
+  buffer_height = (buffer_height + 3) & ~3;
+
+  /* Square buffer allows in-place swaps, which are roughly 70% faster, but we
+   * don't want to over-allocate too much memory.
+   */
+  if (buffer_height < buffer_width && buffer_height > (3 * buffer_width) / 4)
+    buffer_height = buffer_width;
+  if (buffer_width < buffer_height && buffer_width > (3 * buffer_height) / 4)
+    buffer_width = buffer_height;
+
+  buffer = g_malloc0 (buffer_width * buffer_height);
+
+  /* Blurring with multiple box-blur passes is fast, but (especially for
+   * large shadow sizes) we can improve efficiency by restricting the blur
+   * to the region that actually needs to be blurred.
+   */
+  row_convolve_region = meta_make_border_region (region, spread, spread, FALSE);
+  column_convolve_region = meta_make_border_region (region, 0, spread, TRUE);
+
+  /* Offsets between coordinates of the regions and coordinates in the buffer */
+  x_offset = spread;
+  y_offset = spread;
+
+  /* Step 1: unblurred image */
+  n_rectangles = cairo_region_num_rectangles (region);
+  for (k = 0; k < n_rectangles; k++)
+    {
+      cairo_rectangle_int_t rect;
+
+      cairo_region_get_rectangle (region, k, &rect);
+      for (j = y_offset + rect.y; j < y_offset + rect.y + rect.height; j++)
+	memset (buffer + buffer_width * j + x_offset + rect.x, 255, rect.width);
+    }
+
+  /* Step 2: swap rows and columns */
+  buffer = flip_buffer (buffer, buffer_width, buffer_height);
+
+  /* Step 3: blur rows (really columns) */
+  blur_rows (column_convolve_region, y_offset, x_offset,
+             buffer, buffer_height, buffer_width,
+             d);
+
+  /* Step 4: swap rows and columns */
+  buffer = flip_buffer (buffer, buffer_height, buffer_width);
+
+  /* Step 5: blur rows */
+  blur_rows (row_convolve_region, x_offset, y_offset,
+             buffer, buffer_width, buffer_height,
+             d);
+
+  /* Step 6: fade out the top, if applicable */
+  if (shadow->key.top_fade >= 0)
+    {
+      for (j = y_offset; j < y_offset + MIN (shadow->key.top_fade, extents.height + shadow->outer_border_bottom); j++)
+        fade_bytes(buffer + j * buffer_width, buffer_width, j - y_offset, shadow->key.top_fade);
+    }
+
+  /* We offset the passed in pixels to crop off the extra area we allocated at the top
+   * in the case of top_fade >= 0. We also account for padding at the left for symmetry
+   * though that doesn't currently occur.
+   */
+  shadow->texture = cogl_texture_new_from_data (shadow->outer_border_left + extents.width + shadow->outer_border_right,
+                                                shadow->outer_border_top + extents.height + shadow->outer_border_bottom,
+                                                COGL_TEXTURE_NONE,
+                                                COGL_PIXEL_FORMAT_A_8,
+                                                COGL_PIXEL_FORMAT_ANY,
+                                                buffer_width,
+                                                (buffer +
+                                                 (y_offset - shadow->outer_border_top) * buffer_width +
+                                                 (x_offset - shadow->outer_border_left)));
+
+  cairo_region_destroy (row_convolve_region);
+  cairo_region_destroy (column_convolve_region);
+  g_free (buffer);
+
+  shadow->material = meta_create_texture_material (shadow->texture);
+}
+
+static MetaShadowParams *
+get_shadow_params (MetaShadowFactory *factory,
+                   const char        *class_name,
+                   gboolean           focused,
+                   gboolean           create)
+{
+  MetaShadowClassInfo *class_info = g_hash_table_lookup (factory->shadow_classes,
+                                                         class_name);
+  if (class_info == NULL)
+    {
+      if (create)
+        {
+          class_info = g_slice_new0 (MetaShadowClassInfo);
+          *class_info = default_shadow_classes[0];
+          class_info->name = g_strdup (class_info->name);
+
+          g_hash_table_insert (factory->shadow_classes,
+                               (char *)class_info->name, class_info);
+        }
+      else
+        {
+          class_info = &default_shadow_classes[0];
+        }
+    }
+
+  if (focused)
+    return &class_info->focused;
+  else
+    return &class_info->unfocused;
+}
+
+/**
+ * meta_shadow_factory_get_shadow:
+ * @factory: a #MetaShadowFactory
+ * @shape: the size-invariant shape of the window's region
+ * @width: the actual width of the window's region
+ * @height: the actual height of the window's region
+ * @class_name: name of the class of window shadows
+ * @focused: whether the shadow is for a focused window
+ *
+ * Gets the appropriate shadow object for drawing shadows for the
+ * specified window shape. The region that we are shadowing is specified
+ * as a combination of a size-invariant extracted shape and the size.
+ * In some cases, the same shadow object can be shared between sizes;
+ * in other cases a different shadow object is used for each size.
+ *
+ * Return value: (transfer full): a newly referenced #MetaShadow; unref with
+ *  meta_shadow_unref()
+ */
+MetaShadow *
+meta_shadow_factory_get_shadow (MetaShadowFactory *factory,
+                                MetaWindowShape   *shape,
+                                int                width,
+                                int                height,
+                                const char        *class_name,
+                                gboolean           focused)
+{
+  MetaShadowParams *params;
+  MetaShadowCacheKey key;
+  MetaShadow *shadow;
+  cairo_region_t *region;
+  int spread;
+  int shape_border_top, shape_border_right, shape_border_bottom, shape_border_left;
+  int inner_border_top, inner_border_right, inner_border_bottom, inner_border_left;
+  int outer_border_top, outer_border_right, outer_border_bottom, outer_border_left;
+  gboolean scale_width, scale_height;
+  gboolean cacheable;
+  int center_width, center_height;
+
+  g_return_val_if_fail (META_IS_SHADOW_FACTORY (factory), NULL);
+  g_return_val_if_fail (shape != NULL, NULL);
+
+  /* Using a single shadow texture for different window sizes only works
+   * when there is a central scaled area that is greater than twice
+   * the spread of the gaussian blur we are applying to get to the
+   * shadow image.
+   *                         *********          ***********
+   *  /----------\         *###########*      *#############*
+   *  |          |   =>   **#*********#** => **#***********#**
+   *  |          |        **#**     **#**    **#**       **#**
+   *  |          |        **#*********#**    **#***********#**
+   *  \----------/         *###########*      *#############*
+   *                         **********         ************
+   *   Original                Blur            Stretched Blur
+   *
+   * For smaller sizes, we create a separate shadow image for each size;
+   * since we assume that there will be little reuse, we don't try to
+   * cache such images but just recreate them. (Since the current cache
+   * policy is to only keep around referenced shadows, there wouldn't
+   * be any harm in caching them, it would just make the book-keeping
+   * a bit tricker.)
+   *
+   * In the case where we are fading a the top, that also has to fit
+   * within the top unscaled border.
+   */
+
+  params = get_shadow_params (factory, class_name, focused, FALSE);
+
+  spread = get_shadow_spread (params->radius);
+  meta_window_shape_get_borders (shape,
+                                 &shape_border_top,
+                                 &shape_border_right,
+                                 &shape_border_bottom,
+                                 &shape_border_left);
+
+  inner_border_top = MAX (shape_border_top + spread, params->top_fade);
+  outer_border_top = params->top_fade >= 0 ? 0 : spread;
+  inner_border_right = shape_border_right + spread;
+  outer_border_right = spread;
+  inner_border_bottom = shape_border_bottom + spread;
+  outer_border_bottom = spread;
+  inner_border_left = shape_border_left + spread;
+  outer_border_left = spread;
+
+  scale_width = inner_border_left + inner_border_right <= width;
+  scale_height = inner_border_top + inner_border_bottom <= height;
+  cacheable = scale_width && scale_height;
+
+  if (cacheable)
+    {
+      key.shape = shape;
+      key.radius = params->radius;
+      key.top_fade = params->top_fade;
+
+      shadow = g_hash_table_lookup (factory->shadows, &key);
+      if (shadow)
+        return meta_shadow_ref (shadow);
+    }
+
+  shadow = g_slice_new0 (MetaShadow);
+
+  shadow->ref_count = 1;
+  shadow->factory = factory;
+  shadow->key.shape = meta_window_shape_ref (shape);
+  shadow->key.radius = params->radius;
+  shadow->key.top_fade = params->top_fade;
+
+  shadow->outer_border_top = outer_border_top;
+  shadow->inner_border_top = inner_border_top;
+  shadow->outer_border_right = outer_border_right;
+  shadow->inner_border_right = inner_border_right;
+  shadow->outer_border_bottom = outer_border_bottom;
+  shadow->inner_border_bottom = inner_border_bottom;
+  shadow->outer_border_left = outer_border_left;
+  shadow->inner_border_left = inner_border_left;
+
+  shadow->scale_width = scale_width;
+  if (scale_width)
+    center_width = inner_border_left + inner_border_right - (shape_border_left + shape_border_right);
+  else
+    center_width = width - (shape_border_left + shape_border_right);
+
+  shadow->scale_height = scale_height;
+  if (scale_height)
+    center_height = inner_border_top + inner_border_bottom - (shape_border_top + shape_border_bottom);
+  else
+    center_height = height - (shape_border_top + shape_border_bottom);
+
+  g_assert (center_width >= 0 && center_height >= 0);
+
+  region = meta_window_shape_to_region (shape, center_width, center_height);
+  make_shadow (shadow, region);
+
+  cairo_region_destroy (region);
+
+  if (cacheable)
+    g_hash_table_insert (factory->shadows, &shadow->key, shadow);
+
+  return shadow;
+}
+
+/**
+ * meta_shadow_factory_set_params:
+ * @factory: a #MetaShadowFactory
+ * @class_name: name of the class of shadow to set the params for.
+ *  the default shadow classes are the names of the different
+ *  theme frame types (normal, dialog, modal_dialog, utility,
+ *  border, menu, attached) and in addition, popup-menu
+ *  and dropdown-menu.
+ * @focused: whether the shadow is for a focused window
+ * @params: new parameter values
+ *
+ * Updates the shadow parameters for a particular class of shadows
+ * for either the focused or unfocused state. If the class name
+ * does not name an existing class, a new class will be created
+ * (the other focus state for that class will have default values
+ * assigned to it.)
+ */
+void
+meta_shadow_factory_set_params (MetaShadowFactory *factory,
+                                const char        *class_name,
+                                gboolean           focused,
+                                MetaShadowParams  *params)
+{
+  MetaShadowParams *stored_params;
+
+  g_return_if_fail (META_IS_SHADOW_FACTORY (factory));
+  g_return_if_fail (class_name != NULL);
+  g_return_if_fail (params != NULL);
+  g_return_if_fail (params->radius >= 0);
+
+  stored_params = get_shadow_params (factory, class_name, focused, TRUE);
+
+  *stored_params = *params;
+
+  g_signal_emit (factory, signals[CHANGED], 0);
+}
+
+/**
+ * meta_shadow_factory_get_params:
+ * @factory: a #MetaShadowFactory
+ * @class_name: name of the class of shadow to get the params for
+ * @focused: whether the shadow is for a focused window
+ * @params: (out caller-allocates): location to store the current parameter values
+ *
+ * Gets the shadow parameters for a particular class of shadows
+ * for either the focused or unfocused state. If the class name
+ * does not name an existing class, default values will be returned
+ * without printing an error.
+ */
+void
+meta_shadow_factory_get_params (MetaShadowFactory *factory,
+                                const char        *class_name,
+                                gboolean           focused,
+                                MetaShadowParams  *params)
+{
+  MetaShadowParams *stored_params;
+
+  g_return_if_fail (META_IS_SHADOW_FACTORY (factory));
+  g_return_if_fail (class_name != NULL);
+
+  stored_params = get_shadow_params (factory, class_name, focused, FALSE);
+
+  if (params)
+    *params = *stored_params;
+}
--- a/src/compositor/mutter-shaped-texture.c
+++ b/src/compositor/mutter-shaped-texture.c
@@ -25,50 +25,50 @@

 #include <config.h>

-#include "mutter-shaped-texture.h"
-#include "mutter-texture-tower.h"
+#include "meta-shaped-texture.h"
+#include "meta-texture-tower.h"

 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
 #include <string.h>

-static void mutter_shaped_texture_dispose (GObject *object);
-static void mutter_shaped_texture_finalize (GObject *object);
-static void mutter_shaped_texture_notify (GObject *object,
+static void meta_shaped_texture_dispose  (GObject    *object);
+static void meta_shaped_texture_finalize (GObject    *object);
+static void meta_shaped_texture_notify   (GObject    *object,
 					  GParamSpec *pspec);

-static void mutter_shaped_texture_paint (ClutterActor *actor);
-static void mutter_shaped_texture_pick (ClutterActor *actor,
-					const ClutterColor *color);
+static void meta_shaped_texture_paint (ClutterActor       *actor);
+static void meta_shaped_texture_pick  (ClutterActor       *actor,
+				       const ClutterColor *color);

-static void mutter_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
-                                               int                      x,
-                                               int                      y,
-                                               int                      width,
-                                               int                      height);
+static void meta_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
+					     int                      x,
+					     int                      y,
+					     int                      width,
+					     int                      height);

-static void mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex);
+static void meta_shaped_texture_dirty_mask (MetaShapedTexture *stex);

 #ifdef HAVE_GLX_TEXTURE_PIXMAP
-G_DEFINE_TYPE (MutterShapedTexture, mutter_shaped_texture,
+G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
               CLUTTER_GLX_TYPE_TEXTURE_PIXMAP);
 #else /* HAVE_GLX_TEXTURE_PIXMAP */
-G_DEFINE_TYPE (MutterShapedTexture, mutter_shaped_texture,
+G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
               CLUTTER_X11_TYPE_TEXTURE_PIXMAP);
 #endif /* HAVE_GLX_TEXTURE_PIXMAP */

-#define MUTTER_SHAPED_TEXTURE_GET_PRIVATE(obj) \
-  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), MUTTER_TYPE_SHAPED_TEXTURE, \
-                                MutterShapedTexturePrivate))
+#define META_SHAPED_TEXTURE_GET_PRIVATE(obj) \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_SHAPED_TEXTURE, \
+                                MetaShapedTexturePrivate))

-struct _MutterShapedTexturePrivate
+struct _MetaShapedTexturePrivate
 {
-  MutterTextureTower *paint_tower;
+  MetaTextureTower *paint_tower;
  CoglHandle mask_texture;
  CoglHandle material;
  CoglHandle material_unshaped;

-  MetaRegion *clip_region;
+  cairo_region_t *clip_region;

  guint mask_width, mask_height;

@@ -78,49 +78,49 @@ struct _MutterShapedTexturePrivate
 };

 static void
-mutter_shaped_texture_class_init (MutterShapedTextureClass *klass)
+meta_shaped_texture_class_init (MetaShapedTextureClass *klass)
 {
  GObjectClass *gobject_class = (GObjectClass *) klass;
  ClutterActorClass *actor_class = (ClutterActorClass *) klass;
  ClutterX11TexturePixmapClass *x11_texture_class = (ClutterX11TexturePixmapClass *) klass;

-  gobject_class->dispose = mutter_shaped_texture_dispose;
-  gobject_class->finalize = mutter_shaped_texture_finalize;
-  gobject_class->notify = mutter_shaped_texture_notify;
+  gobject_class->dispose = meta_shaped_texture_dispose;
+  gobject_class->finalize = meta_shaped_texture_finalize;
+  gobject_class->notify = meta_shaped_texture_notify;

-  actor_class->paint = mutter_shaped_texture_paint;
-  actor_class->pick = mutter_shaped_texture_pick;
+  actor_class->paint = meta_shaped_texture_paint;
+  actor_class->pick = meta_shaped_texture_pick;

-  x11_texture_class->update_area = mutter_shaped_texture_update_area;
+  x11_texture_class->update_area = meta_shaped_texture_update_area;

-  g_type_class_add_private (klass, sizeof (MutterShapedTexturePrivate));
+  g_type_class_add_private (klass, sizeof (MetaShapedTexturePrivate));
 }

 static void
-mutter_shaped_texture_init (MutterShapedTexture *self)
+meta_shaped_texture_init (MetaShapedTexture *self)
 {
-  MutterShapedTexturePrivate *priv;
+  MetaShapedTexturePrivate *priv;

-  priv = self->priv = MUTTER_SHAPED_TEXTURE_GET_PRIVATE (self);
+  priv = self->priv = META_SHAPED_TEXTURE_GET_PRIVATE (self);

  priv->rectangles = g_array_new (FALSE, FALSE, sizeof (XRectangle));

-  priv->paint_tower = mutter_texture_tower_new ();
+  priv->paint_tower = meta_texture_tower_new ();
  priv->mask_texture = COGL_INVALID_HANDLE;
  priv->create_mipmaps = TRUE;
 }

 static void
-mutter_shaped_texture_dispose (GObject *object)
+meta_shaped_texture_dispose (GObject *object)
 {
-  MutterShapedTexture *self = (MutterShapedTexture *) object;
-  MutterShapedTexturePrivate *priv = self->priv;
+  MetaShapedTexture *self = (MetaShapedTexture *) object;
+  MetaShapedTexturePrivate *priv = self->priv;

  if (priv->paint_tower)
-    mutter_texture_tower_free (priv->paint_tower);
+    meta_texture_tower_free (priv->paint_tower);
  priv->paint_tower = NULL;

-  mutter_shaped_texture_dirty_mask (self);
+  meta_shaped_texture_dirty_mask (self);

  if (priv->material != COGL_INVALID_HANDLE)
    {
@@ -133,28 +133,28 @@ mutter_shaped_texture_dispose (GObject *object)
      priv->material_unshaped = COGL_INVALID_HANDLE;
    }

-  mutter_shaped_texture_set_clip_region (self, NULL);
+  meta_shaped_texture_set_clip_region (self, NULL);

-  G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->dispose (object);
+  G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
 }

 static void
-mutter_shaped_texture_finalize (GObject *object)
+meta_shaped_texture_finalize (GObject *object)
 {
-  MutterShapedTexture *self = (MutterShapedTexture *) object;
-  MutterShapedTexturePrivate *priv = self->priv;
+  MetaShapedTexture *self = (MetaShapedTexture *) object;
+  MetaShapedTexturePrivate *priv = self->priv;

  g_array_free (priv->rectangles, TRUE);

-  G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->finalize (object);
+  G_OBJECT_CLASS (meta_shaped_texture_parent_class)->finalize (object);
 }

 static void
-mutter_shaped_texture_notify (GObject    *object,
-			      GParamSpec *pspec)
+meta_shaped_texture_notify (GObject    *object,
+			    GParamSpec *pspec)
 {
-  if (G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->notify)
-    G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->notify (object, pspec);
+  if (G_OBJECT_CLASS (meta_shaped_texture_parent_class)->notify)
+    G_OBJECT_CLASS (meta_shaped_texture_parent_class)->notify (object, pspec);

  /* It seems like we could just do this out of update_area(), but unfortunately,
   * clutter_glx_texture_pixmap() doesn't call through the vtable on the
@@ -163,21 +163,21 @@ mutter_shaped_texture_notify (GObject    *object,
   */
  if (strcmp (pspec->name, "cogl-texture") == 0)
    {
-      MutterShapedTexture *stex = (MutterShapedTexture *) object;
-      MutterShapedTexturePrivate *priv = stex->priv;
+      MetaShapedTexture *stex = (MetaShapedTexture *) object;
+      MetaShapedTexturePrivate *priv = stex->priv;

-      mutter_shaped_texture_clear (stex);
+      meta_shaped_texture_clear (stex);

      if (priv->create_mipmaps)
-	mutter_texture_tower_set_base_texture (priv->paint_tower,
+	meta_texture_tower_set_base_texture (priv->paint_tower,
 					       clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (stex)));
    }
 }

 static void
-mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex)
+meta_shaped_texture_dirty_mask (MetaShapedTexture *stex)
 {
-  MutterShapedTexturePrivate *priv = stex->priv;
+  MetaShapedTexturePrivate *priv = stex->priv;

  if (priv->mask_texture != COGL_INVALID_HANDLE)
    {
@@ -187,8 +187,10 @@ mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex)
      cogl_texture_get_gl_texture (priv->mask_texture,
                                   &mask_gl_tex, &mask_gl_target);

+#ifdef GL_TEXTURE_RECTANGLE_ARB
      if (mask_gl_target == GL_TEXTURE_RECTANGLE_ARB)
        glDeleteTextures (1, &mask_gl_tex);
+#endif

      cogl_handle_unref (priv->mask_texture);
      priv->mask_texture = COGL_INVALID_HANDLE;
@@ -199,9 +201,9 @@ mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex)
 }

 static void
-mutter_shaped_texture_ensure_mask (MutterShapedTexture *stex)
+meta_shaped_texture_ensure_mask (MetaShapedTexture *stex)
 {
-  MutterShapedTexturePrivate *priv = stex->priv;
+  MetaShapedTexturePrivate *priv = stex->priv;
  CoglHandle paint_tex;
  guint tex_width, tex_height;

@@ -217,7 +219,7 @@ mutter_shaped_texture_ensure_mask (MutterShapedTexture *stex)
     recreate it */
  if (priv->mask_texture != COGL_INVALID_HANDLE
      && (priv->mask_width != tex_width || priv->mask_height != tex_height))
-    mutter_shaped_texture_dirty_mask (stex);
+    meta_shaped_texture_dirty_mask (stex);

  /* If we don't have a mask texture yet then create one */
  if (priv->mask_texture == COGL_INVALID_HANDLE)
@@ -253,6 +255,7 @@ mutter_shaped_texture_ensure_mask (MutterShapedTexture *stex)

      cogl_texture_get_gl_texture (paint_tex, NULL, &paint_gl_target);

+#ifdef GL_TEXTURE_RECTANGLE_ARB
      if (paint_gl_target == GL_TEXTURE_RECTANGLE_ARB)
        {
          GLuint tex;
@@ -275,6 +278,7 @@ mutter_shaped_texture_ensure_mask (MutterShapedTexture *stex)
                                             COGL_PIXEL_FORMAT_A_8);
        }
      else
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
        priv->mask_texture = cogl_texture_new_from_data (tex_width, tex_height,
                                                         COGL_TEXTURE_NONE,
                                                         COGL_PIXEL_FORMAT_A_8,
@@ -290,10 +294,10 @@ mutter_shaped_texture_ensure_mask (MutterShapedTexture *stex)
 }

 static void
-mutter_shaped_texture_paint (ClutterActor *actor)
+meta_shaped_texture_paint (ClutterActor *actor)
 {
-  MutterShapedTexture *stex = (MutterShapedTexture *) actor;
-  MutterShapedTexturePrivate *priv = stex->priv;
+  MetaShapedTexture *stex = (MetaShapedTexture *) actor;
+  MetaShapedTexturePrivate *priv = stex->priv;
  CoglHandle paint_tex;
  guint tex_width, tex_height;
  ClutterActorBox alloc;
@@ -303,7 +307,7 @@ mutter_shaped_texture_paint (ClutterActor *actor)

  CoglHandle material;

-  if (priv->clip_region && meta_region_is_empty (priv->clip_region))
+  if (priv->clip_region && cairo_region_is_empty (priv->clip_region))
    return;

  if (!CLUTTER_ACTOR_IS_REALIZED (CLUTTER_ACTOR (stex)))
@@ -325,7 +329,7 @@ mutter_shaped_texture_paint (ClutterActor *actor)
   * support for TFP textures will result in fallbacks to XGetImage.
   */
  if (priv->create_mipmaps)
-    paint_tex = mutter_texture_tower_get_paint_texture (priv->paint_tower);
+    paint_tex = meta_texture_tower_get_paint_texture (priv->paint_tower);
  else
    paint_tex = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (stex));

@@ -353,7 +357,7 @@ mutter_shaped_texture_paint (ClutterActor *actor)
    }
  else
    {
-      mutter_shaped_texture_ensure_mask (stex);
+      meta_shaped_texture_ensure_mask (stex);

      if (priv->material == COGL_INVALID_HANDLE)
 	{
@@ -386,7 +390,6 @@ mutter_shaped_texture_paint (ClutterActor *actor)

  if (priv->clip_region)
    {
-      GdkRectangle *rects;
      int n_rects;
      int i;

@@ -394,31 +397,27 @@ mutter_shaped_texture_paint (ClutterActor *actor)
       * fall back and draw the whole thing */
 #     define MAX_RECTS 16

-      /* Would be nice to be able to check the number of rects first */
-      meta_region_get_rectangles (priv->clip_region, &rects, &n_rects);
-      if (n_rects > MAX_RECTS)
-	{
-	  g_free (rects);
-	  /* Fall through to following code */
-	}
-      else
+      n_rects = cairo_region_num_rectangles (priv->clip_region);
+      if (n_rects <= MAX_RECTS)
 	{
 	  float coords[8];
          float x1, y1, x2, y2;

 	  for (i = 0; i < n_rects; i++)
 	    {
-	      GdkRectangle *rect = &rects[i];
+	      cairo_rectangle_int_t rect;

-	      x1 = rect->x;
-	      y1 = rect->y;
-	      x2 = rect->x + rect->width;
-	      y2 = rect->y + rect->height;
+	      cairo_region_get_rectangle (priv->clip_region, i, &rect);

-              coords[0] = rect->x / (alloc.x2 - alloc.x1);
-	      coords[1] = rect->y / (alloc.y2 - alloc.y1);
-	      coords[2] = (rect->x + rect->width) / (alloc.x2 - alloc.x1);
-	      coords[3] = (rect->y + rect->height) / (alloc.y2 - alloc.y1);
+	      x1 = rect.x;
+	      y1 = rect.y;
+	      x2 = rect.x + rect.width;
+	      y2 = rect.y + rect.height;
+
+	      coords[0] = rect.x / (alloc.x2 - alloc.x1);
+	      coords[1] = rect.y / (alloc.y2 - alloc.y1);
+	      coords[2] = (rect.x + rect.width) / (alloc.x2 - alloc.x1);
+	      coords[3] = (rect.y + rect.height) / (alloc.y2 - alloc.y1);

              coords[4] = coords[0];
              coords[5] = coords[1];
@@ -429,8 +428,6 @@ mutter_shaped_texture_paint (ClutterActor *actor)
                                                       &coords[0], 8);
            }

-	  g_free (rects);
-
 	  return;
 	}
    }
@@ -441,15 +438,15 @@ mutter_shaped_texture_paint (ClutterActor *actor)
 }

 static void
-mutter_shaped_texture_pick (ClutterActor *actor,
-			    const ClutterColor *color)
+meta_shaped_texture_pick (ClutterActor       *actor,
+			  const ClutterColor *color)
 {
-  MutterShapedTexture *stex = (MutterShapedTexture *) actor;
-  MutterShapedTexturePrivate *priv = stex->priv;
+  MetaShapedTexture *stex = (MetaShapedTexture *) actor;
+  MetaShapedTexturePrivate *priv = stex->priv;

  /* If there are no rectangles then use the regular pick */
  if (priv->rectangles->len < 1)
-    CLUTTER_ACTOR_CLASS (mutter_shaped_texture_parent_class)
+    CLUTTER_ACTOR_CLASS (meta_shaped_texture_parent_class)
      ->pick (actor, color);
  else if (clutter_actor_should_pick_paint (actor))
    {
@@ -468,7 +465,7 @@ mutter_shaped_texture_pick (ClutterActor *actor,
      if (tex_width == 0 || tex_height == 0) /* no contents yet */
        return;

-      mutter_shaped_texture_ensure_mask (stex);
+      meta_shaped_texture_ensure_mask (stex);

      cogl_set_source_color4ub (color->red, color->green, color->blue,
                                 color->alpha);
@@ -485,36 +482,36 @@ mutter_shaped_texture_pick (ClutterActor *actor,
 }

 static void
-mutter_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
-                                   int                      x,
-                                   int                      y,
-                                   int                      width,
-                                   int                      height)
+meta_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
+				 int                      x,
+				 int                      y,
+				 int                      width,
+				 int                      height)
 {
-  MutterShapedTexture *stex = (MutterShapedTexture *) texture;
-  MutterShapedTexturePrivate *priv = stex->priv;
+  MetaShapedTexture *stex = (MetaShapedTexture *) texture;
+  MetaShapedTexturePrivate *priv = stex->priv;

-  CLUTTER_X11_TEXTURE_PIXMAP_CLASS (mutter_shaped_texture_parent_class)->update_area (texture,
+  CLUTTER_X11_TEXTURE_PIXMAP_CLASS (meta_shaped_texture_parent_class)->update_area (texture,
                                                                                      x, y, width, height);

-  mutter_texture_tower_update_area (priv->paint_tower, x, y, width, height);
+  meta_texture_tower_update_area (priv->paint_tower, x, y, width, height);
 }

 ClutterActor *
-mutter_shaped_texture_new (void)
+meta_shaped_texture_new (void)
 {
-  ClutterActor *self = g_object_new (MUTTER_TYPE_SHAPED_TEXTURE, NULL);
+  ClutterActor *self = g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);

  return self;
 }

 void
-mutter_shaped_texture_set_create_mipmaps (MutterShapedTexture *stex,
-					  gboolean             create_mipmaps)
+meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
+					gboolean           create_mipmaps)
 {
-  MutterShapedTexturePrivate *priv;
+  MetaShapedTexturePrivate *priv;

-  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

  priv = stex->priv;

@@ -529,7 +526,7 @@ mutter_shaped_texture_set_create_mipmaps (MutterShapedTexture *stex,
      base_texture = create_mipmaps ?
 	clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (stex)) : COGL_INVALID_HANDLE;

-      mutter_texture_tower_set_base_texture (priv->paint_tower, base_texture);
+      meta_texture_tower_set_base_texture (priv->paint_tower, base_texture);
    }
 }

@@ -550,15 +547,15 @@ mutter_shaped_texture_set_create_mipmaps (MutterShapedTexture *stex,
 * that will be very easy to do.
 */
 void
-mutter_shaped_texture_clear (MutterShapedTexture *stex)
+meta_shaped_texture_clear (MetaShapedTexture *stex)
 {
-  MutterShapedTexturePrivate *priv;
+  MetaShapedTexturePrivate *priv;

-  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

  priv = stex->priv;

-  mutter_texture_tower_set_base_texture (priv->paint_tower, COGL_INVALID_HANDLE);
+  meta_texture_tower_set_base_texture (priv->paint_tower, COGL_INVALID_HANDLE);

  if (priv->material != COGL_INVALID_HANDLE)
    cogl_material_set_layer (priv->material, 0, COGL_INVALID_HANDLE);
@@ -568,47 +565,47 @@ mutter_shaped_texture_clear (MutterShapedTexture *stex)
 }

 void
-mutter_shaped_texture_clear_rectangles (MutterShapedTexture *stex)
+meta_shaped_texture_clear_rectangles (MetaShapedTexture *stex)
 {
-  MutterShapedTexturePrivate *priv;
+  MetaShapedTexturePrivate *priv;

-  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

  priv = stex->priv;

  g_array_set_size (priv->rectangles, 0);
-  mutter_shaped_texture_dirty_mask (stex);
+  meta_shaped_texture_dirty_mask (stex);
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

 void
-mutter_shaped_texture_add_rectangle (MutterShapedTexture *stex,
-				     const XRectangle *rect)
+meta_shaped_texture_add_rectangle (MetaShapedTexture *stex,
+				   const XRectangle  *rect)
 {
-  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

-  mutter_shaped_texture_add_rectangles (stex, 1, rect);
+  meta_shaped_texture_add_rectangles (stex, 1, rect);
 }

 void
-mutter_shaped_texture_add_rectangles (MutterShapedTexture *stex,
-				      size_t num_rects,
-				      const XRectangle *rects)
+meta_shaped_texture_add_rectangles (MetaShapedTexture *stex,
+				    size_t             num_rects,
+				    const XRectangle  *rects)
 {
-  MutterShapedTexturePrivate *priv;
+  MetaShapedTexturePrivate *priv;

-  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

  priv = stex->priv;

  g_array_append_vals (priv->rectangles, rects, num_rects);

-  mutter_shaped_texture_dirty_mask (stex);
+  meta_shaped_texture_dirty_mask (stex);
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

 /**
- * mutter_shaped_texture_set_clip_region:
+ * meta_shaped_texture_set_clip_region:
 * @frame: a #TidyTextureframe
 * @clip_region: (transfer full): the region of the texture that
 *   is visible and should be painted. OWNERSHIP IS ASSUMED BY
@@ -623,18 +620,18 @@ mutter_shaped_texture_add_rectangles (MutterShapedTexture *stex,
 * painting its children, and then unset it afterwards.
 */
 void
-mutter_shaped_texture_set_clip_region (MutterShapedTexture *stex,
-				       MetaRegion          *clip_region)
+meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,
+				     cairo_region_t    *clip_region)
 {
-  MutterShapedTexturePrivate *priv;
+  MetaShapedTexturePrivate *priv;

-  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

  priv = stex->priv;

  if (priv->clip_region)
    {
-      meta_region_destroy (priv->clip_region);
+      cairo_region_destroy (priv->clip_region);
      priv->clip_region = NULL;
    }

--- a/src/compositor/meta-shaped-texture.h
+++ b/src/compositor/meta-shaped-texture.h
@@ -0,0 +1,92 @@
+/*
+ * shaped texture
+ *
+ * An actor to draw a texture clipped to a list of rectangles
+ *
+ * Authored By Neil Roberts  <neil@linux.intel.com>
+ *
+ * Copyright (C) 2008 Intel Corporation
+ *
+ * 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_SHAPED_TEXTURE_H__
+#define __META_SHAPED_TEXTURE_H__
+
+#include <config.h>
+
+#include <clutter/clutter.h>
+#ifdef HAVE_GLX_TEXTURE_PIXMAP
+#include <clutter/glx/clutter-glx.h>
+#endif /* HAVE_GLX_TEXTURE_PIXMAP */
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SHAPED_TEXTURE            (meta_shaped_texture_get_type())
+#define META_SHAPED_TEXTURE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj),META_TYPE_SHAPED_TEXTURE, MetaShapedTexture))
+#define META_SHAPED_TEXTURE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_SHAPED_TEXTURE, MetaShapedTextureClass))
+#define META_IS_SHAPED_TEXTURE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SHAPED_TEXTURE))
+#define META_IS_SHAPED_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_SHAPED_TEXTURE))
+#define META_SHAPED_TEXTURE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_SHAPED_TEXTURE, MetaShapedTextureClass))
+
+typedef struct _MetaShapedTexture        MetaShapedTexture;
+typedef struct _MetaShapedTextureClass   MetaShapedTextureClass;
+typedef struct _MetaShapedTexturePrivate MetaShapedTexturePrivate;
+
+struct _MetaShapedTextureClass
+{
+#ifdef HAVE_GLX_TEXTURE_PIXMAP
+  ClutterGLXTexturePixmapClass parent_class;
+#else
+  ClutterX11TexturePixmapClass parent_class;
+#endif
+};
+
+struct _MetaShapedTexture
+{
+#ifdef HAVE_GLX_TEXTURE_PIXMAP
+  ClutterGLXTexturePixmap parent;
+#else
+  ClutterX11TexturePixmap parent;
+#endif
+
+  MetaShapedTexturePrivate *priv;
+};
+
+GType meta_shaped_texture_get_type (void) G_GNUC_CONST;
+
+ClutterActor *meta_shaped_texture_new (void);
+
+void meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
+					     gboolean           create_mipmaps);
+
+void meta_shaped_texture_clear (MetaShapedTexture *stex);
+
+void meta_shaped_texture_clear_rectangles (MetaShapedTexture *stex);
+
+void meta_shaped_texture_add_rectangle  (MetaShapedTexture *stex,
+					 const XRectangle  *rect);
+void meta_shaped_texture_add_rectangles (MetaShapedTexture *stex,
+					 size_t             num_rects,
+					 const XRectangle  *rects);
+
+/* Assumes ownership of clip_region */
+void meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,
+					  cairo_region_t    *clip_region);
+
+G_END_DECLS
+
+#endif /* __META_SHAPED_TEXTURE_H__ */
--- a/src/compositor/mutter-texture-tower.c
+++ b/src/compositor/mutter-texture-tower.c
@@ -1,6 +1,6 @@
 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 /*
- * MutterTextureTower
+ * MetaTextureTower
 *
 * Mipmap emulation by creation of scaled down images
 *
@@ -25,7 +25,7 @@
 #include <math.h>
 #include <string.h>

-#include "mutter-texture-tower.h"
+#include "meta-texture-tower.h"

 #ifndef M_LOG2E
 #define M_LOG2E 1.4426950408889634074
@@ -55,7 +55,7 @@ typedef struct
  guint16 y2;
 } Box;

-struct _MutterTextureTower
+struct _MetaTextureTower
 {
  int n_levels;
  CoglHandle textures[MAX_TEXTURE_LEVELS];
@@ -64,39 +64,40 @@ struct _MutterTextureTower
 };

 /**
- * mutter_texture_tower_new:
+ * meta_texture_tower_new:
 *
 * Creates a new texture tower. The base texture has to be set with
- * mutter_texture_tower_set_base_texture() before use.
+ * meta_texture_tower_set_base_texture() before use.
 *
- * Return value: the new texture tower. Free with mutter_texture_tower_free()
+ * Return value: the new texture tower. Free with meta_texture_tower_free()
 */
-MutterTextureTower *
-mutter_texture_tower_new (void)
+MetaTextureTower *
+meta_texture_tower_new (void)
 {
-  MutterTextureTower *tower;
+  MetaTextureTower *tower;

-  tower = g_slice_new0 (MutterTextureTower);
+  tower = g_slice_new0 (MetaTextureTower);

  return tower;
 }

 /**
- * mutter_texture_tower_free:
- * @tower: a #MutterTextureTower
+ * meta_texture_tower_free:
+ * @tower: a #MetaTextureTower
 *
- * Frees a texture tower created with mutter_texture_tower_new().
+ * Frees a texture tower created with meta_texture_tower_new().
 */
 void
-mutter_texture_tower_free (MutterTextureTower *tower)
+meta_texture_tower_free (MetaTextureTower *tower)
 {
  g_return_if_fail (tower != NULL);

-  mutter_texture_tower_set_base_texture (tower, COGL_INVALID_HANDLE);
+  meta_texture_tower_set_base_texture (tower, COGL_INVALID_HANDLE);

-  g_slice_free (MutterTextureTower, tower);
+  g_slice_free (MetaTextureTower, tower);
 }

+#ifdef GL_TEXTURE_RECTANGLE_ARB
 static gboolean
 texture_is_rectangle (CoglHandle texture)
 {
@@ -106,10 +107,12 @@ texture_is_rectangle (CoglHandle texture)
  cogl_texture_get_gl_texture (texture, &gl_tex, &gl_target);
  return gl_target == GL_TEXTURE_RECTANGLE_ARB;
 }
+#endif /* GL_TEXTURE_RECTANGLE_ARB */

 static void
 free_texture (CoglHandle texture)
 {
+#ifdef GL_TEXTURE_RECTANGLE_ARB
  GLuint gl_tex;
  GLenum gl_target;

@@ -117,13 +120,14 @@ free_texture (CoglHandle texture)

  if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
    glDeleteTextures (1, &gl_tex);
+#endif /* GL_TEXTURE_RECTANGLE_ARB */

  cogl_handle_unref (texture);
 }

 /**
- * mutter_texture_tower_update_area:
- * @tower: a MutterTextureTower
+ * meta_texture_tower_update_area:
+ * @tower: a MetaTextureTower
 * @texture: the new texture used as a base for scaled down versions
 *
 * Sets the base texture that is the scaled texture that the
@@ -132,8 +136,8 @@ free_texture (CoglHandle texture)
 * unset or until the tower is freed.
 */
 void
-mutter_texture_tower_set_base_texture (MutterTextureTower *tower,
-                                       CoglHandle          texture)
+meta_texture_tower_set_base_texture (MetaTextureTower *tower,
+                                     CoglHandle        texture)
 {
  int i;

@@ -176,7 +180,7 @@ mutter_texture_tower_set_base_texture (MutterTextureTower *tower,
      tower->n_levels = 1 + MAX ((int)(M_LOG2E * log (width)), (int)(M_LOG2E * log (height)));
      tower->n_levels = MIN(tower->n_levels, MAX_TEXTURE_LEVELS);

-      mutter_texture_tower_update_area (tower, 0, 0, width, height);
+      meta_texture_tower_update_area (tower, 0, 0, width, height);
    }
  else
    {
@@ -185,8 +189,8 @@ mutter_texture_tower_set_base_texture (MutterTextureTower *tower,
 }

 /**
- * mutter_texture_tower_update_area:
- * @tower: a MutterTextureTower
+ * meta_texture_tower_update_area:
+ * @tower: a MetaTextureTower
 * @x: X coordinate of upper left of rectangle that changed
 * @y: Y coordinate of upper left of rectangle that changed
 * @width: width of rectangle that changed
@@ -197,11 +201,11 @@ mutter_texture_tower_set_base_texture (MutterTextureTower *tower,
 * the appropriate area of the scaled down texture will be updated.
 */
 void
-mutter_texture_tower_update_area (MutterTextureTower *tower,
-                                  int                 x,
-                                  int                 y,
-                                  int                 width,
-                                  int                 height)
+meta_texture_tower_update_area (MetaTextureTower *tower,
+                                int               x,
+                                int               y,
+                                int               width,
+                                int               height)
 {
  int texture_width, texture_height;
  Box invalid;
@@ -257,7 +261,7 @@ mutter_texture_tower_update_area (MutterTextureTower *tower,
 * If window is being painted at an angle from the viewer, then we have to
 * pick a point in the texture; we use the middle of the texture (which is
 * why the width/height are passed in.) This is not the normal case for
- * Mutter.
+ * Meta.
 */
 static int
 get_paint_level (int width, int height)
@@ -362,18 +366,21 @@ get_paint_level (int width, int height)
    return (int)(0.5 + lambda);
 }

+#ifdef GL_TEXTURE_RECTANGLE_ARB
 static gboolean
 is_power_of_two (int x)
 {
  return (x & (x - 1)) == 0;
 }
+#endif /* GL_TEXTURE_RECTANGLE_ARB */

 static void
-texture_tower_create_texture (MutterTextureTower *tower,
-                              int                 level,
-                              int                 width,
-                              int                 height)
+texture_tower_create_texture (MetaTextureTower *tower,
+                              int               level,
+                              int               width,
+                              int               height)
 {
+#ifdef GL_TEXTURE_RECTANGLE_ARB
  if ((!is_power_of_two (width) || !is_power_of_two (height)) &&
      texture_is_rectangle (tower->textures[level - 1]))
    {
@@ -396,6 +403,7 @@ texture_tower_create_texture (MutterTextureTower *tower,
                                                              TEXTURE_FORMAT);
    }
  else
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
    {
      tower->textures[level] = cogl_texture_new_with_size (width, height,
                                                           COGL_TEXTURE_NO_AUTO_MIPMAP,
@@ -409,8 +417,8 @@ texture_tower_create_texture (MutterTextureTower *tower,
 }

 static gboolean
-texture_tower_revalidate_fbo (MutterTextureTower *tower,
-                              int                 level)
+texture_tower_revalidate_fbo (MetaTextureTower *tower,
+                              int               level)
 {
  CoglHandle source_texture = tower->textures[level - 1];
  int source_texture_width = cogl_texture_get_width (source_texture);
@@ -487,8 +495,8 @@ fill_scale_down (guchar       *buf,
 }

 static void
-texture_tower_revalidate_client (MutterTextureTower *tower,
-                                 int                 level)
+texture_tower_revalidate_client (MetaTextureTower *tower,
+                                 int               level)
 {
  CoglHandle source_texture = tower->textures[level - 1];
  int source_texture_width = cogl_texture_get_width (source_texture);
@@ -587,16 +595,16 @@ texture_tower_revalidate_client (MutterTextureTower *tower,
 }

 static void
-texture_tower_revalidate (MutterTextureTower *tower,
-                          int                 level)
+texture_tower_revalidate (MetaTextureTower *tower,
+                          int               level)
 {
  if (!texture_tower_revalidate_fbo (tower, level))
    texture_tower_revalidate_client (tower, level);
 }

 /**
- * mutter_texture_tower_get_paint_texture:
- * @tower: a MutterTextureTower
+ * meta_texture_tower_get_paint_texture:
+ * @tower: a MetaTextureTower
 *
 * Gets the texture from the tower that best matches the current
 * rendering scale. (On the assumption here the texture is going to
@@ -608,7 +616,7 @@ texture_tower_revalidate (MutterTextureTower *tower,
 *  %COGL_INVALID_HANDLE if no base texture has yet been set.
 */
 CoglHandle
-mutter_texture_tower_get_paint_texture (MutterTextureTower *tower)
+meta_texture_tower_get_paint_texture (MetaTextureTower *tower)
 {
  int texture_width, texture_height;
  int level;
--- a/src/compositor/mutter-texture-tower.h
+++ b/src/compositor/mutter-texture-tower.h
@@ -1,6 +1,6 @@
 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 /*
- * MutterTextureTower
+ * MetaTextureTower
 *
 * Mipmap emulation by creation of scaled down images
 *
@@ -22,18 +22,18 @@
 * 02111-1307, USA.
 */

-#ifndef __MUTTER_TEXTURE_TOWER_H__
-#define __MUTTER_TEXTURE_TOWER_H__
+#ifndef __META_TEXTURE_TOWER_H__
+#define __META_TEXTURE_TOWER_H__

 #include <clutter/clutter.h>

 G_BEGIN_DECLS

 /**
- * SECTION:MutterTextureTower
+ * SECTION:MetaTextureTower
 * @short_description: mipmap emulation by creation of scaled down images
 *
- * A #MutterTextureTower is used to get good looking scaled down images when
+ * A #MetaTextureTower is used to get good looking scaled down images when
 * we can't use the GL drivers mipmap support. There are two separate reasons
 *
 *  - Some cards (including radeon cards <= r5xx) only support
@@ -51,19 +51,19 @@ G_BEGIN_DECLS
 * scale for the entire texture.)
 */

-typedef struct _MutterTextureTower MutterTextureTower;
+typedef struct _MetaTextureTower MetaTextureTower;

-MutterTextureTower *mutter_texture_tower_new               (void);
-void                mutter_texture_tower_free              (MutterTextureTower *tower);
-void                mutter_texture_tower_set_base_texture  (MutterTextureTower *tower,
-                                                            CoglHandle          texture);
-void                mutter_texture_tower_update_area       (MutterTextureTower *tower,
-                                                            int                 x,
-                                                            int                 y,
-                                                            int                 width,
-                                                            int                 height);
-CoglHandle          mutter_texture_tower_get_paint_texture (MutterTextureTower *tower);
+MetaTextureTower *meta_texture_tower_new               (void);
+void              meta_texture_tower_free              (MetaTextureTower *tower);
+void              meta_texture_tower_set_base_texture  (MetaTextureTower *tower,
+                                                        CoglHandle        texture);
+void              meta_texture_tower_update_area       (MetaTextureTower *tower,
+                                                        int               x,
+                                                        int               y,
+                                                        int               width,
+                                                        int               height);
+CoglHandle        meta_texture_tower_get_paint_texture (MetaTextureTower *tower);

 G_BEGIN_DECLS

-#endif /* __MUTTER_TEXTURE_TOWER_H__ */
+#endif /* __META_TEXTURE_TOWER_H__ */
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -0,0 +1,53 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#ifndef META_WINDOW_ACTOR_PRIVATE_H
+#define META_WINDOW_ACTOR_PRIVATE_H
+
+#include <config.h>
+
+#include <X11/extensions/Xdamage.h>
+#include "compositor-mutter.h"
+
+MetaWindowActor *meta_window_actor_new (MetaWindow *window);
+
+void meta_window_actor_destroy   (MetaWindowActor *self);
+
+void meta_window_actor_show (MetaWindowActor *self,
+                             MetaCompEffect   effect);
+void meta_window_actor_hide (MetaWindowActor *self,
+                             MetaCompEffect   effect);
+
+void meta_window_actor_maximize   (MetaWindowActor *self,
+                                   MetaRectangle   *old_rect,
+                                   MetaRectangle   *new_rect);
+void meta_window_actor_unmaximize (MetaWindowActor *self,
+                                   MetaRectangle   *old_rect,
+                                   MetaRectangle   *new_rect);
+
+void meta_window_actor_process_damage (MetaWindowActor    *self,
+                                       XDamageNotifyEvent *event);
+void meta_window_actor_pre_paint      (MetaWindowActor    *self);
+
+void meta_window_actor_invalidate_shadow (MetaWindowActor *self);
+
+gboolean meta_window_actor_effect_in_progress  (MetaWindowActor *self);
+void     meta_window_actor_sync_actor_position (MetaWindowActor *self);
+void     meta_window_actor_sync_visibility     (MetaWindowActor *self);
+void     meta_window_actor_update_shape        (MetaWindowActor *self,
+                                                gboolean         shaped);
+void     meta_window_actor_update_opacity      (MetaWindowActor *self);
+void     meta_window_actor_mapped              (MetaWindowActor *self);
+void     meta_window_actor_unmapped            (MetaWindowActor *self);
+
+cairo_region_t *meta_window_actor_get_obscured_region (MetaWindowActor *self);
+
+void meta_window_actor_set_visible_region         (MetaWindowActor *self,
+                                                   cairo_region_t  *visible_region);
+void meta_window_actor_set_visible_region_beneath (MetaWindowActor *self,
+                                                   cairo_region_t  *beneath_region);
+void meta_window_actor_reset_visible_regions      (MetaWindowActor *self);
+
+void meta_window_actor_effect_completed (MetaWindowActor *actor,
+                                         gulong           event);
+
+#endif /* META_WINDOW_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
--- a/src/compositor/mutter-window-group.c
+++ b/src/compositor/mutter-window-group.c
@@ -5,23 +5,25 @@
 #define _ISOC99_SOURCE /* for roundf */
 #include <math.h>

-#include "mutter-window-private.h"
-#include "mutter-window-group.h"
-#include "region.h"
+#include <gdk/gdk.h> /* for gdk_rectangle_intersect() */

-struct _MutterWindowGroupClass
+#include "meta-window-actor-private.h"
+#include "meta-window-group.h"
+#include "meta-background-actor.h"
+
+struct _MetaWindowGroupClass
 {
  ClutterGroupClass parent_class;
 };

-struct _MutterWindowGroup
+struct _MetaWindowGroup
 {
  ClutterGroup parent;

  MetaScreen *screen;
 };

-G_DEFINE_TYPE (MutterWindowGroup, mutter_window_group, CLUTTER_TYPE_GROUP);
+G_DEFINE_TYPE (MetaWindowGroup, meta_window_group, CLUTTER_TYPE_GROUP);

 /* We want to find out if the window is "close enough" to
 * 1:1 transform. We do that by converting the transformed coordinates
@@ -99,11 +101,13 @@ actor_is_untransformed (ClutterActor *actor,
 }

 static void
-mutter_window_group_paint (ClutterActor *actor)
+meta_window_group_paint (ClutterActor *actor)
 {
-  MutterWindowGroup *window_group = MUTTER_WINDOW_GROUP (actor);
-  MetaRegion *visible_region;
-  GdkRectangle screen_rect = { 0 };
+  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
+  cairo_region_t *visible_region;
+  GLboolean scissor_test;
+  cairo_rectangle_int_t screen_rect = { 0 };
+  cairo_rectangle_int_t scissor_rect;
  GList *children, *l;

  /* We walk the list from top to bottom (opposite of painting order),
@@ -119,77 +123,113 @@ mutter_window_group_paint (ClutterActor *actor)
   * optimization, however.)
   */
  meta_screen_get_size (window_group->screen, &screen_rect.width, &screen_rect.height);
-  visible_region = meta_region_new_from_rectangle (&screen_rect);
+
+  /* When doing a partial stage paint, Clutter will set the GL scissor
+   * box to the clip rectangle for the partial repaint. We combine the screen
+   * rectangle with the scissor box to get the region we need to
+   * paint. (Strangely, the scissor box sometimes seems to be bigger
+   * than the stage ... Clutter should probably be clampimg)
+   */
+  glGetBooleanv (GL_SCISSOR_TEST, &scissor_test);
+
+  if (scissor_test)
+    {
+      GLint scissor_box[4];
+      glGetIntegerv (GL_SCISSOR_BOX, scissor_box);
+
+      scissor_rect.x = scissor_box[0];
+      scissor_rect.y = screen_rect.height - (scissor_box[1] + scissor_box[3]);
+      scissor_rect.width = scissor_box[2];
+      scissor_rect.height = scissor_box[3];
+
+      gdk_rectangle_intersect (&scissor_rect, &screen_rect, &scissor_rect);
+    }
+  else
+    {
+      scissor_rect = screen_rect;
+    }
+
+  visible_region = cairo_region_create_rectangle (&scissor_rect);

  for (l = children; l; l = l->next)
    {
-      MutterWindow *cw;
-      gboolean x, y;
-
-      if (!MUTTER_IS_WINDOW (l->data) || !CLUTTER_ACTOR_IS_VISIBLE (l->data))
+      if (!CLUTTER_ACTOR_IS_VISIBLE (l->data))
        continue;

-      cw = l->data;
-
-      if (!actor_is_untransformed (CLUTTER_ACTOR (cw), &x, &y))
-        continue;
-
-      /* Temporarily move to the coordinate system of the actor */
-      meta_region_translate (visible_region, - x, - y);
-
-      mutter_window_set_visible_region (cw, visible_region);
-
-      if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (cw)) == 0xff)
+      if (META_IS_WINDOW_ACTOR (l->data))
        {
-          MetaRegion *obscured_region = mutter_window_get_obscured_region (cw);
-          if (obscured_region)
-            meta_region_subtract (visible_region, obscured_region);
-        }
+          MetaWindowActor *window_actor = l->data;
+          gboolean x, y;

-      mutter_window_set_visible_region_beneath (cw, visible_region);
-      meta_region_translate (visible_region, x, y);
+          if (!actor_is_untransformed (CLUTTER_ACTOR (window_actor), &x, &y))
+            continue;
+
+          /* Temporarily move to the coordinate system of the actor */
+          cairo_region_translate (visible_region, - x, - y);
+
+          meta_window_actor_set_visible_region (window_actor, visible_region);
+
+          if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
+            {
+              cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (window_actor);
+              if (obscured_region)
+                cairo_region_subtract (visible_region, obscured_region);
+            }
+
+          meta_window_actor_set_visible_region_beneath (window_actor, visible_region);
+          cairo_region_translate (visible_region, x, y);
+        }
+      else if (META_IS_BACKGROUND_ACTOR (l->data))
+        {
+          MetaBackgroundActor *background_actor = l->data;
+          meta_background_actor_set_visible_region (background_actor, visible_region);
+        }
    }

-  meta_region_destroy (visible_region);
+  cairo_region_destroy (visible_region);

-  CLUTTER_ACTOR_CLASS (mutter_window_group_parent_class)->paint (actor);
+  CLUTTER_ACTOR_CLASS (meta_window_group_parent_class)->paint (actor);

  /* Now that we are done painting, unset the visible regions (they will
   * mess up painting clones of our actors)
   */
  for (l = children; l; l = l->next)
    {
-      MutterWindow *cw;
-
-      if (!MUTTER_IS_WINDOW (l->data))
-        continue;
-
-      cw = l->data;
-      mutter_window_reset_visible_regions (cw);
+      if (META_IS_WINDOW_ACTOR (l->data))
+        {
+          MetaWindowActor *window_actor = l->data;
+          window_actor = l->data;
+          meta_window_actor_reset_visible_regions (window_actor);
+        }
+      else if (META_IS_BACKGROUND_ACTOR (l->data))
+        {
+          MetaBackgroundActor *background_actor = l->data;
+          meta_background_actor_set_visible_region (background_actor, NULL);
+        }
    }

  g_list_free (children);
 }

 static void
-mutter_window_group_class_init (MutterWindowGroupClass *klass)
+meta_window_group_class_init (MetaWindowGroupClass *klass)
 {
  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);

-  actor_class->paint = mutter_window_group_paint;
+  actor_class->paint = meta_window_group_paint;
 }

 static void
-mutter_window_group_init (MutterWindowGroup *window_group)
+meta_window_group_init (MetaWindowGroup *window_group)
 {
 }

 ClutterActor *
-mutter_window_group_new (MetaScreen *screen)
+meta_window_group_new (MetaScreen *screen)
 {
-  MutterWindowGroup *window_group;
+  MetaWindowGroup *window_group;

-  window_group = g_object_new (MUTTER_TYPE_WINDOW_GROUP, NULL);
+  window_group = g_object_new (META_TYPE_WINDOW_GROUP, NULL);

  window_group->screen = screen;

--- a/src/compositor/mutter-window-group.h
+++ b/src/compositor/mutter-window-group.h
@@ -1,17 +1,17 @@
 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

-#ifndef MUTTER_WINDOW_GROUP_H
-#define MUTTER_WINDOW_GROUP_H
+#ifndef META_WINDOW_GROUP_H
+#define META_WINDOW_GROUP_H

 #include <clutter/clutter.h>

 #include "screen.h"

 /**
- * MutterWindowGroup:
+ * MetaWindowGroup:
 *
 * This class is a subclass of ClutterGroup with special handling for
- * MutterWindow when painting the group. When we are painting a stack
+ * MetaWindowActor when painting the group. When we are painting a stack
 * of 5-10 maximized windows, the standard bottom-to-top method of
 * drawing every actor results in a tremendous amount of overdraw
 * and can easily max out the available memory bandwidth on a low-end
@@ -21,7 +21,7 @@
 * The basic technique applied here is to do a pre-pass before painting
 * where we walk window from top to bottom and compute the visible area
 * at each step by subtracting out the windows above it. The visible
- * area is passed to MutterWindow which uses it to clip the portion of
+ * area is passed to MetaWindowActor which uses it to clip the portion of
 * the window which drawn and avoid redrawing the shadow if it is completely
 * obscured.
 *
@@ -34,19 +34,19 @@
 * we have lots of memory and bandwidth.)
 */

-#define MUTTER_TYPE_WINDOW_GROUP            (mutter_window_group_get_type ())
-#define MUTTER_WINDOW_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_WINDOW_GROUP, MutterWindowGroup))
-#define MUTTER_WINDOW_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MUTTER_TYPE_WINDOW_GROUP, MutterWindowGroupClass))
-#define MUTTER_IS_WINDOW_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_WINDOW_GROUP))
-#define MUTTER_IS_WINDOW_GROU_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), MUTTER_TYPE_WINDOW_GROUP))
-#define MUTTER_WINDOW_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MUTTER_TYPE_WINDOW_GROUP, MutterWindowGroupClass))
+#define META_TYPE_WINDOW_GROUP            (meta_window_group_get_type ())
+#define META_WINDOW_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_WINDOW_GROUP, MetaWindowGroup))
+#define META_WINDOW_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_WINDOW_GROUP, MetaWindowGroupClass))
+#define META_IS_WINDOW_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_WINDOW_GROUP))
+#define META_IS_WINDOW_GROUP_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_WINDOW_GROUP))
+#define META_WINDOW_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_WINDOW_GROUP, MetaWindowGroupClass))

-typedef struct _MutterWindowGroup        MutterWindowGroup;
-typedef struct _MutterWindowGroupClass   MutterWindowGroupClass;
-typedef struct _MutterWindowGroupPrivate MutterWindowGroupPrivate;
+typedef struct _MetaWindowGroup        MetaWindowGroup;
+typedef struct _MetaWindowGroupClass   MetaWindowGroupClass;
+typedef struct _MetaWindowGroupPrivate MetaWindowGroupPrivate;

-GType mutter_window_group_get_type (void);
+GType meta_window_group_get_type (void);

-ClutterActor *mutter_window_group_new (MetaScreen *screen);
+ClutterActor *meta_window_group_new (MetaScreen *screen);

-#endif /* MUTTER_WINDOW_GROUP_H */
+#endif /* META_WINDOW_GROUP_H */
--- a/src/compositor/meta-window-shape.c
+++ b/src/compositor/meta-window-shape.c
@@ -0,0 +1,254 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MetaWindowShape
+ *
+ * Extracted invariant window shape
+ *
+ * Copyright (C) 2010 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 <string.h>
+
+#include "meta-window-shape.h"
+#include "region-utils.h"
+
+struct _MetaWindowShape
+{
+  guint ref_count;
+
+  int top, right, bottom, left;
+  int n_rectangles;
+  cairo_rectangle_int_t *rectangles;
+  guint hash;
+};
+
+MetaWindowShape *
+meta_window_shape_new (cairo_region_t *region)
+{
+  MetaWindowShape *shape;
+  MetaRegionIterator iter;
+  cairo_rectangle_int_t extents;
+  int max_yspan_y1 = 0;
+  int max_yspan_y2 = 0;
+  int max_xspan_x1 = -1;
+  int max_xspan_x2 = -1;
+  guint hash;
+
+  shape = g_slice_new0 (MetaWindowShape);
+  shape->ref_count = 1;
+
+  cairo_region_get_extents (region, &extents);
+
+  shape->n_rectangles = cairo_region_num_rectangles (region);
+
+  if (shape->n_rectangles == 0)
+    {
+      shape->rectangles = NULL;
+      shape->top = shape->right = shape->bottom = shape->left = 0;
+      shape->hash = 0;
+      return shape;
+    }
+
+  for (meta_region_iterator_init (&iter, region);
+       !meta_region_iterator_at_end (&iter);
+       meta_region_iterator_next (&iter))
+    {
+      int max_line_xspan_x1 = -1;
+      int max_line_xspan_x2 = -1;
+
+      if (iter.rectangle.width > max_line_xspan_x2 - max_line_xspan_x1)
+        {
+          max_line_xspan_x1 = iter.rectangle.x;
+          max_line_xspan_x2 = iter.rectangle.x + iter.rectangle.width;
+        }
+
+      if (iter.line_end)
+        {
+          if (iter.rectangle.height > max_yspan_y2 - max_yspan_y1)
+            {
+              max_yspan_y1 = iter.rectangle.y;
+              max_yspan_y2 = iter.rectangle.y + iter.rectangle.height;
+            }
+
+          if (max_xspan_x1 < 0) /* First line */
+            {
+              max_xspan_x1 = max_line_xspan_x1;
+              max_xspan_x2 = max_line_xspan_x2;
+            }
+          else
+            {
+              max_xspan_x1 = MAX (max_xspan_x1, max_line_xspan_x1);
+              max_xspan_x2 = MIN (max_xspan_x2, max_line_xspan_x2);
+
+              if (max_xspan_x2 < max_xspan_x1)
+                max_xspan_x2 = max_xspan_x1;
+            }
+        }
+    }
+
+#if 0
+  g_print ("xspan: %d -> %d, yspan: %d -> %d\n",
+           max_xspan_x1, max_xspan_x2,
+           max_yspan_y1, max_yspan_y2);
+#endif
+
+  shape->top = max_yspan_y1 - extents.y;
+  shape->right = extents.x + extents.width - max_xspan_x2;
+  shape->bottom = extents.y + extents.height - max_yspan_y2;
+  shape->left = max_xspan_x1 - extents.x;
+
+  shape->rectangles = g_new (cairo_rectangle_int_t, shape->n_rectangles);
+
+  hash = 0;
+  for (meta_region_iterator_init (&iter, region);
+       !meta_region_iterator_at_end (&iter);
+       meta_region_iterator_next (&iter))
+    {
+      int x1, x2, y1, y2;
+
+      x1 = iter.rectangle.x;
+      x2 = iter.rectangle.x + iter.rectangle.width;
+      y1 = iter.rectangle.y;
+      y2 = iter.rectangle.y + iter.rectangle.height;
+
+      if (x1 > max_xspan_x1)
+        x1 -= MIN (x1, max_xspan_x2 - 1) - max_xspan_x1;
+      if (x2 > max_xspan_x1)
+        x2 -= MIN (x2, max_xspan_x2 - 1) - max_xspan_x1;
+      if (y1 > max_yspan_y1)
+        y1 -= MIN (y1, max_yspan_y2 - 1) - max_yspan_y1;
+      if (y2 > max_yspan_y1)
+        y2 -= MIN (y2, max_yspan_y2 - 1) - max_yspan_y1;
+
+      shape->rectangles[iter.i].x = x1 - extents.x;
+      shape->rectangles[iter.i].y = y1 - extents.y;
+      shape->rectangles[iter.i].width = x2 - x1;
+      shape->rectangles[iter.i].height = y2 - y1;
+
+#if 0
+      g_print ("%d: +%d+%dx%dx%d => +%d+%dx%dx%d\n",
+               iter.i, iter.rectangle.x, iter.rectangle.y, iter.rectangle.width, iter.rectangle.height,
+               shape->rectangles[iter.i].x, shape->rectangles[iter.i].y,
+               hape->rectangles[iter.i].width, shape->rectangles[iter.i].height);
+#endif
+
+      hash = hash * 31 + x1 * 17 + x2 * 27 + y1 * 37 + y2 * 43;
+    }
+
+  shape->hash = hash;
+
+#if 0
+  g_print ("%d %d %d %d: %#x\n\n", shape->top, shape->right, shape->bottom, shape->left, shape->hash);
+#endif
+
+  return shape;
+}
+
+MetaWindowShape *
+meta_window_shape_ref (MetaWindowShape *shape)
+{
+  shape->ref_count++;
+
+  return shape;
+}
+
+void
+meta_window_shape_unref (MetaWindowShape *shape)
+{
+  shape->ref_count--;
+  if (shape->ref_count == 0)
+    {
+      g_free (shape->rectangles);
+      g_slice_free (MetaWindowShape, shape);
+    }
+}
+
+guint
+meta_window_shape_hash (MetaWindowShape *shape)
+{
+  return shape->hash;
+}
+
+gboolean
+meta_window_shape_equal (MetaWindowShape *shape_a,
+                         MetaWindowShape *shape_b)
+{
+  if (shape_a->n_rectangles != shape_b->n_rectangles)
+    return FALSE;
+
+  return memcmp (shape_a->rectangles, shape_b->rectangles,
+                 sizeof (cairo_rectangle_int_t) * shape_a->n_rectangles) == 0;
+}
+
+void
+meta_window_shape_get_borders (MetaWindowShape *shape,
+                               int             *border_top,
+                               int             *border_right,
+                               int             *border_bottom,
+                               int             *border_left)
+{
+  if (border_top)
+    *border_top = shape->top;
+  if (border_right)
+    *border_right = shape->right;
+  if (border_bottom)
+    *border_bottom = shape->bottom;
+  if (border_left)
+    *border_left = shape->left;
+}
+
+/**
+ * meta_window_shape_to_region:
+ * @shape: a #MetaWindowShape
+ * @center_width: size of the central region horizontally
+ * @center_height: size of the central region vertically
+ *
+ * Converts the shape to to a cairo_region_t using the given width
+ * and height for the central scaled region.
+ *
+ * Return value: a newly created region
+ */
+cairo_region_t *
+meta_window_shape_to_region (MetaWindowShape *shape,
+                             int              center_width,
+                             int              center_height)
+{
+  cairo_region_t *region;
+  int i;
+
+  region = cairo_region_create ();
+
+  for (i = 0; i < shape->n_rectangles; i++)
+    {
+      cairo_rectangle_int_t rect = shape->rectangles[i];
+
+      if (rect.x <= shape->left && rect.x + rect.width >= shape->left + 1)
+        rect.width += center_width;
+      else if (rect.x >= shape->left + 1)
+        rect.x += center_width;
+
+      if (rect.y <= shape->top && rect.y + rect.height >= shape->top + 1)
+        rect.height += center_height;
+      else if (rect.y >= shape->top + 1)
+        rect.y += center_height;
+
+      cairo_region_union_rectangle (region, &rect);
+    }
+
+  return region;
+}
+
--- a/src/compositor/meta-window-shape.h
+++ b/src/compositor/meta-window-shape.h
@@ -0,0 +1,60 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MetaWindowShape
+ *
+ * Extracted invariant window shape
+ *
+ * Copyright (C) 2010 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_SHAPE_H__
+#define __META_WINDOW_SHAPE_H__
+
+#include <cairo.h>
+#include <glib.h>
+
+/**
+ * MetaWindowShape:
+ * #MetaWindowShape represents a 9-sliced region with borders on all sides that
+ * are unscaled, and a constant central region that is scaled. For example,
+ * the regions representing two windows that are rounded rectangles,
+ * with the same corner radius but different sizes, have the
+ * same MetaWindowShape.
+ *
+ * #MetaWindowShape is designed to be used as part of a hash table key, so has
+ * efficient hash and equal functions.
+ */
+typedef struct _MetaWindowShape MetaWindowShape;
+
+MetaWindowShape *  meta_window_shape_new         (cairo_region_t  *region);
+MetaWindowShape *  meta_window_shape_ref         (MetaWindowShape *shape);
+void               meta_window_shape_unref       (MetaWindowShape *shape);
+guint              meta_window_shape_hash        (MetaWindowShape *shape);
+gboolean           meta_window_shape_equal       (MetaWindowShape *shape_a,
+                                                  MetaWindowShape *shape_b);
+void               meta_window_shape_get_borders (MetaWindowShape *shape,
+                                                  int             *border_top,
+                                                  int             *border_right,
+                                                  int             *border_bottom,
+                                                  int             *border_left);
+cairo_region_t    *meta_window_shape_to_region   (MetaWindowShape *shape,
+                                                  int              center_width,
+                                                  int              center_height);
+
+#endif /* __META_WINDOW_SHAPE_H __*/
+
--- a/src/compositor/mutter-plugin-manager.h
+++ b/src/compositor/mutter-plugin-manager.h
@@ -1,77 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright (c) 2008 Intel Corp.
- *
- * Author: Tomas Frydrych <tf@linux.intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 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 MUTTER_PLUGIN_MANAGER_H_
-#define MUTTER_PLUGIN_MANAGER_H_
-
-#include "types.h"
-#include "screen.h"
-
-#define  MUTTER_PLUGIN_FROM_MANAGER_
-#include "mutter-plugin.h"
-#undef   MUTTER_PLUGIN_FROM_MANAGER_
-
-#define MUTTER_PLUGIN_MINIMIZE         (1<<0)
-#define MUTTER_PLUGIN_MAXIMIZE         (1<<1)
-#define MUTTER_PLUGIN_UNMAXIMIZE       (1<<2)
-#define MUTTER_PLUGIN_MAP              (1<<3)
-#define MUTTER_PLUGIN_DESTROY          (1<<4)
-#define MUTTER_PLUGIN_SWITCH_WORKSPACE (1<<5)
-
-#define MUTTER_PLUGIN_ALL_EFFECTS      (~0)
-
-/**
- * MutterPluginManager: (skip)
- *
- */
-typedef struct MutterPluginManager MutterPluginManager;
-
-MutterPluginManager * mutter_plugin_manager_get         (MetaScreen *screen);
-MutterPluginManager * mutter_plugin_manager_get_default (void);
-
-gboolean mutter_plugin_manager_load (MutterPluginManager *mgr);
-gboolean mutter_plugin_manager_initialize (MutterPluginManager *plugin_mgr);
-gboolean mutter_plugin_manager_event_simple (MutterPluginManager *mgr,
-					     MutterWindow  *actor,
-					     unsigned long    event);
-
-gboolean mutter_plugin_manager_event_maximize (MutterPluginManager *mgr,
-					       MutterWindow  *actor,
-					       unsigned long    event,
-					       gint             target_x,
-					       gint             target_y,
-					       gint             target_width,
-					       gint		target_height);
-void mutter_plugin_manager_update_workspaces (MutterPluginManager *mgr);
-
-void mutter_plugin_manager_update_workspace (MutterPluginManager *mgr, MetaWorkspace *w);
-
-gboolean mutter_plugin_manager_switch_workspace (MutterPluginManager *mgr,
-						 gint          from,
-						 gint          to,
-						 MetaMotionDirection direction);
-
-gboolean mutter_plugin_manager_xevent_filter (MutterPluginManager *mgr,
-					      XEvent *xev);
-
-#endif
--- a/src/compositor/mutter-shaped-texture.h
+++ b/src/compositor/mutter-shaped-texture.h
@@ -1,108 +0,0 @@
-/*
- * shaped texture
- *
- * An actor to draw a texture clipped to a list of rectangles
- *
- * Authored By Neil Roberts  <neil@linux.intel.com>
- *
- * Copyright (C) 2008 Intel Corporation
- *
- * 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 __MUTTER_SHAPED_TEXTURE_H__
-#define __MUTTER_SHAPED_TEXTURE_H__
-
-#include <config.h>
-
-#include <clutter/clutter.h>
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-#include <clutter/glx/clutter-glx.h>
-#endif /* HAVE_GLX_TEXTURE_PIXMAP */
-
-#include "region.h"
-
-G_BEGIN_DECLS
-
-#define MUTTER_TYPE_SHAPED_TEXTURE			    \
-  (mutter_shaped_texture_get_type())
-#define MUTTER_SHAPED_TEXTURE(obj)                          \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj),                       \
-                               MUTTER_TYPE_SHAPED_TEXTURE,  \
-                               MutterShapedTexture))
-#define MUTTER_SHAPED_TEXTURE_CLASS(klass)                  \
-  (G_TYPE_CHECK_CLASS_CAST ((klass),			    \
-                            MUTTER_TYPE_SHAPED_TEXTURE,	    \
-                            MutterShapedTextureClass))
-#define MUTTER_IS_SHAPED_TEXTURE(obj)                       \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj),			    \
-                               MUTTER_TYPE_SHAPED_TEXTURE))
-#define MUTTER_IS_SHAPED_TEXTURE_CLASS(klass)		    \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass),			    \
-                            MUTTER_TYPE_SHAPED_TEXTURE))
-#define MUTTER_SHAPED_TEXTURE_GET_CLASS(obj)                \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj),                        \
-                              MUTTER_TYPE_SHAPED_TEXTURE,   \
-                              MutterShapedTextureClass))
-
-typedef struct _MutterShapedTexture        MutterShapedTexture;
-typedef struct _MutterShapedTextureClass   MutterShapedTextureClass;
-typedef struct _MutterShapedTexturePrivate MutterShapedTexturePrivate;
-
-struct _MutterShapedTextureClass
-{
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-  ClutterGLXTexturePixmapClass parent_class;
-#else
-  ClutterX11TexturePixmapClass parent_class;
-#endif
-};
-
-struct _MutterShapedTexture
-{
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-  ClutterGLXTexturePixmap parent;
-#else
-  ClutterX11TexturePixmap parent;
-#endif
-
-  MutterShapedTexturePrivate *priv;
-};
-
-GType mutter_shaped_texture_get_type (void) G_GNUC_CONST;
-
-ClutterActor *mutter_shaped_texture_new (void);
-
-void mutter_shaped_texture_set_create_mipmaps (MutterShapedTexture *stex,
-					       gboolean             create_mipmaps);
-
-void mutter_shaped_texture_clear (MutterShapedTexture *stex);
-
-void mutter_shaped_texture_clear_rectangles (MutterShapedTexture *stex);
-
-void mutter_shaped_texture_add_rectangle (MutterShapedTexture *stex,
-					  const XRectangle *rect);
-void mutter_shaped_texture_add_rectangles (MutterShapedTexture *stex,
-					   size_t num_rects,
-					   const XRectangle *rects);
-
-/* Assumes ownership of clip_region */
-void mutter_shaped_texture_set_clip_region (MutterShapedTexture *stex,
-					    MetaRegion          *clip_region);
-
-G_END_DECLS
-
-#endif /* __MUTTER_SHAPED_TEXTURE_H__ */
--- a/src/compositor/mutter-window-private.h
+++ b/src/compositor/mutter-window-private.h
@@ -1,52 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-#ifndef MUTTER_WINDOW_PRIVATE_H
-#define MUTTER_WINDOW_PRIVATE_H
-
-#include <config.h>
-
-#include <X11/extensions/Xdamage.h>
-#include "compositor-mutter.h"
-#include "region.h"
-
-MutterWindow *mutter_window_new (MetaWindow *window);
-
-void mutter_window_destroy   (MutterWindow *cw);
-
-void mutter_window_show (MutterWindow   *cw,
-                         MetaCompEffect  effect);
-void mutter_window_hide (MutterWindow   *cw,
-                         MetaCompEffect  effect);
-
-void mutter_window_maximize   (MutterWindow  *cw,
-                               MetaRectangle *old_rect,
-                               MetaRectangle *new_rect);
-void mutter_window_unmaximize (MutterWindow  *cw,
-                               MetaRectangle *old_rect,
-                               MetaRectangle *new_rect);
-
-void     mutter_window_process_damage          (MutterWindow       *cw,
-                                                XDamageNotifyEvent *event);
-void     mutter_window_pre_paint               (MutterWindow       *self);
-
-gboolean mutter_window_effect_in_progress      (MutterWindow       *cw);
-void     mutter_window_sync_actor_position     (MutterWindow       *cw);
-void     mutter_window_sync_visibility         (MutterWindow       *cw);
-void     mutter_window_update_shape            (MutterWindow       *cw,
-                                                gboolean            shaped);
-void     mutter_window_update_opacity          (MutterWindow       *cw);
-void     mutter_window_mapped                  (MutterWindow       *cw);
-void     mutter_window_unmapped                (MutterWindow       *cw);
-
-MetaRegion *mutter_window_get_obscured_region  (MutterWindow       *cw);
-
-void mutter_window_set_visible_region          (MutterWindow       *cw,
-                                                MetaRegion         *visible_region);
-void mutter_window_set_visible_region_beneath  (MutterWindow       *cw,
-                                                MetaRegion         *beneath_region);
-void mutter_window_reset_visible_regions       (MutterWindow       *cw);
-
-void mutter_window_effect_completed (MutterWindow *actor,
-                                     gulong        event);
-
-#endif /* MUTTER_WINDOW_PRIVATE_H */
--- a/src/compositor/plugins/default.c
+++ b/src/compositor/plugins/default.c
@@ -21,7 +21,7 @@
 * 02111-1307, USA.
 */

-#include "mutter-plugin.h"
+#include "meta-plugin.h"
 #include "window.h"

 #include <libintl.h>
@@ -40,63 +40,70 @@

 #define ACTOR_DATA_KEY "MCCP-Default-actor-data"

-#define MUTTER_TYPE_DEFAULT_PLUGIN            (mutter_default_plugin_get_type ())
-#define MUTTER_DEFAULT_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_DEFAULT_PLUGIN, MutterDefaultPlugin))
-#define MUTTER_DEFAULT_PLUGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  MUTTER_TYPE_DEFAULT_PLUGIN, MutterDefaultPluginClass))
-#define MUTTER_IS_DEFAULT_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_DEFAULT_PLUGIN_TYPE))
-#define MUTTER_IS_DEFAULT_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  MUTTER_TYPE_DEFAULT_PLUGIN))
-#define MUTTER_DEFAULT_PLUGIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  MUTTER_TYPE_DEFAULT_PLUGIN, MutterDefaultPluginClass))
+#define META_TYPE_DEFAULT_PLUGIN            (meta_default_plugin_get_type ())
+#define META_DEFAULT_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_DEFAULT_PLUGIN, MetaDefaultPlugin))
+#define META_DEFAULT_PLUGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_DEFAULT_PLUGIN, MetaDefaultPluginClass))
+#define META_IS_DEFAULT_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_DEFAULT_PLUGIN_TYPE))
+#define META_IS_DEFAULT_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_DEFAULT_PLUGIN))
+#define META_DEFAULT_PLUGIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_DEFAULT_PLUGIN, MetaDefaultPluginClass))

-#define MUTTER_DEFAULT_PLUGIN_GET_PRIVATE(obj) \
-(G_TYPE_INSTANCE_GET_PRIVATE ((obj), MUTTER_TYPE_DEFAULT_PLUGIN, MutterDefaultPluginPrivate))
+#define META_DEFAULT_PLUGIN_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_DEFAULT_PLUGIN, MetaDefaultPluginPrivate))

-typedef struct _MutterDefaultPlugin        MutterDefaultPlugin;
-typedef struct _MutterDefaultPluginClass   MutterDefaultPluginClass;
-typedef struct _MutterDefaultPluginPrivate MutterDefaultPluginPrivate;
+typedef struct _MetaDefaultPlugin        MetaDefaultPlugin;
+typedef struct _MetaDefaultPluginClass   MetaDefaultPluginClass;
+typedef struct _MetaDefaultPluginPrivate MetaDefaultPluginPrivate;

-struct _MutterDefaultPlugin
+struct _MetaDefaultPlugin
 {
-  MutterPlugin parent;
+  MetaPlugin parent;

-  MutterDefaultPluginPrivate *priv;
+  MetaDefaultPluginPrivate *priv;
 };

-struct _MutterDefaultPluginClass
+struct _MetaDefaultPluginClass
 {
-  MutterPluginClass parent_class;
+  MetaPluginClass parent_class;
 };

 static GQuark actor_data_quark = 0;

-static void     minimize   (MutterPlugin *plugin,
-                            MutterWindow *actor);
-static void     map        (MutterPlugin *plugin,
-                            MutterWindow *actor);
-static void     destroy    (MutterPlugin *plugin,
-                            MutterWindow *actor);
-static void     maximize   (MutterPlugin *plugin,
-                            MutterWindow *actor,
-                            gint x, gint y, gint width, gint height);
-static void     unmaximize (MutterPlugin *plugin,
-                            MutterWindow *actor,
-                            gint x, gint y, gint width, gint height);
+static void minimize   (MetaPlugin      *plugin,
+                        MetaWindowActor *actor);
+static void map        (MetaPlugin      *plugin,
+                        MetaWindowActor *actor);
+static void destroy    (MetaPlugin      *plugin,
+                        MetaWindowActor *actor);
+static void maximize   (MetaPlugin      *plugin,
+                        MetaWindowActor *actor,
+                        gint             x,
+                        gint             y,
+                        gint             width,
+                        gint             height);
+static void unmaximize (MetaPlugin      *plugin,
+                        MetaWindowActor *actor,
+                        gint             x,
+                        gint             y,
+                        gint             width,
+                        gint             height);

-static void switch_workspace (MutterPlugin *plugin,
-                              gint from, gint to,
-                              MetaMotionDirection direction);
+static void switch_workspace (MetaPlugin          *plugin,
+                              gint                 from,
+                              gint                 to,
+                              MetaMotionDirection  direction);

-static void kill_window_effects (MutterPlugin *plugin,
-                                 MutterWindow *actor);
-static void kill_switch_workspace (MutterPlugin     *plugin);
+static void kill_window_effects   (MetaPlugin      *plugin,
+                                   MetaWindowActor *actor);
+static void kill_switch_workspace (MetaPlugin      *plugin);

-static const MutterPluginInfo * plugin_info (MutterPlugin *plugin);
+static const MetaPluginInfo * plugin_info (MetaPlugin *plugin);

-MUTTER_PLUGIN_DECLARE(MutterDefaultPlugin, mutter_default_plugin);
+META_PLUGIN_DECLARE(MetaDefaultPlugin, meta_default_plugin);

 /*
 * Plugin private data that we store in the .plugin_private member.
 */
-struct _MutterDefaultPluginPrivate
+struct _MetaDefaultPluginPrivate
 {
  /* Valid only when switch_workspace effect is in progress */
  ClutterTimeline       *tml_switch_workspace1;
@@ -104,7 +111,7 @@ struct _MutterDefaultPluginPrivate
  ClutterActor          *desktop1;
  ClutterActor          *desktop2;

-  MutterPluginInfo       info;
+  MetaPluginInfo         info;

  gboolean               debug_mode : 1;
 };
@@ -129,26 +136,26 @@ typedef struct _ActorPrivate
 typedef struct
 {
  ClutterActor *actor;
-  MutterPlugin *plugin;
+  MetaPlugin *plugin;
 } EffectCompleteData;


 static void
-mutter_default_plugin_dispose (GObject *object)
+meta_default_plugin_dispose (GObject *object)
 {
-  /* MutterDefaultPluginPrivate *priv = MUTTER_DEFAULT_PLUGIN (object)->priv;
+  /* MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (object)->priv;
  */
-  G_OBJECT_CLASS (mutter_default_plugin_parent_class)->dispose (object);
+  G_OBJECT_CLASS (meta_default_plugin_parent_class)->dispose (object);
 }

 static void
-mutter_default_plugin_finalize (GObject *object)
+meta_default_plugin_finalize (GObject *object)
 {
-  G_OBJECT_CLASS (mutter_default_plugin_parent_class)->finalize (object);
+  G_OBJECT_CLASS (meta_default_plugin_parent_class)->finalize (object);
 }

 static void
-mutter_default_plugin_set_property (GObject      *object,
+meta_default_plugin_set_property (GObject      *object,
 			    guint         prop_id,
 			    const GValue *value,
 			    GParamSpec   *pspec)
@@ -162,7 +169,7 @@ mutter_default_plugin_set_property (GObject      *object,
 }

 static void
-mutter_default_plugin_get_property (GObject    *object,
+meta_default_plugin_get_property (GObject    *object,
 			    guint       prop_id,
 			    GValue     *value,
 			    GParamSpec *pspec)
@@ -176,9 +183,9 @@ mutter_default_plugin_get_property (GObject    *object,
 }

 static void
-start (MutterPlugin *plugin)
+start (MetaPlugin *plugin)
 {
-  MutterDefaultPluginPrivate *priv   = MUTTER_DEFAULT_PLUGIN (plugin)->priv;
+  MetaDefaultPluginPrivate *priv   = META_DEFAULT_PLUGIN (plugin)->priv;

  guint destroy_timeout  = DESTROY_TIMEOUT;
  guint minimize_timeout = MINIMIZE_TIMEOUT;
@@ -186,7 +193,7 @@ start (MutterPlugin *plugin)
  guint map_timeout      = MAP_TIMEOUT;
  guint switch_timeout   = SWITCH_TIMEOUT;

-  if (mutter_plugin_debug_mode (plugin))
+  if (meta_plugin_debug_mode (plugin))
    {
      g_debug ("Plugin %s: Entering debug mode.", priv->info.name);

@@ -204,15 +211,15 @@ start (MutterPlugin *plugin)
 }

 static void
-mutter_default_plugin_class_init (MutterDefaultPluginClass *klass)
+meta_default_plugin_class_init (MetaDefaultPluginClass *klass)
 {
  GObjectClass      *gobject_class = G_OBJECT_CLASS (klass);
-  MutterPluginClass *plugin_class  = MUTTER_PLUGIN_CLASS (klass);
+  MetaPluginClass *plugin_class  = META_PLUGIN_CLASS (klass);

-  gobject_class->finalize        = mutter_default_plugin_finalize;
-  gobject_class->dispose         = mutter_default_plugin_dispose;
-  gobject_class->set_property    = mutter_default_plugin_set_property;
-  gobject_class->get_property    = mutter_default_plugin_get_property;
+  gobject_class->finalize        = meta_default_plugin_finalize;
+  gobject_class->dispose         = meta_default_plugin_dispose;
+  gobject_class->set_property    = meta_default_plugin_set_property;
+  gobject_class->get_property    = meta_default_plugin_get_property;

  plugin_class->start            = start;
  plugin_class->map              = map;
@@ -225,15 +232,15 @@ mutter_default_plugin_class_init (MutterDefaultPluginClass *klass)
  plugin_class->kill_window_effects   = kill_window_effects;
  plugin_class->kill_switch_workspace = kill_switch_workspace;

-  g_type_class_add_private (gobject_class, sizeof (MutterDefaultPluginPrivate));
+  g_type_class_add_private (gobject_class, sizeof (MetaDefaultPluginPrivate));
 }

 static void
-mutter_default_plugin_init (MutterDefaultPlugin *self)
+meta_default_plugin_init (MetaDefaultPlugin *self)
 {
-  MutterDefaultPluginPrivate *priv;
+  MetaDefaultPluginPrivate *priv;

-  self->priv = priv = MUTTER_DEFAULT_PLUGIN_GET_PRIVATE (self);
+  self->priv = priv = META_DEFAULT_PLUGIN_GET_PRIVATE (self);

  priv->info.name        = "Default Effects";
  priv->info.version     = "0.1";
@@ -253,7 +260,7 @@ free_actor_private (gpointer data)
 }

 static ActorPrivate *
-get_actor_private (MutterWindow *actor)
+get_actor_private (MetaWindowActor *actor)
 {
  ActorPrivate *priv = g_object_get_qdata (G_OBJECT (actor), actor_data_quark);

@@ -275,15 +282,15 @@ get_actor_private (MutterWindow *actor)
 static void
 on_switch_workspace_effect_complete (ClutterTimeline *timeline, gpointer data)
 {
-  MutterPlugin               *plugin  = MUTTER_PLUGIN (data);
-  MutterDefaultPluginPrivate *priv = MUTTER_DEFAULT_PLUGIN (plugin)->priv;
-  GList        *l     = mutter_plugin_get_windows (plugin);
+  MetaPlugin               *plugin  = META_PLUGIN (data);
+  MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv;
+  GList        *l     = meta_plugin_get_window_actors (plugin);

  while (l)
    {
      ClutterActor *a = l->data;
-      MutterWindow *mc_window = MUTTER_WINDOW (a);
-      ActorPrivate *apriv = get_actor_private (mc_window);
+      MetaWindowActor *window_actor = META_WINDOW_ACTOR (a);
+      ActorPrivate *apriv = get_actor_private (window_actor);

      if (apriv->orig_parent)
        {
@@ -302,27 +309,25 @@ on_switch_workspace_effect_complete (ClutterTimeline *timeline, gpointer data)
  priv->desktop1 = NULL;
  priv->desktop2 = NULL;

-  mutter_plugin_switch_workspace_completed (plugin);
+  meta_plugin_switch_workspace_completed (plugin);
 }

 static void
-switch_workspace (MutterPlugin *plugin,
+switch_workspace (MetaPlugin *plugin,
                  gint from, gint to,
                  MetaMotionDirection direction)
 {
-  MutterDefaultPluginPrivate *priv = MUTTER_DEFAULT_PLUGIN (plugin)->priv;
+  MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv;
  GList        *l;
-  gint          n_workspaces;
  ClutterActor *workspace0  = clutter_group_new ();
  ClutterActor *workspace1  = clutter_group_new ();
  ClutterActor *stage;
  int           screen_width, screen_height;
-  MetaScreen   *screen = mutter_plugin_get_screen (plugin);
  ClutterAnimation *animation;

-  stage = mutter_plugin_get_stage (plugin);
+  stage = meta_plugin_get_stage (plugin);

-  mutter_plugin_query_screen_size (plugin,
+  meta_plugin_query_screen_size (plugin,
 					      &screen_width,
 					      &screen_height);
  clutter_actor_set_anchor_point (workspace1,
@@ -339,31 +344,29 @@ switch_workspace (MutterPlugin *plugin,

  if (from == to)
    {
-      mutter_plugin_switch_workspace_completed (plugin);
+      meta_plugin_switch_workspace_completed (plugin);
      return;
    }

-  n_workspaces = meta_screen_get_n_workspaces (screen);
-
-  l = g_list_last (mutter_plugin_get_windows (plugin));
+  l = g_list_last (meta_plugin_get_window_actors (plugin));

  while (l)
    {
-      MutterWindow *mc_window	= l->data;
-      ActorPrivate *apriv	= get_actor_private (mc_window);
-      ClutterActor *window	= CLUTTER_ACTOR (mc_window);
-      gint          win_workspace;
+      MetaWindowActor *window_actor = l->data;
+      ActorPrivate    *apriv	    = get_actor_private (window_actor);
+      ClutterActor    *actor	    = CLUTTER_ACTOR (window_actor);
+      gint             win_workspace;

-      win_workspace = mutter_window_get_workspace (mc_window);
+      win_workspace = meta_window_actor_get_workspace (window_actor);

      if (win_workspace == to || win_workspace == from)
        {
-          apriv->orig_parent = clutter_actor_get_parent (window);
+          apriv->orig_parent = clutter_actor_get_parent (actor);

-          clutter_actor_reparent (window,
+          clutter_actor_reparent (actor,
 				  win_workspace == to ? workspace1 : workspace0);
-          clutter_actor_show_all (window);
-          clutter_actor_raise_top (window);
+          clutter_actor_show_all (actor);
+          clutter_actor_raise_top (actor);
        }
      else if (win_workspace < 0)
        {
@@ -373,7 +376,7 @@ switch_workspace (MutterPlugin *plugin,
      else
        {
          /* Window on some other desktop */
-          clutter_actor_hide (window);
+          clutter_actor_hide (actor);
          apriv->orig_parent = NULL;
        }

@@ -414,11 +417,11 @@ on_minimize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
   * Must reverse the effect of the effect; must hide it first to ensure
   * that the restoration will not be visible.
   */
-  MutterPlugin *plugin = data->plugin;
+  MetaPlugin *plugin = data->plugin;
  ActorPrivate *apriv;
-  MutterWindow *mc_window = MUTTER_WINDOW (data->actor);
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (data->actor);

-  apriv = get_actor_private (MUTTER_WINDOW (data->actor));
+  apriv = get_actor_private (META_WINDOW_ACTOR (data->actor));
  apriv->tml_minimize = NULL;

  clutter_actor_hide (data->actor);
@@ -430,7 +433,7 @@ on_minimize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
                                                CLUTTER_GRAVITY_NORTH_WEST);

  /* Now notify the manager that we are done with this effect */
-  mutter_plugin_minimize_completed (plugin, mc_window);
+  meta_plugin_minimize_completed (plugin, window_actor);

  g_free (data);
 }
@@ -440,11 +443,11 @@ on_minimize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
 * completion).
 */
 static void
-minimize (MutterPlugin *plugin, MutterWindow *mc_window)
+minimize (MetaPlugin *plugin, MetaWindowActor *window_actor)
 {
  MetaWindowType type;
-  MetaWindow *meta_window = mutter_window_get_meta_window (mc_window);
-  ClutterActor               *actor  = CLUTTER_ACTOR (mc_window);
+  MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);
+  ClutterActor *actor  = CLUTTER_ACTOR (window_actor);


  type = meta_window_get_window_type (meta_window);
@@ -453,7 +456,7 @@ minimize (MutterPlugin *plugin, MutterWindow *mc_window)
    {
      ClutterAnimation *animation;
      EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
-      ActorPrivate *apriv = get_actor_private (mc_window);
+      ActorPrivate *apriv = get_actor_private (window_actor);

      apriv->is_minimized = TRUE;

@@ -475,7 +478,7 @@ minimize (MutterPlugin *plugin, MutterWindow *mc_window)

    }
  else
-    mutter_plugin_minimize_completed (plugin, mc_window);
+    meta_plugin_minimize_completed (plugin, window_actor);
 }

 /*
@@ -488,9 +491,9 @@ on_maximize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
  /*
   * Must reverse the effect of the effect.
   */
-  MutterPlugin * plugin = data->plugin;
-  MutterWindow  *mc_window = MUTTER_WINDOW (data->actor);
-  ActorPrivate  *apriv     = get_actor_private (mc_window);
+  MetaPlugin *plugin = data->plugin;
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (data->actor);
+  ActorPrivate *apriv = get_actor_private (window_actor);

  apriv->tml_maximize = NULL;

@@ -500,7 +503,7 @@ on_maximize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
                                                CLUTTER_GRAVITY_NORTH_WEST);

  /* Now notify the manager that we are done with this effect */
-  mutter_plugin_maximize_completed (plugin, mc_window);
+  meta_plugin_maximize_completed (plugin, window_actor);

  g_free (data);
 }
@@ -514,13 +517,13 @@ on_maximize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
 * (Something like a sound would be more appropriate.)
 */
 static void
-maximize (MutterPlugin *plugin,
-          MutterWindow *mc_window,
+maximize (MetaPlugin *plugin,
+          MetaWindowActor *window_actor,
          gint end_x, gint end_y, gint end_width, gint end_height)
 {
  MetaWindowType type;
-  ClutterActor	     *actor = CLUTTER_ACTOR (mc_window);
-  MetaWindow *meta_window = mutter_window_get_meta_window (mc_window);
+  ClutterActor *actor = CLUTTER_ACTOR (window_actor);
+  MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);

  gdouble  scale_x    = 1.0;
  gdouble  scale_y    = 1.0;
@@ -533,7 +536,7 @@ maximize (MutterPlugin *plugin,
    {
      ClutterAnimation *animation;
      EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
-      ActorPrivate *apriv = get_actor_private (mc_window);
+      ActorPrivate *apriv = get_actor_private (window_actor);
      gfloat width, height;
      gfloat x, y;

@@ -571,7 +574,7 @@ maximize (MutterPlugin *plugin,
      return;
    }

-  mutter_plugin_maximize_completed (plugin, mc_window);
+  meta_plugin_maximize_completed (plugin, window_actor);
 }

 /*
@@ -580,22 +583,22 @@ maximize (MutterPlugin *plugin,
 * (Just a skeleton code.)
 */
 static void
-unmaximize (MutterPlugin *plugin,
-            MutterWindow *mc_window,
+unmaximize (MetaPlugin *plugin,
+            MetaWindowActor *window_actor,
            gint end_x, gint end_y, gint end_width, gint end_height)
 {
-  MetaWindow *meta_window = mutter_window_get_meta_window (mc_window);
+  MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);
  MetaWindowType type = meta_window_get_window_type (meta_window);

  if (type == META_WINDOW_NORMAL)
    {
-      ActorPrivate *apriv = get_actor_private (mc_window);
+      ActorPrivate *apriv = get_actor_private (window_actor);

      apriv->is_maximized = FALSE;
    }

  /* Do this conditionally, if the effect requires completion callback. */
-  mutter_plugin_unmaximize_completed (plugin, mc_window);
+  meta_plugin_unmaximize_completed (plugin, window_actor);
 }

 static void
@@ -604,9 +607,9 @@ on_map_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data)
  /*
   * Must reverse the effect of the effect.
   */
-  MutterPlugin  *plugin = data->plugin;
-  MutterWindow  *mc_window = MUTTER_WINDOW (data->actor);
-  ActorPrivate  *apriv     = get_actor_private (mc_window);
+  MetaPlugin *plugin = data->plugin;
+  MetaWindowActor  *window_actor = META_WINDOW_ACTOR (data->actor);
+  ActorPrivate  *apriv = get_actor_private (window_actor);

  apriv->tml_map = NULL;

@@ -614,7 +617,7 @@ on_map_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data)
                                                CLUTTER_GRAVITY_NORTH_WEST);

  /* Now notify the manager that we are done with this effect */
-  mutter_plugin_map_completed (plugin, mc_window);
+  meta_plugin_map_completed (plugin, window_actor);

  g_free (data);
 }
@@ -624,11 +627,11 @@ on_map_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data)
 * completion).
 */
 static void
-map (MutterPlugin *plugin, MutterWindow *mc_window)
+map (MetaPlugin *plugin, MetaWindowActor *window_actor)
 {
  MetaWindowType type;
-  ClutterActor       *actor = CLUTTER_ACTOR (mc_window);
-  MetaWindow *meta_window = mutter_window_get_meta_window (mc_window);
+  ClutterActor *actor = CLUTTER_ACTOR (window_actor);
+  MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);

  type = meta_window_get_window_type (meta_window);

@@ -636,7 +639,7 @@ map (MutterPlugin *plugin, MutterWindow *mc_window)
    {
      ClutterAnimation *animation;
      EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
-      ActorPrivate *apriv = get_actor_private (mc_window);
+      ActorPrivate *apriv = get_actor_private (window_actor);

      clutter_actor_move_anchor_point_from_gravity (actor,
                                                    CLUTTER_GRAVITY_CENTER);
@@ -661,7 +664,7 @@ map (MutterPlugin *plugin, MutterWindow *mc_window)

    }
  else
-    mutter_plugin_map_completed (plugin, mc_window);
+    meta_plugin_map_completed (plugin, window_actor);
 }

 /*
@@ -671,24 +674,24 @@ map (MutterPlugin *plugin, MutterWindow *mc_window)
 static void
 on_destroy_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data)
 {
-  MutterPlugin *plugin = data->plugin;
-  MutterWindow *mc_window = MUTTER_WINDOW (data->actor);
-  ActorPrivate *apriv = get_actor_private (mc_window);
+  MetaPlugin *plugin = data->plugin;
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (data->actor);
+  ActorPrivate *apriv = get_actor_private (window_actor);

  apriv->tml_destroy = NULL;

-  mutter_plugin_destroy_completed (plugin, mc_window);
+  meta_plugin_destroy_completed (plugin, window_actor);
 }

 /*
 * Simple TV-out like effect.
 */
 static void
-destroy (MutterPlugin *plugin, MutterWindow *mc_window)
+destroy (MetaPlugin *plugin, MetaWindowActor *window_actor)
 {
  MetaWindowType type;
-  ClutterActor	      *actor = CLUTTER_ACTOR (mc_window);
-  MetaWindow *meta_window = mutter_window_get_meta_window (mc_window);
+  ClutterActor *actor = CLUTTER_ACTOR (window_actor);
+  MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);

  type = meta_window_get_window_type (meta_window);

@@ -696,7 +699,7 @@ destroy (MutterPlugin *plugin, MutterWindow *mc_window)
    {
      ClutterAnimation *animation;
      EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
-      ActorPrivate *apriv = get_actor_private (mc_window);
+      ActorPrivate *apriv = get_actor_private (window_actor);

      clutter_actor_move_anchor_point_from_gravity (actor,
                                                    CLUTTER_GRAVITY_CENTER);
@@ -715,13 +718,13 @@ destroy (MutterPlugin *plugin, MutterWindow *mc_window)
                        data);
    }
  else
-    mutter_plugin_destroy_completed (plugin, mc_window);
+    meta_plugin_destroy_completed (plugin, window_actor);
 }

 static void
-kill_switch_workspace (MutterPlugin     *plugin)
+kill_switch_workspace (MetaPlugin     *plugin)
 {
-  MutterDefaultPluginPrivate *priv = MUTTER_DEFAULT_PLUGIN (plugin)->priv;
+  MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv;

  if (priv->tml_switch_workspace1)
    {
@@ -732,11 +735,12 @@ kill_switch_workspace (MutterPlugin     *plugin)
 }

 static void
-kill_window_effects (MutterPlugin *plugin, MutterWindow *mc_window)
+kill_window_effects (MetaPlugin      *plugin,
+                     MetaWindowActor *window_actor)
 {
  ActorPrivate *apriv;

-  apriv = get_actor_private (mc_window);
+  apriv = get_actor_private (window_actor);

  if (apriv->tml_minimize)
    {
@@ -763,10 +767,10 @@ kill_window_effects (MutterPlugin *plugin, MutterWindow *mc_window)
    }
 }

-static const MutterPluginInfo *
-plugin_info (MutterPlugin *plugin)
+static const MetaPluginInfo *
+plugin_info (MetaPlugin *plugin)
 {
-  MutterDefaultPluginPrivate *priv = MUTTER_DEFAULT_PLUGIN (plugin)->priv;
+  MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv;

  return &priv->info;
 }
--- a/src/compositor/region-utils.c
+++ b/src/compositor/region-utils.c
@@ -0,0 +1,336 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * Utilities for region manipulation
+ *
+ * Copyright (C) 2010 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 "region-utils.h"
+
+#include <math.h>
+
+/* MetaRegionBuilder */
+
+/* Various algorithms in this file require unioning together a set of rectangles
+ * that are unsorted or overlap; unioning such a set of rectangles 1-by-1
+ * using cairo_region_union_rectangle() produces O(N^2) behavior (if the union
+ * adds or removes rectangles in the middle of the region, then it has to
+ * move all the rectangles after that.) To avoid this behavior, MetaRegionBuilder
+ * creates regions for small groups of rectangles and merges them together in
+ * a binary tree.
+ *
+ * Possible improvement: From a glance at the code, accumulating all the rectangles
+ *  into a flat array and then calling the (not usefully documented)
+ *  cairo_region_create_rectangles() would have the same behavior and would be
+ *  simpler and a bit more efficient.
+ */
+
+/* Optimium performance seems to be with MAX_CHUNK_RECTANGLES=4; 8 is about 10% slower.
+ * But using 8 may be more robust to systems with slow malloc(). */
+#define MAX_CHUNK_RECTANGLES 8
+#define MAX_LEVELS 16
+
+typedef struct
+{
+  /* To merge regions in binary tree order, we need to keep track of
+   * the regions that we've already merged together at different
+   * levels of the tree. We fill in an array in the pattern:
+   *
+   * |a  |
+   * |b  |a  |
+   * |c  |   |ab |
+   * |d  |c  |ab |
+   * |e  |   |   |abcd|
+   */
+  cairo_region_t *levels[MAX_LEVELS];
+  int n_levels;
+} MetaRegionBuilder;
+
+static void
+meta_region_builder_init (MetaRegionBuilder *builder)
+{
+  int i;
+  for (i = 0; i < MAX_LEVELS; i++)
+    builder->levels[i] = NULL;
+  builder->n_levels = 1;
+}
+
+static void
+meta_region_builder_add_rectangle (MetaRegionBuilder *builder,
+                                   int                x,
+                                   int                y,
+                                   int                width,
+                                   int                height)
+{
+  cairo_rectangle_int_t rect;
+  int i;
+
+  if (builder->levels[0] == NULL)
+    builder->levels[0] = cairo_region_create ();
+
+  rect.x = x;
+  rect.y = y;
+  rect.width = width;
+  rect.height = height;
+
+  cairo_region_union_rectangle (builder->levels[0], &rect);
+  if (cairo_region_num_rectangles (builder->levels[0]) >= MAX_CHUNK_RECTANGLES)
+    {
+      for (i = 1; i < builder->n_levels + 1; i++)
+        {
+          if (builder->levels[i] == NULL)
+            {
+              if (i < MAX_LEVELS)
+                {
+                  builder->levels[i] = builder->levels[i - 1];
+                  builder->levels[i - 1] = NULL;
+                  if (i == builder->n_levels)
+                    builder->n_levels++;
+                }
+
+              break;
+            }
+          else
+            {
+              cairo_region_union (builder->levels[i], builder->levels[i - 1]);
+              cairo_region_destroy (builder->levels[i - 1]);
+              builder->levels[i - 1] = NULL;
+            }
+        }
+    }
+}
+
+static cairo_region_t *
+meta_region_builder_finish (MetaRegionBuilder *builder)
+{
+  cairo_region_t *result = NULL;
+  int i;
+
+  for (i = 0; i < builder->n_levels; i++)
+    {
+      if (builder->levels[i])
+        {
+          if (result == NULL)
+            result = builder->levels[i];
+          else
+            {
+              cairo_region_union(result, builder->levels[i]);
+              cairo_region_destroy (builder->levels[i]);
+            }
+        }
+    }
+
+  if (result == NULL)
+    result = cairo_region_create ();
+
+  return result;
+}
+
+
+/* MetaRegionIterator */
+
+void
+meta_region_iterator_init (MetaRegionIterator *iter,
+                           cairo_region_t     *region)
+{
+  iter->region = region;
+  iter->i = 0;
+  iter->n_rectangles = cairo_region_num_rectangles (region);
+  iter->line_start = TRUE;
+
+  if (iter->n_rectangles > 1)
+    {
+      cairo_region_get_rectangle (region, 0, &iter->rectangle);
+      cairo_region_get_rectangle (region, 1, &iter->next_rectangle);
+
+      iter->line_end = iter->next_rectangle.y != iter->rectangle.y;
+    }
+  else if (iter->n_rectangles > 0)
+    {
+      cairo_region_get_rectangle (region, 0, &iter->rectangle);
+      iter->line_end = TRUE;
+    }
+}
+
+gboolean
+meta_region_iterator_at_end (MetaRegionIterator *iter)
+{
+  return iter->i >= iter->n_rectangles;
+}
+
+void
+meta_region_iterator_next (MetaRegionIterator *iter)
+{
+  iter->i++;
+  iter->rectangle = iter->next_rectangle;
+  iter->line_start = iter->line_end;
+
+  if (iter->i + 1 < iter->n_rectangles)
+    {
+      cairo_region_get_rectangle (iter->region, iter->i + 1, &iter->next_rectangle);
+      iter->line_end = iter->next_rectangle.y != iter->rectangle.y;
+    }
+  else
+    {
+      iter->line_end = TRUE;
+    }
+}
+
+static void
+add_expanded_rect (MetaRegionBuilder  *builder,
+                   int                 x,
+                   int                 y,
+                   int                 width,
+                   int                 height,
+                   int                 x_amount,
+                   int                 y_amount,
+                   gboolean            flip)
+{
+  if (flip)
+    meta_region_builder_add_rectangle (builder,
+                                       y - y_amount, x - x_amount,
+                                       height + 2 * y_amount, width + 2 * x_amount);
+  else
+    meta_region_builder_add_rectangle (builder,
+                                       x - x_amount, y - y_amount,
+                                       width + 2 * x_amount, height + 2 * y_amount);
+}
+
+static cairo_region_t *
+expand_region (cairo_region_t *region,
+               int             x_amount,
+               int             y_amount,
+               gboolean        flip)
+{
+  MetaRegionBuilder builder;
+  int n;
+  int i;
+
+  meta_region_builder_init (&builder);
+
+  n = cairo_region_num_rectangles (region);
+  for (i = 0; i < n; i++)
+    {
+      cairo_rectangle_int_t rect;
+
+      cairo_region_get_rectangle (region, i, &rect);
+      add_expanded_rect (&builder,
+                         rect.x, rect.y, rect.width, rect.height,
+                         x_amount, y_amount, flip);
+    }
+
+  return meta_region_builder_finish (&builder);
+}
+
+/* This computes a (clipped version) of the inverse of the region
+ * and expands it by the given amount */
+static cairo_region_t *
+expand_region_inverse (cairo_region_t *region,
+                       int             x_amount,
+                       int             y_amount,
+                       gboolean        flip)
+{
+  MetaRegionBuilder builder;
+  MetaRegionIterator iter;
+  cairo_rectangle_int_t extents;
+  cairo_region_t *chunk;
+
+  int last_x;
+
+  meta_region_builder_init (&builder);
+
+  cairo_region_get_extents (region, &extents);
+  add_expanded_rect (&builder,
+                     extents.x, extents.y - 1, extents.width, 1,
+                     x_amount, y_amount, flip);
+  add_expanded_rect (&builder,
+                     extents.x - 1, extents.y, 1, extents.height,
+                     x_amount, y_amount, flip);
+  add_expanded_rect (&builder,
+                     extents.x + extents.width, extents.y, 1, extents.height,
+                     x_amount, y_amount, flip);
+  add_expanded_rect (&builder,
+                     extents.x, extents.y + extents.height, extents.width, 1,
+                     x_amount, y_amount, flip);
+
+  chunk = NULL;
+
+  last_x = extents.x;
+  for (meta_region_iterator_init (&iter, region);
+       !meta_region_iterator_at_end (&iter);
+       meta_region_iterator_next (&iter))
+    {
+      if (chunk == NULL)
+        chunk = cairo_region_create ();
+
+      if (iter.rectangle.x > last_x)
+        add_expanded_rect (&builder,
+                           last_x, iter.rectangle.y,
+                           iter.rectangle.x - last_x, iter.rectangle.height,
+                           x_amount, y_amount, flip);
+
+      if (iter.line_end)
+        {
+          if (extents.x + extents.width > iter.rectangle.x + iter.rectangle.width)
+            add_expanded_rect (&builder,
+                               iter.rectangle.x + iter.rectangle.width, iter.rectangle.y,
+                               (extents.x + extents.width) - (iter.rectangle.x + iter.rectangle.width), iter.rectangle.height,
+                               x_amount, y_amount, flip);
+          last_x = extents.x;
+        }
+      else
+        last_x = iter.rectangle.x + iter.rectangle.width;
+    }
+
+  return meta_region_builder_finish (&builder);
+}
+
+/**
+ * meta_make_border_region:
+ * @region: a #cairo_region_t
+ * @x_amount: distance from the border to extend horizontally
+ * @y_amount: distance from the border to extend vertically
+ * @flip: if true, the result is computed with x and y interchanged
+ *
+ * Computes the "border region" of a given region, which is roughly
+ * speaking the set of points near the boundary of the region.  If we
+ * define the operation of growing a region as computing the set of
+ * points within a given manhattan distance of the region, then the
+ * border is 'grow(region) intersect grow(inverse(region))'.
+ *
+ * If we create an image by filling the region with a solid color,
+ * the border is the region affected by blurring the region.
+ *
+ * Return value: a new region which is the border of the given region
+ */
+cairo_region_t *
+meta_make_border_region (cairo_region_t *region,
+                         int             x_amount,
+                         int             y_amount,
+                         gboolean        flip)
+{
+  cairo_region_t *border_region;
+  cairo_region_t *inverse_region;
+
+  border_region = expand_region (region, x_amount, y_amount, flip);
+  inverse_region = expand_region_inverse (region, x_amount, y_amount, flip);
+  cairo_region_intersect (border_region, inverse_region);
+  cairo_region_destroy (inverse_region);
+
+  return border_region;
+}
--- a/src/compositor/region-utils.h
+++ b/src/compositor/region-utils.h
@@ -0,0 +1,76 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * Utilities for region manipulation
+ *
+ * Copyright (C) 2010 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_REGION_UTILS_H__
+#define __META_REGION_UTILS_H__
+
+#include <clutter/clutter.h>
+
+#include <cairo.h>
+#include <glib.h>
+
+/**
+ * MetaRegionIterator:
+ * @region: region being iterated
+ * @rectangle: current rectangle
+ * @line_start: whether the current rectangle starts a horizontal band
+ * @line_end: whether the current rectangle ends a horizontal band
+ *
+ * cairo_region_t is a yx banded region; sometimes its useful to iterate through
+ * such a region treating the start and end of each horizontal band in a distinct
+ * fashion.
+ *
+ * Usage:
+ *
+ *  MetaRegionIterator iter;
+ *  for (meta_region_iterator_init (&iter, region);
+ *       !meta_region_iterator_at_end (&iter);
+ *       meta_region_iterator_next (&iter))
+ *  {
+ *    [ Use iter.rectangle, iter.line_start, iter.line_end ]
+ *  }
+ */
+typedef struct _MetaRegionIterator MetaRegionIterator;
+
+struct _MetaRegionIterator {
+  cairo_region_t *region;
+  cairo_rectangle_int_t rectangle;
+  gboolean line_start;
+  gboolean line_end;
+  int i;
+
+  /*< private >*/
+  int n_rectangles;
+  cairo_rectangle_int_t next_rectangle;
+};
+
+void     meta_region_iterator_init      (MetaRegionIterator *iter,
+                                         cairo_region_t     *region);
+gboolean meta_region_iterator_at_end    (MetaRegionIterator *iter);
+void     meta_region_iterator_next      (MetaRegionIterator *iter);
+
+cairo_region_t *meta_make_border_region (cairo_region_t *region,
+                                         int             x_amount,
+                                         int             y_amount,
+                                         gboolean        flip);
+
+#endif /* __META_REGION_UTILS_H__ */
--- a/src/compositor/shadow.c
+++ b/src/compositor/shadow.c
@@ -1,350 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-#define _GNU_SOURCE /* For M_PI */
-
-#include <math.h>
-
-#include "compositor-private.h"
-#include "shadow.h"
-#include "tidy/tidy-texture-frame.h"
-
-#define SHADOW_RADIUS 8
-#define SHADOW_OPACITY	0.9
-#define SHADOW_OFFSET_X	(SHADOW_RADIUS)
-#define SHADOW_OFFSET_Y	(SHADOW_RADIUS)
-
-#define MAX_TILE_SZ 8 	/* Must be <= shaddow radius */
-#define TILE_WIDTH  (3*MAX_TILE_SZ)
-#define TILE_HEIGHT (3*MAX_TILE_SZ)
-
-static unsigned char* shadow_gaussian_make_tile (void);
-
-ClutterActor *
-mutter_create_shadow_frame (MetaCompositor *compositor)
-{
-  ClutterActor *frame;
-
-  if (!compositor->shadow_src)
-    {
-      guchar *data;
-
-      data = shadow_gaussian_make_tile ();
-
-      compositor->shadow_src = clutter_texture_new ();
-
-      clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (compositor->shadow_src),
-                                         data,
-                                         TRUE,
-                                         TILE_WIDTH,
-                                         TILE_HEIGHT,
-                                         TILE_WIDTH*4,
-                                         4,
-                                         0,
-                                         NULL);
-      g_free (data);
-    }
-
-  frame = tidy_texture_frame_new (CLUTTER_TEXTURE (compositor->shadow_src),
-                                  MAX_TILE_SZ,
-                                  MAX_TILE_SZ,
-                                  MAX_TILE_SZ,
-                                  MAX_TILE_SZ);
-
-  clutter_actor_set_position (frame,
-                              SHADOW_OFFSET_X , SHADOW_OFFSET_Y);
-
-  return frame;
-}
-
-typedef struct GaussianMap
-{
-  int	   size;
-  double * data;
-} GaussianMap;
-
-static double
-gaussian (double r, double x, double y)
-{
-  return ((1 / (sqrt (2 * M_PI * r))) *
-	  exp ((- (x * x + y * y)) / (2 * r * r)));
-}
-
-
-static GaussianMap *
-make_gaussian_map (double r)
-{
-  GaussianMap  *c;
-  int	          size = ((int) ceil ((r * 3)) + 1) & ~1;
-  int	          center = size / 2;
-  int	          x, y;
-  double          t = 0.0;
-  double          g;
-
-  c = g_malloc (sizeof (GaussianMap) + size * size * sizeof (double));
-  c->size = size;
-
-  c->data = (double *) (c + 1);
-
-  for (y = 0; y < size; y++)
-    for (x = 0; x < size; x++)
-      {
-	g = gaussian (r, (double) (x - center), (double) (y - center));
-	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 unsigned char
-sum_gaussian (GaussianMap * map, double opacity,
-              int x, int y, int width, int height)
-{
-  int	           fx, fy;
-  double         * g_data;
-  double         * g_line = map->data;
-  int	           g_size = map->size;
-  int	           center = g_size / 2;
-  int	           fx_start, fx_end;
-  int	           fy_start, fy_end;
-  double           v;
-  unsigned int     r;
-
-  /*
-   * Compute set of filter values which are "in range",
-   * that's the set with:
-   *	0 <= x + (fx-center) && x + (fx-center) < width &&
-   *  0 <= y + (fy-center) && y + (fy-center) < height
-   *
-   *  0 <= x + (fx - center)	x + fx - center < width
-   *  center - x <= fx	fx < width + center - x
-   */
-
-  fx_start = center - x;
-  if (fx_start < 0)
-    fx_start = 0;
-  fx_end = width + center - x;
-  if (fx_end > g_size)
-    fx_end = g_size;
-
-  fy_start = center - y;
-  if (fy_start < 0)
-    fy_start = 0;
-  fy_end = height + center - y;
-  if (fy_end > g_size)
-    fy_end = g_size;
-
-  g_line = g_line + fy_start * g_size + fx_start;
-
-  v = 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)
-    v = 1;
-
-  v *= (opacity * 255.0);
-
-  r = (unsigned int) v;
-
-  return (unsigned char) r;
-}
-
-static unsigned char *
-shadow_gaussian_make_tile ()
-{
-  unsigned char              * data;
-  int		               size;
-  int		               center;
-  int		               x, y;
-  unsigned char                d;
-  int                          pwidth, pheight;
-  double                       opacity = SHADOW_OPACITY;
-  static GaussianMap       * gaussian_map = NULL;
-
-  struct _mypixel
-  {
-    unsigned char r;
-    unsigned char g;
-    unsigned char b;
-    unsigned char a;
-  } * _d;
-
-
-  if (!gaussian_map)
-    gaussian_map =
-      make_gaussian_map (SHADOW_RADIUS);
-
-  size   = gaussian_map->size;
-  center = size / 2;
-
-  /* Top & bottom */
-
-  pwidth  = MAX_TILE_SZ;
-  pheight = MAX_TILE_SZ;
-
-  data = g_malloc0 (4 * TILE_WIDTH * TILE_HEIGHT);
-
-  _d = (struct _mypixel*) data;
-
-  /* N */
-  for (y = 0; y < pheight; y++)
-    {
-      d = sum_gaussian (gaussian_map, opacity,
-                        center, y - center,
-                        TILE_WIDTH, TILE_HEIGHT);
-      for (x = 0; x < pwidth; x++)
-	{
-	  _d[y*3*pwidth + x + pwidth].r = 0;
-	  _d[y*3*pwidth + x + pwidth].g = 0;
-	  _d[y*3*pwidth + x + pwidth].b = 0;
-	  _d[y*3*pwidth + x + pwidth].a = d;
-	}
-
-    }
-
-  /* S */
-  pwidth = MAX_TILE_SZ;
-  pheight = MAX_TILE_SZ;
-
-  for (y = 0; y < pheight; y++)
-    {
-      d = sum_gaussian (gaussian_map, opacity,
-                        center, y - center,
-                        TILE_WIDTH, TILE_HEIGHT);
-      for (x = 0; x < pwidth; x++)
-	{
-	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].r = 0;
-	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].g = 0;
-	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].b = 0;
-	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].a = d;
-	}
-
-    }
-
-
-  /* w */
-  pwidth = MAX_TILE_SZ;
-  pheight = MAX_TILE_SZ;
-
-  for (x = 0; x < pwidth; x++)
-    {
-      d = sum_gaussian (gaussian_map, opacity,
-                        x - center, center,
-                        TILE_WIDTH, TILE_HEIGHT);
-      for (y = 0; y < pheight; y++)
-	{
-	  _d[y*3*pwidth + 3*pwidth*pheight + x].r = 0;
-	  _d[y*3*pwidth + 3*pwidth*pheight + x].g = 0;
-	  _d[y*3*pwidth + 3*pwidth*pheight + x].b = 0;
-	  _d[y*3*pwidth + 3*pwidth*pheight + x].a = d;
-	}
-
-    }
-
-  /* E */
-  for (x = 0; x < pwidth; x++)
-    {
-      d = sum_gaussian (gaussian_map, opacity,
-					       x - center, center,
-					       TILE_WIDTH, TILE_HEIGHT);
-      for (y = 0; y < pheight; y++)
-	{
-	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].r = 0;
-	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].g = 0;
-	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].b = 0;
-	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].a = d;
-	}
-
-    }
-
-  /* NW */
-  pwidth = MAX_TILE_SZ;
-  pheight = MAX_TILE_SZ;
-
-  for (x = 0; x < pwidth; x++)
-    for (y = 0; y < pheight; y++)
-      {
-	d = sum_gaussian (gaussian_map, opacity,
-                          x-center, y-center,
-                          TILE_WIDTH, TILE_HEIGHT);
-
-	_d[y*3*pwidth + x].r = 0;
-	_d[y*3*pwidth + x].g = 0;
-	_d[y*3*pwidth + x].b = 0;
-	_d[y*3*pwidth + x].a = d;
-      }
-
-  /* SW */
-  for (x = 0; x < pwidth; x++)
-    for (y = 0; y < pheight; y++)
-      {
-	d = sum_gaussian (gaussian_map, opacity,
-                          x-center, y-center,
-                          TILE_WIDTH, TILE_HEIGHT);
-
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].r = 0;
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].g = 0;
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].b = 0;
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].a = d;
-      }
-
-  /* SE */
-  for (x = 0; x < pwidth; x++)
-    for (y = 0; y < pheight; y++)
-      {
-	d = sum_gaussian (gaussian_map, opacity,
-                          x-center, y-center,
-                          TILE_WIDTH, TILE_HEIGHT);
-
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
-	   2*pwidth].r = 0;
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
-	   2*pwidth].g = 0;
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
-	   2*pwidth].b = 0;
-	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
-	   2*pwidth].a = d;
-      }
-
-  /* NE */
-  for (x = 0; x < pwidth; x++)
-    for (y = 0; y < pheight; y++)
-      {
-	d = sum_gaussian (gaussian_map, opacity,
-                          x-center, y-center,
-                          TILE_WIDTH, TILE_HEIGHT);
-
-	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].r = 0;
-	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].g = 0;
-	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].b = 0;
-	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].a = d;
-      }
-
-  /* center */
-  pwidth = MAX_TILE_SZ;
-  pheight = MAX_TILE_SZ;
-
-  d = sum_gaussian (gaussian_map, opacity,
-                    center, center, TILE_WIDTH, TILE_HEIGHT);
-
-  for (x = 0; x < pwidth; x++)
-    for (y = 0; y < pheight; y++)
-      {
-	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].r = 0;
-	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].g = 0;
-	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].b = 0;
-	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].a = 0;
-      }
-
-  return data;
-}
--- a/src/compositor/shadow.h
+++ b/src/compositor/shadow.h
@@ -1,9 +0,0 @@
-#ifndef SHADOW_H
-#define SHADOW_H
-
-#include <clutter/clutter.h>
-#include "compositor.h"
-
-ClutterActor *mutter_create_shadow_frame (MetaCompositor *compositor);
-
-#endif /* SHADOW_H */
--- a/src/compositor/tidy/tidy-texture-frame.c
+++ b/src/compositor/tidy/tidy-texture-frame.c
@@ -1,641 +0,0 @@
-/* tidy-texture-frame.h: Expandible texture actor
- *
- * Copyright (C) 2007 OpenedHand
- *
- * 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.
- */
-
-/**
- * SECTION:tidy-texture-frame
- * @short_description: Stretch a texture to fit the entire allocation
- *
- * #TidyTextureFrame
- *
- */
-
-#include <cogl/cogl.h>
-
-#include "tidy-texture-frame.h"
-
-#define TIDY_PARAM_READABLE     \
-        (G_PARAM_READABLE |     \
-         G_PARAM_STATIC_NICK | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB)
-
-#define TIDY_PARAM_READWRITE    \
-        (G_PARAM_READABLE | G_PARAM_WRITABLE | \
-         G_PARAM_STATIC_NICK | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB)
-
-enum
-{
-  PROP_0,
-
-  PROP_PARENT_TEXTURE,
-
-  PROP_LEFT,
-  PROP_TOP,
-  PROP_RIGHT,
-  PROP_BOTTOM
-};
-
-G_DEFINE_TYPE (TidyTextureFrame, tidy_texture_frame, CLUTTER_TYPE_ACTOR);
-
-#define TIDY_TEXTURE_FRAME_GET_PRIVATE(obj)     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFramePrivate))
-
-struct _TidyTextureFramePrivate
-{
-  ClutterTexture *parent_texture;
-
-  gfloat left;
-  gfloat top;
-  gfloat right;
-  gfloat bottom;
-
-  CoglHandle material;
-
-  guint needs_paint : 1;
-};
-
-static void
-tidy_texture_frame_get_preferred_width (ClutterActor *self,
-                                        gfloat        for_height,
-                                        gfloat       *min_width_p,
-                                        gfloat       *natural_width_p)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
-
-  if (G_UNLIKELY (priv->parent_texture == NULL))
-    {
-      if (min_width_p)
-        *min_width_p = 0;
-
-      if (natural_width_p)
-        *natural_width_p = 0;
-    }
-  else
-    {
-      ClutterActorClass *klass;
-
-      /* by directly querying the parent texture's class implementation
-       * we are going around any override mechanism the parent texture
-       * might have in place, and we ask directly for the original
-       * preferred width
-       */
-      klass = CLUTTER_ACTOR_GET_CLASS (priv->parent_texture);
-      klass->get_preferred_width (CLUTTER_ACTOR (priv->parent_texture),
-                                  for_height,
-                                  min_width_p,
-                                  natural_width_p);
-    }
-}
-
-static void
-tidy_texture_frame_get_preferred_height (ClutterActor *self,
-                                         gfloat        for_width,
-                                         gfloat       *min_height_p,
-                                         gfloat       *natural_height_p)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
-
-  if (G_UNLIKELY (priv->parent_texture == NULL))
-    {
-      if (min_height_p)
-        *min_height_p = 0;
-
-      if (natural_height_p)
-        *natural_height_p = 0;
-    }
-  else
-    {
-      ClutterActorClass *klass;
-
-      /* by directly querying the parent texture's class implementation
-       * we are going around any override mechanism the parent texture
-       * might have in place, and we ask directly for the original
-       * preferred height
-       */
-      klass = CLUTTER_ACTOR_GET_CLASS (priv->parent_texture);
-      klass->get_preferred_height (CLUTTER_ACTOR (priv->parent_texture),
-                                   for_width,
-                                   min_height_p,
-                                   natural_height_p);
-    }
-}
-
-static void
-tidy_texture_frame_realize (ClutterActor *self)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
-
-  if (priv->material != COGL_INVALID_HANDLE)
-    return;
-
-  priv->material = cogl_material_new ();
-
-  CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
-}
-
-static void
-tidy_texture_frame_unrealize (ClutterActor *self)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
-
-  if (priv->material == COGL_INVALID_HANDLE)
-    return;
-
-  cogl_handle_unref (priv->material);
-  priv->material = COGL_INVALID_HANDLE;
-
-  CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
-}
-
-static void
-tidy_texture_frame_paint (ClutterActor *self)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
-  CoglHandle cogl_texture = COGL_INVALID_HANDLE;
-  ClutterActorBox box = { 0, };
-  gfloat width, height;
-  gfloat tex_width, tex_height;
-  gfloat ex, ey;
-  gfloat tx1, ty1, tx2, ty2;
-  guint8 opacity;
-
-  /* no need to paint stuff if we don't have a texture */
-  if (G_UNLIKELY (priv->parent_texture == NULL))
-    return;
-
-  if (!priv->needs_paint)
-    return;
-
-  /* parent texture may have been hidden, so need to make sure it gets
-   * realized
-   */
-  if (!CLUTTER_ACTOR_IS_REALIZED (priv->parent_texture))
-    clutter_actor_realize (CLUTTER_ACTOR (priv->parent_texture));
-
-  cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture);
-  if (cogl_texture == COGL_INVALID_HANDLE)
-    return;
-
-  tex_width  = cogl_texture_get_width (cogl_texture);
-  tex_height = cogl_texture_get_height (cogl_texture);
-
-  clutter_actor_get_allocation_box (self, &box);
-  width = box.x2 - box.x1;
-  height = box.y2 - box.y1;
-
-  tx1 = priv->left / tex_width;
-  tx2 = (tex_width - priv->right) / tex_width;
-  ty1 = priv->top / tex_height;
-  ty2 = (tex_height - priv->bottom) / tex_height;
-
-  ex = width - priv->right;
-  if (ex < 0)
-    ex = priv->right; 		/* FIXME ? */
-
-  ey = height - priv->bottom;
-  if (ey < 0)
-    ey = priv->bottom; 		/* FIXME ? */
-
-  opacity = clutter_actor_get_paint_opacity (self);
-
-  g_assert (priv->material != COGL_INVALID_HANDLE);
-
-  /* set the source material using the parent texture's COGL handle */
-  cogl_material_set_color4ub (priv->material, opacity, opacity, opacity, opacity);
-  cogl_material_set_layer (priv->material, 0, cogl_texture);
-  cogl_set_source (priv->material);
-
-  /* top left corner */
-  cogl_rectangle_with_texture_coords (0, 0, priv->left, priv->top,
-                                      0.0, 0.0,
-                                      tx1, ty1);
-
-  /* top middle */
-  cogl_rectangle_with_texture_coords (priv->left, 0, ex, priv->top,
-                                      tx1, 0.0,
-                                      tx2, ty1);
-
-  /* top right */
-  cogl_rectangle_with_texture_coords (ex, 0, width, priv->top,
-                                      tx2, 0.0,
-                                      1.0, ty1);
-
-  /* mid left */
-  cogl_rectangle_with_texture_coords (0, priv->top, priv->left, ey,
-                                      0.0, ty1,
-                                      tx1, ty2);
-
-  /* center */
-  cogl_rectangle_with_texture_coords (priv->left, priv->top, ex, ey,
-                                      tx1, ty1,
-                                      tx2, ty2);
-
-  /* mid right */
-  cogl_rectangle_with_texture_coords (ex, priv->top, width, ey,
-                                      tx2, ty1,
-                                      1.0, ty2);
-  
-  /* bottom left */
-  cogl_rectangle_with_texture_coords (0, ey, priv->left, height,
-                                      0.0, ty2,
-                                      tx1, 1.0);
-
-  /* bottom center */
-  cogl_rectangle_with_texture_coords (priv->left, ey, ex, height,
-                                      tx1, ty2,
-                                      tx2, 1.0);
-
-  /* bottom right */
-  cogl_rectangle_with_texture_coords (ex, ey, width, height,
-                                      tx2, ty2,
-                                      1.0, 1.0);
-}
-
-static inline void
-tidy_texture_frame_set_frame_internal (TidyTextureFrame *frame,
-                                       gfloat            left,
-                                       gfloat            top,
-                                       gfloat            right,
-                                       gfloat            bottom)
-{
-  TidyTextureFramePrivate *priv = frame->priv;
-  GObject *gobject = G_OBJECT (frame);
-  gboolean changed = FALSE;
-
-  g_object_freeze_notify (gobject);
-
-  if (priv->top != top)
-    {
-      priv->top = top;
-      g_object_notify (gobject, "top");
-      changed = TRUE;
-    }
-
-  if (priv->right != right)
-    {
-      priv->right = right;
-      g_object_notify (gobject, "right");
-      changed = TRUE;
-    }
-
-  if (priv->bottom != bottom)
-    {
-      priv->bottom = bottom;
-      g_object_notify (gobject, "bottom");
-      changed = TRUE;
-    }
-
-  if (priv->left != left)
-    {
-      priv->left = left;
-      g_object_notify (gobject, "left");
-      changed = TRUE;
-    }
-
-  if (changed && CLUTTER_ACTOR_IS_VISIBLE (frame))
-    clutter_actor_queue_redraw (CLUTTER_ACTOR (frame));
-
-  g_object_thaw_notify (gobject);
-}
-
-static void
-tidy_texture_frame_set_property (GObject      *gobject,
-                                 guint         prop_id,
-                                 const GValue *value,
-                                 GParamSpec   *pspec)
-{
-  TidyTextureFrame *frame = TIDY_TEXTURE_FRAME (gobject);
-  TidyTextureFramePrivate *priv = frame->priv;
-
-  switch (prop_id)
-    {
-    case PROP_PARENT_TEXTURE:
-      tidy_texture_frame_set_parent_texture (frame,
-                                             g_value_get_object (value));
-      break;
-
-    case PROP_TOP:
-      tidy_texture_frame_set_frame_internal (frame,
-                                             priv->left,
-                                             g_value_get_float (value),
-                                             priv->right,
-                                             priv->bottom);
-      break;
-
-    case PROP_RIGHT:
-      tidy_texture_frame_set_frame_internal (frame,
-                                             priv->top,
-                                             g_value_get_float (value),
-                                             priv->bottom,
-                                             priv->left);
-      break;
-
-    case PROP_BOTTOM:
-      tidy_texture_frame_set_frame_internal (frame,
-                                             priv->top,
-                                             priv->right,
-                                             g_value_get_float (value),
-                                             priv->left);
-      break;
-
-    case PROP_LEFT:
-      tidy_texture_frame_set_frame_internal (frame,
-                                             priv->top,
-                                             priv->right,
-                                             priv->bottom,
-                                             g_value_get_float (value));
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-tidy_texture_frame_get_property (GObject    *gobject,
-                                 guint       prop_id,
-                                 GValue     *value,
-                                 GParamSpec *pspec)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (gobject)->priv;
-
-  switch (prop_id)
-    {
-    case PROP_PARENT_TEXTURE:
-      g_value_set_object (value, priv->parent_texture);
-      break;
-
-    case PROP_LEFT:
-      g_value_set_float (value, priv->left);
-      break;
-
-    case PROP_TOP:
-      g_value_set_float (value, priv->top);
-      break;
-
-    case PROP_RIGHT:
-      g_value_set_float (value, priv->right);
-      break;
-
-    case PROP_BOTTOM:
-      g_value_set_float (value, priv->bottom);
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-tidy_texture_frame_dispose (GObject *gobject)
-{
-  TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (gobject)->priv;
-
-  if (priv->parent_texture)
-    {
-      g_object_unref (priv->parent_texture);
-      priv->parent_texture = NULL;
-    }
-
-  if (priv->material)
-    {
-      cogl_handle_unref (priv->material);
-      priv->material = COGL_INVALID_HANDLE;
-    }
-
-  G_OBJECT_CLASS (tidy_texture_frame_parent_class)->dispose (gobject);
-}
-
-static void
-tidy_texture_frame_class_init (TidyTextureFrameClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
-  GParamSpec *pspec;
-
-  g_type_class_add_private (gobject_class, sizeof (TidyTextureFramePrivate));
-
-  actor_class->get_preferred_width =
-    tidy_texture_frame_get_preferred_width;
-  actor_class->get_preferred_height =
-    tidy_texture_frame_get_preferred_height;
-  actor_class->realize = tidy_texture_frame_realize;
-  actor_class->unrealize = tidy_texture_frame_unrealize;
-  actor_class->paint = tidy_texture_frame_paint;
-
-  gobject_class->set_property = tidy_texture_frame_set_property;
-  gobject_class->get_property = tidy_texture_frame_get_property;
-  gobject_class->dispose = tidy_texture_frame_dispose;
-
-  pspec = g_param_spec_object ("parent-texture",
-                               "Parent Texture",
-                               "The parent ClutterTexture",
-                               CLUTTER_TYPE_TEXTURE,
-                               TIDY_PARAM_READWRITE |
-                               G_PARAM_CONSTRUCT);
-  g_object_class_install_property (gobject_class, PROP_PARENT_TEXTURE, pspec);
-
-  pspec = g_param_spec_float ("left",
-                              "Left",
-                              "Left offset",
-			      0, G_MAXFLOAT,
-                              0,
-                              TIDY_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_LEFT, pspec);
-
-  pspec = g_param_spec_float ("top",
-                              "Top",
-                              "Top offset",
-                              0, G_MAXFLOAT,
-                              0,
-                              TIDY_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_TOP, pspec);
-
-  pspec = g_param_spec_float ("bottom",
-                              "Bottom",
-                              "Bottom offset",
-                              0, G_MAXFLOAT,
-                              0,
-                              TIDY_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_BOTTOM, pspec);
-
-  pspec = g_param_spec_float ("right",
-                              "Right",
-                              "Right offset",
-                              0, G_MAXFLOAT,
-                              0,
-                              TIDY_PARAM_READWRITE);
-  g_object_class_install_property (gobject_class, PROP_RIGHT, pspec);
-}
-
-static void
-tidy_texture_frame_init (TidyTextureFrame *self)
-{
-  TidyTextureFramePrivate *priv;
-
-  self->priv = priv = TIDY_TEXTURE_FRAME_GET_PRIVATE (self);
-
-  priv->material = COGL_INVALID_HANDLE;
-}
-
-/**
- * tidy_texture_frame_new:
- * @texture: a #ClutterTexture or %NULL
- * @left: left margin preserving its content
- * @top: top margin preserving its content
- * @right: right margin preserving its content
- * @bottom: bottom margin preserving its content
- *
- * A #TidyTextureFrame is a specialized texture that efficiently clones
- * an area of the given @texture while keeping preserving portions of the
- * same texture.
- *
- * A #TidyTextureFrame can be used to make a rectangular texture fit a
- * given size without stretching its borders.
- *
- * Return value: the newly created #TidyTextureFrame
- */
-ClutterActor*
-tidy_texture_frame_new (ClutterTexture *texture, 
-			gfloat          left,
-			gfloat          top,
-			gfloat          right,
-			gfloat          bottom)
-{
-  g_return_val_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture), NULL);
-
-  return g_object_new (TIDY_TYPE_TEXTURE_FRAME,
- 		       "parent-texture", texture,
-		       "left", left,
-		       "top", top,
-		       "right", right,
-		       "bottom", bottom,
-		       NULL);
-}
-
-ClutterTexture *
-tidy_texture_frame_get_parent_texture (TidyTextureFrame *frame)
-{
-  g_return_val_if_fail (TIDY_IS_TEXTURE_FRAME (frame), NULL);
-
-  return frame->priv->parent_texture;
-}
-
-void
-tidy_texture_frame_set_parent_texture (TidyTextureFrame *frame,
-                                       ClutterTexture   *texture)
-{
-  TidyTextureFramePrivate *priv;
-  gboolean was_visible;
-
-  g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
-  g_return_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture));
-
-  priv = frame->priv;
-
-  was_visible = CLUTTER_ACTOR_IS_VISIBLE (frame);
-
-  if (priv->parent_texture == texture)
-    return;
-
-  if (priv->parent_texture)
-    {
-      g_object_unref (priv->parent_texture);
-      priv->parent_texture = NULL;
-
-      if (was_visible)
-        clutter_actor_hide (CLUTTER_ACTOR (frame));
-    }
-
-  if (texture)
-    {
-      priv->parent_texture = g_object_ref (texture);
-
-      if (was_visible && CLUTTER_ACTOR_IS_VISIBLE (priv->parent_texture))
-        clutter_actor_show (CLUTTER_ACTOR (frame));
-    }
-
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (frame));
-
-  g_object_notify (G_OBJECT (frame), "parent-texture");
-}
-
-void
-tidy_texture_frame_set_frame (TidyTextureFrame *frame,
-                              gfloat            top,
-                              gfloat            right,
-                              gfloat            bottom,
-                              gfloat            left)
-{
-  g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
-
-  tidy_texture_frame_set_frame_internal (frame, top, right, bottom, left);
-}
-
-void
-tidy_texture_frame_get_frame (TidyTextureFrame *frame,
-                              gfloat           *top,
-                              gfloat           *right,
-                              gfloat           *bottom,
-                              gfloat           *left)
-{
-  TidyTextureFramePrivate *priv;
-
-  g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
-
-  priv = frame->priv;
-
-  if (top)
-    *top = priv->top;
-
-  if (right)
-    *right = priv->right;
-
-  if (bottom)
-    *bottom = priv->bottom;
-
-  if (left)
-    *left = priv->left;
-}
-
-/**
- * tidy_texture_frame_set_needs_paint:
- * @frame: a #TidyTextureframe
- * @needs_paint: if %FALSE, the paint will be skipped
- *
- * Provides a hint to the texture frame that it is totally obscured
- * and doesn't need to be painted. This would typically be called
- * by a parent container if it detects the condition prior to
- * painting its children and then unset afterwards.
- *
- * Since it is not supposed to have any effect on display, it does
- * not queue a repaint.
- */
-void
-tidy_texture_frame_set_needs_paint (TidyTextureFrame *frame,
-				    gboolean          needs_paint)
-{
-  TidyTextureFramePrivate *priv;
-
-  g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
-
-  priv = frame->priv;
-
-  priv->needs_paint = needs_paint;
-}
--- a/src/compositor/tidy/tidy-texture-frame.h
+++ b/src/compositor/tidy/tidy-texture-frame.h
@@ -1,84 +0,0 @@
-/* tidy-texture-frame.h: Expandible texture actor
- *
- * Copyright (C) 2007, 2008 OpenedHand Ltd
- * Copyright (C) 2009 Intel Corp.
- *
- * 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.
- */
-
-#ifndef _HAVE_TIDY_TEXTURE_FRAME_H
-#define _HAVE_TIDY_TEXTURE_FRAME_H
-
-#include <clutter/clutter.h>
-
-G_BEGIN_DECLS
-
-#define TIDY_TYPE_TEXTURE_FRAME                 (tidy_texture_frame_get_type ())
-#define TIDY_TEXTURE_FRAME(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrame))
-#define TIDY_TEXTURE_FRAME_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrameClass))
-#define TIDY_IS_TEXTURE_FRAME(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TIDY_TYPE_TEXTURE_FRAME))
-#define TIDY_IS_TEXTURE_FRAME_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), TIDY_TYPE_TEXTURE_FRAME))
-#define TIDY_TEXTURE_FRAME_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrameClass))
-
-typedef struct _TidyTextureFrame                TidyTextureFrame;
-typedef struct _TidyTextureFramePrivate         TidyTextureFramePrivate;
-typedef struct _TidyTextureFrameClass           TidyTextureFrameClass;
-
-struct _TidyTextureFrame
-{
-  /*< private >*/
-  ClutterActor parent_instance;
-  
-  TidyTextureFramePrivate    *priv;
-};
-
-struct _TidyTextureFrameClass
-{
-  ClutterActorClass parent_class;
-
-  /* padding for future expansion */
-  void (*_clutter_box_1) (void);
-  void (*_clutter_box_2) (void);
-  void (*_clutter_box_3) (void);
-  void (*_clutter_box_4) (void);
-};
-
-GType           tidy_texture_frame_get_type           (void) G_GNUC_CONST;
-ClutterActor *  tidy_texture_frame_new                (ClutterTexture   *texture,
-                                                       gfloat            top,
-                                                       gfloat            right,
-                                                       gfloat            bottom,
-                                                       gfloat            left);
-void            tidy_texture_frame_set_parent_texture (TidyTextureFrame *frame,
-                                                       ClutterTexture   *texture);
-ClutterTexture *tidy_texture_frame_get_parent_texture (TidyTextureFrame *frame);
-void            tidy_texture_frame_set_frame          (TidyTextureFrame *frame,
-                                                       gfloat            top,
-                                                       gfloat            right,
-                                                       gfloat            bottom,
-                                                       gfloat            left);
-void            tidy_texture_frame_get_frame          (TidyTextureFrame *frame,
-                                                       gfloat           *top,
-                                                       gfloat           *right,
-                                                       gfloat           *bottom,
-                                                       gfloat           *left);
-
-void            tidy_texture_frame_set_needs_paint    (TidyTextureFrame *frame,
-                                                       gboolean          needs_paint);
-
-G_END_DECLS
-
-#endif /* _HAVE_TIDY_TEXTURE_FRAME_H */
--- a/src/core/above-tab-keycode.c
+++ b/src/core/above-tab-keycode.c
@@ -0,0 +1,241 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Find the keycode for the key above the tab key */
+/*
+ * Copyright 2010 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.
+ */
+
+/* The standard cycle-windows keybinding should be the key above the
+ * tab key. This will have a different keysym on different keyboards -
+ * it's the ` (grave) key on US keyboards but something else on many
+ * other national layouts. So we need to figure out the keycode for
+ * this key without reference to key symbol.
+ *
+ * The "correct" way to do this is to get the XKB geometry from the
+ * X server, find the Tab key, find the key above the Tab key in the
+ * same section and use the keycode for that key. This is what I
+ * implemented here, but unfortunately, fetching the geometry is rather
+ * slow (It could take 20ms or more.)
+ *
+ * If you looking for a way to optimize Mutter startup performance:
+ * On all Linux systems using evdev the key above TAB will have
+ * keycode 49. (KEY_GRAVE=41 + the 8 code point offset between
+ * evdev keysyms and X keysyms.) So a configure option
+ * --with-above-tab-keycode=49 could be added that bypassed this
+ * code. It wouldn't work right for displaying Mutter remotely
+ * to a non-Linux X server, but that is pretty rare.
+ */
+
+#include <config.h>
+
+#include <string.h>
+
+#include "display-private.h"
+
+#include <X11/keysym.h>
+
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKBgeom.h>
+
+static guint
+compute_above_tab_keycode (Display *xdisplay)
+{
+  XkbDescPtr keyboard;
+  XkbGeometryPtr geometry;
+  int i, j, k;
+  int tab_keycode;
+  char *tab_name;
+  XkbSectionPtr tab_section;
+  XkbBoundsRec tab_bounds;
+  XkbKeyPtr best_key = NULL;
+  guint best_keycode = (guint)-1;
+  int best_x_dist = G_MAXINT;
+  int best_y_dist = G_MAXINT;
+
+  /* We need only the Names and the Geometry, but asking for these results
+   * in the Keyboard information retrieval failing for unknown reasons.
+   * (Testing with xorg-1.9.1.) So we ask for a part that we don't need
+   * as well.
+   */
+  keyboard = XkbGetKeyboard (xdisplay,
+                             XkbGBN_ClientSymbolsMask | XkbGBN_KeyNamesMask | XkbGBN_GeometryMask,
+                             XkbUseCoreKbd);
+
+  geometry = keyboard->geom;
+
+  /* There could potentially be multiple keys with the Tab keysym on the keyboard;
+   * but XKeysymToKeycode() returns us the one that the alt-Tab binding will
+   * use which is good enough
+   */
+  tab_keycode = XKeysymToKeycode (xdisplay, XK_Tab);
+  if (tab_keycode == 0 || tab_keycode < keyboard->min_key_code || tab_keycode > keyboard->max_key_code)
+    goto out;
+
+  /* The keyboard geometry is stored by key "name" rather than keycode.
+   * (Key names are 4-character strings like like TAB or AE01.) We use the
+   * 'names' part of the keyboard description to map keycode to key name.
+   *
+   * XKB has a "key aliases" feature where a single keyboard key can have
+   * multiple names (with separate sets of aliases in the 'names' part and
+   * in the 'geometry' part), but I don't really understand it or how it is used,
+   * so I'm ignoring it here.
+   */
+
+  tab_name = keyboard->names->keys[tab_keycode].name; /* Not NULL terminated! */
+
+  /* First, iterate through the keyboard geometry to find the tab key; the keyboard
+   * geometry has a three-level heirarchy of section > row > key
+   */
+  for (i = 0; i < geometry->num_sections; i++)
+    {
+      XkbSectionPtr section = &geometry->sections[i];
+      for (j = 0; j < section->num_rows; j++)
+        {
+          int x = 0;
+          int y = 0;
+
+          XkbRowPtr row = &section->rows[j];
+          for (k = 0; k < row->num_keys; k++)
+            {
+              XkbKeyPtr key = &row->keys[k];
+              XkbShapePtr shape = XkbKeyShape (geometry, key);
+
+              if (row->vertical)
+                y += key->gap;
+              else
+                x += key->gap;
+
+              if (strncmp (key->name.name, tab_name, XkbKeyNameLength) == 0)
+                {
+                  tab_section = section;
+                  tab_bounds = shape->bounds;
+                  tab_bounds.x1 += row->left + x;
+                  tab_bounds.x2 += row->left + x;
+                  tab_bounds.y1 += row->top + y;
+                  tab_bounds.y2 += row->top + y;
+
+                  goto found_tab;
+                }
+
+              if (row->vertical)
+                y += (shape->bounds.y2 - shape->bounds.y1);
+              else
+                x += (shape->bounds.x2 - shape->bounds.x1);
+            }
+        }
+    }
+
+  /* No tab key found */
+  goto out;
+
+ found_tab:
+
+  /* Now find the key that:
+   *  - Is in the same section as the Tab key
+   *  - Has a horizontal center in the Tab key's horizonal bounds
+   *  - Is above the Tab key at a distance closer than any other key
+   *  - In case of ties, has its horizontal center as close as possible
+   *    to the Tab key's horizontal center
+   */
+  for (j = 0; j < tab_section->num_rows; j++)
+    {
+      int x = 0;
+      int y = 0;
+
+      XkbRowPtr row = &tab_section->rows[j];
+      for (k = 0; k < row->num_keys; k++)
+        {
+          XkbKeyPtr key = &row->keys[k];
+          XkbShapePtr shape = XkbKeyShape(geometry, key);
+          XkbBoundsRec bounds = shape->bounds;
+          int x_center;
+          int x_dist, y_dist;
+
+          if (row->vertical)
+            y += key->gap;
+          else
+            x += key->gap;
+
+          bounds.x1 += row->left + x;
+          bounds.x2 += row->left + x;
+          bounds.y1 += row->top + y;
+          bounds.y2 += row->top + y;
+
+          y_dist = tab_bounds.y1 - bounds.y2;
+          if (y_dist < 0)
+            continue;
+
+          x_center = (bounds.x1 + bounds.x2) / 2;
+          if (x_center < tab_bounds.x1 || x_center > tab_bounds.x2)
+            continue;
+
+          x_dist = ABS (x_center - (tab_bounds.x1 + tab_bounds.x2) / 2);
+
+          if (y_dist < best_y_dist ||
+              (y_dist == best_y_dist && x_dist < best_x_dist))
+            {
+              best_key = key;
+              best_x_dist = x_dist;
+              best_y_dist = y_dist;
+             }
+
+          if (row->vertical)
+            y += (shape->bounds.y2 - shape->bounds.y1);
+          else
+            x += (shape->bounds.x2 - shape->bounds.x1);
+        }
+    }
+
+  if (best_key == NULL)
+    goto out;
+
+  /* Now we need to resolve the name of the best key back to a keycode */
+  for (i = keyboard->min_key_code; i < keyboard->max_key_code; i++)
+    {
+      if (strncmp (best_key->name.name, keyboard->names->keys[i].name, XkbKeyNameLength) == 0)
+        {
+          best_keycode = i;
+          break;
+        }
+    }
+
+ out:
+  XkbFreeKeyboard (keyboard, 0, True);
+
+  return best_keycode;
+}
+#else /* !HAVE_XKB */
+static guint
+compute_above_tab_keycode (Display *xdisplay)
+{
+  return XKeysymToKeycode (xdisplay, XK_grave);
+}
+#endif /* HAVE_XKB */
+
+guint
+meta_display_get_above_tab_keycode (MetaDisplay *display)
+{
+  if (display->above_tab_keycode == 0) /* not yet computed */
+    display->above_tab_keycode = compute_above_tab_keycode (display->xdisplay);
+
+  if (display->above_tab_keycode == (guint)-1) /* failed to compute */
+    return 0;
+  else
+    return display->above_tab_keycode;
+}
--- a/src/core/boxes-private.h
+++ b/src/core/boxes-private.h
@@ -0,0 +1,220 @@
+/* -*- 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_PRIVATE_H
+#define META_BOXES_PRIVATE_H
+
+#include <glib-object.h>
+#include "common.h"
+#include "boxes.h"
+
+#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;
+
+/* 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);
+
+/* 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_monitor_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 monitors which are not covered by the given
+ * struts.
+ */
+GList* meta_rectangle_find_nonintersected_monitor_edges (
+                                           const GList         *monitor_rects,
+                                           const GSList        *all_struts);
+
+#endif /* META_BOXES_PRIVATE_H */
--- a/src/core/boxes.c
+++ b/src/core/boxes.c
@@ -26,7 +26,7 @@
 * 02111-1307, USA.
 */

-#include "boxes.h"
+#include "boxes-private.h"
 #include "util.h"
 #include <X11/Xutil.h>  /* Just for the definition of the various gravities */

@@ -340,7 +340,6 @@ meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
   */

  /* First, the x direction */
-  int adjust = 0;
  switch (gravity)
    {
    case NorthWestGravity:
@@ -373,7 +372,6 @@ meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
  rect->width = new_width;
  
  /* Next, the y direction */
-  adjust = 0;
  switch (gravity)
    {
    case NorthWestGravity:
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -24,6 +24,7 @@
 */

 #include <config.h>
+#include "boxes-private.h"
 #include "constraints.h"
 #include "workspace-private.h"
 #include "place.h"
@@ -795,7 +796,7 @@ constrain_maximization (MetaWindow         *window,

  /* Determine whether constraint applies; exit if it doesn't */
  if ((!window->maximized_horizontally && !window->maximized_vertically) ||
-      META_WINDOW_TILED (window))
+      META_WINDOW_TILED_SIDE_BY_SIDE (window))
    return TRUE;

  /* Calculate target_size = maximized size of (window + frame) */
@@ -879,7 +880,7 @@ constrain_tiling (MetaWindow         *window,
    return TRUE;

  /* Determine whether constraint applies; exit if it doesn't */
-  if (!META_WINDOW_TILED (window))
+  if (!META_WINDOW_TILED_SIDE_BY_SIDE (window))
    return TRUE;

  /* Calculate target_size - as the tile previews need this as well, we
@@ -967,7 +968,8 @@ constrain_size_increments (MetaWindow         *window,

  /* Determine whether constraint applies; exit if it doesn't */
  if (META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
-      META_WINDOW_TILED (window) || info->action_type == ACTION_MOVE)
+      META_WINDOW_TILED_SIDE_BY_SIDE (window) ||
+      info->action_type == ACTION_MOVE)
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is */
@@ -1098,7 +1100,8 @@ constrain_aspect_ratio (MetaWindow         *window,
  constraints_are_inconsistent = minr > maxr;
  if (constraints_are_inconsistent ||
      META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
-      META_WINDOW_TILED (window) || info->action_type == ACTION_MOVE)
+      META_WINDOW_TILED_SIDE_BY_SIDE (window) ||
+      info->action_type == ACTION_MOVE)
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is.  We
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -117,65 +117,8 @@ meta_core_get (Display *xdisplay,
        *((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:
-	    case META_WINDOW_DROPDOWN_MENU:
-	    case META_WINDOW_POPUP_MENU:
-	    case META_WINDOW_TOOLTIP:
-	    case META_WINDOW_NOTIFICATION:
-	    case META_WINDOW_COMBO:
-	    case META_WINDOW_DND:
-	    case META_WINDOW_OVERRIDE_OTHER:
-              /* 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; 
-          }
+        *((MetaFrameType*)answer) = meta_window_get_frame_type (window);
+        break;
      case META_CORE_GET_MINI_ICON:
        *((GdkPixbuf**)answer) = window->mini_icon;
        break;
@@ -348,7 +291,7 @@ meta_core_lower_beneath_focus_window (Display *xdisplay,
                    xwindow,
                    CWSibling | CWStackMode,
                    &changes);
-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 void
--- a/src/core/delete.c
+++ b/src/core/delete.c
@@ -136,7 +136,7 @@ meta_window_delete (MetaWindow  *window,
                  window->desc);
      XKillClient (window->display->xdisplay, window->xwindow);
    }
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);

  meta_display_ping_window (window->display,
                            window,
@@ -200,7 +200,7 @@ meta_window_kill (MetaWindow *window)
              window->desc);
  meta_error_trap_push (window->display);
  XKillClient (window->display->xdisplay, window->xwindow);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 }

 void
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -77,6 +77,13 @@ typedef enum {
 */
 #define N_IGNORED_SERIALS           4

+typedef enum {
+  META_TILE_NONE,
+  META_TILE_LEFT,
+  META_TILE_RIGHT,
+  META_TILE_MAXIMIZED
+} MetaTileMode;
+
 struct _MetaDisplay
 {
  GObject parent_instance;
@@ -179,6 +186,7 @@ struct _MetaDisplay
  int         grab_anchor_root_x;
  int         grab_anchor_root_y;
  MetaRectangle grab_anchor_window_pos;
+  MetaTileMode  grab_tile_mode;
  int         grab_latest_motion_x;
  int         grab_latest_motion_y;
  gulong      grab_mask;
@@ -221,6 +229,7 @@ struct _MetaDisplay
  KeySym *keymap;
  int keysyms_per_keycode;
  XModifierKeymap *modmap;
+  unsigned int above_tab_keycode;
  unsigned int ignored_modifier_mask;
  unsigned int num_lock_mask;
  unsigned int scroll_lock_mask;
@@ -433,4 +442,7 @@ void meta_display_remove_autoraise_callback (MetaDisplay *display);

 void meta_display_overlay_key_activate (MetaDisplay *display);

+/* In above-tab-keycode.c */
+guint meta_display_get_above_tab_keycode (MetaDisplay *display);
+
 #endif
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -347,7 +347,7 @@ sn_error_trap_pop (SnDisplay *sn_display,
  MetaDisplay *display;
  display = meta_display_for_x_display (xdisplay);
  if (display != NULL)
-    meta_error_trap_pop (display, FALSE);
+    meta_error_trap_pop (display);
 }
 #endif

@@ -387,26 +387,6 @@ enable_compositor (MetaDisplay *display,
    }
 }

-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;
-}
-
 static void
 meta_display_init (MetaDisplay *disp)
 {
@@ -573,6 +553,7 @@ meta_display_open (void)
  the_display->grab_window = NULL;
  the_display->grab_screen = NULL;
  the_display->grab_resize_popup = NULL;
+  the_display->grab_tile_mode = META_TILE_NONE;

  the_display->grab_edge_resistance_data = NULL;

@@ -839,8 +820,7 @@ meta_display_open (void)
  /* 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 (1) /* meta_prefs_get_compositing_manager ()) FIXME */
-    enable_compositor (the_display, FALSE);
+  enable_compositor (the_display, FALSE);
   
  meta_display_grab (the_display);
  
@@ -890,7 +870,7 @@ meta_display_open (void)
                                                  timestamp);
      }

-    meta_error_trap_pop (the_display, FALSE);
+    meta_error_trap_pop (the_display);
  }
  
  meta_display_ungrab (the_display);  
@@ -1099,7 +1079,7 @@ meta_display_screen_for_xwindow (MetaDisplay *display,
  meta_error_trap_push (display);
  attr.screen = NULL;
  result = XGetWindowAttributes (display->xdisplay, xwindow, &attr);
-  meta_error_trap_pop (display, TRUE);
+  meta_error_trap_pop (display);

  /* Note, XGetWindowAttributes is on all kinds of crack
   * and returns 1 on success 0 on failure, rather than Success
@@ -1492,7 +1472,7 @@ window_raise_with_delay_callback (void *data)
 				   window->xwindow,
 				   &root, &child,
 				   &root_x, &root_y, &x, &y, &mask);
-      meta_error_trap_pop (window->display, TRUE);
+      meta_error_trap_pop (window->display);

      point_in_window = 
        (window->frame && POINT_IN_RECT (root_x, root_y, window->frame->rect)) ||
@@ -2208,7 +2188,7 @@ event_callback (XEvent   *event,
                            window->frame->xwindow);
              meta_error_trap_push (display);
              meta_window_destroy_frame (window->frame->window);
-              meta_error_trap_pop (display, FALSE);
+              meta_error_trap_pop (display);
            }
          else
            {
@@ -2377,7 +2357,7 @@ event_callback (XEvent   *event,
          meta_error_trap_push (display);
          XConfigureWindow (display->xdisplay, event->xconfigurerequest.window,
                            xwcm, &xwc);
-          meta_error_trap_pop (display, FALSE);
+          meta_error_trap_pop (display);
        }
      else
        {
@@ -2642,6 +2622,10 @@ event_callback (XEvent   *event,
                  meta_bell_notify (display, xkb_ev);
                }
 	      break;
+            case XkbNewKeyboardNotify:
+            case XkbMapNotify:
+              meta_display_process_mapping_event (display, event);
+              break;
 	    }
 	}
 #endif
@@ -3148,7 +3132,7 @@ meta_spew_event (MetaDisplay *display,
        meta_error_trap_push (display);
        str = XGetAtomName (display->xdisplay,
                            event->xproperty.atom);
-        meta_error_trap_pop (display, TRUE);
+        meta_error_trap_pop (display);

        if (event->xproperty.state == PropertyNewValue)
          state = "PropertyNewValue";
@@ -3182,7 +3166,7 @@ meta_spew_event (MetaDisplay *display,
        meta_error_trap_push (display);
        str = XGetAtomName (display->xdisplay,
                            event->xclient.message_type);
-        meta_error_trap_pop (display, TRUE);
+        meta_error_trap_pop (display);
        extra = g_strdup_printf ("type: %s format: %d\n",
                                 str ? str : "(unknown atom)",
                                 event->xclient.format);
@@ -3460,7 +3444,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
      meta_topic (META_DEBUG_WINDOW_OPS,
                  "Changed pointer with XChangeActivePointerGrab()\n");

-      if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+      if (meta_error_trap_pop_with_return (display) != Success)
        {
          meta_topic (META_DEBUG_WINDOW_OPS,
                      "Error trapped from XChangeActivePointerGrab()\n");
@@ -3493,7 +3477,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
                      "XGrabPointer() failed time %u\n",
                      timestamp);
        }
-      meta_error_trap_pop (display, TRUE);
+      meta_error_trap_pop (display);
    }

 #undef GRAB_MASK
@@ -3597,6 +3581,10 @@ meta_display_begin_grab_op (MetaDisplay *display,
  display->grab_xwindow = grab_xwindow;
  display->grab_button = button;
  display->grab_mask = modmask;
+  if (window)
+    display->grab_tile_mode = window->tile_mode;
+  else
+    display->grab_tile_mode = META_TILE_NONE;
  display->grab_anchor_root_x = root_x;
  display->grab_anchor_root_y = root_y;
  display->grab_latest_motion_x = root_x;
@@ -3669,7 +3657,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
                                                         XSyncCAEvents,
                                                         &values);

-          if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+          if (meta_error_trap_pop_with_return (display) != Success)
 	    display->grab_sync_request_alarm = None;

          meta_topic (META_DEBUG_RESIZING,
@@ -3793,6 +3781,7 @@ meta_display_end_grab_op (MetaDisplay *display,
  display->grab_window = NULL;
  display->grab_screen = NULL;
  display->grab_xwindow = None;
+  display->grab_tile_mode = META_TILE_NONE;
  display->grab_op = META_GRAB_OP_NONE;

  if (display->grab_resize_popup)
@@ -3888,7 +3877,7 @@ meta_change_button_grab (MetaDisplay *display,
        {
          int result;
          
-          result = meta_error_trap_pop_with_return (display, FALSE);
+          result = meta_error_trap_pop_with_return (display);
          
          if (result != Success)
            meta_verbose ("Failed to %s button %d with mask 0x%x for window 0x%lx error code %d\n",
@@ -3899,7 +3888,7 @@ meta_change_button_grab (MetaDisplay *display,
      ++ignored_mask;
    }

-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 void
@@ -4083,7 +4072,7 @@ meta_display_update_active_window_hint (MetaDisplay *display)
                       XA_WINDOW,
                       32, PropModeReplace, (guchar*) data, 1);

-      meta_error_trap_pop (display, FALSE);
+      meta_error_trap_pop (display);

      tmp = tmp->next;
    }
@@ -4363,7 +4352,7 @@ process_request_frame_extents (MetaDisplay    *display,
                   display->atom__NET_FRAME_EXTENTS,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 4);
-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);

  meta_XFree (hints);
 }
@@ -4841,11 +4830,11 @@ convert_property (MetaDisplay *display,
 		     (unsigned char *)icccm_version, 2);
  else
    {
-      meta_error_trap_pop_with_return (display, FALSE);
+      meta_error_trap_pop_with_return (display);
      return FALSE;
    }
  
-  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+  if (meta_error_trap_pop_with_return (display) != Success)
    return FALSE;

  /* Be sure the PropertyNotify has arrived so we
@@ -4877,7 +4866,7 @@ process_selection_request (MetaDisplay   *display,
      meta_error_trap_push (display);
      str = XGetAtomName (display->xdisplay,
                          event->xselectionrequest.selection);
-      meta_error_trap_pop (display, TRUE);
+      meta_error_trap_pop (display);
      
      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);
@@ -4911,11 +4900,11 @@ process_selection_request (MetaDisplay   *display,
                                  display->atom_ATOM_PAIR,
                                  &type, &format, &num, &rest, &data) != Success)
            {
-              meta_error_trap_pop_with_return (display, TRUE);
+              meta_error_trap_pop_with_return (display);
              return;
            }
          
-          if (meta_error_trap_pop_with_return (display, TRUE) == Success)
+          if (meta_error_trap_pop_with_return (display) == Success)
            {              
              /* FIXME: to be 100% correct, should deal with rest > 0,
               * but since we have 4 possible targets, we will hardly ever
@@ -4938,7 +4927,7 @@ process_selection_request (MetaDisplay   *display,
                               event->xselectionrequest.property,
                               display->atom_ATOM_PAIR,
                               32, PropModeReplace, data, num);
-              meta_error_trap_pop (display, FALSE);
+              meta_error_trap_pop (display);
              meta_XFree (data);
            }
        }
@@ -4994,7 +4983,7 @@ process_selection_clear (MetaDisplay   *display,
    meta_error_trap_push (display);
    str = XGetAtomName (display->xdisplay,
                        event->xselectionclear.selection);
-    meta_error_trap_pop (display, TRUE);
+    meta_error_trap_pop (display);

    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);
@@ -5184,15 +5173,6 @@ prefs_changed_callback (MetaPreference pref,
    {
      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);
-    }
  else if (pref == META_PREF_ATTACH_MODAL_DIALOGS)
    {
      MetaDisplay *display = data;
@@ -5366,7 +5346,7 @@ meta_display_set_input_focus_window (MetaDisplay *display,
                  focus_frame ? window->frame->xwindow : window->xwindow,
                  RevertToPointerRoot,
                  timestamp);
-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);

  display->expected_focus_window = window;
  display->last_focus_time = timestamp;
@@ -5491,6 +5471,13 @@ meta_display_get_shape_event_base (MetaDisplay *display)
 }
 #endif

+/**
+ * meta_display_get_atom: (skip)
+ *
+ * Gets up an X atom that Mutter prefetched at startup.
+ *
+ * Return value: the X atom corresponding to the given atom enumeration
+ */
 Atom meta_display_get_atom (MetaDisplay *display, MetaAtom meta_atom)
 {
  Atom *atoms = & display->atom_WM_PROTOCOLS;
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@@ -23,7 +23,7 @@

 #include <config.h>
 #include "edge-resistance.h"
-#include "boxes.h"
+#include "boxes-private.h"
 #include "display-private.h"
 #include "workspace-private.h"

--- a/src/core/errors.c
+++ b/src/core/errors.c
@@ -28,7 +28,6 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <gdk/gdk.h>
-#include <gtk/gtk.h> /* Only for GTK_CHECK_VERSION */

 /* In GTK+-3.0, the error trapping code was significantly rewritten. The new code
 * has some neat features (like knowing automatically if a sync is needed or not
@@ -41,26 +40,6 @@
 * use the GTK+ handling straight-up.
 * (See https://bugzilla.gnome.org/show_bug.cgi?id=630216 for restoring logging.)
 */
-#if GTK_CHECK_VERSION(2, 90, 0)
-#define USE_GDK_ERROR_HANDLERS 1
-#endif
-
-#ifndef USE_GDK_ERROR_HANDLERS
-static int x_error_handler    (Display     *display,
-                               XErrorEvent *error);
-static int x_io_error_handler (Display     *display);
-#endif
-
-void
-meta_errors_init (void)
-{
-#ifndef USE_GDK_ERROR_HANDLERS
-  XSetErrorHandler (x_error_handler);
-  XSetIOErrorHandler (x_io_error_handler);
-#endif
-}
-
-#ifdef USE_GDK_ERROR_HANDLERS

 void
 meta_error_trap_push (MetaDisplay *display)
@@ -69,8 +48,7 @@ meta_error_trap_push (MetaDisplay *display)
 }

 void
-meta_error_trap_pop (MetaDisplay *display,
-                     gboolean     last_request_was_roundtrip)
+meta_error_trap_pop (MetaDisplay *display)
 {
  gdk_error_trap_pop_ignored ();
 }
@@ -82,220 +60,7 @@ meta_error_trap_push_with_return (MetaDisplay *display)
 }

 int
-meta_error_trap_pop_with_return  (MetaDisplay *display,
-                                  gboolean     last_request_was_roundtrip)
+meta_error_trap_pop_with_return  (MetaDisplay *display)
 {
  return gdk_error_trap_pop ();
 }
-
-#else /* !USE_GDK_ERROR_HANDLERS */
-
-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;
-
-  XGetErrorText (xdisplay, error->error_code, buf, 63);  
-
-  display = meta_display_for_x_display (xdisplay);
-
-  /* Display can be NULL here Xlib only has one global error handler; and
-   * there might be other displays open in the process.
-   */
-  if (display && 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 (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 ? display->name : DisplayString (xdisplay));
-    }
-  else
-    {
-      meta_warning (_("Fatal IO error %d (%s) on display '%s'.\n"),
-                    errno, g_strerror (errno),
-                    display ? display->name : DisplayString (xdisplay));
-    }
-
-  /* Xlib would force an exit anyhow */
-  exit (1);
-  
-  return 0;
-}
-
-#endif /* USE_GDK_ERROR_HANDLERS */
--- a/src/core/frame.c
+++ b/src/core/frame.c
@@ -153,7 +153,7 @@ meta_window_ensure_frame (MetaWindow *window)
                   window->rect.x,
                   window->rect.y);
  /* FIXME handle this error */
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
  
  /* stick frame to the window */
  window->frame = frame;
@@ -217,7 +217,7 @@ meta_window_destroy_frame (MetaWindow *window)
                    */
                   window->frame->rect.x,
                   window->frame->rect.y);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);

  meta_ui_destroy_frame_window (window->screen->ui, frame->xwindow);

@@ -291,6 +291,12 @@ meta_frame_get_flags (MetaFrame *frame)
  if (META_WINDOW_MAXIMIZED (frame->window))
    flags |= META_FRAME_MAXIMIZED;

+  if (META_WINDOW_TILED_LEFT (frame->window))
+    flags |= META_FRAME_TILED_LEFT;
+
+  if (META_WINDOW_TILED_RIGHT (frame->window))
+    flags |= META_FRAME_TILED_RIGHT;
+
  if (frame->window->fullscreen)
    flags |= META_FRAME_FULLSCREEN;

--- a/src/core/iconcache.c
+++ b/src/core/iconcache.c
@@ -241,7 +241,7 @@ read_rgb_icon (MetaDisplay   *display,
 			       0, G_MAXLONG,
 			       False, XA_CARDINAL, &type, &format, &nitems,
 			       &bytes_after, &data);
-  err = meta_error_trap_pop_with_return (display, TRUE);
+  err = meta_error_trap_pop_with_return (display);

  if (err != Success ||
      result != Success)
@@ -406,7 +406,7 @@ try_pixmap_and_mask (MetaDisplay *display,
                                              w, h);
    }

-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);

  if (mask)
    {
@@ -482,7 +482,7 @@ get_kwm_win_icon (MetaDisplay *display,
 			       &bytes_after, &data);
  icons = (Pixmap *)data;

-  err = meta_error_trap_pop_with_return (display, TRUE);
+  err = meta_error_trap_pop_with_return (display);
  if (err != Success ||
      result != Success)
    return;
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -117,6 +117,10 @@ reload_keymap (MetaDisplay *display)
  if (display->keymap)
    meta_XFree (display->keymap);

+  /* This is expensive to compute, so we'll lazily load if and when we first
+   * need it */
+  display->above_tab_keycode = 0;
+
  display->keymap = XGetKeyboardMapping (display->xdisplay,
                                         display->min_keycode,
                                         display->max_keycode -
@@ -228,17 +232,26 @@ reload_modmap (MetaDisplay *display)
              display->meta_mask);
 }

+static guint
+keysym_to_keycode (MetaDisplay *display,
+                   guint        keysym)
+{
+  if (keysym == META_KEY_ABOVE_TAB)
+    return meta_display_get_above_tab_keycode (display);
+  else
+    return XKeysymToKeycode (display->xdisplay, keysym);
+}
+
 static void
 reload_keycodes (MetaDisplay *display)
 {
  meta_topic (META_DEBUG_KEYBINDINGS,
              "Reloading keycodes for binding tables\n");
-  
-  if (display->overlay_key_combo.keysym 
-      && display->overlay_key_combo.keycode == 0)
+
+  if (display->overlay_key_combo.keysym != 0)
    {
-      display->overlay_key_combo.keycode = XKeysymToKeycode (
-          display->xdisplay, display->overlay_key_combo.keysym);
+      display->overlay_key_combo.keycode =
+        keysym_to_keycode (display, display->overlay_key_combo.keysym);
    }
  
  if (display->key_bindings)
@@ -248,9 +261,11 @@ reload_keycodes (MetaDisplay *display)
      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);
+          if (display->key_bindings[i].keysym != 0)
+            {
+              display->key_bindings[i].keycode =
+                keysym_to_keycode (display, display->key_bindings[i].keysym);
+            }
          
          ++i;
        }
@@ -470,7 +485,7 @@ regrab_key_bindings (MetaDisplay *display)
      
      tmp = tmp->next;
    }
-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);

  g_slist_free (windows);
 }
@@ -502,24 +517,27 @@ display_get_keybinding (MetaDisplay  *display,
 /**
 * meta_display_get_keybinding_action:
 * @display: A #MetaDisplay
- * @keysym: Key symbol
 * @keycode: Raw keycode
 * @mask: Event mask
 *
- * Returns: The action that should be taken for the given key, or %META_KEYBINDING_ACTION_NONE.
- *
+ * Returns: The action that should be taken for the given key, or
+ * %META_KEYBINDING_ACTION_NONE.
 */
 MetaKeyBindingAction
 meta_display_get_keybinding_action (MetaDisplay  *display,
-                                    unsigned int  keysym,
                                    unsigned int  keycode,
                                    unsigned long mask)
 {
  MetaKeyBinding *binding;
+  KeySym keysym;

+  keysym = XKeycodeToKeysym (display->xdisplay, keycode, 0);
  mask = mask & 0xff & ~display->ignored_modifier_mask;
  binding = display_get_keybinding (display, keysym, keycode, mask);

+  if (!binding && keycode == meta_display_get_above_tab_keycode (display))
+    binding = display_get_keybinding (display, META_KEY_ABOVE_TAB, keycode, mask);
+
  if (binding)
    return meta_prefs_get_keybinding_action (binding->name);
  else
@@ -530,26 +548,51 @@ void
 meta_display_process_mapping_event (MetaDisplay *display,
                                    XEvent      *event)
 { 
+  gboolean keymap_changed = FALSE;
+  gboolean modmap_changed = FALSE;
+
+#ifdef HAVE_XKB
+  if (event->type == display->xkb_base_event_type)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "XKB mapping changed, will redo keybindings\n");
+
+      keymap_changed = TRUE;
+      modmap_changed = TRUE;
+    }
+  else
+#endif
  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);
+      modmap_changed = TRUE;
    }
  else if (event->xmapping.request == MappingKeyboard)
    {
      meta_topic (META_DEBUG_KEYBINDINGS,
                  "Received MappingKeyboard event, will reload keycodes and redo keybindings\n");

-      reload_keymap (display);
+      keymap_changed = TRUE;
+    }
+
+  /* Now to do the work itself */
+
+  if (keymap_changed || modmap_changed)
+    {
+      if (keymap_changed)
+        reload_keymap (display);
+
+      /* Deciphering the modmap depends on the loaded keysyms to find out
+       * what modifiers is Super and so forth, so we need to reload it
+       * even when only the keymap changes */
      reload_modmap (display);
-      
-      reload_keycodes (display);
+
+      if (keymap_changed)
+        reload_keycodes (display);
+
+      reload_modifiers (display);

      regrab_key_bindings (display);
    }
@@ -617,6 +660,14 @@ meta_display_init_keys (MetaDisplay *display)
  /* Keys are actually grabbed in meta_screen_grab_keys() */
  
  meta_prefs_add_listener (bindings_changed_callback, display);
+
+#ifdef HAVE_XKB
+  /* meta_display_init_keys() should have already called XkbQueryExtension() */
+  if (display->xkb_base_event_type != -1)
+    XkbSelectEvents (display->xdisplay, XkbUseCoreKbd,
+                     XkbNewKeyboardNotifyMask | XkbMapNotifyMask,
+                     XkbNewKeyboardNotifyMask | XkbMapNotifyMask);
+#endif
 }

 void
@@ -700,7 +751,7 @@ meta_change_keygrab (MetaDisplay *display,
        {
          int result;
          
-          result = meta_error_trap_pop_with_return (display, FALSE);
+          result = meta_error_trap_pop_with_return (display);
          
          if (grab && result != Success)
            {      
@@ -716,7 +767,7 @@ meta_change_keygrab (MetaDisplay *display,
      ++ignored_mask;
    }

-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 static void
@@ -758,7 +809,7 @@ grab_keys (MetaKeyBinding *bindings,
      ++i;
    }

-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 static void
@@ -777,14 +828,14 @@ ungrab_all_keys (MetaDisplay *display,
    {
      int result;
      
-      result = meta_error_trap_pop_with_return (display, FALSE);
+      result = meta_error_trap_pop_with_return (display);
      
      if (result != Success)    
        meta_topic (META_DEBUG_KEYBINDINGS,
                    "Ungrabbing all keys on 0x%lx failed\n", xwindow);
    }
  else
-    meta_error_trap_pop (display, FALSE);
+    meta_error_trap_pop (display);
 }

 void
@@ -916,7 +967,7 @@ grab_keyboard (MetaDisplay *display,
  
  if (grab_status != GrabSuccess)
    {
-      meta_error_trap_pop_with_return (display, TRUE);
+      meta_error_trap_pop_with_return (display);
      meta_topic (META_DEBUG_KEYBINDINGS,
                  "XGrabKeyboard() returned failure status %s time %u\n",
                  grab_status_to_string (grab_status),
@@ -925,7 +976,7 @@ grab_keyboard (MetaDisplay *display,
    }
  else
    {
-      result = meta_error_trap_pop_with_return (display, TRUE);
+      result = meta_error_trap_pop_with_return (display);
      if (result != Success)
        {
          meta_topic (META_DEBUG_KEYBINDINGS,
@@ -948,7 +999,7 @@ ungrab_keyboard (MetaDisplay *display, guint32 timestamp)
              "Ungrabbing keyboard with timestamp %u\n",
              timestamp);
  XUngrabKeyboard (display->xdisplay, timestamp);
-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 gboolean
@@ -1373,8 +1424,7 @@ meta_display_process_key_event (MetaDisplay *display,
    return FALSE; /* 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))
+  if (meta_ui_window_is_widget (screen->ui, event->xany.window))
    return FALSE;
  
  /* window may be NULL */
@@ -1501,15 +1551,24 @@ process_mouse_move_resize_grab (MetaDisplay *display,

  if (keysym == XK_Escape)
    {
+      /* Hide the tiling preview if necessary */
+      if (window->tile_mode != META_TILE_NONE)
+        meta_screen_tile_preview_hide (screen);
+
+      /* Restore the original tile mode */
+      window->tile_mode = display->grab_tile_mode;
+
      /* 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.
       */
-      if (window->shaken_loose)
+      if (window->shaken_loose || window->tile_mode == META_TILE_MAXIMIZED)
        meta_window_maximize (window,
                              META_MAXIMIZE_HORIZONTAL |
                              META_MAXIMIZE_VERTICAL);
+      else if (window->tile_mode != META_TILE_NONE)
+        meta_window_tile (window);
      else
        meta_window_move_resize (display->grab_window,
                                 TRUE,
@@ -2778,7 +2837,6 @@ process_workspace_switch_grab (MetaDisplay *display,
      MetaKeyBindingAction action;

      action = meta_display_get_keybinding_action (display,
-                                                   keysym,
                                                   event->xkey.keycode,
                                                   display->grab_mask);

@@ -2900,7 +2958,7 @@ handle_panel (MetaDisplay    *display,
 	      StructureNotifyMask,
 	      (XEvent*) &ev);

-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 static void
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -75,7 +75,7 @@

 #ifdef HAVE_INTROSPECTION
 #include <girepository.h>
-#include "compositor/mutter-plugin-manager.h"
+#include "compositor/meta-plugin-manager.h"
 #endif

 /**
@@ -296,18 +296,6 @@ meta_parse_options (int *argc, char ***argv,
      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,
@@ -454,7 +442,7 @@ sigterm_handler (int signum)
 {
  if (sigterm_pipe_fds[1] >= 0)
    {
-      int dummy;
+      int G_GNUC_UNUSED dummy;

      dummy = write (sigterm_pipe_fds[1], "", 1);
      close (sigterm_pipe_fds[1]);
@@ -586,8 +574,8 @@ main (int argc, char **argv)
           * is initialized at this point, and we don't plan to run any real
           * plugin code.
           */
-          MutterPluginManager *mgr = mutter_plugin_manager_get_default ();
-          if (!mutter_plugin_manager_load (mgr))
+          MetaPluginManager *mgr = meta_plugin_manager_get_default ();
+          if (!meta_plugin_manager_load (mgr))
            g_critical ("failed to load plugins");
        }
      if (!g_irepository_dump (meta_args.introspect, &error))
@@ -623,9 +611,6 @@ main (int argc, char **argv)

  g_option_context_free (ctx);

-  /* 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);
@@ -708,9 +693,6 @@ main (int argc, char **argv)
  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);

--- a/src/core/place.c
+++ b/src/core/place.c
@@ -26,6 +26,7 @@

 #include <config.h>

+#include "boxes-private.h"
 #include "place.h"
 #include "workspace.h"
 #include "prefs.h"
--- a/src/core/prefs.c
+++ b/src/core/prefs.c
@@ -27,7 +27,7 @@
 #include "prefs.h"
 #include "ui.h"
 #include "util.h"
-#include "compositor/mutter-plugin-manager.h"
+#include "compositor/meta-plugin-manager.h"
 #ifdef HAVE_GCONF
 #include <gconf/gconf-client.h>
 #endif
@@ -50,7 +50,6 @@
 */
 #define KEY_TITLEBAR_FONT "/apps/metacity/general/titlebar_font"
 #define KEY_NUM_WORKSPACES "/apps/metacity/general/num_workspaces"
-#define KEY_COMPOSITOR "/apps/metacity/general/compositing_manager"
 #define KEY_GNOME_ACCESSIBILITY "/desktop/gnome/interface/accessibility"

 #define KEY_COMMAND_DIRECTORY "/apps/metacity/keybinding_commands"
@@ -102,9 +101,8 @@ static gboolean gnome_accessibility = FALSE;
 static gboolean gnome_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 side_by_side_tiling = FALSE;
+static gboolean edge_tiling = FALSE;
 static gboolean force_fullscreen = TRUE;

 static MetaVisualBellType visual_bell_type = META_VISUAL_BELL_FULLSCREEN_FLASH;
@@ -413,19 +411,14 @@ static MetaBoolPreference preferences_bool[] =
      &gnome_animations,
      TRUE,
    },
-    { "/apps/metacity/general/compositing_manager",
-      META_PREF_COMPOSITING_MANAGER,
-      &compositing_manager,
-      FALSE,
-    },
    { "/apps/metacity/general/resize_with_right_button",
      META_PREF_RESIZE_WITH_RIGHT_BUTTON,
      &resize_with_right_button,
      FALSE,
    },
-    { "/apps/metacity/general/side_by_side_tiling",
-      META_PREF_SIDE_BY_SIDE_TILING,
-      &side_by_side_tiling,
+    { "/apps/metacity/general/edge_tiling",
+      META_PREF_EDGE_TILING,
+      &edge_tiling,
      FALSE,
    },
    { "/apps/mutter/general/live_hidden_windows",
@@ -1058,7 +1051,7 @@ meta_prefs_init (void)
 #ifdef HAVE_GCONF
  GError *err = NULL;
  gchar **gconf_dir_cursor;
-  MutterPluginManager *plugin_manager;
+  MetaPluginManager *plugin_manager;
  
  if (default_client != NULL)
    return;
@@ -1087,8 +1080,8 @@ meta_prefs_init (void)

  /* We now initialize plugins so that they can override any preference locations */

-  plugin_manager = mutter_plugin_manager_get_default ();
-  mutter_plugin_manager_load (plugin_manager);
+  plugin_manager = meta_plugin_manager_get_default ();
+  meta_plugin_manager_load (plugin_manager);

  /* Pick up initial values. */

@@ -2004,14 +1997,11 @@ meta_preference_to_string (MetaPreference pref)
    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_SIDE_BY_SIDE_TILING:
-      return "SIDE_BY_SIDE_TILING";
+    case META_PREF_EDGE_TILING:
+      return "EDGE_TILING";

    case META_PREF_FORCE_FULLSCREEN:
      return "FORCE_FULLSCREEN";
@@ -2118,6 +2108,8 @@ init_bindings (void)
  GConfValue *value;
  GHashTable *to_update;

+  g_assert (G_N_ELEMENTS (key_bindings) == META_KEYBINDING_ACTION_LAST + 1);
+
  to_update = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);

  for (i = 0; prefix[i]; i++)
@@ -2924,9 +2916,9 @@ meta_prefs_get_gnome_animations ()
 }

 gboolean
-meta_prefs_get_side_by_side_tiling ()
+meta_prefs_get_edge_tiling ()
 {
-  return side_by_side_tiling;
+  return edge_tiling;
 }

 MetaKeyBindingAction
@@ -2990,12 +2982,6 @@ meta_prefs_get_window_binding (const char          *name,
  g_assert_not_reached ();
 }

-gboolean
-meta_prefs_get_compositing_manager (void)
-{
-  return compositing_manager;
-}
-
 guint
 meta_prefs_get_mouse_button_resize (void)
 {
@@ -3014,28 +3000,6 @@ meta_prefs_get_force_fullscreen (void)
  return force_fullscreen;
 }

-void
-meta_prefs_set_compositing_manager (gboolean whether)
-{
-#ifdef HAVE_GCONF
-  GError *err = NULL;
-
-  gconf_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
-}
-
 /**
 * meta_prefs_get_clutter_plugins:
 *
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -50,14 +50,6 @@ struct _MetaMonitorInfo
 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,
@@ -127,6 +119,7 @@ struct _MetaScreen
  int columns_of_workspaces;
  MetaScreenCorner starting_corner;
  guint vertical_workspaces : 1;
+  guint workspace_layout_overridden : 1;
  
  guint keys_grabbed : 1;
  guint all_keys_grabbed : 1;
@@ -184,6 +177,7 @@ void          meta_screen_workspace_popup_destroy      (MetaScreen    *screen);

 void          meta_screen_tile_preview_update          (MetaScreen    *screen,
                                                        gboolean       delay);
+void          meta_screen_tile_preview_hide            (MetaScreen    *screen);

 MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
                                                MetaWindow                 *not_this_one);
@@ -254,4 +248,6 @@ void     meta_screen_workspace_switched (MetaScreen         *screen,
                                         int                 to,
                                         MetaMotionDirection direction);

+void meta_screen_set_active_workspace_hint (MetaScreen *screen);
+
 #endif
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -601,7 +601,7 @@ meta_screen_new (MetaDisplay *display,
      attrs.event_mask = StructureNotifyMask;
      XChangeWindowAttributes (xdisplay,
                               current_wm_sn_owner, CWEventMask, &attrs);
-      if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+      if (meta_error_trap_pop_with_return (display) != Success)
        current_wm_sn_owner = None; /* don't wait for it to die later on */
    }

@@ -670,7 +670,7 @@ meta_screen_new (MetaDisplay *display,
                KeyPressMask | KeyReleaseMask |
                FocusChangeMask | StructureNotifyMask |
                ExposureMask | attr.your_event_mask);
-  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+  if (meta_error_trap_pop_with_return (display) != Success)
    {
      meta_warning (_("Screen %d on display \"%s\" already has a window manager\n"),
                    number, display->name);
@@ -856,7 +856,7 @@ meta_screen_free (MetaScreen *screen,

  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)
+  if (meta_error_trap_pop_with_return (screen->display) != Success)
    meta_warning (_("Could not release screen %d on display \"%s\"\n"),
                  screen->number, screen->display->name);

@@ -913,7 +913,7 @@ list_windows (MetaScreen *screen)
      XGetWindowAttributes (screen->display->xdisplay,
                            children[i], &info->attrs);

-      if (meta_error_trap_pop_with_return (screen->display, TRUE))
+      if (meta_error_trap_pop_with_return (screen->display))
 	{
          meta_verbose ("Failed to get attributes for window 0x%lx\n",
                        children[i]);
@@ -951,11 +951,10 @@ meta_screen_manage_all_windows (MetaScreen *screen)
  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,
-                                           META_COMP_EFFECT_NONE,
-                                           &info->attrs);
+      meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
+                                  META_COMP_EFFECT_NONE,
+                                  &info->attrs);
    }
  meta_stack_thaw (screen->stack);

@@ -978,7 +977,15 @@ meta_screen_composite_all_windows (MetaScreen *screen)
  windows = meta_display_list_windows (display,
                                       META_LIST_INCLUDE_OVERRIDE_REDIRECT);
  for (tmp = windows; tmp != NULL; tmp = tmp->next)
-    meta_compositor_add_window (display->compositor, tmp->data);
+    {
+      MetaWindow *window = tmp->data;
+
+      meta_compositor_add_window (display->compositor, window);
+      if (window->visible_to_compositor)
+        meta_compositor_show_window (display->compositor, window,
+                                     META_COMP_EFFECT_NONE);
+    }
+
  g_slist_free (windows);
  
  /* initialize the compositor's view of the stacking order */
@@ -1220,7 +1227,7 @@ set_number_of_spaces_hint (MetaScreen *screen,
                   screen->display->atom__NET_NUMBER_OF_DESKTOPS,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 1);
-  meta_error_trap_pop (screen->display, FALSE);
+  meta_error_trap_pop (screen->display);
 }

 static void
@@ -1241,7 +1248,7 @@ set_desktop_geometry_hint (MetaScreen *screen)
                   screen->display->atom__NET_DESKTOP_GEOMETRY,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 2);
-  meta_error_trap_pop (screen->display, FALSE);
+  meta_error_trap_pop (screen->display);
 }

 static void
@@ -1265,7 +1272,7 @@ set_desktop_viewport_hint (MetaScreen *screen)
                   screen->display->atom__NET_DESKTOP_VIEWPORT,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 2);
-  meta_error_trap_pop (screen->display, FALSE);
+  meta_error_trap_pop (screen->display);
 }

 void
@@ -1276,6 +1283,7 @@ meta_screen_remove_workspace (MetaScreen *screen, MetaWorkspace *workspace,
  MetaWorkspace *neighbour = NULL;
  GList         *next = NULL;
  int            index;
+  gboolean       active_index_changed;
  int            new_num;

  l = screen->workspaces;
@@ -1314,6 +1322,7 @@ meta_screen_remove_workspace (MetaScreen *screen, MetaWorkspace *workspace,

  /* To emit the signal after removing the workspace */
  index = meta_workspace_index (workspace);
+  active_index_changed = index < meta_screen_get_active_workspace_index (screen);

  /* This also removes the workspace from the screens list */
  meta_workspace_remove (workspace);
@@ -1323,6 +1332,11 @@ meta_screen_remove_workspace (MetaScreen *screen, MetaWorkspace *workspace,
  set_number_of_spaces_hint (screen, new_num);
  meta_prefs_set_num_workspaces (new_num);

+  /* If deleting a workspace before the current workspace, the active
+   * workspace index changes, so we need to update that hint */
+  if (active_index_changed)
+      meta_screen_set_active_workspace_hint (workspace->screen);
+
  l = next;
  while (l)
    {
@@ -1758,6 +1772,7 @@ meta_screen_tile_preview_update_timeout (gpointer data)
  MetaScreen *screen = data;
  MetaWindow *window = screen->display->grab_window;
  gboolean composited = screen->display->compositor != NULL;
+  gboolean needs_preview = FALSE;

  screen->tile_preview_timeout_id = 0;

@@ -1775,9 +1790,28 @@ meta_screen_tile_preview_update_timeout (gpointer data)
                                     create_serial);
    }

-  if (window
-      && !META_WINDOW_TILED (window)
-      && window->tile_mode != META_TILE_NONE)
+  if (window)
+    {
+      switch (window->tile_mode)
+        {
+          case META_TILE_LEFT:
+          case META_TILE_RIGHT:
+              if (!META_WINDOW_TILED_SIDE_BY_SIDE (window))
+                needs_preview = TRUE;
+              break;
+
+          case META_TILE_MAXIMIZED:
+              if (!META_WINDOW_MAXIMIZED (window))
+                needs_preview = TRUE;
+              break;
+
+          default:
+              needs_preview = FALSE;
+              break;
+        }
+    }
+
+  if (needs_preview)
    {
      MetaRectangle tile_rect;

@@ -1815,6 +1849,16 @@ meta_screen_tile_preview_update (MetaScreen *screen,
    }
 }

+void
+meta_screen_tile_preview_hide (MetaScreen *screen)
+{
+  if (screen->tile_preview_timeout_id > 0)
+    g_source_remove (screen->tile_preview_timeout_id);
+
+  if (screen->tile_preview)
+    meta_tile_preview_hide (screen->tile_preview);
+}
+
 MetaWindow*
 meta_screen_get_mouse_window (MetaScreen  *screen,
                              MetaWindow  *not_this_one)
@@ -1839,7 +1883,7 @@ meta_screen_get_mouse_window (MetaScreen  *screen,
                 &win_x_return,
                 &win_y_return,
                 &mask_return);
-  meta_error_trap_pop (screen->display, TRUE);
+  meta_error_trap_pop (screen->display);

  window = meta_stack_get_default_focus_window_at_point (screen->stack,
                                                         screen->active_workspace,
@@ -2119,6 +2163,9 @@ meta_screen_update_workspace_layout (MetaScreen *screen)
 {
  gulong *list;
  int n_items;
+
+  if (screen->workspace_layout_overridden)
+    return;
  
  list = NULL;
  n_items = 0;
@@ -2205,6 +2252,43 @@ meta_screen_update_workspace_layout (MetaScreen *screen)
                screen->starting_corner);
 }

+/**
+ * meta_screen_override_workspace_layout:
+ * @screen: a #MetaScreen
+ * @starting_corner: the corner at which the first workspace is found
+ * @vertical_layout: if %TRUE the workspaces are laid out in columns rather than rows
+ * @n_rows: number of rows of workspaces, or -1 to determine the number of rows from
+ *   @n_columns and the total number of workspaces
+ * @n_columns: number of columns of workspaces, or -1 to determine the number of columns from
+ *   @n_rows and the total number of workspaces
+ *
+ * Explicitly set the layout of workspaces. Once this has been called, the contents of the
+ * _NET_DESKTOP_LAYOUT property on the root window are completely ignored.
+ */
+void
+meta_screen_override_workspace_layout (MetaScreen      *screen,
+                                       MetaScreenCorner starting_corner,
+                                       gboolean         vertical_layout,
+                                       int              n_rows,
+                                       int              n_columns)
+{
+  g_return_if_fail (META_IS_SCREEN (screen));
+  g_return_if_fail (n_rows > 0 || n_columns > 0);
+  g_return_if_fail (n_rows != 0 && n_columns != 0);
+
+  screen->workspace_layout_overridden = TRUE;
+  screen->vertical_workspaces = vertical_layout != FALSE;
+  screen->starting_corner = starting_corner;
+  screen->rows_of_workspaces = n_rows;
+  screen->columns_of_workspaces = n_columns;
+
+  /* In theory we should remove _NET_DESKTOP_LAYOUT from _NET_SUPPORTED at this
+   * point, but it's unlikely that anybody checks that, and it's unlikely that
+   * anybody who checks that handles changes, so we'd probably just create
+   * a race condition. And it's hard to implement with the code in set_supported_hint()
+   */
+}
+
 static void
 set_workspace_names (MetaScreen *screen)
 {
@@ -2242,7 +2326,7 @@ set_workspace_names (MetaScreen *screen)
 		   screen->display->atom_UTF8_STRING,
                   8, PropModeReplace,
 		   (unsigned char *)flattened->str, flattened->len);
-  meta_error_trap_pop (screen->display, FALSE);
+  meta_error_trap_pop (screen->display);
  
  g_string_free (flattened, TRUE);
 }
@@ -2346,7 +2430,7 @@ set_work_area_hint (MetaScreen *screen)
 		   XA_CARDINAL, 32, PropModeReplace,
 		   (guchar*) data, num_workspaces*4);
  g_free (data);
-  meta_error_trap_pop (screen->display, FALSE);
+  meta_error_trap_pop (screen->display);

  g_signal_emit (screen, screen_signals[WORKAREAS_CHANGED], 0);
 }
@@ -2721,7 +2805,7 @@ meta_screen_update_showing_desktop_hint (MetaScreen *screen)
                   screen->display->atom__NET_SHOWING_DESKTOP,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 1);
-  meta_error_trap_pop (screen->display, FALSE);
+  meta_error_trap_pop (screen->display);
 }

 static void
@@ -3308,3 +3392,29 @@ meta_screen_workspace_switched (MetaScreen         *screen,
                 from, to, direction);
 }

+void
+meta_screen_set_active_workspace_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);
+}
+
--- a/src/core/stack-tracker.c
+++ b/src/core/stack-tracker.c
@@ -54,8 +54,8 @@
 *
 * When we receive a new event: a) we compare the serial in the event to
 * the serial of the queued requests and remove any that are now
- * no longer pending b) drop the predicted stacking order to recompute
- * it at the next opportunity.
+ * no longer pending b) if necessary, drop the predicted stacking
+ * order to recompute it at the next opportunity.
 *
 * Possible optimizations:
 *  Keep the stacks as an array + reverse-mapping hash table to avoid
@@ -505,6 +505,8 @@ static void
 stack_tracker_event_received (MetaStackTracker *tracker,
 			      MetaStackOp      *op)
 {
+  gboolean need_sync = FALSE;
+
  meta_stack_op_dump (op, "Stack op event received: ", "\n");

  if (op->any.serial < tracker->server_serial)
@@ -512,7 +514,8 @@ stack_tracker_event_received (MetaStackTracker *tracker,

  tracker->server_serial = op->any.serial;

-  meta_stack_op_apply (op, tracker->server_stack);
+  if (meta_stack_op_apply (op, tracker->server_stack))
+    need_sync = TRUE;

  while (tracker->queued_requests->head)
    {
@@ -522,17 +525,21 @@ stack_tracker_event_received (MetaStackTracker *tracker,

      g_queue_pop_head (tracker->queued_requests);
      meta_stack_op_free (queued_op);
+      need_sync = TRUE;
    }

-  if (tracker->predicted_stack)
+  if (need_sync)
    {
-      g_array_free (tracker->predicted_stack, TRUE);
-      tracker->predicted_stack = NULL;
+      if (tracker->predicted_stack)
+        {
+          g_array_free (tracker->predicted_stack, TRUE);
+          tracker->predicted_stack = NULL;
+        }
+
+      meta_stack_tracker_queue_sync_stack (tracker);
    }

  meta_stack_tracker_dump (tracker);
-
-  meta_stack_tracker_queue_sync_stack (tracker);
 }

 void
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -1026,7 +1026,7 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
                                xwindow,
                                CWSibling | CWStackMode,
                                &changes);
-              meta_error_trap_pop (screen->display, FALSE);
+              meta_error_trap_pop (screen->display);

              break;
            }
@@ -1046,7 +1046,7 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
                                       XNextRequest (screen->display->xdisplay));
      XLowerWindow (screen->display->xdisplay,
                    xwindow);
-      meta_error_trap_pop (screen->display, FALSE);
+      meta_error_trap_pop (screen->display);
    }
 }

@@ -1267,7 +1267,7 @@ stack_sync_to_server (MetaStack *stack)
 		   all_hidden->len);
  g_array_free (all_hidden, TRUE);

-  meta_error_trap_pop (stack->screen->display, FALSE);
+  meta_error_trap_pop (stack->screen->display);
  /* 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.
--- a/src/core/testasyncgetprop.c
+++ b/src/core/testasyncgetprop.c
@@ -416,7 +416,6 @@ run_speed_comparison (Display *xdisplay,
      
      while ((task = ag_get_next_completed_task (xdisplay)))
        {
-          int result;
          Atom actual_type;
          int actual_format;
          unsigned long n_items;
@@ -426,12 +425,12 @@ run_speed_comparison (Display *xdisplay,
          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);
+          ag_task_get_reply_and_free (task,
+                                      &actual_type,
+                                      &actual_format,
+                                      &n_items,
+                                      &bytes_after,
+                                      &data);
          
          if (data)
            XFree (data);
--- a/src/core/testboxes.c
+++ b/src/core/testboxes.c
@@ -21,7 +21,7 @@
 * 02111-1307, USA.
 */

-#include "boxes.h"
+#include "boxes-private.h"
 #include <glib.h>
 #include <stdlib.h>
 #include <stdio.h>
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -880,29 +880,5 @@ meta_later_remove (guint later_id)
    }
 }

-#ifdef USE_CAIRO_REGION
-#include "region.h"
-
-void
-meta_region_get_rectangles (MetaRegion    *region,
-                            GdkRectangle **rectangles,
-                            int           *n_rectangles)
-{
-  int n = cairo_region_num_rectangles (region);
-
-  if (n_rectangles != NULL)
-    *n_rectangles = n;
-
-  if (rectangles != NULL)
-    {
-      int i;
-
-      *rectangles = g_new (cairo_rectangle_int_t, n);
-      for (i = 0; i < n; i++)
-        cairo_region_get_rectangle (region, i, *rectangles + i);
-    }
-}
-#endif
-
 /* eof util.c */

--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -61,12 +61,6 @@ typedef enum {

 #define NUMBER_OF_QUEUES 3

-typedef enum {
-  META_TILE_NONE,
-  META_TILE_LEFT,
-  META_TILE_RIGHT
-} MetaTileMode;
-
 struct _MetaWindow
 {
  GObject parent_instance;
@@ -409,11 +403,15 @@ struct _MetaWindowClass
                                        (w)->maximized_vertically)
 #define META_WINDOW_MAXIMIZED_VERTICALLY(w)    ((w)->maximized_vertically)
 #define META_WINDOW_MAXIMIZED_HORIZONTALLY(w)  ((w)->maximized_horizontally)
-#define META_WINDOW_TILED(w)           ((w)->maximized_vertically && \
-                                        !(w)->maximized_horizontally && \
-                                        (w)->tile_mode != META_TILE_NONE)
+#define META_WINDOW_TILED_SIDE_BY_SIDE(w)      ((w)->maximized_vertically && \
+                                                !(w)->maximized_horizontally && \
+                                                 (w)->tile_mode != META_TILE_NONE)
+#define META_WINDOW_TILED_LEFT(w)     (META_WINDOW_TILED_SIDE_BY_SIDE(w) && \
+                                       (w)->tile_mode == META_TILE_LEFT)
+#define META_WINDOW_TILED_RIGHT(w)    (META_WINDOW_TILED_SIDE_BY_SIDE(w) && \
+                                       (w)->tile_mode == META_TILE_RIGHT)
 #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) && !META_WINDOW_TILED(w) && !(w)->fullscreen && !(w)->shaded)
+#define META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS(w)   ((w)->has_resize_func && !META_WINDOW_MAXIMIZED (w) && !META_WINDOW_TILED_SIDE_BY_SIDE(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)))
@@ -433,6 +431,7 @@ void        meta_window_unmanage           (MetaWindow  *window,
 void        meta_window_calc_showing       (MetaWindow  *window);
 void        meta_window_queue              (MetaWindow  *window,
                                            guint queuebits);
+void        meta_window_tile               (MetaWindow        *window);
 void        meta_window_maximize_internal  (MetaWindow        *window,
                                            MetaMaximizeFlags  directions,
                                            MetaRectangle     *saved_rect);
@@ -461,8 +460,6 @@ void        meta_window_update_fullscreen_monitors (MetaWindow    *window,
                                                    unsigned long  left,
                                                    unsigned long  right);

-gboolean meta_window_appears_focused (MetaWindow *window);
-
 /* args to move are window pos, not frame pos */
 void        meta_window_move               (MetaWindow  *window,
                                            gboolean     user_op,
--- a/src/core/window-props.c
+++ b/src/core/window-props.c
@@ -442,7 +442,7 @@ set_title_text (MetaWindow  *window,
      XDeleteProperty (window->display->xdisplay,
                       window->xwindow,
                       atom);
-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);
    }

  return modified;
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -26,6 +26,7 @@

 #include <config.h>
 #include "window-private.h"
+#include "boxes-private.h"
 #include "edge-resistance.h"
 #include "util.h"
 #include "frame-private.h"
@@ -483,11 +484,11 @@ meta_window_new (MetaDisplay *display,

  if (XGetWindowAttributes (display->xdisplay,xwindow, &attrs))
   {
-      if(meta_error_trap_pop_with_return (display, TRUE) != Success)
+      if(meta_error_trap_pop_with_return (display) != Success)
       {
          meta_verbose ("Failed to get attributes for window 0x%lx\n",
                        xwindow);
-          meta_error_trap_pop (display, TRUE);
+          meta_error_trap_pop (display);
          meta_display_ungrab (display);
          return NULL;
       }
@@ -498,16 +499,16 @@ meta_window_new (MetaDisplay *display,
   }
  else
   {
-         meta_error_trap_pop_with_return (display, TRUE);
+         meta_error_trap_pop_with_return (display);
         meta_verbose ("Failed to get attributes for window 0x%lx\n",
                        xwindow);
-         meta_error_trap_pop (display, TRUE);
+         meta_error_trap_pop (display);
         meta_display_ungrab (display);
         return NULL;
   }


-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
  meta_display_ungrab (display);

  return window;
@@ -606,7 +607,7 @@ meta_window_new_with_attrs (MetaDisplay       *display,
            (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_error_trap_pop (display);
          meta_display_ungrab (display);
          return NULL;
        }
@@ -628,7 +629,7 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   */
  meta_error_trap_push_with_return (display);
  XAddToSaveSet (display->xdisplay, xwindow);
-  meta_error_trap_pop_with_return (display, FALSE);
+  meta_error_trap_pop_with_return (display);

  event_mask =
    PropertyChangeMask | EnterWindowMask | LeaveWindowMask |
@@ -684,11 +685,11 @@ meta_window_new_with_attrs (MetaDisplay       *display,
                               &set_attrs);
    }

-  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+  if (meta_error_trap_pop_with_return (display) != Success)
    {
      meta_verbose ("Window 0x%lx disappeared just as we tried to manage it\n",
                    xwindow);
-      meta_error_trap_pop (display, FALSE);
+      meta_error_trap_pop (display);
      meta_display_ungrab (display);
      return NULL;
    }
@@ -1161,7 +1162,7 @@ meta_window_new_with_attrs (MetaDisplay       *display,
      !window->initially_iconic)
    unminimize_window_and_all_transient_parents (window);

-  meta_error_trap_pop (display, FALSE); /* pop the XSync()-reducing trap */
+  meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
  meta_display_ungrab (display);

  window->constructing = FALSE;
@@ -1481,7 +1482,7 @@ meta_window_unmanage (MetaWindow  *window,
                       window->xwindow,
                       window->display->atom__NET_WM_FULLSCREEN_MONITORS);
      set_wm_state (window, WithdrawnState);
-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);
    }
  else
    {
@@ -1492,7 +1493,7 @@ meta_window_unmanage (MetaWindow  *window,
        {
          meta_error_trap_push (window->display);
          set_wm_state (window, NormalState);
-          meta_error_trap_pop (window->display, FALSE);
+          meta_error_trap_pop (window->display);
        }

      /* And we need to be sure the window is mapped so other WMs
@@ -1501,7 +1502,7 @@ meta_window_unmanage (MetaWindow  *window,
      meta_error_trap_push (window->display);
      XMapWindow (window->display->xdisplay,
                  window->xwindow);
-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);
    }

  meta_window_ungrab_keys (window);
@@ -1549,7 +1550,7 @@ meta_window_unmanage (MetaWindow  *window,
    XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask);
 #endif

-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);

  g_signal_emit (window, window_signals[UNMANAGED], 0);

@@ -1576,7 +1577,7 @@ set_wm_state (MetaWindow *window,
                   window->display->atom_WM_STATE,
                   window->display->atom_WM_STATE,
                   32, PropModeReplace, (guchar*) data, 2);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 }

 static void
@@ -1654,7 +1655,7 @@ set_net_wm_state (MetaWindow *window)
                   window->display->atom__NET_WM_STATE,
                   XA_ATOM,
                   32, PropModeReplace, (guchar*) data, i);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);

  if (window->fullscreen)
    {
@@ -1670,7 +1671,7 @@ set_net_wm_state (MetaWindow *window)
                       window->display->atom__NET_WM_FULLSCREEN_MONITORS,
                       XA_CARDINAL, 32, PropModeReplace,
                       (guchar*) data, 4);
-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);
    }
 }

@@ -2413,7 +2414,7 @@ map_client_window (MetaWindow *window)
      window->mapped = TRUE;
      meta_error_trap_push (window->display);
      XMapWindow (window->display->xdisplay, window->xwindow);
-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);

      return TRUE;
    }
@@ -2437,7 +2438,7 @@ unmap_client_window (MetaWindow *window,
      window->unmaps_pending += 1;
      meta_error_trap_push (window->display);
      XUnmapWindow (window->display->xdisplay, window->xwindow);
-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);

      return TRUE;
    }
@@ -2677,6 +2678,8 @@ meta_window_show (MetaWindow *window)

  if (!window->visible_to_compositor)
    {
+      window->visible_to_compositor = TRUE;
+
      if (window->display->compositor)
        {
          MetaCompEffect effect = META_COMP_EFFECT_NONE;
@@ -2696,8 +2699,6 @@ meta_window_show (MetaWindow *window)
          meta_compositor_show_window (window->display->compositor,
                                       window, effect);
        }
-
-      window->visible_to_compositor = TRUE;
    }

  /* We don't want to worry about all cases from inside
@@ -2768,6 +2769,8 @@ meta_window_hide (MetaWindow *window)

  if (window->visible_to_compositor)
    {
+      window->visible_to_compositor = FALSE;
+
      if (window->display->compositor)
        {
          MetaCompEffect effect = META_COMP_EFFECT_NONE;
@@ -2787,8 +2790,6 @@ meta_window_hide (MetaWindow *window)
          meta_compositor_hide_window (window->display->compositor,
                                       window, effect);
        }
-
-      window->visible_to_compositor = FALSE;
    }

  did_hide = FALSE;
@@ -2971,7 +2972,7 @@ ensure_size_hints_satisfied (MetaRectangle    *rect,
 static void
 meta_window_save_rect (MetaWindow *window)
 {
-  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED (window) || window->fullscreen))
+  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED_SIDE_BY_SIDE (window) || window->fullscreen))
    {
      /* save size/pos as appropriate args for move_resize */
      if (!window->maximized_horizontally)
@@ -3013,7 +3014,7 @@ force_save_user_window_placement (MetaWindow *window)
 static void
 save_user_window_placement (MetaWindow *window)
 {
-  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED (window) || window->fullscreen))
+  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED_SIDE_BY_SIDE (window) || window->fullscreen))
    {
      MetaRectangle user_rect;

@@ -3157,14 +3158,47 @@ meta_window_maximize (MetaWindow        *window,
    }
 }

-static void
+/**
+ * meta_window_get_maximized:
+ *
+ * Gets the current maximization state of the window, as combination
+ * of the %META_MAXIMIZE_HORIZONTAL and %META_MAXIMIZE_VERTICAL flags;
+ *
+ * Return value: current maximization state
+ */
+MetaMaximizeFlags
+meta_window_get_maximized (MetaWindow *window)
+{
+  return ((window->maximized_horizontally ? META_MAXIMIZE_HORIZONTAL : 0) |
+          (window->maximized_vertically ? META_MAXIMIZE_VERTICAL : 0));
+}
+
+/**
+ * meta_window_is_fullscreen:
+ *
+ * Return value: %TRUE if the window is currently fullscreen
+ */
+gboolean
+meta_window_is_fullscreen (MetaWindow *window)
+{
+  return window->fullscreen;
+}
+
+void
 meta_window_tile (MetaWindow *window)
 {
+  MetaMaximizeFlags directions;
+
  /* Don't do anything if no tiling is requested */
  if (window->tile_mode == META_TILE_NONE)
    return;

-  meta_window_maximize_internal (window, META_MAXIMIZE_VERTICAL, NULL);
+  if (window->tile_mode == META_TILE_MAXIMIZED)
+    directions = META_MAXIMIZE_VERTICAL | META_MAXIMIZE_HORIZONTAL;
+  else
+    directions = META_MAXIMIZE_VERTICAL;
+
+  meta_window_maximize_internal (window, directions, NULL);
  meta_screen_tile_preview_update (window->screen, FALSE);

  if (window->display->compositor)
@@ -3191,7 +3225,7 @@ meta_window_tile (MetaWindow *window)
 }

 static gboolean
-meta_window_can_tile (MetaWindow *window)
+meta_window_can_tile_side_by_side (MetaWindow *window)
 {
  const MetaMonitorInfo *monitor;
  MetaRectangle tile_area;
@@ -3222,6 +3256,18 @@ meta_window_can_tile (MetaWindow *window)
         tile_area.height >= window->size_hints.min_height;
 }

+static gboolean
+meta_window_can_tile_maximized (MetaWindow *window)
+{
+  if (!META_WINDOW_ALLOWS_RESIZE (window))
+    return FALSE;
+
+  if (!window->has_maximize_func)
+    return FALSE;
+
+  return TRUE;
+}
+
 static void
 unmaximize_window_before_freeing (MetaWindow        *window)
 {
@@ -3289,6 +3335,13 @@ meta_window_unmaximize_internal (MetaWindow        *window,
      window->maximized_vertically =
        window->maximized_vertically   && !unmaximize_vertically;

+      /* Reset the tile mode for maximized tiled windows for consistency
+       * with "normal" maximized windows, but keep other tile modes,
+       * as side-by-side tiled windows may snap back.
+       */
+      if (window->tile_mode == META_TILE_MAXIMIZED)
+        window->tile_mode = META_TILE_NONE;
+
      /* Unmaximize to the saved_rect position in the direction(s)
       * being unmaximized.
       */
@@ -3372,7 +3425,8 @@ meta_window_unmaximize (MetaWindow        *window,
                        MetaMaximizeFlags  directions)
 {
  /* Restore tiling if necessary */
-  if (window->tile_mode != META_TILE_NONE)
+  if (window->tile_mode == META_TILE_LEFT ||
+      window->tile_mode == META_TILE_RIGHT)
    {
      window->maximized_horizontally = FALSE;
      meta_window_tile (window);
@@ -4322,7 +4376,7 @@ meta_window_move_resize_internal (MetaWindow          *window,
                        mask,
                        &values);

-      meta_error_trap_pop (window->display, FALSE);
+      meta_error_trap_pop (window->display);
    }

  if (!configure_frame_first && window->frame)
@@ -4664,6 +4718,13 @@ meta_window_get_geometry (MetaWindow  *window,
    window->size_hints.height_inc;
 }

+/**
+ * meta_window_get_outer_rect:
+ * @window: a #MetaWindow
+ * @rect: (out): pointer to an allocated #MetaRectangle
+ *
+ * Gets the rectangle that bounds @window and, if decorated, its decorations.
+ */
 void
 meta_window_get_outer_rect (const MetaWindow *window,
                            MetaRectangle    *rect)
@@ -5025,7 +5086,7 @@ update_net_frame_extents (MetaWindow *window)
                   window->display->atom__NET_FRAME_EXTENTS,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 4);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 }

 void
@@ -5052,7 +5113,7 @@ meta_window_set_current_workspace_hint (MetaWindow *window)
                   window->display->atom__NET_WM_DESKTOP,
                   XA_CARDINAL,
                   32, PropModeReplace, (guchar*) data, 1);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 }

 static gboolean
@@ -5177,7 +5238,7 @@ meta_window_send_icccm_message (MetaWindow *window,
    meta_error_trap_push (window->display);
    XSendEvent (window->display->xdisplay,
                window->xwindow, False, 0, (XEvent*) &ev);
-    meta_error_trap_pop (window->display, FALSE);
+    meta_error_trap_pop (window->display);
 }

 void
@@ -5582,12 +5643,12 @@ meta_window_client_message (MetaWindow *window,

          meta_error_trap_push_with_return (display);
          str1 = XGetAtomName (display->xdisplay, first);
-          if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+          if (meta_error_trap_pop_with_return (display) != 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)
+          if (meta_error_trap_pop_with_return (display) != Success)
            str2 = NULL;

          meta_verbose ("Request to change _NET_WM_STATE action %lu atom1: %s atom2: %s\n",
@@ -5875,7 +5936,7 @@ meta_window_client_message (MetaWindow *window,
                             &query_root_x, &query_root_y,
                             &x, &y,
                             &mask);
-              meta_error_trap_pop (window->display, TRUE);
+              meta_error_trap_pop (window->display);

              if (mask & Button1Mask)
                button = 1;
@@ -5909,12 +5970,12 @@ meta_window_client_message (MetaWindow *window,
  else if (event->xclient.message_type ==
           display->atom__NET_MOVERESIZE_WINDOW)
    {
-      int gravity, source;
+      int gravity;
      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;
+      /* source = (event->xclient.data.l[0] & 0xf000) >> 12; */

      if (gravity == 0)
        gravity = window->size_hints.win_gravity;
@@ -5957,7 +6018,6 @@ meta_window_client_message (MetaWindow *window,
  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",
@@ -5967,7 +6027,7 @@ meta_window_client_message (MetaWindow *window,
      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];
+      /* source_indication = event->xclient.data.l[4]; */

      meta_window_update_fullscreen_monitors (window, top, bottom, left, right);
    }
@@ -6111,7 +6171,7 @@ meta_window_notify_focus (MetaWindow *window,
          meta_error_trap_push (window->display);
          XInstallColormap (window->display->xdisplay,
                            window->colormap);
-          meta_error_trap_pop (window->display, FALSE);
+          meta_error_trap_pop (window->display);

          /* move into FOCUSED_WINDOW layer */
          meta_window_update_layer (window);
@@ -6174,7 +6234,7 @@ meta_window_notify_focus (MetaWindow *window,
          meta_error_trap_push (window->display);
          XUninstallColormap (window->display->xdisplay,
                              window->colormap);
-          meta_error_trap_pop (window->display, FALSE);
+          meta_error_trap_pop (window->display);

          /* move out of FOCUSED_WINDOW layer */
          meta_window_update_layer (window);
@@ -6265,7 +6325,7 @@ send_configure_notify (MetaWindow *window)
  XSendEvent (window->display->xdisplay,
              window->xwindow,
              False, StructureNotifyMask, &event);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 }

 /* FIXME: @rect should be marked (out), but gjs doesn't currently support
@@ -6501,7 +6561,7 @@ meta_window_update_net_wm_type (MetaWindow *window)
        {
          meta_error_trap_push (window->display);
          str = XGetAtomName (window->display->xdisplay, window->type_atom);
-          meta_error_trap_pop (window->display, TRUE);
+          meta_error_trap_pop (window->display);
        }

      meta_verbose ("Window %s type atom %s\n", window->desc,
@@ -6862,7 +6922,7 @@ recalc_window_type (MetaWindow *window)
          meta_error_trap_push (window->display);
          atom_name = XGetAtomName (window->display->xdisplay,
                                    window->type_atom);
-          meta_error_trap_pop (window->display, TRUE);
+          meta_error_trap_pop (window->display);

          meta_warning ("Unrecognized type atom [%s] set for %s \n",
                        atom_name ? atom_name : "unknown",
@@ -7020,7 +7080,7 @@ set_allowed_actions_hint (MetaWindow *window)
                   window->display->atom__NET_WM_ALLOWED_ACTIONS,
                   XA_ATOM,
                   32, PropModeReplace, (guchar*) data, i);
-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 #undef MAX_N_ACTIONS
 }

@@ -7577,7 +7637,6 @@ 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;
@@ -7591,7 +7650,6 @@ meta_window_titlebar_is_onscreen (MetaWindow *window)
  /* 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.
@@ -7765,14 +7823,13 @@ update_move (MetaWindow  *window,
  shake_threshold = meta_ui_get_drag_threshold (window->screen->ui) *
    DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR;

-  if (meta_prefs_get_side_by_side_tiling () &&
-      meta_window_can_tile (window))
+  if (meta_prefs_get_edge_tiling ())
    {
      const MetaMonitorInfo *monitor;
      MetaRectangle work_area;

-      /* For tiling we are interested in the work area of the monitor where
-       * the pointer is located.
+      /* For side-by-side tiling we are interested in the inside vertical
+       * edges of the work area of the monitor where the pointer is located.
       * Also see comment in meta_window_get_current_tile_area()
       */
      monitor = meta_screen_get_current_monitor (window->screen);
@@ -7780,17 +7837,38 @@ update_move (MetaWindow  *window,
                                             monitor->number,
                                             &work_area);

-      if (y >= monitor->rect.y &&
-          y < (monitor->rect.y + monitor->rect.height))
+      if (meta_window_can_tile_side_by_side (window))
        {
-          /* check if cursor is near an edge of the work area */
-          if (x >= monitor->rect.x && x < (work_area.x + shake_threshold))
-            window->tile_mode = META_TILE_LEFT;
-          else if (x >= work_area.x + work_area.width - shake_threshold &&
-                   x < (monitor->rect.x + monitor->rect.width))
-            window->tile_mode = META_TILE_RIGHT;
-          else
-            window->tile_mode = META_TILE_NONE;
+          if (y >= monitor->rect.y &&
+              y < (monitor->rect.y + monitor->rect.height))
+            {
+              /* check if cursor is near an edge of the work area */
+              if (x >= monitor->rect.x && x < (work_area.x + shake_threshold))
+                window->tile_mode = META_TILE_LEFT;
+              else if (x >= work_area.x + work_area.width - shake_threshold &&
+                       x < (monitor->rect.x + monitor->rect.width))
+                window->tile_mode = META_TILE_RIGHT;
+              else
+                window->tile_mode = META_TILE_NONE;
+            }
+        }
+
+      /* For maximized tiling we are interested in the outside top edge
+       * of the work area of the monitor where the pointer is located.
+       *
+       * We use the outside edge instead of the inside edge, because we
+       * don't want to force users to maximize windows they are placing
+       * near the top of their screens.
+       */
+      if (meta_window_can_tile_maximized (window))
+        {
+          if (x >= monitor->rect.x &&
+              x < (monitor->rect.x + monitor->rect.width))
+            {
+              /* check if cursor is on the top edge of the monitor*/
+              if (y >= monitor->rect.y && y <= work_area.y)
+                  window->tile_mode = META_TILE_MAXIMIZED;
+            }
        }
    }

@@ -7800,12 +7878,15 @@ update_move (MetaWindow  *window,
   */

  if ((META_WINDOW_MAXIMIZED (window) && ABS (dy) >= shake_threshold) ||
-      (META_WINDOW_TILED (window) && (MAX (ABS (dx), ABS (dy)) >= shake_threshold)))
+      (META_WINDOW_TILED_SIDE_BY_SIDE (window) && (MAX (ABS (dx), ABS (dy)) >= shake_threshold)))
    {
      double prop;

-      /* Shake loose */
-      window->shaken_loose = !META_WINDOW_TILED (window);
+      /* Shake loose, so that the window snaps back to maximized
+       * when dragged near the top; do not snap back if tiling
+       * is enabled, as top edge tiling can be used in that case
+       */
+      window->shaken_loose = !meta_prefs_get_edge_tiling ();
      window->tile_mode = META_TILE_NONE;

      /* move the unmaximized window to the cursor */
@@ -7838,12 +7919,13 @@ update_move (MetaWindow  *window,
   * loose or it is still maximized (then move straight)
   */
  else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) &&
-           window->tile_mode == META_TILE_NONE)
+           window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT)
    {
      const MetaMonitorInfo *wmonitor;
      MetaRectangle work_area;
      int monitor;

+      window->tile_mode = META_TILE_NONE;
      wmonitor = meta_screen_get_monitor_for_window (window->screen, window);

      for (monitor = 0; monitor < window->screen->n_monitor_infos; monitor++)
@@ -7902,7 +7984,7 @@ update_move (MetaWindow  *window,
  meta_window_get_client_root_coords (window, &old);

  /* Don't allow movement in the maximized directions or while tiled */
-  if (window->maximized_horizontally || META_WINDOW_TILED (window))
+  if (window->maximized_horizontally || META_WINDOW_TILED_SIDE_BY_SIDE (window))
    new_x = old.x;
  if (window->maximized_vertically)
    new_y = old.y;
@@ -8338,6 +8420,23 @@ check_use_this_motion_notify (MetaWindow *window,
    }
 }

+static void
+update_tile_mode (MetaWindow *window)
+{
+  switch (window->tile_mode)
+    {
+      case META_TILE_LEFT:
+      case META_TILE_RIGHT:
+          if (!META_WINDOW_TILED_SIDE_BY_SIDE (window))
+              window->tile_mode = META_TILE_NONE;
+          break;
+      case META_TILE_MAXIMIZED:
+          if (!META_WINDOW_MAXIMIZED (window))
+              window->tile_mode = META_TILE_NONE;
+          break;
+    }
+}
+
 void
 meta_window_handle_mouse_grab_op_event (MetaWindow *window,
                                        XEvent     *event)
@@ -8430,9 +8529,7 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window,
               * would break the ability to snap back to the tiled
               * state, so we wait until mouse release.
               */
-              if (!window->maximized_vertically &&
-                  window->tile_mode != META_TILE_NONE)
-                window->tile_mode = META_TILE_NONE;
+              update_tile_mode (window);
            }
        }

@@ -8492,7 +8589,7 @@ meta_window_set_gravity (MetaWindow *window,
                           CWWinGravity,
                           &attrs);

-  meta_error_trap_pop (window->display, FALSE);
+  meta_error_trap_pop (window->display);
 }

 static void
@@ -8936,7 +9033,7 @@ warp_grab_pointer (MetaWindow          *window,
                0, 0, 0, 0,
                *x, *y);

-  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+  if (meta_error_trap_pop_with_return (display) != Success)
    {
      meta_verbose ("Failed to warp pointer for window %s\n",
                    window->desc);
@@ -9274,9 +9371,22 @@ transient_has_focus (MetaWindow *window,
  return FALSE;
 }

+/**
+ * meta_window_appears_focused:
+ * @window: a #MetaWindow
+ *
+ * Determines if the window should be drawn with a focused appearance. This is
+ * true for focused windows but also true for windows with a focused modal
+ * dialog attached.
+ *
+ * Return value: %TRUE if the window should be drawn with a focused frame
+ */
 gboolean
 meta_window_appears_focused (MetaWindow *window)
 {
+  /* FIXME: meta_window_foreach_transient() iterates over all windows; we
+   *  should eat the complexity to cache a bit for this.
+   */
  if (!window->has_focus && meta_prefs_get_attach_modal_dialogs ())
    {
      gboolean focus = FALSE;
@@ -9376,6 +9486,17 @@ meta_window_get_window_type (MetaWindow *window)
  return window->type;
 }

+/**
+ * meta_window_get_window_type_atom: (skip)
+ * @window: a #MetaWindow
+ *
+ * Gets the X atom from the _NET_WM_WINDOW_TYPE property used by the
+ * application to set the window type. (Note that this is constrained
+ * to be some value that Mutter recognizes - a completely unrecognized
+ * type atom will be returned as None.)
+ *
+ * Return value: the raw X atom for the window type, or None
+ */
 Atom
 meta_window_get_window_type_atom (MetaWindow *window)
 {
@@ -9643,3 +9764,74 @@ meta_window_get_mutter_hints (MetaWindow *window)

  return window->mutter_hints;
 }
+
+/**
+ * meta_window_get_frame_type:
+ * @window: a #MetaWindow
+ *
+ * Gets the type of window decorations that should be used for this window.
+ *
+ * Return value: the frame type
+ */
+MetaFrameType
+meta_window_get_frame_type (MetaWindow *window)
+{
+  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:
+      if (meta_prefs_get_attach_modal_dialogs () &&
+          meta_window_get_transient_for (window) != NULL)
+        base_type = META_FRAME_TYPE_ATTACHED;
+      else
+        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:
+    case META_WINDOW_DROPDOWN_MENU:
+    case META_WINDOW_POPUP_MENU:
+    case META_WINDOW_TOOLTIP:
+    case META_WINDOW_NOTIFICATION:
+    case META_WINDOW_COMBO:
+    case META_WINDOW_DND:
+    case META_WINDOW_OVERRIDE_OTHER:
+      /* No frame */
+      base_type = META_FRAME_TYPE_LAST;
+      break;
+    }
+
+  if (base_type == META_FRAME_TYPE_LAST)
+    {
+      /* can't add border if undecorated */
+      return META_FRAME_TYPE_LAST;
+    }
+  else if (window->border_only && base_type != META_FRAME_TYPE_ATTACHED)
+    {
+      /* override base frame type */
+      return META_FRAME_TYPE_BORDER;
+    }
+  else
+    {
+      return base_type;
+    }
+}
--- a/src/core/workspace.c
+++ b/src/core/workspace.c
@@ -24,8 +24,10 @@
 */

 #include <config.h>
+#include "screen-private.h"
 #include "workspace.h"
 #include "workspace-private.h"
+#include "boxes-private.h"
 #include "errors.h"
 #include "prefs.h"

@@ -44,7 +46,6 @@ enum {
 };

 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);
@@ -556,7 +557,7 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace,

  workspace->screen->active_workspace = workspace;

-  set_active_space_hint (workspace->screen);
+  meta_screen_set_active_workspace_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
@@ -617,10 +618,20 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace,
   meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
                                      new_space, &layout2);

-   if (layout1.current_col < layout2.current_col)
-     direction = META_MOTION_RIGHT;
-   if (layout1.current_col > layout2.current_col)
-     direction = META_MOTION_LEFT;
+   if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+     {
+       if (layout1.current_col > layout2.current_col)
+         direction = META_MOTION_RIGHT;
+       else if (layout1.current_col < layout2.current_col)
+         direction = META_MOTION_LEFT;
+     }
+   else
+    {
+       if (layout1.current_col < layout2.current_col)
+         direction = META_MOTION_RIGHT;
+       else if (layout1.current_col > layout2.current_col)
+         direction = META_MOTION_LEFT;
+    }

   if (layout1.current_row < layout2.current_row)
     {
@@ -741,32 +752,6 @@ meta_workspace_list_windows (MetaWorkspace *workspace)
  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)
 {
@@ -1048,7 +1033,7 @@ strut_lists_equal (GSList *l,
 /**
 * meta_workspace_set_builtin_struts:
 * @workspace: a #MetaWorkspace
- * @struts: (element-type Strut) (transfer none): list of #MetaStrut
+ * @struts: (element-type Meta.Strut) (transfer none): list of #MetaStrut
 *
 * Sets a list of struts that will be used in addition to the struts
 * of the windows in the workspace when computing the work area of
--- a/src/core/xprops.c
+++ b/src/core/xprops.c
@@ -126,7 +126,7 @@ validate_or_free_results (GetPropertyResults *results,
  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);
+  meta_error_trap_pop (results->display);

  w = meta_display_lookup_x_window (results->display, results->xwindow);

@@ -204,11 +204,11 @@ get_property (MetaDisplay        *display,
    {
      if (results->prop)
        XFree (results->prop);
-      meta_error_trap_pop_with_return (display, TRUE);
+      meta_error_trap_pop_with_return (display);
      return FALSE;
    }

-  if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+  if (meta_error_trap_pop_with_return (display) != Success)
    {
      if (results->prop)
        XFree (results->prop);
@@ -490,7 +490,7 @@ utf8_list_from_results (GetPropertyResults *results,

          meta_error_trap_push (results->display);
          name = XGetAtomName (results->display->xdisplay, results->xatom);
-          meta_error_trap_pop (results->display, TRUE);
+          meta_error_trap_pop (results->display);
          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);
@@ -547,7 +547,7 @@ meta_prop_set_utf8_string_hint (MetaDisplay *display,
                   xwindow, atom,
                   display->atom_UTF8_STRING, 
                   8, PropModeReplace, (guchar*) val, strlen (val));
-  meta_error_trap_pop (display, FALSE);
+  meta_error_trap_pop (display);
 }

 static gboolean
--- a/src/gdk-compat.h
+++ b/src/gdk-compat.h
@@ -1,80 +0,0 @@
-#ifndef __GDK_COMPAT_H__
-#define __GDK_COMPAT_H__
-
-#include <gdk/gdk.h>
-#include <math.h>
-
-/* Provide a compatibility layer for accessor function introduced
- * in GTK+ 2.22 which we need to build without deprecated GDK symbols.
- * That way it is still possible to build with GTK+ 2.18 when not
- * using GDK_DISABLE_DEPRECATED.
- */
-
-#if !GTK_CHECK_VERSION (2, 21, 1)
-
-#define gdk_visual_get_depth(v)           GDK_VISUAL(v)->depth
-
-#endif /* GTK_CHECK_VERSION (2, 21, 1) */
-
-#if !GTK_CHECK_VERSION (2, 90, 8)
-
-#define gdk_window_get_screen gdk_drawable_get_screen
-#define gdk_pixbuf_get_from_window(window, src_x, src_y, width, height) \
-    gdk_pixbuf_get_from_drawable(NULL, window, NULL, src_x, src_y, 0, 0, width, height)
-
-static inline int
-gdk_window_get_width (GdkWindow *window)
-{
-  int width;
-
-  gdk_drawable_get_size (window, &width, NULL);
-
-  return width;
-}
-
-static inline int
-gdk_window_get_height (GdkWindow *window)
-{
-  int height;
-
-  gdk_drawable_get_size (window, NULL, &height);
-
-  return height;
-}
-
-
-static inline gboolean
-gdk_cairo_get_clip_rectangle (cairo_t      *cr,
-                              GdkRectangle *rect)
-{
-  double x1, y1, x2, y2;
-  gboolean clip_exists;
-
-  cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
-
-  clip_exists = x1 < x2 && y1 < y2;
-
-  if (rect)
-    {
-      x1 = floor (x1);
-      y1 = floor (y1);
-      x2 = ceil (x2);
-      y2 = ceil (y2);
-
-      rect->x      = CLAMP (x1,      G_MININT, G_MAXINT);
-      rect->y      = CLAMP (y1,      G_MININT, G_MAXINT);
-      rect->width  = CLAMP (x2 - x1, G_MININT, G_MAXINT);
-      rect->height = CLAMP (y2 - y1, G_MININT, G_MAXINT);
-    }
-
-  return clip_exists;
-}
-
-#endif /* GTK_CHECK_VERSION (2, 90, 8) */
-
-/* Compatibility with old GDK key symbols */
-#ifndef GDK_KEY_Escape
-#define GDK_KEY_Escape GDK_Escape
-#endif /* GDK_KEY_Escape */
-
-#endif /* __GDK_COMPAT_H__ */
--- a/src/gdk2-drawing-utils.c
+++ b/src/gdk2-drawing-utils.c
@@ -1,177 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* 
- * Copyright (C) 2010 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 "gdk2-drawing-utils.h"
-
-#include <math.h>
-
-#include "gdk-compat.h"
-
-#ifndef USE_GTK3
-
-static const cairo_user_data_key_t context_key;
-
-cairo_t *
-meta_cairo_create (GdkDrawable *drawable)
-{
-  cairo_t *cr;
-  
-  cr = gdk_cairo_create (drawable);
-  cairo_set_user_data (cr, &context_key, drawable, NULL);
-
-  return cr;
-}
-
-static GdkWindow *
-extract_window (cairo_t      *cr,
-                int          *dx,
-                int          *dy,
-                GdkRectangle *clip_area)
-{
-  GdkWindow *window = cairo_get_user_data (cr, &context_key);
-  cairo_matrix_t matrix;
-
-  g_assert (dx != NULL);
-  g_assert (dy != NULL);
-  g_assert (clip_area != NULL);
-
-  /* lots of stuff that mustn't happen because we can't cope with it. */
-  if (window == NULL)
-    {
-      g_error ("Could not get the GdkWindow from the cairo context passed to\n"
-               "theme drawing functions. A GdkWindow must be set on all cairo\n"
-               "context passed to theme drawing functions when using GTK2.\n"
-               "Please use meta_cairo_create() to create the Cairo context.\n");
-    }
-  cairo_get_matrix (cr, &matrix);
-  if (matrix.xx != 1.0 || matrix.yy != 1.0 ||
-      matrix.xy != 0.0 || matrix.yx != 0.0 ||
-      floor (matrix.x0) != matrix.x0 ||
-      floor (matrix.y0) != matrix.y0)
-    {
-      g_error ("GTK2 drawing requires that the matrix set on the cairo context\n"
-               "is an integer translation, however that is not the case.\n");
-    }
-
-  gdk_cairo_get_clip_rectangle (cr, clip_area);
-  clip_area->x += matrix.x0;
-  clip_area->y += matrix.y0;
-
-  *dx = matrix.x0;
-  *dy = matrix.y0;
-
-  return window;
-}
-
-void
-meta_paint_vline (GtkStyle           *style,
-                  cairo_t            *cr,
-                  GtkStateType        state_type,
-                  GtkWidget          *widget,
-                  const gchar        *detail,
-                  gint                y1_,
-                  gint                y2_,
-                  gint                x)
-{
-  int dx, dy;
-  GdkWindow *window;
-  GdkRectangle area;
-
-  window = extract_window (cr, &dx, &dy, &area);
-
-  gtk_paint_vline (style, window, state_type, &area,
-                   widget, detail, y1_ + dy, y2_ + dy, x + dx);
-}
-
-void
-meta_paint_arrow (GtkStyle           *style,
-                  cairo_t            *cr,
-                  GtkStateType        state_type,
-                  GtkShadowType       shadow_type,
-                  GtkWidget          *widget,
-                  const gchar        *detail,
-                  GtkArrowType        arrow_type,
-                  gboolean            fill,
-                  gint                x,
-                  gint                y,
-                  gint                width,
-                  gint                height)
-{
-  int dx, dy;
-  GdkWindow *window;
-  GdkRectangle area;
-
-  window = extract_window (cr, &dx, &dy, &area);
-
-  gtk_paint_arrow (style, window, state_type, shadow_type,
-                   &area, widget, detail, arrow_type,
-                   fill, x + dx, y + dy, width, height);
-}
-
-void
-meta_paint_box (GtkStyle           *style,
-                cairo_t            *cr,
-                GtkStateType        state_type,
-                GtkShadowType       shadow_type,
-                GtkWidget          *widget,
-                const gchar        *detail,
-                gint                x,
-                gint                y,
-                gint                width,
-                gint                height)
-{
-  int dx, dy;
-  GdkWindow *window;
-  GdkRectangle area;
-
-  window = extract_window (cr, &dx, &dy, &area);
-
-  gtk_paint_box (style, window, state_type, shadow_type,
-                 &area, widget, detail,
-                 x + dx, y + dy, width, height);
-}
-
-void
-meta_paint_flat_box (GtkStyle           *style,
-                     cairo_t            *cr,
-                     GtkStateType        state_type,
-                     GtkShadowType       shadow_type,
-                     GtkWidget          *widget,
-                     const gchar        *detail,
-                     gint                x,
-                     gint                y,
-                     gint                width,
-                     gint                height)
-{
-  int dx, dy;
-  GdkWindow *window;
-  GdkRectangle area;
-
-  window = extract_window (cr, &dx, &dy, &area);
-
-  gtk_paint_flat_box (style, window, state_type, shadow_type,
-                      &area, widget, detail,
-                      x + dx, y + dy, width, height);
-}
-
-#endif /* USE_GTK3 */
--- a/src/gdk2-drawing-utils.h
+++ b/src/gdk2-drawing-utils.h
@@ -1,100 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* 
- * Copyright (C) 2010 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 __GTK3_COMPAT_H__
-#define __GTK3_COMPAT_H__
-
-#include <gtk/gtk.h>
-
-#if GTK_CHECK_VERSION (2, 90, 8)
-
-#define USE_GTK3 1
-
-#define MetaPixmap cairo_surface_t
-
-#define meta_pixmap_new(window, w, h) gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR, w, h)
-#define meta_pixmap_free(pixmap) cairo_surface_destroy (pixmap)
-#define meta_pixmap_cairo_create(pixmap) cairo_create (pixmap)
-#define meta_cairo_set_source_pixmap(cr, pixmap, x, y) cairo_set_source_surface (cr, pixmap, x, y)
-
-#define meta_paint_vline gtk_paint_vline
-#define meta_paint_box gtk_paint_box
-#define meta_paint_arrow gtk_paint_arrow
-#define meta_paint_flat_box gtk_paint_flat_box
-
-#else /* GTK_VERSION < 2.90.8 */
-
-#undef USE_GTK3
-
-#define MetaPixmap GdkPixmap
-
-#define meta_pixmap_new(window, w, h) gdk_pixmap_new (window, w, h, -1)
-#define meta_pixmap_free(pixmap) g_object_unref (pixmap)
-#define meta_pixmap_cairo_create(pixmap) meta_cairo_create (pixmap)
-#define meta_cairo_set_source_pixmap(cr, pixmap, x, y) gdk_cairo_set_source_pixmap (cr, pixmap, x, y)
-
-/* This function only exists for GTK2 code. */
-cairo_t *     meta_cairo_create            (GdkDrawable        *drawable);
-
-void          meta_paint_vline             (GtkStyle           *style,
-                                            cairo_t            *cr,
-                                            GtkStateType        state_type,
-                                            GtkWidget          *widget,
-                                            const gchar        *detail,
-                                            gint                y1_,
-                                            gint                y2_,
-                                            gint                x);
-void          meta_paint_arrow             (GtkStyle           *style,
-                                            cairo_t            *cr,
-                                            GtkStateType        state_type,
-                                            GtkShadowType       shadow_type,
-                                            GtkWidget          *widget,
-                                            const gchar        *detail,
-                                            GtkArrowType        arrow_type,
-                                            gboolean            fill,
-                                            gint                x,
-                                            gint                y,
-                                            gint                width,
-                                            gint                height);
-void          meta_paint_box               (GtkStyle           *style,
-                                            cairo_t            *cr,
-                                            GtkStateType        state_type,
-                                            GtkShadowType       shadow_type,
-                                            GtkWidget          *widget,
-                                            const gchar        *detail,
-                                            gint                x,
-                                            gint                y,
-                                            gint                width,
-                                            gint                height);
-void          meta_paint_flat_box          (GtkStyle           *style,
-                                            cairo_t            *cr,
-                                            GtkStateType        state_type,
-                                            GtkShadowType       shadow_type,
-                                            GtkWidget          *widget,
-                                            const gchar        *detail,
-                                            gint                x,
-                                            gint                y,
-                                            gint                width,
-                                            gint                height);
-
-#endif /* GTK_VERSION < 2.90.8 */
-
-#endif /* __GTK3_COMPAT_H__ */
--- a/src/gtk-compat.h
+++ b/src/gtk-compat.h
@@ -1,26 +0,0 @@
-#ifndef __GTK_COMPAT_H__
-#define __GTK_COMPAT_H__
-
-#include <gtk/gtk.h>
-
-/* Provide a compatibility layer for accessor function introduces
- * in GTK+ 2.20 which we need to build with GSEAL_ENABLE.
- * That way it is still possible to build with GTK+ 2.18 when not
- * using GSEAL_ENABLE
- */
-
-#if !GTK_CHECK_VERSION (2, 20, 0)
-
-#define gtk_widget_get_realized(w) GTK_WIDGET_REALIZED (w)
-#define gtk_widget_get_requisition(w,r) (*r = GTK_WIDGET (w)->requisition)
-#define gtk_widget_set_mapped(w,m)            \
-  G_STMT_START {                              \
-    if (m)                                    \
-      GTK_WIDGET_SET_FLAGS (w, GTK_MAPPED);   \
-    else                                      \
-      GTK_WIDGET_UNSET_FLAGS (w, GTK_MAPPED); \
-  } G_STMT_END
-
-#endif /* GTK_CHECK_VERSION */
-
-#endif /* __GTK_COMPAT_H__ */
--- a/src/include/all-keybindings.h
+++ b/src/include/all-keybindings.h
@@ -167,7 +167,7 @@ keybind (switch_panels_backward,   handle_switch,        META_TAB_LIST_DOCKS,
          "using a popup window"))

 keybind (cycle_group,               handle_cycle,         META_TAB_LIST_GROUP,
-        BINDING_REVERSES,        "<Alt>grave",
+        BINDING_REVERSES,        "<Alt>Above_Tab",
        _("Move between windows of an application immediately"))
 keybind (cycle_group_backward,     handle_cycle,         META_TAB_LIST_GROUP,
        REVERSES_AND_REVERSED,   NULL,
--- a/src/include/boxes.h
+++ b/src/include/boxes.h
@@ -45,18 +45,6 @@ struct _MetaStrut
  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,
@@ -77,28 +65,6 @@ GType meta_rectangle_get_type (void);
 MetaRectangle *meta_rectangle_copy (const MetaRectangle *rect);
 void           meta_rectangle_free (MetaRectangle       *rect);

-/* 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);

@@ -139,159 +105,4 @@ gboolean meta_rectangle_could_fit_rect  (const MetaRectangle *outer_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_monitor_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 monitors which are not covered by the given
- * struts.
- */
-GList* meta_rectangle_find_nonintersected_monitor_edges (
-                                           const GList         *monitor_rects,
-                                           const GSList        *all_struts);
-
 #endif /* META_BOXES_H */
--- a/src/include/common.h
+++ b/src/include/common.h
@@ -47,7 +47,9 @@ typedef enum
  META_FRAME_ALLOWS_MOVE              = 1 << 11,
  META_FRAME_FULLSCREEN               = 1 << 12,
  META_FRAME_IS_FLASHING              = 1 << 13,
-  META_FRAME_ABOVE                    = 1 << 14
+  META_FRAME_ABOVE                    = 1 << 14,
+  META_FRAME_TILED_LEFT               = 1 << 15,
+  META_FRAME_TILED_RIGHT              = 1 << 16
 } MetaFrameFlags;

 typedef enum
@@ -195,6 +197,7 @@ typedef enum
  META_FRAME_TYPE_UTILITY,
  META_FRAME_TYPE_MENU,
  META_FRAME_TYPE_BORDER,
+  META_FRAME_TYPE_ATTACHED,
  META_FRAME_TYPE_LAST
 } MetaFrameType;

--- a/src/include/compositor-mutter.h
+++ b/src/include/compositor-mutter.h
@@ -30,13 +30,15 @@

 #include "types.h"
 #include "compositor.h"
-#include "mutter-window.h"
+#include "meta-window-actor.h"

 /* Public compositor API */
-ClutterActor * mutter_get_stage_for_screen (MetaScreen *screen);
-ClutterActor * mutter_get_overlay_group_for_screen (MetaScreen *screen);
-Window         mutter_get_overlay_window (MetaScreen *screen);
-GList        * mutter_get_windows (MetaScreen *screen);
-ClutterActor * mutter_get_window_group_for_screen (MetaScreen *screen);
+ClutterActor *meta_get_stage_for_screen         (MetaScreen *screen);
+ClutterActor *meta_get_overlay_group_for_screen (MetaScreen *screen);
+Window        meta_get_overlay_window           (MetaScreen *screen);
+GList        *meta_get_window_actors            (MetaScreen *screen);
+ClutterActor *meta_get_window_group_for_screen  (MetaScreen *screen);
+
+ClutterActor *meta_get_background_actor_for_screen (MetaScreen *screen);

 #endif
--- a/src/include/display.h
+++ b/src/include/display.h
@@ -125,7 +125,6 @@ void     meta_display_end_grab_op   (MetaDisplay *display,
 MetaGrabOp meta_display_get_grab_op (MetaDisplay *display);

 MetaKeyBindingAction meta_display_get_keybinding_action (MetaDisplay  *display,
-                                                         unsigned int  keysym,
                                                         unsigned int  keycode,
                                                         unsigned long mask);

--- a/src/include/errors.h
+++ b/src/include/errors.h
@@ -29,16 +29,12 @@
 #include "util.h"
 #include "display.h"

-void      meta_errors_init     (void);
-
 void      meta_error_trap_push (MetaDisplay *display);
-void      meta_error_trap_pop  (MetaDisplay *display,
-                                gboolean     last_request_was_roundtrip);
+void      meta_error_trap_pop  (MetaDisplay *display);

 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);
+int       meta_error_trap_pop_with_return  (MetaDisplay *display);


 #endif
--- a/src/include/mutter-plugin.h
+++ b/src/include/mutter-plugin.h
@@ -21,8 +21,8 @@
 * 02111-1307, USA.
 */

-#ifndef MUTTER_PLUGIN_H_
-#define MUTTER_PLUGIN_H_
+#ifndef META_PLUGIN_H_
+#define META_PLUGIN_H_

 #include "types.h"
 #include "compositor.h"
@@ -32,64 +32,64 @@
 #include <X11/extensions/Xfixes.h>
 #include <gmodule.h>

-#define MUTTER_TYPE_PLUGIN            (mutter_plugin_get_type ())
-#define MUTTER_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_PLUGIN, MutterPlugin))
-#define MUTTER_PLUGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  MUTTER_TYPE_PLUGIN, MutterPluginClass))
-#define MUTTER_IS_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_PLUGIN))
-#define MUTTER_IS_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  MUTTER_TYPE_PLUGIN))
-#define MUTTER_PLUGIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  MUTTER_TYPE_PLUGIN, MutterPluginClass))
+#define META_TYPE_PLUGIN            (meta_plugin_get_type ())
+#define META_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_PLUGIN, MetaPlugin))
+#define META_PLUGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_PLUGIN, MetaPluginClass))
+#define META_IS_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_PLUGIN))
+#define META_IS_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_PLUGIN))
+#define META_PLUGIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_PLUGIN, MetaPluginClass))

 /**
- * MutterPlugin: (skip)
+ * MetaPlugin: (skip)
 *
 */
-typedef struct _MutterPlugin        MutterPlugin;
+typedef struct _MetaPlugin        MetaPlugin;
 /**
- * MutterPluginClass: (skip)
+ * MetaPluginClass: (skip)
 *
 */
-typedef struct _MutterPluginClass   MutterPluginClass;
-typedef struct _MutterPluginVersion MutterPluginVersion;
-typedef struct _MutterPluginInfo    MutterPluginInfo;
-typedef struct _MutterPluginPrivate MutterPluginPrivate;
+typedef struct _MetaPluginClass   MetaPluginClass;
+typedef struct _MetaPluginVersion MetaPluginVersion;
+typedef struct _MetaPluginInfo    MetaPluginInfo;
+typedef struct _MetaPluginPrivate MetaPluginPrivate;

-struct _MutterPlugin
+struct _MetaPlugin
 {
  GObject parent;

-  MutterPluginPrivate *priv;
+  MetaPluginPrivate *priv;
 };

-struct _MutterPluginClass
+struct _MetaPluginClass
 {
  GObjectClass parent_class;

-  void (*start)            (MutterPlugin       *plugin);
+  void (*start)            (MetaPlugin         *plugin);

-  void (*minimize)         (MutterPlugin       *plugin,
-                            MutterWindow       *actor);
+  void (*minimize)         (MetaPlugin         *plugin,
+                            MetaWindowActor    *actor);

-  void (*maximize)         (MutterPlugin       *plugin,
-                            MutterWindow       *actor,
+  void (*maximize)         (MetaPlugin         *plugin,
+                            MetaWindowActor    *actor,
                            gint                x,
                            gint                y,
                            gint                width,
                            gint                height);

-  void (*unmaximize)       (MutterPlugin       *plugin,
-                            MutterWindow       *actor,
+  void (*unmaximize)       (MetaPlugin         *plugin,
+                            MetaWindowActor    *actor,
                            gint                x,
                            gint                y,
                            gint                width,
                            gint                height);

-  void (*map)              (MutterPlugin       *plugin,
-                            MutterWindow       *actor);
+  void (*map)              (MetaPlugin         *plugin,
+                            MetaWindowActor    *actor);

-  void (*destroy)          (MutterPlugin       *plugin,
-                            MutterWindow       *actor);
+  void (*destroy)          (MetaPlugin         *plugin,
+                            MetaWindowActor    *actor);

-  void (*switch_workspace) (MutterPlugin       *plugin,
+  void (*switch_workspace) (MetaPlugin         *plugin,
                            gint                from,
                            gint                to,
                            MetaMotionDirection direction);
@@ -98,21 +98,21 @@ struct _MutterPluginClass
   * Called if an effects should be killed prematurely; the plugin must
   * call the completed() callback as if the effect terminated naturally.
   */
-  void (*kill_window_effects)      (MutterPlugin     *plugin,
-                                    MutterWindow     *actor);
+  void (*kill_window_effects)      (MetaPlugin      *plugin,
+                                    MetaWindowActor *actor);

-  void (*kill_switch_workspace)    (MutterPlugin     *plugin);
+  void (*kill_switch_workspace)    (MetaPlugin     *plugin);

-  /* General XEvent filter. This is fired *before* mutter itself handles
+  /* General XEvent filter. This is fired *before* meta itself handles
   * an event. Return TRUE to block any further processing.
   */
-  gboolean (*xevent_filter) (MutterPlugin       *plugin,
-                             XEvent             *event);
+  gboolean (*xevent_filter) (MetaPlugin       *plugin,
+                             XEvent           *event);

-  const MutterPluginInfo * (*plugin_info) (MutterPlugin *plugin);
+  const MetaPluginInfo * (*plugin_info) (MetaPlugin *plugin);
 };

-struct _MutterPluginInfo
+struct _MetaPluginInfo
 {
  const gchar *name;
  const gchar *version;
@@ -121,18 +121,19 @@ struct _MutterPluginInfo
  const gchar *description;
 };

-GType mutter_plugin_get_type (void);
+GType meta_plugin_get_type (void);

-gulong        mutter_plugin_features            (MutterPlugin *plugin);
-gboolean      mutter_plugin_disabled            (MutterPlugin *plugin);
-gboolean      mutter_plugin_running             (MutterPlugin *plugin);
-gboolean      mutter_plugin_debug_mode          (MutterPlugin *plugin);
-const MutterPluginInfo * mutter_plugin_get_info (MutterPlugin *plugin);
+gulong        meta_plugin_features            (MetaPlugin *plugin);
+gboolean      meta_plugin_disabled            (MetaPlugin *plugin);
+gboolean      meta_plugin_running             (MetaPlugin *plugin);
+gboolean      meta_plugin_debug_mode          (MetaPlugin *plugin);

-struct _MutterPluginVersion
+const MetaPluginInfo * meta_plugin_get_info (MetaPlugin *plugin);
+
+struct _MetaPluginVersion
 {
  /*
-   * Version information; the first three numbers match the Mutter version
+   * Version information; the first three numbers match the Meta version
   * with which the plugin was compiled (see clutter-plugins/simple.c for sample
   * code).
   */
@@ -151,13 +152,13 @@ struct _MutterPluginVersion
 /*
 * Convenience macro to set up the plugin type. Based on GEdit.
 */
-#define MUTTER_PLUGIN_DECLARE(ObjectName, object_name)                  \
-  G_MODULE_EXPORT MutterPluginVersion mutter_plugin_version =           \
+#define META_PLUGIN_DECLARE(ObjectName, object_name)                    \
+  G_MODULE_EXPORT MetaPluginVersion meta_plugin_version =               \
    {                                                                   \
-      MUTTER_MAJOR_VERSION,                                           \
-      MUTTER_MINOR_VERSION,                                           \
-      MUTTER_MICRO_VERSION,                                           \
-      MUTTER_PLUGIN_API_VERSION                               \
+      MUTTER_MAJOR_VERSION,                                             \
+      MUTTER_MINOR_VERSION,                                             \
+      MUTTER_MICRO_VERSION,                                             \
+      MUTTER_PLUGIN_API_VERSION                                         \
    };                                                                  \
                                                                        \
  static GType g_define_type_id = 0;                                    \
@@ -170,7 +171,7 @@ struct _MutterPluginVersion
  GType object_name##_register_type (GTypeModule *type_module);         \
                                                                        \
  G_MODULE_EXPORT                                                       \
-  GType mutter_plugin_register_type (GTypeModule *type_module);         \
+  GType meta_plugin_register_type (GTypeModule *type_module);           \
                                                                        \
  GType                                                                 \
  object_name##_get_type ()                                             \
@@ -204,7 +205,7 @@ struct _MutterPluginVersion
      };                                                                \
                                                                        \
    g_define_type_id = g_type_module_register_type (type_module,        \
-                                                    MUTTER_TYPE_PLUGIN, \
+                                                    META_TYPE_PLUGIN,   \
                                                    #ObjectName,        \
                                                    &our_info,          \
                                                    0);                 \
@@ -214,59 +215,62 @@ struct _MutterPluginVersion
  }                                                                     \
                                                                        \
  G_MODULE_EXPORT GType                                                 \
-  mutter_plugin_register_type (GTypeModule *type_module)                \
+  meta_plugin_register_type (GTypeModule *type_module)                  \
  {                                                                     \
    return object_name##_register_type (type_module);                   \
  }                                                                     \

 void
-mutter_plugin_switch_workspace_completed (MutterPlugin *plugin);
+meta_plugin_switch_workspace_completed (MetaPlugin *plugin);

 void
-mutter_plugin_minimize_completed (MutterPlugin *plugin,
-                                  MutterWindow *actor);
+meta_plugin_minimize_completed (MetaPlugin      *plugin,
+                                MetaWindowActor *actor);

 void
-mutter_plugin_maximize_completed (MutterPlugin *plugin,
-                                  MutterWindow *actor);
+meta_plugin_maximize_completed (MetaPlugin      *plugin,
+                                MetaWindowActor *actor);

 void
-mutter_plugin_unmaximize_completed (MutterPlugin *plugin,
-                                    MutterWindow *actor);
+meta_plugin_unmaximize_completed (MetaPlugin      *plugin,
+                                  MetaWindowActor *actor);

 void
-mutter_plugin_map_completed (MutterPlugin *plugin,
-                             MutterWindow *actor);
+meta_plugin_map_completed (MetaPlugin      *plugin,
+                           MetaWindowActor *actor);

 void
-mutter_plugin_destroy_completed (MutterPlugin *plugin,
-                                 MutterWindow *actor);
+meta_plugin_destroy_completed (MetaPlugin      *plugin,
+                               MetaWindowActor *actor);

 ClutterActor *
-mutter_plugin_get_overlay_group (MutterPlugin *plugin);
+meta_plugin_get_overlay_group (MetaPlugin *plugin);

 ClutterActor *
-mutter_plugin_get_window_group (MutterPlugin *plugin);
+meta_plugin_get_window_group (MetaPlugin *plugin);

 ClutterActor *
-mutter_plugin_get_stage (MutterPlugin *plugin);
+meta_plugin_get_background_actor (MetaPlugin *plugin);
+
+ClutterActor *
+meta_plugin_get_stage (MetaPlugin *plugin);

 void
-mutter_plugin_query_screen_size (MutterPlugin *plugin,
-                                 int          *width,
-                                 int          *height);
+meta_plugin_query_screen_size (MetaPlugin *plugin,
+                               int        *width,
+                               int        *height);

 void
-mutter_plugin_set_stage_reactive (MutterPlugin *plugin,
-                                  gboolean      reactive);
+meta_plugin_set_stage_reactive (MetaPlugin *plugin,
+                                gboolean    reactive);

 void
-mutter_plugin_set_stage_input_area (MutterPlugin *plugin,
-                                    gint x, gint y, gint width, gint height);
+meta_plugin_set_stage_input_area (MetaPlugin *plugin,
+                                  gint x, gint y, gint width, gint height);

 void
-mutter_plugin_set_stage_input_region (MutterPlugin *plugin,
-                                      XserverRegion region);
+meta_plugin_set_stage_input_region (MetaPlugin   *plugin,
+                                    XserverRegion region);

 /**
 * MetaModalOptions:
@@ -275,7 +279,7 @@ mutter_plugin_set_stage_input_region (MutterPlugin *plugin,
 * @META_MODAL_KEYBOARD_ALREADY_GRABBED: if set the keyboard is already
 *   grabbed by the plugin and should not be grabbed again.
 *
- * Options that can be provided when calling mutter_plugin_begin_modal().
+ * Options that can be provided when calling meta_plugin_begin_modal().
 */
 typedef enum {
  META_MODAL_POINTER_ALREADY_GRABBED = 1 << 0,
@@ -283,26 +287,21 @@ typedef enum {
 } MetaModalOptions;

 gboolean
-mutter_plugin_begin_modal (MutterPlugin      *plugin,
-                           Window             grab_window,
-                           Cursor             cursor,
-                           MetaModalOptions   options,
-                           guint32            timestamp);
+meta_plugin_begin_modal (MetaPlugin      *plugin,
+                         Window           grab_window,
+                         Cursor           cursor,
+                         MetaModalOptions options,
+                         guint32          timestamp);

 void
-mutter_plugin_end_modal (MutterPlugin *plugin,
-                         guint32       timestamp);
+meta_plugin_end_modal (MetaPlugin *plugin,
+                       guint32     timestamp);

-GList *
-mutter_plugin_get_windows (MutterPlugin *plugin);
-
-Display *
-mutter_plugin_get_xdisplay (MutterPlugin *plugin);
-
-MetaScreen *
-mutter_plugin_get_screen (MutterPlugin *plugin);
+GList *     meta_plugin_get_window_actors (MetaPlugin *plugin);
+Display *   meta_plugin_get_xdisplay      (MetaPlugin *plugin);
+MetaScreen *meta_plugin_get_screen        (MetaPlugin *plugin);

 void
-_mutter_plugin_effect_started (MutterPlugin *plugin);
+_meta_plugin_effect_started (MetaPlugin *plugin);

-#endif /* MUTTER_PLUGIN_H_ */
+#endif /* META_PLUGIN_H_ */
--- a/src/include/meta-shadow-factory.h
+++ b/src/include/meta-shadow-factory.h
@@ -0,0 +1,84 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MetaShadowFactory:
+ *
+ * Create and cache shadow textures for arbitrary window shapes
+ *
+ * Copyright (C) 2010 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_SHADOW_FACTORY_H__
+#define __META_SHADOW_FACTORY_H__
+
+#include <glib-object.h>
+
+/**
+ * MetaShadowParams:
+ * The #MetaShadowParams structure holds information about how to draw
+ * a particular style of shadow.
+ * @radius: the radius (gaussian standard deviation) of the shadow
+ * @top_fade: if >= 0, the shadow doesn't extend above the top
+ *  of the shape, and fades out over the given number of pixels
+ * @x_offset: horizontal offset of the shadow with respect to the
+ *  shape being shadowed, in pixels
+ * @y_offset: vertical offset of the shadow with respect to the
+ *  shape being shadowed, in pixels
+ * @opacity: opacity of the shadow, from 0 to 255
+ */
+
+typedef struct _MetaShadowParams MetaShadowParams;
+
+struct _MetaShadowParams
+{
+  int radius;
+  int top_fade;
+  int x_offset;
+  int y_offset;
+  guint8 opacity;
+};
+
+#define META_TYPE_SHADOW_FACTORY            (meta_shadow_factory_get_type ())
+#define META_SHADOW_FACTORY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SHADOW_FACTORY, MetaShadowFactory))
+#define META_SHADOW_FACTORY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SHADOW_FACTORY, MetaShadowFactoryClass))
+#define META_IS_SHADOW_FACTORY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SHADOW_FACTORY))
+#define META_IS_SHADOW_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SHADOW_FACTORY))
+#define META_SHADOW_FACTORY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SHADOW_FACTORY, MetaShadowFactoryClass))
+
+/**
+ * MetaShadowFactory:
+ * #MetaShadowFactory is used to create window shadows. It caches shadows internally
+ * so that multiple shadows created for the same shape with the same radius will
+ * share the same MetaShadow.
+ */
+typedef struct _MetaShadowFactory      MetaShadowFactory;
+typedef struct _MetaShadowFactoryClass MetaShadowFactoryClass;
+
+MetaShadowFactory *meta_shadow_factory_get_default (void);
+
+GType meta_shadow_factory_get_type (void);
+
+void meta_shadow_factory_set_params (MetaShadowFactory *factory,
+                                     const char        *class_name,
+                                     gboolean           focused,
+                                     MetaShadowParams  *params);
+void meta_shadow_factory_get_params (MetaShadowFactory *factory,
+                                     const char        *class_name,
+                                     gboolean           focused,
+                                     MetaShadowParams  *params);
+
+#endif /* __META_SHADOW_FACTORY_H__ */
--- a/src/include/meta-window-actor.h
+++ b/src/include/meta-window-actor.h
@@ -0,0 +1,70 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Matthew Allum
+ * 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_WINDOW_ACTOR_H_
+#define META_WINDOW_ACTOR_H_
+
+#include <clutter/clutter.h>
+#include <X11/Xlib.h>
+
+#include "compositor.h"
+
+/*
+ * MetaWindowActor object (ClutterGroup sub-class)
+ */
+#define META_TYPE_WINDOW_ACTOR            (meta_window_actor_get_type ())
+#define META_WINDOW_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_WINDOW_ACTOR, MetaWindowActor))
+#define META_WINDOW_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_WINDOW_ACTOR, MetaWindowActorClass))
+#define META_IS_WINDOW_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_WINDOW_ACTOR))
+#define META_IS_WINDOW_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_WINDOW_ACTOR))
+#define META_WINDOW_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_WINDOW_ACTOR, MetaWindowActorClass))
+
+typedef struct _MetaWindowActor        MetaWindowActor;
+typedef struct _MetaWindowActorClass   MetaWindowActorClass;
+typedef struct _MetaWindowActorPrivate MetaWindowActorPrivate;
+
+struct _MetaWindowActorClass
+{
+  ClutterGroupClass parent_class;
+};
+
+struct _MetaWindowActor
+{
+  ClutterGroup           parent;
+
+  MetaWindowActorPrivate *priv;
+};
+
+GType meta_window_actor_get_type (void);
+
+Window             meta_window_actor_get_x_window         (MetaWindowActor *self);
+gint               meta_window_actor_get_workspace        (MetaWindowActor *self);
+MetaWindow *       meta_window_actor_get_meta_window      (MetaWindowActor *self);
+ClutterActor *     meta_window_actor_get_texture          (MetaWindowActor *self);
+gboolean           meta_window_actor_is_override_redirect (MetaWindowActor *self);
+const char *       meta_window_actor_get_description      (MetaWindowActor *self);
+gboolean       meta_window_actor_showing_on_its_workspace (MetaWindowActor *self);
+gboolean       meta_window_actor_is_destroyed (MetaWindowActor *self);
+
+#endif /* META_WINDOW_ACTOR_H */
--- a/src/include/mutter-window.h
+++ b/src/include/mutter-window.h
@@ -1,70 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright (C) 2008 Matthew Allum
- * 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 MUTTER_WINDOW_H_
-#define MUTTER_WINDOW_H_
-
-#include <clutter/clutter.h>
-#include <X11/Xlib.h>
-
-#include "compositor.h"
-
-/*
- * MutterWindow object (ClutterGroup sub-class)
- */
-#define MUTTER_TYPE_COMP_WINDOW       (mutter_window_get_type ())
-#define MUTTER_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_COMP_WINDOW, MutterWindow))
-#define MUTTER_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MUTTER_TYPE_COMP_WINDOW, MutterWindowClass))
-#define MUTTER_IS_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_COMP_WINDOW))
-#define MUTTER_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MUTTER_TYPE_COMP_WINDOW))
-#define MUTTER_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MUTTER_TYPE_COMP_WINDOW, MutterWindowClass))
-
-typedef struct _MutterWindow        MutterWindow;
-typedef struct _MutterWindowClass   MutterWindowClass;
-typedef struct _MutterWindowPrivate MutterWindowPrivate;
-
-struct _MutterWindowClass
-{
-  ClutterGroupClass parent_class;
-};
-
-struct _MutterWindow
-{
-  ClutterGroup           parent;
-
-  MutterWindowPrivate *priv;
-};
-
-GType mutter_window_get_type (void);
-
-Window             mutter_window_get_x_window         (MutterWindow *mcw);
-gint               mutter_window_get_workspace        (MutterWindow *mcw);
-gboolean           mutter_window_is_hidden            (MutterWindow *mcw);
-MetaWindow *       mutter_window_get_meta_window      (MutterWindow *mcw);
-ClutterActor *     mutter_window_get_texture          (MutterWindow *mcw);
-gboolean           mutter_window_is_override_redirect (MutterWindow *mcw);
-const char *       mutter_window_get_description      (MutterWindow *mcw);
-gboolean       mutter_window_showing_on_its_workspace (MutterWindow *mcw);
-
-#endif /* MUTTER_WINDOW_H */
--- a/src/include/prefs.h
+++ b/src/include/prefs.h
@@ -58,9 +58,8 @@ typedef enum
  META_PREF_GNOME_ANIMATIONS,
  META_PREF_CURSOR_THEME,
  META_PREF_CURSOR_SIZE,
-  META_PREF_COMPOSITING_MANAGER,
  META_PREF_RESIZE_WITH_RIGHT_BUTTON,
-  META_PREF_SIDE_BY_SIDE_TILING,
+  META_PREF_EDGE_TILING,
  META_PREF_FORCE_FULLSCREEN,
  META_PREF_CLUTTER_PLUGINS,
  META_PREF_LIVE_HIDDEN_WINDOWS,
@@ -99,7 +98,7 @@ gboolean                    meta_prefs_get_auto_raise         (void);
 int                         meta_prefs_get_auto_raise_delay   (void);
 gboolean                    meta_prefs_get_gnome_accessibility (void);
 gboolean                    meta_prefs_get_gnome_animations   (void);
-gboolean                    meta_prefs_get_side_by_side_tiling (void);
+gboolean                    meta_prefs_get_edge_tiling        (void);

 const char*                 meta_prefs_get_command            (int i);

@@ -195,9 +194,12 @@ typedef enum _MetaKeyBindingAction
  META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD,
  META_KEYBINDING_ACTION_CYCLE_PANELS,
  META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD,
+  META_KEYBINDING_ACTION_TAB_POPUP_SELECT,
+  META_KEYBINDING_ACTION_TAB_POPUP_CANCEL,
  META_KEYBINDING_ACTION_SHOW_DESKTOP,
  META_KEYBINDING_ACTION_PANEL_MAIN_MENU,
  META_KEYBINDING_ACTION_PANEL_RUN_DIALOG,
+  META_KEYBINDING_ACTION_TOGGLE_RECORDING,
  META_KEYBINDING_ACTION_COMMAND_1,
  META_KEYBINDING_ACTION_COMMAND_2,
  META_KEYBINDING_ACTION_COMMAND_3,
@@ -209,7 +211,75 @@ typedef enum _MetaKeyBindingAction
  META_KEYBINDING_ACTION_COMMAND_9,
  META_KEYBINDING_ACTION_COMMAND_10,
  META_KEYBINDING_ACTION_COMMAND_11,
-  META_KEYBINDING_ACTION_COMMAND_12
+  META_KEYBINDING_ACTION_COMMAND_12,
+  META_KEYBINDING_ACTION_COMMAND_13,
+  META_KEYBINDING_ACTION_COMMAND_14,
+  META_KEYBINDING_ACTION_COMMAND_15,
+  META_KEYBINDING_ACTION_COMMAND_16,
+  META_KEYBINDING_ACTION_COMMAND_17,
+  META_KEYBINDING_ACTION_COMMAND_18,
+  META_KEYBINDING_ACTION_COMMAND_19,
+  META_KEYBINDING_ACTION_COMMAND_20,
+  META_KEYBINDING_ACTION_COMMAND_21,
+  META_KEYBINDING_ACTION_COMMAND_22,
+  META_KEYBINDING_ACTION_COMMAND_23,
+  META_KEYBINDING_ACTION_COMMAND_24,
+  META_KEYBINDING_ACTION_COMMAND_25,
+  META_KEYBINDING_ACTION_COMMAND_26,
+  META_KEYBINDING_ACTION_COMMAND_27,
+  META_KEYBINDING_ACTION_COMMAND_28,
+  META_KEYBINDING_ACTION_COMMAND_29,
+  META_KEYBINDING_ACTION_COMMAND_30,
+  META_KEYBINDING_ACTION_COMMAND_31,
+  META_KEYBINDING_ACTION_COMMAND_32,
+  META_KEYBINDING_ACTION_COMMAND_SCREENSHOT,
+  META_KEYBINDING_ACTION_COMMAND_WINDOW_SCREENSHOT,
+  META_KEYBINDING_ACTION_COMMAND_TERMINAL,
+  META_KEYBINDING_ACTION_SET_SPEW_MARK,
+  META_KEYBINDING_ACTION_ACTIVATE_WINDOW_MENU,
+  META_KEYBINDING_ACTION_TOGGLE_FULLSCREEN,
+  META_KEYBINDING_ACTION_TOGGLE_MAXIMIZED,
+  META_KEYBINDING_ACTION_TOGGLE_ABOVE,
+  META_KEYBINDING_ACTION_MAXIMIZE,
+  META_KEYBINDING_ACTION_UNMAXIMIZE,
+  META_KEYBINDING_ACTION_TOGGLE_SHADED,
+  META_KEYBINDING_ACTION_MINIMIZE,
+  META_KEYBINDING_ACTION_CLOSE,
+  META_KEYBINDING_ACTION_BEGIN_MOVE,
+  META_KEYBINDING_ACTION_BEGIN_RESIZE,
+  META_KEYBINDING_ACTION_TOGGLE_ON_ALL_WORKSPACES,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_1,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_2,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_3,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_4,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_5,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_6,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_7,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_8,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_9,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_10,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_11,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_12,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_LEFT,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_RIGHT,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_UP,
+  META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_DOWN,
+  META_KEYBINDING_ACTION_RAISE_OR_LOWER,
+  META_KEYBINDING_ACTION_RAISE,
+  META_KEYBINDING_ACTION_LOWER,
+  META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY,
+  META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY,
+  META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW,
+  META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE,
+  META_KEYBINDING_ACTION_MOVE_TO_CORNER_SW,
+  META_KEYBINDING_ACTION_MOVE_TO_CORNER_SE,
+  META_KEYBINDING_ACTION_MOVE_TO_SIDE_N,
+  META_KEYBINDING_ACTION_MOVE_TO_SIDE_S,
+  META_KEYBINDING_ACTION_MOVE_TO_SIDE_E,
+  META_KEYBINDING_ACTION_MOVE_TO_SIDE_W,
+  META_KEYBINDING_ACTION_MOVE_TO_CENTER,
+
+  META_KEYBINDING_ACTION_LAST
 } MetaKeyBindingAction;

 typedef struct
--- a/src/include/region.h
+++ b/src/include/region.h
@@ -1,60 +0,0 @@
-#ifndef META_REGION_H
-#define META_REGION_H
-
-#ifndef PACKAGE_NAME
-#error "<config.h> must be included before region.h"
-#endif
-
-#include <gdk/gdk.h>
-
-#ifdef USE_CAIRO_REGION
-#include <cairo.h>
-
-#define MetaRegion    cairo_region_t
-
-typedef enum {
-  META_REGION_OVERLAP_IN   = CAIRO_REGION_OVERLAP_IN,
-  META_REGION_OVERLAP_OUT  = CAIRO_REGION_OVERLAP_OUT,
-  META_REGION_OVERLAP_PART = CAIRO_REGION_OVERLAP_PART
-} MetaOverlapType;
-
-#define meta_region_new()                    cairo_region_create()
-#define meta_region_new_from_rectangle(rect) cairo_region_create_rectangle(rect)
-#define meta_region_copy(r)                  cairo_region_copy(r)
-#define meta_region_destroy(r)               cairo_region_destroy(r)
-#define meta_region_is_empty(r)              cairo_region_is_empty(r)
-#define meta_region_union_rectangle(r, rect) cairo_region_union_rectangle(r, rect)
-#define meta_region_subtract(r, other)       cairo_region_subtract(r, other)
-#define meta_region_translate(r, x, y)       cairo_region_translate(r, x, y)
-#define meta_region_intersect(r, other)      cairo_region_intersect(r, other)
-#define meta_region_contains_rectangle(r, rect) cairo_region_contains_rectangle(r, rect)
-
-void     meta_region_get_rectangles      (MetaRegion    *region,
-                                          GdkRectangle **rectangles,
-                                          int           *n_rectangles);
-
-#else
-
-#define MetaRegion    GdkRegion
-
-typedef enum {
-  META_REGION_OVERLAP_IN   = GDK_OVERLAP_RECTANGLE_IN,
-  META_REGION_OVERLAP_OUT  = GDK_OVERLAP_RECTANGLE_OUT,
-  META_REGION_OVERLAP_PART = GDK_OVERLAP_RECTANGLE_PART
-} MetaOverlapType;
-
-#define meta_region_new()                    gdk_region_new()
-#define meta_region_new_from_rectangle(rect) gdk_region_rectangle(rect)
-#define meta_region_copy(r)                  gdk_region_copy(r)
-#define meta_region_destroy(r)               gdk_region_destroy(r)
-#define meta_region_is_empty(r)              gdk_region_empty(r)
-#define meta_region_union_rectangle(r, rect) gdk_region_union_with_rect(r, rect)
-#define meta_region_subtract(r, other)       gdk_region_subtract(r, other)
-#define meta_region_translate(r, x, y)       gdk_region_offset(r, x, y)
-#define meta_region_intersect(r, other)      gdk_region_intersect(r, other)
-#define meta_region_contains_rectangle(r, rect) gdk_region_rect_in(r, rect)
-#define meta_region_get_rectangles(r, rects, num) gdk_region_get_rectangles(r, rects, num)
-
-#endif /* HAVE_CAIRO_REGION */
-
-#endif /* META_REGION_H */
--- a/src/include/screen.h
+++ b/src/include/screen.h
@@ -80,4 +80,17 @@ void meta_screen_get_monitor_geometry (MetaScreen    *screen,
                                       int            monitor,
                                       MetaRectangle *geometry);

+typedef enum
+{
+  META_SCREEN_TOPLEFT,
+  META_SCREEN_TOPRIGHT,
+  META_SCREEN_BOTTOMLEFT,
+  META_SCREEN_BOTTOMRIGHT
+} MetaScreenCorner;
+
+void meta_screen_override_workspace_layout (MetaScreen      *screen,
+                                            MetaScreenCorner starting_corner,
+                                            gboolean         vertical_layout,
+                                            int              n_rows,
+                                            int              n_columns);
 #endif
--- a/Show More
+++ b/Show More