xdg-shell: Update for new state change mechanism

We're still not properly going through the request system. This
will require a dense investigation of the code, but it will happen
soon...

.gitignore

@@ -79,13 +79,10 @@ src/meta-dbus-xrandr.[ch]
 src/meta-dbus-idle-monitor.[ch]
 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
 doc/reference/*.args
 doc/reference/*.bak

NEWS

@@ -1,3 +1,28 @@
+3.11.5
+======
+* Fix CSD titlebars being placed off-screen [Jasper; #719772]
+* Add support for subsurfaces [Jonas; #705502]
+* Expose MetaWindow:skip-taskbar property [Florian; #723307]
+* Fix legacy tray icons showing up blank [Adel; #721596]
+* Fix configuration of cloned monitors [Adel; #710610]
+* Misc bug fixes and cleanups [Jasper, Adel, Marek, Jonas; #720631, #723468,
+  #720818, #723563, #723564]
+
+Contributors:
+  Jonas Ådahl, Marek Ch, Adel Gadllah, Florian Müllner, Jasper St. Pierre
+
+3.11.4
+======
+* Don't leave focus on windows that are being unmanaged [Owen; #711618]
+* Reduce server grabs [Daniel Drake; #721345, #721709]
+* Improve heuristic to determine display output name [Cosimo Cecchi; #721674]
+* Atomically unmaximize both directions [Jasper; #722108]
+* Misc bug fixes [Debarshi, Andika, Florian; #721517, #721674, #722347]
+
+Contributors:
+  Cosimo Cecchi, Daniel Drake, Florian Müllner, Debarshi Ray, Jasper St. Pierre,
+  Andika Triwidada, Owen W. Taylor
+
 3.11.3
 ======
 * Fix focus issues with external OSKs[Jasper; #715030]

autogen.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 # Run this to generate all the initial makefiles, etc.
 
 srcdir=`dirname $0`

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], [3])
+m4_define([mutter_micro_version], [5])
 
 m4_define([mutter_version],
           [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -212,9 +212,6 @@ fi
 
 MUTTER_PC_MODULES="$MUTTER_PC_MODULES xcursor"
 
-# We always build with wayland enabled
-AC_DEFINE(HAVE_WAYLAND, , [Building with Wayland support])
-
 AC_PATH_PROG([WAYLAND_SCANNER],[wayland-scanner],[no])
 AS_IF([test "x$WAYLAND_SCANNER" = "xno"],
   AC_MSG_ERROR([Could not find wayland-scanner in your PATH, required for parsing wayland extension protocols]))

doc/reference/meta-sections.txt

@@ -96,8 +96,6 @@ meta_compositor_hide_window
 meta_compositor_switch_workspace
 meta_compositor_maximize_window
 meta_compositor_unmaximize_window
-meta_compositor_window_mapped
-meta_compositor_window_unmapped
 meta_compositor_sync_window_geometry
 meta_compositor_set_updates_frozen
 meta_compositor_queue_frame_drawn

protocol/xdg-shell.xml

@@ -43,7 +43,7 @@
 	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"/>
+      <entry name="current" value="2" summary="Always the latest version"/>
     </enum>
 
 
@@ -84,6 +84,28 @@
       <arg name="y" type="int"/>
       <arg name="flags" type="uint"/>
     </request>
+
+    <event name="ping">
+      <description summary="check if the client is alive">
+        The ping event asks the client if it's still alive. Pass the
+        serial specified in the event back to the compositor by sending
+        a "pong" request back with the specified serial.
+
+        Compositors can use this to determine if the client is still
+        alive. It's unspecified what will happen if the client doesn't
+        respond to the ping request, or in what timeframe. Clients should
+        try to respond in a reasonable amount of time.
+      </description>
+      <arg name="serial" type="uint" summary="pass this to the callback"/>
+    </event>
+
+    <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>
   </interface>
 
   <interface name="xdg_surface" version="1">
@@ -124,6 +146,32 @@
       <arg name="parent" type="object" interface="wl_surface" allow-null="true"/>
     </request>
 
+    <request name="set_margin">
+      <description summary="set the visible frame boundaries">
+        This tells the compositor what the visible size of the window
+        should be, so it can use it to determine what borders to use for
+        constrainment and alignment.
+
+        CSD often has invisible areas for decoration purposes, like drop
+        shadows. These "shadow" drawings need to be subtracted out of the
+        normal boundaries of the window when computing where to place
+        windows (e.g. to set this window so it's centered on top of another,
+        or to put it to the left or right of the screen.)
+
+        This value should change as little as possible at runtime, to
+        prevent flicker.
+
+        This value is also ignored when the window is maximized or
+        fullscreen, and assumed to be 0.
+
+        If never called, this value is assumed to be 0.
+      </description>
+      <arg name="left_margin" type="int"/>
+      <arg name="right_margin" type="int"/>
+      <arg name="top_margin" type="int"/>
+      <arg name="bottom_margin" type="int"/>
+    </request>
+
     <request name="set_title">
       <description summary="set surface title">
 	Set a short title for the surface.
@@ -150,22 +198,6 @@
       <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.
@@ -217,12 +249,6 @@
 	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 client is free to dismiss all but the last configure
 	event it received.
 
@@ -230,7 +256,6 @@
 	in surface local coordinates.
       </description>
 
-      <arg name="edges" type="uint"/>
       <arg name="width" type="int"/>
       <arg name="height" type="int"/>
     </event>
@@ -250,128 +275,122 @@
       <arg name="output" type="object" interface="wl_output" allow-null="true"/>
     </request>
 
-    <event name="request_set_fullscreen">
-      <description summary="server requests that the client set fullscreen">
-	Event sent from the compositor to the client requesting that the client
-	goes to a fullscreen state. It's the client job to call set_fullscreen
-	and really trigger the fullscreen state.
+    <enum name="state_type">
+      <description summary="types of state on the surface">
+        The different state values used on the surface. This is designed for
+        state values like maximized, fullscreen. It is paired with the
+        request_change_state event to ensure that both the client and the
+        compositor setting the state can be synchronized.
+
+        States set in this way are double-buffered. They will get applied on
+        the next commit.
+
+        Desktop environments may extend this enum by taking up a range of
+        values and documenting the range they chose in this description.
+        They are not required to document the values for the range that they
+        chose. Ideally, any good extensions from a desktop environment should
+        make its way into standardization into this enum.
+
+        The current reserved ranges are:
+
+        0x0000 - 0x0FFF: xdg-shell core values, documented below.
+        0x1000 - 0x1FFF: GNOME
       </description>
-    </event>
+      <entry name="maximized" value="1" summary="the surface is maximized">
+        A non-zero value indicates the surface is maximized. Otherwise,
+        the surface is unmaximized.
+      </entry>
+      <entry name="fullscreen" value="2" summary="the surface is fullscreen">
+        A non-zero value indicates the surface is fullscreen. Otherwise,
+        the surface is not fullscreen.
+      </entry>
+    </enum>
 
-    <event name="request_unset_fullscreen">
-      <description summary="server requests that the client unset fullscreen">
-	Event sent from the compositor to the client requesting that the client
-	leaves the fullscreen state. It's the client job to call
-	unset_fullscreen and really leave the fullscreen state.
-      </description>
-    </event>
-
-    <request name="set_fullscreen">
-      <description summary="set the surface state as fullscreen">
-	Set the surface as fullscreen.
-
-	After this request, the compositor should send a configure event
-	informing the output size.
-
-	This request informs the compositor that the next attached buffer
-	committed will be in a fullscreen state. The buffer size should be the
-	same size as the size informed in the configure event, if the client
-	doesn't want to leave any empty area.
-
-	In other words: the next attached buffer after set_maximized is the new
-	maximized buffer. And the surface will be positioned at the maximized
-	position on commit.
-
-	A simple way to synchronize and wait for the correct configure event is
-	to use a wl_display.sync request right after the set_fullscreen
-	request. When the sync callback returns, the last configure event
-	received just before it will be the correct one, and should contain the
-	right size for the surface to maximize.
-
-	Setting one state won't unset another state. Use
-	xdg_surface.unset_fullscreen for unsetting it.
+    <request name="request_change_state">
+      <description summary="client requests to change a surface's state">
+        This asks the compositor to change the state. If the compositor wants
+        to change the state, it will send a change_state event with the same
+        state_type, value, and serial, and the event flow continues as if it
+        it was initiated by the compositor.
+
+        If the compositor does not want to change the state, it will send a
+        change_state to the client with the old value of the state.
       </description>
+      <arg name="state_type" type="uint" summary="the state to set"/>
+      <arg name="value" type="uint" summary="the value to change the state to"/>
+      <arg name="serial" type="uint" summary="an event serial">
+        This serial is so the client can know which change_state event corresponds
+        to which request_change_state request it sent out.
+      </arg>
     </request>
 
-    <request name="unset_fullscreen">
-      <description summary="unset the surface state as fullscreen">
-	Unset the surface fullscreen state.
-
-	Same negotiation as set_fullscreen must be used.
+    <event name="change_state">
+      <description summary="compositor wants to change a surface's state">
+        This event tells the client to change a surface's state. The client
+        should respond with an ack_change_state request to the compositor to
+        guarantee that the compositor knows that the client has seen it.
       </description>
-    </request>
 
-    <event name="request_set_maximized">
-      <description summary="server requests that the client set maximized">
-	Event sent from the compositor to the client requesting that the client
-	goes to a maximized state. It's the client job to call set_maximized
-	and really trigger the maximized state.
-      </description>
+      <arg name="state_type" type="uint" summary="the state to set"/>
+      <arg name="value" type="uint" summary="the value to change the state to"/>
+      <arg name="serial" type="uint" summary="a serial for the compositor's own tracking"/>
     </event>
 
-    <event name="request_unset_maximized">
-      <description summary="server requests that the client unset maximized">
-	Event sent from the compositor to the client requesting that the client
-	leaves the maximized state. It's the client job to call unset_maximized
-	and really leave the maximized state.
-      </description>
-    </event>
-
-    <request name="set_maximized">
-      <description summary="set the surface state as maximized">
-	Set the surface as maximized.
-
-	After this request, the compositor will send a configure event
-	informing the output size minus panel and other MW decorations.
-
-	This request informs the compositor that the next attached buffer
-	committed will be in a maximized state. The buffer size should be the
-	same size as the size informed in the configure event, if the client
-	doesn't want to leave any empty area.
-
-	In other words: the next attached buffer after set_maximized is the new
-	maximized buffer. And the surface will be positioned at the maximized
-	position on commit.
-
-	A simple way to synchronize and wait for the correct configure event is
-	to use a wl_display.sync request right after the set_maximized request.
-	When the sync callback returns, the last configure event received just
-	before it will be the correct one, and should contain the right size
-	for the surface to maximize.
-
-	Setting one state won't unset another state. Use
-	xdg_surface.unset_maximized for unsetting it.
-      </description>
-    </request>
-
-    <request name="unset_maximized">
-      <description summary="unset the surface state as maximized">
-	Unset the surface maximized state.
-
-	Same negotiation as set_maximized must be used.
+    <request name="ack_change_state">
+      <description summary="ack a change_state event">
+        When a change_state event is received, a client should then ack it
+        using the ack_change_state request to ensure that the compositor
+        knows the client has seen the event.
+
+        By this point, the state is confirmed, and the next attach should
+        contain the buffer drawn for the new state value.
+
+        The values here need to be the same as the values in the cooresponding
+        change_state event.
       </description>
+      <arg name="state_type" type="uint" summary="the state to set"/>
+      <arg name="value" type="uint" summary="the value to change the state to"/>
+      <arg name="serial" type="uint" summary="a serial to pass to change_state"/>
     </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 summary="minimize the surface">
+        Minimize the surface.
       </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.
+    <event name="activated">
+      <description summary="surface was activated">
+	The activated_set event is sent when this surface has been
+	activated, which means that the surface has user attention.
+        Window decorations should be updated accordingly. You should
+        not use this event for anything but the style of decorations
+        you display, use wl_keyboard.enter and wl_keyboard.leave for
+        determining keyboard focus.
       </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.
+    <event name="deactivated">
+      <description summary="surface was deactivated">
+	The deactivate event is sent when this surface has been
+        deactivated, which means that the surface lost user attention.
+        Window decorations should be updated accordingly. You should
+        not use this event for anything but the style of decorations
+        you display, use wl_keyboard.enter and wl_keyboard.leave for
+        determining keyboard focus.
+      </description>
+    </event>
+
+    <event name="delete">
+      <description summary="surface wants to be closed">
+        The delete event is sent by the compositor when the user
+        wants the surface to be closed. This should be equivalent to
+        the user clicking the close button in client-side decorations,
+        if your application has any...
+
+        This is only a request that the user intends to close your
+        window. The client may choose to ignore this request, or show
+        a dialog to ask the user to save their data...
       </description>
     </event>
   </interface>
@@ -409,22 +428,6 @@
       </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,

src/Makefile.am

@@ -42,13 +42,10 @@ mutter_built_sources = \
 	mutter-enum-types.c			\
 	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
+	wayland/xserver-server-protocol.h
 
 libmutter_wayland_la_SOURCES =			\
 	core/async-getprop.c			\
@@ -163,6 +160,8 @@ libmutter_wayland_la_SOURCES =			\
 	core/util-private.h			\
 	core/window-props.c			\
 	core/window-props.h			\
+	core/window-x11.c			\
+	core/window-x11.h			\
 	core/window.c				\
 	core/window-private.h			\
 	meta/window.h				\
@@ -189,12 +188,7 @@ libmutter_wayland_la_SOURCES =			\
 	ui/theme.c				\
 	meta/theme.h				\
 	ui/theme-private.h			\
-	ui/ui.c
-
-nodist_libmutter_wayland_la_SOURCES =		\
-	$(mutter_built_sources)
-
-libmutter_wayland_la_SOURCES +=			\
+	ui/ui.c					\
 	wayland/meta-wayland.c			\
 	wayland/meta-wayland-private.h		\
 	wayland/meta-xwayland-private.h		\
@@ -216,6 +210,9 @@ libmutter_wayland_la_SOURCES +=			\
 	wayland/meta-weston-launch.c		\
 	wayland/meta-weston-launch.h
 
+nodist_libmutter_wayland_la_SOURCES =		\
+	$(mutter_built_sources)
+
 libmutter_wayland_la_LDFLAGS = -no-undefined
 libmutter_wayland_la_LIBADD  = $(MUTTER_LIBS)
 
@@ -418,6 +415,3 @@ wayland/%-protocol.c : $(top_builddir)/protocol/%.xml
 wayland/%-server-protocol.h : $(top_builddir)/protocol/%.xml
 	mkdir -p wayland
 	$(AM_V_GEN)$(WAYLAND_SCANNER) server-header < $< > $@
-wayland/%-client-protocol.h : $(top_builddir)/protocol/%.xml
-	mkdir -p wayland
-	$(AM_V_GEN)$(WAYLAND_SCANNER) client-header < $< > $@

src/compositor/compositor-private.h

@@ -46,11 +46,8 @@ struct _MetaCompScreen
   CoglFrameClosure      *frame_closure;
 
   /* Used for unredirecting fullscreen windows */
-  guint                   disable_unredirect_count;
-  MetaWindowActor             *unredirected_window;
-
-  /* Before we create the output window */
-  XserverRegion     pending_input_region;
+  guint                  disable_unredirect_count;
+  MetaWindow            *unredirected_window;
 
   gint                   switch_workspace_in_progress;
 

src/compositor/compositor.c

@@ -42,15 +42,6 @@
  * the call, so it may be necessary to readjust the display based on the
  * old_rect to start the animation.
  *
- * meta_compositor_window_mapped() and meta_compositor_window_unmapped() are
- * notifications when the toplevel window (frame or client window) is mapped or
- * unmapped. That is, when the result of meta_window_toplevel_is_mapped()
- * changes. The main use of this is to drop resources when a window is unmapped.
- * A window will always be mapped before meta_compositor_show_window()
- * is called and will not be unmapped until after meta_compositor_hide_window()
- * is called. If the live_hidden_windows preference is set, windows will never
- * be unmapped.
- *
  * # Containers #
  *
  * There's two containers in the stage that are used to place window actors, here
@@ -149,19 +140,6 @@ meta_compositor_destroy (MetaCompositor *compositor)
   clutter_threads_remove_repaint_func (compositor->repaint_func_id);
 }
 
-static void
-add_win (MetaWindow *window)
-{
-  MetaScreen		*screen = meta_window_get_screen (window);
-  MetaCompScreen        *info = meta_screen_get_compositor_data (screen);
-
-  g_return_if_fail (info != NULL);
-
-  meta_window_actor_new (window);
-
-  sync_actor_stacking (info);
-}
-
 static void
 process_damage (MetaCompositor     *compositor,
                 XDamageNotifyEvent *event,
@@ -283,25 +261,6 @@ meta_get_window_actors (MetaScreen *screen)
   return info->windows;
 }
 
-static void
-do_set_stage_input_region (MetaScreen   *screen,
-                           XserverRegion region)
-{
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-  MetaDisplay *display = meta_screen_get_display (screen);
-  Display        *xdpy = meta_display_get_xdisplay (display);
-  Window        xstage = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-
-  XFixesSetWindowShapeRegion (xdpy, xstage, ShapeInput, 0, 0, region);
-
-  /* It's generally a good heuristic that when a crossing event is generated because
-   * we reshape the overlay, we don't want it to affect focus-follows-mouse focus -
-   * it's not the user doing something, it's the environment changing under the user.
-   */
-  meta_display_add_ignored_crossing_serial (display, XNextRequest (xdpy));
-  XFixesSetWindowShapeRegion (xdpy, info->output, ShapeInput, 0, 0, region);
-}
-
 void
 meta_set_stage_input_region (MetaScreen   *screen,
                              XserverRegion region)
@@ -313,29 +272,19 @@ meta_set_stage_input_region (MetaScreen   *screen,
    */
   if (!meta_is_wayland_compositor ())
     {
-      MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-      MetaDisplay  *display = meta_screen_get_display (screen);
-      Display      *xdpy    = meta_display_get_xdisplay (display);
+      MetaCompScreen *info    = meta_screen_get_compositor_data (screen);
+      MetaDisplay    *display = meta_screen_get_display (screen);
+      Display        *xdpy    = meta_display_get_xdisplay (display);
+      Window          xstage  = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
 
-      if (info->stage && info->output)
-        {
-          do_set_stage_input_region (screen, region);
-        }
-      else 
-        {
-          /* Reset info->pending_input_region if one existed before and set the new
-           * one to use it later. */ 
-          if (info->pending_input_region)
-            {
-              XFixesDestroyRegion (xdpy, info->pending_input_region);
-              info->pending_input_region = None;
-            }
-          if (region != None)
-            {
-              info->pending_input_region = XFixesCreateRegion (xdpy, NULL, 0);
-              XFixesCopyRegion (xdpy, info->pending_input_region, region);
-            }
-        } 
+      XFixesSetWindowShapeRegion (xdpy, xstage, ShapeInput, 0, 0, region);
+
+      /* It's generally a good heuristic that when a crossing event is generated because
+       * we reshape the overlay, we don't want it to affect focus-follows-mouse focus -
+       * it's not the user doing something, it's the environment changing under the user.
+       */
+      meta_display_add_ignored_crossing_serial (display, XNextRequest (xdpy));
+      XFixesSetWindowShapeRegion (xdpy, info->output, ShapeInput, 0, 0, region);
     }
 }
 
@@ -677,21 +626,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
     return;
 
   info = g_new0 (MetaCompScreen, 1);
-  /*
-   * We use an empty input region for Clutter as a default because that allows
-   * the user to interact with all the windows displayed on the screen.
-   * We have to initialize info->pending_input_region to an empty region explicitly, 
-   * because None value is used to mean that the whole screen is an input region.
-   */
-  if (!meta_is_wayland_compositor ())
-    info->pending_input_region = XFixesCreateRegion (xdisplay, NULL, 0);
-  else
-    {
-      /* Stage input region trickery isn't needed when we're running as a
-       * wayland compositor. */
-      info->pending_input_region = None;
-    }
-
   info->screen = screen;
 
   meta_screen_set_compositor_data (screen, info);
@@ -777,6 +711,8 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
       info->output = get_output_window (screen);
       XReparentWindow (xdisplay, xwin, info->output, 0, 0);
 
+      meta_empty_stage_input_region (screen);
+
       /* Make sure there isn't any left-over output shape on the 
        * overlay window by setting the whole screen to be an
        * output region.
@@ -787,13 +723,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
        */
       XFixesSetWindowShapeRegion (xdisplay, info->output, ShapeBounding, 0, 0, None);
 
-      do_set_stage_input_region (screen, info->pending_input_region);
-      if (info->pending_input_region != None)
-        {
-          XFixesDestroyRegion (xdisplay, info->pending_input_region);
-          info->pending_input_region = None;
-        }
-
       /* Map overlay window before redirecting windows offscreen so we catch their
        * contents until we show the stage.
        */
@@ -863,19 +792,50 @@ meta_shape_cow_for_window (MetaScreen *screen,
     }
 }
 
