Bump version to 3.11.4

Update NEWS.
cursor-tracker: Rely on gbm_bo_imports()'s buffer validation
2014-01-16 10:42:11 -05:00 · 2014-01-16 10:18:32 -05:00 · 2014-01-13 13:55:58 -05:00 · 2014-01-13 13:28:38 -05:00 · 2014-01-13 13:08:17 -05:00 · 2014-01-13 11:35:48 -05:00
168 changed files with 2672 additions and 2538 deletions
--- a/41
+++ b/41
@@ -1,12 +1,12 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991

- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

-			    Preamble
+                            Preamble

  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -15,7 +15,7 @@ software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
+the GNU Lesser General Public License instead.)  You can apply it to
 your programs, too.

  When we speak of free software, we are referring to freedom, not
@@ -55,8 +55,8 @@ patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
 modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
+
+                    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
@@ -110,7 +110,7 @@ above, provided that you also meet all of these conditions:
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
-
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -168,7 +168,7 @@ access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
+
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -225,7 +225,7 @@ impose that choice.

 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
+
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -255,7 +255,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.

-			    NO WARRANTY
+                            NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.

-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
@@ -303,17 +303,16 @@ the "copyright" line and a pointer to where the full notice is found.
    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
-
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 Also add information on how to contact you by electronic and paper mail.

 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:

