Bump version to 3.13.90

Update NEWS.
wayland: Initialize SHM again
2014-08-20 01:35:22 +02:00 · 2014-08-19 18:27:21 -04:00 · 2014-08-19 16:04:40 -04:00 · 2014-08-19 15:11:10 -04:00 · 2014-08-19 15:10:55 -04:00 · 2014-08-19 14:58:47 -04:00
150 changed files with 15498 additions and 15329 deletions
--- a/.cvsignore
+++ b/.cvsignore
@@ -1,35 +0,0 @@
-Makefile
-Makefile.in
-aclocal.m4
-confdefs.h
-config.cache
-config.guess
-config.h
-config.log
-config.status
-config.sub
-configure
-configure.scan
-libtool
-ltconfig
-ltmain.sh
-stamp-h
-stamp-h.in
-stamp-h1
-stamp.h
-version.h
-config.h.in
-install-sh
-missing
-mkinstalldirs
-INSTALL
-intl
-ABOUT-NLS
-COPYING
-intltool-*
-metacity.spec
-autom4te.cache
-compile
-depcomp
-omf.make
-xmldocs.make
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@ Makefile.in
 Makefile.in.in
 aclocal.m4
 autom4te.cache
+build-aux
 compile
 config.guess
 config.h
@@ -19,11 +20,11 @@ libtool
 ltmain.sh
 missing
 .deps
-src/50-mutter-navigation.xml
-src/50-mutter-system.xml
-src/50-mutter-windows.xml
-src/mutter.desktop
-src/mutter-wayland.desktop
+50-mutter-navigation.xml
+50-mutter-system.xml
+50-mutter-windows.xml
+mutter.desktop
+mutter-wayland.desktop
 *.o
 *.a
 *.lo
@@ -32,10 +33,6 @@ src/mutter-wayland.desktop
 *.swp
 *.gir
 *.typelib
-tidy-enum-types.[ch]
-tidy-marshal.[ch]
-stamp-tidy-enum-types.h
-stamp-tidy-marshal.h
 stamp-h1
 *.gmo
 *.make
@@ -44,10 +41,9 @@ stamp-it
 .intltool-merge-cache
 POTFILES
 po/*.pot
-50-metacity-desktop-key.xml
-50-metacity-key.xml
 libmutter.pc
 mutter
+mutter-restart-helper
 org.gnome.mutter.gschema.valid
 org.gnome.mutter.gschema.xml
 org.gnome.mutter.wayland.gschema.valid
@@ -56,19 +52,6 @@ testasyncgetprop
 testboxes
 testgradient
 m4/*
-mutter-grayscale
-mutter-mag
-mutter-message
-mutter-window-demo
-focus-window
-test-attached
-test-focus
-test-gravity
-test-resizing
-test-size-hints
-# We can't say just "wm-tester" here or it will ignore the directory
-# rather than the binary
-src/wm-tester/wm-tester
 INSTALL
 mkinstalldirs
 src/mutter-enum-types.[ch]
@@ -84,6 +67,7 @@ src/xdg-shell-protocol.c
 src/xdg-shell-server-protocol.h
 src/xserver-protocol.c
 src/xserver-server-protocol.h
+src/meta/meta-version.h
 doc/reference/*.args
 doc/reference/*.bak
 doc/reference/*.hierarchy
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,10 +1,13 @@

-SUBDIRS=src po doc
+SUBDIRS = data src po doc

 ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}

-DISTCLEANFILES = intltool-extract intltool-merge intltool-update po/stamp-it po/.intltool-merge-cache
+DISTCLEANFILES = \
+	intltool-extract \
+	intltool-merge \
+	intltool-update \
+	po/stamp-it \
+	po/.intltool-merge-cache

 DISTCHECK_CONFIGURE_FLAGS = --enable-gtk-doc
-
-ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
--- a/59
+++ b/59
@@ -1,3 +1,62 @@
+3.13.90
+=======
+* Only call XSync() once per frame [Rui; #728464]
+* Update capabilities on device list changes [Carlos; #733563]
+* Make use of GLSL optional [Adel; #733623]
+* Handle gestures and touch events on wayland [Carlos; #733631]
+* Add support for unminimize compositor effects [Cosimo; #733789]
+* Always set the frame background to None [Giovanni; #734054]
+* Add backend methods to handle keymaps [Rui; #734301]
+* Actually mark revalidated MetaTextureTower levels as valid [Owen; #734400]
+* Rely on explicit -backward switcher keybindings instead of <shift>-magic
+  [Christophe; #732295, #732385]
+* Misc. bug fixes and cleanups [Rui, Adel, Christophe; #727178, #734852,
+  #734960]
+
+Contributors:
+  Emmanuele Bassi, Giovanni Campagna, Cosimo Cecchi, Piotr Drąg,
+  Christophe Fergeau, Adel Gadllah, Carlos Garnacho, Rui Matos,
+  Florian Müllner, Jasper St. Pierre, Rico Tzschichholz, Olav Vitters,
+  Owen W. Taylor
+
+Translations:
+  Kjartan Maraas [nb], Inaki Larranaga Murgoitio [eu], Lasse Liehu [fi],
+  ngoswami [as], Daniel Mustieles [es]
+
+3.13.4
+======
+* Fix move/resize operations for wayland clients [Marek; #731237]
+* Add ::first-frame signal to MetaWindowActor [Owen; #732343]
+* Handle keysyms without the XF86 prefix [Owen; #727993]
+* Add touch gesture support [Carlos]
+* Fix a deadlock when exiting [Owen; #733068]
+* Add framework for restarting the compositor with nice visuals
+  [Owen; #733026]
+* Toggle seat capabilities on VT switch [Carlos; #733563]
+* Misc bug fixes [Florian, Owen; #732695, #732350]
+
+Contributors:
+  Tom Beckmann, Giovanni Campagna, Marek Chalupa, Adel Gadllah,
+  Carlos Garnacho, Florian Müllner, Jasper St. Pierre, Rico Tzschichholz,
+  Owen W. Taylor
+
+Translations:
+  Yuri Myasoedov [ru], Fran Diéguez [gl], Aurimas Černius [lt], MarMav [el],
+  Enrico Nicoletto [pt_BR]
+
+3.13.3
+======
+* Improve behavior of window buttons with compositor menus [Florian; #731058]
+* Implement touch support on wayland [Carlos; #724442]
+* Update window shadows [Nikita; #731866]
+* Keep windows on the preferred output [Florian; #731760]
+* Misc bug fixes [Jonas, Florian, Jasper; #729601, #730681, #731353, #731332,
+  #730527, #662962]
+
+Contributors:
+  Jonas Ådahl, Nikita Churaev, Carlos Garnacho, Florian Müllner,
+  Jasper St. Pierre, Rico Tzschichholz
+
 3.13.2
 ======
 * Add basic HiDPI support on wayland [Adel; #728902]
--- a/autogen.sh
+++ b/autogen.sh
@@ -5,7 +5,7 @@ srcdir=`dirname $0`
 test -z "$srcdir" && srcdir=.

 PKG_NAME="mutter"
-REQUIRED_AUTOMAKE_VERSION=1.10
+REQUIRED_AUTOMAKE_VERSION=1.11

 (test -f $srcdir/configure.ac \
  && test -d $srcdir/src) || {
--- a/configure.ac
+++ b/configure.ac
@@ -1,9 +1,8 @@
-AC_PREREQ(2.50)
-AC_CONFIG_MACRO_DIR([m4])
+AC_PREREQ(2.62)

 m4_define([mutter_major_version], [3])
 m4_define([mutter_minor_version], [13])
-m4_define([mutter_micro_version], [2])
+m4_define([mutter_micro_version], [90])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -14,6 +13,7 @@ AC_INIT([mutter], [mutter_version],
        [http://bugzilla.gnome.org/enter_bug.cgi?product=mutter])

 AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([build-aux])
 AC_CONFIG_SRCDIR(src/core/display.c)
 AC_CONFIG_HEADERS(config.h)

@@ -40,12 +40,14 @@ GETTEXT_PACKAGE=mutter
 AC_SUBST(GETTEXT_PACKAGE)
 AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE",[Name of default gettext domain])

-IT_PROG_INTLTOOL([0.34.90])
+LT_PREREQ([2.2.6])
+LT_INIT([disable-static])
+IT_PROG_INTLTOOL([0.41])
 AC_PROG_CC
-AC_ISC_POSIX
+AC_PROG_CC_C_O
+AC_PROG_INSTALL
 AC_HEADER_STDC
-AC_LIBTOOL_WIN32_DLL
-AM_PROG_LIBTOOL
+PKG_PROG_PKG_CONFIG([0.21])

 # Sets GLIB_GENMARSHAL and GLIB_MKENUMS
 AM_PATH_GLIB_2_0()
@@ -70,15 +72,22 @@ CLUTTER_PACKAGE=clutter-1.0

 MUTTER_PC_MODULES="
   gtk+-3.0 >= 3.9.11
-   gio-2.0 >= 2.25.10
+   gio-unix-2.0 >= 2.25.10
   pango >= 1.2.0
   cairo >= 1.10.0
   gsettings-desktop-schemas >= 3.7.3
   xcomposite >= 0.2 xfixes xext xdamage xi >= 1.6.0
-   $CLUTTER_PACKAGE >= 1.17.5
+   xcursor
+   $CLUTTER_PACKAGE >= 1.19.5
+   clutter-egl-1.0
   cogl-1.0 >= 1.17.1
+   libinput
   upower-glib >= 0.99.0
   gnome-desktop-3.0
+   xkbfile
+   xkeyboard-config
+   xkbcommon-x11
+   xcb-randr
 "

 GLIB_GSETTINGS
@@ -107,26 +116,12 @@ AC_ARG_WITH(libcanberra,
                 [disable the use of libcanberra for playing sounds]),,
  with_libcanberra=auto)

-AC_ARG_ENABLE(xsync,
-  AC_HELP_STRING([--disable-xsync],
-                 [disable mutter's use of the XSync extension]),,
-  enable_xsync=auto)
-
-AC_ARG_ENABLE(shape,
-  AC_HELP_STRING([--disable-shape],
-                 [disable mutter's use of the shaped window extension]),,
-  enable_shape=auto)
-
 AC_ARG_WITH([xwayland-path],
            [AS_HELP_STRING([--with-xwayland-path], [Absolute path for an X Wayland server])],
            [XWAYLAND_PATH="$withval"],
            [XWAYLAND_PATH="$bindir/Xwayland"])

-AM_GLIB_GNU_GETTEXT
-
 ## here we get the flags we'll actually use
-# GRegex requires Glib-2.14.0
-PKG_CHECK_MODULES(ALL, glib-2.0 >= 2.14.0)

 # Unconditionally use this dir to avoid a circular dep with gnomecc
 GNOME_KEYBINDINGS_KEYSDIR="${datadir}/gnome-control-center/keybindings"
@@ -191,15 +186,12 @@ if test x$found_introspection != xno; then
  AC_SUBST(META_GIR)
 fi

-MUTTER_PC_MODULES="$MUTTER_PC_MODULES xcursor"
-
 AC_PATH_PROG([WAYLAND_SCANNER],[wayland-scanner],[no])
 AS_IF([test "x$WAYLAND_SCANNER" = "xno"],
  AC_MSG_ERROR([Could not find wayland-scanner in your PATH, required for parsing wayland extension protocols]))
 AC_SUBST([WAYLAND_SCANNER])
 AC_SUBST(XWAYLAND_PATH)

-MUTTER_PC_MODULES="$MUTTER_PC_MODULES clutter-wayland-1.0 clutter-wayland-compositor-1.0 clutter-egl-1.0 wayland-server >= 1.4.93"
 PKG_CHECK_MODULES(MUTTER, $MUTTER_PC_MODULES)

 PKG_CHECK_MODULES(MUTTER_NATIVE_BACKEND, [libdrm libsystemd], [have_native_backend=yes], [have_native_backend=no])
@@ -208,6 +200,12 @@ if test $have_native_backend = yes; then
 fi
 AM_CONDITIONAL([HAVE_NATIVE_BACKEND],[test $have_native_backend = yes])

+PKG_CHECK_MODULES(MUTTER_WAYLAND, [clutter-wayland-1.0 clutter-wayland-compositor-1.0 wayland-server >= 1.5.90], [have_wayland=yes], [have_wayland=no])
+if test $have_wayland = yes; then
+   AC_DEFINE([HAVE_WAYLAND],[1],[Define if you want to enable Wayland support])
+fi
+AM_CONDITIONAL([HAVE_WAYLAND],[test $have_wayland = yes])
+
 PKG_CHECK_EXISTS([xi >= 1.6.99.1],
                 AC_DEFINE([HAVE_XI23],[1],[Define if you have support for XInput 2.3 or greater]))

@@ -244,16 +242,8 @@ if test x$have_xinerama = xno; then
   AC_MSG_ERROR([Xinerama extension was not found])
 fi

-found_xkb=no
-AC_CHECK_LIB(X11, XkbQueryExtension,
-               [AC_CHECK_HEADER(X11/XKBlib.h,
-                                found_xkb=yes)],
-	, $ALL_X_LIBS)
-
-if test "x$found_xkb" = "xyes"; then
-   AC_DEFINE(HAVE_XKB, , [Have keyboard extension library])
-fi
-
+AC_DEFINE_UNQUOTED([XKB_BASE], ["`$PKG_CONFIG --variable xkb_base xkeyboard-config`"],
+                               [XKB base dir])

 RANDR_LIBS=
 found_randr=no
@@ -299,17 +289,6 @@ fi

 AM_CONDITIONAL(HAVE_SM, test "$found_sm" = "yes")

-HOST_ALIAS=$host_alias
-AC_SUBST(HOST_ALIAS)
-
-AC_PATH_PROG(GDK_PIXBUF_CSOURCE, gdk-pixbuf-csource, no)
-
-if test x"$GDK_PIXBUF_CSOURCE" = xno; then
-  AC_MSG_ERROR([gdk-pixbuf-csource executable not found in your path - should be installed with GTK])
-fi
-
-AC_SUBST(GDK_PIXBUF_CSOURCE)
-
 AC_PATH_PROG(ZENITY, zenity, no)
 if test x"$ZENITY" = xno; then
  AC_MSG_ERROR([zenity not found in your path - needed for dialogs])
@@ -392,6 +371,7 @@ changequote([,])dnl

 AC_CONFIG_FILES([
 Makefile
+data/Makefile
 doc/Makefile
 doc/man/Makefile
 doc/reference/Makefile
@@ -399,6 +379,7 @@ doc/reference/meta-docs.sgml
 src/Makefile
 src/libmutter.pc
 src/compositor/plugins/Makefile
+src/meta/meta-version.h
 po/Makefile.in
 ])

--- a/data/50-mutter-navigation.xml.in
+++ b/data/50-mutter-navigation.xml.in
@@ -45,26 +45,68 @@
 	              _description="Move window one monitor down" />

 	<KeyListEntry name="switch-applications"
+	              reverse-entry="switch-applications-backward"
 	              _description="Switch applications"/>

+	<KeyListEntry name="switch-applications-backward"
+	              reverse-entry="switch-applications"
+	              hidden="true"
+	              _description="Switch to previous application"/>
+
 	<KeyListEntry name="switch-windows"
+	              reverse-entry="switch-windows-backward"
 	              _description="Switch windows"/>

+	<KeyListEntry name="switch-windows-backward"
+	              reverse-entry="switch-windows"
+	              hidden="true"
+	              _description="Switch to previous window"/>
+
 	<KeyListEntry name="switch-group"
+	              reverse-entry="switch-group-backward"
 	              _description="Switch windows of an application"/>

+	<KeyListEntry name="switch-group-backward"
+	              reverse-entry="switch-group"
+	              hidden="true"
+	              _description="Switch to previous window of an application"/>
+
 	<KeyListEntry name="switch-panels"
+	              reverse-entry="switch-panels-backward"
 	              _description="Switch system controls"/>

+	<KeyListEntry name="switch-panels-backward"
+	              reverse-entry="switch-panels"
+	              hidden="true"
+	              _description="Switch to previous system control"/>
+
 	<KeyListEntry name="cycle-windows"
+	              reverse-entry="cycle-windows-backward"
 	              _description="Switch windows directly"/>

+	<KeyListEntry name="cycle-windows-backward"
+	              reverse-entry="cycle-windows"
+	              hidden="true"
+	              _description="Switch directly to previous window"/>
+
 	<KeyListEntry name="cycle-group"
+	              reverse-entry="cycle-group-backward"
 	              _description="Switch windows of an app directly"/>

+	<KeyListEntry name="cycle-group-backward"
+	              reverse-entry="cycle-group"
+	              hidden="true"
+	              _description="Switch directly to previous window of an app"/>
+
 	<KeyListEntry name="cycle-panels"
+	              reverse-entry="cycle-panels-backward"
 	              _description="Switch system controls directly"/>

+	<KeyListEntry name="cycle-panels-backward"
+	              reverse-entry="cycle-panels"
+	              hidden="true"
+	              _description="Switch directly to previous system control"/>
+
 	<KeyListEntry name="show-desktop"
 	              _description="Hide all normal windows"/>

--- a/data/50-mutter-system.xml.in
+++ b/data/50-mutter-system.xml.in
--- a/data/50-mutter-windows.xml.in
+++ b/data/50-mutter-windows.xml.in
--- a/data/Makefile.am
+++ b/data/Makefile.am
@@ -1,3 +1,36 @@
-defaultcursordir = $(datadir)/mutter/cursors
+desktopfiles_in_files = \
+	mutter.desktop.in \
+	mutter-wayland.desktop.in
+desktopfilesdir = $(datadir)/applications
+desktopfiles_DATA = $(desktopfiles_in_files:.desktop.in=.desktop)

-dist_defaultcursor_DATA = left_ptr.png
+@INTLTOOL_DESKTOP_RULE@
+
+xml_in_files = \
+        50-mutter-navigation.xml.in \
+        50-mutter-system.xml.in \
+        50-mutter-windows.xml.in
+xmldir = $(GNOME_KEYBINDINGS_KEYSDIR)
+xml_DATA = $(xml_in_files:.xml.in=.xml)
+
+gschema_in_files = \
+	org.gnome.mutter.gschema.xml.in	\
+	org.gnome.mutter.wayland.gschema.xml.in
+gsettings_SCHEMAS = $(gschema_in_files:.xml.in=.xml)
+
+@INTLTOOL_XML_NOMERGE_RULE@
+@GSETTINGS_RULES@
+
+convertdir = $(datadir)/GConf/gsettings
+convert_DATA = mutter-schemas.convert
+
+CLEANFILES = \
+	$(desktopfiles_DATA) \
+	$(gsettings_SCHEMAS) \
+	$(xml_DATA)
+
+EXTRA_DIST = \
+	$(convert_DATA) \
+	$(desktopfiles_in_files) \
+	$(gschema_in_files) \
+	$(xml_in_files)
--- a/data/default_icon.png
+++ b/data/default_icon.png
--- a/data/mutter-schemas.convert
+++ b/data/mutter-schemas.convert
--- a/data/mutter-wayland.desktop.in
+++ b/data/mutter-wayland.desktop.in
--- a/data/mutter.desktop.in
+++ b/data/mutter.desktop.in
--- a/data/org.gnome.mutter.gschema.xml.in
+++ b/data/org.gnome.mutter.gschema.xml.in
--- a/data/org.gnome.mutter.wayland.gschema.xml.in
+++ b/data/org.gnome.mutter.wayland.gschema.xml.in
--- a/doc/reference/meta-sections.txt
+++ b/doc/reference/meta-sections.txt
@@ -300,6 +300,7 @@ MetaPluginVersion
 META_PLUGIN_DECLARE
 meta_plugin_switch_workspace_completed
 meta_plugin_minimize_completed
+meta_plugin_unminimize_completed
 meta_plugin_maximize_completed
 meta_plugin_unmaximize_completed
 meta_plugin_map_completed
@@ -555,7 +556,7 @@ meta_window_is_monitor_sized
 meta_window_is_override_redirect
 meta_window_is_skip_taskbar
 meta_window_get_rect
-meta_window_get_input_rect
+meta_window_get_buffer_rect
 meta_window_get_frame_rect
 meta_window_get_outer_rect
 meta_window_client_rect_to_frame_rect
--- a/mutter.doap
+++ b/mutter.doap
@@ -23,7 +23,8 @@ environment.</description>
  <download-page rdf:resource="http://download.gnome.org/sources/mutter/" />
  <bug-database rdf:resource="http://bugzilla.gnome.org/browse.cgi?product=mutter" />

-  <category rdf:resource="http://api.gnome.org/doap-extensions#desktop" />
+  <category rdf:resource="http://api.gnome.org/doap-extensions#core" />
+  <programming-language>C</programming-language>

  <maintainer>
    <foaf:Person>
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -1,8 +1,11 @@
 # List of source files containing translatable strings.
 # Please keep this file sorted alphabetically.
-src/50-mutter-navigation.xml.in
-src/50-mutter-system.xml.in
-src/50-mutter-windows.xml.in
+data/50-mutter-navigation.xml.in
+data/50-mutter-system.xml.in
+data/50-mutter-windows.xml.in
+data/mutter.desktop.in
+data/org.gnome.mutter.gschema.xml.in
+data/org.gnome.mutter.wayland.gschema.xml.in
 src/backends/meta-monitor-manager.c
 src/compositor/compositor.c
 src/compositor/meta-background.c
@@ -18,9 +21,6 @@ src/core/prefs.c
 src/core/screen.c
 src/core/util.c
 src/core/window.c
-src/mutter.desktop.in
-src/org.gnome.mutter.gschema.xml.in
-src/org.gnome.mutter.wayland.gschema.xml.in
 src/ui/frames.c
 src/ui/resizepopup.c
 src/ui/theme.c
--- a/po/POTFILES.skip
+++ b/po/POTFILES.skip
@@ -1,2 +1 @@
-src/metacity.schemas.in
-src/mutter-wayland.desktop.in
+data/mutter-wayland.desktop.in
--- a/po/as.po
+++ b/po/as.po
--- a/po/el.po
+++ b/po/el.po
--- a/po/es.po
+++ b/po/es.po
--- a/po/eu.po
+++ b/po/eu.po
--- a/po/fi.po
+++ b/po/fi.po
--- a/po/gl.po
+++ b/po/gl.po
--- a/po/lt.po
+++ b/po/lt.po
--- a/po/nb.po
+++ b/po/nb.po
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
--- a/po/ru.po
+++ b/po/ru.po
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -5,33 +5,31 @@ lib_LTLIBRARIES = libmutter.la

 SUBDIRS=compositor/plugins

-INCLUDES=								\
+AM_CPPFLAGS = \
 	-DCLUTTER_ENABLE_COMPOSITOR_API					\
 	-DCLUTTER_ENABLE_EXPERIMENTAL_API				\
 	-DCOGL_ENABLE_EXPERIMENTAL_API					\
 	-DCOGL_ENABLE_EXPERIMENTAL_2_0_API                              \
+	-DCLUTTER_DISABLE_DEPRECATION_WARNINGS				\
+	-DCOGL_DISABLE_DEPRECATION_WARNINGS				\
 	$(MUTTER_CFLAGS)						\
 	$(MUTTER_NATIVE_BACKEND_CFLAGS)					\
+	-I$(builddir)							\
 	-I$(srcdir)							\
 	-I$(srcdir)/backends						\
 	-I$(srcdir)/core						\
 	-I$(srcdir)/ui							\
 	-I$(srcdir)/compositor						\
 	-DMUTTER_LIBEXECDIR=\"$(libexecdir)\"				\
-	-DHOST_ALIAS=\"@HOST_ALIAS@\"					\
-	-DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\"		\
+	-DMUTTER_LOCALEDIR=\"$(localedir)\"				\
 	-DMUTTER_PKGDATADIR=\"$(pkgdatadir)\"				\
 	-DMUTTER_DATADIR=\"$(datadir)\"					\
 	-DG_LOG_DOMAIN=\"mutter\"					\
 	-DSN_API_NOT_YET_FROZEN=1					\
-	-DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION)			\
-	-DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION)			\
-	-DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION)			\
-	-DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION)	\
 	-DMUTTER_PKGLIBDIR=\"$(pkglibdir)\"				\
-	-DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"			\
+	-DMUTTER_PLUGIN_DIR=\"$(MUTTER_PLUGIN_DIR)\"			\
 	-DGETTEXT_PACKAGE=\"$(GETTEXT_PACKAGE)\"			\
-	-DXWAYLAND_PATH='"@XWAYLAND_PATH@"'
+	-DXWAYLAND_PATH=\"$(XWAYLAND_PATH)\"

 mutter_built_sources = \
 	$(dbus_idle_built_sources)		\
@@ -50,7 +48,7 @@ wayland_protocols = \

 libmutter_la_SOURCES =				\
 	backends/meta-backend.c			\
-	backends/meta-backend.h			\
+	meta/meta-backend.h			\
 	backends/meta-backend-private.h		\
 	backends/meta-cursor.c			\
 	backends/meta-cursor.h			\
@@ -70,6 +68,8 @@ libmutter_la_SOURCES =				\
 	backends/meta-monitor-manager.h		\
 	backends/meta-monitor-manager-dummy.c	\
 	backends/meta-monitor-manager-dummy.h	\
+	backends/meta-stage.h			\
+	backends/meta-stage.c			\
 	backends/edid-parse.c			\
 	backends/edid.h				\
 	backends/x11/meta-backend-x11.c			\
@@ -114,10 +114,6 @@ libmutter_la_SOURCES =				\
 	compositor/meta-surface-actor.h		\
 	compositor/meta-surface-actor-x11.c	\
 	compositor/meta-surface-actor-x11.h	\
-	compositor/meta-surface-actor-wayland.c	\
-	compositor/meta-surface-actor-wayland.h	\
-	compositor/meta-stage.h			\
-	compositor/meta-stage.c			\
 	compositor/meta-texture-rectangle.c	\
 	compositor/meta-texture-rectangle.h	\
 	compositor/meta-texture-tower.c		\
@@ -155,6 +151,8 @@ libmutter_la_SOURCES =				\
 	core/frame.h				\
 	ui/gradient.c				\
 	meta/gradient.h				\
+	core/meta-gesture-tracker.c		\
+	core/meta-gesture-tracker-private.h	\
 	core/keybindings.c			\
 	core/keybindings-private.h		\
 	core/main.c				\
@@ -166,6 +164,7 @@ libmutter_la_SOURCES =				\
 	core/screen-private.h			\
 	meta/screen.h				\
 	meta/types.h				\
+	core/restart.c				\
 	core/stack.c				\
 	core/stack.h				\
 	core/stack-tracker.c			\
@@ -194,6 +193,8 @@ libmutter_la_SOURCES =				\
 	x11/iconcache.h				\
 	x11/async-getprop.c			\
 	x11/async-getprop.h			\
+	x11/events.c				\
+	x11/events.h				\
 	x11/group-private.h			\
 	x11/group-props.c			\
 	x11/group-props.h			\
@@ -208,7 +209,12 @@ libmutter_la_SOURCES =				\
 	x11/window-x11-private.h		\
 	x11/xprops.c				\
 	x11/xprops.h				\
-	x11/mutter-Xatomtype.h			\
+	x11/mutter-Xatomtype.h
+
+if HAVE_WAYLAND
+libmutter_la_SOURCES +=				\
+	compositor/meta-surface-actor-wayland.c	\
+	compositor/meta-surface-actor-wayland.h	\
 	wayland/meta-wayland.c			\
 	wayland/meta-wayland.h			\
 	wayland/meta-wayland-private.h		\
@@ -223,6 +229,8 @@ libmutter_la_SOURCES =				\
 	wayland/meta-wayland-pointer.h		\
 	wayland/meta-wayland-seat.c		\
 	wayland/meta-wayland-seat.h		\
+	wayland/meta-wayland-touch.c		\
+	wayland/meta-wayland-touch.h		\
 	wayland/meta-wayland-surface.c		\
 	wayland/meta-wayland-surface.h		\
 	wayland/meta-wayland-types.h		\
@@ -231,6 +239,7 @@ libmutter_la_SOURCES =				\
 	wayland/meta-wayland-outputs.h		\
 	wayland/window-wayland.c		\
 	wayland/window-wayland.h
+endif

 if HAVE_NATIVE_BACKEND
 libmutter_la_SOURCES +=					\
@@ -256,7 +265,7 @@ libmutter_la_LIBADD  = $(MUTTER_LIBS) $(MUTTER_NATIVE_BACKEND_LIBS)

 # Headers installed for plugins; introspected information will
 # be extracted into Mutter-<version>.gir
-libmutterinclude_base_headers =		\
+libmutterinclude_headers =			\
 	meta/barrier.h				\
 	meta/boxes.h				\
 	meta/common.h				\
@@ -268,6 +277,7 @@ libmutterinclude_base_headers =		\
 	meta/group.h				\
 	meta/keybindings.h			\
 	meta/main.h				\
+	meta/meta-backend.h			\
 	meta/meta-background-actor.h		\
 	meta/meta-background-group.h		\
 	meta/meta-background.h			\
@@ -285,6 +295,13 @@ libmutterinclude_base_headers =		\
 	meta/window.h				\
 	meta/workspace.h

+libmutterinclude_built_headers =		\
+	meta/meta-version.h
+
+libmutterinclude_base_headers =			\
+	$(libmutterinclude_headers)		\
+	$(libmutterinclude_built_headers)
+
 # Excluded from scanning for introspection but installed
 # atomnames.h: macros cause problems for scanning process
 libmutterinclude_extra_headers =		\
@@ -293,14 +310,21 @@ libmutterinclude_extra_headers =		\
 libmutterincludedir = $(includedir)/mutter/meta

 libmutterinclude_HEADERS =			\
-	$(libmutterinclude_base_headers)	\
+	$(libmutterinclude_headers)		\
 	$(libmutterinclude_extra_headers)

+nodist_libmutterinclude_HEADERS =		\
+	$(libmutterinclude_built_headers)
+
 bin_PROGRAMS=mutter

 mutter_SOURCES = core/mutter.c
 mutter_LDADD = $(MUTTER_LIBS) libmutter.la

+libexec_PROGRAMS = mutter-restart-helper
+mutter_restart_helper_SOURCES = core/restart-helper.c
+mutter_restart_helper_LDADD = $(MUTTER_LIBS)
+
 if HAVE_INTROSPECTION
 include $(INTROSPECTION_MAKEFILE)

@@ -324,7 +348,7 @@ INTROSPECTION_GIRS = Meta-$(api_version).gir
 Meta-$(api_version).gir: libmutter.la
@META_GIR@_INCLUDES = GObject-2.0 GDesktopEnums-3.0 Gdk-3.0 Gtk-3.0 Clutter-1.0 xlib-2.0 xfixes-4.0 Cogl-1.0
@META_GIR@_EXPORT_PACKAGES = libmutter
-@META_GIR@_CFLAGS = $(INCLUDES)
+@META_GIR@_CFLAGS = $(AM_CPPFLAGS)
@META_GIR@_LIBS = libmutter.la
@META_GIR@_FILES =				\
 	mutter-enum-types.h			\
@@ -344,53 +368,21 @@ testboxes_LDADD = $(MUTTER_LIBS) libmutter.la
 testgradient_LDADD = $(MUTTER_LIBS) libmutter.la
 testasyncgetprop_LDADD = $(MUTTER_LIBS) libmutter.la

-@INTLTOOL_DESKTOP_RULE@
-
-desktopfilesdir=$(datadir)/applications
-desktopfiles_in_files=mutter.desktop.in
-desktopfiles_files=$(desktopfiles_in_files:.desktop.in=.desktop)
-desktopfiles_DATA = $(desktopfiles_files)
-
-xmldir       = @GNOME_KEYBINDINGS_KEYSDIR@
-xml_in_files = \
-        50-mutter-navigation.xml.in	\
-        50-mutter-system.xml.in		\
-        50-mutter-windows.xml.in
-xml_DATA     = $(xml_in_files:.xml.in=.xml)
-
 dbus_idle_built_sources = meta-dbus-idle-monitor.c meta-dbus-idle-monitor.h

-gsettings_SCHEMAS = org.gnome.mutter.gschema.xml org.gnome.mutter.wayland.gschema.xml
-@INTLTOOL_XML_NOMERGE_RULE@
-@GSETTINGS_RULES@
-
-convertdir = $(datadir)/GConf/gsettings
-convert_DATA = mutter-schemas.convert
-
 CLEANFILES =					\
-	mutter.desktop				\
-	mutter-wm.desktop			\
-	org.gnome.mutter.gschema.xml		\
-	org.gnome.mutter.wayland.gschema.xml	\
-	$(xml_DATA)				\
 	$(mutter_built_sources)			\
 	$(typelib_DATA)				\
 	$(gir_DATA)

-pkgconfigdir = $(libdir)/pkgconfig
+DISTCLEANFILES = 				\
+	$(libmutterinclude_built_headers)

+pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = libmutter.pc

-EXTRA_DIST=$(desktopfiles_files) 	\
-	$(wmproperties_files)		\
-	$(IMAGES) 			\
-	$(desktopfiles_in_files)	\
-	$(wmproperties_in_files)	\
-	$(xml_in_files)			\
+EXTRA_DIST =				\
 	$(wayland_protocols)		\
-	org.gnome.mutter.gschema.xml.in \
-	org.gnome.mutter.wayland.gschema.xml.in \
-	mutter-schemas.convert \
 	libmutter.pc.in \
 	mutter-enum-types.h.in \
 	mutter-enum-types.c.in \
@@ -398,7 +390,10 @@ EXTRA_DIST=$(desktopfiles_files) 	\
 	org.gnome.Mutter.DisplayConfig.xml	\
 	org.gnome.Mutter.IdleMonitor.xml

-BUILT_SOURCES = $(mutter_built_sources)
+BUILT_SOURCES =					\
+	$(mutter_built_sources)			\
+	$(libmutterinclude_built_headers)
+
 MUTTER_STAMP_FILES = stamp-mutter-enum-types.h
 CLEANFILES += $(MUTTER_STAMP_FILES)

--- a/src/backends/meta-backend-private.h
+++ b/src/backends/meta-backend-private.h
@@ -28,7 +28,15 @@

 #include <glib-object.h>

-#include "meta-backend.h"
+#include <xkbcommon/xkbcommon.h>
+
+#include <meta/meta-backend.h>
+#include <meta/meta-idle-monitor.h>
+#include "meta-cursor-renderer.h"
+#include "meta-monitor-manager.h"
+
+#define DEFAULT_XKB_RULES_FILE "evdev"
+#define DEFAULT_XKB_MODEL "pc105+inet"

 #define META_TYPE_BACKEND             (meta_backend_get_type ())
 #define META_BACKEND(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_BACKEND, MetaBackend))
@@ -66,6 +74,37 @@ struct _MetaBackendClass
  void (* warp_pointer) (MetaBackend *backend,
                         int          x,
                         int          y);
+
+  void (* set_keymap) (MetaBackend *backend,
+                       const char  *layouts,
+                       const char  *variants,
+                       const char  *options);
+
+  struct xkb_keymap * (* get_keymap) (MetaBackend *backend);
+
+  void (* lock_layout_group) (MetaBackend *backend,
+                              guint        idx);
+
+  void (* update_screen_size) (MetaBackend *backend, int width, int height);
+  void (* select_stage_events) (MetaBackend *backend);
 };

+MetaIdleMonitor * meta_backend_get_idle_monitor (MetaBackend *backend,
+                                                 int          device_id);
+MetaMonitorManager * meta_backend_get_monitor_manager (MetaBackend *backend);
+MetaCursorRenderer * meta_backend_get_cursor_renderer (MetaBackend *backend);
+
+gboolean meta_backend_grab_device (MetaBackend *backend,
+                                   int          device_id,
+                                   uint32_t     timestamp);
+gboolean meta_backend_ungrab_device (MetaBackend *backend,
+                                     int          device_id,
+                                     uint32_t     timestamp);
+
+void meta_backend_warp_pointer (MetaBackend *backend,
+                                int          x,
+                                int          y);
+
+struct xkb_keymap * meta_backend_get_keymap (MetaBackend *backend);
+
 #endif /* META_BACKEND_PRIVATE_H */
--- a/src/backends/meta-backend.c
+++ b/src/backends/meta-backend.c
@@ -24,12 +24,11 @@

 #include "config.h"

-#include "meta-backend.h"
+#include <meta/meta-backend.h>
 #include "meta-backend-private.h"

-#include <clutter/clutter.h>
-
 #include "backends/x11/meta-backend-x11.h"
+#include "meta-stage.h"

 #ifdef HAVE_NATIVE_BACKEND
 #include "backends/native/meta-backend-native.h"
@@ -37,6 +36,13 @@

 static MetaBackend *_backend;

