resize

2014-03-05 17:52:57 -05:00
45 changed files with 1034 additions and 752 deletions
--- a/14
+++ b/14
@@ -1,17 +1,3 @@
-3.11.91
-=======
-* Don't use keysym to match keybindings [Rui; #678001]
-* Fix message tray icons showing up blank (again) [Adel; #725180]
-* Improve keybinding lookups [Rui; #725588]
-* Fix dynamic updates of titlebar style properties [Owen; #725751]
-* Fix positioning of manually positioned windows [Owen; #724049]
-* Misc bug fixes and cleanups [Jasper, Carlos, Adel, Giovanni, Florian; #720631,
-  #724969, #725216, #724402, #722266, #725338, #725525]
-
-Contributors:
-  Giovanni Campagna, Adel Gadllah, Carlos Garnacho, Rui Matos, Florian Müllner,
-  Jasper St. Pierre, Owen W. Taylor
-
 3.11.90
 =======
 * Fix double-scaling on high DPI resolutions [Adel; #723931]
--- a/autogen.sh
+++ b/autogen.sh
@@ -5,7 +5,7 @@ srcdir=`dirname $0`
 test -z "$srcdir" && srcdir=.

 PKG_NAME="mutter"
-REQUIRED_AUTOMAKE_VERSION=1.10
+REQUIRED_AUTOMAKE_VERSION=1.13

 (test -f $srcdir/configure.ac \
  && test -d $srcdir/src) || {
--- a/configure.ac
+++ b/configure.ac
@@ -3,7 +3,7 @@ AC_CONFIG_MACRO_DIR([m4])

 m4_define([mutter_major_version], [3])
 m4_define([mutter_minor_version], [11])
-m4_define([mutter_micro_version], [91])
+m4_define([mutter_micro_version], [90])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -142,6 +142,11 @@ AM_GLIB_GNU_GETTEXT
 PKG_CHECK_MODULES(ALL, glib-2.0 >= 2.14.0)
 PKG_CHECK_MODULES(MUTTER_LAUNCH, libdrm libsystemd-login)

+saved_LIBS="$LIBS"
+LIBS="$LIBS $MUTTER_LAUNCH"
+AC_CHECK_FUNCS([sd_session_get_vt])
+LIBS="$saved_LIBS"
+
 # Unconditionally use this dir to avoid a circular dep with gnomecc
 GNOME_KEYBINDINGS_KEYSDIR="${datadir}/gnome-control-center/keybindings"
 AC_SUBST(GNOME_KEYBINDINGS_KEYSDIR)
--- a/protocol/xdg-shell.xml
+++ b/protocol/xdg-shell.xml
@@ -40,22 +40,19 @@

    <enum name="version">
      <description summary="latest protocol version">
-	The 'current' member of this enum gives the version of the
-	protocol.  Implementations can compare this to the version
-	they implement using static_assert to ensure the protocol and
-	implementation versions match.
+	Use this enum to check the protocol version, and it will be updated
+	automatically.
      </description>
-      <entry name="current" value="3" summary="Always the latest version"/>
+      <entry name="current" value="2" summary="Always the latest version"/>
    </enum>


    <request name="use_unstable_version">
      <description summary="enable use of this unstable version">
-	Negotiate the unstable version of the interface.  This
-	mechanism is in place to ensure client and server agree on the
-	unstable versions of the protocol that they speak or exit
-	cleanly if they don't agree.  This request will go away once
-	the xdg-shell protocol is stable.
+	Use this request in order to enable use of this interface.
+
+	Understand and agree that one is using an unstable interface,
+	that will likely change in the future, breaking the API.
      </description>
      <arg name="version" type="int"/>
    </request>
@@ -278,87 +275,113 @@
      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
    </request>

-    <enum name="state">
-      <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
+    <event name="request_set_fullscreen">
+      <description summary="server requests that the client set fullscreen">
+	Event sent from the compositor to the client requesting that the client
+	goes to a fullscreen state. It's the client job to call set_fullscreen
+	and really trigger the fullscreen state.
      </description>
-      <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>
-
-    <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>
-
-    <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>
-
-      <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>

-    <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.
+    <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.
+      </description>
+    </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.
+      </description>
+    </request>
+
+    <event name="request_set_maximized">
+      <description summary="server requests that the client set maximized">
+	Event sent from the compositor to the client requesting that the client
+	goes to a maximized state. It's the client job to call set_maximized
+	and really trigger the maximized state.
+      </description>
+    </event>
+
+    <event name="request_unset_maximized">
+      <description summary="server requests that the client unset maximized">
+	Event sent from the compositor to the client requesting that the client
+	leaves the maximized state. It's the client job to call unset_maximized
+	and really leave the maximized state.
+      </description>
+    </event>
+
+    <request name="set_maximized">
+      <description summary="set the surface state as maximized">
+	Set the surface as maximized.
+
+	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.
      </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="minimize the surface">
-        Minimize the surface.
+      <description summary="set the surface state as minimized">
+	Set the surface minimized state.
+
+	Setting one state won't unset another state.
      </description>
    </request>

--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -128,8 +128,8 @@ libmutter_wayland_la_SOURCES =			\
 	core/group-props.h			\
 	core/group.c				\
 	meta/group.h				\
-	core/icons.c				\
-	core/icons.h				\
+	core/iconcache.c			\
+	core/iconcache.h			\
 	core/keybindings.c			\
 	core/keybindings-private.h		\
 	core/main.c				\
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -436,6 +436,45 @@ begin_modal_x11 (MetaScreen       *screen,
  return FALSE;
 }

+static gboolean
+begin_modal_wayland (MetaScreen       *screen,
+                     MetaPlugin       *plugin,
+                     MetaModalOptions  options,
+                     guint32           timestamp)
+{
+  MetaWaylandCompositor *compositor;
+  gboolean pointer_grabbed = FALSE;
+  gboolean keyboard_grabbed = FALSE;
+
+  compositor = meta_wayland_compositor_get_default ();
+
+  if ((options & META_MODAL_POINTER_ALREADY_GRABBED) == 0)
+    {
+      if (!meta_wayland_pointer_begin_modal (&compositor->seat->pointer))
+        goto fail;
+
+      pointer_grabbed = TRUE;
+    }
+  if ((options & META_MODAL_KEYBOARD_ALREADY_GRABBED) == 0)
+    {
+      if (!meta_wayland_keyboard_begin_modal (&compositor->seat->keyboard,
+                                              timestamp))
+        goto fail;
+
+      keyboard_grabbed = TRUE;
+    }
+
+  return TRUE;
+
+ fail:
+  if (pointer_grabbed)
+    meta_wayland_pointer_end_modal (&compositor->seat->pointer);
+  if (keyboard_grabbed)
+    meta_wayland_keyboard_end_modal (&compositor->seat->keyboard, timestamp);
+
+  return FALSE;
+}
+
 gboolean
 meta_begin_modal_for_plugin (MetaScreen       *screen,
                             MetaPlugin       *plugin,
@@ -454,7 +493,7 @@ meta_begin_modal_for_plugin (MetaScreen       *screen,
    return FALSE;

  if (meta_is_wayland_compositor ())
-    ok = TRUE;
+    ok = begin_modal_wayland (screen, plugin, options, timestamp);
  else
    ok = begin_modal_x11 (screen, plugin, options, timestamp);
  if (!ok)
@@ -482,7 +521,15 @@ meta_end_modal_for_plugin (MetaScreen     *screen,

  g_return_if_fail (compositor->modal_plugin == plugin);

-  if (!meta_is_wayland_compositor ())
+  if (meta_is_wayland_compositor ())
+    {
+      MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
+
+      meta_wayland_pointer_end_modal (&compositor->seat->pointer);
+      meta_wayland_keyboard_end_modal (&compositor->seat->keyboard,
+                                       timestamp);
+    }
+  else
    {
      XIUngrabDevice (xdpy, META_VIRTUAL_CORE_POINTER_ID, timestamp);
      XIUngrabDevice (xdpy, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -425,9 +425,8 @@ setup_constraint_info (ConstraintInfo      *info,
   * the monitor.
   */
  if (meta_prefs_get_force_fullscreen() &&
-      window->client_type != META_WINDOW_CLIENT_TYPE_WAYLAND &&
      !window->hide_titlebar_when_maximized &&
-      (window->decorated || !meta_window_is_client_decorated (window)) &&
+      window->decorated &&
      meta_rectangle_equal (new, &monitor_info->rect) &&
      window->has_fullscreen_func &&
      !window->fullscreen)
@@ -492,17 +491,12 @@ place_window_if_needed(MetaWindow     *window,
      !window->minimized &&
      !window->fullscreen)
    {
-      MetaRectangle orig_rect;
      MetaRectangle placed_rect;
      MetaWorkspace *cur_workspace;
      const MetaMonitorInfo *monitor_info;

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

--- a/src/core/core.c
+++ b/src/core/core.c
@@ -736,6 +736,31 @@ meta_core_increment_event_serial (Display *xdisplay)
  meta_display_increment_event_serial (display);
 }

+void
+meta_invalidate_default_icons (void)
+{
+  MetaDisplay *display = meta_get_display ();
+  GSList *windows;
+  GSList *l;
+
+  if (display == NULL)
+    return; /* We can validly be called before the display is opened. */
+
+  windows = meta_display_list_windows (display, META_LIST_DEFAULT);
+  for (l = windows; l != NULL; l = l->next)
+    {
+      MetaWindow *window = (MetaWindow*)l->data;
+
+      if (window->icon_cache.origin == USING_FALLBACK_ICON)
+        {
+          meta_icon_cache_free (&(window->icon_cache));
+          meta_window_update_icon_now (window);
+        }
+    }
+
+  g_slist_free (windows);
+}
+
 void
 meta_core_add_old_event_mask (Display     *xdisplay,
                              Window       xwindow,
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -199,6 +199,8 @@ void       meta_core_set_screen_cursor (Display *xdisplay,
 */
 void meta_core_increment_event_serial (Display *display);

+void meta_invalidate_default_icons (void);
+
 void meta_core_add_old_event_mask (Display     *xdisplay,
                                   Window       xwindow,
                                   XIEventMask *mask);
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -1295,6 +1295,10 @@ meta_get_display (void)
  return the_display;
 }

+#ifdef WITH_VERBOSE_MODE
+static gboolean dump_events = TRUE;
+#endif
+
 static gboolean
 grab_op_is_mouse_only (MetaGrabOp op)
 {
@@ -1414,20 +1418,6 @@ meta_grab_op_is_moving (MetaGrabOp op)
    }
 }

-static gboolean
-grab_op_should_block_mouse_events (MetaGrabOp op)
-{
-  switch (op)
-    {
-    case META_GRAB_OP_WAYLAND_CLIENT:
-    case META_GRAB_OP_COMPOSITOR:
-      return TRUE;
-
-    default:
-      return FALSE;
-    }
-}
-
 /**
 * meta_display_xserver_time_is_before:
 * @display: a #MetaDisplay
@@ -2064,7 +2054,7 @@ meta_display_handle_event (MetaDisplay        *display,
  switch (event->type)
    {
    case CLUTTER_BUTTON_PRESS:
-      if (grab_op_should_block_mouse_events (display->grab_op))
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
        break;

      display->overlay_key_only_pressed = FALSE;
@@ -2236,7 +2226,7 @@ meta_display_handle_event (MetaDisplay        *display,
        }
      break;
    case CLUTTER_BUTTON_RELEASE:
-      if (grab_op_should_block_mouse_events (display->grab_op))
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
        break;

      display->overlay_key_only_pressed = FALSE;
@@ -2250,7 +2240,7 @@ meta_display_handle_event (MetaDisplay        *display,
        }
      break;
    case CLUTTER_MOTION:
-      if (grab_op_should_block_mouse_events (display->grab_op))
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
        break;

      if (display->grab_window == window &&
@@ -2284,10 +2274,6 @@ meta_display_handle_event (MetaDisplay        *display,
  if (display->grab_op == META_GRAB_OP_COMPOSITOR)
    bypass_wayland = TRUE;

-  /* If a Wayland client has a grab, don't pass that through to Clutter */
-  if (display->grab_op == META_GRAB_OP_WAYLAND_CLIENT)
-    bypass_clutter = TRUE;
-
  if (compositor && !bypass_wayland)
    {
      if (meta_wayland_compositor_handle_event (compositor, event))
@@ -2988,8 +2974,9 @@ meta_display_handle_xevent (MetaDisplay *display,
  MetaMonitorManager *monitor;
  MetaScreen *screen;

-#if 0
-  meta_spew_event (display, event);
+#ifdef WITH_VERBOSE_MODE
+  if (dump_events)
+    meta_spew_event (display, event);
 #endif

 #ifdef HAVE_STARTUP_NOTIFICATION
@@ -3265,7 +3252,8 @@ event_get_time (MetaDisplay *display,
    }
 }

-G_GNUC_UNUSED const char*
+#ifdef WITH_VERBOSE_MODE
+const char*
 meta_event_detail_to_string (int d)
 {
  const char *detail = "???";
@@ -3301,8 +3289,10 @@ meta_event_detail_to_string (int d)

  return detail;
 }
+#endif /* WITH_VERBOSE_MODE */

-G_GNUC_UNUSED const char*
+#ifdef WITH_VERBOSE_MODE
+const char*
 meta_event_mode_to_string (int m)
 {
  const char *mode = "???";
@@ -3324,8 +3314,10 @@ meta_event_mode_to_string (int m)

  return mode;
 }
+#endif /* WITH_VERBOSE_MODE */

-G_GNUC_UNUSED static const char*
+#ifdef WITH_VERBOSE_MODE
+static const char*
 stack_mode_to_string (int mode)
 {
  switch (mode)
@@ -3344,9 +3336,11 @@ stack_mode_to_string (int mode)

  return "Unknown";
 }
+#endif /* WITH_VERBOSE_MODE */

 #ifdef HAVE_XSYNC
-G_GNUC_UNUSED static gint64
+#ifdef WITH_VERBOSE_MODE
+static gint64
 sync_value_to_64 (const XSyncValue *value)
 {
  gint64 v;
@@ -3356,8 +3350,10 @@ sync_value_to_64 (const XSyncValue *value)
  
  return v;
 }
+#endif /* WITH_VERBOSE_MODE */

-G_GNUC_UNUSED static const char*
+#ifdef WITH_VERBOSE_MODE
+static const char*
 alarm_state_to_string (XSyncAlarmState state)
 {
  switch (state)
@@ -3372,9 +3368,12 @@ alarm_state_to_string (XSyncAlarmState state)
      return "(unknown)";
    }
 }
+#endif /* WITH_VERBOSE_MODE */
+
 #endif /* HAVE_XSYNC */

-G_GNUC_UNUSED static void
+#ifdef WITH_VERBOSE_MODE
+static void
 meta_spew_xi2_event (MetaDisplay *display,
                     XIEvent     *input_event,
                     const char **name_p,
@@ -3434,7 +3433,7 @@ meta_spew_xi2_event (MetaDisplay *display,
  *extra_p = extra;
 }

-G_GNUC_UNUSED static void
+static void
 meta_spew_core_event (MetaDisplay *display,
                      XEvent      *event,
                      const char **name_p,
@@ -3658,7 +3657,7 @@ meta_spew_core_event (MetaDisplay *display,
  *extra_p = extra;
 }

-G_GNUC_UNUSED static void
+static void
 meta_spew_event (MetaDisplay *display,
                 XEvent      *event)
 {
@@ -3667,6 +3666,9 @@ meta_spew_event (MetaDisplay *display,
  char *winname;
  MetaScreen *screen;
  XIEvent *input_event;
+
+  if (!meta_is_verbose())
+    return;
  
  /* filter overnumerous events */
  if (event->type == Expose || event->type == MotionNotify ||
@@ -3696,16 +3698,18 @@ meta_spew_event (MetaDisplay *display,
  else
    winname = g_strdup_printf ("0x%lx", event->xany.window);

-  g_print ("%s on %s%s %s %sserial %lu\n", name, winname,
-           extra ? ":" : "", extra ? extra : "",
-           event->xany.send_event ? "SEND " : "",
-           event->xany.serial);
+  meta_topic (META_DEBUG_EVENTS,
+              "%s on %s%s %s %sserial %lu\n", name, winname,
+              extra ? ":" : "", extra ? extra : "",
+              event->xany.send_event ? "SEND " : "",
+              event->xany.serial);

  g_free (winname);

  if (extra)
    g_free (extra);
 }
+#endif /* WITH_VERBOSE_MODE */

 MetaWindow*
 meta_display_lookup_x_window (MetaDisplay *display,
--- a/src/core/iconcache.c
+++ b/src/core/iconcache.c
--- a/src/core/iconcache.h
+++ b/src/core/iconcache.h
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -3916,7 +3916,6 @@ init_builtin_key_bindings (MetaDisplay *display)

  g_object_unref (common_keybindings);
  g_object_unref (mutter_keybindings);
-  g_object_unref (mutter_wayland_keybindings);
 }

 void
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -42,7 +42,7 @@
 */

 #define _GNU_SOURCE
-#define _XOPEN_SOURCE /* for putenv() and some signal-related functions */
+#define _SVID_SOURCE /* for putenv() and some signal-related functions */

 #include <config.h>
 #include <meta/main.h>
@@ -190,7 +190,6 @@ static gboolean  opt_replace_wm;
 static gboolean  opt_disable_sm;
 static gboolean  opt_sync;
 static gboolean  opt_wayland;
-static gboolean  opt_display_server;

 static GOptionEntry meta_options[] = {
  {
@@ -234,11 +233,6 @@ static GOptionEntry meta_options[] = {
    N_("Run as a wayland compositor"),
    NULL
  },
-  {
-    "display-server", 0, 0, G_OPTION_ARG_NONE,
-    &opt_display_server,
-    N_("Run as a full display server, rather than nested")
-  },
  {NULL}
 };

@@ -407,7 +401,8 @@ meta_init (void)
  if (g_getenv ("MUTTER_DEBUG"))
    meta_set_debugging (TRUE);

-  if (opt_display_server)
+  /* 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);
@@ -502,32 +497,6 @@ meta_register_with_session (void)
  g_free (opt_client_id);
 }

-/**
- * meta_activate_session:
- *
- * Tells mutter to activate the session. When mutter is a
- * Wayland compositor, this tells logind to switch over to
- * the new session.
- */
-gboolean
-meta_activate_session (void)
-{
-  if (meta_is_wayland_compositor ())
-    {
-      MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
-      GError *error = NULL;
-
-      if (!meta_wayland_compositor_activate_session (compositor, &error))
-        {
-          g_warning ("Could not activate session: %s\n", error->message);
-          g_error_free (error);
-          return FALSE;
-        }
-    }
-
-  return TRUE;
-}
-
 /**
 * meta_run: (skip)
 *
--- a/src/core/meta-cursor-tracker-private.h
+++ b/src/core/meta-cursor-tracker-private.h
@@ -43,7 +43,4 @@ void     meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
 					      int                new_x,
 					      int                new_y);
 void     meta_cursor_tracker_paint           (MetaCursorTracker *tracker);
-
-void     meta_cursor_tracker_force_update (MetaCursorTracker *tracker);
-
 #endif
--- a/src/core/meta-cursor-tracker.c
+++ b/src/core/meta-cursor-tracker.c
@@ -39,7 +39,6 @@
 #include <gbm.h>

 #include <gdk/gdk.h>
-#include <gdk/gdkx.h>

 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
@@ -570,9 +569,6 @@ make_wayland_cursor_tracker (MetaScreen *screen)

  compositor = meta_wayland_compositor_get_default ();
  compositor->seat->cursor_tracker = self;
-  meta_cursor_tracker_update_position (self,
-                                       wl_fixed_to_int (compositor->seat->pointer.x),
-                                       wl_fixed_to_int (compositor->seat->pointer.y));

 #if defined(CLUTTER_WINDOWING_EGL)
  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
@@ -1078,13 +1074,12 @@ get_pointer_position_gdk (int         *x,
  GdkScreen *gscreen;

  gmanager = gdk_display_get_device_manager (gdk_display_get_default ());
-  gdevice = gdk_x11_device_manager_lookup (gmanager, META_VIRTUAL_CORE_POINTER_ID);
+  gdevice = gdk_device_manager_get_client_pointer (gmanager);

  gdk_device_get_position (gdevice, &gscreen, x, y);
-  if (mods)
-    gdk_device_get_state (gdevice,
-                          gdk_screen_get_root_window (gscreen),
-                          NULL, (GdkModifierType*)mods);
+  gdk_device_get_state (gdevice,
+                        gdk_screen_get_root_window (gscreen),
+                        NULL, (GdkModifierType*)mods);
 }

 static void
@@ -1100,12 +1095,9 @@ get_pointer_position_clutter (int         *x,
  cdevice = clutter_device_manager_get_core_device (cmanager, CLUTTER_POINTER_DEVICE);

  clutter_input_device_get_coords (cdevice, NULL, &point);
-  if (x)
-    *x = point.x;
-  if (y)
-    *y = point.y;
-  if (mods)
-    *mods = clutter_input_device_get_modifier_state (cdevice);
+  *x = point.x;
+  *y = point.y;
+  *mods = clutter_input_device_get_modifier_state (cdevice);
 }

 void
@@ -1147,12 +1139,3 @@ meta_cursor_tracker_set_pointer_visible (MetaCursorTracker *tracker,
                          tracker->screen->xroot);
    }
 }
-
-void
-meta_cursor_tracker_force_update (MetaCursorTracker *tracker)
-{
-  g_assert (meta_is_wayland_compositor ());
-
-  update_hw_cursor (tracker);
-  sync_cursor (tracker);
-}
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -1514,19 +1514,38 @@ meta_screen_get_mouse_window (MetaScreen  *screen,
                              MetaWindow  *not_this_one)
 {
  MetaWindow *window;
-  int x, y;
+  Window root_return, child_return;
+  double root_x_return, root_y_return;
+  double win_x_return, win_y_return;
+  XIButtonState buttons;
+  XIModifierState mods;
+  XIGroupState group;

  if (not_this_one)
    meta_topic (META_DEBUG_FOCUS,
                "Focusing mouse window excluding %s\n", not_this_one->desc);

-  meta_cursor_tracker_get_pointer (screen->cursor_tracker,
-                                   &x, &y, NULL);
+  meta_error_trap_push (screen->display);
+  XIQueryPointer (screen->display->xdisplay,
+                  META_VIRTUAL_CORE_POINTER_ID,
+                  screen->xroot,
+                  &root_return,
+                  &child_return,
+                  &root_x_return,
+                  &root_y_return,
+                  &win_x_return,
+                  &win_y_return,
+                  &buttons,
+                  &mods,
+                  &group);
+  meta_error_trap_pop (screen->display);
+  free (buttons.mask);

  window = meta_stack_get_default_focus_window_at_point (screen->stack,
                                                         screen->active_workspace,
                                                         not_this_one,
-                                                         x, y);
+                                                         root_x_return,
+                                                         root_y_return);

  return window;
 }
@@ -1808,11 +1827,28 @@ meta_screen_get_current_monitor (MetaScreen *screen)
  
  if (screen->display->monitor_cache_invalidated)
    {
-      int x, y;
+      Window root_return, child_return;
+      double win_x_return, win_y_return;
+      double root_x_return, root_y_return;
+      XIButtonState buttons;
+      XIModifierState mods;
+      XIGroupState group;

-      meta_cursor_tracker_get_pointer (screen->cursor_tracker,
-                                       &x, &y, NULL);
-      meta_screen_get_current_monitor_for_pos (screen, x, y);
+      XIQueryPointer (screen->display->xdisplay,
+                      META_VIRTUAL_CORE_POINTER_ID,
+                      screen->xroot,
+                      &root_return,
+                      &child_return,
+                      &root_x_return,
+                      &root_y_return,
+                      &win_x_return,
+                      &win_y_return,
+                      &buttons,
+                      &mods,
+                      &group);
+      free (buttons.mask);
+
+      meta_screen_get_current_monitor_for_pos (screen, root_x_return, root_y_return);
    }

  return screen->last_monitor_index;
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -92,6 +92,7 @@ struct _MetaWindow
  char *icon_name;
  GdkPixbuf *icon;
  GdkPixbuf *mini_icon;
+  MetaIconCache icon_cache;
  Pixmap wm_hints_pixmap;
  Pixmap wm_hints_mask;
  
@@ -407,12 +408,6 @@ struct _MetaWindow
   */
  MetaRectangle rect;

-  /* The size and position we want the window to be (i.e. what we last asked
-   * the client to configure).
-   * This is only used for wayland clients.
-   */
-  MetaRectangle expected_rect;
-
  gboolean has_custom_frame_extents;
  GtkBorder custom_frame_extents;

@@ -683,8 +678,9 @@ void meta_window_update_layer (MetaWindow *window);

 void meta_window_recalc_features    (MetaWindow *window);

-void meta_window_set_type (MetaWindow     *window,
-                           MetaWindowType  type);
+/* recalc_window_type is x11 only, wayland does its thing and then calls type_changed */
+void meta_window_recalc_window_type (MetaWindow *window);
+void meta_window_type_changed       (MetaWindow *window);

 void meta_window_frame_size_changed (MetaWindow *window);

@@ -749,6 +745,4 @@ void meta_window_activate_full (MetaWindow     *window,
                                MetaClientType  source_indication,
                                MetaWorkspace  *workspace);

-gboolean meta_window_is_client_decorated (MetaWindow *window);
-
 #endif
--- a/src/core/window-props.c
+++ b/src/core/window-props.c
@@ -35,7 +35,7 @@
 */

 #define _GNU_SOURCE
-#define _XOPEN_SOURCE 500 /* for gethostname() */
+#define _SVID_SOURCE /* for gethostname() */

 #include <config.h>
 #include "window-props.h"
@@ -237,6 +237,9 @@ static void
 reload_icon (MetaWindow    *window,
             Atom           atom)
 {
+  meta_icon_cache_property_changed (&window->icon_cache,
+                                    window->display,
+                                    atom);
  meta_window_queue(window, META_QUEUE_UPDATE_ICON);
 }

@@ -724,7 +727,7 @@ reload_net_wm_state (MetaWindow    *window,
  meta_verbose ("Reloaded _NET_WM_STATE for %s\n",
                window->desc);

-  meta_window_x11_recalc_window_type (window);
+  meta_window_recalc_window_type (window);
  meta_window_recalc_features (window);
 }

@@ -1500,6 +1503,10 @@ reload_wm_hints (MetaWindow    *window,
  if (!initial && window->wm_hints_urgent && !old_urgent)
    g_signal_emit_by_name (window->display, "window-marked-urgent", window);

+  meta_icon_cache_property_changed (&window->icon_cache,
+                                    window->display,
+                                    XA_WM_HINTS);
+
  meta_window_queue (window, META_QUEUE_UPDATE_ICON | META_QUEUE_MOVE_RESIZE);
 }

--- a/src/core/window-x11.c
+++ b/src/core/window-x11.c
@@ -38,7 +38,6 @@
 #include <meta/common.h>
 #include <meta/errors.h>
 #include <meta/prefs.h>
-#include <meta/meta-cursor-tracker.h>

 #include "window-private.h"
 #include "window-props.h"
@@ -226,7 +225,7 @@ meta_window_x11_update_net_wm_type (MetaWindow *window)
        meta_XFree (str);
    }

-  meta_window_x11_recalc_window_type (window);
+  meta_window_recalc_window_type (window);
 }

 void
@@ -674,19 +673,35 @@ meta_window_x11_property_notify (MetaWindow *window,
 static int
 query_pressed_buttons (MetaWindow *window)
 {
-  ClutterModifierType mods;
+  double x, y, query_root_x, query_root_y;
+  Window root, child;
+  XIButtonState buttons;
+  XIModifierState mods;
+  XIGroupState group;
  int button = 0;

-  meta_cursor_tracker_get_pointer (window->screen->cursor_tracker,
-                                   NULL, NULL, &mods);
+  meta_error_trap_push (window->display);
+  XIQueryPointer (window->display->xdisplay,
+                  META_VIRTUAL_CORE_POINTER_ID,
+                  window->xwindow,
+                  &root, &child,
+                  &query_root_x, &query_root_y,
+                  &x, &y,
+                  &buttons, &mods, &group);

-  if (mods & CLUTTER_BUTTON1_MASK)
+  if (meta_error_trap_pop_with_return (window->display) != Success)
+    goto out;
+
+  if (XIMaskIsSet (buttons.mask, Button1))
    button |= 1 << 1;
-  if (mods & CLUTTER_BUTTON2_MASK)
+  if (XIMaskIsSet (buttons.mask, Button2))
    button |= 1 << 2;
-  if (mods & CLUTTER_BUTTON3_MASK)
+  if (XIMaskIsSet (buttons.mask, Button3))
    button |= 1 << 3;

+  free (buttons.mask);
+
+ out:
  return button;
 }

@@ -872,7 +887,7 @@ meta_window_x11_client_message (MetaWindow *window,
            (action == _NET_WM_STATE_ADD) ||
            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_modal);

-          meta_window_x11_recalc_window_type (window);
+          meta_window_recalc_window_type (window);
          meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
        }

@@ -1506,114 +1521,3 @@ error:
  meta_error_trap_pop (display);
  return NULL;
 }
-
-void
-meta_window_x11_recalc_window_type (MetaWindow *window)
-{
-  MetaWindowType type;
-
-  if (window->type_atom != None)
-    {
-      if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP)
-        type = META_WINDOW_DESKTOP;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DOCK)
-        type = META_WINDOW_DOCK;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR)
-        type = META_WINDOW_TOOLBAR;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_MENU)
-        type = META_WINDOW_MENU;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY)
-        type = META_WINDOW_UTILITY;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
-        type = META_WINDOW_SPLASHSCREEN;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
-        type = META_WINDOW_DIALOG;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
-        type = META_WINDOW_NORMAL;
-      /* The below are *typically* override-redirect windows, but the spec does
-       * not disallow using them for managed windows.
-       */
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DROPDOWN_MENU)
-        type = META_WINDOW_DROPDOWN_MENU;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_POPUP_MENU)
-        type = META_WINDOW_POPUP_MENU;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLTIP)
-        type = META_WINDOW_TOOLTIP;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NOTIFICATION)
-        type = META_WINDOW_NOTIFICATION;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_COMBO)
-        type = META_WINDOW_COMBO;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DND)
-        type = META_WINDOW_DND;
-      else
-        {
-          char *atom_name;
-
-          /*
-           * Fallback on a normal type, and print warning. Don't abort.
-           */
-          type = META_WINDOW_NORMAL;
-
-          meta_error_trap_push (window->display);
-          atom_name = XGetAtomName (window->display->xdisplay,
-                                    window->type_atom);
-          meta_error_trap_pop (window->display);
-
-          meta_warning ("Unrecognized type atom [%s] set for %s \n",
-                        atom_name ? atom_name : "unknown",
-                        window->desc);
-
-          if (atom_name)
-            XFree (atom_name);
-        }
-    }
-  else if (window->transient_for != NULL)
-    {
-      type = META_WINDOW_DIALOG;
-    }
-  else
-    {
-      type = META_WINDOW_NORMAL;
-    }
-
-  if (type == META_WINDOW_DIALOG &&
-      window->wm_state_modal)
-    type = META_WINDOW_MODAL_DIALOG;
-
-  /* We don't want to allow override-redirect windows to have decorated-window
-   * types since that's just confusing.
-   */
-  if (window->override_redirect)
-    {
-      switch (window->type)
-        {
-        /* Decorated types */
-        case META_WINDOW_NORMAL:
-        case META_WINDOW_DIALOG:
-        case META_WINDOW_MODAL_DIALOG:
-        case META_WINDOW_MENU:
-        case META_WINDOW_UTILITY:
-          type = META_WINDOW_OVERRIDE_OTHER;
-          break;
-        /* Undecorated types, normally not override-redirect */
-        case META_WINDOW_DESKTOP:
-        case META_WINDOW_DOCK:
-        case META_WINDOW_TOOLBAR:
-        case META_WINDOW_SPLASHSCREEN:
-        /* Undecorated types, normally override-redirect types */
-        case META_WINDOW_DROPDOWN_MENU:
-        case META_WINDOW_POPUP_MENU:
-        case META_WINDOW_TOOLTIP:
-        case META_WINDOW_NOTIFICATION:
-        case META_WINDOW_COMBO:
-        case META_WINDOW_DND:
-        /* To complete enum */
-        case META_WINDOW_OVERRIDE_OTHER:
-          break;
-        }
-    }
-
-  meta_verbose ("Calculated type %u for %s, old type %u\n",
-                type, window->desc, type);
-  meta_window_set_type (window, type);
-}
--- a/src/core/window-x11.h
+++ b/src/core/window-x11.h
@@ -35,8 +35,6 @@ 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);

-void meta_window_x11_recalc_window_type          (MetaWindow *window);
-
 gboolean meta_window_x11_configure_request       (MetaWindow *window,
                                                  XEvent     *event);
 gboolean meta_window_x11_property_notify         (MetaWindow *window,
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -233,6 +233,8 @@ meta_window_finalize (GObject *object)
  if (window->transient_for)
    g_object_unref (window->transient_for);

+  meta_icon_cache_free (&window->icon_cache);
+
  g_free (window->sm_client_id);
  g_free (window->wm_client_machine);
  g_free (window->startup_id);
@@ -816,6 +818,7 @@ _meta_window_shared_new (MetaDisplay         *display,
  window->icon_name = NULL;
  window->icon = NULL;
  window->mini_icon = NULL;
+  meta_icon_cache_init (&window->icon_cache);
  window->wm_hints_pixmap = None;
  window->wm_hints_mask = None;
  window->wm_hints_urgent = FALSE;
@@ -3117,9 +3120,6 @@ meta_window_maximize_internal (MetaWindow        *window,
  meta_window_recalc_features (window);
  set_net_wm_state (window);

-  if (window->surface && window->maximized_horizontally && window->maximized_vertically)
-    meta_wayland_surface_send_maximized (window->surface);
-
  g_object_freeze_notify (G_OBJECT (window));
  g_object_notify (G_OBJECT (window), "maximized-horizontally");
  g_object_notify (G_OBJECT (window), "maximized-vertically");
@@ -3605,13 +3605,10 @@ meta_window_unmaximize_internal (MetaWindow        *window,
      set_net_wm_state (window);
    }

-  if (window->surface && !window->maximized_horizontally && !window->maximized_vertically)
-    meta_wayland_surface_send_unmaximized (window->surface);
-
-  g_object_freeze_notify (G_OBJECT (window));
-  g_object_notify (G_OBJECT (window), "maximized-horizontally");
-  g_object_notify (G_OBJECT (window), "maximized-vertically");
-  g_object_thaw_notify (G_OBJECT (window));
+    g_object_freeze_notify (G_OBJECT (window));
+    g_object_notify (G_OBJECT (window), "maximized-horizontally");
+    g_object_notify (G_OBJECT (window), "maximized-vertically");
+    g_object_thaw_notify (G_OBJECT (window));
 }

 void
@@ -3714,9 +3711,6 @@ meta_window_make_fullscreen_internal (MetaWindow  *window)
      /* For the auto-minimize feature, if we fail to get focus */
      meta_screen_queue_check_fullscreen (window->screen);

-      if (window->surface)
-        meta_wayland_surface_send_fullscreened (window->surface);
-
      g_object_notify (G_OBJECT (window), "fullscreen");
    }
 }
@@ -3773,9 +3767,6 @@ meta_window_unmake_fullscreen (MetaWindow  *window)

      meta_window_update_layer (window);

-      if (window->surface)
-        meta_wayland_surface_send_unfullscreened (window->surface);
-
      g_object_notify (G_OBJECT (window), "fullscreen");
    }
 }
@@ -4605,70 +4596,34 @@ meta_window_move_resize_internal (MetaWindow          *window,
      root_x_nw = new_rect.x;
      root_y_nw = new_rect.y;

-      /* First, save where we would like the client to be. This is used by the next
-       * attach to determine if the client is really moving/resizing or not.
-       */
-      window->expected_rect = new_rect;
-
-      if (is_wayland_resize)
-        {
-          /* This is a call to wl_surface_commit(), ignore the new_rect and
-           * update the real client size to match the buffer size.
-           */
-
-          window->rect.width = w;
-          window->rect.height = h;
-        }
-
      if (new_rect.width != window->rect.width ||
          new_rect.height != window->rect.height)
        {
-          /* We need to resize the client. Resizing is in two parts:
-           * some of the movement happens immediately, and some happens as part
-           * of the resizing (through dx/dy in wl_surface_attach).
-           *
-           * To do so, we need to compute the resize from the point of the view
-           * of the client, and then adjust the immediate resize to match.
-           *
-           * dx/dy are the values we expect from the new attach(), while deltax/
-           * deltay reflect the overall movement.
-           */
-          MetaRectangle client_rect;
-          int dx, dy;
-          int deltax, deltay;
+          if (!is_wayland_resize)
+            meta_wayland_surface_configure_notify (window->surface,
+                                                   new_rect.width,
+                                                   new_rect.height);

          meta_rectangle_resize_with_gravity (&old_rect,
-                                              &client_rect,
+                                              &new_rect,
                                              gravity,
                                              new_rect.width,
                                              new_rect.height);

-          deltax = new_rect.x - old_rect.x;
-          deltay = new_rect.y - old_rect.y;
-          dx = client_rect.x - old_rect.x;
-          dy = client_rect.y - old_rect.y;
+          if (window->rect.width != new_rect.width ||
+              window->rect.height != new_rect.height)
+            need_resize_client = TRUE;

-          if (deltax != dx || deltay != dy)
-            need_move_client = TRUE;
-
-          window->rect.x += (deltax - dx);
-          window->rect.y += (deltay - dy);
-
-          need_resize_client = TRUE;
-          meta_wayland_surface_configure_notify (window->surface,
-                                                 new_rect.width,
-                                                 new_rect.height);
+          window->rect.width = new_rect.width;
+          window->rect.height = new_rect.height;
        }
-      else
-        {
-          /* No resize happening, we can just move the window and live with it. */
-          if (window->rect.x != new_rect.x ||
-              window->rect.y != new_rect.y)
-            need_move_client = TRUE;

-          window->rect.x = new_rect.x;
-          window->rect.y = new_rect.y;
-        }
+      if (window->rect.x != new_rect.x ||
+          window->rect.y != new_rect.y)
+        need_move_client = TRUE;
+
+      window->rect.x = new_rect.x;
+      window->rect.y = new_rect.y;
    }
  else
    {
@@ -5080,18 +5035,16 @@ meta_window_move_resize_wayland (MetaWindow *window,

  flags = META_IS_WAYLAND_RESIZE;

-  meta_window_get_position (window, &x, &y);
-  x += dx; y += dy;
+  x = window->rect.x + dx;
+  y = window->rect.y + dy;

-  if (x != window->expected_rect.x || y != window->expected_rect.y)
+  if (dx != 0 || dy != 0)
    flags |= META_IS_MOVE_ACTION;
-  if (width != window->expected_rect.width ||
-      height != window->expected_rect.height)
+  if (width != window->rect.width || height != window->rect.height)
    flags |= META_IS_RESIZE_ACTION;

  meta_window_move_resize_internal (window, flags, NorthWestGravity,
                                    x, y, width, height);
-  save_user_window_placement (window);
 }

 /**
@@ -6790,13 +6743,25 @@ meta_window_update_icon_now (MetaWindow *window)
  icon = NULL;
  mini_icon = NULL;

-  if (read_icons (window->screen,
-                  window->xwindow,
-                  window->wm_hints_pixmap,
-                  window->wm_hints_mask,
-                  &window->icon))
+  if (meta_read_icons (window->screen,
+                       window->xwindow,
+                       &window->icon_cache,
+                       window->wm_hints_pixmap,
+                       window->wm_hints_mask,
+                       &icon,
+                       META_ICON_WIDTH, META_ICON_HEIGHT,
+                       &mini_icon,
+                       META_MINI_ICON_WIDTH,
+                       META_MINI_ICON_HEIGHT))
    {
+      if (window->icon)
+        g_object_unref (G_OBJECT (window->icon));
+
+      if (window->mini_icon)
+        g_object_unref (G_OBJECT (window->mini_icon));
+
      window->icon = icon;
+      window->mini_icon = mini_icon;

      g_object_freeze_notify (G_OBJECT (window));
      g_object_notify (G_OBJECT (window), "icon");
@@ -7049,7 +7014,122 @@ meta_window_update_struts (MetaWindow *window)
    }
 }

-static void
+void
+meta_window_recalc_window_type (MetaWindow *window)
+{
+  MetaWindowType old_type;
+
+  old_type = window->type;
+
+  if (window->type_atom != None)
+    {
+      if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP)
+        window->type = META_WINDOW_DESKTOP;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DOCK)
+        window->type = META_WINDOW_DOCK;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR)
+        window->type = META_WINDOW_TOOLBAR;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_MENU)
+        window->type = META_WINDOW_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY)
+        window->type = META_WINDOW_UTILITY;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+        window->type = META_WINDOW_SPLASHSCREEN;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
+        window->type = META_WINDOW_DIALOG;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
+        window->type = META_WINDOW_NORMAL;
+      /* The below are *typically* override-redirect windows, but the spec does
+       * not disallow using them for managed windows.
+       */
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DROPDOWN_MENU)
+        window->type = META_WINDOW_DROPDOWN_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_POPUP_MENU)
+        window->type = META_WINDOW_POPUP_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLTIP)
+        window->type = META_WINDOW_TOOLTIP;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NOTIFICATION)
+        window->type = META_WINDOW_NOTIFICATION;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_COMBO)
+        window->type = META_WINDOW_COMBO;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DND)
+        window->type = META_WINDOW_DND;
+      else
+        {
+          char *atom_name;
+
+          /*
+           * Fallback on a normal type, and print warning. Don't abort.
+           */
+          window->type = META_WINDOW_NORMAL;
+
+          meta_error_trap_push (window->display);
+          atom_name = XGetAtomName (window->display->xdisplay,
+                                    window->type_atom);
+          meta_error_trap_pop (window->display);
+
+          meta_warning ("Unrecognized type atom [%s] set for %s \n",
+                        atom_name ? atom_name : "unknown",
+                        window->desc);
+
+          if (atom_name)
+            XFree (atom_name);
+        }
+    }
+  else if (window->transient_for != NULL)
+    {
+      window->type = META_WINDOW_DIALOG;
+    }
+  else
+    {
+      window->type = META_WINDOW_NORMAL;
+    }
+
+  if (window->type == META_WINDOW_DIALOG &&
+      window->wm_state_modal)
+    window->type = META_WINDOW_MODAL_DIALOG;
+
+  /* We don't want to allow override-redirect windows to have decorated-window
+   * types since that's just confusing.
+   */
+  if (window->override_redirect)
+    {
+      switch (window->type)
+        {
+        /* Decorated types */
+        case META_WINDOW_NORMAL:
+        case META_WINDOW_DIALOG:
+        case META_WINDOW_MODAL_DIALOG:
+        case META_WINDOW_MENU:
+        case META_WINDOW_UTILITY:
+          window->type = META_WINDOW_OVERRIDE_OTHER;
+          break;
+        /* Undecorated types, normally not override-redirect */
+        case META_WINDOW_DESKTOP:
+        case META_WINDOW_DOCK:
+        case META_WINDOW_TOOLBAR:
+        case META_WINDOW_SPLASHSCREEN:
+        /* Undecorated types, normally override-redirect types */
+        case META_WINDOW_DROPDOWN_MENU:
+        case META_WINDOW_POPUP_MENU:
+        case META_WINDOW_TOOLTIP:
+        case META_WINDOW_NOTIFICATION:
+        case META_WINDOW_COMBO:
+        case META_WINDOW_DND:
+        /* To complete enum */
+        case META_WINDOW_OVERRIDE_OTHER:
+          break;
+        }
+    }
+
+  meta_verbose ("Calculated type %u for %s, old type %u\n",
+                window->type, window->desc, old_type);
+
+  if (old_type != window->type)
+    meta_window_type_changed (window);
+}
+
+void
 meta_window_type_changed (MetaWindow *window)
 {
  gboolean old_decorated = window->decorated;
@@ -7082,17 +7162,6 @@ meta_window_type_changed (MetaWindow *window)
  g_object_thaw_notify (object);
 }

