Bump version to 3.11.2

Update NEWS.
display: Remove unused variables
2013-11-19 20:15:13 +01:00 · 2013-11-19 20:12:51 +01:00 · 2013-11-19 20:08:46 +01:00 · 2013-11-19 20:08:46 +01:00 · 2013-11-19 14:04:16 -05:00 · 2013-11-19 14:04:16 -05:00
49 changed files with 1953 additions and 1563 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -81,6 +81,9 @@ src/mutter-plugins.pc
 src/wayland/gtk-shell-protocol.c
 src/wayland/gtk-shell-client-protocol.h
 src/wayland/gtk-shell-server-protocol.h
+src/wayland/xdg-shell-protocol.c
+src/wayland/xdg-shell-client-protocol.h
+src/wayland/xdg-shell-server-protocol.h
 src/wayland/xserver-protocol.c
 src/wayland/xserver-client-protocol.h
 src/wayland/xserver-server-protocol.h
--- a/16
+++ b/16
@@ -1,3 +1,19 @@
+3.11.2
+======
+* Support setting a NULL opaque region [Andreas; #711518]
+* Sync keymap from X to wayland [Giovanni; #707446]
+* Implement support for subsurfaces [Jonas; #705502]
+* Don't focus the no-focus-window for globally active windows [Jasper; #710296]
+* Support "hotplug_mode_update" property [Marc-André; #711216]
+* Fix resize operations using mouse-button-modifier [Lionel; #710251]
+* Fix position of attached modals for CSD windows [Giovanni, Owen; #707194]
+* Misc. bug fixes [Rui, Jasper, Neil, Florian; #712247, #711731]
+
+Contributors:
+  Giovanni Campagna, Andreas Heider, Lionel Landwerlin, Marc-André Lureau,
+  Rui Matos, Florian Müllner, Neil Roberts, Sindhu S, Jasper St. Pierre,
+  Rico Tzschichholz, Owen W. Taylor, Jonas Ådahl
+
 3.11.1
 ======
 * Fix tile previews getting stuck on right click during drags [Lionel; #704759]
--- a/configure.ac
+++ b/configure.ac
@@ -3,7 +3,7 @@ AC_CONFIG_MACRO_DIR([m4])

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

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -78,7 +78,7 @@ MUTTER_PC_MODULES="
   cairo >= 1.10.0
   gsettings-desktop-schemas >= 3.7.3
   xcomposite >= 0.2 xfixes xrender xdamage xi >= 1.6.0
-   $CLUTTER_PACKAGE >= 1.15.94
+   $CLUTTER_PACKAGE >= 1.17.1
   cogl-1.0 >= 1.13.3
   upower-glib >= 0.99.0
   gnome-desktop-3.0
--- a/doc/reference/Makefile.am
+++ b/doc/reference/Makefile.am
@@ -49,8 +49,8 @@ FIXXREF_OPTIONS=
 # Used for dependencies. The docs will be rebuilt if any of these change.
 # e.g. HFILE_GLOB=$(top_srcdir)/gtk/*.h
 # e.g. CFILE_GLOB=$(top_srcdir)/gtk/*.c
-HFILE_GLOB=$(top_srcdir)/src/*.h
-CFILE_GLOB=$(top_srcdir)/src/*.c
+HFILE_GLOB=$(top_srcdir)/src/*/*.h
+CFILE_GLOB=$(top_srcdir)/src/*/*.c

 # Extra header to include when scanning, which are not under DOC_SOURCE_DIR
 # e.g. EXTRA_HFILES=$(top_srcdir}/contrib/extra.h
--- a/doc/reference/meta-sections.txt
+++ b/doc/reference/meta-sections.txt
@@ -541,7 +541,10 @@ meta_window_is_override_redirect
 meta_window_is_skip_taskbar
 meta_window_get_rect
 meta_window_get_input_rect
+meta_window_get_frame_rect
 meta_window_get_outer_rect
+meta_window_client_rect_to_frame_rect
+meta_window_frame_rect_to_client_rect
 meta_window_get_screen
 meta_window_get_display
 meta_window_get_xwindow
--- a/protocol/Makefile.am
+++ b/protocol/Makefile.am
@@ -1 +1,7 @@
-EXTRA_DIST = xserver.xml
+NULL =
+
+EXTRA_DIST = \
+	gtk-shell.xml \
+	xdg-shell.xml \
+	xserver.xml \
+	$(NULL)
--- a/protocol/xdg-shell.xml
+++ b/protocol/xdg-shell.xml
@@ -0,0 +1,385 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="xdg_surface">
+
+  <copyright>
+    Copyright © 2008-2013 Kristian Høgsberg
+    Copyright © 2013      Rafael Antognolli
+    Copyright © 2013      Jasper St. Pierre
+    Copyright © 2010-2013 Intel Corporation
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <interface name="xdg_shell" version="1">
+    <description summary="create desktop-style surfaces">
+      This interface is implemented by servers that provide
+      desktop-style user interfaces.
+
+      It allows clients to associate a xdg_surface with
+      a basic surface.
+    </description>
+
+    <enum name="version">
+      <description summary="latest protocol version">
+	Use this enum to check the protocol version, and it will be updated
+	automatically.
+      </description>
+      <entry name="current" value="1" summary="Always the latest version"/>
+    </enum>
+
+
+    <request name="use_unstable_version">
+      <description summary="enable use of this unstable version">
+	Use this request in order to enable use of this interface.
+
+	Understand and agree that one is using an unstable interface,
+	that will likely change in the future, breaking the API.
+      </description>
+      <arg name="version" type="int"/>
+    </request>
+
+    <request name="get_xdg_surface">
+      <description summary="create a shell surface from a surface">
+	Create a shell surface for an existing surface.
+
+	Only one shell or popup surface can be associated with a given
+	surface.
+      </description>
+      <arg name="id" type="new_id" interface="xdg_surface"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </request>
+
+    <request name="get_xdg_popup">
+      <description summary="create a shell surface from a surface">
+	Create a popup surface for an existing surface.
+
+	Only one shell or popup surface can be associated with a given
+	surface.
+      </description>
+      <arg name="id" type="new_id" interface="xdg_popup"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="parent" type="object" interface="wl_surface"/>
+      <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat whose pointer is used"/>
+      <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="flags" type="uint"/>
+    </request>
+  </interface>
+
+  <interface name="xdg_surface" version="1">
+
+    <description summary="desktop-style metadata interface">
+      An interface that may be implemented by a wl_surface, for
+      implementations that provide a desktop-style user interface.
+
+      It provides requests to treat surfaces like windows, allowing to set
+      properties like maximized, fullscreen, minimized, and to move and resize
+      them, and associate metadata like title and app id.
+
+      On the server side the object is automatically destroyed when
+      the related wl_surface is destroyed.  On client side,
+      xdg_surface.destroy() must be called before destroying
+      the wl_surface object.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="remove xdg_surface interface">
+	The xdg_surface interface is removed from the wl_surface object
+	that was turned into a xdg_surface with
+	xdg_shell.get_xdg_surface request. The xdg_surface properties,
+	like maximized and fullscreen, are lost. The wl_surface loses
+	its role as a xdg_surface. The wl_surface is unmapped.
+      </description>
+    </request>
+
+    <request name="set_transient_for">
+      <description summary="surface is a child of another surface">
+	Setting a surface as transient of another means that it is child
+	of another surface.
+
+	Child surfaces are stacked above their parents, and will be
+	unmapped if the parent is unmapped too. They should not appear
+	on task bars and alt+tab.
+      </description>
+      <arg name="parent" type="object" interface="wl_surface"/>
+    </request>
+
+    <request name="set_title">
+      <description summary="set surface title">
+	Set a short title for the surface.
+
+	This string may be used to identify the surface in a task bar,
+	window list, or other user interface elements provided by the
+	compositor.
+
+	The string must be encoded in UTF-8.
+      </description>
+      <arg name="title" type="string"/>
+    </request>
+
+    <request name="set_app_id">
+      <description summary="set surface class">
+	Set an id for the surface.
+
+	The app id identifies the general class of applications to which
+	the surface belongs.
+
+	It should be the ID that appears in the new desktop entry
+	specification, the interface name.
+      </description>
+      <arg name="app_id" type="string"/>
+    </request>
+
+    <request name="pong">
+      <description summary="respond to a ping event">
+	A client must respond to a ping event with a pong request or
+	the client may be deemed unresponsive.
+      </description>
+      <arg name="serial" type="uint" summary="serial of the ping event"/>
+    </request>
+
+    <event name="ping">
+      <description summary="ping client">
+	Ping a client to check if it is receiving events and sending
+	requests. A client is expected to reply with a pong request.
+      </description>
+      <arg name="serial" type="uint"/>
+    </event>
+
+    <request name="move">
+      <description summary="start an interactive move">
+	Start a pointer-driven move of the surface.
+
+	This request must be used in response to a button press event.
+	The server may ignore move requests depending on the state of
+	the surface (e.g. fullscreen or maximized).
+      </description>
+      <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat whose pointer is used"/>
+      <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/>
+    </request>
+
+    <enum name="resize_edge">
+      <description summary="edge values for resizing">
+	These values are used to indicate which edge of a surface
+	is being dragged in a resize operation. The server may
+	use this information to adapt its behavior, e.g. choose
+	an appropriate cursor image.
+      </description>
+      <entry name="none" value="0"/>
+      <entry name="top" value="1"/>
+      <entry name="bottom" value="2"/>
+      <entry name="left" value="4"/>
+      <entry name="top_left" value="5"/>
+      <entry name="bottom_left" value="6"/>
+      <entry name="right" value="8"/>
+      <entry name="top_right" value="9"/>
+      <entry name="bottom_right" value="10"/>
+    </enum>
+
+    <request name="resize">
+      <description summary="start an interactive resize">
+	Start a pointer-driven resizing of the surface.
+
+	This request must be used in response to a button press event.
+	The server may ignore resize requests depending on the state of
+	the surface (e.g. fullscreen or maximized).
+      </description>
+      <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat whose pointer is used"/>
+      <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/>
+      <arg name="edges" type="uint" summary="which edge or corner is being dragged"/>
+    </request>
+
+    <event name="configure">
+      <description summary="suggest resize">
+	The configure event asks the client to resize its surface.
+
+	The size is a hint, in the sense that the client is free to
+	ignore it if it doesn't resize, pick a smaller size (to
+	satisfy aspect ratio or resize in steps of NxM pixels).
+
+	The edges parameter provides a hint about how the surface
+	was resized. The client may use this information to decide
+	how to adjust its content to the new size (e.g. a scrolling
+	area might adjust its content position to leave the viewable
+	content unmoved). Valid edge values are from resize_edge enum.
+
+	The maximized parameter informs if the surface is in a maximized
+	state. Same for the fullscreen parameter.
+
+	The client is free to dismiss all but the last configure
+	event it received.
+
+	The width and height arguments specify the size of the window
+	in surface local coordinates.
+      </description>
+
+      <arg name="edges" type="uint"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+      <arg name="maximized" type="uint"/>
+      <arg name="fullscreen" type="uint"/>
+    </event>
+
+    <request name="set_output">
+      <description summary="set the default output used by this surface">
+	Set the default output used by this surface when it is first mapped.
+
+	If this value is NULL (default), it's up to the compositor to choose
+	which display will be used to map this surface.
+
+	When fullscreen or maximized state are set on this surface, and it
+	wasn't mapped yet, the output set with this method will be used.
+	Otherwise, the output where the surface is currently mapped will be
+	used.
+      </description>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+    </request>
+
+    <request name="set_fullscreen">
+      <description summary="set the surface state as fullscreen">
+	Set the surface as fullscreen.
+
+	The compositor must reply to this request with a configure event
+	with the dimensions for the output on which the surface will be
+	made fullscreen.
+
+	Once the fullscreen state is set, a "fullscreen_set" event will
+	be sent to the client.
+
+	Setting one state won't unset another state. Use
+	xdg_surface.unset_fullscreen for unsetting it.
+      </description>
+    </request>
+
+    <request name="unset_fullscreen">
+      <description summary="unset the surface state as fullscreen">
+	Unset the surface fullscreen state.
+      </description>
+    </request>
+
+    <request name="set_maximized">
+      <description summary="set the surface state as maximized">
+	Set the surface as maximized.
+
+	The compositor must reply to this request with a configure event
+	with the dimensions for the output on which the surface will be
+	made maximized.
+
+	Once the maximized state is set, a "maximized_set" event will be
+	sent to the client.
+
+	Setting one state won't unset another state. Use
+	xdg_surface.unset_maximized for unsetting it.
+      </description>
+    </request>
+
+    <request name="unset_maximized">
+      <description summary="unset the surface state as maximized">
+	Unset the surface maximized state.
+      </description>
+    </request>
+
+    <request name="set_minimized">
+      <description summary="set the surface state as minimized">
+	Set the surface minimized state.
+
+	Setting one state won't unset another state.
+      </description>
+    </request>
+
+    <event name="focused_set">
+      <description summary="surface was focused">
+	The focused_set event is sent when this surface has been
+	activated. Window decorations should be updated accordingly.
+      </description>
+    </event>
+
+    <event name="focused_unset">
+      <description summary="surface was unfocused">
+	The focused_unset event is sent when this surface has been
+	deactivated, because another surface has been activated. Window
+	decorations should be updated accordingly.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="xdg_popup" version="1">
+    <description summary="desktop-style metadata interface">
+      An interface that may be implemented by a wl_surface, for
+      implementations that provide a desktop-style popups/menus. A popup
+      surface is a transient surface with an added pointer grab.
+
+      An existing implicit grab will be changed to owner-events mode,
+      and the popup grab will continue after the implicit grab ends
+      (i.e. releasing the mouse button does not cause the popup to be
+      unmapped).
+
+      The popup grab continues until the window is destroyed or a mouse
+      button is pressed in any other clients window. A click in any of
+      the clients surfaces is reported as normal, however, clicks in
+      other clients surfaces will be discarded and trigger the callback.
+
+      The x and y arguments specify the locations of the upper left
+      corner of the surface relative to the upper left corner of the
+      parent surface, in surface local coordinates.
+
+      xdg_popup surfaces are always transient for another surface.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="remove xdg_surface interface">
+	The xdg_surface interface is removed from the wl_surface object
+	that was turned into a xdg_surface with
+	xdg_shell.get_xdg_surface request. The xdg_surface properties,
+	like maximized and fullscreen, are lost. The wl_surface loses
+	its role as a xdg_surface. The wl_surface is unmapped.
+      </description>
+    </request>
+
+    <request name="pong">
+      <description summary="respond to a ping event">
+	A client must respond to a ping event with a pong request or
+	the client may be deemed unresponsive.
+      </description>
+      <arg name="serial" type="uint" summary="serial of the ping event"/>
+    </request>
+
+    <event name="ping">
+      <description summary="ping client">
+	Ping a client to check if it is receiving events and sending
+	requests. A client is expected to reply with a pong request.
+      </description>
+      <arg name="serial" type="uint"/>
+    </event>
+
+    <event name="popup_done">
+      <description summary="popup interaction is done">
+	The popup_done event is sent out when a popup grab is broken,
+	that is, when the users clicks a surface that doesn't belong
+	to the client owning the popup surface.
+      </description>
+      <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/>
+    </event>
+
+  </interface>
+</protocol>
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -43,6 +43,9 @@ mutter_built_sources = \
 	wayland/gtk-shell-protocol.c		\
 	wayland/gtk-shell-server-protocol.h	\
 	wayland/gtk-shell-client-protocol.h	\
+	wayland/xdg-shell-protocol.c		\
+	wayland/xdg-shell-server-protocol.h	\
+	wayland/xdg-shell-client-protocol.h	\
 	wayland/xserver-protocol.c		\
 	wayland/xserver-server-protocol.h	\
 	wayland/xserver-client-protocol.h
@@ -77,6 +80,8 @@ libmutter_wayland_la_SOURCES =			\
 	compositor/meta-shadow-factory-private.h	\
 	compositor/meta-shaped-texture.c	\
 	compositor/meta-shaped-texture-private.h 	\
+	compositor/meta-surface-actor.c		\
+	compositor/meta-surface-actor.h		\
 	compositor/meta-texture-rectangle.c	\
 	compositor/meta-texture-rectangle.h	\
 	compositor/meta-texture-tower.c		\
@@ -183,7 +188,9 @@ libmutter_wayland_la_SOURCES =			\
 	ui/theme.c				\
 	meta/theme.h				\
 	ui/theme-private.h			\
-	ui/ui.c					\
+	ui/ui.c
+
+nodist_libmutter_wayland_la_SOURCES =		\
 	$(mutter_built_sources)

 libmutter_wayland_la_SOURCES +=			\
@@ -297,7 +304,7 @@ Meta-$(api_version).gir: libmutter-wayland.la
@META_GIR@_FILES =				\
 	mutter-enum-types.h			\
 	$(libmutterinclude_base_headers)	\
-	$(filter %.c,$(libmutter_wayland_la_SOURCES))
+	$(filter %.c,$(libmutter_wayland_la_SOURCES) $(nodist_libmutter_wayland_la_SOURCES))
@META_GIR@_SCANNERFLAGS = --warn-all --warn-error

 endif
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -650,11 +650,6 @@ redirect_windows (MetaCompositor *compositor,
  guint        n_retries;
  guint        max_retries;

-  /* If we're running with wayland, connected to a headless xwayland
-   * server then all the windows are implicitly redirected offscreen
-   * already and it would generate an error to try and explicitly
-   * redirect them via XCompositeRedirectSubwindows() */
-
  if (meta_get_replace_current_wm ())
    max_retries = 5;
  else
@@ -792,8 +787,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
  clutter_actor_add_child (info->stage, info->window_group);
  clutter_actor_add_child (info->stage, info->top_window_group);

-  info->plugin_mgr = meta_plugin_manager_new (screen);
-
  if (meta_is_wayland_compositor ())
    {
      /* NB: When running as a wayland compositor we don't need an X
@@ -803,13 +796,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
    }
  else
    {
-      /*
-       * Delay the creation of the overlay window as long as we can, to avoid
-       * blanking out the screen. This means that during the plugin loading, the
-       * overlay window is not accessible; if the plugin needs to access it
-       * directly, it should hook into the "show" signal on stage, and do
-       * its stuff there.
-       */
      info->output = get_output_window (screen);
      XReparentWindow (xdisplay, xwin, info->output, 0, 0);

@@ -830,6 +816,8 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
          info->pending_input_region = None;
        }

+      info->plugin_mgr = meta_plugin_manager_new (screen);
+
      /* Map overlay window before redirecting windows offscreen so we catch their
       * contents until we show the stage.
       */
@@ -876,7 +864,7 @@ meta_shape_cow_for_window (MetaScreen *screen,
      int width, height;
      MetaRectangle rect;

-      meta_window_get_outer_rect (metaWindow, &rect);
+      meta_window_get_frame_rect (metaWindow, &rect);

      window_bounds.x = rect.x;
      window_bounds.y = rect.y;
--- a/src/compositor/meta-shaped-texture-private.h
+++ b/src/compositor/meta-shaped-texture-private.h
@@ -28,17 +28,9 @@
 #define __META_SHAPED_TEXTURE_PRIVATE_H__

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

-ClutterActor *meta_shaped_texture_new_with_xwindow (Window xwindow);
-ClutterActor *meta_shaped_texture_new_with_wayland_surface  (MetaWaylandSurface *surface);
-void meta_shaped_texture_set_wayland_surface                (MetaShapedTexture  *stex,
-                                                             MetaWaylandSurface *surface);
-MetaWaylandSurface *meta_shaped_texture_get_wayland_surface (MetaShapedTexture *stex);
-
-void meta_shaped_texture_set_pixmap (MetaShapedTexture *stex,
-                                     Pixmap             pixmap);
-void meta_shaped_texture_attach_wayland_buffer (MetaShapedTexture  *stex,
-                                                MetaWaylandBuffer  *buffer);
+ClutterActor *meta_shaped_texture_new (void);
+void meta_shaped_texture_set_texture (MetaShapedTexture *stex,
+                                      CoglTexture       *texture);

 #endif
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -35,12 +35,9 @@
 #include "meta-texture-tower.h"

 #include "meta-shaped-texture-private.h"
-#include "meta-wayland-private.h"
-#include <cogl/cogl-wayland-server.h>

 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
-#include <cogl/cogl-texture-pixmap-x11.h>
 #include <gdk/gdk.h> /* for gdk_rectangle_intersect() */

 static void meta_shaped_texture_dispose  (GObject    *object);
@@ -61,15 +58,7 @@ static void meta_shaped_texture_get_preferred_height (ClutterActor *self,

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

-typedef enum _MetaShapedTextureType
-{
-  META_SHAPED_TEXTURE_TYPE_X11_PIXMAP,
-  META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE,
-} MetaShapedTextureType;
-
-
-G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
-               CLUTTER_TYPE_ACTOR);
+G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture, CLUTTER_TYPE_ACTOR);

 #define META_SHAPED_TEXTURE_GET_PRIVATE(obj) \
  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_SHAPED_TEXTURE, \
@@ -79,18 +68,7 @@ struct _MetaShapedTexturePrivate
 {
  MetaTextureTower *paint_tower;

-  MetaShapedTextureType type;
-  union {
-    struct {
-      Pixmap pixmap;
-    } x11;
-    struct {
-      MetaWaylandSurface *surface;
-    } wayland;
-  };
-
  CoglTexture *texture;
-
  CoglTexture *mask_texture;

  cairo_region_t *clip_region;
@@ -128,9 +106,7 @@ meta_shaped_texture_init (MetaShapedTexture *self)

  priv->paint_tower = meta_texture_tower_new ();

-  priv->type = META_SHAPED_TEXTURE_TYPE_X11_PIXMAP;
  priv->texture = NULL;
-
  priv->mask_texture = NULL;
  priv->create_mipmaps = TRUE;
 }
@@ -220,10 +196,8 @@ paint_clipped_rectangle (CoglFramebuffer       *fb,
  cogl_framebuffer_draw_multitextured_rectangle (fb, pipeline,
                                                 x1, y1, x2, y2,
                                                 &coords[0], 8);
-
 }

-
 static void
 set_cogl_texture (MetaShapedTexture *stex,
                  CoglTexture       *cogl_tex)
@@ -266,6 +240,9 @@ set_cogl_texture (MetaShapedTexture *stex,
   * know how much of the buffer has changed with respect to the
   * previous buffer. We only queue a redraw in response to surface
   * damage. */
+
+  if (priv->create_mipmaps)
+    meta_texture_tower_set_base_texture (priv->paint_tower, cogl_tex);
 }

 static void
@@ -568,48 +545,6 @@ meta_shaped_texture_get_paint_volume (ClutterActor *self,
  return clutter_paint_volume_set_from_allocation (volume, self);
 }

-ClutterActor *
-meta_shaped_texture_new_with_wayland_surface (MetaWaylandSurface *surface)
-{
-  ClutterActor *actor = g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);
-  MetaShapedTexturePrivate *priv = META_SHAPED_TEXTURE (actor)->priv;
-
-  /* XXX: it could probably be better to have a "type" construct-only
-   * property or create wayland/x11 subclasses */
-  priv->type = META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE;
-
-  meta_shaped_texture_set_wayland_surface (META_SHAPED_TEXTURE (actor),
-                                           surface);
-
-  return actor;
-}
-
-void
-meta_shaped_texture_set_wayland_surface (MetaShapedTexture *stex,
-                                         MetaWaylandSurface *surface)
-{
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  priv->wayland.surface = surface;
-
-  if (surface && surface->buffer_ref.buffer)
-    meta_shaped_texture_attach_wayland_buffer (stex,
-                                               surface->buffer_ref.buffer);
-}
-
-MetaWaylandSurface *
-meta_shaped_texture_get_wayland_surface (MetaShapedTexture *stex)
-{
-  MetaShapedTexturePrivate *priv = stex->priv;
-  return priv->wayland.surface;
-}
-
-ClutterActor *
-meta_shaped_texture_new_with_xwindow (Window xwindow)
-{
-  return g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);
-}
-
 void
 meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
 					gboolean           create_mipmaps)
@@ -652,66 +587,6 @@ meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }

-static void
-wayland_surface_update_area (MetaShapedTexture *stex,
-                             int                x,
-                             int                y,
-                             int                width,
-                             int                height)
-{
-  MetaShapedTexturePrivate *priv;
-  MetaWaylandBuffer *buffer;
-
-  priv = stex->priv;
-
-  g_return_if_fail (priv->type == META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE);
-  g_return_if_fail (priv->texture != NULL);
-
-  buffer = priv->wayland.surface->buffer_ref.buffer;
-
-  if (buffer)
-    {
-      struct wl_resource *resource = buffer->resource;
-      struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
-
-      if (shm_buffer)
-        {
-          CoglPixelFormat format;
-
-          switch (wl_shm_buffer_get_format (shm_buffer))
-            {
-#if G_BYTE_ORDER == G_BIG_ENDIAN
-            case WL_SHM_FORMAT_ARGB8888:
-              format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
-              break;
-            case WL_SHM_FORMAT_XRGB8888:
-              format = COGL_PIXEL_FORMAT_ARGB_8888;
-              break;
-#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
-            case WL_SHM_FORMAT_ARGB8888:
-              format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
-              break;
-            case WL_SHM_FORMAT_XRGB8888:
-              format = COGL_PIXEL_FORMAT_BGRA_8888;
-              break;
-#endif
-            default:
-              g_warn_if_reached ();
-              format = COGL_PIXEL_FORMAT_ARGB_8888;
-            }
-
-          cogl_texture_set_region (priv->texture,
-                                   x, y,
-                                   x, y,
-                                   width, height,
-                                   width, height,
-                                   format,
-                                   wl_shm_buffer_get_stride (shm_buffer),
-                                   wl_shm_buffer_get_data (shm_buffer));
-        }
-    }
-}
-
 static gboolean
 get_clip (MetaShapedTexture *stex,
          int x,
@@ -770,8 +645,8 @@ get_clip (MetaShapedTexture *stex,
 * has a mapped clone)
 *
 * Repairs the damaged area indicated by @x, @y, @width and @height
- * and queues a redraw for the intersection @visibible_region and
- * the damage area. If @visibible_region is %NULL a redraw will always
+ * and queues a redraw for the intersection @unobscured_region and
+ * the damage area. If @unobscured_region is %NULL a redraw will always
 * get queued.
 *
 * Return value: Whether a redraw have been queued or not
@@ -793,17 +668,6 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
  if (priv->texture == NULL)
    return FALSE;

-  switch (priv->type)
-    {
-    case META_SHAPED_TEXTURE_TYPE_X11_PIXMAP:
-      cogl_texture_pixmap_x11_update_area (COGL_TEXTURE_PIXMAP_X11 (priv->texture),
-                                           x, y, width, height);
-      break;
-    case META_SHAPED_TEXTURE_TYPE_WAYLAND_SURFACE:
-      wayland_surface_update_area (stex, x, y, width, height);
-      break;
-    }
-
  meta_texture_tower_update_area (priv->paint_tower, x, y, width, height);

  has_clip = get_clip (stex, x, y, width, height, &clip);
@@ -843,66 +707,17 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
 }

 /**
- * meta_shaped_texture_set_pixmap:
+ * meta_shaped_texture_set_texture:
 * @stex: The #MetaShapedTexture
- * @pixmap: The pixmap you want the stex to assume
+ * @pixmap: The #CoglTexture to display
 */
 void
-meta_shaped_texture_set_pixmap (MetaShapedTexture *stex,
-                                Pixmap             pixmap)
+meta_shaped_texture_set_texture (MetaShapedTexture *stex,
+                                 CoglTexture       *texture)
 {
-  MetaShapedTexturePrivate *priv;
-
  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));

-  priv = stex->priv;
-
-  if (priv->x11.pixmap == pixmap)
-    return;
-
-  priv->x11.pixmap = pixmap;
-
-  if (pixmap != None)
-    {
-      CoglContext *ctx =
-        clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      CoglTexture *texture =
-        COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, pixmap, FALSE, NULL));
-      set_cogl_texture (stex, texture);
-    }
-  else
-    set_cogl_texture (stex, NULL);
-
-  if (priv->create_mipmaps)
-    meta_texture_tower_set_base_texture (priv->paint_tower,
-                                         COGL_TEXTURE (priv->texture));
-}
-
-void
-meta_shaped_texture_attach_wayland_buffer (MetaShapedTexture  *stex,
-                                           MetaWaylandBuffer  *buffer)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  /* TODO: we should change this api to be something like
-   * meta_shaped_texture_notify_buffer_attach() since we now maintain
-   * a reference to the MetaWaylandSurface where we can access the
-   * buffer without it being explicitly passed as an argument.
-   */
-  g_return_if_fail (priv->wayland.surface->buffer_ref.buffer == buffer);
-
-  if (buffer)
-    set_cogl_texture (stex, buffer->texture);
-  else
-    set_cogl_texture (stex, NULL);
-
-  if (priv->create_mipmaps)
-    meta_texture_tower_set_base_texture (priv->paint_tower,
-                                         COGL_TEXTURE (priv->texture));
+  set_cogl_texture (stex, texture);
 }

 /**
@@ -1113,3 +928,9 @@ meta_shaped_texture_get_image (MetaShapedTexture     *stex,

  return surface;
 }
+
+ClutterActor *
+meta_shaped_texture_new (void)
+{
+  return g_object_new (META_TYPE_SHAPED_TEXTURE, NULL);
+}
--- a/src/compositor/meta-surface-actor.c
+++ b/src/compositor/meta-surface-actor.c
@@ -0,0 +1,149 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * SECTION:meta-surface-actor
+ * @title: MetaSurfaceActor
+ * @short_description: An actor representing a surface in the scene graph
+ *
+ * A surface can be either a shaped texture, or a group of shaped texture,
+ * used to draw the content of a window.
+ */
+
+#include <config.h>
+#include <clutter/clutter.h>
+#include <cogl/cogl-wayland-server.h>
+#include <cogl/cogl-texture-pixmap-x11.h>
+#include <meta/meta-shaped-texture.h>
+#include "meta-surface-actor.h"
+
+#include "meta-shaped-texture-private.h"
+
+struct _MetaSurfaceActorPrivate
+{
+  MetaShapedTexture *texture;
+  MetaWaylandBuffer *buffer;
+  Pixmap pixmap;
+};
+
+G_DEFINE_TYPE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR);
+
+static void
+meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
+{
+  g_type_class_add_private (klass, sizeof (MetaSurfaceActorPrivate));
+}
+
+static void
+meta_surface_actor_init (MetaSurfaceActor *self)
+{
+  MetaSurfaceActorPrivate *priv;
+
+  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+                                                   META_TYPE_SURFACE_ACTOR,
+                                                   MetaSurfaceActorPrivate);
+
+  priv->texture = NULL;
+}
+
+MetaSurfaceActor *
+meta_surface_actor_new (void)
+{
+  MetaSurfaceActor *self = g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
+  MetaShapedTexture *stex;
+
+  stex = META_SHAPED_TEXTURE (meta_shaped_texture_new ());
+  self->priv->texture = stex;
+
+  clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (stex));
+
+  return self;
+}
+
+cairo_surface_t *
+meta_surface_actor_get_image (MetaSurfaceActor      *self,
+                              cairo_rectangle_int_t *clip)
+{
+  return meta_shaped_texture_get_image (self->priv->texture, clip);
+}
+
+MetaShapedTexture *
+meta_surface_actor_get_texture (MetaSurfaceActor *self)
+{
+  return self->priv->texture;
+}
+
+void
+meta_surface_actor_set_clip_region (MetaSurfaceActor *self,
+                                    cairo_region_t   *clip_region)
+{
+  meta_shaped_texture_set_clip_region (self->priv->texture, clip_region);
+}
+
+static void
+update_area (MetaSurfaceActor *self,
+             int x, int y, int width, int height)
+{
+  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_2d_update_area (texture, shm_buffer, x, y, width, height);
+        }
+    }
+  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,
+                               cairo_region_t   *unobscured_region)
+{
+  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 (self->priv->texture,
+                                          0, 0,
+                                          cogl_texture_get_width (texture),
+                                          cogl_texture_get_height (texture),
+                                          unobscured_region);
+}
+
+gboolean
+meta_surface_actor_damage_area (MetaSurfaceActor *self,
+                                int               x,
+                                int               y,
+                                int               width,
+                                int               height,
+                                cairo_region_t   *unobscured_region)
+{
+  update_area (self, x, y, width, height);
+  return meta_shaped_texture_update_area (self->priv->texture,
+                                          x, y, width, height,
+                                          unobscured_region);
+}
+
+void
+meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor *self,
+                                          MetaWaylandBuffer *buffer)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+  priv->buffer = buffer;
+  meta_shaped_texture_set_texture (self->priv->texture, buffer->texture);
+}
+
+void
+meta_surface_actor_set_texture (MetaSurfaceActor *self,
+                                CoglTexture      *texture)
+{
+  meta_shaped_texture_set_texture (self->priv->texture, texture);
+}
--- a/src/compositor/meta-surface-actor.h
+++ b/src/compositor/meta-surface-actor.h
@@ -0,0 +1,66 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#ifndef META_SURFACE_ACTOR_PRIVATE_H
+#define META_SURFACE_ACTOR_PRIVATE_H
+
+#include <config.h>
+
+#include <meta/meta-shaped-texture.h>
+#include "meta-wayland-private.h"
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SURFACE_ACTOR            (meta_surface_actor_get_type())
+#define META_SURFACE_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR, MetaSurfaceActor))
+#define META_SURFACE_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_SURFACE_ACTOR, MetaSurfaceActorClass))
+#define META_IS_SURFACE_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR))
+#define META_IS_SURFACE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_SURFACE_ACTOR))
+#define META_SURFACE_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_SURFACE_ACTOR, MetaSurfaceActorClass))
+
+typedef struct _MetaSurfaceActor        MetaSurfaceActor;
+typedef struct _MetaSurfaceActorClass   MetaSurfaceActorClass;
+typedef struct _MetaSurfaceActorPrivate MetaSurfaceActorPrivate;
+
+struct _MetaSurfaceActorClass
+{
+  /*< private >*/
+  ClutterActorClass parent_class;
+};
+
+struct _MetaSurfaceActor
+{
+  ClutterActor            parent;
+
+  MetaSurfaceActorPrivate *priv;
+};
+
+GType meta_surface_actor_get_type (void);
+
+MetaSurfaceActor *meta_surface_actor_new (void);
+
+cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,
+                                               cairo_rectangle_int_t *clip);
+
+MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);
+
+void meta_surface_actor_set_clip_region (MetaSurfaceActor *self,
+                                         cairo_region_t   *clip_region);
+
+gboolean meta_surface_actor_damage_all (MetaSurfaceActor *self,
+                                        cairo_region_t   *unobscured_region);
+
+gboolean meta_surface_actor_damage_area (MetaSurfaceActor *self,
+                                         int               x,
+                                         int               y,
+                                         int               width,
+                                         int               height,
+                                         cairo_region_t   *unobscured_region);
+
+void meta_surface_actor_set_texture (MetaSurfaceActor *self,
+                                     CoglTexture      *texture);
+void meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor  *self,
+                                               MetaWaylandBuffer *buffer);
+
+G_END_DECLS
+
+#endif /* META_SURFACE_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -10,6 +10,7 @@

 #include <X11/extensions/Xdamage.h>
 #include <meta/compositor-mutter.h>