+static void
+set_unredirected_window (MetaCompScreen *info,
+                         MetaWindow     *window)
+{
+  if (info->unredirected_window == window)
+    return;
+
+  if (info->unredirected_window != NULL)
+    {
+      MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (info->unredirected_window));
+      meta_window_actor_set_unredirected (window_actor, FALSE);
+    }
+
+  info->unredirected_window = window;
+
+  if (info->unredirected_window != NULL)
+    {
+      MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (info->unredirected_window));
+      meta_window_actor_set_unredirected (window_actor, TRUE);
+    }
+
+  meta_shape_cow_for_window (info->screen, info->unredirected_window);
+}
+
 void
 meta_compositor_add_window (MetaCompositor    *compositor,
                             MetaWindow        *window)
 {
   MetaScreen *screen = meta_window_get_screen (window);
   MetaDisplay *display = meta_screen_get_display (screen);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  g_return_if_fail (info != NULL);
+
+  /* Window was already added previously, probably coming
+   * back from hiding */
+  if (window->compositor_private != NULL)
+    return;
 
-  DEBUG_TRACE ("meta_compositor_add_window\n");
   meta_error_trap_push (display);
-
-  add_win (window);
-
+  meta_window_actor_new (window);
   meta_error_trap_pop (display);
+
+  sync_actor_stacking (info);
 }
 
 void
@@ -891,19 +851,11 @@ meta_compositor_remove_window (MetaCompositor *compositor,
   if (!window_actor)
     return;
 
-  if (!meta_is_wayland_compositor ())
-    {
-      screen = meta_window_get_screen (window);
-      info = meta_screen_get_compositor_data (screen);
+  screen = meta_window_get_screen (window);
+  info = meta_screen_get_compositor_data (screen);
 
-      if (window_actor == info->unredirected_window)
-        {
-          meta_window_actor_set_redirected (window_actor, TRUE);
-          meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
-                                     NULL);
-          info->unredirected_window = NULL;
-        }
-    }
+  if (info->unredirected_window == window)
+    set_unredirected_window (info, NULL);
 
   meta_window_actor_destroy (window_actor);
 }
@@ -1402,30 +1354,6 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
   sync_actor_stacking (info);
 }
 
-void
-meta_compositor_window_mapped (MetaCompositor *compositor,
-                               MetaWindow     *window)
-{
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_window_mapped\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_mapped (window_actor);
-}
-
-void
-meta_compositor_window_unmapped (MetaCompositor *compositor,
-                                 MetaWindow     *window)
-{
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_window_unmapped\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_unmapped (window_actor);
-}
-
 void
 meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window,
@@ -1533,7 +1461,6 @@ pre_paint_windows (MetaCompScreen *info)
 {
   GList *l;
   MetaWindowActor *top_window;
-  MetaWindowActor *expected_unredirected_window = NULL;
 
   if (info->onscreen == NULL)
     {
@@ -1547,33 +1474,13 @@ pre_paint_windows (MetaCompScreen *info)
   if (info->windows == NULL)
     return;
 
-  if (!meta_is_wayland_compositor ())
-    {
-      top_window = g_list_last (info->windows)->data;
+  top_window = g_list_last (info->windows)->data;
 
-      if (meta_window_actor_should_unredirect (top_window) &&
-          info->disable_unredirect_count == 0)
-        expected_unredirected_window = top_window;
-
-      if (info->unredirected_window != expected_unredirected_window)
-        {
-          if (info->unredirected_window != NULL)
-            {
-              meta_window_actor_set_redirected (info->unredirected_window, TRUE);
-              meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
-                                         NULL);
-            }
-
-          if (expected_unredirected_window != NULL)
-            {
-              meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (top_window)),
-                                         meta_window_actor_get_meta_window (top_window));
-              meta_window_actor_set_redirected (top_window, FALSE);
-            }
-
-          info->unredirected_window = expected_unredirected_window;
-        }
-    }
+  if (meta_window_actor_should_unredirect (top_window) &&
+      info->disable_unredirect_count == 0)
+    set_unredirected_window (info, meta_window_actor_get_meta_window (top_window));
+  else
+    set_unredirected_window (info, NULL);
 
   for (l = info->windows; l; l = l->next)
     meta_window_actor_pre_paint (l->data);

src/compositor/meta-cullable.c

@@ -70,10 +70,16 @@ meta_cullable_cull_out_children (MetaCullable   *cullable,
   while (clutter_actor_iter_prev (&iter, &child))
     {
       float x, y;
+      gboolean needs_culling;
 
-      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
+      if (!META_IS_CULLABLE (child))
         continue;
 
+      needs_culling = (unobscured_region != NULL && clip_region != NULL);
+
+      if (needs_culling && !CLUTTER_ACTOR_IS_VISIBLE (child))
+        needs_culling = FALSE;
+
       /* If an actor has effects applied, then that can change the area
        * it paints and the opacity, so we no longer can figure out what
        * portion of the actor is obscured and what portion of the screen
@@ -90,25 +96,29 @@ meta_cullable_cull_out_children (MetaCullable   *cullable,
        * as well for the same reason, but omitted for simplicity in the
        * hopes that no-one will do that.
        */
-      if (clutter_actor_has_effects (child))
-        continue;
+      if (needs_culling && clutter_actor_has_effects (child))
+        needs_culling = FALSE;
 
-      if (!META_IS_CULLABLE (child))
-        continue;
+      if (needs_culling && !meta_actor_is_untransformed (child, NULL, NULL))
+        needs_culling = FALSE;
 
-      if (!meta_actor_is_untransformed (child, NULL, NULL))
-        continue;
+      if (needs_culling)
+        {
+          clutter_actor_get_position (child, &x, &y);
 
-      clutter_actor_get_position (child, &x, &y);
+          /* Temporarily move to the coordinate system of the actor */
+          cairo_region_translate (unobscured_region, - x, - y);
+          cairo_region_translate (clip_region, - x, - y);
 
-      /* Temporarily move to the coordinate system of the actor */
-      cairo_region_translate (unobscured_region, - x, - y);
-      cairo_region_translate (clip_region, - x, - y);
+          meta_cullable_cull_out (META_CULLABLE (child), unobscured_region, clip_region);
 
-      meta_cullable_cull_out (META_CULLABLE (child), unobscured_region, clip_region);
-
-      cairo_region_translate (unobscured_region, x, y);
-      cairo_region_translate (clip_region, x, y);
+          cairo_region_translate (unobscured_region, x, y);
+          cairo_region_translate (clip_region, x, y);
+        }
+      else
+        {
+          meta_cullable_cull_out (META_CULLABLE (child), NULL, NULL);
+        }
     }
 }
 

src/compositor/meta-shaped-texture-private.h

@@ -32,5 +32,8 @@
 ClutterActor *meta_shaped_texture_new (void);
 void meta_shaped_texture_set_texture (MetaShapedTexture *stex,
                                       CoglTexture       *texture);
+gboolean meta_shaped_texture_get_unobscured_bounds (MetaShapedTexture     *stex,
+                                                    cairo_rectangle_int_t *unobscured_bounds);
+gboolean meta_shaped_texture_is_obscured (MetaShapedTexture *self);
 
 #endif

src/compositor/meta-shaped-texture.c

@@ -73,10 +73,15 @@ struct _MetaShapedTexturePrivate
   CoglTexture *texture;
   CoglTexture *mask_texture;
 
-  cairo_region_t *clip_region;
   cairo_region_t *input_shape_region;
+
+  /* The region containing only fully opaque pixels */
   cairo_region_t *opaque_region;
 
+  /* MetaCullable regions, see that documentation for more details */
+  cairo_region_t *clip_region;
+  cairo_region_t *unobscured_region;
+
   guint tex_width, tex_height;
 
   guint create_mipmaps : 1;
@@ -113,6 +118,21 @@ meta_shaped_texture_init (MetaShapedTexture *self)
   priv->create_mipmaps = TRUE;
 }
 
+static void
+set_unobscured_region (MetaShapedTexture *self,
+                       cairo_region_t    *unobscured_region)
+{
+  MetaShapedTexturePrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->unobscured_region, (GDestroyNotify) cairo_region_destroy);
+  if (unobscured_region)
+    {
+      cairo_rectangle_int_t bounds = { 0, 0, priv->tex_width, priv->tex_height };
+      priv->unobscured_region = cairo_region_copy (unobscured_region);
+      cairo_region_intersect_rectangle (priv->unobscured_region, &bounds);
+    }
+}
+
 static void
 set_clip_region (MetaShapedTexture *self,
                  cairo_region_t    *clip_region)
@@ -138,6 +158,7 @@ meta_shaped_texture_dispose (GObject *object)
   g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
 
   meta_shaped_texture_set_mask_texture (self, NULL);
+  set_unobscured_region (self, NULL);
   set_clip_region (self, NULL);
 
   G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
@@ -546,10 +567,37 @@ meta_shaped_texture_get_preferred_height (ClutterActor *self,
 }
 
 static gboolean
-meta_shaped_texture_get_paint_volume (ClutterActor *self,
+meta_shaped_texture_get_paint_volume (ClutterActor *actor,
                                       ClutterPaintVolume *volume)
 {
-  return clutter_paint_volume_set_from_allocation (volume, self);
+  MetaShapedTexture *self = META_SHAPED_TEXTURE (actor);
+  cairo_rectangle_int_t unobscured_bounds;
+
+  if (!clutter_paint_volume_set_from_allocation (volume, actor))
+    return FALSE;
+
+  if (meta_shaped_texture_get_unobscured_bounds (self, &unobscured_bounds))
+    {
+      ClutterVertex origin;
+      cairo_rectangle_int_t bounds;
+
+      /* I hate ClutterPaintVolume so much... */
+      clutter_paint_volume_get_origin (volume, &origin);
+      bounds.x = origin.x;
+      bounds.y = origin.y;
+      bounds.width = clutter_paint_volume_get_width (volume);
+      bounds.height = clutter_paint_volume_get_height (volume);
+
+      gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
+
+      origin.x = bounds.x;
+      origin.y = bounds.y;
+      clutter_paint_volume_set_origin (volume, &origin);
+      clutter_paint_volume_set_width (volume, bounds.width);
+      clutter_paint_volume_set_height (volume, bounds.height);
+    }
+
+  return TRUE;
 }
 
 void
@@ -594,50 +642,38 @@ meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
   clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }
 
-static gboolean
-get_clip (MetaShapedTexture *stex,
-          int x,
-          int y,
-          int width,
-          int height,
-          cairo_rectangle_int_t *clip)
+static cairo_region_t *
+effective_unobscured_region (MetaShapedTexture *self)
 {
-  ClutterActor *self = CLUTTER_ACTOR (stex);
-  MetaShapedTexturePrivate *priv;
-  ClutterActorBox allocation;
-  float scale_x;
-  float scale_y;
+  MetaShapedTexturePrivate *priv = self->priv;
 
-  /* NB: clutter_actor_queue_redraw_with_clip expects a box in the actor's
-   * coordinate space so we need to convert from surface coordinates to
-   * actor coordinates...
-   */
+  return clutter_actor_has_mapped_clones (CLUTTER_ACTOR (self)) ? NULL : priv->unobscured_region;
+}
 
-  /* Calling clutter_actor_get_allocation_box() is enormously expensive
-   * if the actor has an out-of-date allocation, since it triggers
-   * a full redraw. clutter_actor_queue_redraw_with_clip() would redraw
-   * the whole stage anyways in that case, so just go ahead and do
-   * it here.
-   */
-  if (!clutter_actor_has_allocation (self))
+gboolean
+meta_shaped_texture_get_unobscured_bounds (MetaShapedTexture     *self,
+                                           cairo_rectangle_int_t *unobscured_bounds)
+{
+  cairo_region_t *unobscured_region = effective_unobscured_region (self);
+
+  if (unobscured_region)
+    {
+      cairo_region_get_extents (unobscured_region, unobscured_bounds);
+      return TRUE;
+    }
+  else
     return FALSE;
+}
 
-  priv = stex->priv;
+gboolean
+meta_shaped_texture_is_obscured (MetaShapedTexture *self)
+{
+  cairo_region_t *unobscured_region = effective_unobscured_region (self);
 
-  if (priv->tex_width == 0 || priv->tex_height == 0)
+  if (unobscured_region)
+    return cairo_region_is_empty (unobscured_region);
+  else
     return FALSE;
-
-  clutter_actor_get_allocation_box (self, &allocation);
-
-  scale_x = (allocation.x2 - allocation.x1) / priv->tex_width;
-  scale_y = (allocation.y2 - allocation.y1) / priv->tex_height;
-
-  clip->x = x * scale_x;
-  clip->y = y * scale_y;
-  clip->width = width * scale_x;
-  clip->height = height * scale_y;
-
-  return TRUE;
 }
 
 /**
@@ -647,14 +683,9 @@ get_clip (MetaShapedTexture *stex,
  * @y: the y coordinate of the damaged area
  * @width: the width of the damaged area
  * @height: the height of the damaged area
- * @unobscured_region: The unobscured region of the window or %NULL if
- * there is no valid one (like when the actor is transformed or
- * has a mapped clone)
  *
  * Repairs the damaged area indicated by @x, @y, @width and @height
- * and queues a redraw for the intersection @unobscured_region and
- * the damage area. If @unobscured_region is %NULL a redraw will always
- * get queued.
+ * and potentially queues a redraw.
  *
  * Return value: Whether a redraw have been queued or not
  */
@@ -663,12 +694,11 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
 				 int                x,
 				 int                y,
 				 int                width,
-				 int                height,
-				 cairo_region_t    *unobscured_region)
+				 int                height)
 {
   MetaShapedTexturePrivate *priv;
-  cairo_rectangle_int_t clip;
-  gboolean has_clip;
+  cairo_region_t *unobscured_region;
+  const cairo_rectangle_int_t clip = { x, y, width, height };
 
   priv = stex->priv;
 
@@ -677,8 +707,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
 
   meta_texture_tower_update_area (priv->paint_tower, x, y, width, height);
 
-  has_clip = get_clip (stex, x, y, width, height, &clip);
-
+  unobscured_region = effective_unobscured_region (stex);
   if (unobscured_region)
     {
       cairo_region_t *intersection;
@@ -687,8 +716,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
         return FALSE;
 
       intersection = cairo_region_copy (unobscured_region);
-      if (has_clip)
-	cairo_region_intersect_rectangle (intersection, &clip);
+      cairo_region_intersect_rectangle (intersection, &clip);
 
       if (!cairo_region_is_empty (intersection))
         {
@@ -696,21 +724,17 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
           cairo_region_get_extents (intersection, &damage_rect);
           clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &damage_rect);
           cairo_region_destroy (intersection);
-
           return TRUE;
         }
 
       cairo_region_destroy (intersection);
-
       return FALSE;
     }
-
-  if (has_clip)
-    clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &clip);
   else
-    clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-
-  return TRUE;
+    {
+      clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stex), &clip);
+      return TRUE;
+    }
 }
 
 /**
@@ -911,14 +935,17 @@ meta_shaped_texture_cull_out (MetaCullable   *cullable,
   MetaShapedTexture *self = META_SHAPED_TEXTURE (cullable);
   MetaShapedTexturePrivate *priv = self->priv;
 
+  set_unobscured_region (self, unobscured_region);
   set_clip_region (self, clip_region);
 
   if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (self)) == 0xff)
     {
       if (priv->opaque_region)
         {
-          cairo_region_subtract (unobscured_region, priv->opaque_region);
-          cairo_region_subtract (clip_region, priv->opaque_region);
+          if (unobscured_region)
+            cairo_region_subtract (unobscured_region, priv->opaque_region);
+          if (clip_region)
+            cairo_region_subtract (clip_region, priv->opaque_region);
         }
     }
 }

src/compositor/meta-surface-actor.c

@@ -31,6 +31,14 @@ static void cullable_iface_init (MetaCullableInterface *iface);
 G_DEFINE_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
                          G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
 
+gboolean
+meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
+                                          cairo_rectangle_int_t *unobscured_bounds)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+  return meta_shaped_texture_get_unobscured_bounds (priv->texture, unobscured_bounds);
+}
+
 static void
 meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
 {
@@ -109,18 +117,13 @@ update_area (MetaSurfaceActor *self,
 }
 
 gboolean
-meta_surface_actor_damage_all (MetaSurfaceActor *self,
-                               cairo_region_t   *unobscured_region)
+meta_surface_actor_damage_all (MetaSurfaceActor *self)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
   CoglTexture *texture = meta_shaped_texture_get_texture (priv->texture);
 
   update_area (self, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
-  return meta_shaped_texture_update_area (priv->texture,
-                                          0, 0,
-                                          cogl_texture_get_width (texture),
-                                          cogl_texture_get_height (texture),
-                                          unobscured_region);
+  return meta_shaped_texture_update_area (priv->texture, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
 }
 
 gboolean
@@ -128,15 +131,19 @@ meta_surface_actor_damage_area (MetaSurfaceActor *self,
                                 int               x,
                                 int               y,
                                 int               width,
-                                int               height,
-                                cairo_region_t   *unobscured_region)
+                                int               height)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
 
   update_area (self, x, y, width, height);
-  return meta_shaped_texture_update_area (priv->texture,
-                                          x, y, width, height,
-                                          unobscured_region);
+  return meta_shaped_texture_update_area (priv->texture, x, y, width, height);
+}
+
+gboolean
+meta_surface_actor_is_obscured (MetaSurfaceActor *self)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+  return meta_shaped_texture_is_obscured (priv->texture);
 }
 
 void

src/compositor/meta-surface-actor.h

@@ -43,15 +43,16 @@ cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,
 
 MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);
 
-gboolean meta_surface_actor_damage_all (MetaSurfaceActor *self,
-                                        cairo_region_t   *unobscured_region);
-
+gboolean meta_surface_actor_damage_all  (MetaSurfaceActor *self);
 gboolean meta_surface_actor_damage_area (MetaSurfaceActor *self,
                                          int               x,
                                          int               y,
                                          int               width,
-                                         int               height,
-                                         cairo_region_t   *unobscured_region);
+                                         int               height);
+
+gboolean meta_surface_actor_is_obscured (MetaSurfaceActor *self);
+gboolean meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
+                                                   cairo_rectangle_int_t *unobscured_bounds);
 
 void meta_surface_actor_set_texture (MetaSurfaceActor *self,
                                      CoglTexture      *texture);

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

@@ -39,13 +39,13 @@ void meta_window_actor_frame_complete (MetaWindowActor    *self,
 
 void meta_window_actor_invalidate_shadow (MetaWindowActor *self);
 
-void meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state);
-
-gboolean meta_window_actor_should_unredirect (MetaWindowActor *self);
-
 void meta_window_actor_get_shape_bounds (MetaWindowActor       *self,
                                           cairo_rectangle_int_t *bounds);
 
+gboolean meta_window_actor_should_unredirect   (MetaWindowActor *self);
+void     meta_window_actor_set_unredirected    (MetaWindowActor *self,
+                                                gboolean         unredirected);
+
 gboolean meta_window_actor_effect_in_progress  (MetaWindowActor *self);
 void     meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
                                                 gboolean         did_placement);
@@ -59,9 +59,6 @@ void     meta_window_actor_set_updates_frozen  (MetaWindowActor *self,
 void     meta_window_actor_queue_frame_drawn   (MetaWindowActor *self,
                                                 gboolean         no_delay_frame);
 
-void meta_window_actor_set_unobscured_region      (MetaWindowActor *self,
-                                                   cairo_region_t  *unobscured_region);
-
 void meta_window_actor_effect_completed (MetaWindowActor *actor,
                                          gulong           event);
 

src/compositor/meta-window-actor.c

@@ -37,15 +37,6 @@
 #include "monitor-private.h"
 #include "meta-cullable.h"
 
-enum {
-  POSITION_CHANGED,
-  SIZE_CHANGED,
-  LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL] = {0};
-
-
 struct _MetaWindowActorPrivate
 {
   MetaWindow       *window;
@@ -72,9 +63,6 @@ struct _MetaWindowActorPrivate
   /* The region we should clip to when painting the shadow */
   cairo_region_t   *shadow_clip;
 
-  /* The region that is visible, used to optimize out redraws */
-  cairo_region_t   *unobscured_region;
-
   guint              send_frame_messages_timer;
   gint64             frame_drawn_time;
 
@@ -106,7 +94,6 @@ struct _MetaWindowActorPrivate
   Damage            damage; /* Not used in wayland compositor mode */
 
   guint		    visible                : 1;
-  guint		    mapped                 : 1;
   guint		    argb32                 : 1;
   guint		    disposed               : 1;
   guint             redecorating           : 1;
@@ -249,19 +236,6 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
   g_object_class_install_property (object_class,
                                    PROP_SHADOW_CLASS,
                                    pspec);