-void
-meta_window_set_type (MetaWindow     *window,
-                      MetaWindowType  type)
-{
-  if (window->type == type)
-    return;
-
-  window->type = type;
-  meta_window_type_changed (window);
-}
-
 void
 meta_window_frame_size_changed (MetaWindow *window)
 {
@@ -7734,7 +7803,7 @@ meta_window_titlebar_is_onscreen (MetaWindow *window)

  /* Titlebar can't be offscreen if there is no titlebar... */
  if (!window->frame)
-    return TRUE;
+    return FALSE;

  /* Get the rectangle corresponding to the titlebar */
  meta_window_get_frame_rect (window, &titlebar_rect);
@@ -8749,34 +8818,6 @@ meta_window_same_application (MetaWindow *window,
    group==other_group;
 }

-/**
- * meta_window_is_client_decorated:
- *
- * Check if if the window has decorations drawn by the client.
- * (window->decorated refers only to whether we should add decorations)
- */
-gboolean
-meta_window_is_client_decorated (MetaWindow *window)
-{
-  if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-    {
-      /* Assume all Wayland clients draw decorations - not strictly
-       * true but good enough for current purposes.
-       */
-      return TRUE;
-    }
-  else
-    {
-      /* Currently the implementation here is hackish -
-       * has_custom_frame_extents() is set if _GTK_FRAME_EXTENTS is set
-       * to any value even 0. GTK+ always sets _GTK_FRAME_EXTENTS for
-       * client-side-decorated window, even if the value is 0 because
-       * the window is maxized and has no invisible borders or shadows.
-       */
-      return window->has_custom_frame_extents;
-    }
-}
-
 void
 meta_window_refresh_resize_popup (MetaWindow *window)
 {
@@ -10139,8 +10180,7 @@ meta_window_set_transient_for (MetaWindow *window,
    meta_window_propagate_focus_appearance (window, FALSE);

  /* may now be a dialog */
-  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
-    meta_window_x11_recalc_window_type (window);
+  meta_window_recalc_window_type (window);

  if (!window->constructing)
    {
@@ -10266,15 +10306,25 @@ window_focus_on_pointer_rest_callback (gpointer data)
  MetaWindow *window = focus_data->window;
  MetaDisplay *display = window->display;
  MetaScreen *screen = window->screen;
-  int root_x, root_y;
+  Window root, child;
+  double root_x, root_y, x, y;
  guint32 timestamp;
-  ClutterActor *child;
+  XIButtonState buttons;
+  XIModifierState mods;
+  XIGroupState group;

  if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK)
    goto out;

-  meta_cursor_tracker_get_pointer (screen->cursor_tracker,
-                                   &root_x, &root_y, NULL);
+  meta_error_trap_push (display);
+  XIQueryPointer (display->xdisplay,
+                  META_VIRTUAL_CORE_POINTER_ID,
+                  screen->xroot,
+                  &root, &child,
+                  &root_x, &root_y, &x, &y,
+                  &buttons, &mods, &group);
+  meta_error_trap_pop (display);
+  free (buttons.mask);

  if (root_x != focus_data->pointer_x ||
      root_y != focus_data->pointer_y)
@@ -10284,15 +10334,17 @@ window_focus_on_pointer_rest_callback (gpointer data)
      return TRUE;
    }

-  child = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (clutter_stage_get_default ()),
-                                          CLUTTER_PICK_REACTIVE, root_x, root_y);
-  if (!META_IS_SURFACE_ACTOR (child))
+  /* Explicitly check for the overlay window, as get_focus_window_at_point()
+   * may return windows that extend underneath the chrome (like
+   * override-redirect or DESKTOP windows)
+   */
+  if (child == meta_get_overlay_window (screen))
    goto out;

  window =
    meta_stack_get_default_focus_window_at_point (screen->stack,
                                                  screen->active_workspace,
-                                                  NULL, root_x, root_y);
+                                                  None, root_x, root_y);

  if (window == NULL)
    goto out;
