Fix input and bounding shapes

1) We need to select for shape events
2) For decorated windows, we don't want to apply any input
   shape, because the frame is always rectangular and eats
   all the input
3) For undecorated windows, the "has input shape" check is
   wrong if the window has a bounding shape but not an input
   shape

src/Makefile.am

@@ -80,6 +80,10 @@ libmutter_wayland_la_SOURCES =			\
 	compositor/meta-shaped-texture-private.h 	\
 	compositor/meta-surface-actor.c		\
 	compositor/meta-surface-actor.h		\
+	compositor/meta-surface-actor-x11.c	\
+	compositor/meta-surface-actor-x11.h	\
+	compositor/meta-surface-actor-wayland.c	\
+	compositor/meta-surface-actor-wayland.h	\
 	compositor/meta-texture-rectangle.c	\
 	compositor/meta-texture-rectangle.h	\
 	compositor/meta-texture-tower.c		\

src/compositor/compositor.c

@@ -140,6 +140,19 @@ meta_compositor_destroy (MetaCompositor *compositor)
   clutter_threads_remove_repaint_func (compositor->repaint_func_id);
 }
 
+static void
+add_win (MetaWindow *window)
+{
+  MetaScreen		*screen = meta_window_get_screen (window);
+  MetaCompScreen        *info = meta_screen_get_compositor_data (screen);
+
+  g_return_if_fail (info != NULL);
+
+  meta_window_actor_new (window);
+
+  sync_actor_stacking (info);
+}
+
 static void
 process_damage (MetaCompositor     *compositor,
                 XDamageNotifyEvent *event,
@@ -316,39 +329,36 @@ meta_focus_stage_window (MetaScreen *screen,
   if (!stage)
     return;
 
-  if (!meta_is_wayland_compositor ())
-    {
-      window = clutter_x11_get_stage_window (stage);
+  window = clutter_x11_get_stage_window (stage);
 
-      if (window == None)
-        return;
+  if (window == None)
+    return;
 
-      meta_display_set_input_focus_xwindow (screen->display,
-                                            screen,
-                                            META_FOCUS_STAGE,
-                                            window,
-                                            timestamp);
-    }
-  else
-    {
-      meta_display_set_input_focus_xwindow (screen->display,
-                                            screen,
-                                            META_FOCUS_STAGE,
-                                            None,
-                                            timestamp);
-    }
+  meta_display_set_input_focus_xwindow (screen->display,
+                                        screen,
+                                        window,
+                                        timestamp);
 }
 
 gboolean
 meta_stage_is_focused (MetaScreen *screen)
 {
   ClutterStage *stage;
+  Window window;
+
+  if (meta_is_wayland_compositor ())
+    return TRUE;
 
   stage = CLUTTER_STAGE (meta_get_stage_for_screen (screen));
   if (!stage)
     return FALSE;
 
-  return (screen->display->focus_type == META_FOCUS_STAGE);
+  window = clutter_x11_get_stage_window (stage);
+
+  if (window == None)
+    return FALSE;
+
+  return (screen->display->focus_xwindow == window);
 }
 
 static gboolean
@@ -822,20 +832,13 @@ meta_compositor_add_window (MetaCompositor    *compositor,
 {
   MetaScreen *screen = meta_window_get_screen (window);
   MetaDisplay *display = meta_screen_get_display (screen);
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-
-  g_return_if_fail (info != NULL);
-
-  /* Window was already added previously, probably coming
-   * back from hiding */
-  if (window->compositor_private != NULL)
-    return;
 
+  DEBUG_TRACE ("meta_compositor_add_window\n");
   meta_error_trap_push (display);
-  meta_window_actor_new (window);
-  meta_error_trap_pop (display);
 
-  sync_actor_stacking (info);
+  add_win (window);
+
+  meta_error_trap_pop (display);
 }
 
 void
@@ -937,6 +940,18 @@ meta_compositor_window_opacity_changed (MetaCompositor *compositor,
   meta_window_actor_update_opacity (window_actor);
 }
 
+void
+meta_compositor_window_surface_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_surface (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

src/compositor/meta-surface-actor-wayland.c

@@ -0,0 +1,153 @@
+/* -*- 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:
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#include "config.h"
+
+#include "meta-surface-actor-wayland.h"
+
+#include <cogl/cogl-wayland-server.h>
+#include "meta-shaped-texture-private.h"
+
+struct _MetaSurfaceActorWaylandPrivate
+{
+  MetaWaylandSurface *surface;
+  MetaWaylandBuffer *buffer;
+};
+typedef struct _MetaSurfaceActorWaylandPrivate MetaSurfaceActorWaylandPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorWayland, meta_surface_actor_wayland, META_TYPE_SURFACE_ACTOR)
+
+static void
+meta_surface_actor_wayland_process_damage (MetaSurfaceActor *actor,
+                                           int x, int y, int width, int height)
+{
+  MetaSurfaceActorWayland *self = META_SURFACE_ACTOR_WAYLAND (actor);
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+
+  struct wl_resource *resource = priv->buffer->resource;
+  struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
+
+  if (shm_buffer)
+    {
+      CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
+      cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
+    }
+
+  meta_surface_actor_update_area (META_SURFACE_ACTOR (self), x, y, width, height);
+}
+
+static void
+meta_surface_actor_wayland_pre_paint (MetaSurfaceActor *actor)
+{
+}
+
+static gboolean
+meta_surface_actor_wayland_is_argb32 (MetaSurfaceActor *actor)
+{
+  /* XXX -- look at the SHM buffer format. */
+  return TRUE;
+}
+
+static gboolean
+meta_surface_actor_wayland_is_visible (MetaSurfaceActor *actor)
+{
+  /* TODO: ensure that the buffer isn't NULL, implement
+   * wayland mapping semantics */
+  return TRUE;
+}
+
+static gboolean
+meta_surface_actor_wayland_should_unredirect (MetaSurfaceActor *actor)
+{
+  return FALSE;
+}
+
+static void
+meta_surface_actor_wayland_set_unredirected (MetaSurfaceActor *actor,
+                                             gboolean          unredirected)
+{
+  /* Do nothing. In the future, we'll use KMS to set this
+   * up as a hardware overlay or something. */
+}
+
+static gboolean
+meta_surface_actor_wayland_is_unredirected (MetaSurfaceActor *actor)
+{
+  return FALSE;
+}
+
+static void
+meta_surface_actor_wayland_class_init (MetaSurfaceActorWaylandClass *klass)
+{
+  MetaSurfaceActorClass *surface_actor_class = META_SURFACE_ACTOR_CLASS (klass);
+
+  surface_actor_class->process_damage = meta_surface_actor_wayland_process_damage;
+  surface_actor_class->pre_paint = meta_surface_actor_wayland_pre_paint;
+  surface_actor_class->is_argb32 = meta_surface_actor_wayland_is_argb32;
+  surface_actor_class->is_visible = meta_surface_actor_wayland_is_visible;
+
+  surface_actor_class->should_unredirect = meta_surface_actor_wayland_should_unredirect;
+  surface_actor_class->set_unredirected = meta_surface_actor_wayland_set_unredirected;
+  surface_actor_class->is_unredirected = meta_surface_actor_wayland_is_unredirected;
+}
+
+static void
+meta_surface_actor_wayland_init (MetaSurfaceActorWayland *self)
+{
+}
+
+MetaSurfaceActor *
+meta_surface_actor_wayland_new (MetaWaylandSurface *surface)
+{
+  MetaSurfaceActorWayland *self = g_object_new (META_TYPE_SURFACE_ACTOR_WAYLAND, NULL);
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+
+  g_assert (meta_is_wayland_compositor ());
+
+  priv->surface = surface;
+
+  return META_SURFACE_ACTOR (self);
+}
+
+void
+meta_surface_actor_wayland_set_buffer (MetaSurfaceActorWayland *self,
+                                       MetaWaylandBuffer       *buffer)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+
+  priv->buffer = buffer;
+
+  if (buffer)
+    meta_shaped_texture_set_texture (stex, buffer->texture);
+  else
+    meta_shaped_texture_set_texture (stex, NULL);
+}
+
+MetaWaylandSurface *
+meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+  return priv->surface;
+}