-
-  signals[POSITION_CHANGED] =
-    g_signal_new ("position-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
-  signals[SIZE_CHANGED] =
-    g_signal_new ("size-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
 }
 
 static void
@@ -331,8 +305,6 @@ surface_allocation_changed_notify (ClutterActor           *actor,
 {
   meta_window_actor_sync_actor_geometry (self, FALSE);
   meta_window_actor_update_shape (self);
-
-  g_signal_emit (self, signals[SIZE_CHANGED], 0);
 }
 
 static gboolean
@@ -425,7 +397,6 @@ meta_window_actor_dispose (GObject *object)
       priv->send_frame_messages_timer = 0;
     }
 
-  g_clear_pointer (&priv->unobscured_region, cairo_region_destroy);
   g_clear_pointer (&priv->shape_region, cairo_region_destroy);
   g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
 
@@ -696,7 +667,7 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (actor);
   MetaWindowActorPrivate *priv = self->priv;
-  cairo_rectangle_int_t bounds;
+  cairo_rectangle_int_t unobscured_bounds, bounds;
   gboolean appears_focused = meta_window_appears_focused (priv->window);
   ClutterVertex origin;
 
@@ -721,12 +692,8 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
       gdk_rectangle_union (&bounds, &shadow_bounds, &bounds);
     }
 
-  if (priv->unobscured_region)
-    {
-      cairo_rectangle_int_t unobscured_bounds;
-      cairo_region_get_extents (priv->unobscured_region, &unobscured_bounds);
-      gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
-    }
+  if (meta_surface_actor_get_unobscured_bounds (priv->surface, &unobscured_bounds))
+    gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
 
   origin.x = bounds.x;
   origin.y = bounds.y;
@@ -860,59 +827,6 @@ meta_window_actor_is_destroyed (MetaWindowActor *self)
   return self->priv->disposed;
 }
 
-gboolean
-meta_window_actor_is_override_redirect (MetaWindowActor *self)
-{
-  return meta_window_is_override_redirect (self->priv->window);
-}
-
-/**
- * meta_window_actor_get_workspace:
- * @self: #MetaWindowActor
- *
- * Returns the index of workspace on which this window is located; if the
- * window is sticky, or is not currently located on any workspace, returns -1.
- * This function is deprecated  and should not be used in newly written code;
- * meta_window_get_workspace() instead.
- *
- * Return value: (transfer none): index of workspace on which this window is
- * located.
- */
-gint
-meta_window_actor_get_workspace (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv;
-  MetaWorkspace          *workspace;
-
-  if (!self)
-    return -1;
-
-  priv = self->priv;
-
-  if (!priv->window || meta_window_is_on_all_workspaces (priv->window))
-    return -1;
-
-  workspace = meta_window_get_workspace (priv->window);
-
-  if (!workspace)
-    return -1;
-
-  return meta_workspace_index (workspace);
-}
-
-gboolean
-meta_window_actor_showing_on_its_workspace (MetaWindowActor *self)
-{
-  if (!self)
-    return FALSE;
-
-  /* If override redirect: */
-  if (!self->priv->window)
-    return TRUE;
-
-  return meta_window_showing_on_its_workspace (self->priv->window);
-}
-
 static void
 meta_window_actor_freeze (MetaWindowActor *self)
 {
@@ -978,21 +892,15 @@ static void
 meta_window_actor_damage_all (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
-  cairo_region_t *unobscured_region;
   gboolean redraw_queued;
 
   if (!priv->needs_damage_all)
     return;
 
-  if (!priv->mapped || priv->needs_pixmap)
+  if (priv->needs_pixmap)
     return;
 
-  unobscured_region =
-    clutter_actor_has_mapped_clones (CLUTTER_ACTOR (priv->surface))
-    ? NULL : priv->unobscured_region;
-
-  redraw_queued = meta_surface_actor_damage_all (priv->surface, unobscured_region);
-
+  redraw_queued = meta_surface_actor_damage_all (priv->surface);
   priv->repaint_scheduled = priv->repaint_scheduled || redraw_queued;
   priv->needs_damage_all = FALSE;
 }
@@ -1050,17 +958,7 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
 
   if (!priv->repaint_scheduled)
     {
-      gboolean is_obscured = FALSE;
-
-      /* Find out whether the window is completly obscured */
-      if (priv->unobscured_region)
-        {
-          cairo_region_t *unobscured_window_region;
-          unobscured_window_region = cairo_region_copy (priv->shape_region);
-          cairo_region_intersect (unobscured_window_region, priv->unobscured_region);
-          is_obscured = cairo_region_is_empty (unobscured_window_region);
-          cairo_region_destroy (unobscured_window_region);
-        }
+      gboolean is_obscured = meta_surface_actor_is_obscured (priv->surface);
 
       /* A frame was marked by the client without actually doing any
        * damage or any unobscured, or while we had the window frozen
@@ -1074,7 +972,7 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
         {
           queue_send_frame_messages_timeout (self);
         }
-      else if (priv->mapped && (!meta_is_wayland_compositor () || !priv->needs_pixmap))
+      else
         {
           const cairo_rectangle_int_t clip = { 0, 0, 1, 1 };
           clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (priv->surface), &clip);
@@ -1106,9 +1004,6 @@ meta_window_actor_queue_create_x11_pixmap (MetaWindowActor *self)
 
   priv->needs_pixmap = TRUE;
 
-  if (!priv->mapped)
-    return;
-
   if (is_frozen (self))
     return;
 
@@ -1206,9 +1101,6 @@ meta_window_actor_after_effects (MetaWindowActor *self)
 
   if (!meta_is_wayland_compositor ())
     {
-      if (!meta_window_is_mapped (priv->window))
-        meta_window_actor_detach_x11_pixmap (self);
-
       if (priv->needs_pixmap)
         clutter_actor_queue_redraw (CLUTTER_ACTOR (priv->surface));
     }
@@ -1321,6 +1213,9 @@ meta_window_actor_should_unredirect (MetaWindowActor *self)
   MetaWindow *metaWindow = meta_window_actor_get_meta_window (self);
   MetaWindowActorPrivate *priv = self->priv;
 
+  if (meta_is_wayland_compositor ())
+    return FALSE;
+
   if (meta_window_requested_dont_bypass_compositor (metaWindow))
     return FALSE;
 
@@ -1342,14 +1237,15 @@ meta_window_actor_should_unredirect (MetaWindowActor *self)
   if (meta_window_is_override_redirect (metaWindow))
     return TRUE;
 
-  if (!meta_is_wayland_compositor () && priv->does_full_damage)
+  if (priv->does_full_damage)
     return TRUE;
 
   return FALSE;
 }
 
 void
-meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state)
+meta_window_actor_set_unredirected (MetaWindowActor *self,
+                                    gboolean         unredirected)
 {
   MetaWindow *metaWindow = meta_window_actor_get_meta_window (self);
   MetaDisplay *display = meta_window_get_display (metaWindow);
@@ -1357,21 +1253,20 @@ meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state)
   Display *xdisplay = meta_display_get_xdisplay (display);
   Window  xwin = meta_window_get_toplevel_xwindow (metaWindow);
 
-  if (state)
+  meta_error_trap_push (display);
+
+  if (unredirected)
     {
-      meta_error_trap_push (display);
-      XCompositeRedirectWindow (xdisplay, xwin, CompositeRedirectManual);
-      meta_error_trap_pop (display);
-      meta_window_actor_detach_x11_pixmap (self);
-      self->priv->unredirected = FALSE;
+      XCompositeUnredirectWindow (xdisplay, xwin, CompositeRedirectManual);
     }
   else
     {
-      meta_error_trap_push (display);
-      XCompositeUnredirectWindow (xdisplay, xwin, CompositeRedirectManual);
-      meta_error_trap_pop (display);
-      self->priv->unredirected = TRUE;
+      XCompositeRedirectWindow (xdisplay, xwin, CompositeRedirectManual);
+      meta_window_actor_detach_x11_pixmap (self);
     }
+
+  self->priv->unredirected = unredirected;
+  meta_error_trap_pop (display);
 }
 
 void
@@ -1388,6 +1283,12 @@ meta_window_actor_destroy (MetaWindowActor *self)
   window_type = meta_window_get_window_type (window);
   meta_window_set_compositor_private (window, NULL);
 
+  if (priv->send_frame_messages_timer != 0)
+    {
+      g_source_remove (priv->send_frame_messages_timer);
+      priv->send_frame_messages_timer = 0;
+    }
+
   /*
    * We remove the window from internal lookup hashes and thus any other
    * unmap events etc fail
@@ -1465,8 +1366,6 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
                               window_rect.x, window_rect.y);
   clutter_actor_set_size (CLUTTER_ACTOR (self),
                           window_rect.width, window_rect.height);
-
-  g_signal_emit (self, signals[POSITION_CHANGED], 0);
 }
 
 void
@@ -1626,15 +1525,13 @@ meta_window_actor_new (MetaWindow *window)
                        NULL);
 
   priv = self->priv;
-  priv->mapped = meta_window_toplevel_is_mapped (priv->window);
 
   if (!meta_is_wayland_compositor ())
     {
       priv->last_width = -1;
       priv->last_height = -1;
 
-      if (priv->mapped)
-        meta_window_actor_queue_create_x11_pixmap (self);
+      meta_window_actor_queue_create_x11_pixmap (self);
 
       meta_window_actor_set_updates_frozen (self,
                                             meta_window_updates_are_frozen (priv->window));
@@ -1670,38 +1567,6 @@ meta_window_actor_new (MetaWindow *window)
   return self;
 }
 
-void
-meta_window_actor_mapped (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  g_return_if_fail (!priv->mapped);
-
-  priv->mapped = TRUE;
-
-  if (!meta_is_wayland_compositor ())
-    meta_window_actor_queue_create_x11_pixmap (self);
-}
-
-void
-meta_window_actor_unmapped (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  g_return_if_fail (priv->mapped);
-
-  priv->mapped = FALSE;
-
-  if (meta_window_actor_effect_in_progress (self))
-    return;
-
-  if (!meta_is_wayland_compositor ())
-    {
-      meta_window_actor_detach_x11_pixmap (self);
-      priv->needs_pixmap = FALSE;
-    }
-}
-
 #if 0
 /* Print out a region; useful for debugging */
 static void
@@ -1743,30 +1608,6 @@ see_region (cairo_region_t *region,
 }
 #endif
 
-/**
- * meta_window_actor_set_unobscured_region:
- * @self: a #MetaWindowActor
- * @unobscured_region: the region of the screen that isn't completely
- *  obscured.
- *
- * Provides a hint as to what areas of the window need to queue
- * redraws when damaged. Regions not in @unobscured_region are completely obscured.
- */
-void
-meta_window_actor_set_unobscured_region (MetaWindowActor *self,
-                                         cairo_region_t  *unobscured_region)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  if (priv->unobscured_region)
-    cairo_region_destroy (priv->unobscured_region);
-
-  if (unobscured_region)
-    priv->unobscured_region = cairo_region_copy (unobscured_region);
-  else
-    priv->unobscured_region = NULL;
-}
-
 /**
  * meta_window_actor_set_clip_region_beneath:
  * @self: a #MetaWindowActor
@@ -1789,13 +1630,19 @@ meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
   if (appears_focused ? priv->focused_shadow : priv->unfocused_shadow)
     {
       g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
-      priv->shadow_clip = cairo_region_copy (beneath_region);
 
-      if (clip_shadow_under_window (self))
+      if (beneath_region)
         {
-          cairo_region_t *frame_bounds = meta_window_get_frame_bounds (priv->window);
-          cairo_region_subtract (priv->shadow_clip, frame_bounds);
+          priv->shadow_clip = cairo_region_copy (beneath_region);
+
+          if (clip_shadow_under_window (self))
+            {
+              cairo_region_t *frame_bounds = meta_window_get_frame_bounds (priv->window);
+              cairo_region_subtract (priv->shadow_clip, frame_bounds);
+            }
         }
+      else
+        priv->shadow_clip = NULL;
     }
 }
 
@@ -1805,17 +1652,12 @@ meta_window_actor_cull_out (MetaCullable   *cullable,
                             cairo_region_t *clip_region)
 {
   MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
+  MetaWindowActorPrivate *priv = self->priv;
 
-  if (!meta_is_wayland_compositor ())
-    {
-      MetaCompScreen *info = meta_screen_get_compositor_data (self->priv->screen);
+  /* Don't do any culling for the unredirected window */
+  if (priv->unredirected)
+    return;
 
-      /* Don't do any culling for the unredirected window */
-      if (self == info->unredirected_window)
-        return;
-    }
-
-  meta_window_actor_set_unobscured_region (self, unobscured_region);
   meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
   meta_window_actor_set_clip_region_beneath (self, clip_region);
 }
@@ -1854,9 +1696,6 @@ check_needs_x11_pixmap (MetaWindowActor *self)
   if (!priv->needs_pixmap)
     return;
 
-  if (!priv->mapped)
-    return;
-
   if (xwindow == meta_screen_get_xroot (screen) ||
       xwindow == clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage)))
     return;
@@ -1901,17 +1740,6 @@ check_needs_x11_pixmap (MetaWindowActor *self)
         g_warning ("NOTE: Not using GLX TFP!\n");
 
       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
-       * a change to the window size was exactly balanced by a change to the
-       * invisible borders, we would miss emitting the signal. We would also
-       * emit spurious signals when we get a new pixmap without a new size,
-       * but that should be mostly harmless.
-       */
-      g_signal_emit (self, signals[SIZE_CHANGED], 0);
     }
 
   priv->needs_pixmap = FALSE;
@@ -1930,9 +1758,6 @@ check_needs_shadow (MetaWindowActor *self)
   gboolean should_have_shadow;
   gboolean appears_focused;
 
-  if (!priv->mapped)
-    return;
-
   /* Calling meta_window_actor_has_shadow() here at every pre-paint is cheap
    * and avoids the need to explicitly handle window type changes, which
    * we would do if tried to keep track of when we might be adding or removing
@@ -1992,7 +1817,6 @@ 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;
 
@@ -2037,21 +1861,15 @@ meta_window_actor_process_x11_damage (MetaWindowActor    *self,
       return;
     }
 
-  if (!priv->mapped || priv->needs_pixmap)
+  if (priv->needs_pixmap)
     return;
 
-  unobscured_region =
-    clutter_actor_has_mapped_clones (CLUTTER_ACTOR (priv->surface))
-    ? NULL : priv->unobscured_region;
   redraw_queued = meta_surface_actor_damage_area (priv->surface,
                                                   event->area.x,
                                                   event->area.y,
                                                   event->area.width,
-                                                  event->area.height,
-                                                  unobscured_region);
-
-  priv->repaint_scheduled = priv->repaint_scheduled  || redraw_queued;
-
+                                                  event->area.height);
+  priv->repaint_scheduled = priv->repaint_scheduled || redraw_queued;
 }
 
 void
@@ -2316,9 +2134,6 @@ check_needs_reshape (MetaWindowActor *self)
   MetaFrameBorders borders;
   cairo_rectangle_int_t client_area;
 
-  if (!priv->mapped)
-    return;
-
   if (!priv->needs_reshape)
     return;
 

src/compositor/meta-window-group.c

@@ -115,8 +115,6 @@ meta_window_group_paint (ClutterActor *actor)
 {
   cairo_region_t *clip_region;
   cairo_region_t *unobscured_region;
-  ClutterActorIter iter;
-  ClutterActor *child;
   cairo_rectangle_int_t visible_rect, clip_rect;
   int paint_x_offset, paint_y_offset;
   int paint_x_origin, paint_y_origin;
@@ -125,18 +123,6 @@ meta_window_group_paint (ClutterActor *actor)
   MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
   ClutterActor *stage = clutter_actor_get_stage (actor);
 
-  /* Start off by treating all windows as completely unobscured, so damage anywhere
-   * in a window queues redraws, but confine it more below. */
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_next (&iter, &child))
-    {
-      if (META_IS_WINDOW_ACTOR (child))
-        {
-          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
-          meta_window_actor_set_unobscured_region (window_actor, NULL);
-        }
-    }
-
   /* Normally we expect an actor to be drawn at it's position on the screen.
    * However, if we're inside the paint of a ClutterClone, that won't be the
    * case and we need to compensate. We look at the position of the window
@@ -184,9 +170,8 @@ meta_window_group_paint (ClutterActor *actor)
       if (info->unredirected_window != NULL)
         {
           cairo_rectangle_int_t unredirected_rect;
-          MetaWindow *window = meta_window_actor_get_meta_window (info->unredirected_window);
 
-          meta_window_get_frame_rect (window, (MetaRectangle *)&unredirected_rect);
+          meta_window_get_frame_rect (info->unredirected_window, (MetaRectangle *)&unredirected_rect);
           cairo_region_subtract_rectangle (unobscured_region, &unredirected_rect);
           cairo_region_subtract_rectangle (clip_region, &unredirected_rect);
         }

src/compositor/plugins/default.c

@@ -32,7 +32,7 @@
 #include <gmodule.h>
 #include <string.h>
 
-#define DESTROY_TIMEOUT   250
+#define DESTROY_TIMEOUT   100
 #define MINIMIZE_TIMEOUT  250
 #define MAXIMIZE_TIMEOUT  250
 #define MAP_TIMEOUT       250
@@ -289,26 +289,13 @@ on_switch_workspace_effect_complete (ClutterTimeline *timeline, gpointer data)
   meta_plugin_switch_workspace_completed (plugin);
 }
 
-static gboolean
-show_stage (MetaPlugin *plugin)
-{
-  MetaScreen *screen;
-  ClutterActor *stage;
-
-  screen = meta_plugin_get_screen (plugin);
-  stage = meta_get_stage_for_screen (screen);
-
-  clutter_actor_show (stage);
-
-  return FALSE;
-}
-
 static void
 on_monitors_changed (MetaScreen *screen,
                      MetaPlugin *plugin)
 {
   MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
   int i, n;
+  GRand *rand = g_rand_new_with_seed (12345);
 
   clutter_actor_destroy_all_children (self->priv->background_group);
 
@@ -331,14 +318,16 @@ on_monitors_changed (MetaScreen *screen,
          reproducible.
       */
       clutter_color_init (&color,
-                          g_random_int () % 255,
-                          g_random_int () % 255,
-                          g_random_int () % 255,
+                          g_rand_int_range (rand, 0, 255),
+                          g_rand_int_range (rand, 0, 255),
+                          g_rand_int_range (rand, 0, 255),
                           255);
       clutter_actor_set_background_color (background, &color);
 
       clutter_actor_add_child (self->priv->background_group, background);
     }
+
+  g_rand_free (rand);
 }
 
 static void
@@ -355,10 +344,7 @@ start (MetaPlugin *plugin)
                     G_CALLBACK (on_monitors_changed), plugin);
   on_monitors_changed (screen, plugin);
 
-  meta_later_add (META_LATER_BEFORE_REDRAW,
-                  (GSourceFunc) show_stage,
-                  plugin,
-                  NULL);
+  clutter_actor_show (meta_get_stage_for_screen (screen));
 }
 
 static void