--- a/src/meta/common.h
+++ b/src/meta/common.h
@@ -228,10 +228,7 @@ typedef enum
  META_GRAB_OP_CLICKING_UNSTICK,

  /* Special grab op when the compositor asked for a grab */
-  META_GRAB_OP_COMPOSITOR,
-
-  /* For when a client takes a popup grab */
-  META_GRAB_OP_WAYLAND_CLIENT,
+  META_GRAB_OP_COMPOSITOR
 } MetaGrabOp;

 /**
@@ -492,6 +489,12 @@ struct _MetaFrameBorders
 /* sets all dimensions to zero */
 void meta_frame_borders_clear (MetaFrameBorders *self);

+/* should investigate changing these to whatever most apps use */
+#define META_ICON_WIDTH 96
+#define META_ICON_HEIGHT 96
+#define META_MINI_ICON_WIDTH 16
+#define META_MINI_ICON_HEIGHT 16
+
 #define META_DEFAULT_ICON_NAME "window"

 /* Main loop priorities determine when activity in the GLib
--- a/src/meta/main.h
+++ b/src/meta/main.h
@@ -28,7 +28,6 @@ GOptionContext *meta_get_option_context     (void);
 void            meta_init                   (void);
 int             meta_run                    (void);
 void            meta_register_with_session  (void);
-gboolean        meta_activate_session       (void);
 gboolean        meta_get_replace_current_wm (void);  /* Actually defined in util.c */

 void            meta_set_wm_name              (const char *wm_name);
