Bump version to 3.11.90

Update NEWS.

NEWS

@@ -1,3 +1,14 @@
+3.11.90
+=======
+* Fix double-scaling on high DPI resolutions [Adel; #723931]
+* Make tile previews a compositor effect [Stefano, Florian; #665758]
+* Misc. bug fixes and cleanups [Ryan, Giovanni, Jasper, Adel; #722530, #724257,
+  #724258, #720631, #724364, #724472]
+
+Contributors:
+  Giovanni Campagna, Marek Chalupa, Stefano Facchini, Adel Gadllah,
+  Ryan Lortie, Florian Müllner, Jasper St. Pierre, Rico Tzschichholz
+
 3.11.5
 ======
 * Fix CSD titlebars being placed off-screen [Jasper; #719772]

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

src/Makefile.am

@@ -80,10 +80,6 @@ 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		\
@@ -186,8 +182,6 @@ libmutter_wayland_la_SOURCES =			\
 	ui/resizepopup.h			\
 	ui/tabpopup.c				\
 	ui/tabpopup.h				\
-	ui/tile-preview.c			\
-	ui/tile-preview.h			\
 	ui/theme-parser.c			\
 	ui/theme.c				\
 	meta/theme.h				\

src/compositor/compositor.c

@@ -1695,3 +1695,31 @@ meta_compositor_monotonic_time_to_server_time (MetaDisplay *display,
   else
     return monotonic_time + compositor->server_time_offset;
 }
+
+void
+meta_compositor_show_tile_preview (MetaCompositor *compositor,
+                                   MetaScreen     *screen,
+                                   MetaWindow     *window,
+                                   MetaRectangle  *tile_rect,
+                                   int             tile_monitor_number)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (!info->plugin_mgr)
+    return;
+
+  meta_plugin_manager_show_tile_preview (info->plugin_mgr,
+                                         window, tile_rect, tile_monitor_number);
+}
+
+void
+meta_compositor_hide_tile_preview (MetaCompositor *compositor,
+                                   MetaScreen     *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (!info->plugin_mgr)
+    return;
+
+  meta_plugin_manager_hide_tile_preview (info->plugin_mgr);
+}

src/compositor/meta-plugin-manager.c

@@ -324,3 +324,44 @@ meta_plugin_manager_confirm_display_change (MetaPluginManager *plugin_mgr)
   else
     return meta_plugin_complete_display_change (plugin, TRUE);
 }
+
+gboolean
+meta_plugin_manager_show_tile_preview (MetaPluginManager *plugin_mgr,
+                                       MetaWindow        *window,
+                                       MetaRectangle     *tile_rect,
+                                       int                tile_monitor_number)
+{
+  MetaPlugin *plugin = plugin_mgr->plugin;
+  MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
+  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
+
+  if (display->display_opening)
+    return FALSE;
+
+  if (klass->show_tile_preview)
+    {
+      klass->show_tile_preview (plugin, window, tile_rect, tile_monitor_number);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+gboolean
+meta_plugin_manager_hide_tile_preview (MetaPluginManager *plugin_mgr)
+{
+  MetaPlugin *plugin = plugin_mgr->plugin;
+  MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
+  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
+
+  if (display->display_opening)
+    return FALSE;
+
+  if (klass->hide_tile_preview)
+    {
+      klass->hide_tile_preview (plugin);
+      return TRUE;
+    }
+
+  return FALSE;
+}

src/compositor/meta-plugin-manager.h

@@ -75,4 +75,9 @@ gboolean _meta_plugin_xevent_filter (MetaPlugin *plugin,
 
 void     meta_plugin_manager_confirm_display_change (MetaPluginManager *mgr);
 
+gboolean meta_plugin_manager_show_tile_preview (MetaPluginManager *mgr,
+                                                MetaWindow        *window,
+                                                MetaRectangle     *tile_rect,
+                                                int                tile_monitor_number);
+gboolean meta_plugin_manager_hide_tile_preview (MetaPluginManager *mgr);
 #endif

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

@@ -1,153 +0,0 @@
-/* -*- 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

@@ -1,66 +0,0 @@
-/* -*- 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

@@ -1,453 +0,0 @@
-/* -*- 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;
-}
-
-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);
-  Display *xdisplay = meta_display_get_xdisplay (display);
-  Window xwindow = meta_window_get_toplevel_xwindow (window);
-
-  g_assert (!meta_is_wayland_compositor ());
-
-  priv->window = window;
-  priv->display = display;
-
-  priv->damage = XDamageCreate (xdisplay, xwindow, XDamageReportBoundingBox);
-  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

@@ -1,69 +0,0 @@
-/* -*- 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,30 @@
  */
 
 #include <config.h>
-
-#include "meta-surface-actor.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 "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 freeze_count;
-  guint needs_damage_all : 1;
 };
 
 static void cullable_iface_init (MetaCullableInterface *iface);
 
-G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
-                                  G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+G_DEFINE_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
+                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
 
 gboolean
 meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
@@ -164,11 +164,50 @@ meta_surface_actor_get_texture (MetaSurfaceActor *self)
   return self->priv->texture;
 }
 
-gboolean
-meta_surface_actor_update_area (MetaSurfaceActor *self,
-                                int x, int y, int width, int height)
+static void
+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);
 }
 
@@ -179,6 +218,27 @@ 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)
@@ -202,114 +262,20 @@ meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
   meta_shaped_texture_set_opaque_region (priv->texture, region);
 }
 
-static gboolean
-is_frozen (MetaSurfaceActor *self)
+MetaWaylandSurface *
+meta_surface_actor_get_surface (MetaSurfaceActor *self)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
-  return (priv->freeze_count > 0);
+  return priv->surface;
 }
 
-void
-meta_surface_actor_process_damage (MetaSurfaceActor *self,
-                                   int x, int y, int width, int height)
+MetaSurfaceActor *
+meta_surface_actor_new (MetaWaylandSurface *surface)
 {
+  MetaSurfaceActor *self = g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
   MetaSurfaceActorPrivate *priv = self->priv;
 
-  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;
-    }
+  priv->surface = surface;
 
-  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_freeze (MetaSurfaceActor *self)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-
-  priv->freeze_count ++;
-}
-
-void
-meta_surface_actor_thaw (MetaSurfaceActor *self)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-
-  if (priv->freeze_count == 0)
-    {
-      g_critical ("Error in freeze/thaw accounting.");
-      return;
-    }
-
-  priv->freeze_count --;
-
-  /* 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. */
-  if (priv->needs_damage_all)
-    {
-      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_is_frozen (MetaSurfaceActor *self)
-{
-  return is_frozen (self);
-}
-
-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);
+  return self;
 }

src/compositor/meta-surface-actor.h

@@ -6,6 +6,7 @@
 #include <config.h>
 
 #include <meta/meta-shaped-texture.h>