-    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
@@ -336,5 +335,5 @@ necessary.  Here is a sample; alter the names:
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
+library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.
--- a/29
+++ b/29
@@ -1,3 +1,32 @@
+3.11.4
+======
+* Don't leave focus on windows that are being unmanaged [Owen; #711618]
+* Reduce server grabs [Daniel Drake; #721345, #721709]
+* Improve heuristic to determine display output name [Cosimo Cecchi; #721674]
+* Atomically unmaximize both directions [Jasper; #722108]
+* Misc bug fixes [Debarshi, Andika, Florian; #721517, #721674, #722347]
+
+Contributors:
+  Cosimo Cecchi, Daniel Drake, Florian Müllner, Debarshi Ray, Jasper St. Pierre,
+  Andika Triwidada, Owen W. Taylor
+
+3.11.3
+======
+* Fix focus issues with external OSKs[Jasper; #715030]
+* Add a MetaCullable interface [Jasper; #714706]
+* Fix window keybindings [Rui; #719724]
+* Fix settings keyboard/pointer focus for new clients [Rui; #719725]
+* Fix window group paint volume [Owen; #719669]
+* Fix frame extents problems [Owen; #714707]
+* Add shortcut to move windows between monitors [Florian; #671054]
+* Fix problems with focus tracking [Owen; #720558]
+* Misc. bug fixes and cleanups: [Rui, Colin, Lionel, Jasper, Owen; #712833,
+  #719557, #719695, #719833, #678989, #720417, #720630]
+
+Contributors:
+  Lionel Landwerlin, Rui Matos, Alberto Milone, Florian Müllner,
+  Jasper St. Pierre, Rico Tzschichholz, Owen W. Taylor, Colin Walters
+
 3.11.2
 ======
 * Support setting a NULL opaque region [Andreas; #711518]
--- a/configure.ac
+++ b/configure.ac
@@ -3,7 +3,7 @@ AC_CONFIG_MACRO_DIR([m4])

 m4_define([mutter_major_version], [3])
 m4_define([mutter_minor_version], [11])
-m4_define([mutter_micro_version], [2])
+m4_define([mutter_micro_version], [4])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -79,7 +79,7 @@ MUTTER_PC_MODULES="
   gsettings-desktop-schemas >= 3.7.3
   xcomposite >= 0.2 xfixes xrender xdamage xi >= 1.6.0
   $CLUTTER_PACKAGE >= 1.17.1
-   cogl-1.0 >= 1.13.3
+   cogl-1.0 >= 1.17.1
   upower-glib >= 0.99.0
   gnome-desktop-3.0
 "
--- a/doc/reference/meta-sections.txt
+++ b/doc/reference/meta-sections.txt
@@ -388,6 +388,23 @@ MetaWindowActorPrivate
 meta_window_actor_get_type
 </SECTION>

+<SECTION>
+<FILE>meta-cullable</FILE>
+<TITLE>MetaCullable</TITLE>
+MetaCullable
+MetaCullableInterface
+meta_cullable_cull_out
+meta_cullable_reset_culling
+meta_cullable_cull_out_children
+meta_cullable_reset_culling_children
+<SUBSECTION Standard>
+META_TYPE_CULLABLE
+META_CULLABLE
+META_IS_CULLABLE
+META_CULLABLE_GET_IFACE
+meta_cullable_get_type
+</SECTION>
+
 <SECTION>
 <FILE>prefs</FILE>
 MetaPreference
--- a/protocol/xdg-shell.xml
+++ b/protocol/xdg-shell.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<protocol name="xdg_surface">
+<protocol name="xdg_shell">

  <copyright>
    Copyright © 2008-2013 Kristian Høgsberg
@@ -121,7 +121,7 @@
 	unmapped if the parent is unmapped too. They should not appear
 	on task bars and alt+tab.
      </description>
-      <arg name="parent" type="object" interface="wl_surface"/>
+      <arg name="parent" type="object" interface="wl_surface" allow-null="true"/>
    </request>

    <request name="set_title">
@@ -223,9 +223,6 @@
 	area might adjust its content position to leave the viewable
 	content unmoved). Valid edge values are from resize_edge enum.

-	The maximized parameter informs if the surface is in a maximized
-	state. Same for the fullscreen parameter.
-
 	The client is free to dismiss all but the last configure
 	event it received.

@@ -236,8 +233,6 @@
      <arg name="edges" type="uint"/>
      <arg name="width" type="int"/>
      <arg name="height" type="int"/>
-      <arg name="maximized" type="uint"/>
-      <arg name="fullscreen" type="uint"/>
    </event>

    <request name="set_output">
@@ -255,16 +250,43 @@
      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
    </request>

+    <event name="request_set_fullscreen">
+      <description summary="server requests that the client set fullscreen">
+	Event sent from the compositor to the client requesting that the client
+	goes to a fullscreen state. It's the client job to call set_fullscreen
+	and really trigger the fullscreen state.
+      </description>
+    </event>
+
+    <event name="request_unset_fullscreen">
+      <description summary="server requests that the client unset fullscreen">
+	Event sent from the compositor to the client requesting that the client
+	leaves the fullscreen state. It's the client job to call
+	unset_fullscreen and really leave the fullscreen state.
+      </description>
+    </event>
+
    <request name="set_fullscreen">
      <description summary="set the surface state as fullscreen">
 	Set the surface as fullscreen.

-	The compositor must reply to this request with a configure event
-	with the dimensions for the output on which the surface will be
-	made fullscreen.
+	After this request, the compositor should send a configure event
+	informing the output size.

-	Once the fullscreen state is set, a "fullscreen_set" event will
-	be sent to the client.
+	This request informs the compositor that the next attached buffer
+	committed will be in a fullscreen state. The buffer size should be the
+	same size as the size informed in the configure event, if the client
+	doesn't want to leave any empty area.
+
+	In other words: the next attached buffer after set_maximized is the new
+	maximized buffer. And the surface will be positioned at the maximized
+	position on commit.
+
+	A simple way to synchronize and wait for the correct configure event is
+	to use a wl_display.sync request right after the set_fullscreen
+	request. When the sync callback returns, the last configure event
+	received just before it will be the correct one, and should contain the
+	right size for the surface to maximize.

 	Setting one state won't unset another state. Use
 	xdg_surface.unset_fullscreen for unsetting it.
@@ -274,19 +296,48 @@
    <request name="unset_fullscreen">
      <description summary="unset the surface state as fullscreen">
 	Unset the surface fullscreen state.
+
+	Same negotiation as set_fullscreen must be used.
      </description>
    </request>

+    <event name="request_set_maximized">
+      <description summary="server requests that the client set maximized">
+	Event sent from the compositor to the client requesting that the client
+	goes to a maximized state. It's the client job to call set_maximized
+	and really trigger the maximized state.
+      </description>
+    </event>
+
+    <event name="request_unset_maximized">
+      <description summary="server requests that the client unset maximized">
+	Event sent from the compositor to the client requesting that the client
+	leaves the maximized state. It's the client job to call unset_maximized
+	and really leave the maximized state.
+      </description>
+    </event>
+
    <request name="set_maximized">
      <description summary="set the surface state as maximized">
 	Set the surface as maximized.

-	The compositor must reply to this request with a configure event
-	with the dimensions for the output on which the surface will be
-	made maximized.
+	After this request, the compositor will send a configure event
+	informing the output size minus panel and other MW decorations.

-	Once the maximized state is set, a "maximized_set" event will be
-	sent to the client.
+	This request informs the compositor that the next attached buffer
+	committed will be in a maximized state. The buffer size should be the
+	same size as the size informed in the configure event, if the client
+	doesn't want to leave any empty area.
+
+	In other words: the next attached buffer after set_maximized is the new
+	maximized buffer. And the surface will be positioned at the maximized
+	position on commit.
+
+	A simple way to synchronize and wait for the correct configure event is
+	to use a wl_display.sync request right after the set_maximized request.
+	When the sync callback returns, the last configure event received just
+	before it will be the correct one, and should contain the right size
+	for the surface to maximize.

 	Setting one state won't unset another state. Use
 	xdg_surface.unset_maximized for unsetting it.
@@ -296,6 +347,8 @@
    <request name="unset_maximized">
      <description summary="unset the surface state as maximized">
 	Unset the surface maximized state.
+
+	Same negotiation as set_maximized must be used.
      </description>
    </request>

--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -70,7 +70,8 @@ libmutter_wayland_la_SOURCES =			\
 	compositor/meta-background-actor.c	\
 	compositor/meta-background-actor-private.h	\
 	compositor/meta-background-group.c	\
-	compositor/meta-background-group-private.h	\
+	compositor/meta-cullable.c		\
+	compositor/meta-cullable.h		\
 	compositor/meta-module.c		\
 	compositor/meta-module.h		\
 	compositor/meta-plugin.c		\
--- a/src/compositor/clutter-utils.c
+++ b/src/compositor/clutter-utils.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "clutter-utils.h"
@@ -95,8 +93,10 @@ meta_actor_vertices_are_untransformed (ClutterVertex *verts,
      v3x != v1x || v3y != v2y)
    return FALSE;

-  *x_origin = x;
-  *y_origin = y;
+  if (x_origin)
+    *x_origin = x;
+  if (y_origin)
+    *y_origin = y;

  return TRUE;
 }
--- a/src/compositor/clutter-utils.h
+++ b/src/compositor/clutter-utils.h
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_CLUTTER_UTILS_H__
--- a/src/compositor/cogl-utils.c
+++ b/src/compositor/cogl-utils.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <clutter/clutter.h>
--- a/src/compositor/cogl-utils.h
+++ b/src/compositor/cogl-utils.h
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_COGL_UTILS_H__
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -17,8 +17,6 @@ struct _MetaCompositor
 {
  MetaDisplay    *display;

-  Atom            atom_x_root_pixmap;
-  Atom            atom_net_wm_window_opacity;
  guint           repaint_func_id;

  ClutterActor   *shadow_src;
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -179,31 +179,6 @@ process_damage (MetaCompositor     *compositor,
  meta_window_actor_process_x11_damage (window_actor, event);
 }

-static void
-process_property_notify (MetaCompositor	*compositor,
-                         XPropertyEvent *event,
-                         MetaWindow     *window)
-{
-  MetaWindowActor *window_actor;
-
-  if (window == NULL)
-    return;
-
-  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  if (window_actor == NULL)
-    return;
-
-  /* Check for the opacity changing */
-  if (event->atom == compositor->atom_net_wm_window_opacity)
-    {
-      meta_window_actor_update_opacity (window_actor);
-      DEBUG_TRACE ("process_property_notify: net_wm_window_opacity\n");
-      return;
-    }
-
-  DEBUG_TRACE ("process_property_notify: unknown\n");
-}
-
 static Window
 get_output_window (MetaScreen *screen)
 {
@@ -637,6 +612,9 @@ after_stage_paint (ClutterStage *stage,

  for (l = info->windows; l; l = l->next)
    meta_window_actor_post_paint (l->data);
+
+  if (meta_is_wayland_compositor ())
+    meta_wayland_compositor_paint_finished (meta_wayland_compositor_get_default ());
 }

 static void
@@ -816,15 +794,15 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
          info->pending_input_region = None;
        }

-      info->plugin_mgr = meta_plugin_manager_new (screen);
-
      /* Map overlay window before redirecting windows offscreen so we catch their
       * contents until we show the stage.
       */
      XMapWindow (xdisplay, info->output);
-
-      redirect_windows (compositor, screen);
    }
+
+  redirect_windows (compositor, screen);
+
+  info->plugin_mgr = meta_plugin_manager_new (screen);
 }

 void
@@ -995,23 +973,30 @@ meta_compositor_window_shape_changed (MetaCompositor *compositor,
  meta_window_actor_update_shape (window_actor);
 }

+void
+meta_compositor_window_opacity_changed (MetaCompositor *compositor,
+                                        MetaWindow     *window)
+{
+  MetaWindowActor *window_actor;
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (!window_actor)
+    return;
+
+  meta_window_actor_update_opacity (window_actor);
+}
+
 /* Clutter makes the assumption that there is only one X window
 * per stage, which is a valid assumption to make for a generic
 * application toolkit. As such, it will ignore any events sent
 * to the a stage that isn't its X window.
 *
- * When a user clicks on what she thinks is the wallpaper, she
- * is actually clicking on the guard window, which is an entirely
- * separate top-level override-redirect window in the hierarchy.
- * We want to recieve events on this guard window so that users
- * can right-click on the background actor. We do this by telling
- * Clutter a little white lie, by transforming clicks on the guard
- * window to become clicks on the stage window, allowing Clutter
- * to process the event normally.
+ * When running as an X window manager, we need to respond to
+ * events from lots of windows. Trick Clutter into translating
+ * these events by pretending we got an event on the stage window.
 */
 static void
-maybe_spoof_guard_window_event_as_stage_event (MetaCompScreen *info,
-                                               XEvent         *event)
+maybe_spoof_event_as_stage_event (MetaCompScreen *info,
+                                  XEvent         *event)
 {
  MetaDisplay *display = meta_screen_get_display (info->screen);

@@ -1020,19 +1005,22 @@ maybe_spoof_guard_window_event_as_stage_event (MetaCompScreen *info,
    {
      XIEvent *input_event = (XIEvent *) event->xcookie.data;

-      /* Only care about pointer events for now. */
      switch (input_event->evtype)
        {
        case XI_Motion:
        case XI_ButtonPress:
        case XI_ButtonRelease:
+        case XI_KeyPress:
+        case XI_KeyRelease:
          {
            XIDeviceEvent *device_event = ((XIDeviceEvent *) input_event);
-            if (device_event->event == info->screen->guard_window)
-              {
-                Window xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-                device_event->event = xwin;
-              }
+
+            /* If this is a GTK+ widget, like a window menu, let GTK+ handle
+             * it as-is without mangling. */
+            if (meta_ui_window_is_widget (info->screen->ui, device_event->event))
+              break;
+
+            device_event->event = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
          }
          break;
        default:
@@ -1089,7 +1077,7 @@ meta_compositor_process_event (MetaCompositor *compositor,

 	  info = meta_screen_get_compositor_data (screen);

-          maybe_spoof_guard_window_event_as_stage_event (info, event);
+          maybe_spoof_event_as_stage_event (info, event);

 	  if (meta_plugin_manager_xevent_filter (info->plugin_mgr, event))
 	    {
@@ -1101,29 +1089,20 @@ meta_compositor_process_event (MetaCompositor *compositor,
 	}
    }

-  switch (event->type)
+  if (!meta_is_wayland_compositor () &&
+      event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
    {
-    case PropertyNotify:
-      process_property_notify (compositor, (XPropertyEvent *) event, window);
-      break;
-
-    default:
-      if (!meta_is_wayland_compositor () &&
-          event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
+      /* Core code doesn't handle damage events, so we need to extract the MetaWindow
+       * ourselves
+       */
+      if (window == NULL)
        {
-          /* Core code doesn't handle damage events, so we need to extract the MetaWindow
-           * ourselves
-           */
-          if (window == NULL)
-            {
-              Window xwin = ((XDamageNotifyEvent *) event)->drawable;
-              window = meta_display_lookup_x_window (compositor->display, xwin);
-            }
-
-	  DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
-          process_damage (compositor, (XDamageNotifyEvent *) event, window);
+          Window xwin = ((XDamageNotifyEvent *) event)->drawable;
+          window = meta_display_lookup_x_window (compositor->display, xwin);
        }
-      break;
+
+      DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
+      process_damage (compositor, (XDamageNotifyEvent *) event, window);
    }

  /* Clutter needs to know about MapNotify events otherwise it will
@@ -1648,13 +1627,7 @@ on_shadow_factory_changed (MetaShadowFactory *factory,
 MetaCompositor *
 meta_compositor_new (MetaDisplay *display)
 {
-  char *atom_names[] = {
-    "_XROOTPMAP_ID",
-    "_NET_WM_WINDOW_OPACITY",
-  };
-  Atom                   atoms[G_N_ELEMENTS(atom_names)];
  MetaCompositor        *compositor;
-  Display               *xdisplay = meta_display_get_xdisplay (display);

  if (!composite_at_least_version (display, 0, 3))
    return NULL;
@@ -1666,18 +1639,11 @@ meta_compositor_new (MetaDisplay *display)
  if (g_getenv("META_DISABLE_MIPMAPS"))
    compositor->no_mipmaps = TRUE;

-  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
-  XInternAtoms (xdisplay, atom_names, G_N_ELEMENTS (atom_names),
-                False, atoms);
-
  g_signal_connect (meta_shadow_factory_get_default (),
                    "changed",
                    G_CALLBACK (on_shadow_factory_changed),
                    compositor);

-  compositor->atom_x_root_pixmap = atoms[0];
-  compositor->atom_net_wm_window_opacity = atoms[1];
-
  compositor->repaint_func_id = clutter_threads_add_repaint_func (meta_repaint_func,
                                                                  compositor,
                                                                  NULL);
--- a/src/compositor/meta-background-actor-private.h
+++ b/src/compositor/meta-background-actor-private.h
@@ -6,9 +6,6 @@
 #include <meta/screen.h>
 #include <meta/meta-background-actor.h>

-void meta_background_actor_set_clip_region  (MetaBackgroundActor *self,
-                                             cairo_region_t      *clip_region);
-
 cairo_region_t *meta_background_actor_get_clip_region (MetaBackgroundActor *self);

 #endif /* META_BACKGROUND_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-background-actor.c
+++ b/src/compositor/meta-background-actor.c
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Portions adapted from gnome-shell/src/shell-global.c
 */
@@ -41,20 +39,35 @@
 #include <meta/errors.h>
 #include <meta/meta-background.h>
 #include "meta-background-actor-private.h"
+#include "meta-cullable.h"

 struct _MetaBackgroundActorPrivate
 {
  cairo_region_t *clip_region;
 };

-G_DEFINE_TYPE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR);
+static void cullable_iface_init (MetaCullableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+
+static void
+set_clip_region (MetaBackgroundActor *self,
+                 cairo_region_t      *clip_region)
+{
+  MetaBackgroundActorPrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->clip_region, (GDestroyNotify) cairo_region_destroy);
+  if (clip_region)
+    priv->clip_region = cairo_region_copy (clip_region);
+}

 static void
 meta_background_actor_dispose (GObject *object)
 {
  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);

-  meta_background_actor_set_clip_region (self, NULL);
+  set_clip_region (self, NULL);

  G_OBJECT_CLASS (meta_background_actor_parent_class)->dispose (object);
 }
@@ -104,26 +117,6 @@ meta_background_actor_get_preferred_height (ClutterActor *actor,
    *natural_height_p = height;
 }

-static gboolean
-meta_background_actor_get_paint_volume (ClutterActor       *actor,
-                                        ClutterPaintVolume *volume)
-{
-  ClutterContent *content;
-  gfloat width, height;
-
-  content = clutter_actor_get_content (actor);
-
-  if (!content)
-    return FALSE;
-
-  clutter_content_get_preferred_size (content, &width, &height);
-
-  clutter_paint_volume_set_width (volume, width);
-  clutter_paint_volume_set_height (volume, height);
-
-  return TRUE;
-}
-
 static void
 meta_background_actor_class_init (MetaBackgroundActorClass *klass)
 {
@@ -136,7 +129,6 @@ meta_background_actor_class_init (MetaBackgroundActorClass *klass)

  actor_class->get_preferred_width = meta_background_actor_get_preferred_width;
  actor_class->get_preferred_height = meta_background_actor_get_preferred_height;
-  actor_class->get_paint_volume = meta_background_actor_get_paint_volume;
 }

 static void
@@ -166,31 +158,27 @@ meta_background_actor_new (void)
  return CLUTTER_ACTOR (self);
 }

-/**
- * meta_background_actor_set_clip_region:
- * @self: a #MetaBackgroundActor
- * @clip_region: (allow-none): the area of the actor (in allocate-relative
- *   coordinates) that is visible.
- *
- * Sets the area of the background that is unobscured by overlapping windows.
- * This is used to optimize and only paint the visible portions.
- */
-void
-meta_background_actor_set_clip_region (MetaBackgroundActor *self,
-                                       cairo_region_t      *clip_region)
+static void
+meta_background_actor_cull_out (MetaCullable   *cullable,
+                                cairo_region_t *unobscured_region,
+                                cairo_region_t *clip_region)
 {
-  MetaBackgroundActorPrivate *priv;
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (cullable);
+  set_clip_region (self, clip_region);
+}

-  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
+static void
+meta_background_actor_reset_culling (MetaCullable *cullable)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (cullable);
+  set_clip_region (self, NULL);
+}

-  priv = self->priv;
-
-  g_clear_pointer (&priv->clip_region,
-                   (GDestroyNotify)
-                   cairo_region_destroy);
-
-  if (clip_region)
-    priv->clip_region = cairo_region_copy (clip_region);
+static void
+cullable_iface_init (MetaCullableInterface *iface)
+{
+  iface->cull_out = meta_background_actor_cull_out;
+  iface->reset_culling = meta_background_actor_reset_culling;
 }

 /**
--- a/src/compositor/meta-background-group-private.h
+++ b/src/compositor/meta-background-group-private.h
@@ -1,11 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-#ifndef META_BACKGROUND_GROUP_PRIVATE_H
-#define META_BACKGROUND_GROUP_PRIVATE_H
-
-#include <meta/screen.h>
-#include <meta/meta-background-group.h>
-
-void meta_background_group_set_clip_region  (MetaBackgroundGroup *self,
-                                             cairo_region_t      *visible_region);
-#endif /* META_BACKGROUND_GROUP_PRIVATE_H */
--- a/src/compositor/meta-background-group.c
+++ b/src/compositor/meta-background-group.c
@@ -16,87 +16,43 @@

 #include <config.h>

-#include "compositor-private.h"
-#include "clutter-utils.h"
-#include "meta-background-actor-private.h"
-#include "meta-background-group-private.h"
+#include <meta/meta-background-group.h>
+#include "meta-cullable.h"

-G_DEFINE_TYPE (MetaBackgroundGroup, meta_background_group, CLUTTER_TYPE_ACTOR);
+static void cullable_iface_init (MetaCullableInterface *iface);

-struct _MetaBackgroundGroupPrivate
-{
-  gpointer dummy;
-};
-
-static void
-meta_background_group_dispose (GObject *object)
-{
-  G_OBJECT_CLASS (meta_background_group_parent_class)->dispose (object);
-}
-
-static gboolean
-meta_background_group_get_paint_volume (ClutterActor       *actor,
-                                        ClutterPaintVolume *volume)
-{
-  return clutter_paint_volume_set_from_allocation (volume, actor);
-}
+G_DEFINE_TYPE_WITH_CODE (MetaBackgroundGroup, meta_background_group, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));

 static void
 meta_background_group_class_init (MetaBackgroundGroupClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+}

-  actor_class->get_paint_volume = meta_background_group_get_paint_volume;
-  object_class->dispose = meta_background_group_dispose;
+static void
+meta_background_group_cull_out (MetaCullable   *cullable,
+                                cairo_region_t *unobscured_region,
+                                cairo_region_t *clip_region)
+{
+  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
+}

-  g_type_class_add_private (klass, sizeof (MetaBackgroundGroupPrivate));
+static void
+meta_background_group_reset_culling (MetaCullable *cullable)
+{
+  meta_cullable_reset_culling_children (cullable);
+}
+
+static void
+cullable_iface_init (MetaCullableInterface *iface)
+{
+  iface->cull_out = meta_background_group_cull_out;
+  iface->reset_culling = meta_background_group_reset_culling;
 }

 static void
 meta_background_group_init (MetaBackgroundGroup *self)
 {
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                            META_TYPE_BACKGROUND_GROUP,
-                                            MetaBackgroundGroupPrivate);
-}
-
-/**
- * meta_background_group_set_clip_region:
- * @self: a #MetaBackgroundGroup
- * @region: (allow-none): the parts of the background to paint
- *
- * Sets the area of the backgrounds that is unobscured by overlapping windows.
- * This is used to optimize and only paint the visible portions.
- */
-void
-meta_background_group_set_clip_region (MetaBackgroundGroup *self,
-                                       cairo_region_t      *region)
-{
-  GList *children, *l;
-
-  children = clutter_actor_get_children (CLUTTER_ACTOR (self));
-  for (l = children; l; l = l->next)
-    {
-      ClutterActor *actor = l->data;
-
-      if (META_IS_BACKGROUND_ACTOR (actor))
-        {
-          meta_background_actor_set_clip_region (META_BACKGROUND_ACTOR (actor), region);
-        }
-      else if (META_IS_BACKGROUND_GROUP (actor))
-        {
-          int x, y;
-
-          if (!meta_actor_is_untransformed (actor, &x, &y))
-            continue;
-
-          cairo_region_translate (region, -x, -y);
-          meta_background_group_set_clip_region (META_BACKGROUND_GROUP (actor), region);
-          cairo_region_translate (region, x, y);
-        }
-    }
-  g_list_free (children);
 }

 ClutterActor *
--- a/src/compositor/meta-background.c
+++ b/src/compositor/meta-background.c
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/compositor/meta-cullable.c
+++ b/src/compositor/meta-cullable.c
@@ -0,0 +1,191 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * Copyright (C) 2013 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Written by:
+ *     Owen Taylor <otaylor@redhat.com>
+ *     Ray Strode <rstrode@redhat.com>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#include "config.h"
+#include "meta-cullable.h"
+#include "clutter-utils.h"
+
+G_DEFINE_INTERFACE (MetaCullable, meta_cullable, CLUTTER_TYPE_ACTOR);
+
+/**
+ * SECTION:meta-cullable
+ * @title: MetaCullable
+ * @short_description: CPU culling operations for efficient drawing
+ *
+ * When we are painting a stack of 5-10 large actors, the standard
+ * bottom-to-top method of drawing every actor results in a tremendous
+ * amount of overdraw. If these actors are painting textures like
+ * windows, it can easily max out the available memory bandwidth on a
+ * low-end graphics chipset. It's even worse if window textures are
+ * being accessed over the AGP bus.
+ *
+ * #MetaCullable is our solution. The basic technique applied here is to
+ * do a pre-pass before painting where we walk each actor from top to bottom
+ * and ask each actor to "cull itself out". We pass in a region it can copy
+ * to clip its drawing to, and the actor can subtract its fully opaque pixels
+ * so that actors underneath know not to draw there as well.
+ */
+
+/**
+ * meta_cullable_cull_out_children:
+ * @cullable: The #MetaCullable
+ * @unobscured_region: The unobscured region, as passed into cull_out()
+ * @clip_region: The clip region, as passed into cull_out()
+ *
+ * This is a helper method for actors that want to recurse over their
+ * child actors, and cull them out.
+ *
+ * See #MetaCullable and meta_cullable_cull_out() for more details.
+ */
+void
+meta_cullable_cull_out_children (MetaCullable   *cullable,
+                                 cairo_region_t *unobscured_region,
+                                 cairo_region_t *clip_region)
+{
+  ClutterActor *actor = CLUTTER_ACTOR (cullable);
+  ClutterActor *child;
+  ClutterActorIter iter;
+
+  clutter_actor_iter_init (&iter, actor);
+  while (clutter_actor_iter_prev (&iter, &child))
+    {
+      float x, y;
+
+      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
+        continue;
+
+      /* If an actor has effects applied, then that can change the area
+       * it paints and the opacity, so we no longer can figure out what
+       * portion of the actor is obscured and what portion of the screen
+       * it obscures, so we skip the actor.
+       *
+       * This has a secondary beneficial effect: if a ClutterOffscreenEffect
+       * is applied to an actor, then our clipped redraws interfere with the
+       * caching of the FBO - even if we only need to draw a small portion
+       * of the window right now, ClutterOffscreenEffect may use other portions
+       * of the FBO later. So, skipping actors with effects applied also
+       * prevents these bugs.
+       *
+       * Theoretically, we should check clutter_actor_get_offscreen_redirect()
+       * as well for the same reason, but omitted for simplicity in the
+       * hopes that no-one will do that.
+       */
+      if (clutter_actor_has_effects (child))
+        continue;
+
+      if (!META_IS_CULLABLE (child))
+        continue;
+
+      if (!meta_actor_is_untransformed (child, NULL, NULL))
+        continue;
+
+      clutter_actor_get_position (child, &x, &y);
+
+      /* Temporarily move to the coordinate system of the actor */
+      cairo_region_translate (unobscured_region, - x, - y);
+      cairo_region_translate (clip_region, - x, - y);
+
+      meta_cullable_cull_out (META_CULLABLE (child), unobscured_region, clip_region);
+
+      cairo_region_translate (unobscured_region, x, y);
+      cairo_region_translate (clip_region, x, y);
+    }
+}
+
+/**
+ * meta_cullable_reset_culling_children:
+ * @cullable: The #MetaCullable
+ *
+ * This is a helper method for actors that want to recurse over their
+ * child actors, and cull them out.
+ *
+ * See #MetaCullable and meta_cullable_reset_culling() for more details.
+ */
+void
+meta_cullable_reset_culling_children (MetaCullable *cullable)
+{
+  ClutterActor *actor = CLUTTER_ACTOR (cullable);
+  ClutterActor *child;
+  ClutterActorIter iter;
+
+  clutter_actor_iter_init (&iter, actor);
+  while (clutter_actor_iter_next (&iter, &child))
+    {
+      if (!META_IS_CULLABLE (child))
+        continue;
+
+      meta_cullable_reset_culling (META_CULLABLE (child));
+    }
+}
+
+static void
+meta_cullable_default_init (MetaCullableInterface *iface)
+{
+}
+
+/**
+ * meta_cullable_cull_out:
+ * @cullable: The #MetaCullable
+ * @unobscured_region: The unobscured region, in @cullable's space.
+ * @clip_region: The clip region, in @cullable's space.
+ *
+ * When #MetaWindowGroup is painted, we walk over its direct cullable
+ * children from top to bottom and ask themselves to "cull out". Cullables
+ * can use @unobscured_region and @clip_region to clip their drawing. Actors
+ * interested in eliminating overdraw should copy the @clip_region and only
+ * paint those parts, as everything else has been obscured by actors above it.
+ *
+ * Actors that may have fully opaque parts should also subtract out a region
+ * that is fully opaque from @unobscured_region and @clip_region.
+ *
+ * @unobscured_region and @clip_region are extremely similar. The difference
+ * is that @clip_region starts off with the stage's clip, if Clutter detects
+ * that we're doing a clipped redraw. @unobscured_region, however, starts off
+ * with the full stage size, so actors that may want to record what parts of
+ * their window are unobscured for e.g. scheduling repaints can do so.
+ *
+ * Actors that have children can also use the meta_cullable_cull_out_children()
+ * helper method to do a simple cull across all their children.
+ */
+void
+meta_cullable_cull_out (MetaCullable   *cullable,
+                        cairo_region_t *unobscured_region,
+                        cairo_region_t *clip_region)
+{
+  META_CULLABLE_GET_IFACE (cullable)->cull_out (cullable, unobscured_region, clip_region);
+}
+
+/**
+ * meta_cullable_reset_culling:
+ * @cullable: The #MetaCullable
+ *
+ * Actors that copied data in their cull_out() implementation can now
+ * reset their data, as the paint is now over. Additional paints may be
+ * done by #ClutterClone or similar, and they should not be affected by
+ * the culling operation.
+ */
+void
+meta_cullable_reset_culling (MetaCullable *cullable)
+{
+  META_CULLABLE_GET_IFACE (cullable)->reset_culling (cullable);
+}
--- a/src/compositor/meta-cullable.h
+++ b/src/compositor/meta-cullable.h
@@ -0,0 +1,66 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Written by:
+ *     Owen Taylor <otaylor@redhat.com>
+ *     Ray Strode <rstrode@redhat.com>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef __META_CULLABLE_H__
+#define __META_CULLABLE_H__
+
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+#define META_TYPE_CULLABLE             (meta_cullable_get_type ())
+#define META_CULLABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_CULLABLE, MetaCullable))
+#define META_IS_CULLABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_CULLABLE))
+#define META_CULLABLE_GET_IFACE(obj)   (G_TYPE_INSTANCE_GET_INTERFACE ((obj),  META_TYPE_CULLABLE, MetaCullableInterface))
+
+typedef struct _MetaCullable MetaCullable;
+typedef struct _MetaCullableInterface MetaCullableInterface;
+
+struct _MetaCullableInterface
+{
+  GTypeInterface g_iface;
+
+  void (* cull_out)      (MetaCullable   *cullable,
+                          cairo_region_t *unobscured_region,
+                          cairo_region_t *clip_region);
+  void (* reset_culling) (MetaCullable  *cullable);
+};
+
+GType meta_cullable_get_type (void);
+
+void meta_cullable_cull_out (MetaCullable   *cullable,
+                             cairo_region_t *unobscured_region,
+                             cairo_region_t *clip_region);
+void meta_cullable_reset_culling (MetaCullable *cullable);
+
+/* Utility methods for implementations */
+void meta_cullable_cull_out_children (MetaCullable   *cullable,
+                                      cairo_region_t *unobscured_region,
+                                      cairo_region_t *clip_region);
+void meta_cullable_reset_culling_children (MetaCullable *cullable);
+
+G_END_DECLS
+
+#endif /* __META_CULLABLE_H__ */
+
--- a/src/compositor/meta-module.c
+++ b/src/compositor/meta-module.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <meta/meta-plugin.h>
--- a/src/compositor/meta-module.h
+++ b/src/compositor/meta-module.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_MODULE_H_
--- a/src/compositor/meta-plugin-manager.c
+++ b/src/compositor/meta-plugin-manager.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "config.h"
--- a/src/compositor/meta-plugin-manager.h
+++ b/src/compositor/meta-plugin-manager.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_PLUGIN_MANAGER_H_
--- a/src/compositor/meta-plugin.c
+++ b/src/compositor/meta-plugin.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/compositor/meta-shadow-factory-private.h
+++ b/src/compositor/meta-shadow-factory-private.h
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_SHADOW_FACTORY_PRIVATE_H__
--- a/src/compositor/meta-shadow-factory.c
+++ b/src/compositor/meta-shadow-factory.c
@@ -13,9 +13,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
@@ -39,6 +37,7 @@
 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
 #include <gdk/gdk.h> /* for gdk_rectangle_intersect() */
+#include "meta-cullable.h"

 static void meta_shaped_texture_dispose  (GObject    *object);

@@ -58,7 +57,10 @@ static void meta_shaped_texture_get_preferred_height (ClutterActor *self,

 static gboolean meta_shaped_texture_get_paint_volume (ClutterActor *self, ClutterPaintVolume *volume);

-G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture, CLUTTER_TYPE_ACTOR);
+static void cullable_iface_init (MetaCullableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaShapedTexture, meta_shaped_texture, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));

 #define META_SHAPED_TEXTURE_GET_PRIVATE(obj) \
  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_SHAPED_TEXTURE, \
@@ -111,6 +113,17 @@ meta_shaped_texture_init (MetaShapedTexture *self)
  priv->create_mipmaps = TRUE;
 }

+static void
+set_clip_region (MetaShapedTexture *self,
+                 cairo_region_t    *clip_region)
+{
+  MetaShapedTexturePrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->clip_region, (GDestroyNotify) cairo_region_destroy);
+  if (clip_region)
+    priv->clip_region = cairo_region_copy (clip_region);
+}
+
 static void
 meta_shaped_texture_dispose (GObject *object)
 {
@@ -125,7 +138,7 @@ meta_shaped_texture_dispose (GObject *object)
  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);

  meta_shaped_texture_set_mask_texture (self, NULL);
-  meta_shaped_texture_set_clip_region (self, NULL);
+  set_clip_region (self, NULL);

  G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
 }
@@ -212,10 +225,11 @@ set_cogl_texture (MetaShapedTexture *stex,
  if (priv->texture)
    cogl_object_unref (priv->texture);

-  priv->texture = cogl_object_ref (cogl_tex);
+  priv->texture = cogl_tex;

  if (cogl_tex != NULL)
    {
+      cogl_object_ref (cogl_tex);
      width = cogl_texture_get_width (COGL_TEXTURE (cogl_tex));
      height = cogl_texture_get_height (COGL_TEXTURE (cogl_tex));

@@ -301,15 +315,8 @@ meta_shaped_texture_paint (ClutterActor *actor)

  filter = COGL_PIPELINE_FILTER_LINEAR;

-  if (!clutter_actor_is_in_clone_paint (actor))
-    {
-      int x_origin, y_origin;
-
-      if (meta_actor_is_untransformed (actor,
-                                       &x_origin,
-                                       &y_origin))
-        filter = COGL_PIPELINE_FILTER_NEAREST;
-    }
+  if (!clutter_actor_is_in_clone_paint (actor) && meta_actor_is_untransformed (actor, NULL, NULL))
+    filter = COGL_PIPELINE_FILTER_NEAREST;

  ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
  fb = cogl_get_draw_framebuffer ();
@@ -768,39 +775,6 @@ meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

-/**
- * meta_shaped_texture_set_clip_region:
- * @stex: a #MetaShapedTexture
- * @clip_region: the region of the texture that is visible and
- *   should be painted.
- *
- * Provides a hint to the texture about what areas of the texture
- * are not completely obscured and thus need to be painted. This
- * is an optimization and is not supposed to have any effect on
- * the output.
- *
- * Typically a parent container will set the clip region before
- * painting its children, and then unset it afterwards.
- */
-void
-meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,
-				     cairo_region_t    *clip_region)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  if (priv->clip_region)
-    cairo_region_destroy (priv->clip_region);
-
-  if (clip_region)
-    priv->clip_region = cairo_region_copy (clip_region);
-  else
-    priv->clip_region = NULL;
-}
-
 /**
 * meta_shaped_texture_set_opaque_region:
 * @stex: a #MetaShapedTexture
@@ -929,6 +903,40 @@ meta_shaped_texture_get_image (MetaShapedTexture     *stex,
  return surface;
 }

+static void
+meta_shaped_texture_cull_out (MetaCullable   *cullable,
+                              cairo_region_t *unobscured_region,
+                              cairo_region_t *clip_region)
+{
+  MetaShapedTexture *self = META_SHAPED_TEXTURE (cullable);
+  MetaShapedTexturePrivate *priv = self->priv;
+
+  set_clip_region (self, clip_region);
+
+  if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (self)) == 0xff)
+    {
+      if (priv->opaque_region)
+        {
+          cairo_region_subtract (unobscured_region, priv->opaque_region);
+          cairo_region_subtract (clip_region, priv->opaque_region);
+        }
+    }
+}
+
+static void
+meta_shaped_texture_reset_culling (MetaCullable *cullable)
+{
+  MetaShapedTexture *self = META_SHAPED_TEXTURE (cullable);
+  set_clip_region (self, NULL);
+}
+
+static void
+cullable_iface_init (MetaCullableInterface *iface)
+{
+  iface->cull_out = meta_shaped_texture_cull_out;
+  iface->reset_culling = meta_shaped_texture_reset_culling;
+}
+
 ClutterActor *
 meta_shaped_texture_new (void)
 {
--- a/src/compositor/meta-surface-actor.c
+++ b/src/compositor/meta-surface-actor.c
@@ -15,6 +15,8 @@
 #include <cogl/cogl-texture-pixmap-x11.h>
 #include <meta/meta-shaped-texture.h>
 #include "meta-surface-actor.h"
+#include "meta-wayland-private.h"
+#include "meta-cullable.h"

 #include "meta-shaped-texture-private.h"

@@ -22,10 +24,12 @@ struct _MetaSurfaceActorPrivate
 {
  MetaShapedTexture *texture;
  MetaWaylandBuffer *buffer;
-  Pixmap pixmap;
 };

-G_DEFINE_TYPE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR);
+static void cullable_iface_init (MetaCullableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));

 static void
 meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
@@ -33,6 +37,27 @@ meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
  g_type_class_add_private (klass, sizeof (MetaSurfaceActorPrivate));
 }

+static void
+meta_surface_actor_cull_out (MetaCullable   *cullable,
+                             cairo_region_t *unobscured_region,
+                             cairo_region_t *clip_region)
+{
+  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
+}
+
+static void
+meta_surface_actor_reset_culling (MetaCullable *cullable)
+{
+  meta_cullable_reset_culling_children (cullable);
+}
+
+static void
+cullable_iface_init (MetaCullableInterface *iface)
+{
+  iface->cull_out = meta_surface_actor_cull_out;
+  iface->reset_culling = meta_surface_actor_reset_culling;
+}
+
 static void
 meta_surface_actor_init (MetaSurfaceActor *self)
 {
@@ -42,21 +67,8 @@ meta_surface_actor_init (MetaSurfaceActor *self)
                                                   META_TYPE_SURFACE_ACTOR,
                                                   MetaSurfaceActorPrivate);

-  priv->texture = NULL;
-}
-
-MetaSurfaceActor *
-meta_surface_actor_new (void)
-{
-  MetaSurfaceActor *self = g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
-  MetaShapedTexture *stex;
-
-  stex = META_SHAPED_TEXTURE (meta_shaped_texture_new ());
-  self->priv->texture = stex;
-
-  clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (stex));
-
-  return self;
+  priv->texture = META_SHAPED_TEXTURE (meta_shaped_texture_new ());
+  clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->texture));
 }

 cairo_surface_t *
@@ -72,13 +84,6 @@ meta_surface_actor_get_texture (MetaSurfaceActor *self)
  return self->priv->texture;
 }

-void
-meta_surface_actor_set_clip_region (MetaSurfaceActor *self,
-                                    cairo_region_t   *clip_region)
-{
-  meta_shaped_texture_set_clip_region (self->priv->texture, clip_region);
-}
-
 static void
 update_area (MetaSurfaceActor *self,
             int x, int y, int width, int height)
@@ -93,7 +98,7 @@ update_area (MetaSurfaceActor *self,
      if (shm_buffer)
        {
          CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
-          cogl_wayland_texture_2d_update_area (texture, shm_buffer, x, y, width, height);
+          cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
        }
    }
  else
@@ -111,7 +116,7 @@ meta_surface_actor_damage_all (MetaSurfaceActor *self,
  CoglTexture *texture = meta_shaped_texture_get_texture (priv->texture);

  update_area (self, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
-  return meta_shaped_texture_update_area (self->priv->texture,
+  return meta_shaped_texture_update_area (priv->texture,
                                          0, 0,
                                          cogl_texture_get_width (texture),
                                          cogl_texture_get_height (texture),
@@ -126,8 +131,10 @@ meta_surface_actor_damage_area (MetaSurfaceActor *self,
                                int               height,
                                cairo_region_t   *unobscured_region)
 {
+  MetaSurfaceActorPrivate *priv = self->priv;
+
  update_area (self, x, y, width, height);
-  return meta_shaped_texture_update_area (self->priv->texture,
+  return meta_shaped_texture_update_area (priv->texture,
                                          x, y, width, height,
                                          unobscured_region);
 }
@@ -138,12 +145,39 @@ meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor *self,
 {
  MetaSurfaceActorPrivate *priv = self->priv;
  priv->buffer = buffer;
-  meta_shaped_texture_set_texture (self->priv->texture, buffer->texture);
+
+  if (buffer)
+    meta_shaped_texture_set_texture (priv->texture, buffer->texture);
+  else
+    meta_shaped_texture_set_texture (priv->texture, NULL);
 }

 void
 meta_surface_actor_set_texture (MetaSurfaceActor *self,
                                CoglTexture      *texture)
 {
-  meta_shaped_texture_set_texture (self->priv->texture, texture);
+  MetaSurfaceActorPrivate *priv = self->priv;
+  meta_shaped_texture_set_texture (priv->texture, texture);
+}
+
+void
+meta_surface_actor_set_input_region (MetaSurfaceActor *self,
+                                     cairo_region_t   *region)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+  meta_shaped_texture_set_input_shape_region (priv->texture, region);
+}
+
+void
+meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
+                                      cairo_region_t   *region)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+  meta_shaped_texture_set_opaque_region (priv->texture, region);
+}
+
+MetaSurfaceActor *
+meta_surface_actor_new (void)
+{
+  return g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
 }
--- a/src/compositor/meta-surface-actor.h
+++ b/src/compositor/meta-surface-actor.h
@@ -6,7 +6,7 @@
 #include <config.h>

 #include <meta/meta-shaped-texture.h>
-#include "meta-wayland-private.h"
+#include "meta-wayland-types.h"

 G_BEGIN_DECLS

@@ -43,9 +43,6 @@ cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,

 MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);

-void meta_surface_actor_set_clip_region (MetaSurfaceActor *self,
-                                         cairo_region_t   *clip_region);
-
 gboolean meta_surface_actor_damage_all (MetaSurfaceActor *self,
                                        cairo_region_t   *unobscured_region);

@@ -60,6 +57,10 @@ void meta_surface_actor_set_texture (MetaSurfaceActor *self,
                                     CoglTexture      *texture);
 void meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor  *self,
                                               MetaWaylandBuffer *buffer);
+void meta_surface_actor_set_input_region (MetaSurfaceActor *self,
+                                          cairo_region_t   *region);
+void meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
+                                           cairo_region_t   *region);

 G_END_DECLS

--- a/src/compositor/meta-texture-rectangle.c
+++ b/src/compositor/meta-texture-rectangle.c
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
@@ -28,41 +26,6 @@
 #include <clutter/clutter.h>
 #include "meta-texture-rectangle.h"

-CoglTexture *
-meta_texture_rectangle_new (unsigned int width,
-                            unsigned int height,
-                            CoglPixelFormat format,
-                            CoglPixelFormat internal_format,
-                            unsigned int rowstride,
-                            const guint8 *data,
-                            GError **error)
-{
-  ClutterBackend *backend =
-    clutter_get_default_backend ();
-  CoglContext *context =
-    clutter_backend_get_cogl_context (backend);
-  CoglTextureRectangle *tex_rect;
-
-  tex_rect = cogl_texture_rectangle_new_with_size (context,
-                                                   width, height,
-                                                   internal_format,
-                                                   error);
-  if (tex_rect == NULL)
-    return NULL;
-
-  if (data)
-    cogl_texture_set_region (COGL_TEXTURE (tex_rect),
-                             0, 0, /* src_x/y */
-                             0, 0, /* dst_x/y */
-                             width, height, /* dst_width/height */
-                             width, height, /* width/height */
-                             format,
-                             rowstride,
-                             data);
-
-  return COGL_TEXTURE (tex_rect);
-}
-
 static void
 texture_rectangle_check_cb (CoglTexture *sub_texture,
                            const float *sub_texture_coords,
--- a/src/compositor/meta-texture-rectangle.h
+++ b/src/compositor/meta-texture-rectangle.h
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_TEXTURE_RECTANGLE_H__
@@ -30,15 +28,6 @@

 G_BEGIN_DECLS

-CoglTexture *
-meta_texture_rectangle_new (unsigned int width,
-                            unsigned int height,
-                            CoglPixelFormat format,
-                            CoglPixelFormat internal_format,
-                            unsigned int rowstride,
-                            const guint8 *data,
-                            GError **error);
-
 gboolean
 meta_texture_rectangle_check (CoglTexture *texture);

--- a/src/compositor/meta-texture-tower.c
+++ b/src/compositor/meta-texture-tower.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <math.h>
@@ -357,18 +355,10 @@ texture_tower_create_texture (MetaTextureTower *tower,
  if ((!is_power_of_two (width) || !is_power_of_two (height)) &&
      meta_texture_rectangle_check (tower->textures[level - 1]))
    {
-      tower->textures[level] =
-        meta_texture_rectangle_new (width, height,
-                                    /* data format */
-                                    TEXTURE_FORMAT,
-                                    /* internal cogl format */
-                                    TEXTURE_FORMAT,
-                                    /* rowstride */
-                                    width * 4,
-                                    /* data */
-                                    NULL,
-                                    /* error */
-                                    NULL);
+      ClutterBackend *backend = clutter_get_default_backend ();
+      CoglContext *context = clutter_backend_get_cogl_context (backend);
+
+      tower->textures[level] = cogl_texture_rectangle_new_with_size (context, width, height);
    }
  else
    {
--- a/src/compositor/meta-texture-tower.h
+++ b/src/compositor/meta-texture-tower.h
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_TEXTURE_TOWER_H__
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -31,14 +31,6 @@ void meta_window_actor_unmaximize (MetaWindowActor *self,
 void meta_window_actor_process_x11_damage (MetaWindowActor    *self,
                                           XDamageNotifyEvent *event);

-void meta_window_actor_process_wayland_damage (MetaWindowActor *self,
-                                               int              x,
-                                               int              y,
-                                               int              width,
-                                               int              height);
-void meta_window_actor_attach_wayland_buffer  (MetaWindowActor   *self,
-                                               MetaWaylandBuffer *buffer);
-
 void meta_window_actor_pre_paint      (MetaWindowActor    *self);
 void meta_window_actor_post_paint     (MetaWindowActor    *self);
 void meta_window_actor_frame_complete (MetaWindowActor    *self,
@@ -67,14 +59,6 @@ void     meta_window_actor_set_updates_frozen  (MetaWindowActor *self,
 void     meta_window_actor_queue_frame_drawn   (MetaWindowActor *self,
                                                gboolean         no_delay_frame);

-cairo_region_t *meta_window_actor_get_obscured_region (MetaWindowActor *self);
-
-void meta_window_actor_set_clip_region         (MetaWindowActor *self,
-                                                cairo_region_t  *clip_region);
-void meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
-                                                cairo_region_t  *beneath_region);
-void meta_window_actor_reset_clip_regions      (MetaWindowActor *self);
-
 void meta_window_actor_set_unobscured_region      (MetaWindowActor *self,
                                                   cairo_region_t  *unobscured_region);

--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -35,6 +35,7 @@
 #include "region-utils.h"
 #include "meta-wayland-private.h"
 #include "monitor-private.h"
+#include "meta-cullable.h"

 enum {
  POSITION_CHANGED,
@@ -48,13 +49,10 @@ static guint signals[LAST_SIGNAL] = {0};
 struct _MetaWindowActorPrivate
 {
  MetaWindow       *window;
-  Window            xwindow;
  MetaScreen       *screen;

  MetaSurfaceActor *surface;

-  guint             surface_allocation_changed_id;
-
  /* MetaShadowFactory only caches shadows that are actually in use;
   * to avoid unnecessary recomputation we do two things: 1) we store
   * both a focused and unfocused shadow for the window. If the window
@@ -69,15 +67,8 @@ struct _MetaWindowActorPrivate
  MetaShadow       *focused_shadow;
  MetaShadow       *unfocused_shadow;

-  guint8            opacity;
-
  /* A region that matches the shape of the window, including frame bounds */
  cairo_region_t   *shape_region;
-  /* If the window has an input shape, a region that matches the shape */
-  cairo_region_t   *input_region;
-  /* The opaque region, from _NET_WM_OPAQUE_REGION, intersected with
-   * the shape region. */
-  cairo_region_t   *opaque_region;
  /* The region we should clip to when painting the shadow */
  cairo_region_t   *shadow_clip;

@@ -165,8 +156,6 @@ struct _FrameData
 enum
 {
  PROP_META_WINDOW = 1,
-  PROP_META_SCREEN,
-  PROP_X_WINDOW,
  PROP_NO_SHADOW,
  PROP_SHADOW_CLASS
 };
@@ -202,7 +191,10 @@ static void do_send_frame_timings (MetaWindowActor  *self,
                                   gint             refresh_interval,
                                   gint64           presentation_time);

-G_DEFINE_TYPE (MetaWindowActor, meta_window_actor, CLUTTER_TYPE_ACTOR);
+static void cullable_iface_init (MetaCullableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaWindowActor, meta_window_actor, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));

 static void
 frame_data_free (FrameData *frame)
@@ -232,33 +224,12 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
                               "MetaWindow",
                               "The displayed MetaWindow",
                               META_TYPE_WINDOW,
-                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);

  g_object_class_install_property (object_class,
                                   PROP_META_WINDOW,
                                   pspec);

-  pspec = g_param_spec_pointer ("meta-screen",
-				"MetaScreen",
-				"MetaScreen",
-				G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
-
-  g_object_class_install_property (object_class,
-                                   PROP_META_SCREEN,
-                                   pspec);
-
-  pspec = g_param_spec_ulong ("x-window",
-			      "Window",
-			      "Window",
-			      0,
-			      G_MAXULONG,
-			      0,
-			      G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
-
-  g_object_class_install_property (object_class,
-                                   PROP_X_WINDOW,
-                                   pspec);
-
  pspec = g_param_spec_boolean ("no-shadow",
                                "No shadow",
                                "Do not add shaddow to this window",
@@ -301,9 +272,6 @@ meta_window_actor_init (MetaWindowActor *self)
  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 						   META_TYPE_WINDOW_ACTOR,
 						   MetaWindowActorPrivate);
-
-  priv->surface_allocation_changed_id = 0;
-  priv->opacity = 0xff;
  priv->shadow_class = NULL;
 }

@@ -314,11 +282,9 @@ window_decorated_notify (MetaWindow *mw,
 {
  MetaWindowActor        *self     = META_WINDOW_ACTOR (data);
  MetaWindowActorPrivate *priv     = self->priv;
-  MetaFrame              *frame    = meta_window_get_frame (mw);
  MetaScreen             *screen   = priv->screen;
  MetaDisplay            *display  = meta_screen_get_display (screen);
  Display                *xdisplay = meta_display_get_xdisplay (display);
-  Window                  new_xwindow;

  /*
   * Basically, we have to reconstruct the the internals of this object
@@ -326,11 +292,6 @@ window_decorated_notify (MetaWindow *mw,
   */
  priv->redecorating = TRUE;

-  if (frame)
-    new_xwindow = meta_frame_get_xwindow (frame);
-  else
-    new_xwindow = meta_window_get_xwindow (mw);
-
  if (!meta_is_wayland_compositor ())
    {
      meta_window_actor_detach_x11_pixmap (self);
@@ -348,8 +309,6 @@ window_decorated_notify (MetaWindow *mw,
        }
    }

-  priv->xwindow = new_xwindow;
-
  /*
   * Recreate the contents.
   */
@@ -371,21 +330,33 @@ surface_allocation_changed_notify (ClutterActor           *actor,
                                   MetaWindowActor        *self)
 {
  meta_window_actor_sync_actor_geometry (self, FALSE);
+  meta_window_actor_update_shape (self);

  g_signal_emit (self, signals[SIZE_CHANGED], 0);
 }

+static gboolean
+is_non_opaque (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  MetaWindow *window = priv->window;
+
+  return priv->argb32 || (window->opacity != 0xFF);
+}
+
 static void
 meta_window_actor_constructed (GObject *object)
 {
  MetaWindowActor        *self     = META_WINDOW_ACTOR (object);
  MetaWindowActorPrivate *priv     = self->priv;
-  MetaScreen             *screen   = priv->screen;
-  MetaDisplay            *display  = meta_screen_get_display (screen);
-  Window                  xwindow  = priv->xwindow;
  MetaWindow             *window   = priv->window;
+  Window                  xwindow  = meta_window_get_toplevel_xwindow (window);
+  MetaScreen             *screen   = meta_window_get_screen (window);
+  MetaDisplay            *display  = meta_screen_get_display (screen);
  Display                *xdisplay = meta_display_get_xdisplay (display);

+  priv->screen = screen;
+
  if (!meta_is_wayland_compositor ())
    priv->damage = XDamageCreate (xdisplay, xwindow,
                                  XDamageReportBoundingBox);
@@ -407,46 +378,24 @@ meta_window_actor_constructed (GObject *object)

  if (!priv->surface)
    {
-      priv->surface = meta_surface_actor_new ();
+      if (window->surface)
+        priv->surface = window->surface->surface_actor;
+      else
+        priv->surface = meta_surface_actor_new ();
+      g_object_ref_sink (priv->surface);

      clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));
-      clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);

-      priv->surface_allocation_changed_id =
-        g_signal_connect (CLUTTER_ACTOR (priv->surface),
-                          "allocation-changed",
-                          G_CALLBACK (surface_allocation_changed_notify),
-                          self);
-
-      /*
-       * Since we are holding a pointer to this actor independently of the
-       * ClutterContainer internals, and provide a public API to access it,
-       * add a reference here, so that if someone is messing about with us
-       * via the container interface, we do not end up with a dangling pointer.
-       * We will release it in dispose().
-       */
-      g_object_ref (priv->surface);
-
-      g_signal_connect_object (window, "notify::decorated",
-                               G_CALLBACK (window_decorated_notify), self, 0);
-      g_signal_connect_object (window, "notify::appears-focused",
-                               G_CALLBACK (window_appears_focused_notify), self, 0);
-    }
-  else
-    {
-      /*
-       * This is the case where existing window is gaining/loosing frame.
-       * Just ensure the actor is top most (i.e., above shadow).
-       */
-      clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface), NULL);
+      g_signal_connect_object (priv->surface, "allocation-changed",
+                               G_CALLBACK (surface_allocation_changed_notify), self, 0);
+      meta_window_actor_update_shape (self);
    }

  meta_window_actor_update_opacity (self);

-  /* Start off with empty regions to maintain the invariant that
-     these regions are always set */
+  /* Start off with an empty shape region to maintain the invariant
+   * that it's always set */
  priv->shape_region = cairo_region_create ();
-  priv->input_region = cairo_region_create ();
 }

 static void
@@ -478,8 +427,6 @@ meta_window_actor_dispose (GObject *object)

  g_clear_pointer (&priv->unobscured_region, cairo_region_destroy);
  g_clear_pointer (&priv->shape_region, cairo_region_destroy);
-  g_clear_pointer (&priv->input_region, cairo_region_destroy);
-  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);

  g_clear_pointer (&priv->shadow_class, g_free);
@@ -503,11 +450,6 @@ meta_window_actor_dispose (GObject *object)

  g_clear_object (&priv->window);

-  if (priv->surface != NULL && priv->surface_allocation_changed_id != 0)
-    g_signal_handler_disconnect (priv->surface,
-                                 priv->surface_allocation_changed_id);
-  priv->surface_allocation_changed_id = 0;
-
  /*
   * Release the extra reference we took on the actor.
   */
@@ -539,17 +481,12 @@ meta_window_actor_set_property (GObject      *object,
  switch (prop_id)
    {
    case PROP_META_WINDOW:
-      {
-        if (priv->window)
-          g_object_unref (priv->window);
-        priv->window = g_value_dup_object (value);
-      }
-      break;
-    case PROP_META_SCREEN:
-      priv->screen = g_value_get_pointer (value);
-      break;
-    case PROP_X_WINDOW:
-      priv->xwindow = g_value_get_ulong (value);
+      priv->window = g_value_dup_object (value);
+
+      g_signal_connect_object (priv->window, "notify::decorated",
+                               G_CALLBACK (window_decorated_notify), self, 0);
+      g_signal_connect_object (priv->window, "notify::appears-focused",
+                               G_CALLBACK (window_appears_focused_notify), self, 0);
      break;
    case PROP_NO_SHADOW:
      {
@@ -595,12 +532,6 @@ meta_window_actor_get_property (GObject      *object,
    case PROP_META_WINDOW:
      g_value_set_object (value, priv->window);
      break;
-    case PROP_META_SCREEN:
-      g_value_set_pointer (value, priv->screen);
-      break;
-    case PROP_X_WINDOW:
-      g_value_set_ulong (value, priv->xwindow);
-      break;
    case PROP_NO_SHADOW:
      g_value_set_boolean (value, priv->no_shadow);
      break;
@@ -698,7 +629,7 @@ clip_shadow_under_window (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;

-  return (priv->argb32 || priv->opacity != 0xff) && priv->window->frame;
+  return is_non_opaque (self) && priv->window->frame;
 }

 static void
@@ -724,6 +655,7 @@ meta_window_actor_paint (ClutterActor *actor)
      MetaShadowParams params;
      cairo_rectangle_int_t shape_bounds;
      cairo_region_t *clip = priv->shadow_clip;
+      MetaWindow *window = priv->window;

      meta_window_actor_get_shape_bounds (self, &shape_bounds);
      meta_window_actor_get_shadow_params (self, appears_focused, &params);
@@ -747,7 +679,7 @@ meta_window_actor_paint (ClutterActor *actor)
                         params.y_offset + shape_bounds.y,
                         shape_bounds.width,
                         shape_bounds.height,
-                         (clutter_actor_get_paint_opacity (actor) * params.opacity * priv->opacity) / (255 * 255),
+                         (clutter_actor_get_paint_opacity (actor) * params.opacity * window->opacity) / (255 * 255),
                         clip,
                         clip_shadow_under_window (self)); /* clip_strictly - not just as an optimization */

@@ -790,7 +722,11 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
    }

  if (priv->unobscured_region)
-    cairo_region_intersect_rectangle (priv->unobscured_region, &bounds);
+    {
+      cairo_rectangle_int_t unobscured_bounds;
+      cairo_region_get_extents (priv->unobscured_region, &unobscured_bounds);
+      gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
+    }

  origin.x = bounds.x;
  origin.y = bounds.y;
@@ -834,10 +770,10 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
    return TRUE;

  /*
-   * Do not add shadows to ARGB windows; eventually we should generate a
-   * shadow from the input shape for such windows.
+   * Do not add shadows to non-opaque windows; eventually we should generate
+   * a shadow from the input shape for such windows.
   */
-  if (priv->argb32 || priv->opacity != 0xff)
+  if (is_non_opaque (self))
    return FALSE;

  /*
@@ -868,20 +804,6 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
  return FALSE;
 }

-/**
- * meta_window_actor_get_x_window: (skip)
- * @self: a #MetaWindowActor
- *
- */
-Window
-meta_window_actor_get_x_window (MetaWindowActor *self)
-{
-  if (!self)
-    return None;
-
-  return self->priv->xwindow;
-}
-
 /**
 * meta_window_actor_get_meta_window:
 * @self: a #MetaWindowActor
@@ -1402,7 +1324,7 @@ meta_window_actor_should_unredirect (MetaWindowActor *self)
  if (meta_window_requested_dont_bypass_compositor (metaWindow))
    return FALSE;

-  if (priv->opacity != 0xff)
+  if (metaWindow->opacity != 0xFF)
    return FALSE;

  if (metaWindow->shape_region != NULL)
@@ -1433,7 +1355,7 @@ meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state)
  MetaDisplay *display = meta_window_get_display (metaWindow);

  Display *xdisplay = meta_display_get_xdisplay (display);
-  Window  xwin = meta_window_actor_get_x_window (self);
+  Window  xwin = meta_window_get_toplevel_xwindow (metaWindow);

  if (state)
    {
@@ -1603,6 +1525,7 @@ meta_window_actor_hide (MetaWindowActor *self,
  g_return_if_fail (priv->visible);

  priv->visible = FALSE;
+  clutter_actor_set_reactive (CLUTTER_ACTOR (self), FALSE);

  /* If a plugin is animating a workspace transition, we have to
   * hold off on hiding the window, and do it after the workspace
@@ -1696,31 +1619,10 @@ meta_window_actor_new (MetaWindow *window)
  MetaCompScreen         *info = meta_screen_get_compositor_data (screen);
  MetaWindowActor        *self;
  MetaWindowActorPrivate *priv;
-  MetaFrame		 *frame;
-  Window		  top_window = None;
  ClutterActor           *window_group;

-  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
-    {
-      frame = meta_window_get_frame (window);
-      if (frame)
-        top_window = meta_frame_get_xwindow (frame);
-      else
-        top_window = meta_window_get_xwindow (window);
-
-      meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint)top_window);
-    }
-  else
-    {
-      meta_verbose ("add window: Meta %p, wayland surface %p\n",
-                    window, window->surface);
-      top_window = None;
-    }
-
  self = g_object_new (META_TYPE_WINDOW_ACTOR,
-                       "meta-window",         window,
-                       "x-window",            top_window,
-                       "meta-screen",         screen,
+                       "meta-window", window,
                       NULL);

  priv = self->priv;
@@ -1800,38 +1702,6 @@ meta_window_actor_unmapped (MetaWindowActor *self)
    }
 }

-/**
- * meta_window_actor_get_obscured_region:
- * @self: a #MetaWindowActor
- *
- * Gets the region that is completely obscured by the window. Coordinates
- * are relative to the upper-left of the window.
- *
- * Return value: (transfer none): the area obscured by the window,
- *  %NULL is the same as an empty region.
- */
-cairo_region_t *
-meta_window_actor_get_obscured_region (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (!priv->window->shaded)
-    {
-      if (meta_is_wayland_compositor ())
-        {
-          if (priv->opacity == 0xff)
-            return priv->opaque_region;
-        }
-      else
-        {
-          if (priv->back_pixmap && priv->opacity == 0xff)
-            return priv->opaque_region;
-        }
-    }
-
-  return NULL;
-}
-
 #if 0
 /* Print out a region; useful for debugging */
 static void
@@ -1881,8 +1751,6 @@ see_region (cairo_region_t *region,
 *
 * Provides a hint as to what areas of the window need to queue
 * redraws when damaged. Regions not in @unobscured_region are completely obscured.
- * Unlike meta_window_actor_set_clip_region(), the region here
- * doesn't take into account any clipping that is in effect while drawing.
 */
 void
 meta_window_actor_set_unobscured_region (MetaWindowActor *self,
@@ -1899,26 +1767,6 @@ meta_window_actor_set_unobscured_region (MetaWindowActor *self,
    priv->unobscured_region = NULL;
 }

-/**
- * meta_window_actor_set_clip_region:
- * @self: a #MetaWindowActor
- * @clip_region: the region of the screen that isn't completely
- *  obscured.
- *
- * Provides a hint as to what areas of the window need to be
- * drawn. Regions not in @clip_region are completely obscured or
- * not drawn in this frame.
- * This will be set before painting then unset afterwards.
- */
-void
-meta_window_actor_set_clip_region (MetaWindowActor *self,
-                                   cairo_region_t  *clip_region)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  meta_surface_actor_set_clip_region (priv->surface, clip_region);
-}
-
 /**
 * meta_window_actor_set_clip_region_beneath:
 * @self: a #MetaWindowActor
@@ -1931,7 +1779,7 @@ meta_window_actor_set_clip_region (MetaWindowActor *self,
 * shadow hid by the window itself. This will be set before painting
 * then unset afterwards.
 */
-void
+static void
 meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
                                           cairo_region_t  *beneath_region)
 {
@@ -1951,20 +1799,43 @@ meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
    }
 }

-/**
- * meta_window_actor_reset_clip_regions:
- * @self: a #MetaWindowActor
- *
- * Unsets the regions set by meta_window_actor_set_clip_region() and
- * meta_window_actor_set_clip_region_beneath()
- */
-void
-meta_window_actor_reset_clip_regions (MetaWindowActor *self)
+static void
+meta_window_actor_cull_out (MetaCullable   *cullable,
+                            cairo_region_t *unobscured_region,
+                            cairo_region_t *clip_region)
 {
+  MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
+
+  if (!meta_is_wayland_compositor ())
+    {
+      MetaCompScreen *info = meta_screen_get_compositor_data (self->priv->screen);
+
+      /* Don't do any culling for the unredirected window */
+      if (self == info->unredirected_window)
+        return;
+    }
+
+  meta_window_actor_set_unobscured_region (self, unobscured_region);
+  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
+  meta_window_actor_set_clip_region_beneath (self, clip_region);
+}
+
+static void
+meta_window_actor_reset_culling (MetaCullable *cullable)
+{
+  MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
  MetaWindowActorPrivate *priv = self->priv;

-  meta_surface_actor_set_clip_region (priv->surface, NULL);
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
+
+  meta_cullable_reset_culling_children (cullable);
+}
+
+static void
+cullable_iface_init (MetaCullableInterface *iface)
+{
+  iface->cull_out = meta_window_actor_cull_out;
+  iface->reset_culling = meta_window_actor_reset_culling;
 }

 /* When running as a wayland compositor we don't make requests for
@@ -1978,7 +1849,7 @@ check_needs_x11_pixmap (MetaWindowActor *self)
  MetaDisplay         *display  = meta_screen_get_display (screen);
  Display             *xdisplay = meta_display_get_xdisplay (display);
  MetaCompScreen      *info     = meta_screen_get_compositor_data (screen);
-  Window               xwindow  = priv->xwindow;
+  Window               xwindow  = meta_window_get_toplevel_xwindow (priv->window);

  if (!priv->needs_pixmap)
    return;
@@ -2183,30 +2054,6 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,

 }

-void
-meta_window_actor_process_wayland_damage (MetaWindowActor *self,
-                                          int x,
-                                          int y,
-                                          int width,
-                                          int height)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  cairo_region_t *unobscured_region;
-  gboolean redraw_queued;
-
-  if (!priv->mapped)
-    return;
-
-  unobscured_region =
-    clutter_actor_has_mapped_clones (CLUTTER_ACTOR (priv->surface))
-    ? NULL : priv->unobscured_region;
-  redraw_queued = meta_surface_actor_damage_area (priv->surface,
-                                                  x, y, width, height,
-                                                  unobscured_region);
-
-  priv->repaint_scheduled = priv->repaint_scheduled  || redraw_queued;
-}
-
 void
 meta_window_actor_sync_visibility (MetaWindowActor *self)
 {
@@ -2325,12 +2172,18 @@ build_and_scan_frame_mask (MetaWindowActor       *self,

  if (meta_texture_rectangle_check (paint_tex))
    {
-      mask_texture = meta_texture_rectangle_new (tex_width, tex_height,
-                                                 COGL_PIXEL_FORMAT_A_8,
-                                                 COGL_PIXEL_FORMAT_A_8,
-                                                 stride,
-                                                 mask_data,
-                                                 NULL /* error */);
+      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));
+      cogl_texture_set_components (mask_texture, COGL_TEXTURE_COMPONENTS_A);
+      cogl_texture_set_region (mask_texture,
+                               0, 0, /* src_x/y */
+                               0, 0, /* dst_x/y */
+                               tex_width, tex_height, /* dst_width/height */
+                               tex_width, tex_height, /* width/height */
+                               COGL_PIXEL_FORMAT_A_8,
+                               stride, mask_data);
    }
  else
    {
@@ -2391,12 +2244,8 @@ meta_window_actor_update_input_region (MetaWindowActor       *self,
                                       cairo_rectangle_int_t *client_area)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaShapedTexture *stex = meta_surface_actor_get_texture (priv->surface);
  cairo_region_t *region = NULL;

-  if (!stex)
-    return;
-
  if (priv->window->frame != NULL && priv->window->input_region != NULL)
    {
      region = meta_frame_get_frame_bounds (priv->window->frame);
@@ -2409,7 +2258,7 @@ meta_window_actor_update_input_region (MetaWindowActor       *self,
      cairo_region_union (region, priv->window->input_region);
      cairo_region_translate (region, client_area->x, client_area->y);
    }
-  else if (priv->window->shape_region != NULL)
+  else if (priv->window->input_region != NULL)
    {
      region = cairo_region_reference (priv->window->input_region);
    }
@@ -2421,7 +2270,7 @@ meta_window_actor_update_input_region (MetaWindowActor       *self,
      region = cairo_region_create_rectangle (client_area);
    }

-  meta_shaped_texture_set_input_shape_region (stex, region);
+  meta_surface_actor_set_input_region (priv->surface, region);
  cairo_region_destroy (region);
 }

@@ -2429,13 +2278,7 @@ static void
 meta_window_actor_update_opaque_region (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaShapedTexture *stex;
-
-  stex = meta_surface_actor_get_texture (priv->surface);
-  if (!stex)
-    return;
-
-  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
+  cairo_region_t *opaque_region;

  if (priv->argb32 && priv->window->opaque_region != NULL)
    {
@@ -2453,16 +2296,17 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
       * to be undefined, and considered a client bug. In mutter's
       * case, graphical glitches will occur.
       */
-      priv->opaque_region = cairo_region_copy (priv->window->opaque_region);
-      cairo_region_translate (priv->opaque_region, borders.total.left, borders.total.top);
-      cairo_region_intersect (priv->opaque_region, priv->shape_region);
+      opaque_region = cairo_region_copy (priv->window->opaque_region);
+      cairo_region_translate (opaque_region, borders.total.left, borders.total.top);
+      cairo_region_intersect (opaque_region, priv->shape_region);
    }
  else if (priv->argb32)
-    priv->opaque_region = NULL;
+    opaque_region = NULL;
  else
-    priv->opaque_region = cairo_region_reference (priv->shape_region);
+    opaque_region = cairo_region_reference (priv->shape_region);

-  meta_shaped_texture_set_opaque_region (stex, priv->opaque_region);
+  meta_surface_actor_set_opaque_region (priv->surface, opaque_region);
+  cairo_region_destroy (opaque_region);
 }

 static void
@@ -2489,8 +2333,12 @@ check_needs_reshape (MetaWindowActor *self)
    client_area.height = priv->window->rect.height;

  meta_window_actor_update_shape_region (self, &client_area);
-  meta_window_actor_update_input_region (self, &client_area);
-  meta_window_actor_update_opaque_region (self);
+
+  if (priv->window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    {
+      meta_window_actor_update_input_region (self, &client_area);
+      meta_window_actor_update_opaque_region (self);
+    }

  priv->needs_reshape = FALSE;
 }
@@ -2508,14 +2356,6 @@ meta_window_actor_update_shape (MetaWindowActor *self)
  clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
 }

-void
-meta_window_actor_attach_wayland_buffer (MetaWindowActor *self,
-                                         MetaWaylandBuffer *buffer)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  meta_surface_actor_attach_wayland_buffer (priv->surface, buffer);
-}
-
 static void
 meta_window_actor_handle_updates (MetaWindowActor *self)
 {
@@ -2749,23 +2589,9 @@ void
 meta_window_actor_update_opacity (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaDisplay *display = meta_screen_get_display (priv->screen);
-  MetaCompositor *compositor = meta_display_get_compositor (display);
-  Window xwin = meta_window_get_xwindow (priv->window);
-  gulong value;
-  guint8 opacity;
+  MetaWindow *window = priv->window;

-  if (meta_prop_get_cardinal (display, xwin,
-                              compositor->atom_net_wm_window_opacity,
-                              &value))
-    {
-      opacity = (guint8)((gfloat)value * 255.0 / ((gfloat)0xffffffff));
-    }
-  else
-    opacity = 255;
-
-  self->priv->opacity = opacity;
-  clutter_actor_set_opacity (CLUTTER_ACTOR (self->priv->surface), opacity);
+  clutter_actor_set_opacity (CLUTTER_ACTOR (self->priv->surface), window->opacity);
 }

 void
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@@ -11,9 +11,8 @@
 #include "compositor-private.h"
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "meta-background-actor-private.h"
-#include "meta-background-group-private.h"
 #include "window-private.h"
+#include "meta-cullable.h"

 struct _MetaWindowGroupClass
 {
@@ -27,7 +26,10 @@ struct _MetaWindowGroup
  MetaScreen *screen;
 };

-G_DEFINE_TYPE (MetaWindowGroup, meta_window_group, CLUTTER_TYPE_ACTOR);
+static void cullable_iface_init (MetaCullableInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MetaWindowGroup, meta_window_group, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));

 /* Help macros to scale from OpenGL <-1,1> coordinates system to
 * window coordinates ranging [0,window-size]. Borrowed from clutter-utils.c
@@ -87,6 +89,27 @@ painting_untransformed (MetaWindowGroup *window_group,
  return meta_actor_vertices_are_untransformed (vertices, width, height, x_origin, y_origin);
 }

+static void
+meta_window_group_cull_out (MetaCullable   *cullable,
+                            cairo_region_t *unobscured_region,
+                            cairo_region_t *clip_region)
+{
+  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
+}
+
+static void
+meta_window_group_reset_culling (MetaCullable *cullable)
+{
+  meta_cullable_reset_culling_children (cullable);
+}
+
+static void
+cullable_iface_init (MetaCullableInterface *iface)
+{
+  iface->cull_out = meta_window_group_cull_out;
+  iface->reset_culling = meta_window_group_reset_culling;
+}
+
 static void
 meta_window_group_paint (ClutterActor *actor)
 {
@@ -95,12 +118,11 @@ meta_window_group_paint (ClutterActor *actor)
  ClutterActorIter iter;
  ClutterActor *child;
  cairo_rectangle_int_t visible_rect, clip_rect;
+  int paint_x_offset, paint_y_offset;
  int paint_x_origin, paint_y_origin;
  int actor_x_origin, actor_y_origin;
-  int paint_x_offset, paint_y_offset;

  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
-  MetaCompScreen *info = meta_screen_get_compositor_data (window_group->screen);
  ClutterActor *stage = clutter_actor_get_stage (actor);

  /* Start off by treating all windows as completely unobscured, so damage anywhere
@@ -135,9 +157,6 @@ meta_window_group_paint (ClutterActor *actor)
      return;
    }

-  paint_x_offset = paint_x_origin - actor_x_origin;
-  paint_y_offset = paint_y_origin - actor_y_origin;
-
  visible_rect.x = visible_rect.y = 0;
  visible_rect.width = clutter_actor_get_width (CLUTTER_ACTOR (stage));
  visible_rect.height = clutter_actor_get_height (CLUTTER_ACTOR (stage));
@@ -155,9 +174,13 @@ meta_window_group_paint (ClutterActor *actor)

  clip_region = cairo_region_create_rectangle (&clip_rect);

+  paint_x_offset = paint_x_origin - actor_x_origin;
+  paint_y_offset = paint_y_origin - actor_y_origin;
+  cairo_region_translate (clip_region, -paint_x_offset, -paint_y_offset);
+
  if (!meta_is_wayland_compositor ())
    {
-      info = meta_screen_get_compositor_data (window_group->screen);
+      MetaCompScreen *info = meta_screen_get_compositor_data (window_group->screen);
      if (info->unredirected_window != NULL)
        {
          cairo_rectangle_int_t unredirected_rect;
@@ -169,124 +192,40 @@ meta_window_group_paint (ClutterActor *actor)
        }
    }

-  /* We walk the list from top to bottom (opposite of painting order),
-   * and subtract the opaque area of each window out of the visible
-   * region that we pass to the windows below.
-   */
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_prev (&iter, &child))
-    {
-      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
-        continue;
-
-      if (!meta_is_wayland_compositor () &&
-          info->unredirected_window != NULL &&
-          child == CLUTTER_ACTOR (info->unredirected_window))
-        continue;
-
-      /* If an actor has effects applied, then that can change the area
-       * it paints and the opacity, so we no longer can figure out what
-       * portion of the actor is obscured and what portion of the screen
-       * it obscures, so we skip the actor.
-       *
-       * This has a secondary beneficial effect: if a ClutterOffscreenEffect
-       * is applied to an actor, then our clipped redraws interfere with the
-       * caching of the FBO - even if we only need to draw a small portion
-       * of the window right now, ClutterOffscreenEffect may use other portions
-       * of the FBO later. So, skipping actors with effects applied also
-       * prevents these bugs.
-       *
-       * Theoretically, we should check clutter_actor_get_offscreen_redirect()
-       * as well for the same reason, but omitted for simplicity in the
-       * hopes that no-one will do that.
-       */
-      if (clutter_actor_has_effects (child))
-        continue;
-
-      if (META_IS_WINDOW_ACTOR (child))
-        {
-          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
-          int x, y;
-
-          if (!meta_actor_is_untransformed (CLUTTER_ACTOR (window_actor), &x, &y))
-            continue;
-
-          x += paint_x_offset;
-          y += paint_y_offset;
-
-
-          /* Temporarily move to the coordinate system of the actor */
-          cairo_region_translate (unobscured_region, - x, - y);
-          cairo_region_translate (clip_region, - x, - y);
-
-          meta_window_actor_set_unobscured_region (window_actor, unobscured_region);
-          meta_window_actor_set_clip_region (window_actor, clip_region);
-
-          if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
-            {
-              cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (window_actor);
-              if (obscured_region)
-                {
-                  cairo_region_subtract (unobscured_region, obscured_region);
-                  cairo_region_subtract (clip_region, obscured_region);
-                }
-            }
-
-          meta_window_actor_set_clip_region_beneath (window_actor, clip_region);
-
-          cairo_region_translate (unobscured_region, x, y);
-          cairo_region_translate (clip_region, x, y);
-        }
-      else if (META_IS_BACKGROUND_ACTOR (child) ||
-               META_IS_BACKGROUND_GROUP (child))
-        {
-          int x, y;
-
-          if (!meta_actor_is_untransformed (child, &x, &y))
-            continue;
-
-          x += paint_x_offset;
-          y += paint_y_offset;
-
-          cairo_region_translate (clip_region, - x, - y);
-
-          if (META_IS_BACKGROUND_GROUP (child))
-            meta_background_group_set_clip_region (META_BACKGROUND_GROUP (child), clip_region);
-          else
-            meta_background_actor_set_clip_region (META_BACKGROUND_ACTOR (child), clip_region);
-          cairo_region_translate (clip_region, x, y);
-        }
-    }
+  meta_cullable_cull_out (META_CULLABLE (window_group), unobscured_region, clip_region);

  cairo_region_destroy (unobscured_region);
  cairo_region_destroy (clip_region);

  CLUTTER_ACTOR_CLASS (meta_window_group_parent_class)->paint (actor);

-  /* Now that we are done painting, unset the visible regions (they will
-   * mess up painting clones of our actors)
-   */
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_next (&iter, &child))
-    {
-      if (META_IS_WINDOW_ACTOR (child))
-        {
-          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
-          meta_window_actor_reset_clip_regions (window_actor);
-        }
-      else if (META_IS_BACKGROUND_ACTOR (child))
-        {
-          MetaBackgroundActor *background_actor = META_BACKGROUND_ACTOR (child);
-          meta_background_actor_set_clip_region (background_actor, NULL);
-        }
-    }
+  meta_cullable_reset_culling (META_CULLABLE (window_group));
 }

+/* Adapted from clutter_actor_update_default_paint_volume() */
 static gboolean
-meta_window_group_get_paint_volume (ClutterActor       *actor,
+meta_window_group_get_paint_volume (ClutterActor       *self,
                                    ClutterPaintVolume *volume)
 {
-  return clutter_paint_volume_set_from_allocation (volume, actor);
+  ClutterActorIter iter;
+  ClutterActor *child;
+
+  clutter_actor_iter_init (&iter, self);
+  while (clutter_actor_iter_next (&iter, &child))
+    {
+      const ClutterPaintVolume *child_volume;
+
+      if (!CLUTTER_ACTOR_IS_MAPPED (child))
+        continue;
+
+      child_volume = clutter_actor_get_transformed_paint_volume (child, self);
+      if (child_volume == NULL)
+        return FALSE;
+
+      clutter_paint_volume_union (volume, child_volume);
+    }
+
+  return TRUE;
 }

 static void
--- a/src/compositor/meta-window-group.h
+++ b/src/compositor/meta-window-group.h
@@ -11,29 +11,9 @@
 * MetaWindowGroup:
 *
 * This class is a subclass of ClutterActor with special handling for
- * MetaWindowActor/MetaBackgroundActor/MetaBackgroundGroup when painting
- * children.
- *
- * When we are painting a stack of 5-10 maximized windows, the
- * standard bottom-to-top method of drawing every actor results in a
- * tremendous amount of overdraw and can easily max out the available
- * memory bandwidth on a low-end graphics chipset. It's even worse if
- * window textures are being accessed over the AGP bus.
- *
- * The basic technique applied here is to do a pre-pass before painting
- * where we walk window from top to bottom and compute the visible area
- * at each step by subtracting out the windows above it. The visible
- * area is passed to MetaWindowActor which uses it to clip the portion of
- * the window which drawn and avoid redrawing the shadow if it is completely
- * obscured.
- *
- * A caveat is that this is ineffective if applications are using ARGB
- * visuals, since we have no way of knowing whether a window obscures
- * the windows behind it or not. Alternate approaches using the depth
- * or stencil buffer rather than client side regions might be able to
- * handle alpha windows, but the combination of glAlphaFunc and stenciling
- * tends not to be efficient except on newer cards. (And on newer cards
- * we have lots of memory and bandwidth.)
+ * #MetaCullable when painting children. It uses code similar to
+ * meta_cullable_cull_out_children(), but also has additional special
+ * cases for the undirected window, and similar.
 */

 #define META_TYPE_WINDOW_GROUP            (meta_window_group_get_type ())
--- a/src/compositor/meta-window-shape.c
+++ b/src/compositor/meta-window-shape.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */
 #include <string.h>

--- a/src/compositor/meta-window-shape.h
+++ b/src/compositor/meta-window-shape.h
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_WINDOW_SHAPE_H__
--- a/src/compositor/plugins/default.c
+++ b/src/compositor/plugins/default.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/compositor/region-utils.c
+++ b/src/compositor/region-utils.c
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "region-utils.h"
--- a/src/compositor/region-utils.h
+++ b/src/compositor/region-utils.h
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef __META_REGION_UTILS_H__
--- a/src/core/above-tab-keycode.c
+++ b/src/core/above-tab-keycode.c
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /* The standard cycle-windows keybinding should be the key above the
--- a/src/core/bell.c
+++ b/src/core/bell.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /*
--- a/src/core/bell.h
+++ b/src/core/bell.h
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <X11/Xlib.h>
--- a/src/core/boxes-private.h
+++ b/src/core/boxes-private.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_BOXES_PRIVATE_H
--- a/src/core/boxes.c
+++ b/src/core/boxes.c
@@ -25,9 +25,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "boxes-private.h"
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/constraints.h
+++ b/src/core/constraints.h
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_CONSTRAINTS_H
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
@@ -283,8 +281,7 @@ meta_core_lower_beneath_grab_window (Display *xdisplay,
    return;

  changes.stack_mode = Below;
-  changes.sibling = grab_window->frame ? grab_window->frame->xwindow
-                                       : grab_window->xwindow;
+  changes.sibling = meta_window_get_toplevel_xwindow (grab_window);

  stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
  stack_window.x11.xwindow = xwindow;
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_CORE_H
--- a/src/core/delete.c
+++ b/src/core/delete.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #define _XOPEN_SOURCE /* for kill() */
@@ -43,14 +41,11 @@ static void meta_window_present_delete_dialog (MetaWindow *window,
                                               guint32     timestamp);

 static void
-delete_ping_reply_func (MetaDisplay *display,
-                        Window       xwindow,
+delete_ping_reply_func (MetaWindow  *window,
                        guint32      timestamp,
                        void        *user_data)
 {
-  meta_topic (META_DEBUG_PING,
-              "Got reply to delete ping for %s\n",
-              ((MetaWindow*)user_data)->desc);
+  meta_topic (META_DEBUG_PING, "Got reply to delete ping for %s\n", window->desc);

  /* we do nothing */
 }
@@ -68,12 +63,10 @@ dialog_exited (GPid pid, int status, gpointer user_data)
 }

 static void
-delete_ping_timeout_func (MetaDisplay *display,
-                          Window       xwindow,
+delete_ping_timeout_func (MetaWindow  *window,
                          guint32      timestamp,
                          void        *user_data)
 {
-  MetaWindow *window = user_data;
  char *window_title;
  gchar *window_content, *tmp;
  GPid dialog_pid;
@@ -137,12 +130,11 @@ void
 meta_window_check_alive (MetaWindow *window,
                         guint32     timestamp)
 {
-  meta_display_ping_window (window->display,
-                            window,
-                            timestamp,
-                            delete_ping_reply_func,
-                            delete_ping_timeout_func,
-                            window);
+  meta_window_ping (window,
+                    timestamp,
+                    delete_ping_reply_func,
+                    delete_ping_timeout_func,
+                    NULL);
 }

 void
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -19,9 +19,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_DISPLAY_PRIVATE_H
@@ -57,11 +55,6 @@ typedef struct _MetaWindowPropHooks MetaWindowPropHooks;

 typedef struct MetaEdgeResistanceData MetaEdgeResistanceData;

-typedef void (* MetaWindowPingFunc) (MetaDisplay *display,
-				     Window       xwindow,
-				     guint32      timestamp,
-				     gpointer     user_data);
-
 typedef enum {
  META_LIST_DEFAULT                   = 0,      /* normal windows */
  META_LIST_INCLUDE_OVERRIDE_REDIRECT = 1 << 0, /* normal and O-R */
@@ -150,6 +143,14 @@ struct _MetaDisplay
   */
  guint allow_terminal_deactivation : 1;

+  /* If true, server->focus_serial refers to us changing the focus; in
+   * this case, we can ignore focus events that have exactly focus_serial,
+   * since we take care to make another request immediately afterwards.
+   * But if focus is being changed by another client, we have to accept
+   * multiple events with the same serial.
+   */
+  guint focused_by_us : 1;
+
  guint static_gravity_works : 1;
  
  /*< private-ish >*/
@@ -182,7 +183,7 @@ struct _MetaDisplay
  guint32 window_sequence_counter;

  /* Pings which we're waiting for a reply from */
-  GSList     *pending_pings;
+  GHashTable *pending_pings;

  /* Pending focus change */
  guint       focus_timeout_id;
@@ -448,15 +449,6 @@ void meta_display_retheme_all (void);
 void meta_display_set_cursor_theme (const char *theme, 
 				    int         size);

-void meta_display_ping_window      (MetaDisplay        *display,
-                                    MetaWindow         *window,
-                                    guint32             timestamp,
-                                    MetaWindowPingFunc  ping_reply_func,
-                                    MetaWindowPingFunc  ping_timeout_func,
-                                    void               *user_data);
-gboolean meta_display_window_has_pending_pings (MetaDisplay        *display,
-						MetaWindow         *window);
-
 int meta_resize_gravity_from_grab_op (MetaGrabOp op);

 gboolean meta_grab_op_is_moving   (MetaGrabOp op);
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
@@ -83,41 +81,6 @@
         g == META_GRAB_OP_KEYBOARD_ESCAPING_DOCK   ||  \
         g == META_GRAB_OP_KEYBOARD_ESCAPING_GROUP)

-/*
- * SECTION:pings
- *
- * Sometimes we want to see whether a window is responding,
- * so we send it a "ping" message and see whether it sends us back a "pong"
- * message within a reasonable time. Here we have a system which lets us
- * nominate one function to be called if we get the pong in time and another
- * function if we don't. The system is rather more complicated than it needs
- * to be, since we only ever use it to destroy windows which are asked to
- * close themselves and don't do so within a reasonable amount of time, and
- * therefore we always use the same callbacks. It's possible that we might
- * use it for other things in future, or on the other hand we might decide
- * that we're never going to do so and simplify it a bit.
- */
-
-/**
- * MetaPingData:
- *
- * Describes a ping on a window. When we send a ping to a window, we build
- * one of these structs, and it eventually gets passed to the timeout function
- * or to the function which handles the response from the window. If the window
- * does or doesn't respond to the ping, we use this information to deal with
- * these facts; we have a handler function for each.
- */
-typedef struct 
-{
-  MetaDisplay *display;
-  Window       xwindow;
-  guint32      timestamp;
-  MetaWindowPingFunc ping_reply_func;
-  MetaWindowPingFunc ping_timeout_func;
-  void        *user_data;
-  guint        ping_timeout_id;
-} MetaPingData;
-
 G_DEFINE_TYPE(MetaDisplay, meta_display, G_TYPE_OBJECT);

 /* Signals */
@@ -172,8 +135,6 @@ static guint32 event_get_time           (MetaDisplay    *display,
                                         XEvent         *event);
 static void    process_request_frame_extents (MetaDisplay    *display,
                                              XEvent         *event);
-static void    process_pong_message     (MetaDisplay    *display,
-                                         XEvent         *event);
 static void    process_selection_request (MetaDisplay   *display,
                                          XEvent        *event);
 static void    process_selection_clear   (MetaDisplay   *display,
@@ -321,62 +282,6 @@ meta_display_class_init (MetaDisplayClass *klass)
                                                        G_PARAM_READABLE));
 }

-
-/**
- * ping_data_free:
- *
- * Destructor for #MetaPingData structs. Will destroy the
- * event source for the struct as well.
- */
-static void
-ping_data_free (MetaPingData *ping_data)
-{
-  /* Remove the timeout */
-  if (ping_data->ping_timeout_id != 0)
-    g_source_remove (ping_data->ping_timeout_id);
-
-  g_free (ping_data);
-}
-
-/**
- * remove_pending_pings_for_window:
- * @display: The display the window appears on
- * @xwindow: The X ID of the window whose pings we should remove
- *
- * Frees every pending ping structure for the given X window on the
- * given display. This means that we also destroy the timeouts.
- */
-static void
-remove_pending_pings_for_window (MetaDisplay *display, Window xwindow)
-{
-  GSList *tmp;
-  GSList *dead;
-
-  /* could obviously be more efficient, don't care */
-  
-  /* build list to be removed */
-  dead = NULL;
-  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
-    {
-      MetaPingData *ping_data = tmp->data;
-
-      if (ping_data->xwindow == xwindow)
-        dead = g_slist_prepend (dead, ping_data);
-    }
-
-  /* remove what we found */
-  for (tmp = dead; tmp; tmp = tmp->next)
-    {
-      MetaPingData *ping_data = tmp->data;
-
-      display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
-      ping_data_free (ping_data);
-    }
-
-  g_slist_free (dead);
-}
-
-
 #ifdef HAVE_STARTUP_NOTIFICATION
 static void
 sn_error_trap_push (SnDisplay *sn_display,
@@ -528,7 +433,6 @@ meta_display_open (void)
  the_display->server_grab_count = 0;
  the_display->display_opening = TRUE;

-  the_display->pending_pings = NULL;
  the_display->autoraise_timeout_id = 0;
  the_display->autoraise_window = NULL;
  the_display->focus_window = NULL;
@@ -600,6 +504,7 @@ meta_display_open (void)

  the_display->xids = g_hash_table_new (meta_unsigned_long_hash,
                                        meta_unsigned_long_equal);
+  the_display->pending_pings = g_hash_table_new (g_int_hash, g_int_equal);
  the_display->wayland_windows = g_hash_table_new (NULL, NULL);

  i = 0;
@@ -918,8 +823,6 @@ meta_display_open (void)

  enable_compositor (the_display);
   
-  meta_display_grab (the_display);
-  
  /* Now manage all existing windows */
  tmp = the_display->screens;
  while (tmp != NULL)
@@ -987,8 +890,6 @@ meta_display_open (void)

  meta_idle_monitor_init_dbus ();

-  meta_display_ungrab (the_display);
-
  /* Done opening new display */
  the_display->display_opening = FALSE;

@@ -1248,7 +1149,18 @@ meta_display_screen_for_x_screen (MetaDisplay *display,
  return NULL;
 }

-/* Grab/ungrab routines taken from fvwm */
+/* Grab/ungrab routines taken from fvwm.
+ * Calling this function will cause X to ignore all other clients until
+ * you ungrab. This may not be quite as bad as it sounds, yet there is
+ * agreement that avoiding server grabs except when they are clearly needed
+ * is a good thing.
+ *
+ * If you do use such grabs, please clearly explain the necessity for their
+ * usage in a comment. Try to keep their scope extremely limited. In
+ * particular, try to avoid emitting any signals or notifications while
+ * a grab is active (if the signal receiver tries to block on an X request
+ * from another client at this point, you will have a deadlock).
+ */
 void
 meta_display_grab (MetaDisplay *display)
 {
@@ -1696,7 +1608,7 @@ get_window_for_event (MetaDisplay        *display,
 {
  ClutterActor *source;

-  if (display->grab_window)
+  if (display->grab_op != META_GRAB_OP_NONE)
    return display->grab_window;

  source = clutter_event_get_source (event);
@@ -1763,11 +1675,13 @@ update_focus_window (MetaDisplay   *display,
                     MetaFocusType  type,
                     MetaWindow    *window,
                     Window         xwindow,
-                     gulong         serial)
+                     gulong         serial,
+                     gboolean       focused_by_us)
 {
  MetaWaylandCompositor *compositor;

  display->focus_serial = serial;
+  display->focused_by_us = focused_by_us;

  if (display->focus_xwindow == xwindow &&
      display->focus_type == type &&
@@ -1799,9 +1713,19 @@ update_focus_window (MetaDisplay   *display,

  if (display->focus_window)
    {
+      ClutterActor *window_actor;
+
      meta_topic (META_DEBUG_FOCUS, "* Focus --> %s with serial %lu\n",
                  display->focus_window->desc, serial);
      meta_window_set_focused_internal (display->focus_window, TRUE);
+
+      /* XXX -- this is sort of a layer violation, but because we
+       * rely on the compositor for event delivery anyway, I don't
+       * think it's too bad... */
+
+      window_actor = CLUTTER_ACTOR (display->focus_window->compositor_private);
+      if (window_actor)
+        clutter_actor_grab_key_focus (window_actor);
    }
  else
    meta_topic (META_DEBUG_FOCUS, "* Focus --> NULL with serial %lu\n", serial);
@@ -1894,7 +1818,8 @@ request_xserver_input_focus_change (MetaDisplay   *display,
                       type,
                       meta_window,
                       xwindow,
-                       serial);
+                       serial,
+                       TRUE);

  meta_error_trap_pop (display);

@@ -2023,16 +1948,37 @@ handle_window_focus_event (MetaDisplay  *display,
  else
    g_return_if_reached ();

-  if (display->server_focus_serial > display->focus_serial)
+  /* If display->focused_by_us, then the focus_serial will be used only
+   * for a focus change we made and have already accounted for.
+   * (See request_xserver_input_focus_change().) Otherwise, we can get
+   * multiple focus events with the same serial.
+   */
+  if (display->server_focus_serial > display->focus_serial ||
+      (!display->focused_by_us &&
+       display->server_focus_serial == display->focus_serial))
    {
      update_focus_window (display,
                           type,
                           focus_window,
                           focus_window ? focus_window->xwindow : None,
-                           display->server_focus_serial);
+                           display->server_focus_serial,
+                           FALSE);
    }
 }

+static gboolean
+window_has_xwindow (MetaWindow *window,
+                    Window      xwindow)
+{
+  if (window->xwindow == xwindow)
+    return TRUE;
+
+  if (window->frame && window->frame->xwindow == xwindow)
+    return TRUE;
+
+  return FALSE;
+}
+
 static gboolean
 meta_display_handle_event (MetaDisplay        *display,
                           const ClutterEvent *event)
@@ -2308,9 +2254,11 @@ handle_input_xevent (MetaDisplay *display,
                     XIEvent     *input_event,
                     gulong       serial)
 {
+  XIDeviceEvent *device_event = (XIDeviceEvent *) input_event;
  XIEnterEvent *enter_event = (XIEnterEvent *) input_event;
  Window modified;
  MetaWindow *window;
+  gboolean frame_was_receiver;

  if (input_event == NULL)
    return FALSE;
@@ -2318,8 +2266,242 @@ handle_input_xevent (MetaDisplay *display,
  modified = xievent_get_modified_window (display, input_event);
  window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;

+  frame_was_receiver = FALSE;
+  if (window &&
+      window->frame &&
+      modified == window->frame->xwindow)
+    {
+      /* Note that if the frame and the client both have an
+       * XGrabButton (as is normal with our setup), the event
+       * goes to the frame.
+       */
+      frame_was_receiver = TRUE;
+      meta_topic (META_DEBUG_EVENTS, "Frame was receiver of event for %s\n",
+                  window->desc);
+    }
+
+  if (window && !window->override_redirect &&
+      (input_event->evtype == XI_KeyPress || input_event->evtype == XI_ButtonPress))
+    {
+      if (CurrentTime == display->current_time)
+        {
+          /* We can't use missing (i.e. invalid) timestamps to set user time,
+           * nor do we want to use them to sanity check other timestamps.
+           * See bug 313490 for more details.
+           */
+          meta_warning ("Event has no timestamp! You may be using a broken "
+                        "program such as xse.  Please ask the authors of that "
+                        "program to fix it.\n");
+        }
+      else
+        {
+          meta_window_set_user_time (window, display->current_time);
+          sanity_check_timestamps (display, display->current_time);
+        }
+    }
+
  switch (input_event->evtype)
    {
+    case XI_ButtonPress:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
+      display->overlay_key_only_pressed = FALSE;
+
+      if (device_event->detail == 4 || device_event->detail == 5)
+        /* Scrollwheel event, do nothing and deliver event to compositor below */
+        break;
+
+      if ((window &&
+           meta_grab_op_is_mouse (display->grab_op) &&
+           (device_event->mods.effective & display->window_grab_modifiers) &&
+           display->grab_button != device_event->detail &&
+           display->grab_window == window) ||
+          grab_op_is_keyboard (display->grab_op))
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Ending grab op %u on window %s due to button press\n",
+                      display->grab_op,
+                      (display->grab_window ?
+                       display->grab_window->desc :
+                       "none"));
+          if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
+            {
+              MetaScreen *screen;
+              meta_topic (META_DEBUG_WINDOW_OPS,
+                          "Syncing to old stack positions.\n");
+              screen =
+                meta_display_screen_for_root (display, device_event->event);
+
+              if (screen!=NULL)
+                meta_stack_set_positions (screen->stack,
+                                          display->grab_old_window_stacking);
+            }
+          meta_display_end_grab_op (display,
+                                    device_event->time);
+        }
+      else if (window && display->grab_op == META_GRAB_OP_NONE)
+        {
+          gboolean begin_move = FALSE;
+          unsigned int grab_mask;
+          gboolean unmodified;
+
+          grab_mask = display->window_grab_modifiers;
+          if (g_getenv ("MUTTER_DEBUG_BUTTON_GRABS"))
+            grab_mask |= ControlMask;
+
+          /* Two possible sources of an unmodified event; one is a
+           * client that's letting button presses pass through to the
+           * frame, the other is our focus_window_grab on unmodified
+           * button 1.  So for all such events we focus the window.
+           */
+          unmodified = (device_event->mods.effective & grab_mask) == 0;
+
+          if (unmodified ||
+              device_event->detail == 1)
+            {
+              /* don't focus if frame received, will be lowered in
+               * frames.c or special-cased if the click was on a
+               * minimize/close button.
+               */
+              if (!frame_was_receiver)
+                {
+                  if (meta_prefs_get_raise_on_click ())
+                    meta_window_raise (window);
+                  else
+                    meta_topic (META_DEBUG_FOCUS,
+                                "Not raising window on click due to don't-raise-on-click option\n");
+
+                  /* Don't focus panels--they must explicitly request focus.
+                   * See bug 160470
+                   */
+                  if (window->type != META_WINDOW_DOCK)
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Focusing %s due to unmodified button %u press (display.c)\n",
+                                  window->desc, device_event->detail);
+                      meta_window_focus (window, device_event->time);
+                    }
+                  else
+                    /* However, do allow terminals to lose focus due to new
+                     * window mappings after the user clicks on a panel.
+                     */
+                    display->allow_terminal_deactivation = TRUE;
+                }
+
+              /* you can move on alt-click but not on
+               * the click-to-focus
+               */
+              if (!unmodified)
+                begin_move = TRUE;
+            }
+          else if (!unmodified && device_event->detail == meta_prefs_get_mouse_button_resize())
+            {
+              if (window->has_resize_func)
+                {
+                  gboolean north, south;
+                  gboolean west, east;
+                  MetaRectangle frame_rect;
+                  MetaGrabOp op;
+
+                  meta_window_get_frame_rect (window, &frame_rect);
+
+                  west = device_event->root_x <  (frame_rect.x + 1 * frame_rect.width  / 3);
+                  east = device_event->root_x >  (frame_rect.x + 2 * frame_rect.width  / 3);
+                  north = device_event->root_y < (frame_rect.y + 1 * frame_rect.height / 3);
+                  south = device_event->root_y > (frame_rect.y + 2 * frame_rect.height / 3);
+
+                  if (north && west)
+                    op = META_GRAB_OP_RESIZING_NW;
+                  else if (north && east)
+                    op = META_GRAB_OP_RESIZING_NE;
+                  else if (south && west)
+                    op = META_GRAB_OP_RESIZING_SW;
+                  else if (south && east)
+                    op = META_GRAB_OP_RESIZING_SE;
+                  else if (north)
+                    op = META_GRAB_OP_RESIZING_N;
+                  else if (west)
+                    op = META_GRAB_OP_RESIZING_W;
+                  else if (east)
+                    op = META_GRAB_OP_RESIZING_E;
+                  else if (south)
+                    op = META_GRAB_OP_RESIZING_S;
+                  else /* Middle region is no-op to avoid user triggering wrong action */
+                    op = META_GRAB_OP_NONE;
+
+                  if (op != META_GRAB_OP_NONE)
+                    meta_display_begin_grab_op (display,
+                                                window->screen,
+                                                window,
+                                                op,
+                                                TRUE,
+                                                FALSE,
+                                                device_event->detail,
+                                                0,
+                                                device_event->time,
+                                                device_event->root_x,
+                                                device_event->root_y);
+                }
+            }
+          else if (device_event->detail == meta_prefs_get_mouse_button_menu())
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_show_menu (window,
+                                     device_event->root_x,
+                                     device_event->root_y,
+                                     device_event->detail,
+                                     device_event->time);
+            }
+
+          if (!frame_was_receiver && unmodified)
+            {
+              /* This is from our synchronous grab since
+               * it has no modifiers and was on the client window
+               */
+
+              meta_verbose ("Allowing events time %u\n",
+                            (unsigned int)device_event->time);
+
+              XIAllowEvents (display->xdisplay, device_event->deviceid,
+                             XIReplayDevice, device_event->time);
+            }
+
+          if (begin_move && window->has_move_func)
+            {
+              meta_display_begin_grab_op (display,
+                                          window->screen,
+                                          window,
+                                          META_GRAB_OP_MOVING,
+                                          TRUE,
+                                          FALSE,
+                                          device_event->detail,
+                                          0,
+                                          device_event->time,
+                                          device_event->root_x,
+                                          device_event->root_y);
+            }
+        }
+      break;
+    case XI_ButtonRelease:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
+      display->overlay_key_only_pressed = FALSE;
+
+      if (display->grab_window == window &&
+          meta_grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_xevent (window, device_event);
+      break;
+    case XI_Motion:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
+      if (display->grab_window == window &&
+          meta_grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_xevent (window, device_event);
+      break;
    case XI_Enter:
      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
        break;
@@ -2629,14 +2811,14 @@ handle_other_xevent (MetaDisplay *display,
          && meta_display_screen_for_root (display, event->xmap.event))
        {
          window = meta_window_new (display, event->xmap.window,
-                                    FALSE);
+                                    FALSE, META_COMP_EFFECT_CREATE);
        }
      break;
    case MapRequest:
      if (window == NULL)
        {
          window = meta_window_new (display, event->xmaprequest.window,
-                                    FALSE);
+                                    FALSE, META_COMP_EFFECT_CREATE);
        }
      /* if frame was receiver it's some malicious send event or something */
      else if (!frame_was_receiver && window)
@@ -2887,7 +3069,13 @@ handle_other_xevent (MetaDisplay *display,

                  if ((Atom)event->xclient.data.l[0] == display->atom__NET_WM_PING)
                    {
-                      process_pong_message (display, event);
+                      guint32 timestamp = event->xclient.data.l[1];
+                      window = g_hash_table_lookup (display->pending_pings, &timestamp);
+
+                      if (window)
+                        meta_window_pong (window, timestamp);
+                      else
+                        meta_verbose ("Received invalid _NET_WM_PING for unknown timestamp %d\n", timestamp);

                      /* We don't want ping reply events going into
                       * the GTK+ event loop because gtk+ will treat
@@ -3013,9 +3201,10 @@ meta_display_handle_xevent (MetaDisplay *display,
  display->current_time = event_get_time (display, event);
  display->monitor_cache_invalidated = TRUE;

-  if (event->xany.serial > display->focus_serial &&
+  if (display->focused_by_us &&
+      event->xany.serial > display->focus_serial &&
      display->focus_window &&
-      display->focus_window->xwindow != display->server_focus_window)
+      !window_has_xwindow (display->focus_window, display->server_focus_window))
    {
      meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                  display->focus_window->desc);
@@ -3023,7 +3212,8 @@ meta_display_handle_xevent (MetaDisplay *display,
                           META_FOCUS_NONE,
                           meta_display_lookup_x_window (display, display->server_focus_window),
                           display->server_focus_window,
-                           display->server_focus_serial);
+                           display->server_focus_serial,
+                           FALSE);
    }

  screen = meta_display_screen_for_root (display, event->xany.window);
@@ -3794,9 +3984,6 @@ meta_display_unregister_x_window (MetaDisplay *display,
  g_return_if_fail (g_hash_table_lookup (display->xids, &xwindow) != NULL);

  g_hash_table_remove (display->xids, &xwindow);
-
-  /* Remove any pending pings */
-  remove_pending_pings_for_window (display, xwindow);
 }

 void
@@ -3938,6 +4125,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
 {
  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+  MetaCursor cursor = meta_cursor_for_grab_op (op);

  XISetMask (mask.mask, XI_ButtonPress);
  XISetMask (mask.mask, XI_ButtonRelease);
@@ -3952,7 +4140,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
                    META_VIRTUAL_CORE_POINTER_ID,
                    grab_xwindow,
                    timestamp,
-                    None,
+                    meta_display_create_x_cursor (display, cursor),
                    XIGrabModeAsync, XIGrabModeAsync,
                    False, /* owner_events */
                    &mask) == Success)
@@ -3971,7 +4159,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,

  meta_error_trap_pop (display);

-  meta_cursor_tracker_set_grab_cursor (screen->cursor_tracker, meta_cursor_for_grab_op (op));
+  meta_cursor_tracker_set_grab_cursor (screen->cursor_tracker, cursor);
 }

 gboolean
@@ -4034,7 +4222,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
   *   key grab on the RootWindow.
   */
  if (grab_window)
-    grab_xwindow = grab_window->frame ? grab_window->frame->xwindow : grab_window->xwindow;
+    grab_xwindow = meta_window_get_toplevel_xwindow (grab_window);
  else
    grab_xwindow = screen->xroot;

@@ -4644,120 +4832,6 @@ meta_set_syncing (gboolean setting)
    }
 }

-/*
- * How long, in milliseconds, we should wait after pinging a window
- * before deciding it's not going to get back to us.
- */
-#define PING_TIMEOUT_DELAY 5000
-
-/**
- * meta_display_ping_timeout:
- * @data: All the information about this ping. It is a #MetaPingData
- *        cast to a #gpointer in order to be passable to a timeout function.
- *        This function will also free this parameter.
- *
- * Does whatever it is we decided to do when a window didn't respond
- * to a ping. We also remove the ping from the display's list of
- * pending pings. This function is called by the event loop when the timeout
- * times out which we created at the start of the ping.
- *
- * Returns: Always returns %FALSE, because this function is called as a
- *          timeout and we don't want to run the timer again.
- */
-static gboolean
-meta_display_ping_timeout (gpointer data)
-{
-  MetaPingData *ping_data;
-
-  ping_data = data;
-
-  ping_data->ping_timeout_id = 0;
-
-  meta_topic (META_DEBUG_PING,
-              "Ping %u on window %lx timed out\n",
-              ping_data->timestamp, ping_data->xwindow);
-  
-  (* ping_data->ping_timeout_func) (ping_data->display, ping_data->xwindow,
-                                    ping_data->timestamp, ping_data->user_data);
-
-  ping_data->display->pending_pings =
-    g_slist_remove (ping_data->display->pending_pings,
-                    ping_data);
-  ping_data_free (ping_data);
-  
-  return FALSE;
-}
-
-/**
- * meta_display_ping_window:
- * @display: The #MetaDisplay that the window is on
- * @window: The #MetaWindow to send the ping to
- * @timestamp: The timestamp of the ping. Used for uniqueness.
- *             Cannot be CurrentTime; use a real timestamp!
- * @ping_reply_func: The callback to call if we get a response.
- * @ping_timeout_func: The callback to call if we don't get a response.
- * @user_data: Arbitrary data that will be passed to the callback
- *             function. (In practice it's often a pointer to
- *             the window.)
- *
- * Sends a ping request to a window. The window must respond to
- * the request within a certain amount of time. If it does, we
- * will call one callback; if the time passes and we haven't had
- * a response, we call a different callback. The window must have
- * the hint showing that it can respond to a ping; if it doesn't,
- * we call the "got a response" callback immediately and return.
- * This function returns straight away after setting things up;
- * the callbacks will be called from the event loop.
- *
- * FIXME: This should probably be a method on windows, rather than displays
- *        for one of their windows.
- *
- */
-void
-meta_display_ping_window (MetaDisplay       *display,
-			  MetaWindow        *window,
-			  guint32            timestamp,
-			  MetaWindowPingFunc ping_reply_func,
-			  MetaWindowPingFunc ping_timeout_func,
-			  gpointer           user_data)
-{
-  MetaPingData *ping_data;
-
-  if (timestamp == CurrentTime)
-    {
-      meta_warning ("Tried to ping a window with CurrentTime! Not allowed.\n");
-      return;
-    }
-
-  if (!window->net_wm_ping)
-    {
-      if (ping_reply_func)
-        (* ping_reply_func) (display, window->xwindow, timestamp, user_data);
-
-      return;
-    }
-  
-  ping_data = g_new (MetaPingData, 1);
-  ping_data->display = display;
-  ping_data->xwindow = window->xwindow;
-  ping_data->timestamp = timestamp;
-  ping_data->ping_reply_func = ping_reply_func;
-  ping_data->ping_timeout_func = ping_timeout_func;
-  ping_data->user_data = user_data;
-  ping_data->ping_timeout_id = g_timeout_add (PING_TIMEOUT_DELAY,
-					      meta_display_ping_timeout,
-					      ping_data);
-  
-  display->pending_pings = g_slist_prepend (display->pending_pings, ping_data);
-
-  meta_topic (META_DEBUG_PING,
-              "Sending ping with timestamp %u to window %s\n",
-              timestamp, window->desc);
-  meta_window_send_icccm_message (window,
-                                  display->atom__NET_WM_PING,
-                                  timestamp);
-}
-
 static void
 process_request_frame_extents (MetaDisplay    *display,
                               XEvent         *event)
@@ -4818,91 +4892,6 @@ process_request_frame_extents (MetaDisplay    *display,
  meta_XFree (hints);
 }

-/**
- * process_pong_message:
- * @display: the display we got the pong from
- * @event: the #XEvent which is a pong; we can tell which
- *         ping it corresponds to because it bears the
- *         same timestamp.
- *
- * Process the pong (the response message) from the ping we sent
- * to the window. This involves removing the timeout, calling the
- * reply handler function, and freeing memory.
- */
-static void
-process_pong_message (MetaDisplay    *display,
-                      XEvent         *event)
-{
-  GSList *tmp;
-  guint32 timestamp = event->xclient.data.l[1];
-
-  meta_topic (META_DEBUG_PING, "Received a pong with timestamp %u\n",
-              timestamp);
-  
-  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
-    {
-      MetaPingData *ping_data = tmp->data;
-			  
-      if (timestamp == ping_data->timestamp)
-        {
-          meta_topic (META_DEBUG_PING,
-                      "Matching ping found for pong %u\n", 
-                      ping_data->timestamp);
-
-          /* Remove the ping data from the list */
-          display->pending_pings = g_slist_remove (display->pending_pings,
-                                                   ping_data);
-
-          /* Remove the timeout */
-          if (ping_data->ping_timeout_id != 0)
-            {
-              g_source_remove (ping_data->ping_timeout_id);
-              ping_data->ping_timeout_id = 0;
-            }
-          
-          /* Call callback */
-          (* ping_data->ping_reply_func) (display, 
-                                          ping_data->xwindow,
-                                          ping_data->timestamp, 
-                                          ping_data->user_data);
-			      
-          ping_data_free (ping_data);
-
-          break;
-        }
-    }
-}
-
-/**
- * meta_display_window_has_pending_pings:
- * @display: The #MetaDisplay of the window.
- * @window: The #MetaWindow whose pings we want to know about.
- *
- * Finds whether a window has any pings waiting on it.
- *
- * FIXME: This should probably be a method on windows, rather than displays
- *        for one of their windows.
- *
- * Returns: %TRUE if there is at least one ping which has been sent
- *          to the window without getting a response; %FALSE otherwise.
- */
-gboolean
-meta_display_window_has_pending_pings (MetaDisplay *display,
-				       MetaWindow  *window)
-{
-  GSList *tmp;
-
-  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
-    {
-      MetaPingData *ping_data = tmp->data;
-
-      if (ping_data->xwindow == window->xwindow) 
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
 MetaGroup*
 get_focussed_group (MetaDisplay *display)
 {
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/edge-resistance.h
+++ b/src/core/edge-resistance.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_EDGE_RESISTANCE_H
--- a/src/core/errors.c
+++ b/src/core/errors.c
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/core/frame.c
+++ b/src/core/frame.c
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
@@ -52,9 +50,6 @@ meta_window_ensure_frame (MetaWindow *window)
  if (window->frame)
    return;
  
-  /* See comment below for why this is required. */
-  meta_display_grab (window->display);
-  
  frame = g_new (MetaFrame, 1);

  frame->window = window;
@@ -120,14 +115,6 @@ meta_window_ensure_frame (MetaWindow *window)
  
  meta_display_register_x_window (window->display, &frame->xwindow, window);

-  /* Reparent the client window; it may be destroyed,
-   * thus the error trap. We'll get a destroy notify later
-   * and free everything. Comment in FVWM source code says
-   * we need a server grab or the child can get its MapNotify
-   * before we've finished reparenting and getting the decoration
-   * window onscreen, so ensure_frame must be called with
-   * a grab.
-   */
  meta_error_trap_push (window->display);
  if (window->mapped)
    {
@@ -170,8 +157,6 @@ meta_window_ensure_frame (MetaWindow *window)

  /* Move keybindings to frame instead of window */
  meta_window_grab_keys (window);
-
-  meta_display_ungrab (window->display);
 }

 void
--- a/src/core/frame.h
+++ b/src/core/frame.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_FRAME_PRIVATE_H
--- a/src/core/group-private.h
+++ b/src/core/group-private.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_GROUP_PRIVATE_H
--- a/src/core/group-props.c
+++ b/src/core/group-props.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/group-props.h
+++ b/src/core/group-props.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_GROUP_PROPS_H
--- a/src/core/group.c
+++ b/src/core/group.c
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/core/iconcache.c
+++ b/src/core/iconcache.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/iconcache.h
+++ b/src/core/iconcache.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_ICON_CACHE_H
--- a/src/core/keybindings-private.h
+++ b/src/core/keybindings-private.h
@@ -21,9 +21,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_KEYBINDINGS_PRIVATE_H
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
@@ -41,6 +39,7 @@
 #include "ui.h"
 #include "frame.h"
 #include "place.h"
+#include "screen-private.h"
 #include <meta/prefs.h>
 #include "util-private.h"

@@ -55,6 +54,9 @@

 #ifdef HAVE_WAYLAND
 #include "meta-wayland-private.h"
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/vt.h>
 #endif

 #define SCHEMA_COMMON_KEYBINDINGS "org.gnome.desktop.wm.keybindings"
@@ -1277,7 +1279,7 @@ meta_window_grab_keys (MetaWindow  *window)
    }

  meta_window_change_keygrabs (window,
-                               window->frame ? window->frame->xwindow : window->xwindow,
+                               meta_window_get_toplevel_xwindow (window),
                               TRUE);

  window->keys_grabbed = TRUE;
@@ -1584,7 +1586,7 @@ meta_window_grab_all_keys (MetaWindow  *window,
              window->desc);
  meta_window_focus (window, timestamp);

-  grabwindow = window->frame ? window->frame->xwindow : window->xwindow;
+  grabwindow = meta_window_get_toplevel_xwindow (window);

  meta_topic (META_DEBUG_KEYBINDINGS,
              "Grabbing all keys on window %s\n", window->desc);
@@ -1862,7 +1864,7 @@ process_event (MetaKeyBinding       *bindings,
      MetaKeyHandler *handler = bindings[i].handler;

      if ((!on_window && handler->flags & META_KEY_BINDING_PER_WINDOW) ||
-          bindings[i].keycode != event->keyval ||
+          (event->keyval != bindings[i].keysym) ||
          (event->modifier_state != bindings[i].mask) ||
          meta_compositor_filter_keybinding (display->compositor, screen, &bindings[i]))
        continue;
@@ -2001,7 +2003,7 @@ process_iso_next_group (MetaDisplay *display,
  gboolean activate;
  int i;

-  if (event->type != CLUTTER_KEY_RELEASE)
+  if (event->type == CLUTTER_KEY_RELEASE)
    return FALSE;

  activate = FALSE;
@@ -3929,6 +3931,26 @@ handle_move_to_workspace  (MetaDisplay     *display,
    }
 }

+static void
+handle_move_to_monitor (MetaDisplay    *display,
+                        MetaScreen     *screen,
+                        MetaWindow     *window,
+		        ClutterKeyEvent *event,
+                        MetaKeyBinding *binding,
+                        gpointer        dummy)
+{
+  gint which = binding->handler->data;
+  const MetaMonitorInfo *current, *new;
+
+  current = meta_screen_get_monitor_for_window (screen, window);
+  new = meta_screen_get_monitor_neighbor (screen, current->number, which);
+
+  if (new == NULL)
+    return;
+
+  meta_window_move_to_monitor (window, new->number);
+}
+
 static void
 handle_raise_or_lower (MetaDisplay     *display,
                       MetaScreen      *screen,
@@ -4062,6 +4084,18 @@ handle_set_spew_mark (MetaDisplay     *display,
 }

 #ifdef HAVE_WAYLAND
+static gboolean
+activate_vt (int vt)
+{
+  int tty, reply;
+
+  tty = open ("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
+  reply = ioctl (tty, VT_ACTIVATE, vt);
+  close (tty);
+
+  return (reply == 0);
+}
+
 static void
 handle_switch_vt (MetaDisplay     *display,
                  MetaScreen      *screen,
@@ -4070,28 +4104,10 @@ handle_switch_vt (MetaDisplay     *display,
                  MetaKeyBinding  *binding,
                  gpointer         dummy)
 {
-    gint vt = binding->handler->data;
-    MetaWaylandCompositor *compositor;
-    MetaLauncher *launcher;
+  gint vt = binding->handler->data;

-    compositor = meta_wayland_compositor_get_default ();
-    launcher = meta_wayland_compositor_get_launcher (compositor);
-
-    if (launcher)
-      {
-        GError *error;
-
-        error = NULL;
-        if (!meta_launcher_activate_vt (launcher, vt, &error))
-          {
-            g_warning ("Failed to switch VT: %s", error->message);
-            g_error_free (error);
-          }
-      }
-    else
-      {
-        g_debug ("Ignoring VT switch keybinding, not running as VT manager");
-      }
+  if (!activate_vt (vt))
+    g_warning ("Failed to switch VT");
 }
 #endif

@@ -4670,6 +4686,34 @@ init_builtin_key_bindings (MetaDisplay *display)
                          META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_DOWN,
                          handle_move_to_workspace, META_MOTION_DOWN);

+  add_builtin_keybinding (display,
+                          "move-to-monitor-left",
+                          common_keybindings,
+                          META_KEY_BINDING_PER_WINDOW,
+                          META_KEYBINDING_ACTION_MOVE_TO_MONITOR_LEFT,
+                          handle_move_to_monitor, META_SCREEN_LEFT);
+
+  add_builtin_keybinding (display,
+                          "move-to-monitor-right",
+                          common_keybindings,
+                          META_KEY_BINDING_PER_WINDOW,
+                          META_KEYBINDING_ACTION_MOVE_TO_MONITOR_RIGHT,
+                          handle_move_to_monitor, META_SCREEN_RIGHT);
+
+  add_builtin_keybinding (display,
+                          "move-to-monitor-down",
+                          common_keybindings,
+                          META_KEY_BINDING_PER_WINDOW,
+                          META_KEYBINDING_ACTION_MOVE_TO_MONITOR_DOWN,
+                          handle_move_to_monitor, META_SCREEN_DOWN);
+
+  add_builtin_keybinding (display,
+                          "move-to-monitor-up",
+                          common_keybindings,
+                          META_KEY_BINDING_PER_WINDOW,
+                          META_KEYBINDING_ACTION_MOVE_TO_MONITOR_UP,
+                          handle_move_to_monitor, META_SCREEN_UP);
+
  add_builtin_keybinding (display,
                          "raise-or-lower",
                          common_keybindings,
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/core/meta-cursor-tracker-private.h
+++ b/src/core/meta-cursor-tracker-private.h
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Giovanni Campagna <gcampagn@redhat.com>
 */
--- a/src/core/meta-cursor-tracker.c
+++ b/src/core/meta-cursor-tracker.c
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Giovanni Campagna <gcampagn@redhat.com>
 */
@@ -124,6 +122,7 @@ static guint signals[LAST_SIGNAL];
 static void meta_cursor_tracker_set_crtc_has_hw_cursor (MetaCursorTracker *tracker,
                                                        MetaCRTC          *crtc,
                                                        gboolean           has_hw_cursor);
+static void sync_cursor (MetaCursorTracker *tracker);

 static MetaCursorReference *
 meta_cursor_reference_ref (MetaCursorReference *self)
@@ -306,7 +305,6 @@ meta_cursor_reference_from_theme (MetaCursorTracker  *tracker,
  self->texture = cogl_texture_2d_new_from_data (cogl_context,
                                                 width, height,
                                                 cogl_format,
-                                                 COGL_PIXEL_FORMAT_ANY,
                                                 rowstride,
                                                 (uint8_t*)image->pixels,
                                                 NULL);
@@ -366,7 +364,7 @@ meta_cursor_reference_from_buffer (MetaCursorTracker  *tracker,
  ClutterBackend *backend;
  CoglContext *cogl_context;
  MetaCursorReference *self;
-  CoglPixelFormat cogl_format, cogl_internal_format;
+  CoglPixelFormat cogl_format;
  struct wl_shm_buffer *shm_buffer;
  uint32_t gbm_format;

@@ -390,37 +388,31 @@ meta_cursor_reference_from_buffer (MetaCursorTracker  *tracker,
 #if G_BYTE_ORDER == G_BIG_ENDIAN
          case WL_SHM_FORMAT_ARGB8888:
            cogl_format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
-            cogl_internal_format = COGL_PIXEL_FORMAT_ANY;
            gbm_format = GBM_FORMAT_ARGB8888;
            break;
          case WL_SHM_FORMAT_XRGB8888:
            cogl_format = COGL_PIXEL_FORMAT_ARGB_8888;
-            cogl_internal_format = COGL_PIXEL_FORMAT_RGB_888;
            gbm_format = GBM_FORMAT_XRGB8888;
            break;
 #else
          case WL_SHM_FORMAT_ARGB8888:
            cogl_format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
-            cogl_internal_format = COGL_PIXEL_FORMAT_ANY;
            gbm_format = GBM_FORMAT_ARGB8888;
            break;
          case WL_SHM_FORMAT_XRGB8888:
            cogl_format = COGL_PIXEL_FORMAT_BGRA_8888;
-            cogl_internal_format = COGL_PIXEL_FORMAT_BGR_888;
            gbm_format = GBM_FORMAT_XRGB8888;
            break;
 #endif
          default:
            g_warn_if_reached ();
            cogl_format = COGL_PIXEL_FORMAT_ARGB_8888;
-            cogl_internal_format = COGL_PIXEL_FORMAT_ANY;
            gbm_format = GBM_FORMAT_ARGB8888;
        }

      self->texture = cogl_texture_2d_new_from_data (cogl_context,
                                                     width, height,
                                                     cogl_format,
-                                                     cogl_internal_format,
                                                     rowstride,
                                                     wl_shm_buffer_get_data (shm_buffer),
                                                     NULL);
@@ -476,47 +468,10 @@ meta_cursor_reference_from_buffer (MetaCursorTracker  *tracker,

      if (tracker->gbm)
        {
-          cogl_format = cogl_texture_get_format (COGL_TEXTURE (self->texture));
-          switch (cogl_format)
-            {
-#if G_BYTE_ORDER == G_LITTLE_ENDIAN
-            case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
-            case COGL_PIXEL_FORMAT_ARGB_8888:
-              gbm_format = GBM_FORMAT_BGRA8888;
-              break;
-            case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
-            case COGL_PIXEL_FORMAT_BGRA_8888:
-              break;
-            case COGL_PIXEL_FORMAT_RGB_888:
-              break;
-#else
-            case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
-            case COGL_PIXEL_FORMAT_ARGB_8888:
-              gbm_format = GBM_FORMAT_ARGB8888;
-              break;
-            case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
-            case COGL_PIXEL_FORMAT_BGRA_8888:
-              gbm_format = GBM_FORMAT_BGRA8888;
-              break;
-            case COGL_PIXEL_FORMAT_RGB_888:
-              gbm_format = GBM_FORMAT_RGB888;
-              break;
-#endif
-            default:
-              meta_warning ("Unknown cogl format %d\n", cogl_format);
-              return self;
-            }
-
-          if (gbm_device_is_format_supported (tracker->gbm, gbm_format,
-                                              GBM_BO_USE_CURSOR_64X64))
-            {
-              self->bo = gbm_bo_import (tracker->gbm, GBM_BO_IMPORT_WL_BUFFER,
-                                        buffer, GBM_BO_USE_CURSOR_64X64);
-              if (!self->bo)
-                meta_warning ("Importing HW cursor from wl_buffer failed\n");
-            }
-          else
-            meta_warning ("HW cursor for format %d not supported\n", gbm_format);
+          self->bo = gbm_bo_import (tracker->gbm, GBM_BO_IMPORT_WL_BUFFER,
+                                    buffer, GBM_BO_USE_CURSOR_64X64);
+          if (!self->bo)
+            meta_warning ("Importing HW cursor from wl_buffer failed\n");
        }
     }

@@ -615,9 +570,12 @@ make_wayland_cursor_tracker (MetaScreen *screen)
  compositor = meta_wayland_compositor_get_default ();
  compositor->seat->cursor_tracker = self;

-  self->drm_fd = compositor->drm_fd;
-  if (self->drm_fd >= 0)
-    self->gbm = gbm_create_device (compositor->drm_fd);
+  if (meta_wayland_compositor_is_native (compositor))
+    {
+      CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (ctx));
+      self->drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
+      self->gbm = gbm_create_device (self->drm_fd);
+    }

  monitors = meta_monitor_manager_get ();
  g_signal_connect_object (monitors, "monitors-changed",
@@ -675,6 +633,7 @@ set_window_cursor (MetaCursorTracker   *tracker,
  if (cursor)
    tracker->window_cursor = meta_cursor_reference_ref (cursor);
  tracker->has_window_cursor = has_cursor;
+  sync_cursor (tracker);
 }

 gboolean
@@ -694,7 +653,6 @@ meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
    return FALSE;

  set_window_cursor (tracker, FALSE, NULL);
-  g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);

  return TRUE;
 }
@@ -746,7 +704,6 @@ ensure_xfixes_cursor (MetaCursorTracker *tracker)
                                          cursor_image->width,
                                          cursor_image->height,
                                          CLUTTER_CAIRO_FORMAT_ARGB32,
-                                          COGL_PIXEL_FORMAT_ANY,
                                          cursor_image->width * 4, /* stride */
                                          cursor_data,
                                          NULL);
@@ -839,6 +796,7 @@ meta_cursor_tracker_set_grab_cursor (MetaCursorTracker *tracker,
  g_clear_pointer (&tracker->grab_cursor, meta_cursor_reference_unref);
  if (cursor != META_CURSOR_DEFAULT)
    tracker->grab_cursor = ensure_wayland_cursor (tracker, cursor);
+  sync_cursor (tracker);
 }

 void
@@ -882,6 +840,7 @@ meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
    {
      g_clear_pointer (&tracker->root_cursor, meta_cursor_reference_unref);
      tracker->root_cursor = ensure_wayland_cursor (tracker, cursor);
+      sync_cursor (tracker);
    }
 }

@@ -966,12 +925,15 @@ sync_displayed_cursor (MetaCursorTracker *tracker)
  if (displayed_cursor)
    tracker->displayed_cursor = meta_cursor_reference_ref (displayed_cursor);

-  if (displayed_cursor)
-    cogl_pipeline_set_layer_texture (tracker->pipeline, 0, COGL_TEXTURE (displayed_cursor->texture));
-  else
-    cogl_pipeline_set_layer_texture (tracker->pipeline, 0, NULL);
+  if (meta_is_wayland_compositor ())
+    {
+      if (displayed_cursor)
+        cogl_pipeline_set_layer_texture (tracker->pipeline, 0, COGL_TEXTURE (displayed_cursor->texture));
+      else
+        cogl_pipeline_set_layer_texture (tracker->pipeline, 0, NULL);

-  update_hw_cursor (tracker);
+      update_hw_cursor (tracker);
+    }

  g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);
 }
@@ -1030,10 +992,13 @@ sync_cursor (MetaCursorTracker *tracker)
      tracker->current_rect.height = 0;
    }

-  if (tracker->has_hw_cursor)
-    move_hw_cursor (tracker);
-  else
-    meta_cursor_tracker_queue_redraw (tracker);
+  if (meta_is_wayland_compositor ())
+    {
+      if (tracker->has_hw_cursor)
+        move_hw_cursor (tracker);
+      else
+        meta_cursor_tracker_queue_redraw (tracker);
+    }
 }

 void
--- a/src/core/meta-idle-monitor-private.h
+++ b/src/core/meta-idle-monitor-private.h
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
 *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
--- a/src/core/meta-idle-monitor.c
+++ b/src/core/meta-idle-monitor.c
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
 *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
@@ -949,6 +947,8 @@ on_bus_acquired (GDBusConnection *connection,
  for (iter = devices; iter; iter = iter->next)
    on_device_added (device_manager, iter->data, manager);

+  g_slist_free (devices);
+
  g_signal_connect_object (device_manager, "device-added",
                           G_CALLBACK (on_device_added), manager, 0);
  g_signal_connect_object (device_manager, "device-removed",
--- a/src/core/meta-xrandr-shared.h
+++ b/src/core/meta-xrandr-shared.h
@@ -13,9 +13,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /* This file is shared between mutter (src/core/meta-xrandr-shared.h)
--- a/src/core/monitor-config.c
+++ b/src/core/monitor-config.c
@@ -20,9 +20,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /*
--- a/src/core/monitor-private.h
+++ b/src/core/monitor-private.h
@@ -29,9 +29,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_MONITOR_PRIVATE_H
--- a/src/core/monitor-xrandr.c
+++ b/src/core/monitor-xrandr.c
@@ -20,9 +20,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "config.h"
@@ -453,8 +451,10 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
      XRRFreeCrtcInfo (crtc);
    }

+  meta_error_trap_push (meta_get_display ());
  primary_output = XRRGetOutputPrimary (manager_xrandr->xdisplay,
 					DefaultRootWindow (manager_xrandr->xdisplay));
+  meta_error_trap_pop (meta_get_display ());

  n_actual_outputs = 0;
  for (i = 0; i < (unsigned)resources->noutput; i++)
@@ -691,10 +691,11 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
 						 unsigned int         n_outputs)
 {
  MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
+  MetaDisplay *display = meta_get_display ();
  unsigned i;
  int width, height, width_mm, height_mm;

-  meta_display_grab (meta_get_display ());
+  meta_display_grab (display);

  /* First compute the new size of the screen (framebuffer) */
  width = 0; height = 0;
@@ -788,10 +789,10 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
   */
  width_mm = (width / DPI_FALLBACK) * 25.4 + 0.5;
  height_mm = (height / DPI_FALLBACK) * 25.4 + 0.5;
-  meta_error_trap_push (meta_get_display ());
+  meta_error_trap_push (display);
  XRRSetScreenSize (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
                    width, height, width_mm, height_mm);
-  meta_error_trap_pop (meta_get_display ());
+  meta_error_trap_pop (display);

  for (i = 0; i < n_crtcs; i++)
    {
@@ -848,7 +849,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
              goto next;
            }

-          meta_error_trap_push (meta_get_display ());
+          meta_error_trap_push (display);
          ok = XRRSetCrtcConfig (manager_xrandr->xdisplay,
                                 manager_xrandr->resources,
                                 (XID)crtc->crtc_id,
@@ -857,7 +858,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
                                 (XID)mode->mode_id,
                                 wl_transform_to_xrandr (crtc_info->transform),
                                 outputs, n_outputs);
-          meta_error_trap_pop (meta_get_display ());
+          meta_error_trap_pop (display);

          if (ok != Success)
            {
@@ -898,9 +899,11 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,

      if (output_info->is_primary)
        {
+          meta_error_trap_push (display);
          XRRSetOutputPrimary (manager_xrandr->xdisplay,
                               DefaultRootWindow (manager_xrandr->xdisplay),
                               (XID)output_info->output->output_id);
+          meta_error_trap_pop (display);
        }

      output_set_presentation_xrandr (manager_xrandr,
@@ -926,7 +929,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
      output->is_primary = FALSE;
    }

-  meta_display_ungrab (meta_get_display ());
+  meta_display_ungrab (display);
 }

 static void
--- a/src/core/monitor.c
+++ b/src/core/monitor.c
@@ -20,9 +20,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "config.h"
@@ -614,46 +612,60 @@ static char *
 make_display_name (MetaMonitorManager *manager,
                   MetaOutput         *output)
 {
+  char *inches = NULL;
+  char *vendor_name = NULL;
+  char *ret;
+
  if (g_str_has_prefix (output->name, "LVDS") ||
      g_str_has_prefix (output->name, "eDP"))
-    return g_strdup (_("Built-in display"));
+    {
+      ret = g_strdup (_("Built-in display"));
+      goto out;
+    }

-  if (output->width_mm != -1 && output->height_mm != -1)
+  if (output->width_mm > 0 && output->height_mm > 0)
    {
      double d = sqrt (output->width_mm * output->width_mm +
                       output->height_mm * output->height_mm);
-      char *inches = diagonal_to_str (d / 25.4);
-      char *vendor_name;
-      char *ret;
+      inches = diagonal_to_str (d / 25.4);
+    }

-      if (g_strcmp0 (output->vendor, "unknown") != 0)
-        {
-          if (!manager->pnp_ids)
-            manager->pnp_ids = gnome_pnp_ids_new ();
+  if (g_strcmp0 (output->vendor, "unknown") != 0)
+    {
+      if (!manager->pnp_ids)
+        manager->pnp_ids = gnome_pnp_ids_new ();

-          vendor_name = gnome_pnp_ids_get_pnp_id (manager->pnp_ids,
-                                                  output->vendor);
+      vendor_name = gnome_pnp_ids_get_pnp_id (manager->pnp_ids,
+                                              output->vendor);

-          ret = g_strdup_printf ("%s %s", vendor_name, inches);
-
-          g_free (vendor_name);
-        }
-      else
-        {
-          /* TRANSLATORS: this is a monitor name (in case we don't know
-             the vendor), it's Unknown followed by a size in inches,
-             like 'Unknown 15"'
-          */
-          ret = g_strdup_printf (_("Unknown %s"), inches);
-        }
-
-      g_free (inches);
-      return ret;
+      if (!vendor_name)
+        vendor_name = g_strdup (output->vendor);
    }
  else
    {
-      return g_strdup (output->vendor);
+      if (inches != NULL)
+        vendor_name = g_strdup (_("Unknown"));
+      else
+        vendor_name = g_strdup (_("Unknown Display"));
    }
+
+  if (inches != NULL)
+    {
+      /* TRANSLATORS: this is a monitor vendor name, followed by a
+       * size in inches, like 'Dell 15"'
+       */
+      ret = g_strdup_printf (_("%s %s"), vendor_name, inches);
+    }
+  else
+    {
+      ret = g_strdup (vendor_name);
+    }
+
+ out:
+  g_free (inches);
+  g_free (vendor_name);
+
+  return ret;
 }

 static gboolean
--- a/src/core/mutter.c
+++ b/src/core/mutter.c
@@ -14,9 +14,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "config.h"
--- a/src/core/place.c
+++ b/src/core/place.c
@@ -19,9 +19,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/place.h
+++ b/src/core/place.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_PLACE_H
--- a/src/core/prefs.c
+++ b/src/core/prefs.c
@@ -17,9 +17,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -25,9 +25,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_SCREEN_PRIVATE_H
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -19,9 +19,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
@@ -880,83 +878,31 @@ meta_screen_free (MetaScreen *screen,
  meta_display_ungrab (display);
 }

-typedef struct
-{
-  Window		xwindow;
-  XWindowAttributes	attrs;
-} WindowInfo;
-
-static GList *
-list_windows (MetaScreen *screen)
-{
-  Window ignored1, ignored2;
-  Window *children;
-  guint n_children, i;
-  GList *result;
-
-  XQueryTree (screen->display->xdisplay,
-              screen->xroot,
-              &ignored1, &ignored2, &children, &n_children);
-
-  result = NULL;
-  for (i = 0; i < n_children; ++i)
-    {
-      WindowInfo *info = g_new0 (WindowInfo, 1);
-
-      meta_error_trap_push_with_return (screen->display);
-      
-      XGetWindowAttributes (screen->display->xdisplay,
-                            children[i], &info->attrs);
-
-      if (meta_error_trap_pop_with_return (screen->display))
-	{
-          meta_verbose ("Failed to get attributes for window 0x%lx\n",
-                        children[i]);
-	  g_free (info);
-        }
-      else
-        {
-	  info->xwindow = children[i];
-	}
-
-      result = g_list_prepend (result, info);
-    }
-
-  if (children)
-    XFree (children);
-
-  return g_list_reverse (result);
-}
-
 void
 meta_screen_manage_all_windows (MetaScreen *screen)
 {
-  GList *windows;
-  GList *list;
-
-  meta_display_grab (screen->display);
+  MetaStackWindow *_children;
+  MetaStackWindow *children;
+  int n_children, i;

  if (screen->guard_window == None)
    screen->guard_window =
      meta_screen_create_guard_window (screen->display->xdisplay, screen);

-  windows = list_windows (screen);
-
  meta_stack_freeze (screen->stack);
-  for (list = windows; list != NULL; list = list->next)
+  meta_stack_tracker_get_stack (screen->stack_tracker, &_children, &n_children);
+
+  /* Copy the stack as it will be modified as part of the loop */
+  children = g_memdup (_children, sizeof (MetaStackWindow) * n_children);
+
+  for (i = 0; i < n_children; ++i)
    {
-      WindowInfo *info = list->data;
-
-      meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
-                                  META_COMP_EFFECT_NONE,
-                                  &info->attrs);
+      meta_window_new (screen->display, children[i].x11.xwindow, TRUE,
+                       META_COMP_EFFECT_NONE);
    }
+
+  g_free (children);
  meta_stack_thaw (screen->stack);
-
-  g_list_foreach (windows, (GFunc)g_free, NULL);
-  g_list_free (windows);
-
-  meta_display_ungrab (screen->display);
 }

 /**
--- a/src/core/session.c
+++ b/src/core/session.c
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/session.h
+++ b/src/core/session.h
@@ -23,9 +23,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_SESSION_H
--- a/src/core/stack-tracker.c
+++ b/src/core/stack-tracker.c
@@ -29,9 +29,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/stack-tracker.h
+++ b/src/core/stack-tracker.h
@@ -28,9 +28,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_STACK_TRACKER_H
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -22,9 +22,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include <config.h>
--- a/src/core/stack.h
+++ b/src/core/stack.h
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_STACK_H
--- a/src/core/testboxes.c
+++ b/src/core/testboxes.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #include "boxes-private.h"
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -15,9 +15,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -26,9 +26,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_WINDOW_PRIVATE_H
@@ -102,7 +100,7 @@ struct _MetaWindow
  
  MetaWindowType type;
  Atom type_atom;
-  
+
  /* NOTE these five are not in UTF-8, we just treat them as random
   * binary data
   */
@@ -351,6 +349,10 @@ 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;

@@ -363,6 +365,9 @@ struct _MetaWindow
  /* the input shape region for picking */
  cairo_region_t *input_region;

+  /* _NET_WM_WINDOW_OPACITY */
+  guint opacity;
+
  /* if TRUE, the we have the new form of sync request counter which
   * also handles application frames */
  guint extended_sync_request_counter : 1;
@@ -462,6 +467,8 @@ struct _MetaWindow

  /* Bypass compositor hints */
  guint bypass_compositor;
+
+  GSList *pending_pings;
 };

 struct _MetaWindowClass
@@ -501,15 +508,9 @@ struct _MetaWindowClass

 MetaWindow* meta_window_new                (MetaDisplay *display,
                                            Window       xwindow,
-                                            gboolean     must_be_viewable);
-MetaWindow* meta_window_new_with_attrs     (MetaDisplay       *display,
-                                            Window             xwindow,
-                                            gboolean           must_be_viewable,
-                                            MetaCompEffect     effect,
-                                            XWindowAttributes *attrs);
+                                            gboolean     must_be_viewable,
+                                            MetaCompEffect     effect);
 MetaWindow *meta_window_new_for_wayland    (MetaDisplay        *display,
-                                            int                 width,
-                                            int                 height,
                                            MetaWaylandSurface *surface);
 void        meta_window_unmanage           (MetaWindow  *window,
                                            guint32      timestamp);