--- a/src/mutter-wayland.desktop.in
+++ b/src/mutter-wayland.desktop.in
@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Application
 _Name=Mutter (wayland compositor)
-Exec=mutter-launch -- mutter --wayland --display-server
+Exec=mutter-launch -- mutter --wayland
 NoDisplay=true
 # name of loadable control center module
 X-GNOME-WMSettingsModule=metacity
--- a/src/ui/frames.c
+++ b/src/ui/frames.c
@@ -44,6 +44,8 @@
 static void meta_frames_destroy       (GtkWidget       *object);
 static void meta_frames_finalize      (GObject         *object);
 static void meta_frames_style_updated (GtkWidget       *widget);
+static void meta_frames_map           (GtkWidget       *widget);
+static void meta_frames_unmap         (GtkWidget       *widget);

 static void meta_frames_update_prelit_control (MetaFrames      *frames,
                                               MetaUIFrame     *frame,
@@ -132,6 +134,9 @@ meta_frames_class_init (MetaFramesClass *class)

  widget_class->style_updated = meta_frames_style_updated;

+  widget_class->map = meta_frames_map;
+  widget_class->unmap = meta_frames_unmap;
+  
  widget_class->draw = meta_frames_draw;
  widget_class->destroy_event = meta_frames_destroy_event;  
  widget_class->button_press_event = meta_frames_button_press_event;
@@ -226,7 +231,6 @@ meta_frames_init (MetaFrames *frames)

  frames->style_variants = g_hash_table_new_full (g_str_hash, g_str_equal,
                                                  g_free, g_object_unref);
-
  update_style_contexts (frames);

  gtk_widget_set_double_buffered (GTK_WIDGET (frames), FALSE);
@@ -518,26 +522,13 @@ MetaFrames*
 meta_frames_new (int screen_number)
 {
  GdkScreen *screen;
-  MetaFrames *frames;

  screen = gdk_display_get_screen (gdk_display_get_default (),
                                   screen_number);

-  frames = g_object_new (META_TYPE_FRAMES,
-                         "screen", screen,
-                         "type", GTK_WINDOW_POPUP,
-                         NULL);
-
-  /* Put the window at an arbitrary offscreen location; the one place
-   * it can't be is at -100x-100, since the meta_window_new() will
-   * mistake it for a window created via meta_create_offscreen_window()
-   * and ignore it, and we need this window to get frame-synchronization
-   * messages so that GTK+'s style change handling works.
-   */
-  gtk_window_move (GTK_WINDOW (frames), -200, -200);
-  gtk_window_resize (GTK_WINDOW (frames), 1, 1);
-
-  return frames;
+  return g_object_new (META_TYPE_FRAMES,
+                       "screen", screen,
+                       NULL);  
 }

 /* In order to use a style with a window it has to be attached to that
@@ -644,6 +635,22 @@ meta_frames_unmanage_window (MetaFrames *frames,
    meta_warning ("Frame 0x%lx not managed, can't unmanage\n", xwindow);
 }

+static void
+meta_frames_map (GtkWidget *widget)
+{
+  /* We override the parent map function to a no-op because we don't
+   * want to actually show the GDK window. But GTK needs to think that
+   * the widget is mapped or it won't deliver the events we care about.
+   */
+  gtk_widget_set_mapped (widget, TRUE);
+}
+
+static void
+meta_frames_unmap (GtkWidget *widget)
+{
+  gtk_widget_set_mapped (widget, FALSE);
+}
+
 static MetaUIFrame*
 meta_frames_lookup_window (MetaFrames *frames,
                           Window      xwindow)