+#include "meta-wayland-types.h"
 
 G_BEGIN_DECLS
 
@@ -24,17 +25,6 @@ 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
@@ -46,37 +36,34 @@ 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);
 
-gboolean 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_freeze (MetaSurfaceActor *actor);
-void meta_surface_actor_thaw (MetaSurfaceActor *actor);
-gboolean meta_surface_actor_is_frozen (MetaSurfaceActor *actor);
-
-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);
+MetaWaylandSurface *meta_surface_actor_get_surface (MetaSurfaceActor *surface);
 
 G_END_DECLS
 

src/compositor/meta-window-actor.c

@@ -10,6 +10,10 @@
 
 #include <math.h>
 
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xrender.h>
+
 #include <clutter/x11/clutter-x11.h>
 #include <cogl/cogl-texture-pixmap-x11.h>
 #include <gdk/gdk.h> /* for gdk_rectangle_union() */
@@ -26,15 +30,13 @@
 #include "meta-shaped-texture-private.h"
 #include "meta-shadow-factory-private.h"
 #include "meta-window-actor-private.h"
+#include "meta-surface-actor.h"
 #include "meta-texture-rectangle.h"
 #include "region-utils.h"
 #include "meta-wayland-private.h"
 #include "monitor-private.h"
 #include "meta-cullable.h"
 
-#include "meta-surface-actor.h"
-#include "meta-surface-actor-x11.h"
-
 struct _MetaWindowActorPrivate
 {
   MetaWindow       *window;
@@ -61,12 +63,18 @@ struct _MetaWindowActorPrivate
   /* The region we should clip to when painting the shadow */
   cairo_region_t   *shadow_clip;
 
+  guint              send_frame_messages_timer;
+  gint64             frame_drawn_time;
+
   /* Extracted size-invariant shape used for shadows */
   MetaWindowShape  *shadow_shape;
-  char *            shadow_class;
 
-  guint             send_frame_messages_timer;
-  gint64            frame_drawn_time;
+  gint              last_width;
+  gint              last_height;
+
+  gint              freeze_count;
+
+  char *            shadow_class;
 
   /*
    * These need to be counters rather than flags, since more plugins
@@ -82,7 +90,11 @@ struct _MetaWindowActorPrivate
   /* List of FrameData for recent frames */
   GList            *frames;
 
+  Pixmap            back_pixmap; /* Not used in wayland compositor mode */
+  Damage            damage; /* Not used in wayland compositor mode */
+
   guint		    visible                : 1;
+  guint		    argb32                 : 1;
   guint		    disposed               : 1;
   guint             redecorating           : 1;
 
@@ -99,7 +111,24 @@ struct _MetaWindowActorPrivate
 
   guint             no_shadow              : 1;
 
+
+  /* 
+   * None of these are used in wayland compositor mode...
+   */
+
+  guint		    needs_damage_all       : 1;
+  guint		    received_x11_damage    : 1;
+
+  guint		    needs_pixmap           : 1;
+
+  guint		    x11_size_changed       : 1;
   guint             updates_frozen         : 1;
+
+  guint             unredirected           : 1;
+
+  /* This is used to detect fullscreen windows that need to be unredirected */
+  guint             full_damage_frames_count;
+  guint             does_full_damage  : 1;
 };
 
 typedef struct _FrameData FrameData;
@@ -136,6 +165,7 @@ static gboolean meta_window_actor_get_paint_volume (ClutterActor       *actor,
                                                     ClutterPaintVolume *volume);
 
 
+static void meta_window_actor_detach_x11_pixmap     (MetaWindowActor *self);
 static gboolean meta_window_actor_has_shadow (MetaWindowActor *self);
 
 static void meta_window_actor_handle_updates (MetaWindowActor *self);