src/compositor/meta-surface-actor-wayland.h

@@ -0,0 +1,66 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by:
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef __META_SURFACE_ACTOR_WAYLAND_H__
+#define __META_SURFACE_ACTOR_WAYLAND_H__
+
+#include <glib-object.h>
+
+#include "meta-surface-actor.h"
+
+#include "meta-wayland-private.h"
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SURFACE_ACTOR_WAYLAND            (meta_surface_actor_wayland_get_type ())
+#define META_SURFACE_ACTOR_WAYLAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR_WAYLAND, MetaSurfaceActorWayland))
+#define META_SURFACE_ACTOR_WAYLAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SURFACE_ACTOR_WAYLAND, MetaSurfaceActorWaylandClass))
+#define META_IS_SURFACE_ACTOR_WAYLAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR_WAYLAND))
+#define META_IS_SURFACE_ACTOR_WAYLAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SURFACE_ACTOR_WAYLAND))
+#define META_SURFACE_ACTOR_WAYLAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SURFACE_ACTOR_WAYLAND, MetaSurfaceActorWaylandClass))
+
+typedef struct _MetaSurfaceActorWayland      MetaSurfaceActorWayland;
+typedef struct _MetaSurfaceActorWaylandClass MetaSurfaceActorWaylandClass;
+
+struct _MetaSurfaceActorWayland
+{
+  MetaSurfaceActor parent;
+};
+
+struct _MetaSurfaceActorWaylandClass
+{
+  MetaSurfaceActorClass parent_class;
+};
+
+GType meta_surface_actor_wayland_get_type (void);
+
+MetaSurfaceActor * meta_surface_actor_wayland_new (MetaWaylandSurface *surface);
+MetaWaylandSurface * meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self);
+
+void meta_surface_actor_wayland_set_buffer (MetaSurfaceActorWayland *self,
+                                            MetaWaylandBuffer         *buffer);
+
+G_END_DECLS
+
+#endif /* __META_SURFACE_ACTOR_WAYLAND_H__ */

src/compositor/meta-surface-actor-x11.c