--- a/src/ui/ui.c
+++ b/src/ui/ui.c
@@ -295,12 +295,9 @@ meta_ui_new (Display *xdisplay,
  g_assert (gdisplay == gdk_display_get_default ());

  ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
-  /* GTK+ needs the frame-sync protocol to work in order to properly
-   * handle style changes. This means that the dummy widget we create
-   * to get the style for title bars actually needs to be mapped
-   * and fully tracked as a MetaWindow. Horrible, but mostly harmless -
-   * the window is a 1x1 overide redirect window positioned offscreen.
-   */
+  /* This does not actually show any widget. MetaFrames has been hacked so
+   * that showing it doesn't actually do anything. But we need the flags
+   * set for GTK to deliver events properly. */
  gtk_widget_show (GTK_WIDGET (ui->frames));

  g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
@@ -598,6 +595,76 @@ meta_gdk_pixbuf_get_from_pixmap (Pixmap       xpixmap,
  return retval;
 }

+GdkPixbuf*
+meta_ui_get_default_window_icon (MetaUI *ui)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "image-missing",
+                                                   META_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+
+  g_object_ref (G_OBJECT (default_icon));
+  
+  return default_icon;
+}
+
+GdkPixbuf*
+meta_ui_get_default_mini_icon (MetaUI *ui)
+{
+  static GdkPixbuf *default_icon = NULL;
+
+  if (default_icon == NULL)
+    {
+      GtkIconTheme *theme;
+      gboolean icon_exists;
+
+      theme = gtk_icon_theme_get_default ();
+
+      icon_exists = gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME);
+
+      if (icon_exists)
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   META_DEFAULT_ICON_NAME,
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+      else
+          default_icon = gtk_icon_theme_load_icon (theme,
+                                                   "image-missing",
+                                                   META_MINI_ICON_WIDTH,
+                                                   0,
+                                                   NULL);
+
+      g_assert (default_icon);
+    }
+
+  g_object_ref (G_OBJECT (default_icon));
+  
+  return default_icon;
+}
+
 gboolean
 meta_ui_window_should_not_cause_focus (Display *xdisplay,
                                       Window   xwindow)
@@ -705,6 +772,7 @@ void
 meta_ui_set_current_theme (const char *name)
 {
  meta_theme_set_current (name);
+  meta_invalidate_default_icons ();
 }

 gboolean
--- a/src/ui/ui.h
+++ b/src/ui/ui.h
@@ -143,6 +143,9 @@ GdkPixbuf* meta_gdk_pixbuf_get_from_pixmap (Pixmap       xpixmap,
                                            int          width,
                                            int          height);

+GdkPixbuf* meta_ui_get_default_window_icon (MetaUI *ui);
+GdkPixbuf* meta_ui_get_default_mini_icon (MetaUI *ui);
+
 gboolean  meta_ui_window_should_not_cause_focus (Display *xdisplay,
                                                 Window   xwindow);

--- a/src/wayland/meta-wayland-data-device.c
+++ b/src/wayland/meta-wayland-data-device.c
@@ -48,7 +48,7 @@ data_offer_accept (struct wl_client *client,
   * this be a wl_data_device request? */

  if (offer->source)
-    wl_data_source_send_target (offer->source->resource, mime_type);
+    offer->source->accept (offer->source, serial, mime_type);
 }

 static void
@@ -58,9 +58,9 @@ data_offer_receive (struct wl_client *client, struct wl_resource *resource,
  MetaWaylandDataOffer *offer = wl_resource_get_user_data (resource);

  if (offer->source)
-    wl_data_source_send_send (offer->source->resource, mime_type, fd);
-
-  close (fd);
+    offer->source->send (offer->source, mime_type, fd);
+  else
+    close (fd);
 }

 static void
@@ -82,8 +82,7 @@ destroy_data_offer (struct wl_resource *resource)

  if (offer->source)
    wl_list_remove (&offer->source_destroy_listener.link);
-
-  g_slice_free (MetaWaylandDataOffer, offer);
+  free (offer);
 }

 static void