+#include "meta-surface-actor.h"

 MetaWindowActor *meta_window_actor_new (MetaWindow *window);

@@ -35,8 +36,6 @@ void meta_window_actor_process_wayland_damage (MetaWindowActor *self,
                                               int              y,
                                               int              width,
                                               int              height);
-void meta_window_actor_set_wayland_surface    (MetaWindowActor    *self,
-                                               MetaWaylandSurface *surface);
 void meta_window_actor_attach_wayland_buffer  (MetaWindowActor   *self,
                                               MetaWaylandBuffer *buffer);

@@ -82,4 +81,6 @@ void meta_window_actor_set_unobscured_region      (MetaWindowActor *self,
 void meta_window_actor_effect_completed (MetaWindowActor *actor,
                                         gulong           event);

+MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self);
+
 #endif /* META_WINDOW_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -30,6 +30,7 @@
 #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"
@@ -50,7 +51,9 @@ struct _MetaWindowActorPrivate
  Window            xwindow;
  MetaScreen       *screen;

-  ClutterActor     *actor;
+  MetaSurfaceActor *surface;
+
+  guint             surface_allocation_changed_id;

  /* MetaShadowFactory only caches shadows that are actually in use;
   * to avoid unnecessary recomputation we do two things: 1) we store
@@ -298,6 +301,8 @@ meta_window_actor_init (MetaWindowActor *self)
  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 						   META_TYPE_WINDOW_ACTOR,
 						   MetaWindowActorPrivate);
+
+  priv->surface_allocation_changed_id = 0;
  priv->opacity = 0xff;
  priv->shadow_class = NULL;
 }
@@ -359,6 +364,17 @@ window_appears_focused_notify (MetaWindow *mw,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (data));
 }

+static void
+surface_allocation_changed_notify (ClutterActor           *actor,
+                                   const ClutterActorBox  *allocation,
+                                   ClutterAllocationFlags  flags,
+                                   MetaWindowActor        *self)
+{
+  meta_window_actor_sync_actor_geometry (self, FALSE);
+
+  g_signal_emit (self, signals[SIZE_CHANGED], 0);
+}
+
 static void
 meta_window_actor_constructed (GObject *object)
 {
@@ -389,17 +405,18 @@ meta_window_actor_constructed (GObject *object)
      priv->argb32 = TRUE;
    }

-  if (!priv->actor)
+  if (!priv->surface)
    {
-      if (meta_is_wayland_compositor ())
-        priv->actor = meta_shaped_texture_new_with_wayland_surface (window->surface);
-      else
-        priv->actor = meta_shaped_texture_new_with_xwindow (xwindow);
+      priv->surface = meta_surface_actor_new ();

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

-      if (meta_is_wayland_compositor ())
-        clutter_actor_set_reactive (priv->actor, TRUE);
+      priv->surface_allocation_changed_id =
+        g_signal_connect (CLUTTER_ACTOR (priv->surface),
+                          "allocation-changed",
+                          G_CALLBACK (surface_allocation_changed_notify),
+                          self);

      /*
       * Since we are holding a pointer to this actor independently of the
@@ -408,7 +425,7 @@ meta_window_actor_constructed (GObject *object)
       * via the container interface, we do not end up with a dangling pointer.
       * We will release it in dispose().
       */
-      g_object_ref (priv->actor);
+      g_object_ref (priv->surface);

      g_signal_connect_object (window, "notify::decorated",
                               G_CALLBACK (window_decorated_notify), self, 0);
@@ -421,7 +438,7 @@ meta_window_actor_constructed (GObject *object)
       * This is the case where existing window is gaining/loosing frame.
       * Just ensure the actor is top most (i.e., above shadow).
       */
-      clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self), priv->actor, NULL);
+      clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self), CLUTTER_ACTOR (priv->surface), NULL);
    }

  meta_window_actor_update_opacity (self);
@@ -486,10 +503,15 @@ meta_window_actor_dispose (GObject *object)

  g_clear_object (&priv->window);

+  if (priv->surface != NULL && priv->surface_allocation_changed_id != 0)
+    g_signal_handler_disconnect (priv->surface,
+                                 priv->surface_allocation_changed_id);
+  priv->surface_allocation_changed_id = 0;
+
  /*
   * Release the extra reference we took on the actor.
   */
-  g_clear_object (&priv->actor);
+  g_clear_object (&priv->surface);

  G_OBJECT_CLASS (meta_window_actor_parent_class)->dispose (object);
 }
@@ -885,7 +907,21 @@ meta_window_actor_get_meta_window (MetaWindowActor *self)
 ClutterActor *
 meta_window_actor_get_texture (MetaWindowActor *self)
 {
-  return self->priv->actor;
+  return CLUTTER_ACTOR (meta_surface_actor_get_texture (self->priv->surface));
+}
+
+/**
+ * meta_window_actor_get_surface:
+ * @self: a #MetaWindowActor
+ *
+ * Gets the MetaSurfaceActor that draws the content of this window
+ *
+ * Return value: (transfer none): the #MetaSurfaceActor for the contents
+ */
+MetaSurfaceActor *
+meta_window_actor_get_surface (MetaWindowActor *self)
+{
+  return self->priv->surface;
 }

 /**
@@ -962,8 +998,8 @@ meta_window_actor_freeze (MetaWindowActor *self)
    self->priv->freeze_count++;
 }

-static
-gboolean send_frame_messages_timeout (gpointer data)
+static gboolean
+send_frame_messages_timeout (gpointer data)
 {
  MetaWindowActor *self = (MetaWindowActor *) data;
  MetaWindowActorPrivate *priv = self->priv;
@@ -1020,26 +1056,22 @@ static void
 meta_window_actor_damage_all (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  CoglTexture *texture;
+  cairo_region_t *unobscured_region;
  gboolean redraw_queued;

  if (!priv->needs_damage_all)
    return;

-  texture = meta_shaped_texture_get_texture (META_SHAPED_TEXTURE (priv->actor));
-
  if (!priv->mapped || priv->needs_pixmap)
    return;

-  redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
-                                                   0, 0,
-                                                   cogl_texture_get_width (texture),
-                                                   cogl_texture_get_height (texture),
-                                                   clutter_actor_has_mapped_clones (priv->actor) ?
-                                                   NULL : priv->unobscured_region);
+  unobscured_region =
+    clutter_actor_has_mapped_clones (CLUTTER_ACTOR (priv->surface))
+    ? NULL : priv->unobscured_region;

-  priv->repaint_scheduled = priv->repaint_scheduled  || redraw_queued;
+  redraw_queued = meta_surface_actor_damage_all (priv->surface, unobscured_region);

+  priv->repaint_scheduled = priv->repaint_scheduled || redraw_queued;
  priv->needs_damage_all = FALSE;
 }

@@ -1123,7 +1155,7 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
      else if (priv->mapped && (!meta_is_wayland_compositor () || !priv->needs_pixmap))
        {
          const cairo_rectangle_int_t clip = { 0, 0, 1, 1 };
-          clutter_actor_queue_redraw_with_clip (priv->actor, &clip);
+          clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (priv->surface), &clip);
          priv->repaint_scheduled = TRUE;
        }
    }
@@ -1166,7 +1198,7 @@ meta_window_actor_queue_create_x11_pixmap (MetaWindowActor *self)
   *
   * The compositor paint function repairs all windows.
   */
-  clutter_actor_queue_redraw (priv->actor);
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
 }

 static gboolean
@@ -1256,7 +1288,7 @@ meta_window_actor_after_effects (MetaWindowActor *self)
        meta_window_actor_detach_x11_pixmap (self);

      if (priv->needs_pixmap)
-        clutter_actor_queue_redraw (priv->actor);
+        clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
    }
 }

@@ -1352,8 +1384,7 @@ meta_window_actor_detach_x11_pixmap (MetaWindowActor *self)
   * 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_pixmap (META_SHAPED_TEXTURE (priv->actor),
-                                  None);
+  meta_surface_actor_set_texture (priv->surface, NULL);
  cogl_flush();

  XFreePixmap (xdisplay, priv->back_pixmap);
@@ -1431,9 +1462,6 @@ meta_window_actor_destroy (MetaWindowActor *self)

  priv = self->priv;

-  if (meta_is_wayland_compositor ())
-    meta_shaped_texture_set_wayland_surface (META_SHAPED_TEXTURE (priv->actor), NULL);
-
  window = priv->window;
  window_type = meta_window_get_window_type (window);
  meta_window_set_compositor_private (window, NULL);