@@ -644,8 +645,10 @@ void meta_window_update_sync_request_counter (MetaWindow *window,
                                              gint64      new_counter_value);
 #endif /* HAVE_XSYNC */

-void meta_window_handle_mouse_grab_op_event (MetaWindow         *window,
-                                             const ClutterEvent *event);
+void meta_window_handle_mouse_grab_op_event  (MetaWindow         *window,
+                                              const ClutterEvent *event);
+void meta_window_handle_mouse_grab_op_xevent (MetaWindow         *window,
+                                              XIDeviceEvent      *xevent);

 GList* meta_window_get_workspaces (MetaWindow *window);

@@ -709,16 +712,8 @@ void meta_window_compute_tile_match (MetaWindow *window);

 gboolean meta_window_updates_are_frozen (MetaWindow *window);

-void meta_window_set_opaque_region        (MetaWindow     *window,
-                                           cairo_region_t *region);
 void meta_window_update_opaque_region_x11 (MetaWindow *window);
-
-void meta_window_set_input_region         (MetaWindow     *window,
-                                           cairo_region_t *region);
 void meta_window_update_input_region_x11  (MetaWindow *window);
-
-void meta_window_set_shape_region         (MetaWindow     *window,
-                                           cairo_region_t *region);
 void meta_window_update_shape_region_x11  (MetaWindow *window);

 void meta_window_set_title                (MetaWindow *window,
@@ -737,9 +732,28 @@ void meta_window_set_gtk_dbus_properties  (MetaWindow *window,
 void meta_window_set_transient_for        (MetaWindow *window,
                                           MetaWindow *parent);

+void meta_window_set_opacity              (MetaWindow *window,
+                                           guint       opacity);
+
 void meta_window_handle_enter (MetaWindow  *window,
                               guint32      timestamp,
                               guint        root_x,
                               guint        root_y);

+void meta_window_set_surface_mapped (MetaWindow *window,
+                                     gboolean    surface_mapped);
+
+typedef void (* MetaWindowPingFunc) (MetaWindow  *window,
+				     guint32      timestamp,
+				     gpointer     user_data);
+
+void meta_window_ping (MetaWindow         *window,
+                       guint32             timestamp,
+                       MetaWindowPingFunc  ping_reply_func,
+                       MetaWindowPingFunc  ping_timeout_func,
+                       void               *user_data);
+void meta_window_pong (MetaWindow *window,
+                       guint32     timestamp);
+Window meta_window_get_toplevel_xwindow (MetaWindow *window);
+
 #endif
--- a/src/core/window-props.c
+++ b/src/core/window-props.c
@@ -31,9 +31,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #define _GNU_SOURCE
@@ -317,6 +315,9 @@ reload_gtk_frame_extents (MetaWindow    *window,
    {
      window->has_custom_frame_extents = FALSE;
    }
+
+  if (!initial)
+    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
 }

 static void
@@ -1652,6 +1653,20 @@ reload_bypass_compositor (MetaWindow    *window,
  window->bypass_compositor = requested_value;
 }

+static void
+reload_window_opacity (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+
+{
+  int requested_value = 0xFF;
+
+  if (value->type != META_PROP_VALUE_INVALID)
+    requested_value = (int) value->v.cardinal;
+
+  meta_window_set_opacity (window, requested_value);
+}
+
 #define RELOAD_STRING(var_name, propname) \
  static void                                       \
  reload_ ## var_name (MetaWindow    *window,       \
@@ -1754,6 +1769,7 @@ meta_display_init_window_prop_hooks (MetaDisplay *display)
    { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
    { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
    { display->atom__NET_WM_BYPASS_COMPOSITOR, META_PROP_VALUE_CARDINAL,  reload_bypass_compositor, FALSE, FALSE },
+    { display->atom__NET_WM_WINDOW_OPACITY, META_PROP_VALUE_CARDINAL, reload_window_opacity,  TRUE, TRUE },
    { 0 },
  };

--- a/src/core/window-props.h
+++ b/src/core/window-props.h
@@ -25,9 +25,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_WINDOW_PROPS_H
--- a/src/core/window.c
+++ b/src/core/window.c
--- a/src/core/workspace-private.h
+++ b/src/core/workspace-private.h
@@ -25,9 +25,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_WORKSPACE_PRIVATE_H
--- a/src/core/workspace.c
+++ b/src/core/workspace.c
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /**
--- a/src/core/xprops.c
+++ b/src/core/xprops.c
@@ -22,9 +22,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /***********************************************************
--- a/src/core/xprops.h
+++ b/src/core/xprops.h
@@ -16,9 +16,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef META_XPROPS_H
--- a/src/meta/atomnames.h
+++ b/src/meta/atomnames.h
@@ -18,9 +18,7 @@
 * 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

 /*
@@ -180,6 +178,7 @@ item(_NET_WM_BYPASS_COMPOSITOR)
 item(_NET_WM_OPAQUE_REGION)
 item(_NET_WM_FRAME_DRAWN)
 item(_NET_WM_FRAME_TIMINGS)
+item(_NET_WM_WINDOW_OPACITY)

 #if 0
 /* We apparently never use: */
--- a/Show More
+++ b/Show More