@@ -100,9 +99,13 @@ static struct wl_resource *
 meta_wayland_data_source_send_offer (MetaWaylandDataSource *source,
                                     struct wl_resource *target)
 {
-  MetaWaylandDataOffer *offer = g_slice_new0 (MetaWaylandDataOffer);
+  MetaWaylandDataOffer *offer;
  char **p;

+  offer = malloc (sizeof *offer);
+  if (offer == NULL)
+    return NULL;
+
  offer->source = source;
  offer->source_destroy_listener.notify = destroy_offer_data_source;

@@ -315,12 +318,8 @@ data_device_start_drag (struct wl_client *client,
 {
  MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
  MetaWaylandDragGrab *drag_grab;
-
-  if ((seat->pointer.button_count == 0 ||
-       seat->pointer.grab_serial != serial ||
-       !seat->pointer.focus_surface ||
-       seat->pointer.focus_surface != wl_resource_get_user_data (origin_resource)))
-    return;
+  /* FIXME: Check that client has implicit grab on the origin
+   * surface that matches the given time. */

  /* FIXME: Check that the data source type array isn't empty. */

@@ -333,7 +332,6 @@ data_device_start_drag (struct wl_client *client,
  drag_grab->generic.pointer = &seat->pointer;

  drag_grab->drag_client = client;
-  drag_grab->seat = seat;

  if (source_resource)
    {
@@ -377,7 +375,7 @@ destroy_selection_data_source (struct wl_listener *listener, void *data)
    }
 }

-static void
+void
 meta_wayland_seat_set_selection (MetaWaylandSeat *seat,
                                 MetaWaylandDataSource *source,
                                 guint32 serial)
@@ -391,7 +389,7 @@ meta_wayland_seat_set_selection (MetaWaylandSeat *seat,

  if (seat->selection_data_source)
    {
-      wl_data_source_send_cancelled (seat->selection_data_source->resource);
+      seat->selection_data_source->cancel (seat->selection_data_source);
      wl_list_remove (&seat->selection_data_source_listener.link);
      seat->selection_data_source = NULL;
    }
@@ -451,21 +449,47 @@ static const struct wl_data_device_interface data_device_interface = {
 static void
 destroy_data_source (struct wl_resource *resource)
 {
-  MetaWaylandDataSource *source = wl_resource_get_user_data (resource);
+  MetaWaylandDataSource *source = wl_container_of (resource, source, resource);
  char **p;

  wl_array_for_each (p, &source->mime_types) free (*p);

  wl_array_release (&source->mime_types);
+}

-  g_slice_free (MetaWaylandDataSource, source);
+static void
+client_source_accept (MetaWaylandDataSource *source,
+                      guint32 time, const char *mime_type)
+{
+  wl_data_source_send_target (source->resource, mime_type);
+}
+
+static void
+client_source_send (MetaWaylandDataSource *source,
+                    const char *mime_type, int32_t fd)
+{
+  wl_data_source_send_send (source->resource, mime_type, fd);
+  close (fd);
+}
+
+static void
+client_source_cancel (MetaWaylandDataSource *source)
+{
+  wl_data_source_send_cancelled (source->resource);
 }

 static void
 create_data_source (struct wl_client *client,
                    struct wl_resource *resource, guint32 id)
 {
-  MetaWaylandDataSource *source = g_slice_new0 (MetaWaylandDataSource);
+  MetaWaylandDataSource *source;
+
+  source = malloc (sizeof *source);
+  if (source == NULL)
+    {
+      wl_resource_post_no_memory (resource);
+      return;
+    }

  source->resource = wl_resource_create (client, &wl_data_source_interface,
 					 MIN (META_WL_DATA_SOURCE_VERSION,
@@ -473,6 +497,10 @@ create_data_source (struct wl_client *client,
  wl_resource_set_implementation (source->resource, &data_source_interface,
 				  source, destroy_data_source);

+  source->accept = client_source_accept;
+  source->send = client_source_send;
+  source->cancel = client_source_cancel;
+
  wl_array_init (&source->mime_types);
 }

--- a/src/wayland/meta-wayland-data-device.h
+++ b/src/wayland/meta-wayland-data-device.h
@@ -33,4 +33,10 @@ meta_wayland_data_device_set_keyboard_focus (MetaWaylandSeat *seat);
 int
 meta_wayland_data_device_manager_init (struct wl_display *display);

+void
+meta_wayland_seat_set_selection (MetaWaylandSeat *seat,
+                                 MetaWaylandDataSource *source,
+                                 uint32_t serial);
+
+
 #endif /* __META_WAYLAND_DATA_DEVICE_H__ */
--- a/src/wayland/meta-wayland-keyboard.c
+++ b/src/wayland/meta-wayland-keyboard.c
@@ -142,6 +142,20 @@ meta_wayland_keyboard_take_keymap (MetaWaylandKeyboard *keyboard,
    xkb_keymap_unref (xkb_info->keymap);
  xkb_info->keymap = keymap;

+  xkb_info->shift_mod =
+    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_SHIFT);
+  xkb_info->caps_mod =
+    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_CAPS);
+  xkb_info->ctrl_mod =
+    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_CTRL);
+  xkb_info->alt_mod =
+    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_ALT);
+  xkb_info->mod2_mod = xkb_map_mod_get_index (xkb_info->keymap, "Mod2");
+  xkb_info->mod3_mod = xkb_map_mod_get_index (xkb_info->keymap, "Mod3");
+  xkb_info->super_mod =
+    xkb_map_mod_get_index (xkb_info->keymap, XKB_MOD_NAME_LOGO);
+  xkb_info->mod5_mod = xkb_map_mod_get_index (xkb_info->keymap, "Mod5");
+
  keymap_str = xkb_map_get_as_string (xkb_info->keymap);
  if (keymap_str == NULL)
    {
@@ -281,6 +295,31 @@ static const MetaWaylandKeyboardGrabInterface
  default_grab_modifiers,
 };

+static gboolean
+modal_key (MetaWaylandKeyboardGrab *grab,
+	   uint32_t                 time,
+	   uint32_t                 key,
+	   uint32_t                 state)
+{
+  /* FALSE means: let the event through to clutter */
+  return FALSE;
+}
+
+static void
+modal_modifiers (MetaWaylandKeyboardGrab *grab,
+		 uint32_t                 serial,
+		 uint32_t                 mods_depressed,
+		 uint32_t                 mods_latched,
+		 uint32_t                 mods_locked,
+		 uint32_t                 group)
+{
+}
+
+static MetaWaylandKeyboardGrabInterface modal_grab = {
+  modal_key,
+  modal_modifiers,
+};
+
 gboolean
 meta_wayland_keyboard_init (MetaWaylandKeyboard *keyboard,
                            struct wl_display   *display)
@@ -496,13 +535,26 @@ meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
          struct wl_display *display = wl_client_get_display (client);
          uint32_t serial = wl_display_next_serial (display);

-          wl_keyboard_send_modifiers (keyboard->focus_resource, serial,
-                                      keyboard->modifier_state.mods_depressed,
-                                      keyboard->modifier_state.mods_latched,
-                                      keyboard->modifier_state.mods_locked,
-                                      keyboard->modifier_state.group);
-          wl_keyboard_send_enter (keyboard->focus_resource, serial, keyboard->focus_surface->resource,
-                                  &keyboard->keys);
+          /* If we're in a modal grab, the client is focused but doesn't see
+             modifiers or pressed keys (and fix that up when we exit the modal) */
+          if (keyboard->grab->interface == &modal_grab)
+            {
+              struct wl_array empty;
+              wl_array_init (&empty);
+
+              wl_keyboard_send_modifiers (keyboard->focus_resource, serial, 0, 0, 0, 0);
+              wl_keyboard_send_enter (keyboard->focus_resource, serial, keyboard->focus_surface->resource, &empty);
+            }
+          else
+            {
+              wl_keyboard_send_modifiers (keyboard->focus_resource, serial,
+                                          keyboard->modifier_state.mods_depressed,
+                                          keyboard->modifier_state.mods_latched,
+                                          keyboard->modifier_state.mods_locked,
+                                          keyboard->modifier_state.group);
+              wl_keyboard_send_enter (keyboard->focus_resource, serial, keyboard->focus_surface->resource,
+                                      &keyboard->keys);
+            }

          wl_resource_add_destroy_listener (keyboard->focus_resource, &keyboard->focus_resource_listener);
          keyboard->focus_serial = serial;
@@ -536,6 +588,85 @@ meta_wayland_keyboard_release (MetaWaylandKeyboard *keyboard)
  wl_array_release (&keyboard->keys);
 }

+gboolean
+meta_wayland_keyboard_begin_modal (MetaWaylandKeyboard *keyboard,
+				   guint32              timestamp)
+{
+  MetaWaylandKeyboardGrab *grab;
+  uint32_t *end = (void *) ((char *) keyboard->keys.data +
+			    keyboard->keys.size);
+  uint32_t *k;
+  uint32_t serial;
+
+  meta_verbose ("Asked to acquire modal keyboard grab, timestamp %d\n", timestamp);
+
+  if (keyboard->grab != &keyboard->default_grab)
+    return FALSE;
+
+  if (keyboard->focus_surface)
+    {
+      /* Fake key release events for the focused app */
+      serial = wl_display_next_serial (keyboard->display);
+      keyboard->grab->interface->modifiers (keyboard->grab,
+					    serial,
+					    0, 0, 0, 0);
+
+      for (k = keyboard->keys.data; k < end; k++)
+	{
+	  keyboard->grab->interface->key (keyboard->grab,
+					  timestamp,
+					  *k, 0);
+	}
+    }
+
+  grab = g_slice_new0 (MetaWaylandKeyboardGrab);
+  grab->interface = &modal_grab;
+  meta_wayland_keyboard_start_grab (keyboard, grab);
+
+  meta_verbose ("Acquired modal keyboard grab, timestamp %d\n", timestamp);
+
+  return TRUE;
+}
+
+void
+meta_wayland_keyboard_end_modal (MetaWaylandKeyboard *keyboard,
+				 guint32              timestamp)
+{
+  MetaWaylandKeyboardGrab *grab;
+  uint32_t *end = (void *) ((char *) keyboard->keys.data +
+			    keyboard->keys.size);
+  uint32_t *k;
+  uint32_t serial;
+
+  grab = keyboard->grab;
+
+  g_assert (grab->interface == &modal_grab);
+
+  meta_wayland_keyboard_end_grab (keyboard);
+  g_slice_free (MetaWaylandKeyboardGrab, grab);
+
+  if (keyboard->focus_surface)
+    {
+      /* Fake key press events for the focused app */
+      serial = wl_display_next_serial (keyboard->display);
+      keyboard->grab->interface->modifiers (keyboard->grab,
+					    serial,
+					    keyboard->modifier_state.mods_depressed,
+					    keyboard->modifier_state.mods_latched, 
+					    keyboard->modifier_state.mods_locked,
+					    keyboard->modifier_state.group);
+
+      for (k = keyboard->keys.data; k < end; k++)
+	{
+	  keyboard->grab->interface->key (keyboard->grab,
+					  timestamp,
+					  *k, 1);
+	}
+    }
+
+  meta_verbose ("Released modal keyboard grab, timestamp %d\n", timestamp);
+}
+
 void
 meta_wayland_keyboard_set_keymap_names (MetaWaylandKeyboard *keyboard,
 					const char          *rules,
--- a/src/wayland/meta-wayland-keyboard.h
+++ b/src/wayland/meta-wayland-keyboard.h
@@ -72,6 +72,14 @@ typedef struct
  int keymap_fd;
  size_t keymap_size;
  char *keymap_area;
+  xkb_mod_index_t shift_mod;
+  xkb_mod_index_t caps_mod;
+  xkb_mod_index_t ctrl_mod;
+  xkb_mod_index_t alt_mod;
+  xkb_mod_index_t mod2_mod;
+  xkb_mod_index_t mod3_mod;
+  xkb_mod_index_t super_mod;
+  xkb_mod_index_t mod5_mod;
 } MetaWaylandXkbInfo;

 typedef struct
@@ -142,6 +150,13 @@ meta_wayland_keyboard_start_grab (MetaWaylandKeyboard *device,
 void
 meta_wayland_keyboard_end_grab (MetaWaylandKeyboard *keyboard);

+gboolean
+meta_wayland_keyboard_begin_modal (MetaWaylandKeyboard *keyboard,
+				   guint32              timestamp);
+void
+meta_wayland_keyboard_end_modal   (MetaWaylandKeyboard *keyboard,
+				   guint32              timestamp);
+
 void
 meta_wayland_keyboard_release (MetaWaylandKeyboard *keyboard);

--- a/src/wayland/meta-wayland-pointer.c
+++ b/src/wayland/meta-wayland-pointer.c
@@ -398,6 +398,61 @@ meta_wayland_pointer_end_grab (MetaWaylandPointer *pointer)
  interface->focus (pointer->grab, pointer->current, NULL);
 }

+static void
+modal_focus (MetaWaylandPointerGrab *grab,
+	     MetaWaylandSurface     *surface,
+	     const ClutterEvent     *event)
+{
+}
+
+static void
+modal_motion (MetaWaylandPointerGrab *grab,
+	      const ClutterEvent     *event)
+{
+}
+
+static void
+modal_button (MetaWaylandPointerGrab *grab,
+	      const ClutterEvent     *event)
+{
+}
+
+static MetaWaylandPointerGrabInterface modal_grab = {
+  modal_focus,
+  modal_motion,
+  modal_button
+};
+
+gboolean
+meta_wayland_pointer_begin_modal (MetaWaylandPointer *pointer)
+{
+  MetaWaylandPointerGrab *grab;
+
+  if (pointer->grab != &pointer->default_grab)
+    return FALSE;
+
+  meta_wayland_pointer_set_focus (pointer, NULL);
+
+  grab = g_slice_new0 (MetaWaylandPointerGrab);
+  grab->interface = &modal_grab;
+  meta_wayland_pointer_start_grab (pointer, grab);
+
+  return TRUE;
+}
+
+void
+meta_wayland_pointer_end_modal (MetaWaylandPointer *pointer)
+{
+  MetaWaylandPointerGrab *grab;
+
+  grab = pointer->grab;
+
+  g_assert (grab->interface == &modal_grab);
+
+  meta_wayland_pointer_end_grab (pointer);
+  g_slice_free (MetaWaylandPointerGrab, grab);
+}
+
 typedef struct {
  MetaWaylandPointerGrab  generic;

@@ -478,12 +533,6 @@ meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer)
      g_slice_free (MetaWaylandPopup, popup);
    }

-  {
-    MetaDisplay *display = meta_get_display ();
-    meta_display_end_grab_op (display,
-                              meta_display_get_current_time_roundtrip (display));
-  }
-
  meta_wayland_pointer_end_grab (pointer);
  g_slice_free (MetaWaylandPopupGrab, popup_grab);
 }
@@ -523,8 +572,6 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,

  if (pointer->grab == &pointer->default_grab)
    {
-      MetaWindow *window = surface->window;
-
      grab = g_slice_new0 (MetaWaylandPopupGrab);
      grab->generic.interface = &popup_grab_interface;
      grab->generic.pointer = pointer;
@@ -532,19 +579,6 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,
      wl_list_init (&grab->all_popups);

      meta_wayland_pointer_start_grab (pointer, (MetaWaylandPointerGrab*)grab);
-
-      meta_display_begin_grab_op (window->display,
-                                  window->screen,
-                                  window,
-                                  META_GRAB_OP_WAYLAND_CLIENT,
-                                  FALSE, /* pointer_already_grabbed */
-                                  FALSE, /* frame_action */
-                                  1, /* button. XXX? */
-                                  0, /* modmask */
-                                  meta_display_get_current_time_roundtrip (window->display),
-                                  wl_fixed_to_int (pointer->grab_x),
-                                  wl_fixed_to_int (pointer->grab_y));
-
    }
  else
    grab = (MetaWaylandPopupGrab*)pointer->grab;
@@ -559,6 +593,7 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,
    wl_resource_add_destroy_listener (surface->wl_shell_surface.resource, &popup->surface_destroy_listener);

  wl_list_insert (&grab->all_popups, &popup->link);
+      
  return TRUE;
 }

--- a/src/wayland/meta-wayland-pointer.h
+++ b/src/wayland/meta-wayland-pointer.h
@@ -85,6 +85,11 @@ meta_wayland_pointer_start_grab (MetaWaylandPointer *pointer,
 void
 meta_wayland_pointer_end_grab (MetaWaylandPointer *pointer);

+gboolean
+meta_wayland_pointer_begin_modal (MetaWaylandPointer *pointer);
+void
+meta_wayland_pointer_end_modal   (MetaWaylandPointer *pointer);
+
 gboolean
 meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,
 				       MetaWaylandSurface *popup);
--- a/src/wayland/meta-wayland-seat.c
+++ b/src/wayland/meta-wayland-seat.c
@@ -276,53 +276,42 @@ static void
 handle_scroll_event (MetaWaylandSeat    *seat,
                     const ClutterEvent *event)
 {
-  wl_fixed_t x_value = 0, y_value = 0;
+  enum wl_pointer_axis axis;
+  wl_fixed_t value;

  notify_motion (seat, event);

-  if (!seat->pointer.focus_resource)
-    return;
-
-  if (clutter_event_is_pointer_emulated (event))
-    return;
-
  switch (clutter_event_get_scroll_direction (event))
    {
    case CLUTTER_SCROLL_UP:
-      y_value = -DEFAULT_AXIS_STEP_DISTANCE;
+      axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
+      value = -DEFAULT_AXIS_STEP_DISTANCE;
      break;

    case CLUTTER_SCROLL_DOWN:
-      y_value = DEFAULT_AXIS_STEP_DISTANCE;
+      axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
+      value = DEFAULT_AXIS_STEP_DISTANCE;
      break;

    case CLUTTER_SCROLL_LEFT:
-      x_value = -DEFAULT_AXIS_STEP_DISTANCE;
+      axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
+      value = -DEFAULT_AXIS_STEP_DISTANCE;
      break;

    case CLUTTER_SCROLL_RIGHT:
-      x_value = DEFAULT_AXIS_STEP_DISTANCE;
-      break;
-
-    case CLUTTER_SCROLL_SMOOTH:
-      {
-        double dx, dy;
-        clutter_event_get_scroll_delta (event, &dx, &dy);
-        x_value = wl_fixed_from_double (dx);
-        y_value = wl_fixed_from_double (dy);
-      }
+      axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
+      value = DEFAULT_AXIS_STEP_DISTANCE;
      break;

    default:
      return;
    }

-  if (x_value)
-    wl_pointer_send_axis (seat->pointer.focus_resource, clutter_event_get_time (event),
-                          WL_POINTER_AXIS_HORIZONTAL_SCROLL, x_value);
-  if (y_value)
-    wl_pointer_send_axis (seat->pointer.focus_resource, clutter_event_get_time (event),
-                          WL_POINTER_AXIS_VERTICAL_SCROLL, y_value);
+  if (seat->pointer.focus_resource)
+    wl_pointer_send_axis (seat->pointer.focus_resource,
+                          clutter_event_get_time (event),
+                          axis,
+                          value);
 }

 static int
--- a/src/wayland/meta-wayland-seat.h
+++ b/src/wayland/meta-wayland-seat.h
@@ -43,6 +43,12 @@ struct _MetaWaylandDataSource
 {
  struct wl_resource *resource;
  struct wl_array mime_types;
+
+  void (*accept) (MetaWaylandDataSource * source,
+                  uint32_t serial, const char *mime_type);
+  void (*send) (MetaWaylandDataSource * source,
+                const char *mime_type, int32_t fd);
+  void (*cancel) (MetaWaylandDataSource * source);
 };

 struct _MetaWaylandSeat
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
@@ -336,6 +336,22 @@ toplevel_surface_commit (MetaWaylandSurface             *surface,

  if (pending->frame_extents_changed)
    meta_window_set_custom_frame_extents (surface->window, &pending->frame_extents);
+
+  if (pending->maximized.changed)
+    {
+      if (pending->maximized.value)
+        meta_window_maximize (surface->window, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+      else
+        meta_window_unmaximize (surface->window, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+    }
+
+  if (pending->fullscreen.changed)
+    {
+      if (pending->fullscreen.value)
+        meta_window_make_fullscreen (surface->window);
+      else
+        meta_window_unmake_fullscreen (surface->window);
+    }
 }

 static void
@@ -361,6 +377,8 @@ double_buffered_state_init (MetaWaylandDoubleBufferedState *state)
  wl_list_init (&state->frame_callback_list);

  state->frame_extents_changed = FALSE;
+  state->maximized.changed = FALSE;
+  state->fullscreen.changed = FALSE;
 }

 static void
@@ -843,44 +861,44 @@ xdg_surface_set_output (struct wl_client *client,
 }

 static void
-xdg_surface_request_change_state (struct wl_client *client,
-                                  struct wl_resource *resource,
-                                  uint32_t state_type,
-                                  uint32_t value,
-                                  uint32_t serial)
+xdg_surface_set_fullscreen (struct wl_client *client,
+                            struct wl_resource *resource)
 {
  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);

-  surface->state_changed_serial = serial;
-
-  switch (state_type)
-    {
-    case XDG_SURFACE_STATE_MAXIMIZED:
-      if (value)
-        meta_window_maximize (surface->window, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
-      else
-        meta_window_unmaximize (surface->window, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
-      break;
-    case XDG_SURFACE_STATE_FULLSCREEN:
-      if (value)
-        meta_window_make_fullscreen (surface->window);
-      else
-        meta_window_unmake_fullscreen (surface->window);
-    }
+  surface->pending.fullscreen.changed = TRUE;
+  surface->pending.fullscreen.value = TRUE;
 }

 static void
-xdg_surface_ack_change_state (struct wl_client *client,
-                              struct wl_resource *resource,
-                              uint32_t state_type,
-                              uint32_t value,
-                              uint32_t serial)
+xdg_surface_unset_fullscreen (struct wl_client *client,
+                              struct wl_resource *resource)
 {
-  /* Do nothing for now. In the future, we'd imagine that
-   * we'd ignore attaches when we have a state pending that
-   * we haven't had the client ACK'd, to prevent a race
-   * condition when we have an in-flight attach when the
-   * client gets the new state. */
+  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
+  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+
+  surface->pending.fullscreen.changed = TRUE;
+  surface->pending.fullscreen.value = FALSE;
+}
+
+static void
+xdg_surface_set_maximized (struct wl_client *client,
+                           struct wl_resource *resource)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  surface->pending.maximized.changed = TRUE;
+  surface->pending.maximized.value = TRUE;
+}
+
+static void
+xdg_surface_unset_maximized (struct wl_client *client,
+                             struct wl_resource *resource)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  surface->pending.maximized.changed = TRUE;
+  surface->pending.maximized.value = FALSE;
 }

 static void
@@ -901,8 +919,10 @@ static const struct xdg_surface_interface meta_wayland_xdg_surface_interface = {
  xdg_surface_move,
  xdg_surface_resize,
  xdg_surface_set_output,
-  xdg_surface_request_change_state,
-  xdg_surface_ack_change_state,
+  xdg_surface_set_fullscreen,
+  xdg_surface_unset_fullscreen,
+  xdg_surface_set_maximized,
+  xdg_surface_unset_maximized,
  xdg_surface_set_minimized,
 };

@@ -991,7 +1011,8 @@ xdg_shell_get_xdg_popup (struct wl_client *client,
  surface->window->placed = TRUE;
  meta_window_set_transient_for (surface->window, parent_surf->window);

-  meta_window_set_type (surface->window, META_WINDOW_DROPDOWN_MENU);
+  surface->window->type = META_WINDOW_DROPDOWN_MENU;
+  meta_window_type_changed (surface->window);

  meta_wayland_pointer_start_popup_grab (&seat->pointer, surface);
 }
@@ -1444,6 +1465,8 @@ subsurface_parent_surface_committed (MetaWaylandSurface *surface)

  if (surface->sub.synchronous)
    commit_double_buffered_state (surface, pending_surface_state);
+
+  double_buffered_state_reset (pending_surface_state);
 }

 static void