@@ -1888,8 +1916,7 @@ meta_window_actor_set_clip_region (MetaWindowActor *self,
 {
  MetaWindowActorPrivate *priv = self->priv;

-  meta_shaped_texture_set_clip_region (META_SHAPED_TEXTURE (priv->actor),
-                                       clip_region);
+  meta_surface_actor_set_clip_region (priv->surface, clip_region);
 }

 /**
@@ -1936,8 +1963,7 @@ meta_window_actor_reset_clip_regions (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;

-  meta_shaped_texture_set_clip_region (META_SHAPED_TEXTURE (priv->actor),
-                                       NULL);
+  meta_surface_actor_set_clip_region (priv->surface, NULL);
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
 }

@@ -1952,7 +1978,6 @@ check_needs_x11_pixmap (MetaWindowActor *self)
  MetaDisplay         *display  = meta_screen_get_display (screen);
  Display             *xdisplay = meta_display_get_xdisplay (display);
  MetaCompScreen      *info     = meta_screen_get_compositor_data (screen);
-  MetaCompositor      *compositor;
  Window               xwindow  = priv->xwindow;

  if (!priv->needs_pixmap)
@@ -1965,8 +1990,6 @@ check_needs_x11_pixmap (MetaWindowActor *self)
      xwindow == clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage)))
    return;

-  compositor = meta_display_get_compositor (display);
-
  if (priv->x11_size_changed)
    {
      meta_window_actor_detach_x11_pixmap (self);
@@ -1977,6 +2000,7 @@ check_needs_x11_pixmap (MetaWindowActor *self)

  if (priv->back_pixmap == None)
    {
+      CoglContext *ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
      CoglTexture *texture;

      meta_error_trap_push (display);
@@ -2001,24 +2025,13 @@ check_needs_x11_pixmap (MetaWindowActor *self)
          goto out;
        }

-      if (compositor->no_mipmaps)
-        meta_shaped_texture_set_create_mipmaps (META_SHAPED_TEXTURE (priv->actor),
-                                                FALSE);
-
-      meta_shaped_texture_set_pixmap (META_SHAPED_TEXTURE (priv->actor),
-                                      priv->back_pixmap);
-
-      texture = meta_shaped_texture_get_texture (META_SHAPED_TEXTURE (priv->actor));
-
-      /*
-       * This only works *after* actually setting the pixmap, so we have to
-       * do it here.
-       * See: http://bugzilla.clutter-project.org/show_bug.cgi?id=2236
-       */
+      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");

-      /* ::size-changed is supposed to refer to meta_window_get_outer_rect().
+      meta_surface_actor_set_texture (META_SURFACE_ACTOR (priv->surface), texture);
+
+      /* ::size-changed is supposed to refer to meta_window_get_frame_rect().
       * Emitting it here works pretty much OK because a new value of the
       * *input* rect (which is the outer rect with the addition of invisible
       * borders) forces a new pixmap and we get here. In the rare case where
@@ -2108,13 +2121,14 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
  MetaWindowActorPrivate *priv = self->priv;
  MetaCompScreen *info = meta_screen_get_compositor_data (priv->screen);
  gboolean redraw_queued;
+  cairo_region_t *unobscured_region;

  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_outer_rect (priv->window, &window_rect);
+      meta_window_get_frame_rect (priv->window, &window_rect);

      if (window_rect.x == event->area.x &&
          window_rect.y == event->area.y &&
@@ -2155,13 +2169,15 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
  if (!priv->mapped || priv->needs_pixmap)
    return;

-  redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
-                                                   event->area.x,
-                                                   event->area.y,
-                                                   event->area.width,
-                                                   event->area.height,
-                                                   clutter_actor_has_mapped_clones (priv->actor) ?
-                                                   NULL : priv->unobscured_region);
+  unobscured_region =
+    clutter_actor_has_mapped_clones (CLUTTER_ACTOR (priv->surface))
+    ? NULL : priv->unobscured_region;
+  redraw_queued = meta_surface_actor_damage_area (priv->surface,
+                                                  event->area.x,
+                                                  event->area.y,
+                                                  event->area.width,
+                                                  event->area.height,
+                                                  unobscured_region);

  priv->repaint_scheduled = priv->repaint_scheduled  || redraw_queued;

@@ -2175,15 +2191,18 @@ meta_window_actor_process_wayland_damage (MetaWindowActor *self,
                                          int height)
 {
  MetaWindowActorPrivate *priv = self->priv;
+  cairo_region_t *unobscured_region;
  gboolean redraw_queued;

  if (!priv->mapped)
    return;

-  redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
-                                                   x, y, width, height,
-                                                   clutter_actor_has_mapped_clones (priv->actor) ?
-                                                   NULL : priv->unobscured_region);
+  unobscured_region =
+    clutter_actor_has_mapped_clones (CLUTTER_ACTOR (priv->surface))
+    ? NULL : priv->unobscured_region;
+  redraw_queued = meta_surface_actor_damage_area (priv->surface,
+                                                  x, y, width, height,
+                                                  unobscured_region);

  priv->repaint_scheduled = priv->repaint_scheduled  || redraw_queued;
 }
@@ -2247,12 +2266,18 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
  MetaWindowActorPrivate *priv = self->priv;
  guchar *mask_data;
  guint tex_width, tex_height;
+  MetaShapedTexture *stex;
  CoglTexture *paint_tex, *mask_texture;
  int stride;
  cairo_t *cr;
  cairo_surface_t *surface;

-  paint_tex = meta_shaped_texture_get_texture (META_SHAPED_TEXTURE (priv->actor));
+  stex = meta_surface_actor_get_texture (priv->surface);
+  g_return_if_fail (stex);
+
+  meta_shaped_texture_set_mask_texture (stex, NULL);
+
+  paint_tex = meta_shaped_texture_get_texture (stex);
  if (paint_tex == NULL)
    return;

@@ -2320,8 +2345,7 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
                                                 mask_data);
    }

-  meta_shaped_texture_set_mask_texture (META_SHAPED_TEXTURE (priv->actor),
-                                        mask_texture);
+  meta_shaped_texture_set_mask_texture (stex, mask_texture);
  cogl_object_unref (mask_texture);

  g_free (mask_data);
@@ -2351,7 +2375,6 @@ meta_window_actor_update_shape_region (MetaWindowActor       *self,
      region = cairo_region_create_rectangle (client_area);
    }

-  meta_shaped_texture_set_mask_texture (META_SHAPED_TEXTURE (priv->actor), NULL);
  if ((priv->window->shape_region != NULL) || (priv->window->frame != NULL))
    build_and_scan_frame_mask (self, client_area, region);

@@ -2368,9 +2391,12 @@ meta_window_actor_update_input_region (MetaWindowActor       *self,
                                       cairo_rectangle_int_t *client_area)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaShapedTexture *stex = META_SHAPED_TEXTURE (priv->actor);
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (priv->surface);
  cairo_region_t *region = NULL;

+  if (!stex)
+    return;
+
  if (priv->window->frame != NULL && priv->window->input_region != NULL)
    {
      region = meta_frame_get_frame_bounds (priv->window->frame);
@@ -2403,6 +2429,11 @@ static void
 meta_window_actor_update_opaque_region (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
+  MetaShapedTexture *stex;
+
+  stex = meta_surface_actor_get_texture (priv->surface);
+  if (!stex)
+    return;

  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);

@@ -2431,8 +2462,7 @@ meta_window_actor_update_opaque_region (MetaWindowActor *self)
  else
    priv->opaque_region = cairo_region_reference (priv->shape_region);

-  meta_shaped_texture_set_opaque_region (META_SHAPED_TEXTURE (priv->actor),
-                                         priv->opaque_region);
+  meta_shaped_texture_set_opaque_region (stex, priv->opaque_region);
 }

 static void
@@ -2475,52 +2505,7 @@ meta_window_actor_update_shape (MetaWindowActor *self)
  if (is_frozen (self))
    return;

-  clutter_actor_queue_redraw (priv->actor);
-}
-
-static void
-maybe_emit_size_changed (MetaWindowActor *self,
-                         MetaWaylandBuffer *new_buffer)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  int                     width = 0, height = 0;
-
-  if (new_buffer)
-    {
-      width = new_buffer->width;
-      height = new_buffer->height;
-    }
-
-  if (priv->last_width != width || priv->last_height != height)
-    {
-      meta_window_actor_update_shape (self);
-
-      /* ::size-changed is supposed to refer to meta_window_get_outer_rect()
-       * but here we are only looking at buffer size changes.
-       *
-       * Emitting it here works pretty much OK because a new buffer size (which
-       * will correspond to the outer rect with the addition of invisible
-       * borders) also normally implies a change to the outer rect. In the rare
-       * case where a change to the window size was exactly balanced by a
-       * change to the invisible borders, we would miss emitting the signal.
-       */
-      g_signal_emit (self, signals[SIZE_CHANGED], 0);
-
-      priv->last_width = width;
-      priv->last_height = height;
-    }
-}
-
-void
-meta_window_actor_set_wayland_surface (MetaWindowActor *self,
-                                       MetaWaylandSurface *surface)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  meta_shaped_texture_set_wayland_surface (META_SHAPED_TEXTURE (priv->actor),
-                                           surface);
-  if (surface && surface->buffer_ref.buffer)
-    maybe_emit_size_changed (self, surface->buffer_ref.buffer);
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
 }

 void
@@ -2528,15 +2513,7 @@ meta_window_actor_attach_wayland_buffer (MetaWindowActor *self,
                                         MetaWaylandBuffer *buffer)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaShapedTexture *stex = META_SHAPED_TEXTURE (priv->actor);
-  CoglTexture *prev_tex = meta_shaped_texture_get_texture (stex);
-
-  meta_shaped_texture_attach_wayland_buffer (stex, buffer);
-
-  if (!prev_tex)
-    meta_window_actor_sync_actor_geometry (self, FALSE);
-
-  maybe_emit_size_changed (self, buffer);
+  meta_surface_actor_attach_wayland_buffer (priv->surface, buffer);
 }

 static void
@@ -2788,7 +2765,7 @@ meta_window_actor_update_opacity (MetaWindowActor *self)
    opacity = 255;

  self->priv->opacity = opacity;
-  clutter_actor_set_opacity (self->priv->actor, opacity);
+  clutter_actor_set_opacity (CLUTTER_ACTOR (self->priv->surface), opacity);
 }

 void
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@@ -163,7 +163,7 @@ meta_window_group_paint (ClutterActor *actor)
          cairo_rectangle_int_t unredirected_rect;
          MetaWindow *window = meta_window_actor_get_meta_window (info->unredirected_window);