@@ -226,6 +256,9 @@ window_decorated_notify (MetaWindow *mw,
 {
   MetaWindowActor        *self     = META_WINDOW_ACTOR (data);
   MetaWindowActorPrivate *priv     = self->priv;
+  MetaScreen             *screen   = priv->screen;
+  MetaDisplay            *display  = meta_screen_get_display (screen);
+  Display                *xdisplay = meta_display_get_xdisplay (display);
 
   /*
    * Basically, we have to reconstruct the the internals of this object
@@ -233,6 +266,23 @@ window_decorated_notify (MetaWindow *mw,
    */
   priv->redecorating = TRUE;
 
+  if (!meta_is_wayland_compositor ())
+    {
+      meta_window_actor_detach_x11_pixmap (self);
+
+      /*
+       * First of all, clean up any resources we are currently using and will
+       * be replacing.
+       */
+      if (priv->damage != None)
+        {
+          meta_error_trap_push (display);
+          XDamageDestroy (xdisplay, priv->damage);
+          meta_error_trap_pop (display);
+          priv->damage = None;
+        }
+    }
+
   /*
    * Recreate the contents.
    */
@@ -257,52 +307,13 @@ surface_allocation_changed_notify (ClutterActor           *actor,
   meta_window_actor_update_shape (self);
 }
 
-static gboolean
-is_argb32 (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  return meta_surface_actor_is_argb32 (priv->surface);
-}
-
 static gboolean
 is_non_opaque (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
   MetaWindow *window = priv->window;
 
-  return is_argb32 (self) || (window->opacity != 0xFF);
-}
-
-static gboolean
-is_frozen (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  return meta_surface_actor_is_frozen (priv->surface);
-}
-
-static void
-meta_window_actor_freeze (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  meta_surface_actor_freeze (priv->surface);
-}
-
-static void
-meta_window_actor_thaw (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  meta_surface_actor_thaw (priv->surface);
-
-  if (is_frozen (self))
-    return;
-
-  /* We sometimes ignore moves and resizes on frozen windows */
-  meta_window_actor_sync_actor_geometry (self, FALSE);
-
-  /* We do this now since we might be going right back into the
-   * frozen state */
-  meta_window_actor_handle_updates (self);
+  return priv->argb32 || (window->opacity != 0xFF);
 }
 
 static void
@@ -311,15 +322,38 @@ meta_window_actor_constructed (GObject *object)
   MetaWindowActor        *self     = META_WINDOW_ACTOR (object);
   MetaWindowActorPrivate *priv     = self->priv;
   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 = window->screen;
+  priv->screen = screen;
+
+  if (!meta_is_wayland_compositor ())
+    priv->damage = XDamageCreate (xdisplay, xwindow,
+                                  XDamageReportBoundingBox);
+
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    {
+      XRenderPictFormat      *format;
+
+      format = XRenderFindVisualFormat (xdisplay, window->xvisual);
+
+      if (format && format->type == PictTypeDirect && format->direct.alphaMask)
+        priv->argb32 = TRUE;
+    }
+  else
+    {
+      /* XXX: parse shm formats to determine argb32 */
+      priv->argb32 = TRUE;
+    }
 
   if (!priv->surface)
     {
       if (window->surface)
         priv->surface = window->surface->surface_actor;
       else
-        priv->surface = meta_surface_actor_x11_new (window);
+        priv->surface = meta_surface_actor_new (NULL);
       g_object_ref_sink (priv->surface);
 
       clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface));
@@ -342,6 +376,8 @@ meta_window_actor_dispose (GObject *object)
   MetaWindowActor        *self = META_WINDOW_ACTOR (object);
   MetaWindowActorPrivate *priv = self->priv;
   MetaScreen             *screen;
+  MetaDisplay            *display;
+  Display                *xdisplay;
   MetaCompScreen         *info;
 
   if (priv->disposed)
@@ -352,6 +388,9 @@ meta_window_actor_dispose (GObject *object)
   screen   = priv->screen;
   info     = meta_screen_get_compositor_data (screen);
 
+  if (!meta_is_wayland_compositor ())
+    meta_window_actor_detach_x11_pixmap (self);
+
   if (priv->send_frame_messages_timer != 0)
     {
       g_source_remove (priv->send_frame_messages_timer);
@@ -366,6 +405,18 @@ meta_window_actor_dispose (GObject *object)
   g_clear_pointer (&priv->unfocused_shadow, meta_shadow_unref);
   g_clear_pointer (&priv->shadow_shape, meta_window_shape_unref);
 
+  if (!meta_is_wayland_compositor () && priv->damage != None)
+    {
+      display  = meta_screen_get_display (screen);
+      xdisplay = meta_display_get_xdisplay (display);
+
+      meta_error_trap_push (display);
+      XDamageDestroy (xdisplay, priv->damage);
+      meta_error_trap_pop (display);
+
+      priv->damage = None;
+    }
+
   info->windows = g_list_remove (info->windows, (gconstpointer) self);
 
   g_clear_object (&priv->window);
@@ -776,6 +827,13 @@ meta_window_actor_is_destroyed (MetaWindowActor *self)
   return self->priv->disposed;
 }
 
+static void
+meta_window_actor_freeze (MetaWindowActor *self)
+{
+  if (!meta_is_wayland_compositor ())
+    self->priv->freeze_count++;
+}
+
 static gboolean
 send_frame_messages_timeout (gpointer data)
 {
@@ -830,6 +888,55 @@ queue_send_frame_messages_timeout (MetaWindowActor *self)
   priv->send_frame_messages_timer = g_timeout_add_full (META_PRIORITY_REDRAW, offset, send_frame_messages_timeout, self, NULL);
 }
 
+static void
+meta_window_actor_damage_all (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  gboolean redraw_queued;
+
+  if (!priv->needs_damage_all)
+    return;
+
+  if (priv->needs_pixmap)
+    return;
+
+  redraw_queued = meta_surface_actor_damage_all (priv->surface);
+  priv->repaint_scheduled = priv->repaint_scheduled || redraw_queued;
+  priv->needs_damage_all = FALSE;
+}
+
+static void
+meta_window_actor_thaw (MetaWindowActor *self)
+{
+  if (!meta_is_wayland_compositor ())
+    {
+      self->priv->freeze_count--;
+
+      if (G_UNLIKELY (self->priv->freeze_count < 0))
+        {
+          g_warning ("Error in freeze/thaw accounting.");
+          self->priv->freeze_count = 0;
+          return;
+        }
+
+      if (self->priv->freeze_count)
+        return;
+
+      /* We sometimes ignore moves and resizes on frozen windows */
+      meta_window_actor_sync_actor_geometry (self, FALSE);
+
+      /* We do this now since we might be going right back into the
+       * frozen state */
+      meta_window_actor_handle_updates (self);
+
+      /* 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. */
+      if (self->priv->needs_damage_all)
+        meta_window_actor_damage_all (self);
+    }
+}
+
 void
 meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
                                      gboolean         no_delay_frame)
@@ -884,6 +991,33 @@ meta_window_actor_effect_in_progress (MetaWindowActor *self)
 	  self->priv->destroy_in_progress);
 }
 
+static gboolean
+is_frozen (MetaWindowActor *self)
+{
+  return self->priv->freeze_count ? TRUE : FALSE;
+}
+
+static void
+meta_window_actor_queue_create_x11_pixmap (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+
+  priv->needs_pixmap = TRUE;
+
+  if (is_frozen (self))
+    return;
+
+  /* This will cause the compositor paint function to be run
+   * if the actor is visible or a clone of the actor is visible.
+   * if the actor isn't visible in any way, then we don't
+   * need to repair the window anyways, and can wait until
+   * the stage is redrawn for some other reason
+   *
+   * The compositor paint function repairs all windows.
+   */
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
+}
+
 static gboolean
 is_freeze_thaw_effect (gulong event)
 {
@@ -964,6 +1098,12 @@ meta_window_actor_after_effects (MetaWindowActor *self)
 
   meta_window_actor_sync_visibility (self);
   meta_window_actor_sync_actor_geometry (self, FALSE);
+
+  if (!meta_is_wayland_compositor ())
+    {
+      if (priv->needs_pixmap)
+        clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
+    }
 }
 
 void
@@ -1038,19 +1178,95 @@ meta_window_actor_effect_completed (MetaWindowActor *self,
     meta_window_actor_after_effects (self);
 }
 
+/* Called to drop our reference to a window backing pixmap that we
+ * previously obtained with XCompositeNameWindowPixmap. We do this
+ * when the window is unmapped or when we want to update to a new
+ * pixmap for a new size.
+ */
+static void
+meta_window_actor_detach_x11_pixmap (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv     = self->priv;
+  MetaScreen            *screen   = priv->screen;
+  MetaDisplay           *display  = meta_screen_get_display (screen);
+  Display               *xdisplay = meta_display_get_xdisplay (display);
+
+  if (!priv->back_pixmap)
+    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_surface_actor_set_texture (priv->surface, NULL);
+  cogl_flush();
+
+  XFreePixmap (xdisplay, priv->back_pixmap);
+  priv->back_pixmap = None;
+
+  meta_window_actor_queue_create_x11_pixmap (self);
+}
+
 gboolean
 meta_window_actor_should_unredirect (MetaWindowActor *self)
 {
+  MetaWindow *metaWindow = meta_window_actor_get_meta_window (self);
   MetaWindowActorPrivate *priv = self->priv;
-  return meta_surface_actor_should_unredirect (priv->surface);
+
+  if (meta_is_wayland_compositor ())
+    return FALSE;
+
+  if (meta_window_requested_dont_bypass_compositor (metaWindow))
+    return FALSE;
+
+  if (metaWindow->opacity != 0xFF)
+    return FALSE;
+
+  if (metaWindow->shape_region != NULL)
+    return FALSE;
+
+  if (priv->argb32 && !meta_window_requested_bypass_compositor (metaWindow))
+    return FALSE;
+
+  if (!meta_window_is_monitor_sized (metaWindow))
+    return FALSE;
+
+  if (meta_window_requested_bypass_compositor (metaWindow))
+    return TRUE;
+
+  if (meta_window_is_override_redirect (metaWindow))
+    return TRUE;
+
+  if (priv->does_full_damage)
+    return TRUE;
+
+  return FALSE;
 }
 
 void
 meta_window_actor_set_unredirected (MetaWindowActor *self,
                                     gboolean         unredirected)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-  meta_surface_actor_set_unredirected (priv->surface, unredirected);