+/**
+ * meta_get_backend:
+ *
+ * Accessor for the singleton MetaBackend.
+ *
+ * Returns: (transfer none): The only #MetaBackend there is.
+ */
 MetaBackend *
 meta_get_backend (void)
 {
@@ -47,6 +53,8 @@ struct _MetaBackendPrivate
 {
  MetaMonitorManager *monitor_manager;
  MetaCursorRenderer *cursor_renderer;
+
+  ClutterActor *stage;
 };
 typedef struct _MetaBackendPrivate MetaBackendPrivate;

@@ -70,12 +78,40 @@ meta_backend_finalize (GObject *object)
  G_OBJECT_CLASS (meta_backend_parent_class)->finalize (object);
 }

+static void
+meta_backend_sync_screen_size (MetaBackend *backend)
+{
+  MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
+  int width, height;
+
+  meta_monitor_manager_get_screen_size (priv->monitor_manager, &width, &height);
+
+  META_BACKEND_GET_CLASS (backend)->update_screen_size (backend, width, height);
+}
+
+static void
+on_monitors_changed (MetaMonitorManager *monitors,
+                     gpointer user_data)
+{
+  MetaBackend *backend = META_BACKEND (user_data);
+  meta_backend_sync_screen_size (backend);
+}
+
 static void
 meta_backend_real_post_init (MetaBackend *backend)
 {
  MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);

+  priv->stage = meta_stage_new ();
+  clutter_actor_realize (priv->stage);
+  META_BACKEND_GET_CLASS (backend)->select_stage_events (backend);
+
  priv->monitor_manager = META_BACKEND_GET_CLASS (backend)->create_monitor_manager (backend);
+
+  g_signal_connect (priv->monitor_manager, "monitors-changed",
+                    G_CALLBACK (on_monitors_changed), backend);
+  meta_backend_sync_screen_size (backend);
+
  priv->cursor_renderer = META_BACKEND_GET_CLASS (backend)->create_cursor_renderer (backend);
 }

@@ -104,9 +140,16 @@ meta_backend_real_ungrab_device (MetaBackend *backend,
 }

 static void
-meta_backend_real_warp_pointer (MetaBackend *backend,
-                                int          x,
-                                int          y)
+meta_backend_real_update_screen_size (MetaBackend *backend,
+                                      int width, int height)
+{
+  MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
+
+  clutter_actor_set_size (priv->stage, width, height);
+}
+
+static void
+meta_backend_real_select_stage_events (MetaBackend *backend)
 {
  /* Do nothing */
 }
@@ -122,7 +165,15 @@ meta_backend_class_init (MetaBackendClass *klass)
  klass->create_cursor_renderer = meta_backend_real_create_cursor_renderer;
  klass->grab_device = meta_backend_real_grab_device;
  klass->ungrab_device = meta_backend_real_ungrab_device;
-  klass->warp_pointer = meta_backend_real_warp_pointer;
+  klass->update_screen_size = meta_backend_real_update_screen_size;
+  klass->select_stage_events = meta_backend_real_select_stage_events;
+
+  g_signal_new ("keymap-changed",
+                G_TYPE_FROM_CLASS (object_class),
+                G_SIGNAL_RUN_LAST,
+                0,
+                NULL, NULL, NULL,
+                G_TYPE_NONE, 0);
 }

 static void
@@ -154,6 +205,9 @@ meta_backend_post_init (MetaBackend *backend)
  META_BACKEND_GET_CLASS (backend)->post_init (backend);
 }

+/**
+ * meta_backend_get_idle_monitor: (skip)
+ */
 MetaIdleMonitor *
 meta_backend_get_idle_monitor (MetaBackend *backend,
                               int          device_id)
@@ -169,6 +223,9 @@ meta_backend_get_idle_monitor (MetaBackend *backend,
  return backend->device_monitors[device_id];
 }

+/**
+ * meta_backend_get_monitor_manager: (skip)
+ */
 MetaMonitorManager *
 meta_backend_get_monitor_manager (MetaBackend *backend)
 {
@@ -177,6 +234,9 @@ meta_backend_get_monitor_manager (MetaBackend *backend)
  return priv->monitor_manager;
 }

+/**
+ * meta_backend_get_cursor_renderer: (skip)
+ */
 MetaCursorRenderer *
 meta_backend_get_cursor_renderer (MetaBackend *backend)
 {
@@ -185,6 +245,9 @@ meta_backend_get_cursor_renderer (MetaBackend *backend)
  return priv->cursor_renderer;
 }

