Bump version to 3.11.3

Update NEWS.

NEWS

@@ -1,3 +1,20 @@
+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]

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], [3])
 
 m4_define([mutter_version],
           [mutter_major_version.mutter_minor_version.mutter_micro_version])

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

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>
 

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		\

src/compositor/clutter-utils.c

@@ -95,8 +95,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;
 }

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;

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

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

src/compositor/meta-background-actor.c

@@ -41,20 +41,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 +119,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 +131,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 +160,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;
 }
 
 /**

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

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 *

src/compositor/meta-cullable.c

@@ -0,0 +1,193 @@
+/* -*- 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * 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);
+}

src/compositor/meta-cullable.h

@@ -0,0 +1,68 @@
+/* -*- 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * 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__ */
+

src/compositor/meta-shaped-texture.c

@@ -39,6 +39,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 +59,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 +115,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 +140,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 +227,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 +317,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 +777,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 +905,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)
 {

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);
 }

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
 

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

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)
 {
@@ -2391,12 +2238,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 +2252,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 +2264,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 +2272,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 +2290,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 +2327,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 +2350,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 +2583,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

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

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 ())

src/core/core.c

@@ -283,8 +283,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;

src/core/delete.c

@@ -43,14 +43,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 +65,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 +132,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

src/core/display-private.h

@@ -57,11 +57,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 +145,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 +185,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 +451,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);

src/core/display.c

@@ -83,41 +83,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 +137,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 +284,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 +435,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 +506,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;
@@ -1696,7 +1603,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 +1670,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 +1708,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 +1813,8 @@ request_xserver_input_focus_change (MetaDisplay   *display,
                        type,
                        meta_window,
                        xwindow,
-                       serial);
+                       serial,
+                       TRUE);
 
   meta_error_trap_pop (display);
 
@@ -2023,16 +1943,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 +2249,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 +2261,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;
@@ -2887,7 +3064,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 +3196,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 +3207,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 +3979,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 +4120,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 +4135,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 +4154,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 +4217,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 +4827,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 +4887,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)
 {

src/core/keybindings.c

@@ -41,6 +41,7 @@
 #include "ui.h"
 #include "frame.h"
 #include "place.h"
+#include "screen-private.h"
 #include <meta/prefs.h>
 #include "util-private.h"
 
@@ -1277,7 +1278,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 +1585,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 +1863,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 +2002,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 +3930,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,
@@ -4670,6 +4691,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,

src/core/meta-cursor-tracker.c

@@ -124,6 +124,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)
@@ -675,6 +676,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 +696,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;
 }
@@ -839,6 +840,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 +884,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 +969,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 +1036,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

src/core/meta-idle-monitor.c

@@ -949,6 +949,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",

src/core/monitor-xrandr.c

@@ -453,8 +453,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 +693,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 +791,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 +851,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 +860,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 +901,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 +931,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

src/core/window-private.h

@@ -102,7 +102,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 +351,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 +367,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 +469,8 @@ struct _MetaWindow
 
   /* Bypass compositor hints */
   guint bypass_compositor;
+
+  GSList *pending_pings;
 };
 
 struct _MetaWindowClass
@@ -508,8 +517,6 @@ MetaWindow* meta_window_new_with_attrs     (MetaDisplay       *display,
                                             MetaCompEffect     effect,
                                             XWindowAttributes *attrs);
 MetaWindow *meta_window_new_for_wayland    (MetaDisplay        *display,
-                                            int                 width,
-                                            int                 height,
                                             MetaWaylandSurface *surface);
 void        meta_window_unmanage           (MetaWindow  *window,
                                             guint32      timestamp);
@@ -644,8 +651,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 +718,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 +738,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

src/core/window-props.c

@@ -317,6 +317,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 +1655,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 +1771,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 },
   };
 

src/core/window.c

@@ -73,6 +73,26 @@
 
 static int destroying_windows_disallowed = 0;
 
+/**
+ * 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
+{
+  MetaWindow  *window;
+  guint32      timestamp;
+  MetaWindowPingFunc ping_reply_func;
+  MetaWindowPingFunc ping_timeout_func;
+  void        *user_data;
+  guint        ping_timeout_id;
+} MetaPingData;
+
+static void ping_data_free (MetaPingData *ping_data);
 
 static void     update_sm_hints           (MetaWindow     *window);
 static void     update_net_frame_extents  (MetaWindow     *window);
@@ -827,7 +847,7 @@ meta_window_new_shared (MetaDisplay         *display,
                         MetaWindowClientType client_type,
                         MetaWaylandSurface  *surface,
                         Window               xwindow,
-                        gboolean             must_be_viewable,
+                        gboolean             surface_mapped,
                         gulong               existing_wm_state,
                         MetaCompEffect       effect,
                         XWindowAttributes   *attrs)
@@ -838,8 +858,7 @@ meta_window_new_shared (MetaDisplay         *display,
 
   g_assert (attrs != NULL);
 
-  meta_verbose ("must_be_viewable = %d attrs->map_state = %d (%s)\n",
-                must_be_viewable,
+  meta_verbose ("attrs->map_state = %d (%s)\n",
                 attrs->map_state,
                 (attrs->map_state == IsUnmapped) ?
                 "IsUnmapped" :
@@ -858,6 +877,7 @@ meta_window_new_shared (MetaDisplay         *display,
   window->client_type = client_type;
   window->surface = surface;
   window->xwindow = xwindow;
+  window->surface_mapped = surface_mapped;
 
   /* this is in window->screen->display, but that's too annoying to
    * type
@@ -1057,6 +1077,8 @@ meta_window_new_shared (MetaDisplay         *display,
   else
     meta_display_register_wayland_window (display, window);
 
+  window->opacity = 0xFF;
+
   /* assign the window to its group, or create a new group if needed
    */
   window->group = NULL;