+  MetaWindow *metaWindow = meta_window_actor_get_meta_window (self);
+  MetaDisplay *display = meta_window_get_display (metaWindow);
+
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window  xwin = meta_window_get_toplevel_xwindow (metaWindow);
+
+  meta_error_trap_push (display);
+
+  if (unredirected)
+    {
+      XCompositeUnredirectWindow (xdisplay, xwin, CompositeRedirectManual);
+    }
+  else
+    {
+      XCompositeRedirectWindow (xdisplay, xwin, CompositeRedirectManual);
+      meta_window_actor_detach_x11_pixmap (self);
+    }
+
+  self->priv->unredirected = unredirected;
+  meta_error_trap_pop (display);
 }
 
 void
@@ -1110,11 +1326,19 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
 
   meta_window_get_input_rect (priv->window, &window_rect);
 
-  /* When running as a Wayland compositor we catch size changes when new
-   * buffers are attached */
-  if (META_IS_SURFACE_ACTOR_X11 (priv->surface))
-    meta_surface_actor_x11_set_size (META_SURFACE_ACTOR_X11 (priv->surface),
-                                     window_rect.width, window_rect.height);
+  /* When running as a display server we catch size changes when new
+     buffers are attached */
+  if (!meta_is_wayland_compositor ())
+    {
+      if (priv->last_width != window_rect.width ||
+          priv->last_height != window_rect.height)
+        {
+          priv->x11_size_changed = TRUE;
+
+          priv->last_width = window_rect.width;
+          priv->last_height = window_rect.height;
+        }
+    }
 
   /* Normally we want freezing a window to also freeze its position; this allows
    * windows to atomically move and resize together, either under app control,
@@ -1126,6 +1350,15 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
   if (is_frozen (self) && !did_placement)
     return;
 
+  if (!meta_is_wayland_compositor ())
+    {
+      if (priv->x11_size_changed)
+        {
+          meta_window_actor_queue_create_x11_pixmap (self);
+          meta_window_actor_update_shape (self);
+        }
+    }
+
   if (meta_window_actor_effect_in_progress (self))
     return;
 
@@ -1292,13 +1525,22 @@ meta_window_actor_new (MetaWindow *window)
 
   priv = self->priv;
 
-  meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (priv->window));
+  if (!meta_is_wayland_compositor ())
+    {
+      priv->last_width = -1;
+      priv->last_height = -1;
 
-  /* If a window doesn't start off with updates frozen, we should
-   * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
-   */
-  if (priv->window->extended_sync_request_counter && !priv->updates_frozen)
-    meta_window_actor_queue_frame_drawn (self, FALSE);
+      meta_window_actor_queue_create_x11_pixmap (self);
+
+      meta_window_actor_set_updates_frozen (self,
+                                            meta_window_updates_are_frozen (priv->window));
+
+      /* If a window doesn't start off with updates frozen, we should
+       * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
+       */
+      if (priv->window->extended_sync_request_counter && !priv->updates_frozen)
+        meta_window_actor_queue_frame_drawn (self, FALSE);
+    }
 
   meta_window_actor_sync_actor_geometry (self, priv->window->placed);
 
@@ -1407,6 +1649,13 @@ meta_window_actor_cull_out (MetaCullable   *cullable,
                             cairo_region_t *clip_region)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
+  MetaWindowActorPrivate *priv = self->priv;
+
+  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
+
+  /* Don't do any culling for the unredirected window */
+  if (priv->unredirected)
+    return;
 
   meta_window_actor_set_clip_region_beneath (self, clip_region);
 }
@@ -1429,6 +1678,68 @@ cullable_iface_init (MetaCullableInterface *iface)
   iface->reset_culling = meta_window_actor_reset_culling;
 }
 