@@ -1715,55 +1738,6 @@ meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
                                     0, new_width, new_height);
 }

-static void
-send_change_state (MetaWaylandSurface *surface,
-                   uint32_t state_type,
-                   uint32_t value)
-{
-  if (surface->xdg_surface.resource)
-    {
-      uint32_t serial;
-
-      if (surface->state_changed_serial != 0)
-        {
-          serial = surface->state_changed_serial;
-          surface->state_changed_serial = 0;
-        }
-      else
-        {
-          struct wl_client *client = wl_resource_get_client (surface->xdg_surface.resource);
-          struct wl_display *display = wl_client_get_display (client);
-          serial = wl_display_next_serial (display);
-        }
-
-      xdg_surface_send_change_state (surface->xdg_surface.resource, state_type, value, serial);
-    }
-}
-
-void
-meta_wayland_surface_send_maximized (MetaWaylandSurface *surface)
-{
-  send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, TRUE);
-}
-
-void
-meta_wayland_surface_send_unmaximized (MetaWaylandSurface *surface)
-{
-  send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, FALSE);
-}
-
-void
-meta_wayland_surface_send_fullscreened (MetaWaylandSurface *surface)
-{
-  send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, TRUE);
-}
-
-void
-meta_wayland_surface_send_unfullscreened (MetaWaylandSurface *surface)
-{
-  send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, FALSE);
-}
-
 void
 meta_wayland_surface_activated (MetaWaylandSurface *surface)
 {
--- a/src/wayland/meta-wayland-surface.h
+++ b/src/wayland/meta-wayland-surface.h
@@ -41,6 +41,12 @@ struct _MetaWaylandBuffer
  uint32_t ref_count;
 };