@@ -407,9 +393,11 @@ switch_workspace (MetaPlugin *plugin,
       MetaWindowActor *window_actor = l->data;
       ActorPrivate    *apriv	    = get_actor_private (window_actor);
       ClutterActor    *actor	    = CLUTTER_ACTOR (window_actor);
+      MetaWorkspace   *workspace;
       gint             win_workspace;
 
-      win_workspace = meta_window_actor_get_workspace (window_actor);
+      workspace = meta_window_get_workspace (meta_window_actor_get_meta_window (window_actor));
+      win_workspace = meta_workspace_index (workspace);
 
       if (win_workspace == to || win_workspace == from)
         {
@@ -481,8 +469,6 @@ on_minimize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
   /* FIXME - we shouldn't assume the original scale, it should be saved
    * at the start of the effect */
   clutter_actor_set_scale (data->actor, 1.0, 1.0);
-  clutter_actor_move_anchor_point_from_gravity (data->actor,
-                                                CLUTTER_GRAVITY_NORTH_WEST);
 
   /* Now notify the manager that we are done with this effect */
   meta_plugin_minimize_completed (plugin, window_actor);
@@ -519,9 +505,6 @@ minimize (MetaPlugin *plugin, MetaWindowActor *window_actor)
 
       apriv->is_minimized = TRUE;
 
-      clutter_actor_move_anchor_point_from_gravity (actor,
-                                                    CLUTTER_GRAVITY_CENTER);
-
       animation = clutter_actor_animate (actor,
                                          CLUTTER_EASE_IN_SINE,
                                          MINIMIZE_TIMEOUT,
@@ -560,8 +543,6 @@ on_maximize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data
 
   /* FIXME - don't assume the original scale was 1.0 */
   clutter_actor_set_scale (data->actor, 1.0, 1.0);
-  clutter_actor_move_anchor_point_from_gravity (data->actor,
-                                                CLUTTER_GRAVITY_NORTH_WEST);
 
   /* Now notify the manager that we are done with this effect */
   meta_plugin_maximize_completed (plugin, window_actor);
@@ -586,10 +567,8 @@ maximize (MetaPlugin *plugin,
   ClutterActor *actor = CLUTTER_ACTOR (window_actor);
   MetaWindow *meta_window = meta_window_actor_get_meta_window (window_actor);
 
-  gdouble  scale_x    = 1.0;
-  gdouble  scale_y    = 1.0;
-  gfloat   anchor_x   = 0;
-  gfloat   anchor_y   = 0;
+  gdouble  scale_x = 1.0;
+  gdouble  scale_y = 1.0;
 
   type = meta_window_get_window_type (meta_window);
 
@@ -613,13 +592,6 @@ maximize (MetaPlugin *plugin,
       scale_x = (gdouble)end_width / (gdouble) width;
       scale_y = (gdouble)end_height / (gdouble) height;
 
-      anchor_x = (gdouble)(x - end_x)*(gdouble)width /
-        ((gdouble)(end_width - width));
-      anchor_y = (gdouble)(y - end_y)*(gdouble)height /
-        ((gdouble)(end_height - height));
-
-      clutter_actor_move_anchor_point (actor, anchor_x, anchor_y);
-
       animation = clutter_actor_animate (actor,
                                          CLUTTER_EASE_IN_SINE,
                                          MAXIMIZE_TIMEOUT,
@@ -674,9 +646,6 @@ on_map_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data)
 
   apriv->tml_map = NULL;
 
-  clutter_actor_move_anchor_point_from_gravity (data->actor,
-                                                CLUTTER_GRAVITY_NORTH_WEST);
-
   /* Now notify the manager that we are done with this effect */
   meta_plugin_map_completed (plugin, window_actor);
 
@@ -702,15 +671,15 @@ map (MetaPlugin *plugin, MetaWindowActor *window_actor)
       EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
       ActorPrivate *apriv = get_actor_private (window_actor);
 
-      clutter_actor_move_anchor_point_from_gravity (actor,
-                                                    CLUTTER_GRAVITY_CENTER);
-
-      clutter_actor_set_scale (actor, 0.0, 0.0);
+      clutter_actor_set_pivot_point (actor, 0.5, 0.5);
+      clutter_actor_set_opacity (actor, 0);
+      clutter_actor_set_scale (actor, 0.5, 0.5);
       clutter_actor_show (actor);
 
       animation = clutter_actor_animate (actor,
-                                         CLUTTER_EASE_IN_SINE,
+                                         CLUTTER_EASE_OUT_QUAD,
                                          MAP_TIMEOUT,
+                                         "opacity", 255,
                                          "scale-x", 1.0,
                                          "scale-y", 1.0,
                                          NULL);
@@ -762,14 +731,12 @@ destroy (MetaPlugin *plugin, MetaWindowActor *window_actor)
       EffectCompleteData *data = g_new0 (EffectCompleteData, 1);
       ActorPrivate *apriv = get_actor_private (window_actor);
 
-      clutter_actor_move_anchor_point_from_gravity (actor,
-                                                    CLUTTER_GRAVITY_CENTER);
-
       animation = clutter_actor_animate (actor,
-                                         CLUTTER_EASE_IN_SINE,
+                                         CLUTTER_EASE_OUT_QUAD,
                                          DESTROY_TIMEOUT,
-                                         "scale-x", 0.0,
-                                         "scale-y", 1.0,
+                                         "opacity", 0,
+                                         "scale-x", 0.8,
+                                         "scale-y", 0.8,
                                          NULL);
       apriv->tml_destroy = clutter_animation_get_timeline (animation);
       data->plugin = plugin;

src/core/constraints.c

@@ -1353,7 +1353,6 @@ constrain_titlebar_visible (MetaWindow         *window,
       window->type == META_WINDOW_DOCK    ||
       window->fullscreen                  ||
       !window->require_titlebar_visible   ||
-      !window->decorated                  ||
       unconstrained_user_action)
     return TRUE;
 

src/core/delete.c

@@ -37,6 +37,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 
+#include "meta-wayland-surface.h"
+
 static void meta_window_present_delete_dialog (MetaWindow *window,
                                                guint32     timestamp);
 
@@ -130,35 +132,42 @@ void
 meta_window_check_alive (MetaWindow *window,
                          guint32     timestamp)
 {
-  meta_window_ping (window,
-                    timestamp,
-                    delete_ping_reply_func,
-                    delete_ping_timeout_func,
-                    NULL);
+  meta_display_ping_window (window,
+                            timestamp,
+                            delete_ping_reply_func,
+                            delete_ping_timeout_func,
+                            NULL);
 }
 
 void
 meta_window_delete (MetaWindow  *window,
                     guint32      timestamp)
 {
-  meta_error_trap_push (window->display);
-  if (window->delete_window)
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
     {
-      meta_topic (META_DEBUG_WINDOW_OPS,
-                  "Deleting %s with delete_window request\n",
-                  window->desc);
-      meta_window_send_icccm_message (window,
-                                      window->display->atom_WM_DELETE_WINDOW,
-                                      timestamp);
+      meta_error_trap_push (window->display);
+      if (window->delete_window)
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Deleting %s with delete_window request\n",
+                      window->desc);
+          meta_window_send_icccm_message (window,
+                                          window->display->atom_WM_DELETE_WINDOW,
+                                          timestamp);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Deleting %s with explicit kill\n",
+                      window->desc);
+          XKillClient (window->display->xdisplay, window->xwindow);
+        }
+      meta_error_trap_pop (window->display);
     }
   else
     {
-      meta_topic (META_DEBUG_WINDOW_OPS,
-                  "Deleting %s with explicit kill\n",
-                  window->desc);
-      XKillClient (window->display->xdisplay, window->xwindow);
+      meta_wayland_surface_delete (window->surface);
     }
-  meta_error_trap_pop (window->display);
 
   meta_window_check_alive (window, timestamp);
 

src/core/display-private.h

@@ -55,6 +55,10 @@ typedef struct _MetaWindowPropHooks MetaWindowPropHooks;
 
 typedef struct MetaEdgeResistanceData MetaEdgeResistanceData;
 
+typedef void (* MetaWindowPingFunc) (MetaWindow  *window,
+                                     guint32      timestamp,
+                                     gpointer     user_data);
+
 typedef enum {
   META_LIST_DEFAULT                   = 0,      /* normal windows */
   META_LIST_INCLUDE_OVERRIDE_REDIRECT = 1 << 0, /* normal and O-R */
@@ -183,7 +187,7 @@ struct _MetaDisplay
   guint32 window_sequence_counter;
 
   /* Pings which we're waiting for a reply from */
-  GHashTable *pending_pings;
+  GSList     *pending_pings;
 
   /* Pending focus change */
   guint       focus_timeout_id;
@@ -449,6 +453,14 @@ void meta_display_retheme_all (void);
 void meta_display_set_cursor_theme (const char *theme, 
 				    int         size);
 
+void meta_display_ping_window      (MetaWindow         *window,
+                                    guint32             timestamp,
+                                    MetaWindowPingFunc  ping_reply_func,
+                                    MetaWindowPingFunc  ping_timeout_func,
+                                    void               *user_data);
+void meta_display_pong_for_serial  (MetaDisplay        *display,
+                                    guint32             serial);
+
 int meta_resize_gravity_from_grab_op (MetaGrabOp op);
 
 gboolean meta_grab_op_is_moving   (MetaGrabOp op);

src/core/display.c

@@ -36,6 +36,7 @@
 #include <meta/main.h>
 #include "screen-private.h"
 #include "window-private.h"
+#include "window-x11.h"
 #include "window-props.h"
 #include "group-props.h"
 #include "frame.h"
@@ -81,6 +82,40 @@
          g == META_GRAB_OP_KEYBOARD_ESCAPING_DOCK   ||  \
          g == META_GRAB_OP_KEYBOARD_ESCAPING_GROUP)
 
+/*
+ * SECTION:pings
+ *
+ * Sometimes we want to see whether a window is responding,
+ * so we send it a "ping" message and see whether it sends us back a "pong"
+ * message within a reasonable time. Here we have a system which lets us
+ * nominate one function to be called if we get the pong in time and another
+ * function if we don't. The system is rather more complicated than it needs
+ * to be, since we only ever use it to destroy windows which are asked to
+ * close themselves and don't do so within a reasonable amount of time, and
+ * therefore we always use the same callbacks. It's possible that we might
+ * use it for other things in future, or on the other hand we might decide
+ * that we're never going to do so and simplify it a bit.
+ */
+
+/**
+ * MetaPingData:
+ *
+ * Describes a ping on a window. When we send a ping to a window, we build
+ * one of these structs, and it eventually gets passed to the timeout function
+ * or to the function which handles the response from the window. If the window
+ * does or doesn't respond to the ping, we use this information to deal with
+ * these facts; we have a handler function for each.
+ */
+typedef struct
+{
+  MetaWindow  *window;
+  guint32      timestamp;
+  MetaWindowPingFunc ping_reply_func;
+  MetaWindowPingFunc ping_timeout_func;
+  void        *user_data;
+  guint        ping_timeout_id;
+} MetaPingData;
+
 G_DEFINE_TYPE(MetaDisplay, meta_display, G_TYPE_OBJECT);
 
 /* Signals */
@@ -282,6 +317,62 @@ meta_display_class_init (MetaDisplayClass *klass)
                                                         G_PARAM_READABLE));
 }
 