+/* When running as a wayland compositor we don't make requests for
+ * replacement pixmaps when resizing windows, we will instead be
+ * asked to attach replacement buffers by the clients. */
+static void
+check_needs_x11_pixmap (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  MetaDisplay *display = meta_screen_get_display (priv->screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window xwindow  = meta_window_get_toplevel_xwindow (priv->window);
+
+  if (!priv->needs_pixmap)
+    return;
+
+  if (priv->x11_size_changed)
+    {
+      meta_window_actor_detach_x11_pixmap (self);
+      priv->x11_size_changed = FALSE;
+    }
+
+  meta_error_trap_push (display);
+
+  if (priv->back_pixmap == None)
+    {
+      CoglContext *ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+      CoglTexture *texture;
+
+      meta_error_trap_push (display);
+
+      priv->back_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.)
+           */
+          priv->back_pixmap = None;
+        }
+
+      if (priv->back_pixmap == None)
+        {
+          meta_verbose ("Unable to get named pixmap for %p\n", self);
+          goto out;
+        }
+
+      texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, priv->back_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");
+
+      meta_surface_actor_set_texture (META_SURFACE_ACTOR (priv->surface), texture);
+    }
+
+  priv->needs_pixmap = FALSE;
+
+ out:
+  meta_error_trap_pop (display);
+}
+
 static void
 check_needs_shadow (MetaWindowActor *self)
 {
@@ -1496,12 +1807,61 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
                                       XDamageNotifyEvent *event)
 {
   MetaWindowActorPrivate *priv = self->priv;
+  MetaCompScreen *info = meta_screen_get_compositor_data (priv->screen);
+  gboolean redraw_queued;
 
-  meta_surface_actor_process_damage (priv->surface,
-                                     event->area.x,
-                                     event->area.y,
-                                     event->area.width,
-                                     event->area.height);
+  priv->received_x11_damage = TRUE;
+
+  if (meta_window_is_fullscreen (priv->window) && g_list_last (info->windows)->data == self && !priv->unredirected)
+    {
+      MetaRectangle window_rect;
+      meta_window_get_frame_rect (priv->window, &window_rect);
+
+      if (window_rect.x == event->area.x &&
+          window_rect.y == event->area.y &&
+          window_rect.width == event->area.width &&
+          window_rect.height == event->area.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;
+
+  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;
+    }
+
+  if (priv->needs_pixmap)
+    return;
+
+  redraw_queued = meta_surface_actor_damage_area (priv->surface,
+                                                  event->area.x,
+                                                  event->area.y,
+                                                  event->area.width,
+                                                  event->area.height);
+  priv->repaint_scheduled = priv->repaint_scheduled || redraw_queued;
 }
 
 void
@@ -1729,9 +2089,8 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
   cairo_region_t *opaque_region;
-  gboolean argb32 = is_argb32 (self);
 
-  if (argb32 && priv->window->opaque_region != NULL)
+  if (priv->argb32 && priv->window->opaque_region != NULL)
     {
       MetaFrameBorders borders;
 
@@ -1751,7 +2110,7 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
       cairo_region_translate (opaque_region, borders.total.left, borders.total.top);
       cairo_region_intersect (opaque_region, priv->shape_region);
     }
-  else if (argb32)
+  else if (priv->argb32)
     opaque_region = NULL;
   else
     opaque_region = cairo_region_reference (priv->shape_region);
@@ -1808,6 +2167,9 @@ static void
 meta_window_actor_handle_updates (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
+  MetaScreen          *screen   = priv->screen;
+  MetaDisplay         *display  = meta_screen_get_display (screen);
+  Display             *xdisplay = meta_display_get_xdisplay (display);
 
   if (is_frozen (self))
     {
@@ -1816,13 +2178,45 @@ meta_window_actor_handle_updates (MetaWindowActor *self)
       return;
     }
 
-  if (meta_surface_actor_is_unredirected (priv->surface))
-    return;
+  if (!meta_is_wayland_compositor ())
+    {
+      if (priv->unredirected)
+        {
+          /* Nothing to do here until/if the window gets redirected again */
+          return;
+        }
 
-  meta_surface_actor_pre_paint (priv->surface);
+      if (priv->received_x11_damage)
+        {
+          meta_error_trap_push (display);
+          XDamageSubtract (xdisplay, priv->damage, None, None);
+          meta_error_trap_pop (display);
 
-  if (!meta_surface_actor_is_visible (priv->surface))
-    return;
+          /* 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_x11_damage = FALSE;
+        }
+
+      check_needs_x11_pixmap (self);
+    }
 
   check_needs_reshape (self);
   check_needs_shadow (self);
@@ -2011,16 +2405,20 @@ void
 meta_window_actor_set_updates_frozen (MetaWindowActor *self,
                                       gboolean         updates_frozen)
 {
-  MetaWindowActorPrivate *priv = self->priv;
-
-  updates_frozen = updates_frozen != FALSE;
-
-  if (priv->updates_frozen != updates_frozen)
+  /* On wayland we shouldn't need to ever freeze updates... */
+  if (!meta_is_wayland_compositor ())
     {
-      priv->updates_frozen = updates_frozen;
-      if (updates_frozen)
-        meta_window_actor_freeze (self);
-      else
-        meta_window_actor_thaw (self);
+      MetaWindowActorPrivate *priv = self->priv;
+
+      updates_frozen = updates_frozen != FALSE;
+
+      if (priv->updates_frozen != updates_frozen)
+        {
+          priv->updates_frozen = updates_frozen;
+          if (updates_frozen)
+            meta_window_actor_freeze (self);
+          else
+            meta_window_actor_thaw (self);
+        }
     }
 }

src/compositor/plugins/default.c

@@ -39,6 +39,7 @@
 #define SWITCH_TIMEOUT    500
 
 #define ACTOR_DATA_KEY "MCCP-Default-actor-data"
+#define SCREEN_TILE_PREVIEW_DATA_KEY "MCCP-Default-screen-tile-preview-data"
 
 #define META_TYPE_DEFAULT_PLUGIN            (meta_default_plugin_get_type ())
 #define META_DEFAULT_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_DEFAULT_PLUGIN, MetaDefaultPlugin))
@@ -67,6 +68,7 @@ struct _MetaDefaultPluginClass
 };
 
 static GQuark actor_data_quark = 0;
+static GQuark screen_tile_preview_data_quark = 0;
 
 static void start      (MetaPlugin      *plugin);
 static void minimize   (MetaPlugin      *plugin,
@@ -97,6 +99,12 @@ static void kill_window_effects   (MetaPlugin      *plugin,
                                    MetaWindowActor *actor);
 static void kill_switch_workspace (MetaPlugin      *plugin);
 
+static void show_tile_preview (MetaPlugin      *plugin,
+                               MetaWindow      *window,
+                               MetaRectangle   *tile_rect,
+                               int              tile_monitor_number);
+static void hide_tile_preview (MetaPlugin      *plugin);
+
 static void confirm_display_change (MetaPlugin *plugin);
 
 static const MetaPluginInfo * plugin_info (MetaPlugin *plugin);
@@ -143,6 +151,15 @@ typedef struct
 } EffectCompleteData;
 
 
+typedef struct _ScreenTilePreview
+{
+  ClutterActor   *actor;
+
+  GdkRGBA        *preview_color;
+
+  MetaRectangle   tile_rect;
+} ScreenTilePreview;
+
 static void
 meta_default_plugin_dispose (GObject *object)
 {
@@ -203,6 +220,8 @@ meta_default_plugin_class_init (MetaDefaultPluginClass *klass)
   plugin_class->unmaximize       = unmaximize;
   plugin_class->destroy          = destroy;
   plugin_class->switch_workspace = switch_workspace;
+  plugin_class->show_tile_preview = show_tile_preview;
+  plugin_class->hide_tile_preview = hide_tile_preview;
   plugin_class->plugin_info      = plugin_info;
   plugin_class->kill_window_effects   = kill_window_effects;
   plugin_class->kill_switch_workspace = kill_switch_workspace;
@@ -749,6 +768,82 @@ destroy (MetaPlugin *plugin, MetaWindowActor *window_actor)
     meta_plugin_destroy_completed (plugin, window_actor);
 }
 
+/*
+ * Tile preview private data accessor
+ */
+static void
+free_screen_tile_preview (gpointer data)
+{
+  ScreenTilePreview *preview = data;
+
+  if (G_LIKELY (preview != NULL)) {
+    clutter_actor_destroy (preview->actor);
+    g_slice_free (ScreenTilePreview, preview);
+  }
+}
+
+static ScreenTilePreview *
+get_screen_tile_preview (MetaScreen *screen)
+{
+  ScreenTilePreview *preview = g_object_get_qdata (G_OBJECT (screen), screen_tile_preview_data_quark);
+
+  if (G_UNLIKELY (screen_tile_preview_data_quark == 0))
+    screen_tile_preview_data_quark = g_quark_from_static_string (SCREEN_TILE_PREVIEW_DATA_KEY);
+
+  if (G_UNLIKELY (!preview))
+    {
+      preview = g_slice_new0 (ScreenTilePreview);
+
+      preview->actor = clutter_actor_new ();
+      clutter_actor_set_background_color (preview->actor, CLUTTER_COLOR_Blue);
+      clutter_actor_set_opacity (preview->actor, 100);
+
+      clutter_actor_add_child (meta_get_window_group_for_screen (screen), preview->actor);
+      g_object_set_qdata_full (G_OBJECT (screen),
+                               screen_tile_preview_data_quark, preview,
+                               free_screen_tile_preview);
+    }
+
+  return preview;
+}
+
+static void
+show_tile_preview (MetaPlugin    *plugin,
+                   MetaWindow    *window,
+                   MetaRectangle *tile_rect,
+                   int            tile_monitor_number)
+{
+  MetaScreen *screen = meta_plugin_get_screen (plugin);
+  ScreenTilePreview *preview = get_screen_tile_preview (screen);
+  ClutterActor *window_actor;
+
+  if (CLUTTER_ACTOR_IS_VISIBLE (preview->actor)
+      && preview->tile_rect.x == tile_rect->x
+      && preview->tile_rect.y == tile_rect->y
+      && preview->tile_rect.width == tile_rect->width
+      && preview->tile_rect.height == tile_rect->height)
+    return; /* nothing to do */
+
+  clutter_actor_set_position (preview->actor, tile_rect->x, tile_rect->y);
+  clutter_actor_set_size (preview->actor, tile_rect->width, tile_rect->height);
+
+  clutter_actor_show (preview->actor);
+
+  window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window));
+  clutter_actor_lower (preview->actor, window_actor);
+
+  preview->tile_rect = *tile_rect;
+}
+
+static void
+hide_tile_preview (MetaPlugin *plugin)
+{
+  MetaScreen *screen = meta_plugin_get_screen (plugin);
+  ScreenTilePreview *preview = get_screen_tile_preview (screen);
+
+  clutter_actor_hide (preview->actor);
+}
+
 static void
 kill_switch_workspace (MetaPlugin     *plugin)
 {

src/core/display.c

@@ -73,7 +73,6 @@
 #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  ||  \
@@ -1683,9 +1682,9 @@ get_window_for_event (MetaDisplay        *display,
     return display->grab_window;
 
   source = clutter_event_get_source (event);
-  if (META_IS_SURFACE_ACTOR_WAYLAND (source))
+  if (META_IS_SURFACE_ACTOR (source))
     {
-      MetaWaylandSurface *surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (source));
+      MetaWaylandSurface *surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (source));
       g_assert (surface != NULL);
       return surface->window;
     }