-          meta_window_get_outer_rect (window, (MetaRectangle *)&unredirected_rect);
+          meta_window_get_frame_rect (window, (MetaRectangle *)&unredirected_rect);
          cairo_region_subtract_rectangle (unobscured_region, &unredirected_rect);
          cairo_region_subtract_rectangle (clip_region, &unredirected_rect);
        }
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -118,8 +118,6 @@ typedef struct
 {
  MetaRectangle        orig;
  MetaRectangle        current;
-  MetaFrameBorders    *borders;
-  gboolean             must_free_borders;
  ActionType           action_type;
  gboolean             is_user_action;

@@ -195,7 +193,6 @@ static gboolean constrain_partially_onscreen (MetaWindow         *window,

 static void setup_constraint_info        (ConstraintInfo      *info,
                                          MetaWindow          *window,
-                                          MetaFrameBorders    *orig_borders,
                                          MetaMoveResizeFlags  flags,
                                          int                  resize_gravity,
                                          const MetaRectangle *orig,
@@ -204,13 +201,12 @@ static void place_window_if_needed       (MetaWindow     *window,
                                          ConstraintInfo *info);
 static void update_onscreen_requirements (MetaWindow     *window,
                                          ConstraintInfo *info);
-static void extend_by_frame              (MetaRectangle           *rect,
-                                          const MetaFrameBorders  *borders);
-static void unextend_by_frame            (MetaRectangle           *rect,
-                                          const MetaFrameBorders  *borders);
-static inline void get_size_limits       (const MetaWindow        *window,
-                                          const MetaFrameBorders  *borders,
-                                          gboolean include_frame,
+static void extend_by_frame              (MetaWindow     *window,
+                                          MetaRectangle  *rect);
+static void unextend_by_frame            (MetaWindow     *window,
+                                          MetaRectangle  *rect);
+static inline void get_size_limits       (MetaWindow    *window,
+                                          gboolean       include_frame,
                                          MetaRectangle *min_size,
                                          MetaRectangle *max_size);

@@ -280,7 +276,6 @@ do_all_constraints (MetaWindow         *window,

 void
 meta_window_constrain (MetaWindow          *window,
-                       MetaFrameBorders    *orig_borders,
                       MetaMoveResizeFlags  flags,
                       int                  resize_gravity,
                       const MetaRectangle *orig,
@@ -303,7 +298,6 @@ meta_window_constrain (MetaWindow          *window,

  setup_constraint_info (&info,
                         window, 
-                         orig_borders,
                         flags,
                         resize_gravity,
                         orig,
@@ -333,19 +327,11 @@ meta_window_constrain (MetaWindow          *window,
   * if this was a user move or user move-and-resize operation.
   */
  update_onscreen_requirements (window, &info);
-
-  /* Ew, what an ugly way to do things.  Destructors (in a real OOP language,
-   * not gobject-style--gobject would be more pain than it's worth) or
-   * smart pointers would be so much nicer here.  *shrug*
-   */
-  if (info.must_free_borders)
-    g_free (info.borders);
 }

 static void
 setup_constraint_info (ConstraintInfo      *info,
                       MetaWindow          *window,
-                       MetaFrameBorders    *orig_borders,
                       MetaMoveResizeFlags  flags,
                       int                  resize_gravity,
                       const MetaRectangle *orig,
@@ -357,18 +343,6 @@ setup_constraint_info (ConstraintInfo      *info,
  info->orig    = *orig;
  info->current = *new;

-  /* Create a fake frame geometry if none really exists */
-  if (orig_borders && !window->fullscreen)
-    {
-      info->borders = orig_borders;
-      info->must_free_borders = FALSE;
-    }
-  else
-    {
-      info->borders = g_new0 (MetaFrameBorders, 1);
-      info->must_free_borders = TRUE;
-    }
-
  if (flags & META_IS_MOVE_ACTION && flags & META_IS_RESIZE_ACTION)
    info->action_type = ACTION_MOVE_AND_RESIZE;
  else if (flags & META_IS_RESIZE_ACTION)
@@ -519,11 +493,12 @@ place_window_if_needed(MetaWindow     *window,
      !window->minimized &&
      !window->fullscreen)
    {
-      MetaRectangle placed_rect = info->orig;
+      MetaRectangle placed_rect;
      MetaWorkspace *cur_workspace;
      const MetaMonitorInfo *monitor_info;

-      meta_window_place (window, info->borders, info->orig.x, info->orig.y,
+      meta_window_get_frame_rect (window, &placed_rect);
+      meta_window_place (window, info->orig.x, info->orig.y,
                         &placed_rect.x, &placed_rect.y);
      did_placement = TRUE;

@@ -541,6 +516,7 @@ place_window_if_needed(MetaWindow     *window,
        meta_workspace_get_onmonitor_region (cur_workspace, 
                                             monitor_info->number);

+      meta_window_frame_rect_to_client_rect (window, &placed_rect, &placed_rect);

      info->current.x = placed_rect.x;
      info->current.y = placed_rect.y;
@@ -586,10 +562,6 @@ place_window_if_needed(MetaWindow     *window,
                (window->maximize_vertically_after_placement ?
                 META_MAXIMIZE_VERTICAL : 0), &info->current);

-          /* maximization may have changed frame geometry */
-          if (!window->fullscreen)
-            meta_frame_calc_borders (window->frame, info->borders);
-
          if (window->fullscreen_after_placement)
            {
              window->saved_rect = info->current;
@@ -649,7 +621,7 @@ update_onscreen_requirements (MetaWindow     *window,
  /* The require onscreen/on-single-monitor and titlebar_visible
   * stuff is relative to the outer window, not the inner
   */
-  extend_by_frame (&info->current, info->borders);
+  extend_by_frame (window, &info->current);

  /* Update whether we want future constraint runs to require the
   * window to be on fully onscreen.
@@ -682,10 +654,13 @@ update_onscreen_requirements (MetaWindow     *window,
   */
  if (window->frame && window->decorated)
    {
+      MetaFrameBorders borders;
      MetaRectangle titlebar_rect;

+      meta_frame_calc_borders (window->frame, &borders);
+
      titlebar_rect = info->current;
-      titlebar_rect.height = info->borders->visible.top;
+      titlebar_rect.height = borders.visible.top;
      old = window->require_titlebar_visible;
      window->require_titlebar_visible =
        meta_rectangle_overlaps_with_region (info->usable_screen_region,
@@ -698,39 +673,33 @@ update_onscreen_requirements (MetaWindow     *window,
    }

  /* Don't forget to restore the position of the window */
-  unextend_by_frame (&info->current, info->borders);
+  unextend_by_frame (window, &info->current);
 }

 static void
-extend_by_frame (MetaRectangle           *rect,
-                 const MetaFrameBorders *borders)
+extend_by_frame (MetaWindow    *window,
+                 MetaRectangle *rect)
 {
-  rect->x -= borders->visible.left;
-  rect->y -= borders->visible.top;
-  rect->width  += borders->visible.left + borders->visible.right;
-  rect->height += borders->visible.top + borders->visible.bottom;
+  meta_window_client_rect_to_frame_rect (window, rect, rect);
 }

 static void
-unextend_by_frame (MetaRectangle           *rect,
-                   const MetaFrameBorders *borders)
+unextend_by_frame (MetaWindow    *window,
+                   MetaRectangle *rect)
 {
-  rect->x += borders->visible.left;
-  rect->y += borders->visible.top;
-  rect->width  -= borders->visible.left + borders->visible.right;
-  rect->height -= borders->visible.top + borders->visible.bottom;
+  meta_window_frame_rect_to_client_rect (window, rect, rect);
 }

 static inline void
-get_size_limits (const MetaWindow        *window,
-                 const MetaFrameBorders *borders,
-                 gboolean                 include_frame,
+get_size_limits (MetaWindow    *window,
+                 gboolean       include_frame,
                 MetaRectangle *min_size,
                 MetaRectangle *max_size)
 {
  /* We pack the results into MetaRectangle structs just for convienience; we
   * don't actually use the position of those rects.
   */
+  min_size->x = min_size->y = max_size->x = max_size->y = 0;
  min_size->width  = window->size_hints.min_width;
  min_size->height = window->size_hints.min_height;
  max_size->width  = window->size_hints.max_width;
@@ -738,22 +707,8 @@ get_size_limits (const MetaWindow        *window,

  if (include_frame)
    {
-      int fw = borders->visible.left + borders->visible.right;
-      int fh = borders->visible.top + borders->visible.bottom;
-
-      min_size->width  += fw;
-      min_size->height += fh;
-      /* Do check to avoid overflow (e.g. max_size->width & max_size->height
-       * may be set to G_MAXINT by meta_set_normal_hints()).
-       */
-      if (max_size->width < (G_MAXINT - fw))
-        max_size->width += fw;
-      else
-        max_size->width = G_MAXINT;
-      if (max_size->height < (G_MAXINT - fh))
-        max_size->height += fh;
-      else
-        max_size->height = G_MAXINT;
+      meta_window_client_rect_to_frame_rect (window, min_size, min_size);
+      meta_window_client_rect_to_frame_rect (window, max_size, max_size);
    }
 }

@@ -765,18 +720,28 @@ constrain_modal_dialog (MetaWindow         *window,
 {
  int x, y;
  MetaWindow *parent = meta_window_get_transient_for (window);
+  MetaRectangle child_rect, parent_rect;
  gboolean constraint_already_satisfied;

  if (!meta_window_is_attached_dialog (window))
    return TRUE;

-  x = parent->rect.x + (parent->rect.width / 2  - info->current.width / 2);
-  y = parent->rect.y + (parent->rect.height / 2 - info->current.height / 2);
-  if (parent->frame)
-    {
-      x += parent->frame->rect.x;
-      y += parent->frame->rect.y;
-    }
+  /* We want to center the dialog on the parent, including the decorations
+     for both of them. info->current is in client X window coordinates, so we need
+     to convert them to frame coordinates, apply the centering and then
+     convert back to client.
+  */
+
+  child_rect = info->current;
+  extend_by_frame (window, &child_rect);
+
+  meta_window_get_frame_rect (parent, &parent_rect);
+
+  child_rect.x = parent_rect.x + (parent_rect.width / 2  - child_rect.width / 2);
+  child_rect.y = parent_rect.y + (parent_rect.height / 2 - child_rect.height / 2);
+  unextend_by_frame (window, &child_rect);
+  x = child_rect.x;
+  y = child_rect.y;

  constraint_already_satisfied = (x == info->current.x) && (y == info->current.y);

@@ -841,19 +806,19 @@ constrain_maximization (MetaWindow         *window,
      active_workspace_struts = window->screen->active_workspace->all_struts;

      target_size = info->current;
-      extend_by_frame (&target_size, info->borders);
+      extend_by_frame (window, &target_size);
      meta_rectangle_expand_to_avoiding_struts (&target_size,
                                                &info->entire_monitor,
                                                direction,
                                                active_workspace_struts);
   }
  /* Now make target_size = maximized size of client window */
-  unextend_by_frame (&target_size, info->borders);
+  unextend_by_frame (window, &target_size);

  /* Check min size constraints; max size constraints are ignored for maximized
   * windows, as per bug 327543.
   */
-  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
+  get_size_limits (window, FALSE, &min_size, &max_size);
  hminbad = target_size.width < min_size.width && window->maximized_horizontally;
  vminbad = target_size.height < min_size.height && window->maximized_vertically;
  if (hminbad || vminbad)
@@ -907,12 +872,12 @@ constrain_tiling (MetaWindow         *window,
   * use an external function for the actual calculation
   */
  meta_window_get_current_tile_area (window, &target_size);
-  unextend_by_frame (&target_size, info->borders);
+  unextend_by_frame (window, &target_size);

  /* Check min size constraints; max size constraints are ignored as for
   * maximized windows.
   */
-  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
+  get_size_limits (window, FALSE, &min_size, &max_size);
  hminbad = target_size.width < min_size.width;
  vminbad = target_size.height < min_size.height;
  if (hminbad || vminbad)
@@ -955,7 +920,7 @@ constrain_fullscreen (MetaWindow         *window,

  monitor = info->entire_monitor;

-  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
+  get_size_limits (window, FALSE, &min_size, &max_size);
  too_big =   !meta_rectangle_could_fit_rect (&monitor, &min_size);
  too_small = !meta_rectangle_could_fit_rect (&max_size, &monitor);
  if (too_big || too_small)
@@ -1064,7 +1029,7 @@ constrain_size_limits (MetaWindow         *window,
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is */
-  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
+  get_size_limits (window, FALSE, &min_size, &max_size);
  /* We ignore max-size limits for maximized windows; see #327543 */
  if (window->maximized_horizontally)
    max_size.width = MAX (max_size.width, info->current.width);
@@ -1256,8 +1221,8 @@ do_screen_and_monitor_relative_constraints (

  /* Determine whether constraint applies; exit if it doesn't */
  how_far_it_can_be_smushed = info->current;
-  get_size_limits (window, info->borders, TRUE, &min_size, &max_size);
-  extend_by_frame (&info->current, info->borders);
+  get_size_limits (window, TRUE, &min_size, &max_size);
+  extend_by_frame (window, &info->current);

  if (info->action_type != ACTION_MOVE)
    {
@@ -1277,7 +1242,7 @@ do_screen_and_monitor_relative_constraints (
                                        &info->current);
  if (exit_early || constraint_satisfied || check_only)
    {
-      unextend_by_frame (&info->current, info->borders);
+      unextend_by_frame (window, &info->current);
      return constraint_satisfied;
    }

@@ -1301,7 +1266,7 @@ do_screen_and_monitor_relative_constraints (
                                      info->fixed_directions,
                                      &info->current);

-  unextend_by_frame (&info->current, info->borders);
+  unextend_by_frame (window, &info->current);
  return TRUE;
 }

@@ -1414,8 +1379,11 @@ constrain_titlebar_visible (MetaWindow         *window,
   */
  if (window->frame)
    {
-      bottom_amount = info->current.height + info->borders->visible.bottom;
-      vert_amount_onscreen = info->borders->visible.top;
+      MetaFrameBorders borders;
+      meta_frame_calc_borders (window->frame, &borders);
+
+      bottom_amount = info->current.height + borders.visible.bottom;
+      vert_amount_onscreen = borders.visible.top;
    }
  else
    bottom_amount = vert_amount_offscreen;
@@ -1489,8 +1457,11 @@ constrain_partially_onscreen (MetaWindow         *window,
   */
  if (window->frame)
    {
-      bottom_amount = info->current.height + info->borders->visible.bottom;
-      vert_amount_onscreen = info->borders->visible.top;
+      MetaFrameBorders borders;
+      meta_frame_calc_borders (window->frame, &borders);
+
+      bottom_amount = info->current.height + borders.visible.bottom;
+      vert_amount_onscreen = borders.visible.top;
    }
  else
    bottom_amount = vert_amount_offscreen;
--- a/src/core/constraints.h
+++ b/src/core/constraints.h
@@ -40,7 +40,6 @@ typedef enum
 } MetaMoveResizeFlags;

 void meta_window_constrain (MetaWindow          *window,
-                            MetaFrameBorders    *orig_borders,
                            MetaMoveResizeFlags  flags,
                            int                  resize_gravity,
                            const MetaRectangle *orig,
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -172,6 +172,7 @@ meta_core_queue_frame_resize (Display *xdisplay,
  MetaWindow *window = get_window (xdisplay, frame_xwindow);

  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+  meta_window_frame_size_changed (window);
 }

 void
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -102,6 +102,8 @@ struct _MetaDisplay
  char *name;
  Display *xdisplay;

+  int clutter_event_filter;
+
  Window leader_window;
  Window timestamp_pinging_window;

@@ -482,12 +484,6 @@ gboolean meta_display_modifiers_accelerator_activate (MetaDisplay *display);
 /* In above-tab-keycode.c */
 guint meta_display_get_above_tab_keycode (MetaDisplay *display);

-gboolean meta_display_handle_xevent (MetaDisplay *display,
-                                     XEvent      *event);
-
-gboolean meta_display_handle_event (MetaDisplay        *display,
-                                    const ClutterEvent *event);
-
 #ifdef HAVE_XI23
 gboolean meta_display_process_barrier_event (MetaDisplay *display,
                                             XIEvent     *event);
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -53,6 +53,7 @@
 #include <X11/Xatom.h>
 #include "mutter-enum-types.h"
 #include "meta-idle-monitor-private.h"
+#include "meta-cursor-tracker-private.h"

 #ifdef HAVE_RANDR
 #include <X11/extensions/Xrandr.h>
@@ -592,8 +593,11 @@ meta_display_open (void)
  meta_ui_add_event_func (the_display->xdisplay,
                          xevent_callback,
                          the_display);
-  clutter_event_add_filter (event_callback, the_display);
-  
+  the_display->clutter_event_filter = clutter_event_add_filter (NULL,
+                                                                event_callback,
+                                                                NULL,
+                                                                the_display);
+
  the_display->xids = g_hash_table_new (meta_unsigned_long_hash,
                                        meta_unsigned_long_equal);
  the_display->wayland_windows = g_hash_table_new (NULL, NULL);
@@ -1124,7 +1128,8 @@ meta_display_close (MetaDisplay *display,
  meta_ui_remove_event_func (display->xdisplay,
                             xevent_callback,
                             display);
-  clutter_event_remove_filter (event_callback, display);
+  clutter_event_remove_filter (display->clutter_event_filter);
+  display->clutter_event_filter = 0;
  
  /* Free all screens */
  tmp = display->screens;
@@ -1602,6 +1607,7 @@ window_raise_with_delay_callback (void *data)
    {
      int x, y, root_x, root_y;
      Window root, child;
+      MetaRectangle frame_rect;
      unsigned int mask;
      gboolean same_screen;
      gboolean point_in_window;
@@ -1613,9 +1619,8 @@ window_raise_with_delay_callback (void *data)
 				   &root_x, &root_y, &x, &y, &mask);
      meta_error_trap_pop (window->display);

-      point_in_window = 
-        (window->frame && POINT_IN_RECT (root_x, root_y, window->frame->rect)) ||
-        (window->frame == NULL && POINT_IN_RECT (root_x, root_y, window->rect));
+      meta_window_get_frame_rect (window, &frame_rect);
+      point_in_window = POINT_IN_RECT (root_x, root_y, frame_rect);
      if (same_screen && point_in_window)
 	meta_window_raise (window);
      else
@@ -1686,27 +1691,17 @@ handle_net_restack_window (MetaDisplay* display,
 #endif

 static MetaWindow *
-get_window_for_actor (ClutterActor *actor,
-                      gboolean     *frame_was_receiver)
+get_window_for_event (MetaDisplay        *display,
+                      const ClutterEvent *event)
 {
-  /* Look for any ancestor that is a MetaWindowActor to determine
-     which window the actor's event belongs to */
+  ClutterActor *source;

-  *frame_was_receiver = TRUE;
+  if (display->grab_window)
+    return display->grab_window;

-  while (actor)
-    {
-      if (META_IS_WINDOW_ACTOR (actor))
-        return meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor));
-
-      /* If the frame is the receiver then the source will directly be
-         the MetaWindowActor, otherwise it will be a child of a
-         MetaWindowActor so if we make it here then the event isn't
-         referring to the frame. */
-      *frame_was_receiver = FALSE;
-
-      actor = clutter_actor_get_parent (actor);
-    }
+  source = clutter_event_get_source (event);
+  if (META_IS_WINDOW_ACTOR (source))
+    return meta_window_actor_get_meta_window (META_WINDOW_ACTOR (source));

  return NULL;
 }
@@ -2038,14 +2033,25 @@ handle_window_focus_event (MetaDisplay  *display,
    }
 }

-gboolean
+static gboolean
 meta_display_handle_event (MetaDisplay        *display,
                           const ClutterEvent *event)
 {
  MetaWindow *window;
-  gboolean frame_was_receiver;

-  window = get_window_for_actor (event->any.source, &frame_was_receiver);
+  /* XXX -- we need to fill this in properly at some point... */
+  gboolean frame_was_receiver = FALSE;
+#ifdef HAVE_WAYLAND
+  MetaWaylandCompositor *compositor = NULL;
+
+  if (meta_is_wayland_compositor ())
+    {
+      compositor = meta_wayland_compositor_get_default ();
+      meta_wayland_compositor_update (compositor, event);
+    }
+#endif  /* HAVE_WAYLAND */
+
+  window = get_window_for_event (display, event);

  display->current_time = event->any.time;

@@ -2167,15 +2173,15 @@ meta_display_handle_event (MetaDisplay        *display,
                {
                  gboolean north, south;
                  gboolean west, east;
-                  int root_x, root_y;
+                  MetaRectangle frame_rect;
                  MetaGrabOp op;

-                  meta_window_get_position (window, &root_x, &root_y);
+                  meta_window_get_frame_rect (window, &frame_rect);

-                  west = event->button.x < (root_x + 1 * window->rect.width / 3);
-                  east = event->button.x > (root_x + 2 * window->rect.width / 3);
-                  north = event->button.y < (root_y + 1 * window->rect.height / 3);
-                  south = event->button.y > (root_y + 2 * window->rect.height / 3);
+                  west = event->button.x < (frame_rect.x + 1 * frame_rect.width / 3);
+                  east = event->button.x > (frame_rect.x + 2 * frame_rect.width / 3);
+                  north = event->button.y < (frame_rect.y + 1 * frame_rect.height / 3);
+                  south = event->button.y > (frame_rect.y + 2 * frame_rect.height / 3);

                  if (north && west)
                    op = META_GRAB_OP_RESIZING_NW;
@@ -2286,17 +2292,15 @@ meta_display_handle_event (MetaDisplay        *display,
    }

 #ifdef HAVE_WAYLAND
-  if (meta_is_wayland_compositor() && display->grab_op != META_GRAB_OP_NONE)
+  if (compositor && (display->grab_op == META_GRAB_OP_NONE))
    {
-      MetaWaylandCompositor *compositor;
-      compositor = meta_wayland_compositor_get_default ();
-
      if (meta_wayland_compositor_handle_event (compositor, event))
        return TRUE;
    }
 #endif /* HAVE_WAYLAND */

-  return (display->grab_op != META_GRAB_OP_COMPOSITOR);
+  return (display->grab_op != META_GRAB_OP_NONE &&
+          display->grab_op != META_GRAB_OP_COMPOSITOR);
 }

 static gboolean
@@ -2976,7 +2980,7 @@ handle_other_xevent (MetaDisplay *display,
 * busy around here. Most of this function is a ginormous switch statement
 * dealing with all the kinds of events that might turn up.
 */
-gboolean
+static gboolean
 meta_display_handle_xevent (MetaDisplay *display,
                            XEvent      *event)
 {
@@ -3876,59 +3880,53 @@ meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
  return is_a_no_focus_window;
 }

-static Cursor
-xcursor_for_op (MetaDisplay *display,
-                MetaGrabOp   op)
+static MetaCursor
+meta_cursor_for_grab_op (MetaGrabOp op)
 {
-  MetaCursor cursor = META_CURSOR_DEFAULT;
-  
  switch (op)
    {
    case META_GRAB_OP_RESIZING_SE:
    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
-      cursor = META_CURSOR_SE_RESIZE;
+      return META_CURSOR_SE_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_S:
    case META_GRAB_OP_KEYBOARD_RESIZING_S:
-      cursor = META_CURSOR_SOUTH_RESIZE;
+      return META_CURSOR_SOUTH_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_SW:
    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
-      cursor = META_CURSOR_SW_RESIZE;
+      return META_CURSOR_SW_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_N:
    case META_GRAB_OP_KEYBOARD_RESIZING_N:
-      cursor = META_CURSOR_NORTH_RESIZE;
+      return META_CURSOR_NORTH_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_NE:
    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
-      cursor = META_CURSOR_NE_RESIZE;
+      return META_CURSOR_NE_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_NW:
    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
-      cursor = META_CURSOR_NW_RESIZE;
+      return META_CURSOR_NW_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_W:
    case META_GRAB_OP_KEYBOARD_RESIZING_W:
-      cursor = META_CURSOR_WEST_RESIZE;
+      return META_CURSOR_WEST_RESIZE;
      break;
    case META_GRAB_OP_RESIZING_E:
    case META_GRAB_OP_KEYBOARD_RESIZING_E:
-      cursor = META_CURSOR_EAST_RESIZE;
+      return META_CURSOR_EAST_RESIZE;
      break;
    case META_GRAB_OP_MOVING:
    case META_GRAB_OP_KEYBOARD_MOVING:
    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
-      cursor = META_CURSOR_MOVE_OR_RESIZE_WINDOW;
+      return META_CURSOR_MOVE_OR_RESIZE_WINDOW;
      break;
-      
    default:
      break;
    }

-  if (cursor == META_CURSOR_DEFAULT)
-    return None;
-  return meta_display_create_x_cursor (display, cursor);
+  return META_CURSOR_DEFAULT;
 }

 void
@@ -3938,7 +3936,6 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
                                 Window       grab_xwindow,
                                 guint32      timestamp)
 {
-  Cursor cursor = xcursor_for_op (display, op);
  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };

@@ -3955,7 +3952,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
                    META_VIRTUAL_CORE_POINTER_ID,
                    grab_xwindow,
                    timestamp,
-                    cursor,
+                    None,
                    XIGrabModeAsync, XIGrabModeAsync,
                    False, /* owner_events */
                    &mask) == Success)
@@ -3971,10 +3968,10 @@ meta_display_set_grab_op_cursor (MetaDisplay *display,
                  "XIGrabDevice() failed time %u\n",
                  timestamp);
    }
+
  meta_error_trap_pop (display);
-  
-  if (cursor != None)
-    XFreeCursor (display->xdisplay, cursor);
+
+  meta_cursor_tracker_set_grab_cursor (screen->cursor_tracker, meta_cursor_for_grab_op (op));
 }

 gboolean
@@ -4236,7 +4233,8 @@ meta_display_end_grab_op (MetaDisplay *display,
        meta_screen_ungrab_all_keys (display->grab_screen, timestamp);
    }

-  
+  meta_cursor_tracker_set_grab_cursor (display->grab_screen->cursor_tracker, META_CURSOR_DEFAULT);
+
  display->grab_timestamp = 0;
  display->grab_window = NULL;
  display->grab_screen = NULL;
@@ -4565,6 +4563,7 @@ meta_display_queue_retheme_all_windows (MetaDisplay *display)
      MetaWindow *window = tmp->data;
      
      meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+      meta_window_frame_size_changed (window);
      if (window->frame)
        {
          meta_frame_queue_draw (window->frame);
@@ -5746,25 +5745,6 @@ meta_display_request_take_focus (MetaDisplay *display,
  meta_topic (META_DEBUG_FOCUS, "WM_TAKE_FOCUS(%s, %u)\n",
              window->desc, timestamp);

-  if (window != display->focus_window)
-    {
-      /* The "Globally Active Input" window case, where the window
-       * doesn't want us to call XSetInputFocus on it, but does
-       * want us to send a WM_TAKE_FOCUS.
-       *
-       * We can't just set display->focus_window to @window, since we
-       * we don't know when (or even if) the window will actually take
-       * focus, so we could end up being wrong for arbitrarily long.
-       * But we also can't leave it set to the current window, or else
-       * bug #597352 would come back. So we focus the no_focus_window
-       * now (and set display->focus_window to that), send the
-       * WM_TAKE_FOCUS, and then just forget about @window
-       * until/unless we get a FocusIn.
-       */
-      meta_display_focus_the_no_focus_window (display,
-                                              window->screen,
-                                              timestamp);
-    }
  meta_window_send_icccm_message (window,
                                  display->atom_WM_TAKE_FOCUS,
                                  timestamp);
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@@ -985,7 +985,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
        {
          MetaRectangle *new_rect;
          new_rect = g_new (MetaRectangle, 1);
-          meta_window_get_outer_rect (cur_window, new_rect);
+          meta_window_get_frame_rect (cur_window, new_rect);
          obscuring_windows = g_slist_prepend (obscuring_windows, new_rect);
          window_stacking = 
            g_slist_prepend (window_stacking, GINT_TO_POINTER (stack_position));
@@ -1010,7 +1010,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
    {
      MetaRectangle  cur_rect;
      MetaWindow    *cur_window = cur_window_iter->data;
-      meta_window_get_outer_rect (cur_window, &cur_rect);
+      meta_window_get_frame_rect (cur_window, &cur_rect);

      /* Check if we want to use this window's edges for edge
       * resistance (note that dock edges are considered screen edges
@@ -1151,7 +1151,7 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
  MetaRectangle old_outer, proposed_outer, new_outer;
  gboolean is_resize;

-  meta_window_get_outer_rect (window, &old_outer);
+  meta_window_get_frame_rect (window, &old_outer);

  proposed_outer = old_outer;
  proposed_outer.x += (*new_x - old_x);
@@ -1237,7 +1237,7 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
  int proposed_outer_width, proposed_outer_height;
  gboolean is_resize;

-  meta_window_get_outer_rect (window, &old_outer);
+  meta_window_get_frame_rect (window, &old_outer);
  proposed_outer_width  = old_outer.width  + (*new_width  - old_width);
  proposed_outer_height = old_outer.height + (*new_height - old_height);
  meta_rectangle_resize_with_gravity (&old_outer, 
--- a/src/core/frame.c
+++ b/src/core/frame.c
@@ -69,6 +69,7 @@ meta_window_ensure_frame (MetaWindow *window)

  frame->mapped = FALSE;
  frame->is_flashing = FALSE;
+  frame->borders_cached = FALSE;
  
  meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
                window->desc,
@@ -334,9 +335,23 @@ meta_frame_calc_borders (MetaFrame        *frame,
  if (frame == NULL)
    meta_frame_borders_clear (borders);
  else
-    meta_ui_get_frame_borders (frame->window->screen->ui,
-                               frame->xwindow,
-                               borders);
+    {
+      if (!frame->borders_cached)
+        {
+          meta_ui_get_frame_borders (frame->window->screen->ui,
+                                     frame->xwindow,
+                                     &frame->cached_borders);
+          frame->borders_cached = TRUE;
+        }
+
+      *borders = frame->cached_borders;
+    }
+}
+
+void
+meta_frame_clear_cached_borders (MetaFrame *frame)
+{
+  frame->borders_cached = FALSE;
 }

 gboolean
--- a/src/core/frame.h
+++ b/src/core/frame.h
@@ -41,6 +41,8 @@ struct _MetaFrame
   */
  MetaRectangle rect;

+  MetaFrameBorders cached_borders; /* valid if borders_cached is set */
+
  /* position of client, size of frame */
  int child_x;
  int child_y;
@@ -50,6 +52,7 @@ struct _MetaFrame
  guint mapped : 1;
  guint need_reapply_frame_shape : 1;
  guint is_flashing : 1; /* used by the visual bell flash */
+  guint borders_cached : 1;
 };

 void     meta_window_ensure_frame           (MetaWindow *window);
@@ -68,6 +71,8 @@ gboolean meta_frame_sync_to_window (MetaFrame         *frame,
                                    gboolean           need_move,
                                    gboolean           need_resize);

+void meta_frame_clear_cached_borders (MetaFrame *frame);
+
 cairo_region_t *meta_frame_get_frame_bounds (MetaFrame *frame);

 void meta_frame_get_mask (MetaFrame *frame,
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -1566,6 +1566,10 @@ meta_window_grab_all_keys (MetaWindow  *window,
  Window grabwindow;
  gboolean retval;

+  /* We don't need to grab Wayland clients */
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
+    return TRUE;
+
  if (window->all_keys_grabbed)
    return FALSE;

@@ -3090,6 +3094,20 @@ handle_maximize_horizontally (MetaDisplay     *display,
    }
 }

+static void
+handle_always_on_top (MetaDisplay     *display,
+                      MetaScreen      *screen,
+                      MetaWindow      *window,
+                      ClutterKeyEvent *event,
+                      MetaKeyBinding  *binding,
+                      gpointer         dummy)
+{
+  if (window->wm_state_above == FALSE)
+    meta_window_make_above (window);
+  else
+    meta_window_unmake_above (window);
+}
+
 /* Move a window to a corner; to_bottom/to_right are FALSE for the
 * top or left edge, or TRUE for the bottom/right edge.  xchange/ychange
 * are FALSE if that dimension is not to be changed, TRUE otherwise.
@@ -3107,17 +3125,17 @@ handle_move_to_corner_backend (MetaDisplay    *display,
                               gpointer        dummy)
 {
  MetaRectangle work_area;
-  MetaRectangle outer;
+  MetaRectangle frame_rect;
  int orig_x, orig_y;
  int new_x, new_y;

  meta_window_get_work_area_all_monitors (window, &work_area);
-  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_frame_rect (window, &frame_rect);
  meta_window_get_position (window, &orig_x, &orig_y);

  if (xchange) {
    new_x = work_area.x + (to_right ?
-                           work_area.width - outer.width :
+                           work_area.width - frame_rect.width :
                           0);
  } else {
    new_x = orig_x;
@@ -3125,7 +3143,7 @@ handle_move_to_corner_backend (MetaDisplay    *display,

  if (ychange) {
    new_y = work_area.y + (to_bottom ?
-                           work_area.height - outer.height :
+                           work_area.height - frame_rect.height :
                           0);
  } else {
    new_y = orig_y;
@@ -3234,12 +3252,12 @@ handle_move_to_center  (MetaDisplay     *display,
                        gpointer         dummy)
 {
  MetaRectangle work_area;
-  MetaRectangle outer;
+  MetaRectangle frame_rect;
  int orig_x, orig_y;
  int frame_width, frame_height;

  meta_window_get_work_area_all_monitors (window, &work_area);
-  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_frame_rect (window, &frame_rect);
  meta_window_get_position (window, &orig_x, &orig_y);

  frame_width = (window->frame ? window->frame->child_x : 0);
@@ -3247,8 +3265,8 @@ handle_move_to_center  (MetaDisplay     *display,

  meta_window_move_resize (window,
                           TRUE,
-                           work_area.x + (work_area.width +frame_width -outer.width )/2,
-                           work_area.y + (work_area.height+frame_height-outer.height)/2,
+                           work_area.x + (work_area.width +frame_width -frame_rect.width )/2,
+                           work_area.y + (work_area.height+frame_height-frame_rect.height)/2,
                           window->rect.width,
                           window->rect.height);
 }
@@ -3940,8 +3958,8 @@ handle_raise_or_lower (MetaDisplay     *display,

      if (above->mapped)
        {
-          meta_window_get_outer_rect (window, &win_rect);
-          meta_window_get_outer_rect (above, &above_rect);
+          meta_window_get_frame_rect (window, &win_rect);
+          meta_window_get_frame_rect (above, &above_rect);

          /* Check if obscured */
          if (meta_rectangle_intersect (&win_rect, &above_rect, &tmp))
@@ -4687,6 +4705,13 @@ init_builtin_key_bindings (MetaDisplay *display)
                          META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY,
                          handle_maximize_horizontally, 0);

+  add_builtin_keybinding (display,
+                          "always-on-top",
+                          common_keybindings,
+                          META_KEY_BINDING_PER_WINDOW,
+                          META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
+                          handle_always_on_top, 0);
+
  add_builtin_keybinding (display,
                          "move-to-corner-nw",
                          common_keybindings,
--- a/src/core/meta-cursor-tracker-private.h
+++ b/src/core/meta-cursor-tracker-private.h
@@ -31,18 +31,18 @@
 gboolean meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
 					    XEvent            *xevent);

-void     meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
-                                              MetaCursor         cursor);
-void     meta_cursor_tracker_revert_root     (MetaCursorTracker *tracker);
-void     meta_cursor_tracker_set_buffer      (MetaCursorTracker  *tracker,
-                                              struct wl_resource *buffer,
-                                              int                 hot_x,
-                                              int                 hot_y);
+void     meta_cursor_tracker_set_grab_cursor     (MetaCursorTracker  *tracker,
+                                                  MetaCursor          cursor);
+void     meta_cursor_tracker_set_window_cursor   (MetaCursorTracker  *tracker,
+                                                  struct wl_resource *buffer,
+                                                  int                 hot_x,
+                                                  int                 hot_y);
+void     meta_cursor_tracker_unset_window_cursor (MetaCursorTracker  *tracker);
+void     meta_cursor_tracker_set_root_cursor     (MetaCursorTracker  *tracker,
+                                                  MetaCursor          cursor);

 void     meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
 					      int                new_x,
 					      int                new_y);
 void     meta_cursor_tracker_paint           (MetaCursorTracker *tracker);
-void     meta_cursor_tracker_queue_redraw    (MetaCursorTracker *tracker,
-					      ClutterActor      *stage);
 #endif
--- a/src/core/meta-cursor-tracker.c
+++ b/src/core/meta-cursor-tracker.c
@@ -68,11 +68,34 @@ struct _MetaCursorTracker {
  MetaScreen *screen;

  gboolean is_showing;
-  gboolean has_cursor;
  gboolean has_hw_cursor;

-  MetaCursorReference *sprite;
+  /* The cursor tracker stores the cursor for the current grab
+   * operation, the cursor for the window with pointer focus, and
+   * the cursor for the root window, which contains either the
+   * default arrow cursor or the 'busy' hourglass if we're launching
+   * an app.
+   *
+   * We choose the first one available -- if there's a grab cursor,
+   * we choose that cursor, if there's window cursor, we choose that,
+   * otherwise we choose the root cursor.
+   *
+   * The displayed_cursor contains the chosen cursor.
+   */
+  MetaCursorReference *displayed_cursor;
+
+  MetaCursorReference *grab_cursor;
+
+  /* Wayland clients can set a NULL buffer as their cursor 
+   * explicitly, which means that we shouldn't display anything.
+   * So, we can't simply store a NULL in window_cursor to
+   * determine an unset window cursor; we need an extra boolean.
+   */
+  gboolean has_window_cursor;
+  MetaCursorReference *window_cursor;
+
  MetaCursorReference *root_cursor;
+
  MetaCursorReference *default_cursors[META_CURSOR_LAST];

  int current_x, current_y;
@@ -98,9 +121,6 @@ enum {

 static guint signals[LAST_SIGNAL];

-static void meta_cursor_tracker_set_sprite (MetaCursorTracker   *tracker,
-                                            MetaCursorReference *sprite);
-
 static void meta_cursor_tracker_set_crtc_has_hw_cursor (MetaCursorTracker *tracker,
                                                        MetaCRTC          *crtc,
                                                        gboolean           has_hw_cursor);
@@ -354,7 +374,7 @@ meta_cursor_reference_from_buffer (MetaCursorTracker  *tracker,
  self->ref_count = 1;
  self->hot_x = hot_x;
  self->hot_y = hot_y;
- 
+
  backend = clutter_get_default_backend ();
  cogl_context = clutter_backend_get_cogl_context (backend);

@@ -520,8 +540,8 @@ meta_cursor_tracker_finalize (GObject *object)
  MetaCursorTracker *self = META_CURSOR_TRACKER (object);
  int i;

-  if (self->sprite)
-    meta_cursor_reference_unref (self->sprite);
+  if (self->displayed_cursor)
+    meta_cursor_reference_unref (self->displayed_cursor);
  if (self->root_cursor)
    meta_cursor_reference_unref (self->root_cursor);

@@ -646,6 +666,17 @@ meta_cursor_tracker_get_for_screen (MetaScreen *screen)
  return self;
 }

+static void
+set_window_cursor (MetaCursorTracker   *tracker,
+                   gboolean             has_cursor,
+                   MetaCursorReference *cursor)
+{
+  g_clear_pointer (&tracker->window_cursor, meta_cursor_reference_unref);
+  if (cursor)
+    tracker->window_cursor = meta_cursor_reference_ref (cursor);
+  tracker->has_window_cursor = has_cursor;
+}
+
 gboolean
 meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
                                   XEvent            *xevent)
@@ -662,7 +693,7 @@ meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
  if (notify_event->subtype != XFixesDisplayCursorNotify)
    return FALSE;

-  g_clear_pointer (&tracker->sprite, meta_cursor_reference_unref);
+  set_window_cursor (tracker, FALSE, NULL);
  g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);

  return TRUE;
@@ -677,7 +708,7 @@ ensure_xfixes_cursor (MetaCursorTracker *tracker)
  gboolean free_cursor_data;
  CoglContext *ctx;

-  if (tracker->sprite)
+  if (tracker->has_window_cursor)
    return;

  cursor_image = XFixesGetCursorImage (tracker->screen->display->xdisplay);
@@ -725,9 +756,11 @@ ensure_xfixes_cursor (MetaCursorTracker *tracker)

  if (sprite != NULL)
    {
-      tracker->sprite = meta_cursor_reference_take_texture (sprite);
-      tracker->sprite->hot_x = cursor_image->xhot;
-      tracker->sprite->hot_y = cursor_image->yhot;
+      MetaCursorReference *cursor = meta_cursor_reference_take_texture (sprite);
+      cursor->hot_x = cursor_image->xhot;
+      cursor->hot_y = cursor_image->yhot;
+
+      set_window_cursor (tracker, TRUE, cursor);
    }
  XFree (cursor_image);
 }
@@ -745,8 +778,8 @@ meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker)
  if (!meta_is_wayland_compositor ())
    ensure_xfixes_cursor (tracker);

-  if (tracker->sprite)
-    return COGL_TEXTURE (tracker->sprite->texture);
+  if (tracker->displayed_cursor)
+    return COGL_TEXTURE (tracker->displayed_cursor->texture);
  else
    return NULL;
 }
@@ -768,12 +801,13 @@ meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
  if (!meta_is_wayland_compositor ())
    ensure_xfixes_cursor (tracker);

-  if (tracker->sprite)
+  if (tracker->displayed_cursor)
    {
+      MetaCursorReference *displayed_cursor = tracker->displayed_cursor;
      if (x)
-        *x = tracker->sprite->hot_x;
+        *x = displayed_cursor->hot_x;
      if (y)
-        *y = tracker->sprite->hot_y;
+        *y = displayed_cursor->hot_y;
    }
  else
    {
@@ -788,14 +822,45 @@ static MetaCursorReference *
 ensure_wayland_cursor (MetaCursorTracker *tracker,
                       MetaCursor         cursor)
 {
-  if (tracker->default_cursors[cursor])
-    return tracker->default_cursors[cursor];
-
-  tracker->default_cursors[cursor] = meta_cursor_reference_from_theme (tracker, cursor);
  if (!tracker->default_cursors[cursor])
-    meta_warning ("Failed to load cursor from theme\n");
+    {
+      tracker->default_cursors[cursor] = meta_cursor_reference_from_theme (tracker, cursor);
+      if (!tracker->default_cursors[cursor])
+        meta_warning ("Failed to load cursor from theme\n");
+    }

-  return tracker->default_cursors[cursor];
+  return meta_cursor_reference_ref (tracker->default_cursors[cursor]);
+}
+
+void
+meta_cursor_tracker_set_grab_cursor (MetaCursorTracker *tracker,
+                                     MetaCursor         cursor)
+{
+  g_clear_pointer (&tracker->grab_cursor, meta_cursor_reference_unref);
+  if (cursor != META_CURSOR_DEFAULT)
+    tracker->grab_cursor = ensure_wayland_cursor (tracker, cursor);
+}
+
+void
+meta_cursor_tracker_set_window_cursor (MetaCursorTracker  *tracker,
+                                       struct wl_resource *buffer,
+                                       int                 hot_x,
+                                       int                 hot_y)
+{
+  MetaCursorReference *cursor;
+
+  if (buffer)
+    cursor = meta_cursor_reference_from_buffer (tracker, buffer, hot_x, hot_y);
+  else
+    cursor = NULL;
+
+  set_window_cursor (tracker, TRUE, cursor);
+}
+
+void
+meta_cursor_tracker_unset_window_cursor (MetaCursorTracker *tracker)
+{
+  set_window_cursor (tracker, FALSE, NULL);
 }

 void
@@ -815,21 +880,11 @@ meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
  /* Now update the real root cursor */
  if (meta_is_wayland_compositor ())
    {
-      MetaCursorReference *ref;
-
-      ref = ensure_wayland_cursor (tracker, cursor);
-
      g_clear_pointer (&tracker->root_cursor, meta_cursor_reference_unref);
-      tracker->root_cursor = meta_cursor_reference_ref (ref);
+      tracker->root_cursor = ensure_wayland_cursor (tracker, cursor);
    }
 }

-void
-meta_cursor_tracker_revert_root (MetaCursorTracker *tracker)
-{
-  meta_cursor_tracker_set_sprite (tracker, tracker->root_cursor);
-}
-
 static void
 update_hw_cursor (MetaCursorTracker *tracker)
 {
@@ -838,7 +893,7 @@ update_hw_cursor (MetaCursorTracker *tracker)
  unsigned int i, n_crtcs;
  gboolean enabled;

-  enabled = tracker->has_cursor && tracker->sprite->bo != NULL;
+  enabled = tracker->displayed_cursor && tracker->displayed_cursor->bo != NULL;
  tracker->has_hw_cursor = enabled;

  monitors = meta_monitor_manager_get ();
@@ -884,105 +939,48 @@ move_hw_cursor (MetaCursorTracker *tracker)
    }
 }

-void
-meta_cursor_tracker_set_buffer (MetaCursorTracker  *tracker,
-                                struct wl_resource *buffer,
-                                int                 hot_x,
-                                int                 hot_y)
+static MetaCursorReference *
+get_displayed_cursor (MetaCursorTracker *tracker)
 {
-  MetaCursorReference *new_cursor;
+  if (!tracker->is_showing)
+    return NULL;

-  if (buffer)
-    {
-      new_cursor = meta_cursor_reference_from_buffer (tracker, buffer, hot_x, hot_y);
-      meta_cursor_tracker_set_sprite (tracker, new_cursor);
-      meta_cursor_reference_unref (new_cursor);
-    }
-  else
-    meta_cursor_tracker_set_sprite (tracker, NULL);
+  if (tracker->grab_cursor)
+    return tracker->grab_cursor;
+
+  if (tracker->has_window_cursor)
+    return tracker->window_cursor;
+
+  return tracker->root_cursor;
 }

 static void
-meta_cursor_tracker_set_sprite (MetaCursorTracker   *tracker,
-                                MetaCursorReference *sprite)
+sync_displayed_cursor (MetaCursorTracker *tracker)
 {
-  g_assert (meta_is_wayland_compositor ());
+  MetaCursorReference *displayed_cursor = get_displayed_cursor (tracker);

-  if (sprite == tracker->sprite)
+  if (tracker->displayed_cursor == displayed_cursor)
    return;

-  g_clear_pointer (&tracker->sprite, meta_cursor_reference_unref);
+  g_clear_pointer (&tracker->displayed_cursor, meta_cursor_reference_unref);
+  if (displayed_cursor)
+    tracker->displayed_cursor = meta_cursor_reference_ref (displayed_cursor);

-  if (sprite)
-    {
-      tracker->sprite = meta_cursor_reference_ref (sprite);
-      cogl_pipeline_set_layer_texture (tracker->pipeline, 0, COGL_TEXTURE (tracker->sprite->texture));
-    }
+  if (displayed_cursor)
+    cogl_pipeline_set_layer_texture (tracker->pipeline, 0, COGL_TEXTURE (displayed_cursor->texture));
  else
    cogl_pipeline_set_layer_texture (tracker->pipeline, 0, NULL);

-  tracker->has_cursor = tracker->sprite != NULL && tracker->is_showing;
  update_hw_cursor (tracker);

  g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);
-
-  meta_cursor_tracker_update_position (tracker, tracker->current_x, tracker->current_y);
 }

-void
-meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
-                                     int                new_x,
-                                     int                new_y)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  tracker->current_x = new_x;
-  tracker->current_y = new_y;
-
-  if (tracker->sprite)
-    {
-      tracker->current_rect.x = tracker->current_x - tracker->sprite->hot_x;
-      tracker->current_rect.y = tracker->current_y - tracker->sprite->hot_y;
-      tracker->current_rect.width = cogl_texture_get_width (COGL_TEXTURE (tracker->sprite->texture));
-      tracker->current_rect.height = cogl_texture_get_height (COGL_TEXTURE (tracker->sprite->texture));
-    }
-  else
-    {
-      tracker->current_rect.x = 0;
-      tracker->current_rect.y = 0;
-      tracker->current_rect.width = 0;
-      tracker->current_rect.height = 0;
-    }
-
-  if (tracker->has_hw_cursor)
-    move_hw_cursor (tracker);
-}
-
-void
-meta_cursor_tracker_paint (MetaCursorTracker *tracker)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  if (tracker->has_hw_cursor || !tracker->has_cursor)
-    return;
-
-  cogl_framebuffer_draw_rectangle (cogl_get_draw_framebuffer (),
-                                   tracker->pipeline,
-                                   tracker->current_rect.x,
-                                   tracker->current_rect.y,
-                                   tracker->current_rect.x +
-                                   tracker->current_rect.width,
-                                   tracker->current_rect.y +
-                                   tracker->current_rect.height);
-
-  tracker->previous_rect = tracker->current_rect;
-  tracker->previous_is_valid = TRUE;
-}
-
-void
-meta_cursor_tracker_queue_redraw (MetaCursorTracker *tracker,
-                                  ClutterActor      *stage)
+static void
+meta_cursor_tracker_queue_redraw (MetaCursorTracker *tracker)
 {
+  MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
+  ClutterActor *stage = compositor->stage;
  cairo_rectangle_int_t clip;

  g_assert (meta_is_wayland_compositor ());
@@ -999,7 +997,7 @@ meta_cursor_tracker_queue_redraw (MetaCursorTracker *tracker,
      tracker->previous_is_valid = FALSE;
    }

-  if (tracker->has_hw_cursor || !tracker->has_cursor)
+  if (tracker->has_hw_cursor || !tracker->displayed_cursor)
    return;

  clip.x = tracker->current_rect.x;
@@ -1009,6 +1007,69 @@ meta_cursor_tracker_queue_redraw (MetaCursorTracker *tracker,
  clutter_actor_queue_redraw_with_clip (stage, &clip);
 }

+static void
+sync_cursor (MetaCursorTracker *tracker)
+{
+  MetaCursorReference *displayed_cursor;
+
+  sync_displayed_cursor (tracker);
+  displayed_cursor = tracker->displayed_cursor;
+
+  if (displayed_cursor)
+    {
+      tracker->current_rect.x = tracker->current_x - displayed_cursor->hot_x;
+      tracker->current_rect.y = tracker->current_y - displayed_cursor->hot_y;
+      tracker->current_rect.width = cogl_texture_get_width (COGL_TEXTURE (displayed_cursor->texture));
+      tracker->current_rect.height = cogl_texture_get_height (COGL_TEXTURE (displayed_cursor->texture));
+    }
+  else
+    {
+      tracker->current_rect.x = 0;
+      tracker->current_rect.y = 0;
+      tracker->current_rect.width = 0;
+      tracker->current_rect.height = 0;
+    }
+
+  if (tracker->has_hw_cursor)
+    move_hw_cursor (tracker);
+  else
+    meta_cursor_tracker_queue_redraw (tracker);
+}
+
+void
+meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
+                                     int                new_x,
+                                     int                new_y)
+{
+  g_assert (meta_is_wayland_compositor ());
+
+  tracker->current_x = new_x;
+  tracker->current_y = new_y;
+
+  sync_cursor (tracker);
+}
+
+void
+meta_cursor_tracker_paint (MetaCursorTracker *tracker)
+{
+  g_assert (meta_is_wayland_compositor ());
+
+  if (tracker->has_hw_cursor || !tracker->displayed_cursor)
+    return;
+
+  cogl_framebuffer_draw_rectangle (cogl_get_draw_framebuffer (),
+                                   tracker->pipeline,
+                                   tracker->current_rect.x,
+                                   tracker->current_rect.y,
+                                   tracker->current_rect.x +
+                                   tracker->current_rect.width,
+                                   tracker->current_rect.y +
+                                   tracker->current_rect.height);
+
+  tracker->previous_rect = tracker->current_rect;
+  tracker->previous_is_valid = TRUE;
+}
+
 static void
 meta_cursor_tracker_set_crtc_has_hw_cursor (MetaCursorTracker *tracker,
                                            MetaCRTC          *crtc,
@@ -1016,15 +1077,16 @@ meta_cursor_tracker_set_crtc_has_hw_cursor (MetaCursorTracker *tracker,
 {
  if (has)
    {
+      MetaCursorReference *displayed_cursor = tracker->displayed_cursor;
      union gbm_bo_handle handle;
      int width, height;
      int hot_x, hot_y;

-      handle = gbm_bo_get_handle (tracker->sprite->bo);
-      width = gbm_bo_get_width (tracker->sprite->bo);
-      height = gbm_bo_get_height (tracker->sprite->bo);
-      hot_x = tracker->sprite->hot_x;
-      hot_y = tracker->sprite->hot_y;
+      handle = gbm_bo_get_handle (displayed_cursor->bo);
+      width = gbm_bo_get_width (displayed_cursor->bo);
+      height = gbm_bo_get_height (displayed_cursor->bo);
+      hot_x = displayed_cursor->hot_x;
+      hot_y = displayed_cursor->hot_y;

      drmModeSetCursor2 (tracker->drm_fd, crtc->crtc_id, handle.u32,
                         width, height, hot_x, hot_y);
@@ -1100,13 +1162,7 @@ meta_cursor_tracker_set_pointer_visible (MetaCursorTracker *tracker,

  if (meta_is_wayland_compositor ())
    {
-      MetaWaylandCompositor *compositor;
-
-      compositor = meta_wayland_compositor_get_default ();
-
-      tracker->has_cursor = tracker->sprite != NULL && visible;
-      update_hw_cursor (tracker);
-      meta_cursor_tracker_queue_redraw (tracker, compositor->stage);
+      sync_cursor (tracker);
    }
  else
    {
--- a/src/core/monitor-config.c
+++ b/src/core/monitor-config.c
@@ -817,6 +817,22 @@ meta_monitor_config_match_current (MetaMonitorConfig  *self,
  return ok;
 }

+gboolean
+meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager)
+{
+  MetaOutput *outputs;
+  unsigned n_outputs;
+  unsigned int i;
+
+  outputs = meta_monitor_manager_get_outputs (manager, &n_outputs);
+
+  for (i = 0; i < n_outputs; i++)
+    if (outputs[i].hotplug_mode_update)
+      return TRUE;
+
+  return FALSE;
+}
+
 static MetaConfiguration *
 meta_monitor_config_get_stored (MetaMonitorConfig *self,
 				MetaOutput        *outputs,
--- a/src/core/monitor-private.h
+++ b/src/core/monitor-private.h
@@ -119,6 +119,9 @@ struct _MetaOutput

  gpointer driver_private;
  GDestroyNotify driver_notify;
+
+  /* get a new preferred mode on hotplug events, to handle dynamic guest resizing */
+  gboolean hotplug_mode_update;
 };

 struct _MetaCRTC
@@ -407,6 +410,7 @@ void               meta_monitor_manager_free_output_array (MetaOutput *old_outpu
                                                           int         n_old_outputs);
 void               meta_monitor_manager_free_mode_array (MetaMonitorMode *old_modes,
                                                         int              n_old_modes);
+gboolean           meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager);

 /* Returns true if transform causes width and height to be inverted
   This is true for the odd transforms in the enum */
--- a/src/core/monitor-xrandr.c
+++ b/src/core/monitor-xrandr.c
@@ -311,6 +311,29 @@ read_output_edid (MetaMonitorManagerXrandr *manager_xrandr,
  return NULL;
 }

+static gboolean
+output_get_hotplug_mode_update (MetaMonitorManagerXrandr *manager_xrandr,
+                                XID                       output_id)
+{
+  MetaDisplay *display = meta_get_display ();
+  XRRPropertyInfo *info;
+  gboolean result = FALSE;
+
+  meta_error_trap_push (display);
+  info = XRRQueryOutputProperty (manager_xrandr->xdisplay, output_id,
+                                 display->atom_hotplug_mode_update);
+  meta_error_trap_pop (display);
+
+  if (info)
+    {
+      result = TRUE;
+      XFree (info);
+    }
+
+  return result;
+}
+
+
 static void
 meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
 {
@@ -484,6 +507,8 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
 	  meta_output->width_mm = output->mm_width;
 	  meta_output->height_mm = output->mm_height;
 	  meta_output->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
+          meta_output->hotplug_mode_update =
+              output_get_hotplug_mode_update (manager_xrandr, meta_output->output_id);

 	  meta_output->n_modes = output->nmode;
 	  meta_output->modes = g_new0 (MetaMonitorMode *, meta_output->n_modes);
@@ -969,6 +994,16 @@ meta_monitor_manager_xrandr_set_crtc_gamma (MetaMonitorManager *manager,
  XRRFreeGamma (gamma);
 }

+static void
+meta_monitor_manager_xrandr_rebuild_derived (MetaMonitorManager *manager)
+{
+  /* This will be a no-op if the change was from our side, as
+     we already called it in the DBus method handler */
+  meta_monitor_config_update_current (manager->config, manager);
+
+  meta_monitor_manager_rebuild_derived (manager);
+}
+
 static gboolean
 meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManager *manager,
 					   XEvent             *event)
@@ -978,6 +1013,7 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManager *manager,
  MetaCRTC *old_crtcs;
  MetaMonitorMode *old_modes;
  unsigned int n_old_outputs, n_old_modes;
+  gboolean new_config;

  if ((event->type - manager_xrandr->rr_event_base) != RRScreenChangeNotify)
    return FALSE;
@@ -994,31 +1030,36 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManager *manager,
  manager->serial++;
  meta_monitor_manager_xrandr_read_current (manager);

-  /* Check if the current intended configuration has the same outputs
-     as the new real one, or if the event is a result of an XRandR call.
-     If so, we can go straight to rebuild the logical config and tell
-     the outside world.
-     Otherwise, this event was caused by hotplug, so give a chance to
-     MetaMonitorConfig.
+  new_config = manager_xrandr->resources->timestamp >=
+    manager_xrandr->resources->configTimestamp;
+  if (meta_monitor_manager_has_hotplug_mode_update (manager))

-     Note that we need to check both the timestamps and the list of
-     outputs, because the X server might emit spurious events with
-     new configTimestamps (bug 702804), and the driver may have
-     changed the EDID for some other reason (old broken qxl and vbox
-     drivers...).
-  */
-  if (manager_xrandr->resources->timestamp >= manager_xrandr->resources->configTimestamp ||
-      meta_monitor_config_match_current (manager->config, manager))
    {
-      /* This will be a no-op if the change was from our side, as
-         we already called it in the DBus method handler */
-      meta_monitor_config_update_current (manager->config, manager);
-
-      meta_monitor_manager_rebuild_derived (manager);
+      /* Check if the current intended configuration is a result of an
+         XRandR call.  Otherwise, hotplug_mode_update tells us to get
+         a new preferred mode on hotplug events to handle dynamic
+         guest resizing. */
+      if (new_config)
+        meta_monitor_manager_xrandr_rebuild_derived (manager);
+      else
+        meta_monitor_config_make_default (manager->config, manager);
    }
  else
    {
-      if (!meta_monitor_config_apply_stored (manager->config, manager))
+      /* Check if the current intended configuration has the same outputs
+         as the new real one, or if the event is a result of an XRandR call.
+         If so, we can go straight to rebuild the logical config and tell
+         the outside world.
+         Otherwise, this event was caused by hotplug, so give a chance to
+         MetaMonitorConfig.
+
+         Note that we need to check both the timestamps and the list of
+         outputs, because the X server might emit spurious events with new
+         configTimestamps (bug 702804), and the driver may have changed
+         the EDID for some other reason (old qxl and vbox drivers). */
+      if (new_config || meta_monitor_config_match_current (manager->config, manager))
+        meta_monitor_manager_xrandr_rebuild_derived (manager);
+      else if (!meta_monitor_config_apply_stored (manager->config, manager))
        meta_monitor_config_make_default (manager->config, manager);
    }

--- a/src/core/place.c
+++ b/src/core/place.c
@@ -47,34 +47,18 @@ northwestcmp (gconstpointer a, gconstpointer b)
 {
  MetaWindow *aw = (gpointer) a;
  MetaWindow *bw = (gpointer) b;
+  MetaRectangle a_frame;
+  MetaRectangle b_frame;
  int from_origin_a;
  int from_origin_b;
  int ax, ay, bx, by;

-  /* we're interested in the frame position for cascading,
-   * not meta_window_get_position()
-   */
-  if (aw->frame)
-    {
-      ax = aw->frame->rect.x;
-      ay = aw->frame->rect.y;
-    }
-  else
-    {
-      ax = aw->rect.x;
-      ay = aw->rect.y;
-    }
-
-  if (bw->frame)
-    {
-      bx = bw->frame->rect.x;
-      by = bw->frame->rect.y;
-    }
-  else
-    {
-      bx = bw->rect.x;
-      by = bw->rect.y;
-    }
+  meta_window_get_frame_rect (aw, &a_frame);
+  meta_window_get_frame_rect (bw, &b_frame);
+  ax = a_frame.x;
+  ay = a_frame.y;
+  bx = b_frame.x;
+  by = b_frame.y;
  
  /* probably there's a fast good-enough-guess we could use here. */
  from_origin_a = sqrt (ax * ax + ay * ay);
@@ -90,7 +74,6 @@ northwestcmp (gconstpointer a, gconstpointer b)

 static void
 find_next_cascade (MetaWindow *window,
-                   MetaFrameBorders *borders,
                   /* visible windows on relevant workspaces */
                   GList      *windows,
                   int         x,
@@ -102,6 +85,7 @@ find_next_cascade (MetaWindow *window,
  GList *sorted;
  int cascade_x, cascade_y;
  int x_threshold, y_threshold;
+  MetaRectangle frame_rect;
  int window_width, window_height;
  int cascade_stage;
  MetaRectangle work_area;
@@ -120,10 +104,13 @@ find_next_cascade (MetaWindow *window,
   * manually cascade.
   */
 #define CASCADE_FUZZ 15
-  if (borders)
+  if (window->frame)
    {
-      x_threshold = MAX (borders->visible.left, CASCADE_FUZZ);
-      y_threshold = MAX (borders->visible.top, CASCADE_FUZZ);
+      MetaFrameBorders borders;
+
+      meta_frame_calc_borders (window->frame, &borders);
+      x_threshold = MAX (borders.visible.left, CASCADE_FUZZ);
+      y_threshold = MAX (borders.visible.top, CASCADE_FUZZ);
    }
  else
    {
@@ -143,30 +130,25 @@ find_next_cascade (MetaWindow *window,
  cascade_y = MAX (0, work_area.y);
  
  /* Find first cascade position that's not used. */
-  
-  window_width = window->frame ? window->frame->rect.width : window->rect.width;
-  window_height = window->frame ? window->frame->rect.height : window->rect.height;
+
+  meta_window_get_frame_rect (window, &frame_rect);
+  window_width = frame_rect.width;
+  window_height = frame_rect.height;
  
  cascade_stage = 0;
  tmp = sorted;
  while (tmp != NULL)
    {
      MetaWindow *w;
+      MetaRectangle w_frame_rect;
      int wx, wy;
      
      w = tmp->data;

      /* we want frame position, not window position */
-      if (w->frame)
-        {
-          wx = w->frame->rect.x;
-          wy = w->frame->rect.y;
-        }
-      else
-        {
-          wx = w->rect.x;
-          wy = w->rect.y;
-        }
+      meta_window_get_frame_rect (w, &w_frame_rect);
+      wx = w_frame_rect.x;
+      wy = w_frame_rect.y;
      
      if (ABS (wx - cascade_x) < x_threshold &&
          ABS (wy - cascade_y) < y_threshold)
@@ -223,22 +205,12 @@ find_next_cascade (MetaWindow *window,
  
  g_list_free (sorted);

-  /* Convert coords to position of window, not position of frame. */
-  if (borders == NULL)
-    {
-      *new_x = cascade_x;
-      *new_y = cascade_y;
-    }
-  else
-    {
-      *new_x = cascade_x + borders->visible.left;
-      *new_y = cascade_y + borders->visible.top;
-    }
+  *new_x = cascade_x;
+  *new_y = cascade_y;
 }

 static void
 find_most_freespace (MetaWindow *window,
-                     MetaFrameBorders *borders,
                     /* visible windows on relevant workspaces */
                     MetaWindow *focus_window,
                     int         x,
@@ -250,29 +222,25 @@ find_most_freespace (MetaWindow *window,
  int max_area;
  int max_width, max_height, left, right, top, bottom;
  int left_space, right_space, top_space, bottom_space;
-  int frame_size_left, frame_size_top;
  MetaRectangle work_area;
  MetaRectangle avoid;
-  MetaRectangle outer;
-
-  frame_size_left = borders ? borders->visible.left : 0;
-  frame_size_top  = borders ? borders->visible.top : 0;
+  MetaRectangle frame_rect;

  meta_window_get_work_area_current_monitor (focus_window, &work_area);
-  meta_window_get_outer_rect (focus_window, &avoid);
-  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_frame_rect (focus_window, &avoid);
+  meta_window_get_frame_rect (window, &frame_rect);

  /* Find the areas of choosing the various sides of the focus window */
-  max_width  = MIN (avoid.width, outer.width);
-  max_height = MIN (avoid.height, outer.height);
+  max_width  = MIN (avoid.width, frame_rect.width);
+  max_height = MIN (avoid.height, frame_rect.height);
  left_space   = avoid.x - work_area.x;
  right_space  = work_area.width - (avoid.x + avoid.width - work_area.x);
  top_space    = avoid.y - work_area.y;
  bottom_space = work_area.height - (avoid.y + avoid.height - work_area.y);
-  left   = MIN (left_space,   outer.width);
-  right  = MIN (right_space,  outer.width);
-  top    = MIN (top_space,    outer.height);
-  bottom = MIN (bottom_space, outer.height);
+  left   = MIN (left_space,   frame_rect.width);
+  right  = MIN (right_space,  frame_rect.width);
+  top    = MIN (top_space,    frame_rect.height);
+  bottom = MIN (bottom_space, frame_rect.height);

  /* Find out which side of the focus_window can show the most of the window */
  side = META_LEFT;
@@ -304,39 +272,56 @@ find_most_freespace (MetaWindow *window,
  switch (side)
    {
    case META_LEFT:
-      *new_y = avoid.y + frame_size_top;
-      if (left_space > outer.width)
-        *new_x = avoid.x - outer.width + frame_size_left;
+      *new_y = avoid.y;
+      if (left_space > frame_rect.width)
+        *new_x = avoid.x - frame_rect.width;
      else
-        *new_x = work_area.x + frame_size_left;
+        *new_x = work_area.x;
      break;
    case META_RIGHT:
-      *new_y = avoid.y + frame_size_top;
-      if (right_space > outer.width)
-        *new_x = avoid.x + avoid.width + frame_size_left;
+      *new_y = avoid.y;
+      if (right_space > frame_rect.width)
+        *new_x = avoid.x + avoid.width;
      else
-        *new_x = work_area.x + work_area.width - outer.width + frame_size_left;
+        *new_x = work_area.x + work_area.width - frame_rect.width;
      break;
    case META_TOP:
-      *new_x = avoid.x + frame_size_left;
-      if (top_space > outer.height)
-        *new_y = avoid.y - outer.height + frame_size_top;
+      *new_x = avoid.x;
+      if (top_space > frame_rect.height)
+        *new_y = avoid.y - frame_rect.height;
      else
-        *new_y = work_area.y + frame_size_top;
+        *new_y = work_area.y;
      break;
    case META_BOTTOM:
-      *new_x = avoid.x + frame_size_left;
-      if (bottom_space > outer.height)
-        *new_y = avoid.y + avoid.height + frame_size_top;
+      *new_x = avoid.x;
+      if (bottom_space > frame_rect.height)
+        *new_y = avoid.y + avoid.height;
      else
-        *new_y = work_area.y + work_area.height - outer.height + frame_size_top;
+        *new_y = work_area.y + work_area.height - frame_rect.height;
      break;
    }
 }

+static gboolean
+window_overlaps_focus_window (MetaWindow *window)
+{
+  MetaWindow *focus_window;
+  MetaRectangle window_frame, focus_frame, overlap;
+
+  focus_window = window->display->focus_window;
+  if (focus_window == NULL)
+    return FALSE;
+
+  meta_window_get_frame_rect (window, &window_frame);
+  meta_window_get_frame_rect (focus_window, &focus_frame);
+
+  return meta_rectangle_intersect (&window_frame,
+                                   &focus_frame,
+                                   &overlap);
+}
+
 static void
 avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
-                                             MetaFrameBorders *borders,
                                             int        *x,
                                             int        *y)
 {
@@ -355,18 +340,17 @@ avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
   */

  MetaWindow *focus_window;
-  MetaRectangle overlap;

  focus_window = window->display->focus_window;

+  /* denied_focus_and_not_transient is only set when focus_window != NULL */
+
  if (window->denied_focus_and_not_transient &&
      window->wm_state_modal && /* FIXME: Maybe do this for all transients? */
      meta_window_same_application (window, focus_window) &&
-      meta_rectangle_intersect (&window->rect,
-                                &focus_window->rect,
-                                &overlap))
+      window_overlaps_focus_window (window))
    {
-      find_most_freespace (window, borders, focus_window, *x, *y, x, y);
+      find_most_freespace (window, focus_window, *x, *y, x, y);
      meta_topic (META_DEBUG_PLACEMENT,
                  "Dialog window %s was denied focus but may be modal "
                  "to the focus window; had to move it to avoid the "
@@ -409,7 +393,7 @@ rectangle_overlaps_some_window (MetaRectangle *rect,
        case META_WINDOW_UTILITY:
        case META_WINDOW_TOOLBAR:
        case META_WINDOW_MENU:
-          meta_window_get_outer_rect (other, &other_rect);
+          meta_window_get_frame_rect (other, &other_rect);
          
          if (meta_rectangle_intersect (rect, &other_rect, &dest))
            return TRUE;
@@ -427,20 +411,14 @@ leftmost_cmp (gconstpointer a, gconstpointer b)
 {
  MetaWindow *aw = (gpointer) a;
  MetaWindow *bw = (gpointer) b;
+  MetaRectangle a_frame;
+  MetaRectangle b_frame;
  int ax, bx;

-  /* we're interested in the frame position for cascading,
-   * not meta_window_get_position()
-   */
-  if (aw->frame)
-    ax = aw->frame->rect.x;
-  else
-    ax = aw->rect.x;
-
-  if (bw->frame)
-    bx = bw->frame->rect.x;
-  else
-    bx = bw->rect.x;
+  meta_window_get_frame_rect (aw, &a_frame);
+  meta_window_get_frame_rect (bw, &b_frame);
+  ax = a_frame.x;
+  bx = b_frame.x;

  if (ax < bx)
    return -1;
@@ -455,20 +433,14 @@ topmost_cmp (gconstpointer a, gconstpointer b)
 {
  MetaWindow *aw = (gpointer) a;
  MetaWindow *bw = (gpointer) b;
+  MetaRectangle a_frame;
+  MetaRectangle b_frame;
  int ay, by;

-  /* we're interested in the frame position for cascading,
-   * not meta_window_get_position()
-   */
-  if (aw->frame)
-    ay = aw->frame->rect.y;
-  else
-    ay = aw->rect.y;
-
-  if (bw->frame)
-    by = bw->frame->rect.y;
-  else
-    by = bw->rect.y;
+  meta_window_get_frame_rect (aw, &a_frame);
+  meta_window_get_frame_rect (bw, &b_frame);
+  ay = a_frame.y;
+  by = b_frame.y;

  if (ay < by)
    return -1;
@@ -506,7 +478,6 @@ center_tile_rect_in_area (MetaRectangle *rect,
 */
 static gboolean
 find_first_fit (MetaWindow *window,
-                MetaFrameBorders *borders,
                /* visible windows on relevant workspaces */
                GList      *windows,
 		int         monitor,
@@ -540,15 +511,8 @@ find_first_fit (MetaWindow *window,
  right_sorted = g_list_copy (windows);
  right_sorted = g_list_sort (right_sorted, topmost_cmp);
  right_sorted = g_list_sort (right_sorted, leftmost_cmp);
-  
-  rect.width = window->rect.width;
-  rect.height = window->rect.height;
-  
-  if (borders)
-    {
-      rect.width += borders->visible.left + borders->visible.right;
-      rect.height += borders->visible.top + borders->visible.bottom;
-    }
+
+  meta_window_get_frame_rect (window, &rect);

 #ifdef WITH_VERBOSE_MODE
    {
@@ -570,11 +534,6 @@ find_first_fit (MetaWindow *window,
      {
        *new_x = rect.x;
        *new_y = rect.y;
-        if (borders)
-          {
-            *new_x += borders->visible.left;
-            *new_y += borders->visible.top;
-          }
    
        retval = TRUE;
       
@@ -586,23 +545,18 @@ find_first_fit (MetaWindow *window,
    while (tmp != NULL)
      {
        MetaWindow *w = tmp->data;
-        MetaRectangle outer_rect;
+        MetaRectangle frame_rect;

-        meta_window_get_outer_rect (w, &outer_rect);
+        meta_window_get_frame_rect (w, &frame_rect);
      
-        rect.x = outer_rect.x;
-        rect.y = outer_rect.y + outer_rect.height;
+        rect.x = frame_rect.x;
+        rect.y = frame_rect.y + frame_rect.height;
      
        if (meta_rectangle_contains_rect (&work_area, &rect) &&
            !rectangle_overlaps_some_window (&rect, below_sorted))
          {
            *new_x = rect.x;
            *new_y = rect.y;
-            if (borders)
-              {
-                *new_x += borders->visible.left;
-                *new_y += borders->visible.top;
-              }
          
            retval = TRUE;
          
@@ -617,23 +571,18 @@ find_first_fit (MetaWindow *window,
    while (tmp != NULL)
      {
        MetaWindow *w = tmp->data;
-        MetaRectangle outer_rect;
+        MetaRectangle frame_rect;
   
-        meta_window_get_outer_rect (w, &outer_rect);
+        meta_window_get_frame_rect (w, &frame_rect);
     
-        rect.x = outer_rect.x + outer_rect.width;
-        rect.y = outer_rect.y;
+        rect.x = frame_rect.x + frame_rect.width;
+        rect.y = frame_rect.y;
   
        if (meta_rectangle_contains_rect (&work_area, &rect) &&
            !rectangle_overlaps_some_window (&rect, right_sorted))
          {
            *new_x = rect.x;
            *new_y = rect.y;
-            if (borders)
-              {
-                *new_x += borders->visible.left;
-                *new_y += borders->visible.top;
-              }
        
            retval = TRUE;
       
@@ -652,7 +601,6 @@ find_first_fit (MetaWindow *window,

 void
 meta_window_place (MetaWindow        *window,
-                   MetaFrameBorders  *borders,
                   int                x,
                   int                y,
                   int               *new_x,
@@ -661,13 +609,6 @@ meta_window_place (MetaWindow        *window,
  GList *windows;
  const MetaMonitorInfo *xi;

-  /* frame member variables should NEVER be used in here, only
-   * MetaFrameBorders. But remember borders == NULL
-   * for undecorated windows. Also, this function should
-   * NEVER have side effects other than computing the
-   * placement coordinates.
-   */
-
  meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);

  windows = NULL;
@@ -756,7 +697,7 @@ meta_window_place (MetaWindow        *window,
        {
          meta_topic (META_DEBUG_PLACEMENT,
                      "Not placing window with PPosition or USPosition set\n");
-          avoid_being_obscured_as_second_modal_dialog (window, borders, &x, &y);
+          avoid_being_obscured_as_second_modal_dialog (window, &x, &y);
          goto done_no_constraints;
        }
    }
@@ -775,29 +716,27 @@ meta_window_place (MetaWindow        *window,

      if (parent)
        {
-          int w;
+          MetaRectangle frame_rect, parent_frame_rect;

-          meta_window_get_position (parent, &x, &y);
-          w = parent->rect.width;
+          meta_window_get_frame_rect (window, &frame_rect);
+          meta_window_get_frame_rect (parent, &parent_frame_rect);
+
+          y = parent_frame_rect.y;

          /* center of parent */
-          x = x + w / 2;
+          x = parent_frame_rect.x + parent_frame_rect.width / 2;
          /* center of child over center of parent */
-          x -= window->rect.width / 2;
+          x -= frame_rect.width / 2;

          /* "visually" center window over parent, leaving twice as
           * much space below as on top.
           */
-          y += (parent->rect.height - window->rect.height)/3;
-
-          /* put top of child's frame, not top of child's client */
-          if (borders)
-            y += borders->visible.top;
+          y += (parent_frame_rect.height - frame_rect.height)/3;

          meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
                      window->desc);
          
-          avoid_being_obscured_as_second_modal_dialog (window, borders, &x, &y);
+          avoid_being_obscured_as_second_modal_dialog (window, &x, &y);

          goto done;
        }
@@ -813,6 +752,9 @@ meta_window_place (MetaWindow        *window,
    {
      /* Center on current monitor */
      int w, h;
+      MetaRectangle frame_rect;
+
+      meta_window_get_frame_rect (window, &frame_rect);

      /* Warning, this function is a round trip! */
      xi = meta_screen_get_current_monitor_info (window->screen);
@@ -820,8 +762,8 @@ meta_window_place (MetaWindow        *window,
      w = xi->rect.width;
      h = xi->rect.height;

-      x = (w - window->rect.width) / 2;
-      y = (h - window->rect.height) / 2;
+      x = (w - frame_rect.width) / 2;
+      y = (h - frame_rect.height) / 2;

      x += xi->rect.x;
      y += xi->rect.y;
@@ -865,7 +807,7 @@ meta_window_place (MetaWindow        *window,
  x = xi->rect.x;
  y = xi->rect.y;

-  if (find_first_fit (window, borders, windows,
+  if (find_first_fit (window, windows,
                      xi->number,
                      x, y, &x, &y))
    goto done_check_denied_focus;
@@ -878,17 +820,17 @@ meta_window_place (MetaWindow        *window,
      !window->fullscreen)
    {
      MetaRectangle workarea;
-      MetaRectangle outer;
+      MetaRectangle frame_rect;

      meta_window_get_work_area_for_monitor (window,
                                             xi->number,
                                             &workarea);      
-      meta_window_get_outer_rect (window, &outer);
+      meta_window_get_frame_rect (window, &frame_rect);
      
      /* If the window is bigger than the screen, then automaximize.  Do NOT
       * auto-maximize the directions independently.  See #419810.
       */
-      if (outer.width >= workarea.width && outer.height >= workarea.height)
+      if (frame_rect.width >= workarea.width && frame_rect.height >= workarea.height)
        {
          window->maximize_horizontally_after_placement = TRUE;
          window->maximize_vertically_after_placement = TRUE;
@@ -899,7 +841,7 @@ meta_window_place (MetaWindow        *window,
   * fully overlapping window (e.g. starting multiple terminals)
   * */
  if (x == xi->rect.x && y == xi->rect.y)  
-    find_next_cascade (window, borders, windows, x, y, &x, &y);
+    find_next_cascade (window, windows, x, y, &x, &y);

 done_check_denied_focus:
  /* If the window is being denied focus and isn't a transient of the
@@ -909,17 +851,14 @@ meta_window_place (MetaWindow        *window,
   */
  if (window->denied_focus_and_not_transient)
    {
-      gboolean       found_fit;
      MetaWindow    *focus_window;
-      MetaRectangle  overlap;
+      gboolean       found_fit;

      focus_window = window->display->focus_window;
      g_assert (focus_window != NULL);

      /* No need to do anything if the window doesn't overlap at all */
-      found_fit = !meta_rectangle_intersect (&window->rect,
-                                             &focus_window->rect,
-                                             &overlap);
+      found_fit = !window_overlaps_focus_window (window);

      /* Try to do a first fit again, this time only taking into account the
       * focus window.
@@ -933,7 +872,7 @@ meta_window_place (MetaWindow        *window,
          x = xi->rect.x;
          y = xi->rect.y;

-          found_fit = find_first_fit (window, borders, focus_window_list,
+          found_fit = find_first_fit (window, focus_window_list,
                                      xi->number,
                                      x, y, &x, &y);
          g_list_free (focus_window_list);
@@ -943,7 +882,7 @@ meta_window_place (MetaWindow        *window,
       * as possible.
       */
      if (!found_fit)
-        find_most_freespace (window, borders, focus_window, x, y, &x, &y);
+        find_most_freespace (window, focus_window, x, y, &x, &y);
    }
  
 done:
--- a/src/core/place.h
+++ b/src/core/place.h
@@ -28,7 +28,6 @@
 #include "frame.h"

 void meta_window_place (MetaWindow *window,
-                        MetaFrameBorders *borders,
                        int         x,
                        int         y,
                        int        *new_x,
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -859,9 +859,9 @@ meta_screen_free (MetaScreen *screen,
                  screen->wm_sn_selection_window);
  
  if (screen->work_area_later != 0)
-    g_source_remove (screen->work_area_later);
+    meta_later_remove (screen->work_area_later);
  if (screen->check_fullscreen_later != 0)
-    g_source_remove (screen->check_fullscreen_later);
+    meta_later_remove (screen->check_fullscreen_later);

  if (screen->monitor_infos)
    g_free (screen->monitor_infos);
@@ -1528,7 +1528,7 @@ meta_screen_tab_popup_create (MetaScreen      *screen,
      if (show_type == META_TAB_SHOW_INSTANTLY ||
          !entries[i].hidden                   ||
          !meta_window_get_icon_geometry (window, &r))
-        meta_window_get_outer_rect (window, &r);
+        meta_window_get_frame_rect (window, &r);

      entries[i].rect = r;

@@ -1914,7 +1914,7 @@ meta_screen_get_monitor_for_window (MetaScreen *screen,
 {
  MetaRectangle window_rect;
  
-  meta_window_get_outer_rect (window, &window_rect);
+  meta_window_get_frame_rect (window, &window_rect);

  return meta_screen_get_monitor_for_rect (screen, &window_rect);
 }
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -92,16 +92,6 @@ meta_stack_new (MetaScreen *screen)
 static void
 free_last_all_root_children_stacked_cache (MetaStack *stack)
 {
-  unsigned int i;
-
-  for (i = 0; i < stack->last_all_root_children_stacked->len; i++)
-    {
-      MetaStackWindow *window = &g_array_index (stack->last_all_root_children_stacked, MetaStackWindow, i);
-      if (window->any.type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-        g_object_remove_weak_pointer (G_OBJECT (window->wayland.meta_window),
-                                      (gpointer *)&window->wayland.meta_window);
-    }
-
  g_array_free (stack->last_all_root_children_stacked, TRUE);
  stack->last_all_root_children_stacked = NULL;
 }
@@ -1337,17 +1327,6 @@ stack_sync_to_xserver (MetaStack *stack)
      /* build XRestackWindows() array from top to bottom */
      if (w->client_type == META_WINDOW_CLIENT_TYPE_X11)
        g_array_append_val (x11_root_children_stacked, top_level_window);
-      else
-        {
-          MetaStackWindow *new;
-
-          /* So we can determine later if a cached stack window is
-           * stale because the corresponding window has been freed we
-           * associate a weak pointer with the new window. */
-          new = &g_array_index (all_root_children_stacked, MetaStackWindow, all_root_children_stacked->len - 1);
-          g_object_add_weak_pointer (G_OBJECT (new->wayland.meta_window),
-                                     (gpointer *)&new->wayland.meta_window);
-        }
    }

  meta_topic (META_DEBUG_STACK, "\n");
@@ -1705,7 +1684,7 @@ window_contains_point (MetaWindow *window,
 {
  MetaRectangle rect;

-  meta_window_get_outer_rect (window, &rect);
+  meta_window_get_frame_rect (window, &rect);

  return POINT_IN_RECT (root_x, root_y, rect);
 }
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -533,6 +533,7 @@ void        meta_window_update_fullscreen_monitors (MetaWindow    *window,
                                                    unsigned long  left,
                                                    unsigned long  right);

+
 /* args to move are window pos, not frame pos */
 void        meta_window_move               (MetaWindow  *window,
                                            gboolean     user_op,
@@ -683,6 +684,8 @@ void meta_window_recalc_features    (MetaWindow *window);
 void meta_window_recalc_window_type (MetaWindow *window);
 void meta_window_type_changed       (MetaWindow *window);

+void meta_window_frame_size_changed (MetaWindow *window);
+
 void meta_window_stack_just_below (MetaWindow *window,
                                   MetaWindow *below_this_one);

--- a/src/core/window.c
+++ b/src/core/window.c
@@ -1065,8 +1065,6 @@ meta_window_new_shared (MetaDisplay         *display,

  if (client_type == META_WINDOW_CLIENT_TYPE_X11)
    meta_window_load_initial_properties (window);
-  else
-    meta_wayland_surface_set_initial_state (window->surface, window);

  if (window->override_redirect)
    {
@@ -2933,8 +2931,8 @@ static gboolean
 windows_overlap (const MetaWindow *w1, const MetaWindow *w2)
 {
  MetaRectangle w1rect, w2rect;
-  meta_window_get_outer_rect (w1, &w1rect);
-  meta_window_get_outer_rect (w2, &w2rect);
+  meta_window_get_frame_rect (w1, &w1rect);
+  meta_window_get_frame_rect (w2, &w2rect);
  return meta_rectangle_overlap (&w1rect, &w2rect);
 }

@@ -3735,11 +3733,11 @@ meta_window_maximize (MetaWindow        *window,
          MetaRectangle old_rect;
 	  MetaRectangle new_rect;

-	  meta_window_get_outer_rect (window, &old_rect);
+	  meta_window_get_frame_rect (window, &old_rect);

          meta_window_move_resize_now (window);

-	  meta_window_get_outer_rect (window, &new_rect);
+	  meta_window_get_frame_rect (window, &new_rect);
          meta_compositor_maximize_window (window->display->compositor,
                                           window,
                                           &old_rect,
@@ -3798,7 +3796,7 @@ meta_window_get_all_monitors (MetaWindow *window, gsize *length)
  int i;

  monitors = g_array_new (FALSE, FALSE, sizeof (int));
-  meta_window_get_outer_rect (window, &window_rect);
+  meta_window_get_frame_rect (window, &window_rect);

  for (i = 0; i < window->screen->n_monitor_infos; i++)
    {
@@ -3831,7 +3829,7 @@ meta_window_is_screen_sized (MetaWindow *window)
  int screen_width, screen_height;

  meta_screen_get_size (window->screen, &screen_width, &screen_height);
-  meta_window_get_outer_rect (window, &window_rect);
+  meta_window_get_frame_rect (window, &window_rect);

  if (window_rect.x == 0 && window_rect.y == 0 &&
      window_rect.width == screen_width && window_rect.height == screen_height)
@@ -3860,7 +3858,7 @@ meta_window_is_monitor_sized (MetaWindow *window)
    {
      MetaRectangle window_rect, monitor_rect;

-      meta_window_get_outer_rect (window, &window_rect);
+      meta_window_get_frame_rect (window, &window_rect);
      meta_screen_get_monitor_geometry (window->screen, window->monitor->number, &monitor_rect);

      if (meta_rectangle_equal (&window_rect, &monitor_rect))
@@ -3928,11 +3926,11 @@ meta_window_tile (MetaWindow *window)
      MetaRectangle old_rect;
      MetaRectangle new_rect;

-      meta_window_get_outer_rect (window, &old_rect);
+      meta_window_get_frame_rect (window, &old_rect);

      meta_window_move_resize_now (window);

-      meta_window_get_outer_rect (window, &new_rect);
+      meta_window_get_frame_rect (window, &new_rect);
      meta_compositor_maximize_window (window->display->compositor,
                                       window,
                                       &old_rect,
@@ -3961,7 +3959,7 @@ meta_window_can_tile_side_by_side (MetaWindow *window)
 {
  int monitor;
  MetaRectangle tile_area;
-  MetaFrameBorders borders;
+  MetaRectangle client_rect;

  if (!meta_window_can_tile_maximized (window))
    return FALSE;
@@ -3975,13 +3973,10 @@ meta_window_can_tile_side_by_side (MetaWindow *window)

  tile_area.width /= 2;

-  meta_frame_calc_borders (window->frame, &borders);
+  meta_window_frame_rect_to_client_rect (window, &tile_area, &client_rect);

-  tile_area.width  -= (borders.visible.left + borders.visible.right);
-  tile_area.height -= (borders.visible.top + borders.visible.bottom);
-
-  return tile_area.width >= window->size_hints.min_width &&
-         tile_area.height >= window->size_hints.min_height;
+  return client_rect.width >= window->size_hints.min_width &&
+         client_rect.height >= window->size_hints.min_height;
 }

 static void
@@ -4103,7 +4098,7 @@ meta_window_unmaximize_internal (MetaWindow        *window,
        {
          MetaRectangle old_rect, new_rect;

-	  meta_window_get_outer_rect (window, &old_rect);
+	  meta_window_get_frame_rect (window, &old_rect);

          meta_window_move_resize_internal (window,
                                            META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION,
@@ -4113,7 +4108,7 @@ meta_window_unmaximize_internal (MetaWindow        *window,
                                            target_rect.width,
                                            target_rect.height);

-	  meta_window_get_outer_rect (window, &new_rect);
+	  meta_window_get_frame_rect (window, &new_rect);
          meta_compositor_unmaximize_window (window->display->compositor,
 					     window,
                                             &old_rect,
@@ -4218,6 +4213,7 @@ meta_window_set_above (MetaWindow *window,
  window->wm_state_above = new_value;
  meta_window_update_layer (window);
  set_net_wm_state (window);
+  meta_window_frame_size_changed (window);
  g_object_notify (G_OBJECT (window), "above");
 }

@@ -4357,6 +4353,7 @@ meta_window_shade (MetaWindow  *window,
      window->shaded = TRUE;

      meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+      meta_window_frame_size_changed (window);

      /* After queuing the calc showing, since _focus flushes it,
       * and we need to focus the frame
@@ -4382,6 +4379,7 @@ meta_window_unshade (MetaWindow  *window,
    {
      window->shaded = FALSE;
      meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+      meta_window_frame_size_changed (window);

      /* focus the window */
      meta_topic (META_DEBUG_FOCUS,
@@ -5120,7 +5118,6 @@ meta_window_move_resize_internal (MetaWindow          *window,
  if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION))
    {
      meta_window_constrain (window,
-                             window->frame ? &borders : NULL,
                             flags,
                             gravity,
                             &old_rect,
@@ -5672,23 +5669,10 @@ meta_window_move_frame (MetaWindow  *window,
                  int          root_x_nw,
                  int          root_y_nw)
 {
-  int x = root_x_nw;
-  int y = root_y_nw;
+  MetaRectangle rect = { root_x_nw, root_y_nw, 0, 0 };

-  if (window->frame)
-    {
-      MetaFrameBorders borders;
-      meta_frame_calc_borders (window->frame, &borders);
-
-      /* root_x_nw and root_y_nw correspond to where the top of
-       * the visible frame should be. Offset by the distance between
-       * the origin of the window and the origin of the enclosing
-       * window decorations.
-       */
-      x += window->frame->child_x - borders.invisible.left;
-      y += window->frame->child_y - borders.invisible.top;
-    }
-  meta_window_move (window, user_op, x, y);
+  meta_window_frame_rect_to_client_rect (window, &rect, &rect);
+  meta_window_move (window, user_op, rect.x, rect.y);
 }

 static void
@@ -5736,18 +5720,10 @@ meta_window_move_resize_frame (MetaWindow  *window,
                               int          w,
                               int          h)
 {
-  MetaFrameBorders borders;
+  MetaRectangle rect = { root_x_nw, root_y_nw, w, h };
+  meta_window_frame_rect_to_client_rect (window, &rect, &rect);

-  meta_frame_calc_borders (window->frame, &borders);
-  /* offset by the distance between the origin of the window
-   * and the origin of the enclosing window decorations ( + border)
-   */
-  root_x_nw += borders.visible.left;
-  root_y_nw += borders.visible.top;
-  w -= borders.visible.left + borders.visible.right;
-  h -= borders.visible.top + borders.visible.bottom;
-
-  meta_window_move_resize (window, user_op, root_x_nw, root_y_nw, w, h);
+  meta_window_move_resize (window, user_op, rect.x, rect.y, rect.width, rect.height);
 }

 /**
@@ -6060,16 +6036,110 @@ meta_window_get_input_rect (const MetaWindow *window,
 }

 /**
- * meta_window_get_outer_rect:
+ * meta_window_client_rect_to_frame_rect:
+ * @window: a #MetaWindow
+ * @frame_rect: client rectangle in root coordinates
+ * @client_rect: (out): location to store the computed corresponding frame bounds.
+ *
+ * Converts a desired bounds of the client window - what is passed to meta_window_move_resize() -
+ * into the corresponding bounds of the window frame (excluding invisible borders
+ * and client side shadows.)
+ */
+void
+meta_window_client_rect_to_frame_rect (MetaWindow    *window,
+                                       MetaRectangle *frame_rect,
+                                       MetaRectangle *client_rect)
+{
+  if (!client_rect)
+    return;
+
+  *client_rect = *frame_rect;
+
+  /* The support for G_MAXINT here to mean infinity is a convenience for
+   * constraints.c:get_size_limits() and not something that we provide
+   * in other locations or document.
+   */
+  if (window->frame)
+    {
+      MetaFrameBorders borders;
+      meta_frame_calc_borders (window->frame, &borders);
+
+      client_rect->x -= borders.visible.left;
+      client_rect->y -= borders.visible.top;
+      if (client_rect->width != G_MAXINT)
+        client_rect->width += borders.visible.left + borders.visible.right;
+      if (client_rect->height != G_MAXINT)
+        client_rect->height += borders.visible.top  + borders.visible.bottom;
+    }
+  else
+    {
+      if (window->has_custom_frame_extents)
+        {
+          const GtkBorder *extents = &window->custom_frame_extents;
+          client_rect->x += extents->left;
+          client_rect->y += extents->top;
+          if (client_rect->width != G_MAXINT)
+            client_rect->width -= extents->left + extents->right;
+          if (client_rect->height != G_MAXINT)
+            client_rect->height -= extents->top + extents->bottom;
+        }
+    }
+}
+
+/**
+ * meta_window_frame_rect_to_client_rect:
+ * @window: a #MetaWindow
+ * @frame_rect: desired frame bounds for the window
+ * @client_rect: (out): location to store the computed corresponding client rectangle.
+ *
+ * Converts a desired frame bounds for a window into the bounds of the client
+ * window - what is passed to meta_window_move_resize().
+ */
+void
+meta_window_frame_rect_to_client_rect (MetaWindow    *window,
+                                       MetaRectangle *frame_rect,
+                                       MetaRectangle *client_rect)
+{
+  if (!client_rect)
+    return;
+
+  *client_rect = *frame_rect;
+
+  if (window->frame)
+    {
+      MetaFrameBorders borders;
+      meta_frame_calc_borders (window->frame, &borders);
+
+      client_rect->x += borders.visible.left;
+      client_rect->y += borders.visible.top;
+      client_rect->width  -= borders.visible.left + borders.visible.right;
+      client_rect->height -= borders.visible.top  + borders.visible.bottom;
+    }
+  else
+    {
+      if (window->has_custom_frame_extents)
+        {
+          const GtkBorder *extents = &window->custom_frame_extents;
+          client_rect->x -= extents->left;
+          client_rect->y -= extents->top;
+          client_rect->width += extents->left + extents->right;
+          client_rect->height += extents->top + extents->bottom;
+        }
+    }
+}
+
+/**
+ * meta_window_get_frame_rect:
 * @window: a #MetaWindow
 * @rect: (out): pointer to an allocated #MetaRectangle
 *
- * Gets the rectangle that bounds @window that is responsive to mouse events.
- * This includes only what is visible; it doesn't include any extra reactive
- * area we add to the edges of windows.
+ * Gets the rectangle that bounds @window that is what the user thinks of
+ * as the edge of the window. This doesn't include any extra reactive
+ * area that we or the client adds to the window, or any area that the
+ * client adds to draw a client-side shadow.
 */
 void
-meta_window_get_outer_rect (const MetaWindow *window,
+meta_window_get_frame_rect (const MetaWindow *window,
                            MetaRectangle    *rect)
 {
  if (window->frame)
@@ -6098,6 +6168,25 @@ meta_window_get_outer_rect (const MetaWindow *window,
    }
 }

+/**
+ * meta_window_get_outer_rect:
+ * @window: a #MetaWindow
+ * @rect: (out): pointer to an allocated #MetaRectangle
+ *
+ * Gets the rectangle that bounds @window that is what the user thinks of
+ * as the edge of the window. This doesn't include any extra reactive
+ * area that we or the client adds to the window, or any area that the
+ * client adds to draw a client-side shadow.
+ *
+ * Deprecated: 3.10: Use meta_window_get_frame_rect() instead.
+ */
+void
+meta_window_get_outer_rect (const MetaWindow *window,
+                            MetaRectangle    *rect)
+{
+  meta_window_get_frame_rect (window, rect);
+}
+
 const char*
 meta_window_get_startup_id (MetaWindow *window)
 {
@@ -6319,6 +6408,7 @@ window_stick_impl (MetaWindow  *window)
   * toggled back off.
   */
  window->on_all_workspaces_requested = TRUE;
+  meta_window_frame_size_changed (window);
  meta_window_update_on_all_workspaces (window);

  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
@@ -6333,6 +6423,7 @@ window_unstick_impl (MetaWindow  *window)
  /* Revert to window->workspaces */

  window->on_all_workspaces_requested = FALSE;
+  meta_window_frame_size_changed (window);
  meta_window_update_on_all_workspaces (window);

  /* We change ourselves to the active workspace, since otherwise you'd get
@@ -7408,6 +7499,7 @@ static void
 meta_window_appears_focused_changed (MetaWindow *window)
 {
  set_net_wm_state (window);
+  meta_window_frame_size_changed (window);

  g_object_notify (G_OBJECT (window), "appears-focused");

@@ -8584,6 +8676,13 @@ meta_window_type_changed (MetaWindow *window)
  g_object_thaw_notify (object);
 }

+void
+meta_window_frame_size_changed (MetaWindow *window)
+{
+  if (window->frame)
+    meta_frame_clear_cached_borders (window->frame);
+}
+
 static void
 set_allowed_actions_hint (MetaWindow *window)
 {
@@ -8786,18 +8885,13 @@ recalc_window_features (MetaWindow *window)

  if (window->has_maximize_func)
    {
-      MetaRectangle work_area;
-      MetaFrameBorders borders;
-      int min_frame_width, min_frame_height;
+      MetaRectangle work_area, client_rect;

      meta_window_get_work_area_current_monitor (window, &work_area);
-      meta_frame_calc_borders (window->frame, &borders);
+      meta_window_frame_rect_to_client_rect (window, &work_area, &client_rect);

-      min_frame_width = window->size_hints.min_width + borders.visible.left + borders.visible.right;
-      min_frame_height = window->size_hints.min_height + borders.visible.top + borders.visible.bottom;
-
-      if (min_frame_width >= work_area.width ||
-          min_frame_height >= work_area.height)
+      if (window->size_hints.min_width >= client_rect.width ||
+          window->size_hints.min_height >= client_rect.height)
        window->has_maximize_func = FALSE;
    }

@@ -8889,6 +8983,8 @@ recalc_window_features (MetaWindow *window)
  if (window->has_resize_func != old_has_resize_func)
    g_object_notify (G_OBJECT (window), "resizeable");

+  meta_window_frame_size_changed (window);
+
  /* FIXME perhaps should ensure if we don't have a shade func,
   * we aren't shaded, etc.
   */
@@ -9165,7 +9261,7 @@ meta_window_show_menu (MetaWindow *window,
 void
 meta_window_shove_titlebar_onscreen (MetaWindow *window)
 {
-  MetaRectangle  outer_rect;
+  MetaRectangle  frame_rect;
  GList         *onscreen_region;
  int            horiz_amount, vert_amount;
  int            newx, newy;
@@ -9177,15 +9273,15 @@ meta_window_shove_titlebar_onscreen (MetaWindow *window)
    return;

  /* Get the basic info we need */
-  meta_window_get_outer_rect (window, &outer_rect);
+  meta_window_get_frame_rect (window, &frame_rect);
  onscreen_region = window->screen->active_workspace->screen_region;

  /* Extend the region (just in case the window is too big to fit on the
   * screen), then shove the window on screen, then return the region to
   * normal.
   */
-  horiz_amount = outer_rect.width;
-  vert_amount  = outer_rect.height;
+  horiz_amount = frame_rect.width;
+  vert_amount  = frame_rect.height;
  meta_rectangle_expand_region (onscreen_region,
                                horiz_amount,
                                horiz_amount,
@@ -9193,15 +9289,15 @@ meta_window_shove_titlebar_onscreen (MetaWindow *window)
                                vert_amount);
  meta_rectangle_shove_into_region(onscreen_region,
                                   FIXED_DIRECTION_X,
-                                   &outer_rect);
+                                   &frame_rect);
  meta_rectangle_expand_region (onscreen_region,
                                -horiz_amount,
                                -horiz_amount,
                                0,
                                -vert_amount);

-  newx = outer_rect.x + window->frame->child_x;
-  newy = outer_rect.y + window->frame->child_y;
+  newx = frame_rect.x + window->frame->child_x;
+  newy = frame_rect.y + window->frame->child_y;
  meta_window_move_resize (window,
                           FALSE,
                           newx,
@@ -9226,7 +9322,7 @@ meta_window_titlebar_is_onscreen (MetaWindow *window)
    return FALSE;

  /* Get the rectangle corresponding to the titlebar */
-  meta_window_get_outer_rect (window, &titlebar_rect);
+  meta_window_get_frame_rect (window, &titlebar_rect);
  titlebar_rect.height = window->frame->child_y;

  /* Run through the spanning rectangles for the screen and see if one of
@@ -10003,7 +10099,8 @@ meta_window_handle_mouse_grab_op_event (MetaWindow         *window,
  switch (event->type)
    {
    case CLUTTER_BUTTON_RELEASE:
-      if (event->button.button == 1)
+      if (event->button.button == 1 ||
+          event->button.button == (unsigned int) meta_prefs_get_mouse_button_resize ())
        {
          meta_display_check_threshold_reached (window->display,
                                                event->button.x,
@@ -10455,7 +10552,7 @@ warp_grab_pointer (MetaWindow          *window,
  /* We may not have done begin_grab_op yet, i.e. may not be in a grab
   */

-  meta_window_get_outer_rect (window, &rect);
+  meta_window_get_frame_rect (window, &rect);

  switch (grab_op)
    {
@@ -10794,7 +10891,7 @@ meta_window_set_demands_attention (MetaWindow *window)
    }
  else
    {
-      meta_window_get_outer_rect (window, &candidate_rect);
+      meta_window_get_frame_rect (window, &candidate_rect);

      /* The stack is sorted with the top windows first. */

@@ -10805,7 +10902,7 @@ meta_window_set_demands_attention (MetaWindow *window)

          if (meta_window_located_on_workspace (other_window, window->workspace))
            {
-              meta_window_get_outer_rect (other_window, &other_rect);
+              meta_window_get_frame_rect (other_window, &other_rect);

              if (meta_rectangle_overlap (&candidate_rect, &other_rect))
                {
@@ -11511,8 +11608,8 @@ meta_window_compute_tile_match (MetaWindow *window)
          bottommost = match;
        }

-      meta_window_get_outer_rect (bottommost, &bottommost_rect);
-      meta_window_get_outer_rect (topmost, &topmost_rect);
+      meta_window_get_frame_rect (bottommost, &bottommost_rect);
+      meta_window_get_frame_rect (topmost, &topmost_rect);
      /*
       * If there's a window stacked in between which is partially visible
       * behind the topmost tile we don't consider the tiles to match.
@@ -11526,7 +11623,7 @@ meta_window_compute_tile_match (MetaWindow *window)
              meta_window_get_workspace (above) != meta_window_get_workspace (window))
            continue;

-          meta_window_get_outer_rect (above, &above_rect);
+          meta_window_get_frame_rect (above, &above_rect);

          if (meta_rectangle_overlap (&above_rect, &bottommost_rect) &&
              meta_rectangle_overlap (&above_rect, &topmost_rect))
--- a/src/meta/atomnames.h
+++ b/src/meta/atomnames.h
@@ -82,6 +82,7 @@ item(VERSION)
 item(ATOM_PAIR)
 item(BACKLIGHT)
 item(_XKB_RULES_NAMES)
+item(hotplug_mode_update)

 /* Oddities: These are used, and we need atoms for them,
 * but when we need all _NET_WM hints (i.e. when we're making
--- a/src/meta/prefs.h
+++ b/src/meta/prefs.h
@@ -248,6 +248,7 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
 * @META_KEYBINDING_ACTION_LOWER: FILLME 
 * @META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY: FILLME 
 * @META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY: FILLME 
+ * @META_KEYBINDING_ACTION_ALWAYS_ON_TOP: FILLME 
 * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW: FILLME 
 * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE: FILLME 
 * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_SW: FILLME 
@@ -339,6 +340,7 @@ typedef enum _MetaKeyBindingAction
  META_KEYBINDING_ACTION_RAISE,
  META_KEYBINDING_ACTION_LOWER,
  META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY,
+  META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
  META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY,
  META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW,
  META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE,
--- a/src/meta/window.h
+++ b/src/meta/window.h
@@ -110,7 +110,17 @@ gboolean meta_window_is_override_redirect (MetaWindow *window);
 gboolean meta_window_is_skip_taskbar (MetaWindow *window);
 MetaRectangle *meta_window_get_rect (MetaWindow *window);
 void meta_window_get_input_rect (const MetaWindow *window, MetaRectangle *rect);
-void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect);
+
+void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect);
+void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect) G_GNUC_DEPRECATED;
+
+void meta_window_client_rect_to_frame_rect (MetaWindow    *window,
+                                            MetaRectangle *frame_rect,
+                                            MetaRectangle *client_rect);
+void meta_window_frame_rect_to_client_rect (MetaWindow    *window,
+                                            MetaRectangle *frame_rect,
+                                            MetaRectangle *client_rect);
+
 MetaScreen *meta_window_get_screen (MetaWindow *window);
 MetaDisplay *meta_window_get_display (MetaWindow *window);
 Window meta_window_get_xwindow (MetaWindow *window);
--- a/src/wayland/meta-wayland-keyboard.c
+++ b/src/wayland/meta-wayland-keyboard.c
@@ -522,6 +522,8 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
      serial = wl_display_next_serial (display);
      wl_keyboard_send_leave (resource, serial, keyboard->focus->resource);
      wl_list_remove (&keyboard->focus_listener.link);
+
+      meta_wayland_surface_focused_unset (keyboard->focus);
    }

  resource = find_resource_for_surface (&keyboard->resource_list, surface);
@@ -558,6 +560,8 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
 	}
      wl_resource_add_destroy_listener (resource, &keyboard->focus_listener);
      keyboard->focus_serial = serial;
+
+      meta_wayland_surface_focused_set (surface);
    }

  keyboard->focus_resource = resource;
--- a/src/wayland/meta-wayland-pointer.c
+++ b/src/wayland/meta-wayland-pointer.c
@@ -49,6 +49,7 @@

 #include "meta-wayland-pointer.h"
 #include "meta-wayland-private.h"
+#include "xdg-shell-server-protocol.h"

 #include <string.h>

@@ -537,9 +538,14 @@ meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer)

  wl_list_for_each_safe (popup, tmp, &popup_grab->all_popups, link)
    {
-      MetaWaylandSurfaceExtension *shell_surface = popup->surface->shell_surface;
+      MetaWaylandSurfaceExtension *shell_surface = popup->surface->xdg_surface;
+      struct wl_client *client = wl_resource_get_client (shell_surface->resource);
+      struct wl_display *display = wl_client_get_display (client);
+      uint32_t serial;

-      wl_shell_surface_send_popup_done (shell_surface->resource);
+      serial = wl_display_next_serial (display);
+
+      xdg_popup_send_popup_done (shell_surface->resource, serial);
      wl_list_remove (&popup->surface_destroy_listener.link);
      wl_list_remove (&popup->link);
      g_slice_free (MetaWaylandPopup, popup);
--- a/src/wayland/meta-wayland-private.h
+++ b/src/wayland/meta-wayland-private.h
@@ -107,5 +107,7 @@ MetaWaylandBuffer *     meta_wayland_buffer_from_resource       (struct wl_resou
 void                    meta_wayland_buffer_reference           (MetaWaylandBufferReference *ref,
 								 MetaWaylandBuffer          *buffer);

+void                    meta_wayland_compositor_update          (MetaWaylandCompositor *compositor,
+                                                                 const ClutterEvent    *event);

 #endif /* META_WAYLAND_PRIVATE_H */
--- a/src/wayland/meta-wayland-seat.c
+++ b/src/wayland/meta-wayland-seat.c
@@ -51,14 +51,7 @@ static void
 pointer_unmap_sprite (MetaWaylandSeat *seat)
 {
  if (seat->cursor_tracker)
-    {
-      meta_cursor_tracker_set_buffer (seat->cursor_tracker,
-				      NULL, 0, 0);
-
-      if (seat->current_stage)
-	meta_cursor_tracker_queue_redraw (seat->cursor_tracker,
-					  CLUTTER_ACTOR (seat->current_stage));
-    }
+    meta_cursor_tracker_set_window_cursor (seat->cursor_tracker, NULL, 0, 0);

  if (seat->sprite)
    {
@@ -76,14 +69,10 @@ meta_wayland_seat_update_sprite (MetaWaylandSeat *seat)
    return;

  buffer = seat->sprite->buffer_ref.buffer->resource;
-  meta_cursor_tracker_set_buffer (seat->cursor_tracker,
-				  buffer,
-				  seat->hotspot_x,
-				  seat->hotspot_y);
-
-  if (seat->current_stage)
-    meta_cursor_tracker_queue_redraw (seat->cursor_tracker,
-				      CLUTTER_ACTOR (seat->current_stage));
+  meta_cursor_tracker_set_window_cursor (seat->cursor_tracker,
+                                         buffer,
+                                         seat->hotspot_x,
+                                         seat->hotspot_y);
 }

 static void
@@ -257,11 +246,6 @@ notify_motion (MetaWaylandSeat    *seat,
               const ClutterEvent *event)
 {
  MetaWaylandPointer *pointer = &seat->pointer;
-  float x, y;
-
-  clutter_event_get_coords (event, &x, &y);
-  pointer->x = wl_fixed_from_double (x);
-  pointer->y = wl_fixed_from_double (y);

  meta_wayland_seat_repick (seat, event);

@@ -280,12 +264,22 @@ handle_button_event (MetaWaylandSeat    *seat,
                     const ClutterEvent *event)
 {
  MetaWaylandPointer *pointer = &seat->pointer;
+  gboolean implicit_grab;

  notify_motion (seat, event);

+  implicit_grab = (event->type == CLUTTER_BUTTON_PRESS) && (pointer->button_count == 1);
+  if (implicit_grab)
+    {
+      pointer->grab_button = clutter_event_get_button (event);
+      pointer->grab_time = clutter_event_get_time (event);
+      pointer->grab_x = pointer->x;
+      pointer->grab_y = pointer->y;
+    }
+
  pointer->grab->interface->button (pointer->grab, event);

-  if (pointer->button_count == 1)
+  if (implicit_grab)
    pointer->grab_serial = wl_display_get_serial (seat->display);
 }

@@ -353,10 +347,16 @@ count_buttons (const ClutterEvent *event)
  return count;
 }

-gboolean
-meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
-                                const ClutterEvent *event)
+void
+meta_wayland_seat_update_pointer (MetaWaylandSeat    *seat,
+                                  const ClutterEvent *event)
 {
+  float x, y;
+
+  clutter_event_get_coords (event, &x, &y);
+  seat->pointer.x = wl_fixed_from_double (x);
+  seat->pointer.y = wl_fixed_from_double (y);
+
  seat->pointer.button_count = count_buttons (event);

  if (seat->cursor_tracker)
@@ -366,12 +366,14 @@ meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
 					   wl_fixed_to_int (seat->pointer.y));

      if (seat->pointer.current == NULL)
-	meta_cursor_tracker_revert_root (seat->cursor_tracker);
-
-      meta_cursor_tracker_queue_redraw (seat->cursor_tracker,
-                                        CLUTTER_ACTOR (event->any.stage));
+	meta_cursor_tracker_unset_window_cursor (seat->cursor_tracker);
    }
+}

+gboolean
+meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
+                                const ClutterEvent *event)
+{
  switch (event->type)
    {
    case CLUTTER_MOTION:
@@ -437,12 +439,6 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,

      surface = window->surface;
    }
-  else if (META_IS_SHAPED_TEXTURE (actor))
-    {
-      MetaShapedTexture *shaped_texture = META_SHAPED_TEXTURE (actor);
-
-      surface = meta_shaped_texture_get_wayland_surface (shaped_texture);
-    }

  pointer->current = surface;
  if (surface != pointer->focus)
--- a/src/wayland/meta-wayland-seat.h
+++ b/src/wayland/meta-wayland-seat.h
@@ -77,6 +77,10 @@ MetaWaylandSeat *
 meta_wayland_seat_new (struct wl_display *display,
 		       gboolean           is_native);

+void
+meta_wayland_seat_update_pointer (MetaWaylandSeat *seat,
+                                  const ClutterEvent *event);
+
 gboolean
 meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
                                const ClutterEvent *event);
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
--- a/src/wayland/meta-wayland-surface.h
+++ b/src/wayland/meta-wayland-surface.h
@@ -64,31 +64,19 @@ typedef struct

  /* wl_surface.frame */
  struct wl_list frame_callback_list;
-} MetaWaylandDoubleBufferedState;
-
-typedef enum {
-  META_WAYLAND_SURFACE_TOPLEVEL = 0,
-  META_WAYLAND_SURFACE_MAXIMIZED,
-  META_WAYLAND_SURFACE_FULLSCREEN,
-  META_WAYLAND_SURFACE_POPUP,
-} MetaWaylandSurfaceType;
-
-typedef struct
-{
-  MetaWaylandSurfaceType initial_type;
-  struct wl_resource *transient_for;
-  int x, y;

+  /* xdg_surface */
  char *title;
-  char *wm_class;
+  char *app_id;

+  /* gtk_surface */
  char *gtk_application_id;
  char *gtk_unique_bus_name;
  char *gtk_app_menu_path;
  char *gtk_menubar_path;
  char *gtk_application_object_path;
  char *gtk_window_object_path;
-} MetaWaylandSurfaceInitialState;
+} MetaWaylandDoubleBufferedState;

 typedef struct
 {
@@ -103,15 +91,11 @@ struct _MetaWaylandSurface
  MetaWaylandCompositor *compositor;
  MetaWaylandBufferReference buffer_ref;
  MetaWindow *window;
-  MetaWaylandSurfaceExtension *shell_surface;
+  MetaWaylandSurfaceExtension *xdg_surface;
  MetaWaylandSurfaceExtension *gtk_surface;

  /* All the pending state, that wl_surface.commit will apply. */
  MetaWaylandDoubleBufferedState pending;
-
-  /* All the initial state, that wl_shell_surface.set_* will apply
-     (through meta_window_new_for_wayland) */
-  MetaWaylandSurfaceInitialState *initial_state;
 };

 void                meta_wayland_init_shell     (MetaWaylandCompositor *compositor);
@@ -122,12 +106,12 @@ MetaWaylandSurface *meta_wayland_surface_create (MetaWaylandCompositor *composit
 						 guint32                version);
 void                meta_wayland_surface_free   (MetaWaylandSurface    *surface);

-void                meta_wayland_surface_set_initial_state (MetaWaylandSurface *surface,
-							    MetaWindow         *window);
-
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
 							   int                 width,
 							   int                 height,
 							   int                 edges);

+void                meta_wayland_surface_focused_set (MetaWaylandSurface *surface);
+void                meta_wayland_surface_focused_unset (MetaWaylandSurface *surface);
+
 #endif
--- a/src/wayland/meta-wayland-versions.h
+++ b/src/wayland/meta-wayland-versions.h
@@ -37,23 +37,23 @@
 /* Global/master objects (version exported by wl_registry and negotiated through bind) */
 #define META_WL_COMPOSITOR_VERSION          3
 #define META_WL_DATA_DEVICE_MANAGER_VERSION 1
-#define META_WL_SHELL_VERSION               1
 #define META_WL_SEAT_VERSION                2 /* 3 not implemented yet */
 #define META_WL_OUTPUT_VERSION              2
 #define META_XSERVER_VERSION                1
 #define META_GTK_SHELL_VERSION              1
+#define META_XDG_SHELL_VERSION              1

 /* Slave objects (version inherited from a master object) */
 #define META_WL_DATA_OFFER_VERSION          1 /* from wl_data_device */
 #define META_WL_DATA_SOURCE_VERSION         1 /* from wl_data_device */
 #define META_WL_DATA_DEVICE_VERSION         1 /* from wl_data_device_manager */
-#define META_WL_SHELL_SURFACE_VERSION       1 /* from wl_shell */
 #define META_WL_SURFACE_VERSION             3 /* from wl_compositor */
 #define META_WL_POINTER_VERSION             2 /* from wl_seat; 3 not implemented yet */
 #define META_WL_KEYBOARD_VERSION            2 /* from wl_seat; 3 not implemented yet */
 #define META_WL_TOUCH_VERSION               0 /* from wl_seat; wl_touch not supported */
 #define META_WL_REGION_VERSION              1 /* from wl_compositor */
 #define META_GTK_SURFACE_VERSION            1 /* from gtk_shell */
+#define META_XDG_SURFACE_VERSION            1 /* from xdg_shell */

 /* The first version to implement a specific event */
 #define META_WL_SEAT_HAS_NAME               2
--- a/src/wayland/meta-wayland.c
+++ b/src/wayland/meta-wayland.c
@@ -533,14 +533,18 @@ stage_destroy_cb (void)
  meta_quit (META_EXIT_SUCCESS);
 }

-static void
-reset_idletimes (const ClutterEvent *event)
+void
+meta_wayland_compositor_update (MetaWaylandCompositor *compositor,
+                                const ClutterEvent    *event)
 {
  ClutterInputDevice *device, *source_device;
  MetaIdleMonitor *core_monitor, *device_monitor;
  int device_id;

  device = clutter_event_get_device (event);
+  if (device == NULL)
+    return;
+
  device_id = clutter_input_device_get_device_id (device);

  core_monitor = meta_idle_monitor_get_core ();
@@ -556,14 +560,23 @@ reset_idletimes (const ClutterEvent *event)
      device_monitor = meta_idle_monitor_get_for_device (device_id);
      meta_idle_monitor_reset_idletime (device_monitor);
    }
+
+  switch (event->type)
+    {
+    case CLUTTER_MOTION:
+    case CLUTTER_BUTTON_PRESS:
+    case CLUTTER_BUTTON_RELEASE:
+    case CLUTTER_SCROLL:
+      meta_wayland_seat_update_pointer (compositor->seat, event);
+    default:
+      break;
+    }
 }

 gboolean
 meta_wayland_compositor_handle_event (MetaWaylandCompositor *compositor,
                                      const ClutterEvent    *event)
 {
-  reset_idletimes (event);
-
  return meta_wayland_seat_handle_event (compositor->seat, event);
 }

--- a/src/wayland/meta-xwayland.c
+++ b/src/wayland/meta-xwayland.c
@@ -48,11 +48,6 @@ xserver_set_window_id (struct wl_client *client,
  window  = meta_display_lookup_x_window (display, xid);
  if (window)
    {
-      MetaWindowActor *window_actor =
-        META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-
-      meta_window_actor_set_wayland_surface (window_actor, surface);
-
      surface->window = window;
      window->surface = surface;
Author	SHA1	Message	Date
Florian Müllner	a6ebc70170	Bump version to 3.11.2 Update NEWS.	2013-11-19 20:15:13 +01:00
Florian Müllner	3025cb7c48	display: Remove unused variables	2013-11-19 20:12:51 +01:00
Florian Müllner	17f48baf3a	display: Tweak code to work around a compiler warning The compiler is not quite smart enough to figure out that the condition for setting the "compositor" variable matches a later condition for accessing it, so express this in a way the compiler will understand.	2013-11-19 20:08:46 +01:00
Florian Müllner	333661a9d8	stack: Drop unused code Since commit `2b2b2d3191` the code is unused and triggers a compiler error with -Werror=unused-but-set-variable.	2013-11-19 20:08:46 +01:00
Owen W. Taylor	b9da43b753	Rename meta_window_get_outer_rect() to meta_window_get_frame_rect() For clarity, rename meta_window_get_outer_rect() to match terminology we use elsewhere. The old function is left as a deprecated compatibility wrapper.	2013-11-19 14:04:16 -05:00
Owen W. Taylor	097ee776c7	Stop passing around MetaFrameBorders Instead of passing around MetaFrameBorders, compute it when we need it. This also allows us to know that we are using MetaFrameBorders only for windows with frames (where it is meaningful) and not for frameless windows, which can have custom borders which we need to interpret differently. https://bugzilla.gnome.org/show_bug.cgi?id=707194	2013-11-19 14:04:16 -05:00
Owen W. Taylor	a4a8f1f863	MetaFrame: Cache borders Cache the computed border size so we can fetch the border size at any time without worrying that we'll be spending too much time in the theme code (in some cases we might allocate a PangoFontDescription or do other significant work.) The main effort here is clearing the cache when various bits of window state change that could potentially affect the computed borders. https://bugzilla.gnome.org/show_bug.cgi?id=707194	2013-11-19 14:04:16 -05:00
Owen W. Taylor	f36a627330	Use utility functions to convert between frame and client rectangles There are extensive places in the code where we convert between the client rectangle and the frame rectangle. Instead of manually doing it use new helper functions on MetaWindow and the existing meta_window_get_outer_rect(). This fixes a number of bugs where the computation was being done incorrectly, most of these bugs are with the recently added custom frame extents, but some relate to invisible borders or even simply to confusion between the window and frame rectangle. Switch the placement code to place the frame rectangle rather than the client window - this simplifies things considerably. https://bugzilla.gnome.org/show_bug.cgi?id=707194	2013-11-19 14:04:16 -05:00
Giovanni Campagna	a1087c3f30	constraints: account for decorations when positioning modal dialogs What we want to achieve is that the dialog is visually centered on the parent, including the decorations for both, and making sure that CSD/frame_extents are respected. https://bugzilla.gnome.org/show_bug.cgi?id=707194	2013-11-19 14:04:16 -05:00
Jasper St. Pierre	aad275b9a2	window: Fix signedness warning	2013-11-19 14:03:09 -05:00
Jasper St. Pierre	f0397eab94	keybindings: Fix warning keybinding handlers now take a ClutterEvent, not an XIDeviceEvent	2013-11-19 14:02:42 -05:00
Jasper St. Pierre	392e224831	Fix build Forgot to delete the line above it when cherry-picking... oops.	2013-11-19 14:01:18 -05:00
Lionel Landwerlin	6867d44573	window: don't ignore resize button release event for move/resize actions https://bugzilla.gnome.org/show_bug.cgi?id=710251	2013-11-19 13:55:17 -05:00
Jasper St. Pierre	a841fff2ac	screen: Laters are not GSources This warns with the new GLib when we destroy the screen. https://bugzilla.gnome.org/show_bug.cgi?id=711731	2013-11-19 13:52:56 -05:00
Jasper St. Pierre	26aa10a974	compositor: Clean up comment So it seems that we were intentionally delaying the output window, although I wonder why...	2013-11-19 13:52:45 -05:00
Jasper St. Pierre	f6144082b1	compositor: Initialize the plugin manager after initializing the output window Plugins like gnome-shell may want to grab the output window immediately before bouncing back to the mainloop.	2013-11-19 13:52:13 -05:00
Marc-André Lureau	957513242c	xrandr: use "hotplug_mode_update" property Use the "hotplug_mode_update" connector property indicating that the screen settings should be updated: get a new preferred mode on hotplug events to handle dynamic guest resizing (where you resize the host window and the guest resizes with it). https://bugzilla.gnome.org/show_bug.cgi?id=711216	2013-11-19 13:50:15 -05:00
Florian Müllner	17fd25e216	doc: Fix file globs Any files matching the previously used globs are no longer distributed, breaking distcheck. Match the actual sources in compositor/, core/, meta/ and ui/ instead.	2013-11-19 13:48:40 -05:00
Sindhu S	e91268a250	Add keyboard shortcut for Always on Top, bug 704831	2013-11-19 13:48:35 -05:00
Jasper St. Pierre	82cb4e8267	display: Don't focus the no-focus-window when sending WM_TAKE_FOCUS to a globally active window Clients like on-screen keyboards try not to take focus when the user clicks on their window by setting the Input hint to false. However, due to GTK+ and GDK bugs, the public API for setting the Input hint to false don't remove WM_TAKE_FOCUS from WM_PROTOCOLS, unintentionally putting them into Globally Active mode. These clients also expect that since they don't want to take focus, they want the focus to remain on the existing window. In this case, for clients like on-screen keyboards, it's so they can send synthesized keyboard events to the focused window. https://bugzilla.gnome.org/show_bug.cgi?id=710296	2013-11-19 13:46:34 -05:00
Rico Tzschichholz	68eb87cc58	build: Make sure built-sources are introspected as needed	2013-11-19 13:46:22 -05:00
Rico Tzschichholz	f3e52d5b18	build: Do not ship generated source-files in tarball	2013-11-19 13:46:21 -05:00
Jasper St. Pierre	2b2b2d3191	stack: Don't take a weak pointer Since this is stored in an array full of data that will be copied around, we can't rely on pointer addresses for every item in a stack not changing. I don't see any reason that we even have a weak pointer, either. This code looks safe to me without it.	2013-11-19 13:10:45 -05:00
Jasper St. Pierre	9461c612de	wayland-surface: Only spew about set_buffer_scale if it's not 1 ... to stop the GTK+ spam on my system.	2013-11-19 13:00:34 -05:00
Jasper St. Pierre	f0280a8868	wayland-surface: Allow setting a NULL buffer to effectively unmap	2013-11-19 12:47:50 -05:00
Jasper St. Pierre	c749f7b6fb	Revert "ff" This reverts commit `74462133ca`. Pushed by accident, if it wasn't obvious...	2013-11-19 11:22:49 -05:00
Jasper St. Pierre	74462133ca	ff	2013-11-18 21:35:30 -05:00
Jonas Ådahl	7c45d6594c	MetaWindowActor: Use allocation changes signals for size changed signals When a Wayland compositor, simply rely on the clutter actor allocation changed signal to sync geometry and emit window actor size changed signals. Attaching a wl_buffer to a MetaShapedTexture will signal allocation changed on the corresponding MetaSurfaceActor, which the MetaWindowActor is listening to. Signed-off-by: Jonas Ådahl <jadahl@gmail.com> https://bugzilla.gnome.org/show_bug.cgi?id=705502	2013-11-18 21:19:01 -05:00
Jonas Ådahl	ea916b6c49	Introduce MetaSurfaceActor for drawing MetaWindowActor content Instead of having MetaWindowActor only have one single MetaShapedTexture as actor drawing its content, introduce a new abstract MetaSurfaceActor that takes care of drawing. This is one step in the direction to decouple MetaWaylandSurface with a MetaWindow and MetaWindowActor (except for shell/xdg surfaces) in order to finally support subsurfaces like features, or any feature where window is not drawn using a single texture. The first step, implemented in this patch, is to not have MetaWindowActor work directly with a shaped texture. There are still some cases where it simply gets the texture and goes on as before, but this should be changed by either removing the need of going via MetaWindowActor or by adding some generic interface to MetaSurfaceActor that doesn't limit its functionality to one shaped texture. There should be no visible difference nor after this patch, but meta_window_actor_get_texture() and meta_surface_actor_get_texture() should be deprecated when equivalent functionality has been introduced. Signed-off-by: Jonas Ådahl <jadahl@gmail.com> https://bugzilla.gnome.org/show_bug.cgi?id=705502	2013-11-18 21:19:00 -05:00
Jasper St. Pierre	a02d734243	window-actor: Move all buffer management and damage correction here We want ShapedTexture to be a dumb actor that knows how to pick/paint fairly easily, without any "platform knowledge", so to say...	2013-11-18 21:19:00 -05:00
Jasper St. Pierre	735b736110	shaped-texture: Use the cogl helper methods for fetching shm_buffer contents Rather than doing the set_region ourselves.	2013-11-18 21:19:00 -05:00
Jasper St. Pierre	bbbb9ac53c	display: Make handle_[x]event private	2013-11-18 21:19:00 -05:00
Jasper St. Pierre	8dd97b4998	compositor: Remove outdated comment XWayland no longer redirects windows by default.	2013-11-18 21:18:59 -05:00
Jasper St. Pierre	73a9082062	cursor-tracker: Make ensure_wayland_cursor take a ref This fixes a crash in the last commit because that's what I thought this would do. It also simplifies callers drastically...	2013-11-18 19:47:34 -05:00
Jasper St. Pierre	4091f5493d	cursor-tracker: Force the grab cursor on grab ops This makes window moving have a 'window move' cursor, and similar.	2013-11-18 19:34:24 -05:00
Jasper St. Pierre	d96b053c9d	cursor-tracker: Use a sync methodology for the cursor image Rather than have MetaWaylandSeat do all the state management itself, put the split between the root cursor and the window cursor in the cursor tracker itself. We'll expand this to add a "grab" cursor in the next commit, allowing us to force a cursor on grab operations.	2013-11-18 19:25:47 -05:00
Jasper St. Pierre	1f569bef76	Fix dragging on move/resize grabs We need to use the grab_window for incoming events if we have an active grab.	2013-11-18 18:38:24 -05:00
Jasper St. Pierre	1a88176cc0	keyboard: Fix surface focusing Bad rebase...	2013-11-18 16:52:10 -05:00
Jasper St. Pierre	662c9729bc	trivial: window-actor: Fix formatting	2013-11-17 19:16:30 -05:00
Jasper St. Pierre	56a0dd6b2c	trivial: shaped-texture: Move set_base_texture to set_cogl_texture A simple code cleanup.	2013-11-17 19:16:29 -05:00
Jasper St. Pierre	9dc6028b3d	trivial: shaped-texture: Fix documentation typo	2013-11-17 19:16:29 -05:00
Jasper St. Pierre	932e913d88	wayland-surface: Fix formatting	2013-11-14 21:49:51 -05:00
Jasper St. Pierre	b72315e27a	wayland-surface: Support xdg_surface_resize as well	2013-11-14 21:48:39 -05:00
Jasper St. Pierre	3c7cd1f38c	wayland-surface: Use begin_grab_op for move grabs	2013-11-14 21:34:20 -05:00
Jasper St. Pierre	1946c548bf	Bump required Clutter version	2013-11-14 14:40:43 -05:00
Jasper St. Pierre	cf181fe109	display: Adapt to new clutter event filter API	2013-11-14 14:34:53 -05:00
Rui Matos	63b9110f93	wayland: Update internal wayland state unconditionally Things like idle times and the cursor position need to be updated even if there's a mutter grab in effect. https://bugzilla.gnome.org/show_bug.cgi?id=712247	2013-11-13 21:55:05 +01:00
Rui Matos	ae44bff0b1	display: Without a grab op let events go through clutter too We want events to reach clutter no only when there a compositor modal grab but also when no grab op is in effect. https://bugzilla.gnome.org/show_bug.cgi?id=712247	2013-11-13 21:55:04 +01:00
Jasper St. Pierre	23ba3e527f	wayland: Support alternative focus modes like focus-follows-mouse Use the existing code for MetaWindow focus-follows-mouse to support this.	2013-11-12 16:53:15 -05:00
Jasper St. Pierre	08df9bf559	display: Use MetaWindow for auto-raise callbacks This allows us to autoraise Wayland windows... well, except for the XQueryPointer, but we'll replace that soon.	2013-11-12 16:53:15 -05:00
Jasper St. Pierre	648639fffe	display: Invoke Wayland from the Grand Central Station callback	2013-11-12 16:53:15 -05:00
Jasper St. Pierre	6cc014a941	wayland: Move cursor tracker handling code to meta_wayland_seat_handle_event	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	b7b95123ed	wayland: Drop raise on click too We'll handle this through GCD as well.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	153463790a	wayland: Drop focus on click The native raise-on-click works with Wayland clients through the standard Grand Central Station event handling, with MetaWindow.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	875bbec949	wayland: Drop old hack to synthesize motion events mutter now uses Clutter events for the source of its drag support, so we don't need to synthesize X11 events anymore.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	666e5f1f98	keybindings: Port to Clutter	2013-11-12 16:53:14 -05:00
Neil Roberts	e6790038dd	wayland: Use an event filter instead of the captured event signal In order to see all Clutter events, Mutter was previously installing a signal handler on the ‘captured-event’ signal on the stage and additionally using a signal emission hook to cope with grabs. This changes it to use the new clutter_event_add_filter API so that we can avoid the signal emission hook hack.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	e86c53230f	display: Move the pointer event handling code to work in terms of Clutter events There is now a meta_display_handle_event alongside the meta_display_handle_xevent function which handles events in terms of Clutter events instead of X events. A Clutter event filter is registered so that all Clutter events will pass through this function. The pointer event handling code from the X event version has been moved into this new function and has been modified to use the details from the Clutter event instead of the X event. This is a step towards moving all of the event handling code over to use Clutter events. Based-heavily-on-a-patch-by: Neil Roberts <neil@linux.intel.com>	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	4ea4658abf	display: Split out other event handling as well This vastly simplifies the code in event_callback and allows us to potentially take more of this logic and punt it to Wayland-specific backends.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	58f6ab0a27	display: Split out input event handling This helps with git's diff code by moving all the giant indentation changes, letting us know what's going on better when we move to Clutter for event handling.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	9c0cc664d1	display: Rename filter_out_event to bypass_gtk This clarifies the intent of the variable and makes it match bypass_compositor	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	84d26e31f1	display: Move barrier event processing to barrier.c This puts all the code that's easily ported to Clutter events in one giant switch statement, as Clutter doesn't translate barrier events.	2013-11-12 16:53:14 -05:00
Jasper St. Pierre	64a848fcb7	display: Add a quick out path to handle_xevent This makes the code flow more like the scheme we usually use, and allows us to flatten out the method somewhat.	2013-11-12 16:53:14 -05:00
Neil Roberts	429583ae8b	display: Rename meta_display_handle_event to meta_display_handle_xevent The plan is to make a new version of meta_display_handle_event that will accept Clutter events instead of X events and then gradually move over the events to the new function and finally remove the X version.	2013-11-12 16:53:14 -05:00
Giovanni Campagna	93ae868987	wayland: sync the keymap from X to wayland When X clients change the keyboard map, the also update a property on the root window. We can notice that and rebuild our data structures with the new values, as well as inform the wayland clients. This is a terrible hack, and it's not how we want to implement things in 3.12, but it's enough to have the same keyboard layout in the shell, in X clients and in wayland clients in 3.10, until we decide on the fate of the keyboard g-s-d plugin. https://bugzilla.gnome.org/show_bug.cgi?id=707446	2013-11-12 16:53:13 -05:00
Jasper St. Pierre	72a900787f	wayland: Send xdg_surface_focused_set / xdg_surface_focused_unset	2013-11-12 16:53:13 -05:00
Jasper St. Pierre	7186841db0	wayland-surface: Remove initial_state Just put everything in the double buffered state so it all arrives at the same time; on commit.	2013-11-12 16:53:13 -05:00
Jasper St. Pierre	ab080e3e6b	Add support for xdg-shell Replace our existing support for wl_shell with xdg_shell, the new proposal for how Wayland surfaces should work.	2013-11-12 16:53:13 -05:00
Jasper St. Pierre	ad84aef766	wayland-seat: Fix updating the grab serial We shouldn't update the grab serial if we go from 2 buttons => 1.	2013-11-12 15:52:14 -05:00
Jasper St. Pierre	7908eca579	protocol: Ship gtk-shell.xml	2013-11-08 17:03:10 -05:00
Andreas Heider	237d990dea	mutter-wl: Support setting NULL surface regions. According to the wayland spec (A.14.1.5. wl_surface::set_opaque_region), setting a NULL opaque region is possible and should cause the pending opaque region to be set to empty. This implements the required behavoir. Also fixes set_input_region, which suffered from an analogous bug. Previously the weston-simple-egl demo client caused mutter-wayland to crash with a segfault in meta_wayland_surface_set_opaque_region, with this patch it works as intended. https://bugzilla.gnome.org/show_bug.cgi?id=711518	2013-11-05 18:18:15 -05:00