+
+/**
+ * ping_data_free:
+ *
+ * Destructor for #MetaPingData structs. Will destroy the
+ * event source for the struct as well.
+ */
+static void
+ping_data_free (MetaPingData *ping_data)
+{
+  /* Remove the timeout */
+  if (ping_data->ping_timeout_id != 0)
+    g_source_remove (ping_data->ping_timeout_id);
+
+  g_free (ping_data);
+}
+
+/**
+ * remove_pending_pings_for_window:
+ * @display: The display the window appears on
+ * @xwindow: The X ID of the window whose pings we should remove
+ *
+ * Frees every pending ping structure for the given X window on the
+ * given display. This means that we also destroy the timeouts.
+ */
+static void
+remove_pending_pings_for_window (MetaDisplay *display, Window xwindow)
+{
+  GSList *tmp;
+  GSList *dead;
+
+  /* could obviously be more efficient, don't care */
+
+  /* build list to be removed */
+  dead = NULL;
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (ping_data->window->xwindow == xwindow)
+        dead = g_slist_prepend (dead, ping_data);
+    }
+
+  /* remove what we found */
+  for (tmp = dead; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
+      ping_data_free (ping_data);
+    }
+
+  g_slist_free (dead);
+}
+
+
 #ifdef HAVE_STARTUP_NOTIFICATION
 static void
 sn_error_trap_push (SnDisplay *sn_display,
@@ -387,7 +478,6 @@ meta_display_open (void)
   Display *xdisplay;
   GSList *screens;
   MetaScreen *screen;
-  GSList *tmp;
   int i;
   guint32 timestamp;
 
@@ -433,6 +523,7 @@ meta_display_open (void)
   the_display->server_grab_count = 0;
   the_display->display_opening = TRUE;
 
+  the_display->pending_pings = NULL;
   the_display->autoraise_timeout_id = 0;
   the_display->autoraise_window = NULL;
   the_display->focus_window = NULL;
@@ -504,7 +595,6 @@ meta_display_open (void)
 
   the_display->xids = g_hash_table_new (meta_unsigned_long_hash,
                                         meta_unsigned_long_equal);
-  the_display->pending_pings = g_hash_table_new (g_int_hash, g_int_equal);
   the_display->wayland_windows = g_hash_table_new (NULL, NULL);
 
   i = 0;
@@ -807,12 +897,7 @@ meta_display_open (void)
 
   screen = meta_screen_new (the_display, i, timestamp);
 
-  if (screen)
-    screens = g_slist_prepend (screens, screen);
-  
-  the_display->screens = screens;
-  
-  if (screens == NULL)
+  if (!screen)
     {
       /* This would typically happen because all the screens already
        * have window managers.
@@ -821,34 +906,19 @@ meta_display_open (void)
       return FALSE;
     }
 
+  screens = g_slist_prepend (screens, screen);
+
+  the_display->screens = screens;
+
   enable_compositor (the_display);
-   
-  /* Now manage all existing windows */
-  tmp = the_display->screens;
-  while (tmp != NULL)
-    {
-      MetaScreen *screen = tmp->data;
 
-      if (meta_is_wayland_compositor ())
-        {
-          /* Instead of explicitly enumerating all windows during
-           * initialization, when we run as a wayland compositor we can rely on
-           * xwayland notifying us of all top level windows so we create
-           * MetaWindows when we get those notifications.
-           *
-           * We still want a guard window so we can avoid
-           * unmapping/withdrawing minimized windows for live
-           * thumbnails...
-           */
-          if (screen->guard_window == None)
-            screen->guard_window =
-              meta_screen_create_guard_window (screen->display->xdisplay, screen);
-        }
-      else
-        meta_screen_manage_all_windows (screen);
+  meta_screen_create_guard_window (screen);
 
-      tmp = tmp->next;
-    }
+  /* We know that if mutter is running as a Wayland compositor,
+   * we start out with no windows.
+   */
+  if (!meta_is_wayland_compositor ())
+    meta_screen_manage_all_windows (screen);
 
   {
     Window focus;
@@ -1581,7 +1651,7 @@ handle_net_restack_window (MetaDisplay* display,
        *
        * Also, unconditionally following these is REALLY stupid--we should
        * combine this code with the stuff in
-       * meta_window_configure_request() which is smart about whether to
+       * meta_window_x11_configure_request() which is smart about whether to
        * follow the request or do something else (though not smart enough
        * and is also too stupid to handle the sibling stuff).
        */
@@ -1984,18 +2054,17 @@ meta_display_handle_event (MetaDisplay        *display,
                            const ClutterEvent *event)
 {
   MetaWindow *window;
+  gboolean bypass_clutter = FALSE, bypass_wayland = FALSE;
+  MetaWaylandCompositor *compositor = NULL;
 
   /* 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);
 
@@ -2055,8 +2124,9 @@ meta_display_handle_event (MetaDisplay        *display,
                 meta_stack_set_positions (window->screen->stack,
                                           display->grab_old_window_stacking);
             }
-          meta_display_end_grab_op (display,
-                                    event->any.time);
+          meta_display_end_grab_op (display, event->any.time);
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
         }
       else if (window && display->grab_op == META_GRAB_OP_NONE)
         {
@@ -2171,20 +2241,8 @@ meta_display_handle_event (MetaDisplay        *display,
                                      event->button.y,
                                      event->button.button,
                                      event->any.time);
-            }
-
-          if (!frame_was_receiver && unmodified)
-            {
-              /* This is from our synchronous grab since
-               * it has no modifiers and was on the client window
-               */
-
-              meta_verbose ("Allowing events time %u\n",
-                            (unsigned int) event->any.time);
-
-              /* XXX -- implement this in Wayland */
-              XIAllowEvents (display->xdisplay, META_VIRTUAL_CORE_POINTER_ID,
-                             XIReplayDevice, event->any.time);
+              bypass_clutter = TRUE;
+              bypass_wayland = TRUE;
             }
 
           if (begin_move && window->has_move_func)
@@ -2200,6 +2258,8 @@ meta_display_handle_event (MetaDisplay        *display,
                                           event->any.time,
                                           event->button.x,
                                           event->button.y);
+              bypass_clutter = TRUE;
+              bypass_wayland = TRUE;
             }
         }
       break;
@@ -2211,7 +2271,11 @@ meta_display_handle_event (MetaDisplay        *display,
 
       if (display->grab_window == window &&
           meta_grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_event (window, event);
+        {
+          meta_window_handle_mouse_grab_op_event (window, event);
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
+        }
       break;
     case CLUTTER_MOTION:
       if (display->grab_op == META_GRAB_OP_COMPOSITOR)
@@ -2219,7 +2283,11 @@ meta_display_handle_event (MetaDisplay        *display,
 
       if (display->grab_window == window &&
           meta_grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_event (window, event);
+        {
+          meta_window_handle_mouse_grab_op_event (window, event);
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
+        }
       break;
 
     case CLUTTER_KEY_PRESS:
@@ -2231,22 +2299,26 @@ meta_display_handle_event (MetaDisplay        *display,
        * want to pass the key event to the compositor or Wayland at all.
        */
       if (meta_display_process_key_event (display, window, (ClutterKeyEvent *) event))
-        return TRUE;
+        {
+          bypass_clutter = TRUE;
+          bypass_wayland = TRUE;
+        }
 
     default:
       break;
     }
 
-#ifdef HAVE_WAYLAND
-  if (compositor && (display->grab_op == META_GRAB_OP_NONE))
+  /* If the compositor has a grab, don't pass that through to Wayland */
+  if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+    bypass_wayland = TRUE;
+
+  if (compositor && !bypass_wayland)
     {
       if (meta_wayland_compositor_handle_event (compositor, event))
-        return TRUE;
+        bypass_clutter = TRUE;
     }
-#endif /* HAVE_WAYLAND */
 
-  return (display->grab_op != META_GRAB_OP_NONE &&
-          display->grab_op != META_GRAB_OP_COMPOSITOR);
+  return bypass_clutter;
 }
 
 static gboolean
@@ -2686,9 +2758,9 @@ handle_other_xevent (MetaDisplay *display,
           XShapeEvent *sev = (XShapeEvent*) event;
 
           if (sev->kind == ShapeBounding)
-            meta_window_update_shape_region_x11 (window);
+            meta_window_x11_update_shape_region (window);
           else if (sev->kind == ShapeInput)
-            meta_window_update_input_region_x11 (window);
+            meta_window_x11_update_input_region (window);
         }
       else
         {
@@ -2777,7 +2849,7 @@ handle_other_xevent (MetaDisplay *display,
 
           if (display->grab_op != META_GRAB_OP_NONE &&
               display->grab_window == window &&
-              ((window->frame == NULL) || !window->frame->mapped))
+              window->frame == NULL)
             meta_display_end_grab_op (display, timestamp);
 
           if (!frame_was_receiver)
@@ -2810,15 +2882,15 @@ handle_other_xevent (MetaDisplay *display,
       if (display->compositor && window == NULL
           && meta_display_screen_for_root (display, event->xmap.event))
         {
-          window = meta_window_new (display, event->xmap.window,
-                                    FALSE, META_COMP_EFFECT_CREATE);
+          window = meta_window_x11_new (display, event->xmap.window,
+                                        FALSE, META_COMP_EFFECT_CREATE);
         }
       break;
     case MapRequest:
       if (window == NULL)
         {
-          window = meta_window_new (display, event->xmaprequest.window,
-                                    FALSE, META_COMP_EFFECT_CREATE);
+          window = meta_window_x11_new (display, event->xmaprequest.window,
+                                        FALSE, META_COMP_EFFECT_CREATE);
         }
       /* if frame was receiver it's some malicious send event or something */
       else if (!frame_was_receiver && window)
@@ -2897,7 +2969,7 @@ handle_other_xevent (MetaDisplay *display,
       else
         {
           if (!frame_was_receiver)
-            meta_window_configure_request (window, event);
+            meta_window_x11_configure_request (window, event);
         }
       break;
     case GravityNotify:
@@ -2914,9 +2986,9 @@ handle_other_xevent (MetaDisplay *display,
         MetaScreen *screen;
 
         if (window && !frame_was_receiver)
-          meta_window_property_notify (window, event);
+          meta_window_x11_property_notify (window, event);
         else if (property_for_window && !frame_was_receiver)
-          meta_window_property_notify (property_for_window, event);
+          meta_window_x11_property_notify (property_for_window, event);
 
         group = meta_display_lookup_group (display,
                                            event->xproperty.window);
@@ -2987,7 +3059,7 @@ handle_other_xevent (MetaDisplay *display,
       if (window)
         {
           if (!frame_was_receiver)
-            meta_window_client_message (window, event);
+            meta_window_x11_client_message (window, event);
         }
       else
         {
@@ -3070,12 +3142,8 @@ handle_other_xevent (MetaDisplay *display,
                   if ((Atom)event->xclient.data.l[0] == display->atom__NET_WM_PING)
                     {
                       guint32 timestamp = event->xclient.data.l[1];
-                      window = g_hash_table_lookup (display->pending_pings, &timestamp);
 
-                      if (window)
-                        meta_window_pong (window, timestamp);
-                      else
-                        meta_verbose ("Received invalid _NET_WM_PING for unknown timestamp %d\n", timestamp);
+                      meta_display_pong_for_serial (display, timestamp);
 
                       /* We don't want ping reply events going into
                        * the GTK+ event loop because gtk+ will treat
@@ -3984,6 +4052,9 @@ meta_display_unregister_x_window (MetaDisplay *display,
   g_return_if_fail (g_hash_table_lookup (display->xids, &xwindow) != NULL);
 
   g_hash_table_remove (display->xids, &xwindow);
+
+  /* Remove any pending pings */
+  remove_pending_pings_for_window (display, xwindow);
 }
 
 void
@@ -4832,6 +4903,115 @@ meta_set_syncing (gboolean setting)
     }
 }
 
+/*
+ * How long, in milliseconds, we should wait after pinging a window
+ * before deciding it's not going to get back to us.
+ */
+#define PING_TIMEOUT_DELAY 5000
+
+/**
+ * meta_display_ping_timeout:
+ * @data: All the information about this ping. It is a #MetaPingData
+ *        cast to a #gpointer in order to be passable to a timeout function.
+ *        This function will also free this parameter.
+ *
+ * Does whatever it is we decided to do when a window didn't respond
+ * to a ping. We also remove the ping from the display's list of
+ * pending pings. This function is called by the event loop when the timeout
+ * times out which we created at the start of the ping.
+ *
+ * Returns: Always returns %FALSE, because this function is called as a
+ *          timeout and we don't want to run the timer again.
+ */
+static gboolean
+meta_display_ping_timeout (gpointer data)
+{
+  MetaPingData *ping_data = data;
+  MetaDisplay *display = ping_data->window->display;
+
+  ping_data->ping_timeout_id = 0;
+
+  meta_topic (META_DEBUG_PING,
+              "Ping %u on window %s timed out\n",
+              ping_data->timestamp, ping_data->window->desc);
+
+  (* ping_data->ping_timeout_func) (ping_data->window, ping_data->timestamp, ping_data->user_data);
+
+  display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
+  ping_data_free (ping_data);
+
+  return FALSE;
+}
+
+/**
+ * meta_display_ping_window:
+ * @display: The #MetaDisplay that the window is on
+ * @window: The #MetaWindow to send the ping to
+ * @timestamp: The timestamp of the ping. Used for uniqueness.
+ *             Cannot be CurrentTime; use a real timestamp!
+ * @ping_reply_func: The callback to call if we get a response.
+ * @ping_timeout_func: The callback to call if we don't get a response.
+ * @user_data: Arbitrary data that will be passed to the callback
+ *             function. (In practice it's often a pointer to
+ *             the window.)
+ *
+ * Sends a ping request to a window. The window must respond to
+ * the request within a certain amount of time. If it does, we
+ * will call one callback; if the time passes and we haven't had
+ * a response, we call a different callback. The window must have
+ * the hint showing that it can respond to a ping; if it doesn't,
+ * we call the "got a response" callback immediately and return.
+ * This function returns straight away after setting things up;
+ * the callbacks will be called from the event loop.
+ */
+void
+meta_display_ping_window (MetaWindow        *window,
+			  guint32            timestamp,
+			  MetaWindowPingFunc ping_reply_func,
+			  MetaWindowPingFunc ping_timeout_func,
+			  gpointer           user_data)
+{
+  MetaDisplay *display = window->display;
+  MetaPingData *ping_data;
+
+  if (timestamp == CurrentTime)
+    {
+      meta_warning ("Tried to ping a window with CurrentTime! Not allowed.\n");
+      return;
+    }
+
+  if (!window->net_wm_ping)
+    {
+      if (ping_reply_func)
+        (* ping_reply_func) (window, timestamp, user_data);
+
+      return;
+    }
+
+  ping_data = g_new (MetaPingData, 1);
+  ping_data->window = window;
+  ping_data->timestamp = timestamp;
+  ping_data->ping_reply_func = ping_reply_func;
+  ping_data->ping_timeout_func = ping_timeout_func;
+  ping_data->user_data = user_data;
+  ping_data->ping_timeout_id = g_timeout_add (PING_TIMEOUT_DELAY,
+					      meta_display_ping_timeout,
+					      ping_data);
+
+  display->pending_pings = g_slist_prepend (display->pending_pings, ping_data);
+
+  meta_topic (META_DEBUG_PING,
+              "Sending ping with timestamp %u to window %s\n",
+              timestamp, window->desc);
+
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    meta_window_send_icccm_message (window,
+                                    display->atom__NET_WM_PING,
+                                    timestamp);
+  else
+    meta_wayland_surface_ping (window->surface, timestamp);
+}
+
 static void
 process_request_frame_extents (MetaDisplay    *display,
                                XEvent         *event)
@@ -4892,6 +5072,56 @@ process_request_frame_extents (MetaDisplay    *display,
   meta_XFree (hints);
 }
 
+/**
+ * meta_display_pong_for_serial:
+ * @display: the display we got the pong from
+ * @serial: the serial in the pong repsonse
+ *
+ * Process the pong (the response message) from the ping we sent
+ * to the window. This involves removing the timeout, calling the
+ * reply handler function, and freeing memory.
+ */
+void
+meta_display_pong_for_serial (MetaDisplay    *display,
+                              guint32         serial)
+{
+  GSList *tmp;
+
+  meta_topic (META_DEBUG_PING, "Received a pong with serial %u\n", serial);
+
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (serial == ping_data->timestamp)
+        {
+          meta_topic (META_DEBUG_PING,
+                      "Matching ping found for pong %u\n",
+                      ping_data->timestamp);
+
+          /* Remove the ping data from the list */
+          display->pending_pings = g_slist_remove (display->pending_pings,
+                                                   ping_data);
+
+          /* Remove the timeout */
+          if (ping_data->ping_timeout_id != 0)
+            {
+              g_source_remove (ping_data->ping_timeout_id);
+              ping_data->ping_timeout_id = 0;
+            }
+
+          /* Call callback */
+          (* ping_data->ping_reply_func) (ping_data->window,
+                                          ping_data->timestamp,
+                                          ping_data->user_data);
+
+          ping_data_free (ping_data);
+
+          break;
+        }
+    }
+}
+
 MetaGroup*
 get_focussed_group (MetaDisplay *display)
 {

src/core/frame.c

@@ -62,7 +62,6 @@ meta_window_ensure_frame (MetaWindow *window)
   frame->right_width = 0;
   frame->current_cursor = 0;
 
-  frame->mapped = FALSE;
   frame->is_flashing = FALSE;
   frame->borders_cached = FALSE;
   
@@ -157,6 +156,8 @@ meta_window_ensure_frame (MetaWindow *window)
 
   /* Move keybindings to frame instead of window */
   meta_window_grab_keys (window);
+
+  meta_ui_map_frame (frame->window->screen->ui, frame->xwindow);
 }
 
 void

src/core/frame.h

@@ -47,7 +47,6 @@ struct _MetaFrame
   int right_width;
   int bottom_height;
 
-  guint mapped : 1;
   guint need_reapply_frame_shape : 1;
   guint is_flashing : 1; /* used by the visual bell flash */
   guint borders_cached : 1;

src/core/keybindings.c

@@ -28,7 +28,6 @@
  */
 
 #define _GNU_SOURCE
-#define _SVID_SOURCE /* for putenv() */
 
 #include <config.h>
 #include "keybindings-private.h"
@@ -42,6 +41,7 @@
 #include "screen-private.h"
 #include <meta/prefs.h>
 #include "util-private.h"
+#include "meta-wayland-private.h"
 
 #include <X11/keysym.h>
 #include <string.h>
@@ -52,13 +52,6 @@
 #include <X11/XKBlib.h>
 #endif
 
-#ifdef HAVE_WAYLAND
-#include "meta-wayland-private.h"
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <linux/vt.h>
-#endif
-
 #define SCHEMA_COMMON_KEYBINDINGS "org.gnome.desktop.wm.keybindings"
 #define SCHEMA_MUTTER_KEYBINDINGS "org.gnome.mutter.keybindings"
 #define SCHEMA_MUTTER_WAYLAND_KEYBINDINGS "org.gnome.mutter.wayland.keybindings"
@@ -4083,19 +4076,6 @@ handle_set_spew_mark (MetaDisplay     *display,
   meta_verbose ("-- MARK MARK MARK MARK --\n");
 }
 
-#ifdef HAVE_WAYLAND
-static gboolean
-activate_vt (int vt)
-{
-  int tty, reply;
-
-  tty = open ("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
-  reply = ioctl (tty, VT_ACTIVATE, vt);
-  close (tty);
-
-  return (reply == 0);
-}
-
 static void
 handle_switch_vt (MetaDisplay     *display,
                   MetaScreen      *screen,
@@ -4105,11 +4085,15 @@ handle_switch_vt (MetaDisplay     *display,
                   gpointer         dummy)
 {
   gint vt = binding->handler->data;
+  MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
+  GError *error = NULL;
 
-  if (!activate_vt (vt))
-    g_warning ("Failed to switch VT");
+  if (!meta_wayland_compositor_activate_vt (compositor, vt, &error))
+    {
+      g_warning ("Failed to switch VT: %s", error->message);
+      g_error_free (error);
+    }
 }
-#endif
 
 /**
  * meta_keybindings_set_custom_handler:
@@ -4414,7 +4398,6 @@ init_builtin_key_bindings (MetaDisplay *display)
                           META_KEYBINDING_ACTION_SET_SPEW_MARK,
                           handle_set_spew_mark, 0);
 
-#ifdef HAVE_WAYLAND
   if (meta_is_wayland_compositor ())
     {
       add_builtin_keybinding (display,
@@ -4466,7 +4449,6 @@ init_builtin_key_bindings (MetaDisplay *display)
                               META_KEYBINDING_ACTION_NONE,
                               handle_switch_vt, 7);
     }
-#endif
 
 #undef REVERSES_AND_REVERSED
 

src/core/main.c

@@ -254,19 +254,8 @@ meta_get_option_context (void)
   bindtextdomain (GETTEXT_PACKAGE, MUTTER_LOCALEDIR);
   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 
-  /* We must set the windowing backend here, because Clutter creates the backend
-     object when the first call is made.
-
-     We consider running from mutter-launch equivalent to running from bare metal.
-  */
-  if (getenv ("WESTON_LAUNCHER_SOCK"))
-    clutter_set_windowing_backend (CLUTTER_WINDOWING_EGL);
-
   ctx = g_option_context_new (NULL);
   g_option_context_add_main_entries (ctx, meta_options, GETTEXT_PACKAGE);
-  g_option_context_add_group (ctx, clutter_get_option_group_without_init ());
-  g_option_context_add_group (ctx, cogl_get_option_group ());
-
   return ctx;
 }
 
@@ -302,8 +291,12 @@ event_dispatch (GSource    *source,
                 gpointer    user_data)
 {
   ClutterEvent *event = clutter_event_get ();
+
   if (event)
-    clutter_do_event (event);
+    {
+      clutter_do_event (event);
+      clutter_event_free (event);
+    }
 
   return TRUE;
 }
@@ -341,16 +334,16 @@ meta_clutter_init (void)
  * also is %NULL, use the default - :0.0
  */
 static void
-meta_select_display (gchar *display_name)
+meta_select_display (char *display_arg)
 {
-  gchar *envVar = "";
-  if (display_name)
-    envVar = g_strconcat ("DISPLAY=", display_name, NULL);
-  else if (g_getenv ("MUTTER_DISPLAY"))
-    envVar = g_strconcat ("DISPLAY=",
-      g_getenv ("MUTTER_DISPLAY"), NULL);
-  /* DO NOT FREE envVar, putenv() sucks */
-  putenv (envVar);
+  const char *display_name;
+
+  if (display_arg)
+    display_name = (const char *) display_arg;
+  else
+    display_name = g_getenv ("MUTTER_DISPLAY");
+
+  g_setenv ("DISPLAY", display_name, TRUE);
 }
 
 static void
@@ -385,7 +378,8 @@ meta_init (void)
 {
   struct sigaction act;
   sigset_t empty_mask;
-  
+  ClutterSettings *clutter_settings;
+
   sigemptyset (&empty_mask);
   act.sa_handler = SIG_IGN;
   act.sa_mask    = empty_mask;
@@ -406,6 +400,10 @@ meta_init (void)
   if (g_getenv ("MUTTER_DEBUG"))
     meta_set_debugging (TRUE);
 
+  /* We consider running from mutter-launch equivalent to running from bare metal. */
+  if (getenv ("WESTON_LAUNCHER_SOCK"))
+    clutter_set_windowing_backend (CLUTTER_WINDOWING_EGL);
+
   meta_set_is_wayland_compositor (opt_wayland);
 
   if (g_get_home_dir ())
@@ -437,7 +435,7 @@ meta_init (void)
     meta_fatal ("Can't specify both SM save file and SM client id\n");
   
   meta_main_loop = g_main_loop_new (NULL, FALSE);
-  
+
   meta_ui_init ();
 
   /* If we are running with wayland then we don't wait until we have
@@ -451,6 +449,13 @@ meta_init (void)
        */
       meta_clutter_init ();
     }
+
+  /*
+   * XXX: We cannot handle high dpi scaling yet, so fix the scale to 1
+   * for now.
+   */
+  clutter_settings = clutter_settings_get_default ();
+  g_object_set (clutter_settings, "window-scaling-factor", 1, NULL);
 }
 
 /**

src/core/meta-cursor-tracker.c

@@ -468,47 +468,10 @@ meta_cursor_reference_from_buffer (MetaCursorTracker  *tracker,
 
       if (tracker->gbm)
         {
-          cogl_format = cogl_texture_get_format (COGL_TEXTURE (self->texture));
-          switch (cogl_format)
-            {
-#if G_BYTE_ORDER == G_LITTLE_ENDIAN
-            case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
-            case COGL_PIXEL_FORMAT_ARGB_8888:
-              gbm_format = GBM_FORMAT_BGRA8888;
-              break;
-            case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
-            case COGL_PIXEL_FORMAT_BGRA_8888:
-              break;
-            case COGL_PIXEL_FORMAT_RGB_888:
-              break;
-#else
-            case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
-            case COGL_PIXEL_FORMAT_ARGB_8888:
-              gbm_format = GBM_FORMAT_ARGB8888;
-              break;
-            case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
-            case COGL_PIXEL_FORMAT_BGRA_8888:
-              gbm_format = GBM_FORMAT_BGRA8888;
-              break;
-            case COGL_PIXEL_FORMAT_RGB_888:
-              gbm_format = GBM_FORMAT_RGB888;
-              break;
-#endif
-            default:
-              meta_warning ("Unknown cogl format %d\n", cogl_format);
-              return self;
-            }
-
-          if (gbm_device_is_format_supported (tracker->gbm, gbm_format,
-                                              GBM_BO_USE_CURSOR_64X64))
-            {
-              self->bo = gbm_bo_import (tracker->gbm, GBM_BO_IMPORT_WL_BUFFER,
-                                        buffer, GBM_BO_USE_CURSOR_64X64);
-              if (!self->bo)
-                meta_warning ("Importing HW cursor from wl_buffer failed\n");
-            }
-          else
-            meta_warning ("HW cursor for format %d not supported\n", gbm_format);
+          self->bo = gbm_bo_import (tracker->gbm, GBM_BO_IMPORT_WL_BUFFER,
+                                    buffer, GBM_BO_USE_CURSOR_64X64);
+          if (!self->bo)
+            meta_warning ("Importing HW cursor from wl_buffer failed\n");
         }
      }
 
@@ -607,12 +570,14 @@ make_wayland_cursor_tracker (MetaScreen *screen)
   compositor = meta_wayland_compositor_get_default ();
   compositor->seat->cursor_tracker = self;
 
-  if (meta_wayland_compositor_is_native (compositor))
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
     {
       CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (ctx));
       self->drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
       self->gbm = gbm_create_device (self->drm_fd);
     }
+#endif
 
   monitors = meta_monitor_manager_get ();
   g_signal_connect_object (monitors, "monitors-changed",
@@ -650,11 +615,9 @@ meta_cursor_tracker_get_for_screen (MetaScreen *screen)
   if (screen->cursor_tracker)
     return screen->cursor_tracker;
 
-#ifdef HAVE_WAYLAND
   if (meta_is_wayland_compositor ())
     self = make_wayland_cursor_tracker (screen);
   else
-#endif
     self = make_x11_cursor_tracker (screen);
 
   screen->cursor_tracker = self;

src/core/meta-idle-monitor.c

@@ -535,7 +535,7 @@ make_watch (MetaIdleMonitor           *monitor,
           watch->timeout_source = source;
         }
     }
-  else
+  else if (monitor->user_active_alarm != None)
     {
       if (timeout_msec != 0)
         {

src/core/monitor-kms.c

@@ -111,8 +111,7 @@ make_output_name (drmModeConnector *connector)
   };
   const char *connector_type_name;
 
-  if (connector->connector_type >= 0 &&
-      connector->connector_type < G_N_ELEMENTS (connector_type_names))
+  if (connector->connector_type < G_N_ELEMENTS (connector_type_names))
     connector_type_name = connector_type_names[connector->connector_type];
   else
     connector_type_name = "unknown";

src/core/monitor-private.h

@@ -42,9 +42,7 @@
 #include <meta/screen.h>
 #include "stack-tracker.h"
 #include "ui.h"
-#ifdef HAVE_WAYLAND
 #include <wayland-server.h>
-#endif
 #include "meta-xrandr-shared.h"
 
 #include "meta-dbus-xrandr.h"
@@ -54,19 +52,6 @@ typedef struct _MetaMonitorManager         MetaMonitorManager;
 typedef struct _MetaMonitorConfigClass    MetaMonitorConfigClass;
 typedef struct _MetaMonitorConfig         MetaMonitorConfig;
 
-#ifndef HAVE_WAYLAND
-enum wl_output_transform {
-  WL_OUTPUT_TRANSFORM_NORMAL,
-  WL_OUTPUT_TRANSFORM_90,
-  WL_OUTPUT_TRANSFORM_180,
-  WL_OUTPUT_TRANSFORM_270,
-  WL_OUTPUT_TRANSFORM_FLIPPED,
-  WL_OUTPUT_TRANSFORM_FLIPPED_90,
-  WL_OUTPUT_TRANSFORM_FLIPPED_180,
-  WL_OUTPUT_TRANSFORM_FLIPPED_270
-};
-#endif
-
 typedef struct _MetaOutput MetaOutput;
 typedef struct _MetaCRTC MetaCRTC;
 typedef struct _MetaMonitorMode MetaMonitorMode;

src/core/monitor.c

@@ -288,7 +288,7 @@ make_logical_config (MetaMonitorManager *manager)
 
       for (j = 0; j < monitor_infos->len; j++)
         {
-          MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, i);
+          MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, j);
           if (meta_rectangle_equal (&crtc->rect,
                                     &info->rect))
             {
@@ -356,19 +356,35 @@ make_logical_config (MetaMonitorManager *manager)
 static GType
 get_default_backend (void)
 {
-  if (meta_is_wayland_compositor ())
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
+    return META_TYPE_MONITOR_MANAGER_KMS;
+#endif
+
+#if defined(CLUTTER_WINDOWING_X11)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
     {
-      MetaWaylandCompositor *compositor;
-
-      compositor = meta_wayland_compositor_get_default ();
-
-      if (meta_wayland_compositor_is_native (compositor))
-        return META_TYPE_MONITOR_MANAGER_KMS;
-      else
+      /* If we're a Wayland compositor using the X11 backend,
+       * we're a nested configuration, so return the dummy
+       * monitor setup. */
+      if (meta_is_wayland_compositor ())
         return META_TYPE_MONITOR_MANAGER;
+      else
+        return META_TYPE_MONITOR_MANAGER_XRANDR;
     }
-  else
-    return META_TYPE_MONITOR_MANAGER_XRANDR;
+#endif
+
+#if defined(CLUTTER_WINDOWING_WAYLAND)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WAYLAND))
+    {
+      /* Use the dummy implementation on Wayland for now.
+       * In the future, we should support wl_fullscreen_output
+       * which will have CRTC management in the protocol. */
+      return META_TYPE_MONITOR_MANAGER;
+    }
+#endif
+
+  g_assert_not_reached ();
 }
 
 static MetaMonitorManager *

src/core/screen-private.h

@@ -241,7 +241,7 @@ void     meta_screen_workspace_switched (MetaScreen         *screen,
 
 void meta_screen_set_active_workspace_hint (MetaScreen *screen);
 
-Window   meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen);
+void meta_screen_create_guard_window (MetaScreen *screen);
 
 gboolean meta_screen_handle_xevent (MetaScreen *screen,
                                     XEvent     *xevent);

src/core/screen.c

@@ -389,6 +389,8 @@ int
 meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen,
                                              int         index)
 {
+  g_return_val_if_fail (index >= 0 && index < screen->n_monitor_infos, -1);
+
   meta_screen_ensure_xinerama_indices (screen);
 
   return screen->monitor_infos[index].xinerama_index;
@@ -445,17 +447,16 @@ reload_monitor_infos (MetaScreen *screen)
  * should effectively be forwarded to events on the background actor,
  * providing that the scene graph is set up correctly.
  */
-Window
-meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen)
+static Window
+create_guard_window (Display *xdisplay, MetaScreen *screen)
 {
   XSetWindowAttributes attributes;
   Window guard_window;
   gulong create_serial;
   MetaStackWindow stack_window;
-  
+
   attributes.event_mask = NoEventMask;
   attributes.override_redirect = True;
-  attributes.background_pixel = BlackPixel (xdisplay, screen->number);
 
   /* We have to call record_add() after we have the new window ID,
    * so save the serial for the CreateWindow request until then */
@@ -468,10 +469,10 @@ meta_screen_create_guard_window (Display *xdisplay, MetaScreen *screen)
 		   screen->rect.width,
 		   screen->rect.height,
 		   0, /* border width */
-		   CopyFromParent, /* depth */
-		   CopyFromParent, /* class */
+		   0, /* depth */
+		   InputOnly, /* class */
 		   CopyFromParent, /* visual */
-		   CWEventMask|CWOverrideRedirect|CWBackPixel,
+		   CWEventMask|CWOverrideRedirect,
 		   &attributes);
 
   {
@@ -878,6 +879,13 @@ meta_screen_free (MetaScreen *screen,
   meta_display_ungrab (display);
 }
 
+void
+meta_screen_create_guard_window (MetaScreen *screen)
+{
+  if (screen->guard_window == None)
+    screen->guard_window = create_guard_window (screen->display->xdisplay, screen);
+}
+
 void
 meta_screen_manage_all_windows (MetaScreen *screen)
 {
@@ -885,10 +893,6 @@ meta_screen_manage_all_windows (MetaScreen *screen)
   MetaStackWindow *children;
   int n_children, i;
 
-  if (screen->guard_window == None)
-    screen->guard_window =
-      meta_screen_create_guard_window (screen->display->xdisplay, screen);
-
   meta_stack_freeze (screen->stack);
   meta_stack_tracker_get_stack (screen->stack_tracker, &_children, &n_children);
 
@@ -897,8 +901,8 @@ meta_screen_manage_all_windows (MetaScreen *screen)
 
   for (i = 0; i < n_children; ++i)
     {
-      meta_window_new (screen->display, children[i].x11.xwindow, TRUE,
-                       META_COMP_EFFECT_NONE);
+      meta_window_x11_new (screen->display, children[i].x11.xwindow, TRUE,
+                           META_COMP_EFFECT_NONE);
     }
 
   g_free (children);

src/core/window-private.h

@@ -79,9 +79,7 @@ struct _MetaWindow
   const MetaMonitorInfo *monitor;
   MetaWorkspace *workspace;
   MetaWindowClientType client_type;
-#ifdef HAVE_WAYLAND
   MetaWaylandSurface *surface;
-#endif
   Window xwindow;
   /* may be NULL! not all windows get decorated */
   MetaFrame *frame;
@@ -467,8 +465,6 @@ struct _MetaWindow
 
   /* Bypass compositor hints */
   guint bypass_compositor;
-
-  GSList *pending_pings;
 };
 
 struct _MetaWindowClass
@@ -506,12 +502,22 @@ struct _MetaWindowClass
 #define META_WINDOW_ALLOWS_HORIZONTAL_RESIZE(w) (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_width < (w)->size_hints.max_width)
 #define META_WINDOW_ALLOWS_VERTICAL_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_height < (w)->size_hints.max_height)
 
-MetaWindow* meta_window_new                (MetaDisplay *display,
-                                            Window       xwindow,
-                                            gboolean     must_be_viewable,
-                                            MetaCompEffect     effect);
-MetaWindow *meta_window_new_for_wayland    (MetaDisplay        *display,
+MetaWindow * _meta_window_shared_new       (MetaDisplay         *display,
+                                            MetaScreen          *screen,
+                                            MetaWindowClientType client_type,
+                                            MetaWaylandSurface  *surface,
+                                            Window               xwindow,
+                                            gulong               existing_wm_state,
+                                            MetaCompEffect       effect,
+                                            XWindowAttributes   *attrs);
+
+MetaWindow * meta_window_x11_new           (MetaDisplay        *display,
+                                            Window              xwindow,
+                                            gboolean            must_be_viewable,
+                                            MetaCompEffect      effect);
+MetaWindow * meta_window_wayland_new       (MetaDisplay        *display,
                                             MetaWaylandSurface *surface);
+
 void        meta_window_unmanage           (MetaWindow  *window,
                                             guint32      timestamp);
 void        meta_window_calc_showing       (MetaWindow  *window);
@@ -615,12 +621,6 @@ void     meta_window_move_resize_wayland (MetaWindow *window,
                                           int         height,
                                           int         dx,
                                           int         dy);
-gboolean meta_window_configure_request (MetaWindow *window,
-                                        XEvent     *event);
-gboolean meta_window_property_notify   (MetaWindow *window,
-                                        XEvent     *event);
-gboolean meta_window_client_message    (MetaWindow *window,
-                                        XEvent     *event);
 void     meta_window_set_focused_internal (MetaWindow *window,
                                            gboolean    focused);
 
@@ -697,8 +697,6 @@ void meta_window_set_user_time (MetaWindow *window,
 
 void meta_window_update_icon_now (MetaWindow *window);
 
-void meta_window_update_role (MetaWindow *window);
-void meta_window_update_net_wm_type (MetaWindow *window);
 void meta_window_update_for_monitors_changed (MetaWindow *window);
 void meta_window_update_on_all_workspaces (MetaWindow *window);
 
@@ -712,10 +710,6 @@ void meta_window_compute_tile_match (MetaWindow *window);
 
 gboolean meta_window_updates_are_frozen (MetaWindow *window);
 
-void meta_window_update_opaque_region_x11 (MetaWindow *window);
-void meta_window_update_input_region_x11  (MetaWindow *window);
-void meta_window_update_shape_region_x11  (MetaWindow *window);
-
 void meta_window_set_title                (MetaWindow *window,
                                            const char *title);
 void meta_window_set_wm_class             (MetaWindow *window,
@@ -735,6 +729,9 @@ void meta_window_set_transient_for        (MetaWindow *window,
 void meta_window_set_opacity              (MetaWindow *window,
                                            guint       opacity);
 
+void meta_window_set_custom_frame_extents (MetaWindow *window,
+                                           GtkBorder  *extents);
+
 void meta_window_handle_enter (MetaWindow  *window,
                                guint32      timestamp,
                                guint        root_x,
@@ -743,17 +740,11 @@ void meta_window_handle_enter (MetaWindow  *window,
 void meta_window_set_surface_mapped (MetaWindow *window,
                                      gboolean    surface_mapped);
 
-typedef void (* MetaWindowPingFunc) (MetaWindow  *window,
-				     guint32      timestamp,
-				     gpointer     user_data);
-
-void meta_window_ping (MetaWindow         *window,
-                       guint32             timestamp,
-                       MetaWindowPingFunc  ping_reply_func,
-                       MetaWindowPingFunc  ping_timeout_func,
-                       void               *user_data);
-void meta_window_pong (MetaWindow *window,
-                       guint32     timestamp);
 Window meta_window_get_toplevel_xwindow (MetaWindow *window);
 
+void meta_window_activate_full (MetaWindow     *window,
+                                guint32         timestamp,
+                                MetaClientType  source_indication,
+                                MetaWorkspace  *workspace);
+
 #endif

src/core/window-props.c

@@ -39,6 +39,7 @@
 
 #include <config.h>
 #include "window-props.h"
+#include "window-x11.h"
 #include <meta/errors.h>
 #include "xprops.h"
 #include "frame.h"
@@ -229,7 +230,7 @@ reload_net_wm_window_type (MetaWindow    *window,
                            MetaPropValue *value,
                            gboolean       initial)
 {
-  meta_window_update_net_wm_type (window);
+  meta_window_x11_update_net_wm_type (window);
 }
 
 static void
@@ -302,22 +303,18 @@ reload_gtk_frame_extents (MetaWindow    *window,
         }
       else
         {
-          GtkBorder *extents = &window->custom_frame_extents;
-
-          window->has_custom_frame_extents = TRUE;
-          extents->left   = (int)value->v.cardinal_list.cardinals[0];
-          extents->right  = (int)value->v.cardinal_list.cardinals[1];
-          extents->top    = (int)value->v.cardinal_list.cardinals[2];
-          extents->bottom = (int)value->v.cardinal_list.cardinals[3];
+          GtkBorder extents;
+          extents.left   = (int)value->v.cardinal_list.cardinals[0];
+          extents.right  = (int)value->v.cardinal_list.cardinals[1];
+          extents.top    = (int)value->v.cardinal_list.cardinals[2];
+          extents.bottom = (int)value->v.cardinal_list.cardinals[3];
+          meta_window_set_custom_frame_extents (window, &extents);
         }
     }
   else
     {
-      window->has_custom_frame_extents = FALSE;
+      meta_window_set_custom_frame_extents (window, NULL);
     }
-
-  if (!initial)
-    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
 }
 
 static void
@@ -333,7 +330,7 @@ reload_wm_window_role (MetaWindow    *window,
                        MetaPropValue *value,
                        gboolean       initial)
 {
-  meta_window_update_role (window);
+  meta_window_x11_update_role (window);
 }
 
 static void
@@ -558,7 +555,7 @@ reload_opaque_region (MetaWindow    *window,
                       MetaPropValue *value,
                       gboolean       initial)
 {
-  meta_window_update_opaque_region_x11 (window);
+  meta_window_x11_update_opaque_region (window);
 }
 
 static void
@@ -845,7 +842,7 @@ reload_mwm_hints (MetaWindow    *window,
 
   meta_window_recalc_features (window);
   
-  /* We do all this anyhow at the end of meta_window_new() */
+  /* We do all this anyhow at the end of meta_window_x11_new() */
   if (!window->constructing)
     {
       if (window->decorated)
@@ -1764,8 +1761,8 @@ meta_display_init_window_prop_hooks (MetaDisplay *display)
     { display->atom__NET_WM_ICON_GEOMETRY, META_PROP_VALUE_CARDINAL_LIST, reload_icon_geometry,     FALSE, FALSE },
     { display->atom_WM_CLIENT_LEADER,  META_PROP_VALUE_INVALID, complain_about_broken_client, FALSE, FALSE },
     { display->atom_SM_CLIENT_ID,      META_PROP_VALUE_INVALID, complain_about_broken_client, FALSE, FALSE },
-    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role,        FALSE, FALSE },
-    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type,  FALSE, TRUE },
+    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role,         TRUE, FALSE },
+    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type,  TRUE, TRUE },
     { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
     { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
     { display->atom__NET_WM_BYPASS_COMPOSITOR, META_PROP_VALUE_CARDINAL,  reload_bypass_compositor, FALSE, FALSE },

src/core/window-x11.h

@@ -0,0 +1,45 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef META_WINDOW_X11_H
+#define META_WINDOW_X11_H
+
+#include <meta/window.h>
+#include <X11/Xlib.h>
+
+void meta_window_x11_set_net_wm_state            (MetaWindow *window);
+void meta_window_x11_set_wm_state                (MetaWindow *window);
+
+void meta_window_x11_update_role                 (MetaWindow *window);
+void meta_window_x11_update_net_wm_type          (MetaWindow *window);
+void meta_window_x11_update_opaque_region        (MetaWindow *window);
+void meta_window_x11_update_input_region         (MetaWindow *window);
+void meta_window_x11_update_shape_region         (MetaWindow *window);
+
+gboolean meta_window_x11_configure_request       (MetaWindow *window,
+                                                  XEvent     *event);
+gboolean meta_window_x11_property_notify         (MetaWindow *window,
+                                                  XEvent     *event);
+gboolean meta_window_x11_client_message          (MetaWindow *window,
+                                                  XEvent     *event);
+
+#endif

src/meta/compositor.h

@@ -75,11 +75,10 @@ gboolean meta_compositor_filter_keybinding (MetaCompositor *compositor,
                                             MetaScreen     *screen,
                                             MetaKeyBinding *binding);
 
-void meta_compositor_add_window    (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-void meta_compositor_remove_window (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-
+void meta_compositor_add_window        (MetaCompositor      *compositor,
+                                        MetaWindow          *window);
+void meta_compositor_remove_window     (MetaCompositor      *compositor,
+                                        MetaWindow          *window);
 void meta_compositor_show_window       (MetaCompositor      *compositor,
                                         MetaWindow          *window,
                                         MetaCompEffect       effect);
@@ -101,10 +100,6 @@ void meta_compositor_unmaximize_window (MetaCompositor      *compositor,
                                         MetaRectangle       *old_rect,
                                         MetaRectangle       *new_rect);
 
-void meta_compositor_window_mapped        (MetaCompositor *compositor,
-                                           MetaWindow     *window);
-void meta_compositor_window_unmapped      (MetaCompositor *compositor,
-                                           MetaWindow     *window);
 void meta_compositor_sync_window_geometry (MetaCompositor *compositor,
                                            MetaWindow     *window,
                                            gboolean        did_placement);

src/meta/meta-shaped-texture.h

@@ -69,8 +69,7 @@ gboolean meta_shaped_texture_update_area (MetaShapedTexture *stex,
                                           int                x,
                                           int                y,
                                           int                width,
-                                          int                height,
-                                          cairo_region_t    *unobscured_region);
+                                          int                height);
 
 CoglTexture * meta_shaped_texture_get_texture (MetaShapedTexture *stex);
 

src/meta/meta-window-actor.h

@@ -58,11 +58,8 @@ struct _MetaWindowActor
 GType meta_window_actor_get_type (void);
 
 Window             meta_window_actor_get_x_window         (MetaWindowActor *self);
-gint               meta_window_actor_get_workspace        (MetaWindowActor *self);
 MetaWindow *       meta_window_actor_get_meta_window      (MetaWindowActor *self);
 ClutterActor *     meta_window_actor_get_texture          (MetaWindowActor *self);
-gboolean           meta_window_actor_is_override_redirect (MetaWindowActor *self);
-gboolean       meta_window_actor_showing_on_its_workspace (MetaWindowActor *self);
 gboolean       meta_window_actor_is_destroyed (MetaWindowActor *self);
 
 #endif /* META_WINDOW_ACTOR_H */

src/meta/window.h

@@ -189,8 +189,6 @@ gboolean          meta_window_requested_bypass_compositor (MetaWindow *window);
 gboolean          meta_window_requested_dont_bypass_compositor (MetaWindow *window);
 gint             *meta_window_get_all_monitors (MetaWindow *window, gsize *length);
 
-gboolean meta_window_is_mapped (MetaWindow  *window);
-gboolean meta_window_toplevel_is_mapped (MetaWindow  *window);
 gboolean meta_window_get_icon_geometry (MetaWindow    *window,
                                         MetaRectangle *rect);
 void meta_window_set_icon_geometry (MetaWindow    *window,

src/wayland/meta-wayland-keyboard.c

@@ -115,7 +115,7 @@ inform_clients_of_new_keymap (MetaWaylandKeyboard *keyboard,
   struct wl_resource *keyboard_resource;
 
   compositor = meta_wayland_compositor_get_default ();
-  xclient = compositor->xwayland_client;
+  xclient = compositor->xwayland_manager.client;
 
   wl_resource_for_each (keyboard_resource, &keyboard->resource_list)
     {
@@ -201,13 +201,17 @@ meta_wayland_keyboard_take_keymap (MetaWaylandKeyboard *keyboard,
   strcpy (xkb_info->keymap_area, keymap_str);
   free (keymap_str);
 
-  if (keyboard->is_evdev)
+#if defined(CLUTTER_WINDOWING_EGL)
+  /* XXX -- the evdev backend can be used regardless of the
+   * windowing backend. To do this properly we need a Clutter
+   * API to check the input backend. */
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
     {
       ClutterDeviceManager *manager;
-
       manager = clutter_device_manager_get_default ();
       clutter_evdev_set_keyboard_map (manager, xkb_info->keymap);
     }
+#endif
 
   inform_clients_of_new_keymap (keyboard, flags);
 
@@ -222,13 +226,27 @@ err_keymap_str:
 }
 
 static void
-lose_keyboard_focus (struct wl_listener *listener, void *data)
+release_focus (MetaWaylandKeyboard *keyboard)
 {
-  MetaWaylandKeyboard *keyboard =
-    wl_container_of (listener, keyboard, focus_listener);
+  wl_list_remove (&keyboard->focus_surface_listener.link);
+  wl_list_remove (&keyboard->focus_resource_listener.link);
 
   keyboard->focus_resource = NULL;
-  keyboard->focus = NULL;
+  keyboard->focus_surface = NULL;
+}
+
+static void
+keyboard_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_surface_listener);
+  release_focus (keyboard);
+}
+
+static void
+keyboard_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_resource_listener);
+  release_focus (keyboard);
 }
 
 static gboolean
@@ -284,10 +302,9 @@ default_grab_modifiers (MetaWaylandKeyboardGrab *grab, uint32_t serial,
   wl_keyboard_send_modifiers (resource, serial, mods_depressed,
                               mods_latched, mods_locked, group);
 
-  if (pointer && pointer->focus && pointer->focus != keyboard->focus)
+  if (pointer && pointer->focus_surface && pointer->focus_surface != keyboard->focus_surface)
     {
-      pr = find_resource_for_surface (&keyboard->resource_list,
-                                      pointer->focus);
+      pr = find_resource_for_surface (&keyboard->resource_list, pointer->focus_surface);
       if (pr)
         {
           wl_keyboard_send_modifiers (pr, serial,
@@ -332,15 +349,17 @@ static MetaWaylandKeyboardGrabInterface modal_grab = {
 
 gboolean
 meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
-                            struct wl_display   *display,
-			    gboolean             is_evdev)
+                            struct wl_display   *display)
 {
   memset (keyboard, 0, sizeof *keyboard);
   keyboard->xkb_info.keymap_fd = -1;
 
   wl_list_init (&keyboard->resource_list);
   wl_array_init (&keyboard->keys);
-  keyboard->focus_listener.notify = lose_keyboard_focus;
+
+  keyboard->focus_surface_listener.notify = keyboard_handle_focus_surface_destroy;
+  keyboard->focus_resource_listener.notify = keyboard_handle_focus_resource_destroy;
+
   keyboard->default_grab.interface = &default_keyboard_grab_interface;
   keyboard->default_grab.keyboard = keyboard;
   keyboard->grab = &keyboard->default_grab;
@@ -348,7 +367,6 @@ meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
   keyboard->display = display;
 
   keyboard->xkb_context = xkb_context_new (0 /* flags */);
-  keyboard->is_evdev = is_evdev;
 
   /* Compute a default until gnome-settings-daemon starts and sets
      the appropriate values
@@ -512,19 +530,27 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
   struct wl_resource *resource;
   uint32_t serial;
 
-  if (keyboard->focus == surface && keyboard->focus_resource != NULL)
+  if (keyboard->focus_surface == surface && keyboard->focus_resource != NULL)
     return;
 
   resource = keyboard->focus_resource;
-  if (keyboard->focus_resource && keyboard->focus->resource)
+  if (resource)
     {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_keyboard_send_leave (resource, serial, keyboard->focus->resource);
-      wl_list_remove (&keyboard->focus_listener.link);
+      if (keyboard->focus_surface->resource)
+        {
+          struct wl_client *client = wl_resource_get_client (resource);
+          struct wl_display *display = wl_client_get_display (client);
+          serial = wl_display_next_serial (display);
+          wl_keyboard_send_leave (resource, serial, keyboard->focus_surface->resource);
 
-      meta_wayland_surface_focused_unset (keyboard->focus);
+          meta_wayland_surface_deactivated (keyboard->focus_surface);
+        }
+
+      wl_list_remove (&keyboard->focus_resource_listener.link);
+      wl_list_remove (&keyboard->focus_surface_listener.link);
+
+      keyboard->focus_resource = NULL;
+      keyboard->focus_surface = NULL;
     }
 
   resource = find_resource_for_surface (&keyboard->resource_list, surface);
@@ -557,14 +583,17 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
 	  wl_keyboard_send_enter (resource, serial, surface->resource,
 				  &keyboard->keys);
 	}
-      wl_resource_add_destroy_listener (resource, &keyboard->focus_listener);
+
+      meta_wayland_surface_activated (surface);
+
+      keyboard->focus_resource = resource;
+      keyboard->focus_surface = surface;
+
+      wl_resource_add_destroy_listener (keyboard->focus_resource, &keyboard->focus_resource_listener);
+      wl_resource_add_destroy_listener (keyboard->focus_surface->resource, &keyboard->focus_surface_listener);
+
       keyboard->focus_serial = serial;
-
-      meta_wayland_surface_focused_set (surface);
     }
-
-  keyboard->focus_resource = resource;
-  keyboard->focus = surface;
 }
 
 void
@@ -590,8 +619,6 @@ meta_wayland_keyboard_release (MetaWaylandKeyboard *keyboard)
   xkb_context_unref (keyboard->xkb_context);
 
   /* XXX: What about keyboard->resource_list? */
-  if (keyboard->focus_resource)
-    wl_list_remove (&keyboard->focus_listener.link);
   wl_array_release (&keyboard->keys);
 }
 
@@ -610,7 +637,7 @@ meta_wayland_keyboard_begin_modal (MetaWaylandKeyboard *keyboard,
   if (keyboard->grab != &keyboard->default_grab)
     return FALSE;
 
-  if (keyboard->focus)
+  if (keyboard->focus_surface)
     {
       /* Fake key release events for the focused app */
       serial = wl_display_next_serial (keyboard->display);
@@ -652,7 +679,7 @@ meta_wayland_keyboard_end_modal (MetaWaylandKeyboard *keyboard,
   meta_wayland_keyboard_end_grab (keyboard);
   g_slice_free (MetaWaylandKeyboardGrab, grab);
 
-  if (keyboard->focus)
+  if (keyboard->focus_surface)
     {
       /* Fake key press events for the focused app */
       serial = wl_display_next_serial (keyboard->display);

src/wayland/meta-wayland-keyboard.h

@@ -92,9 +92,11 @@ typedef struct
 struct _MetaWaylandKeyboard
 {
   struct wl_list resource_list;
-  MetaWaylandSurface *focus;
+
+  MetaWaylandSurface *focus_surface;
+  struct wl_listener focus_surface_listener;
   struct wl_resource *focus_resource;
-  struct wl_listener focus_listener;
+  struct wl_listener focus_resource_listener;
   uint32_t focus_serial;
 
   MetaWaylandKeyboardGrab *grab;
@@ -110,7 +112,6 @@ struct _MetaWaylandKeyboard
   struct wl_display *display;
 
   struct xkb_context *xkb_context;
-  gboolean is_evdev;
   MetaWaylandXkbInfo xkb_info;
 
   MetaWaylandKeyboardGrab input_method_grab;
@@ -119,8 +120,7 @@ struct _MetaWaylandKeyboard
 
 gboolean
 meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
-                            struct wl_display   *display,
-			    gboolean             is_evdev);
+                            struct wl_display   *display);
 
 typedef enum {
   META_WAYLAND_KEYBOARD_SKIP_XCLIENTS = 1,

src/wayland/meta-wayland-pointer.c

@@ -64,13 +64,27 @@ meta_wayland_pointer_get_seat (MetaWaylandPointer *pointer)
 }
 
 static void
-lose_pointer_focus (struct wl_listener *listener, void *data)
+release_focus (MetaWaylandPointer *pointer)
 {
-  MetaWaylandPointer *pointer =
-    wl_container_of (listener, pointer, focus_listener);
+  wl_list_remove (&pointer->focus_surface_listener.link);
+  wl_list_remove (&pointer->focus_resource_listener.link);
 
   pointer->focus_resource = NULL;
-  pointer->focus = NULL;
+  pointer->focus_surface = NULL;
+}
+
+static void
+pointer_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_surface_listener);
+  release_focus (pointer);
+}
+
+static void
+pointer_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
+{
+  MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_resource_listener);
+  release_focus (pointer);
 }
 
 static void
@@ -98,7 +112,7 @@ default_grab_motion (MetaWaylandPointerGrab *grab,
       wl_fixed_t sx, sy;
 
       meta_wayland_pointer_get_relative_coordinates (grab->pointer,
-						     grab->pointer->focus,
+						     grab->pointer->focus_surface,
 						     &sx, &sy);
       wl_pointer_send_motion (resource, clutter_event_get_time (event), sx, sy);
     }
@@ -258,8 +272,7 @@ pointer_constrain_callback (ClutterInputDevice *device,
 }
 
 void
-meta_wayland_pointer_init (MetaWaylandPointer *pointer,
-			   gboolean            is_native)
+meta_wayland_pointer_init (MetaWaylandPointer *pointer)
 {
   ClutterDeviceManager *manager;
   ClutterInputDevice *device;
@@ -267,7 +280,10 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer,
 
   memset (pointer, 0, sizeof *pointer);
   wl_list_init (&pointer->resource_list);
-  pointer->focus_listener.notify = lose_pointer_focus;
+
+  pointer->focus_surface_listener.notify = pointer_handle_focus_surface_destroy;
+  pointer->focus_resource_listener.notify = pointer_handle_focus_resource_destroy;
+
   pointer->default_grab.interface = &default_pointer_grab_interface;
   pointer->default_grab.pointer = pointer;
   pointer->grab = &pointer->default_grab;
@@ -275,9 +291,16 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer,
   manager = clutter_device_manager_get_default ();
   device = clutter_device_manager_get_core_device (manager, CLUTTER_POINTER_DEVICE);
 
-  if (is_native)
-    clutter_evdev_set_pointer_constrain_callback (manager, pointer_constrain_callback,
-						  pointer, NULL);
+#if defined(CLUTTER_WINDOWING_EGL)
+  /* XXX -- the evdev backend can be used regardless of the
+   * windowing backend. To do this properly we need a Clutter
+   * API to check the input backend. */
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
+    {
+      clutter_evdev_set_pointer_constrain_callback (manager, pointer_constrain_callback,
+                                                    pointer, NULL);
+    }
+#endif
 
   clutter_input_device_get_coords (device, NULL, &current);
   pointer->x = wl_fixed_from_double (current.x);
@@ -287,12 +310,7 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer,
 void
 meta_wayland_pointer_release (MetaWaylandPointer *pointer)
 {
-  /* XXX: What about pointer->resource_list? */
-  if (pointer->focus_resource)
-    wl_list_remove (&pointer->focus_listener.link);
-
-  pointer->focus = NULL;
-  pointer->focus_resource = NULL;
+  release_focus (pointer);
 }
 
 static struct wl_resource *
@@ -318,17 +336,25 @@ meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
   struct wl_resource *resource, *kr;
   uint32_t serial;
 
-  if (pointer->focus == surface && pointer->focus_resource != NULL)
+  if (pointer->focus_surface == surface && pointer->focus_resource != NULL)
     return;
 
   resource = pointer->focus_resource;
-  if (resource && pointer->focus->resource)
+  if (resource)
     {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      serial = wl_display_next_serial (display);
-      wl_pointer_send_leave (resource, serial, pointer->focus->resource);
-      wl_list_remove (&pointer->focus_listener.link);
+      if (pointer->focus_surface->resource)
+        {
+          struct wl_client *client = wl_resource_get_client (resource);
+          struct wl_display *display = wl_client_get_display (client);
+          serial = wl_display_next_serial (display);
+          wl_pointer_send_leave (resource, serial, pointer->focus_surface->resource);
+        }
+
+      wl_list_remove (&pointer->focus_surface_listener.link);
+      wl_list_remove (&pointer->focus_resource_listener.link);
+
+      pointer->focus_surface = NULL;
+      pointer->focus_resource = NULL;
     }
 
   resource = find_resource_for_surface (&pointer->resource_list, surface);
@@ -361,12 +387,15 @@ meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
                                 wl_fixed_to_int (pointer->x),
                                 wl_fixed_to_int (pointer->y));
       wl_pointer_send_enter (resource, serial, surface->resource, sx, sy);
-      wl_resource_add_destroy_listener (resource, &pointer->focus_listener);
+
+      pointer->focus_resource = resource;
+      pointer->focus_surface = surface;
+
+      wl_resource_add_destroy_listener (pointer->focus_resource, &pointer->focus_resource_listener);
+      wl_resource_add_destroy_listener (pointer->focus_surface->resource, &pointer->focus_surface_listener);
+
       pointer->focus_serial = serial;
     }
-
-  pointer->focus_resource = resource;
-  pointer->focus = surface;
 }
 
 void
@@ -563,15 +592,13 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,
 
   if (pointer->grab != &pointer->default_grab)
     {
-      if (pointer->grab->interface == &popup_grab_interface)
-	{
-	  grab = (MetaWaylandPopupGrab*)pointer->grab;
+      if (pointer->grab->interface != &popup_grab_interface)
+        return FALSE;
 
-	  if (wl_resource_get_client (surface->resource) != grab->grab_client)
-	    return FALSE;
-	}
+      grab = (MetaWaylandPopupGrab*)pointer->grab;
 
-      return FALSE;
+      if (wl_resource_get_client (surface->resource) != grab->grab_client)
+        return FALSE;
     }
 
   if (pointer->grab == &pointer->default_grab)

src/wayland/meta-wayland-pointer.h

@@ -46,9 +46,11 @@ struct _MetaWaylandPointerGrab
 struct _MetaWaylandPointer
 {
   struct wl_list resource_list;
-  MetaWaylandSurface *focus;
+
+  MetaWaylandSurface *focus_surface;
+  struct wl_listener focus_surface_listener;
   struct wl_resource *focus_resource;
-  struct wl_listener focus_listener;
+  struct wl_listener focus_resource_listener;
   guint32 focus_serial;
   guint32 click_serial;
 
@@ -67,8 +69,7 @@ struct _MetaWaylandPointer
 };
 
 void
-meta_wayland_pointer_init (MetaWaylandPointer *pointer,
-			   gboolean            is_native);
+meta_wayland_pointer_init (MetaWaylandPointer *pointer);
 
 void
 meta_wayland_pointer_release (MetaWaylandPointer *pointer);

src/wayland/meta-wayland-private.h

@@ -59,28 +59,34 @@ typedef struct
   struct wl_resource *resource;
 } MetaWaylandFrameCallback;
 
+typedef struct
+{
+  int display_index;
+  char *lockfile;
+  int abstract_fd;
+  int unix_fd;
+  pid_t pid;
+  struct wl_client *client;
+  struct wl_resource *xserver_resource;
+  char *display_name;
+
+  GMainLoop *init_loop;
+} MetaXWaylandManager;
+
 struct _MetaWaylandCompositor
 {
   struct wl_display *wayland_display;
   char *display_name;
   struct wl_event_loop *wayland_loop;
-  GMainLoop *init_loop;
   ClutterActor *stage;
   GHashTable *outputs;
   GSource *wayland_event_source;
   GList *surfaces;
   struct wl_list frame_callbacks;
 
-  int xwayland_display_index;
-  char *xwayland_lockfile;
-  int xwayland_abstract_fd;
-  int xwayland_unix_fd;
-  pid_t xwayland_pid;
-  struct wl_client *xwayland_client;
-  struct wl_resource *xserver_resource;
+  MetaXWaylandManager xwayland_manager;
 
   MetaLauncher *launcher;
-  gboolean native;
 
   MetaWaylandSeat *seat;
 };
@@ -99,15 +105,16 @@ void                    meta_wayland_compositor_set_input_focus (MetaWaylandComp
 gboolean                meta_wayland_compositor_handle_event    (MetaWaylandCompositor *compositor,
                                                                  const ClutterEvent    *event);
 
-gboolean                meta_wayland_compositor_is_native       (MetaWaylandCompositor *compositor);
-
-MetaWaylandBuffer *     meta_wayland_buffer_from_resource       (struct wl_resource *resource);
-
-void                    meta_wayland_buffer_reference           (MetaWaylandBufferReference *ref,
-								 MetaWaylandBuffer          *buffer);
+MetaWaylandBuffer *     meta_wayland_buffer_from_resource       (struct wl_resource    *resource);
+void                    meta_wayland_buffer_ref                 (MetaWaylandBuffer     *buffer);
+void                    meta_wayland_buffer_unref               (MetaWaylandBuffer     *buffer);
 
 void                    meta_wayland_compositor_update          (MetaWaylandCompositor *compositor,
                                                                  const ClutterEvent    *event);
 void                    meta_wayland_compositor_paint_finished  (MetaWaylandCompositor *compositor);
 
+gboolean                meta_wayland_compositor_activate_vt     (MetaWaylandCompositor  *compositor,
+                                                                 int                     vt,
+                                                                 GError                **error);
+
 #endif /* META_WAYLAND_PRIVATE_H */

src/wayland/meta-wayland-seat.c

@@ -48,28 +48,32 @@ unbind_resource (struct wl_resource *resource)
 }
 
 static void
-pointer_unmap_sprite (MetaWaylandSeat *seat)
+set_cursor_surface (MetaWaylandSeat    *seat,
+                    MetaWaylandSurface *surface)
 {
-  if (seat->cursor_tracker)
-    meta_cursor_tracker_set_window_cursor (seat->cursor_tracker, NULL, 0, 0);
+  if (seat->cursor_surface == surface)
+    return;
 
-  if (seat->sprite)
-    {
-      wl_list_remove (&seat->sprite_destroy_listener.link);
-      seat->sprite = NULL;
-    }
+  if (seat->cursor_surface)
+    wl_list_remove (&seat->cursor_surface_destroy_listener.link);
+
+  seat->cursor_surface = surface;
+
+  if (seat->cursor_surface)
+    wl_resource_add_destroy_listener (seat->cursor_surface->resource,
+                                      &seat->cursor_surface_destroy_listener);
 }
 
 void
-meta_wayland_seat_update_sprite (MetaWaylandSeat *seat)
+meta_wayland_seat_update_cursor_surface (MetaWaylandSeat *seat)
 {
   struct wl_resource *buffer;
 
   if (seat->cursor_tracker == NULL)
     return;
 
-  if (seat->sprite->buffer_ref.buffer)
-    buffer = seat->sprite->buffer_ref.buffer->resource;
+  if (seat->cursor_surface && seat->cursor_surface->buffer)
+    buffer = seat->cursor_surface->buffer->resource;
   else
     buffer = NULL;
 
@@ -89,42 +93,24 @@ pointer_set_cursor (struct wl_client *client,
   MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
   MetaWaylandSurface *surface;
 
-  surface = (surface_resource ?
-             wl_resource_get_user_data (surface_resource) :
-             NULL);
+  surface = (surface_resource ? wl_resource_get_user_data (surface_resource) : NULL);
 
-  if (seat->pointer.focus == NULL)
+  if (seat->pointer.focus_surface == NULL)
     return;
-  if (wl_resource_get_client (seat->pointer.focus->resource) != client)
+  if (wl_resource_get_client (seat->pointer.focus_surface->resource) != client)
     return;
   if (seat->pointer.focus_serial - serial > G_MAXUINT32 / 2)
     return;
 
   seat->hotspot_x = x;
   seat->hotspot_y = y;
-
-  if (seat->sprite != surface)
-    {
-      pointer_unmap_sprite (seat);
-
-      if (!surface)
-        return;
-
-      wl_resource_add_destroy_listener (surface->resource,
-                                        &seat->sprite_destroy_listener);
-
-      seat->sprite = surface;
-
-      if (seat->sprite->buffer_ref.buffer)
-        meta_wayland_seat_update_sprite (seat);
-    }
+  set_cursor_surface (seat, surface);
+  meta_wayland_seat_update_cursor_surface (seat);
 }
 
-static const struct wl_pointer_interface
-pointer_interface =
-  {
-    pointer_set_cursor
-  };
+static const struct wl_pointer_interface pointer_interface = {
+  pointer_set_cursor
+};
 
 static void
 seat_get_pointer (struct wl_client *client,
@@ -139,9 +125,9 @@ seat_get_pointer (struct wl_client *client,
   wl_resource_set_implementation (cr, &pointer_interface, seat, unbind_resource);
   wl_list_insert (&seat->pointer.resource_list, wl_resource_get_link (cr));
 
-  if (seat->pointer.focus &&
-      wl_resource_get_client (seat->pointer.focus->resource) == client)
-    meta_wayland_pointer_set_focus (&seat->pointer, seat->pointer.focus);
+  if (seat->pointer.focus_surface &&
+      wl_resource_get_client (seat->pointer.focus_surface->resource) == client)
+    meta_wayland_pointer_set_focus (&seat->pointer, seat->pointer.focus_surface);
 }
 
 static void
@@ -162,10 +148,10 @@ seat_get_keyboard (struct wl_client *client,
                            seat->keyboard.xkb_info.keymap_fd,
                            seat->keyboard.xkb_info.keymap_size);
 
-  if (seat->keyboard.focus &&
-      wl_resource_get_client (seat->keyboard.focus->resource) == client)
+  if (seat->keyboard.focus_surface &&
+      wl_resource_get_client (seat->keyboard.focus_surface->resource) == client)
     {
-      meta_wayland_keyboard_set_focus (&seat->keyboard, seat->keyboard.focus);
+      meta_wayland_keyboard_set_focus (&seat->keyboard, seat->keyboard.focus_surface);
       meta_wayland_data_device_set_keyboard_focus (seat);
     }
 }
@@ -209,17 +195,16 @@ bind_seat (struct wl_client *client,
 }
 
 static void
-pointer_handle_sprite_destroy (struct wl_listener *listener, void *data)
+pointer_handle_cursor_surface_destroy (struct wl_listener *listener, void *data)
 {
-  MetaWaylandSeat *seat =
-    wl_container_of (listener, seat, sprite_destroy_listener);
+  MetaWaylandSeat *seat = wl_container_of (listener, seat, cursor_surface_destroy_listener);
 
-  pointer_unmap_sprite (seat);
+  set_cursor_surface (seat, NULL);
+  meta_wayland_seat_update_cursor_surface (seat);
 }
 
 MetaWaylandSeat *
-meta_wayland_seat_new (struct wl_display *display,
-		       gboolean           is_native)
+meta_wayland_seat_new (struct wl_display *display)
 {
   MetaWaylandSeat *seat = g_new0 (MetaWaylandSeat, 1);
 
@@ -227,16 +212,15 @@ meta_wayland_seat_new (struct wl_display *display,
   wl_list_init (&seat->base_resource_list);
   wl_list_init (&seat->data_device_resource_list);
 
-  meta_wayland_pointer_init (&seat->pointer, is_native);
-
-  meta_wayland_keyboard_init (&seat->keyboard, display, is_native);
+  meta_wayland_pointer_init (&seat->pointer);
+  meta_wayland_keyboard_init (&seat->keyboard, display);
 
   seat->display = display;
 
   seat->current_stage = 0;
 
-  seat->sprite = NULL;
-  seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
+  seat->cursor_surface = NULL;
+  seat->cursor_surface_destroy_listener.notify = pointer_handle_cursor_surface_destroy;
   seat->hotspot_x = 16;
   seat->hotspot_y = 16;
 
@@ -445,7 +429,7 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
     }
 
   pointer->current = surface;
-  if (surface != pointer->focus)
+  if (surface != pointer->focus_surface)
     {
       const MetaWaylandPointerGrabInterface *interface =
         pointer->grab->interface;
@@ -457,7 +441,7 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
 void
 meta_wayland_seat_free (MetaWaylandSeat *seat)
 {
-  pointer_unmap_sprite (seat);
+  set_cursor_surface (seat, NULL);
 
   meta_wayland_pointer_release (&seat->pointer);
   meta_wayland_keyboard_release (&seat->keyboard);

src/wayland/meta-wayland-seat.h

@@ -66,16 +66,15 @@ struct _MetaWaylandSeat
   struct wl_display *display;
 
   MetaCursorTracker *cursor_tracker;
-  MetaWaylandSurface *sprite;
+  MetaWaylandSurface *cursor_surface;
   int hotspot_x, hotspot_y;
-  struct wl_listener sprite_destroy_listener;
+  struct wl_listener cursor_surface_destroy_listener;
 
   ClutterActor *current_stage;
 };
 
 MetaWaylandSeat *
-meta_wayland_seat_new (struct wl_display *display,
-		       gboolean           is_native);
+meta_wayland_seat_new (struct wl_display *display);
 
 void
 meta_wayland_seat_update_pointer (MetaWaylandSeat *seat,
@@ -90,7 +89,7 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
 			  const ClutterEvent *for_event);
 
 void
-meta_wayland_seat_update_sprite (MetaWaylandSeat *seat);
+meta_wayland_seat_update_cursor_surface (MetaWaylandSeat *seat);
 
 void
 meta_wayland_seat_free (MetaWaylandSeat *seat);

src/wayland/meta-wayland-surface.h

@@ -39,13 +39,7 @@ struct _MetaWaylandBuffer
 
   CoglTexture *texture;
   int32_t width, height;
-  uint32_t busy_count;
-};
-
-struct _MetaWaylandBufferReference
-{
-  MetaWaylandBuffer *buffer;
-  struct wl_listener destroy_listener;
+  uint32_t ref_count;
 };
 
 typedef struct
@@ -65,6 +59,9 @@ typedef struct
 
   /* wl_surface.frame */
   struct wl_list frame_callback_list;
+
+  gboolean frame_extents_changed;
+  GtkBorder frame_extents;
 } MetaWaylandDoubleBufferedState;
 
 typedef struct
@@ -77,7 +74,6 @@ struct _MetaWaylandSurface
 {
   struct wl_resource *resource;
   MetaWaylandCompositor *compositor;
-  MetaWaylandBufferReference buffer_ref;
   MetaSurfaceActor *surface_actor;
   MetaWindow *window;
   MetaWaylandSurfaceExtension xdg_surface;
@@ -85,6 +81,26 @@ struct _MetaWaylandSurface
   MetaWaylandSurfaceExtension gtk_surface;
   MetaWaylandSurfaceExtension subsurface;
 
+  MetaWaylandBuffer *buffer;
+  struct wl_listener buffer_destroy_listener;
+
+  GList *subsurfaces;
+
+  struct {
+    MetaWaylandSurface *parent;
+    struct wl_listener parent_destroy_listener;
+
+    gboolean synchronous;
+    MetaWaylandDoubleBufferedState pending_surface_state;
+
+    int32_t pending_x;
+    int32_t pending_y;
+    gboolean pending_pos;
+    GSList *pending_placement_ops;
+  } sub;
+
+  uint32_t state_changed_serial;
+
   /* All the pending state, that wl_surface.commit will apply. */
   MetaWaylandDoubleBufferedState pending;
 };
@@ -95,15 +111,22 @@ MetaWaylandSurface *meta_wayland_surface_create (MetaWaylandCompositor *composit
 						 struct wl_client      *client,
 						 guint32                id,
 						 guint32                version);
+
+void                meta_wayland_surface_window_unmanaged (MetaWaylandSurface *surface);
+
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
 							   int                 width,
-							   int                 height,
-							   int                 edges);
+							   int                 height);
+void                meta_wayland_surface_send_maximized (MetaWaylandSurface *surface);
+void                meta_wayland_surface_send_unmaximized (MetaWaylandSurface *surface);
+void                meta_wayland_surface_send_fullscreened (MetaWaylandSurface *surface);
+void                meta_wayland_surface_send_unfullscreened (MetaWaylandSurface *surface);
 
-void                meta_wayland_surface_focused_set (MetaWaylandSurface *surface);
-void                meta_wayland_surface_focused_unset (MetaWaylandSurface *surface);
+void                meta_wayland_surface_activated (MetaWaylandSurface *surface);
+void                meta_wayland_surface_deactivated (MetaWaylandSurface *surface);
 
 void                meta_wayland_surface_ping (MetaWaylandSurface *surface,
                                                guint32             serial);
+void                meta_wayland_surface_delete (MetaWaylandSurface *surface);
 
 #endif

src/wayland/meta-wayland-versions.h

@@ -41,7 +41,6 @@
 #define META_WL_OUTPUT_VERSION              2
 #define META_XSERVER_VERSION                1
 #define META_GTK_SHELL_VERSION              1
-#define META_XDG_SHELL_VERSION              1
 #define META_WL_SUBCOMPOSITOR_VERSION       1
 
 /* Slave objects (version inherited from a master object) */

src/wayland/meta-wayland.c

@@ -138,6 +138,24 @@ meta_wayland_buffer_destroy_handler (struct wl_listener *listener,
   g_slice_free (MetaWaylandBuffer, buffer);
 }
 
+void
+meta_wayland_buffer_ref (MetaWaylandBuffer *buffer)
+{
+  buffer->ref_count++;
+}
+
+void
+meta_wayland_buffer_unref (MetaWaylandBuffer *buffer)
+{
+  buffer->ref_count--;
+  if (buffer->ref_count == 0)
+    {
+      g_clear_pointer (&buffer->texture, cogl_object_unref);
+      g_assert (wl_resource_get_client (buffer->resource));
+      wl_resource_queue_event (buffer->resource, WL_BUFFER_RELEASE);
+    }
+}
+
 MetaWaylandBuffer *
 meta_wayland_buffer_from_resource (struct wl_resource *resource)
 {
@@ -165,46 +183,6 @@ meta_wayland_buffer_from_resource (struct wl_resource *resource)
   return buffer;
 }
 
-static void
-meta_wayland_buffer_reference_handle_destroy (struct wl_listener *listener,
-                                              void *data)
-{
-  MetaWaylandBufferReference *ref =
-    wl_container_of (listener, ref, destroy_listener);
-
-  g_assert (data == ref->buffer);
-
-  ref->buffer = NULL;
-}
-
-void
-meta_wayland_buffer_reference (MetaWaylandBufferReference *ref,
-                               MetaWaylandBuffer *buffer)
-{
-  if (ref->buffer && buffer != ref->buffer)
-    {
-      ref->buffer->busy_count--;
-
-      if (ref->buffer->busy_count == 0)
-        {
-	  g_clear_pointer (&ref->buffer->texture, cogl_object_unref);
-          g_assert (wl_resource_get_client (ref->buffer->resource));
-          wl_resource_queue_event (ref->buffer->resource, WL_BUFFER_RELEASE);
-        }
-
-      wl_list_remove (&ref->destroy_listener.link);
-    }
-
-  if (buffer && buffer != ref->buffer)
-    {
-      buffer->busy_count++;
-      wl_signal_add (&buffer->destroy_signal, &ref->destroy_listener);
-    }
-
-  ref->buffer = buffer;
-  ref->destroy_listener.notify = meta_wayland_buffer_reference_handle_destroy;
-}
-
 void
 meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
                                          MetaWindow            *window)
@@ -505,8 +483,7 @@ meta_wayland_compositor_paint_finished (MetaWaylandCompositor *compositor)
       MetaWaylandFrameCallback *callback =
         wl_container_of (compositor->frame_callbacks.next, callback, link);
 
-      wl_resource_post_event (callback->resource,
-                              WL_CALLBACK_DONE, get_time ());
+      wl_callback_send_done (callback->resource, get_time ());
       wl_resource_destroy (callback->resource);
     }
 }
@@ -623,31 +600,11 @@ meta_wayland_log_func (const char *fmt,
   g_free (str);
 }
 
-static gboolean
-are_we_native (int *out_drm_fd)
-{
-  ClutterBackend *backend = clutter_get_default_backend ();
-  CoglContext *cogl_context = clutter_backend_get_cogl_context (backend);
-  CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (cogl_context));
-
-  if (cogl_renderer_get_winsys_id (cogl_renderer) == COGL_WINSYS_ID_EGL_KMS)
-    {
-      *out_drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
-      return TRUE;
-    }
-  else
-    {
-      return FALSE;
-    }
-}
-
 void
 meta_wayland_init (void)
 {
   MetaWaylandCompositor *compositor = &_meta_wayland_compositor;
   MetaMonitorManager *monitors;
-  char *display_name;
-  int drm_fd;
 
   memset (compositor, 0, sizeof (MetaWaylandCompositor));
 
@@ -686,27 +643,24 @@ meta_wayland_init (void)
 
   clutter_wayland_set_compositor_display (compositor->wayland_display);
 
-  if (getenv ("WESTON_LAUNCHER_SOCK"))
-      compositor->launcher = meta_launcher_new ();
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
+    compositor->launcher = meta_launcher_new ();
+#endif
 
   if (clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS)
     g_error ("Failed to initialize Clutter");
 
-  if (are_we_native (&drm_fd))
+#if defined(CLUTTER_WINDOWING_EGL)
+  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
     {
-      GError *error = NULL;
-      if (!meta_launcher_set_drm_fd (compositor->launcher, drm_fd, &error))
-	{
-	  g_error ("Failed to set DRM fd to weston-launch and become DRM master: %s", error->message);
-	  g_error_free (error);
-	}
-
-      compositor->native = TRUE;
-    }
-  else
-    {
-      compositor->native = FALSE;
+      ClutterBackend *backend = clutter_get_default_backend ();
+      CoglContext *cogl_context = clutter_backend_get_cogl_context (backend);
+      CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (cogl_context));
+      int drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
+      meta_launcher_set_drm_fd (compositor->launcher, drm_fd, NULL);
     }
+#endif
 
   meta_monitor_manager_initialize ();
   monitors = meta_monitor_manager_get ();
@@ -722,7 +676,7 @@ meta_wayland_init (void)
 
   meta_wayland_data_device_manager_init (compositor->wayland_display);
 
-  compositor->seat = meta_wayland_seat_new (compositor->wayland_display, compositor->native);
+  compositor->seat = meta_wayland_seat_new (compositor->wayland_display);
 
   meta_wayland_init_shell (compositor);
 
@@ -743,13 +697,10 @@ meta_wayland_init (void)
    * and so EGL must be initialized by this point.
    */
 
-  if (!meta_xwayland_start (compositor))
+  if (!meta_xwayland_start (&compositor->xwayland_manager, compositor->wayland_display))
     g_error ("Failed to start X Wayland");
 
-  display_name = g_strdup_printf (":%d", compositor->xwayland_display_index);
-  set_gnome_env ("DISPLAY", display_name);
-  g_free (display_name);
-
+  set_gnome_env ("DISPLAY", compositor->xwayland_manager.display_name);
   set_gnome_env ("WAYLAND_DISPLAY", compositor->display_name);
 }
 
@@ -760,12 +711,24 @@ meta_wayland_finalize (void)
 
   compositor = meta_wayland_compositor_get_default ();
 
-  meta_xwayland_stop (compositor);
-  meta_launcher_free (compositor->launcher);
+  meta_xwayland_stop (&compositor->xwayland_manager);
+
+  if (compositor->launcher)
+    meta_launcher_free (compositor->launcher);
 }
 
 gboolean
-meta_wayland_compositor_is_native (MetaWaylandCompositor *compositor)
+meta_wayland_compositor_activate_vt (MetaWaylandCompositor  *compositor,
+                                     int                     vt,
+                                     GError                **error)
 {
-  return compositor->native;
+  if (compositor->launcher)
+    {
+      return meta_launcher_activate_vt (compositor->launcher, vt, error);
+    }
+  else
+    {
+      g_debug ("Ignoring VT switch keybinding, not running as VT manager");
+      return TRUE;
+    }
 }

src/wayland/meta-weston-launch.c

@@ -385,3 +385,17 @@ meta_launcher_free (MetaLauncher *launcher)
 
   g_slice_free (MetaLauncher, launcher);
 }
+
+gboolean
+meta_launcher_activate_vt (MetaLauncher  *launcher,
+			   int            vt,
+			   GError       **error)
+{
+  struct weston_launcher_activate_vt message;
+
+  message.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
+  message.vt = vt;
+
+  return send_message_to_wl (launcher, &message, sizeof (message), NULL, NULL, error);
+}
+

src/wayland/meta-weston-launch.h

@@ -28,6 +28,10 @@ typedef struct _MetaLauncher MetaLauncher;
 MetaLauncher     *meta_launcher_new                     (void);
 void              meta_launcher_free                    (MetaLauncher  *self);
 
+gboolean          meta_launcher_activate_vt             (MetaLauncher  *self,
+							 int            number,
+							 GError       **error);
+
 gboolean          meta_launcher_set_drm_fd              (MetaLauncher  *self,
 							 int            drm_fd,
 							 GError       **error);

src/wayland/meta-xwayland-private.h

@@ -25,12 +25,13 @@
 #include <glib.h>
 
 gboolean
-meta_xwayland_start (MetaWaylandCompositor *compositor);
+meta_xwayland_start (MetaXWaylandManager *manager,
+                     struct wl_display   *display);
 
 void
 meta_xwayland_complete_init (void);
 
 void
-meta_xwayland_stop (MetaWaylandCompositor *compositor);
+meta_xwayland_stop (MetaXWaylandManager *manager);
 
 #endif /* META_XWAYLAND_PRIVATE_H */

src/wayland/meta-xwayland.c

@@ -44,15 +44,17 @@ xserver_set_window_id (struct wl_client *client,
   MetaWindow *window;
 
   window = meta_display_lookup_x_window (display, xid);
-  if (window)
-    {
-      surface->window = window;
-      window->surface = surface;
-    }
+  if (!window)
+    return;
+
+  surface->window = window;
+  window->surface = surface;
+
+  meta_window_set_surface_mapped (window, TRUE);
 }
 
 static const struct xserver_interface xserver_implementation = {
-    xserver_set_window_id
+  xserver_set_window_id
 };
 
 static void
@@ -61,25 +63,20 @@ bind_xserver (struct wl_client *client,
               guint32 version,
               guint32 id)
 {
-  MetaWaylandCompositor *compositor = data;
+  MetaXWaylandManager *manager = data;
 
   /* If it's a different client than the xserver we launched,
-   * don't start the wm. */
-  if (client != compositor->xwayland_client)
+   * just freeze up... */
+  if (client != manager->client)
     return;
 
-  compositor->xserver_resource = wl_resource_create (client, &xserver_interface,
-						     MIN (META_XSERVER_VERSION, version), id);
-  wl_resource_set_implementation (compositor->xserver_resource,
-				  &xserver_implementation, compositor, NULL);
+  manager->xserver_resource = wl_resource_create (client, &xserver_interface,
+                                                  MIN (META_XSERVER_VERSION, version), id);
+  wl_resource_set_implementation (manager->xserver_resource,
+				  &xserver_implementation, manager, NULL);
 
-  wl_resource_post_event (compositor->xserver_resource,
-                          XSERVER_LISTEN_SOCKET,
-                          compositor->xwayland_abstract_fd);
-
-  wl_resource_post_event (compositor->xserver_resource,
-                          XSERVER_LISTEN_SOCKET,
-                          compositor->xwayland_unix_fd);
+  xserver_send_listen_socket (manager->xserver_resource, manager->abstract_fd);
+  xserver_send_listen_socket (manager->xserver_resource, manager->unix_fd);
 
   /* Make sure xwayland will recieve the above sockets in a finite
    * time before unblocking the initialization mainloop since we are
@@ -91,8 +88,8 @@ bind_xserver (struct wl_client *client,
    * connections so we can quit the transient initialization mainloop
    * and unblock meta_wayland_init() to continue initializing mutter.
    * */
-  g_main_loop_quit (compositor->init_loop);
-  g_clear_pointer (&compositor->init_loop, g_main_loop_unref);
+  g_main_loop_quit (manager->init_loop);
+  g_clear_pointer (&manager->init_loop, g_main_loop_unref);
 }
 
 static char *
@@ -123,7 +120,7 @@ create_lockfile (int display, int *display_out)
               /* ignore error and try the next display number */
               display++;
               continue;
-          }
+            }
           close (fd);
 
           other = strtol (pid, &end, 0);
@@ -135,7 +132,7 @@ create_lockfile (int display, int *display_out)
               /* ignore error and try the next display number */
               display++;
               continue;
-          }
+            }
 
           if (kill (other, 0) < 0 && errno == ESRCH)
             {
@@ -148,7 +145,7 @@ create_lockfile (int display, int *display_out)
                 }
               g_free (filename);
               continue;