src/core/keybindings.c

@@ -2165,7 +2165,7 @@ process_mouse_move_resize_grab (MetaDisplay     *display,
     {
       /* Hide the tiling preview if necessary */
       if (window->tile_mode != META_TILE_NONE)
-        meta_screen_tile_preview_hide (screen);
+        meta_screen_hide_tile_preview (screen);
 
       /* Restore the original tile mode */
       window->tile_mode = display->grab_tile_mode;

src/core/screen-private.h

@@ -65,7 +65,6 @@ struct _MetaScreen
   MetaRectangle rect;  /* Size of screen; rect.x & rect.y are always 0 */
   MetaUI *ui;
   MetaTabPopup *tab_popup, *ws_popup;
-  MetaTilePreview *tile_preview;
 
   guint tile_preview_timeout_id;
 
@@ -167,9 +166,9 @@ void          meta_screen_workspace_popup_select       (MetaScreen    *screen,
 MetaWorkspace*meta_screen_workspace_popup_get_selected (MetaScreen    *screen);
 void          meta_screen_workspace_popup_destroy      (MetaScreen    *screen);
 
-void          meta_screen_tile_preview_update          (MetaScreen    *screen,
+void          meta_screen_update_tile_preview          (MetaScreen    *screen,
                                                         gboolean       delay);
-void          meta_screen_tile_preview_hide            (MetaScreen    *screen);
+void          meta_screen_hide_tile_preview            (MetaScreen    *screen);
 
 MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
                                                 MetaWindow                 *not_this_one);

src/core/screen.c

@@ -762,7 +762,6 @@ meta_screen_new (MetaDisplay *display,
 
   screen->tab_popup = NULL;
   screen->ws_popup = NULL;
-  screen->tile_preview = NULL;
 
   screen->tile_preview_timeout_id = 0;
 
@@ -868,9 +867,6 @@ meta_screen_free (MetaScreen *screen,
   if (screen->tile_preview_timeout_id)
     g_source_remove (screen->tile_preview_timeout_id);
 
-  if (screen->tile_preview)
-    meta_tile_preview_free (screen->tile_preview);
-  
   g_free (screen->screen_name);
 
   g_object_unref (screen);
@@ -1680,7 +1676,7 @@ meta_screen_workspace_popup_destroy (MetaScreen *screen)
 }
 
 static gboolean
-meta_screen_tile_preview_update_timeout (gpointer data)
+meta_screen_update_tile_preview_timeout (gpointer data)
 {
   MetaScreen *screen = data;
   MetaWindow *window = screen->display->grab_window;
@@ -1688,22 +1684,6 @@ meta_screen_tile_preview_update_timeout (gpointer data)
 
   screen->tile_preview_timeout_id = 0;
 
-  if (!screen->tile_preview)
-    {
-      Window xwindow;
-      gulong create_serial;
-      MetaStackWindow stack_window;
-
-      screen->tile_preview = meta_tile_preview_new (screen->number);
-      xwindow = meta_tile_preview_get_xwindow (screen->tile_preview,
-                                               &create_serial);
-      stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-      stack_window.x11.xwindow = xwindow;
-      meta_stack_tracker_record_add (screen->stack_tracker,
-                                     &stack_window,
-                                     create_serial);
-    }
-
   if (window)
     {
       switch (window->tile_mode)
@@ -1728,12 +1708,16 @@ meta_screen_tile_preview_update_timeout (gpointer data)
   if (needs_preview)
     {
       MetaRectangle tile_rect;
+      int monitor;
 
+      monitor = meta_window_get_current_tile_monitor_number (window);
       meta_window_get_current_tile_area (window, &tile_rect);
-      meta_tile_preview_show (screen->tile_preview, &tile_rect);
+      meta_compositor_show_tile_preview (screen->display->compositor,
+                                         screen, window, &tile_rect, monitor);
     }
   else
-    meta_tile_preview_hide (screen->tile_preview);
+    meta_compositor_hide_tile_preview (screen->display->compositor,
+                                       screen);
 
   return FALSE;
 }
@@ -1741,7 +1725,7 @@ meta_screen_tile_preview_update_timeout (gpointer data)
 #define TILE_PREVIEW_TIMEOUT_MS 200
 
 void
-meta_screen_tile_preview_update (MetaScreen *screen,
+meta_screen_update_tile_preview (MetaScreen *screen,
                                  gboolean    delay)
 {
   if (delay)
@@ -1751,7 +1735,7 @@ meta_screen_tile_preview_update (MetaScreen *screen,
 
       screen->tile_preview_timeout_id =
         g_timeout_add (TILE_PREVIEW_TIMEOUT_MS,
-                       meta_screen_tile_preview_update_timeout,
+                       meta_screen_update_tile_preview_timeout,
                        screen);
     }
   else
@@ -1759,18 +1743,18 @@ meta_screen_tile_preview_update (MetaScreen *screen,
       if (screen->tile_preview_timeout_id > 0)
         g_source_remove (screen->tile_preview_timeout_id);
 
-      meta_screen_tile_preview_update_timeout ((gpointer)screen);
+      meta_screen_update_tile_preview_timeout ((gpointer)screen);
     }
 }
 
 void
-meta_screen_tile_preview_hide (MetaScreen *screen)
+meta_screen_hide_tile_preview (MetaScreen *screen)
 {
   if (screen->tile_preview_timeout_id > 0)
     g_source_remove (screen->tile_preview_timeout_id);
 
-  if (screen->tile_preview)
-    meta_tile_preview_hide (screen->tile_preview);
+  meta_compositor_hide_tile_preview (screen->display->compositor,
+                                     screen);
 }
 
 MetaWindow*

src/core/window-private.h

@@ -652,6 +652,7 @@ void meta_window_handle_mouse_grab_op_xevent (MetaWindow         *window,
 
 GList* meta_window_get_workspaces (MetaWindow *window);
 
+int meta_window_get_current_tile_monitor_number (MetaWindow *window);
 void meta_window_get_current_tile_area         (MetaWindow    *window,
                                                 MetaRectangle *tile_area);
 

src/core/window.c

@@ -1177,9 +1177,6 @@ _meta_window_shared_new (MetaDisplay         *display,
   if (!window->override_redirect)
     meta_stack_add (window->screen->stack,
                     window);
-  else if (window->screen->tile_preview != NULL &&
-           meta_tile_preview_get_xwindow (window->screen->tile_preview, NULL) == xwindow)
-    window->layer = META_LAYER_NORMAL;
   else
     window->layer = META_LAYER_OVERRIDE_REDIRECT; /* otherwise set by MetaStack */
 
@@ -3369,7 +3366,7 @@ meta_window_tile (MetaWindow *window)
     directions = META_MAXIMIZE_VERTICAL;
 
   meta_window_maximize_internal (window, directions, NULL);
-  meta_screen_tile_preview_update (window->screen, FALSE);
+  meta_screen_update_tile_preview (window->screen, FALSE);
 
   if (window->display->compositor)
     {
@@ -8108,7 +8105,7 @@ update_move (MetaWindow  *window,
    * trigger it unwittingly, e.g. when shaking loose the window or moving
    * it to another monitor.
    */
-  meta_screen_tile_preview_update (window->screen,
+  meta_screen_update_tile_preview (window->screen,
                                    window->tile_mode != META_TILE_NONE);
 
   meta_window_get_client_root_coords (window, &old);
@@ -8956,6 +8953,20 @@ meta_window_get_work_area_all_monitors (MetaWindow    *window,
               window->desc, area->x, area->y, area->width, area->height);
 }
 
+int
+meta_window_get_current_tile_monitor_number (MetaWindow *window)
+{
+  int tile_monitor_number = window->tile_monitor_number;
+
+  if (tile_monitor_number < 0)
+    {
+      meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC);
+      tile_monitor_number = 0;
+    }
+
+  return tile_monitor_number;
+}
+
 void
 meta_window_get_current_tile_area (MetaWindow    *window,
                                    MetaRectangle *tile_area)
@@ -8964,12 +8975,7 @@ meta_window_get_current_tile_area (MetaWindow    *window,
 
   g_return_if_fail (window->tile_mode != META_TILE_NONE);
 
-  tile_monitor_number = window->tile_monitor_number;
-  if (tile_monitor_number < 0)
-    {
-      meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC);
-      tile_monitor_number = 0;
-    }
+  tile_monitor_number = meta_window_get_current_tile_monitor_number (window);
 
   meta_window_get_work_area_for_monitor (window, tile_monitor_number, tile_area);
 

src/meta/compositor.h

@@ -121,4 +121,12 @@ void meta_compositor_sync_screen_size          (MetaCompositor *compositor,
 void meta_compositor_flash_screen              (MetaCompositor *compositor,
                                                 MetaScreen     *screen);
 
+void meta_compositor_show_tile_preview (MetaCompositor *compositor,
+                                        MetaScreen     *screen,
+                                        MetaWindow     *window,
+                                        MetaRectangle  *tile_rect,
+                                        int             tile_monitor_number);
+void meta_compositor_hide_tile_preview (MetaCompositor *compositor,
+                                        MetaScreen     *screen);
+
 #endif /* META_COMPOSITOR_H */

src/meta/meta-plugin.h

@@ -158,6 +158,11 @@ struct _MetaPluginClass
                             gint                to,
                             MetaMotionDirection direction);
 
+  void (*show_tile_preview) (MetaPlugin      *plugin,
+                             MetaWindow      *window,
+                             MetaRectangle   *tile_rect,
+                             int              tile_monitor_number);
+  void (*hide_tile_preview) (MetaPlugin      *plugin);
 
   /**
    * MetaPluginClass::kill_window_effects:

src/ui/tile-preview.c

@@ -1,196 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Mutter tile-preview marks the area a window will *ehm* snap to */
-
-/*
- * Copyright (C) 2010 Florian Müllner
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <config.h>
-
-#include <gtk/gtk.h>
-#include <cairo.h>
-
-#include "tile-preview.h"
-#include "core.h"
-
-#define OUTLINE_WIDTH 5  /* frame width in non-composite case */
-
-
-struct _MetaTilePreview {
-  GtkWidget     *preview_window;
-  gulong         create_serial;
-
-  GdkRGBA       *preview_color;
-
-  MetaRectangle  tile_rect;
-};
-
-static gboolean
-meta_tile_preview_draw (GtkWidget *widget,
-                        cairo_t   *cr,
-                        gpointer   user_data)
-{
-  MetaTilePreview *preview = user_data;
-
-  cairo_set_line_width (cr, 1.0);
-
-  /* Fill the preview area with a transparent color */
-  gdk_cairo_set_source_rgba (cr, preview->preview_color);
-
-  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
-  cairo_paint (cr);
-
-  /* Use the opaque color for the border */
-  cairo_set_source_rgb (cr,
-                        preview->preview_color->red,
-                        preview->preview_color->green,
-                        preview->preview_color->blue);
-
-  cairo_rectangle (cr,
-                   0.5, 0.5,
-                   preview->tile_rect.width - 1,
-                   preview->tile_rect.height - 1);
-  cairo_stroke (cr);
-
-  return FALSE;
-}
-
-MetaTilePreview *
-meta_tile_preview_new (int      screen_number)
-{
-  MetaTilePreview *preview;
-  GdkScreen *screen;
-  GtkStyleContext *context;
-  GtkWidgetPath *path;
-  guchar selection_alpha = 0xFF;
-
-  screen = gdk_display_get_screen (gdk_display_get_default (), screen_number);
-
-  preview = g_new (MetaTilePreview, 1);
-
-  preview->preview_window = gtk_window_new (GTK_WINDOW_POPUP);
-
-  gtk_window_set_screen (GTK_WINDOW (preview->preview_window), screen);
-  gtk_widget_set_app_paintable (preview->preview_window, TRUE);
-
-  preview->preview_color = NULL;
-
-  preview->tile_rect.x = preview->tile_rect.y = 0;
-  preview->tile_rect.width = preview->tile_rect.height = 0;
-
-  gtk_widget_set_visual (preview->preview_window,
-                         gdk_screen_get_rgba_visual (screen));
-
-  path = gtk_widget_path_new ();
-  gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW);
-
-  context = gtk_style_context_new ();
-  gtk_style_context_set_path (context, path);
-  gtk_style_context_add_class (context,
-                               GTK_STYLE_CLASS_RUBBERBAND);
-
-  gtk_widget_path_free (path);
-
-  gtk_style_context_get (context, GTK_STATE_FLAG_SELECTED,
-                         "background-color", &preview->preview_color,
-                         NULL);
-
-  /* The background-color for the .rubberband class should probably
-   * contain the correct alpha value - unfortunately, at least for now
-   * it doesn't. Hopefully the following workaround can be removed
-   * when GtkIconView gets ported to GtkStyleContext.
-   */
-  gtk_style_context_get_style (context,
-                               "selection-box-alpha", &selection_alpha,
-                               NULL);
-  preview->preview_color->alpha = (double)selection_alpha / 0xFF;
-
-  g_object_unref (context);
-
-  /* We make an assumption that XCreateWindow will be the first operation
-   * when calling gtk_widget_realize() (via gdk_window_new()), or that it
-   * is at least "close enough".
-   */
-  preview->create_serial = XNextRequest (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
-  gtk_widget_realize (preview->preview_window);
-  g_signal_connect (preview->preview_window, "draw",
-                    G_CALLBACK (meta_tile_preview_draw), preview);
-
-  return preview;
-}
-
-void
-meta_tile_preview_free (MetaTilePreview *preview)
-{
-  gtk_widget_destroy (preview->preview_window);
-
-  if (preview->preview_color)
-    gdk_rgba_free (preview->preview_color);
-
-  g_free (preview);
-}
-
-void
-meta_tile_preview_show (MetaTilePreview *preview,
-                        MetaRectangle   *tile_rect)
-{
-  GdkWindow *window;
-  GdkRectangle old_rect;
-
-  if (gtk_widget_get_visible (preview->preview_window)
-      && preview->tile_rect.x == tile_rect->x
-      && preview->tile_rect.y == tile_rect->y
-      && preview->tile_rect.width == tile_rect->width
-      && preview->tile_rect.height == tile_rect->height)
-    return; /* nothing to do */
-
-  gtk_widget_show (preview->preview_window);
-  window = gtk_widget_get_window (preview->preview_window);
-  meta_core_lower_beneath_grab_window (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
-                                       GDK_WINDOW_XID (window),
-                                       gtk_get_current_event_time ());
-
-  old_rect.x = old_rect.y = 0;
-  old_rect.width = preview->tile_rect.width;
-  old_rect.height = preview->tile_rect.height;
-
-  gdk_window_invalidate_rect (window, &old_rect, FALSE);
-
-  preview->tile_rect = *tile_rect;
-
-  gdk_window_move_resize (window,
-                          preview->tile_rect.x, preview->tile_rect.y,
-                          preview->tile_rect.width, preview->tile_rect.height);
-}
-
-void
-meta_tile_preview_hide (MetaTilePreview *preview)
-{
-  gtk_widget_hide (preview->preview_window);
-}
-
-Window
-meta_tile_preview_get_xwindow (MetaTilePreview *preview,
-                               gulong          *create_serial)
-{
-  GdkWindow *window = gtk_widget_get_window (preview->preview_window);
-
-  if (create_serial)
-    *create_serial = preview->create_serial;
-
-  return GDK_WINDOW_XID (window);
-}

src/ui/tile-preview.h

@@ -1,36 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Meta tile preview */
-
-/*
- * Copyright (C) 2010 Florian Müllner
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef META_TILE_PREVIEW_H
-#define META_TILE_PREVIEW_H
-
-#include <meta/boxes.h>
-
-typedef struct _MetaTilePreview MetaTilePreview;
-
-MetaTilePreview   *meta_tile_preview_new    (int                screen_number);
-void               meta_tile_preview_free   (MetaTilePreview   *preview);
-void               meta_tile_preview_show   (MetaTilePreview   *preview,
-                                             MetaRectangle     *rect);
-void               meta_tile_preview_hide   (MetaTilePreview   *preview);
-Window             meta_tile_preview_get_xwindow (MetaTilePreview   *preview,
-                                                  gulong            *create_serial);
-
-#endif /* META_TILE_PREVIEW_H */

src/ui/ui.h

@@ -179,6 +179,5 @@ int      meta_ui_get_drag_threshold       (MetaUI *ui);
 MetaUIDirection meta_ui_get_direction (void);
 
 #include "tabpopup.h"
-#include "tile-preview.h"
 
 #endif

src/wayland/meta-wayland-seat.c

@@ -38,7 +38,6 @@
 #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)
 
@@ -421,8 +420,8 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
   else
     seat->current_stage = NULL;
 
-  if (META_IS_SURFACE_ACTOR_WAYLAND (actor))
-    surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (actor));
+  if (META_IS_SURFACE_ACTOR (actor))
+    surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (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,9 +58,6 @@
 #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,
@@ -117,8 +114,8 @@ surface_process_damage (MetaWaylandSurface *surface,
     {
       cairo_rectangle_int_t rect;
       cairo_region_get_rectangle (region, i, &rect);
-      meta_surface_actor_process_damage (surface->surface_actor,
-                                         rect.x, rect.y, rect.width, rect.height);
+      meta_surface_actor_damage_area (surface->surface_actor,
+                                      rect.x, rect.y, rect.width, rect.height);
     }
 }
 
@@ -298,7 +295,7 @@ actor_surface_commit (MetaWaylandSurface             *surface,
   if (buffer_changed)
     {
       ensure_buffer_texture (buffer);
-      meta_surface_actor_wayland_set_buffer (META_SURFACE_ACTOR_WAYLAND (surface->surface_actor), buffer);
+      meta_surface_actor_attach_wayland_buffer (surface_actor, buffer);
     }
 
   surface_process_damage (surface, pending->damage);
@@ -648,7 +645,7 @@ 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_wayland_new (surface));
+  surface->surface_actor = g_object_ref_sink (meta_surface_actor_new (surface));
   clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), TRUE);
 
   double_buffered_state_init (&surface->pending);