@@ -0,0 +1,475 @@
+/* -*- 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>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#include "config.h"
+
+#include "meta-surface-actor-x11.h"
+
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xrender.h>
+#include <cogl/cogl-texture-pixmap-x11.h>
+
+#include <meta/errors.h>
+#include "window-private.h"
+#include "meta-shaped-texture-private.h"
+#include "meta-cullable.h"
+
+struct _MetaSurfaceActorX11Private
+{
+  MetaWindow *window;
+
+  MetaDisplay *display;
+
+  CoglTexture *texture;
+  Pixmap pixmap;
+  Damage damage;
+
+  int last_width;
+  int last_height;
+
+  /* This is used to detect fullscreen windows that need to be unredirected */
+  guint full_damage_frames_count;
+  guint does_full_damage  : 1;
+
+  /* Other state... */
+  guint argb32 : 1;
+  guint received_damage : 1;
+  guint size_changed : 1;
+
+  guint unredirected   : 1;
+};
+typedef struct _MetaSurfaceActorX11Private MetaSurfaceActorX11Private;
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorX11, meta_surface_actor_x11, META_TYPE_SURFACE_ACTOR)
+
+static void
+free_damage (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (priv->damage == None)
+    return;
+
+  meta_error_trap_push (display);
+  XDamageDestroy (xdisplay, priv->damage);
+  priv->damage = None;
+  meta_error_trap_pop (display);
+}
+
+static void
+detach_pixmap (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+
+  if (priv->pixmap == None)
+    return;
+
+  /* Get rid of all references to the pixmap before freeing it; it's unclear whether
+   * you are supposed to be able to free a GLXPixmap after freeing the underlying
+   * pixmap, but it certainly doesn't work with current DRI/Mesa
+   */
+  meta_shaped_texture_set_texture (stex, NULL);
+  cogl_flush ();
+
+  meta_error_trap_push (display);
+  XFreePixmap (xdisplay, priv->pixmap);
+  priv->pixmap = None;
+  meta_error_trap_pop (display);
+
+  cogl_object_unref (priv->texture);
+  priv->texture = NULL;
+}
+
+static void
+set_pixmap (MetaSurfaceActorX11 *self,
+            Pixmap               pixmap)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  CoglContext *ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+  CoglTexture *texture;
+
+  g_assert (priv->pixmap == None);
+  priv->pixmap = pixmap;
+
+  texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, priv->pixmap, FALSE, NULL));
+
+  if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (COGL_TEXTURE_PIXMAP_X11 (texture))))
+    g_warning ("NOTE: Not using GLX TFP!\n");
+
+  priv->texture = texture;
+  meta_shaped_texture_set_texture (stex, texture);
+}
+
+static void
+update_pixmap (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (priv->size_changed)
+    {
+      detach_pixmap (self);
+      priv->size_changed = FALSE;
+    }
+
+  if (priv->pixmap == None)
+    {
+      Pixmap new_pixmap;
+      Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+
+      meta_error_trap_push (display);
+      new_pixmap = XCompositeNameWindowPixmap (xdisplay, xwindow);
+
+      if (meta_error_trap_pop_with_return (display) != Success)
+        {
+          /* Probably a BadMatch if the window isn't viewable; we could
+           * GrabServer/GetWindowAttributes/NameWindowPixmap/UngrabServer/Sync
+           * to avoid this, but there's no reason to take two round trips
+           * when one will do. (We need that Sync if we want to handle failures
+           * for any reason other than !viewable. That's unlikely, but maybe
+           * we'll BadAlloc or something.)
+           */
+          new_pixmap = None;
+        }
+
+      if (new_pixmap == None)
+        {
+          meta_verbose ("Unable to get named pixmap for %s\n",
+                        meta_window_get_description (priv->window));
+          return;
+        }
+
+      set_pixmap (self, new_pixmap);
+    }
+}
+
+static gboolean
+is_visible (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  return (priv->pixmap != None) && !priv->unredirected;
+}
+
+static void
+damage_area (MetaSurfaceActorX11 *self,
+             int x, int y, int width, int height)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  if (!is_visible (self))
+    return;
+
+  cogl_texture_pixmap_x11_update_area (priv->texture, x, y, width, height);
+  meta_surface_actor_update_area (META_SURFACE_ACTOR (self), x, y, width, height);
+}
+
+static void
+meta_surface_actor_x11_process_damage (MetaSurfaceActor *actor,
+                                       int x, int y, int width, int height)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  priv->received_damage = TRUE;
+
+  if (meta_window_is_fullscreen (priv->window) && !priv->unredirected && !priv->does_full_damage)
+    {
+      MetaRectangle window_rect;
+      meta_window_get_frame_rect (priv->window, &window_rect);
+
+      if (window_rect.x == x &&
+          window_rect.y == y &&
+          window_rect.width == width &&
+          window_rect.height == height)
+        priv->full_damage_frames_count++;
+      else
+        priv->full_damage_frames_count = 0;
+
+      if (priv->full_damage_frames_count >= 100)
+        priv->does_full_damage = TRUE;
+    }
+
+  /* Drop damage event for unredirected windows */
+  if (priv->unredirected)
+    return;
+
+  damage_area (self, x, y, width, height);
+}
+
+static void
+meta_surface_actor_x11_pre_paint (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (priv->received_damage)
+    {
+      meta_error_trap_push (display);
+      XDamageSubtract (xdisplay, priv->damage, None, None);
+      meta_error_trap_pop (display);
+
+      /* We need to make sure that any X drawing that happens before the
+       * XDamageSubtract() above is visible to subsequent GL rendering;
+       * the only standardized way to do this is EXT_x11_sync_object,
+       * which isn't yet widely available. For now, we count on details
+       * of Xorg and the open source drivers, and hope for the best
+       * otherwise.
+       *
+       * Xorg and open source driver specifics:
+       *
+       * The X server makes sure to flush drawing to the kernel before
+       * sending out damage events, but since we use DamageReportBoundingBox
+       * there may be drawing between the last damage event and the
+       * XDamageSubtract() that needs to be flushed as well.
+       *
+       * Xorg always makes sure that drawing is flushed to the kernel
+       * before writing events or responses to the client, so any round trip
+       * request at this point is sufficient to flush the GLX buffers.
+       */
+      XSync (xdisplay, False);
+
+      priv->received_damage = FALSE;
+    }
+
+  update_pixmap (self);
+}
+
+static void
+update_is_argb32 (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  XRenderPictFormat *format;
+  format = XRenderFindVisualFormat (xdisplay, priv->window->xvisual);
+
+  priv->argb32 = (format && format->type == PictTypeDirect && format->direct.alphaMask);
+}
+
+static gboolean
+meta_surface_actor_x11_is_argb32 (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  return priv->argb32;
+}
+
+static gboolean
+meta_surface_actor_x11_is_visible (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  return is_visible (self);
+}
+
+static gboolean
+meta_surface_actor_x11_should_unredirect (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  MetaWindow *window = priv->window;
+
+  if (meta_window_requested_dont_bypass_compositor (window))
+    return FALSE;
+
+  if (window->opacity != 0xFF)
+    return FALSE;
+
+  if (window->shape_region != NULL)
+    return FALSE;
+
+  if (priv->argb32 && !meta_window_requested_bypass_compositor (window))
+    return FALSE;
+
+  if (!meta_window_is_monitor_sized (window))
+    return FALSE;
+
+  if (meta_window_requested_bypass_compositor (window))
+    return TRUE;
+
+  if (meta_window_is_override_redirect (window))
+    return TRUE;
+
+  if (priv->does_full_damage)
+    return TRUE;
+
+  return FALSE;
+}
+
+static void
+sync_unredirected (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = priv->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+
+  meta_error_trap_push (display);
+
+  if (priv->unredirected)
+    {
+      detach_pixmap (self);
+      XCompositeUnredirectWindow (xdisplay, xwindow, CompositeRedirectManual);
+    }
+  else
+    {
+      XCompositeRedirectWindow (xdisplay, xwindow, CompositeRedirectManual);
+    }
+
+  meta_error_trap_pop (display);
+}
+
+static void
+meta_surface_actor_x11_set_unredirected (MetaSurfaceActor *actor,
+                                         gboolean          unredirected)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  if (priv->unredirected == unredirected)
+    return;
+
+  priv->unredirected = unredirected;
+  sync_unredirected (self);
+}
+
+static gboolean
+meta_surface_actor_x11_is_unredirected (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (actor);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  return priv->unredirected;
+}
+
+static void
+meta_surface_actor_x11_dispose (GObject *object)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (object);
+
+  detach_pixmap (self);
+  free_damage (self);
+
+  G_OBJECT_CLASS (meta_surface_actor_x11_parent_class)->dispose (object);
+}
+
+static void
+meta_surface_actor_x11_class_init (MetaSurfaceActorX11Class *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  MetaSurfaceActorClass *surface_actor_class = META_SURFACE_ACTOR_CLASS (klass);
+
+  object_class->dispose = meta_surface_actor_x11_dispose;
+
+  surface_actor_class->process_damage = meta_surface_actor_x11_process_damage;
+  surface_actor_class->pre_paint = meta_surface_actor_x11_pre_paint;
+  surface_actor_class->is_argb32 = meta_surface_actor_x11_is_argb32;
+  surface_actor_class->is_visible = meta_surface_actor_x11_is_visible;
+
+  surface_actor_class->should_unredirect = meta_surface_actor_x11_should_unredirect;
+  surface_actor_class->set_unredirected = meta_surface_actor_x11_set_unredirected;
+  surface_actor_class->is_unredirected = meta_surface_actor_x11_is_unredirected;
+}
+
+static void
+meta_surface_actor_x11_init (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  priv->last_width = -1;
+  priv->last_height = -1;
+}
+
+static void
+create_damage (MetaSurfaceActorX11 *self)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  Display *xdisplay = meta_display_get_xdisplay (priv->display);
+  Window xwindow = meta_window_get_toplevel_xwindow (priv->window);
+
+  priv->damage = XDamageCreate (xdisplay, xwindow, XDamageReportBoundingBox);
+}
+
+static void
+window_decorated_notify (MetaWindow *window,
+                         GParamSpec *pspec,
+                         gpointer    user_data)
+{
+  MetaSurfaceActorX11 *self = META_SURFACE_ACTOR_X11 (user_data);
+
+  free_damage (self);
+  create_damage (self);
+}
+
+MetaSurfaceActor *
+meta_surface_actor_x11_new (MetaWindow *window)
+{
+  MetaSurfaceActorX11 *self = g_object_new (META_TYPE_SURFACE_ACTOR_X11, NULL);
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+  MetaDisplay *display = meta_window_get_display (window);
+
+  g_assert (!meta_is_wayland_compositor ());
+
+  priv->window = window;
+  priv->display = display;
+
+  create_damage (self);
+  g_signal_connect_object (priv->window, "notify::decorated",
+                           G_CALLBACK (window_decorated_notify), self, 0);
+
+  update_is_argb32 (self);
+
+  priv->unredirected = FALSE;
+  sync_unredirected (self);
+
+  return META_SURFACE_ACTOR (self);
+}
+
+void
+meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self,
+                                 int width, int height)
+{
+  MetaSurfaceActorX11Private *priv = meta_surface_actor_x11_get_instance_private (self);
+
+  if (priv->last_width == width &&
+      priv->last_height == height)
+    return;
+
+  priv->size_changed = TRUE;
+  priv->last_width = width;
+  priv->last_height = height;
+}