+/**
+ * meta_backend_grab_device: (skip)
+ */
 gboolean
 meta_backend_grab_device (MetaBackend *backend,
                          int          device_id,
@@ -193,6 +256,9 @@ meta_backend_grab_device (MetaBackend *backend,
  return META_BACKEND_GET_CLASS (backend)->grab_device (backend, device_id, timestamp);
 }

+/**
+ * meta_backend_ungrab_device: (skip)
+ */
 gboolean
 meta_backend_ungrab_device (MetaBackend *backend,
                            int          device_id,
@@ -201,6 +267,9 @@ meta_backend_ungrab_device (MetaBackend *backend,
  return META_BACKEND_GET_CLASS (backend)->ungrab_device (backend, device_id, timestamp);
 }

+/**
+ * meta_backend_warp_pointer: (skip)
+ */
 void
 meta_backend_warp_pointer (MetaBackend *backend,
                           int          x,
@@ -209,6 +278,47 @@ meta_backend_warp_pointer (MetaBackend *backend,
  META_BACKEND_GET_CLASS (backend)->warp_pointer (backend, x, y);
 }

+void
+meta_backend_set_keymap (MetaBackend *backend,
+                         const char  *layouts,
+                         const char  *variants,
+                         const char  *options)
+{
+  META_BACKEND_GET_CLASS (backend)->set_keymap (backend, layouts, variants, options);
+}
+
+/**
+ * meta_backend_get_keymap: (skip)
+ */
+struct xkb_keymap *
+meta_backend_get_keymap (MetaBackend *backend)
+
+{
+  return META_BACKEND_GET_CLASS (backend)->get_keymap (backend);
+}
+
+void
+meta_backend_lock_layout_group (MetaBackend *backend,
+                                guint idx)
+{
+  META_BACKEND_GET_CLASS (backend)->lock_layout_group (backend, idx);
+}
+
+/**
+ * meta_backend_get_stage:
+ * @backend: A #MetaBackend
+ *
+ * Gets the global #ClutterStage that's managed by this backend.
+ *
+ * Returns: (transfer none): the #ClutterStage
+ */
+ClutterActor *
+meta_backend_get_stage (MetaBackend *backend)
+{
+  MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
+  return priv->stage;
+}
+
 static GType
 get_backend_type (void)
 {
@@ -281,6 +391,9 @@ static GSourceFuncs event_funcs = {
  event_dispatch
 };

+/**
+ * meta_clutter_init: (skip)
+ */
 void
 meta_clutter_init (void)
 {
--- a/src/backends/meta-cursor-renderer.c
+++ b/src/backends/meta-cursor-renderer.c
@@ -27,14 +27,14 @@
 #include "meta-cursor-renderer.h"
 #include "meta-cursor-private.h"

+#include <meta/meta-backend.h>
+#include <meta/util.h>
+
 #include <cogl/cogl.h>
-#include <cogl/cogl-wayland-server.h>
 #include <clutter/clutter.h>

 #include "meta-stage.h"

-#include "wayland/meta-wayland-private.h"
-
 struct _MetaCursorRendererPrivate
 {
  int current_x, current_y;
@@ -51,8 +51,8 @@ static void
 queue_redraw (MetaCursorRenderer *renderer)
 {
  MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
-  MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
-  ClutterActor *stage = compositor->stage;
+  MetaBackend *backend = meta_get_backend ();
+  ClutterActor *stage = meta_backend_get_stage (backend);

  /* During early initialization, we can have no stage */
  if (!stage)
--- a/src/backends/meta-cursor-tracker-private.h
+++ b/src/backends/meta-cursor-tracker-private.h
@@ -23,8 +23,6 @@
 #define META_CURSOR_TRACKER_PRIVATE_H

 #include <meta/meta-cursor-tracker.h>
-#include <wayland-server.h>
-#include <gbm.h>

 #include "meta-cursor.h"
 #include "meta-cursor-renderer.h"
@@ -32,7 +30,6 @@
 struct _MetaCursorTracker {
  GObject parent_instance;

-  MetaScreen *screen;
  MetaCursorRenderer *renderer;

  gboolean is_showing;
--- a/src/backends/meta-cursor-tracker.c
+++ b/src/backends/meta-cursor-tracker.c
@@ -34,25 +34,21 @@
 #include <meta/errors.h>

 #include <cogl/cogl.h>
-#include <cogl/cogl-wayland-server.h>
 #include <clutter/clutter.h>

 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>

-#include "meta-backend.h"
+#include "meta-backend-private.h"

 #include "meta-cursor-private.h"
 #include "meta-cursor-tracker-private.h"
-#include "screen-private.h"
-
-#include "wayland/meta-wayland-private.h"

 G_DEFINE_TYPE (MetaCursorTracker, meta_cursor_tracker, G_TYPE_OBJECT);

 enum {
-    CURSOR_CHANGED,
-    LAST_SIGNAL
+  CURSOR_CHANGED,
+  LAST_SIGNAL
 };

 static guint signals[LAST_SIGNAL];
@@ -60,10 +56,12 @@ static guint signals[LAST_SIGNAL];
 static MetaCursorReference *
 get_displayed_cursor (MetaCursorTracker *tracker)
 {
+  MetaDisplay *display = meta_get_display ();
+
  if (!tracker->is_showing)
    return NULL;

-  if (tracker->screen->display->grab_op == META_GRAB_OP_NONE)
+  if (meta_display_windows_are_interactable (display))
    {
      if (tracker->has_window_cursor)
        return tracker->window_cursor;
@@ -97,6 +95,9 @@ sync_cursor (MetaCursorTracker *tracker)
 static void
 meta_cursor_tracker_init (MetaCursorTracker *self)
 {
+  MetaBackend *backend = meta_get_backend ();
+
+  self->renderer = meta_backend_get_cursor_renderer (backend);
  self->is_showing = TRUE;
 }

@@ -129,47 +130,9 @@ meta_cursor_tracker_class_init (MetaCursorTrackerClass *klass)
 }

 static MetaCursorTracker *
-make_wayland_cursor_tracker (MetaScreen *screen)
+meta_cursor_tracker_new (void)
 {
-  MetaBackend *backend = meta_get_backend ();
-  MetaWaylandCompositor *compositor;
-  MetaCursorTracker *self;
-
-  self = g_object_new (META_TYPE_CURSOR_TRACKER, NULL);
-  self->screen = screen;
-  self->renderer = meta_backend_get_cursor_renderer (backend);
-
-  compositor = meta_wayland_compositor_get_default ();
-  compositor->seat->pointer.cursor_tracker = self;
-  meta_cursor_tracker_update_position (self, 0, 0);
-
-  return self;
-}
-
-static MetaCursorTracker *
-make_x11_cursor_tracker (MetaScreen *screen)
-{
-  MetaBackend *backend = meta_get_backend ();
-  MetaCursorTracker *self;
-
-  self = g_object_new (META_TYPE_CURSOR_TRACKER, NULL);
-  self->screen = screen;
-  self->renderer = meta_backend_get_cursor_renderer (backend);
-
-  XFixesSelectCursorInput (screen->display->xdisplay,
-                           screen->xroot,
-                           XFixesDisplayCursorNotifyMask);
-
-  return self;
-}
-
-static MetaCursorTracker *
-meta_cursor_tracker_new (MetaScreen *screen)
-{
-  if (meta_is_wayland_compositor ())
-    return make_wayland_cursor_tracker (screen);
-  else
-    return make_x11_cursor_tracker (screen);
+  return g_object_new (META_TYPE_CURSOR_TRACKER, NULL);
 }

 static MetaCursorTracker *_cursor_tracker;
@@ -186,7 +149,7 @@ MetaCursorTracker *
 meta_cursor_tracker_get_for_screen (MetaScreen *screen)
 {
  if (!_cursor_tracker)
-    _cursor_tracker = meta_cursor_tracker_new (screen);
+    _cursor_tracker = meta_cursor_tracker_new ();

  return _cursor_tracker;
 }
@@ -207,12 +170,13 @@ gboolean
 meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
                                   XEvent            *xevent)
 {
+  MetaDisplay *display = meta_get_display ();
  XFixesCursorNotifyEvent *notify_event;

  if (meta_is_wayland_compositor ())
    return FALSE;

-  if (xevent->xany.type != tracker->screen->display->xfixes_event_base + XFixesCursorNotify)
+  if (xevent->xany.type != display->xfixes_event_base + XFixesCursorNotify)
    return FALSE;

  notify_event = (XFixesCursorNotifyEvent *)xevent;
@@ -243,6 +207,7 @@ meta_cursor_reference_take_texture (CoglTexture2D *texture,
 static void
 ensure_xfixes_cursor (MetaCursorTracker *tracker)
 {
+  MetaDisplay *display = meta_get_display ();
  XFixesCursorImage *cursor_image;
  CoglTexture2D *sprite;
  guint8 *cursor_data;
@@ -252,7 +217,7 @@ ensure_xfixes_cursor (MetaCursorTracker *tracker)
  if (tracker->xfixes_cursor)
    return;

-  cursor_image = XFixesGetCursorImage (tracker->screen->display->xdisplay);
+  cursor_image = XFixesGetCursorImage (display->xdisplay);
  if (!cursor_image)
    return;

--- a/src/backends/meta-cursor.c
+++ b/src/backends/meta-cursor.c
@@ -27,7 +27,7 @@

 #include "display-private.h"
 #include "screen-private.h"
-#include "meta-backend.h"
+#include "meta-backend-private.h"

 #ifdef HAVE_NATIVE_BACKEND
 #include "backends/native/meta-cursor-renderer-native.h"
@@ -39,7 +39,9 @@
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xcursor/Xcursor.h>

+#ifdef HAVE_WAYLAND
 #include <cogl/cogl-wayland-server.h>
+#endif

 MetaCursorReference *
 meta_cursor_reference_ref (MetaCursorReference *self)
@@ -247,6 +249,7 @@ meta_cursor_reference_from_theme (MetaCursor cursor)
  return self;
 }

+#ifdef HAVE_WAYLAND
 static void
 meta_cursor_image_load_from_buffer (MetaCursorImage    *image,
                                    struct wl_resource *buffer,
@@ -345,6 +348,7 @@ meta_cursor_reference_from_buffer (struct wl_resource *buffer,

  return self;
 }
+#endif

 CoglTexture *
 meta_cursor_reference_get_cogl_texture (MetaCursorReference *cursor,
--- a/src/backends/meta-cursor.h
+++ b/src/backends/meta-cursor.h
@@ -28,13 +28,15 @@ MetaCursorReference * meta_cursor_reference_ref (MetaCursorReference *cursor);
 void meta_cursor_reference_unref (MetaCursorReference *cursor);

 #include <meta/common.h>
-#include <wayland-server.h>

 MetaCursorReference * meta_cursor_reference_from_theme  (MetaCursor          cursor);

+#ifdef HAVE_WAYLAND
+#include <wayland-server.h>
 MetaCursorReference * meta_cursor_reference_from_buffer (struct wl_resource *buffer,
                                                         int                 hot_x,
                                                         int                 hot_y);
+#endif

 MetaCursor meta_cursor_reference_get_meta_cursor (MetaCursorReference *cursor);

--- a/src/backends/meta-idle-monitor.c
+++ b/src/backends/meta-idle-monitor.c
@@ -38,7 +38,7 @@
 #include <meta/meta-idle-monitor.h>
 #include "meta-idle-monitor-private.h"
 #include "meta-idle-monitor-dbus.h"
-#include "meta-backend.h"
+#include "meta-backend-private.h"

 G_STATIC_ASSERT(sizeof(unsigned long) == sizeof(gpointer));

--- a/src/backends/meta-monitor-config.c
+++ b/src/backends/meta-monitor-config.c
@@ -60,7 +60,7 @@ typedef struct {
  gboolean enabled;
  MetaRectangle rect;
  float refresh_rate;
-  enum wl_output_transform transform;
+  MetaMonitorTransform transform;

  gboolean is_primary;
  gboolean is_presentation;
@@ -656,20 +656,20 @@ handle_text (GMarkupParseContext *context,
        else if (strcmp (parser->output_field, "rotation") == 0)
          {
            if (strncmp (text, "normal", text_len) == 0)
-              parser->output.transform = WL_OUTPUT_TRANSFORM_NORMAL;
+              parser->output.transform = META_MONITOR_TRANSFORM_NORMAL;
            else if (strncmp (text, "left", text_len) == 0)
-              parser->output.transform = WL_OUTPUT_TRANSFORM_90;
+              parser->output.transform = META_MONITOR_TRANSFORM_90;
            else if (strncmp (text, "upside_down", text_len) == 0)
-              parser->output.transform = WL_OUTPUT_TRANSFORM_180;
+              parser->output.transform = META_MONITOR_TRANSFORM_180;
            else if (strncmp (text, "right", text_len) == 0)
-              parser->output.transform = WL_OUTPUT_TRANSFORM_270;
+              parser->output.transform = META_MONITOR_TRANSFORM_270;
            else
              g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                           "Invalid rotation type %.*s", (int)text_len, text);
          }
        else if (strcmp (parser->output_field, "reflect_x") == 0)
          parser->output.transform += read_bool (text, text_len, error) ?
-            WL_OUTPUT_TRANSFORM_FLIPPED : 0;
+            META_MONITOR_TRANSFORM_FLIPPED : 0;
        else if (strcmp (parser->output_field, "reflect_y") == 0)
          {
            /* FIXME (look at the rotation map in monitor.c) */
@@ -1115,7 +1115,7 @@ make_default_config (MetaMonitorConfig *self,
      ret->outputs[0].rect.width = outputs[0].preferred_mode->width;
      ret->outputs[0].rect.height = outputs[0].preferred_mode->height;
      ret->outputs[0].refresh_rate = outputs[0].preferred_mode->refresh_rate;
-      ret->outputs[0].transform = WL_OUTPUT_TRANSFORM_NORMAL;
+      ret->outputs[0].transform = META_MONITOR_TRANSFORM_NORMAL;
      ret->outputs[0].is_primary = TRUE;

      return ret;
@@ -1167,7 +1167,7 @@ make_default_config (MetaMonitorConfig *self,
                  ret->outputs[j].rect.width = outputs[0].preferred_mode->width;
                  ret->outputs[j].rect.height = outputs[0].preferred_mode->height;
                  ret->outputs[j].refresh_rate = outputs[0].preferred_mode->refresh_rate;
-                  ret->outputs[j].transform = WL_OUTPUT_TRANSFORM_NORMAL;
+                  ret->outputs[j].transform = META_MONITOR_TRANSFORM_NORMAL;
                  ret->outputs[j].is_primary = FALSE;
                  ret->outputs[j].is_presentation = FALSE;
                }
@@ -1202,7 +1202,7 @@ make_default_config (MetaMonitorConfig *self,
      ret->outputs[i].rect.width = output->preferred_mode->width;
      ret->outputs[i].rect.height = output->preferred_mode->height;
      ret->outputs[i].refresh_rate = output->preferred_mode->refresh_rate;
-      ret->outputs[i].transform = WL_OUTPUT_TRANSFORM_NORMAL;
+      ret->outputs[i].transform = META_MONITOR_TRANSFORM_NORMAL;
      ret->outputs[i].is_primary = (output == primary);

      /* Disable outputs that would go beyond framebuffer limits */
@@ -1250,7 +1250,7 @@ ensure_at_least_one_output (MetaMonitorConfig  *self,
          ret->outputs[i].rect.width = output->preferred_mode->width;
          ret->outputs[i].rect.height = output->preferred_mode->height;
          ret->outputs[i].refresh_rate = output->preferred_mode->refresh_rate;
-          ret->outputs[i].transform = WL_OUTPUT_TRANSFORM_NORMAL;
+          ret->outputs[i].transform = META_MONITOR_TRANSFORM_NORMAL;
          ret->outputs[i].is_primary = TRUE;
        }
      else
@@ -1512,7 +1512,7 @@ meta_monitor_config_save (MetaMonitorConfig *self)
                                      output->rect.x,
                                      output->rect.y,
                                      rotation_map[output->transform & 0x3],
-                                      output->transform >= WL_OUTPUT_TRANSFORM_FLIPPED ? "yes" : "no",
+                                      output->transform >= META_MONITOR_TRANSFORM_FLIPPED ? "yes" : "no",
                                      output->is_primary ? "yes" : "no",
                                      output->is_presentation ? "yes" : "no");
            }
@@ -1621,13 +1621,13 @@ output_supports_mode (MetaOutput      *output,
 }

 static gboolean
-crtc_assignment_assign (CrtcAssignment            *assign,
-			MetaCRTC                  *crtc,
-			MetaMonitorMode           *mode,
-			int                        x,
-			int                        y,
-			enum wl_output_transform   transform,
-			MetaOutput                *output)
+crtc_assignment_assign (CrtcAssignment       *assign,
+			MetaCRTC             *crtc,
+			MetaMonitorMode      *mode,
+			int                   x,
+			int                   y,
+			MetaMonitorTransform  transform,
+			MetaOutput           *output)
 {
  MetaCRTCInfo *info = g_hash_table_lookup (assign->info, crtc);

--- a/src/backends/meta-monitor-manager-dummy.c
+++ b/src/backends/meta-monitor-manager-dummy.c
@@ -27,7 +27,7 @@

 #include "meta-monitor-manager-dummy.h"

-#define ALL_WL_TRANSFORMS ((1 << (WL_OUTPUT_TRANSFORM_FLIPPED_270 + 1)) - 1)
+#define ALL_TRANSFORMS ((1 << (META_MONITOR_TRANSFORM_FLIPPED_270 + 1)) - 1)

 struct _MetaMonitorManagerDummy
 {
@@ -66,8 +66,8 @@ meta_monitor_manager_dummy_read_current (MetaMonitorManager *manager)
  manager->crtcs[0].rect.width = manager->modes[0].width;
  manager->crtcs[0].rect.height = manager->modes[0].height;
  manager->crtcs[0].current_mode = &manager->modes[0];
-  manager->crtcs[0].transform = WL_OUTPUT_TRANSFORM_NORMAL;
-  manager->crtcs[0].all_transforms = ALL_WL_TRANSFORMS;
+  manager->crtcs[0].transform = META_MONITOR_TRANSFORM_NORMAL;
+  manager->crtcs[0].all_transforms = ALL_TRANSFORMS;
  manager->crtcs[0].is_dirty = FALSE;
  manager->crtcs[0].logical_monitor = NULL;

@@ -75,7 +75,7 @@ meta_monitor_manager_dummy_read_current (MetaMonitorManager *manager)
  manager->n_outputs = 1;

  manager->outputs[0].crtc = &manager->crtcs[0];
-  manager->outputs[0].output_id = 1;
+  manager->outputs[0].winsys_id = 1;
  manager->outputs[0].name = g_strdup ("LVDS");
  manager->outputs[0].vendor = g_strdup ("MetaProducts Inc.");
  manager->outputs[0].product = g_strdup ("unknown");
--- a/src/backends/meta-monitor-manager.c
+++ b/src/backends/meta-monitor-manager.c
@@ -37,7 +37,7 @@
 #include <meta/errors.h>
 #include "meta-monitor-config.h"
 #include "backends/x11/meta-monitor-manager-xrandr.h"
-#include "meta-backend.h"
+#include "meta-backend-private.h"

 enum {
  CONFIRM_DISPLAY_CHANGE,
@@ -125,7 +125,7 @@ make_logical_config (MetaMonitorManager *manager)
          */
          info.is_presentation = TRUE;
          info.in_fullscreen = -1;
-          info.output_id = 0;
+          info.winsys_id = 0;

          g_array_append_val (monitor_infos, info);

@@ -156,8 +156,8 @@ make_logical_config (MetaMonitorManager *manager)
      info->is_primary = info->is_primary || output->is_primary;
      info->is_presentation = info->is_presentation && output->is_presentation;

-      if (output->is_primary || info->output_id == 0)
-        info->output_id = output->output_id;
+      if (output->is_primary || info->winsys_id == 0)
+        info->winsys_id = output->winsys_id;

      if (info->is_primary)
        manager->primary_monitor_index = info->number;
@@ -477,7 +477,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
      GVariantBuilder transforms;

      g_variant_builder_init (&transforms, G_VARIANT_TYPE ("au"));
-      for (j = 0; j <= WL_OUTPUT_TRANSFORM_FLIPPED_270; j++)
+      for (j = 0; j <= META_MONITOR_TRANSFORM_FLIPPED_270; j++)
        if (crtc->all_transforms & (1 << j))
          g_variant_builder_add (&transforms, "u", j);

@@ -560,7 +560,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,

      g_variant_builder_add (&output_builder, "(uxiausauaua{sv})",
                             i, /* ID */
-                             (gint64)output->output_id,
+                             (gint64)output->winsys_id,
                             (int)(output->crtc ? output->crtc - manager->crtcs : -1),
                             &crtcs,
                             output->name,
@@ -667,7 +667,7 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
  int new_mode, x, y;
  int new_screen_width, new_screen_height;
  guint transform;
-  guint output_id;
+  guint output_index;
  GPtrArray *crtc_infos, *output_infos;

  if (serial != manager->serial)
@@ -694,7 +694,6 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
      MetaOutput *first_output;
      MetaCRTC *crtc;
      MetaMonitorMode *mode;
-      guint output_id;

      crtc_info = g_slice_new (MetaCRTCInfo);
      crtc_info->outputs = g_ptr_array_new ();
@@ -756,8 +755,8 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
          crtc_info->y = 0;
        }

-      if (transform < WL_OUTPUT_TRANSFORM_NORMAL ||
-          transform > WL_OUTPUT_TRANSFORM_FLIPPED_270 ||
+      if (transform < META_MONITOR_TRANSFORM_NORMAL ||
+          transform > META_MONITOR_TRANSFORM_FLIPPED_270 ||
          ((crtc->all_transforms & (1 << transform)) == 0))
        {
          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
@@ -768,18 +767,18 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
      crtc_info->transform = transform;

      first_output = NULL;
-      while (g_variant_iter_loop (nested_outputs, "u", &output_id))
+      while (g_variant_iter_loop (nested_outputs, "u", &output_index))
        {
          MetaOutput *output;

-          if (output_id >= manager->n_outputs)
+          if (output_index >= manager->n_outputs)
            {
              g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                     G_DBUS_ERROR_INVALID_ARGS,
                                                     "Invalid output id");
              return TRUE;
            }
-          output = &manager->outputs[output_id];
+          output = &manager->outputs[output_index];

          if (!output_can_config (output, crtc, mode))
            {
@@ -824,12 +823,12 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
    }

  g_variant_iter_init (&output_iter, outputs);
-  while (g_variant_iter_loop (&output_iter, "(u@a{sv})", &output_id, &properties))
+  while (g_variant_iter_loop (&output_iter, "(u@a{sv})", &output_index, &properties))
    {
      MetaOutputInfo *output_info;
      gboolean primary, presentation;

-      if (output_id >= manager->n_outputs)
+      if (output_index >= manager->n_outputs)
        {
          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                                 G_DBUS_ERROR_INVALID_ARGS,
@@ -838,7 +837,7 @@ meta_monitor_manager_handle_apply_configuration  (MetaDBusDisplayConfig *skeleto
        }

      output_info = g_slice_new0 (MetaOutputInfo);
-      output_info->output = &manager->outputs[output_id];
+      output_info->output = &manager->outputs[output_index];

      if (g_variant_lookup (properties, "primary", "b", &primary))
        output_info->is_primary = primary;
@@ -909,7 +908,7 @@ static gboolean
 meta_monitor_manager_handle_change_backlight  (MetaDBusDisplayConfig *skeleton,
                                               GDBusMethodInvocation *invocation,
                                               guint                  serial,
-                                               guint                  output_id,
+                                               guint                  output_index,
                                               gint                   value)
 {
  MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
@@ -923,14 +922,14 @@ meta_monitor_manager_handle_change_backlight  (MetaDBusDisplayConfig *skeleton,
      return TRUE;
    }

-  if (output_id >= manager->n_outputs)
+  if (output_index >= manager->n_outputs)
    {
      g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
                                             G_DBUS_ERROR_INVALID_ARGS,
                                             "Invalid output id");
      return TRUE;
    }
-  output = &manager->outputs[output_id];
+  output = &manager->outputs[output_index];

  if (value < 0 || value > 100)
    {
--- a/src/backends/meta-monitor-manager.h
+++ b/src/backends/meta-monitor-manager.h
@@ -41,8 +41,6 @@
 #include "display-private.h"
 #include <meta/screen.h>
 #include "stack-tracker.h"
-#include "ui.h"
-#include <wayland-server.h>

 #include "meta-display-config-shared.h"
 #include "meta-dbus-display-config.h"
@@ -60,12 +58,23 @@ typedef struct _MetaMonitorInfo MetaMonitorInfo;
 typedef struct _MetaCRTCInfo MetaCRTCInfo;
 typedef struct _MetaOutputInfo MetaOutputInfo;

+typedef enum {
+  META_MONITOR_TRANSFORM_NORMAL,
+  META_MONITOR_TRANSFORM_90,
+  META_MONITOR_TRANSFORM_180,
+  META_MONITOR_TRANSFORM_270,
+  META_MONITOR_TRANSFORM_FLIPPED,
+  META_MONITOR_TRANSFORM_FLIPPED_90,
+  META_MONITOR_TRANSFORM_FLIPPED_180,
+  META_MONITOR_TRANSFORM_FLIPPED_270,
+} MetaMonitorTransform;
+
 struct _MetaOutput
 {
  /* The CRTC driving this output, NULL if the output is not enabled */
  MetaCRTC *crtc;
  /* The low-level ID of this output, used to apply back configuration */
-  glong output_id;
+  glong winsys_id;
  char *name;
  char *vendor;
  char *product;
@@ -114,7 +123,7 @@ struct _MetaCRTC
  glong crtc_id;
  MetaRectangle rect;
  MetaMonitorMode *current_mode;
-  enum wl_output_transform transform;
+  MetaMonitorTransform transform;
  unsigned int all_transforms;

  /* Only used to build the logical configuration
@@ -162,14 +171,14 @@ struct _MetaMonitorInfo
  gboolean in_fullscreen;

  /* The primary or first output for this monitor, 0 if we can't figure out.
-     It can be matched to an output_id of a MetaOutput.
+     It can be matched to a winsys_id of a MetaOutput.

     This is used as an opaque token on reconfiguration when switching from
     clone to extened, to decide on what output the windows should go next
     (it's an attempt to keep windows on the same monitor, and preferably on
     the primary one).
  */
-  glong output_id;
+  glong winsys_id;
 };

 /*
@@ -185,7 +194,7 @@ struct _MetaCRTCInfo {
  MetaMonitorMode          *mode;
  int                       x;
  int                       y;
-  enum wl_output_transform  transform;
+  MetaMonitorTransform      transform;
  GPtrArray                *outputs;
 };

@@ -339,7 +348,7 @@ gboolean           meta_monitor_manager_has_hotplug_mode_update (MetaMonitorMana
 /* Returns true if transform causes width and height to be inverted
   This is true for the odd transforms in the enum */
 static inline gboolean
-meta_monitor_transform_is_rotated (enum wl_output_transform transform)
+meta_monitor_transform_is_rotated (MetaMonitorTransform transform)
 {
  return (transform % 2);
 }
--- a/src/compositor/meta-stage.c
+++ b/src/compositor/meta-stage.c
@@ -25,12 +25,11 @@
 #include "meta-stage.h"

 #include "meta-cursor-private.h"
-#include "meta-backend.h"
+#include <meta/meta-backend.h>
 #include <meta/util.h>

 struct _MetaStagePrivate {
  CoglPipeline *pipeline;
-  gboolean should_paint_cursor;

  MetaCursorReference *cursor;

--- a/src/compositor/meta-stage.h
+++ b/src/compositor/meta-stage.h
--- a/src/backends/native/meta-backend-native.c
+++ b/src/backends/native/meta-backend-native.c
@@ -174,6 +174,63 @@ meta_backend_native_create_cursor_renderer (MetaBackend *backend)
  return g_object_new (META_TYPE_CURSOR_RENDERER_NATIVE, NULL);
 }

+static void
+meta_backend_native_warp_pointer (MetaBackend *backend,
+                                  int          x,
+                                  int          y)
+{
+  ClutterDeviceManager *manager = clutter_device_manager_get_default ();
+  ClutterInputDevice *device = clutter_device_manager_get_core_device (manager, CLUTTER_POINTER_DEVICE);
+
+  /* XXX */
+  guint32 time_ = 0;
+
+  clutter_evdev_warp_pointer (device, time_, x, y);
+}
+
+static void
+meta_backend_native_set_keymap (MetaBackend *backend,
+                                const char  *layouts,
+                                const char  *variants,
+                                const char  *options)
+{
+  ClutterDeviceManager *manager = clutter_device_manager_get_default ();
+  struct xkb_rule_names names;
+  struct xkb_keymap *keymap;
+  struct xkb_context *context;
+
+  names.rules = DEFAULT_XKB_RULES_FILE;
+  names.model = DEFAULT_XKB_MODEL;
+  names.layout = layouts;
+  names.variant = variants;
+  names.options = options;
+
+  context = xkb_context_new (XKB_CONTEXT_NO_FLAGS);
+  keymap = xkb_keymap_new_from_names (context, &names, XKB_KEYMAP_COMPILE_NO_FLAGS);
+  xkb_context_unref (context);
+
+  clutter_evdev_set_keyboard_map (manager, keymap);
+
+  g_signal_emit_by_name (backend, "keymap-changed", 0);
+
+  xkb_keymap_unref (keymap);
+}
+
+static struct xkb_keymap *
+meta_backend_native_get_keymap (MetaBackend *backend)
+{
+  ClutterDeviceManager *manager = clutter_device_manager_get_default ();
+  return clutter_evdev_get_keyboard_map (manager);
+}
+
+static void
+meta_backend_native_lock_layout_group (MetaBackend *backend,
+                                       guint        idx)
+{
+  ClutterDeviceManager *manager = clutter_device_manager_get_default ();
+  clutter_evdev_set_keyboard_layout_index (manager, idx);
+}
+
 static void
 meta_backend_native_class_init (MetaBackendNativeClass *klass)
 {
@@ -183,6 +240,11 @@ meta_backend_native_class_init (MetaBackendNativeClass *klass)
  backend_class->create_idle_monitor = meta_backend_native_create_idle_monitor;
  backend_class->create_monitor_manager = meta_backend_native_create_monitor_manager;
  backend_class->create_cursor_renderer = meta_backend_native_create_cursor_renderer;
+
+  backend_class->warp_pointer = meta_backend_native_warp_pointer;
+  backend_class->set_keymap = meta_backend_native_set_keymap;
+  backend_class->get_keymap = meta_backend_native_get_keymap;
+  backend_class->lock_layout_group = meta_backend_native_lock_layout_group;
 }

 static void
--- a/src/backends/native/meta-launcher.c
+++ b/src/backends/native/meta-launcher.c
@@ -41,8 +41,7 @@
 #include "dbus-utils.h"
 #include "meta-dbus-login1.h"

-#include "wayland/meta-wayland-private.h"
-#include "backends/meta-backend.h"
+#include "backends/meta-backend-private.h"
 #include "meta-cursor-renderer-native.h"

 struct _MetaLauncher
@@ -101,15 +100,15 @@ session_unpause (void)
  clutter_egl_thaw_master_clock ();

  {
-    MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
    MetaBackend *backend = meta_get_backend ();
    MetaCursorRenderer *renderer = meta_backend_get_cursor_renderer (backend);
+    ClutterActor *stage = meta_backend_get_stage (backend);

    /* When we mode-switch back, we need to immediately queue a redraw
     * in case nothing else queued one for us, and force the cursor to
     * update. */

-    clutter_actor_queue_redraw (compositor->stage);
+    clutter_actor_queue_redraw (stage);
    meta_cursor_renderer_native_force_update (META_CURSOR_RENDERER_NATIVE (renderer));
  }
 }
--- a/src/backends/native/meta-monitor-manager-kms.c
+++ b/src/backends/native/meta-monitor-manager-kms.c
@@ -40,8 +40,6 @@
 #include <meta/errors.h>
 #include "edid.h"

-#define ALL_WL_TRANSFORMS ((1 << (WL_OUTPUT_TRANSFORM_FLIPPED_270 + 1)) - 1)
-
 typedef struct {
  drmModeConnector *connector;

@@ -259,7 +257,7 @@ find_output_by_id (MetaOutput *outputs,
  unsigned i;

  for (i = 0; i < n_outputs; i++)
-    if (outputs[i].output_id == id)
+    if (outputs[i].winsys_id == id)
      return &outputs[i];

  return NULL;
@@ -363,9 +361,9 @@ meta_monitor_manager_kms_read_current (MetaMonitorManager *manager)
      meta_crtc->rect.width = crtc->width;
      meta_crtc->rect.height = crtc->height;
      meta_crtc->is_dirty = FALSE;
-      meta_crtc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
+      meta_crtc->transform = META_MONITOR_TRANSFORM_NORMAL;
      /* FIXME: implement! */
-      meta_crtc->all_transforms = 1 << WL_OUTPUT_TRANSFORM_NORMAL;
+      meta_crtc->all_transforms = 1 << META_MONITOR_TRANSFORM_NORMAL;

      if (crtc->mode_valid)
        {
@@ -408,7 +406,7 @@ meta_monitor_manager_kms_read_current (MetaMonitorManager *manager)
          meta_output->driver_private = output_kms = g_slice_new0 (MetaOutputKms);
          meta_output->driver_notify = (GDestroyNotify)meta_output_destroy_notify;

-	  meta_output->output_id = connector->connector_id;
+	  meta_output->winsys_id = connector->connector_id;
 	  meta_output->name = make_output_name (connector);
 	  meta_output->width_mm = connector->mmWidth;
 	  meta_output->height_mm = connector->mmHeight;
@@ -491,7 +489,7 @@ meta_monitor_manager_kms_read_current (MetaMonitorManager *manager)
            meta_output->crtc = NULL;

          old_output = find_output_by_id (old_outputs, n_old_outputs,
-                                          meta_output->output_id);
+                                          meta_output->winsys_id);
          if (old_output)
            {
              meta_output->is_primary = old_output->is_primary;
@@ -667,7 +665,7 @@ meta_monitor_manager_kms_set_power_save_mode (MetaMonitorManager *manager,

      if (output_kms->dpms_prop_id != 0)
        {
-          int ok = drmModeConnectorSetProperty(manager_kms->fd, meta_output->output_id,
+          int ok = drmModeConnectorSetProperty(manager_kms->fd, meta_output->winsys_id,
                                               output_kms->dpms_prop_id, state);

          if (ok < 0)
@@ -748,7 +746,7 @@ meta_monitor_manager_kms_apply_configuration (MetaMonitorManager *manager,
            {
              MetaOutput *output = g_ptr_array_index (crtc_info->outputs, j);

-              connectors[j] = output->output_id;
+              connectors[j] = output->winsys_id;

              output->is_dirty = TRUE;
              output->crtc = crtc;
--- a/src/backends/x11/meta-backend-x11.c
+++ b/src/backends/x11/meta-backend-x11.c
@@ -24,11 +24,18 @@

 #include "config.h"

+#include <string.h>
+#include <stdlib.h>
+
 #include "meta-backend-x11.h"

 #include <clutter/x11/clutter-x11.h>

 #include <X11/extensions/sync.h>
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKBrules.h>
+#include <X11/Xlib-xcb.h>
+#include <xkbcommon/xkbcommon-x11.h>

 #include "meta-idle-monitor-xsync.h"
 #include "meta-monitor-manager-xrandr.h"
@@ -43,6 +50,7 @@ struct _MetaBackendX11Private
 {
  /* The host X11 display */
  Display *xdisplay;
+  xcb_connection_t *xcb;
  GSource *source;

  int xsync_event_base;
@@ -51,6 +59,12 @@ struct _MetaBackendX11Private
  int xinput_opcode;
  int xinput_event_base;
  int xinput_error_base;
+  Time latest_evtime;
+
+  uint8_t xkb_event_base;
+  uint8_t xkb_error_base;
+
+  struct xkb_keymap *keymap;
 };
 typedef struct _MetaBackendX11Private MetaBackendX11Private;

@@ -71,6 +85,7 @@ static void
 translate_device_event (MetaBackendX11 *x11,
                        XIDeviceEvent  *device_event)
 {
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
  Window stage_window = meta_backend_x11_get_xwindow (x11);

  if (device_event->event != stage_window)
@@ -88,6 +103,21 @@ translate_device_event (MetaBackendX11 *x11,
      device_event->event_x = device_event->root_x;
      device_event->event_y = device_event->root_y;
    }
+
+  if (!device_event->send_event && device_event->time != CurrentTime)
+    {
+      if (device_event->time < priv->latest_evtime)
+        {
+          /* Emulated pointer events received after XIRejectTouch is received
+           * on a passive touch grab will contain older timestamps, update those
+           * so we dont get InvalidTime at grabs.
+           */
+          device_event->time = priv->latest_evtime;
+        }
+
+      /* Update the internal latest evtime, for any possible later use */
+      priv->latest_evtime = device_event->time;
+    }
 }

 /* Clutter makes the assumption that there is only one X window
@@ -117,6 +147,9 @@ maybe_spoof_event_as_stage_event (MetaBackendX11 *x11,
        case XI_ButtonRelease:
        case XI_KeyPress:
        case XI_KeyRelease:
+        case XI_TouchBegin:
+        case XI_TouchUpdate:
+        case XI_TouchEnd:
          translate_device_event (x11, (XIDeviceEvent *) input_event);
          break;
        default:
@@ -125,6 +158,21 @@ maybe_spoof_event_as_stage_event (MetaBackendX11 *x11,
    }
 }

+static void
+keymap_changed (MetaBackend *backend)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+
+  if (priv->keymap)
+    {
+      xkb_keymap_unref (priv->keymap);
+      priv->keymap = NULL;
+    }
+
+  g_signal_emit_by_name (backend, "keymap-changed", 0);
+}
+
 static void
 handle_host_xevent (MetaBackend *backend,
                    XEvent      *event)
@@ -135,24 +183,49 @@ handle_host_xevent (MetaBackend *backend,

  XGetEventData (priv->xdisplay, &event->xcookie);

+  {
+    MetaDisplay *display = meta_get_display ();
+
+    if (display)
+      {
+        MetaCompositor *compositor = display->compositor;
+        if (meta_plugin_manager_xevent_filter (compositor->plugin_mgr, event))
+          bypass_clutter = TRUE;
+      }
+  }
+
  if (event->type == (priv->xsync_event_base + XSyncAlarmNotify))
    handle_alarm_notify (backend, event);

+  if (event->type == priv->xkb_event_base)
+    {
+      XkbAnyEvent *xkb_ev = (XkbAnyEvent *) event;
+
+      if (xkb_ev->device == META_VIRTUAL_CORE_KEYBOARD_ID)
+        {
+          switch (xkb_ev->xkb_type)
+            {
+            case XkbNewKeyboardNotify:
+            case XkbMapNotify:
+              keymap_changed (backend);
+            default:
+              break;
+            }
+        }
+    }
+
  {
    MetaMonitorManager *manager = meta_backend_get_monitor_manager (backend);
    if (META_IS_MONITOR_MANAGER_XRANDR (manager) &&
        meta_monitor_manager_xrandr_handle_xevent (META_MONITOR_MANAGER_XRANDR (manager), event))
-      {
-        bypass_clutter = TRUE;
-        goto out;
-      }
+      bypass_clutter = TRUE;
  }

-  maybe_spoof_event_as_stage_event (x11, event);
-
- out:
  if (!bypass_clutter)
-    clutter_x11_handle_event (event);
+    {
+      maybe_spoof_event_as_stage_event (x11, event);
+      clutter_x11_handle_event (event);
+    }

  XFreeEventData (priv->xdisplay, &event->xcookie);
 }
@@ -235,6 +308,24 @@ x_event_source_new (MetaBackend *backend)
  return source;
 }

+static void
+take_touch_grab (MetaBackend *backend)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+  XIEventMask mask = { META_VIRTUAL_CORE_POINTER_ID, sizeof (mask_bits), mask_bits };
+  XIGrabModifiers mods = { XIAnyModifier, 0 };
+
+  XISetMask (mask.mask, XI_TouchBegin);
+  XISetMask (mask.mask, XI_TouchUpdate);
+  XISetMask (mask.mask, XI_TouchEnd);
+
+  XIGrabTouchBegin (priv->xdisplay, META_VIRTUAL_CORE_POINTER_ID,
+                    DefaultRootWindow (priv->xdisplay),
+                    False, &mask, 1, &mods);
+}
+
 static void
 meta_backend_x11_post_init (MetaBackend *backend)
 {
@@ -272,6 +363,19 @@ meta_backend_x11_post_init (MetaBackend *backend)
      meta_fatal ("X server doesn't have the XInput extension, version 2.2 or newer\n");
  }

+  take_touch_grab (backend);
+
+  priv->xcb = XGetXCBConnection (priv->xdisplay);
+  if (!xkb_x11_setup_xkb_extension (priv->xcb,
+                                    XKB_X11_MIN_MAJOR_XKB_VERSION,
+                                    XKB_X11_MIN_MINOR_XKB_VERSION,
+                                    XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
+                                    NULL, NULL,
+                                    &priv->xkb_event_base,
+                                    &priv->xkb_error_base))
+    meta_fatal ("X server doesn't have the XKB extension, version %d.%d or newer\n",
+                XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION);
+
  META_BACKEND_CLASS (meta_backend_x11_parent_class)->post_init (backend);
 }

@@ -313,6 +417,9 @@ meta_backend_x11_grab_device (MetaBackend *backend,
  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
  int ret;

+  if (timestamp != CurrentTime)
+    timestamp = MAX (timestamp, priv->latest_evtime);
+
  XISetMask (mask.mask, XI_ButtonPress);
  XISetMask (mask.mask, XI_ButtonRelease);
  XISetMask (mask.mask, XI_Enter);
@@ -362,6 +469,198 @@ meta_backend_x11_warp_pointer (MetaBackend *backend,
                 x, y);
 }

+static void
+get_xkbrf_var_defs (Display           *xdisplay,
+                    const char        *layouts,
+                    const char        *variants,
+                    const char        *options,
+                    char             **rules_p,
+                    XkbRF_VarDefsRec  *var_defs)
+{
+  char *rules = NULL;
+
+  /* Get it from the X property or fallback on defaults */
+  if (!XkbRF_GetNamesProp (xdisplay, &rules, var_defs) || !rules)
+    {
+      rules = strdup (DEFAULT_XKB_RULES_FILE);
+      var_defs->model = strdup (DEFAULT_XKB_MODEL);
+      var_defs->layout = NULL;
+      var_defs->variant = NULL;
+      var_defs->options = NULL;
+    }
+
+  /* Swap in our new options... */
+  free (var_defs->layout);
+  var_defs->layout = strdup (layouts);
+  free (var_defs->variant);
+  var_defs->variant = strdup (variants);
+  free (var_defs->options);
+  var_defs->options = strdup (options);
+
+  /* Sometimes, the property is a file path, and sometimes it's
+     not. Normalize it so it's always a file path. */
+  if (rules[0] == '/')
+    *rules_p = g_strdup (rules);
+  else
+    *rules_p = g_build_filename (XKB_BASE, "rules", rules, NULL);
+
+  free (rules);
+}
+
+static void
+free_xkbrf_var_defs (XkbRF_VarDefsRec *var_defs)
+{
+  free (var_defs->model);
+  free (var_defs->layout);
+  free (var_defs->variant);
+  free (var_defs->options);
+}
+
+static void
+free_xkb_component_names (XkbComponentNamesRec *p)
+{
+  free (p->keymap);
+  free (p->keycodes);
+  free (p->types);
+  free (p->compat);
+  free (p->symbols);
+  free (p->geometry);
+}
+
+static void
+upload_xkb_description (Display              *xdisplay,
+                        const gchar          *rules_file_path,
+                        XkbRF_VarDefsRec     *var_defs,
+                        XkbComponentNamesRec *comp_names)
+{
+  XkbDescRec *xkb_desc;
+  gchar *rules_file;
+
+  /* Upload it to the X server using the same method as setxkbmap */
+  xkb_desc = XkbGetKeyboardByName (xdisplay,
+                                   XkbUseCoreKbd,
+                                   comp_names,
+                                   XkbGBN_AllComponentsMask,
+                                   XkbGBN_AllComponentsMask &
+                                   (~XkbGBN_GeometryMask), True);
+  if (!xkb_desc)
+    {
+      g_warning ("Couldn't upload new XKB keyboard description");
+      return;
+    }
+
+  XkbFreeKeyboard (xkb_desc, 0, True);
+
+  rules_file = g_path_get_basename (rules_file_path);
+
+  if (!XkbRF_SetNamesProp (xdisplay, rules_file, var_defs))
+    g_warning ("Couldn't update the XKB root window property");
+
+  g_free (rules_file);
+}
+
+static void
+meta_backend_x11_set_keymap (MetaBackend *backend,
+                             const char  *layouts,
+                             const char  *variants,
+                             const char  *options)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+  XkbRF_RulesRec *xkb_rules;
+  XkbRF_VarDefsRec xkb_var_defs = { 0 };
+  gchar *rules_file_path;
+
+  get_xkbrf_var_defs (priv->xdisplay,
+                      layouts,
+                      variants,
+                      options,
+                      &rules_file_path,
+                      &xkb_var_defs);
+
+  xkb_rules = XkbRF_Load (rules_file_path, NULL, True, True);
+  if (xkb_rules)
+    {
+      XkbComponentNamesRec xkb_comp_names = { 0 };
+
+      XkbRF_GetComponents (xkb_rules, &xkb_var_defs, &xkb_comp_names);
+      upload_xkb_description (priv->xdisplay, rules_file_path, &xkb_var_defs, &xkb_comp_names);
+
+      free_xkb_component_names (&xkb_comp_names);
+      XkbRF_Free (xkb_rules, True);
+    }
+  else
+    {
+      g_warning ("Couldn't load XKB rules");
+    }
+
+  free_xkbrf_var_defs (&xkb_var_defs);
+  g_free (rules_file_path);
+}
+
+static struct xkb_keymap *
+meta_backend_x11_get_keymap (MetaBackend *backend)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+
+  if (priv->keymap == NULL)
+    {
+      struct xkb_context *context = xkb_context_new (XKB_CONTEXT_NO_FLAGS);
+      priv->keymap = xkb_x11_keymap_new_from_device (context,
+                                                     priv->xcb,
+                                                     xkb_x11_get_core_keyboard_device_id (priv->xcb),
+                                                     XKB_KEYMAP_COMPILE_NO_FLAGS);
+      xkb_context_unref (context);
+    }
+
+  return priv->keymap;
+}
+
+static void
+meta_backend_x11_lock_layout_group (MetaBackend *backend,
+                                    guint        idx)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+
+  XkbLockGroup (priv->xdisplay, XkbUseCoreKbd, idx);
+}
+
+static void
+meta_backend_x11_update_screen_size (MetaBackend *backend,
+                                     int width, int height)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+  Window xwin = meta_backend_x11_get_xwindow (x11);
+  XResizeWindow (priv->xdisplay, xwin, width, height);
+}
+
+static void
+meta_backend_x11_select_stage_events (MetaBackend *backend)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+  Window xwin = meta_backend_x11_get_xwindow (x11);
+  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+
+  XISetMask (mask.mask, XI_KeyPress);
+  XISetMask (mask.mask, XI_KeyRelease);
+  XISetMask (mask.mask, XI_ButtonPress);
+  XISetMask (mask.mask, XI_ButtonRelease);
+  XISetMask (mask.mask, XI_Enter);
+  XISetMask (mask.mask, XI_Leave);
+  XISetMask (mask.mask, XI_FocusIn);
+  XISetMask (mask.mask, XI_FocusOut);
+  XISetMask (mask.mask, XI_Motion);
+  XIClearMask (mask.mask, XI_TouchBegin);
+  XIClearMask (mask.mask, XI_TouchEnd);
+  XIClearMask (mask.mask, XI_TouchUpdate);
+  XISelectEvents (priv->xdisplay, xwin, &mask, 1);
+}
+
 static void
 meta_backend_x11_class_init (MetaBackendX11Class *klass)
 {
@@ -371,10 +670,14 @@ meta_backend_x11_class_init (MetaBackendX11Class *klass)
  backend_class->create_idle_monitor = meta_backend_x11_create_idle_monitor;
  backend_class->create_monitor_manager = meta_backend_x11_create_monitor_manager;
  backend_class->create_cursor_renderer = meta_backend_x11_create_cursor_renderer;
-
  backend_class->grab_device = meta_backend_x11_grab_device;
  backend_class->ungrab_device = meta_backend_x11_ungrab_device;
  backend_class->warp_pointer = meta_backend_x11_warp_pointer;
+  backend_class->set_keymap = meta_backend_x11_set_keymap;
+  backend_class->get_keymap = meta_backend_x11_get_keymap;
+  backend_class->lock_layout_group = meta_backend_x11_lock_layout_group;
+  backend_class->update_screen_size = meta_backend_x11_update_screen_size;
+  backend_class->select_stage_events = meta_backend_x11_select_stage_events;
 }

 static void
@@ -395,12 +698,6 @@ meta_backend_x11_get_xdisplay (MetaBackendX11 *x11)
 Window
 meta_backend_x11_get_xwindow (MetaBackendX11 *x11)
 {
-  MetaDisplay *display = meta_get_display ();
-  MetaCompositor *compositor = display->compositor;
-
-  if (compositor == NULL)
-    return None;
-
-  ClutterStage *stage = CLUTTER_STAGE (compositor->stage);
-  return clutter_x11_get_stage_window (stage);
+  ClutterActor *stage = meta_backend_get_stage (META_BACKEND (x11));
+  return clutter_x11_get_stage_window (CLUTTER_STAGE (stage));
 }
--- a/src/backends/x11/meta-monitor-manager-xrandr.c
+++ b/src/backends/x11/meta-monitor-manager-xrandr.c
@@ -35,6 +35,8 @@
 #include <X11/Xatom.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/dpms.h>
+#include <X11/Xlib-xcb.h>
+#include <xcb/randr.h>

 #include "meta-backend-x11.h"
 #include <meta/main.h>
@@ -42,7 +44,7 @@
 #include "edid.h"
 #include "meta-monitor-config.h"

-#define ALL_WL_TRANSFORMS ((1 << (WL_OUTPUT_TRANSFORM_FLIPPED_270 + 1)) - 1)
+#define ALL_TRANSFORMS ((1 << (META_MONITOR_TRANSFORM_FLIPPED_270 + 1)) - 1)

 /* Look for DPI_FALLBACK in:
 * http://git.gnome.org/browse/gnome-settings-daemon/tree/plugins/xsettings/gsd-xsettings-manager.c
@@ -67,31 +69,31 @@ struct _MetaMonitorManagerXrandrClass

 G_DEFINE_TYPE (MetaMonitorManagerXrandr, meta_monitor_manager_xrandr, META_TYPE_MONITOR_MANAGER);

-static enum wl_output_transform
-wl_transform_from_xrandr (Rotation rotation)
+static MetaMonitorTransform
+meta_monitor_transform_from_xrandr (Rotation rotation)
 {
-  static const enum wl_output_transform y_reflected_map[4] = {
-    WL_OUTPUT_TRANSFORM_FLIPPED_180,
-    WL_OUTPUT_TRANSFORM_FLIPPED_90,
-    WL_OUTPUT_TRANSFORM_FLIPPED,
-    WL_OUTPUT_TRANSFORM_FLIPPED_270
+  static const MetaMonitorTransform y_reflected_map[4] = {
+    META_MONITOR_TRANSFORM_FLIPPED_180,
+    META_MONITOR_TRANSFORM_FLIPPED_90,
+    META_MONITOR_TRANSFORM_FLIPPED,
+    META_MONITOR_TRANSFORM_FLIPPED_270
  };
-  enum wl_output_transform ret;
+  MetaMonitorTransform ret;

  switch (rotation & 0x7F)
    {
    default:
    case RR_Rotate_0:
-      ret = WL_OUTPUT_TRANSFORM_NORMAL;
+      ret = META_MONITOR_TRANSFORM_NORMAL;
      break;
    case RR_Rotate_90:
-      ret = WL_OUTPUT_TRANSFORM_90;
+      ret = META_MONITOR_TRANSFORM_90;
      break;
    case RR_Rotate_180:
-      ret = WL_OUTPUT_TRANSFORM_180;
+      ret = META_MONITOR_TRANSFORM_180;
      break;
    case RR_Rotate_270:
-      ret = WL_OUTPUT_TRANSFORM_270;
+      ret = META_MONITOR_TRANSFORM_270;
      break;
    }

@@ -105,42 +107,42 @@ wl_transform_from_xrandr (Rotation rotation)

 #define ALL_ROTATIONS (RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270)

-static unsigned int
-wl_transform_from_xrandr_all (Rotation rotation)
+static MetaMonitorTransform
+meta_monitor_transform_from_xrandr_all (Rotation rotation)
 {
  unsigned ret;

  /* Handle the common cases first (none or all) */
  if (rotation == 0 || rotation == RR_Rotate_0)
-    return (1 << WL_OUTPUT_TRANSFORM_NORMAL);
+    return (1 << META_MONITOR_TRANSFORM_NORMAL);

  /* All rotations and one reflection -> all of them by composition */
  if ((rotation & ALL_ROTATIONS) &&
      ((rotation & RR_Reflect_X) || (rotation & RR_Reflect_Y)))
-    return ALL_WL_TRANSFORMS;
+    return ALL_TRANSFORMS;

-  ret = 1 << WL_OUTPUT_TRANSFORM_NORMAL;
+  ret = 1 << META_MONITOR_TRANSFORM_NORMAL;
  if (rotation & RR_Rotate_90)
-    ret |= 1 << WL_OUTPUT_TRANSFORM_90;
+    ret |= 1 << META_MONITOR_TRANSFORM_90;
  if (rotation & RR_Rotate_180)
-    ret |= 1 << WL_OUTPUT_TRANSFORM_180;
+    ret |= 1 << META_MONITOR_TRANSFORM_180;
  if (rotation & RR_Rotate_270)
-    ret |= 1 << WL_OUTPUT_TRANSFORM_270;
+    ret |= 1 << META_MONITOR_TRANSFORM_270;
  if (rotation & (RR_Rotate_0 | RR_Reflect_X))
-    ret |= 1 << WL_OUTPUT_TRANSFORM_FLIPPED;
+    ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED;
  if (rotation & (RR_Rotate_90 | RR_Reflect_X))
-    ret |= 1 << WL_OUTPUT_TRANSFORM_FLIPPED_90;
+    ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_90;
  if (rotation & (RR_Rotate_180 | RR_Reflect_X))
-    ret |= 1 << WL_OUTPUT_TRANSFORM_FLIPPED_180;
+    ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_180;
  if (rotation & (RR_Rotate_270 | RR_Reflect_X))
-    ret |= 1 << WL_OUTPUT_TRANSFORM_FLIPPED_270;
+    ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_270;

  return ret;
 }

 static gboolean
-output_get_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
-                                MetaOutput               *output)
+output_get_boolean_property (MetaMonitorManagerXrandr *manager_xrandr,
+                             MetaOutput *output, const char *propname)
 {
  gboolean value;
  Atom atom, actual_type;
@@ -148,9 +150,9 @@ output_get_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
  unsigned long nitems, bytes_after;
  unsigned char *buffer;

-  atom = XInternAtom (manager_xrandr->xdisplay, "_MUTTER_PRESENTATION_OUTPUT", False);
+  atom = XInternAtom (manager_xrandr->xdisplay, propname, False);
  XRRGetOutputProperty (manager_xrandr->xdisplay,
-                        (XID)output->output_id,
+                        (XID)output->winsys_id,
                        atom,
                        0, G_MAXLONG, False, False, XA_CARDINAL,
                        &actual_type, &actual_format,
@@ -166,6 +168,13 @@ output_get_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
  return value;
 }

+static gboolean
+output_get_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
+                                MetaOutput *output)
+{
+  return output_get_boolean_property (manager_xrandr, output, "_MUTTER_PRESENTATION_OUTPUT");
+}
+
 static int
 normalize_backlight (MetaOutput *output,
                     int         hw_value)
@@ -186,7 +195,7 @@ output_get_backlight_xrandr (MetaMonitorManagerXrandr *manager_xrandr,

  atom = XInternAtom (manager_xrandr->xdisplay, "Backlight", False);
  XRRGetOutputProperty (manager_xrandr->xdisplay,
-                        (XID)output->output_id,
+                        (XID)output->winsys_id,
                        atom,
                        0, G_MAXLONG, False, False, XA_INTEGER,
                        &actual_type, &actual_format,
@@ -207,30 +216,34 @@ output_get_backlight_limits_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
                                    MetaOutput               *output)
 {
  Atom atom;
-  XRRPropertyInfo *info;
+  xcb_connection_t *xcb_conn;
+  xcb_randr_query_output_property_reply_t *reply;

  atom = XInternAtom (manager_xrandr->xdisplay, "Backlight", False);
-  info = XRRQueryOutputProperty (manager_xrandr->xdisplay,
-                                 (XID)output->output_id,
-                                 atom);

-  if (info == NULL)
-    {
-      meta_verbose ("could not get output property for %s\n", output->name);
-      return;
-    }
+  xcb_conn = XGetXCBConnection (manager_xrandr->xdisplay);
+  reply = xcb_randr_query_output_property_reply (xcb_conn,
+                                                 xcb_randr_query_output_property (xcb_conn,
+                                                                                  (xcb_randr_output_t) output->winsys_id,
+                                                                                  (xcb_atom_t) atom),
+                                                 NULL);

-  if (!info->range || info->num_values != 2)
+  /* This can happen on systems without backlights. */
+  if (reply == NULL)
+    return;
+
+  if (!reply->range || reply->length != 2)
    {
      meta_verbose ("backlight %s was not range\n", output->name);
      goto out;
    }

-  output->backlight_min = info->values[0];
-  output->backlight_max = info->values[1];
+  int32_t *values = xcb_randr_query_output_property_valid_values (reply);
+  output->backlight_min = values[0];
+  output->backlight_max = values[1];

 out:
-  XFree (info);
+  free (reply);
 }

 static int
@@ -278,25 +291,25 @@ get_edid_property (Display  *dpy,

 static GBytes *
 read_output_edid (MetaMonitorManagerXrandr *manager_xrandr,
-                  XID                       output_id)
+                  XID                       winsys_id)
 {
  Atom edid_atom;
  guint8 *result;
  gsize len;

  edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID", FALSE);
-  result = get_edid_property (manager_xrandr->xdisplay, output_id, edid_atom, &len);
+  result = get_edid_property (manager_xrandr->xdisplay, winsys_id, edid_atom, &len);

  if (!result)
    {
      edid_atom = XInternAtom (manager_xrandr->xdisplay, "EDID_DATA", FALSE);
-      result = get_edid_property (manager_xrandr->xdisplay, output_id, edid_atom, &len);
+      result = get_edid_property (manager_xrandr->xdisplay, winsys_id, edid_atom, &len);
    }

  if (!result)
    {
      edid_atom = XInternAtom (manager_xrandr->xdisplay, "XFree86_DDC_EDID1_RAWDATA", FALSE);
-      result = get_edid_property (manager_xrandr->xdisplay, output_id, edid_atom, &len);
+      result = get_edid_property (manager_xrandr->xdisplay, winsys_id, edid_atom, &len);
    }

  if (result)
@@ -312,26 +325,11 @@ read_output_edid (MetaMonitorManagerXrandr *manager_xrandr,

 static gboolean
 output_get_hotplug_mode_update (MetaMonitorManagerXrandr *manager_xrandr,
-                                XID                       output_id)
+                                MetaOutput               *output)
 {
-  Atom atom;
-  XRRPropertyInfo *info;
-  gboolean result = FALSE;
-
-  atom = XInternAtom (manager_xrandr->xdisplay, "hotplug_mode_update", False);
-  info = XRRQueryOutputProperty (manager_xrandr->xdisplay, output_id,
-                                 atom);
-
-  if (info)
-    {
-      result = TRUE;
-      XFree (info);
-    }
-
-  return result;
+  return output_get_boolean_property (manager_xrandr, output, "hotplug_mode_update");
 }

-
 static void
 meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
 {
@@ -434,8 +432,8 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
      meta_crtc->rect.width = crtc->width;
      meta_crtc->rect.height = crtc->height;
      meta_crtc->is_dirty = FALSE;
-      meta_crtc->transform = wl_transform_from_xrandr (crtc->rotation);
-      meta_crtc->all_transforms = wl_transform_from_xrandr_all (crtc->rotations);
+      meta_crtc->transform = meta_monitor_transform_from_xrandr (crtc->rotation);
+      meta_crtc->all_transforms = meta_monitor_transform_from_xrandr_all (crtc->rotations);

      for (j = 0; j < (unsigned)resources->nmode; j++)
 	{
@@ -467,10 +465,10 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
          GBytes *edid;
          MonitorInfo *parsed_edid;

-	  meta_output->output_id = resources->outputs[i];
+	  meta_output->winsys_id = resources->outputs[i];
 	  meta_output->name = g_strdup (output->name);

-          edid = read_output_edid (manager_xrandr, meta_output->output_id);
+          edid = read_output_edid (manager_xrandr, meta_output->winsys_id);
          if (edid)
            {
              gsize len;
@@ -503,8 +501,7 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
 	  meta_output->width_mm = output->mm_width;
 	  meta_output->height_mm = output->mm_height;
 	  meta_output->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
-          meta_output->hotplug_mode_update =
-              output_get_hotplug_mode_update (manager_xrandr, meta_output->output_id);
+          meta_output->hotplug_mode_update = output_get_hotplug_mode_update (manager_xrandr, meta_output);

 	  meta_output->n_modes = output->nmode;
 	  meta_output->modes = g_new0 (MetaMonitorMode *, meta_output->n_modes);
@@ -556,7 +553,7 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
 	      meta_output->possible_clones[j] = GINT_TO_POINTER (output->clones[j]);
 	    }

-	  meta_output->is_primary = ((XID)meta_output->output_id == primary_output);
+	  meta_output->is_primary = ((XID)meta_output->winsys_id == primary_output);
 	  meta_output->is_presentation = output_get_presentation_xrandr (manager_xrandr, meta_output);
 	  output_get_backlight_limits_xrandr (manager_xrandr, meta_output);

@@ -589,7 +586,7 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)

 	  for (k = 0; k < manager->n_outputs; k++)
 	    {
-	      if (clone == (XID)manager->outputs[k].output_id)
+	      if (clone == (XID)manager->outputs[k].winsys_id)
 		{
 		  meta_output->possible_clones[j] = &manager->outputs[k];
 		  break;
@@ -605,7 +602,7 @@ meta_monitor_manager_xrandr_read_edid (MetaMonitorManager *manager,
 {
  MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);

-  return read_output_edid (manager_xrandr, output->output_id);
+  return read_output_edid (manager_xrandr, output->winsys_id);
 }

 static void
@@ -637,25 +634,25 @@ meta_monitor_manager_xrandr_set_power_save_mode (MetaMonitorManager *manager,
 }

 static Rotation
-wl_transform_to_xrandr (enum wl_output_transform transform)
+meta_monitor_transform_to_xrandr (MetaMonitorTransform transform)
 {
  switch (transform)
    {
-    case WL_OUTPUT_TRANSFORM_NORMAL:
+    case META_MONITOR_TRANSFORM_NORMAL:
      return RR_Rotate_0;
-    case WL_OUTPUT_TRANSFORM_90:
+    case META_MONITOR_TRANSFORM_90:
      return RR_Rotate_90;
-    case WL_OUTPUT_TRANSFORM_180:
+    case META_MONITOR_TRANSFORM_180:
      return RR_Rotate_180;
-    case WL_OUTPUT_TRANSFORM_270:
+    case META_MONITOR_TRANSFORM_270:
      return RR_Rotate_270;
-    case WL_OUTPUT_TRANSFORM_FLIPPED:
+    case META_MONITOR_TRANSFORM_FLIPPED:
      return RR_Reflect_X | RR_Rotate_0;
-    case WL_OUTPUT_TRANSFORM_FLIPPED_90:
+    case META_MONITOR_TRANSFORM_FLIPPED_90:
      return RR_Reflect_X | RR_Rotate_90;
-    case WL_OUTPUT_TRANSFORM_FLIPPED_180:
+    case META_MONITOR_TRANSFORM_FLIPPED_180:
      return RR_Reflect_X | RR_Rotate_180;
-    case WL_OUTPUT_TRANSFORM_FLIPPED_270:
+    case META_MONITOR_TRANSFORM_FLIPPED_270:
      return RR_Reflect_X | RR_Rotate_270;
    }

@@ -672,7 +669,7 @@ output_set_presentation_xrandr (MetaMonitorManagerXrandr *manager_xrandr,

  atom = XInternAtom (manager_xrandr->xdisplay, "_MUTTER_PRESENTATION_OUTPUT", False);
  XRRChangeOutputProperty (manager_xrandr->xdisplay,
-                           (XID)output->output_id,
+                           (XID)output->winsys_id,
                           atom,
                           XA_CARDINAL, 32, PropModeReplace,
                           (unsigned char*) &value, 1);
@@ -828,7 +825,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
              output->crtc = crtc;
              new_controlled_mask |= 1UL << j;

-              outputs[j] = output->output_id;
+              outputs[j] = output->winsys_id;
            }

          if (crtc->current_mode == mode &&
@@ -847,7 +844,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
                                 manager_xrandr->time,
                                 crtc_info->x, crtc_info->y,
                                 (XID)mode->mode_id,
-                                 wl_transform_to_xrandr (crtc_info->transform),
+                                 meta_monitor_transform_to_xrandr (crtc_info->transform),
                                 outputs, n_outputs);

          if (ok != Success)
@@ -891,7 +888,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
        {
          XRRSetOutputPrimary (manager_xrandr->xdisplay,
                               DefaultRootWindow (manager_xrandr->xdisplay),
-                               (XID)output_info->output->output_id);
+                               (XID)output_info->output->winsys_id);
        }

      output_set_presentation_xrandr (manager_xrandr,
@@ -934,7 +931,7 @@ meta_monitor_manager_xrandr_change_backlight (MetaMonitorManager *manager,

  atom = XInternAtom (manager_xrandr->xdisplay, "Backlight", False);
  XRRChangeOutputProperty (manager_xrandr->xdisplay,
-                           (XID)output->output_id,
+                           (XID)output->winsys_id,
                           atom,
                           XA_INTEGER, 32, PropModeReplace,
                           (unsigned char *) &hw_value, 1);
--- a/src/compositor/cogl-utils.c
+++ b/src/compositor/cogl-utils.c
@@ -22,48 +22,6 @@
 #include <clutter/clutter.h>
 #include "cogl-utils.h"

-/**
- * meta_create_color_texture_4ub:
- * @red: red component
- * @green: green component
- * @blue: blue component
- * @alpha: alpha component
- * @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE;
- *   %COGL_TEXTURE_NO_SLICING is useful if the texture will be
- *   repeated to create a constant color fill, since hardware
- *   repeat can't be used for a sliced texture.
- *
- * Creates a texture that is a single pixel with the specified
- * unpremultiplied color components.
- *
- * Return value: (transfer full): a newly created Cogl texture
- */
-CoglTexture *
-meta_create_color_texture_4ub (guint8           red,
-                               guint8           green,
-                               guint8           blue,
-                               guint8           alpha,
-                               CoglTextureFlags flags)
-{
-  CoglColor color;
-  guint8 pixel[4];
-
-  cogl_color_init_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,
-                                     flags,
-                                     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 */

 /**
--- a/src/compositor/cogl-utils.h
+++ b/src/compositor/cogl-utils.h
@@ -23,11 +23,6 @@

 #include <cogl/cogl.h>

-CoglTexture * meta_create_color_texture_4ub (guint8           red,
-                                             guint8           green,
-                                             guint8           blue,
-                                             guint8           alpha,
-                                             CoglTextureFlags flags);
 CoglPipeline * meta_create_texture_pipeline (CoglTexture *texture);

 #endif /* __META_COGL_UTILS_H__ */
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -38,6 +38,8 @@ struct _MetaCompositor
  gint                   switch_workspace_in_progress;

  MetaPluginManager *plugin_mgr;
+
+  gboolean frame_has_updated_xsurfaces;
 };

 /* Wait 2ms after vblank before starting to draw next frame */
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -67,20 +67,19 @@
 #include <meta/compositor-mutter.h>
 #include <meta/prefs.h>
 #include <meta/main.h>
+#include <meta/meta-backend.h>
 #include <meta/meta-background-actor.h>
 #include <meta/meta-background-group.h>
 #include <meta/meta-shadow-factory.h>
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "meta-stage.h"
 #include "window-private.h" /* to check window->hidden */
-#include "display-private.h" /* for meta_display_lookup_x_window() */
+#include "display-private.h" /* for meta_display_lookup_x_window() and meta_display_cancel_touch() */
 #include "util-private.h"
 #include "frame.h"
 #include <X11/extensions/shape.h>
 #include <X11/extensions/Xcomposite.h>

-#include "backends/meta-backend.h"
 #include "backends/x11/meta-backend-x11.h"

 #include "wayland/meta-wayland-private.h"
@@ -88,19 +87,7 @@
 static gboolean
 is_modal (MetaDisplay *display)
 {
-  return display->grab_op == META_GRAB_OP_COMPOSITOR;
-}
-
-static inline gboolean
-composite_at_least_version (MetaDisplay *display, int maj, int min)
-{
-  static int major = -1;
-  static int minor = -1;
-
-  if (major == -1)
-    meta_display_get_compositor_version (display, &major, &minor);
-
-  return (major > maj || (major == maj && minor >= min));
+  return display->event_route == META_EVENT_ROUTE_COMPOSITOR_GRAB;
 }

 static void sync_actor_stacking (MetaCompositor *compositor);
@@ -146,33 +133,8 @@ process_damage (MetaCompositor     *compositor,
 {
  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
  meta_window_actor_process_x11_damage (window_actor, event);
-}

-static Window
-get_output_window (MetaCompositor *compositor)
-{
-  MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ());
-  Display *xdisplay = meta_backend_x11_get_xdisplay (backend);
-  Window output;
-  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-
-  output = XCompositeGetOverlayWindow (xdisplay, DefaultRootWindow (xdisplay));
-
-  meta_core_add_old_event_mask (xdisplay, output, &mask);
-
-  XISetMask (mask.mask, XI_KeyPress);
-  XISetMask (mask.mask, XI_KeyRelease);
-  XISetMask (mask.mask, XI_ButtonPress);
-  XISetMask (mask.mask, XI_ButtonRelease);
-  XISetMask (mask.mask, XI_Enter);
-  XISetMask (mask.mask, XI_Leave);
-  XISetMask (mask.mask, XI_FocusIn);
-  XISetMask (mask.mask, XI_FocusOut);
-  XISetMask (mask.mask, XI_Motion);
-  XISelectEvents (xdisplay, output, &mask, 1);
-
-  return output;
+  compositor->frame_has_updated_xsurfaces = TRUE;
 }

 /* compat helper */
@@ -381,12 +343,20 @@ meta_begin_modal_for_plugin (MetaCompositor   *compositor,
    return FALSE;

  display->grab_op = META_GRAB_OP_COMPOSITOR;
+  display->event_route = META_EVENT_ROUTE_COMPOSITOR_GRAB;
  display->grab_window = NULL;
  display->grab_have_pointer = TRUE;
  display->grab_have_keyboard = TRUE;

+  g_signal_emit_by_name (display, "grab-op-begin",
+                         meta_plugin_get_screen (plugin),
+                         display->grab_window, display->grab_op);
+
  if (meta_is_wayland_compositor ())
-    meta_display_sync_wayland_input_focus (display);
+    {
+      meta_display_sync_wayland_input_focus (display);
+      meta_display_cancel_touch (display);
+    }

  return TRUE;
 }
@@ -401,7 +371,12 @@ meta_end_modal_for_plugin (MetaCompositor *compositor,

  g_return_if_fail (is_modal (display));

+  g_signal_emit_by_name (display, "grab-op-end",
+                         meta_plugin_get_screen (plugin),
+                         display->grab_window, display->grab_op);
+
  display->grab_op = META_GRAB_OP_NONE;
+  display->event_route = META_EVENT_ROUTE_NORMAL;
  display->grab_window = NULL;
  display->grab_have_pointer = FALSE;
  display->grab_have_keyboard = FALSE;
@@ -423,8 +398,10 @@ after_stage_paint (ClutterStage *stage,
  for (l = compositor->windows; l; l = l->next)
    meta_window_actor_post_paint (l->data);

+#ifdef HAVE_WAYLAND
  if (meta_is_wayland_compositor ())
    meta_wayland_compositor_paint_finished (meta_wayland_compositor_get_default ());
+#endif
 }

 static void
@@ -476,62 +453,24 @@ meta_compositor_manage (MetaCompositor *compositor)
  MetaDisplay *display = compositor->display;
  Display *xdisplay = display->xdisplay;
  MetaScreen *screen = display->screen;
-  Window xwin = 0;
-  gint width, height;

  meta_screen_set_cm_selection (display->screen);

-  if (meta_is_wayland_compositor ())
-    {
-      MetaWaylandCompositor *wayland_compositor = meta_wayland_compositor_get_default ();
+  {
+    MetaBackend *backend = meta_get_backend ();
+    compositor->stage = meta_backend_get_stage (backend);
+  }

-      compositor->stage = meta_stage_new ();
-      clutter_actor_show (compositor->stage);
-
-      wayland_compositor->stage = compositor->stage;
-
-      meta_screen_get_size (screen, &width, &height);
-      clutter_actor_set_size (compositor->stage, width, height);
-    }
-  else
-    {
-      compositor->stage = clutter_stage_new ();
-
-      meta_screen_get_size (screen, &width, &height);
-      clutter_actor_realize (compositor->stage);
-
-      xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (compositor->stage));
-
-      XResizeWindow (xdisplay, xwin, width, height);
-
-        {
-          MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ());
-          Display *backend_xdisplay = meta_backend_x11_get_xdisplay (backend);
-          unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-          XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-
-          meta_core_add_old_event_mask (backend_xdisplay, xwin, &mask);
-
-          XISetMask (mask.mask, XI_KeyPress);
-          XISetMask (mask.mask, XI_KeyRelease);
-          XISetMask (mask.mask, XI_ButtonPress);
-          XISetMask (mask.mask, XI_ButtonRelease);
-          XISetMask (mask.mask, XI_Enter);
-          XISetMask (mask.mask, XI_Leave);
-          XISetMask (mask.mask, XI_FocusIn);
-          XISetMask (mask.mask, XI_FocusOut);
-          XISetMask (mask.mask, XI_Motion);
-          XIClearMask (mask.mask, XI_TouchBegin);
-          XIClearMask (mask.mask, XI_TouchEnd);
-          XIClearMask (mask.mask, XI_TouchUpdate);
-          XISelectEvents (backend_xdisplay, xwin, &mask, 1);
-        }
-    }
-
-  clutter_stage_set_paint_callback (CLUTTER_STAGE (compositor->stage),
-                                    after_stage_paint,
-                                    compositor,
-                                    NULL);
+  /* We use connect_after() here to accomodate code in GNOME Shell that,
+   * when benchmarking drawing performance, connects to ::after-paint
+   * and calls glFinish(). The timing information from that will be
+   * more accurate if we hold off until that completes before we signal
+   * apps to begin drawing the next frame. If there are no other
+   * connections to ::after-paint, connect() vs. connect_after() doesn't
+   * matter.
+   */
+  g_signal_connect_after (CLUTTER_STAGE (compositor->stage), "after-paint",
+                          G_CALLBACK (after_stage_paint), compositor);

  clutter_stage_set_sync_delay (CLUTTER_STAGE (compositor->stage), META_SYNC_DELAY);

@@ -550,7 +489,12 @@ meta_compositor_manage (MetaCompositor *compositor)
    }
  else
    {
-      compositor->output = get_output_window (compositor);
+      Window xwin;
+
+      compositor->output = screen->composite_overlay_window;
+
+      xwin = meta_backend_x11_get_xwindow (META_BACKEND_X11 (meta_get_backend ()));
+
      XReparentWindow (xdisplay, xwin, compositor->output, 0, 0);

      meta_empty_stage_input_region (screen);
@@ -691,12 +635,11 @@ meta_compositor_remove_window (MetaCompositor *compositor,
 }

 void
-meta_compositor_set_updates_frozen (MetaCompositor *compositor,
-                                    MetaWindow     *window,
-                                    gboolean        updates_frozen)
+meta_compositor_sync_updates_frozen (MetaCompositor *compositor,
+                                     MetaWindow     *window)
 {
  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  meta_window_actor_set_updates_frozen (window_actor, updates_frozen);
+  meta_window_actor_sync_updates_frozen (window_actor);
 }

 void
@@ -756,9 +699,6 @@ meta_compositor_process_event (MetaCompositor *compositor,
                               XEvent         *event,
                               MetaWindow     *window)
 {
-  if (meta_plugin_manager_xevent_filter (compositor->plugin_mgr, event))
-    return TRUE;
-
  if (!meta_is_wayland_compositor () &&
      event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
    {
@@ -1046,43 +986,6 @@ meta_compositor_sync_window_geometry (MetaCompositor *compositor,
  meta_window_actor_sync_actor_geometry (window_actor, did_placement);
 }

-void
-meta_compositor_sync_screen_size (MetaCompositor  *compositor,
-				  guint		   width,
-				  guint		   height)
-{
-  MetaDisplay *display = compositor->display;
-
-  if (meta_is_wayland_compositor ())
-    {
-      /* FIXME: when we support a sliced stage, this is the place to do it
-         But! This is not the place to apply KMS config, here we only
-         notify Clutter/Cogl/GL that the framebuffer sizes changed.
-
-         And because for now clutter does not do sliced, we use one
-         framebuffer the size of the whole screen, and when running on
-         bare metal MetaMonitorManager will do the necessary tricks to
-         show the right portions on the right screens.
-      */
-
-      clutter_actor_set_size (compositor->stage, width, height);
-    }
-  else
-    {
-      Display        *xdisplay;
-      Window          xwin;
-
-      xdisplay = meta_display_get_xdisplay (display);
-      xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (compositor->stage));
-
-      XResizeWindow (xdisplay, xwin, width, height);
-    }
-
-  meta_verbose ("Changed size for stage on screen %d to %dx%d\n",
-                meta_screen_get_screen_number (display->screen),
-                width, height);
-}
-
 static void
 frame_callback (CoglOnscreen  *onscreen,
                CoglFrameEvent event,
@@ -1153,6 +1056,33 @@ pre_paint_windows (MetaCompositor *compositor)

  for (l = compositor->windows; l; l = l->next)
    meta_window_actor_pre_paint (l->data);
+
+  if (compositor->frame_has_updated_xsurfaces)
+    {
+      /* We need to make sure that any X drawing that happens before
+       * the XDamageSubtract() for each window above is visible to
+       * subsequent GL rendering; the only standardized way to do this
+       * is EXT_x11_sync_object, which isn't yet widely available. For
+       * now, we count on details of Xorg and the open source drivers,
+       * and hope for the best otherwise.
+       *
+       * Xorg and open source driver specifics:
+       *
+       * The X server makes sure to flush drawing to the kernel before
+       * sending out damage events, but since we use
+       * DamageReportBoundingBox there may be drawing between the last
+       * damage event and the XDamageSubtract() that needs to be
+       * flushed as well.
+       *
+       * Xorg always makes sure that drawing is flushed to the kernel
+       * before writing events or responses to the client, so any
+       * round trip request at this point is sufficient to flush the
+       * GLX buffers.
+       */
+      XSync (compositor->display->xdisplay, False);
+
+      compositor->frame_has_updated_xsurfaces = FALSE;
+    }
 }

 static gboolean
@@ -1183,11 +1113,7 @@ meta_compositor_new (MetaDisplay *display)
 {
  MetaCompositor        *compositor;

-  if (!composite_at_least_version (display, 0, 3))
-    return NULL;
-
  compositor = g_new0 (MetaCompositor, 1);
-
  compositor->display = display;

  if (g_getenv("META_DISABLE_MIPMAPS"))
@@ -1366,3 +1292,12 @@ meta_compositor_show_window_menu (MetaCompositor     *compositor,
 {
  meta_plugin_manager_show_window_menu (compositor->plugin_mgr, window, menu, x, y);
 }
+
+void
+meta_compositor_show_window_menu_for_rect (MetaCompositor     *compositor,
+                                           MetaWindow         *window,
+                                           MetaWindowMenuType  menu,
+					   MetaRectangle      *rect)
+{
+  meta_plugin_manager_show_window_menu_for_rect (compositor->plugin_mgr, window, menu, rect);
+}
--- a/src/compositor/meta-background-actor.c
+++ b/src/compositor/meta-background-actor.c
@@ -185,7 +185,7 @@ cullable_iface_init (MetaCullableInterface *iface)
 * meta_background_actor_get_clip_region:
 * @self: a #MetaBackgroundActor
 *
- * Return value (transfer full): a #cairo_region_t that represents the part of
+ * Return value (transfer none): a #cairo_region_t that represents the part of
 * the background not obscured by other #MetaBackgroundActor or
 * #MetaWindowActor objects.
 */
@@ -193,24 +193,5 @@ cairo_region_t *
 meta_background_actor_get_clip_region (MetaBackgroundActor *self)
 {
  MetaBackgroundActorPrivate *priv = self->priv;
-  ClutterActorBox content_box;
-  cairo_rectangle_int_t content_area = { 0 };
-  cairo_region_t *clip_region;
-
-  g_return_val_if_fail (META_IS_BACKGROUND_ACTOR (self), NULL);
-
-  if (!priv->clip_region)
-      return NULL;
-
-  clutter_actor_get_content_box (CLUTTER_ACTOR (self), &content_box);
-
-  content_area.x = content_box.x1;
-  content_area.y = content_box.y1;
-  content_area.width = content_box.x2 - content_box.x1;
-  content_area.height = content_box.y2 - content_box.y1;
-
-  clip_region = cairo_region_create_rectangle (&content_area);
-  cairo_region_intersect (clip_region, priv->clip_region);
-
-  return clip_region;
+  return priv->clip_region;
 }
--- a/src/compositor/meta-background.c
+++ b/src/compositor/meta-background.c
@@ -288,6 +288,26 @@ get_wrap_mode (MetaBackground *self)
    }
 }

+static gboolean
+texture_has_alpha (CoglTexture *texture)
+{
+  if (!texture)
+    return FALSE;
+
+  switch (cogl_texture_get_components (texture))
+    {
+    case COGL_TEXTURE_COMPONENTS_A:
+    case COGL_TEXTURE_COMPONENTS_RGBA:
+      return TRUE;
+    case COGL_TEXTURE_COMPONENTS_RG:
+    case COGL_TEXTURE_COMPONENTS_RGB:
+    case COGL_TEXTURE_COMPONENTS_DEPTH:
+      return FALSE;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
 static ClutterPaintNode *
 meta_background_paint_node_new (MetaBackground *self,
                                ClutterActor   *actor)
@@ -296,6 +316,7 @@ meta_background_paint_node_new (MetaBackground *self,
  ClutterPaintNode *node;
  guint8 opacity;
  guint8 color_component;
+  gboolean needs_blending;

  opacity = clutter_actor_get_paint_opacity (actor);
  color_component = (guint8) (0.5 + opacity * priv->brightness);
@@ -308,6 +329,13 @@ meta_background_paint_node_new (MetaBackground *self,

  node = clutter_pipeline_node_new (priv->pipeline);

+  needs_blending = (opacity < 255) || (texture_has_alpha (priv->texture));
+
+  if (needs_blending)
+    cogl_pipeline_set_blend (priv->pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))", NULL);
+  else
+    cogl_pipeline_set_blend (priv->pipeline, "RGBA = ADD (SRC_COLOR, 0)", NULL);
+
  return node;
 }

@@ -382,8 +410,6 @@ meta_background_paint_content (ClutterContent   *content,
  if (priv->texture == NULL)
    return;

-  node = meta_background_paint_node_new (self, actor);
-
  clutter_actor_get_content_box (actor, &actor_box);

  /* First figure out where on the monitor the texture is supposed to be painted.
@@ -413,12 +439,14 @@ meta_background_paint_content (ClutterContent   *content,
      clip_region = meta_background_actor_get_clip_region (META_BACKGROUND_ACTOR (actor));

      if (clip_region != NULL)
-        {
-          cairo_region_intersect (paintable_region, clip_region);
-          cairo_region_destroy (clip_region);
-        }
+        cairo_region_intersect (paintable_region, clip_region);
    }

+  if (cairo_region_is_empty (paintable_region))
+    goto out;
+
+  node = meta_background_paint_node_new (self, actor);
+
  /* Finally, split the paintable region up into distinct areas
   * and paint each area one by one
   */
@@ -441,10 +469,11 @@ meta_background_paint_content (ClutterContent   *content,

      clutter_paint_node_add_texture_rectangle (node, &texture_rectangle, tx1, ty1, tx2, ty2);
    }
-  cairo_region_destroy (paintable_region);
-
  clutter_paint_node_add_child (root, node);
  clutter_paint_node_unref (node);
+
+ out:
+  cairo_region_destroy (paintable_region);
 }

 static void
@@ -498,7 +527,8 @@ set_brightness (MetaBackground *self,

  priv->brightness = brightness;

-  if (priv->effects & META_BACKGROUND_EFFECTS_VIGNETTE)
+  if (clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL) &&
+      priv->effects & META_BACKGROUND_EFFECTS_VIGNETTE)
    {
      ensure_pipeline (self);
      cogl_pipeline_set_uniform_1f (priv->pipeline,
@@ -506,6 +536,14 @@ set_brightness (MetaBackground *self,
                                                                        "brightness"),
                                    priv->brightness);
    }
+  else
+    {
+      ensure_pipeline (self);
+      CoglColor blend_color;
+      cogl_color_init_from_4f (&blend_color, brightness, brightness, brightness, 1.0);
+      cogl_pipeline_set_layer_combine (priv->pipeline, 1, "RGB=MODULATE(PREVIOUS, CONSTANT) A=REPLACE(PREVIOUS)", NULL);
+      cogl_pipeline_set_layer_combine_constant (priv->pipeline, 1, &blend_color);
+    }

  clutter_content_invalidate (CLUTTER_CONTENT (self));

@@ -523,6 +561,9 @@ set_vignette_sharpness (MetaBackground *self,

  priv->vignette_sharpness = sharpness;

+  if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
+    return;
+
  if (priv->effects & META_BACKGROUND_EFFECTS_VIGNETTE)
    {
      ensure_pipeline (self);
@@ -543,6 +584,9 @@ add_vignette (MetaBackground *self)
  MetaBackgroundPrivate *priv = self->priv;
  static CoglSnippet *snippet = NULL;

+  if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
+    return;
+
  ensure_pipeline (self);

  /* Cogl automatically caches pipelines with no eviction policy,
@@ -770,6 +814,8 @@ meta_background_load_gradient (MetaBackground             *self,
                               ClutterColor               *color,
                               ClutterColor               *second_color)
 {
+  ClutterBackend *backend = clutter_get_default_backend ();
+  CoglContext *ctx = clutter_backend_get_cogl_context (backend);
  MetaBackgroundPrivate *priv = self->priv;
  CoglTexture *texture;
  guint width, height;
@@ -799,18 +845,17 @@ meta_background_load_gradient (MetaBackground             *self,
  pixels[0] = color->red;
  pixels[1] = color->green;
  pixels[2] = color->blue;
-  pixels[3] = color->alpha;
+  pixels[3] = 0xFF;
  pixels[4] = second_color->red;
  pixels[5] = second_color->green;
  pixels[6] = second_color->blue;
-  pixels[7] = second_color->alpha;
+  pixels[7] = 0xFF;

-  texture = cogl_texture_new_from_data (width, height,
-                                        COGL_TEXTURE_NO_SLICING,
-                                        COGL_PIXEL_FORMAT_RGBA_8888,
-                                        COGL_PIXEL_FORMAT_ANY,
-                                        4,
-                                        pixels);
+  texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, width, height,
+                                                         COGL_PIXEL_FORMAT_RGB_888,
+                                                         4,
+                                                         pixels,
+                                                         NULL));
  set_texture (self, COGL_TEXTURE (texture));
 }

@@ -828,10 +873,13 @@ void
 meta_background_load_color (MetaBackground *self,
                            ClutterColor   *color)
 {
+  ClutterBackend *backend = clutter_get_default_backend ();
+  CoglContext *ctx = clutter_backend_get_cogl_context (backend);
  MetaBackgroundPrivate *priv = self->priv;
  CoglTexture  *texture;
  ClutterActor *stage = meta_get_stage_for_screen (priv->screen);
  ClutterColor  stage_color;
+  uint8_t pixels[4];

  ensure_pipeline (self);

@@ -844,11 +892,16 @@ meta_background_load_color (MetaBackground *self,
      color = &stage_color;
    }

-  texture = meta_create_color_texture_4ub (color->red,
-                                           color->green,
-                                           color->blue,
-                                           0xff,
-                                           COGL_TEXTURE_NO_SLICING);
+  pixels[0] = color->red;
+  pixels[1] = color->green;
+  pixels[2] = color->blue;
+  pixels[3] = 0xFF;
+
+  texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, 1, 1,
+                                                         COGL_PIXEL_FORMAT_RGB_888,
+                                                         4,
+                                                         pixels,
+                                                         NULL));
  set_texture (self, COGL_TEXTURE (texture));
 }

@@ -946,6 +999,8 @@ meta_background_load_file_finish (MetaBackground  *self,
                                  GAsyncResult    *result,
                                  GError         **error)
 {
+  ClutterBackend *backend = clutter_get_default_backend ();
+  CoglContext *ctx = clutter_backend_get_cogl_context (backend);
  GTask *task;
  LoadFileTaskData *task_data;
  CoglTexture *texture;
@@ -954,6 +1009,7 @@ meta_background_load_file_finish (MetaBackground  *self,
  guchar *pixels;
  gboolean has_alpha;
  gboolean loaded = FALSE;
+  CoglPixelFormat pixel_format;

  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);

@@ -972,15 +1028,13 @@ meta_background_load_file_finish (MetaBackground  *self,
  pixels = gdk_pixbuf_get_pixels (pixbuf);
  has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);

-  texture = cogl_texture_new_from_data (width,
-                                        height,
-                                        COGL_TEXTURE_NO_ATLAS,
-                                        has_alpha ?
-                                        COGL_PIXEL_FORMAT_RGBA_8888 :
-                                        COGL_PIXEL_FORMAT_RGB_888,
-                                        COGL_PIXEL_FORMAT_ANY,
-                                        row_stride,
-                                        pixels);
+  pixel_format = has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888;
+
+  texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, width, height,
+                                                         pixel_format,
+                                                         row_stride,
+                                                         pixels,
+                                                         NULL));

  if (texture == NULL)
    {
--- a/src/compositor/meta-module.c
+++ b/src/compositor/meta-module.c
@@ -20,6 +20,7 @@
 */

 #include <meta/meta-plugin.h>
+#include <meta/meta-version.h>
 #include "meta-module.h"

 #include <gmodule.h>
@@ -68,7 +69,7 @@ meta_module_load (GTypeModule *gmodule)
 		       (gpointer *)(void *)&register_type) &&
      info && register_type)
    {
-      if (info->version_api != MUTTER_PLUGIN_API_VERSION)
+      if (info->version_api != META_PLUGIN_API_VERSION)
 	g_warning ("Plugin API mismatch for [%s]", priv->path);
      else
        {
--- a/src/compositor/meta-plugin-manager.c
+++ b/src/compositor/meta-plugin-manager.c
@@ -170,6 +170,15 @@ meta_plugin_manager_event_simple (MetaPluginManager *plugin_mgr,
          klass->minimize (plugin, actor);
        }
      break;
+    case META_PLUGIN_UNMINIMIZE:
+      if (klass->unminimize)
+        {
+          retval = TRUE;
+          meta_plugin_manager_kill_window_effects (plugin_mgr,
+                                                   actor);
+          klass->unminimize (plugin, actor);
+        }
+      break;
    case META_PLUGIN_MAP:
      if (klass->map)
        {
@@ -374,3 +383,20 @@ meta_plugin_manager_show_window_menu (MetaPluginManager  *plugin_mgr,
  if (klass->show_window_menu)
    klass->show_window_menu (plugin, window, menu, x, y);
 }
+
+void
+meta_plugin_manager_show_window_menu_for_rect (MetaPluginManager  *plugin_mgr,
+                                               MetaWindow         *window,
+                                               MetaWindowMenuType  menu,
+					       MetaRectangle      *rect)
+{
+  MetaPlugin *plugin = plugin_mgr->plugin;
+  MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
+  MetaDisplay *display = plugin_mgr->compositor->display;
+
+  if (display->display_opening)
+    return;
+
+  if (klass->show_window_menu_for_rect)
+    klass->show_window_menu_for_rect (plugin, window, menu, rect);
+}
--- a/src/compositor/meta-plugin-manager.h
+++ b/src/compositor/meta-plugin-manager.h
@@ -35,6 +35,7 @@
 #define META_PLUGIN_MAP              (1<<3)
 #define META_PLUGIN_DESTROY          (1<<4)
 #define META_PLUGIN_SWITCH_WORKSPACE (1<<5)
+#define META_PLUGIN_UNMINIMIZE       (1<<6)

 #define META_PLUGIN_ALL_EFFECTS      (~0)

@@ -87,5 +88,10 @@ void meta_plugin_manager_show_window_menu (MetaPluginManager  *mgr,
                                           int                 x,
                                           int                 y);

+void meta_plugin_manager_show_window_menu_for_rect (MetaPluginManager  *mgr,
+		                                    MetaWindow         *window,
+						    MetaWindowMenuType  menu,
+						    MetaRectangle      *rect);
+

 #endif
--- a/src/compositor/meta-plugin.c
+++ b/src/compositor/meta-plugin.c
@@ -110,6 +110,13 @@ meta_plugin_minimize_completed (MetaPlugin      *plugin,
  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_MINIMIZE);
 }

+void
+meta_plugin_unminimize_completed (MetaPlugin      *plugin,
+                                  MetaWindowActor *actor)
+{
+  meta_plugin_window_effect_completed (plugin, actor, META_PLUGIN_UNMINIMIZE);
+}
+
 void
 meta_plugin_maximize_completed (MetaPlugin      *plugin,
                                MetaWindowActor *actor)
--- a/src/compositor/meta-shadow-factory.c
+++ b/src/compositor/meta-shadow-factory.c
@@ -121,17 +121,17 @@ 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",       { 6, -1, 0, 3, 128 }, { 3, -1, 0, 3, 32 } },
-  { "dialog",       { 6, -1, 0, 3, 128 }, { 3, -1, 0, 3, 32 } },
-  { "modal_dialog", { 6, -1, 0, 1, 128 }, { 3, -1, 0, 3, 32 } },
+  { "normal",       { 3, -1, 0, 3, 128 }, { 3, -1, 0, 3, 32 } },
+  { "dialog",       { 3, -1, 0, 3, 128 }, { 3, -1, 0, 3, 32 } },
+  { "modal_dialog", { 3, -1, 0, 1, 128 }, { 3, -1, 0, 3, 32 } },
  { "utility",      { 3, -1, 0, 1, 128 }, { 3, -1, 0, 1, 32 } },
-  { "border",       { 6, -1, 0, 3, 128 }, { 3, -1, 0, 3, 32 } },
-  { "menu",         { 6, -1, 0, 3, 128 }, { 3, -1, 0, 0, 32 } },
+  { "border",       { 3, -1, 0, 3, 128 }, { 3, -1, 0, 3, 32 } },
+  { "menu",         { 3, -1, 0, 3, 128 }, { 3, -1, 0, 0, 32 } },

-  { "popup-menu",    { 1, -1, 0, 1, 128 }, { 1, -1, 0, 1, 128 } },
+  { "popup-menu",    { 1, 0, 0, 1, 128 }, { 1, -1, 0, 1, 128 } },

  { "dropdown-menu", { 1, 10, 0, 1, 128 }, { 1, 10, 0, 1, 128 } },
-  { "attached",      { 1, -1, 0, 1, 128 }, { 1, -1, 0, 1, 128 } }
+  { "attached",      { 1, 0, 0, 1, 128 }, { 1, -1, 0, 1, 128 } }
 };

 G_DEFINE_TYPE (MetaShadowFactory, meta_shadow_factory, G_TYPE_OBJECT);
@@ -496,7 +496,12 @@ get_box_filter_size (int radius)
 static int
 get_shadow_spread (int radius)
 {
-  int d = get_box_filter_size (radius);
+  int d;
+
+  if (radius == 0)
+    return 0;
+
+  d = get_box_filter_size (radius);

  if (d % 2 == 1)
    return 3 * (d / 2);
@@ -536,7 +541,7 @@ blur_xspan (guchar *row,
   * 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
+   * to be the integer division per 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.)
@@ -544,27 +549,27 @@ blur_xspan (guchar *row,
  for (i = x0 - d + offset; i < x1 + offset; i++)
    {
      if (i >= 0 && i < row_width)
-	sum += row[i];
+        sum += row[i];

      if (i >= x0 + offset)
-	{
-	  if (i >= d)
-	    sum -= row[i - d];
+        {
+          if (i >= d)
+            sum -= row[i - d];

-	  tmp_buffer[i - offset] = (sum + d / 2) / d;
-	}
+          tmp_buffer[i - offset] = (sum + d / 2) / d;
+        }
    }

-  memcpy(row + x0, tmp_buffer + x0, x1 - x0);
+  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,
+           guchar           *buffer,
+           int               buffer_width,
+           int               buffer_height,
           int               d)
 {
  int i, j;
@@ -581,30 +586,30 @@ blur_rows (cairo_region_t   *convolve_region,
      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;
+        {
+          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)
+           * (technique 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);
-	    }
-	}
+          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);
@@ -629,7 +634,7 @@ fade_bytes (guchar *bytes,
 */
 static guchar *
 flip_buffer (guchar *buffer,
-	     int     width,
+             int     width,
             int     height)
 {
  /* Working in blocks increases cache efficiency, compared to reading
@@ -641,33 +646,33 @@ flip_buffer (guchar *buffer,
      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;
+        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;
-		    }
-	      }
-	  }
+            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;
    }
@@ -678,15 +683,15 @@ flip_buffer (guchar *buffer,

      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;
+          {
+            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];
-	  }
+                new_buffer[i * height + j] = buffer[j * width + i];
+          }

      g_free (buffer);

@@ -699,6 +704,8 @@ static void
 make_shadow (MetaShadow     *shadow,
             cairo_region_t *region)
 {
+  ClutterBackend *backend = clutter_get_default_backend ();
+  CoglContext *ctx = clutter_backend_get_cogl_context (backend);
  int d = get_box_filter_size (shadow->key.radius);
  int spread = get_shadow_spread (shadow->key.radius);
  cairo_rectangle_int_t extents;
@@ -758,7 +765,7 @@ make_shadow (MetaShadow     *shadow,

      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);
+        memset (buffer + buffer_width * j + x_offset + rect.x, 255, rect.width);
    }

  /* Step 2: swap rows and columns */
@@ -788,15 +795,15 @@ make_shadow (MetaShadow     *shadow,
   * 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)));
+  shadow->texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx,
+                                                                 shadow->outer_border_left + extents.width + shadow->outer_border_right,
+                                                                 shadow->outer_border_top + extents.height + shadow->outer_border_bottom,
+                                                                 COGL_PIXEL_FORMAT_A_8,
+                                                                 buffer_width,
+                                                                 (buffer +
+                                                                  (y_offset - shadow->outer_border_top) * buffer_width +
+                                                                  (x_offset - shadow->outer_border_left)),
+                                                                 NULL));

  cairo_region_destroy (row_convolve_region);
  cairo_region_destroy (column_convolve_region);
--- a/src/compositor/meta-shaped-texture-private.h
+++ b/src/compositor/meta-shaped-texture-private.h
@@ -32,8 +32,6 @@
 ClutterActor *meta_shaped_texture_new (void);
 void meta_shaped_texture_set_texture (MetaShapedTexture *stex,
                                      CoglTexture       *texture);
-gboolean meta_shaped_texture_get_unobscured_bounds (MetaShapedTexture     *stex,
-                                                    cairo_rectangle_int_t *unobscured_bounds);
 gboolean meta_shaped_texture_is_obscured (MetaShapedTexture *self);

 #endif
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -65,6 +65,14 @@ G_DEFINE_TYPE_WITH_CODE (MetaShapedTexture, meta_shaped_texture, CLUTTER_TYPE_AC
  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_SHAPED_TEXTURE, \
                                MetaShapedTexturePrivate))

+enum {
+  SIZE_CHANGED,
+
+  LAST_SIGNAL,
+};
+
+static guint signals[LAST_SIGNAL];
+
 struct _MetaShapedTexturePrivate
 {
  MetaTextureTower *paint_tower;
@@ -97,6 +105,13 @@ meta_shaped_texture_class_init (MetaShapedTextureClass *klass)
  actor_class->paint = meta_shaped_texture_paint;
  actor_class->get_paint_volume = meta_shaped_texture_get_paint_volume;

+  signals[SIZE_CHANGED] = g_signal_new ("size-changed",
+                                        G_TYPE_FROM_CLASS (gobject_class),
+                                        G_SIGNAL_RUN_LAST,
+                                        0,
+                                        NULL, NULL, NULL,
+                                        G_TYPE_NONE, 0);
+
  g_type_class_add_private (klass, sizeof (MetaShapedTexturePrivate));
 }

@@ -249,22 +264,20 @@ set_cogl_texture (MetaShapedTexture *stex,
      cogl_object_ref (cogl_tex);
      width = cogl_texture_get_width (COGL_TEXTURE (cogl_tex));
      height = cogl_texture_get_height (COGL_TEXTURE (cogl_tex));
-
-      if (width != priv->tex_width ||
-          height != priv->tex_height)
-        {
-          priv->tex_width = width;
-          priv->tex_height = height;
-
-          clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
-        }
    }
  else
    {
-      /* size changed to 0 going to an invalid handle */
-      priv->tex_width = 0;
-      priv->tex_height = 0;
+      width = 0;
+      height = 0;
+    }
+
+  if (priv->tex_width != width ||
+      priv->tex_height != height)
+    {
+      priv->tex_width = width;
+      priv->tex_height = height;
      clutter_actor_queue_relayout (CLUTTER_ACTOR (stex));
+      g_signal_emit (stex, signals[SIZE_CHANGED], 0);
    }

  /* NB: We don't queue a redraw of the actor here because we don't
@@ -497,37 +510,63 @@ meta_shaped_texture_get_preferred_height (ClutterActor *self,
    *natural_height_p = priv->tex_height;
 }

+static cairo_region_t *
+effective_unobscured_region (MetaShapedTexture *self)
+{
+  MetaShapedTexturePrivate *priv = self->priv;
+  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR (self));
+
+  if (clutter_actor_has_mapped_clones (CLUTTER_ACTOR (self)))
+    return NULL;
+
+  while (parent && !META_IS_WINDOW_ACTOR (parent))
+    parent = clutter_actor_get_parent (parent);
+
+  if (parent && clutter_actor_has_mapped_clones (parent))
+    return NULL;
+
+  return priv->unobscured_region;
+}
+
+static gboolean
+get_unobscured_bounds (MetaShapedTexture     *self,
+                       cairo_rectangle_int_t *unobscured_bounds)
+{
+  cairo_region_t *unobscured_region = effective_unobscured_region (self);
+
+  if (unobscured_region)
+    {
+      cairo_region_get_extents (unobscured_region, unobscured_bounds);
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
 static gboolean
 meta_shaped_texture_get_paint_volume (ClutterActor *actor,
                                      ClutterPaintVolume *volume)
 {
  MetaShapedTexture *self = META_SHAPED_TEXTURE (actor);
+  ClutterActorBox box;
  cairo_rectangle_int_t unobscured_bounds;

-  if (!clutter_paint_volume_set_from_allocation (volume, actor))
+  if (!clutter_actor_has_allocation (actor))
    return FALSE;

-  if (meta_shaped_texture_get_unobscured_bounds (self, &unobscured_bounds))
+  clutter_actor_get_allocation_box (actor, &box);
+
+  if (get_unobscured_bounds (self, &unobscured_bounds))
    {
-      ClutterVertex origin;
-      cairo_rectangle_int_t bounds;
-
-      /* I hate ClutterPaintVolume so much... */
-      clutter_paint_volume_get_origin (volume, &origin);
-      bounds.x = origin.x;
-      bounds.y = origin.y;
-      bounds.width = clutter_paint_volume_get_width (volume);
-      bounds.height = clutter_paint_volume_get_height (volume);
-
-      gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
-
-      origin.x = bounds.x;
-      origin.y = bounds.y;
-      clutter_paint_volume_set_origin (volume, &origin);
-      clutter_paint_volume_set_width (volume, bounds.width);
-      clutter_paint_volume_set_height (volume, bounds.height);
+      box.x1 = MAX (unobscured_bounds.x, box.x1);
+      box.x2 = MIN (unobscured_bounds.x + unobscured_bounds.width, box.x2);
+      box.y1 = MAX (unobscured_bounds.y, box.y1);
+      box.y2 = MIN (unobscured_bounds.y + unobscured_bounds.height, box.y2);
    }
+  box.x2 = MAX (box.x2, box.x1);
+  box.y2 = MAX (box.y2, box.y1);

+  clutter_paint_volume_union_box (volume, &box);
  return TRUE;
 }

@@ -573,39 +612,6 @@ meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

-static cairo_region_t *
-effective_unobscured_region (MetaShapedTexture *self)
-{
-  MetaShapedTexturePrivate *priv = self->priv;
-  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR (self));
-
-  if (clutter_actor_has_mapped_clones (CLUTTER_ACTOR (self)))
-    return NULL;
-
-  while (parent && !META_IS_WINDOW_ACTOR (parent))
-    parent = clutter_actor_get_parent (parent);
-
-  if (parent && clutter_actor_has_mapped_clones (parent))
-    return NULL;
-
-  return priv->unobscured_region;
-}
-
-gboolean
-meta_shaped_texture_get_unobscured_bounds (MetaShapedTexture     *self,
-                                           cairo_rectangle_int_t *unobscured_bounds)
-{
-  cairo_region_t *unobscured_region = effective_unobscured_region (self);
-
-  if (unobscured_region)
-    {
-      cairo_region_get_extents (unobscured_region, unobscured_bounds);
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
 gboolean
 meta_shaped_texture_is_obscured (MetaShapedTexture *self)
 {
--- a/src/compositor/meta-surface-actor-wayland.c
+++ b/src/compositor/meta-surface-actor-wayland.c
@@ -109,7 +109,7 @@ meta_surface_actor_wayland_is_unredirected (MetaSurfaceActor *actor)
 }

 static int
-get_output_scale (int output_id)
+get_output_scale (int winsys_id)
 {
  MetaMonitorManager *monitor_manager = meta_monitor_manager_get ();
  MetaOutput *outputs;
@@ -120,7 +120,7 @@ get_output_scale (int output_id)

  for (i = 0; i < n_outputs; i++)
    {
-      if (outputs[i].output_id == output_id)
+      if (outputs[i].winsys_id == winsys_id)
        {
          output_scale = outputs[i].scale;
          break;
@@ -150,7 +150,7 @@ meta_surface_actor_wayland_get_scale (MetaSurfaceActorWayland *actor)

   /* XXX: We do not handle x11 clients yet */
   if (window && window->client_type != META_WINDOW_CLIENT_TYPE_X11)
-     output_scale = get_output_scale (window->monitor->output_id);
+     output_scale = get_output_scale (window->monitor->winsys_id);

   return (double)output_scale / (double)priv->surface->scale;
 }
--- a/src/compositor/meta-surface-actor-x11.c
+++ b/src/compositor/meta-surface-actor-x11.c
@@ -34,6 +34,7 @@
 #include "window-private.h"
 #include "meta-shaped-texture-private.h"
 #include "meta-cullable.h"
+#include "x11/window-x11.h"

 struct _MetaSurfaceActorX11Private
 {
@@ -143,7 +144,7 @@ update_pixmap (MetaSurfaceActorX11 *self)
  if (priv->pixmap == None)
    {
      Pixmap new_pixmap;
-      Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+      Window xwindow = meta_window_x11_get_toplevel_xwindow (priv->window);

      meta_error_trap_push (display);
      new_pixmap = XCompositeNameWindowPixmap (xdisplay, xwindow);
@@ -238,26 +239,6 @@ meta_surface_actor_x11_pre_paint (MetaSurfaceActor *actor)
      XDamageSubtract (xdisplay, priv->damage, None, None);
      meta_error_trap_pop (display);

-      /* We need to make sure that any X drawing that happens before the
-       * XDamageSubtract() above is visible to subsequent GL rendering;
-       * the only standardized way to do this is EXT_x11_sync_object,
-       * which isn't yet widely available. For now, we count on details
-       * of Xorg and the open source drivers, and hope for the best
-       * otherwise.
-       *
-       * Xorg and open source driver specifics:
-       *
-       * The X server makes sure to flush drawing to the kernel before
-       * sending out damage events, but since we use DamageReportBoundingBox
-       * there may be drawing between the last damage event and the
-       * XDamageSubtract() that needs to be flushed as well.
-       *
-       * Xorg always makes sure that drawing is flushed to the kernel
-       * before writing events or responses to the client, so any round trip
-       * request at this point is sufficient to flush the GLX buffers.
-       */
-      XSync (xdisplay, False);
-
      priv->received_damage = FALSE;
    }

@@ -312,7 +293,7 @@ sync_unredirected (MetaSurfaceActorX11 *self)
  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
  MetaDisplay *display = priv->display;
  Display *xdisplay = meta_display_get_xdisplay (display);
-  Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+  Window xwindow = meta_window_x11_get_toplevel_xwindow (priv->window);

  meta_error_trap_push (display);

@@ -404,7 +385,7 @@ create_damage (MetaSurfaceActorX11 *self)
 {
  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
  Display *xdisplay = meta_display_get_xdisplay (priv->display);
-  Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+  Window xwindow = meta_window_x11_get_toplevel_xwindow (priv->window);

  priv->damage = XDamageCreate (xdisplay, xwindow, XDamageReportBoundingBox);
 }
--- a/src/compositor/meta-surface-actor.c
+++ b/src/compositor/meta-surface-actor.c
@@ -36,20 +36,13 @@ G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_

 enum {
  REPAINT_SCHEDULED,
+  SIZE_CHANGED,

  LAST_SIGNAL,
 };

 static guint signals[LAST_SIGNAL];

-gboolean
-meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
-                                          cairo_rectangle_int_t *unobscured_bounds)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  return meta_shaped_texture_get_unobscured_bounds (priv->texture, unobscured_bounds);
-}
-
 static void
 meta_surface_actor_pick (ClutterActor       *actor,
                         const ClutterColor *color)
@@ -128,6 +121,13 @@ meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
                                             NULL, NULL, NULL,
                                             G_TYPE_NONE, 0);

+  signals[SIZE_CHANGED] = g_signal_new ("size-changed",
+                                        G_TYPE_FROM_CLASS (object_class),
+                                        G_SIGNAL_RUN_LAST,
+                                        0,
+                                        NULL, NULL, NULL,
+                                        G_TYPE_NONE, 0);
+
  g_type_class_add_private (klass, sizeof (MetaSurfaceActorPrivate));
 }

@@ -152,6 +152,14 @@ cullable_iface_init (MetaCullableInterface *iface)
  iface->reset_culling = meta_surface_actor_reset_culling;
 }

+static void
+texture_size_changed (MetaShapedTexture *texture,
+                      gpointer           user_data)
+{
+  MetaSurfaceActor *actor = META_SURFACE_ACTOR (user_data);
+  g_signal_emit (actor, signals[SIZE_CHANGED], 0);
+}
+
 static void
 meta_surface_actor_init (MetaSurfaceActor *self)
 {
@@ -162,6 +170,8 @@ meta_surface_actor_init (MetaSurfaceActor *self)
                                                   MetaSurfaceActorPrivate);

  priv->texture = META_SHAPED_TEXTURE (meta_shaped_texture_new ());
+  g_signal_connect_object (priv->texture, "size-changed",
+                           G_CALLBACK (texture_size_changed), self, 0);
  clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->texture));
 }

--- a/src/compositor/meta-surface-actor.h
+++ b/src/compositor/meta-surface-actor.h
@@ -55,8 +55,6 @@ MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);
 MetaWindow        *meta_surface_actor_get_window  (MetaSurfaceActor *self);

 gboolean meta_surface_actor_is_obscured (MetaSurfaceActor *self);
-gboolean meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
-                                                   cairo_rectangle_int_t *unobscured_bounds);

 void meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                          cairo_region_t   *region);
--- a/src/compositor/meta-texture-tower.c
+++ b/src/compositor/meta-texture-tower.c
@@ -378,8 +378,8 @@ texture_tower_create_texture (MetaTextureTower *tower,
 }

 static void
-texture_tower_revalidate_fbo (MetaTextureTower *tower,
-                              int               level)
+texture_tower_revalidate (MetaTextureTower *tower,
+                          int               level)
 {
  CoglTexture *source_texture = tower->textures[level - 1];
  int source_texture_width = cogl_texture_get_width (source_texture);
@@ -425,13 +425,9 @@ texture_tower_revalidate_fbo (MetaTextureTower *tower,
                                            (2. * invalid->y2) / source_texture_height);

  cogl_object_unref (pipeline);
-}

-static void
-texture_tower_revalidate (MetaTextureTower *tower,
-                          int               level)
-{
-  texture_tower_revalidate_fbo (tower, level);
+  tower->invalid[level].x1 = tower->invalid[level].x2 = 0;
+  tower->invalid[level].y1 = tower->invalid[level].y2 = 0;
 }

 /**
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -51,8 +51,7 @@ void     meta_window_actor_update_shape        (MetaWindowActor *self);
 void     meta_window_actor_update_opacity      (MetaWindowActor *self);
 void     meta_window_actor_mapped              (MetaWindowActor *self);
 void     meta_window_actor_unmapped            (MetaWindowActor *self);
-void     meta_window_actor_set_updates_frozen  (MetaWindowActor *self,
-                                                gboolean         updates_frozen);
+void     meta_window_actor_sync_updates_frozen (MetaWindowActor *self);
 void     meta_window_actor_queue_frame_drawn   (MetaWindowActor *self,
                                                gboolean         no_delay_frame);

--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -32,10 +32,19 @@

 #include "meta-surface-actor.h"
 #include "meta-surface-actor-x11.h"
+
+#ifdef HAVE_WAYLAND
 #include "meta-surface-actor-wayland.h"
+#endif

 #include "wayland/meta-wayland-surface.h"

+typedef enum {
+  INITIALLY_FROZEN,
+  DRAWING_FIRST_FRAME,
+  EMITTED_FIRST_FRAME
+} FirstFrameState;
+
 struct _MetaWindowActorPrivate
 {
  MetaWindow *window;
@@ -70,7 +79,7 @@ struct _MetaWindowActorPrivate
  gint64            frame_drawn_time;

  guint             repaint_scheduled_id;
-  guint             allocation_changed_id;
+  guint             size_changed_id;

  /*
   * These need to be counters rather than flags, since more plugins
@@ -78,6 +87,7 @@ struct _MetaWindowActorPrivate
   * might be dubious, but we have to at least handle it correctly.
   */
  gint              minimize_in_progress;
+  gint              unminimize_in_progress;
  gint              maximize_in_progress;
  gint              unmaximize_in_progress;
  gint              map_in_progress;
@@ -104,6 +114,7 @@ struct _MetaWindowActorPrivate
  guint             no_shadow              : 1;

  guint             updates_frozen         : 1;
+  guint             first_frame_state      : 2; /* FirstFrameState */
 };

 typedef struct _FrameData FrameData;
@@ -115,6 +126,14 @@ struct _FrameData
  gint64 frame_drawn_time;
 };

+enum
+{
+  FIRST_FRAME,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
 enum
 {
  PROP_META_WINDOW = 1,
@@ -181,6 +200,31 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
  actor_class->paint = meta_window_actor_paint;
  actor_class->get_paint_volume = meta_window_actor_get_paint_volume;

+  /**
+   * MetaWindowActor::first-frame:
+   * @actor: the #MetaWindowActor instance
+   *
+   * The ::first-frame signal will be emitted the first time a frame
+   * of window contents has been drawn by the application and Mutter
+   * has had the chance to drawn that frame to the screen. If the
+   * window starts off initially hidden, obscured, or on on a
+   * different workspace, the ::first-frame signal will be emitted
+   * even though the user doesn't see the contents.
+   *
+   * MetaDisplay::window-created is a good place to connect to this
+   * signal - at that point, the MetaWindowActor for the window
+   * exists, but the window has reliably not yet been drawn.
+   * Connecting to an existing window that has already been drawn to
+   * the screen is not useful.
+   */
+  signals[FIRST_FRAME] =
+    g_signal_new ("first-frame",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
  pspec = g_param_spec_object ("meta-window",
                               "MetaWindow",
                               "The displayed MetaWindow",
@@ -232,12 +276,11 @@ window_appears_focused_notify (MetaWindow *mw,
 }

 static void
-surface_allocation_changed_notify (ClutterActor           *actor,
-                                   const ClutterActorBox  *allocation,
-                                   ClutterAllocationFlags  flags,
-                                   MetaWindowActor        *self)
+surface_size_changed (MetaSurfaceActor *actor,
+                      gpointer          user_data)
 {
-  meta_window_actor_sync_actor_geometry (self, FALSE);
+  MetaWindowActor *self = META_WINDOW_ACTOR (user_data);
+
  meta_window_actor_update_shape (self);
 }

@@ -306,6 +349,9 @@ meta_window_actor_thaw (MetaWindowActor *self)
  if (priv->freeze_count > 0)
    return;

+  if (priv->first_frame_state == INITIALLY_FROZEN)
+    priv->first_frame_state = DRAWING_FIRST_FRAME;
+
  if (priv->surface)
    meta_surface_actor_set_frozen (priv->surface, FALSE);

@@ -326,9 +372,8 @@ set_surface (MetaWindowActor  *self,
  if (priv->surface)
    {
      g_signal_handler_disconnect (priv->surface, priv->repaint_scheduled_id);
+      g_signal_handler_disconnect (priv->surface, priv->size_changed_id);
      priv->repaint_scheduled_id = 0;
-      g_signal_handler_disconnect (priv->surface, priv->allocation_changed_id);
-      priv->allocation_changed_id = 0;
      clutter_actor_remove_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));
      g_object_unref (priv->surface);
    }
@@ -340,14 +385,17 @@ set_surface (MetaWindowActor  *self,
      g_object_ref_sink (priv->surface);
      priv->repaint_scheduled_id = g_signal_connect (priv->surface, "repaint-scheduled",
                                                     G_CALLBACK (surface_repaint_scheduled), self);
-      priv->allocation_changed_id = g_signal_connect (priv->surface, "allocation-changed",
-                                                      G_CALLBACK (surface_allocation_changed_notify), self);
+      priv->size_changed_id = g_signal_connect (priv->surface, "size-changed",
+                                                G_CALLBACK (surface_size_changed), self);
      clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));

      /* If the previous surface actor was frozen, start out
       * frozen as well... */
      meta_surface_actor_set_frozen (priv->surface, priv->freeze_count > 0);

+      if (!is_frozen (self) && priv->first_frame_state == INITIALLY_FROZEN)
+        priv->first_frame_state = DRAWING_FIRST_FRAME;
+
      meta_window_actor_update_shape (self);
    }
 }
@@ -551,6 +599,7 @@ meta_window_actor_get_shape_bounds (MetaWindowActor       *self,

  cairo_region_get_extents (priv->shape_region, bounds);

+#ifdef HAVE_WAYLAND
  if (META_IS_SURFACE_ACTOR_WAYLAND (priv->surface))
    {
      double scale = priv->surface ?
@@ -560,6 +609,7 @@ meta_window_actor_get_shape_bounds (MetaWindowActor       *self,
      bounds->width *= scale;
      bounds->height *= scale;
    }
+#endif
 }

 static void
@@ -667,25 +717,16 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
 {
  MetaWindowActor *self = META_WINDOW_ACTOR (actor);
  MetaWindowActorPrivate *priv = self->priv;
-  cairo_rectangle_int_t unobscured_bounds, bounds;
  gboolean appears_focused = meta_window_appears_focused (priv->window);
-  ClutterVertex origin;

  /* The paint volume is computed before paint functions are called
   * so our bounds might not be updated yet. Force an update. */
  meta_window_actor_handle_updates (self);

-  meta_window_actor_get_shape_bounds (self, &bounds);
-
-  if (priv->surface)
-    {
-      if (meta_surface_actor_get_unobscured_bounds (priv->surface, &unobscured_bounds))
-        gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
-    }
-
  if (appears_focused ? priv->focused_shadow : priv->unfocused_shadow)
    {
      cairo_rectangle_int_t shadow_bounds;
+      ClutterActorBox shadow_box;

      /* We could compute an full clip region as we do for the window
       * texture, but the shadow is relatively cheap to draw, and
@@ -695,16 +736,24 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
       */

      meta_window_actor_get_shadow_bounds (self, appears_focused, &shadow_bounds);
-      gdk_rectangle_union (&bounds, &shadow_bounds, &bounds);
+      shadow_box.x1 = shadow_bounds.x;
+      shadow_box.x2 = shadow_bounds.x + shadow_bounds.width;
+      shadow_box.y1 = shadow_bounds.y;
+      shadow_box.y2 = shadow_bounds.y + shadow_bounds.height;
+
+      clutter_paint_volume_union_box (volume, &shadow_box);
    }

-  origin.x = bounds.x;
-  origin.y = bounds.y;
-  origin.z = 0.0f;
-  clutter_paint_volume_set_origin (volume, &origin);
+  if (priv->surface)
+    {
+      const ClutterPaintVolume *child_volume;

-  clutter_paint_volume_set_width (volume, bounds.width);
-  clutter_paint_volume_set_height (volume, bounds.height);
+      child_volume = clutter_actor_get_transformed_paint_volume (CLUTTER_ACTOR (priv->surface), actor);
+      if (!child_volume)
+        return FALSE;
+
+      clutter_paint_volume_union (volume, child_volume);
+    }

  return TRUE;
 }
@@ -746,9 +795,11 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
    return FALSE;

  /*
-   * Add shadows to override redirect windows (e.g., Gtk menus).
+   * Add shadows to override redirect windows on X11 unless the toolkit
+   * indicates that it is handling shadows itself (e.g., Gtk menus).
   */
-  if (priv->window->override_redirect)
+  if (priv->window->override_redirect &&
+      !priv->window->has_custom_frame_extents)
    return TRUE;

  return FALSE;
@@ -851,7 +902,7 @@ queue_send_frame_messages_timeout (MetaWindowActor *self)
  outputs = meta_monitor_manager_get_outputs (monitor_manager, &n_outputs);
  for (i = 0; i < n_outputs; i++)
    {
-      if (outputs[i].output_id == window->monitor->output_id && outputs[i].crtc)
+      if (outputs[i].winsys_id == window->monitor->winsys_id && outputs[i].crtc)
        {
          refresh_rate = outputs[i].crtc->current_mode->refresh_rate;
          break;
@@ -960,6 +1011,9 @@ start_simple_effect (MetaWindowActor *self,
  case META_PLUGIN_MINIMIZE:
    counter = &priv->minimize_in_progress;
    break;
+  case META_PLUGIN_UNMINIMIZE:
+    counter = &priv->unminimize_in_progress;
+    break;
  case META_PLUGIN_MAP:
    counter = &priv->map_in_progress;
    break;
@@ -1030,6 +1084,16 @@ meta_window_actor_effect_completed (MetaWindowActor *self,
 	}
    }
    break;
+  case META_PLUGIN_UNMINIMIZE:
+    {
+      priv->unminimize_in_progress--;
+      if (priv->unminimize_in_progress < 0)
+       {
+         g_warning ("Error in unminimize accounting.");
+         priv->unminimize_in_progress = 0;
+       }
+    }
+    break;
  case META_PLUGIN_MAP:
    /*
     * Make sure that the actor is at the correct place in case
@@ -1150,7 +1214,7 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
  MetaWindowActorPrivate *priv = self->priv;
  MetaRectangle window_rect;

-  meta_window_get_input_rect (priv->window, &window_rect);
+  meta_window_get_buffer_rect (priv->window, &window_rect);

  /* When running as a Wayland compositor we catch size changes when new
   * buffers are attached */
@@ -1195,8 +1259,7 @@ meta_window_actor_show (MetaWindowActor   *self,
      event = META_PLUGIN_MAP;
      break;
    case META_COMP_EFFECT_UNMINIMIZE:
-      /* FIXME: should have META_PLUGIN_UNMINIMIZE */
-      event = META_PLUGIN_MAP;
+      event = META_PLUGIN_UNMINIMIZE;
      break;
    case META_COMP_EFFECT_NONE:
      break;
@@ -1324,7 +1387,12 @@ meta_window_actor_new (MetaWindow *window)

  priv = self->priv;

-  meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (priv->window));
+  meta_window_actor_sync_updates_frozen (self);
+
+  if (is_frozen (self))
+    priv->first_frame_state = INITIALLY_FROZEN;
+  else
+    priv->first_frame_state = DRAWING_FIRST_FRAME;

  /* If a window doesn't start off with updates frozen, we should
   * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
@@ -1594,6 +1662,8 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
                           cairo_rectangle_int_t *client_area,
                           cairo_region_t        *shape_region)
 {
+  ClutterBackend *backend = clutter_get_default_backend ();
+  CoglContext *ctx = clutter_backend_get_cogl_context (backend);
  MetaWindowActorPrivate *priv = self->priv;
  guchar *mask_data;
  guint tex_width, tex_height;
@@ -1656,10 +1726,7 @@ build_and_scan_frame_mask (MetaWindowActor       *self,

  if (meta_texture_rectangle_check (paint_tex))
    {
-      ClutterBackend *backend = clutter_get_default_backend ();
-      CoglContext *context = clutter_backend_get_cogl_context (backend);
-
-      mask_texture = COGL_TEXTURE (cogl_texture_rectangle_new_with_size (context, tex_width, tex_height));
+      mask_texture = COGL_TEXTURE (cogl_texture_rectangle_new_with_size (ctx, tex_width, tex_height));
      cogl_texture_set_components (mask_texture, COGL_TEXTURE_COMPONENTS_A);
      cogl_texture_set_region (mask_texture,
                               0, 0, /* src_x/y */
@@ -1671,15 +1738,9 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
    }
  else
    {
-      /* Note: we don't allow slicing for this texture because we
-       * need to use it with multi-texturing which doesn't support
-       * sliced textures */
-      mask_texture = cogl_texture_new_from_data (tex_width, tex_height,
-                                                 COGL_TEXTURE_NO_SLICING,
-                                                 COGL_PIXEL_FORMAT_A_8,
-                                                 COGL_PIXEL_FORMAT_ANY,
-                                                 stride,
-                                                 mask_data);
+      mask_texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, tex_width, tex_height,
+                                                                  COGL_PIXEL_FORMAT_A_8,
+                                                                  stride, mask_data, NULL));
    }

  meta_shaped_texture_set_mask_texture (stex, mask_texture);
@@ -1908,6 +1969,12 @@ meta_window_actor_post_paint (MetaWindowActor *self)
      do_send_frame_drawn (self, priv->frames->data);
      priv->needs_frame_drawn = FALSE;
    }
+
+  if (priv->first_frame_state == DRAWING_FIRST_FRAME)
+    {
+      priv->first_frame_state = EMITTED_FIRST_FRAME;
+      g_signal_emit (self, signals[FIRST_FRAME], 0);
+    }
 }

 static void
@@ -2020,7 +2087,7 @@ meta_window_actor_update_opacity (MetaWindowActor *self)
    clutter_actor_set_opacity (CLUTTER_ACTOR (priv->surface), window->opacity);
 }

-void
+static void
 meta_window_actor_set_updates_frozen (MetaWindowActor *self,
                                      gboolean         updates_frozen)
 {
@@ -2037,3 +2104,12 @@ meta_window_actor_set_updates_frozen (MetaWindowActor *self,
        meta_window_actor_thaw (self);
    }
 }
+
+void
+meta_window_actor_sync_updates_frozen (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  MetaWindow *window = priv->window;
+
+  meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (window));
+}
--- a/src/compositor/plugins/Makefile.am
+++ b/src/compositor/plugins/Makefile.am
@@ -1,12 +1,22 @@

-pkglibdir=@MUTTER_PLUGIN_DIR@
+pkglibdir = $(MUTTER_PLUGIN_DIR)

-INCLUDES=@MUTTER_CFLAGS@ -I $(top_srcdir)/src -DMUTTER_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMUTTER_PKGDATADIR=\"$(pkgdatadir)\" -DMUTTER_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"mutter\" -DSN_API_NOT_YET_FROZEN=1 -DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION) -DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION) -DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION) -DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION) -DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"
+AM_CPPFLAGS = \
+	$(MUTTER_CFLAGS)						\
+	-I$(top_builddir)/src						\
+	-I$(top_srcdir)/src						\
+	-DMUTTER_LIBEXECDIR=\"$(libexecdir)\"				\
+	-DMUTTER_LOCALEDIR=\"$(localedir)\"				\
+	-DMUTTER_PKGDATADIR=\"$(pkgdatadir)\"				\
+	-DMUTTER_DATADIR=\"$(datadir)\"					\
+	-DG_LOG_DOMAIN=\"mutter\"					\
+	-DSN_API_NOT_YET_FROZEN=1					\
+	-DMUTTER_PLUGIN_DIR=\"$(MUTTER_PLUGIN_DIR)\"

 default_la_CFLAGS   = -fPIC
 default_la_SOURCES  = default.c
 default_la_LDFLAGS  = -module -avoid-version -no-undefined
-default_la_LIBADD   = @CLUTTER_LIBS@
+default_la_LIBADD   = $(CLUTTER_LIBS)

 pkglib_LTLIBRARIES = default.la

--- a/src/core/bell.c
+++ b/src/core/bell.c
@@ -69,12 +69,9 @@
 *
 * If the configure script found we had no XKB, this does not exist.
 */
-#ifdef HAVE_XKB
 static void
-bell_flash_fullscreen (MetaDisplay *display,
-                       XkbAnyEvent *xkb_ev)
+bell_flash_fullscreen (MetaDisplay *display)
 {
-  g_assert (xkb_ev->xkb_type == XkbBellNotify);
  meta_compositor_flash_screen (display->compositor, display->screen);
 }

@@ -139,30 +136,17 @@ bell_flash_window_frame (MetaWindow *window)
 * @display:  The display the bell event came in on
 * @xkb_ev:   The bell event we just received
 *
- * Flashes the frame of the focussed window. If there is no focussed window,
+ * Flashes the frame of the focused window. If there is no focused window,
 * flashes the screen.
 */
 static void
 bell_flash_frame (MetaDisplay *display,
-		  XkbAnyEvent *xkb_ev)
+                  MetaWindow  *window)
 {
-  XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent *) xkb_ev;
-  MetaWindow *window;
-
-  g_assert (xkb_ev->xkb_type == XkbBellNotify);
-  window = meta_display_lookup_x_window (display, xkb_bell_event->window);
-  if (!window && (display->focus_window))
-    {
-      window = display->focus_window;
-    }
  if (window && window->frame)
-    {
-      bell_flash_window_frame (window);
-    }
-  else /* revert to fullscreen flash if there's no focussed window */
-    {
-      bell_flash_fullscreen (display, xkb_ev);
-    }
+    bell_flash_window_frame (window);
+  else
+    bell_flash_fullscreen (display);
 }

 /**
@@ -172,69 +156,73 @@ bell_flash_frame (MetaDisplay *display,
 *
 * Gives the user some kind of visual bell substitute, in response to a
 * bell event. What this is depends on the "visual bell type" pref.
- *
- * If the configure script found we had no XKB, this does not exist.
- */
-
-/*
- * Bug: This should be merged with meta_bell_notify().
 */
 static void
 bell_visual_notify (MetaDisplay *display,
-			 XkbAnyEvent *xkb_ev)
+                    MetaWindow  *window)
 {
  switch (meta_prefs_get_visual_bell_type ())
    {
    case G_DESKTOP_VISUAL_BELL_FULLSCREEN_FLASH:
-      bell_flash_fullscreen (display, xkb_ev);
+      bell_flash_fullscreen (display);
      break;
    case G_DESKTOP_VISUAL_BELL_FRAME_FLASH:
-      bell_flash_frame (display, xkb_ev); /* does nothing yet */
+      bell_flash_frame (display, window);
      break;
    }
 }

+static gboolean
+bell_audible_notify (MetaDisplay *display,
+                     MetaWindow  *window)
+{
+#ifdef HAVE_LIBCANBERRA
+  ca_proplist *p;
+  int res;
+
+  ca_proplist_create (&p);
+  ca_proplist_sets (p, CA_PROP_EVENT_ID, "bell-window-system");
+  ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION, _("Bell event"));
+  ca_proplist_sets (p, CA_PROP_CANBERRA_CACHE_CONTROL, "permanent");
+
+  if (window)
+    {
+      ca_proplist_sets (p, CA_PROP_WINDOW_NAME, window->title);
+      ca_proplist_setf (p, CA_PROP_WINDOW_X11_XID, "%lu", (unsigned long)window->xwindow);
+      ca_proplist_sets (p, CA_PROP_APPLICATION_NAME, window->res_name);
+      ca_proplist_setf (p, CA_PROP_APPLICATION_PROCESS_ID, "%d", window->net_wm_pid);
+    }
+
+  res = ca_context_play_full (ca_gtk_context_get (), 1, p, NULL, NULL);
+
+  ca_proplist_destroy (p);
+
+  return res == CA_SUCCESS || res == CA_ERROR_DISABLED;
+#endif /* HAVE_LIBCANBERRA */
+
+  return FALSE;
+}
+
 void
 meta_bell_notify (MetaDisplay *display,
 		  XkbAnyEvent *xkb_ev)
 {
+  MetaWindow *window;
+  XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
+
+  window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+  if (!window && display->focus_window && display->focus_window->frame)
+    window = display->focus_window;
+
  /* flash something */
  if (meta_prefs_get_visual_bell ())
-    bell_visual_notify (display, xkb_ev);
+    bell_visual_notify (display, window);

-#ifdef HAVE_LIBCANBERRA
  if (meta_prefs_bell_is_audible ())
    {
-      ca_proplist *p;
-      XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
-      MetaWindow *window;
-      int res;
-
-      ca_proplist_create (&p);
-      ca_proplist_sets (p, CA_PROP_EVENT_ID, "bell-window-system");
-      ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION, _("Bell event"));
-      ca_proplist_sets (p, CA_PROP_CANBERRA_CACHE_CONTROL, "permanent");
-
-      window = meta_display_lookup_x_window (display, xkb_bell_event->window);
-      if (!window && (display->focus_window) && (display->focus_window->frame))
-        window = display->focus_window;
-
-      if (window)
+      if (!bell_audible_notify (display, window))
        {
-          ca_proplist_sets (p, CA_PROP_WINDOW_NAME, window->title);
-          ca_proplist_setf (p, CA_PROP_WINDOW_X11_XID, "%lu", (unsigned long)window->xwindow);
-          ca_proplist_sets (p, CA_PROP_APPLICATION_NAME, window->res_name);
-          ca_proplist_setf (p, CA_PROP_APPLICATION_PROCESS_ID, "%d", window->net_wm_pid);
-        }
-
-      /* First, we try to play a real sound ... */
-      res = ca_context_play_full (ca_gtk_context_get (), 1, p, NULL, NULL);
-
-      ca_proplist_destroy (p);
-
-      if (res != CA_SUCCESS && res != CA_ERROR_DISABLED)
-        {
-          /* ...and in case that failed we use the classic X11 bell. */
+          /* Force a classic bell if the libcanberra bell failed. */
          XkbForceDeviceBell (display->xdisplay,
                              xkb_bell_event->device,
                              xkb_bell_event->bell_class,
@@ -242,14 +230,11 @@ meta_bell_notify (MetaDisplay *display,
                              xkb_bell_event->percent);
        }
    }
-#endif /* HAVE_LIBCANBERRA */
 }
-#endif /* HAVE_XKB */

 void
 meta_bell_set_audible (MetaDisplay *display, gboolean audible)
 {
-#ifdef HAVE_XKB
 #ifdef HAVE_LIBCANBERRA
  /* When we are playing sounds using libcanberra support, we handle the
   * bell whether its an audible bell or a visible bell */
@@ -262,13 +247,11 @@ meta_bell_set_audible (MetaDisplay *display, gboolean audible)
                            XkbUseCoreKbd,
                            XkbAudibleBellMask,
                            enable_system_bell ? XkbAudibleBellMask : 0);
-#endif /* HAVE_XKB */
 }

 gboolean
 meta_bell_init (MetaDisplay *display)
 {
-#ifdef HAVE_XKB
  int xkb_base_error_type, xkb_opcode;

  if (!XkbQueryExtension (display->xdisplay, &xkb_opcode,
@@ -298,20 +281,17 @@ meta_bell_init (MetaDisplay *display)
      }
      return TRUE;
    }
-#endif
  return FALSE;
 }

 void
 meta_bell_shutdown (MetaDisplay *display)
 {
-#ifdef HAVE_XKB
  /* TODO: persist initial bell state in display, reset here */
  XkbChangeEnabledControls (display->xdisplay,
 			    XkbUseCoreKbd,
 			    XkbAudibleBellMask,
 			    XkbAudibleBellMask);
-#endif
 }

 /**
--- a/src/core/bell.h
+++ b/src/core/bell.h
@@ -18,13 +18,10 @@
 */

 #include <X11/Xlib.h>
-#ifdef HAVE_XKB
 #include <X11/XKBlib.h>
-#endif
 #include "display-private.h"
 #include "frame.h"

-#ifdef HAVE_XKB
 /**
 * meta_bell_notify:
 * @display: The display the bell event came in on
@@ -37,7 +34,6 @@
 * If the configure script found we had no XKB, this does not exist.
 */
 void meta_bell_notify (MetaDisplay *display, XkbAnyEvent *xkb_ev);
-#endif

 /**
 * meta_bell_set_audible:
@@ -61,12 +57,6 @@ void meta_bell_set_audible (MetaDisplay *display, gboolean audible);
 * to send us bell notifications, and then also switching
 * off the audible bell if we're using a visual one ourselves.
 *
- * Unlike most X extensions we use, we only initialise XKB here
- * (rather than in main()). It's possible that XKB is not
- * installed at all, but if that was known at build time
- * we will have HAVE_XKB undefined, which will cause this
- * function to be a no-op.
- *
 * \bug There is a line of code that's never run that tells
 * XKB to reset the bell status after we quit. Bill H said
 * (<http://bugzilla.gnome.org/show_bug.cgi?id=99886#c12>)
--- a/src/core/boxes.c
+++ b/src/core/boxes.c
@@ -546,6 +546,26 @@ compare_rect_areas (gconstpointer a, gconstpointer b)
  return b_area - a_area; /* positive ret value denotes b > a, ... */
 }

+/* ... and another helper for get_minimal_spanning_set_for_region()... */
+static gboolean
+check_strut_align (MetaStrut *strut, const MetaRectangle *rect)
+{
+  /* Check whether @strut actually aligns to the side of @rect it claims */
+  switch (strut->side)
+    {
+    case META_SIDE_TOP:
+      return BOX_TOP (strut->rect) <= BOX_TOP (*rect);
+    case META_SIDE_BOTTOM:
+      return BOX_BOTTOM (strut->rect) >= BOX_BOTTOM (*rect);
+    case META_SIDE_LEFT:
+      return BOX_LEFT (strut->rect) <= BOX_LEFT (*rect);
+    case META_SIDE_RIGHT:
+      return BOX_RIGHT (strut->rect) >= BOX_RIGHT (*rect);
+    default:
+      return FALSE;
+    }
+}
+
 /**
 * meta_rectangle_get_minimal_spanning_set_for_region:
 * @basic_rect: Input rectangle
@@ -630,7 +650,8 @@ meta_rectangle_get_minimal_spanning_set_for_region (
  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
    {
      GList *rect_iter;
-      MetaRectangle *strut_rect = &((MetaStrut*)strut_iter->data)->rect;
+      MetaStrut *strut = (MetaStrut*)strut_iter->data;
+      MetaRectangle *strut_rect = &strut->rect;

      tmp_list = ret;
      ret = NULL;
@@ -638,7 +659,9 @@ meta_rectangle_get_minimal_spanning_set_for_region (
      while (rect_iter)
        {
          MetaRectangle *rect = (MetaRectangle*) rect_iter->data;
-          if (!meta_rectangle_overlap (rect, strut_rect))
+
+          if (!meta_rectangle_overlap (strut_rect, rect) ||
+              !check_strut_align (strut, basic_rect))
            ret = g_list_prepend (ret, rect);
          else
            {
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -404,31 +404,6 @@ setup_constraint_info (ConstraintInfo      *info,
    meta_workspace_get_onmonitor_region (cur_workspace,
                                         monitor_info->number);

-  /* Workaround braindead legacy apps that don't know how to
-   * fullscreen themselves properly - don't get fooled by
-   * windows which hide their titlebar when maximized or which are
-   * client decorated; that's not the same as fullscreen, even
-   * if there are no struts making the workarea smaller than
-   * the monitor.
-   */
-  if (meta_prefs_get_force_fullscreen() &&
-      window->client_type != META_WINDOW_CLIENT_TYPE_WAYLAND &&
-      !window->hide_titlebar_when_maximized &&
-      (window->decorated || !meta_window_is_client_decorated (window)) &&
-      meta_rectangle_equal (new, &monitor_info->rect) &&
-      window->has_fullscreen_func &&
-      !window->fullscreen)
-    {
-      /*
-      meta_topic (META_DEBUG_GEOMETRY,
-      */
-      meta_warning (
-                  "Treating resize request of legacy application %s as a "
-                  "fullscreen request\n",
-                  window->desc);
-      meta_window_make_fullscreen_internal (window);
-    }
-
  /* Log all this information for debugging */
  meta_topic (META_DEBUG_GEOMETRY,
              "Setting up constraint info:\n"
@@ -613,7 +588,7 @@ update_onscreen_requirements (MetaWindow     *window,
  window->require_fully_onscreen =
    meta_rectangle_contained_in_region (info->usable_screen_region,
                                        &info->current);
-  if (old ^ window->require_fully_onscreen)
+  if (old != window->require_fully_onscreen)
    meta_topic (META_DEBUG_GEOMETRY,
                "require_fully_onscreen for %s toggled to %s\n",
                window->desc,
@@ -626,7 +601,7 @@ update_onscreen_requirements (MetaWindow     *window,
  window->require_on_single_monitor =
    meta_rectangle_contained_in_region (info->usable_monitor_region,
                                        &info->current);
-  if (old ^ window->require_on_single_monitor)
+  if (old != window->require_on_single_monitor)
    meta_topic (META_DEBUG_GEOMETRY,
                "require_on_single_monitor for %s toggled to %s\n",
                window->desc,
@@ -645,7 +620,7 @@ update_onscreen_requirements (MetaWindow     *window,
      window->require_titlebar_visible =
        meta_rectangle_overlaps_with_region (info->usable_screen_region,
                                             &titlebar_rect);
-      if (old ^ window->require_titlebar_visible)
+      if (old != window->require_titlebar_visible)
        meta_topic (META_DEBUG_GEOMETRY,
                    "require_titlebar_visible for %s toggled to %s\n",
                    window->desc,
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -392,6 +392,22 @@ meta_core_show_window_menu (Display            *xdisplay,
  meta_window_show_menu (window, menu, root_x, root_y);
 }

+void
+meta_core_show_window_menu_for_rect (Display            *xdisplay,
+                                     Window              frame_xwindow,
+                                     MetaWindowMenuType  menu,
+                                     MetaRectangle      *rect,
+                                     guint32             timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+  meta_window_focus (window, timestamp);
+
+  meta_window_show_menu_for_rect (window, menu, rect);
+}
+
 const char*
 meta_core_get_workspace_name_with_index (Display *xdisplay,
                                         Window   xroot,
@@ -479,46 +495,5 @@ meta_core_set_screen_cursor (Display *xdisplay,
 void
 meta_invalidate_default_icons (void)
 {
-  MetaDisplay *display = meta_get_display ();
-  GSList *windows;
-  GSList *l;
-
-  if (display == NULL)
-    return; /* We can validly be called before the display is opened. */
-
-  windows = meta_display_list_windows (display, META_LIST_DEFAULT);
-  for (l = windows; l != NULL; l = l->next)
-    {
-      MetaWindow *window = (MetaWindow*)l->data;
-
-      if (window->icon_cache.origin == USING_FALLBACK_ICON)
-        {
-          meta_icon_cache_free (&(window->icon_cache));
-          meta_window_update_icon_now (window);
-        }
-    }
-
-  g_slist_free (windows);
-}
-
-void
-meta_core_add_old_event_mask (Display     *xdisplay,
-                              Window       xwindow,
-                              XIEventMask *mask)
-{
-  XIEventMask *prev;
-  gint n_masks, i, j;
-
-  prev = XIGetSelectedEvents (xdisplay, xwindow, &n_masks);
-
-  for (i = 0; i < n_masks; i++)
-    {
-      if (prev[i].deviceid != XIAllMasterDevices)
-        continue;
-
-      for (j = 0; j < MIN (mask->mask_len, prev[i].mask_len); j++)
-        mask->mask[j] |= prev[i].mask[j];
-    }
-
-  XFree (prev);
+  /* XXX: Actually invalidate the icons when they're used. */
 }
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -26,6 +26,7 @@
 /* Don't include core headers here */
 #include <gdk/gdkx.h>
 #include <meta/common.h>
+#include <meta/boxes.h>

 typedef enum
 {
@@ -138,6 +139,12 @@ void meta_core_show_window_menu (Display            *xdisplay,
                                 int                 root_y,
                                 guint32             timestamp);

+void meta_core_show_window_menu_for_rect (Display            *xdisplay,
+                                          Window              frame_xwindow,
+                                          MetaWindowMenuType  menu,
+                                          MetaRectangle      *rect,
+                                          guint32             timestamp);
+
 gboolean   meta_core_begin_grab_op (Display    *xdisplay,
                                    Window      frame_xwindow,
                                    MetaGrabOp  op,
@@ -162,8 +169,4 @@ void       meta_core_set_screen_cursor (Display *xdisplay,

 void meta_invalidate_default_icons (void);

-void meta_core_add_old_event_mask (Display     *xdisplay,
-                                   Window       xwindow,
-                                   XIEventMask *mask);
-
 #endif
--- a/src/core/delete.c
+++ b/src/core/delete.c
@@ -37,8 +37,6 @@
 #include <stdlib.h>
 #include <stdio.h>

-#include "wayland/meta-wayland-surface.h"
-
 static void
 dialog_exited (GPid pid, int status, gpointer user_data)
 {
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -35,6 +35,7 @@
 #include <meta/boxes.h>
 #include <meta/display.h>
 #include "keybindings-private.h"
+#include "meta-gesture-tracker-private.h"
 #include <meta/prefs.h>
 #include <meta/barrier.h>
 #include <clutter/clutter.h>
@@ -78,6 +79,24 @@ typedef enum {
  META_TILE_MAXIMIZED
 } MetaTileMode;

+typedef enum {
+  /* Normal interaction where you're interacting with windows.
+   * Events go to windows normally. */
+  META_EVENT_ROUTE_NORMAL,
+
+  /* In a compositor grab operation. All events go to the
+   * compositor plugin. */
+  META_EVENT_ROUTE_COMPOSITOR_GRAB,
+
+  /* A Wayland application has a popup open. All events go to
+   * the Wayland application. */
+  META_EVENT_ROUTE_WAYLAND_POPUP,
+
+  /* In a window operation like moving or resizing. All events
+   * goes to MetaWindow, but not to the actual client window. */
+  META_EVENT_ROUTE_WINDOW_OP,
+} MetaEventRoute;
+
 struct _MetaDisplay
 {
  GObject parent_instance;
@@ -145,8 +164,6 @@ struct _MetaDisplay
  GHashTable *xids;
  GHashTable *wayland_windows;

-  int server_grab_count;
-
  /* serials of leave/unmap events that may
   * correspond to an enter event we should
   * ignore
@@ -175,13 +192,12 @@ struct _MetaDisplay
  guint       autoraise_timeout_id;
  MetaWindow* autoraise_window;

-  /* Alt+click button grabs */
-  ClutterModifierType window_grab_modifiers;
+  /* Event routing */
+  MetaEventRoute event_route;

  /* current window operation */
  MetaGrabOp  grab_op;
  MetaWindow *grab_window;
-  Window      grab_xwindow;
  int         grab_button;
  int         grab_anchor_root_x;
  int         grab_anchor_root_y;
@@ -202,34 +218,17 @@ struct _MetaDisplay
  GTimeVal    grab_last_moveresize_time;
  MetaEdgeResistanceData *grab_edge_resistance_data;
  unsigned int grab_last_user_action_was_snap;
-  guint32     grab_timestamp;

  /* we use property updates as sentinels for certain window focus events
   * to avoid some race conditions on EnterNotify events
   */
  int         sentinel_counter;

-#ifdef HAVE_XKB
  int         xkb_base_event_type;
  guint32     last_bell_time;
-#endif
  int	      grab_resize_timeout_id;

-  /* Keybindings stuff */
-  GHashTable     *key_bindings;
-  GHashTable     *key_bindings_index;
-  int             min_keycode;
-  int             max_keycode;
-  KeySym *keymap;
-  int keysyms_per_keycode;
-  unsigned int ignored_modifier_mask;
-  unsigned int hyper_mask;
-  unsigned int super_mask;
-  unsigned int meta_mask;
-  MetaKeyCombo overlay_key_combo;
-  gboolean overlay_key_only_pressed;
-  MetaKeyCombo *iso_next_group_combos;
-  int n_iso_next_group_combos;
+  MetaKeyBindingManager key_binding_manager;

  /* Monitor cache */
  unsigned int monitor_cache_invalidated : 1;
@@ -254,6 +253,9 @@ struct _MetaDisplay
  /* Managed by compositor.c */
  MetaCompositor *compositor;

+  MetaGestureTracker *gesture_tracker;
+  ClutterEventSequence *pointer_emulating_sequence;
+
  int composite_event_base;
  int composite_error_base;
  int composite_major_version;
@@ -312,8 +314,6 @@ struct _MetaDisplayClass
 gboolean      meta_display_open                (void);
 void          meta_display_close               (MetaDisplay *display,
                                                guint32      timestamp);
-void          meta_display_grab                (MetaDisplay *display);
-void          meta_display_ungrab              (MetaDisplay *display);

 void          meta_display_unmanage_windows_for_screen (MetaDisplay *display,
                                                        MetaScreen  *screen,
@@ -398,14 +398,8 @@ int meta_resize_gravity_from_grab_op (MetaGrabOp op);

 gboolean meta_grab_op_is_moving   (MetaGrabOp op);
 gboolean meta_grab_op_is_resizing (MetaGrabOp op);
-gboolean meta_grab_op_is_moving_or_resizing (MetaGrabOp op);
 gboolean meta_grab_op_is_mouse    (MetaGrabOp op);
 gboolean meta_grab_op_is_keyboard (MetaGrabOp op);
-gboolean meta_grab_op_should_block_wayland (MetaGrabOp op);
-
-void meta_display_devirtualize_modifiers (MetaDisplay        *display,
-                                          MetaVirtualModifier modifiers,
-                                          unsigned int       *mask);

 void meta_display_increment_focus_sentinel (MetaDisplay *display);
 void meta_display_decrement_focus_sentinel (MetaDisplay *display);
@@ -443,4 +437,20 @@ void meta_display_sanity_check_timestamps (MetaDisplay *display,
 gboolean meta_display_timestamp_too_old (MetaDisplay *display,
                                         guint32     *timestamp);

+void meta_display_remove_pending_pings_for_window (MetaDisplay *display,
+                                                   MetaWindow  *window);
+
+MetaGestureTracker * meta_display_get_gesture_tracker (MetaDisplay *display);
+
+gboolean meta_display_show_restart_message (MetaDisplay *display,
+                                            const char  *message);
+gboolean meta_display_request_restart      (MetaDisplay *display);
+
+void meta_restart_init (void);
+void meta_restart_finish (void);
+
+void meta_display_cancel_touch (MetaDisplay *display);
+
+gboolean meta_display_windows_are_interactable (MetaDisplay *display);
+
 #endif
--- a/src/core/display.c
+++ b/src/core/display.c
--- a/src/core/events.c
+++ b/src/core/events.c
--- a/src/core/events.h
+++ b/src/core/events.h
@@ -29,4 +29,3 @@ void meta_display_init_events (MetaDisplay *display);
 void meta_display_free_events (MetaDisplay *display);

 #endif
-
--- a/src/core/frame.c
+++ b/src/core/frame.c
@@ -26,14 +26,11 @@
 #include "bell.h"
 #include <meta/errors.h>
 #include "keybindings-private.h"
+#include "backends/x11/meta-backend-x11.h"

 #define EVENT_MASK (SubstructureRedirectMask |                     \
                    StructureNotifyMask | SubstructureNotifyMask | \
-                    ExposureMask |                                 \
-                    ButtonPressMask | ButtonReleaseMask |          \
-                    PointerMotionMask | PointerMotionHintMask |    \
-                    EnterWindowMask | LeaveWindowMask |            \
-                    FocusChangeMask)
+                    ExposureMask | FocusChangeMask)

 void
 meta_window_ensure_frame (MetaWindow *window)
@@ -109,6 +106,19 @@ meta_window_ensure_frame (MetaWindow *window)
  XChangeWindowAttributes (window->display->xdisplay,
 			   frame->xwindow, CWEventMask, &attrs);

+  {
+    unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+    XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+
+    XISetMask (mask.mask, XI_ButtonPress);
+    XISetMask (mask.mask, XI_ButtonRelease);
+    XISetMask (mask.mask, XI_Motion);
+    XISetMask (mask.mask, XI_Enter);
+    XISetMask (mask.mask, XI_Leave);
+
+    XISelectEvents (window->display->xdisplay, frame->xwindow, &mask, 1);
+  }
+
  meta_display_register_x_window (window->display, &frame->xwindow, window);

  meta_error_trap_push (window->display);
@@ -141,7 +151,6 @@ meta_window_ensure_frame (MetaWindow *window)
   * style and background.
   */
  meta_ui_update_frame_style (window->screen->ui, frame->xwindow);
-  meta_ui_reset_frame_bg (window->screen->ui, frame->xwindow);

  if (window->title)
    meta_ui_set_frame_title (window->screen->ui,
@@ -150,10 +159,16 @@ meta_window_ensure_frame (MetaWindow *window)

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

-  /* Since the backend takes keygrabs on another connection, make sure
-   * to sync the GTK+ connection to ensure that the frame window has
-   * been created on the server at this point. */
-  XSync (window->display->xdisplay, False);
+  {
+    MetaBackend *backend = meta_get_backend ();
+    if (META_IS_BACKEND_X11 (backend))
+      {
+        /* Since the backend takes keygrabs on another connection, make sure
+         * to sync the GTK+ connection to ensure that the frame window has
+         * been created on the server at this point. */
+        XSync (window->display->xdisplay, False);
+      }
+  }

  /* Move keybindings to frame instead of window */
  meta_window_grab_keys (window);
@@ -356,15 +371,6 @@ meta_frame_sync_to_window (MetaFrame *frame,
              frame->rect.x + frame->rect.width,
              frame->rect.y + frame->rect.height);

-  /* set bg to none to avoid flicker */
-  if (need_resize)
-    {
-      meta_ui_unflicker_frame_bg (frame->window->screen->ui,
-                                  frame->xwindow,
-                                  frame->rect.width,
-                                  frame->rect.height);
-    }
-
  meta_ui_move_resize_frame (frame->window->screen->ui,
 			     frame->xwindow,
 			     frame->rect.x,
@@ -374,9 +380,6 @@ meta_frame_sync_to_window (MetaFrame *frame,

  if (need_resize)
    {
-      meta_ui_reset_frame_bg (frame->window->screen->ui,
-                              frame->xwindow);
-
      /* If we're interactively resizing the frame, repaint
       * it immediately so we don't start to lag.
       */
--- a/src/core/keybindings-private.h
+++ b/src/core/keybindings-private.h
@@ -29,6 +29,7 @@

 #include <gio/gio.h>
 #include <meta/keybindings.h>
+#include <xkbcommon/xkbcommon.h>

 typedef struct _MetaKeyHandler MetaKeyHandler;
 struct _MetaKeyHandler
@@ -80,9 +81,6 @@ typedef struct
   */
  GSList *combos;

-  /* for keybindings that can have shift or not like Alt+Tab */
-  gboolean      add_shift:1;
-
  /* for keybindings that apply only to a window */
  gboolean      per_window:1;

@@ -90,6 +88,23 @@ typedef struct
  gboolean      builtin:1;
 } MetaKeyPref;

+typedef struct
+{
+  GHashTable     *key_bindings;
+  GHashTable     *key_bindings_index;
+  xkb_mod_mask_t ignored_modifier_mask;
+  xkb_mod_mask_t hyper_mask;
+  xkb_mod_mask_t super_mask;
+  xkb_mod_mask_t meta_mask;
+  MetaKeyCombo overlay_key_combo;
+  gboolean overlay_key_only_pressed;
+  MetaKeyCombo *iso_next_group_combos;
+  int n_iso_next_group_combos;
+
+  /* Alt+click button grabs */
+  ClutterModifierType window_grab_modifiers;
+} MetaKeyBindingManager;
+
 void     meta_display_init_keys             (MetaDisplay *display);
 void     meta_display_shutdown_keys         (MetaDisplay *display);
 void     meta_screen_grab_keys              (MetaScreen  *screen);
@@ -103,8 +118,8 @@ void     meta_window_ungrab_all_keys        (MetaWindow  *window,
 gboolean meta_keybindings_process_event     (MetaDisplay        *display,
                                             MetaWindow         *window,
                                             const ClutterEvent *event);
-void     meta_display_process_mapping_event (MetaDisplay *display,
-                                             XEvent      *event);
+
+ClutterModifierType meta_display_get_window_grab_modifiers (MetaDisplay *display);

 gboolean meta_prefs_add_keybinding          (const char           *name,
                                             GSettings            *settings,
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -52,6 +52,7 @@
 #include "ui.h"
 #include <meta/prefs.h>
 #include <meta/compositor.h>
+#include <meta/meta-backend.h>

 #include <glib-object.h>
 #include <glib-unix.h>
@@ -77,8 +78,9 @@

 #include "x11/session.h"

+#ifdef HAVE_WAYLAND
 #include "wayland/meta-wayland.h"
-#include "backends/meta-backend.h"
+#endif

 /*
 * The exit code we'll return to our parent process when we eventually die.
@@ -94,26 +96,6 @@ static GMainLoop *meta_main_loop = NULL;
 static void prefs_changed_callback (MetaPreference pref,
                                    gpointer       data);

-/**
- * log_handler:
- * @log_domain: the domain the error occurred in (we ignore this)
- * @log_level: the log level so that we can filter out less
- *             important messages
- * @message: the message to log
- * @user_data: arbitrary data (we ignore this)
- *
- * Prints log messages. If Mutter was compiled with backtrace support,
- * also prints a backtrace (see meta_print_backtrace()).
- */
-static void
-log_handler (const gchar   *log_domain,
-             GLogLevelFlags log_level,
-             const gchar   *message,
-             gpointer       user_data)
-{
-  meta_warning ("Log level %d: %s\n", log_level, message);
-}
-
 /**
 * meta_print_compilation_info:
 *
@@ -180,7 +162,9 @@ static gchar    *opt_client_id;
 static gboolean  opt_replace_wm;
 static gboolean  opt_disable_sm;
 static gboolean  opt_sync;
+#ifdef HAVE_WAYLAND
 static gboolean  opt_wayland;
+#endif
 #ifdef HAVE_NATIVE_BACKEND
 static gboolean  opt_display_server;
 #endif
@@ -221,12 +205,14 @@ static GOptionEntry meta_options[] = {
    N_("Make X calls synchronous"),
    NULL
  },
+#ifdef HAVE_WAYLAND
  {
    "wayland", 0, 0, G_OPTION_ARG_NONE,
    &opt_wayland,
    N_("Run as a wayland compositor"),
    NULL
  },
+#endif
 #ifdef HAVE_NATIVE_BACKEND
  {
    "display-server", 0, 0, G_OPTION_ARG_NONE,
@@ -291,8 +277,10 @@ meta_finalize (void)
    meta_display_close (display,
                        CurrentTime); /* I doubt correct timestamps matter here */

+#ifdef HAVE_WAYLAND
  if (meta_is_wayland_compositor ())
    meta_wayland_finalize ();
+#endif
 }

 static gboolean
@@ -339,9 +327,13 @@ meta_init (void)
 #if defined(CLUTTER_WINDOWING_EGL) && defined(HAVE_NATIVE_BACKEND)
  if (opt_display_server)
    clutter_set_windowing_backend (CLUTTER_WINDOWING_EGL);
+  else
 #endif
+    clutter_set_windowing_backend (CLUTTER_WINDOWING_X11);

+#ifdef HAVE_WAYLAND
  meta_set_is_wayland_compositor (opt_wayland);
+#endif

  if (g_get_home_dir ())
    if (chdir (g_get_home_dir ()) < 0)
@@ -354,15 +346,24 @@ meta_init (void)
  g_irepository_prepend_search_path (MUTTER_PKGLIBDIR);
 #endif

+#ifdef HAVE_WAYLAND
  if (meta_is_wayland_compositor ())
-    {
-      /* NB: When running as a hybrid wayland compositor we run our own headless X
-       * server so the user can't control the X display to connect too. */
-      meta_wayland_init ();
-    }
-  else
+    meta_wayland_pre_clutter_init ();
+#endif
+
+  /* NB: When running as a hybrid wayland compositor we run our own headless X
+   * server so the user can't control the X display to connect too. */
+  if (!meta_is_wayland_compositor ())
    meta_select_display (opt_display_name);

+  meta_clutter_init ();
+
+#ifdef HAVE_WAYLAND
+  /* Bring up Wayland. This also launches Xwayland and sets DISPLAY as well... */
+  if (meta_is_wayland_compositor ())
+    meta_wayland_init ();
+#endif
+
  meta_set_syncing (opt_sync || (g_getenv ("MUTTER_SYNC") != NULL));

  if (opt_replace_wm)
@@ -375,17 +376,7 @@ meta_init (void)

  meta_ui_init ();

-  /* If we are running with wayland then we don't wait until we have
-   * an X connection before initializing clutter we instead initialize
-   * it earlier since we need to initialize the GL driver so the driver
-   * can register any needed wayland extensions. */
-  if (!meta_is_wayland_compositor ())
-    {
-      /*
-       * Clutter can only be initialized after the UI.
-       */
-      meta_clutter_init ();
-    }
+  meta_restart_init ();

  /*
   * XXX: We cannot handle high dpi scaling yet, so fix the scale to 1
@@ -444,24 +435,10 @@ meta_register_with_session (void)
 int
 meta_run (void)
 {
-  const gchar *log_domains[] = {
-    NULL, G_LOG_DOMAIN, "Gtk", "Gdk", "GLib",
-    "Pango", "GLib-GObject", "GThread"
-  };
-  guint i;
-
  /* Load prefs */
  meta_prefs_init ();
  meta_prefs_add_listener (prefs_changed_callback, NULL);

-  for (i=0; i<G_N_ELEMENTS(log_domains); i++)
-    g_log_set_handler (log_domains[i],
-                       G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
-                       log_handler, NULL);
-
-  if (g_getenv ("MUTTER_G_FATAL_WARNINGS") != NULL)
-    g_log_set_always_fatal (G_LOG_LEVEL_MASK);
-
  meta_ui_set_current_theme (meta_prefs_get_theme ());

  /* Try to find some theme that'll work if the theme preference
--- a/src/core/meta-accel-parse.c
+++ b/src/core/meta-accel-parse.c
@@ -309,9 +309,16 @@ accelerator_parse (const gchar         *accelerator,
              keyval = xkb_keysym_from_name (accelerator, XKB_KEYSYM_CASE_INSENSITIVE);
 	      if (keyval == XKB_KEY_NoSymbol)
 	        {
-	          error = TRUE;
-	          goto out;
-		}
+                  char *with_xf86 = g_strconcat ("XF86", accelerator, NULL);
+                  keyval = xkb_keysym_from_name (with_xf86, XKB_KEYSYM_CASE_INSENSITIVE);
+                  g_free (with_xf86);
+
+                  if (keyval == XKB_KEY_NoSymbol)
+                    {
+                      error = TRUE;
+                      goto out;
+                    }
+                }
 	    }

          accelerator += len;
--- a/src/core/meta-gesture-tracker-private.h
+++ b/src/core/meta-gesture-tracker-private.h
@@ -0,0 +1,75 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2014 Red Hat
+ *
+ * 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.
+ *
+ * Author: Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#ifndef META_GESTURE_TRACKER_PRIVATE_H
+#define META_GESTURE_TRACKER_PRIVATE_H
+
+#include <glib-object.h>
+#include <clutter/clutter.h>
+#include <meta/window.h>
+
+#define META_TYPE_GESTURE_TRACKER            (meta_gesture_tracker_get_type ())
+#define META_GESTURE_TRACKER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_GESTURE_TRACKER, MetaGestureTracker))
+#define META_GESTURE_TRACKER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_GESTURE_TRACKER, MetaGestureTrackerClass))
+#define META_IS_GESTURE_TRACKER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_GESTURE_TRACKER))
+#define META_IS_GESTURE_TRACKER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_GESTURE_TRACKER))
+#define META_GESTURE_TRACKER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_GESTURE_TRACKER, MetaGestureTrackerClass))
+
+typedef struct _MetaGestureTracker MetaGestureTracker;
+typedef struct _MetaGestureTrackerClass MetaGestureTrackerClass;
+
+typedef enum {
+  META_SEQUENCE_NONE,
+  META_SEQUENCE_ACCEPTED,
+  META_SEQUENCE_REJECTED,
+  META_SEQUENCE_PENDING_END
+} MetaSequenceState;
+
+struct _MetaGestureTracker
+{
+  GObject parent_instance;
+};
+
+struct _MetaGestureTrackerClass
+{
+  GObjectClass parent_class;
+
+  void (* state_changed) (MetaGestureTracker   *tracker,
+                          ClutterEventSequence *sequence,
+                          MetaSequenceState     state);
+};
+
+GType                meta_gesture_tracker_get_type           (void) G_GNUC_CONST;
+
+MetaGestureTracker * meta_gesture_tracker_new                (void);
+
+gboolean             meta_gesture_tracker_handle_event       (MetaGestureTracker   *tracker,
+                                                              const ClutterEvent   *event);
+gboolean             meta_gesture_tracker_set_sequence_state (MetaGestureTracker   *tracker,
+                                                              ClutterEventSequence *sequence,
+                                                              MetaSequenceState     state);
+MetaSequenceState    meta_gesture_tracker_get_sequence_state (MetaGestureTracker   *tracker,
+                                                              ClutterEventSequence *sequence);
+gint                 meta_gesture_tracker_get_n_current_touches (MetaGestureTracker *tracker);
+
+#endif /* META_GESTURE_TRACKER_PRIVATE_H */
--- a/src/core/meta-gesture-tracker.c
+++ b/src/core/meta-gesture-tracker.c
@@ -0,0 +1,582 @@
+/*
+ * Copyright (C) 2014 Red Hat
+ *
+ * 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.
+ *
+ * Author: Carlos Garnacho <carlosg@gnome.org>
+ */
+
+/**
+ * SECTION:gesture-tracker
+ * @Title: MetaGestureTracker
+ * @Short_Description: Manages gestures on windows/desktop
+ *
+ * Forwards touch events to clutter actors, and accepts/rejects touch sequences
+ * based on the outcome of those.
+ */
+
+#include "config.h"
+#include "meta-gesture-tracker-private.h"
+#include "meta-surface-actor.h"
+
+#define DISTANCE_THRESHOLD 30
+
+typedef struct _MetaGestureTrackerPrivate MetaGestureTrackerPrivate;
+typedef struct _GestureActionData GestureActionData;
+typedef struct _MetaSequenceInfo MetaSequenceInfo;
+
+struct _MetaSequenceInfo
+{
+  MetaGestureTracker *tracker;
+  ClutterEventSequence *sequence;
+  MetaSequenceState state;
+  guint autodeny_timeout_id;
+  gfloat start_x;
+  gfloat start_y;
+};
+
+struct _GestureActionData
+{
+  ClutterGestureAction *gesture;
+  MetaSequenceState state;
+  guint gesture_begin_id;
+  guint gesture_end_id;
+  guint gesture_cancel_id;
+};
+
+struct _MetaGestureTrackerPrivate
+{
+  GHashTable *sequences; /* Hashtable of ClutterEventSequence->MetaSequenceInfo */
+
+  MetaSequenceState stage_state;
+  GArray *stage_gestures; /* Array of GestureActionData */
+  GList *listeners; /* List of ClutterGestureAction */
+  guint autodeny_timeout;
+};
+
+enum {
+  PROP_0,
+  PROP_AUTODENY_TIMEOUT,
+  LAST_PROP,
+};
+
+static GParamSpec *obj_props[LAST_PROP];
+
+enum {
+  STATE_CHANGED,
+  N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0 };
+
+#define DEFAULT_AUTODENY_TIMEOUT 150
+
+static void meta_gesture_tracker_untrack_stage (MetaGestureTracker *tracker);
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaGestureTracker, meta_gesture_tracker, G_TYPE_OBJECT)
+
+static void
+meta_gesture_tracker_finalize (GObject *object)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (META_GESTURE_TRACKER (object));
+
+  g_hash_table_destroy (priv->sequences);
+  g_array_free (priv->stage_gestures, TRUE);
+  g_list_free (priv->listeners);
+
+  G_OBJECT_CLASS (meta_gesture_tracker_parent_class)->finalize (object);
+}
+
+static void
+meta_gesture_tracker_set_property (GObject      *object,
+                                   guint         prop_id,
+                                   const GValue *value,
+                                   GParamSpec   *pspec)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (META_GESTURE_TRACKER (object));
+
+  switch (prop_id)
+    {
+    case PROP_AUTODENY_TIMEOUT:
+      priv->autodeny_timeout = g_value_get_uint (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+meta_gesture_tracker_get_property (GObject    *object,
+                                   guint       prop_id,
+                                   GValue     *value,
+                                   GParamSpec *pspec)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (META_GESTURE_TRACKER (object));
+
+  switch (prop_id)
+    {
+    case PROP_AUTODENY_TIMEOUT:
+      g_value_set_uint (value, priv->autodeny_timeout);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+meta_gesture_tracker_class_init (MetaGestureTrackerClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = meta_gesture_tracker_finalize;
+  object_class->set_property = meta_gesture_tracker_set_property;
+  object_class->get_property = meta_gesture_tracker_get_property;
+
+  obj_props[PROP_AUTODENY_TIMEOUT] = g_param_spec_uint ("autodeny-timeout",
+                                                        "Auto-deny timeout",
+                                                        "Auto-deny timeout",
+                                                        0, G_MAXUINT, DEFAULT_AUTODENY_TIMEOUT,
+                                                        G_PARAM_STATIC_STRINGS |
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, LAST_PROP, obj_props);
+
+  signals[STATE_CHANGED] =
+    g_signal_new ("state-changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (MetaGestureTrackerClass, state_changed),
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_UINT);
+}
+
+static gboolean
+autodeny_sequence (gpointer user_data)
+{
+  MetaSequenceInfo *info = user_data;
+
+  /* Deny the sequence automatically after the given timeout */
+  if (info->state == META_SEQUENCE_NONE)
+    meta_gesture_tracker_set_sequence_state (info->tracker, info->sequence,
+                                             META_SEQUENCE_REJECTED);
+
+  info->autodeny_timeout_id = 0;
+  return G_SOURCE_REMOVE;
+}
+
+static MetaSequenceInfo *
+meta_sequence_info_new (MetaGestureTracker *tracker,
+                        const ClutterEvent *event)
+{
+  MetaGestureTrackerPrivate *priv;
+  MetaSequenceInfo *info;
+  guint ms;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  ms = priv->autodeny_timeout;
+
+  info = g_slice_new0 (MetaSequenceInfo);
+  info->tracker = tracker;
+  info->sequence = event->touch.sequence;
+  info->state = META_SEQUENCE_NONE;
+  info->autodeny_timeout_id = g_timeout_add (ms, autodeny_sequence, info);
+
+  clutter_event_get_coords (event, &info->start_x, &info->start_y);
+
+  return info;
+}
+
+static void
+meta_sequence_info_free (MetaSequenceInfo *info)
+{
+  if (info->autodeny_timeout_id)
+    g_source_remove (info->autodeny_timeout_id);
+
+  if (info->state == META_SEQUENCE_NONE)
+    meta_gesture_tracker_set_sequence_state (info->tracker, info->sequence,
+                                             META_SEQUENCE_REJECTED);
+  g_slice_free (MetaSequenceInfo, info);
+}
+
+static gboolean
+state_is_applicable (MetaSequenceState prev_state,
+                     MetaSequenceState state)
+{
+  if (prev_state == META_SEQUENCE_PENDING_END)
+    return FALSE;
+
+  /* Don't allow reverting to none */
+  if (state == META_SEQUENCE_NONE)
+    return FALSE;
+
+  /* PENDING_END state is final */
+  if (prev_state == META_SEQUENCE_PENDING_END)
+    return FALSE;
+
+  /* Sequences must be accepted/denied before PENDING_END */
+  if (prev_state == META_SEQUENCE_NONE &&
+      state == META_SEQUENCE_PENDING_END)
+    return FALSE;
+
+  /* Make sequences stick to their accepted/denied state */
+  if (state != META_SEQUENCE_PENDING_END &&
+      prev_state != META_SEQUENCE_NONE)
+    return FALSE;
+
+  return TRUE;
+}
+
+static gboolean
+meta_gesture_tracker_set_state (MetaGestureTracker *tracker,
+                                MetaSequenceState   state)
+{
+  MetaGestureTrackerPrivate *priv;
+  ClutterEventSequence *sequence;
+  GHashTableIter iter;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+
+  if (priv->stage_state != state &&
+      !state_is_applicable (priv->stage_state, state))
+    return FALSE;
+
+  g_hash_table_iter_init (&iter, priv->sequences);
+  priv->stage_state = state;
+
+  while (g_hash_table_iter_next (&iter, (gpointer*) &sequence, NULL))
+    meta_gesture_tracker_set_sequence_state (tracker, sequence, state);
+
+  return TRUE;
+}
+
+static gboolean
+gesture_begin_cb (ClutterGestureAction *gesture,
+                  ClutterActor         *actor,
+                  MetaGestureTracker   *tracker)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+
+  if (!g_list_find (priv->listeners, gesture) &&
+      meta_gesture_tracker_set_state (tracker, META_SEQUENCE_ACCEPTED))
+    priv->listeners = g_list_prepend (priv->listeners, gesture);
+
+  return TRUE;
+}
+
+static void
+gesture_end_cb (ClutterGestureAction *gesture,
+                ClutterActor         *actor,
+                MetaGestureTracker   *tracker)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  priv->listeners = g_list_remove (priv->listeners, gesture);
+
+  if (!priv->listeners)
+    meta_gesture_tracker_untrack_stage (tracker);
+}
+
+static void
+gesture_cancel_cb (ClutterGestureAction *gesture,
+                   ClutterActor         *actor,
+                   MetaGestureTracker   *tracker)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+
+  if (g_list_find (priv->listeners, gesture))
+    {
+      priv->listeners = g_list_remove (priv->listeners, gesture);
+
+      if (!priv->listeners)
+        meta_gesture_tracker_set_state (tracker, META_SEQUENCE_PENDING_END);
+    }
+}
+
+static gboolean
+cancel_and_unref_gesture_cb (ClutterGestureAction *action)
+{
+  clutter_gesture_action_cancel (action);
+  g_object_unref (action);
+  return G_SOURCE_REMOVE;
+}
+
+static void
+clear_gesture_data (GestureActionData *data)
+{
+  g_signal_handler_disconnect (data->gesture, data->gesture_begin_id);
+  g_signal_handler_disconnect (data->gesture, data->gesture_end_id);
+  g_signal_handler_disconnect (data->gesture, data->gesture_cancel_id);
+
+  /* Defer cancellation to an idle, as it may happen within event handling */
+  g_idle_add ((GSourceFunc) cancel_and_unref_gesture_cb, data->gesture);
+}
+
+static void
+meta_gesture_tracker_init (MetaGestureTracker *tracker)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  priv->sequences = g_hash_table_new_full (NULL, NULL, NULL,
+                                           (GDestroyNotify) meta_sequence_info_free);
+  priv->stage_gestures = g_array_new (FALSE, FALSE, sizeof (GestureActionData));
+  g_array_set_clear_func (priv->stage_gestures, (GDestroyNotify) clear_gesture_data);
+}
+
+MetaGestureTracker *
+meta_gesture_tracker_new (void)
+{
+  return g_object_new (META_TYPE_GESTURE_TRACKER, NULL);
+}
+
+static void
+meta_gesture_tracker_track_stage (MetaGestureTracker *tracker,
+                                  ClutterActor       *stage)
+{
+  MetaGestureTrackerPrivate *priv;
+  GList *actions, *l;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  actions = clutter_actor_get_actions (stage);
+
+  for (l = actions; l; l = l->next)
+    {
+      GestureActionData data;
+
+      if (!CLUTTER_IS_GESTURE_ACTION (l->data))
+        continue;
+
+      data.gesture = g_object_ref (l->data);
+      data.state = META_SEQUENCE_NONE;
+      data.gesture_begin_id =
+        g_signal_connect (data.gesture, "gesture-begin",
+                          G_CALLBACK (gesture_begin_cb), tracker);
+      data.gesture_end_id =
+        g_signal_connect (data.gesture, "gesture-end",
+                          G_CALLBACK (gesture_end_cb), tracker);
+      data.gesture_cancel_id =
+        g_signal_connect (data.gesture, "gesture-cancel",
+                          G_CALLBACK (gesture_cancel_cb), tracker);
+      g_array_append_val (priv->stage_gestures, data);
+    }
+
+  g_list_free (actions);
+}
+
+static void
+meta_gesture_tracker_untrack_stage (MetaGestureTracker *tracker)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  priv->stage_state = META_SEQUENCE_NONE;
+
+  g_hash_table_remove_all (priv->sequences);
+
+  if (priv->stage_gestures->len > 0)
+    g_array_remove_range (priv->stage_gestures, 0, priv->stage_gestures->len);
+
+  g_list_free (priv->listeners);
+  priv->listeners = NULL;
+}
+
+gboolean
+meta_gesture_tracker_handle_event (MetaGestureTracker *tracker,
+				   const ClutterEvent *event)
+{
+  MetaGestureTrackerPrivate *priv;
+  ClutterEventSequence *sequence;
+  MetaSequenceState state;
+  MetaSequenceInfo *info;
+  ClutterActor *stage;
+  gfloat x, y;
+
+  sequence = clutter_event_get_event_sequence (event);
+
+  if (!sequence)
+    return FALSE;
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  stage = CLUTTER_ACTOR (clutter_event_get_stage (event));
+
+  switch (event->type)
+    {
+    case CLUTTER_TOUCH_BEGIN:
+      if (g_hash_table_size (priv->sequences) == 0)
+        meta_gesture_tracker_track_stage (tracker, stage);
+
+      info = meta_sequence_info_new (tracker, event);
+      g_hash_table_insert (priv->sequences, sequence, info);
+
+      if (priv->stage_gestures->len == 0)
+        {
+          /* If no gestures are attached, reject the sequence right away */
+          meta_gesture_tracker_set_sequence_state (tracker, sequence,
+                                                   META_SEQUENCE_REJECTED);
+        }
+      else if (priv->stage_state != META_SEQUENCE_NONE)
+        {
+          /* Make the sequence state match the general state */
+          meta_gesture_tracker_set_sequence_state (tracker, sequence,
+                                                   priv->stage_state);
+        }
+      state = info->state;
+      break;
+    case CLUTTER_TOUCH_END:
+      info = g_hash_table_lookup (priv->sequences, sequence);
+
+      if (!info)
+        return FALSE;
+
+      /* If nothing was done yet about the sequence, reject it so X11
+       * clients may see it
+       */
+      if (info->state == META_SEQUENCE_NONE)
+        meta_gesture_tracker_set_sequence_state (tracker, sequence,
+                                                 META_SEQUENCE_REJECTED);
+
+      state = info->state;
+      g_hash_table_remove (priv->sequences, sequence);
+
+      if (g_hash_table_size (priv->sequences) == 0)
+        meta_gesture_tracker_untrack_stage (tracker);
+      break;
+    case CLUTTER_TOUCH_UPDATE:
+      info = g_hash_table_lookup (priv->sequences, sequence);
+
+      if (!info)
+        return FALSE;
+
+      clutter_event_get_coords (event, &x, &y);
+
+      if (info->state == META_SEQUENCE_NONE &&
+          (ABS (info->start_x - x) > DISTANCE_THRESHOLD ||
+           ABS (info->start_y - y) > DISTANCE_THRESHOLD))
+        meta_gesture_tracker_set_sequence_state (tracker, sequence,
+                                                 META_SEQUENCE_REJECTED);
+      state = info->state;
+      break;
+    default:
+      return FALSE;
+      break;
+    }
+
+  /* As soon as a sequence is accepted, we replay it to
+   * the stage as a captured event, and make sure it's never
+   * propagated anywhere else. Since ClutterGestureAction does
+   * all its event handling from a captured-event handler on
+   * the stage, this effectively acts as a "sequence grab" on
+   * gesture actions.
+   *
+   * Sequences that aren't (yet or never) in an accepted state
+   * will go through, these events will get processed through
+   * the compositor, and eventually through clutter, still
+   * triggering the gestures capturing events on the stage, and
+   * possibly resulting in MetaSequenceState changes.
+   */
+  if (state == META_SEQUENCE_ACCEPTED)
+    {
+      clutter_actor_event (CLUTTER_ACTOR (clutter_event_get_stage (event)),
+                           event, TRUE);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+gboolean
+meta_gesture_tracker_set_sequence_state (MetaGestureTracker   *tracker,
+                                         ClutterEventSequence *sequence,
+                                         MetaSequenceState     state)
+{
+  MetaGestureTrackerPrivate *priv;
+  MetaSequenceInfo *info;
+
+  g_return_val_if_fail (META_IS_GESTURE_TRACKER (tracker), FALSE);
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  info = g_hash_table_lookup (priv->sequences, sequence);
+
+  if (!info)
+    return FALSE;
+  else if (state == info->state)
+    return TRUE;
+
+  if (!state_is_applicable (info->state, state))
+    return FALSE;
+
+  /* Unset autodeny timeout */
+  if (info->autodeny_timeout_id)
+    {
+      g_source_remove (info->autodeny_timeout_id);
+      info->autodeny_timeout_id = 0;
+    }
+
+  info->state = state;
+  g_signal_emit (tracker, signals[STATE_CHANGED], 0, sequence, info->state);
+
+  /* If the sequence was denied, set immediately to PENDING_END after emission */
+  if (state == META_SEQUENCE_REJECTED)
+    {
+      info->state = META_SEQUENCE_PENDING_END;
+      g_signal_emit (tracker, signals[STATE_CHANGED], 0, sequence, info->state);
+    }
+
+  return TRUE;
+}
+
+MetaSequenceState
+meta_gesture_tracker_get_sequence_state (MetaGestureTracker   *tracker,
+                                         ClutterEventSequence *sequence)
+{
+  MetaGestureTrackerPrivate *priv;
+  MetaSequenceInfo *info;
+
+  g_return_val_if_fail (META_IS_GESTURE_TRACKER (tracker), META_SEQUENCE_PENDING_END);
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  info = g_hash_table_lookup (priv->sequences, sequence);
+
+  if (!info)
+    return META_SEQUENCE_PENDING_END;
+
+  return info->state;
+}
+
+gint
+meta_gesture_tracker_get_n_current_touches (MetaGestureTracker *tracker)
+{
+  MetaGestureTrackerPrivate *priv;
+
+  g_return_val_if_fail (META_IS_GESTURE_TRACKER (tracker), 0);
+
+  priv = meta_gesture_tracker_get_instance_private (tracker);
+  return g_hash_table_size (priv->sequences);
+}
--- a/src/core/prefs.c
+++ b/src/core/prefs.c
@@ -28,7 +28,6 @@

 #include <config.h>
 #include <meta/prefs.h>
-#include "ui.h"
 #include "util-private.h"
 #include "meta-plugin-manager.h"
 #include <glib.h>
@@ -67,6 +66,7 @@
 #define SCHEMA_INTERFACE       "org.gnome.desktop.interface"
 #define SCHEMA_INPUT_SOURCES   "org.gnome.desktop.input-sources"
 #define SCHEMA_XSETTINGS       "org.gnome.settings-daemon.plugins.xsettings"
+#define SCHEMA_MOUSE           "org.gnome.settings-daemon.peripherals.mouse"

 #define SETTINGS(s) g_hash_table_lookup (settings_schemas, (s))

@@ -101,6 +101,7 @@ static gboolean gnome_animations = TRUE;
 static char *cursor_theme = NULL;
 static int   cursor_size = 24;
 static int   draggable_border_width = 10;
+static int   drag_threshold;
 static gboolean resize_with_right_button = FALSE;
 static gboolean edge_tiling = FALSE;
 static gboolean force_fullscreen = TRUE;
@@ -492,6 +493,13 @@ static MetaIntPreference preferences_int[] =
      },
      &draggable_border_width
    },
+    {
+      { "drag-threshold",
+        SCHEMA_MOUSE,
+        META_PREF_DRAG_THRESHOLD,
+      },
+      &drag_threshold
+    },
    { { NULL, 0, 0 }, NULL },
  };

@@ -978,6 +986,10 @@ meta_prefs_init (void)
  g_signal_connect (settings, "changed", G_CALLBACK (settings_changed), NULL);
  g_hash_table_insert (settings_schemas, g_strdup (SCHEMA_MUTTER), settings);

+  settings = g_settings_new (SCHEMA_MOUSE);
+  g_signal_connect (settings, "changed", G_CALLBACK (settings_changed), NULL);
+  g_hash_table_insert (settings_schemas, g_strdup (SCHEMA_MOUSE), settings);
+
  /* Individual keys we watch outside of our schemas */
  settings = g_settings_new (SCHEMA_INTERFACE);
  g_signal_connect (settings, "changed::" KEY_GNOME_ACCESSIBILITY,
@@ -1198,8 +1210,9 @@ settings_changed (GSettings *settings,
    }
  else
    {
-      /* Someone added a preference of an unhandled type */
-      g_assert_not_reached ();
+      /* Unknown preference type. This quite likely simply isn't
+       * a preference we track changes to. */
+      return;
    }

  g_variant_unref (value);
@@ -1234,6 +1247,7 @@ xsettings_overrides_changed (GSettings  *settings,
  GVariant *value;
  GVariantDict overrides;
  int shell_shows_app_menu = 1;
+  gboolean changed = FALSE;

  if (!g_settings_get_boolean (settings, "active"))
    goto out;
@@ -1247,8 +1261,13 @@ xsettings_overrides_changed (GSettings  *settings,
                         "Gtk/ShellShowsAppMenu", "i", &shell_shows_app_menu);
  g_variant_dict_clear (&overrides);

+  changed = (show_fallback_app_menu == !!shell_shows_app_menu);
+
 out:
  show_fallback_app_menu = !shell_shows_app_menu;
+
+  if (changed)
+    queue_changed (META_PREF_BUTTON_LAYOUT);
 }

 /**
@@ -1328,10 +1347,26 @@ meta_prefs_get_cursor_theme (void)
  return cursor_theme;
 }

+static int
+get_scale_factor (void)
+{
+  GdkScreen *screen;
+  GValue value = G_VALUE_INIT;
+
+  g_value_init (&value, G_TYPE_INT);
+
+  /* XXX: Should this be in ui/ ? Or MetaMonitorManager? */
+  screen = gdk_screen_get_default ();
+  if (gdk_screen_get_setting (screen, "gdk-window-scaling-factor", &value))
+    return g_value_get_int (&value);
+  else
+    return 1;
+}
+
 int
 meta_prefs_get_cursor_size (void)
 {
-  return cursor_size;
+  return cursor_size * get_scale_factor ();
 }


@@ -1662,43 +1697,43 @@ button_layout_handler (GVariant *value,
  g_strfreev (sides);

  /* Invert the button layout for RTL languages */
-  if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
-  {
-    MetaButtonLayout rtl_layout;
-    int j;
+  if (meta_get_locale_direction() == META_LOCALE_DIRECTION_RTL)
+    {
+      MetaButtonLayout rtl_layout;
+      int j;

-    for (i = 0; new_layout.left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
-    for (j = 0; j < i; j++)
-      {
-        rtl_layout.right_buttons[j] = new_layout.left_buttons[i - j - 1];
-        if (j == 0)
-          rtl_layout.right_buttons_has_spacer[i - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
-        else
-          rtl_layout.right_buttons_has_spacer[j - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
-      }
-    for (; j < MAX_BUTTONS_PER_CORNER; j++)
-      {
-        rtl_layout.right_buttons[j] = META_BUTTON_FUNCTION_LAST;
-        rtl_layout.right_buttons_has_spacer[j] = FALSE;
-      }
+      for (i = 0; new_layout.left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
+      for (j = 0; j < i; j++)
+        {
+          rtl_layout.right_buttons[j] = new_layout.left_buttons[i - j - 1];
+          if (j == 0)
+            rtl_layout.right_buttons_has_spacer[i - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
+          else
+            rtl_layout.right_buttons_has_spacer[j - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
+        }
+      for (; j < MAX_BUTTONS_PER_CORNER; j++)
+        {
+          rtl_layout.right_buttons[j] = META_BUTTON_FUNCTION_LAST;
+          rtl_layout.right_buttons_has_spacer[j] = FALSE;
+        }

-    for (i = 0; new_layout.right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
-    for (j = 0; j < i; j++)
-      {
-        rtl_layout.left_buttons[j] = new_layout.right_buttons[i - j - 1];
-        if (j == 0)
-          rtl_layout.left_buttons_has_spacer[i - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
-        else
-          rtl_layout.left_buttons_has_spacer[j - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
-      }
-    for (; j < MAX_BUTTONS_PER_CORNER; j++)
-      {
-        rtl_layout.left_buttons[j] = META_BUTTON_FUNCTION_LAST;
-        rtl_layout.left_buttons_has_spacer[j] = FALSE;
-      }
+      for (i = 0; new_layout.right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
+      for (j = 0; j < i; j++)
+        {
+          rtl_layout.left_buttons[j] = new_layout.right_buttons[i - j - 1];
+          if (j == 0)
+            rtl_layout.left_buttons_has_spacer[i - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
+          else
+            rtl_layout.left_buttons_has_spacer[j - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
+        }
+      for (; j < MAX_BUTTONS_PER_CORNER; j++)
+        {
+          rtl_layout.left_buttons[j] = META_BUTTON_FUNCTION_LAST;
+          rtl_layout.left_buttons_has_spacer[j] = FALSE;
+        }

-    new_layout = rtl_layout;
-  }
+      new_layout = rtl_layout;
+    }

  if (!button_layout_equal (&button_layout, &new_layout))
    {
@@ -1902,6 +1937,9 @@ meta_preference_to_string (MetaPreference pref)
    case META_PREF_DRAGGABLE_BORDER_WIDTH:
      return "DRAGGABLE_BORDER_WIDTH";

+    case META_PREF_DRAG_THRESHOLD:
+      return "DRAG_TRHESHOLD";
+
    case META_PREF_DYNAMIC_WORKSPACES:
      return "DYNAMIC_WORKSPACES";

@@ -1995,23 +2033,6 @@ update_binding (MetaKeyPref *binding,
          continue;
        }

-      /* Bug 329676: Bindings which can be shifted must not have no modifiers,
-       * nor only SHIFT as a modifier.
-       */
-
-      if (binding->add_shift &&
-          0 != keysym &&
-          (META_VIRTUAL_SHIFT_MASK == mods || 0 == mods))
-        {
-          meta_warning ("Cannot bind \"%s\" to %s: it needs a modifier "
-                        "such as Ctrl or Alt.\n",
-                        binding->name, strokes[i]);
-
-          /* Value is kept and will thus be removed next time we save the key.
-           * Changing the key in response to a modification could lead to cyclic calls. */
-          continue;
-        }
-
      combo = g_malloc0 (sizeof (MetaKeyCombo));
      combo->keysym = keysym;
      combo->keycode = keycode;
@@ -2187,7 +2208,6 @@ meta_prefs_add_keybinding (const char           *name,
  pref->settings = g_object_ref (settings);
  pref->action = action;
  pref->combos = NULL;
-  pref->add_shift = (flags & META_KEY_BINDING_REVERSES) != 0;
  pref->per_window = (flags & META_KEY_BINDING_PER_WINDOW) != 0;
  pref->builtin = (flags & META_KEY_BINDING_BUILTIN) != 0;

@@ -2367,6 +2387,12 @@ meta_prefs_get_draggable_border_width (void)
  return draggable_border_width;
 }

+int
+meta_prefs_get_drag_threshold (void)
+{
+  return drag_threshold;
+}
+
 void
 meta_prefs_set_force_fullscreen (gboolean whether)
 {
--- a/src/core/restart-helper.c
+++ b/src/core/restart-helper.c
@@ -0,0 +1,82 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * SECTION:restart-helper
+ * @short_description: helper program during a restart
+ *
+ * To smoothly restart Mutter, we want to keep the composite
+ * overlay window enabled during the restart. This is done by
+ * spawning this program, which keeps a reference to the the composite
+ * overlay window until Mutter picks it back up.
+ */
+
+/*
+ * Copyright (C) 2014 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/Xcomposite.h>
+
+int
+main (int    argc,
+      char **argv)
+{
+  Display *display = XOpenDisplay (NULL);
+  Window selection_window;
+  XSetWindowAttributes xwa;
+  unsigned long mask = 0;
+
+  xwa.override_redirect = True;
+  mask |= CWOverrideRedirect;
+
+
+  XCompositeGetOverlayWindow (display, DefaultRootWindow (display));
+
+  selection_window = XCreateWindow (display,
+				    DefaultRootWindow (display),
+				    -100, -100, 1, 1, 0,
+				    0,
+				    InputOnly,
+				    DefaultVisual (display, DefaultScreen (display)),
+				    mask, &xwa);
+
+  XSetSelectionOwner (display,
+		      XInternAtom (display, "_MUTTER_RESTART_HELPER", False),
+		      selection_window,
+		      CurrentTime);
+
+  /* Mutter looks for an (arbitrary) line printed to stdout to know that
+   * we have started and have a reference to the COW. XSync() so that
+   * everything is set on the X server before Mutter starts restarting.
+   */
+  XSync (display, False);
+
+  printf ("STARTED\n");
+  fflush (stdout);
+
+  while (True)
+    {
+      XEvent xev;
+
+      XNextEvent (display, &xev);
+      /* Mutter restarted and unset the selection to indicate that
+       * it has a reference on the COW again */
+      if (xev.xany.type == SelectionClear)
+	return 0;
+    }
+}
--- a/src/core/restart.c
+++ b/src/core/restart.c
@@ -0,0 +1,212 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2014 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SECTION:restart
+ * @short_description: Smoothly restart the compositor
+ *
+ * There are some cases where we need to restart Mutter in order
+ * to deal with changes in state - the particular case inspiring
+ * this is enabling or disabling stereo output. To make this
+ * fairly smooth for the user, we need to do two things:
+ *
+ *  - Display a message to the user and make sure that it is
+ *    actually painted before we exit.
+ *  - Use a helper program so that the Composite Overlay Window
+ *    isn't unmapped and mapped.
+ *
+ * This handles both of these.
+ */
+
+#include <config.h>
+
+#include <clutter/clutter.h>
+#include <gio/gunixinputstream.h>
+
+#include <meta/main.h>
+#include "ui.h"
+#include "util-private.h"
+#include "display-private.h"
+
+static gboolean restart_helper_started = FALSE;
+static gboolean restart_message_shown = FALSE;
+static gboolean is_restart = FALSE;
+
+void
+meta_restart_init (void)
+{
+  Display *xdisplay = meta_ui_get_display ();
+  Atom atom_restart_helper = XInternAtom (xdisplay, "_MUTTER_RESTART_HELPER", False);
+  Window restart_helper_window = None;
+
+  restart_helper_window = XGetSelectionOwner (xdisplay, atom_restart_helper);
+  if (restart_helper_window)
+    is_restart = TRUE;
+}
+
+static void
+restart_check_ready (void)
+{
+  if (restart_helper_started && restart_message_shown)
+    meta_display_request_restart (meta_get_display ());
+}
+
+static void
+restart_helper_read_line_callback (GObject      *source_object,
+                                   GAsyncResult *res,
+                                   gpointer      user_data)
+{
+  GError *error = NULL;
+  gsize length;
+  char *line = g_data_input_stream_read_line_finish_utf8 (G_DATA_INPUT_STREAM (source_object),
+                                                          res,
+                                                          &length, &error);
+  if (line == NULL)
+    {
+      meta_warning ("Failed to read output from restart helper%s%s\n",
+                    error ? ": " : NULL,
+                    error ? error->message : NULL);
+    }
+  else
+    g_free (line); /* We don't actually care what the restart helper outputs */
+
+  g_object_unref (source_object);
+
+  restart_helper_started = TRUE;
+  restart_check_ready ();
+}
+
+static gboolean
+restart_message_painted (gpointer data)
+{
+  restart_message_shown = TRUE;
+  restart_check_ready ();
+
+  return FALSE;
+}
+
+/**
+ * meta_restart:
+ * @message: message to display to the user.
+ *
+ * Starts the process of restarting the compositor. Note that Mutter's
+ * involvement here is to make the restart visually smooth for the
+ * user - it cannot itself safely reexec a program that embeds libmuttter.
+ * So in order for this to work, the compositor must handle two
+ * signals -  MetaDisplay::show-restart-message, to display the
+ * message passed here on the Clutter stage, and ::restart to actually
+ * reexec the compositor.
+ */
+void
+meta_restart (const char *message)
+{
+  MetaDisplay *display = meta_get_display();
+  GInputStream *unix_stream;
+  GDataInputStream *data_stream;
+  GError *error = NULL;
+  int helper_out_fd;
+
+  static const char * const helper_argv[] = {
+    MUTTER_LIBEXECDIR "/mutter-restart-helper", NULL
+  };
+
+  if (meta_display_show_restart_message (display, message))
+    {
+      /* Wait until the stage was painted */
+      clutter_threads_add_repaint_func_full (CLUTTER_REPAINT_FLAGS_POST_PAINT,
+                                             restart_message_painted,
+                                             NULL, NULL);
+    }
+  else
+    {
+      /* Can't show the message, show the message as soon as the
+       * restart helper starts
+       */
+      restart_message_painted (NULL);
+    }
+
+  /* We also need to wait for the restart helper to get its
+   * reference to the Composite Overlay Window.
+   */
+  if (!g_spawn_async_with_pipes (NULL, /* working directory */
+                                 (char **)helper_argv,
+                                 NULL, /* envp */
+                                 G_SPAWN_DEFAULT,
+                                 NULL, NULL, /* child_setup */
+                                 NULL, /* child_pid */
+                                 NULL, /* standard_input */
+                                 &helper_out_fd,
+                                 NULL, /* standard_error */
+                                 &error))
+    {
+      meta_warning ("Failed to start restart helper: %s\n", error->message);
+      goto error;
+    }
+
+  unix_stream = g_unix_input_stream_new (helper_out_fd, TRUE);
+  data_stream = g_data_input_stream_new (unix_stream);
+  g_object_unref (unix_stream);
+
+  g_data_input_stream_read_line_async (data_stream, G_PRIORITY_DEFAULT,
+                                       NULL, restart_helper_read_line_callback,
+                                       &error);
+  if (error != NULL)
+    {
+      meta_warning ("Failed to read from restart helper: %s\n", error->message);
+      g_object_unref (data_stream);
+      goto error;
+    }
+
+  return;
+
+ error:
+  /* If starting the restart helper fails, then we just go ahead and restart
+   * immediately. We won't get a smooth transition, since the overlay window
+   * will be destroyed and recreated, but otherwise it will work fine.
+   */
+  restart_helper_started = TRUE;
+  restart_check_ready ();
+
+  return;
+}
+
+void
+meta_restart_finish (void)
+{
+  if (is_restart)
+    {
+      Display *xdisplay = meta_display_get_xdisplay (meta_get_display ());
+      Atom atom_restart_helper = XInternAtom (xdisplay, "_MUTTER_RESTART_HELPER", False);
+      XSetSelectionOwner (xdisplay, atom_restart_helper, None, CurrentTime);
+    }
+}
+
+/**
+ * meta_is_restart:
+ *
+ * Returns %TRUE if this instance of Mutter comes from Mutter
+ * restarting itself (for example to enable/disable stereo.)
+ * See meta_restart(). If this is the case, any startup visuals
+ * or animations should be suppressed.
+ */
+gboolean
+meta_is_restart (void)
+{
+  return is_restart;
+}
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -38,8 +38,8 @@
 #include "ui.h"
 #include "meta-monitor-manager.h"

-typedef void (* MetaScreenWindowFunc) (MetaScreen *screen, MetaWindow *window,
-                                       gpointer user_data);
+typedef void (* MetaScreenWindowFunc) (MetaWindow *window,
+                                       gpointer    user_data);

 typedef enum
 {
@@ -119,6 +119,8 @@ struct _MetaScreen
   * and restack them below a guard window. When using a compositor
   * this allows us to provide live previews of unmapped windows */
  Window guard_window;
+
+  Window composite_overlay_window;
 };

 struct _MetaScreenClass
@@ -135,8 +137,10 @@ MetaScreen*   meta_screen_new                 (MetaDisplay                *displ
                                               guint32                     timestamp);
 void          meta_screen_free                (MetaScreen                 *screen,
                                               guint32                     timestamp);
+void          meta_screen_init_workspaces     (MetaScreen                 *screen);
 void          meta_screen_manage_all_windows  (MetaScreen                 *screen);
 void          meta_screen_foreach_window      (MetaScreen                 *screen,
+                                               MetaListWindowsFlags        flags,
                                               MetaScreenWindowFunc        func,
                                               gpointer                    data);

--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -45,6 +45,7 @@
 #include "meta-cursor-tracker-private.h"

 #include <X11/extensions/Xinerama.h>
+#include <X11/extensions/Xcomposite.h>

 #include <X11/Xatom.h>
 #include <locale.h>
@@ -55,12 +56,13 @@
 #include "x11/window-x11.h"
 #include "x11/xprops.h"

+#include "backends/x11/meta-backend-x11.h"
+
 static char* get_screen_name (MetaDisplay *display,
                              int          number);

 static void update_num_workspaces  (MetaScreen *screen,
                                    guint32     timestamp);
-static void update_focus_mode      (MetaScreen *screen);
 static void set_workspace_names    (MetaScreen *screen);
 static void prefs_changed_callback (MetaPreference pref,
                                    gpointer       data);
@@ -404,17 +406,13 @@ meta_screen_xinerama_index_to_monitor_index (MetaScreen *screen,
 static void
 reload_monitor_infos (MetaScreen *screen)
 {
-  GList *tmp;
+  GList *l;
  MetaMonitorManager *manager;

-  tmp = screen->workspaces;
-  while (tmp != NULL)
+  for (l = screen->workspaces; l != NULL; l = l->next)
    {
-      MetaWorkspace *space = tmp->data;
-
+      MetaWorkspace *space = l->data;
      meta_workspace_invalidate_work_area (space);
-
-      tmp = tmp->next;
    }

  /* Any previous screen->monitor_infos or screen->outputs is freed by the caller */
@@ -469,13 +467,24 @@ create_guard_window (Display *xdisplay, MetaScreen *screen)
  XStoreName (xdisplay, guard_window, "mutter guard window");

  {
-    unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-    XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+    if (!meta_is_wayland_compositor ())
+      {
+        MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ());
+        Display *backend_xdisplay = meta_backend_x11_get_xdisplay (backend);
+        unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+        XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };

-    XISetMask (mask.mask, XI_ButtonPress);
-    XISetMask (mask.mask, XI_ButtonRelease);
-    XISetMask (mask.mask, XI_Motion);
-    XISelectEvents (xdisplay, guard_window, &mask, 1);
+        XISetMask (mask.mask, XI_ButtonPress);
+        XISetMask (mask.mask, XI_ButtonRelease);
+        XISetMask (mask.mask, XI_Motion);
+
+        /* Sync on the connection we created the window on to
+         * make sure it's created before we select on it on the
+         * backend connection. */
+        XSync (xdisplay, False);
+
+        XISelectEvents (backend_xdisplay, guard_window, &mask, 1);
+      }
  }

  stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
@@ -492,6 +501,15 @@ create_guard_window (Display *xdisplay, MetaScreen *screen)
  return guard_window;
 }

+/* Set a black background on the root window so that we don't
+ * see confusing old copies of old windows when debugging
+ * and testing. */
+static void
+meta_screen_set_background (MetaScreen *screen)
+{
+  XSetWindowBackground (screen->display->xdisplay, screen->xroot, 0x00000000);
+}
+
 MetaScreen*
 meta_screen_new (MetaDisplay *display,
                 int          number,
@@ -506,7 +524,6 @@ meta_screen_new (MetaDisplay *display,
  Atom wm_sn_atom;
  char buf[128];
  guint32 manager_timestamp;
-  gulong current_workspace;
  MetaMonitorManager *manager;

  replace_current_wm = meta_get_replace_current_wm ();
@@ -612,24 +629,15 @@ meta_screen_new (MetaDisplay *display,
  /* select our root window events */
  meta_error_trap_push (display);

-  /* We need to or with the existing event mask since
-   * gtk+ may be interested in other events.
-   */
  {
    long event_mask;
    unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
    XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-    XWindowAttributes attr;

-    meta_core_add_old_event_mask (xdisplay, xroot, &mask);
-
-    XISetMask (mask.mask, XI_KeyPress);
-    XISetMask (mask.mask, XI_KeyRelease);
    XISetMask (mask.mask, XI_Enter);
    XISetMask (mask.mask, XI_Leave);
    XISetMask (mask.mask, XI_FocusIn);
    XISetMask (mask.mask, XI_FocusOut);
-    XISetMask (mask.mask, XI_Motion);
 #ifdef HAVE_XI23
    if (META_DISPLAY_HAS_XINPUT_23 (display))
      {
@@ -641,9 +649,6 @@ meta_screen_new (MetaDisplay *display,

    event_mask = (SubstructureRedirectMask | SubstructureNotifyMask |
                  StructureNotifyMask | ColormapChangeMask | PropertyChangeMask);
-    if (XGetWindowAttributes (xdisplay, xroot, &attr))
-      event_mask |= attr.your_event_mask;
-
    XSelectInput (xdisplay, xroot, event_mask);
  }

@@ -657,6 +662,9 @@ meta_screen_new (MetaDisplay *display,
      return NULL;
    }

+  /* Select for cursor changes so the cursor tracker is up to date. */
+  XFixesSelectCursorInput (xdisplay, xroot, XFixesDisplayCursorNotifyMask);
+
  screen = g_object_new (META_TYPE_SCREEN, NULL);
  screen->closing = 0;

@@ -697,9 +705,16 @@ meta_screen_new (MetaDisplay *display,
  screen->starting_corner = META_SCREEN_TOPLEFT;
  screen->guard_window = None;

+  screen->composite_overlay_window = XCompositeGetOverlayWindow (xdisplay, xroot);
+
+  /* Now that we've gotten taken a reference count on the COW, we
+   * can close the helper that is holding on to it */
+  meta_restart_finish ();
+
  reload_monitor_infos (screen);

  meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
+  meta_screen_set_background (screen);

  /* Handle creating a no_focus_window for this screen */
  screen->no_focus_window =
@@ -721,24 +736,10 @@ meta_screen_new (MetaDisplay *display,

  meta_screen_update_workspace_layout (screen);

-  /* Get current workspace */
-  current_workspace = 0;
-  if (meta_prop_get_cardinal (screen->display,
-                              screen->xroot,
-                              screen->display->atom__NET_CURRENT_DESKTOP,
-                              &current_workspace))
-    meta_verbose ("Read existing _NET_CURRENT_DESKTOP = %d\n",
-                  (int) current_workspace);
-  else
-    meta_verbose ("No _NET_CURRENT_DESKTOP present\n");
-
  /* Screens must have at least one workspace at all times,
   * so create that required workspace.
   */
-  meta_workspace_activate (meta_workspace_new (screen), timestamp);
-  update_num_workspaces (screen, timestamp);
-
-  set_workspace_names (screen);
+  meta_workspace_new (screen);

  screen->keys_grabbed = FALSE;
  meta_screen_grab_keys (screen);
@@ -764,23 +765,47 @@ meta_screen_new (MetaDisplay *display,
  screen->startup_sequence_timeout = 0;
 #endif

-  /* Switch to the _NET_CURRENT_DESKTOP workspace */
-  {
-    MetaWorkspace *space;
-
-    space = meta_screen_get_workspace_by_index (screen,
-                                                current_workspace);
-
-    if (space != NULL)
-      meta_workspace_activate (space, timestamp);
-  }
-
  meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
                screen->number, screen->screen_name, screen->xroot);

  return screen;
 }

+void
+meta_screen_init_workspaces (MetaScreen *screen)
+{
+  MetaWorkspace *current_workspace;
+  gulong current_workspace_index = 0;
+  guint32 timestamp;
+
+  g_return_if_fail (META_IS_SCREEN (screen));
+
+  timestamp = screen->wm_sn_timestamp;
+
+  /* Get current workspace */
+  if (meta_prop_get_cardinal (screen->display,
+                              screen->xroot,
+                              screen->display->atom__NET_CURRENT_DESKTOP,
+                              &current_workspace_index))
+    meta_verbose ("Read existing _NET_CURRENT_DESKTOP = %d\n",
+                  (int) current_workspace_index);
+  else
+    meta_verbose ("No _NET_CURRENT_DESKTOP present\n");
+
+  update_num_workspaces (screen, timestamp);
+
+  set_workspace_names (screen);
+
+  /* Switch to the _NET_CURRENT_DESKTOP workspace */
+  current_workspace = meta_screen_get_workspace_by_index (screen,
+                                                          current_workspace_index);
+
+  if (current_workspace != NULL)
+    meta_workspace_activate (current_workspace, timestamp);
+  else
+    meta_workspace_activate (screen->workspaces->data, timestamp);
+}
+
 void
 meta_screen_free (MetaScreen *screen,
                  guint32     timestamp)
@@ -791,8 +816,6 @@ meta_screen_free (MetaScreen *screen,

  screen->closing += 1;

-  meta_display_grab (display);
-
  meta_compositor_unmanage (screen->display->compositor);

  meta_display_unmanage_windows_for_screen (display, screen, timestamp);
@@ -849,9 +872,6 @@ meta_screen_free (MetaScreen *screen,
  g_free (screen->screen_name);

  g_object_unref (screen);
-
-  XFlush (display->xdisplay);
-  meta_display_ungrab (display);
 }

 void
@@ -901,10 +921,6 @@ prefs_changed_callback (MetaPreference pref,
        meta_display_get_current_time_roundtrip (screen->display);
      update_num_workspaces (screen, timestamp);
    }
-  else if (pref == META_PREF_FOCUS_MODE)
-    {
-      update_focus_mode (screen);
-    }
  else if (pref == META_PREF_WORKSPACE_NAMES)
    {
      set_workspace_names (screen);
@@ -942,75 +958,23 @@ get_screen_name (MetaDisplay *display,
  return scr;
 }

-static gint
-ptrcmp (gconstpointer a, gconstpointer b)
-{
-  if (a < b)
-    return -1;
-  else if (a > b)
-    return 1;
-  else
-    return 0;
-}
-
-static void
-listify_func (gpointer key, gpointer value, gpointer data)
-{
-  GSList **listp;
-
-  listp = data;
-
-  *listp = g_slist_prepend (*listp, value);
-}
-
-/**
- * meta_screen_foreach_window:
- * @screen: a #MetaScreen
- * @func: function to call for each window
- * @data: user data to pass to @func
- *
- * Calls the specified function for each window on the screen,
- * ignoring override-redirect windows.
- */
 void
-meta_screen_foreach_window (MetaScreen *screen,
-                            MetaScreenWindowFunc func,
-                            gpointer data)
+meta_screen_foreach_window (MetaScreen           *screen,
+                            MetaListWindowsFlags  flags,
+                            MetaScreenWindowFunc  func,
+                            gpointer              data)
 {
-  GSList *winlist;
-  GSList *tmp;
+  GSList *windows;

  /* If we end up doing this often, just keeping a list
   * of windows might be sensible.
   */

-  winlist = NULL;
-  g_hash_table_foreach (screen->display->xids,
-                        listify_func,
-                        &winlist);
+  windows = meta_display_list_windows (screen->display, flags);

-  winlist = g_slist_sort (winlist, ptrcmp);
+  g_slist_foreach (windows, (GFunc) func, data);

-  tmp = winlist;
-  while (tmp != NULL)
-    {
-      /* If the next node doesn't contain this window
-       * a second time, delete the window.
-       */
-      if (tmp->next == NULL ||
-          (tmp->next && tmp->next->data != tmp->data))
-        {
-          MetaWindow *window = tmp->data;
-
-          if (META_IS_WINDOW (window) &&
-              window->screen == screen &&
-              !window->override_redirect)
-            (* func) (screen, window, data);
-        }
-
-      tmp = tmp->next;
-    }
-  g_slist_free (winlist);
+  g_slist_free (windows);
 }

 int
@@ -1035,27 +999,7 @@ MetaWorkspace*
 meta_screen_get_workspace_by_index (MetaScreen  *screen,
                                    int          idx)
 {
-  GList *tmp;
-  int i;
-
-  /* should be robust, idx is maybe from an app */
-  if (idx < 0)
-    return NULL;
-
-  i = 0;
-  tmp = screen->workspaces;
-  while (tmp != NULL)
-    {
-      MetaWorkspace *w = tmp->data;
-
-      if (i == idx)
-        return w;
-
-      ++i;
-      tmp = tmp->next;
-    }
-
-  return NULL;
+  return g_list_nth_data (screen->workspaces, idx);
 }

 static void
@@ -1129,41 +1073,28 @@ meta_screen_remove_workspace (MetaScreen *screen, MetaWorkspace *workspace,
                              guint32 timestamp)
 {
  GList         *l;
+  GList         *next;
  MetaWorkspace *neighbour = NULL;
-  GList         *next = NULL;
  int            index;
  gboolean       active_index_changed;
  int            new_num;

-  l = screen->workspaces;
-  while (l)
-    {
-      MetaWorkspace *w = l->data;
-
-      if (w == workspace)
-        {
-          if (l->next)
-            next = l->next;
-
-          if (l->prev)
-            neighbour = l->prev->data;
-          else if (l->next)
-            neighbour = l->next->data;
-          else
-            {
-              /* Cannot remove the only workspace! */
-              return;
-            }
-
-          break;
-        }
-
-      l = l->next;
-    }
-
-  if (!neighbour)
+  l = g_list_find (screen->workspaces, workspace);
+  if (!l)
    return;

+  next = l->next;
+
+  if (l->prev)
+    neighbour = l->prev->data;
+  else if (l->next)
+    neighbour = l->next->data;
+  else
+    {
+      /* Cannot remove the only workspace! */
+      return;
+    }
+
  meta_workspace_relocate_windows (workspace, neighbour);

  if (workspace == screen->active_workspace)
@@ -1188,14 +1119,10 @@ meta_screen_remove_workspace (MetaScreen *screen, MetaWorkspace *workspace,
  if (active_index_changed)
      meta_screen_set_active_workspace_hint (screen);

-  l = next;
-  while (l)
+  for (l = next; l != NULL; l = l->next)
    {
      MetaWorkspace *w = l->data;
-
-      meta_workspace_update_window_hints (w);
-
-      l = l->next;
+      meta_workspace_index_changed (w);
    }

  meta_screen_queue_workarea_recalc (screen);
@@ -1255,7 +1182,7 @@ update_num_workspaces (MetaScreen *screen,
                       guint32     timestamp)
 {
  int new_num, old_num;
-  GList *tmp;
+  GList *l;
  int i;
  GList *extras;
  MetaWorkspace *last_remaining;
@@ -1294,10 +1221,9 @@ update_num_workspaces (MetaScreen *screen,
  last_remaining = NULL;
  extras = NULL;
  i = 0;
-  tmp = screen->workspaces;
-  while (tmp != NULL)
+  for (l = screen->workspaces; l != NULL; l = l->next)
    {
-      MetaWorkspace *w = tmp->data;
+      MetaWorkspace *w = l->data;

      if (i >= new_num)
        extras = g_list_prepend (extras, w);
@@ -1305,7 +1231,6 @@ update_num_workspaces (MetaScreen *screen,
        last_remaining = w;

      ++i;
-      tmp = tmp->next;
    }
  old_num = i;

@@ -1318,32 +1243,26 @@ update_num_workspaces (MetaScreen *screen,
   * is on a removed workspace ;-)
   */
  need_change_space = FALSE;
-  tmp = extras;
-  while (tmp != NULL)
+  for (l = extras; l != NULL; l = l->next)
    {
-      MetaWorkspace *w = tmp->data;
+      MetaWorkspace *w = l->data;

      meta_workspace_relocate_windows (w, last_remaining);

      if (w == screen->active_workspace)
        need_change_space = TRUE;
-
-      tmp = tmp->next;
    }

  if (need_change_space)
    meta_workspace_activate (last_remaining, timestamp);

  /* Should now be safe to free the workspaces */
-  tmp = extras;
-  while (tmp != NULL)
+  for (l = extras; l != NULL; l = l->next)
    {
-      MetaWorkspace *w = tmp->data;
+      MetaWorkspace *w = l->data;

      g_assert (w->windows == NULL);
      meta_workspace_remove (w);
-
-      tmp = tmp->next;
    }

  g_list_free (extras);
@@ -1361,12 +1280,6 @@ update_num_workspaces (MetaScreen *screen,
  g_object_notify (G_OBJECT (screen), "n-workspaces");
 }

-static void
-update_focus_mode (MetaScreen *screen)
-{
-  /* nothing to do anymore */ ;
-}
-
 void
 meta_screen_update_cursor (MetaScreen *screen)
 {
@@ -2091,31 +2004,25 @@ static void
 set_work_area_hint (MetaScreen *screen)
 {
  int num_workspaces;
-  GList *tmp_list;
+  GList *l;
  unsigned long *data, *tmp;
  MetaRectangle area;

  num_workspaces = meta_screen_get_n_workspaces (screen);
  data = g_new (unsigned long, num_workspaces * 4);
-  tmp_list = screen->workspaces;
  tmp = data;

-  while (tmp_list != NULL)
+  for (l = screen->workspaces; l != NULL; l = l->next)
    {
-      MetaWorkspace *workspace = tmp_list->data;
+      MetaWorkspace *workspace = l->data;

-      if (workspace->screen == screen)
-        {
-          meta_workspace_get_work_area_all_monitors (workspace, &area);
-          tmp[0] = area.x;
-          tmp[1] = area.y;
-          tmp[2] = area.width;
-          tmp[3] = area.height;
+      meta_workspace_get_work_area_all_monitors (workspace, &area);
+      tmp[0] = area.x;
+      tmp[1] = area.y;
+      tmp[2] = area.width;
+      tmp[3] = area.height;

-	  tmp += 4;
-        }
-
-      tmp_list = tmp_list->next;
+      tmp += 4;
    }

  meta_error_trap_push (screen->display);
@@ -2455,9 +2362,8 @@ meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout)
 }

 static void
-meta_screen_resize_func (MetaScreen *screen,
-                         MetaWindow *window,
-                         void       *user_data)
+meta_screen_resize_func (MetaWindow *window,
+                         gpointer    user_data)
 {
  if (window->struts)
    {
@@ -2472,8 +2378,6 @@ static void
 on_monitors_changed (MetaMonitorManager *manager,
                     MetaScreen         *screen)
 {
-  GSList *tmp, *windows;
-
  meta_monitor_manager_get_screen_size (manager,
                                        &screen->rect.width,
                                        &screen->rect.height);
@@ -2497,24 +2401,11 @@ on_monitors_changed (MetaMonitorManager *manager,
                       &changes);
    }

-  meta_compositor_sync_screen_size (screen->display->compositor,
-                                    screen->rect.width, screen->rect.height);
-
  /* Queue a resize on all the windows */
-  meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
+  meta_screen_foreach_window (screen, META_LIST_DEFAULT, meta_screen_resize_func, 0);

  /* Fix up monitor for all windows on this screen */
-  windows = meta_display_list_windows (screen->display,
-                                       META_LIST_INCLUDE_OVERRIDE_REDIRECT);
-  for (tmp = windows; tmp != NULL; tmp = tmp->next)
-    {
-      MetaWindow *window = tmp->data;
-
-      if (window->screen == screen)
-        meta_window_update_for_monitors_changed (window);
-    }
-
-  g_slist_free (windows);
+  meta_screen_foreach_window (screen, META_LIST_INCLUDE_OVERRIDE_REDIRECT, (MetaScreenWindowFunc) meta_window_update_for_monitors_changed, 0);

  meta_screen_queue_check_fullscreen (screen);

@@ -2539,8 +2430,7 @@ meta_screen_update_showing_desktop_hint (MetaScreen *screen)
 static void
 queue_windows_showing (MetaScreen *screen)
 {
-  GSList *windows;
-  GSList *tmp;
+  GSList *windows, *l;

  /* Must operate on all windows on display instead of just on the
   * active_workspace's window list, because the active_workspace's
@@ -2548,15 +2438,10 @@ queue_windows_showing (MetaScreen *screen)
   */
  windows = meta_display_list_windows (screen->display, META_LIST_DEFAULT);

-  tmp = windows;
-  while (tmp != NULL)
+  for (l = windows; l != NULL; l = l->next)
    {
-      MetaWindow *w = tmp->data;
-
-      if (w->screen == screen)
-        meta_window_queue (w, META_QUEUE_CALC_SHOWING);
-
-      tmp = tmp->next;
+      MetaWindow *w = l->data;
+      meta_window_queue (w, META_QUEUE_CALC_SHOWING);
    }

  g_slist_free (windows);
@@ -2566,22 +2451,14 @@ void
 meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
                                                     MetaWindow *keep)
 {
-  GList *windows;
-  GList *tmp;
+  GList *l;

-  windows = screen->active_workspace->windows;
-
-  tmp = windows;
-  while (tmp != NULL)
+  for (l = screen->active_workspace->windows; l != NULL; l = l->next)
    {
-      MetaWindow *w = tmp->data;
+      MetaWindow *w = l->data;

-      if (w->screen == screen  &&
-          w->has_minimize_func &&
-	  w != keep)
+      if (w->has_minimize_func && w != keep)
 	meta_window_minimize (w);
-
-      tmp = tmp->next;
    }
 }

@@ -2589,7 +2466,7 @@ void
 meta_screen_show_desktop (MetaScreen *screen,
                          guint32     timestamp)
 {
-  GList *windows;
+  GList *l;

  if (screen->active_workspace->showing_desktop)
    return;
@@ -2601,22 +2478,17 @@ meta_screen_show_desktop (MetaScreen *screen,
  /* Focus the most recently used META_WINDOW_DESKTOP window, if there is one;
   * see bug 159257.
   */
-  windows = screen->active_workspace->mru_list;
-  while (windows != NULL)
+  for (l = screen->active_workspace->mru_list; l != NULL; l = l->next)
    {
-      MetaWindow *w = windows->data;
+      MetaWindow *w = l->data;

-      if (w->screen == screen  &&
-          w->type == META_WINDOW_DESKTOP)
+      if (w->type == META_WINDOW_DESKTOP)
        {
          meta_window_focus (w, timestamp);
          break;
        }
-
-      windows = windows->next;
    }

-
  meta_screen_update_showing_desktop_hint (screen);
 }

@@ -2745,7 +2617,7 @@ startup_sequence_timeout (void *data)
 {
  MetaScreen *screen = data;
  CollectTimedOutData ctod;
-  GSList *tmp;
+  GSList *l;

  ctod.list = NULL;
  g_get_current_time (&ctod.now);
@@ -2753,18 +2625,15 @@ startup_sequence_timeout (void *data)
                   collect_timed_out_foreach,
                   &ctod);

-  tmp = ctod.list;
-  while (tmp != NULL)
+  for (l = ctod.list; l != NULL; l = l->next)
    {
-      SnStartupSequence *sequence = tmp->data;
+      SnStartupSequence *sequence = l->data;

      meta_topic (META_DEBUG_STARTUP,
                  "Timed out sequence %s\n",
                  sn_startup_sequence_get_id (sequence));

      sn_startup_sequence_complete (sequence);
-
-      tmp = tmp->next;
    }

  g_slist_free (ctod.list);
@@ -2865,7 +2734,7 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
 {
 #ifdef HAVE_STARTUP_NOTIFICATION
  const char *startup_id;
-  GSList *tmp;
+  GSList *l;
  SnStartupSequence *sequence;

  /* Does the window have a startup ID stored? */
@@ -2883,12 +2752,12 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
       * startup-notification library whether there's anything
       * stored for the resource name or resource class hints.
       */
-      tmp = screen->startup_sequences;
-      while (tmp != NULL)
+      for (l = screen->startup_sequences; l != NULL; l = l->next)
        {
          const char *wmclass;
+          SnStartupSequence *seq = l->data;

-          wmclass = sn_startup_sequence_get_wmclass (tmp->data);
+          wmclass = sn_startup_sequence_get_wmclass (seq);

          if (wmclass != NULL &&
              ((window->res_class &&
@@ -2896,7 +2765,7 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
               (window->res_name &&
                strcmp (wmclass, window->res_name) == 0)))
            {
-              sequence = tmp->data;
+              sequence = seq;

              g_assert (window->startup_id == NULL);
              window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence));
@@ -2910,8 +2779,6 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
              sn_startup_sequence_complete (sequence);
              break;
            }
-
-          tmp = tmp->next;
        }
    }

@@ -2925,20 +2792,18 @@ meta_screen_apply_startup_properties (MetaScreen *screen,
   */
  if (sequence == NULL)
    {
-      tmp = screen->startup_sequences;
-      while (tmp != NULL)
+      for (l = screen->startup_sequences; l != NULL; l = l->next)
        {
+          SnStartupSequence *seq = l->data;
          const char *id;

-          id = sn_startup_sequence_get_id (tmp->data);
+          id = sn_startup_sequence_get_id (seq);

          if (strcmp (id, startup_id) == 0)
            {
-              sequence = tmp->data;
+              sequence = seq;
              break;
            }
-
-          tmp = tmp->next;
        }
    }

--- a/src/core/stack-tracker.c
+++ b/src/core/stack-tracker.c
@@ -235,31 +235,35 @@ meta_stack_op_dump (MetaStackOp *op,
 }

 static void
-meta_stack_tracker_dump (MetaStackTracker *tracker)
+stack_dump (GArray *stack)
 {
  guint i;
+
+  meta_push_no_msg_prefix ();
+  for (i = 0; i < stack->len; i++)
+    {
+      MetaStackWindow *window = &g_array_index (stack, MetaStackWindow, i);
+      char *window_id = get_window_id (window);
+      meta_topic (META_DEBUG_STACK, "  %s", window_id);
+      g_free (window_id);
+    }
+  meta_topic (META_DEBUG_STACK, "\n");
+  meta_pop_no_msg_prefix ();
+}
+
+static void
+meta_stack_tracker_dump (MetaStackTracker *tracker)
+{
  GList *l;

  meta_topic (META_DEBUG_STACK, "MetaStackTracker state (screen=%d)\n", tracker->screen->number);
  meta_push_no_msg_prefix ();
  meta_topic (META_DEBUG_STACK, "  xserver_serial: %ld\n", tracker->xserver_serial);
  meta_topic (META_DEBUG_STACK, "  xserver_stack: ");
-  for (i = 0; i < tracker->xserver_stack->len; i++)
-    {
-      MetaStackWindow *window = &g_array_index (tracker->xserver_stack, MetaStackWindow, i);
-      char *window_id = get_window_id (window);
-      meta_topic (META_DEBUG_STACK, "  %s", window_id);
-      g_free (window_id);
-    }
-  meta_topic (META_DEBUG_STACK, "\n  verfied_stack: ");
-  for (i = 0; i < tracker->verified_stack->len; i++)
-    {
-      MetaStackWindow *window = &g_array_index (tracker->verified_stack, MetaStackWindow, i);
-      char *window_id = get_window_id (window);
-      meta_topic (META_DEBUG_STACK, "  %s", window_id);
-      g_free (window_id);
-    }
-  meta_topic (META_DEBUG_STACK, "\n  unverified_predictions: [");
+  stack_dump (tracker->xserver_stack);
+  meta_topic (META_DEBUG_STACK, "  verfied_stack: ");
+  stack_dump (tracker->verified_stack);
+  meta_topic (META_DEBUG_STACK, "  unverified_predictions: [");
  for (l = tracker->unverified_predictions->head; l; l = l->next)
    {
      MetaStackOp *op = l->data;
@@ -269,15 +273,8 @@ meta_stack_tracker_dump (MetaStackTracker *tracker)
  if (tracker->predicted_stack)
    {
      meta_topic (META_DEBUG_STACK, "\n  predicted_stack: ");
-      for (i = 0; i < tracker->predicted_stack->len; i++)
-        {
-          MetaStackWindow *window = &g_array_index (tracker->predicted_stack, MetaStackWindow, i);
-          char *window_id = get_window_id (window);
-          meta_topic (META_DEBUG_STACK, "  %s", window_id);
-          g_free (window_id);
-        }
+      stack_dump (tracker->predicted_stack);
    }
-  meta_topic (META_DEBUG_STACK, "\n");
  meta_pop_no_msg_prefix ();
 }

@@ -485,14 +482,12 @@ requery_xserver_stack (MetaStackTracker *tracker)
              screen->xroot,
              &ignored1, &ignored2, &children, &n_children);

-  tracker->xserver_stack =
-    g_array_sized_new (FALSE, FALSE, sizeof (MetaStackWindow), n_children);
+  tracker->xserver_stack = g_array_sized_new (FALSE, FALSE, sizeof (MetaStackWindow), n_children);
  g_array_set_size (tracker->xserver_stack, n_children);

  for (i = 0; i < n_children; i++)
    {
-      MetaStackWindow *window =
-        &g_array_index (tracker->xserver_stack, MetaStackWindow, i);
+      MetaStackWindow *window = &g_array_index (tracker->xserver_stack, MetaStackWindow, i);
      window->any.type = META_WINDOW_CLIENT_TYPE_X11;
      window->x11.xwindow = children[i];
    }
@@ -714,14 +709,10 @@ meta_stack_tracker_record_lower (MetaStackTracker       *tracker,
 *
 * Return value: %TRUE if the predicted state is consistent with
 * receiving the given @op from X, else %FALSE.
- *
- * @modified will be set to %TRUE if tracker->verified_stack is
- * changed by applying any newly validated operations, else %FALSE.
 */
 static gboolean
 stack_tracker_verify_predictions (MetaStackTracker *tracker,
-                                  MetaStackOp      *op,
-                                  gboolean         *modified)
+                                  MetaStackOp      *op)
 {
  GArray *tmp_predicted_stack = NULL;
  GArray *predicted_stack;
@@ -731,6 +722,8 @@ stack_tracker_verify_predictions (MetaStackTracker *tracker,
   * passed to this api. */
  g_return_val_if_fail (op->any.window.any.type == META_WINDOW_CLIENT_TYPE_X11, FALSE);

+  meta_topic (META_DEBUG_STACK, "Verifying predictions:\n");
+
  if (tracker->unverified_predictions->length)
    {
      GList *l;
@@ -750,6 +743,9 @@ stack_tracker_verify_predictions (MetaStackTracker *tracker,
  else
    predicted_stack = tracker->verified_stack;

+  meta_topic (META_DEBUG_STACK, "  predicted_stack: ");
+  stack_dump (predicted_stack);
+
  switch (op->any.type)
    {
    case STACK_OP_ADD:
@@ -825,7 +821,6 @@ verified:
      meta_stack_op_free (queued_op);
    }

-  *modified = modified_stack;
  if (modified_stack)
    {
      g_array_free (tracker->verified_stack, TRUE);
@@ -847,8 +842,6 @@ not_verified:
      tracker->predicted_stack = NULL;
    }

-  *modified = FALSE;
-
  return FALSE;
 }

@@ -881,17 +874,17 @@ resync_verified_stack_with_xserver_stack (MetaStackTracker *tracker)
   *   windows and free the queue of unverified_predictions.
   *
   * - Iterate through the x windows listed in verified_stack at the
-   *   same time as iterating the windows in xserver_list. (Stop
-   *   when we reach the end of the xserver_list)
+   *   same time as iterating the windows in xserver_stack. (Stop
+   *   when we reach the end of the xserver_stack)
   *     - If the window found doesn't match the window expected
-   *     according to the order of xserver_list then:
+   *     according to the order of xserver_stack then:
   *       - Look ahead for the window we were expecting and restack
   *       that above the previous X window. If we fail to find the
   *       expected window then create a new entry for it and stack
   *       that.
   *
   * - Continue to iterate through verified_stack for any remaining
-   *   X windows that we now know aren't in the xserver_list and
+   *   X windows that we now know aren't in the xserver_stack and
   *   remove them.
   *
   * - Free ->predicted_stack if any.
@@ -909,15 +902,11 @@ resync_verified_stack_with_xserver_stack (MetaStackTracker *tracker)
  g_queue_clear (tracker->unverified_predictions);

  j = 0;
-  expected_xwindow =
-    &g_array_index (tracker->xserver_stack, MetaStackWindow, j);
+  expected_xwindow = &g_array_index (tracker->xserver_stack, MetaStackWindow, j);

-  for (i = 0;
-       i < tracker->verified_stack->len;
-       )
+  for (i = 0; i < tracker->verified_stack->len; )
    {
-      MetaStackWindow *current =
-        &g_array_index (tracker->verified_stack, MetaStackWindow, i);
+      MetaStackWindow *current = &g_array_index (tracker->verified_stack, MetaStackWindow, i);

      if (current->any.type != META_WINDOW_CLIENT_TYPE_X11)
        {
@@ -954,8 +943,7 @@ resync_verified_stack_with_xserver_stack (MetaStackTracker *tracker)

          /* Technically we only need to look forward from i if we
           * wanted to optimize this a bit... */
-          expected_index =
-            find_window (tracker->verified_stack, expected_xwindow);
+          expected_index = find_window (tracker->verified_stack, expected_xwindow);

          if (expected_index >= 0)
            {
@@ -993,8 +981,7 @@ resync_verified_stack_with_xserver_stack (MetaStackTracker *tracker)
      i++;

      j++;
-      expected_xwindow =
-        &g_array_index (tracker->xserver_stack, MetaStackWindow, j);
+      expected_xwindow = &g_array_index (tracker->xserver_stack, MetaStackWindow, j);

      if (j >= tracker->xserver_stack->len)
        break;
@@ -1004,8 +991,7 @@ resync_verified_stack_with_xserver_stack (MetaStackTracker *tracker)
   * xserver_stack and so we can remove them. */
  while (i < tracker->verified_stack->len)
    {
-      MetaStackWindow *current =
-        &g_array_index (tracker->verified_stack, MetaStackWindow, i);
+      MetaStackWindow *current = &g_array_index (tracker->verified_stack, MetaStackWindow, i);

      if (current->any.type == META_WINDOW_CLIENT_TYPE_X11)
        g_array_remove_index (tracker->verified_stack, i);
@@ -1016,11 +1002,10 @@ resync_verified_stack_with_xserver_stack (MetaStackTracker *tracker)
    }

  /* If we get to the end of verified_list and there are any remaining
-   * entries in xserver_list then append them all to the end */
+   * entries in xserver_stack then append them all to the end */
  for (; j < tracker->xserver_stack->len; j++)
    {
-      MetaStackWindow *current =
-        &g_array_index (tracker->xserver_stack, MetaStackWindow, j);
+      MetaStackWindow *current = &g_array_index (tracker->xserver_stack, MetaStackWindow, j);
      g_array_append_val (tracker->verified_stack, *current);

      modified_stack = TRUE;
@@ -1044,19 +1029,13 @@ static void
 stack_tracker_event_received (MetaStackTracker *tracker,
 			      MetaStackOp      *op)
 {
-  gboolean need_sync = FALSE;
-  gboolean verified;
+  /* If the event is older than our latest requery, then it's
+   * already included in our tree. Just ignore it. */
+  if (op->any.serial < tracker->xserver_serial)
+    return;

  meta_stack_op_dump (op, "Stack op event received: ", "\n");

-  if (op->any.serial < tracker->xserver_serial)
-    {
-      /* g_warning ("Spurious X event received affecting stack; doing full re-query"); */
-      resync_verified_stack_with_xserver_stack (tracker);
-      meta_stack_tracker_dump (tracker);
-      return;
-    }
-
  tracker->xserver_serial = op->any.serial;

  /* XXX: With the design we have ended up with it looks like we've
@@ -1070,13 +1049,8 @@ stack_tracker_event_received (MetaStackTracker *tracker,
   */
  meta_stack_op_apply (op, tracker->xserver_stack);

-  verified = stack_tracker_verify_predictions (tracker, op, &need_sync);
-  if (!verified)
-    {
-      resync_verified_stack_with_xserver_stack (tracker);
-      meta_stack_tracker_dump (tracker);
-      return;
-    }
+  if (!stack_tracker_verify_predictions (tracker, op))
+    resync_verified_stack_with_xserver_stack (tracker);

  meta_stack_tracker_dump (tracker);
 }
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -45,10 +45,8 @@
           w->type == META_WINDOW_MENU ||               \
           w->type == META_WINDOW_UTILITY)

-#define WINDOW_TRANSIENT_FOR_WHOLE_GROUP(w)             \
-         ((w->xtransient_for == None ||                 \
-           w->transient_parent_is_root_window) &&       \
-          WINDOW_HAS_TRANSIENT_TYPE (w))
+#define WINDOW_TRANSIENT_FOR_WHOLE_GROUP(w)                     \
+  (WINDOW_HAS_TRANSIENT_TYPE (w) && w->transient_for == NULL)

 #define WINDOW_IN_STACK(w) (w->stack_position >= 0)

@@ -414,8 +412,7 @@ compute_layer (MetaWindow *window)
   */
  if (window->layer != META_LAYER_DESKTOP &&
      WINDOW_HAS_TRANSIENT_TYPE(window) &&
-      (window->xtransient_for == None ||
-       window->transient_parent_is_root_window))
+      window->transient_for == NULL)
    {
      /* We only do the group thing if the dialog is NOT transient for
       * a particular window. Imagine a group with a normal window, a dock,
@@ -636,16 +633,13 @@ create_constraints (Constraint **constraints,

          g_slist_free (group_windows);
        }
-      else if (w->xtransient_for != None &&
-               !w->transient_parent_is_root_window)
+      else if (w->transient_for != NULL)
        {
          MetaWindow *parent;

-          parent =
-            meta_display_lookup_x_window (w->display, w->xtransient_for);
+          parent = w->transient_for;

-          if (parent && WINDOW_IN_STACK (parent) &&
-              parent->screen == w->screen)
+          if (parent && WINDOW_IN_STACK (parent))
            {
              meta_topic (META_DEBUG_STACK, "Constraining %s above %s due to transiency\n",
                          w->desc, parent->desc);
@@ -925,7 +919,7 @@ stack_do_relayer (MetaStack *stack)
  GList *tmp;

  if (!stack->need_relayer)
-      return;
+    return;

  meta_topic (META_DEBUG_STACK,
              "Recomputing layers\n");
@@ -1175,16 +1169,16 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,

      /* No sibling to use, just lower ourselves to the bottom
       * to be sure we're below any override redirect windows.
-           */
+       */
      meta_stack_tracker_record_lower (screen->stack_tracker,
                                       window,
                                       serial);
      return;
-        }
+    }

  /* window is the topmost managed child */
-              meta_topic (META_DEBUG_STACK,
-                          "Moving 0x%lx above topmost managed child window 0x%lx\n",
+  meta_topic (META_DEBUG_STACK,
+              "Moving 0x%lx above topmost managed child window 0x%lx\n",
              window->any.type == META_WINDOW_CLIENT_TYPE_X11 ? window->x11.xwindow: 0,
              sibling->any.type == META_WINDOW_CLIENT_TYPE_X11 ? sibling->x11.xwindow: 0);

@@ -1197,26 +1191,26 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
      if (x11_sibling)
        {
          changes.sibling = x11_sibling->x11.xwindow;
-              changes.stack_mode = Above;
+          changes.stack_mode = Above;

-              meta_error_trap_push (screen->display);
-              XConfigureWindow (screen->display->xdisplay,
+          meta_error_trap_push (screen->display);
+          XConfigureWindow (screen->display->xdisplay,
                            window->x11.xwindow,
-                                CWSibling | CWStackMode,
-                                &changes);
-              meta_error_trap_pop (screen->display);
+                            CWSibling | CWStackMode,
+                            &changes);
+          meta_error_trap_pop (screen->display);
        }
      else
-    {
-      /* No sibling to use, just lower ourselves to the bottom
-       * to be sure we're below any override redirect windows.
-       */
-      meta_error_trap_push (screen->display);
-      XLowerWindow (screen->display->xdisplay,
+        {
+          /* No sibling to use, just lower ourselves to the bottom
+           * to be sure we're below any override redirect windows.
+           */
+          meta_error_trap_push (screen->display);
+          XLowerWindow (screen->display->xdisplay,
                        window->x11.xwindow);
-      meta_error_trap_pop (screen->display);
+          meta_error_trap_pop (screen->display);
+        }
    }
-}

  meta_stack_tracker_record_raise_above (screen->stack_tracker,
                                         window,
@@ -1357,7 +1351,7 @@ stack_sync_to_xserver (MetaStack *stack)
          if (x11_root_children_stacked->len > 1)
            {
              serial = XNextRequest (stack->screen->display->xdisplay);
-          XRestackWindows (stack->screen->display->xdisplay,
+              XRestackWindows (stack->screen->display->xdisplay,
                               (Window *) x11_root_children_stacked->data,
                               x11_root_children_stacked->len);
            }
@@ -1490,7 +1484,7 @@ stack_sync_to_xserver (MetaStack *stack)

          /* Restack remaining windows */
          meta_topic (META_DEBUG_STACK, "Restacking remaining %d windows\n",
-                        (int) (new_end - newp));
+                      (int) (new_end - newp));

          /* rewind until we find the last stacked X window that we can use
           * as a reference point for re-stacking remaining X windows */
--- a/src/core/testboxes.c
+++ b/src/core/testboxes.c
@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <X11/Xutil.h> /* Just for the definition of the various gravities */
 #include <time.h>      /* To initialize random seed */
+#include <math.h>

 #define NUM_RANDOM_RUNS 10000

@@ -238,7 +239,7 @@ static GSList*
 get_strut_list (int which)
 {
  GSList *ans;
-  MetaDirection wc = 0; /* wc == who cares? ;-) */
+  MetaSide wc = 0; /* wc == who cares? ;-) */

  ans = NULL;

@@ -248,32 +249,32 @@ get_strut_list (int which)
    case 0:
      break;
    case 1:
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 400, 1160, 1600,   40, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, META_SIDE_TOP));
+      ans = g_slist_prepend (ans, new_meta_strut ( 400, 1160, 1600,   40, META_SIDE_BOTTOM));
      break;
    case 2:
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,  150,   50, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, META_SIDE_TOP));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, META_SIDE_BOTTOM));
+      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,  150,   50, META_SIDE_BOTTOM));
      break;
    case 3:
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,   80,   50, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, META_SIDE_TOP));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, META_SIDE_LEFT));
+      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,   80,   50, META_SIDE_BOTTOM));
      ans = g_slist_prepend (ans, new_meta_strut ( 700,  525,  200,  150, wc));
      break;
    case 4:
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, META_SIDE_LEFT));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, META_SIDE_TOP));
      break;
    case 5:
-      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, wc));
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, wc));
-      ans = g_slist_prepend (ans, new_meta_strut ( 800,   10,  800, 1200, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, META_SIDE_TOP));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, META_SIDE_LEFT));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,   10,  800, 1200, META_SIDE_RIGHT));
      break;
    case 6:
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   40, wc));
-      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   40, META_SIDE_TOP));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, META_SIDE_TOP));
      break;
    }

@@ -623,15 +624,9 @@ test_regions_okay ()
  /*************************************************************/
  region = get_screen_region (3);
  tmp = NULL;
-  tmp = g_list_prepend (tmp, new_meta_rect ( 380,  675,  420,  525)); /* 220500 */
  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  300, 1180)); /* 354000 */
-  tmp = g_list_prepend (tmp, new_meta_rect ( 380,   20,  320, 1180)); /* 377600 */
-  tmp = g_list_prepend (tmp, new_meta_rect (   0,  675,  800,  475)); /* 380000 */
-  tmp = g_list_prepend (tmp, new_meta_rect (1200,   20,  400, 1180)); /* 472000 */
-  tmp = g_list_prepend (tmp, new_meta_rect (   0,  675, 1600,  425)); /* 680000 */
-  tmp = g_list_prepend (tmp, new_meta_rect ( 900,   20,  700, 1080)); /* 756000 */
-  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  700, 1130)); /* 791000 */
-  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20, 1600,  505)); /* 808000 */
+  tmp = g_list_prepend (tmp, new_meta_rect ( 380,   20,  1220, 1180)); /* 377600 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  1600, 1130)); /* 791000 */
 #if 0
  printf ("Got to here...\n");
  char region_list[(RECT_LENGTH+2) * g_list_length (region)];
@@ -1332,6 +1327,7 @@ test_gravity_resize ()
  printf ("%s passed.\n", G_STRFUNC);
 }

+#define EPSILON 0.000000001
 static void
 test_find_closest_point_to_line ()
 {
@@ -1346,7 +1342,7 @@ test_find_closest_point_to_line ()
                                                  x2,  y2,
                                                  px,  py,
                                                  &rx, &ry);
-  g_assert (rx == answer_x && ry == answer_y);
+  g_assert (fabs (rx - answer_x) < EPSILON && fabs (ry - answer_y) < EPSILON);

  /* Special test for x1 == x2, so that slop of line is infinite */
  x1 =  3.0;  y1 =  49.0;
@@ -1357,7 +1353,7 @@ test_find_closest_point_to_line ()
                                                  x2,  y2,
                                                  px,  py,
                                                  &rx, &ry);
-  g_assert (rx == answer_x && ry == answer_y);
+  g_assert (fabs (rx - answer_x) < EPSILON && fabs (ry - answer_y) < EPSILON);

  /* Special test for y1 == y2, so perp line has slope of infinity */
  x1 =  3.14;  y1 =   7.0;
@@ -1368,7 +1364,7 @@ test_find_closest_point_to_line ()
                                                  x2,  y2,
                                                  px,  py,
                                                  &rx, &ry);
-  g_assert (rx == answer_x && ry == answer_y);
+  g_assert (fabs (rx - answer_x) < EPSILON && fabs (ry - answer_y) < EPSILON);

  /* Test when we the point we want to be closest to is actually on the line */
  x1 =  3.0;  y1 =  49.0;
@@ -1379,7 +1375,7 @@ test_find_closest_point_to_line ()
                                                  x2,  y2,
                                                  px,  py,
                                                  &rx, &ry);
-  g_assert (rx == answer_x && ry == answer_y);
+  g_assert (fabs (rx - answer_x) < EPSILON && fabs (ry - answer_y) < EPSILON);

  printf ("%s passed.\n", G_STRFUNC);
 }
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -946,5 +946,19 @@ meta_later_remove (guint later_id)
    }
 }

+MetaLocaleDirection
+meta_get_locale_direction (void)
+{
+  switch (gtk_get_locale_direction ())
+    {
+    case GTK_TEXT_DIR_LTR:
+      return META_LOCALE_DIRECTION_LTR;
+    case GTK_TEXT_DIR_RTL:
+      return META_LOCALE_DIRECTION_RTL;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
 /* eof util.c */

--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -43,7 +43,6 @@
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <clutter/clutter.h>

-#include "x11/iconcache.h"
 #include "x11/group-private.h"

 #include "wayland/meta-wayland-types.h"
@@ -107,9 +106,6 @@ struct _MetaWindow

  GdkPixbuf *icon;
  GdkPixbuf *mini_icon;
-  MetaIconCache icon_cache;
-  Pixmap wm_hints_pixmap;
-  Pixmap wm_hints_mask;

  MetaWindowType type;

@@ -166,6 +162,7 @@ struct _MetaWindow
   * that to toggle between normal/tiled or maximized/tiled states. */
  guint saved_maximize : 1;
  int tile_monitor_number;
+  int preferred_output_winsys_id;

  /* Whether we're shaded */
  guint shaded : 1;
@@ -332,9 +329,6 @@ struct _MetaWindow
   */
  guint calc_placement : 1;

-  /* Transient parent is a root window */
-  guint transient_parent_is_root_window : 1;
-
  /* if TRUE, window was maximized at start of current grab op */
  guint shaken_loose : 1;

@@ -350,10 +344,6 @@ struct _MetaWindow
  /* whether or not the window is from a program running on another machine */
  guint is_remote : 1;

-  /* Used for Wayland -- surfaces can behave as if they were unmapped if
-   * they have a NULL buffer attached... */
-  guint surface_mapped;
-
  /* if non-NULL, the bounds of the window frame */
  cairo_region_t *frame_bounds;

@@ -421,6 +411,15 @@ struct _MetaWindow
   */
  MetaRectangle unconstrained_rect;

+  /* The rectangle of the "server-side" geometry of the buffer,
+   * in root coordinates.
+   *
+   * For X11 windows, this matches XGetGeometry of the toplevel.
+   *
+   * For Wayland windows, this matches the buffer size and where
+   * the surface actor is positioned. */
+  MetaRectangle buffer_rect;
+
  /* Cached net_wm_icon_geometry */
  MetaRectangle icon_geometry;

@@ -478,6 +477,9 @@ struct _MetaWindowClass
  void (*get_default_skip_hints) (MetaWindow *window,
                                  gboolean   *skip_taskbar_out,
                                  gboolean   *skip_pager_out);
+  gboolean (*update_icon)        (MetaWindow  *window,
+                                  GdkPixbuf  **icon,
+                                  GdkPixbuf  **mini_icon);
 };

 /* These differ from window->has_foo_func in that they consider
@@ -575,6 +577,10 @@ void meta_window_show_menu (MetaWindow         *window,
                            int                 x,
                            int                 y);

+void meta_window_show_menu_for_rect (MetaWindow         *window,
+                                     MetaWindowMenuType  menu,
+                                     MetaRectangle      *rect);
+
 gboolean meta_window_handle_mouse_grab_op_event  (MetaWindow         *window,
                                                  const ClutterEvent *event);

@@ -618,10 +624,8 @@ void meta_window_stack_just_below (MetaWindow *window,
 void meta_window_set_user_time (MetaWindow *window,
                                guint32     timestamp);

-void meta_window_update_icon_now (MetaWindow *window);
-
 void meta_window_update_for_monitors_changed (MetaWindow *window);
-void meta_window_update_on_all_workspaces (MetaWindow *window);
+void meta_window_on_all_workspaces_changed (MetaWindow *window);

 gboolean meta_window_should_attach_to_parent (MetaWindow *window);
 gboolean meta_window_can_tile_side_by_side   (MetaWindow *window);
@@ -658,13 +662,8 @@ void meta_window_handle_enter (MetaWindow  *window,
                               guint        root_y);
 void meta_window_handle_leave (MetaWindow  *window);

-gboolean meta_window_handle_ungrabbed_event (MetaWindow         *window,
-                                             const ClutterEvent *event);
-
-void meta_window_set_surface_mapped (MetaWindow *window,
-                                     gboolean    surface_mapped);
-
-Window meta_window_get_toplevel_xwindow (MetaWindow *window);
+void meta_window_handle_ungrabbed_event (MetaWindow         *window,
+                                         const ClutterEvent *event);

 void meta_window_get_client_area_rect (const MetaWindow      *window,
                                       cairo_rectangle_int_t *rect);
@@ -676,9 +675,8 @@ void meta_window_activate_full (MetaWindow     *window,
                                MetaClientType  source_indication,
                                MetaWorkspace  *workspace);

-gboolean meta_window_is_client_decorated (MetaWindow *window);
-
-void meta_window_update_monitor (MetaWindow *window);
+void meta_window_update_monitor (MetaWindow *window,
+                                 gboolean    user_op);

 void meta_window_set_urgent (MetaWindow *window,
                             gboolean    urgent);
@@ -698,4 +696,6 @@ void meta_window_grab_op_ended (MetaWindow *window, MetaGrabOp op);

 void meta_window_set_alive (MetaWindow *window, gboolean is_alive);

+gboolean meta_window_has_pointer (MetaWindow *window);
+
 #endif
--- a/src/core/window.c
+++ b/src/core/window.c
--- a/Show More
+++ b/Show More