-          }
+            }
 
           g_free (filename);
           display++;
@@ -240,11 +237,12 @@ bind_to_unix_socket (int display)
       return -1;
     }
 
-  if (listen (fd, 1) < 0) {
+  if (listen (fd, 1) < 0)
+    {
       unlink (addr.sun_path);
       close (fd);
       return -1;
-  }
+    }
 
   return fd;
 }
@@ -287,7 +285,8 @@ x_io_error (Display *display)
 }
 
 gboolean
-meta_xwayland_start (MetaWaylandCompositor *compositor)
+meta_xwayland_start (MetaXWaylandManager *manager,
+                     struct wl_display   *wl_display)
 {
   int display = 0;
   char *lockfile = NULL;
@@ -295,27 +294,25 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
   pid_t pid;
   char **env;
   char *fd_string;
-  char *display_name;
   char *log_path;
-  char *args[11];
+  char *args[10];
   GError *error;
 
-  wl_global_create (compositor->wayland_display,
-		    &xserver_interface,
+  wl_global_create (wl_display, &xserver_interface,
 		    META_XSERVER_VERSION,
-		    compositor, bind_xserver);
+		    manager, bind_xserver);
 
   do
     {
       lockfile = create_lockfile (display, &display);
       if (!lockfile)
         {
-         g_warning ("Failed to create an X lock file");
-         return FALSE;
+          g_warning ("Failed to create an X lock file");
+          return FALSE;
         }
 
-      compositor->xwayland_abstract_fd = bind_to_abstract_socket (display);
-      if (compositor->xwayland_abstract_fd < 0)
+      manager->abstract_fd = bind_to_abstract_socket (display);
+      if (manager->abstract_fd < 0)
         {
           unlink (lockfile);
 
@@ -328,11 +325,11 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
             return FALSE;
         }
 
-      compositor->xwayland_unix_fd = bind_to_unix_socket (display);
-      if (compositor->xwayland_abstract_fd < 0)
+      manager->unix_fd = bind_to_unix_socket (display);
+      if (manager->abstract_fd < 0)
         {
           unlink (lockfile);
-          close (compositor->xwayland_abstract_fd);
+          close (manager->abstract_fd);
           return FALSE;
         }
 
@@ -340,8 +337,8 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
     }
   while (1);
 
-  compositor->xwayland_display_index = display;
-  compositor->xwayland_lockfile = lockfile;
+  manager->display_index = display;
+  manager->lockfile = lockfile;
 
   /* We want xwayland to be a wayland client so we make a socketpair to setup a
    * wayland protocol connection. */
@@ -357,21 +354,19 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
   env = g_environ_setenv (env, "WAYLAND_SOCKET", fd_string, TRUE);
   g_free (fd_string);
 
-  display_name = g_strdup_printf (":%d",
-                                  compositor->xwayland_display_index);
+  manager->display_name = g_strdup_printf (":%d", manager->display_index);
   log_path = g_build_filename (g_get_user_cache_dir (), "xwayland.log", NULL);
 
   args[0] = XWAYLAND_PATH;
-  args[1] = display_name;
+  args[1] = manager->display_name;
   args[2] = "-wayland";
   args[3] = "-rootless";
-  args[4] = "-retro";
-  args[5] = "-noreset";
-  args[6] = "-logfile";
-  args[7] = log_path;
-  args[8] = "-nolisten";
-  args[9] = "all";
-  args[10] = NULL;
+  args[4] = "-noreset";
+  args[5] = "-logfile";
+  args[6] = log_path;
+  args[7] = "-nolisten";
+  args[8] = "all";
+  args[9] = NULL;
 
   error = NULL;
   if (g_spawn_async (NULL, /* cwd */
@@ -389,10 +384,9 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
       g_message ("forked X server, pid %d\n", pid);
 
       close (sp[1]);
-      compositor->xwayland_client =
-        wl_client_create (compositor->wayland_display, sp[0]);
+      manager->client = wl_client_create (wl_display, sp[0]);
 
-      compositor->xwayland_pid = pid;
+      manager->pid = pid;
       g_child_watch_add (pid, xserver_died, NULL);
     }
   else
@@ -401,15 +395,13 @@ meta_xwayland_start (MetaWaylandCompositor *compositor)
     }
 
   g_strfreev (env);
-  g_free (display_name);
   g_free (log_path);
 
   /* We need to run a mainloop until we know xwayland has a binding
    * for our xserver interface at which point we can assume it's
    * ready to start accepting connections. */
-  compositor->init_loop = g_main_loop_new (NULL, FALSE);
-
-  g_main_loop_run (compositor->init_loop);
+  manager->init_loop = g_main_loop_new (NULL, FALSE);
+  g_main_loop_run (manager->init_loop);
 
   return TRUE;
 }