src/compositor/meta-surface-actor-x11.h

@@ -0,0 +1,69 @@
+/* -*- 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>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef __META_SURFACE_ACTOR_X11_H__
+#define __META_SURFACE_ACTOR_X11_H__
+
+#include <glib-object.h>
+
+#include "meta-surface-actor.h"
+
+#include <X11/extensions/Xdamage.h>
+
+#include <meta/display.h>
+#include <meta/window.h>
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SURFACE_ACTOR_X11            (meta_surface_actor_x11_get_type ())
+#define META_SURFACE_ACTOR_X11(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11))
+#define META_SURFACE_ACTOR_X11_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11Class))
+#define META_IS_SURFACE_ACTOR_X11(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR_X11))
+#define META_IS_SURFACE_ACTOR_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SURFACE_ACTOR_X11))
+#define META_SURFACE_ACTOR_X11_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11Class))
+
+typedef struct _MetaSurfaceActorX11      MetaSurfaceActorX11;
+typedef struct _MetaSurfaceActorX11Class MetaSurfaceActorX11Class;
+
+struct _MetaSurfaceActorX11
+{
+  MetaSurfaceActor parent;
+};
+
+struct _MetaSurfaceActorX11Class
+{
+  MetaSurfaceActorClass parent_class;
+};
+
+GType meta_surface_actor_x11_get_type (void);
+
+MetaSurfaceActor * meta_surface_actor_x11_new (MetaWindow *window);
+
+void meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self,
+                                      int width, int height);
+
+G_END_DECLS
+
+#endif /* __META_SURFACE_ACTOR_X11_H__ */

src/compositor/meta-surface-actor.c

@@ -10,30 +10,38 @@
  */
 
 #include <config.h>
-#include <clutter/clutter.h>
-#include <cogl/cogl-wayland-server.h>
-#include <cogl/cogl-texture-pixmap-x11.h>
-#include <meta/meta-shaped-texture.h>
+
 #include "meta-surface-actor.h"
+
+#include <clutter/clutter.h>
+#include <meta/meta-shaped-texture.h>
 #include "meta-wayland-private.h"
 #include "meta-cullable.h"
-
 #include "meta-shaped-texture-private.h"
 
 struct _MetaSurfaceActorPrivate
 {
-  MetaWaylandSurface *surface;
-
   MetaShapedTexture *texture;
-  MetaWaylandBuffer *buffer;
 
   cairo_region_t *input_region;
+
+  /* Freeze/thaw accounting */
+  guint needs_damage_all : 1;
+  guint frozen : 1;
 };
 
 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));
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
+                                  G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+
+enum {
+  REPAINT_SCHEDULED,
+
+  LAST_SIGNAL,
+};
+
+static guint signals[LAST_SIGNAL];
 
 gboolean
 meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
@@ -114,6 +122,13 @@ meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
   object_class->dispose = meta_surface_actor_dispose;
   actor_class->pick = meta_surface_actor_pick;
 
+  signals[REPAINT_SCHEDULED] = g_signal_new ("repaint-scheduled",
+                                             G_TYPE_FROM_CLASS (object_class),
+                                             G_SIGNAL_RUN_LAST,
+                                             0,
+                                             NULL, NULL, NULL,
+                                             G_TYPE_NONE, 0);
+
   g_type_class_add_private (klass, sizeof (MetaSurfaceActorPrivate));
 }
 
@@ -164,51 +179,14 @@ meta_surface_actor_get_texture (MetaSurfaceActor *self)
   return self->priv->texture;
 }
 
-static void
-update_area (MetaSurfaceActor *self,
-             int x, int y, int width, int height)
+void
+meta_surface_actor_update_area (MetaSurfaceActor *self,
+                                int x, int y, int width, int height)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
 
-  if (meta_is_wayland_compositor ())
-    {
-      struct wl_resource *resource = priv->buffer->resource;
-      struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
-
-      if (shm_buffer)
-        {
-          CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
-          cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
-        }
-    }
-  else
-    {
-      CoglTexturePixmapX11 *texture = COGL_TEXTURE_PIXMAP_X11 (meta_shaped_texture_get_texture (priv->texture));
-      cogl_texture_pixmap_x11_update_area (texture, x, y, width, height);
-    }
-}
-
-gboolean
-meta_surface_actor_damage_all (MetaSurfaceActor *self)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  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 (priv->texture, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
-}
-
-gboolean
-meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                int               x,
-                                int               y,
-                                int               width,
-                                int               height)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-
-  update_area (self, x, y, width, height);
-  return meta_shaped_texture_update_area (priv->texture, x, y, width, height);
+  if (meta_shaped_texture_update_area (priv->texture, x, y, width, height))
+    g_signal_emit (self, signals[REPAINT_SCHEDULED], 0);
 }
 
 gboolean
@@ -218,27 +196,6 @@ meta_surface_actor_is_obscured (MetaSurfaceActor *self)
   return meta_shaped_texture_is_obscured (priv->texture);
 }
 
-void
-meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor *self,
-                                          MetaWaylandBuffer *buffer)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  priv->buffer = buffer;
-
-  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)
-{
-  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)
@@ -262,20 +219,96 @@ meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
   meta_shaped_texture_set_opaque_region (priv->texture, region);
 }
 
-MetaWaylandSurface *
-meta_surface_actor_get_surface (MetaSurfaceActor *self)
+static gboolean
+is_frozen (MetaSurfaceActor *self)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
-  return priv->surface;
+  return priv->frozen;
 }
 
-MetaSurfaceActor *
-meta_surface_actor_new (MetaWaylandSurface *surface)
+void
+meta_surface_actor_process_damage (MetaSurfaceActor *self,
+                                   int x, int y, int width, int height)
 {
-  MetaSurfaceActor *self = g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
   MetaSurfaceActorPrivate *priv = self->priv;
 
-  priv->surface = surface;
+  if (is_frozen (self))
+    {
+      /* The window is frozen due to an effect in progress: we ignore damage
+       * here on the off chance that this will stop the corresponding
+       * texture_from_pixmap from being update.
+       *
+       * needs_damage_all tracks that some unknown damage happened while the
+       * window was frozen so that when the window becomes unfrozen we can
+       * issue a full window update to cover any lost damage.
+       *
+       * It should be noted that this is an unreliable mechanism since it's
+       * quite likely that drivers will aim to provide a zero-copy
+       * implementation of the texture_from_pixmap extension and in those cases
+       * any drawing done to the window is always immediately reflected in the
+       * texture regardless of damage event handling.
+       */
+      priv->needs_damage_all = TRUE;
+      return;
+    }
 
-  return self;
+  META_SURFACE_ACTOR_GET_CLASS (self)->process_damage (self, x, y, width, height);
+}
+
+void
+meta_surface_actor_pre_paint (MetaSurfaceActor *self)
+{
+  META_SURFACE_ACTOR_GET_CLASS (self)->pre_paint (self);
+}
+
+gboolean
+meta_surface_actor_is_argb32 (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_argb32 (self);
+}
+
+gboolean
+meta_surface_actor_is_visible (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_visible (self);
+}
+
+void
+meta_surface_actor_set_frozen (MetaSurfaceActor *self,
+                               gboolean          frozen)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  priv->frozen = frozen;
+
+  if (!frozen && priv->needs_damage_all)
+    {
+      /* Since we ignore damage events while a window is frozen for certain effects
+       * we may need to issue an update_area() covering the whole pixmap if we
+       * don't know what real damage has happened. */
+
+      meta_surface_actor_process_damage (self, 0, 0,
+                                         clutter_actor_get_width (CLUTTER_ACTOR (priv->texture)),
+                                         clutter_actor_get_height (CLUTTER_ACTOR (priv->texture)));
+      priv->needs_damage_all = FALSE;
+    }
+}
+
+gboolean
+meta_surface_actor_should_unredirect (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->should_unredirect (self);
+}
+
+void
+meta_surface_actor_set_unredirected (MetaSurfaceActor *self,
+                                     gboolean          unredirected)
+{
+  META_SURFACE_ACTOR_GET_CLASS (self)->set_unredirected (self, unredirected);
+}
+
+gboolean
+meta_surface_actor_is_unredirected (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_unredirected (self);
 }