@@ -1371,8 +1393,6 @@ display_notify_window (MetaDisplay *display, MetaWindow *window)
 
 MetaWindow *
 meta_window_new_for_wayland (MetaDisplay        *display,
-                             int                 width,
-                             int                 height,
                              MetaWaylandSurface *surface)
 {
   XWindowAttributes attrs;
@@ -1381,8 +1401,8 @@ meta_window_new_for_wayland (MetaDisplay        *display,
 
   attrs.x = 0;
   attrs.y = 0;
-  attrs.width = width;
-  attrs.height = height;
+  attrs.width = 1;
+  attrs.height = 1;
   attrs.border_width = 0;
   attrs.depth = 24;
   attrs.visual = NULL;
@@ -1421,9 +1441,9 @@ meta_window_new_for_wayland (MetaDisplay        *display,
                                    META_WINDOW_CLIENT_TYPE_WAYLAND,
                                    surface,
                                    None,
-                                   TRUE,
+                                   FALSE,
                                    WithdrawnState,
-                                   META_COMP_EFFECT_NONE,
+                                   META_COMP_EFFECT_CREATE,
                                    &attrs);
 
   meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
@@ -1601,7 +1621,7 @@ meta_window_new_with_attrs (MetaDisplay       *display,
                                    META_WINDOW_CLIENT_TYPE_X11,
                                    NULL,
                                    xwindow,
-                                   must_be_viewable,
+                                   TRUE,
                                    existing_wm_state,
                                    effect,
                                    attrs);
@@ -2050,8 +2070,7 @@ meta_window_unmanage (MetaWindow  *window,
   else
     meta_display_unregister_wayland_window (window->display, window);
 
-  if (window->surface)
-    meta_wayland_surface_free (window->surface);
+  g_slist_free_full (window->pending_pings, (GDestroyNotify) ping_data_free);
 
   meta_prefs_remove_listener (prefs_changed_callback, window);
 
@@ -2353,6 +2372,9 @@ meta_window_should_be_showing (MetaWindow  *window)
 {
   gboolean on_workspace;
 
+  if (!window->surface_mapped)
+    return FALSE;
+
   meta_verbose ("Should be showing for window %s\n", window->desc);
 
   /* See if we're on the workspace */
@@ -3346,6 +3368,9 @@ meta_window_show (MetaWindow *window)
   if (did_show)
     meta_screen_queue_check_fullscreen (window->screen);
 
+  if (did_show && window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
+    meta_wayland_compositor_repick (meta_wayland_compositor_get_default ());
+
   /*
    * Now that we have shown the window, we no longer want to consider the
    * initial timestamp in any subsequent deliberations whether to focus this
@@ -4037,8 +4062,10 @@ meta_window_unmaximize_internal (MetaWindow        *window,
     {
       MetaRectangle target_rect;
       MetaRectangle work_area;
+      MetaRectangle old_rect;
 
       meta_window_get_work_area_for_monitor (window, window->monitor->number, &work_area);
+      meta_window_get_frame_rect (window, &old_rect);
 
       meta_topic (META_DEBUG_WINDOW_OPS,
                   "Unmaximizing %s%s\n",
@@ -4052,6 +4079,12 @@ meta_window_unmaximize_internal (MetaWindow        *window,
       window->maximized_vertically =
         window->maximized_vertically   && !unmaximize_vertically;
 
+      /* recalc_window_features() will eventually clear the cached frame
+       * extents, but we need the correct frame extents in the code below,
+       * so invalidate the old frame extents manually up front.
+       */
+      meta_window_frame_size_changed (window);
+
       /* Unmaximize to the saved_rect position in the direction(s)
        * being unmaximized.
        */
@@ -4096,9 +4129,7 @@ meta_window_unmaximize_internal (MetaWindow        *window,
 
       if (window->display->compositor)
         {
-          MetaRectangle old_rect, new_rect;
-
-	  meta_window_get_frame_rect (window, &old_rect);
+          MetaRectangle new_rect;
 
           meta_window_move_resize_internal (window,
                                             META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION,
@@ -5214,6 +5245,11 @@ meta_window_move_resize_internal (MetaWindow          *window,
        * the interaction with frames and the synthetic configure notifies.
        */
 
+      /* meta_window_constrain() might have maximized the window after placement,
+       * changing the borders.
+       */
+      meta_frame_calc_borders (window->frame, &borders);
+
       root_x_nw = new_rect.x;
       root_y_nw = new_rect.y;
       w = new_rect.width;
@@ -6038,8 +6074,8 @@ meta_window_get_input_rect (const MetaWindow *window,
 /**
  * meta_window_client_rect_to_frame_rect:
  * @window: a #MetaWindow
- * @frame_rect: client rectangle in root coordinates
- * @client_rect: (out): location to store the computed corresponding frame bounds.
+ * @client_rect: client rectangle in root coordinates
+ * @frame_rect: (out): location to store the computed corresponding frame bounds.
  *
  * Converts a desired bounds of the client window - what is passed to meta_window_move_resize() -
  * into the corresponding bounds of the window frame (excluding invisible borders
@@ -6047,13 +6083,13 @@ meta_window_get_input_rect (const MetaWindow *window,
  */
 void
 meta_window_client_rect_to_frame_rect (MetaWindow    *window,
-                                       MetaRectangle *frame_rect,
-                                       MetaRectangle *client_rect)
+                                       MetaRectangle *client_rect,
+                                       MetaRectangle *frame_rect)
 {
-  if (!client_rect)
+  if (!frame_rect)
     return;
 
-  *client_rect = *frame_rect;
+  *frame_rect = *client_rect;
 
   /* The support for G_MAXINT here to mean infinity is a convenience for
    * constraints.c:get_size_limits() and not something that we provide
@@ -6064,24 +6100,24 @@ meta_window_client_rect_to_frame_rect (MetaWindow    *window,
       MetaFrameBorders borders;
       meta_frame_calc_borders (window->frame, &borders);
 
-      client_rect->x -= borders.visible.left;
-      client_rect->y -= borders.visible.top;
-      if (client_rect->width != G_MAXINT)
-        client_rect->width += borders.visible.left + borders.visible.right;
-      if (client_rect->height != G_MAXINT)
-        client_rect->height += borders.visible.top  + borders.visible.bottom;
+      frame_rect->x -= borders.visible.left;
+      frame_rect->y -= borders.visible.top;
+      if (frame_rect->width != G_MAXINT)
+        frame_rect->width += borders.visible.left + borders.visible.right;
+      if (frame_rect->height != G_MAXINT)
+        frame_rect->height += borders.visible.top  + borders.visible.bottom;
     }
   else
     {
       if (window->has_custom_frame_extents)
         {
           const GtkBorder *extents = &window->custom_frame_extents;
-          client_rect->x += extents->left;
-          client_rect->y += extents->top;
-          if (client_rect->width != G_MAXINT)
-            client_rect->width -= extents->left + extents->right;
-          if (client_rect->height != G_MAXINT)
-            client_rect->height -= extents->top + extents->bottom;
+          frame_rect->x += extents->left;
+          frame_rect->y += extents->top;
+          if (frame_rect->width != G_MAXINT)
+            frame_rect->width -= extents->left + extents->right;
+          if (frame_rect->height != G_MAXINT)
+            frame_rect->height -= extents->top + extents->bottom;
         }
     }
 }
@@ -6178,7 +6214,7 @@ meta_window_get_frame_rect (const MetaWindow *window,
  * area that we or the client adds to the window, or any area that the
  * client adds to draw a client-side shadow.
  *
- * Deprecated: 3.10: Use meta_window_get_frame_rect() instead.
+ * Deprecated: 3.12: Use meta_window_get_frame_rect() instead.
  */
 void
 meta_window_get_outer_rect (const MetaWindow *window,
@@ -7981,7 +8017,7 @@ meta_window_update_net_wm_type (MetaWindow *window)
   meta_window_recalc_window_type (window);
 }
 
-void
+static void
 meta_window_set_opaque_region (MetaWindow     *window,
                                cairo_region_t *region)
 {
@@ -8067,7 +8103,7 @@ region_create_from_x_rectangles (const XRectangle *rects,
   return cairo_region_create_rectangles (cairo_rects, n_rects);
 }
 
-void
+static void
 meta_window_set_input_region (MetaWindow     *window,
                               cairo_region_t *region)
 {
@@ -8152,7 +8188,7 @@ meta_window_update_input_region_x11 (MetaWindow *window)
   cairo_region_destroy (region);
 }
 
-void
+static void
 meta_window_set_shape_region (MetaWindow     *window,
                               cairo_region_t *region)
 {
@@ -10000,20 +10036,96 @@ update_resize (MetaWindow *window,
     g_get_current_time (&window->display->grab_last_moveresize_time);
 }
 
-static gboolean
-check_use_this_motion_notify (MetaWindow         *window,
-                              const ClutterEvent *event)
+typedef struct
 {
-  /* XXX: Previously this code would walk through the X event queue
-     and filter out motion events that are followed by a later motion
-     event. There currently isn't any API to do the equivalent
-     procedure with the Clutter event queue so this function does
-     nothing. Clutter does its own motion event squashing so it may be
-     the case that this function isn't necessary. If it turns out that
-     we do need additional motion event squashing we could add some
-     extra API to the Clutter event queue and implement this function
-     properly. */
-  return TRUE;
+  Window  window;
+  int     count;
+  guint32 last_time;
+} EventScannerData;
+
+static Bool
+find_last_time_predicate (Display  *display,
+                          XEvent   *ev,
+                          XPointer  arg)
+{
+  EventScannerData *esd = (void*) arg;
+  XIEvent *xev;
+
+  if (ev->type != GenericEvent)
+    return False;
+
+  /* We are peeking into events not yet handled by GDK,
+   * Allocate cookie events here so we can handle XI2.
+   *
+   * GDK will handle later these events, and eventually
+   * free the cookie data itself.
+   */
+  XGetEventData (display, &ev->xcookie);
+  xev = (XIEvent *) ev->xcookie.data;
+
+  if (xev->evtype != XI_Motion)
+    return False;
+
+  if (esd->window != ((XIDeviceEvent *) xev)->event)
+    return False;
+
+  esd->count += 1;
+  esd->last_time = xev->time;
+
+  return False;
+}
+
+static gboolean
+check_use_this_motion_notify (MetaWindow *window,
+                              XIDeviceEvent *xev)
+{
+  EventScannerData esd;
+  XEvent useless;
+
+  /* This code is copied from Owen's GDK code. */
+
+  if (window->display->grab_motion_notify_time != 0)
+    {
+      /* == is really the right test, but I'm all for paranoia */
+      if (window->display->grab_motion_notify_time <=
+          xev->time)
+        {
+          meta_topic (META_DEBUG_RESIZING,
+                      "Arrived at event with time %u (waiting for %u), using it\n",
+                      (unsigned int)xev->time,
+                      window->display->grab_motion_notify_time);
+          window->display->grab_motion_notify_time = 0;
+          return TRUE;
+        }
+      else
+        return FALSE; /* haven't reached the saved timestamp yet */
+    }
+
+  esd.window = xev->event;
+  esd.count = 0;
+  esd.last_time = 0;
+
+  /* "useless" isn't filled in because the predicate never returns True */
+  XCheckIfEvent (window->display->xdisplay,
+                 &useless,
+                 find_last_time_predicate,
+                 (XPointer) &esd);
+
+  if (esd.count > 0)
+    meta_topic (META_DEBUG_RESIZING,
+                "Will skip %d motion events and use the event with time %u\n",
+                esd.count, (unsigned int) esd.last_time);
+
+  if (esd.last_time == 0)
+    return TRUE;
+  else
+    {
+      /* Save this timestamp, and ignore all motion notify
+       * until we get to the one with this stamp.
+       */
+      window->display->grab_motion_notify_time = esd.last_time;
+      return FALSE;
+    }
 }
 
 static void
@@ -10087,8 +10199,98 @@ meta_window_update_sync_request_counter (MetaWindow *window,
 #endif /* HAVE_XSYNC */
 
 void
-meta_window_handle_mouse_grab_op_event (MetaWindow         *window,
-                                        const ClutterEvent *event)
+meta_window_handle_mouse_grab_op_xevent (MetaWindow         *window,
+                                         XIDeviceEvent      *xevent)
+{
+  gboolean is_window_root = (xevent->root == window->screen->xroot);
+
+  switch (xevent->evtype)
+    {
+    case XI_ButtonRelease:
+      if (xevent->detail == 1 ||
+          xevent->detail == meta_prefs_get_mouse_button_resize ())
+        {
+          meta_display_check_threshold_reached (window->display,
+                                                xevent->root_x,
+                                                xevent->root_y);
+          /* If the user was snap moving then ignore the button
+           * release because they may have let go of shift before
+           * releasing the mouse button and they almost certainly do
+           * not want a non-snapped movement to occur from the button
+           * release.
+           */
+          if (!window->display->grab_last_user_action_was_snap)
+            {
+              if (meta_grab_op_is_moving (window->display->grab_op))
+                {
+                  if (window->tile_mode != META_TILE_NONE)
+                    meta_window_tile (window);
+                  else if (is_window_root)
+                    update_move (window,
+                                 xevent->mods.effective & ShiftMask,
+                                 xevent->root_x,
+                                 xevent->root_y);
+                }
+              else if (meta_grab_op_is_resizing (window->display->grab_op))
+                {
+                  if (is_window_root)
+                    update_resize (window,
+                                   xevent->mods.effective & ShiftMask,
+                                   xevent->root_x,
+                                   xevent->root_y,
+                                   TRUE);
+
+                  /* If a tiled window has been dragged free with a
+                   * mouse resize without snapping back to the tiled
+                   * state, it will end up with an inconsistent tile
+                   * mode on mouse release; cleaning the mode earlier
+                   * would break the ability to snap back to the tiled
+                   * state, so we wait until mouse release.
+                   */
+                  update_tile_mode (window);
+                }
+              meta_display_end_grab_op (window->display, xevent->time);
+            }
+        }
+      break;
+
+    case XI_Motion:
+      meta_display_check_threshold_reached (window->display,
+                                            xevent->root_x,
+                                            xevent->root_y);
+      if (meta_grab_op_is_moving (window->display->grab_op))
+        {
+          if (is_window_root)
+            {
+              if (check_use_this_motion_notify (window, xevent))
+                update_move (window,
+                             xevent->mods.effective & ShiftMask,
+                             xevent->root_x,
+                             xevent->root_y);
+            }
+        }
+      else if (meta_grab_op_is_resizing (window->display->grab_op))
+        {
+          if (is_window_root)
+            {
+              if (check_use_this_motion_notify (window, xevent))
+                update_resize (window,
+                               xevent->mods.effective & ShiftMask,
+                               xevent->root_x,
+                               xevent->root_y,
+                               FALSE);
+            }
+        }
+      break;
+
+    default:
+      break;
+    }
+}
+
+void
+meta_window_handle_mouse_grab_op_event  (MetaWindow         *window,
+                                         const ClutterEvent *event)
 {
   gboolean is_window_root = (event->any.stage != NULL &&
                              window &&
@@ -10141,7 +10343,6 @@ meta_window_handle_mouse_grab_op_event (MetaWindow         *window,
                    */
                   update_tile_mode (window);
                 }
-
               meta_display_end_grab_op (window->display, event->any.time);
             }
         }
@@ -10155,23 +10356,21 @@ meta_window_handle_mouse_grab_op_event (MetaWindow         *window,
         {
           if (is_window_root)
             {
-              if (check_use_this_motion_notify (window, event))
-                update_move (window,
-                             event->button.modifier_state & CLUTTER_SHIFT_MASK,
-                             event->motion.x,
-                             event->motion.y);
+              update_move (window,
+                           event->button.modifier_state & CLUTTER_SHIFT_MASK,
+                           event->motion.x,
+                           event->motion.y);
             }
         }
       else if (meta_grab_op_is_resizing (window->display->grab_op))
         {
           if (is_window_root)
             {
-              if (check_use_this_motion_notify (window, event))
-                update_resize (window,
-                               event->button.modifier_state & CLUTTER_SHIFT_MASK,
-                               event->motion.x,
-                               event->motion.y,
-                               FALSE);
+              update_resize (window,
+                             event->button.modifier_state & CLUTTER_SHIFT_MASK,
+                             event->motion.x,
+                             event->motion.y,
+                             FALSE);
             }
         }
       break;
@@ -11767,6 +11966,16 @@ meta_window_set_transient_for (MetaWindow *window,
     meta_window_propagate_focus_appearance (window, TRUE);
 }
 
+void
+meta_window_set_opacity (MetaWindow *window,
+                         guint       opacity)
+{
+  window->opacity = opacity;
+
+  if (window->display->compositor)
+    meta_compositor_window_opacity_changed (window->display->compositor, window);
+}
+
 static void
 reset_ignored_crossing_serials (MetaDisplay *display)
 {
@@ -11948,3 +12157,212 @@ meta_window_handle_enter (MetaWindow  *window,
       break;
     }
 }
+
+void
+meta_window_set_surface_mapped (MetaWindow *window,
+                                gboolean    surface_mapped)
+{
+  if (window->surface_mapped == (guint) surface_mapped)
+    return;
+
+  window->surface_mapped = surface_mapped;
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+}
+
+/*
+ * 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.
+ */
+
+/**
+ * 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)
+{
+  MetaWindow *window = ping_data->window;
+  MetaDisplay *display = window->display;
+
+  /* Remove the timeout */
+  if (ping_data->ping_timeout_id != 0)
+    g_source_remove (ping_data->ping_timeout_id);
+
+  g_hash_table_remove (display->pending_pings, &ping_data->timestamp);
+
+  g_free (ping_data);
+}
+
+/**
+ * meta_window_pong:
+ * @window: the window we got the pong on
+ * @timestamp: the timestamp that the client sent back
+ *
+ * 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.
+ */
+void
+meta_window_pong (MetaWindow *window,
+                  guint32     timestamp)
+{
+  GSList *tmp;
+
+  meta_topic (META_DEBUG_PING, "Received a pong with timestamp %u\n",
+              timestamp);
+
+  for (tmp = window->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 */
+          window->pending_pings = g_slist_remove (window->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) (window,
+                                          ping_data->timestamp,
+                                          ping_data->user_data);
+
+          ping_data_free (ping_data);
+
+          break;
+        }
+    }
+}
+
+/*
+ * 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
+
+/**
+ * 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
+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 %s timed out\n",
+              ping_data->timestamp, ping_data->window->desc);
+
+  (* ping_data->ping_timeout_func) (ping_data->window, ping_data->timestamp, ping_data->user_data);
+
+  ping_data_free (ping_data);
+
+  return FALSE;
+}
+
+/**
+ * meta_window_ping:
+ * @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.
+ */
+void
+meta_window_ping (MetaWindow        *window,
+                  guint32            timestamp,
+                  MetaWindowPingFunc ping_reply_func,
+                  MetaWindowPingFunc ping_timeout_func,
+                  gpointer           user_data)
+{
+  MetaPingData *ping_data;
+  MetaDisplay *display = window->display;
+
+  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) (window, timestamp, user_data);
+
+      return;
+    }
+
+  ping_data = g_new (MetaPingData, 1);
+  ping_data->window = window;
+  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, ping_timeout, ping_data);
+
+  window->pending_pings = g_slist_prepend (window->pending_pings, ping_data);
+
+  g_hash_table_insert (display->pending_pings, &ping_data->timestamp, window);
+
+  meta_topic (META_DEBUG_PING,
+              "Sending ping with timestamp %u to window %s\n",
+              timestamp, window->desc);
+
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    meta_window_send_icccm_message (window, display->atom__NET_WM_PING, timestamp);
+  else
+    meta_wayland_surface_ping (window->surface, timestamp);
+}
+
+Window
+meta_window_get_toplevel_xwindow (MetaWindow *window)
+{
+  return window->frame ? window->frame->xwindow : window->xwindow;
+}

src/meta/atomnames.h

@@ -180,6 +180,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: */

src/meta/compositor.h

@@ -66,6 +66,8 @@ void meta_compositor_unmanage_screen (MetaCompositor *compositor,
 
 void meta_compositor_window_shape_changed (MetaCompositor *compositor,
                                            MetaWindow     *window);
+void meta_compositor_window_opacity_changed (MetaCompositor *compositor,
+                                             MetaWindow     *window);
 
 gboolean meta_compositor_process_event (MetaCompositor *compositor,
                                         XEvent         *event,

src/meta/meta-shaped-texture.h

@@ -81,9 +81,6 @@ void meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
 void meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
                                                  cairo_region_t    *shape_region);
 
-void meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,
-					  cairo_region_t    *clip_region);
-
 void meta_shaped_texture_set_opaque_region (MetaShapedTexture *stex,
                                             cairo_region_t    *opaque_region);
 

src/meta/prefs.h

@@ -243,12 +243,15 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
  * @META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_RIGHT: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_UP: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_DOWN: FILLME 
+ * @META_KEYBINDING_ACTION_MOVE_TO_MONITOR_LEFT: FILLME
+ * @META_KEYBINDING_ACTION_MOVE_TO_MONITOR_RIGHT: FILLME
+ * @META_KEYBINDING_ACTION_MOVE_TO_MONITOR_UP: FILLME
+ * @META_KEYBINDING_ACTION_MOVE_TO_MONITOR_DOWN: FILLME
  * @META_KEYBINDING_ACTION_RAISE_OR_LOWER: FILLME 
  * @META_KEYBINDING_ACTION_RAISE: FILLME 
  * @META_KEYBINDING_ACTION_LOWER: FILLME 
  * @META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY: FILLME 
  * @META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY: FILLME 
- * @META_KEYBINDING_ACTION_ALWAYS_ON_TOP: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_SW: FILLME 
@@ -259,6 +262,7 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
  * @META_KEYBINDING_ACTION_MOVE_TO_SIDE_W: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CENTER: FILLME 
  * @META_KEYBINDING_ACTION_OVERLAY_KEY: FILLME 
+ * @META_KEYBINDING_ACTION_ALWAYS_ON_TOP: FILLME 
  * @META_KEYBINDING_ACTION_LAST: FILLME 
  */
 /* XXX FIXME This should be x-macroed, but isn't yet because it would be
@@ -336,11 +340,14 @@ typedef enum _MetaKeyBindingAction
   META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_RIGHT,
   META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_UP,
   META_KEYBINDING_ACTION_MOVE_TO_WORKSPACE_DOWN,
+  META_KEYBINDING_ACTION_MOVE_TO_MONITOR_LEFT,
+  META_KEYBINDING_ACTION_MOVE_TO_MONITOR_RIGHT,
+  META_KEYBINDING_ACTION_MOVE_TO_MONITOR_UP,
+  META_KEYBINDING_ACTION_MOVE_TO_MONITOR_DOWN,
   META_KEYBINDING_ACTION_RAISE_OR_LOWER,
   META_KEYBINDING_ACTION_RAISE,
   META_KEYBINDING_ACTION_LOWER,
   META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY,
-  META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
   META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY,
   META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW,
   META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE,
@@ -353,6 +360,7 @@ typedef enum _MetaKeyBindingAction
   META_KEYBINDING_ACTION_MOVE_TO_CENTER,
   META_KEYBINDING_ACTION_OVERLAY_KEY,
   META_KEYBINDING_ACTION_ISO_NEXT_GROUP,
+  META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
 
   META_KEYBINDING_ACTION_LAST
 } MetaKeyBindingAction;
@@ -393,7 +401,7 @@ struct _MetaKeyCombo
  * @display: a #MetaDisplay
  * @screen: a #MetaScreen
  * @window: a #MetaWindow
- * @event: a #ClutterKeyEvent
+ * @event: (type gpointer): a #ClutterKeyEvent
  * @binding: a #MetaKeyBinding
  * @user_data: data passed to the function
  *

src/meta/window.h

@@ -115,8 +115,8 @@ void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect);
 void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect) G_GNUC_DEPRECATED;
 
 void meta_window_client_rect_to_frame_rect (MetaWindow    *window,
-                                            MetaRectangle *frame_rect,
-                                            MetaRectangle *client_rect);
+                                            MetaRectangle *client_rect,
+                                            MetaRectangle *frame_rect);
 void meta_window_frame_rect_to_client_rect (MetaWindow    *window,
                                             MetaRectangle *frame_rect,
                                             MetaRectangle *client_rect);

src/wayland/meta-wayland-keyboard.c

@@ -228,6 +228,7 @@ lose_keyboard_focus (struct wl_listener *listener, void *data)
     wl_container_of (listener, keyboard, focus_listener);
 
   keyboard->focus_resource = NULL;
+  keyboard->focus = NULL;
 }
 
 static gboolean
@@ -511,14 +512,14 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
   struct wl_resource *resource;
   uint32_t serial;
 
-  if (keyboard->focus_resource && keyboard->focus != surface)
-    {
-      struct wl_display *display;
-      struct wl_client *client;
+  if (keyboard->focus == surface && keyboard->focus_resource != NULL)
+    return;
 
-      resource = keyboard->focus_resource;
-      client = wl_resource_get_client (resource);
-      display = wl_client_get_display (client);
+  resource = keyboard->focus_resource;
+  if (keyboard->focus_resource && keyboard->focus->resource)
+    {
+      struct wl_client *client = wl_resource_get_client (resource);
+      struct wl_display *display = wl_client_get_display (client);
       serial = wl_display_next_serial (display);
       wl_keyboard_send_leave (resource, serial, keyboard->focus->resource);
       wl_list_remove (&keyboard->focus_listener.link);
@@ -527,13 +528,11 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
     }
 
   resource = find_resource_for_surface (&keyboard->resource_list, surface);
-  if (resource &&
-      (keyboard->focus != surface || keyboard->focus_resource != resource))
+  if (resource)
     {
       struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display;
+      struct wl_display *display = wl_client_get_display (client);
 
-      display = wl_client_get_display (client);
       serial = wl_display_next_serial (display);
 
       /* If we're in a modal grab, the client is focused but doesn't see

src/wayland/meta-wayland-pointer.c

@@ -318,8 +318,11 @@ meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
   struct wl_resource *resource, *kr;
   uint32_t serial;
 
+  if (pointer->focus == surface && pointer->focus_resource != NULL)
+    return;
+
   resource = pointer->focus_resource;
-  if (resource && pointer->focus != surface)
+  if (resource && pointer->focus->resource)
     {
       struct wl_client *client = wl_resource_get_client (resource);
       struct wl_display *display = wl_client_get_display (client);
@@ -329,8 +332,7 @@ meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
     }
 
   resource = find_resource_for_surface (&pointer->resource_list, surface);
-  if (resource &&
-      (pointer->focus != surface || pointer->focus_resource != resource))
+  if (resource)
     {
       struct wl_client *client = wl_resource_get_client (resource);
       struct wl_display *display = wl_client_get_display (client);
@@ -446,24 +448,6 @@ meta_wayland_pointer_end_modal (MetaWaylandPointer *pointer)
   g_slice_free (MetaWaylandPointerGrab, grab);
 }
 
-/* Called when the focused resource is destroyed */
-void
-meta_wayland_pointer_destroy_focus (MetaWaylandPointer *pointer)
-{
-  if (pointer->grab == &pointer->default_grab)
-    {
-      /* The surface was destroyed, but had the implicit pointer grab.
-         Bypass the grab interface. */
-      g_assert (pointer->button_count > 0);
-
-      /* Note: we focus the NULL interface, not the current one, because
-	 we have button down, and the clients would be confused if the
-	 pointer enters the surface.
-      */
-      meta_wayland_pointer_set_focus (pointer, NULL);
-    }
-}
-
 typedef struct {
   MetaWaylandPointerGrab  generic;
 
@@ -488,7 +472,7 @@ popup_grab_focus (MetaWaylandPointerGrab *grab,
 
   /* Popup grabs are in owner-events mode (ie, events for the same client
      are reported as normal) */
-  if (wl_resource_get_client (surface->resource) == popup_grab->grab_client)
+  if (surface && wl_resource_get_client (surface->resource) == popup_grab->grab_client)
     default_grab_focus (grab, surface, event);
   else
     meta_wayland_pointer_set_focus (grab->pointer, NULL);
@@ -538,14 +522,14 @@ meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer)
 
   wl_list_for_each_safe (popup, tmp, &popup_grab->all_popups, link)
     {
-      MetaWaylandSurfaceExtension *shell_surface = popup->surface->xdg_surface;
-      struct wl_client *client = wl_resource_get_client (shell_surface->resource);
+      MetaWaylandSurfaceExtension *xdg_popup = &popup->surface->xdg_popup;
+      struct wl_client *client = wl_resource_get_client (xdg_popup->resource);
       struct wl_display *display = wl_client_get_display (client);
       uint32_t serial;
 
       serial = wl_display_next_serial (display);
 
-      xdg_popup_send_popup_done (shell_surface->resource, serial);
+      xdg_popup_send_popup_done (xdg_popup->resource, serial);
       wl_list_remove (&popup->surface_destroy_listener.link);
       wl_list_remove (&popup->link);
       g_slice_free (MetaWaylandPopup, popup);
@@ -607,7 +591,7 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,
   popup->grab = grab;
   popup->surface = surface;
   popup->surface_destroy_listener.notify = on_popup_surface_destroy;
-  wl_resource_add_destroy_listener (surface->resource, &popup->surface_destroy_listener);
+  wl_resource_add_destroy_listener (surface->xdg_popup.resource, &popup->surface_destroy_listener);
 
   wl_list_insert (&grab->all_popups, &popup->link);
       

src/wayland/meta-wayland-pointer.h

@@ -76,8 +76,6 @@ meta_wayland_pointer_release (MetaWaylandPointer *pointer);
 void
 meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
                                 MetaWaylandSurface *surface);
-void
-meta_wayland_pointer_destroy_focus (MetaWaylandPointer *pointer);
 
 void
 meta_wayland_pointer_start_grab (MetaWaylandPointer *pointer,

src/wayland/meta-wayland-private.h

@@ -109,5 +109,6 @@ void                    meta_wayland_buffer_reference           (MetaWaylandBuff
 
 void                    meta_wayland_compositor_update          (MetaWaylandCompositor *compositor,
                                                                  const ClutterEvent    *event);
+void                    meta_wayland_compositor_paint_finished  (MetaWaylandCompositor *compositor);
 
 #endif /* META_WAYLAND_PRIVATE_H */

src/wayland/meta-wayland-seat.c

@@ -68,7 +68,11 @@ meta_wayland_seat_update_sprite (MetaWaylandSeat *seat)
   if (seat->cursor_tracker == NULL)
     return;
 
-  buffer = seat->sprite->buffer_ref.buffer->resource;
+  if (seat->sprite->buffer_ref.buffer)
+    buffer = seat->sprite->buffer_ref.buffer->resource;
+  else
+    buffer = NULL;
+
   meta_cursor_tracker_set_window_cursor (seat->cursor_tracker,
                                          buffer,
                                          seat->hotspot_x,

src/wayland/meta-wayland-surface.h

@@ -29,6 +29,7 @@
 
 #include <meta/meta-cursor-tracker.h>
 #include "meta-wayland-types.h"
+#include "meta-surface-actor.h"
 
 struct _MetaWaylandBuffer
 {
@@ -64,23 +65,10 @@ typedef struct
 
   /* wl_surface.frame */
   struct wl_list frame_callback_list;
-
-  /* xdg_surface */
-  char *title;
-  char *app_id;
-
-  /* gtk_surface */
-  char *gtk_application_id;
-  char *gtk_unique_bus_name;
-  char *gtk_app_menu_path;
-  char *gtk_menubar_path;
-  char *gtk_application_object_path;
-  char *gtk_window_object_path;
 } MetaWaylandDoubleBufferedState;
 
 typedef struct
 {
-  MetaWaylandSurface *surface;
   struct wl_resource *resource;
   struct wl_listener surface_destroy_listener;
 } MetaWaylandSurfaceExtension;
@@ -90,9 +78,12 @@ struct _MetaWaylandSurface
   struct wl_resource *resource;
   MetaWaylandCompositor *compositor;
   MetaWaylandBufferReference buffer_ref;
+  MetaSurfaceActor *surface_actor;
   MetaWindow *window;
-  MetaWaylandSurfaceExtension *xdg_surface;
-  MetaWaylandSurfaceExtension *gtk_surface;
+  MetaWaylandSurfaceExtension xdg_surface;
+  MetaWaylandSurfaceExtension xdg_popup;
+  MetaWaylandSurfaceExtension gtk_surface;
+  MetaWaylandSurfaceExtension subsurface;
 
   /* All the pending state, that wl_surface.commit will apply. */
   MetaWaylandDoubleBufferedState pending;
@@ -104,8 +95,6 @@ MetaWaylandSurface *meta_wayland_surface_create (MetaWaylandCompositor *composit
 						 struct wl_client      *client,
 						 guint32                id,
 						 guint32                version);
-void                meta_wayland_surface_free   (MetaWaylandSurface    *surface);
-
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
 							   int                 width,
 							   int                 height,
@@ -114,4 +103,7 @@ void                meta_wayland_surface_configure_notify (MetaWaylandSurface *s
 void                meta_wayland_surface_focused_set (MetaWaylandSurface *surface);
 void                meta_wayland_surface_focused_unset (MetaWaylandSurface *surface);
 
+void                meta_wayland_surface_ping (MetaWaylandSurface *surface,
+                                               guint32             serial);
+
 #endif

src/wayland/meta-wayland-versions.h

@@ -42,6 +42,7 @@
 #define META_XSERVER_VERSION                1
 #define META_GTK_SHELL_VERSION              1
 #define META_XDG_SHELL_VERSION              1
+#define META_WL_SUBCOMPOSITOR_VERSION       1
 
 /* Slave objects (version inherited from a master object) */
 #define META_WL_DATA_OFFER_VERSION          1 /* from wl_data_device */
@@ -54,6 +55,8 @@
 #define META_WL_REGION_VERSION              1 /* from wl_compositor */
 #define META_GTK_SURFACE_VERSION            1 /* from gtk_shell */
 #define META_XDG_SURFACE_VERSION            1 /* from xdg_shell */
+#define META_XDG_POPUP_VERSION              1 /* from xdg_shell */
+#define META_WL_SUBSURFACE_VERSION          1 /* from wl_subcompositor */
 
 /* The first version to implement a specific event */
 #define META_WL_SEAT_HAS_NAME               2

src/wayland/meta-wayland.c

@@ -497,11 +497,9 @@ const static struct wl_compositor_interface meta_wayland_compositor_interface =
   meta_wayland_compositor_create_region
 };
 
-static void
-paint_finished_cb (ClutterActor *self, void *user_data)
+void
+meta_wayland_compositor_paint_finished (MetaWaylandCompositor *compositor)
 {
-  MetaWaylandCompositor *compositor = user_data;
-
   while (!wl_list_empty (&compositor->frame_callbacks))
     {
       MetaWaylandFrameCallback *callback =
@@ -616,6 +614,15 @@ set_gnome_env (const char *name,
     }
 }
 
+static void
+meta_wayland_log_func (const char *fmt,
+                       va_list     arg)
+{
+  char *str = g_strdup_vprintf (fmt, arg);
+  g_warning ("WL: %s", str);
+  g_free (str);
+}
+
 void
 meta_wayland_init (void)
 {
@@ -633,6 +640,7 @@ meta_wayland_init (void)
     g_error ("failed to create wayland display");
 
   wl_display_init_shm (compositor->wayland_display);
+  wl_log_set_handler_server(meta_wayland_log_func);
 
   wl_list_init (&compositor->frame_callbacks);
 
@@ -698,8 +706,6 @@ meta_wayland_init (void)
   compositor->outputs = meta_wayland_compositor_update_outputs (compositor, monitors);
 
   compositor->stage = meta_wayland_stage_new ();
-  g_signal_connect_after (compositor->stage, "paint",
-                          G_CALLBACK (paint_finished_cb), compositor);
   g_signal_connect (compositor->stage, "destroy",
                     G_CALLBACK (stage_destroy_cb), NULL);
 

src/wayland/meta-xwayland.c

@@ -39,25 +39,15 @@ xserver_set_window_id (struct wl_client *client,
                        struct wl_resource *surface_resource,
                        guint32 xid)
 {
-  MetaWaylandCompositor *compositor =
-    wl_resource_get_user_data (compositor_resource);
   MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
   MetaDisplay *display = meta_get_display ();
   MetaWindow *window;
 
-  window  = meta_display_lookup_x_window (display, xid);
+  window = meta_display_lookup_x_window (display, xid);
   if (window)
     {
       surface->window = window;
       window->surface = surface;
-
-      /* If the window is already meant to have focus then the
-       * original attempt to call this in response to the FocusIn
-       * event will have been lost because there was no surface
-       * yet. */
-      if (window->has_focus)
-        meta_wayland_compositor_set_input_focus (compositor, window);
-
     }
 }
 
@@ -102,7 +92,7 @@ bind_xserver (struct wl_client *client,
    * and unblock meta_wayland_init() to continue initializing mutter.
    * */
   g_main_loop_quit (compositor->init_loop);
-  compositor->init_loop = NULL;
+  g_clear_pointer (&compositor->init_loop, g_main_loop_unref);
 }
 
 static char *
@@ -306,6 +296,7 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
   char **env;
   char *fd_string;
   char *display_name;
+  char *log_path;
   char *args[11];
   GError *error;
 
@@ -368,6 +359,7 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
 
   display_name = g_strdup_printf (":%d",
                                   compositor->xwayland_display_index);
+  log_path = g_build_filename (g_get_user_cache_dir (), "xwayland.log", NULL);
 
   args[0] = XWAYLAND_PATH;
   args[1] = display_name;
@@ -376,7 +368,7 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
   args[4] = "-retro";
   args[5] = "-noreset";
   args[6] = "-logfile";
-  args[7] = g_build_filename (g_get_user_cache_dir (), "xwayland.log", NULL);
+  args[7] = log_path;
   args[8] = "-nolisten";
   args[9] = "all";
   args[10] = NULL;
@@ -410,6 +402,7 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
 
   g_strfreev (env);
   g_free (display_name);
+  g_free (log_path);
 
   /* We need to run a mainloop until we know xwayland has a binding
    * for our xserver interface at which point we can assume it's

src/wayland/weston-launch.c

@@ -738,9 +738,6 @@ main(int argc, char *argv[])
 
 	if (optind >= argc)
 		error(1, 0, "Expected program argument");
-	if (strcmp (argv[optind], "mutter-wayland") &&
-	    strcmp (argv[optind], "gnome-shell-wayland"))
-	  error(1, 0, "mutter-launch can only be used to launch mutter or gnome-shell");
 
 	wl.pw = getpwuid(getuid());
 	if (wl.pw == NULL)