+typedef struct
+{
+  guint changed : 1;
+  guint value : 1;
+} MetaWaylandStateFlag;
+
 typedef struct
 {
  /* wl_surface.attach */
@@ -61,6 +67,9 @@ typedef struct

  gboolean frame_extents_changed;
  GtkBorder frame_extents;
+
+  MetaWaylandStateFlag fullscreen;
+  MetaWaylandStateFlag maximized;
 } MetaWaylandDoubleBufferedState;

 typedef struct
@@ -98,8 +107,6 @@ struct _MetaWaylandSurface
    GSList *pending_placement_ops;
  } sub;

-  uint32_t state_changed_serial;
-
  /* All the pending state, that wl_surface.commit will apply. */
  MetaWaylandDoubleBufferedState pending;
 };
@@ -117,10 +124,6 @@ void                meta_wayland_surface_window_unmanaged (MetaWaylandSurface *s
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
 							   int                 width,
 							   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_activated (MetaWaylandSurface *surface);
 void                meta_wayland_surface_deactivated (MetaWaylandSurface *surface);
--- a/src/wayland/meta-wayland.c
+++ b/src/wayland/meta-wayland.c
@@ -643,8 +643,6 @@ meta_wayland_init (void)

  clutter_wayland_set_compositor_display (compositor->wayland_display);

-  /* If we're running on bare metal, we're a display server,
-   * so start talking to weston-launch. */
 #if defined(CLUTTER_WINDOWING_EGL)
  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
    compositor->launcher = meta_launcher_new ();
@@ -730,22 +728,7 @@ meta_wayland_compositor_activate_vt (MetaWaylandCompositor  *compositor,
    }
  else
    {
-      g_debug ("Ignoring VT switch keybinding, not running as display server");
-      return TRUE;
-    }
-}
-
-gboolean
-meta_wayland_compositor_activate_session (MetaWaylandCompositor  *compositor,
-                                          GError                **error)
-{
-  if (compositor->launcher)
-    {
-      return meta_launcher_activate_vt (compositor->launcher, -1, error);
-    }
-  else
-    {
-      g_debug ("Ignoring activate_session, not running as display server");
+      g_debug ("Ignoring VT switch keybinding, not running as VT manager");
      return TRUE;
    }
 }
--- a/src/wayland/meta-wayland.h
+++ b/src/wayland/meta-wayland.h
@@ -46,8 +46,6 @@ void                    meta_wayland_compositor_paint_finished  (MetaWaylandComp
 gboolean                meta_wayland_compositor_activate_vt     (MetaWaylandCompositor  *compositor,
                                                                 int                     vt,
                                                                 GError                **error);
-gboolean                meta_wayland_compositor_activate_session (MetaWaylandCompositor  *compositor,
-                                                                  GError                **error);

 #endif

--- a/src/wayland/meta-weston-launch.c
+++ b/src/wayland/meta-weston-launch.c
@@ -41,8 +41,6 @@
 #include <xf86drm.h>
 #include <xf86drmMode.h>

-#include "meta-wayland-private.h"
-#include "meta-cursor-tracker-private.h"
 #include "meta-weston-launch.h"

 struct _MetaLauncher
@@ -181,11 +179,11 @@ meta_launcher_set_drm_fd (MetaLauncher  *self,
  return ok;
 }

-static int
+int
 meta_launcher_open_input_device (MetaLauncher  *self,
-                                 const char    *name,
-                                 int            flags,
-                                 GError       **error)
+				 const char    *name,
+				 int            flags,
+				 GError       **error)
 {
  struct weston_launcher_open *message;
  GSocketControlMessage *cmsg;
@@ -234,17 +232,6 @@ meta_launcher_enter (MetaLauncher *launcher)
  cogl_kms_display_queue_modes_reset (cogl_display);

  clutter_evdev_reclaim_devices ();
-
-  {
-    MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
-
-    /* When we mode-switch back, we need to immediately queue a redraw
-     * in case nothing else queued one for us, and force the cursor to
-     * update. */
-
-    clutter_actor_queue_redraw (compositor->stage);
-    meta_cursor_tracker_force_update (compositor->seat->cursor_tracker);
-  }
 }

 static void
@@ -264,13 +251,6 @@ on_evdev_device_open (const char  *path,
  return meta_launcher_open_input_device (launcher, path, flags, error);
 }

-static void
-on_evdev_device_close (int          fd,
-                       gpointer     user_data)
-{
-  close (fd);
-}
-
 static void
 handle_vt_enter (MetaLauncher *launcher)
 {
@@ -374,6 +354,8 @@ meta_launcher_new (void)

  self->weston_launch = g_socket_new_from_fd (launch_fd, NULL);

+  clutter_evdev_set_open_callback (on_evdev_device_open, self);
+
  self->nested_context = g_main_context_new ();
  self->nested_loop = g_main_loop_new (self->nested_context, FALSE);

@@ -387,10 +369,6 @@ meta_launcher_new (void)
  g_source_attach (self->inner_source, self->nested_context);
  g_source_unref (self->inner_source);

-  clutter_evdev_set_device_callbacks (on_evdev_device_open,
-                                      on_evdev_device_close,
-                                      self);
-
  return self;
 }

@@ -410,7 +388,7 @@ meta_launcher_free (MetaLauncher *launcher)

 gboolean
 meta_launcher_activate_vt (MetaLauncher  *launcher,
-			   signed char    vt,
+			   int            vt,
 			   GError       **error)
 {
  struct weston_launcher_activate_vt message;
--- a/src/wayland/meta-weston-launch.h
+++ b/src/wayland/meta-weston-launch.h
@@ -29,10 +29,18 @@ MetaLauncher     *meta_launcher_new                     (void);
 void              meta_launcher_free                    (MetaLauncher  *self);

 gboolean          meta_launcher_activate_vt             (MetaLauncher  *self,
-							 signed char    vt,
+							 int            number,
 							 GError       **error);

 gboolean          meta_launcher_set_drm_fd              (MetaLauncher  *self,
 							 int            drm_fd,
 							 GError       **error);
+gboolean          meta_launcher_set_master              (MetaLauncher  *self,
+							 gboolean       master,
+							 GError       **error);
+int               meta_launcher_open_input_device       (MetaLauncher  *self,
+							 const char    *name,
+							 int            flags,
+							 GError       **error);
+
 #endif
--- a/src/wayland/meta-xwayland.c
+++ b/src/wayland/meta-xwayland.c
@@ -47,13 +47,6 @@ xserver_set_window_id (struct wl_client *client,
  if (!window)
    return;

-  /* If the window has an existing surface, like if we're
-   * undecorating or decorating the window, then we need
-   * to detach the window from its old surface.
-   */
-  if (window->surface)
-    window->surface->window = NULL;
-
  meta_wayland_surface_make_toplevel (surface);

  surface->window = window;
--- a/src/wayland/weston-launch.c
+++ b/src/wayland/weston-launch.c
@@ -80,7 +80,6 @@ struct weston_launch {
 	struct termios terminal_attributes;
 	int kb_mode;
 	enum vt_state vt_state;
-	unsigned vt;

        int drm_fd;
 };
@@ -275,7 +274,6 @@ handle_activate_vt(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
 {
        struct weston_launcher_reply reply;
 	struct weston_launcher_activate_vt *message;
-	unsigned vt;

 	reply.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
 	reply.ret = -1;
@@ -287,13 +285,7 @@ handle_activate_vt(struct weston_launch *wl, struct msghdr *msg, ssize_t len)

 	message = msg->msg_iov->iov_base;

-	/* Negative values mean that we're activating our own VT */
-	if (message->vt > 0)
-		vt = message->vt;
-	else
-		vt = wl->vt;
-
-	reply.ret = ioctl(wl->tty, VT_ACTIVATE, vt);
+	reply.ret = ioctl(wl->tty, VT_ACTIVATE, message->vt);
 	if (reply.ret < 0)
 		reply.ret = -errno;

@@ -339,13 +331,6 @@ handle_open(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
 		goto err0;
 	}

-	if (major(s.st_rdev) != INPUT_MAJOR) {
-		fprintf(stderr, "Device %s is not an input device\n",
-			message->path);
-		reply.ret = -EPERM;
-		goto err0;
-	}
-
 	fd = open(message->path, message->flags);
 	if (fd < 0) {
 		fprintf(stderr, "Error opening device %s: %m\n",
@@ -354,6 +339,15 @@ handle_open(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
 		goto err0;
 	}

+	if (major(s.st_rdev) != INPUT_MAJOR) {
+		close(fd);
+		fd = -1;
+		fprintf(stderr, "Device %s is not an input device\n",
+			message->path);
+		reply.ret = -EPERM;
+		goto err0;
+	}
+
 err0:
 	memset(&nmsg, 0, sizeof nmsg);
 	nmsg.msg_iov = &iov;
@@ -560,7 +554,7 @@ setup_tty(struct weston_launch *wl)
 	struct stat buf;
 	struct termios raw_attributes;
 	struct vt_mode mode = { 0 };
-	char *session;
+	char *session, *tty;
 	char path[PATH_MAX];
 	int ok;

@@ -568,12 +562,43 @@ setup_tty(struct weston_launch *wl)
 	if (ok < 0)
 	  error(1, -ok, "could not determine current session");

-	ok = sd_session_get_vt(session, &wl->vt);
-	if (ok < 0)
-		error(1, -ok, "could not determine current TTY");
+	ok = sd_session_get_tty(session, &tty);
+	if (ok == 0) {
+		/* Old systemd only has the tty name in the TTY
+		   field, new one has the full char device path.

-	snprintf(path, PATH_MAX, "/dev/tty%u", wl->vt);
-	wl->tty = open(path, O_RDWR | O_NOCTTY | O_CLOEXEC);
+		   Check what we have and fix it properly.
+		*/
+		if (strncmp(tty, "/dev", strlen("/dev")) == 0) {
+			strncpy(path, tty, PATH_MAX);
+			path[PATH_MAX-1] = 0;
+		} else {
+			snprintf(path, PATH_MAX, "/dev/%s", tty);
+		}
+
+		wl->tty = open(path, O_RDWR | O_NOCTTY | O_CLOEXEC);
+		free(tty);
+#ifdef HAVE_SD_SESSION_GET_VT
+	} else if (ok == -ENOENT) {
+		unsigned vt;
+
+		/* Negative errnos are cool, right?
+		   So cool that we can't distinguish "session not found"
+		   from "key does not exist in the session file"!
+		   Let's assume the latter, as we got the value
+		   from sd_pid_get_session()...
+		*/
+
+		ok = sd_session_get_vt(session, &vt);
+		if (ok < 0)
+			error(1, -ok, "could not determine current TTY");
+
+		snprintf(path, PATH_MAX, "/dev/tty%u", vt);
+		wl->tty = open(path, O_RDWR | O_NOCTTY | O_CLOEXEC);
+		free(tty);
+#endif
+	} else
+		error(1, -ok, "could not determine current TTY");

 	if (wl->tty < 0)
 		error(1, errno, "failed to open tty");
--- a/src/wayland/weston-launch.h
+++ b/src/wayland/weston-launch.h
@@ -53,7 +53,7 @@ struct weston_launcher_open {

 struct weston_launcher_activate_vt {
 	struct weston_launcher_message header;
-	signed char vt;
+	int vt;
 };

 struct weston_launcher_reply {