src/compositor/meta-surface-actor.h

@@ -6,7 +6,6 @@
 #include <config.h>
 
 #include <meta/meta-shaped-texture.h>
-#include "meta-wayland-types.h"
 
 G_BEGIN_DECLS
 
@@ -25,6 +24,17 @@ struct _MetaSurfaceActorClass
 {
   /*< private >*/
   ClutterActorClass parent_class;
+
+  void     (* process_damage)    (MetaSurfaceActor *actor,
+                                  int x, int y, int width, int height);
+  void     (* pre_paint)         (MetaSurfaceActor *actor);
+  gboolean (* is_argb32)         (MetaSurfaceActor *actor);
+  gboolean (* is_visible)        (MetaSurfaceActor *actor);
+
+  gboolean (* should_unredirect) (MetaSurfaceActor *actor);
+  void     (* set_unredirected)  (MetaSurfaceActor *actor,
+                                  gboolean          unredirected);
+  gboolean (* is_unredirected)   (MetaSurfaceActor *actor);
 };
 
 struct _MetaSurfaceActor
@@ -36,34 +46,36 @@ struct _MetaSurfaceActor
 
 GType meta_surface_actor_get_type (void);
 
-MetaSurfaceActor *meta_surface_actor_new (MetaWaylandSurface *surface);
-
 cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,
                                                cairo_rectangle_int_t *clip);
 
 MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);
 
-gboolean meta_surface_actor_damage_all  (MetaSurfaceActor *self);
-gboolean meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                         int               x,
-                                         int               y,
-                                         int               width,
-                                         int               height);
-
 gboolean meta_surface_actor_is_obscured (MetaSurfaceActor *self);
 gboolean meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
                                                    cairo_rectangle_int_t *unobscured_bounds);
 
-void meta_surface_actor_set_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);
 