@@ -427,16 +419,14 @@ meta_xwayland_complete_init (void)
 }
 
 void
-meta_xwayland_stop (MetaWaylandCompositor *compositor)
+meta_xwayland_stop (MetaXWaylandManager *manager)
 {
   char path[256];
 
-  snprintf (path, sizeof path, "/tmp/.X%d-lock",
-            compositor->xwayland_display_index);
+  snprintf (path, sizeof path, "/tmp/.X%d-lock", manager->display_index);
   unlink (path);
-  snprintf (path, sizeof path, "/tmp/.X11-unix/X%d",
-            compositor->xwayland_display_index);
+  snprintf (path, sizeof path, "/tmp/.X11-unix/X%d", manager->display_index);
   unlink (path);
 
-  unlink (compositor->xwayland_lockfile);
+  unlink (manager->lockfile);
 }

src/wayland/weston-launch.c

@@ -269,6 +269,40 @@ out:
 	return 0;
 }
 
+static int
+handle_activate_vt(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
+{
+        struct weston_launcher_reply reply;
+	struct weston_launcher_activate_vt *message;
+
+	reply.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
+	reply.ret = -1;
+
+	if (len != sizeof(*message)) {
+		error(0, 0, "missing value in activate_vt request");
+		goto out;
+	}
+
+	message = msg->msg_iov->iov_base;
+
+	reply.ret = ioctl(wl->tty, VT_ACTIVATE, message->vt);
+	if (reply.ret < 0)
+		reply.ret = -errno;
+
+	if (wl->verbose)
+		fprintf(stderr, "mutter-launch: activate VT, ret: %d\n", reply.ret);
+
+out:
+	do {
+		len = send(wl->sock[0], &reply, sizeof reply, 0);
+	} while (len < 0 && errno == EINTR);
+	if (len < 0)
+		return -1;
+
+	return 0;
+}
+
+
 static int
 handle_open(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
 {
@@ -385,6 +419,9 @@ handle_socket_msg(struct weston_launch *wl)
 	case WESTON_LAUNCHER_CONFIRM_VT_SWITCH:
 		ret = handle_confirm_vt_switch(wl, &msg, len);
 		break;
+	case WESTON_LAUNCHER_ACTIVATE_VT:
+		ret = handle_activate_vt(wl, &msg, len);
+		break;
 	}
 
 	return ret;

src/wayland/weston-launch.h

@@ -32,7 +32,8 @@ enum weston_launcher_message_type {
 enum weston_launcher_opcode {
 	WESTON_LAUNCHER_OPEN              = (1 << 1 | WESTON_LAUNCHER_REQUEST),
 	WESTON_LAUNCHER_DRM_SET_FD        = (2 << 1 | WESTON_LAUNCHER_REQUEST),
-	WESTON_LAUNCHER_CONFIRM_VT_SWITCH = (3 << 1 | WESTON_LAUNCHER_REQUEST),
+	WESTON_LAUNCHER_ACTIVATE_VT       = (3 << 1 | WESTON_LAUNCHER_REQUEST),
+	WESTON_LAUNCHER_CONFIRM_VT_SWITCH = (4 << 1 | WESTON_LAUNCHER_REQUEST),
 };
 
 enum weston_launcher_server_opcode {