-MetaWaylandSurface *meta_surface_actor_get_surface (MetaSurfaceActor *surface);
+void meta_surface_actor_update_area (MetaSurfaceActor *actor,
+                                     int x, int y, int width, int height);
+
+void meta_surface_actor_process_damage (MetaSurfaceActor *actor,
+                                        int x, int y, int width, int height);
+void meta_surface_actor_pre_paint (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_argb32 (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_visible (MetaSurfaceActor *actor);
+
+void meta_surface_actor_set_frozen (MetaSurfaceActor *actor,
+                                    gboolean          frozen);
+
+gboolean meta_surface_actor_should_unredirect (MetaSurfaceActor *actor);
+void meta_surface_actor_set_unredirected (MetaSurfaceActor *actor,
+                                          gboolean          unredirected);
+gboolean meta_surface_actor_is_unredirected (MetaSurfaceActor *actor);
 
 G_END_DECLS
 

src/compositor/meta-window-actor-private.h

@@ -63,5 +63,6 @@ void meta_window_actor_effect_completed (MetaWindowActor *actor,
                                          gulong           event);
 
 MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self);
+void meta_window_actor_update_surface (MetaWindowActor *self);
 
 #endif /* META_WINDOW_ACTOR_PRIVATE_H */

src/core/display-private.h

@@ -84,14 +84,6 @@ typedef enum {
   META_TILE_MAXIMIZED
 } MetaTileMode;
 
-typedef enum {
-  META_FOCUS_NONE = 0,
-  META_FOCUS_X_CLIENT = 1,
-  META_FOCUS_WAYLAND_CLIENT = 2,
-  META_FOCUS_NO_FOCUS_WINDOW = 3,
-  META_FOCUS_STAGE = 4
-} MetaFocusType;
-
 struct _MetaDisplay
 {
   GObject parent_instance;
@@ -125,7 +117,6 @@ struct _MetaDisplay
    * like the no_focus_window or the stage X window. */
   Window focus_xwindow;
   gulong focus_serial;
-  MetaFocusType focus_type;
 
   /* last timestamp passed to XSetInputFocus */
   guint32 last_focus_time;
@@ -493,10 +484,9 @@ gboolean meta_display_process_barrier_event (MetaDisplay *display,
                                              XIEvent     *event);
 #endif /* HAVE_XI23 */
 
-void meta_display_set_input_focus_xwindow (MetaDisplay   *display,
-                                           MetaScreen    *screen,
-                                           MetaFocusType  type,
-                                           Window         window,
-                                           guint32        timestamp);
+void meta_display_set_input_focus_xwindow (MetaDisplay *display,
+                                           MetaScreen  *screen,
+                                           Window       window,
+                                           guint32      timestamp);
 
 #endif

src/core/display.c

@@ -73,6 +73,7 @@
 #include <unistd.h>
 
 #include "meta-xwayland-private.h"
+#include "meta-surface-actor-wayland.h"
 
 #define GRAB_OP_IS_WINDOW_SWITCH(g)                     \
         (g == META_GRAB_OP_KEYBOARD_TABBING_NORMAL  ||  \
@@ -1682,9 +1683,9 @@ get_window_for_event (MetaDisplay        *display,
     return display->grab_window;
 
   source = clutter_event_get_source (event);
-  if (META_IS_SURFACE_ACTOR (source))
+  if (META_IS_SURFACE_ACTOR_WAYLAND (source))
     {
-      MetaWaylandSurface *surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (source));
+      MetaWaylandSurface *surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (source));
       g_assert (surface != NULL);
       return surface->window;
     }
@@ -1745,12 +1746,11 @@ get_input_event (MetaDisplay *display,
 }
 
 static void
-update_focus_window (MetaDisplay   *display,
-                     MetaFocusType  type,
-                     MetaWindow    *window,
-                     Window         xwindow,
-                     gulong         serial,
-                     gboolean       focused_by_us)
+update_focus_window (MetaDisplay *display,
+                     MetaWindow  *window,
+                     Window       xwindow,
+                     gulong       serial,
+                     gboolean     focused_by_us)
 {
   MetaWaylandCompositor *compositor;
 
@@ -1758,7 +1758,6 @@ update_focus_window (MetaDisplay   *display,
   display->focused_by_us = focused_by_us;
 
   if (display->focus_xwindow == xwindow &&
-      display->focus_type == type &&
       display->focus_window == window)
     return;
 
@@ -1781,7 +1780,6 @@ update_focus_window (MetaDisplay   *display,
       meta_window_set_focused_internal (previous, FALSE);
     }
 
-  display->focus_type = type;
   display->focus_window = window;
   display->focus_xwindow = xwindow;
 
@@ -1808,8 +1806,7 @@ update_focus_window (MetaDisplay   *display,
     {
       compositor = meta_wayland_compositor_get_default ();
 
-      if (display->focus_type == META_FOCUS_NO_FOCUS_WINDOW ||
-          display->focus_type == META_FOCUS_STAGE)
+      if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
         meta_wayland_compositor_set_input_focus (compositor, NULL);
       else if (window && window->surface)
         meta_wayland_compositor_set_input_focus (compositor, window);
@@ -1851,12 +1848,11 @@ timestamp_too_old (MetaDisplay *display,
 }
 
 static void
-request_xserver_input_focus_change (MetaDisplay   *display,
-                                    MetaScreen    *screen,
-                                    MetaFocusType  type,
-                                    MetaWindow    *meta_window,
-                                    Window         xwindow,
-                                    guint32        timestamp)
+request_xserver_input_focus_change (MetaDisplay *display,
+                                    MetaScreen  *screen,
+                                    MetaWindow  *meta_window,
+                                    Window       xwindow,
+                                    guint32      timestamp)
 {
   gulong serial;
 
@@ -1889,7 +1885,6 @@ request_xserver_input_focus_change (MetaDisplay   *display,
   meta_display_ungrab (display);
 
   update_focus_window (display,
-                       type,
                        meta_window,
                        xwindow,
                        serial,
@@ -1911,12 +1906,9 @@ handle_window_focus_event (MetaDisplay  *display,
                            unsigned long serial)
 {
   MetaWindow *focus_window;
-  MetaFocusType type;
 #ifdef WITH_VERBOSE_MODE
   const char *window_type;
 
-  type = META_FOCUS_NONE;
-
   /* Note the event can be on either the window or the frame,
    * we focus the frame for shaded windows
    */
@@ -1928,26 +1920,14 @@ handle_window_focus_event (MetaDisplay  *display,
         window_type = "frame window";
       else
         window_type = "unknown client window";
-
-      if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-        type = META_FOCUS_WAYLAND_CLIENT;
-      else
-        type = META_FOCUS_X_CLIENT;
     }
   else if (meta_display_xwindow_is_a_no_focus_window (display, event->event))
-    {
-      window_type = "no_focus_window";
-      type = META_FOCUS_NO_FOCUS_WINDOW;
-    }
+    window_type = "no_focus_window";
   else if (meta_display_screen_for_root (display, event->event))
     window_type = "root window";
   else
     window_type = "unknown window";
 
-  /* Don't change type if we don't know the new window */
-  if (type == META_FOCUS_NONE)
-    type = display->focus_type;
-
   meta_topic (META_DEBUG_FOCUS,
               "Focus %s event received on %s 0x%lx (%s) "
               "mode %s detail %s serial %lu\n",
@@ -2032,7 +2012,6 @@ handle_window_focus_event (MetaDisplay  *display,
        display->server_focus_serial == display->focus_serial))
     {
       update_focus_window (display,
-                           type,
                            focus_window,
                            focus_window ? focus_window->xwindow : None,
                            display->server_focus_serial,
@@ -3281,7 +3260,6 @@ meta_display_handle_xevent (MetaDisplay *display,
       meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                   display->focus_window->desc);
       update_focus_window (display,
-                           META_FOCUS_NONE,
                            meta_display_lookup_x_window (display, display->server_focus_window),
                            display->server_focus_window,
                            display->server_focus_serial,
@@ -5950,8 +5928,6 @@ meta_display_set_input_focus_window (MetaDisplay *display,
 {
   request_xserver_input_focus_change (display,
                                       window->screen,
-                                      window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND ?
-                                      META_FOCUS_WAYLAND_CLIENT : META_FOCUS_X_CLIENT,
                                       window,
                                       focus_frame ? window->frame->xwindow : window->xwindow,
                                       timestamp);
@@ -5974,15 +5950,13 @@ meta_display_request_take_focus (MetaDisplay *display,
 }
 
 void
-meta_display_set_input_focus_xwindow (MetaDisplay   *display,
-                                      MetaScreen    *screen,
-                                      MetaFocusType  type,
-                                      Window         window,
-                                      guint32        timestamp)
+meta_display_set_input_focus_xwindow (MetaDisplay *display,
+                                      MetaScreen  *screen,
+                                      Window       window,
+                                      guint32      timestamp)
 {
   request_xserver_input_focus_change (display,
                                       screen,
-                                      type,
                                       NULL,
                                       window,
                                       timestamp);
@@ -5995,7 +5969,6 @@ meta_display_focus_the_no_focus_window (MetaDisplay *display,
 {
   request_xserver_input_focus_change (display,
                                       screen,
-                                      META_FOCUS_NO_FOCUS_WINDOW,
                                       NULL,
                                       screen->no_focus_window,
                                       timestamp);

src/core/meta-idle-monitor.c

@@ -653,8 +653,10 @@ meta_idle_monitor_remove_watch (MetaIdleMonitor *monitor,
 {
   g_return_if_fail (META_IS_IDLE_MONITOR (monitor));
 
+  g_object_ref (monitor);
   g_hash_table_remove (monitor->watches,
                        GUINT_TO_POINTER (id));
+  g_object_unref (monitor);
 }
 
 /**

src/core/stack-tracker.c

@@ -1041,7 +1041,7 @@ stack_tracker_event_received (MetaStackTracker *tracker,
 
   if (op->any.serial < tracker->xserver_serial)
     {
-      g_warning ("Spurious X event received affecting stack; doing full re-query");
+      /* g_warning ("Spurious X event received affecting stack; doing full re-query"); */
       resync_verified_stack_with_xserver_stack (tracker);
       meta_stack_tracker_dump (tracker);
       return;

src/core/window-x11.c

@@ -350,11 +350,43 @@ meta_window_set_input_region (MetaWindow     *window,
     meta_compositor_window_shape_changed (window->display->compositor, window);
 }
 
+#if 0
+/* Print out a region; useful for debugging */
+static void
+print_region (cairo_region_t *region)
+{
+  int n_rects;
+  int i;
+
+  n_rects = cairo_region_num_rectangles (region);
+  g_print ("[");
+  for (i = 0; i < n_rects; i++)
+    {
+      cairo_rectangle_int_t rect;
+      cairo_region_get_rectangle (region, i, &rect);
+      g_print ("+%d+%dx%dx%d ",
+               rect.x, rect.y, rect.width, rect.height);
+    }
+  g_print ("]\n");
+}
+#endif
+
 void
 meta_window_x11_update_input_region (MetaWindow *window)
 {
   cairo_region_t *region = NULL;
 
+  /* Decorated windows don't have an input region, because
+     we don't shape the frame to match the client windows
+     (so the events are blocked by the frame anyway)
+  */
+  if (window->decorated)
+    {
+      if (window->input_region)
+        meta_window_set_input_region (window, NULL);
+      return;
+    }
+
 #ifdef HAVE_SHAPE
   if (META_DISPLAY_HAS_SHAPE (window->display))
     {
@@ -363,17 +395,6 @@ meta_window_x11_update_input_region (MetaWindow *window)
       XRectangle *rects = NULL;
       int n_rects, ordering;
 
-      int x_bounding, y_bounding, x_clip, y_clip;
-      unsigned w_bounding, h_bounding, w_clip, h_clip;
-      int bounding_shaped, clip_shaped;
-
-      meta_error_trap_push (window->display);
-      XShapeQueryExtents (window->display->xdisplay, window->xwindow,
-                          &bounding_shaped, &x_bounding, &y_bounding,
-                          &w_bounding, &h_bounding,
-                          &clip_shaped, &x_clip, &y_clip,
-                          &w_clip, &h_clip);
-
       rects = XShapeGetRectangles (window->display->xdisplay,
                                    window->xwindow,
                                    ShapeInput,
@@ -388,10 +409,10 @@ meta_window_x11_update_input_region (MetaWindow *window)
         {
           if (n_rects > 1 ||
               (n_rects == 1 &&
-               (rects[0].x != x_bounding ||
-                rects[0].y != y_bounding ||
-                rects[0].width != w_bounding ||
-                rects[0].height != h_bounding)))
+               (rects[0].x != 0 ||
+                rects[0].y != 0 ||
+                rects[0].width != window->rect.width ||
+                rects[0].height != window->rect.height)))
             region = region_create_from_x_rectangles (rects, n_rects);
 
           XFree (rects);
@@ -1453,6 +1474,11 @@ meta_window_x11_new (MetaDisplay       *display,
     XISelectEvents (display->xdisplay, xwindow, &mask, 1);
   }
 
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display))
+    XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
+#endif
+
   /* Get rid of any borders */
   if (attrs.border_width != 0)
     XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
@@ -1485,14 +1511,7 @@ meta_window_x11_new (MetaDisplay       *display,
                                     existing_wm_state,
                                     effect,
                                     &attrs);
-
-  /* When running as an X compositor, we can simply show the window now.
-   *
-   * When running as a Wayland compositor, we need to wait until we see
-   * the Wayland surface appear. We will later call meta_window_set_surface_mapped()
-   * to show the window in our in our set_surface_id implementation */
-  if (!meta_is_wayland_compositor ())
-    meta_window_set_surface_mapped (window, TRUE);
+  meta_window_set_surface_mapped (window, TRUE);
 
   meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
   return window;

src/core/window.c

@@ -1217,6 +1217,9 @@ _meta_window_shared_new (MetaDisplay         *display,
       set_net_wm_state (window);
     }
 
+  if (screen->display->compositor)
+    meta_compositor_add_window (screen->display->compositor, window);
+
   /* Sync stack changes */
   meta_stack_thaw (window->screen->stack);
 
@@ -2769,8 +2772,8 @@ meta_window_show (MetaWindow *window)
               break;
             }
 
-          meta_compositor_add_window (window->display->compositor, window);
-          meta_compositor_show_window (window->display->compositor, window, effect);
+          meta_compositor_show_window (window->display->compositor,
+                                       window, effect);
         }
     }
 

src/meta/compositor.h

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

src/org.gnome.mutter.wayland.gschema.xml.in

@@ -2,31 +2,31 @@
   <schema id="org.gnome.mutter.wayland.keybindings" path="/org/gnome/mutter/wayland/keybindings/"
 	  gettext-domain="@GETTEXT_DOMAIN@">
     <key name="switch-to-session-1" type="as">
-      <default><![CDATA[['<Primary><Alt>F1']]]></default>
+      <default><![CDATA[['<Primary><Alt>F1', 'XF86Switch_VT_1']]]></default>
       <_summary>Switch to VT 1</_summary>
     </key>
     <key name="switch-to-session-2" type="as">
-      <default><![CDATA[['<Primary><Alt>F2']]]></default>
+      <default><![CDATA[['<Primary><Alt>F2', 'XF86Switch_VT_2']]]></default>
       <_summary>Switch to VT 2</_summary>
     </key>
     <key name="switch-to-session-3" type="as">
-      <default><![CDATA[['<Primary><Alt>F3']]]></default>
+      <default><![CDATA[['<Primary><Alt>F3', 'XF86Switch_VT_3']]]></default>
       <_summary>Switch to VT 3</_summary>
     </key>
     <key name="switch-to-session-4" type="as">
-      <default><![CDATA[['<Primary><Alt>F4']]]></default>
+      <default><![CDATA[['<Primary><Alt>F4', 'XF86Switch_VT_4']]]></default>
       <_summary>Switch to VT 4</_summary>
     </key>
     <key name="switch-to-session-5" type="as">
-      <default><![CDATA[['<Primary><Alt>F5']]]></default>
+      <default><![CDATA[['<Primary><Alt>F5', 'XF86Switch_VT_5']]]></default>
       <_summary>Switch to VT 5</_summary>
     </key>
     <key name="switch-to-session-6" type="as">
-      <default><![CDATA[['<Primary><Alt>F6']]]></default>
+      <default><![CDATA[['<Primary><Alt>F6', 'XF86Switch_VT_6']]]></default>
       <_summary>Switch to VT 6</_summary>
     </key>
     <key name="switch-to-session-7" type="as">
-      <default><![CDATA[['<Primary><Alt>F7']]]></default>
+      <default><![CDATA[['<Primary><Alt>F7', 'XF86Switch_VT_7']]]></default>
       <_summary>Switch to VT 7</_summary>
     </key>
   </schema>

src/wayland/meta-wayland-keyboard.c

@@ -217,28 +217,28 @@ err_keymap_str:
   return;
 }
 
-static void
-release_focus (MetaWaylandKeyboard *keyboard)
-{
-  wl_list_remove (&keyboard->focus_surface_listener.link);
-  wl_list_remove (&keyboard->focus_resource_listener.link);
-
-  keyboard->focus_resource = NULL;
-  keyboard->focus_surface = NULL;
-}
-
 static void
 keyboard_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_surface_listener);
-  release_focus (keyboard);
+
+  wl_list_remove (&keyboard->focus_surface_listener.link);
+  keyboard->focus_surface = NULL;
+
+  if (keyboard->focus_resource)
+    {
+      wl_list_remove (&keyboard->focus_resource_listener.link);
+      keyboard->focus_resource = NULL;
+    }
 }
 
 static void
 keyboard_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_resource_listener);
-  release_focus (keyboard);
+
+  wl_list_remove (&keyboard->focus_resource_listener.link);
+  keyboard->focus_resource = NULL;
 }
 
 static gboolean

src/wayland/meta-wayland-pointer.c

@@ -55,28 +55,28 @@
 
 static void meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer);
 
-static void
-release_focus (MetaWaylandPointer *pointer)
-{
-  wl_list_remove (&pointer->focus_surface_listener.link);
-  wl_list_remove (&pointer->focus_resource_listener.link);
-
-  pointer->focus_resource = NULL;
-  pointer->focus_surface = NULL;
-}
-
 static void
 pointer_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_surface_listener);
-  release_focus (pointer);
+
+  wl_list_remove (&pointer->focus_surface_listener.link);
+  pointer->focus_surface = NULL;
+
+  if (pointer->focus_resource)
+    {
+      wl_list_remove (&pointer->focus_resource_listener.link);
+      pointer->focus_resource = NULL;
+    }
 }
 
 static void
 pointer_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_resource_listener);
-  release_focus (pointer);
+
+  wl_list_remove (&pointer->focus_resource_listener.link);
+  pointer->focus_resource = NULL;
 }
 
 static void
@@ -302,7 +302,7 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer)
 void
 meta_wayland_pointer_release (MetaWaylandPointer *pointer)
 {
-  release_focus (pointer);
+  /* Do nothing. */
 }
 
 static struct wl_resource *

src/wayland/meta-wayland-seat.c

@@ -38,6 +38,7 @@
 #include "meta-shaped-texture-private.h"
 #include "meta-wayland-stage.h"
 #include "meta-cursor-tracker-private.h"
+#include "meta-surface-actor-wayland.h"
 
 #define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int (10)
 
@@ -420,8 +421,8 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
   else
     seat->current_stage = NULL;
 
-  if (META_IS_SURFACE_ACTOR (actor))
-    surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (actor));
+  if (META_IS_SURFACE_ACTOR_WAYLAND (actor))
+    surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (actor));
 
   pointer->current = surface;
   if (surface != pointer->focus_surface)

src/wayland/meta-wayland-surface.c

@@ -44,11 +44,11 @@
 #include "meta-wayland-private.h"
 #include "meta-xwayland-private.h"
 #include "meta-wayland-stage.h"
-#include "meta-surface-actor.h"
 #include "meta-wayland-seat.h"
 #include "meta-wayland-keyboard.h"
 #include "meta-wayland-pointer.h"
 #include "meta-wayland-data-device.h"
+
 #include "meta-cursor-tracker-private.h"
 #include "display-private.h"
 #include "window-private.h"
@@ -58,6 +58,9 @@
 #include "meta-idle-monitor-private.h"
 #include "monitor-private.h"
 
+#include "meta-surface-actor.h"
+#include "meta-surface-actor-wayland.h"
+
 typedef enum
 {
   META_WAYLAND_SUBSURFACE_PLACEMENT_ABOVE,
@@ -114,8 +117,8 @@ surface_process_damage (MetaWaylandSurface *surface,
     {
       cairo_rectangle_int_t rect;
       cairo_region_get_rectangle (region, i, &rect);
-      meta_surface_actor_damage_area (surface->surface_actor,
-                                      rect.x, rect.y, rect.width, rect.height);
+      meta_surface_actor_process_damage (surface->surface_actor,
+                                         rect.x, rect.y, rect.width, rect.height);
     }
 }
 
@@ -295,7 +298,7 @@ actor_surface_commit (MetaWaylandSurface             *surface,
   if (buffer_changed)
     {
       ensure_buffer_texture (buffer);
-      meta_surface_actor_attach_wayland_buffer (surface_actor, buffer);
+      meta_surface_actor_wayland_set_buffer (META_SURFACE_ACTOR_WAYLAND (surface->surface_actor), buffer);
     }
 
   surface_process_damage (surface, pending->damage);
@@ -571,23 +574,16 @@ const struct wl_surface_interface meta_wayland_surface_interface = {
   meta_wayland_surface_set_buffer_scale
 };
 
-static void
-unparent_actor (MetaWaylandSurface *surface)
+void
+meta_wayland_surface_make_toplevel (MetaWaylandSurface *surface)
 {
-  ClutterActor *parent_actor;
-
-  parent_actor = clutter_actor_get_parent (CLUTTER_ACTOR (surface->surface_actor));
-  clutter_actor_remove_child (parent_actor, CLUTTER_ACTOR (surface->surface_actor));
+  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), TRUE);
 }
 
 void
 meta_wayland_surface_window_unmanaged (MetaWaylandSurface *surface)
 {
-  /* The window is being unmanaged. Unparent our surface actor
-   * before the window actor is destroyed, as we need to hold
-   * onto it... */
-  unparent_actor (surface);
-
+  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), FALSE);
   surface->window = NULL;
 }
 
@@ -645,11 +641,9 @@ meta_wayland_surface_create (MetaWaylandCompositor *compositor,
   wl_resource_set_implementation (surface->resource, &meta_wayland_surface_interface, surface, wl_surface_destructor);
 
   surface->buffer_destroy_listener.notify = surface_handle_buffer_destroy;
-  surface->surface_actor = g_object_ref_sink (meta_surface_actor_new (surface));
-  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), TRUE);
+  surface->surface_actor = g_object_ref_sink (meta_surface_actor_wayland_new (surface));
 
   double_buffered_state_init (&surface->pending);
-
   return surface;
 }
 
@@ -977,6 +971,7 @@ xdg_shell_get_xdg_surface (struct wl_client *client,
       return;
     }
 
+  meta_wayland_surface_make_toplevel (surface);
   surface->window = meta_window_wayland_new (meta_get_display (), surface);
 }
 
@@ -1032,6 +1027,7 @@ xdg_shell_get_xdg_popup (struct wl_client *client,
       return;
     }
 
+  meta_wayland_surface_make_toplevel (surface);
   surface->window = meta_window_wayland_new (meta_get_display (), surface);
   surface->window->rect.x = parent_surf->window->rect.x + x;
   surface->window->rect.y = parent_surf->window->rect.y + y;
@@ -1246,6 +1242,14 @@ subsurface_parent_surface_committed (MetaWaylandSurface *surface)
   double_buffered_state_reset (pending_surface_state);
 }
 
+static void
+unparent_actor (MetaWaylandSurface *surface)
+{
+  ClutterActor *parent_actor;
+  parent_actor = clutter_actor_get_parent (CLUTTER_ACTOR (surface->surface_actor));
+  clutter_actor_remove_child (parent_actor, CLUTTER_ACTOR (surface->surface_actor));
+}
+
 static void
 wl_subsurface_destructor (struct wl_resource *resource)
 {

src/wayland/meta-wayland-surface.h

@@ -118,6 +118,7 @@ MetaWaylandSurface *meta_wayland_surface_create (MetaWaylandCompositor *composit
 						 guint32                id,
 						 guint32                version);
 
+void                meta_wayland_surface_make_toplevel (MetaWaylandSurface *surface);
 void                meta_wayland_surface_window_unmanaged (MetaWaylandSurface *surface);
 
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,

src/wayland/meta-xwayland.c

@@ -47,10 +47,12 @@ xserver_set_window_id (struct wl_client *client,
   if (!window)
     return;
 
+  meta_wayland_surface_make_toplevel (surface);
+
   surface->window = window;
   window->surface = surface;
 
-  meta_window_set_surface_mapped (window, TRUE);
+  meta_compositor_window_surface_changed (display->compositor, window);
 }
 
 static const struct xserver_interface xserver_implementation = {