wayland: Add support for show_window_menu

To show the window menu from a client-side decoration.

.gitignore

@@ -48,7 +48,6 @@ po/*.pot
 50-metacity-key.xml
 libmutter-wayland.pc
 mutter-wayland
-mutter-launch
 org.gnome.mutter.gschema.valid
 org.gnome.mutter.gschema.xml
 org.gnome.mutter.wayland.gschema.valid
@@ -77,6 +76,7 @@ src/mutter-marshal.[ch]
 src/stamp-mutter-marshal.h
 src/meta-dbus-xrandr.[ch]
 src/meta-dbus-idle-monitor.[ch]
+src/meta-dbus-login1.[ch]
 src/mutter-plugins.pc
 src/wayland/gtk-shell-protocol.c
 src/wayland/gtk-shell-server-protocol.h

NEWS

@@ -1,3 +1,28 @@
+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]
+* Make tile previews a compositor effect [Stefano, Florian; #665758]
+* Misc. bug fixes and cleanups [Ryan, Giovanni, Jasper, Adel; #722530, #724257,
+  #724258, #720631, #724364, #724472]
+
+Contributors:
+  Giovanni Campagna, Marek Chalupa, Stefano Facchini, Adel Gadllah,
+  Ryan Lortie, Florian Müllner, Jasper St. Pierre, Rico Tzschichholz
+
 3.11.5
 ======
 * Fix CSD titlebars being placed off-screen [Jasper; #719772]

configure.ac

@@ -3,7 +3,7 @@ AC_CONFIG_MACRO_DIR([m4])
 
 m4_define([mutter_major_version], [3])
 m4_define([mutter_minor_version], [11])
-m4_define([mutter_micro_version], [5])
+m4_define([mutter_micro_version], [91])
 
 m4_define([mutter_version],
           [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -78,7 +78,7 @@ MUTTER_PC_MODULES="
    cairo >= 1.10.0
    gsettings-desktop-schemas >= 3.7.3
    xcomposite >= 0.2 xfixes xrender xdamage xi >= 1.6.0
-   $CLUTTER_PACKAGE >= 1.17.1
+   $CLUTTER_PACKAGE >= 1.17.5
    cogl-1.0 >= 1.17.1
    upower-glib >= 0.99.0
    gnome-desktop-3.0
@@ -140,12 +140,6 @@ AM_GLIB_GNU_GETTEXT
 ## here we get the flags we'll actually use
 # GRegex requires Glib-2.14.0
 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"
@@ -218,7 +212,7 @@ AS_IF([test "x$WAYLAND_SCANNER" = "xno"],
 AC_SUBST([WAYLAND_SCANNER])
 AC_SUBST(XWAYLAND_PATH)
 
-MUTTER_PC_MODULES="$MUTTER_PC_MODULES clutter-wayland-1.0 clutter-wayland-compositor-1.0 clutter-egl-1.0 wayland-server libdrm"
+MUTTER_PC_MODULES="$MUTTER_PC_MODULES clutter-wayland-1.0 clutter-wayland-compositor-1.0 clutter-egl-1.0 wayland-server libdrm libsystemd"
 PKG_CHECK_MODULES(MUTTER, $MUTTER_PC_MODULES)
 
 PKG_CHECK_EXISTS([xi >= 1.6.99.1],

protocol/xdg-shell.xml

@@ -40,19 +40,22 @@
 
     <enum name="version">
       <description summary="latest protocol version">
-	Use this enum to check the protocol version, and it will be updated
-	automatically.
+	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.
       </description>
-      <entry name="current" value="2" summary="Always the latest version"/>
+      <entry name="current" value="3" summary="Always the latest version"/>
     </enum>
 
 
     <request name="use_unstable_version">
       <description summary="enable use of this unstable version">
-	Use this request in order to enable use of this interface.
-
-	Understand and agree that one is using an unstable interface,
-	that will likely change in the future, breaking the API.
+	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.
       </description>
       <arg name="version" type="int"/>
     </request>
@@ -198,6 +201,37 @@
       <arg name="app_id" type="string"/>
     </request>
 
+    <enum name="surface_type">
+      <description summary="surface types">
+        Surface
+      </description>
+      <entry name="normal" value="0" summary="A normal window. This is the default type."/>
+      <entry name="modal_dialog" value="1" summary="A modal dialog."/>
+    </enum>
+
+    <request name="set_surface_type">
+      <description summary="set the surface type">
+        Sets the type of the surface. These are high-level "roles" of
+        surfaces designed to give the compositor more heuristics about
+        how to place and manage the window.
+      </description>
+      <arg name="surface_type" type="uint" summary="a surface type from surface_type"/>
+    </request>
+
+    <request name="show_window_menu">
+      <description summary="show the window menu">
+        Clients implementing client-side decorations might want to show
+        a context menu when right-clicking on the decorations, giving the
+        user a menu that they can use to maximize or minimize the window.
+
+        The seat passed must have either pointer or keyboard focus to pop
+        up the window menu for a surface.
+      </description>
+
+      <arg name="seat" type="object" interface="wl_seat" summary="the seat to pop the window up on"/>
+      <arg name="serial" type="uint" summary="serial of the event to pop up the window for"/>
+    </request>
+
     <request name="move">
       <description summary="start an interactive move">
 	Start a pointer-driven move of the surface.
@@ -275,7 +309,7 @@
       <arg name="output" type="object" interface="wl_output" allow-null="true"/>
     </request>
 
-    <enum name="state_type">
+    <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

src/50-mutter-navigation.xml.in

@@ -29,6 +29,18 @@
 	<KeyListEntry name="move-to-workspace-down"
 	              _description="Move window one workspace down" />
 
+	<KeyListEntry name="move-to-monitor-left"
+	              _description="Move window one monitor to the left" />
+
+	<KeyListEntry name="move-to-monitor-right"
+	              _description="Move window one monitor to the right" />
+
+	<KeyListEntry name="move-to-monitor-up"
+	              _description="Move window one monitor up" />
+
+	<KeyListEntry name="move-to-monitor-down"
+	              _description="Move window one monitor down" />
+
 	<KeyListEntry name="switch-applications"
 	              _description="Switch applications"/>
 

src/Makefile.am

@@ -6,6 +6,7 @@ lib_LTLIBRARIES = libmutter-wayland.la
 SUBDIRS=compositor/plugins
 
 INCLUDES=								\
+	-DCLUTTER_ENABLE_COMPOSITOR_API					\
 	-DCLUTTER_ENABLE_EXPERIMENTAL_API				\
 	-DCOGL_ENABLE_EXPERIMENTAL_API					\
 	-DCOGL_ENABLE_EXPERIMENTAL_2_0_API                              \
@@ -38,6 +39,7 @@ INCLUDES += \
 mutter_built_sources = \
 	$(dbus_idle_built_sources)		\
 	$(dbus_xrandr_built_sources)		\
+	$(dbus_login1_built_sources)		\
 	mutter-enum-types.h 			\
 	mutter-enum-types.c			\
 	wayland/gtk-shell-protocol.c		\
@@ -80,6 +82,10 @@ libmutter_wayland_la_SOURCES =			\
 	compositor/meta-shaped-texture-private.h 	\
 	compositor/meta-surface-actor.c		\
 	compositor/meta-surface-actor.h		\
+	compositor/meta-surface-actor-x11.c	\
+	compositor/meta-surface-actor-x11.h	\
+	compositor/meta-surface-actor-wayland.c	\
+	compositor/meta-surface-actor-wayland.h	\
 	compositor/meta-texture-rectangle.c	\
 	compositor/meta-texture-rectangle.h	\
 	compositor/meta-texture-tower.c		\
@@ -108,8 +114,6 @@ libmutter_wayland_la_SOURCES =			\
 	core/display.c				\
 	core/display-private.h			\
 	meta/display.h				\
-	ui/draw-workspace.c			\
-	ui/draw-workspace.h			\
 	core/edge-resistance.c			\
 	core/edge-resistance.h			\
 	core/edid-parse.c			\
@@ -174,22 +178,15 @@ libmutter_wayland_la_SOURCES =			\
 	ui/ui.h					\
 	ui/frames.c				\
 	ui/frames.h				\
-	ui/menu.c				\
-	ui/menu.h				\
-	ui/metaaccellabel.c			\
-	ui/metaaccellabel.h			\
 	ui/resizepopup.c			\
 	ui/resizepopup.h			\
-	ui/tabpopup.c				\
-	ui/tabpopup.h				\
-	ui/tile-preview.c			\
-	ui/tile-preview.h			\
 	ui/theme-parser.c			\
 	ui/theme.c				\
 	meta/theme.h				\
 	ui/theme-private.h			\
 	ui/ui.c					\
 	wayland/meta-wayland.c			\
+	wayland/meta-wayland.h			\
 	wayland/meta-wayland-private.h		\
 	wayland/meta-xwayland-private.h		\
 	wayland/meta-xwayland.c			\
@@ -207,8 +204,8 @@ libmutter_wayland_la_SOURCES =			\
 	wayland/meta-wayland-surface.h		\
 	wayland/meta-wayland-types.h		\
 	wayland/meta-wayland-versions.h		\
-	wayland/meta-weston-launch.c		\
-	wayland/meta-weston-launch.h
+	wayland/meta-login1.c			\
+	wayland/meta-login1.h
 
 nodist_libmutter_wayland_la_SOURCES =		\
 	$(mutter_built_sources)
@@ -263,17 +260,6 @@ bin_PROGRAMS=mutter-wayland
 mutter_wayland_SOURCES = core/mutter.c
 mutter_wayland_LDADD = $(MUTTER_LIBS) libmutter-wayland.la
 
-bin_PROGRAMS+=mutter-launch
-
-mutter_launch_SOURCES = wayland/weston-launch.c wayland/weston-launch.h
-
-mutter_launch_CFLAGS = $(MUTTER_LAUNCH_CFLAGS) -DLIBDIR=\"$(libdir)\"
-mutter_launch_LDFLAGS = $(MUTTER_LAUNCH_LIBS) -lpam
-
-install-exec-hook:
-	-chown root $(DESTDIR)$(bindir)/mutter-launch
-	-chmod u+s $(DESTDIR)$(bindir)/mutter-launch
-
 if HAVE_INTROSPECTION
 include $(INTROSPECTION_MAKEFILE)
 
@@ -409,6 +395,15 @@ $(dbus_idle_built_sources) : Makefile.am idle-monitor.xml
 		--c-generate-object-manager						\
 		$(srcdir)/idle-monitor.xml
 
+dbus_login1_built_sources = meta-dbus-login1.c meta-dbus-login1.h
+
+$(dbus_login1_built_sources) : Makefile.am org.freedesktop.login1.xml
+	$(AM_V_GEN)gdbus-codegen							\
+		--interface-prefix org.freedesktop.login1				\
+		--c-namespace Login1							\
+		--generate-c-code meta-dbus-login1					\
+		$(srcdir)/org.freedesktop.login1.xml
+
 wayland/%-protocol.c : $(top_builddir)/protocol/%.xml
 	mkdir -p wayland
 	$(AM_V_GEN)$(WAYLAND_SCANNER) code < $< > $@

src/compositor/compositor.c

@@ -76,6 +76,7 @@
 #include "window-private.h" /* to check window->hidden */
 #include "display-private.h" /* for meta_display_lookup_x_window() */
 #include "util-private.h"
+#include "frame.h"
 #include "meta-wayland-private.h"
 #include "meta-wayland-pointer.h"
 #include "meta-wayland-keyboard.h"
@@ -140,6 +141,19 @@ meta_compositor_destroy (MetaCompositor *compositor)
   clutter_threads_remove_repaint_func (compositor->repaint_func_id);
 }
 
+static void
+add_win (MetaWindow *window)
+{
+  MetaScreen		*screen = meta_window_get_screen (window);
+  MetaCompScreen        *info = meta_screen_get_compositor_data (screen);
+
+  g_return_if_fail (info != NULL);
+
+  meta_window_actor_new (window);
+
+  sync_actor_stacking (info);
+}
+
 static void
 process_damage (MetaCompositor     *compositor,
                 XDamageNotifyEvent *event,
@@ -316,39 +330,36 @@ meta_focus_stage_window (MetaScreen *screen,
   if (!stage)
     return;
 
-  if (!meta_is_wayland_compositor ())
-    {
-      window = clutter_x11_get_stage_window (stage);
+  window = clutter_x11_get_stage_window (stage);
 
-      if (window == None)
-        return;
+  if (window == None)
+    return;
 
-      meta_display_set_input_focus_xwindow (screen->display,
-                                            screen,
-                                            META_FOCUS_STAGE,
-                                            window,
-                                            timestamp);
-    }
-  else
-    {
-      meta_display_set_input_focus_xwindow (screen->display,
-                                            screen,
-                                            META_FOCUS_STAGE,
-                                            None,
-                                            timestamp);
-    }
+  meta_display_set_input_focus_xwindow (screen->display,
+                                        screen,
+                                        window,
+                                        timestamp);
 }
 
 gboolean
 meta_stage_is_focused (MetaScreen *screen)
 {
   ClutterStage *stage;
+  Window window;
+
+  if (meta_is_wayland_compositor ())
+    return TRUE;
 
   stage = CLUTTER_STAGE (meta_get_stage_for_screen (screen));
   if (!stage)
     return FALSE;
 
-  return (screen->display->focus_type == META_FOCUS_STAGE);
+  window = clutter_x11_get_stage_window (stage);
+
+  if (window == None)
+    return FALSE;
+
+  return (screen->display->focus_xwindow == window);
 }
 
 static gboolean
@@ -425,45 +436,6 @@ 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,
@@ -482,7 +454,7 @@ meta_begin_modal_for_plugin (MetaScreen       *screen,
     return FALSE;
 
   if (meta_is_wayland_compositor ())
-    ok = begin_modal_wayland (screen, plugin, options, timestamp);
+    ok = TRUE;
   else
     ok = begin_modal_x11 (screen, plugin, options, timestamp);
   if (!ok)
@@ -510,15 +482,7 @@ meta_end_modal_for_plugin (MetaScreen     *screen,
 
   g_return_if_fail (compositor->modal_plugin == plugin);
 
-  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
+  if (!meta_is_wayland_compositor ())
     {
       XIUngrabDevice (xdpy, META_VIRTUAL_CORE_POINTER_ID, timestamp);
       XIUngrabDevice (xdpy, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);
@@ -822,20 +786,13 @@ meta_compositor_add_window (MetaCompositor    *compositor,
 {
   MetaScreen *screen = meta_window_get_screen (window);
   MetaDisplay *display = meta_screen_get_display (screen);
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-
-  g_return_if_fail (info != NULL);
-
-  /* Window was already added previously, probably coming
-   * back from hiding */
-  if (window->compositor_private != NULL)
-    return;
 
+  DEBUG_TRACE ("meta_compositor_add_window\n");
   meta_error_trap_push (display);
-  meta_window_actor_new (window);
-  meta_error_trap_pop (display);
 
-  sync_actor_stacking (info);
+  add_win (window);
+
+  meta_error_trap_pop (display);
 }
 
 void
@@ -937,6 +894,66 @@ meta_compositor_window_opacity_changed (MetaCompositor *compositor,
   meta_window_actor_update_opacity (window_actor);
 }
 
+void
+meta_compositor_window_surface_changed (MetaCompositor *compositor,
+                                        MetaWindow     *window)
+{
+  MetaWindowActor *window_actor;
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (!window_actor)
+    return;
+
+  meta_window_actor_update_surface (window_actor);
+}
+
+static gboolean
+grab_op_is_clicking (MetaGrabOp grab_op)
+{
+  switch (grab_op)
+    {
+    case META_GRAB_OP_CLICKING_MINIMIZE:
+    case META_GRAB_OP_CLICKING_MAXIMIZE:
+    case META_GRAB_OP_CLICKING_UNMAXIMIZE:
+    case META_GRAB_OP_CLICKING_DELETE:
+    case META_GRAB_OP_CLICKING_MENU:
+    case META_GRAB_OP_CLICKING_SHADE:
+    case META_GRAB_OP_CLICKING_UNSHADE:
+    case META_GRAB_OP_CLICKING_ABOVE:
+    case META_GRAB_OP_CLICKING_UNABOVE:
+    case META_GRAB_OP_CLICKING_STICK:
+    case META_GRAB_OP_CLICKING_UNSTICK:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+static gboolean
+event_is_passive_button_grab (MetaDisplay   *display,
+                              XIDeviceEvent *device_event)
+{
+  /* see display.c for which events are passive button
+     grabs (meta_display_grab_window_buttons() and
+     meta_display_handle_events())
+     we need to filter them here because normally they
+     would be sent to gtk+ (they are on gtk+ frame xwindow),
+     but we want to redirect them to clutter
+  */
+
+  if (device_event->evtype != XI_ButtonPress)
+    return FALSE;
+
+  if (display->window_grab_modifiers == 0)
+    return FALSE;
+
+  if ((device_event->mods.effective & display->window_grab_modifiers) !=
+      display->window_grab_modifiers)
+    return FALSE;
+
+  return device_event->detail < 4;
+}
+
 /* Clutter makes the assumption that there is only one X window
  * per stage, which is a valid assumption to make for a generic
  * application toolkit. As such, it will ignore any events sent
@@ -948,6 +965,7 @@ meta_compositor_window_opacity_changed (MetaCompositor *compositor,
  */
 static void
 maybe_spoof_event_as_stage_event (MetaCompScreen *info,
+                                  MetaWindow     *window,
                                   XEvent         *event)
 {
   MetaDisplay *display = meta_screen_get_display (info->screen);
@@ -956,24 +974,30 @@ maybe_spoof_event_as_stage_event (MetaCompScreen *info,
       event->xcookie.extension == display->xinput_opcode)
     {
       XIEvent *input_event = (XIEvent *) event->xcookie.data;
+      XIDeviceEvent *device_event = ((XIDeviceEvent *) input_event);
 
       switch (input_event->evtype)
         {
         case XI_Motion:
         case XI_ButtonPress:
         case XI_ButtonRelease:
+          /* If this is a window frame, and we think GTK+ needs to handle the event,
+             let GTK+ handle it without mangling */
+          if (window && window->frame && device_event->event == window->frame->xwindow &&
+              (grab_op_is_clicking (display->grab_op) ||
+               (display->grab_op == META_GRAB_OP_NONE && !event_is_passive_button_grab (display, device_event))))
+            break;
+
         case XI_KeyPress:
         case XI_KeyRelease:
-          {
-            XIDeviceEvent *device_event = ((XIDeviceEvent *) input_event);
-
             /* If this is a GTK+ widget, like a window menu, let GTK+ handle
              * it as-is without mangling. */
             if (meta_ui_window_is_widget (info->screen->ui, device_event->event))
               break;
 
             device_event->event = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
-          }
+            device_event->event_x = device_event->root_x;
+            device_event->event_y = device_event->root_y;
           break;
         default:
           break;
@@ -993,6 +1017,12 @@ meta_compositor_process_event (MetaCompositor *compositor,
                                XEvent         *event,
                                MetaWindow     *window)
 {
+  MetaDisplay *display = compositor->display;
+  MetaScreen *screen = display->screens->data;
+  MetaCompScreen *info;
+
+  info = meta_screen_get_compositor_data (screen);
+
   if (compositor->modal_plugin && is_grabbed_event (compositor->display, event))
     {
       _meta_plugin_xevent_filter (compositor->modal_plugin, event);
@@ -1002,43 +1032,13 @@ meta_compositor_process_event (MetaCompositor *compositor,
       return TRUE;
     }
 
-  if (window)
+  if (!meta_is_wayland_compositor ())
+    maybe_spoof_event_as_stage_event (info, window, event);
+
+  if (meta_plugin_manager_xevent_filter (info->plugin_mgr, event))
     {
-      MetaCompScreen *info;
-      MetaScreen     *screen;
-
-      screen = meta_window_get_screen (window);
-      info = meta_screen_get_compositor_data (screen);
-
-      if (meta_plugin_manager_xevent_filter (info->plugin_mgr, event))
-	{
-	  DEBUG_TRACE ("meta_compositor_process_event (filtered,window==NULL)\n");
-	  return TRUE;
-	}
-    }
-  else
-    {
-      GSList *l;
-
-      l = meta_display_get_screens (compositor->display);
-
-      while (l)
-	{
-	  MetaScreen     *screen = l->data;
-	  MetaCompScreen *info;
-
-	  info = meta_screen_get_compositor_data (screen);
-
-          maybe_spoof_event_as_stage_event (info, event);
-
-	  if (meta_plugin_manager_xevent_filter (info->plugin_mgr, event))
-	    {
-	      DEBUG_TRACE ("meta_compositor_process_event (filtered,window==NULL)\n");
-	      return TRUE;
-	    }
-
-	  l = l->next;
-	}
+      DEBUG_TRACE ("meta_compositor_process_event (filtered,window==NULL)\n");
+      return TRUE;
     }
 
   if (!meta_is_wayland_compositor () &&
@@ -1695,3 +1695,43 @@ meta_compositor_monotonic_time_to_server_time (MetaDisplay *display,
   else
     return monotonic_time + compositor->server_time_offset;
 }
+
+void
+meta_compositor_show_tile_preview (MetaCompositor *compositor,
+                                   MetaScreen     *screen,
+                                   MetaWindow     *window,
+                                   MetaRectangle  *tile_rect,
+                                   int             tile_monitor_number)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (!info->plugin_mgr)
+    return;
+
+  meta_plugin_manager_show_tile_preview (info->plugin_mgr,
+                                         window, tile_rect, tile_monitor_number);
+}
+
+void
+meta_compositor_hide_tile_preview (MetaCompositor *compositor,
+                                   MetaScreen     *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (!info->plugin_mgr)
+    return;
+
+  meta_plugin_manager_hide_tile_preview (info->plugin_mgr);
+}
+
+void
+meta_compositor_show_window_menu (MetaCompositor *compositor,
+                                  MetaWindow     *window)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (window->screen);
+
+  if (!info->plugin_mgr)
+    return;
+
+  meta_plugin_manager_show_window_menu (info->plugin_mgr, window);
+}

src/compositor/meta-plugin-manager.c

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

src/compositor/meta-plugin-manager.h

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

src/compositor/meta-plugin.c

@@ -30,6 +30,7 @@
 #include "meta-plugin-manager.h"
 #include <meta/screen.h>
 #include <meta/display.h>
+#include <meta/util.h>
 
 #include <string.h>
 #include <X11/Xlib.h>

src/compositor/meta-shaped-texture.c

@@ -33,6 +33,7 @@
 #include "meta-texture-tower.h"
 
 #include "meta-shaped-texture-private.h"
+#include "meta-window-actor-private.h"
 
 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
@@ -42,8 +43,6 @@
 static void meta_shaped_texture_dispose  (GObject    *object);
 
 static void meta_shaped_texture_paint (ClutterActor       *actor);
-static void meta_shaped_texture_pick  (ClutterActor       *actor,
-				       const ClutterColor *color);
 
 static void meta_shaped_texture_get_preferred_width (ClutterActor *self,
                                                      gfloat        for_height,
@@ -73,8 +72,6 @@ struct _MetaShapedTexturePrivate
   CoglTexture *texture;
   CoglTexture *mask_texture;
 
-  cairo_region_t *input_shape_region;
-
   /* The region containing only fully opaque pixels */
   cairo_region_t *opaque_region;
 
@@ -98,7 +95,6 @@ meta_shaped_texture_class_init (MetaShapedTextureClass *klass)
   actor_class->get_preferred_width = meta_shaped_texture_get_preferred_width;
   actor_class->get_preferred_height = meta_shaped_texture_get_preferred_height;
   actor_class->paint = meta_shaped_texture_paint;
-  actor_class->pick = meta_shaped_texture_pick;
   actor_class->get_paint_volume = meta_shaped_texture_get_paint_volume;
 
   g_type_class_add_private (klass, sizeof (MetaShapedTexturePrivate));
@@ -463,71 +459,6 @@ meta_shaped_texture_paint (ClutterActor *actor)
     cairo_region_destroy (blended_region);
 }
 
-static void
-meta_shaped_texture_pick (ClutterActor       *actor,
-			  const ClutterColor *color)
-{
-  MetaShapedTexture *stex = (MetaShapedTexture *) actor;
-  MetaShapedTexturePrivate *priv = stex->priv;
-
-  if (!clutter_actor_should_pick_paint (actor) ||
-      (priv->clip_region && cairo_region_is_empty (priv->clip_region)))
-    return;
-
-  /* If there is no region then use the regular pick */
-  if (priv->input_shape_region == NULL)
-    CLUTTER_ACTOR_CLASS (meta_shaped_texture_parent_class)->pick (actor, color);
-  else
-    {
-      int n_rects;
-      float *rectangles;
-      int i;
-      CoglPipeline *pipeline;
-      CoglContext *ctx;
-      CoglFramebuffer *fb;
-      CoglColor cogl_color;
-
-      /* Note: We don't bother trying to intersect the pick and clip regions
-       * since needing to copy the region, do the intersection, and probably
-       * increase the number of rectangles seems more likely to have a negative
-       * effect.
-       *
-       * NB: Most of the time when just using rectangles for picking then
-       * picking shouldn't involve any rendering, and minimizing the number of
-       * rectangles has more benefit than reducing the area of the pick
-       * region.
-       */
-
-      n_rects = cairo_region_num_rectangles (priv->input_shape_region);
-      rectangles = g_alloca (sizeof (float) * 4 * n_rects);
-
-      for (i = 0; i < n_rects; i++)
-        {
-          cairo_rectangle_int_t rect;
-          int pos = i * 4;
-
-          cairo_region_get_rectangle (priv->input_shape_region, i, &rect);
-
-          rectangles[pos] = rect.x;
-          rectangles[pos + 1] = rect.y;
-          rectangles[pos + 2] = rect.x + rect.width;
-          rectangles[pos + 3] = rect.y + rect.height;
-        }
-
-      ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      fb = cogl_get_draw_framebuffer ();
-
-      cogl_color_init_from_4ub (&cogl_color, color->red, color->green, color->blue, color->alpha);
-
-      pipeline = cogl_pipeline_new (ctx);
-      cogl_pipeline_set_color (pipeline, &cogl_color);
-
-      cogl_framebuffer_draw_rectangles (fb, pipeline,
-                                        rectangles, n_rects);
-      cogl_object_unref (pipeline);
-    }
-}
-
 static void
 meta_shaped_texture_get_preferred_width (ClutterActor *self,
                                          gfloat        for_height,
@@ -646,8 +577,18 @@ static cairo_region_t *
 effective_unobscured_region (MetaShapedTexture *self)
 {
   MetaShapedTexturePrivate *priv = self->priv;
+  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR (self));
 
-  return clutter_actor_has_mapped_clones (CLUTTER_ACTOR (self)) ? NULL : priv->unobscured_region;
+  if (clutter_actor_has_mapped_clones (CLUTTER_ACTOR (self)))
+    return NULL;
+
+  while (parent && !META_IS_WINDOW_ACTOR (parent))
+    parent = clutter_actor_get_parent (parent);
+
+  if (parent && clutter_actor_has_mapped_clones (parent))
+    return NULL;
+
+  return priv->unobscured_region;
 }
 
 gboolean
@@ -764,41 +705,6 @@ meta_shaped_texture_get_texture (MetaShapedTexture *stex)
   return COGL_TEXTURE (stex->priv->texture);
 }
 
-/**
- * meta_shaped_texture_set_input_shape_region:
- * @stex: a #MetaShapedTexture
- * @shape_region: the region of the texture that should respond to
- *    input.
- *
- * Determines what region of the texture should accept input. For
- * X based windows this is defined by the ShapeInput region of the
- * window.
- */
-void
-meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
-                                            cairo_region_t    *shape_region)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  if (priv->input_shape_region != NULL)
-    {
-      cairo_region_destroy (priv->input_shape_region);
-      priv->input_shape_region = NULL;
-    }
-
-  if (shape_region != NULL)
-    {
-      cairo_region_reference (shape_region);
-      priv->input_shape_region = shape_region;
-    }
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-}
-
 /**
  * meta_shaped_texture_set_opaque_region:
  * @stex: a #MetaShapedTexture

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

@@ -0,0 +1,164 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by:
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#include "config.h"
+
+#include "meta-surface-actor-wayland.h"
+
+#include <cogl/cogl-wayland-server.h>
+#include "meta-shaped-texture-private.h"
+#include "meta-wayland-private.h"
+
+struct _MetaSurfaceActorWaylandPrivate
+{
+  MetaWaylandSurface *surface;
+  MetaWaylandBuffer *buffer;
+};
+typedef struct _MetaSurfaceActorWaylandPrivate MetaSurfaceActorWaylandPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (MetaSurfaceActorWayland, meta_surface_actor_wayland, META_TYPE_SURFACE_ACTOR)
+
+static void
+meta_surface_actor_wayland_process_damage (MetaSurfaceActor *actor,
+                                           int x, int y, int width, int height)
+{
+  MetaSurfaceActorWayland *self = META_SURFACE_ACTOR_WAYLAND (actor);
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+
+  struct wl_resource *resource = priv->buffer->resource;
+  struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
+
+  if (shm_buffer)
+    {
+      CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
+      cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
+    }
+
+  meta_surface_actor_update_area (META_SURFACE_ACTOR (self), x, y, width, height);
+}
+
+static void
+meta_surface_actor_wayland_pre_paint (MetaSurfaceActor *actor)
+{
+}
+
+static gboolean
+meta_surface_actor_wayland_is_argb32 (MetaSurfaceActor *actor)
+{
+  /* XXX -- look at the SHM buffer format. */
+  return TRUE;
+}
+
+static gboolean
+meta_surface_actor_wayland_is_visible (MetaSurfaceActor *actor)
+{
+  /* TODO: ensure that the buffer isn't NULL, implement
+   * wayland mapping semantics */
+  return TRUE;
+}
+
+static gboolean
+meta_surface_actor_wayland_should_unredirect (MetaSurfaceActor *actor)
+{
+  return FALSE;
+}
+
+static void
+meta_surface_actor_wayland_set_unredirected (MetaSurfaceActor *actor,
+                                             gboolean          unredirected)
+{
+  /* Do nothing. In the future, we'll use KMS to set this
+   * up as a hardware overlay or something. */
+}
+
+static gboolean
+meta_surface_actor_wayland_is_unredirected (MetaSurfaceActor *actor)
+{
+  return FALSE;
+}
+
+static MetaWindow *
+meta_surface_actor_wayland_get_window (MetaSurfaceActor *actor)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (META_SURFACE_ACTOR_WAYLAND (actor));
+
+  return priv->surface->window;
+}
+
+static void
+meta_surface_actor_wayland_class_init (MetaSurfaceActorWaylandClass *klass)
+{
+  MetaSurfaceActorClass *surface_actor_class = META_SURFACE_ACTOR_CLASS (klass);
+
+  surface_actor_class->process_damage = meta_surface_actor_wayland_process_damage;
+  surface_actor_class->pre_paint = meta_surface_actor_wayland_pre_paint;
+  surface_actor_class->is_argb32 = meta_surface_actor_wayland_is_argb32;
+  surface_actor_class->is_visible = meta_surface_actor_wayland_is_visible;
+
+  surface_actor_class->should_unredirect = meta_surface_actor_wayland_should_unredirect;
+  surface_actor_class->set_unredirected = meta_surface_actor_wayland_set_unredirected;
+  surface_actor_class->is_unredirected = meta_surface_actor_wayland_is_unredirected;
+
+  surface_actor_class->get_window = meta_surface_actor_wayland_get_window;
+}
+
+static void
+meta_surface_actor_wayland_init (MetaSurfaceActorWayland *self)
+{
+}
+
+MetaSurfaceActor *
+meta_surface_actor_wayland_new (MetaWaylandSurface *surface)
+{
+  MetaSurfaceActorWayland *self = g_object_new (META_TYPE_SURFACE_ACTOR_WAYLAND, NULL);
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+
+  g_assert (meta_is_wayland_compositor ());
+
+  priv->surface = surface;
+
+  return META_SURFACE_ACTOR (self);
+}
+
+void
+meta_surface_actor_wayland_set_buffer (MetaSurfaceActorWayland *self,
+                                       MetaWaylandBuffer       *buffer)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+  MetaShapedTexture *stex = meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
+
+  priv->buffer = buffer;
+
+  if (buffer)
+    meta_shaped_texture_set_texture (stex, buffer->texture);
+  else
+    meta_shaped_texture_set_texture (stex, NULL);
+}
+
+MetaWaylandSurface *
+meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self)
+{
+  MetaSurfaceActorWaylandPrivate *priv = meta_surface_actor_wayland_get_instance_private (self);
+  return priv->surface;
+}

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

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

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

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

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

@@ -0,0 +1,69 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2013 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by:
+ *     Owen Taylor <otaylor@redhat.com>
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef __META_SURFACE_ACTOR_X11_H__
+#define __META_SURFACE_ACTOR_X11_H__
+
+#include <glib-object.h>
+
+#include "meta-surface-actor.h"
+
+#include <X11/extensions/Xdamage.h>
+
+#include <meta/display.h>
+#include <meta/window.h>
+
+G_BEGIN_DECLS
+
+#define META_TYPE_SURFACE_ACTOR_X11            (meta_surface_actor_x11_get_type ())
+#define META_SURFACE_ACTOR_X11(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11))
+#define META_SURFACE_ACTOR_X11_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11Class))
+#define META_IS_SURFACE_ACTOR_X11(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SURFACE_ACTOR_X11))
+#define META_IS_SURFACE_ACTOR_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SURFACE_ACTOR_X11))
+#define META_SURFACE_ACTOR_X11_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SURFACE_ACTOR_X11, MetaSurfaceActorX11Class))
+
+typedef struct _MetaSurfaceActorX11      MetaSurfaceActorX11;
+typedef struct _MetaSurfaceActorX11Class MetaSurfaceActorX11Class;
+
+struct _MetaSurfaceActorX11
+{
+  MetaSurfaceActor parent;
+};
+
+struct _MetaSurfaceActorX11Class
+{
+  MetaSurfaceActorClass parent_class;
+};
+
+GType meta_surface_actor_x11_get_type (void);
+
+MetaSurfaceActor * meta_surface_actor_x11_new (MetaWindow *window);
+
+void meta_surface_actor_x11_set_size (MetaSurfaceActorX11 *self,
+                                      int width, int height);
+
+G_END_DECLS
+
+#endif /* __META_SURFACE_ACTOR_X11_H__ */

src/compositor/meta-surface-actor.c

@@ -10,26 +10,37 @@
  */
 
 #include <config.h>
-#include <clutter/clutter.h>
-#include <cogl/cogl-wayland-server.h>
-#include <cogl/cogl-texture-pixmap-x11.h>
-#include <meta/meta-shaped-texture.h>
-#include "meta-surface-actor.h"
-#include "meta-wayland-private.h"
-#include "meta-cullable.h"
 
+#include "meta-surface-actor.h"
+
+#include <clutter/clutter.h>
+#include <meta/meta-shaped-texture.h>
+#include "meta-cullable.h"
 #include "meta-shaped-texture-private.h"
 
 struct _MetaSurfaceActorPrivate
 {
   MetaShapedTexture *texture;
-  MetaWaylandBuffer *buffer;
+
+  cairo_region_t *input_region;
+
+  /* Freeze/thaw accounting */
+  guint needs_damage_all : 1;
+  guint frozen : 1;
 };
 
 static void cullable_iface_init (MetaCullableInterface *iface);
 
-G_DEFINE_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaSurfaceActor, meta_surface_actor, CLUTTER_TYPE_ACTOR,
+                                  G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+
+enum {
+  REPAINT_SCHEDULED,
+
+  LAST_SIGNAL,
+};
+
+static guint signals[LAST_SIGNAL];
 
 gboolean
 meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
@@ -39,9 +50,84 @@ meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
   return meta_shaped_texture_get_unobscured_bounds (priv->texture, unobscured_bounds);
 }
 
+static void
+meta_surface_actor_pick (ClutterActor       *actor,
+                         const ClutterColor *color)
+{
+  MetaSurfaceActor *self = META_SURFACE_ACTOR (actor);
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  if (!clutter_actor_should_pick_paint (actor))
+    return;
+
+  /* If there is no region then use the regular pick */
+  if (priv->input_region == NULL)
+    CLUTTER_ACTOR_CLASS (meta_surface_actor_parent_class)->pick (actor, color);
+  else
+    {
+      int n_rects;
+      float *rectangles;
+      int i;
+      CoglPipeline *pipeline;
+      CoglContext *ctx;
+      CoglFramebuffer *fb;
+      CoglColor cogl_color;
+
+      n_rects = cairo_region_num_rectangles (priv->input_region);
+      rectangles = g_alloca (sizeof (float) * 4 * n_rects);
+
+      for (i = 0; i < n_rects; i++)
+        {
+          cairo_rectangle_int_t rect;
+          int pos = i * 4;
+
+          cairo_region_get_rectangle (priv->input_region, i, &rect);
+
+          rectangles[pos + 0] = rect.x;
+          rectangles[pos + 1] = rect.y;
+          rectangles[pos + 2] = rect.x + rect.width;
+          rectangles[pos + 3] = rect.y + rect.height;
+        }
+
+      ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
+      fb = cogl_get_draw_framebuffer ();
+
+      cogl_color_init_from_4ub (&cogl_color, color->red, color->green, color->blue, color->alpha);
+
+      pipeline = cogl_pipeline_new (ctx);
+      cogl_pipeline_set_color (pipeline, &cogl_color);
+      cogl_framebuffer_draw_rectangles (fb, pipeline, rectangles, n_rects);
+      cogl_object_unref (pipeline);
+    }
+}
+
+static void
+meta_surface_actor_dispose (GObject *object)
+{
+  MetaSurfaceActor *self = META_SURFACE_ACTOR (object);
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->input_region, cairo_region_destroy);
+
+  G_OBJECT_CLASS (meta_surface_actor_parent_class)->dispose (object);
+}
+
 static void
 meta_surface_actor_class_init (MetaSurfaceActorClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+
+  object_class->dispose = meta_surface_actor_dispose;
+  actor_class->pick = meta_surface_actor_pick;
+
+  signals[REPAINT_SCHEDULED] = g_signal_new ("repaint-scheduled",
+                                             G_TYPE_FROM_CLASS (object_class),
+                                             G_SIGNAL_RUN_LAST,
+                                             0,
+                                             NULL, NULL, NULL,
+                                             G_TYPE_NONE, 0);
+
   g_type_class_add_private (klass, sizeof (MetaSurfaceActorPrivate));
 }
 
@@ -92,51 +178,14 @@ meta_surface_actor_get_texture (MetaSurfaceActor *self)
   return self->priv->texture;
 }
 
-static void
-update_area (MetaSurfaceActor *self,
-             int x, int y, int width, int height)
+void
+meta_surface_actor_update_area (MetaSurfaceActor *self,
+                                int x, int y, int width, int height)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
 
-  if (meta_is_wayland_compositor ())
-    {
-      struct wl_resource *resource = priv->buffer->resource;
-      struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get (resource);
-
-      if (shm_buffer)
-        {
-          CoglTexture2D *texture = COGL_TEXTURE_2D (priv->buffer->texture);
-          cogl_wayland_texture_set_region_from_shm_buffer (texture, x, y, width, height, shm_buffer, x, y, 0, NULL);
-        }
-    }
-  else
-    {
-      CoglTexturePixmapX11 *texture = COGL_TEXTURE_PIXMAP_X11 (meta_shaped_texture_get_texture (priv->texture));
-      cogl_texture_pixmap_x11_update_area (texture, x, y, width, height);
-    }
-}
-
-gboolean
-meta_surface_actor_damage_all (MetaSurfaceActor *self)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  CoglTexture *texture = meta_shaped_texture_get_texture (priv->texture);
-
-  update_area (self, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
-  return meta_shaped_texture_update_area (priv->texture, 0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture));
-}
-
-gboolean
-meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                int               x,
-                                int               y,
-                                int               width,
-                                int               height)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-
-  update_area (self, x, y, width, height);
-  return meta_shaped_texture_update_area (priv->texture, x, y, width, height);
+  if (meta_shaped_texture_update_area (priv->texture, x, y, width, height))
+    g_signal_emit (self, signals[REPAINT_SCHEDULED], 0);
 }
 
 gboolean
@@ -146,33 +195,19 @@ meta_surface_actor_is_obscured (MetaSurfaceActor *self)
   return meta_shaped_texture_is_obscured (priv->texture);
 }
 
-void
-meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor *self,
-                                          MetaWaylandBuffer *buffer)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  priv->buffer = buffer;
-
-  if (buffer)
-    meta_shaped_texture_set_texture (priv->texture, buffer->texture);
-  else
-    meta_shaped_texture_set_texture (priv->texture, NULL);
-}
-
-void
-meta_surface_actor_set_texture (MetaSurfaceActor *self,
-                                CoglTexture      *texture)
-{
-  MetaSurfaceActorPrivate *priv = self->priv;
-  meta_shaped_texture_set_texture (priv->texture, texture);
-}
-
 void
 meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                      cairo_region_t   *region)
 {
   MetaSurfaceActorPrivate *priv = self->priv;
-  meta_shaped_texture_set_input_shape_region (priv->texture, region);
+
+  if (priv->input_region)
+    cairo_region_destroy (priv->input_region);
+
+  if (region)
+    priv->input_region = cairo_region_reference (region);
+  else
+    priv->input_region = NULL;
 }
 
 void
@@ -183,8 +218,102 @@ meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
   meta_shaped_texture_set_opaque_region (priv->texture, region);
 }
 
-MetaSurfaceActor *
-meta_surface_actor_new (void)
+static gboolean
+is_frozen (MetaSurfaceActor *self)
 {
-  return g_object_new (META_TYPE_SURFACE_ACTOR, NULL);
+  MetaSurfaceActorPrivate *priv = self->priv;
+  return priv->frozen;
+}
+
+void
+meta_surface_actor_process_damage (MetaSurfaceActor *self,
+                                   int x, int y, int width, int height)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  if (is_frozen (self))
+    {
+      /* The window is frozen due to an effect in progress: we ignore damage
+       * here on the off chance that this will stop the corresponding
+       * texture_from_pixmap from being update.
+       *
+       * needs_damage_all tracks that some unknown damage happened while the
+       * window was frozen so that when the window becomes unfrozen we can
+       * issue a full window update to cover any lost damage.
+       *
+       * It should be noted that this is an unreliable mechanism since it's
+       * quite likely that drivers will aim to provide a zero-copy
+       * implementation of the texture_from_pixmap extension and in those cases
+       * any drawing done to the window is always immediately reflected in the
+       * texture regardless of damage event handling.
+       */
+      priv->needs_damage_all = TRUE;
+      return;
+    }
+
+  META_SURFACE_ACTOR_GET_CLASS (self)->process_damage (self, x, y, width, height);
+}
+
+void
+meta_surface_actor_pre_paint (MetaSurfaceActor *self)
+{
+  META_SURFACE_ACTOR_GET_CLASS (self)->pre_paint (self);
+}
+
+gboolean
+meta_surface_actor_is_argb32 (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_argb32 (self);
+}
+
+gboolean
+meta_surface_actor_is_visible (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_visible (self);
+}
+
+void
+meta_surface_actor_set_frozen (MetaSurfaceActor *self,
+                               gboolean          frozen)
+{
+  MetaSurfaceActorPrivate *priv = self->priv;
+
+  priv->frozen = frozen;
+
+  if (!frozen && priv->needs_damage_all)
+    {
+      /* Since we ignore damage events while a window is frozen for certain effects
+       * we may need to issue an update_area() covering the whole pixmap if we
+       * don't know what real damage has happened. */
+
+      meta_surface_actor_process_damage (self, 0, 0,
+                                         clutter_actor_get_width (CLUTTER_ACTOR (priv->texture)),
+                                         clutter_actor_get_height (CLUTTER_ACTOR (priv->texture)));
+      priv->needs_damage_all = FALSE;
+    }
+}
+
+gboolean
+meta_surface_actor_should_unredirect (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->should_unredirect (self);
+}
+
+void
+meta_surface_actor_set_unredirected (MetaSurfaceActor *self,
+                                     gboolean          unredirected)
+{
+  META_SURFACE_ACTOR_GET_CLASS (self)->set_unredirected (self, unredirected);
+}
+
+gboolean
+meta_surface_actor_is_unredirected (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->is_unredirected (self);
+}
+
+MetaWindow *
+meta_surface_actor_get_window (MetaSurfaceActor *self)
+{
+  return META_SURFACE_ACTOR_GET_CLASS (self)->get_window (self);
 }

src/compositor/meta-surface-actor.h

@@ -6,7 +6,7 @@
 #include <config.h>
 
 #include <meta/meta-shaped-texture.h>
-#include "meta-wayland-types.h"
+#include <meta/window.h>
 
 G_BEGIN_DECLS
 
@@ -25,6 +25,19 @@ struct _MetaSurfaceActorClass
 {
   /*< private >*/
   ClutterActorClass parent_class;
+
+  void     (* process_damage)    (MetaSurfaceActor *actor,
+                                  int x, int y, int width, int height);
+  void     (* pre_paint)         (MetaSurfaceActor *actor);
+  gboolean (* is_argb32)         (MetaSurfaceActor *actor);
+  gboolean (* is_visible)        (MetaSurfaceActor *actor);
+
+  gboolean (* should_unredirect) (MetaSurfaceActor *actor);
+  void     (* set_unredirected)  (MetaSurfaceActor *actor,
+                                  gboolean          unredirected);
+  gboolean (* is_unredirected)   (MetaSurfaceActor *actor);
+
+  MetaWindow *(* get_window)      (MetaSurfaceActor *actor);
 };
 
 struct _MetaSurfaceActor
@@ -36,33 +49,38 @@ struct _MetaSurfaceActor
 
 GType meta_surface_actor_get_type (void);
 
-MetaSurfaceActor *meta_surface_actor_new (void);
-
 cairo_surface_t *meta_surface_actor_get_image (MetaSurfaceActor      *self,
                                                cairo_rectangle_int_t *clip);
 
 MetaShapedTexture *meta_surface_actor_get_texture (MetaSurfaceActor *self);
-
-gboolean meta_surface_actor_damage_all  (MetaSurfaceActor *self);
-gboolean meta_surface_actor_damage_area (MetaSurfaceActor *self,
-                                         int               x,
-                                         int               y,
-                                         int               width,
-                                         int               height);
+MetaWindow        *meta_surface_actor_get_window  (MetaSurfaceActor *self);
 
 gboolean meta_surface_actor_is_obscured (MetaSurfaceActor *self);
 gboolean meta_surface_actor_get_unobscured_bounds (MetaSurfaceActor      *self,
                                                    cairo_rectangle_int_t *unobscured_bounds);
 
-void meta_surface_actor_set_texture (MetaSurfaceActor *self,
-                                     CoglTexture      *texture);
-void meta_surface_actor_attach_wayland_buffer (MetaSurfaceActor  *self,
-                                               MetaWaylandBuffer *buffer);
 void meta_surface_actor_set_input_region (MetaSurfaceActor *self,
                                           cairo_region_t   *region);
 void meta_surface_actor_set_opaque_region (MetaSurfaceActor *self,
                                            cairo_region_t   *region);
 
+void meta_surface_actor_update_area (MetaSurfaceActor *actor,
+                                     int x, int y, int width, int height);
+
+void meta_surface_actor_process_damage (MetaSurfaceActor *actor,
+                                        int x, int y, int width, int height);
+void meta_surface_actor_pre_paint (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_argb32 (MetaSurfaceActor *actor);
+gboolean meta_surface_actor_is_visible (MetaSurfaceActor *actor);
+
+void meta_surface_actor_set_frozen (MetaSurfaceActor *actor,
+                                    gboolean          frozen);
+
+gboolean meta_surface_actor_should_unredirect (MetaSurfaceActor *actor);
+void meta_surface_actor_set_unredirected (MetaSurfaceActor *actor,
+                                          gboolean          unredirected);
+gboolean meta_surface_actor_is_unredirected (MetaSurfaceActor *actor);
+
 G_END_DECLS
 
 #endif /* META_SURFACE_ACTOR_PRIVATE_H */

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

@@ -5,9 +5,6 @@
 
 #include <config.h>
 
-#include <wayland-server.h>
-#include <meta-wayland-private.h>
-
 #include <X11/extensions/Xdamage.h>
 #include <meta/compositor-mutter.h>
 #include "meta-surface-actor.h"
@@ -63,5 +60,6 @@ void meta_window_actor_effect_completed (MetaWindowActor *actor,
                                          gulong           event);
 
 MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self);
+void meta_window_actor_update_surface (MetaWindowActor *self);
 
 #endif /* META_WINDOW_ACTOR_PRIVATE_H */

src/compositor/meta-window-group.c

@@ -164,19 +164,6 @@ meta_window_group_paint (ClutterActor *actor)
   paint_y_offset = paint_y_origin - actor_y_origin;
   cairo_region_translate (clip_region, -paint_x_offset, -paint_y_offset);
 
-  if (!meta_is_wayland_compositor ())
-    {
-      MetaCompScreen *info = meta_screen_get_compositor_data (window_group->screen);
-      if (info->unredirected_window != NULL)
-        {
-          cairo_rectangle_int_t unredirected_rect;
-
-          meta_window_get_frame_rect (info->unredirected_window, (MetaRectangle *)&unredirected_rect);
-          cairo_region_subtract_rectangle (unobscured_region, &unredirected_rect);
-          cairo_region_subtract_rectangle (clip_region, &unredirected_rect);
-        }
-    }
-
   meta_cullable_cull_out (META_CULLABLE (window_group), unobscured_region, clip_region);
 
   cairo_region_destroy (unobscured_region);

src/compositor/plugins/default.c

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

src/core/constraints.c

@@ -425,8 +425,9 @@ 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 &&
+      (window->decorated || !meta_window_is_client_decorated (window)) &&
       meta_rectangle_equal (new, &monitor_info->rect) &&
       window->has_fullscreen_func &&
       !window->fullscreen)
@@ -491,12 +492,17 @@ 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);
-      meta_window_place (window, info->orig.x, info->orig.y,
+
+      orig_rect = info->orig;
+      extend_by_frame (window, &orig_rect);
+
+      meta_window_place (window, orig_rect.x, orig_rect.y,
                          &placed_rect.x, &placed_rect.y);
       did_placement = TRUE;
 
@@ -811,7 +817,7 @@ constrain_maximization (MetaWindow         *window,
                                                 active_workspace_struts);
    }
   /* Now make target_size = maximized size of client window */
-  unextend_by_frame (window, &target_size);
+  /* unextend_by_frame (window, &target_size); */
 
   /* Check min size constraints; max size constraints are ignored for maximized
    * windows, as per bug 327543.

src/core/core.c

@@ -328,8 +328,7 @@ meta_core_maximize (Display *xdisplay,
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
 
-  meta_window_maximize (window, 
-                        META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+  meta_window_maximize (window, META_MAXIMIZE_BOTH);
 }
 
 void
@@ -342,11 +341,9 @@ meta_core_toggle_maximize_vertically (Display *xdisplay,
     meta_window_raise (window);
 
   if (META_WINDOW_MAXIMIZED_VERTICALLY (window))
-    meta_window_unmaximize (window, 
-                            META_MAXIMIZE_VERTICAL);
+    meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL);
   else
-    meta_window_maximize (window,
-    			    META_MAXIMIZE_VERTICAL);
+    meta_window_maximize (window, META_MAXIMIZE_VERTICAL);
 }
 
 void
@@ -359,11 +356,9 @@ meta_core_toggle_maximize_horizontally (Display *xdisplay,
     meta_window_raise (window);
 
   if (META_WINDOW_MAXIMIZED_HORIZONTALLY (window))
-    meta_window_unmaximize (window, 
-                            META_MAXIMIZE_HORIZONTAL);
+    meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL);
   else
-    meta_window_maximize (window,
-    			    META_MAXIMIZE_HORIZONTAL);
+    meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL);
 }
 
 void
@@ -376,11 +371,9 @@ meta_core_toggle_maximize (Display *xdisplay,
     meta_window_raise (window);
 
   if (META_WINDOW_MAXIMIZED (window))
-    meta_window_unmaximize (window, 
-                            META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+    meta_window_unmaximize (window, META_MAXIMIZE_BOTH);
   else
-    meta_window_maximize (window,
-                          META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+    meta_window_maximize (window, META_MAXIMIZE_BOTH);
 }
 
 void
@@ -392,8 +385,7 @@ meta_core_unmaximize (Display *xdisplay,
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
 
-  meta_window_unmaximize (window,
-                          META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+  meta_window_unmaximize (window, META_MAXIMIZE_BOTH);
 }
 
 void
@@ -477,9 +469,6 @@ meta_core_change_workspace (Display *xdisplay,
 void
 meta_core_show_window_menu (Display *xdisplay,
                             Window   frame_xwindow,
-                            int      root_x,
-                            int      root_y,
-                            int      button,
                             guint32  timestamp)
 {
   MetaWindow *window = get_window (xdisplay, frame_xwindow);
@@ -488,121 +477,7 @@ meta_core_show_window_menu (Display *xdisplay,
     meta_window_raise (window);
   meta_window_focus (window, timestamp);
 
-  meta_window_show_menu (window, root_x, root_y, button, timestamp);
-}
-
-void
-meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
-                                int                  workspace,
-                                unsigned int        *keysym,
-                                MetaVirtualModifier *modifiers)
-{
-  const char *name;
-
-  name = NULL;
-  
-  switch (menu_op)
-    {
-    case META_MENU_OP_NONE:
-      /* No keybinding for this one */
-      break;
-    case META_MENU_OP_DELETE:
-      name = "close";
-      break;
-    case META_MENU_OP_MINIMIZE:
-      name = "minimize";
-      break;
-    case META_MENU_OP_UNMAXIMIZE:
-      name = "unmaximize";
-      break;
-    case META_MENU_OP_MAXIMIZE:
-      name = "maximize";
-      break;
-    case META_MENU_OP_UNSHADE:
-    case META_MENU_OP_SHADE:
-      name = "toggle_shaded";
-      break;
-    case META_MENU_OP_UNSTICK:
-    case META_MENU_OP_STICK:
-      name = "toggle-on-all-workspaces";
-      break;
-    case META_MENU_OP_ABOVE:
-    case META_MENU_OP_UNABOVE:
-      name = "toggle-above";
-      break;
-    case META_MENU_OP_WORKSPACES:
-      switch (workspace)
-        {
-        case 1:
-          name = "move-to-workspace-1";
-          break;
-        case 2:
-          name = "move-to-workspace-2";
-          break;
-        case 3:
-          name = "move-to-workspace-3";
-          break; 
-        case 4:
-          name = "move-to-workspace-4";
-          break; 
-        case 5:
-          name = "move-to-workspace-5";
-          break; 
-        case 6:
-          name = "move-to-workspace-6";
-          break; 
-        case 7:
-          name = "move-to-workspace-7";
-          break; 
-        case 8:
-          name = "move-to-workspace-8";
-          break; 
-        case 9:
-          name = "move-to-workspace-9";
-          break; 
-        case 10:
-          name = "move-to-workspace-10";
-          break;
-        case 11:
-          name = "move-to-workspace-11";
-          break;
-        case 12:
-          name = "move-to-workspace-12";
-          break;
-        }
-      break;
-    case META_MENU_OP_MOVE:
-      name = "begin-move";
-      break;
-    case META_MENU_OP_RESIZE:
-      name = "begin-resize";
-      break;
-    case META_MENU_OP_MOVE_LEFT:
-      name = "move-to-workspace-left";
-      break;
-    case META_MENU_OP_MOVE_RIGHT:
-      name = "move-to-workspace-right";
-      break;
-    case META_MENU_OP_MOVE_UP:
-      name = "move-to-workspace-up";
-      break;
-    case META_MENU_OP_MOVE_DOWN:
-      name = "move-to-workspace-down";
-      break;
-    case META_MENU_OP_RECOVER:
-      /* No keybinding for this one */
-      break;
-    }
-
-  if (name)
-    {
-      meta_prefs_get_window_binding (name, keysym, modifiers);
-    }
-  else
-    {
-      *keysym = 0;
-      *modifiers = 0;
-    }
+  meta_window_show_menu (window);
 }
 
 const char*

src/core/core.h

@@ -159,15 +159,8 @@ const char* meta_core_get_workspace_name_with_index (Display *xdisplay,
 
 void meta_core_show_window_menu (Display *xdisplay,
                                  Window   frame_xwindow,
-                                 int      root_x,
-                                 int      root_y,
-                                 int      button,
                                  guint32  timestamp);
 
-void meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
-                                     int                  workspace,
-                                     unsigned int        *keysym,
-                                     MetaVirtualModifier *modifiers);
 
 gboolean   meta_core_begin_grab_op (Display    *xdisplay,
                                     Window      frame_xwindow,

src/core/display-private.h

@@ -84,14 +84,6 @@ typedef enum {
   META_TILE_MAXIMIZED
 } MetaTileMode;
 
-typedef enum {
-  META_FOCUS_NONE = 0,
-  META_FOCUS_X_CLIENT = 1,
-  META_FOCUS_WAYLAND_CLIENT = 2,
-  META_FOCUS_NO_FOCUS_WINDOW = 3,
-  META_FOCUS_STAGE = 4
-} MetaFocusType;
-
 struct _MetaDisplay
 {
   GObject parent_instance;
@@ -125,7 +117,6 @@ struct _MetaDisplay
    * like the no_focus_window or the stage X window. */
   Window focus_xwindow;
   gulong focus_serial;
-  MetaFocusType focus_type;
 
   /* last timestamp passed to XSetInputFocus */
   guint32 last_focus_time;
@@ -224,7 +215,6 @@ struct _MetaDisplay
   gboolean    grab_threshold_movement_reached; /* raise_on_click == FALSE.    */
   MetaResizePopup *grab_resize_popup;
   GTimeVal    grab_last_moveresize_time;
-  guint32     grab_motion_notify_time;
   GList*      grab_old_window_stacking;
   MetaEdgeResistanceData *grab_edge_resistance_data;
   unsigned int grab_last_user_action_was_snap;
@@ -242,8 +232,8 @@ struct _MetaDisplay
   int	      grab_resize_timeout_id;
 
   /* Keybindings stuff */
-  MetaKeyBinding *key_bindings;
-  int             n_key_bindings;
+  GHashTable     *key_bindings;
+  GHashTable     *key_bindings_index;
   int             min_keycode;
   int             max_keycode;
   KeySym *keymap;
@@ -273,10 +263,6 @@ struct _MetaDisplay
   /* Managed by group.c */
   GHashTable *groups_by_leader;
 
-  /* currently-active window menu if any */
-  MetaWindowMenu *window_menu;
-  MetaWindow *window_with_menu;
-
   /* Managed by window-props.c */
   MetaWindowPropHooks *prop_hooks_table;
   GHashTable *prop_hooks;
@@ -493,10 +479,9 @@ gboolean meta_display_process_barrier_event (MetaDisplay *display,
                                              XIEvent     *event);
 #endif /* HAVE_XI23 */
 
-void meta_display_set_input_focus_xwindow (MetaDisplay   *display,
-                                           MetaScreen    *screen,
-                                           MetaFocusType  type,
-                                           Window         window,
-                                           guint32        timestamp);
+void meta_display_set_input_focus_xwindow (MetaDisplay *display,
+                                           MetaScreen  *screen,
+                                           Window       window,
+                                           guint32      timestamp);
 
 #endif

src/core/display.c

@@ -73,14 +73,7 @@
 #include <unistd.h>
 
 #include "meta-xwayland-private.h"
-
-#define GRAB_OP_IS_WINDOW_SWITCH(g)                     \
-        (g == META_GRAB_OP_KEYBOARD_TABBING_NORMAL  ||  \
-         g == META_GRAB_OP_KEYBOARD_TABBING_DOCK    ||  \
-         g == META_GRAB_OP_KEYBOARD_TABBING_GROUP   ||  \
-         g == META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL ||  \
-         g == META_GRAB_OP_KEYBOARD_ESCAPING_DOCK   ||  \
-         g == META_GRAB_OP_KEYBOARD_ESCAPING_GROUP)
+#include "meta-surface-actor-wayland.h"
 
 /*
  * SECTION:pings
@@ -571,9 +564,6 @@ meta_display_open (void)
   the_display->monitor_cache_invalidated = TRUE;
 
   the_display->groups_by_leader = NULL;
-
-  the_display->window_with_menu = NULL;
-  the_display->window_menu = NULL;
   
   the_display->screens = NULL;
   the_display->active_screen = NULL;
@@ -1302,10 +1292,6 @@ 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)
 {
@@ -1374,13 +1360,6 @@ grab_op_is_keyboard (MetaGrabOp op)
     case META_GRAB_OP_KEYBOARD_RESIZING_NE:
     case META_GRAB_OP_KEYBOARD_RESIZING_SW:
     case META_GRAB_OP_KEYBOARD_RESIZING_NW:
-    case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
-    case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
-    case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
-    case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
-    case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
-    case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
-    case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
     case META_GRAB_OP_COMPOSITOR:
       return TRUE;
 
@@ -1432,6 +1411,20 @@ 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
@@ -1681,9 +1674,19 @@ get_window_for_event (MetaDisplay        *display,
   if (display->grab_op != META_GRAB_OP_NONE)
     return display->grab_window;
 
+  /* Always use the key focused window for key events. */
+  switch (event->type)
+    {
+    case CLUTTER_KEY_PRESS:
+    case CLUTTER_KEY_RELEASE:
+      return display->focus_window;
+    default:
+      break;
+    }
+
   source = clutter_event_get_source (event);
-  if (META_IS_WINDOW_ACTOR (source))
-    return meta_window_actor_get_meta_window (META_WINDOW_ACTOR (source));
+  if (META_IS_SURFACE_ACTOR (source))
+    return meta_surface_actor_get_window (META_SURFACE_ACTOR (source));
 
   return NULL;
 }
@@ -1741,12 +1744,11 @@ get_input_event (MetaDisplay *display,
 }
 
 static void
-update_focus_window (MetaDisplay   *display,
-                     MetaFocusType  type,
-                     MetaWindow    *window,
-                     Window         xwindow,
-                     gulong         serial,
-                     gboolean       focused_by_us)
+update_focus_window (MetaDisplay *display,
+                     MetaWindow  *window,
+                     Window       xwindow,
+                     gulong       serial,
+                     gboolean     focused_by_us)
 {
   MetaWaylandCompositor *compositor;
 
@@ -1754,7 +1756,6 @@ update_focus_window (MetaDisplay   *display,
   display->focused_by_us = focused_by_us;
 
   if (display->focus_xwindow == xwindow &&
-      display->focus_type == type &&
       display->focus_window == window)
     return;
 
@@ -1777,25 +1778,14 @@ update_focus_window (MetaDisplay   *display,
       meta_window_set_focused_internal (previous, FALSE);
     }
 
-  display->focus_type = type;
   display->focus_window = window;
   display->focus_xwindow = xwindow;
 
   if (display->focus_window)
     {
-      ClutterActor *window_actor;
-
       meta_topic (META_DEBUG_FOCUS, "* Focus --> %s with serial %lu\n",
                   display->focus_window->desc, serial);
       meta_window_set_focused_internal (display->focus_window, TRUE);
-
-      /* XXX -- this is sort of a layer violation, but because we
-       * rely on the compositor for event delivery anyway, I don't
-       * think it's too bad... */
-
-      window_actor = CLUTTER_ACTOR (display->focus_window->compositor_private);
-      if (window_actor)
-        clutter_actor_grab_key_focus (window_actor);
     }
   else
     meta_topic (META_DEBUG_FOCUS, "* Focus --> NULL with serial %lu\n", serial);
@@ -1804,8 +1794,7 @@ update_focus_window (MetaDisplay   *display,
     {
       compositor = meta_wayland_compositor_get_default ();
 
-      if (display->focus_type == META_FOCUS_NO_FOCUS_WINDOW ||
-          display->focus_type == META_FOCUS_STAGE)
+      if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
         meta_wayland_compositor_set_input_focus (compositor, NULL);
       else if (window && window->surface)
         meta_wayland_compositor_set_input_focus (compositor, window);
@@ -1847,12 +1836,11 @@ timestamp_too_old (MetaDisplay *display,
 }
 
 static void
-request_xserver_input_focus_change (MetaDisplay   *display,
-                                    MetaScreen    *screen,
-                                    MetaFocusType  type,
-                                    MetaWindow    *meta_window,
-                                    Window         xwindow,
-                                    guint32        timestamp)
+request_xserver_input_focus_change (MetaDisplay *display,
+                                    MetaScreen  *screen,
+                                    MetaWindow  *meta_window,
+                                    Window       xwindow,
+                                    guint32      timestamp)
 {
   gulong serial;
 
@@ -1885,7 +1873,6 @@ request_xserver_input_focus_change (MetaDisplay   *display,
   meta_display_ungrab (display);
 
   update_focus_window (display,
-                       type,
                        meta_window,
                        xwindow,
                        serial,
@@ -1907,12 +1894,9 @@ handle_window_focus_event (MetaDisplay  *display,
                            unsigned long serial)
 {
   MetaWindow *focus_window;
-  MetaFocusType type;
 #ifdef WITH_VERBOSE_MODE
   const char *window_type;
 
-  type = META_FOCUS_NONE;
-
   /* Note the event can be on either the window or the frame,
    * we focus the frame for shaded windows
    */
@@ -1924,26 +1908,14 @@ handle_window_focus_event (MetaDisplay  *display,
         window_type = "frame window";
       else
         window_type = "unknown client window";
-
-      if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
-        type = META_FOCUS_WAYLAND_CLIENT;
-      else
-        type = META_FOCUS_X_CLIENT;
     }
   else if (meta_display_xwindow_is_a_no_focus_window (display, event->event))
-    {
-      window_type = "no_focus_window";
-      type = META_FOCUS_NO_FOCUS_WINDOW;
-    }
+    window_type = "no_focus_window";
   else if (meta_display_screen_for_root (display, event->event))
     window_type = "root window";
   else
     window_type = "unknown window";
 
-  /* Don't change type if we don't know the new window */
-  if (type == META_FOCUS_NONE)
-    type = display->focus_type;
-
   meta_topic (META_DEBUG_FOCUS,
               "Focus %s event received on %s 0x%lx (%s) "
               "mode %s detail %s serial %lu\n",
@@ -2028,7 +2000,6 @@ handle_window_focus_event (MetaDisplay  *display,
        display->server_focus_serial == display->focus_serial))
     {
       update_focus_window (display,
-                           type,
                            focus_window,
                            focus_window ? focus_window->xwindow : None,
                            display->server_focus_serial,
@@ -2057,9 +2028,6 @@ meta_display_handle_event (MetaDisplay        *display,
   gboolean bypass_clutter = FALSE, bypass_wayland = FALSE;
   MetaWaylandCompositor *compositor = NULL;
 
-  /* XXX -- we need to fill this in properly at some point... */
-  gboolean frame_was_receiver = FALSE;
-
   if (meta_is_wayland_compositor ())
     {
       compositor = meta_wayland_compositor_get_default ();
@@ -2093,7 +2061,7 @@ meta_display_handle_event (MetaDisplay        *display,
   switch (event->type)
     {
     case CLUTTER_BUTTON_PRESS:
-      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+      if (grab_op_should_block_mouse_events (display->grab_op))
         break;
 
       display->overlay_key_only_pressed = FALSE;
@@ -2111,79 +2079,76 @@ meta_display_handle_event (MetaDisplay        *display,
                       (display->grab_window ?
                        display->grab_window->desc :
                        "none"));
-          if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
-            {
-              meta_topic (META_DEBUG_WINDOW_OPS,
-                          "Syncing to old stack positions.\n");
-
-              /* XXX: I'm not sure if this is the right thing to do.
-                 The pre-Wayland code was only calling
-                 meta_stack_set_positions if the modified window was a
-                 root window */
-              if (event->any.source == CLUTTER_ACTOR (event->any.stage) && window && window->screen)
-                meta_stack_set_positions (window->screen->stack,
-                                          display->grab_old_window_stacking);
-            }
           meta_display_end_grab_op (display, event->any.time);
           bypass_clutter = TRUE;
           bypass_wayland = TRUE;
         }
       else if (window && display->grab_op == META_GRAB_OP_NONE)
         {
-          gboolean begin_move = FALSE;
           ClutterModifierType grab_mask;
           gboolean unmodified;
+          gboolean fully_modified;
 
           grab_mask = display->window_grab_modifiers;
           if (g_getenv ("MUTTER_DEBUG_BUTTON_GRABS"))
             grab_mask |= CLUTTER_CONTROL_MASK;
 
-          /* Two possible sources of an unmodified event; one is a
-           * client that's letting button presses pass through to the
-           * frame, the other is our focus_window_grab on unmodified
-           * button 1.  So for all such events we focus the window.
+          /* We have three passive button grabs:
+           * - on any button, without modifiers => focuses and maybe raises the window
+           * - on resize button, with modifiers => start an interactive resizing
+           *   (normally <Super>middle)
+           * - on move button, with modifiers => start an interactive move
+           *   (normally <Super>left)
+           * - on menu button, with modifiers => show the window menu
+           *   (normally <Super>right)
+           *
+           * We may get here because we actually have a button
+           * grab on the window, or because we're a wayland
+           * compositor and thus we see all the events, so we
+           * need to check if the event is interesting.
+           * We want an event that is not modified, for a window
+           * that has (or would have, the wayland case) the
+           * button grab active.
+           *
+           * We may have other events on the window, for example
+           * a click on a frame button, but that's not for us to
+           * care about. Just let the event through.
            */
           unmodified = (event->button.modifier_state & grab_mask) == 0;
+          fully_modified = grab_mask && (event->button.modifier_state & grab_mask) == grab_mask;
 
-          if (unmodified ||
-              event->button.button == 1)
+          if (unmodified && window && window->have_focus_click_grab)
             {
-              /* don't focus if frame received, will be lowered in
-               * frames.c or special-cased if the click was on a
-               * minimize/close button.
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              else
+                meta_topic (META_DEBUG_FOCUS,
+                            "Not raising window on click due to don't-raise-on-click option\n");
+
+              /* Don't focus panels--they must explicitly request focus.
+               * See bug 160470
                */
-              if (!frame_was_receiver)
+              if (window->type != META_WINDOW_DOCK)
                 {
-                  if (meta_prefs_get_raise_on_click ())
-                    meta_window_raise (window);
-                  else
-                    meta_topic (META_DEBUG_FOCUS,
-                                "Not raising window on click due to don't-raise-on-click option\n");
-
-                  /* Don't focus panels--they must explicitly request focus.
-                   * See bug 160470
-                   */
-                  if (window->type != META_WINDOW_DOCK)
-                    {
-                      meta_topic (META_DEBUG_FOCUS,
-                                  "Focusing %s due to unmodified button %u press (display.c)\n",
-                                  window->desc, event->button.button);
-                      meta_window_focus (window, event->any.time);
-                    }
-                  else
-                    /* However, do allow terminals to lose focus due to new
-                     * window mappings after the user clicks on a panel.
-                     */
-                    display->allow_terminal_deactivation = TRUE;
+                  meta_topic (META_DEBUG_FOCUS,
+                              "Focusing %s due to unmodified button %u press (display.c)\n",
+                              window->desc, event->button.button);
+                  meta_window_focus (window, event->any.time);
                 }
+              else
+                /* However, do allow terminals to lose focus due to new
+                 * window mappings after the user clicks on a panel.
+                 */
+                display->allow_terminal_deactivation = TRUE;
 
-              /* you can move on alt-click but not on
-               * the click-to-focus
-               */
-              if (!unmodified)
-                begin_move = TRUE;
+              meta_verbose ("Allowing events time %u\n",
+                            (unsigned int)event->button.time);
+
+              XIAllowEvents (display->xdisplay, clutter_input_device_get_device_id (event->button.device),
+                             XIReplayDevice, event->button.time);
+              bypass_clutter = TRUE;
             }
-          else if (!unmodified && ((int) event->button.button == meta_prefs_get_mouse_button_resize ()))
+          else if (fully_modified && (int) event->button.button == meta_prefs_get_mouse_button_resize ())
             {
               if (window->has_resize_func)
                 {
@@ -2231,40 +2196,40 @@ meta_display_handle_event (MetaDisplay        *display,
                                                 event->button.x,
                                                 event->button.y);
                 }
-            }
-          else if ((int) event->button.button == meta_prefs_get_mouse_button_menu ())
-            {
-              if (meta_prefs_get_raise_on_click ())
-                meta_window_raise (window);
-              meta_window_show_menu (window,
-                                     event->button.x,
-                                     event->button.y,
-                                     event->button.button,
-                                     event->any.time);
               bypass_clutter = TRUE;
               bypass_wayland = TRUE;
             }
-
-          if (begin_move && window->has_move_func)
+          else if (fully_modified && (int) event->button.button == meta_prefs_get_mouse_button_menu ())
             {
-              meta_display_begin_grab_op (display,
-                                          window->screen,
-                                          window,
-                                          META_GRAB_OP_MOVING,
-                                          TRUE,
-                                          FALSE,
-                                          event->button.button,
-                                          0,
-                                          event->any.time,
-                                          event->button.x,
-                                          event->button.y);
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_show_menu (window);
+              bypass_clutter = TRUE;
+              bypass_wayland = TRUE;
+            }
+          else if (fully_modified && (int) event->button.button == 1)
+            {
+              if (window->has_move_func)
+                {
+                  meta_display_begin_grab_op (display,
+                                              window->screen,
+                                              window,
+                                              META_GRAB_OP_MOVING,
+                                              TRUE,
+                                              FALSE,
+                                              event->button.button,
+                                              0,
+                                              event->any.time,
+                                              event->button.x,
+                                              event->button.y);
+                }
               bypass_clutter = TRUE;
               bypass_wayland = TRUE;
             }
         }
       break;
     case CLUTTER_BUTTON_RELEASE:
-      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+      if (grab_op_should_block_mouse_events (display->grab_op))
         break;
 
       display->overlay_key_only_pressed = FALSE;
@@ -2278,7 +2243,7 @@ meta_display_handle_event (MetaDisplay        *display,
         }
       break;
     case CLUTTER_MOTION:
-      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+      if (grab_op_should_block_mouse_events (display->grab_op))
         break;
 
       if (display->grab_window == window &&
@@ -2312,6 +2277,10 @@ 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))
@@ -2326,11 +2295,10 @@ handle_input_xevent (MetaDisplay *display,
                      XIEvent     *input_event,
                      gulong       serial)
 {
-  XIDeviceEvent *device_event = (XIDeviceEvent *) input_event;
   XIEnterEvent *enter_event = (XIEnterEvent *) input_event;
   Window modified;
   MetaWindow *window;
-  gboolean frame_was_receiver;
+  MetaScreen *screen;
 
   if (input_event == NULL)
     return FALSE;
@@ -2338,242 +2306,8 @@ handle_input_xevent (MetaDisplay *display,
   modified = xievent_get_modified_window (display, input_event);
   window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
 
-  frame_was_receiver = FALSE;
-  if (window &&
-      window->frame &&
-      modified == window->frame->xwindow)
-    {
-      /* Note that if the frame and the client both have an
-       * XGrabButton (as is normal with our setup), the event
-       * goes to the frame.
-       */
-      frame_was_receiver = TRUE;
-      meta_topic (META_DEBUG_EVENTS, "Frame was receiver of event for %s\n",
-                  window->desc);
-    }
-
-  if (window && !window->override_redirect &&
-      (input_event->evtype == XI_KeyPress || input_event->evtype == XI_ButtonPress))
-    {
-      if (CurrentTime == display->current_time)
-        {
-          /* We can't use missing (i.e. invalid) timestamps to set user time,
-           * nor do we want to use them to sanity check other timestamps.
-           * See bug 313490 for more details.
-           */
-          meta_warning ("Event has no timestamp! You may be using a broken "
-                        "program such as xse.  Please ask the authors of that "
-                        "program to fix it.\n");
-        }
-      else
-        {
-          meta_window_set_user_time (window, display->current_time);
-          sanity_check_timestamps (display, display->current_time);
-        }
-    }
-
   switch (input_event->evtype)
     {
-    case XI_ButtonPress:
-      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
-        break;
-
-      display->overlay_key_only_pressed = FALSE;
-
-      if (device_event->detail == 4 || device_event->detail == 5)
-        /* Scrollwheel event, do nothing and deliver event to compositor below */
-        break;
-
-      if ((window &&
-           meta_grab_op_is_mouse (display->grab_op) &&
-           (device_event->mods.effective & display->window_grab_modifiers) &&
-           display->grab_button != device_event->detail &&
-           display->grab_window == window) ||
-          grab_op_is_keyboard (display->grab_op))
-        {
-          meta_topic (META_DEBUG_WINDOW_OPS,
-                      "Ending grab op %u on window %s due to button press\n",
-                      display->grab_op,
-                      (display->grab_window ?
-                       display->grab_window->desc :
-                       "none"));
-          if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
-            {
-              MetaScreen *screen;
-              meta_topic (META_DEBUG_WINDOW_OPS,
-                          "Syncing to old stack positions.\n");
-              screen =
-                meta_display_screen_for_root (display, device_event->event);
-
-              if (screen!=NULL)
-                meta_stack_set_positions (screen->stack,
-                                          display->grab_old_window_stacking);
-            }
-          meta_display_end_grab_op (display,
-                                    device_event->time);
-        }
-      else if (window && display->grab_op == META_GRAB_OP_NONE)
-        {
-          gboolean begin_move = FALSE;
-          unsigned int grab_mask;
-          gboolean unmodified;
-
-          grab_mask = display->window_grab_modifiers;
-          if (g_getenv ("MUTTER_DEBUG_BUTTON_GRABS"))
-            grab_mask |= ControlMask;
-
-          /* Two possible sources of an unmodified event; one is a
-           * client that's letting button presses pass through to the
-           * frame, the other is our focus_window_grab on unmodified
-           * button 1.  So for all such events we focus the window.
-           */
-          unmodified = (device_event->mods.effective & grab_mask) == 0;
-
-          if (unmodified ||
-              device_event->detail == 1)
-            {
-              /* don't focus if frame received, will be lowered in
-               * frames.c or special-cased if the click was on a
-               * minimize/close button.
-               */
-              if (!frame_was_receiver)
-                {
-                  if (meta_prefs_get_raise_on_click ())
-                    meta_window_raise (window);
-                  else
-                    meta_topic (META_DEBUG_FOCUS,
-                                "Not raising window on click due to don't-raise-on-click option\n");
-
-                  /* Don't focus panels--they must explicitly request focus.
-                   * See bug 160470
-                   */
-                  if (window->type != META_WINDOW_DOCK)
-                    {
-                      meta_topic (META_DEBUG_FOCUS,
-                                  "Focusing %s due to unmodified button %u press (display.c)\n",
-                                  window->desc, device_event->detail);
-                      meta_window_focus (window, device_event->time);
-                    }
-                  else
-                    /* However, do allow terminals to lose focus due to new
-                     * window mappings after the user clicks on a panel.
-                     */
-                    display->allow_terminal_deactivation = TRUE;
-                }
-
-              /* you can move on alt-click but not on
-               * the click-to-focus
-               */
-              if (!unmodified)
-                begin_move = TRUE;
-            }
-          else if (!unmodified && device_event->detail == meta_prefs_get_mouse_button_resize())
-            {
-              if (window->has_resize_func)
-                {
-                  gboolean north, south;
-                  gboolean west, east;
-                  MetaRectangle frame_rect;
-                  MetaGrabOp op;
-
-                  meta_window_get_frame_rect (window, &frame_rect);
-
-                  west = device_event->root_x <  (frame_rect.x + 1 * frame_rect.width  / 3);
-                  east = device_event->root_x >  (frame_rect.x + 2 * frame_rect.width  / 3);
-                  north = device_event->root_y < (frame_rect.y + 1 * frame_rect.height / 3);
-                  south = device_event->root_y > (frame_rect.y + 2 * frame_rect.height / 3);
-
-                  if (north && west)
-                    op = META_GRAB_OP_RESIZING_NW;
-                  else if (north && east)
-                    op = META_GRAB_OP_RESIZING_NE;
-                  else if (south && west)
-                    op = META_GRAB_OP_RESIZING_SW;
-                  else if (south && east)
-                    op = META_GRAB_OP_RESIZING_SE;
-                  else if (north)
-                    op = META_GRAB_OP_RESIZING_N;
-                  else if (west)
-                    op = META_GRAB_OP_RESIZING_W;
-                  else if (east)
-                    op = META_GRAB_OP_RESIZING_E;
-                  else if (south)
-                    op = META_GRAB_OP_RESIZING_S;
-                  else /* Middle region is no-op to avoid user triggering wrong action */
-                    op = META_GRAB_OP_NONE;
-
-                  if (op != META_GRAB_OP_NONE)
-                    meta_display_begin_grab_op (display,
-                                                window->screen,
-                                                window,
-                                                op,
-                                                TRUE,
-                                                FALSE,
-                                                device_event->detail,
-                                                0,
-                                                device_event->time,
-                                                device_event->root_x,
-                                                device_event->root_y);
-                }
-            }
-          else if (device_event->detail == meta_prefs_get_mouse_button_menu())
-            {
-              if (meta_prefs_get_raise_on_click ())
-                meta_window_raise (window);
-              meta_window_show_menu (window,
-                                     device_event->root_x,
-                                     device_event->root_y,
-                                     device_event->detail,
-                                     device_event->time);
-            }
-
-          if (!frame_was_receiver && unmodified)
-            {
-              /* This is from our synchronous grab since
-               * it has no modifiers and was on the client window
-               */
-
-              meta_verbose ("Allowing events time %u\n",
-                            (unsigned int)device_event->time);
-
-              XIAllowEvents (display->xdisplay, device_event->deviceid,
-                             XIReplayDevice, device_event->time);
-            }
-
-          if (begin_move && window->has_move_func)
-            {
-              meta_display_begin_grab_op (display,
-                                          window->screen,
-                                          window,
-                                          META_GRAB_OP_MOVING,
-                                          TRUE,
-                                          FALSE,
-                                          device_event->detail,
-                                          0,
-                                          device_event->time,
-                                          device_event->root_x,
-                                          device_event->root_y);
-            }
-        }
-      break;
-    case XI_ButtonRelease:
-      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
-        break;
-
-      display->overlay_key_only_pressed = FALSE;
-
-      if (display->grab_window == window &&
-          meta_grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_xevent (window, device_event);
-      break;
-    case XI_Motion:
-      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
-        break;
-
-      if (display->grab_window == window &&
-          meta_grab_op_is_mouse (display->grab_op))
-        meta_window_handle_mouse_grab_op_xevent (window, device_event);
-      break;
     case XI_Enter:
       if (display->grab_op == META_GRAB_OP_COMPOSITOR)
         break;
@@ -2629,12 +2363,11 @@ handle_input_xevent (MetaDisplay *display,
       if (!window)
         {
           /* Check if the window is a root window. */
-          MetaScreen *screen =
-            meta_display_screen_for_root(display,
-                                         enter_event->event);
-          if (screen == NULL)
+          if (enter_event->root != enter_event->event)
             break;
 
+          screen = meta_display_screen_for_root (display, enter_event->root);
+
           if (enter_event->evtype == XI_FocusIn &&
               enter_event->mode == XINotifyDetailNone)
             {
@@ -2660,7 +2393,9 @@ handle_input_xevent (MetaDisplay *display,
             }
 
         }
-      break;
+
+      /* Don't send FocusIn / FocusOut to Clutter */
+      return TRUE;
     }
 
   return FALSE;
@@ -3246,9 +2981,8 @@ meta_display_handle_xevent (MetaDisplay *display,
   MetaMonitorManager *monitor;
   MetaScreen *screen;
 
-#ifdef WITH_VERBOSE_MODE
-  if (dump_events)
-    meta_spew_event (display, event);
+#if 0
+  meta_spew_event (display, event);
 #endif
 
 #ifdef HAVE_STARTUP_NOTIFICATION
@@ -3277,7 +3011,6 @@ meta_display_handle_xevent (MetaDisplay *display,
       meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                   display->focus_window->desc);
       update_focus_window (display,
-                           META_FOCUS_NONE,
                            meta_display_lookup_x_window (display, display->server_focus_window),
                            display->server_focus_window,
                            display->server_focus_serial,
@@ -3525,8 +3258,7 @@ event_get_time (MetaDisplay *display,
     }
 }
 
-#ifdef WITH_VERBOSE_MODE
-const char*
+G_GNUC_UNUSED const char*
 meta_event_detail_to_string (int d)
 {
   const char *detail = "???";
@@ -3562,10 +3294,8 @@ meta_event_detail_to_string (int d)
 
   return detail;
 }
-#endif /* WITH_VERBOSE_MODE */
 
-#ifdef WITH_VERBOSE_MODE
-const char*
+G_GNUC_UNUSED const char*
 meta_event_mode_to_string (int m)
 {
   const char *mode = "???";
@@ -3587,10 +3317,8 @@ meta_event_mode_to_string (int m)
 
   return mode;
 }
-#endif /* WITH_VERBOSE_MODE */
 
-#ifdef WITH_VERBOSE_MODE
-static const char*
+G_GNUC_UNUSED static const char*
 stack_mode_to_string (int mode)
 {
   switch (mode)
@@ -3609,11 +3337,9 @@ stack_mode_to_string (int mode)
 
   return "Unknown";
 }
-#endif /* WITH_VERBOSE_MODE */
 
 #ifdef HAVE_XSYNC
-#ifdef WITH_VERBOSE_MODE
-static gint64
+G_GNUC_UNUSED static gint64
 sync_value_to_64 (const XSyncValue *value)
 {
   gint64 v;
@@ -3623,10 +3349,8 @@ sync_value_to_64 (const XSyncValue *value)
   
   return v;
 }
-#endif /* WITH_VERBOSE_MODE */
 
-#ifdef WITH_VERBOSE_MODE
-static const char*
+G_GNUC_UNUSED static const char*
 alarm_state_to_string (XSyncAlarmState state)
 {
   switch (state)
@@ -3641,12 +3365,9 @@ alarm_state_to_string (XSyncAlarmState state)
       return "(unknown)";
     }
 }
-#endif /* WITH_VERBOSE_MODE */
-
 #endif /* HAVE_XSYNC */
 
-#ifdef WITH_VERBOSE_MODE
-static void
+G_GNUC_UNUSED static void
 meta_spew_xi2_event (MetaDisplay *display,
                      XIEvent     *input_event,
                      const char **name_p,
@@ -3655,26 +3376,10 @@ meta_spew_xi2_event (MetaDisplay *display,
   const char *name = NULL;
   char *extra = NULL;
 
-  XIDeviceEvent *device_event = (XIDeviceEvent *) input_event;
   XIEnterEvent *enter_event = (XIEnterEvent *) input_event;
 
   switch (input_event->evtype)
     {
-    case XI_Motion:
-      name = "XI_Motion";
-      break;
-    case XI_ButtonPress:
-      name = "XI_ButtonPress";
-      break;
-    case XI_ButtonRelease:
-      name = "XI_ButtonRelease";
-      break;
-    case XI_KeyPress:
-      name = "XI_KeyPress";
-      break;
-    case XI_KeyRelease:
-      name = "XI_KeyRelease";
-      break;
     case XI_FocusIn:
       name = "XI_FocusIn";
       break;
@@ -3699,34 +3404,6 @@ meta_spew_xi2_event (MetaDisplay *display,
 
   switch (input_event->evtype)
     {
-    case XI_Motion:
-      extra = g_strdup_printf ("win: 0x%lx x: %g y: %g",
-                               device_event->event,
-                               device_event->root_x,
-                               device_event->root_y);
-      break;
-    case XI_ButtonPress:
-    case XI_ButtonRelease:
-      extra = g_strdup_printf ("button %u x %g y %g root 0x%lx",
-                               device_event->detail,
-                               device_event->root_x,
-                               device_event->root_y,
-                               device_event->root);
-      break;
-    case XI_KeyPress:
-    case XI_KeyRelease:
-      {
-        KeySym keysym;
-        const char *str;
-  
-        keysym = XKeycodeToKeysym (display->xdisplay, device_event->detail, 0);
-
-        str = XKeysymToString (keysym);
-
-        extra = g_strdup_printf ("Key '%s' state 0x%x",
-                                 str ? str : "none", device_event->mods.effective);
-      }
-      break;
     case XI_FocusIn:
     case XI_FocusOut:
       extra = g_strdup_printf ("detail: %s mode: %s\n",
@@ -3750,7 +3427,7 @@ meta_spew_xi2_event (MetaDisplay *display,
   *extra_p = extra;
 }
 
-static void
+G_GNUC_UNUSED static void
 meta_spew_core_event (MetaDisplay *display,
                       XEvent      *event,
                       const char **name_p,
@@ -3974,7 +3651,7 @@ meta_spew_core_event (MetaDisplay *display,
   *extra_p = extra;
 }
 
-static void
+G_GNUC_UNUSED static void
 meta_spew_event (MetaDisplay *display,
                  XEvent      *event)
 {
@@ -3983,9 +3660,6 @@ 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 ||
@@ -4015,18 +3689,16 @@ meta_spew_event (MetaDisplay *display,
   else
     winname = g_strdup_printf ("0x%lx", event->xany.window);
 
-  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_print ("%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,
@@ -4354,7 +4026,6 @@ meta_display_begin_grab_op (MetaDisplay *display,
   display->grab_latest_motion_y = root_y;
   display->grab_last_moveresize_time.tv_sec = 0;
   display->grab_last_moveresize_time.tv_usec = 0;
-  display->grab_motion_notify_time = 0;
   display->grab_old_window_stacking = NULL;
 #ifdef HAVE_XSYNC
   display->grab_last_user_action_was_snap = FALSE;
@@ -4391,16 +4062,6 @@ meta_display_begin_grab_op (MetaDisplay *display,
   g_assert (display->grab_window != NULL || display->grab_screen != NULL);
   g_assert (display->grab_op != META_GRAB_OP_NONE);
 
-  /* Save the old stacking */
-  if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
-    {
-      meta_topic (META_DEBUG_WINDOW_OPS,
-                  "Saving old stack positions; old pointer was %p.\n",
-                  display->grab_old_window_stacking);
-      display->grab_old_window_stacking = 
-        meta_stack_get_positions (screen->stack);
-    }
-
   if (display->grab_window)
     {
       meta_window_refresh_resize_popup (display->grab_window);
@@ -4442,20 +4103,6 @@ meta_display_end_grab_op (MetaDisplay *display,
       if (!display->grab_threshold_movement_reached)
         meta_window_raise (display->grab_window);
     }
-
-  if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op) ||
-      display->grab_op == META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING)
-    {
-      if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
-        meta_screen_tab_popup_destroy (display->grab_screen);
-      else
-        meta_screen_workspace_popup_destroy (display->grab_screen);
-
-      /* If the ungrab here causes an EnterNotify, ignore it for
-       * sloppy focus
-       */
-      display->ungrab_should_not_cause_focus_window = display->grab_xwindow;
-    }
   
   /* If this was a move or resize clear out the edge cache */
   if (meta_grab_op_is_resizing (display->grab_op) || 
@@ -4980,7 +4627,7 @@ meta_display_ping_window (MetaWindow        *window,
       return;
     }
 
-  if (!window->net_wm_ping)
+  if (!window->can_ping)
     {
       if (ping_reply_func)
         (* ping_reply_func) (window, timestamp, user_data);
@@ -5946,8 +5593,6 @@ meta_display_set_input_focus_window (MetaDisplay *display,
 {
   request_xserver_input_focus_change (display,
                                       window->screen,
-                                      window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND ?
-                                      META_FOCUS_WAYLAND_CLIENT : META_FOCUS_X_CLIENT,
                                       window,
                                       focus_frame ? window->frame->xwindow : window->xwindow,
                                       timestamp);
@@ -5970,15 +5615,13 @@ meta_display_request_take_focus (MetaDisplay *display,
 }
 
 void
-meta_display_set_input_focus_xwindow (MetaDisplay   *display,
-                                      MetaScreen    *screen,
-                                      MetaFocusType  type,
-                                      Window         window,
-                                      guint32        timestamp)
+meta_display_set_input_focus_xwindow (MetaDisplay *display,
+                                      MetaScreen  *screen,
+                                      Window       window,
+                                      guint32      timestamp)
 {
   request_xserver_input_focus_change (display,
                                       screen,
-                                      type,
                                       NULL,
                                       window,
                                       timestamp);
@@ -5991,7 +5634,6 @@ meta_display_focus_the_no_focus_window (MetaDisplay *display,
 {
   request_xserver_input_focus_change (display,
                                       screen,
-                                      META_FOCUS_NO_FOCUS_WINDOW,
                                       NULL,
                                       screen->no_focus_window,
                                       timestamp);

src/core/keybindings-private.h

@@ -30,6 +30,7 @@
 #include <gio/gio.h>
 #include <meta/keybindings.h>
 
+typedef struct _MetaKeyHandler MetaKeyHandler;
 struct _MetaKeyHandler
 {
   char *name;
@@ -47,9 +48,48 @@ struct _MetaKeyBinding
   KeyCode keycode;
   unsigned int mask;
   MetaVirtualModifier modifiers;
+  gint flags;
   MetaKeyHandler *handler;
 };
 
+/**
+ * MetaKeyCombo:
+ * @keysym: keysym
+ * @keycode: keycode
+ * @modifiers: modifiers
+ */
+typedef struct _MetaKeyCombo MetaKeyCombo;
+struct _MetaKeyCombo
+{
+  unsigned int keysym;
+  unsigned int keycode;
+  MetaVirtualModifier modifiers;
+};
+
+typedef struct
+{
+  char *name;
+  GSettings *settings;
+
+  MetaKeyBindingAction action;
+
+  /*
+   * A list of MetaKeyCombos. Each of them is bound to
+   * this keypref. If one has keysym==modifiers==0, it is
+   * ignored.
+   */
+  GSList *combos;
+
+  /* for keybindings that can have shift or not like Alt+Tab */
+  gboolean      add_shift:1;
+
+  /* for keybindings that apply only to a window */
+  gboolean      per_window:1;
+
+  /* for keybindings not added with meta_display_add_keybinding() */
+  gboolean      builtin:1;
+} MetaKeyPref;
+
 void     meta_display_init_keys             (MetaDisplay *display);
 void     meta_display_shutdown_keys         (MetaDisplay *display);
 void     meta_screen_grab_keys              (MetaScreen  *screen);
@@ -77,5 +117,8 @@ gboolean meta_prefs_add_keybinding          (const char           *name,
 
 gboolean meta_prefs_remove_keybinding       (const char    *name);
 
+GList *meta_prefs_get_keybindings (void);
+void meta_prefs_get_overlay_binding (MetaKeyCombo *combo);
+const char *meta_prefs_get_iso_next_group_option (void);
 
 #endif

src/core/main.c

@@ -42,7 +42,7 @@
  */
 
 #define _GNU_SOURCE
-#define _SVID_SOURCE /* for putenv() and some signal-related functions */
+#define _XOPEN_SOURCE /* for putenv() and some signal-related functions */
 
 #include <config.h>
 #include <meta/main.h>
@@ -53,7 +53,7 @@
 #include "session.h"
 #include <meta/prefs.h>
 #include <meta/compositor.h>
-#include "meta-wayland-private.h"
+#include "meta-wayland.h"
 
 #include <glib-object.h>
 #include <glib-unix.h>
@@ -190,6 +190,7 @@ 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[] = {
   {
@@ -233,6 +234,11 @@ 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}
 };
 
@@ -343,7 +349,8 @@ meta_select_display (char *display_arg)
   else
     display_name = g_getenv ("MUTTER_DISPLAY");
 
-  g_setenv ("DISPLAY", display_name, TRUE);
+  if (display_name)
+    g_setenv ("DISPLAY", display_name, TRUE);
 }
 
 static void
@@ -400,8 +407,7 @@ meta_init (void)
   if (g_getenv ("MUTTER_DEBUG"))
     meta_set_debugging (TRUE);
 
-  /* We consider running from mutter-launch equivalent to running from bare metal. */
-  if (getenv ("WESTON_LAUNCHER_SOCK"))
+  if (opt_display_server)
     clutter_set_windowing_backend (CLUTTER_WINDOWING_EGL);
 
   meta_set_is_wayland_compositor (opt_wayland);
@@ -496,6 +502,32 @@ 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)
  *

src/core/meta-cursor-tracker-private.h

@@ -43,4 +43,7 @@ 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

src/core/meta-cursor-tracker.c

@@ -39,6 +39,7 @@
 #include <gbm.h>
 
 #include <gdk/gdk.h>
+#include <gdk/gdkx.h>
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
@@ -569,6 +570,9 @@ 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))
@@ -1074,12 +1078,13 @@ get_pointer_position_gdk (int         *x,
   GdkScreen *gscreen;
 
   gmanager = gdk_display_get_device_manager (gdk_display_get_default ());
-  gdevice = gdk_device_manager_get_client_pointer (gmanager);
+  gdevice = gdk_x11_device_manager_lookup (gmanager, META_VIRTUAL_CORE_POINTER_ID);
 
   gdk_device_get_position (gdevice, &gscreen, x, y);
-  gdk_device_get_state (gdevice,
-                        gdk_screen_get_root_window (gscreen),
-                        NULL, (GdkModifierType*)mods);
+  if (mods)
+    gdk_device_get_state (gdevice,
+                          gdk_screen_get_root_window (gscreen),
+                          NULL, (GdkModifierType*)mods);
 }
 
 static void
@@ -1095,9 +1100,12 @@ 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);
-  *x = point.x;
-  *y = point.y;
-  *mods = clutter_input_device_get_modifier_state (cdevice);
+  if (x)
+    *x = point.x;
+  if (y)
+    *y = point.y;
+  if (mods)
+    *mods = clutter_input_device_get_modifier_state (cdevice);
 }
 
 void
@@ -1139,3 +1147,12 @@ 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);
+}

src/core/meta-idle-monitor.c

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

src/core/monitor-kms.c

@@ -650,7 +650,7 @@ meta_monitor_manager_kms_set_power_save_mode (MetaMonitorManager *manager,
     state = DRM_MODE_DPMS_SUSPEND;
     break;
   case META_POWER_SAVE_OFF:
-    state = DRM_MODE_DPMS_SUSPEND;
+    state = DRM_MODE_DPMS_OFF;
     break;
   default:
     return;

src/core/monitor.c

@@ -34,7 +34,6 @@
 #include "util-private.h"
 #include <meta/errors.h>
 #include "monitor-private.h"
-#include "meta-wayland-private.h"
 
 #include "meta-dbus-xrandr.h"
 

src/core/prefs.c

@@ -57,7 +57,6 @@
 
 #define KEY_OVERLAY_KEY "overlay-key"
 #define KEY_WORKSPACES_ONLY_ON_PRIMARY "workspaces-only-on-primary"
-#define KEY_NO_TAB_POPUP "no-tab-popup"
 
 /* These are the different schemas we are keeping
  * a GSettings instance for */
@@ -112,8 +111,6 @@ static char **workspace_names = NULL;
 
 static gboolean workspaces_only_on_primary = FALSE;
 
-static gboolean no_tab_popup = FALSE;
-
 static char *iso_next_group_option = NULL;
 
 static void handle_preference_update_enum (GSettings *settings,
@@ -365,13 +362,6 @@ static MetaBoolPreference preferences_bool[] =
       },
       &workspaces_only_on_primary,
     },
-    {
-      { KEY_NO_TAB_POPUP,
-        SCHEMA_MUTTER,
-        META_PREF_NO_TAB_POPUP,
-      },
-      &no_tab_popup,
-    },
     {
       { "auto-maximize",
         SCHEMA_MUTTER,
@@ -1813,9 +1803,6 @@ meta_preference_to_string (MetaPreference pref)
     case META_PREF_WORKSPACES_ONLY_ON_PRIMARY:
       return "WORKSPACES_ONLY_ON_PRIMARY";
 
-    case META_PREF_NO_TAB_POPUP:
-      return "NO_TAB_POPUP";
-
     case META_PREF_DRAGGABLE_BORDER_WIDTH:
       return "DRAGGABLE_BORDER_WIDTH";
 
@@ -1869,7 +1856,7 @@ init_bindings (void)
   pref = g_new0 (MetaKeyPref, 1);
   pref->name = g_strdup ("overlay-key");
   pref->action = META_KEYBINDING_ACTION_OVERLAY_KEY;
-  pref->bindings = g_slist_prepend (pref->bindings, &overlay_key_combo);
+  pref->combos = g_slist_prepend (pref->combos, &overlay_key_combo);
   pref->builtin = 1;
 
   g_hash_table_insert (key_bindings, g_strdup ("overlay-key"), pref);
@@ -1879,7 +1866,7 @@ static gboolean
 update_binding (MetaKeyPref *binding,
                 gchar      **strokes)
 {
-  GSList *old_bindings, *a, *b;
+  GSList *old_combos, *a, *b;
   gboolean changed;
   unsigned int keysym;
   unsigned int keycode;
@@ -1891,8 +1878,8 @@ update_binding (MetaKeyPref *binding,
               "Binding \"%s\" has new GSettings value\n",
               binding->name);
 
-  old_bindings = binding->bindings;
-  binding->bindings = NULL;
+  old_combos = binding->combos;
+  binding->combos = NULL;
 
   for (i = 0; strokes && strokes[i]; i++)
     {
@@ -1933,17 +1920,17 @@ update_binding (MetaKeyPref *binding,
       combo->keysym = keysym;
       combo->keycode = keycode;
       combo->modifiers = mods;
-      binding->bindings = g_slist_prepend (binding->bindings, combo);
+      binding->combos = g_slist_prepend (binding->combos, combo);
 
       meta_topic (META_DEBUG_KEYBINDINGS,
                       "New keybinding for \"%s\" is keysym = 0x%x keycode = 0x%x mods = 0x%x\n",
                       binding->name, keysym, keycode, mods);
     }
 
-  binding->bindings = g_slist_reverse (binding->bindings);
+  binding->combos = g_slist_reverse (binding->combos);
 
-  a = old_bindings;
-  b = binding->bindings;
+  a = old_combos;
+  b = binding->combos;
   while (TRUE)
     {
       if ((!a && b) || (a && !b))
@@ -1968,7 +1955,7 @@ update_binding (MetaKeyPref *binding,
         }
     }
 
-  g_slist_free_full (old_bindings, g_free);
+  g_slist_free_full (old_combos, g_free);
 
   return changed;
 }
@@ -2103,7 +2090,7 @@ meta_prefs_add_keybinding (const char           *name,
   pref->name = g_strdup (name);
   pref->settings = g_object_ref (settings);
   pref->action = action;
-  pref->bindings = NULL;
+  pref->combos = NULL;
   pref->add_shift = (flags & META_KEY_BINDING_REVERSES) != 0;
   pref->per_window = (flags & META_KEY_BINDING_PER_WINDOW) != 0;
   pref->builtin = (flags & META_KEY_BINDING_BUILTIN) != 0;
@@ -2167,11 +2154,6 @@ meta_prefs_remove_keybinding (const char *name)
   return TRUE;
 }
 
-/**
- * meta_prefs_get_keybindings:
- *
- * Returns: (element-type MetaKeyPref) (transfer container):
- */
 GList *
 meta_prefs_get_keybindings ()
 {
@@ -2259,43 +2241,6 @@ meta_prefs_get_keybinding_action (const char *name)
               : META_KEYBINDING_ACTION_NONE;
 }
 
-/* This is used by the menu system to decide what key binding
- * to display next to an option. We return the first non-disabled
- * binding, if any.
- */
-void
-meta_prefs_get_window_binding (const char          *name,
-                               unsigned int        *keysym,
-                               MetaVirtualModifier *modifiers)
-{
-  MetaKeyPref *pref = g_hash_table_lookup (key_bindings, name);
-
-  if (pref->per_window)
-    {
-      GSList *s = pref->bindings;
-
-      while (s)
-        {
-          MetaKeyCombo *c = s->data;
-
-          if (c->keysym != 0 || c->modifiers != 0)
-            {
-              *keysym = c->keysym;
-              *modifiers = c->modifiers;
-              return;
-            }
-
-          s = s->next;
-        }
-
-      /* Not found; return the disabled value */
-      *keysym = *modifiers = 0;
-      return;
-    }
-
-  g_assert_not_reached ();
-}
-
 gint
 meta_prefs_get_mouse_button_resize (void)
 {
@@ -2320,25 +2265,6 @@ meta_prefs_get_workspaces_only_on_primary (void)
   return workspaces_only_on_primary;
 }
 
-
-gboolean
-meta_prefs_get_no_tab_popup (void)
-{
-  return no_tab_popup;
-}
-
-void
-meta_prefs_set_no_tab_popup (gboolean whether)
-{
-  MetaBasePreference *pref;
-
-  if (find_pref (preferences_bool, sizeof(MetaBoolPreference),
-                 KEY_NO_TAB_POPUP, &pref))
-    {
-      g_settings_set_boolean (SETTINGS (pref->schema), KEY_NO_TAB_POPUP, whether);
-    }
-}
-
 int
 meta_prefs_get_draggable_border_width (void)
 {

src/core/screen-private.h

@@ -64,8 +64,6 @@ struct _MetaScreen
   Visual *default_xvisual;
   MetaRectangle rect;  /* Size of screen; rect.x & rect.y are always 0 */
   MetaUI *ui;
-  MetaTabPopup *tab_popup, *ws_popup;
-  MetaTilePreview *tile_preview;
 
   guint tile_preview_timeout_id;
 
@@ -151,25 +149,9 @@ void          meta_screen_foreach_window      (MetaScreen                 *scree
 
 void          meta_screen_update_cursor       (MetaScreen                 *screen);
 
-void          meta_screen_tab_popup_create       (MetaScreen              *screen,
-                                                  MetaTabList              list_type,
-                                                  MetaTabShowType          show_type,
-                                                  MetaWindow              *initial_window);
-void          meta_screen_tab_popup_forward      (MetaScreen              *screen);
-void          meta_screen_tab_popup_backward     (MetaScreen              *screen);
-MetaWindow*   meta_screen_tab_popup_get_selected (MetaScreen              *screen);
-void          meta_screen_tab_popup_destroy      (MetaScreen              *screen);
-
-void          meta_screen_workspace_popup_create       (MetaScreen    *screen,
-                                                        MetaWorkspace *initial_selection);
-void          meta_screen_workspace_popup_select       (MetaScreen    *screen,
-                                                        MetaWorkspace *workspace);
-MetaWorkspace*meta_screen_workspace_popup_get_selected (MetaScreen    *screen);
-void          meta_screen_workspace_popup_destroy      (MetaScreen    *screen);
-
-void          meta_screen_tile_preview_update          (MetaScreen    *screen,
+void          meta_screen_update_tile_preview          (MetaScreen    *screen,
                                                         gboolean       delay);
-void          meta_screen_tile_preview_hide            (MetaScreen    *screen);
+void          meta_screen_hide_tile_preview            (MetaScreen    *screen);
 
 MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
                                                 MetaWindow                 *not_this_one);

src/core/screen.c

@@ -43,7 +43,7 @@
 #include <meta/compositor.h>
 #include "mutter-enum-types.h"
 #include "core.h"
-#include "meta-wayland-private.h"
+#include "meta-wayland.h"
 #include "meta-cursor-tracker-private.h"
 
 #include <X11/extensions/Xinerama.h>
@@ -308,6 +308,9 @@ set_supported_hint (MetaScreen *screen)
 #include <meta/atomnames.h>
 #undef item
 #undef EWMH_ATOMS_ONLY
+
+    screen->display->atom__GTK_FRAME_EXTENTS,
+    screen->display->atom__GTK_SHOW_WINDOW_MENU,
   };
 
   XChangeProperty (screen->display->xdisplay, screen->xroot,
@@ -760,10 +763,6 @@ meta_screen_new (MetaDisplay *display,
   screen->ui = meta_ui_new (screen->display->xdisplay,
                             screen->xscreen);
 
-  screen->tab_popup = NULL;
-  screen->ws_popup = NULL;
-  screen->tile_preview = NULL;
-
   screen->tile_preview_timeout_id = 0;
 
   screen->stack = meta_stack_new (screen);
@@ -868,9 +867,6 @@ meta_screen_free (MetaScreen *screen,
   if (screen->tile_preview_timeout_id)
     g_source_remove (screen->tile_preview_timeout_id);
 
-  if (screen->tile_preview)
-    meta_tile_preview_free (screen->tile_preview);
-  
   g_free (screen->screen_name);
 
   g_object_unref (screen);
@@ -1432,255 +1428,8 @@ meta_screen_update_cursor (MetaScreen *screen)
                                        screen->current_cursor);
 }
 
-void
-meta_screen_tab_popup_create (MetaScreen      *screen,
-                              MetaTabList      list_type,
-                              MetaTabShowType  show_type,
-                              MetaWindow      *initial_selection)
-{
-  MetaTabEntry *entries;
-  GList *tab_list;
-  GList *tmp;
-  int len;
-  int i;
-
-  if (screen->tab_popup)
-    return;
-
-  tab_list = meta_display_get_tab_list (screen->display,
-                                        list_type,
-                                        screen,
-                                        screen->active_workspace);
-
-  len = g_list_length (tab_list);
-
-  entries = g_new (MetaTabEntry, len + 1);
-  entries[len].key = NULL;
-  entries[len].title = NULL;
-  entries[len].icon = NULL;
-
-  i = 0;
-  tmp = tab_list;
-  while (i < len)
-    {
-      MetaWindow *window;
-      MetaRectangle r;
-
-      window = tmp->data;
-
-      entries[i].key = (MetaTabEntryKey) window;
-      entries[i].title = window->title;
-      entries[i].icon = g_object_ref (window->icon);
-      entries[i].blank = FALSE;
-      entries[i].hidden = !meta_window_showing_on_its_workspace (window);
-      entries[i].demands_attention = window->wm_state_demands_attention;
-
-      if (show_type == META_TAB_SHOW_INSTANTLY ||
-          !entries[i].hidden                   ||
-          !meta_window_get_icon_geometry (window, &r))
-        meta_window_get_frame_rect (window, &r);
-
-      entries[i].rect = r;
-
-      /* Find inside of highlight rectangle to be used when window is
-       * outlined for tabbing.  This should be the size of the
-       * east/west frame, and the size of the south frame, on those
-       * sides.  On the top it should be the size of the south frame
-       * edge.
-       */
-#define OUTLINE_WIDTH 5
-      /* Top side */
-      if (!entries[i].hidden &&
-          window->frame && window->frame->bottom_height > 0 &&
-          window->frame->child_y >= window->frame->bottom_height)
-        entries[i].inner_rect.y = window->frame->bottom_height;
-      else
-        entries[i].inner_rect.y = OUTLINE_WIDTH;
-
-      /* Bottom side */
-      if (!entries[i].hidden &&
-          window->frame && window->frame->bottom_height != 0)
-        entries[i].inner_rect.height = r.height
-          - entries[i].inner_rect.y - window->frame->bottom_height;
-      else
-        entries[i].inner_rect.height = r.height
-          - entries[i].inner_rect.y - OUTLINE_WIDTH;
-
-      /* Left side */
-      if (!entries[i].hidden && window->frame && window->frame->child_x != 0)
-        entries[i].inner_rect.x = window->frame->child_x;
-      else
-        entries[i].inner_rect.x = OUTLINE_WIDTH;
-
-      /* Right side */
-      if (!entries[i].hidden &&
-          window->frame && window->frame->right_width != 0)
-        entries[i].inner_rect.width = r.width
-          - entries[i].inner_rect.x - window->frame->right_width;
-      else
-        entries[i].inner_rect.width = r.width
-          - entries[i].inner_rect.x - OUTLINE_WIDTH;
-
-      ++i;
-      tmp = tmp->next;
-    }
-
-  if (!meta_prefs_get_no_tab_popup ())
-    screen->tab_popup = meta_ui_tab_popup_new (entries,
-                                               screen->number,
-                                               len,
-                                               5, /* FIXME */
-                                               TRUE);
-
-  for (i = 0; i < len; i++)
-    g_object_unref (entries[i].icon);
-
-  g_free (entries);
-
-  g_list_free (tab_list);
-
-  meta_ui_tab_popup_select (screen->tab_popup,
-                            (MetaTabEntryKey) initial_selection);
-
-  if (show_type != META_TAB_SHOW_INSTANTLY)
-    meta_ui_tab_popup_set_showing (screen->tab_popup, TRUE);
-}
-
-void
-meta_screen_tab_popup_forward (MetaScreen *screen)
-{
-  g_return_if_fail (screen->tab_popup != NULL);
-
-  meta_ui_tab_popup_forward (screen->tab_popup);
-}
-
-void
-meta_screen_tab_popup_backward (MetaScreen *screen)
-{
-  g_return_if_fail (screen->tab_popup != NULL);
-
-  meta_ui_tab_popup_backward (screen->tab_popup);
-}
-
-MetaWindow *
-meta_screen_tab_popup_get_selected (MetaScreen *screen)
-{
-  g_return_val_if_fail (screen->tab_popup != NULL, NULL);
-
-  return (MetaWindow *) meta_ui_tab_popup_get_selected (screen->tab_popup);
-}
-
-void
-meta_screen_tab_popup_destroy (MetaScreen *screen)
-{
-  if (screen->tab_popup)
-    {
-      meta_ui_tab_popup_free (screen->tab_popup);
-      screen->tab_popup = NULL;
-    }
-}
-
-void
-meta_screen_workspace_popup_create (MetaScreen    *screen,
-                                    MetaWorkspace *initial_selection)
-{
-  MetaTabEntry *entries;
-  int len;
-  int i;
-  MetaWorkspaceLayout layout;
-  int n_workspaces;
-  int current_workspace;
-
-  if (screen->ws_popup || meta_prefs_get_no_tab_popup ())
-    return;
-
-  current_workspace = meta_workspace_index (screen->active_workspace);
-  n_workspaces = meta_screen_get_n_workspaces (screen);
-
-  meta_screen_calc_workspace_layout (screen, n_workspaces,
-                                     current_workspace, &layout);
-
-  len = layout.grid_area;
-  
-  entries = g_new (MetaTabEntry, len + 1);
-  entries[len].key = NULL;
-  entries[len].title = NULL;
-  entries[len].icon = NULL;
-
-  i = 0;
-  while (i < len)
-    {
-      if (layout.grid[i] >= 0)
-        {
-          MetaWorkspace *workspace;
-          
-          workspace = meta_screen_get_workspace_by_index (screen,
-                                                          layout.grid[i]);
-          
-          entries[i].key = (MetaTabEntryKey) workspace;
-          entries[i].title = meta_workspace_get_name (workspace);
-          entries[i].icon = NULL;
-          entries[i].blank = FALSE;
-          
-          g_assert (entries[i].title != NULL);
-        }
-      else
-        {
-          entries[i].key = NULL;
-          entries[i].title = NULL;
-          entries[i].icon = NULL;
-          entries[i].blank = TRUE;
-        }
-      entries[i].hidden = FALSE;
-      entries[i].demands_attention = FALSE;
-
-      ++i;
-    }
-
-  screen->ws_popup = meta_ui_tab_popup_new (entries,
-                                            screen->number,
-                                            len,
-                                            layout.cols,
-                                            FALSE);
-
-  g_free (entries);
-  meta_screen_free_workspace_layout (&layout);
-
-  meta_ui_tab_popup_select (screen->ws_popup,
-                            (MetaTabEntryKey) initial_selection);
-  meta_ui_tab_popup_set_showing (screen->ws_popup, TRUE);
-}
-
-void
-meta_screen_workspace_popup_select (MetaScreen    *screen,
-                                    MetaWorkspace *workspace)
-{
-  g_return_if_fail (screen->ws_popup != NULL);
-
-  meta_ui_tab_popup_select (screen->ws_popup,
-                            (MetaTabEntryKey) workspace);
-}
-
-MetaWorkspace *
-meta_screen_workspace_popup_get_selected (MetaScreen *screen)
-{
-  g_return_val_if_fail (screen->ws_popup != NULL, NULL);
-
-  return (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->ws_popup);
-}
-
-void
-meta_screen_workspace_popup_destroy (MetaScreen *screen)
-{
-  if (screen->ws_popup)
-    {
-      meta_ui_tab_popup_free (screen->ws_popup);
-      screen->ws_popup = NULL;
-    }
-}
-
 static gboolean
-meta_screen_tile_preview_update_timeout (gpointer data)
+meta_screen_update_tile_preview_timeout (gpointer data)
 {
   MetaScreen *screen = data;
   MetaWindow *window = screen->display->grab_window;
@@ -1688,22 +1437,6 @@ meta_screen_tile_preview_update_timeout (gpointer data)
 
   screen->tile_preview_timeout_id = 0;
 
-  if (!screen->tile_preview)
-    {
-      Window xwindow;
-      gulong create_serial;
-      MetaStackWindow stack_window;
-
-      screen->tile_preview = meta_tile_preview_new (screen->number);
-      xwindow = meta_tile_preview_get_xwindow (screen->tile_preview,
-                                               &create_serial);
-      stack_window.any.type = META_WINDOW_CLIENT_TYPE_X11;
-      stack_window.x11.xwindow = xwindow;
-      meta_stack_tracker_record_add (screen->stack_tracker,
-                                     &stack_window,
-                                     create_serial);
-    }
-
   if (window)
     {
       switch (window->tile_mode)
@@ -1728,12 +1461,16 @@ meta_screen_tile_preview_update_timeout (gpointer data)
   if (needs_preview)
     {
       MetaRectangle tile_rect;
+      int monitor;
 
+      monitor = meta_window_get_current_tile_monitor_number (window);
       meta_window_get_current_tile_area (window, &tile_rect);
-      meta_tile_preview_show (screen->tile_preview, &tile_rect);
+      meta_compositor_show_tile_preview (screen->display->compositor,
+                                         screen, window, &tile_rect, monitor);
     }
   else
-    meta_tile_preview_hide (screen->tile_preview);
+    meta_compositor_hide_tile_preview (screen->display->compositor,
+                                       screen);
 
   return FALSE;
 }
@@ -1741,7 +1478,7 @@ meta_screen_tile_preview_update_timeout (gpointer data)
 #define TILE_PREVIEW_TIMEOUT_MS 200
 
 void
-meta_screen_tile_preview_update (MetaScreen *screen,
+meta_screen_update_tile_preview (MetaScreen *screen,
                                  gboolean    delay)
 {
   if (delay)
@@ -1751,7 +1488,7 @@ meta_screen_tile_preview_update (MetaScreen *screen,
 
       screen->tile_preview_timeout_id =
         g_timeout_add (TILE_PREVIEW_TIMEOUT_MS,
-                       meta_screen_tile_preview_update_timeout,
+                       meta_screen_update_tile_preview_timeout,
                        screen);
     }
   else
@@ -1759,18 +1496,18 @@ meta_screen_tile_preview_update (MetaScreen *screen,
       if (screen->tile_preview_timeout_id > 0)
         g_source_remove (screen->tile_preview_timeout_id);
 
-      meta_screen_tile_preview_update_timeout ((gpointer)screen);
+      meta_screen_update_tile_preview_timeout ((gpointer)screen);
     }
 }
 
 void
-meta_screen_tile_preview_hide (MetaScreen *screen)
+meta_screen_hide_tile_preview (MetaScreen *screen)
 {
   if (screen->tile_preview_timeout_id > 0)
     g_source_remove (screen->tile_preview_timeout_id);
 
-  if (screen->tile_preview)
-    meta_tile_preview_hide (screen->tile_preview);
+  meta_compositor_hide_tile_preview (screen->display->compositor,
+                                     screen);
 }
 
 MetaWindow*
@@ -1778,38 +1515,19 @@ meta_screen_get_mouse_window (MetaScreen  *screen,
                               MetaWindow  *not_this_one)
 {
   MetaWindow *window;
-  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;
+  int x, y;
 
   if (not_this_one)
     meta_topic (META_DEBUG_FOCUS,
                 "Focusing mouse window excluding %s\n", not_this_one->desc);
 
-  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);
+  meta_cursor_tracker_get_pointer (screen->cursor_tracker,
+                                   &x, &y, NULL);
 
   window = meta_stack_get_default_focus_window_at_point (screen->stack,
                                                          screen->active_workspace,
                                                          not_this_one,
-                                                         root_x_return,
-                                                         root_y_return);
+                                                         x, y);
 
   return window;
 }
@@ -2091,28 +1809,11 @@ meta_screen_get_current_monitor (MetaScreen *screen)
   
   if (screen->display->monitor_cache_invalidated)
     {
-      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;
+      int 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);
+      meta_cursor_tracker_get_pointer (screen->cursor_tracker,
+                                       &x, &y, NULL);
+      meta_screen_get_current_monitor_for_pos (screen, x, y);
     }
 
   return screen->last_monitor_index;

src/core/stack-tracker.c

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

src/core/window-private.h

@@ -238,7 +238,7 @@ struct _MetaWindow
   /* These are the flags from WM_PROTOCOLS */
   guint take_focus : 1;
   guint delete_window : 1;
-  guint net_wm_ping : 1;
+  guint can_ping : 1;
   /* Globally active / No input */
   guint input : 1;
   
@@ -628,11 +628,7 @@ void     meta_window_set_current_workspace_hint (MetaWindow *window);
 
 unsigned long meta_window_get_net_wm_desktop (MetaWindow *window);
 
-void meta_window_show_menu (MetaWindow *window,
-                            int         root_x,
-                            int         root_y,
-                            int         button,
-                            guint32     timestamp);
+void meta_window_show_menu (MetaWindow *window);
 
 gboolean meta_window_titlebar_is_onscreen    (MetaWindow *window);
 void     meta_window_shove_titlebar_onscreen (MetaWindow *window);
@@ -652,6 +648,7 @@ void meta_window_handle_mouse_grab_op_xevent (MetaWindow         *window,
 
 GList* meta_window_get_workspaces (MetaWindow *window);
 
+int meta_window_get_current_tile_monitor_number (MetaWindow *window);
 void meta_window_get_current_tile_area         (MetaWindow    *window,
                                                 MetaRectangle *tile_area);
 
@@ -683,9 +680,8 @@ void meta_window_update_layer (MetaWindow *window);
 
 void meta_window_recalc_features    (MetaWindow *window);
 
-/* 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_set_type (MetaWindow     *window,
+                           MetaWindowType  type);
 
 void meta_window_frame_size_changed (MetaWindow *window);
 
@@ -742,9 +738,14 @@ void meta_window_set_surface_mapped (MetaWindow *window,
 
 Window meta_window_get_toplevel_xwindow (MetaWindow *window);
 
+void meta_window_get_client_area_rect (const MetaWindow      *window,
+                                       cairo_rectangle_int_t *rect);
+
 void meta_window_activate_full (MetaWindow     *window,
                                 guint32         timestamp,
                                 MetaClientType  source_indication,
                                 MetaWorkspace  *workspace);
 
+gboolean meta_window_is_client_decorated (MetaWindow *window);
+
 #endif

src/core/window-props.c

@@ -35,7 +35,7 @@
  */
 
 #define _GNU_SOURCE
-#define _SVID_SOURCE /* for gethostname() */
+#define _XOPEN_SOURCE 500 /* for gethostname() */
 
 #include <config.h>
 #include "window-props.h"
@@ -727,7 +727,7 @@ reload_net_wm_state (MetaWindow    *window,
   meta_verbose ("Reloaded _NET_WM_STATE for %s\n",
                 window->desc);
 
-  meta_window_recalc_window_type (window);
+  meta_window_x11_recalc_window_type (window);
   meta_window_recalc_features (window);
 }
 
@@ -1407,7 +1407,7 @@ reload_wm_protocols (MetaWindow    *window,
   
   window->take_focus = FALSE;
   window->delete_window = FALSE;
-  window->net_wm_ping = FALSE;
+  window->can_ping = FALSE;
   
   if (value->type == META_PROP_VALUE_INVALID)    
     return;
@@ -1423,7 +1423,7 @@ reload_wm_protocols (MetaWindow    *window,
         window->delete_window = TRUE;
       else if (value->v.atom_list.atoms[i] ==
                window->display->atom__NET_WM_PING)
-        window->net_wm_ping = TRUE;
+        window->can_ping = TRUE;
       ++i;
     }
   

src/core/window-x11.c

@@ -38,6 +38,7 @@
 #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"
@@ -225,7 +226,7 @@ meta_window_x11_update_net_wm_type (MetaWindow *window)
         meta_XFree (str);
     }
 
-  meta_window_recalc_window_type (window);
+  meta_window_x11_recalc_window_type (window);
 }
 
 void
@@ -350,11 +351,43 @@ meta_window_set_input_region (MetaWindow     *window,
     meta_compositor_window_shape_changed (window->display->compositor, window);
 }
 
+#if 0
+/* Print out a region; useful for debugging */
+static void
+print_region (cairo_region_t *region)
+{
+  int n_rects;
+  int i;
+
+  n_rects = cairo_region_num_rectangles (region);
+  g_print ("[");
+  for (i = 0; i < n_rects; i++)
+    {
+      cairo_rectangle_int_t rect;
+      cairo_region_get_rectangle (region, i, &rect);
+      g_print ("+%d+%dx%dx%d ",
+               rect.x, rect.y, rect.width, rect.height);
+    }
+  g_print ("]\n");
+}
+#endif
+
 void
 meta_window_x11_update_input_region (MetaWindow *window)
 {
   cairo_region_t *region = NULL;
 
+  /* Decorated windows don't have an input region, because
+     we don't shape the frame to match the client windows
+     (so the events are blocked by the frame anyway)
+  */
+  if (window->decorated)
+    {
+      if (window->input_region)
+        meta_window_set_input_region (window, NULL);
+      return;
+    }
+
 #ifdef HAVE_SHAPE
   if (META_DISPLAY_HAS_SHAPE (window->display))
     {
@@ -363,17 +396,7 @@ meta_window_x11_update_input_region (MetaWindow *window)
       XRectangle *rects = NULL;
       int n_rects, ordering;
 
-      int x_bounding, y_bounding, x_clip, y_clip;
-      unsigned w_bounding, h_bounding, w_clip, h_clip;
-      int bounding_shaped, clip_shaped;
-
       meta_error_trap_push (window->display);
-      XShapeQueryExtents (window->display->xdisplay, window->xwindow,
-                          &bounding_shaped, &x_bounding, &y_bounding,
-                          &w_bounding, &h_bounding,
-                          &clip_shaped, &x_clip, &y_clip,
-                          &w_clip, &h_clip);
-
       rects = XShapeGetRectangles (window->display->xdisplay,
                                    window->xwindow,
                                    ShapeInput,
@@ -388,10 +411,10 @@ meta_window_x11_update_input_region (MetaWindow *window)
         {
           if (n_rects > 1 ||
               (n_rects == 1 &&
-               (rects[0].x != x_bounding ||
-                rects[0].y != y_bounding ||
-                rects[0].width != w_bounding ||
-                rects[0].height != h_bounding)))
+               (rects[0].x != 0 ||
+                rects[0].y != 0 ||
+                rects[0].width != window->rect.width ||
+                rects[0].height != window->rect.height)))
             region = region_create_from_x_rectangles (rects, n_rects);
 
           XFree (rects);
@@ -651,35 +674,19 @@ meta_window_x11_property_notify (MetaWindow *window,
 static int
 query_pressed_buttons (MetaWindow *window)
 {
-  double x, y, query_root_x, query_root_y;
-  Window root, child;
-  XIButtonState buttons;
-  XIModifierState mods;
-  XIGroupState group;
+  ClutterModifierType mods;
   int button = 0;
 
-  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);
+  meta_cursor_tracker_get_pointer (window->screen->cursor_tracker,
+                                   NULL, NULL, &mods);
 
-  if (meta_error_trap_pop_with_return (window->display) != Success)
-    goto out;
-
-  if (XIMaskIsSet (buttons.mask, Button1))
+  if (mods & CLUTTER_BUTTON1_MASK)
     button |= 1 << 1;
-  if (XIMaskIsSet (buttons.mask, Button2))
+  if (mods & CLUTTER_BUTTON2_MASK)
     button |= 1 << 2;
-  if (XIMaskIsSet (buttons.mask, Button3))
+  if (mods & CLUTTER_BUTTON3_MASK)
     button |= 1 << 3;
 
-  free (buttons.mask);
-
- out:
   return button;
 }
 
@@ -865,7 +872,7 @@ meta_window_x11_client_message (MetaWindow *window,
             (action == _NET_WM_STATE_ADD) ||
             (action == _NET_WM_STATE_TOGGLE && !window->wm_state_modal);
 
-          meta_window_recalc_window_type (window);
+          meta_window_x11_recalc_window_type (window);
           meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
         }
 
@@ -1158,6 +1165,11 @@ meta_window_x11_client_message (MetaWindow *window,
 
       meta_window_update_fullscreen_monitors (window, top, bottom, left, right);
     }
+  else if (event->xclient.message_type ==
+           display->atom__GTK_SHOW_WINDOW_MENU)
+    {
+      meta_window_show_menu (window);
+    }
 
   return FALSE;
 }
@@ -1453,6 +1465,11 @@ meta_window_x11_new (MetaDisplay       *display,
     XISelectEvents (display->xdisplay, xwindow, &mask, 1);
   }
 
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display))
+    XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
+#endif
+
   /* Get rid of any borders */
   if (attrs.border_width != 0)
     XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
@@ -1485,14 +1502,7 @@ meta_window_x11_new (MetaDisplay       *display,
                                     existing_wm_state,
                                     effect,
                                     &attrs);
-
-  /* When running as an X compositor, we can simply show the window now.
-   *
-   * When running as a Wayland compositor, we need to wait until we see
-   * the Wayland surface appear. We will later call meta_window_set_surface_mapped()
-   * to show the window in our in our set_surface_id implementation */
-  if (!meta_is_wayland_compositor ())
-    meta_window_set_surface_mapped (window, TRUE);
+  meta_window_set_surface_mapped (window, TRUE);
 
   meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
   return window;
@@ -1501,3 +1511,114 @@ 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);
+}

src/core/window-x11.h

@@ -35,6 +35,8 @@ 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,

src/core/window.c

@@ -874,7 +874,7 @@ _meta_window_shared_new (MetaDisplay         *display,
   window->user_time_window = None;
   window->take_focus = FALSE;
   window->delete_window = FALSE;
-  window->net_wm_ping = FALSE;
+  window->can_ping = FALSE;
   window->input = TRUE;
   window->calc_placement = FALSE;
   window->shaken_loose = FALSE;
@@ -993,6 +993,9 @@ _meta_window_shared_new (MetaDisplay         *display,
       client_type == META_WINDOW_CLIENT_TYPE_X11)
     update_sm_hints (window); /* must come after transient_for */
 
+  if (client_type == META_WINDOW_CLIENT_TYPE_X11)
+    meta_window_x11_update_net_wm_type (window);
+
   if (!window->override_redirect)
     meta_window_update_icon_now (window);
 
@@ -1177,9 +1180,6 @@ _meta_window_shared_new (MetaDisplay         *display,
   if (!window->override_redirect)
     meta_stack_add (window->screen->stack,
                     window);
-  else if (window->screen->tile_preview != NULL &&
-           meta_tile_preview_get_xwindow (window->screen->tile_preview, NULL) == xwindow)
-    window->layer = META_LAYER_NORMAL;
   else
     window->layer = META_LAYER_OVERRIDE_REDIRECT; /* otherwise set by MetaStack */
 
@@ -1220,6 +1220,9 @@ _meta_window_shared_new (MetaDisplay         *display,
       set_net_wm_state (window);
     }
 
+  if (screen->display->compositor)
+    meta_compositor_add_window (screen->display->compositor, window);
+
   /* Sync stack changes */
   meta_stack_thaw (window->screen->stack);
 
@@ -1320,6 +1323,7 @@ meta_window_wayland_new (MetaDisplay        *display,
                                     WithdrawnState,
                                     META_COMP_EFFECT_CREATE,
                                     &attrs);
+  window->can_ping = TRUE;
 
   meta_error_trap_pop (display); /* pop the XSync()-reducing trap */
 
@@ -1364,9 +1368,7 @@ meta_window_apply_session_info (MetaWindow *window,
 
       if (window->has_maximize_func && info->maximized)
         {
-          meta_window_maximize (window,
-                                META_MAXIMIZE_HORIZONTAL |
-                                META_MAXIMIZE_VERTICAL);
+          meta_window_maximize (window, META_MAXIMIZE_BOTH);
 
           if (info->saved_rect_set)
             {
@@ -1520,13 +1522,6 @@ meta_window_unmanage (MetaWindow  *window,
       meta_compositor_remove_window (window->display->compositor, window);
     }
 
-  if (window->display->window_with_menu == window)
-    {
-      meta_ui_window_menu_free (window->display->window_menu);
-      window->display->window_menu = NULL;
-      window->display->window_with_menu = NULL;
-    }
-
   if (destroying_windows_disallowed > 0)
     meta_bug ("Tried to destroy window %s while destruction was not allowed\n",
               window->desc);
@@ -2771,8 +2766,8 @@ meta_window_show (MetaWindow *window)
               break;
             }
 
-          meta_compositor_add_window (window->display->compositor, window);
-          meta_compositor_show_window (window->display->compositor, window, effect);
+          meta_compositor_show_window (window->display->compositor,
+                                       window, effect);
         }
     }
 
@@ -3366,12 +3361,12 @@ meta_window_tile (MetaWindow *window)
     return;
 
   if (window->tile_mode == META_TILE_MAXIMIZED)
-    directions = META_MAXIMIZE_VERTICAL | META_MAXIMIZE_HORIZONTAL;
+    directions = META_MAXIMIZE_BOTH;
   else
     directions = META_MAXIMIZE_VERTICAL;
 
   meta_window_maximize_internal (window, directions, NULL);
-  meta_screen_tile_preview_update (window->screen, FALSE);
+  meta_screen_update_tile_preview (window->screen, FALSE);
 
   if (window->display->compositor)
     {
@@ -5090,6 +5085,7 @@ meta_window_move_resize_wayland (MetaWindow *window,
 
   meta_window_move_resize_internal (window, flags, NorthWestGravity,
                                     x, y, width, height);
+  save_user_window_placement (window);
 }
 
 /**
@@ -5659,6 +5655,37 @@ meta_window_get_outer_rect (const MetaWindow *window,
   meta_window_get_frame_rect (window, rect);
 }
 
+/**
+ * meta_window_get_client_area_rect:
+ * @window: a #MetaWindow
+ * @rect: (out): pointer to a cairo rectangle
+ *
+ * Gets the rectangle for the boundaries of the client area, relative
+ * to the frame. If the window is shaded, the height of the rectangle
+ * is 0.
+ */
+void
+meta_window_get_client_area_rect (const MetaWindow      *window,
+                                  cairo_rectangle_int_t *rect)
+{
+  if (window->frame)
+    {
+      rect->x = window->frame->child_x;
+      rect->y = window->frame->child_y;
+    }
+  else
+    {
+      rect->x = 0;
+      rect->y = 0;
+    }
+
+  rect->width = window->rect.width;
+  if (window->shaded)
+    rect->height = 0;
+  else
+    rect->height = window->rect.height;
+}
+
 const char*
 meta_window_get_startup_id (MetaWindow *window)
 {
@@ -6371,6 +6398,14 @@ meta_window_appears_focused_changed (MetaWindow *window)
 
   if (window->frame)
     meta_frame_queue_draw (window->frame);
+
+  if (window->surface)
+    {
+      if (meta_window_appears_focused (window))
+        meta_wayland_surface_activated (window->surface);
+      else
+        meta_wayland_surface_deactivated (window->surface);
+    }
 }
 
 /**
@@ -7020,122 +7055,7 @@ meta_window_update_struts (MetaWindow *window)
     }
 }
 
-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
+static void
 meta_window_type_changed (MetaWindow *window)
 {
   gboolean old_decorated = window->decorated;
@@ -7168,6 +7088,17 @@ 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)
 {
@@ -7480,272 +7411,11 @@ meta_window_recalc_features (MetaWindow *window)
    */
 }
 
-static void
-menu_callback (MetaWindowMenu *menu,
-               Display        *xdisplay,
-               Window          client_xwindow,
-               guint32         timestamp,
-               MetaMenuOp      op,
-               int             workspace_index,
-               gpointer        data)
-{
-  MetaDisplay *display;
-  MetaWindow *window;
-  MetaWorkspace *workspace;
-
-  display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, client_xwindow);
-  workspace = NULL;
-
-  if (window != NULL) /* window can be NULL */
-    {
-      meta_verbose ("Menu op %u on %s\n", op, window->desc);
-
-      switch (op)
-        {
-        case META_MENU_OP_NONE:
-          /* nothing */
-          break;
-
-        case META_MENU_OP_DELETE:
-          meta_window_delete (window, timestamp);
-          break;
-
-        case META_MENU_OP_MINIMIZE:
-          meta_window_minimize (window);
-          break;
-
-        case META_MENU_OP_UNMAXIMIZE:
-          meta_window_unmaximize (window,
-                                  META_MAXIMIZE_HORIZONTAL |
-                                  META_MAXIMIZE_VERTICAL);
-          break;
-
-        case META_MENU_OP_MAXIMIZE:
-          meta_window_maximize (window,
-                                META_MAXIMIZE_HORIZONTAL |
-                                META_MAXIMIZE_VERTICAL);
-          break;
-
-        case META_MENU_OP_UNSHADE:
-          meta_window_unshade (window, timestamp);
-          break;
-
-        case META_MENU_OP_SHADE:
-          meta_window_shade (window, timestamp);
-          break;
-
-        case META_MENU_OP_MOVE_LEFT:
-          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
-                                                   META_MOTION_LEFT);
-          break;
-
-        case META_MENU_OP_MOVE_RIGHT:
-          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
-                                                   META_MOTION_RIGHT);
-          break;
-
-        case META_MENU_OP_MOVE_UP:
-          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
-                                                   META_MOTION_UP);
-          break;
-
-        case META_MENU_OP_MOVE_DOWN:
-          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
-                                                   META_MOTION_DOWN);
-          break;
-
-        case META_MENU_OP_WORKSPACES:
-          workspace = meta_screen_get_workspace_by_index (window->screen,
-                                                          workspace_index);
-          break;
-
-        case META_MENU_OP_STICK:
-          meta_window_stick (window);
-          break;
-
-        case META_MENU_OP_UNSTICK:
-          meta_window_unstick (window);
-          break;
-
-        case META_MENU_OP_ABOVE:
-        case META_MENU_OP_UNABOVE:
-          if (window->wm_state_above == FALSE)
-            meta_window_make_above (window);
-          else
-            meta_window_unmake_above (window);
-          break;
-
-        case META_MENU_OP_MOVE:
-          meta_window_begin_grab_op (window,
-                                     META_GRAB_OP_KEYBOARD_MOVING,
-                                     TRUE,
-                                     timestamp);
-          break;
-
-        case META_MENU_OP_RESIZE:
-          meta_window_begin_grab_op (window,
-                                     META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
-                                     TRUE,
-                                     timestamp);
-          break;
-
-        case META_MENU_OP_RECOVER:
-          meta_window_shove_titlebar_onscreen (window);
-          break;
-
-        default:
-          meta_warning (G_STRLOC": Unknown window op\n");
-          break;
-        }
-
-      if (workspace)
-	{
-	  meta_window_change_workspace (window,
-					workspace);
-	}
-    }
-  else
-    {
-      meta_verbose ("Menu callback on nonexistent window\n");
-    }
-
-  if (display->window_menu == menu)
-    {
-      display->window_menu = NULL;
-      display->window_with_menu = NULL;
-    }
-
-  meta_ui_window_menu_free (menu);
-}
-
 void
-meta_window_show_menu (MetaWindow *window,
-                       int         root_x,
-                       int         root_y,
-                       int         button,
-                       guint32     timestamp)
+meta_window_show_menu (MetaWindow *window)
 {
-  MetaMenuOp ops;
-  MetaMenuOp insensitive;
-  MetaWindowMenu *menu;
-  MetaWorkspaceLayout layout;
-  int n_workspaces;
-  gboolean ltr;
-
   g_return_if_fail (!window->override_redirect);
-
-  if (window->display->window_menu)
-    {
-      meta_ui_window_menu_free (window->display->window_menu);
-      window->display->window_menu = NULL;
-      window->display->window_with_menu = NULL;
-    }
-
-  ops = META_MENU_OP_NONE;
-  insensitive = META_MENU_OP_NONE;
-
-  ops |= (META_MENU_OP_DELETE | META_MENU_OP_MINIMIZE | META_MENU_OP_MOVE | META_MENU_OP_RESIZE);
-
-  if (!meta_window_titlebar_is_onscreen (window) &&
-      window->type != META_WINDOW_DOCK &&
-      window->type != META_WINDOW_DESKTOP)
-    ops |= META_MENU_OP_RECOVER;
-
-  if (!meta_prefs_get_workspaces_only_on_primary () ||
-      meta_window_is_on_primary_monitor (window))
-    {
-      n_workspaces = meta_screen_get_n_workspaces (window->screen);
-
-      if (n_workspaces > 1)
-        ops |= META_MENU_OP_WORKSPACES;
-
-      meta_screen_calc_workspace_layout (window->screen,
-                                         n_workspaces,
-                                         meta_workspace_index ( window->screen->active_workspace),
-                                         &layout);
-
-      if (!window->on_all_workspaces)
-        {
-          ltr = meta_ui_get_direction() == META_UI_DIRECTION_LTR;
-
-          if (layout.current_col > 0)
-            ops |= ltr ? META_MENU_OP_MOVE_LEFT : META_MENU_OP_MOVE_RIGHT;
-          if ((layout.current_col < layout.cols - 1) &&
-              (layout.current_row * layout.cols + (layout.current_col + 1) < n_workspaces))
-            ops |= ltr ? META_MENU_OP_MOVE_RIGHT : META_MENU_OP_MOVE_LEFT;
-          if (layout.current_row > 0)
-            ops |= META_MENU_OP_MOVE_UP;
-          if ((layout.current_row < layout.rows - 1) &&
-              ((layout.current_row + 1) * layout.cols + layout.current_col < n_workspaces))
-            ops |= META_MENU_OP_MOVE_DOWN;
-        }
-
-      meta_screen_free_workspace_layout (&layout);
-
-      ops |= META_MENU_OP_UNSTICK;
-      ops |= META_MENU_OP_STICK;
-    }
-
-  if (META_WINDOW_MAXIMIZED (window))
-    ops |= META_MENU_OP_UNMAXIMIZE;
-  else
-    ops |= META_MENU_OP_MAXIMIZE;
-
-  if (window->wm_state_above)
-    ops |= META_MENU_OP_UNABOVE;
-  else
-    ops |= META_MENU_OP_ABOVE;
-
-  if (!window->has_maximize_func)
-    insensitive |= META_MENU_OP_UNMAXIMIZE | META_MENU_OP_MAXIMIZE;
-
-  if (!window->has_minimize_func)
-    insensitive |= META_MENU_OP_MINIMIZE;
-
-  if (!window->has_close_func)
-    insensitive |= META_MENU_OP_DELETE;
-
-  if (!window->has_shade_func)
-    insensitive |= META_MENU_OP_SHADE | META_MENU_OP_UNSHADE;
-
-  if (!META_WINDOW_ALLOWS_MOVE (window))
-    insensitive |= META_MENU_OP_MOVE;
-
-  if (!META_WINDOW_ALLOWS_RESIZE (window))
-    insensitive |= META_MENU_OP_RESIZE;
-
-   if (window->always_sticky)
-     insensitive |= META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES;
-
-  if ((window->type == META_WINDOW_DESKTOP) ||
-      (window->type == META_WINDOW_DOCK) ||
-      (window->type == META_WINDOW_SPLASHSCREEN ||
-      META_WINDOW_MAXIMIZED (window)))
-    insensitive |= META_MENU_OP_ABOVE | META_MENU_OP_UNABOVE;
-
-  /* If all operations are disabled, just quit without showing the menu.
-   * This is the case, for example, with META_WINDOW_DESKTOP windows.
-   */
-  if ((ops & ~insensitive) == 0)
-    return;
-
-  menu =
-    meta_ui_window_menu_new (window->screen->ui,
-                             window->xwindow,
-                             ops,
-                             insensitive,
-                             meta_window_get_net_wm_desktop (window),
-                             meta_screen_get_n_workspaces (window->screen),
-                             menu_callback,
-                             NULL);
-
-  window->display->window_menu = menu;
-  window->display->window_with_menu = window;
-
-  meta_verbose ("Popping up window menu for %s\n", window->desc);
-
-  meta_ui_window_menu_popup (menu, root_x, root_y, button, timestamp);
+  meta_compositor_show_window_menu (window->display->compositor, window);
 }
 
 void
@@ -7809,7 +7479,7 @@ meta_window_titlebar_is_onscreen (MetaWindow *window)
 
   /* Titlebar can't be offscreen if there is no titlebar... */
   if (!window->frame)
-    return FALSE;
+    return TRUE;
 
   /* Get the rectangle corresponding to the titlebar */
   meta_window_get_frame_rect (window, &titlebar_rect);
@@ -8041,10 +7711,7 @@ update_move (MetaWindow  *window,
       display->grab_anchor_root_x = x;
       display->grab_anchor_root_y = y;
 
-      meta_window_unmaximize (window,
-                              META_MAXIMIZE_HORIZONTAL |
-                              META_MAXIMIZE_VERTICAL);
-
+      meta_window_unmaximize (window, META_MAXIMIZE_BOTH);
       return;
     }
 
@@ -8088,9 +7755,7 @@ update_move (MetaWindow  *window,
                   window->user_rect.x = window->saved_rect.x;
                   window->user_rect.y = window->saved_rect.y;
 
-                  meta_window_unmaximize (window,
-                                          META_MAXIMIZE_HORIZONTAL |
-                                          META_MAXIMIZE_VERTICAL);
+                  meta_window_unmaximize (window, META_MAXIMIZE_BOTH);
                 }
 
               display->grab_initial_window_pos = work_area;
@@ -8098,10 +7763,7 @@ update_move (MetaWindow  *window,
               display->grab_anchor_root_y = y;
               window->shaken_loose = FALSE;
 
-              meta_window_maximize (window,
-                                    META_MAXIMIZE_HORIZONTAL |
-                                    META_MAXIMIZE_VERTICAL);
-
+              meta_window_maximize (window, META_MAXIMIZE_BOTH);
               return;
             }
         }
@@ -8111,7 +7773,7 @@ update_move (MetaWindow  *window,
    * trigger it unwittingly, e.g. when shaking loose the window or moving
    * it to another monitor.
    */
-  meta_screen_tile_preview_update (window->screen,
+  meta_screen_update_tile_preview (window->screen,
                                    window->tile_mode != META_TILE_NONE);
 
   meta_window_get_client_root_coords (window, &old);
@@ -8490,98 +8152,6 @@ update_resize (MetaWindow *window,
     g_get_current_time (&window->display->grab_last_moveresize_time);
 }
 
-typedef struct
-{
-  Window  window;
-  int     count;
-  guint32 last_time;
-} EventScannerData;
-
-static Bool
-find_last_time_predicate (Display  *display,
-                          XEvent   *ev,
-                          XPointer  arg)
-{
-  EventScannerData *esd = (void*) arg;
-  XIEvent *xev;
-
-  if (ev->type != GenericEvent)
-    return False;
-
-  /* We are peeking into events not yet handled by GDK,
-   * Allocate cookie events here so we can handle XI2.
-   *
-   * GDK will handle later these events, and eventually
-   * free the cookie data itself.
-   */
-  XGetEventData (display, &ev->xcookie);
-  xev = (XIEvent *) ev->xcookie.data;
-
-  if (xev->evtype != XI_Motion)
-    return False;
-
-  if (esd->window != ((XIDeviceEvent *) xev)->event)
-    return False;
-
-  esd->count += 1;
-  esd->last_time = xev->time;
-
-  return False;
-}
-
-static gboolean
-check_use_this_motion_notify (MetaWindow *window,
-                              XIDeviceEvent *xev)
-{
-  EventScannerData esd;
-  XEvent useless;
-
-  /* This code is copied from Owen's GDK code. */
-
-  if (window->display->grab_motion_notify_time != 0)
-    {
-      /* == is really the right test, but I'm all for paranoia */
-      if (window->display->grab_motion_notify_time <=
-          xev->time)
-        {
-          meta_topic (META_DEBUG_RESIZING,
-                      "Arrived at event with time %u (waiting for %u), using it\n",
-                      (unsigned int)xev->time,
-                      window->display->grab_motion_notify_time);
-          window->display->grab_motion_notify_time = 0;
-          return TRUE;
-        }
-      else
-        return FALSE; /* haven't reached the saved timestamp yet */
-    }
-
-  esd.window = xev->event;
-  esd.count = 0;
-  esd.last_time = 0;
-
-  /* "useless" isn't filled in because the predicate never returns True */
-  XCheckIfEvent (window->display->xdisplay,
-                 &useless,
-                 find_last_time_predicate,
-                 (XPointer) &esd);
-
-  if (esd.count > 0)
-    meta_topic (META_DEBUG_RESIZING,
-                "Will skip %d motion events and use the event with time %u\n",
-                esd.count, (unsigned int) esd.last_time);
-
-  if (esd.last_time == 0)
-    return TRUE;
-  else
-    {
-      /* Save this timestamp, and ignore all motion notify
-       * until we get to the one with this stamp.
-       */
-      window->display->grab_motion_notify_time = esd.last_time;
-      return FALSE;
-    }
-}
-
 static void
 update_tile_mode (MetaWindow *window)
 {
@@ -8652,96 +8222,6 @@ meta_window_update_sync_request_counter (MetaWindow *window,
 }
 #endif /* HAVE_XSYNC */
 
-void
-meta_window_handle_mouse_grab_op_xevent (MetaWindow         *window,
-                                         XIDeviceEvent      *xevent)
-{
-  gboolean is_window_root = (xevent->root == window->screen->xroot);
-
-  switch (xevent->evtype)
-    {
-    case XI_ButtonRelease:
-      if (xevent->detail == 1 ||
-          xevent->detail == meta_prefs_get_mouse_button_resize ())
-        {
-          meta_display_check_threshold_reached (window->display,
-                                                xevent->root_x,
-                                                xevent->root_y);
-          /* If the user was snap moving then ignore the button
-           * release because they may have let go of shift before
-           * releasing the mouse button and they almost certainly do
-           * not want a non-snapped movement to occur from the button
-           * release.
-           */
-          if (!window->display->grab_last_user_action_was_snap)
-            {
-              if (meta_grab_op_is_moving (window->display->grab_op))
-                {
-                  if (window->tile_mode != META_TILE_NONE)
-                    meta_window_tile (window);
-                  else if (is_window_root)
-                    update_move (window,
-                                 xevent->mods.effective & ShiftMask,
-                                 xevent->root_x,
-                                 xevent->root_y);
-                }
-              else if (meta_grab_op_is_resizing (window->display->grab_op))
-                {
-                  if (is_window_root)
-                    update_resize (window,
-                                   xevent->mods.effective & ShiftMask,
-                                   xevent->root_x,
-                                   xevent->root_y,
-                                   TRUE);
-
-                  /* If a tiled window has been dragged free with a
-                   * mouse resize without snapping back to the tiled
-                   * state, it will end up with an inconsistent tile
-                   * mode on mouse release; cleaning the mode earlier
-                   * would break the ability to snap back to the tiled
-                   * state, so we wait until mouse release.
-                   */
-                  update_tile_mode (window);
-                }
-              meta_display_end_grab_op (window->display, xevent->time);
-            }
-        }
-      break;
-
-    case XI_Motion:
-      meta_display_check_threshold_reached (window->display,
-                                            xevent->root_x,
-                                            xevent->root_y);
-      if (meta_grab_op_is_moving (window->display->grab_op))
-        {
-          if (is_window_root)
-            {
-              if (check_use_this_motion_notify (window, xevent))
-                update_move (window,
-                             xevent->mods.effective & ShiftMask,
-                             xevent->root_x,
-                             xevent->root_y);
-            }
-        }
-      else if (meta_grab_op_is_resizing (window->display->grab_op))
-        {
-          if (is_window_root)
-            {
-              if (check_use_this_motion_notify (window, xevent))
-                update_resize (window,
-                               xevent->mods.effective & ShiftMask,
-                               xevent->root_x,
-                               xevent->root_y,
-                               FALSE);
-            }
-        }
-      break;
-
-    default:
-      break;
-    }
-}
-
 void
 meta_window_handle_mouse_grab_op_event  (MetaWindow         *window,
                                          const ClutterEvent *event)
@@ -8959,6 +8439,20 @@ meta_window_get_work_area_all_monitors (MetaWindow    *window,
               window->desc, area->x, area->y, area->width, area->height);
 }
 
+int
+meta_window_get_current_tile_monitor_number (MetaWindow *window)
+{
+  int tile_monitor_number = window->tile_monitor_number;
+
+  if (tile_monitor_number < 0)
+    {
+      meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC);
+      tile_monitor_number = 0;
+    }
+
+  return tile_monitor_number;
+}
+
 void
 meta_window_get_current_tile_area (MetaWindow    *window,
                                    MetaRectangle *tile_area)
@@ -8967,12 +8461,7 @@ meta_window_get_current_tile_area (MetaWindow    *window,
 
   g_return_if_fail (window->tile_mode != META_TILE_NONE);
 
-  tile_monitor_number = window->tile_monitor_number;
-  if (tile_monitor_number < 0)
-    {
-      meta_warning ("%s called with an invalid monitor number; using 0 instead\n", G_STRFUNC);
-      tile_monitor_number = 0;
-    }
+  tile_monitor_number = meta_window_get_current_tile_monitor_number (window);
 
   meta_window_get_work_area_for_monitor (window, tile_monitor_number, tile_area);
 
@@ -8997,6 +8486,34 @@ 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)
 {
@@ -10270,12 +9787,6 @@ meta_window_compute_tile_match (MetaWindow *window)
     }
 }
 
-gboolean
-meta_window_can_close (MetaWindow *window)
-{
-  return window->has_close_func;
-}
-
 void
 meta_window_set_title (MetaWindow *window,
                        const char *title)
@@ -10359,7 +9870,8 @@ meta_window_set_transient_for (MetaWindow *window,
     meta_window_propagate_focus_appearance (window, FALSE);
 
   /* may now be a dialog */
-  meta_window_recalc_window_type (window);
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    meta_window_x11_recalc_window_type (window);
 
   if (!window->constructing)
     {
@@ -10485,25 +9997,15 @@ window_focus_on_pointer_rest_callback (gpointer data)
   MetaWindow *window = focus_data->window;
   MetaDisplay *display = window->display;
   MetaScreen *screen = window->screen;
-  Window root, child;
-  double root_x, root_y, x, y;
+  int root_x, root_y;
   guint32 timestamp;
-  XIButtonState buttons;
-  XIModifierState mods;
-  XIGroupState group;
+  ClutterActor *child;
 
   if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK)
     goto out;
 
-  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);
+  meta_cursor_tracker_get_pointer (screen->cursor_tracker,
+                                   &root_x, &root_y, NULL);
 
   if (root_x != focus_data->pointer_x ||
       root_y != focus_data->pointer_y)
@@ -10513,17 +10015,15 @@ window_focus_on_pointer_rest_callback (gpointer data)
       return TRUE;
     }
 
-  /* 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))
+  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))
     goto out;
 
   window =
     meta_stack_get_default_focus_window_at_point (screen->stack,
                                                   screen->active_workspace,
-                                                  None, root_x, root_y);
+                                                  NULL, root_x, root_y);
 
   if (window == NULL)
     goto out;
@@ -10628,3 +10128,51 @@ meta_window_set_custom_frame_extents (MetaWindow *window,
 
   meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
 }
+
+gboolean
+meta_window_can_maximize (MetaWindow *window)
+{
+  return window->has_maximize_func;
+}
+
+gboolean
+meta_window_can_minimize (MetaWindow *window)
+{
+  return window->has_minimize_func;
+}
+
+gboolean
+meta_window_can_shade (MetaWindow *window)
+{
+  return window->has_shade_func;
+}
+
+gboolean
+meta_window_can_close (MetaWindow *window)
+{
+  return window->has_close_func;
+}
+
+gboolean
+meta_window_is_always_on_all_workspaces (MetaWindow *window)
+{
+  return window->always_sticky;
+}
+
+gboolean
+meta_window_is_above (MetaWindow *window)
+{
+  return window->wm_state_above;
+}
+
+gboolean
+meta_window_allows_move (MetaWindow *window)
+{
+  return META_WINDOW_ALLOWS_MOVE (window);
+}
+
+gboolean
+meta_window_allows_resize (MetaWindow *window)
+{
+  return META_WINDOW_ALLOWS_RESIZE (window);
+}

src/meta/atomnames.h

@@ -62,6 +62,7 @@ item(_GTK_WINDOW_OBJECT_PATH)
 item(_GTK_APP_MENU_OBJECT_PATH)
 item(_GTK_MENUBAR_OBJECT_PATH)
 item(_GTK_FRAME_EXTENTS)
+item(_GTK_SHOW_WINDOW_MENU)
 item(_GNOME_WM_KEYBINDINGS)
 item(_GNOME_PANEL_ACTION)
 item(_GNOME_PANEL_ACTION_MAIN_MENU)

src/meta/common.h

@@ -86,61 +86,6 @@ typedef enum
   META_FRAME_TILED_RIGHT              = 1 << 16
 } MetaFrameFlags;
 
-/**
- * MetaMenuOp:
- * @META_MENU_OP_NONE: No menu operation
- * @META_MENU_OP_DELETE: Menu operation delete
- * @META_MENU_OP_MINIMIZE: Menu operation minimize
- * @META_MENU_OP_UNMAXIMIZE: Menu operation unmaximize
- * @META_MENU_OP_MAXIMIZE: Menu operation maximize
- * @META_MENU_OP_UNSHADE: Menu operation unshade
- * @META_MENU_OP_SHADE: Menu operation shade
- * @META_MENU_OP_UNSTICK: Menu operation unstick
- * @META_MENU_OP_STICK: Menu operation stick
- * @META_MENU_OP_WORKSPACES: Menu operation workspaces
- * @META_MENU_OP_MOVE: Menu operation move
- * @META_MENU_OP_RESIZE: Menu operation resize
- * @META_MENU_OP_ABOVE: Menu operation above
- * @META_MENU_OP_UNABOVE: Menu operation unabove
- * @META_MENU_OP_MOVE_LEFT: Menu operation left
- * @META_MENU_OP_MOVE_RIGHT: Menu operation right
- * @META_MENU_OP_MOVE_UP: Menu operation up
- * @META_MENU_OP_MOVE_DOWN: Menu operation down
- * @META_MENU_OP_RECOVER: Menu operation recover
- */
-typedef enum
-{
-  META_MENU_OP_NONE        = 0,
-  META_MENU_OP_DELETE      = 1 << 0,
-  META_MENU_OP_MINIMIZE    = 1 << 1,
-  META_MENU_OP_UNMAXIMIZE  = 1 << 2,
-  META_MENU_OP_MAXIMIZE    = 1 << 3,
-  META_MENU_OP_UNSHADE     = 1 << 4,
-  META_MENU_OP_SHADE       = 1 << 5,
-  META_MENU_OP_UNSTICK     = 1 << 6,
-  META_MENU_OP_STICK       = 1 << 7,
-  META_MENU_OP_WORKSPACES  = 1 << 8,
-  META_MENU_OP_MOVE        = 1 << 9,
-  META_MENU_OP_RESIZE      = 1 << 10,
-  META_MENU_OP_ABOVE       = 1 << 11,
-  META_MENU_OP_UNABOVE     = 1 << 12,
-  META_MENU_OP_MOVE_LEFT   = 1 << 13,
-  META_MENU_OP_MOVE_RIGHT  = 1 << 14,
-  META_MENU_OP_MOVE_UP     = 1 << 15,
-  META_MENU_OP_MOVE_DOWN   = 1 << 16,
-  META_MENU_OP_RECOVER     = 1 << 17
-} MetaMenuOp;
-
-typedef struct _MetaWindowMenu MetaWindowMenu;
-
-typedef void (* MetaWindowMenuFunc) (MetaWindowMenu *menu,
-                                     Display        *xdisplay,
-                                     Window          client_xwindow,
-                                     guint32         timestamp,
-                                     MetaMenuOp      op,
-                                     int             workspace,
-                                     gpointer        user_data);
-
 /**
  * MetaGrabOp:
  * @META_GRAB_OP_NONE: None
@@ -214,21 +159,6 @@ typedef enum
   META_GRAB_OP_KEYBOARD_RESIZING_SW,
   META_GRAB_OP_KEYBOARD_RESIZING_NW,
 
-  /* Alt+Tab */
-  META_GRAB_OP_KEYBOARD_TABBING_NORMAL,
-  META_GRAB_OP_KEYBOARD_TABBING_DOCK,
-
-  /* Alt+Esc */
-  META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL,
-  META_GRAB_OP_KEYBOARD_ESCAPING_DOCK,
-
-  META_GRAB_OP_KEYBOARD_ESCAPING_GROUP,
-  
-  /* Alt+F6 */
-  META_GRAB_OP_KEYBOARD_TABBING_GROUP,
-  
-  META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING,
-  
   /* Frame button ops */
   META_GRAB_OP_CLICKING_MINIMIZE,
   META_GRAB_OP_CLICKING_MAXIMIZE,
@@ -243,7 +173,10 @@ typedef enum
   META_GRAB_OP_CLICKING_UNSTICK,
 
   /* Special grab op when the compositor asked for a grab */
-  META_GRAB_OP_COMPOSITOR
+  META_GRAB_OP_COMPOSITOR,
+
+  /* For when a client takes a popup grab */
+  META_GRAB_OP_WAYLAND_CLIENT,
 } MetaGrabOp;
 
 /**

src/meta/compositor.h

@@ -66,6 +66,8 @@ void meta_compositor_window_shape_changed (MetaCompositor *compositor,
                                            MetaWindow     *window);
 void meta_compositor_window_opacity_changed (MetaCompositor *compositor,
                                              MetaWindow     *window);
+void meta_compositor_window_surface_changed (MetaCompositor *compositor,
+                                             MetaWindow     *window);
 
 gboolean meta_compositor_process_event (MetaCompositor *compositor,
                                         XEvent         *event,
@@ -121,4 +123,14 @@ void meta_compositor_sync_screen_size          (MetaCompositor *compositor,
 void meta_compositor_flash_screen              (MetaCompositor *compositor,
                                                 MetaScreen     *screen);
 
+void meta_compositor_show_tile_preview (MetaCompositor *compositor,
+                                        MetaScreen     *screen,
+                                        MetaWindow     *window,
+                                        MetaRectangle  *tile_rect,
+                                        int             tile_monitor_number);
+void meta_compositor_hide_tile_preview (MetaCompositor *compositor,
+                                        MetaScreen     *screen);
+void meta_compositor_show_window_menu (MetaCompositor *compositor,
+                                       MetaWindow     *window);
+
 #endif /* META_COMPOSITOR_H */

src/meta/main.h

@@ -28,6 +28,7 @@ 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);

src/meta/meta-plugin.h

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

src/meta/meta-shaped-texture.h

@@ -75,9 +75,6 @@ CoglTexture * meta_shaped_texture_get_texture (MetaShapedTexture *stex);
 
 void meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
                                            CoglTexture       *mask_texture);
-void meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
-                                                 cairo_region_t    *shape_region);
-
 void meta_shaped_texture_set_opaque_region (MetaShapedTexture *stex,
                                             cairo_region_t    *opaque_region);
 

src/meta/prefs.h

@@ -62,7 +62,6 @@
  * @META_PREF_EDGE_TILING: edge tiling
  * @META_PREF_FORCE_FULLSCREEN: force fullscreen
  * @META_PREF_WORKSPACES_ONLY_ON_PRIMARY: workspaces only on primary
- * @META_PREF_NO_TAB_POPUP: no tab popup
  * @META_PREF_DRAGGABLE_BORDER_WIDTH: draggable border width
  * @META_PREF_AUTO_MAXIMIZE: auto-maximize
  */
@@ -100,7 +99,6 @@ typedef enum
   META_PREF_EDGE_TILING,
   META_PREF_FORCE_FULLSCREEN,
   META_PREF_WORKSPACES_ONLY_ON_PRIMARY,
-  META_PREF_NO_TAB_POPUP,
   META_PREF_DRAGGABLE_BORDER_WIDTH,
   META_PREF_AUTO_MAXIMIZE
 } MetaPreference;
@@ -163,9 +161,6 @@ void meta_prefs_set_force_fullscreen (gboolean whether);
 
 gboolean meta_prefs_get_workspaces_only_on_primary (void);
 
-gboolean meta_prefs_get_no_tab_popup (void);
-void     meta_prefs_set_no_tab_popup (gboolean whether);
-
 int      meta_prefs_get_draggable_border_width (void);
 
 gboolean meta_prefs_get_ignore_request_hide_titlebar (void);
@@ -204,8 +199,6 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
  * @META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD: FILLME 
  * @META_KEYBINDING_ACTION_CYCLE_PANELS: FILLME 
  * @META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD: FILLME 
- * @META_KEYBINDING_ACTION_TAB_POPUP_SELECT: FILLME 
- * @META_KEYBINDING_ACTION_TAB_POPUP_CANCEL: FILLME 
  * @META_KEYBINDING_ACTION_SHOW_DESKTOP: FILLME 
  * @META_KEYBINDING_ACTION_PANEL_MAIN_MENU: FILLME 
  * @META_KEYBINDING_ACTION_PANEL_RUN_DIALOG: FILLME 
@@ -301,8 +294,6 @@ typedef enum _MetaKeyBindingAction
   META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD,
   META_KEYBINDING_ACTION_CYCLE_PANELS,
   META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD,
-  META_KEYBINDING_ACTION_TAB_POPUP_SELECT,
-  META_KEYBINDING_ACTION_TAB_POPUP_CANCEL,
   META_KEYBINDING_ACTION_SHOW_DESKTOP,
   META_KEYBINDING_ACTION_PANEL_MAIN_MENU,
   META_KEYBINDING_ACTION_PANEL_RUN_DIALOG,
@@ -380,20 +371,6 @@ typedef enum
   META_KEY_BINDING_IS_REVERSED = 1 << 3
 } MetaKeyBindingFlags;
 
-/**
- * MetaKeyCombo:
- * @keysym: keysym
- * @keycode: keycode
- * @modifiers: modifiers
- */
-typedef struct _MetaKeyCombo MetaKeyCombo;
-struct _MetaKeyCombo
-{
-  unsigned int keysym;
-  unsigned int keycode;
-  MetaVirtualModifier modifiers;
-};
-
 /**
  * MetaKeyHandlerFunc:
  * @display: a #MetaDisplay
@@ -411,45 +388,10 @@ typedef void (* MetaKeyHandlerFunc) (MetaDisplay     *display,
                                      MetaKeyBinding  *binding,
                                      gpointer         user_data);
 
-typedef struct _MetaKeyHandler MetaKeyHandler;
-
-typedef struct
-{
-  char *name;
-  GSettings *settings;
-
-  MetaKeyBindingAction action;
-
-  /*
-   * A list of MetaKeyCombos. Each of them is bound to
-   * this keypref. If one has keysym==modifiers==0, it is
-   * ignored.
-   */
-  GSList *bindings;
-
-  /* for keybindings that can have shift or not like Alt+Tab */
-  gboolean      add_shift:1;
-
-  /* for keybindings that apply only to a window */
-  gboolean      per_window:1;
-
-  /* for keybindings not added with meta_display_add_keybinding() */
-  gboolean      builtin:1;
-} MetaKeyPref;
-
 GType meta_key_binding_get_type    (void);
 
-GList *meta_prefs_get_keybindings (void);
-
 MetaKeyBindingAction meta_prefs_get_keybinding_action (const char *name);
 
-void meta_prefs_get_window_binding (const char          *name,
-                                    unsigned int        *keysym,
-                                    MetaVirtualModifier *modifiers);
-
-void meta_prefs_get_overlay_binding (MetaKeyCombo *combo);
-const char *meta_prefs_get_iso_next_group_option (void);
-
 gboolean           meta_prefs_get_visual_bell      (void);
 gboolean           meta_prefs_bell_is_audible      (void);
 GDesktopVisualBellType meta_prefs_get_visual_bell_type (void);

src/meta/window.h

@@ -72,11 +72,13 @@ typedef enum
  * MetaMaximizeFlags:
  * @META_MAXIMIZE_HORIZONTAL: Horizontal
  * @META_MAXIMIZE_VERTICAL: Vertical
+ * @META_MAXIMIZE_BOTH: Both
  */
 typedef enum
 {
   META_MAXIMIZE_HORIZONTAL = 1 << 0,
-  META_MAXIMIZE_VERTICAL   = 1 << 1
+  META_MAXIMIZE_VERTICAL   = 1 << 1,
+  META_MAXIMIZE_BOTH       = (1 << 0 | 1 << 1),
 } MetaMaximizeFlags;
 
 /**
@@ -252,6 +254,13 @@ void meta_window_begin_grab_op (MetaWindow *window,
                                 gboolean    frame_action,
                                 guint32     timestamp);
 
+gboolean meta_window_can_maximize (MetaWindow *window);
+gboolean meta_window_can_minimize (MetaWindow *window);
+gboolean meta_window_can_shade (MetaWindow *window);
 gboolean meta_window_can_close (MetaWindow *window);
+gboolean meta_window_is_always_on_all_workspaces (MetaWindow *window);
+gboolean meta_window_is_above (MetaWindow *window);
+gboolean meta_window_allows_move (MetaWindow *window);
+gboolean meta_window_allows_resize (MetaWindow *window);
 
 #endif

src/mutter-wayland.desktop.in

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Application
 _Name=Mutter (wayland compositor)
-Exec=mutter-launch -- mutter --wayland
+Exec=mutter --wayland --display-server
 NoDisplay=true
 # name of loadable control center module
 X-GNOME-WMSettingsModule=metacity

src/org.freedesktop.login1.xml

@@ -0,0 +1,44 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.freedesktop.login1.Session">
+    <property name="Active" type="b" access="read" />
+
+    <method name="Activate">
+    </method>
+    <method name="TakeControl">
+      <arg name="force" type="b"/>
+    </method>
+    <method name="TakeDevice">
+      <annotation name="org.gtk.GDBus.C.UnixFD" value="true"/>
+      <arg name="major" type="u" direction="in"/>
+      <arg name="minor" type="u" direction="in"/>
+      <arg name="fd" type="h" direction="out"/>
+      <arg name="paused" type="b" direction="out"/>
+    </method>
+    <method name="ReleaseDevice">
+      <arg name="major" type="u"/>
+      <arg name="minor" type="u"/>
+    </method>
+    <method name="PauseDeviceComplete">
+      <arg name="major" type="u"/>
+      <arg name="minor" type="u"/>
+    </method>
+    <signal name="PauseDevice">
+      <arg name="major" type="u"/>
+      <arg name="minor" type="u"/>
+      <arg name="type" type="s"/>
+    </signal>
+    <signal name="ResumeDevice">
+      <arg name="major" type="u"/>
+      <arg name="minor" type="u"/>
+      <arg name="fd" type="h"/>
+    </signal>
+  </interface>
+
+  <interface name="org.freedesktop.login1.Seat">
+    <method name="SwitchTo">
+      <arg name="vt" type="u"/>
+    </method>
+  </interface>
+</node>

src/ui/draw-workspace.c

@@ -1,224 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Draw a workspace */
-
-/* This file should not be modified to depend on other files in
- * libwnck or mutter, since it's used in both of them
- */
-
-/* 
- * Copyright (C) 2002 Red Hat Inc.
- * 
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "draw-workspace.h"
-#include "theme-private.h"
-
-
-static void
-get_window_rect (const WnckWindowDisplayInfo *win,
-                 int                    screen_width,
-                 int                    screen_height,
-                 const GdkRectangle    *workspace_rect,
-                 GdkRectangle          *rect)
-{
-  double width_ratio, height_ratio;
-  int x, y, width, height;
-  
-  width_ratio = (double) workspace_rect->width / (double) screen_width;
-  height_ratio = (double) workspace_rect->height / (double) screen_height;
-  
-  x = win->x;
-  y = win->y;
-  width = win->width;
-  height = win->height;
-  
-  x *= width_ratio;
-  y *= height_ratio;
-  width *= width_ratio;
-  height *= height_ratio;
-  
-  x += workspace_rect->x;
-  y += workspace_rect->y;
-  
-  if (width < 3)
-    width = 3;
-  if (height < 3)
-    height = 3;
-
-  rect->x = x;
-  rect->y = y;
-  rect->width = width;
-  rect->height = height;
-}
-
-static void
-draw_window (GtkWidget                   *widget,
-             cairo_t                     *cr,
-             const WnckWindowDisplayInfo *win,
-             const GdkRectangle          *winrect,
-             GtkStateFlags               state)
-{
-  GdkPixbuf *icon;
-  int icon_x, icon_y, icon_w, icon_h;
-  gboolean is_active;
-  GdkRGBA color;
-  GtkStyleContext *style;
-
-  is_active = win->is_active;
-  
-  cairo_save (cr);
-
-  cairo_rectangle (cr, winrect->x, winrect->y, winrect->width, winrect->height);
-  cairo_clip (cr);
-
-  style = gtk_widget_get_style_context (widget);
-  if (is_active)
-    meta_gtk_style_get_light_color (style, state, &color);
-  else
-    gtk_style_context_get_background_color (style, state, &color);
-  gdk_cairo_set_source_rgba (cr, &color);
-
-  cairo_rectangle (cr,
-                   winrect->x + 1, winrect->y + 1,
-                   MAX (0, winrect->width - 2), MAX (0, winrect->height - 2));
-  cairo_fill (cr);
-
-
-  icon = win->icon;
-
-  icon_w = icon_h = 0;
-          
-  if (icon)
-    {              
-      icon_w = gdk_pixbuf_get_width (icon);
-      icon_h = gdk_pixbuf_get_height (icon);
-
-      /* If the icon is too big, fall back to mini icon.
-       * We don't arbitrarily scale the icon, because it's
-       * just too slow on my Athlon 850.
-       */
-      if (icon_w > (winrect->width - 2) ||
-          icon_h > (winrect->height - 2))
-        {
-          icon = win->mini_icon;
-          if (icon)
-            {
-              icon_w = gdk_pixbuf_get_width (icon);
-              icon_h = gdk_pixbuf_get_height (icon);
-        
-              /* Give up. */
-              if (icon_w > (winrect->width - 2) ||
-                  icon_h > (winrect->height - 2))
-                icon = NULL;
-            }
-        }
-    }
-
-  if (icon)
-    {
-      icon_x = winrect->x + (winrect->width - icon_w) / 2;
-      icon_y = winrect->y + (winrect->height - icon_h) / 2;
-      
-      cairo_save (cr);
-      gdk_cairo_set_source_pixbuf (cr, icon, icon_x, icon_y);
-      cairo_rectangle (cr, icon_x, icon_y, icon_w, icon_h);
-      cairo_clip (cr);
-      cairo_paint (cr);
-      cairo_restore (cr);
-    }
-
-  gtk_style_context_get_color (style, state, &color);
-  gdk_cairo_set_source_rgba (cr, &color);
-  cairo_set_line_width (cr, 1.0);
-  cairo_rectangle (cr,
-                   winrect->x + 0.5, winrect->y + 0.5,
-                   MAX (0, winrect->width - 1), MAX (0, winrect->height - 1));
-  cairo_stroke (cr);
-  
-  cairo_restore (cr);
-}
-
-void
-wnck_draw_workspace (GtkWidget                   *widget,
-                     cairo_t                     *cr,
-                     int                          x,
-                     int                          y,
-                     int                          width,
-                     int                          height,
-                     int                          screen_width,
-                     int                          screen_height,
-                     GdkPixbuf                   *workspace_background,
-                     gboolean                     is_active,
-                     const WnckWindowDisplayInfo *windows,
-                     int                          n_windows)
-{
-  int i;
-  GdkRectangle workspace_rect;
-  GtkStateFlags state;
-  GtkStyleContext *style;
-
-  workspace_rect.x = x;
-  workspace_rect.y = y;
-  workspace_rect.width = width;
-  workspace_rect.height = height;
-
-  if (is_active)
-    state = GTK_STATE_FLAG_SELECTED;
-  else if (workspace_background) 
-    state = GTK_STATE_FLAG_PRELIGHT;
-  else
-    state = GTK_STATE_FLAG_NORMAL;
-
-  style = gtk_widget_get_style_context (widget);
-  
-  cairo_save (cr);
-
-  if (workspace_background)
-    {
-      gdk_cairo_set_source_pixbuf (cr, workspace_background, x, y);
-      cairo_paint (cr);
-    }
-  else
-    {
-      GdkRGBA color;
-
-      meta_gtk_style_get_dark_color (style,state, &color);
-      gdk_cairo_set_source_rgba (cr, &color);
-      cairo_rectangle (cr, x, y, width, height);
-      cairo_fill (cr);
-    }
-
-  i = 0;
-  while (i < n_windows)
-    {
-      const WnckWindowDisplayInfo *win = &windows[i];
-      GdkRectangle winrect;
-      
-      get_window_rect (win, screen_width,
-                       screen_height, &workspace_rect, &winrect);
-      
-      draw_window (widget,
-                   cr,
-                   win,
-                   &winrect,
-                   state);
-      
-      ++i;
-    }
-
-  cairo_restore (cr);
-  
-}

src/ui/draw-workspace.h

@@ -1,59 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Draw a workspace */
-
-/* This file should not be modified to depend on other files in
- * libwnck or metacity, since it's used in both of them
- */
-
-/* 
- * Copyright (C) 2002 Red Hat Inc.
- * 
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef WNCK_DRAW_WORKSPACE_H
-#define WNCK_DRAW_WORKSPACE_H
-
-#include <gdk/gdk.h>
-#include <gdk-pixbuf/gdk-pixbuf.h>
-#include <gtk/gtk.h>
-
-typedef struct
-{
-  GdkPixbuf *icon;
-  GdkPixbuf *mini_icon;
-  int x;
-  int y;
-  int width;
-  int height;
-
-  guint is_active : 1;
-  
-} WnckWindowDisplayInfo;
-
-void wnck_draw_workspace (GtkWidget                   *widget,
-                          cairo_t                     *cr,
-                          int                          x,
-                          int                          y,
-                          int                          width,
-                          int                          height,
-                          int                          screen_width,
-                          int                          screen_height,
-                          GdkPixbuf                   *workspace_background,
-                          gboolean                     is_active,
-                          const WnckWindowDisplayInfo *windows,
-                          int                          n_windows);
-
-#endif

src/ui/frames.c

@@ -44,8 +44,6 @@
 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,
@@ -134,9 +132,6 @@ 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;
@@ -231,6 +226,7 @@ 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);
@@ -522,13 +518,26 @@ MetaFrames*
 meta_frames_new (int screen_number)
 {
   GdkScreen *screen;
+  MetaFrames *frames;
 
   screen = gdk_display_get_screen (gdk_display_get_default (),
                                    screen_number);
 
-  return g_object_new (META_TYPE_FRAMES,
-                       "screen", screen,
-                       NULL);  
+  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;
 }
 
 /* In order to use a style with a window it has to be attached to that
@@ -635,22 +644,6 @@ 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)
@@ -1113,9 +1106,6 @@ meta_frame_titlebar_event (MetaUIFrame    *frame,
     case G_DESKTOP_TITLEBAR_ACTION_MENU:
       meta_core_show_window_menu (display,
                                   frame->xwindow,
-                                  event->x_root,
-                                  event->y_root,
-                                  event->button,
                                   event->time);
       break;
     }
@@ -1275,30 +1265,9 @@ meta_frames_button_press_event (GtkWidget      *widget,
       redraw_control (frames, frame, control);
 
       if (op == META_GRAB_OP_CLICKING_MENU)
-        {
-          MetaFrameGeometry fgeom;
-          GdkRectangle *rect;
-          int dx, dy;
-          
-          meta_frames_calc_geometry (frames, frame, &fgeom);
-          
-          rect = control_rect (META_FRAME_CONTROL_MENU, &fgeom);
-
-          /* get delta to convert to root coords */
-          dx = event->x_root - event->x;
-          dy = event->y_root - event->y;
-          
-          /* Align to the right end of the menu rectangle if RTL */
-          if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
-            dx += rect->width;
-
-          meta_core_show_window_menu (display,
-                                      frame->xwindow,
-                                      rect->x + dx,
-                                      rect->y + rect->height + dy,
-                                      event->button,
-                                      event->time);
-        }
+        meta_core_show_window_menu (display,
+                                    frame->xwindow,
+                                    event->time);
     }
   else if (event->button == 1 &&
            (control == META_FRAME_CONTROL_RESIZE_SE ||

src/ui/menu.c

@@ -1,518 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Mutter window menu */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * Copyright (C) 2004 Rob Adams
- * Copyright (C) 2005 Elijah Newren
- * 
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <string.h>
-#include "menu.h"
-#include <meta/main.h>
-#include "util-private.h"
-#include "core.h"
-#include "metaaccellabel.h"
-#include "ui.h"
-
-typedef struct _MenuItem MenuItem;
-typedef struct _MenuData MenuData;
-
-typedef enum
-{
-  MENU_ITEM_SEPARATOR = 0,
-  MENU_ITEM_NORMAL,
-  MENU_ITEM_CHECKBOX,
-  MENU_ITEM_RADIOBUTTON,
-  MENU_ITEM_WORKSPACE_LIST,
-} MetaMenuItemType;
-
-struct _MenuItem
-{
-  MetaMenuOp op;
-  MetaMenuItemType type;
-  const gboolean checked;
-  const char *label;
-};
-
-
-struct _MenuData
-{
-  MetaWindowMenu *menu;
-  MetaMenuOp op;
-};
-
-static void activate_cb (GtkWidget *menuitem, gpointer data);
-
-static MenuItem menuitems[] = {
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MINIMIZE, MENU_ITEM_NORMAL, FALSE, N_("Mi_nimize") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MAXIMIZE, MENU_ITEM_NORMAL, FALSE, N_("Ma_ximize") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_UNMAXIMIZE, MENU_ITEM_NORMAL, FALSE, N_("Unma_ximize") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_SHADE, MENU_ITEM_NORMAL, FALSE, N_("Roll _Up") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_UNSHADE, MENU_ITEM_NORMAL, FALSE, N_("_Unroll") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MOVE, MENU_ITEM_NORMAL, FALSE, N_("_Move") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_RESIZE, MENU_ITEM_NORMAL, FALSE, N_("_Resize") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_RECOVER, MENU_ITEM_NORMAL, FALSE, N_("Move Titlebar On_screen") },
-  { META_MENU_OP_WORKSPACES, MENU_ITEM_SEPARATOR, FALSE, NULL }, /* separator */
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_ABOVE, MENU_ITEM_CHECKBOX, FALSE, N_("Always on _Top") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_UNABOVE, MENU_ITEM_CHECKBOX, TRUE, N_("Always on _Top") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_STICK, MENU_ITEM_RADIOBUTTON, FALSE, N_("_Always on Visible Workspace") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_UNSTICK, MENU_ITEM_RADIOBUTTON, FALSE,  N_("_Only on This Workspace") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MOVE_LEFT, MENU_ITEM_NORMAL, FALSE, N_("Move to Workspace _Left") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MOVE_RIGHT, MENU_ITEM_NORMAL, FALSE, N_("Move to Workspace R_ight") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MOVE_UP, MENU_ITEM_NORMAL, FALSE, N_("Move to Workspace _Up") },
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_MOVE_DOWN, MENU_ITEM_NORMAL, FALSE, N_("Move to Workspace _Down") },
-  { 0, MENU_ITEM_WORKSPACE_LIST, FALSE, NULL },
-  { 0, MENU_ITEM_SEPARATOR, FALSE, NULL }, /* separator */
-  /* Translators: Translate this string the same way as you do in libwnck! */
-  { META_MENU_OP_DELETE, MENU_ITEM_NORMAL, FALSE, N_("_Close") }
-};
-
-static void
-popup_position_func (GtkMenu   *menu,
-                     gint      *x,
-                     gint      *y,
-                     gboolean  *push_in,
-                     gpointer  user_data)
-{
-  GtkRequisition req;      
-  GdkPoint *pos;
-
-  pos = user_data;
-  
-  gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL);
-
-  *x = pos->x;
-  *y = pos->y;
-  
-  if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
-    *x = MAX (0, *x - req.width); 
-
-  /* Ensure onscreen */
-  *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width));
-  *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height));
-}
-
-static void
-menu_closed (GtkMenu *widget,
-             gpointer data)
-{
-  MetaWindowMenu *menu;
-  
-  menu = data;
-
-  meta_frames_notify_menu_hide (menu->frames);
-  (* menu->func) (menu,
-                  GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
-                  menu->client_xwindow,
-                  gtk_get_current_event_time (),
-                  0, 0,
-                  menu->data);
-  
-  /* menu may now be freed */
-}
-
-static void
-activate_cb (GtkWidget *menuitem, gpointer data)
-{
-  MenuData *md;
-  
-  g_return_if_fail (GTK_IS_WIDGET (menuitem));
-  
-  md = data;
-
-  meta_frames_notify_menu_hide (md->menu->frames);
-  (* md->menu->func) (md->menu,
-                      GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
-                      md->menu->client_xwindow,
-                      gtk_get_current_event_time (),
-                      md->op,
-                      GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuitem),
-                                                          "workspace")),
-                      md->menu->data);
-
-  /* menu may now be freed */
-}
-
-/*
- * Given a Display and an index, get the workspace name and add any
- * accelerators. At the moment this means adding a _ if the name is of
- * the form "Workspace n" where n is less than 10, and escaping any
- * other '_'s so they do not create inadvertant accelerators.
- * 
- * The calling code owns the string, and is reponsible to free the
- * memory after use.
- *
- * See also http://mail.gnome.org/archives/gnome-i18n/2008-March/msg00380.html
- * which discusses possible i18n concerns.
- */
-static char*
-get_workspace_name_with_accel (Display *display,
-                               Window   xroot,
-                               int      index)
-{
-  const char *name;
-  int number;
-  int charcount=0;
-
-  name = meta_core_get_workspace_name_with_index (display, xroot, index);
-
-  g_assert (name != NULL);
-  
-  /*
-   * If the name is of the form "Workspace x" where x is an unsigned
-   * integer, insert a '_' before the number if it is less than 10 and
-   * return it
-   */
-  number = 0;
-  if (sscanf (name, _("Workspace %d%n"), &number, &charcount) != 0 &&
-      *(name + charcount)=='\0')
-    {
-      char *new_name;
-      
-      /*
-       * Above name is a pointer into the Workspace struct. Here we make
-       * a copy copy so we can have our wicked way with it.
-       */
-      if (number == 10)
-        new_name = g_strdup_printf (_("Workspace 1_0"));
-      else
-        new_name = g_strdup_printf (_("Workspace %s%d"),
-                                    number < 10 ? "_" : "",
-                                    number);
-      return new_name;
-    }
-  else
-    {
-      /*
-       * Otherwise this is just a normal name. Escape any _ characters so that
-       * the user's workspace names do not get mangled.  If the number is less
-       * than 10 we provide an accelerator.
-       */
-      char *new_name;
-      const char *source;
-      char *dest;
-
-      /*
-       * Assume the worst case, that every character is a _.  We also
-       * provide memory for " (_#)"
-       */
-      new_name = g_malloc0 (strlen (name) * 2 + 6 + 1);
-
-      /*
-       * Now iterate down the strings, adding '_' to escape as we go
-       */
-      dest = new_name;
-      source = name;
-      while (*source != '\0')
-        {
-          if (*source == '_')
-            *dest++ = '_';
-          *dest++ = *source++;
-        }
-
-      /* People don't start at workspace 0, but workspace 1 */
-      if (index < 9)
-        {
-          g_snprintf (dest, 6, " (_%d)", index + 1);
-        }
-      else if (index == 9)
-        {
-          g_snprintf (dest, 6, " (_0)");
-        }
-
-      return new_name;
-    }
-}
-
-static GtkWidget *
-menu_item_new (MenuItem *menuitem, int workspace_id)
-{
-  unsigned int key;
-  MetaVirtualModifier mods;
-  const char *i18n_label;
-  GtkWidget *mi;
-  GtkWidget *accel_label;
-
-  if (menuitem->type == MENU_ITEM_NORMAL)
-    {
-      mi = gtk_menu_item_new ();
-    }
-  else if (menuitem->type == MENU_ITEM_CHECKBOX)
-    {
-      mi = gtk_check_menu_item_new ();
-      
-      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
-                                      menuitem->checked);
-    }    
-  else if (menuitem->type == MENU_ITEM_RADIOBUTTON)
-    {
-      mi = gtk_check_menu_item_new ();
-
-      gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi),
-                                             TRUE);
-      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
-                                      menuitem->checked);
-    }
-  else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST)
-    return NULL;
-  else
-    return gtk_separator_menu_item_new ();
-
-  i18n_label = _(menuitem->label);
-  meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);
-
-  accel_label = meta_accel_label_new_with_mnemonic (i18n_label);
-  gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
-
-  gtk_container_add (GTK_CONTAINER (mi), accel_label);
-  gtk_widget_show (accel_label);
-
-  meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label),
-                                    key, mods);
-  
-  return mi;
-}
-
-MetaWindowMenu*
-meta_window_menu_new   (MetaFrames         *frames,
-                        MetaMenuOp          ops,
-                        MetaMenuOp          insensitive,
-                        Window              client_xwindow,
-                        unsigned long       active_workspace,
-                        int                 n_workspaces,
-                        MetaWindowMenuFunc  func,
-                        gpointer            data)
-{
-  int i;
-  MetaWindowMenu *menu;
-
-  /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */
-  if (n_workspaces < 2)
-    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);
-  else if (n_workspaces == 2) 
-    /* #151183: If we only have two workspaces, disable the menu listing them. */
-    ops &= ~(META_MENU_OP_WORKSPACES);
-  
-  menu = g_new (MetaWindowMenu, 1);
-  menu->frames = frames;
-  menu->client_xwindow = client_xwindow;
-  menu->func = func;
-  menu->data = data;
-  menu->ops = ops;
-  menu->insensitive = insensitive;  
-  
-  menu->menu = gtk_menu_new ();
-
-  gtk_menu_set_screen (GTK_MENU (menu->menu),
-                       gtk_widget_get_screen (GTK_WIDGET (frames)));
-
-  for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)
-    {
-      MenuItem menuitem = menuitems[i];
-      if (ops & menuitem.op || menuitem.op == 0)
-        {
-          GtkWidget *mi;
-          MenuData *md;
-          unsigned int key;
-          MetaVirtualModifier mods;
-
-          mi = menu_item_new (&menuitem, -1);
-
-          /* Set the activeness of radiobuttons. */
-          switch (menuitem.op)
-            {
-            case META_MENU_OP_STICK:
-              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
-                                              active_workspace == 0xFFFFFFFF);
-              break;
-            case META_MENU_OP_UNSTICK:
-              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
-                                              active_workspace != 0xFFFFFFFF);
-              break;
-            default:
-              break;
-            }
-
-          if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)
-            {
-              if (ops & META_MENU_OP_WORKSPACES)
-                {
-                  Display *display;
-                  Window xroot;
-                  GdkScreen *screen;
-                  GdkWindow *window;
-                  GtkWidget *submenu;
-                  int j;
-
-                  MenuItem to_another_workspace = {
-                    0, MENU_ITEM_NORMAL, FALSE,
-                    N_("Move to Another _Workspace")
-                  };
-
-                  meta_verbose ("Creating %d-workspace menu current space %lu\n",
-                      n_workspaces, active_workspace);
-
-                  window = gtk_widget_get_window (GTK_WIDGET (frames));
-                  display = GDK_WINDOW_XDISPLAY (window);
-
-                  screen = gdk_window_get_screen (window);
-                  xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
-
-                  submenu = gtk_menu_new ();
-
-                  g_assert (mi==NULL);
-                  mi = menu_item_new (&to_another_workspace, -1);
-                  gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);
-
-                  for (j = 0; j < n_workspaces; j++)
-                    {
-                      char *label;
-                      MenuData *md;
-                      unsigned int key;
-                      MetaVirtualModifier mods;
-                      MenuItem moveitem;
-                      GtkWidget *submi;
-
-                      meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,
-                          j + 1,
-                          &key, &mods);
-
-                      label = get_workspace_name_with_accel (display, xroot, j);
-
-                      moveitem.type = MENU_ITEM_NORMAL;
-                      moveitem.op = META_MENU_OP_WORKSPACES;
-                      moveitem.label = label;
-                      submi = menu_item_new (&moveitem, j + 1);
-
-                      g_free (label);
-
-                      if ((active_workspace == (unsigned)j) && (ops & META_MENU_OP_UNSTICK))
-                        gtk_widget_set_sensitive (submi, FALSE);
-
-                      md = g_new (MenuData, 1);
-
-                      md->menu = menu;
-                      md->op = META_MENU_OP_WORKSPACES;
-
-                      g_object_set_data (G_OBJECT (submi),
-                          "workspace",
-                          GINT_TO_POINTER (j));
-
-                      g_signal_connect_data (G_OBJECT (submi),
-                          "activate",
-                          G_CALLBACK (activate_cb),
-                          md,
-                          (GClosureNotify) g_free, 0);
-
-                      gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi);
-
-                      gtk_widget_show (submi);
-                    }
-                  }
-                else
-                  meta_verbose ("not creating workspace menu\n");
-            }
-          else if (menuitem.type != MENU_ITEM_SEPARATOR)
-            {
-              meta_core_get_menu_accelerator (menuitems[i].op, -1,
-                                              &key, &mods);
-
-              if (insensitive & menuitem.op)
-                gtk_widget_set_sensitive (mi, FALSE);
-              
-              md = g_new (MenuData, 1);
-              
-              md->menu = menu;
-              md->op = menuitem.op;
-              
-              g_signal_connect_data (G_OBJECT (mi),
-                                     "activate",
-                                     G_CALLBACK (activate_cb),
-                                     md,
-                                     (GClosureNotify) g_free, 0);
-            }
-
-          if (mi)
-            {
-              gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu), mi);
-          
-              gtk_widget_show (mi);
-            }
-        }
-    }
-
- 
-  g_signal_connect (menu->menu, "selection_done",
-                    G_CALLBACK (menu_closed), menu);  
-
-  return menu;
-}
-
-void
-meta_window_menu_popup (MetaWindowMenu     *menu,
-                        int                 root_x,
-                        int                 root_y,
-                        int                 button,
-                        guint32             timestamp)
-{
-  GdkPoint *pt;
-  
-  pt = g_new (GdkPoint, 1);
-
-  g_object_set_data_full (G_OBJECT (menu->menu),
-                          "destroy-point",
-                          pt,
-                          g_free);
-
-  pt->x = root_x;
-  pt->y = root_y;
-  
-  gtk_menu_popup (GTK_MENU (menu->menu),
-                  NULL, NULL,
-                  popup_position_func, pt,
-                  button,
-                  timestamp);
-
-  if (!gtk_widget_get_visible (menu->menu))
-    meta_warning ("GtkMenu failed to grab the pointer\n");
-}
-
-void
-meta_window_menu_free (MetaWindowMenu *menu)
-{
-  gtk_widget_destroy (menu->menu);
-  g_free (menu);
-}

src/ui/menu.h

@@ -1,55 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Mutter window menu */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * 
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef META_MENU_H
-#define META_MENU_H
-
-#include <gtk/gtk.h>
-#include "frames.h"
-
-struct _MetaWindowMenu
-{
-  MetaFrames *frames;
-  Window client_xwindow;
-  GtkWidget *menu;
-  MetaWindowMenuFunc func;
-  gpointer data;
-  MetaMenuOp ops;
-  MetaMenuOp insensitive;
-};
-
-MetaWindowMenu* meta_window_menu_new      (MetaFrames         *frames,
-                                           MetaMenuOp          ops,
-                                           MetaMenuOp          insensitive,
-                                           Window              client_xwindow,
-                                           unsigned long       active_workspace,
-                                           int                 n_workspaces,
-                                           MetaWindowMenuFunc  func,
-                                           gpointer            data);
-void            meta_window_menu_popup    (MetaWindowMenu     *menu,
-                                           int                 root_x,
-                                           int                 root_y,
-                                           int                 button,
-                                           guint32             timestamp);
-void            meta_window_menu_free     (MetaWindowMenu     *menu);
-
-
-#endif

src/ui/metaaccellabel.c

@@ -1,451 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity hacked-up GtkAccelLabel */
-/* Copyright (C) 2002 Red Hat, Inc. */
-/* GTK - The GIMP Toolkit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * MetaAccelLabel: GtkLabel with accelerator monitoring facilities.
- * Copyright (C) 1998 Tim Janik
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
- * file for a list of people on the GTK+ Team.  See the ChangeLog
- * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#include <config.h>
-#include "metaaccellabel.h"
-#include <gtk/gtk.h>
-#include <string.h>
-#include "util-private.h"
-
-static void     meta_accel_label_destroy      (GtkWidget           *object);
-static void     meta_accel_label_finalize     (GObject             *object);
-static void     meta_accel_label_get_preferred_width  (GtkWidget *widget,
-                                                       gint      *minimum,
-                                                       gint      *natural);
-static void     meta_accel_label_get_preferred_height (GtkWidget *widget,
-                                                       gint      *minimum,
-                                                       gint      *natural);
-static gboolean meta_accel_label_draw         (GtkWidget           *widget,
-                                               cairo_t             *cr);
-
-static void  meta_accel_label_update          (MetaAccelLabel *accel_label);
-static int   meta_accel_label_get_accel_width (MetaAccelLabel *accel_label);
-
-G_DEFINE_TYPE (MetaAccelLabel, meta_accel_label, GTK_TYPE_LABEL);
-
-static void
-meta_accel_label_class_init (MetaAccelLabelClass *class)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
-  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
-
-  gobject_class->finalize = meta_accel_label_finalize;
-
-  widget_class->destroy = meta_accel_label_destroy;
-
-  widget_class->get_preferred_width = meta_accel_label_get_preferred_width;
-  widget_class->get_preferred_height = meta_accel_label_get_preferred_height;
-  widget_class->draw = meta_accel_label_draw;
-
-  class->signal_quote1 = g_strdup ("<:");
-  class->signal_quote2 = g_strdup (":>");
-  /* This is the text that should appear next to menu accelerators
-   * that use the shift key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_shift = g_strdup (_("Shift"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the control key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_control = g_strdup (_("Ctrl"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the alt key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_alt = g_strdup (_("Alt"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the meta key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_meta = g_strdup (_("Meta"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the super key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_super = g_strdup (_("Super"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the hyper key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_hyper = g_strdup (_("Hyper"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the mod2 key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_mod2 = g_strdup (_("Mod2"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the mod3 key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_mod3 = g_strdup (_("Mod3"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the mod4 key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_mod4 = g_strdup (_("Mod4"));
-  /* This is the text that should appear next to menu accelerators
-   * that use the mod5 key. If the text on this key isn't typically
-   * translated on keyboards used for your language, don't translate
-   * this.
-   */
-  class->mod_name_mod5 = g_strdup (_("Mod5"));
-
-  class->mod_separator = g_strdup ("+");
-  class->accel_seperator = g_strdup (" / ");
-  class->latin1_to_char = TRUE;
-}
-
-static void
-meta_accel_label_init (MetaAccelLabel *accel_label)
-{
-  accel_label->accel_padding = 3;
-  accel_label->accel_string = NULL;
-
-  meta_accel_label_update (accel_label);
-}
-
-GtkWidget*
-meta_accel_label_new_with_mnemonic (const gchar *string)
-{
-  MetaAccelLabel *accel_label;
-
-  g_return_val_if_fail (string != NULL, NULL);
-
-  accel_label = g_object_new (META_TYPE_ACCEL_LABEL, NULL);
-
-  gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), string);
-
-  return GTK_WIDGET (accel_label);
-}
-
-static void
-meta_accel_label_destroy (GtkWidget *object)
-{
-  MetaAccelLabel *accel_label = META_ACCEL_LABEL (object);
-
-
-  g_free (accel_label->accel_string);
-  accel_label->accel_string = NULL;
-
-  accel_label->accel_mods = 0;
-  accel_label->accel_key = 0;
-
-  GTK_WIDGET_CLASS (meta_accel_label_parent_class)->destroy (object);
-}
-
-static void
-meta_accel_label_finalize (GObject *object)
-{
-  MetaAccelLabel *accel_label = META_ACCEL_LABEL (object);
-
-  g_free (accel_label->accel_string);
-
-  G_OBJECT_CLASS (meta_accel_label_parent_class)->finalize (object);
-}
-
-void
-meta_accel_label_set_accelerator (MetaAccelLabel         *accel_label,
-                                  guint                   accelerator_key,
-                                  MetaVirtualModifier     accelerator_mods)
-{
-  g_return_if_fail (META_IS_ACCEL_LABEL (accel_label));
-
-  if (accelerator_key != accel_label->accel_key ||
-      accelerator_mods != accel_label->accel_mods)
-    {
-      accel_label->accel_mods = accelerator_mods;
-      accel_label->accel_key = accelerator_key;
-
-      meta_accel_label_update (accel_label);
-    }
-}
-
-static int
-meta_accel_label_get_accel_width (MetaAccelLabel *accel_label)
-{
-  g_return_val_if_fail (META_IS_ACCEL_LABEL (accel_label), 0);
-
-  return (accel_label->accel_string_width +
-	  (accel_label->accel_string_width ? accel_label->accel_padding : 0));
-}
-
-static void
-meta_accel_label_get_preferred_width (GtkWidget *widget,
-                                      gint      *minimum,
-                                      gint      *natural)
-{
-  MetaAccelLabel *accel_label = META_ACCEL_LABEL (widget);
-  PangoLayout *layout;
-  gint width;
-
-  GTK_WIDGET_CLASS (meta_accel_label_parent_class)->get_preferred_width (widget, minimum, natural);
-
-  layout = gtk_widget_create_pango_layout (widget, accel_label->accel_string);
-  pango_layout_get_pixel_size (layout, &width, NULL);
-  accel_label->accel_string_width = width;
-
-  g_object_unref (G_OBJECT (layout));
-}
-
-static void
-meta_accel_label_get_preferred_height (GtkWidget *widget,
-                                       gint      *minimum,
-                                       gint      *natural)
-{
-  GTK_WIDGET_CLASS (meta_accel_label_parent_class)->get_preferred_height (widget, minimum, natural);
-}
-
-/* Mostly taken from GTK3. */
-static gboolean
-meta_accel_label_draw (GtkWidget *widget,
-                       cairo_t   *cr)
-{
-  MetaAccelLabel *accel_label = META_ACCEL_LABEL (widget);
-  GtkMisc *misc = GTK_MISC (accel_label);
-  GtkTextDirection direction;
-  int ac_width;
-  GtkAllocation allocation;
-  GtkRequisition requisition;
-
-  direction = gtk_widget_get_direction (widget);
-  ac_width = meta_accel_label_get_accel_width (accel_label);
-  gtk_widget_get_allocation (widget, &allocation);
-  gtk_widget_get_preferred_size (widget,
-                                 &requisition, NULL);
-
-  if (allocation.width >= requisition.width + ac_width)
-    {
-      GtkStyleContext *style;
-      PangoLayout *label_layout;
-      PangoLayout *accel_layout;
-      GtkLabel *label = GTK_LABEL (widget);
-      gint x, y, xpad, ypad;
-      gfloat xalign, yalign;
-
-      label_layout = gtk_label_get_layout (GTK_LABEL (accel_label));
-      gtk_misc_get_alignment (misc, &xalign, &yalign);
-
-      cairo_save (cr);
-
-      /* XXX: Mad hack: We modify the label's width so it renders
-       * properly in its draw function that we chain to. */
-      if (direction == GTK_TEXT_DIR_RTL)
-        cairo_translate (cr, ac_width, 0);
-      if (gtk_label_get_ellipsize (label))
-        pango_layout_set_width (label_layout,
-                                pango_layout_get_width (label_layout) 
-                                - ac_width * PANGO_SCALE);
-      
-      allocation.width -= ac_width;
-      gtk_widget_set_allocation (widget, &allocation);
-      if (GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw)
-        GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw (widget,
-                                                               cr);
-      allocation.width += ac_width;
-      gtk_widget_set_allocation (widget, &allocation);
-      if (gtk_label_get_ellipsize (label))
-        pango_layout_set_width (label_layout,
-                                pango_layout_get_width (label_layout) 
-                                + ac_width * PANGO_SCALE);
-
-      cairo_restore (cr);
-
-      gtk_misc_get_padding (misc, &xpad, &ypad);
-
-      if (direction == GTK_TEXT_DIR_RTL)
-        x = xpad;
-      else
-        x = gtk_widget_get_allocated_width (widget) - xpad - ac_width;
-
-      gtk_label_get_layout_offsets (GTK_LABEL (accel_label), NULL, &y);
-
-      accel_layout = gtk_widget_create_pango_layout (widget, accel_label->accel_string);
-
-      y = (allocation.height - (requisition.height - ypad * 2)) * yalign + 1.5;
-
-      style = gtk_widget_get_style_context (widget);
-      gtk_style_context_save (style);
-      gtk_style_context_set_state (style,
-                                   gtk_widget_get_state_flags (widget));
-      gtk_render_layout (gtk_widget_get_style_context (widget),
-                         cr,
-                         x, y,
-                         accel_layout);
-      gtk_style_context_restore (style);
-
-      g_object_unref (accel_layout);
-    }
-  else
-    {
-      if (GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw)
-        GTK_WIDGET_CLASS (meta_accel_label_parent_class)->draw (widget, cr);
-    }
-  
-  return FALSE;
-}
-
-static void
-meta_accel_label_update (MetaAccelLabel *accel_label)
-{
-  MetaAccelLabelClass *class;
-  GString *gstring;
-  gboolean seen_mod = FALSE;
-  gunichar ch;
-
-  g_return_if_fail (META_IS_ACCEL_LABEL (accel_label));
-
-  class = META_ACCEL_LABEL_GET_CLASS (accel_label);
-
-  g_free (accel_label->accel_string);
-  accel_label->accel_string = NULL;
-
-  gstring = g_string_new (accel_label->accel_string);
-  g_string_append (gstring, gstring->len ? class->accel_seperator : "   ");
-
-  if (accel_label->accel_mods & META_VIRTUAL_SHIFT_MASK)
-    {
-      g_string_append (gstring, class->mod_name_shift);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_CONTROL_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_control);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_ALT_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_alt);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_META_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_meta);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_SUPER_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_super);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_HYPER_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_hyper);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_MOD2_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_mod2);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_MOD3_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_mod3);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_MOD4_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_mod4);
-      seen_mod = TRUE;
-    }
-  if (accel_label->accel_mods & META_VIRTUAL_MOD5_MASK)
-    {
-      if (seen_mod)
-        g_string_append (gstring, class->mod_separator);
-      g_string_append (gstring, class->mod_name_mod5);
-      seen_mod = TRUE;
-    }
-
-  if (seen_mod)
-    g_string_append (gstring, class->mod_separator);
-
-  ch = gdk_keyval_to_unicode (accel_label->accel_key);
-  if (ch && (g_unichar_isgraph (ch) || ch == ' ') &&
-      (ch < 0x80 || class->latin1_to_char))
-    {
-      switch (ch)
-        {
-        case ' ':
-          g_string_append (gstring, "Space");
-          break;
-        case '\\':
-          g_string_append (gstring, "Backslash");
-          break;
-        default:
-          g_string_append_unichar (gstring, g_unichar_toupper (ch));
-          break;
-        }
-    }
-  else
-    {
-      gchar *tmp;
-
-      tmp = gtk_accelerator_name (accel_label->accel_key, 0);
-      if (tmp[0] != 0 && tmp[1] == 0)
-        tmp[0] = g_ascii_toupper (tmp[0]);
-      g_string_append (gstring, tmp);
-      g_free (tmp);
-    }
-
-  g_free (accel_label->accel_string);
-  accel_label->accel_string = gstring->str;
-  g_string_free (gstring, FALSE);
-
-  g_assert (accel_label->accel_string);
-  /* accel_label->accel_string = g_strdup ("-/-"); */
-
-  gtk_widget_queue_resize (GTK_WIDGET (accel_label));
-}

src/ui/metaaccellabel.h

@@ -1,104 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity hacked-up GtkAccelLabel */
-/* Copyright (C) 2002 Red Hat, Inc. */
-/* GTK - The GIMP Toolkit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * MetaAccelLabel: GtkLabel with accelerator monitoring facilities.
- * Copyright (C) 1998 Tim Janik
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
- * file for a list of people on the GTK+ Team.  See the ChangeLog
- * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#ifndef __META_ACCEL_LABEL_H__
-#define __META_ACCEL_LABEL_H__
-
-#include <gtk/gtk.h>
-#include <meta/common.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-
-#define META_TYPE_ACCEL_LABEL		(meta_accel_label_get_type ())
-#define META_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_ACCEL_LABEL, MetaAccelLabel))
-#define META_ACCEL_LABEL_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_ACCEL_LABEL, MetaAccelLabelClass))
-#define META_IS_ACCEL_LABEL(obj)	 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_ACCEL_LABEL))
-#define META_IS_ACCEL_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_ACCEL_LABEL))
-#define META_ACCEL_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_ACCEL_LABEL, MetaAccelLabelClass))
-
-
-typedef struct _MetaAccelLabel	    MetaAccelLabel;
-typedef struct _MetaAccelLabelClass  MetaAccelLabelClass;
-
-struct _MetaAccelLabel
-{
-  GtkLabel label;
-
-  MetaVirtualModifier accel_mods;
-  guint accel_key;
-  guint accel_padding;
-  gchar *accel_string;
-  guint16 accel_string_width;
-};
-
-struct _MetaAccelLabelClass
-{
-  GtkLabelClass	 parent_class;
-
-  gchar		*signal_quote1;
-  gchar		*signal_quote2;
-  gchar		*mod_name_shift;
-  gchar		*mod_name_control;
-  gchar		*mod_name_alt;
-  gchar		*mod_name_meta;
-  gchar		*mod_name_super;
-  gchar		*mod_name_hyper;
-  gchar		*mod_name_mod2;
-  gchar		*mod_name_mod3;
-  gchar		*mod_name_mod4;
-  gchar		*mod_name_mod5;
-  gchar		*mod_separator;
-  gchar		*accel_seperator;
-  guint		 latin1_to_char : 1;
-
-  /* Padding for future expansion */
-  void (*_gtk_reserved1) (void);
-  void (*_gtk_reserved2) (void);
-  void (*_gtk_reserved3) (void);
-  void (*_gtk_reserved4) (void);
-};
-
-GType	   meta_accel_label_get_type          (void) G_GNUC_CONST;
-GtkWidget* meta_accel_label_new_with_mnemonic (const gchar            *string);
-void       meta_accel_label_set_accelerator   (MetaAccelLabel         *accel_label,
-                                               guint                   accelerator_key,
-                                               MetaVirtualModifier     accelerator_mods);
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-
-#endif /* __META_ACCEL_LABEL_H__ */

src/ui/tabpopup.c

@@ -1,963 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Mutter popup window thing showing windows you can tab to */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * Copyright (C) 2002 Red Hat, Inc.
- * Copyright (C) 2005 Elijah Newren
- * 
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <config.h>
-
-#include <meta/util.h>
-#include "core.h"
-#include "tabpopup.h"
-/* FIXME these two includes are 100% broken ...
- */
-#include "workspace-private.h"
-#include "frame.h"
-#include "draw-workspace.h"
-#include <gtk/gtk.h>
-#include <math.h>
-
-#define OUTSIDE_SELECT_RECT 2
-#define INSIDE_SELECT_RECT 2
-
-typedef struct _TabEntry TabEntry;
-
-struct _TabEntry
-{
-  MetaTabEntryKey  key;
-  char            *title;
-  GdkPixbuf       *icon, *dimmed_icon;
-  GtkWidget       *widget;
-  GdkRectangle     rect;
-  GdkRectangle     inner_rect;
-  guint blank : 1;
-};
-
-struct _MetaTabPopup
-{
-  GtkWidget *window;
-  GtkWidget *label;
-  GList *current;
-  GList *entries;
-  TabEntry *current_selected_entry;
-  GtkWidget *outline_window;
-  gboolean outline;
-};
-
-static GtkWidget* selectable_image_new (GdkPixbuf *pixbuf);
-static void       select_image         (GtkWidget *widget);
-static void       unselect_image       (GtkWidget *widget);
-
-static GtkWidget* selectable_workspace_new (MetaWorkspace *workspace);
-static void       select_workspace         (GtkWidget *widget);
-static void       unselect_workspace       (GtkWidget *widget);
-
-static gboolean
-outline_window_draw (GtkWidget *widget,
-                     cairo_t   *cr,
-                     gpointer   data)
-{
-  MetaTabPopup *popup;
-  TabEntry *te;
-  
-  popup = data;
-
-  if (!popup->outline || popup->current_selected_entry == NULL)
-    return FALSE;
-
-  te = popup->current_selected_entry;
-
-  cairo_set_line_width (cr, 1.0);
-  cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
-
-  cairo_rectangle (cr,
-                   0.5, 0.5,
-                   te->rect.width - 1,
-                   te->rect.height - 1);
-  cairo_stroke (cr);
-
-  cairo_rectangle (cr,
-                   te->inner_rect.x - 0.5, te->inner_rect.y - 0.5,
-                   te->inner_rect.width + 1,
-                   te->inner_rect.height + 1);
-  cairo_stroke (cr);
-
-  return FALSE;
-}
-
-static GdkPixbuf*
-dimm_icon (GdkPixbuf *pixbuf)
-{
-  int x, y, pixel_stride, row_stride;
-  guchar *row, *pixels;
-  int w, h;
-  GdkPixbuf *dimmed_pixbuf;
-
-  if (gdk_pixbuf_get_has_alpha (pixbuf))
-    {
-      dimmed_pixbuf = gdk_pixbuf_copy (pixbuf);
-    }
-  else
-    {
-      dimmed_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
-    }
-
-  w = gdk_pixbuf_get_width (dimmed_pixbuf);
-  h = gdk_pixbuf_get_height (dimmed_pixbuf);      
-
-  pixel_stride = 4;
-
-  row = gdk_pixbuf_get_pixels (dimmed_pixbuf);
-  row_stride = gdk_pixbuf_get_rowstride (dimmed_pixbuf);
-
-  for (y = 0; y < h; y++)
-    {
-      pixels = row;                     
-      for (x = 0; x < w; x++) 
-        {
-          pixels[3] /= 2;                               
-          pixels += pixel_stride;
-        }                       
-      row += row_stride;
-    }
-  return dimmed_pixbuf;
-}
-
-static TabEntry*  
-tab_entry_new (const MetaTabEntry *entry, 
-               gint                screen_width,
-               gboolean            outline)
-{
-  TabEntry *te;
-  
-  te = g_new (TabEntry, 1);
-  te->key = entry->key;
-  te->title = NULL;
-  if (entry->title)
-    {
-      gchar *str;
-      gchar *tmp;
-      gchar *formatter = "%s";
-
-      str = meta_g_utf8_strndup (entry->title, 4096);
-
-      if (entry->hidden)
-        {
-          formatter = "[%s]";
-        }
-
-      tmp = g_markup_printf_escaped (formatter, str);
-      g_free (str);
-      str = tmp;
-
-      if (entry->demands_attention) 
-        {         
-          /* Escape the whole line of text then markup the text and 
-           * copy it back into the original buffer.
-           */
-          tmp = g_strdup_printf ("<b>%s</b>", str);
-          g_free (str);
-          str = tmp;
-        }
-
-        te->title=g_strdup(str);
-
-      g_free (str);
-    }
-  te->widget = NULL;
-  te->icon = entry->icon;
-  te->blank = entry->blank;
-  te->dimmed_icon = NULL;
-  if (te->icon)
-    {
-      g_object_ref (G_OBJECT (te->icon));
-      if (entry->hidden)
-        te->dimmed_icon = dimm_icon (entry->icon);
-    }
-  
-  if (outline)
-    {
-      te->rect.x = entry->rect.x;
-      te->rect.y = entry->rect.y;
-      te->rect.width = entry->rect.width;
-      te->rect.height = entry->rect.height;
-
-      te->inner_rect.x = entry->inner_rect.x;
-      te->inner_rect.y = entry->inner_rect.y;
-      te->inner_rect.width = entry->inner_rect.width;
-      te->inner_rect.height = entry->inner_rect.height;
-    }
-  return te;
-}
-
-MetaTabPopup*
-meta_ui_tab_popup_new (const MetaTabEntry *entries,
-                       int                 screen_number,
-                       int                 entry_count,
-                       int                 width,
-                       gboolean            outline)
-{
-  MetaTabPopup *popup;
-  int i, left, top;
-  int height;
-  GtkWidget *grid;
-  GtkWidget *vbox;
-  GtkWidget *align;
-  GList *tmp;
-  GtkWidget *frame;
-  int max_label_width; /* the actual max width of the labels we create */
-  AtkObject *obj;
-  GdkScreen *screen;
-  int screen_width;
-  
-  popup = g_new (MetaTabPopup, 1);
-
-  popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);
-
-  screen = gdk_display_get_screen (gdk_display_get_default (),
-                                   screen_number);
-  gtk_window_set_screen (GTK_WINDOW (popup->outline_window),
-                         screen);
-
-  gtk_widget_set_app_paintable (popup->outline_window, TRUE);
-  gtk_widget_realize (popup->outline_window);
-
-  g_signal_connect (G_OBJECT (popup->outline_window), "draw",
-                    G_CALLBACK (outline_window_draw), popup);
-  
-  popup->window = gtk_window_new (GTK_WINDOW_POPUP);
-
-  gtk_window_set_screen (GTK_WINDOW (popup->window),
-                         screen);
-
-  gtk_window_set_position (GTK_WINDOW (popup->window),
-                           GTK_WIN_POS_CENTER_ALWAYS);
-  /* enable resizing, to get never-shrink behavior */
-  gtk_window_set_resizable (GTK_WINDOW (popup->window),
-                            TRUE);
-  popup->current = NULL;
-  popup->entries = NULL;
-  popup->current_selected_entry = NULL;
-  popup->outline = outline;
-
-  screen_width = gdk_screen_get_width (screen);
-  for (i = 0; i < entry_count; ++i)
-    {
-      TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline);
-      popup->entries = g_list_prepend (popup->entries, new_entry);
-    }
-
-  popup->entries = g_list_reverse (popup->entries);
-    
-  g_assert (width > 0);
-  height = i / width;
-  if (i % width)
-    height += 1;
-
-  grid = gtk_grid_new ();
-  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-  
-  frame = gtk_frame_new (NULL);
-  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
-  gtk_container_set_border_width (GTK_CONTAINER (grid), 1);
-  gtk_container_add (GTK_CONTAINER (popup->window),
-                     frame);
-  gtk_container_add (GTK_CONTAINER (frame),
-                     vbox);
-
-  align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
-
-  gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
-
-  gtk_container_add (GTK_CONTAINER (align),
-                     grid);
-
-  popup->label = gtk_label_new ("");
-
-  /* Set the accessible role of the label to a status bar so it
-   * will emit name changed events that can be used by screen
-   * readers.
-   */
-  obj = gtk_widget_get_accessible (popup->label);
-  atk_object_set_role (obj, ATK_ROLE_STATUSBAR);
-
-  gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3);
-
-  gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0);
-
-  max_label_width = 0;
-  top = 0;
-  tmp = popup->entries;
-
-  while (tmp && top < height)
-    {      
-      left = 0;
-
-      while (tmp && left < width)
-        {
-          GtkWidget *image;
-          GtkRequisition req;
-
-          TabEntry *te;
-
-          te = tmp->data;
-
-          if (te->blank)
-            {
-              /* just stick a widget here to avoid special cases */
-              image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
-            }
-          else if (outline)
-            {
-              if (te->dimmed_icon)
-                {
-                  image = selectable_image_new (te->dimmed_icon);
-                }
-              else 
-                {
-                  image = selectable_image_new (te->icon);
-                }
-
-              gtk_misc_set_padding (GTK_MISC (image),
-                                    INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,
-                                    INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);
-              gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
-            }   
-          else
-            {
-              image = selectable_workspace_new ((MetaWorkspace *) te->key);
-            }
-
-          te->widget = image;
-
-          gtk_grid_attach (GTK_GRID (grid),
-                           te->widget,
-                           left, top, 1, 1);
-
-          /* Efficiency rules! */
-          gtk_label_set_markup (GTK_LABEL (popup->label),
-                              te->title);
-          gtk_widget_get_preferred_size (popup->label, &req, NULL);
-          max_label_width = MAX (max_label_width, req.width);
-          
-          tmp = tmp->next;
-          
-          ++left;
-        }
-      
-      ++top;
-    }
-
-  /* remove all the temporary text */
-  gtk_label_set_text (GTK_LABEL (popup->label), "");
-  /* Make it so that we ellipsize if the text is too long */
-  gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);
-
-  /* Limit the window size to no bigger than screen_width/4 */
-  if (max_label_width>(screen_width/4)) 
-    {
-      max_label_width = screen_width/4;
-    }
-
-  max_label_width += 20; /* add random padding */
-  
-  gtk_window_set_default_size (GTK_WINDOW (popup->window),
-                               max_label_width,
-                               -1);
-  
-  return popup;
-}
-
-static void
-free_tab_entry (gpointer data, gpointer user_data)
-{
-  TabEntry *te;
-
-  te = data;
-  
-  g_free (te->title);
-  if (te->icon)
-    g_object_unref (G_OBJECT (te->icon));
-  if (te->dimmed_icon)
-    g_object_unref (G_OBJECT (te->dimmed_icon));
-
-  g_free (te);
-}
-
-void
-meta_ui_tab_popup_free (MetaTabPopup *popup)
-{
-  meta_verbose ("Destroying tab popup window\n");
-
-  if (!popup)
-    {
-      meta_warning ("NULL passed to meta_ui_tab_popup_free\n");
-      return;
-    }
-  
-  gtk_widget_destroy (popup->outline_window);
-  gtk_widget_destroy (popup->window);
-  
-  g_list_foreach (popup->entries, free_tab_entry, NULL);
-
-  g_list_free (popup->entries);
-  
-  g_free (popup);
-}
-
-void
-meta_ui_tab_popup_set_showing (MetaTabPopup *popup,
-                               gboolean      showing)
-{
-  if (showing)
-    {
-      gtk_widget_show_all (popup->window);
-    }
-  else
-    {
-      if (gtk_widget_get_visible (popup->window))
-        {
-          meta_verbose ("Hiding tab popup window\n");
-          gtk_widget_hide (popup->window);
-          meta_core_increment_event_serial (
-              GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
-        }
-    }
-}
-
-static void
-display_entry (MetaTabPopup *popup,
-               TabEntry     *te)
-{
-  GdkRectangle rect;
-  GdkWindow *window;
-
-  
-  if (popup->current_selected_entry)
-  {
-    if (popup->outline)
-      unselect_image (popup->current_selected_entry->widget);
-    else
-      unselect_workspace (popup->current_selected_entry->widget);
-  }
-  
-  gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
-
-  if (popup->outline)
-    select_image (te->widget);
-  else
-    select_workspace (te->widget);
-
-  if (popup->outline)
-    {
-      cairo_region_t *region;
-      cairo_region_t *inner_region;
-      GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
-
-      window = gtk_widget_get_window (popup->outline_window);
-
-      /* Do stuff behind gtk's back */
-      gdk_window_hide (window);
-      meta_core_increment_event_serial (
-          GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
-  
-      rect = te->rect;
-      rect.x = 0;
-      rect.y = 0;
-
-      gdk_window_move_resize (window,
-                              te->rect.x, te->rect.y,
-                              te->rect.width, te->rect.height);
-  
-      gdk_window_set_background_rgba (window, &black);
-
-
-      region = cairo_region_create_rectangle (&rect);
-      inner_region = cairo_region_create_rectangle (&te->inner_rect);
-      cairo_region_subtract (region, inner_region);
-      cairo_region_destroy (inner_region);
-
-      gdk_window_shape_combine_region (window,
-                                       region,
-                                       0, 0);
-
-      cairo_region_destroy (region);
-    
-
-      /* This should piss off gtk a bit, but we don't want to raise
-       * above the tab popup.  So, instead of calling gtk_widget_show,
-       * we manually set the window as mapped and then manually map it
-       * with gdk functions.
-       */
-      gtk_widget_set_mapped (popup->outline_window, TRUE);
-      gdk_window_show_unraised (window);
-    }
-
-  /* Must be before we handle an expose for the outline window */
-  popup->current_selected_entry = te;
-}
-
-void
-meta_ui_tab_popup_forward (MetaTabPopup *popup)
-{
-  if (popup->current != NULL)
-    popup->current = popup->current->next;
-
-  if (popup->current == NULL)
-    popup->current = popup->entries;
-  
-  if (popup->current != NULL)
-    {
-      TabEntry *te;
-
-      te = popup->current->data;
-
-      display_entry (popup, te);
-    }
-}
-
-void
-meta_ui_tab_popup_backward (MetaTabPopup *popup)
-{
-  if (popup->current != NULL)
-    popup->current = popup->current->prev;
-
-  if (popup->current == NULL)
-    popup->current = g_list_last (popup->entries);
-  
-  if (popup->current != NULL)
-    {
-      TabEntry *te;
-
-      te = popup->current->data;
-
-      display_entry (popup, te);
-    }
-}
-
-MetaTabEntryKey
-meta_ui_tab_popup_get_selected (MetaTabPopup *popup)
-{
-  if (popup->current)
-    {
-      TabEntry *te;
-
-      te = popup->current->data;
-
-      return te->key;
-    }
-  else
-    return (MetaTabEntryKey)None;
-}
-
-void
-meta_ui_tab_popup_select (MetaTabPopup *popup,
-                          MetaTabEntryKey key)
-{
-  GList *tmp;
-
-  /* Note, "key" may not be in the list of entries; other code assumes
-   * it's OK to pass in a key that isn't.
-   */
-  
-  tmp = popup->entries;
-  while (tmp != NULL)
-    {
-      TabEntry *te;
-
-      te = tmp->data;
-
-      if (te->key == key)
-        {
-          popup->current = tmp;
-          
-          display_entry (popup, te);
-
-          return;
-        }
-      
-      tmp = tmp->next;
-    }
-}
-
-#define META_TYPE_SELECT_IMAGE            (meta_select_image_get_type ())
-#define META_SELECT_IMAGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SELECT_IMAGE, MetaSelectImage))
-
-typedef struct _MetaSelectImage       MetaSelectImage;
-typedef struct _MetaSelectImageClass  MetaSelectImageClass;
-
-struct _MetaSelectImage
-{
-  GtkImage parent_instance;
-  guint selected : 1;
-};
-
-struct _MetaSelectImageClass
-{
-  GtkImageClass parent_class;
-};
-
-
-static GType meta_select_image_get_type (void) G_GNUC_CONST;
-
-static GtkWidget*
-selectable_image_new (GdkPixbuf *pixbuf)
-{
-  GtkWidget *w;
-
-  w = g_object_new (meta_select_image_get_type (), NULL);
-  gtk_image_set_from_pixbuf (GTK_IMAGE (w), pixbuf); 
-
-  return w;
-}
-
-static void
-select_image (GtkWidget *widget)
-{
-  META_SELECT_IMAGE (widget)->selected = TRUE;
-  gtk_widget_queue_draw (widget);
-}
-
-static void
-unselect_image (GtkWidget *widget)
-{
-  META_SELECT_IMAGE (widget)->selected = FALSE;
-  gtk_widget_queue_draw (widget);
-}
-
-static void     meta_select_image_class_init   (MetaSelectImageClass *klass);
-static gboolean meta_select_image_draw         (GtkWidget            *widget,
-                                                cairo_t              *cr);
-
-static GtkImageClass *parent_class;
-
-GType
-meta_select_image_get_type (void)
-{
-  static GType image_type = 0;
-
-  if (!image_type)
-    {
-      static const GTypeInfo image_info =
-      {
-        sizeof (MetaSelectImageClass),
-        NULL,           /* base_init */
-        NULL,           /* base_finalize */
-        (GClassInitFunc) meta_select_image_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (MetaSelectImage),
-        16,             /* n_preallocs */
-        (GInstanceInitFunc) NULL,
-      };
-
-      image_type = g_type_register_static (GTK_TYPE_IMAGE, "MetaSelectImage", &image_info, 0);
-    }
-
-  return image_type;
-}
-
-static void
-meta_select_image_class_init (MetaSelectImageClass *klass)
-{
-  GtkWidgetClass *widget_class;
-  
-  parent_class = g_type_class_peek (gtk_image_get_type ());
-
-  widget_class = GTK_WIDGET_CLASS (klass);
-  
-  widget_class->draw = meta_select_image_draw;
-}
-
-static gboolean
-meta_select_image_draw (GtkWidget *widget,
-                        cairo_t   *cr)
-{
-  GtkAllocation allocation;
-
-  gtk_widget_get_allocation (widget, &allocation);
-
-  if (META_SELECT_IMAGE (widget)->selected)
-    {
-      GtkMisc *misc;
-      GtkRequisition requisition;
-      GtkStyleContext *context;
-      GdkRGBA color;
-      int x, y, w, h;
-      gint xpad, ypad;
-      gfloat xalign, yalign;
-
-      misc = GTK_MISC (widget);
-
-      gtk_widget_get_requisition (widget, &requisition);
-      gtk_misc_get_alignment (misc, &xalign, &yalign);
-      gtk_misc_get_padding (misc, &xpad, &ypad);
-      
-      x = (allocation.width - (requisition.width - xpad * 2)) * xalign + 0.5;
-      y = (allocation.height - (requisition.height - ypad * 2)) * yalign + 0.5;
-
-      x -= INSIDE_SELECT_RECT + 1;
-      y -= INSIDE_SELECT_RECT + 1;      
-      
-      w = requisition.width - OUTSIDE_SELECT_RECT * 2 - 1;
-      h = requisition.height - OUTSIDE_SELECT_RECT * 2 - 1;
-
-      context = gtk_widget_get_style_context (widget);
-
-      gtk_style_context_set_state (context,
-                                   gtk_widget_get_state_flags (widget));
-
-      gtk_style_context_lookup_color (context, "color", &color);
-
-      cairo_set_line_width (cr, 2.0);
-      cairo_set_source_rgb (cr, color.red, color.green, color.blue);
-
-      cairo_rectangle (cr, x, y, w + 1, h + 1);
-      cairo_stroke (cr);
-
-      cairo_set_line_width (cr, 1.0);
-    }
-
-  return GTK_WIDGET_CLASS (parent_class)->draw (widget, cr);
-}
-
-#define META_TYPE_SELECT_WORKSPACE   (meta_select_workspace_get_type ())
-#define META_SELECT_WORKSPACE(obj)   (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SELECT_WORKSPACE, MetaSelectWorkspace))
-
-typedef struct _MetaSelectWorkspace       MetaSelectWorkspace;
-typedef struct _MetaSelectWorkspaceClass  MetaSelectWorkspaceClass;
-
-struct _MetaSelectWorkspace
-{
-  GtkDrawingArea parent_instance;
-  MetaWorkspace *workspace;
-  guint selected : 1;
-};
-
-struct _MetaSelectWorkspaceClass
-{
-  GtkDrawingAreaClass parent_class;
-};
-
-
-static GType meta_select_workspace_get_type (void) G_GNUC_CONST;
-
-#define SELECT_OUTLINE_WIDTH 2
-#define MINI_WORKSPACE_WIDTH 48
-
-static GtkWidget*
-selectable_workspace_new (MetaWorkspace *workspace)
-{
-  GtkWidget *widget;
-  double screen_aspect;
-  
-  widget = g_object_new (meta_select_workspace_get_type (), NULL);
-
-  screen_aspect = (double) workspace->screen->rect.height /
-                  (double) workspace->screen->rect.width;
-  
-  /* account for select rect */ 
-  gtk_widget_set_size_request (widget,
-                               MINI_WORKSPACE_WIDTH + SELECT_OUTLINE_WIDTH * 2,
-                               MINI_WORKSPACE_WIDTH * screen_aspect + SELECT_OUTLINE_WIDTH * 2);
-
-  META_SELECT_WORKSPACE (widget)->workspace = workspace;
-
-  return widget;
-}
-
-static void
-select_workspace (GtkWidget *widget)
-{
-  META_SELECT_WORKSPACE(widget)->selected = TRUE;
-  gtk_widget_queue_draw (widget);
-}
-
-static void
-unselect_workspace (GtkWidget *widget)
-{
-  META_SELECT_WORKSPACE (widget)->selected = FALSE;
-  gtk_widget_queue_draw (widget);
-}
-
-static void meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass);
-
-static gboolean meta_select_workspace_draw         (GtkWidget      *widget,
-                                                    cairo_t        *cr);
-
-GType
-meta_select_workspace_get_type (void)
-{
-  static GType workspace_type = 0;
-
-  if (!workspace_type)
-    {
-      static const GTypeInfo workspace_info =
-      {
-        sizeof (MetaSelectWorkspaceClass),
-        NULL,           /* base_init */
-        NULL,           /* base_finalize */
-        (GClassInitFunc) meta_select_workspace_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (MetaSelectWorkspace),
-        16,             /* n_preallocs */
-        (GInstanceInitFunc) NULL,
-      };
-
-      workspace_type = g_type_register_static (GTK_TYPE_DRAWING_AREA, 
-                                               "MetaSelectWorkspace", 
-                                               &workspace_info, 
-                                               0);
-    }
-
-  return workspace_type;
-}
-
-static void
-meta_select_workspace_class_init (MetaSelectWorkspaceClass *klass)
-{
-  GtkWidgetClass *widget_class;
-  
-  widget_class = GTK_WIDGET_CLASS (klass);
-  
-  widget_class->draw = meta_select_workspace_draw;
-}
-
-/**
- * meta_convert_meta_to_wnck:
- * @window: the #MetaWindow
- * @screen: the #MetaScreen the window is on
- *
- * Converts a #MetaWindow to a #WnckWindowDisplayInfo window
- * that is used to build a thumbnail of a workspace.
- **/
-static WnckWindowDisplayInfo
-meta_convert_meta_to_wnck (MetaWindow *window, MetaScreen *screen)
-{
-  WnckWindowDisplayInfo wnck_window;
-  wnck_window.icon = window->icon;
-  wnck_window.mini_icon = window->mini_icon;
-  wnck_window.is_active = window->has_focus;
-
-  if (window->frame)
-    {
-      wnck_window.x = window->frame->rect.x;
-      wnck_window.y = window->frame->rect.y;
-      wnck_window.width = window->frame->rect.width;
-      wnck_window.height = window->frame->rect.height;
-    }
-  else
-    {
-      wnck_window.x = window->rect.x;
-      wnck_window.y = window->rect.y;
-      wnck_window.width = window->rect.width;
-      wnck_window.height = window->rect.height;
-    }
-  return wnck_window;
-}
-
-
-static gboolean
-meta_select_workspace_draw (GtkWidget *widget,
-                            cairo_t   *cr)
-{
-  MetaWorkspace *workspace;
-  WnckWindowDisplayInfo *windows;
-  GtkAllocation allocation;
-  int i, n_windows;
-  GList *tmp, *list;
-
-  workspace = META_SELECT_WORKSPACE (widget)->workspace;
-              
-  list = meta_stack_list_windows (workspace->screen->stack, workspace);
-  n_windows = g_list_length (list);
-  windows = g_new (WnckWindowDisplayInfo, n_windows);
-
-  tmp = list;
-  i = 0;
-  while (tmp != NULL)
-    {
-      MetaWindow *window;
-      gboolean ignoreable_sticky;
-
-      window = tmp->data;
-
-      ignoreable_sticky = window->on_all_workspaces &&
-                          workspace != workspace->screen->active_workspace;
-
-      if (window->skip_pager || 
-          !meta_window_showing_on_its_workspace (window) ||
-          window->unmaps_pending ||
-          ignoreable_sticky)
-        {
-          --n_windows;
-        }
-      else
-        {
-          windows[i] = meta_convert_meta_to_wnck (window, workspace->screen);
-          i++;
-        }
-      tmp = tmp->next;
-    }
-
-  g_list_free (list);
-
-  gtk_widget_get_allocation (widget, &allocation);
-
-  wnck_draw_workspace (widget,
-                       cr,
-                       SELECT_OUTLINE_WIDTH,
-                       SELECT_OUTLINE_WIDTH,
-                       allocation.width - SELECT_OUTLINE_WIDTH * 2,
-                       allocation.height - SELECT_OUTLINE_WIDTH * 2,
-                       workspace->screen->rect.width,
-                       workspace->screen->rect.height,
-                       NULL,
-                       (workspace->screen->active_workspace == workspace),
-                       windows,
-                       n_windows);
-
-  g_free (windows);
-  
-  if (META_SELECT_WORKSPACE (widget)->selected)
-    {
-      GtkStyleContext *context;
-      GdkRGBA color;
-
-      context = gtk_widget_get_style_context (widget);
-
-      gtk_style_context_set_state (context,
-                                   gtk_widget_get_state_flags (widget));
-
-      gtk_style_context_lookup_color (context, "color", &color);
-
-      cairo_set_line_width (cr, SELECT_OUTLINE_WIDTH);
-      cairo_set_source_rgb (cr, color.red, color.green, color.blue);
-
-      cairo_rectangle (cr,
-                       SELECT_OUTLINE_WIDTH / 2.0, SELECT_OUTLINE_WIDTH / 2.0,
-                       allocation.width - SELECT_OUTLINE_WIDTH,
-                       allocation.height - SELECT_OUTLINE_WIDTH);
-      cairo_stroke (cr);
-    }
-
-  return TRUE;
-}

src/ui/tabpopup.h

@@ -1,65 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Mutter tab popup window */
-
-/* 
- * Copyright (C) 2001 Havoc Pennington
- * Copyright (C) 2005 Elijah Newren
- * 
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef META_TABPOPUP_H
-#define META_TABPOPUP_H
-
-/* Don't include gtk.h or gdk.h here */
-#include <meta/common.h>
-#include <meta/boxes.h>
-#include <X11/Xlib.h>
-#include <glib.h>
-#include <gdk-pixbuf/gdk-pixbuf.h>
-
-typedef struct _MetaTabEntry MetaTabEntry;
-typedef struct _MetaTabPopup MetaTabPopup;
-typedef void *MetaTabEntryKey;
-
-struct _MetaTabEntry
-{
-  MetaTabEntryKey  key;  
-  const char      *title;
-  GdkPixbuf       *icon;
-  MetaRectangle    rect;
-  MetaRectangle    inner_rect;
-  guint            blank : 1;
-  guint            hidden : 1;
-  guint            demands_attention : 1;
-};
-
-MetaTabPopup*   meta_ui_tab_popup_new          (const MetaTabEntry *entries,
-                                                int                 screen_number,
-                                                int                 entry_count,
-                                                int                 width,
-                                                gboolean            outline);
-void            meta_ui_tab_popup_free         (MetaTabPopup       *popup);
-void            meta_ui_tab_popup_set_showing  (MetaTabPopup       *popup,
-                                                gboolean            showing);
-void            meta_ui_tab_popup_forward      (MetaTabPopup       *popup);
-void            meta_ui_tab_popup_backward     (MetaTabPopup       *popup);
-MetaTabEntryKey meta_ui_tab_popup_get_selected (MetaTabPopup      *popup);
-void            meta_ui_tab_popup_select       (MetaTabPopup       *popup,
-                                                MetaTabEntryKey     key);
-
-
-#endif
-

src/ui/tile-preview.c

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

src/ui/tile-preview.h

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

src/ui/ui.c

@@ -295,9 +295,12 @@ meta_ui_new (Display *xdisplay,
   g_assert (gdisplay == gdk_display_get_default ());
 
   ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
-  /* 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+ 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.
+   */
   gtk_widget_show (GTK_WIDGET (ui->frames));
 
   g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
@@ -511,40 +514,6 @@ meta_ui_set_frame_title (MetaUI     *ui,
   meta_frames_set_title (ui->frames, xwindow, title);
 }
 
-MetaWindowMenu*
-meta_ui_window_menu_new  (MetaUI             *ui,
-                          Window              client_xwindow,
-                          MetaMenuOp          ops,
-                          MetaMenuOp          insensitive,
-                          unsigned long       active_workspace,
-                          int                 n_workspaces,
-                          MetaWindowMenuFunc  func,
-                          gpointer            data)
-{
-  return meta_window_menu_new (ui->frames,
-                               ops, insensitive,
-                               client_xwindow,
-                               active_workspace,
-                               n_workspaces,
-                               func, data);
-}
-
-void
-meta_ui_window_menu_popup (MetaWindowMenu     *menu,
-                           int                 root_x,
-                           int                 root_y,
-                           int                 button,
-                           guint32             timestamp)
-{
-  meta_window_menu_popup (menu, root_x, root_y, button, timestamp);
-}
-
-void
-meta_ui_window_menu_free (MetaWindowMenu *menu)
-{
-  meta_window_menu_free (menu);
-}
-
 GdkPixbuf*
 meta_gdk_pixbuf_get_from_pixmap (Pixmap       xpixmap,
                                  int          src_x,

src/ui/ui.h

@@ -120,21 +120,6 @@ void meta_ui_update_frame_style (MetaUI  *ui,
 void meta_ui_repaint_frame (MetaUI *ui,
                             Window xwindow);
 
-MetaWindowMenu* meta_ui_window_menu_new   (MetaUI             *ui,
-                                           Window              client_xwindow,
-                                           MetaMenuOp          ops,
-                                           MetaMenuOp          insensitive,
-                                           unsigned long       active_workspace,
-                                           int                 n_workspaces,
-                                           MetaWindowMenuFunc  func,
-                                           gpointer            data);
-void            meta_ui_window_menu_popup (MetaWindowMenu     *menu,
-                                           int                 root_x,
-                                           int                 root_y,
-                                           int                 button,
-                                           guint32             timestamp);
-void            meta_ui_window_menu_free  (MetaWindowMenu     *menu);
-
 
 /* FIXME these lack a display arg */
 GdkPixbuf* meta_gdk_pixbuf_get_from_pixmap (Pixmap       xpixmap,
@@ -178,7 +163,4 @@ int      meta_ui_get_drag_threshold       (MetaUI *ui);
 
 MetaUIDirection meta_ui_get_direction (void);
 
-#include "tabpopup.h"
-#include "tile-preview.h"
-
 #endif

src/wayland/meta-login1.c

@@ -0,0 +1,441 @@
+/*
+ * Copyright (C) 2014 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "meta-login1.h"
+
+#include "meta-dbus-login1.h"
+
+#include "meta-wayland-private.h"
+#include "meta-cursor-tracker-private.h"
+
+#include <gio/gunixfdlist.h>
+
+#include <clutter/clutter.h>
+#include <clutter/evdev/clutter-evdev.h>
+#include <clutter/egl/clutter-egl.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <malloc.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <systemd/sd-login.h>
+
+struct _MetaLogin1
+{
+  Login1Session *session_proxy;
+  Login1Seat *seat_proxy;
+
+  gboolean session_active;
+};
+
+/* Stolen from tp_escape_as_identifier, from tp-glib,
+ * which follows the same escaping convention as systemd.
+ */
+static inline gboolean
+_esc_ident_bad (gchar c, gboolean is_first)
+{
+  return ((c < 'a' || c > 'z') &&
+          (c < 'A' || c > 'Z') &&
+          (c < '0' || c > '9' || is_first));
+}
+
+static gchar *
+escape_dbus_component (const gchar *name)
+{
+  gboolean bad = FALSE;
+  size_t len = 0;
+  GString *op;
+  const gchar *ptr, *first_ok;
+
+  g_return_val_if_fail (name != NULL, NULL);
+
+  /* fast path for empty name */
+  if (name[0] == '\0')
+    return g_strdup ("_");
+
+  for (ptr = name; *ptr; ptr++)
+    {
+      if (_esc_ident_bad (*ptr, ptr == name))
+        {
+          bad = TRUE;
+          len += 3;
+        }
+      else
+        len++;
+    }
+
+  /* fast path if it's clean */
+  if (!bad)
+    return g_strdup (name);
+
+  /* If strictly less than ptr, first_ok is the first uncopied safe character.
+   */
+  first_ok = name;
+  op = g_string_sized_new (len);
+  for (ptr = name; *ptr; ptr++)
+    {
+      if (_esc_ident_bad (*ptr, ptr == name))
+        {
+          /* copy preceding safe characters if any */
+          if (first_ok < ptr)
+            {
+              g_string_append_len (op, first_ok, ptr - first_ok);
+            }
+          /* escape the unsafe character */
+          g_string_append_printf (op, "_%02x", (unsigned char)(*ptr));
+          /* restart after it */
+          first_ok = ptr + 1;
+        }
+    }
+  /* copy trailing safe characters if any */
+  if (first_ok < ptr)
+    {
+      g_string_append_len (op, first_ok, ptr - first_ok);
+    }
+  return g_string_free (op, FALSE);
+}
+
+static char *
+get_escaped_dbus_path (const char *prefix,
+                       const char *component)
+{
+  char *escaped_component = escape_dbus_component (component);
+  char *path = g_strconcat (prefix, "/", component, NULL);
+
+  g_free (escaped_component);
+  return path;
+}
+
+static Login1Session *
+get_session_proxy (GCancellable *cancellable)
+{
+  char *proxy_path;
+  char *session_id;
+  Login1Session *session_proxy;
+
+  if (sd_pid_get_session (getpid (), &session_id) < 0)
+    return NULL;
+
+  proxy_path = get_escaped_dbus_path ("/org/freedesktop/login1/session", session_id);
+
+  session_proxy = login1_session_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+                                                         G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                                                         "org.freedesktop.login1",
+                                                         proxy_path,
+                                                         cancellable, NULL);
+  free (proxy_path);
+
+  return session_proxy;
+}
+
+static Login1Seat *
+get_seat_proxy (GCancellable *cancellable)
+{
+  return login1_seat_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+                                             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                                             "org.freedesktop.login1",
+                                             "/org/freedesktop/login1/seat/self",
+                                             cancellable, NULL);
+}
+
+static void
+session_unpause (void)
+{
+  ClutterBackend *backend;
+  CoglContext *cogl_context;
+  CoglDisplay *cogl_display;
+
+  backend = clutter_get_default_backend ();
+  cogl_context = clutter_backend_get_cogl_context (backend);
+  cogl_display = cogl_context_get_display (cogl_context);
+  cogl_kms_display_queue_modes_reset (cogl_display);
+
+  clutter_set_paused (FALSE);
+  /* 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 quueed 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
+session_pause (void)
+{
+  clutter_set_paused (TRUE);
+  /* clutter_evdev_release_devices (); */
+}
+
+static void
+sync_active (MetaLogin1 *self)
+{
+  gboolean active = login1_session_get_active (LOGIN1_SESSION (self->session_proxy));
+
+  if (active == self->session_active)
+    return;
+
+  self->session_active = active;
+
+  if (active)
+    session_unpause ();
+  else
+    session_pause ();
+}
+
+static void
+on_active_changed (Login1Session *session,
+                   GParamSpec    *pspec,
+                   gpointer       user_data)
+{
+  MetaLogin1 *self = user_data;
+  sync_active (self);
+}
+
+static gboolean
+take_device (Login1Session *session_proxy,
+             int            dev_major,
+             int            dev_minor,
+             int           *out_fd,
+             GCancellable  *cancellable,
+             GError       **error)
+{
+  gboolean ret = FALSE;
+  GVariant *fd_variant = NULL;
+  int fd = -1;
+  GUnixFDList *fd_list;
+
+  if (!login1_session_call_take_device_sync (session_proxy,
+                                             dev_major,
+                                             dev_minor,
+                                             NULL,
+                                             &fd_variant,
+                                             NULL, /* paused */
+                                             &fd_list,
+                                             cancellable,
+                                             error))
+    goto out;
+
+  fd = g_unix_fd_list_get (fd_list, g_variant_get_handle (fd_variant), error);
+  if (fd == -1)
+    goto out;
+
+  *out_fd = fd;
+  ret = TRUE;
+
+ out:
+  if (fd_variant)
+    g_variant_unref (fd_variant);
+  if (fd_list)
+    g_object_unref (fd_list);
+  return ret;
+}
+
+static gboolean
+get_device_info_from_path (const char *path,
+                           int        *out_major,
+                           int        *out_minor)
+{
+  gboolean ret = FALSE;
+  int r;
+  struct stat st;
+
+  r = stat (path, &st);
+  if (r < 0)
+    goto out;
+  if (!S_ISCHR (st.st_mode))
+    goto out;
+
+  *out_major = major (st.st_rdev);
+  *out_minor = minor (st.st_rdev);
+  ret = TRUE;
+
+ out:
+  return ret;
+}
+
+static gboolean
+get_device_info_from_fd (int  fd,
+                         int *out_major,
+                         int *out_minor)
+{
+  gboolean ret = FALSE;
+  int r;
+  struct stat st;
+
+  r = fstat (fd, &st);
+  if (r < 0)
+    goto out;
+  if (!S_ISCHR (st.st_mode))
+    goto out;
+
+  *out_major = major (st.st_rdev);
+  *out_minor = minor (st.st_rdev);
+  ret = TRUE;
+
+ out:
+  return ret;
+}
+
+static int
+open_evdev_device (const char  *path,
+                   int          flags,
+                   gpointer     user_data,
+                   GError     **error)
+{
+  MetaLogin1 *self = user_data;
+  int fd;
+  int major, minor;
+
+  if (!get_device_info_from_path (path, &major, &minor))
+    {
+      g_set_error (error,
+                   G_IO_ERROR,
+                   G_IO_ERROR_NOT_FOUND,
+                   "Could not get device info for path %s: %m", path);
+      return -1;
+    }
+
+  if (!take_device (self->session_proxy, major, minor, &fd, NULL, error))
+    return -1;
+
+  return fd;
+}
+
+static void
+close_evdev_device (int      fd,
+                    gpointer user_data)
+{
+  MetaLogin1 *self = user_data;
+  int major, minor;
+  GError *error = NULL;
+
+  if (!get_device_info_from_fd (fd, &major, &minor))
+    {
+      g_warning ("Could not get device info for fd %d: %m", fd);
+      return;
+    }
+
+  if (!login1_session_call_release_device_sync (self->session_proxy,
+                                                major, minor,
+                                                NULL, &error))
+    {
+      g_warning ("Could not release device %d,%d: %s", major, minor, error->message);
+    }
+}
+
+static gboolean
+get_kms_fd (Login1Session *session_proxy,
+            int *fd_out)
+{
+  int major, minor;
+  int fd;
+  GError *error = NULL;
+
+  /* XXX -- use udev to find the DRM master device */
+  if (!get_device_info_from_path ("/dev/dri/card0", &major, &minor))
+    {
+      g_warning ("Could not stat /dev/dri/card0: %m");
+      return FALSE;
+    }
+
+  if (!take_device (session_proxy, major, minor, &fd, NULL, &error))
+    {
+      g_warning ("Could not open DRM device: %s\n", error->message);
+      g_error_free (error);
+      return FALSE;
+    }
+
+  *fd_out = fd;
+
+  return TRUE;
+}
+
+MetaLogin1 *
+meta_login1_new (void)
+{
+  MetaLogin1 *self;
+  Login1Session *session_proxy;
+  GError *error = NULL;
+  int kms_fd;
+
+  session_proxy = get_session_proxy (NULL);
+  if (!login1_session_call_take_control_sync (session_proxy, FALSE, NULL, &error))
+    {
+      g_warning ("Could not take control: %s", error->message);
+      g_error_free (error);
+      return NULL;
+    }
+
+  if (!get_kms_fd (session_proxy, &kms_fd))
+    return NULL;
+
+  self = g_slice_new0 (MetaLogin1);
+  self->session_proxy = session_proxy;
+  self->seat_proxy = get_seat_proxy (NULL);
+
+  /* Clutter/Cogl start out in a state that assumes the session is active */
+  self->session_active = TRUE;
+
+  clutter_egl_set_kms_fd (kms_fd);
+  clutter_evdev_set_device_callbacks (open_evdev_device,
+                                      close_evdev_device,
+                                      self);
+
+  g_signal_connect (self->session_proxy, "notify::active", G_CALLBACK (on_active_changed), self);
+  sync_active (self);
+
+  return self;
+}
+
+void
+meta_login1_free (MetaLogin1 *self)
+{
+  g_object_unref (self->seat_proxy);
+  g_object_unref (self->session_proxy);
+  g_slice_free (MetaLogin1, self);
+}
+
+gboolean
+meta_login1_activate_session (MetaLogin1  *self,
+                              GError     **error)
+{
+  if (!login1_session_call_activate_sync (self->session_proxy, NULL, error))
+    return FALSE;
+
+  sync_active (self);
+  return TRUE;
+}
+
+gboolean
+meta_login1_activate_vt (MetaLogin1  *self,
+                         int          vt,
+                         GError     **error)
+{
+  return login1_seat_call_switch_to_sync (self->seat_proxy, vt, NULL, error);
+}

src/wayland/meta-login1.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2014 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_LOGIN1_H
+#define META_LOGIN1_H
+
+#include <glib-object.h>
+
+typedef struct _MetaLogin1 MetaLogin1;
+
+MetaLogin1 *meta_login1_new              (void);
+void        meta_login1_free             (MetaLogin1  *self);
+gboolean    meta_login1_activate_session (MetaLogin1  *self,
+                                          GError     **error);
+gboolean    meta_login1_activate_vt      (MetaLogin1  *self,
+                                          int          vt,
+                                          GError     **error);
+
+#endif

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)
-    offer->source->accept (offer->source, serial, mime_type);
+    wl_data_source_send_target (offer->source->resource, 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)
-    offer->source->send (offer->source, mime_type, fd);
-  else
-    close (fd);
+    wl_data_source_send_send (offer->source->resource, mime_type, fd);
+
+  close (fd);
 }
 
 static void
@@ -82,7 +82,8 @@ destroy_data_offer (struct wl_resource *resource)
 
   if (offer->source)
     wl_list_remove (&offer->source_destroy_listener.link);
-  free (offer);
+
+  g_slice_free (MetaWaylandDataOffer, offer);
 }
 
 static void
@@ -99,13 +100,9 @@ static struct wl_resource *
 meta_wayland_data_source_send_offer (MetaWaylandDataSource *source,
                                      struct wl_resource *target)
 {
-  MetaWaylandDataOffer *offer;
+  MetaWaylandDataOffer *offer = g_slice_new0 (MetaWaylandDataOffer);
   char **p;
 
-  offer = malloc (sizeof *offer);
-  if (offer == NULL)
-    return NULL;
-
   offer->source = source;
   offer->source_destroy_listener.notify = destroy_offer_data_source;
 
@@ -318,8 +315,12 @@ data_device_start_drag (struct wl_client *client,
 {
   MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
   MetaWaylandDragGrab *drag_grab;
-  /* FIXME: Check that client has implicit grab on the origin
-   * surface that matches the given time. */
+
+  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 the data source type array isn't empty. */
 
@@ -332,6 +333,7 @@ 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)
     {
@@ -375,7 +377,7 @@ destroy_selection_data_source (struct wl_listener *listener, void *data)
     }
 }
 
-void
+static void
 meta_wayland_seat_set_selection (MetaWaylandSeat *seat,
                                  MetaWaylandDataSource *source,
                                  guint32 serial)
@@ -389,7 +391,7 @@ meta_wayland_seat_set_selection (MetaWaylandSeat *seat,
 
   if (seat->selection_data_source)
     {
-      seat->selection_data_source->cancel (seat->selection_data_source);
+      wl_data_source_send_cancelled (seat->selection_data_source->resource);
       wl_list_remove (&seat->selection_data_source_listener.link);
       seat->selection_data_source = NULL;
     }
@@ -449,47 +451,21 @@ static const struct wl_data_device_interface data_device_interface = {
 static void
 destroy_data_source (struct wl_resource *resource)
 {
-  MetaWaylandDataSource *source = wl_container_of (resource, source, resource);
+  MetaWaylandDataSource *source = wl_resource_get_user_data (resource);
   char **p;
 
   wl_array_for_each (p, &source->mime_types) free (*p);
 
   wl_array_release (&source->mime_types);
-}
 
-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);
+  g_slice_free (MetaWaylandDataSource, source);
 }
 
 static void
 create_data_source (struct wl_client *client,
                     struct wl_resource *resource, guint32 id)
 {
-  MetaWaylandDataSource *source;
-
-  source = malloc (sizeof *source);
-  if (source == NULL)
-    {
-      wl_resource_post_no_memory (resource);
-      return;
-    }
+  MetaWaylandDataSource *source = g_slice_new0 (MetaWaylandDataSource);
 
   source->resource = wl_resource_create (client, &wl_data_source_interface,
 					 MIN (META_WL_DATA_SOURCE_VERSION,
@@ -497,10 +473,6 @@ 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);
 }
 

src/wayland/meta-wayland-data-device.h

@@ -33,10 +33,4 @@ 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__ */

src/wayland/meta-wayland-keyboard.c

@@ -60,14 +60,6 @@
 
 #include "meta-wayland-private.h"
 
-static MetaWaylandSeat *
-meta_wayland_keyboard_get_seat (MetaWaylandKeyboard *keyboard)
-{
-  MetaWaylandSeat *seat = wl_container_of (keyboard, seat, keyboard);
-
-  return seat;
-}
-
 static int
 create_anonymous_file (off_t size,
                        GError **error)
@@ -150,20 +142,6 @@ 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)
     {
@@ -225,28 +203,26 @@ err_keymap_str:
   return;
 }
 
-static void
-release_focus (MetaWaylandKeyboard *keyboard)
-{
-  wl_list_remove (&keyboard->focus_surface_listener.link);
-  wl_list_remove (&keyboard->focus_resource_listener.link);
-
-  keyboard->focus_resource = NULL;
-  keyboard->focus_surface = NULL;
-}
-
 static void
 keyboard_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_surface_listener);
-  release_focus (keyboard);
+
+  keyboard->focus_surface = NULL;
+
+  if (keyboard->focus_resource)
+    {
+      wl_list_remove (&keyboard->focus_resource_listener.link);
+      keyboard->focus_resource = NULL;
+    }
 }
 
 static void
 keyboard_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandKeyboard *keyboard = wl_container_of (listener, keyboard, focus_resource_listener);
-  release_focus (keyboard);
+
+  keyboard->focus_resource = NULL;
 }
 
 static gboolean
@@ -291,28 +267,11 @@ default_grab_modifiers (MetaWaylandKeyboardGrab *grab, uint32_t serial,
                         uint32_t mods_locked, uint32_t group)
 {
   MetaWaylandKeyboard *keyboard = grab->keyboard;
-  MetaWaylandSeat *seat = meta_wayland_keyboard_get_seat (keyboard);
-  MetaWaylandPointer *pointer = &seat->pointer;
-  struct wl_resource *resource, *pr;
 
-  resource = keyboard->focus_resource;
-  if (!resource)
-    return;
-
-  wl_keyboard_send_modifiers (resource, serial, mods_depressed,
-                              mods_latched, mods_locked, group);
-
-  if (pointer && pointer->focus_surface && pointer->focus_surface != keyboard->focus_surface)
+  if (keyboard->focus_resource)
     {
-      pr = find_resource_for_surface (&keyboard->resource_list, pointer->focus_surface);
-      if (pr)
-        {
-          wl_keyboard_send_modifiers (pr, serial,
-				      mods_depressed,
-                                      mods_latched,
-                                      mods_locked,
-                                      group);
-        }
+      wl_keyboard_send_modifiers (keyboard->focus_resource, serial, mods_depressed,
+                                  mods_latched, mods_locked, group);
     }
 }
 
@@ -322,31 +281,6 @@ 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)
@@ -527,72 +461,52 @@ void
 meta_wayland_keyboard_set_focus (MetaWaylandKeyboard *keyboard,
                                  MetaWaylandSurface *surface)
 {
-  struct wl_resource *resource;
-  uint32_t serial;
-
   if (keyboard->focus_surface == surface && keyboard->focus_resource != NULL)
     return;
 
-  resource = keyboard->focus_resource;
-  if (resource)
+  if (keyboard->focus_surface != NULL)
     {
-      if (keyboard->focus_surface->resource)
+      if (keyboard->focus_resource)
         {
-          struct wl_client *client = wl_resource_get_client (resource);
-          struct wl_display *display = wl_client_get_display (client);
-          serial = wl_display_next_serial (display);
-          wl_keyboard_send_leave (resource, serial, keyboard->focus_surface->resource);
+          if (keyboard->focus_surface->resource)
+            {
+              struct wl_client *client = wl_resource_get_client (keyboard->focus_resource);
+              struct wl_display *display = wl_client_get_display (client);
+              uint32_t serial = wl_display_next_serial (display);
+              wl_keyboard_send_leave (keyboard->focus_resource, serial, keyboard->focus_surface->resource);
+            }
 
-          meta_wayland_surface_deactivated (keyboard->focus_surface);
+          wl_list_remove (&keyboard->focus_resource_listener.link);
+          keyboard->focus_resource = NULL;
         }
 
-      wl_list_remove (&keyboard->focus_resource_listener.link);
       wl_list_remove (&keyboard->focus_surface_listener.link);
-
-      keyboard->focus_resource = NULL;
       keyboard->focus_surface = NULL;
     }
 
-  resource = find_resource_for_surface (&keyboard->resource_list, surface);
-  if (resource)
+  if (surface != NULL)
     {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-
-      serial = wl_display_next_serial (display);
-
-      /* 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 (resource, serial,
-				      0, 0, 0, 0);
-	  wl_keyboard_send_enter (resource, serial, surface->resource,
-				  &empty);
-	}
-      else
-	{
-	  wl_keyboard_send_modifiers (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 (resource, serial, surface->resource,
-				  &keyboard->keys);
-	}
-
-      meta_wayland_surface_activated (surface);
-
-      keyboard->focus_resource = resource;
       keyboard->focus_surface = surface;
-
-      wl_resource_add_destroy_listener (keyboard->focus_resource, &keyboard->focus_resource_listener);
       wl_resource_add_destroy_listener (keyboard->focus_surface->resource, &keyboard->focus_surface_listener);
 
-      keyboard->focus_serial = serial;
+      keyboard->focus_resource = find_resource_for_surface (&keyboard->resource_list, surface);
+      if (keyboard->focus_resource)
+        {
+          struct wl_client *client = wl_resource_get_client (keyboard->focus_resource);
+          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);
+
+          wl_resource_add_destroy_listener (keyboard->focus_resource, &keyboard->focus_resource_listener);
+          keyboard->focus_serial = serial;
+        }
     }
 }
 
@@ -622,85 +536,6 @@ 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,

src/wayland/meta-wayland-keyboard.h

@@ -47,6 +47,7 @@
 
 #include <clutter/clutter.h>
 #include <wayland-server.h>
+#include <xkbcommon/xkbcommon.h>
 
 struct _MetaWaylandKeyboardGrabInterface
 {
@@ -71,14 +72,6 @@ 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
@@ -149,13 +142,6 @@ 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);
 

src/wayland/meta-wayland-pointer.c

@@ -49,42 +49,31 @@
 
 #include "meta-wayland-pointer.h"
 #include "meta-wayland-private.h"
-#include "xdg-shell-server-protocol.h"
 
 #include <string.h>
 
 static void meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer);
 
-static MetaWaylandSeat *
-meta_wayland_pointer_get_seat (MetaWaylandPointer *pointer)
-{
-  MetaWaylandSeat *seat = wl_container_of (pointer, seat, pointer);
-
-  return seat;
-}
-
-static void
-release_focus (MetaWaylandPointer *pointer)
-{
-  wl_list_remove (&pointer->focus_surface_listener.link);
-  wl_list_remove (&pointer->focus_resource_listener.link);
-
-  pointer->focus_resource = NULL;
-  pointer->focus_surface = NULL;
-}
-
 static void
 pointer_handle_focus_surface_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_surface_listener);
-  release_focus (pointer);
+
+  pointer->focus_surface = NULL;
+
+  if (pointer->focus_resource)
+    {
+      wl_list_remove (&pointer->focus_resource_listener.link);
+      pointer->focus_resource = NULL;
+    }
 }
 
 static void
 pointer_handle_focus_resource_destroy (struct wl_listener *listener, void *data)
 {
   MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_resource_listener);
-  release_focus (pointer);
+
+  pointer->focus_resource = NULL;
 }
 
 static void
@@ -310,7 +299,7 @@ meta_wayland_pointer_init (MetaWaylandPointer *pointer)
 void
 meta_wayland_pointer_release (MetaWaylandPointer *pointer)
 {
-  release_focus (pointer);
+  /* Do nothing. */
 }
 
 static struct wl_resource *
@@ -331,70 +320,57 @@ void
 meta_wayland_pointer_set_focus (MetaWaylandPointer *pointer,
                                 MetaWaylandSurface *surface)
 {
-  MetaWaylandSeat *seat = meta_wayland_pointer_get_seat (pointer);
-  MetaWaylandKeyboard *kbd = &seat->keyboard;
-  struct wl_resource *resource, *kr;
-  uint32_t serial;
-
   if (pointer->focus_surface == surface && pointer->focus_resource != NULL)
     return;
 
-  resource = pointer->focus_resource;
-  if (resource)
+  if (pointer->focus_surface)
     {
-      if (pointer->focus_surface->resource)
+      if (pointer->focus_resource)
         {
-          struct wl_client *client = wl_resource_get_client (resource);
-          struct wl_display *display = wl_client_get_display (client);
-          serial = wl_display_next_serial (display);
-          wl_pointer_send_leave (resource, serial, pointer->focus_surface->resource);
+          if (pointer->focus_surface->resource)
+            {
+              struct wl_client *client = wl_resource_get_client (pointer->focus_resource);
+              struct wl_display *display = wl_client_get_display (client);
+              uint32_t serial = wl_display_next_serial (display);
+              wl_pointer_send_leave (pointer->focus_resource, serial, pointer->focus_surface->resource);
+            }
+
+          wl_list_remove (&pointer->focus_resource_listener.link);
+          pointer->focus_resource = NULL;
         }
 
       wl_list_remove (&pointer->focus_surface_listener.link);
-      wl_list_remove (&pointer->focus_resource_listener.link);
-
       pointer->focus_surface = NULL;
-      pointer->focus_resource = NULL;
     }
 
-  resource = find_resource_for_surface (&pointer->resource_list, surface);
-  if (resource)
+  if (surface != NULL)
     {
-      struct wl_client *client = wl_resource_get_client (resource);
-      struct wl_display *display = wl_client_get_display (client);
-      wl_fixed_t sx, sy;
-
-      serial = wl_display_next_serial (display);
-
-      if (kbd)
-        {
-          kr = find_resource_for_surface (&kbd->resource_list, surface);
-          if (kr)
-            {
-              wl_keyboard_send_modifiers (kr,
-                                          serial,
-                                          kbd->modifier_state.mods_depressed,
-                                          kbd->modifier_state.mods_latched,
-                                          kbd->modifier_state.mods_locked,
-                                          kbd->modifier_state.group);
-            }
-        }
-
-      meta_wayland_pointer_get_relative_coordinates (pointer, surface, &sx, &sy);
-      meta_window_handle_enter (surface->window,
-                                /* XXX -- can we reliably get a timestamp for setting focus? */
-                                clutter_get_current_event_time (),
-                                wl_fixed_to_int (pointer->x),
-                                wl_fixed_to_int (pointer->y));
-      wl_pointer_send_enter (resource, serial, surface->resource, sx, sy);
-
-      pointer->focus_resource = resource;
       pointer->focus_surface = surface;
-
-      wl_resource_add_destroy_listener (pointer->focus_resource, &pointer->focus_resource_listener);
       wl_resource_add_destroy_listener (pointer->focus_surface->resource, &pointer->focus_surface_listener);
 
-      pointer->focus_serial = serial;
+      pointer->focus_resource = find_resource_for_surface (&pointer->resource_list, surface);
+      if (pointer->focus_resource)
+        {
+          struct wl_client *client = wl_resource_get_client (pointer->focus_resource);
+          struct wl_display *display = wl_client_get_display (client);
+          uint32_t serial = wl_display_next_serial (display);
+
+          meta_window_handle_enter (pointer->focus_surface->window,
+                                    /* XXX -- can we reliably get a timestamp for setting focus? */
+                                    clutter_get_current_event_time (),
+                                    wl_fixed_to_int (pointer->x),
+                                    wl_fixed_to_int (pointer->y));
+
+          {
+            wl_fixed_t sx, sy;
+
+            meta_wayland_pointer_get_relative_coordinates (pointer, pointer->focus_surface, &sx, &sy);
+            wl_pointer_send_enter (pointer->focus_resource, serial, pointer->focus_surface->resource, sx, sy);
+          }
+
+          wl_resource_add_destroy_listener (pointer->focus_resource, &pointer->focus_resource_listener);
+          pointer->focus_serial = serial;
+        }
     }
 }
 
@@ -422,61 +398,6 @@ 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;
 
@@ -551,19 +472,18 @@ meta_wayland_pointer_end_popup_grab (MetaWaylandPointer *pointer)
 
   wl_list_for_each_safe (popup, tmp, &popup_grab->all_popups, link)
     {
-      MetaWaylandSurfaceExtension *xdg_popup = &popup->surface->xdg_popup;
-      struct wl_client *client = wl_resource_get_client (xdg_popup->resource);
-      struct wl_display *display = wl_client_get_display (client);
-      uint32_t serial;
-
-      serial = wl_display_next_serial (display);
-
-      xdg_popup_send_popup_done (xdg_popup->resource, serial);
+      meta_wayland_surface_popup_done (popup->surface);
       wl_list_remove (&popup->surface_destroy_listener.link);
       wl_list_remove (&popup->link);
       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);
 }
@@ -603,6 +523,8 @@ 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;
@@ -610,6 +532,19 @@ 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;
@@ -618,10 +553,12 @@ meta_wayland_pointer_start_popup_grab (MetaWaylandPointer *pointer,
   popup->grab = grab;
   popup->surface = surface;
   popup->surface_destroy_listener.notify = on_popup_surface_destroy;
-  wl_resource_add_destroy_listener (surface->xdg_popup.resource, &popup->surface_destroy_listener);
+  if (surface->xdg_popup.resource)
+    wl_resource_add_destroy_listener (surface->xdg_popup.resource, &popup->surface_destroy_listener);
+  else if (surface->wl_shell_surface.resource)
+    wl_resource_add_destroy_listener (surface->wl_shell_surface.resource, &popup->surface_destroy_listener);
 
   wl_list_insert (&grab->all_popups, &popup->link);
-      
   return TRUE;
 }
 

src/wayland/meta-wayland-pointer.h

@@ -85,11 +85,6 @@ 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);

src/wayland/meta-wayland-private.h

@@ -21,17 +21,16 @@
 #define META_WAYLAND_PRIVATE_H
 
 #include <wayland-server.h>
-#include <xkbcommon/xkbcommon.h>
 #include <clutter/clutter.h>
 
 #include <glib.h>
 #include <cairo.h>
 
 #include "window-private.h"
-#include "meta-weston-launch.h"
+#include "meta-login1.h"
 #include <meta/meta-cursor-tracker.h>
 
-#include "meta-wayland-types.h"
+#include "meta-wayland.h"
 #include "meta-wayland-versions.h"
 #include "meta-wayland-surface.h"
 #include "meta-wayland-seat.h"
@@ -86,35 +85,13 @@ struct _MetaWaylandCompositor
 
   MetaXWaylandManager xwayland_manager;
 
-  MetaLauncher *launcher;
+  MetaLogin1 *login1;
 
   MetaWaylandSeat *seat;
 };
 
-void                    meta_wayland_init                       (void);
-void                    meta_wayland_finalize                   (void);
-
-/* We maintain a singleton MetaWaylandCompositor which can be got at via this
- * API after meta_wayland_init() has been called. */
-MetaWaylandCompositor  *meta_wayland_compositor_get_default     (void);
-
-void                    meta_wayland_compositor_repick          (MetaWaylandCompositor *compositor);
-
-void                    meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
-                                                                 MetaWindow            *window);
-gboolean                meta_wayland_compositor_handle_event    (MetaWaylandCompositor *compositor,
-                                                                 const ClutterEvent    *event);
-
 MetaWaylandBuffer *     meta_wayland_buffer_from_resource       (struct wl_resource    *resource);
 void                    meta_wayland_buffer_ref                 (MetaWaylandBuffer     *buffer);
 void                    meta_wayland_buffer_unref               (MetaWaylandBuffer     *buffer);
 
-void                    meta_wayland_compositor_update          (MetaWaylandCompositor *compositor,
-                                                                 const ClutterEvent    *event);
-void                    meta_wayland_compositor_paint_finished  (MetaWaylandCompositor *compositor);
-
-gboolean                meta_wayland_compositor_activate_vt     (MetaWaylandCompositor  *compositor,
-                                                                 int                     vt,
-                                                                 GError                **error);
-
 #endif /* META_WAYLAND_PRIVATE_H */

src/wayland/meta-wayland-seat.c

@@ -38,6 +38,7 @@
 #include "meta-shaped-texture-private.h"
 #include "meta-wayland-stage.h"
 #include "meta-cursor-tracker-private.h"
+#include "meta-surface-actor-wayland.h"
 
 #define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int (10)
 
@@ -275,42 +276,53 @@ static void
 handle_scroll_event (MetaWaylandSeat    *seat,
                      const ClutterEvent *event)
 {
-  enum wl_pointer_axis axis;
-  wl_fixed_t value;
+  wl_fixed_t x_value = 0, y_value = 0;
 
   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:
-      axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
-      value = -DEFAULT_AXIS_STEP_DISTANCE;
+      y_value = -DEFAULT_AXIS_STEP_DISTANCE;
       break;
 
     case CLUTTER_SCROLL_DOWN:
-      axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
-      value = DEFAULT_AXIS_STEP_DISTANCE;
+      y_value = DEFAULT_AXIS_STEP_DISTANCE;
       break;
 
     case CLUTTER_SCROLL_LEFT:
-      axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
-      value = -DEFAULT_AXIS_STEP_DISTANCE;
+      x_value = -DEFAULT_AXIS_STEP_DISTANCE;
       break;
 
     case CLUTTER_SCROLL_RIGHT:
-      axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
-      value = DEFAULT_AXIS_STEP_DISTANCE;
+      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);
+      }
       break;
 
     default:
       return;
     }
 
-  if (seat->pointer.focus_resource)
-    wl_pointer_send_axis (seat->pointer.focus_resource,
-                          clutter_event_get_time (event),
-                          axis,
-                          value);
+  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);
 }
 
 static int
@@ -420,13 +432,8 @@ meta_wayland_seat_repick (MetaWaylandSeat    *seat,
   else
     seat->current_stage = NULL;
 
-  if (META_IS_WINDOW_ACTOR (actor))
-    {
-      MetaWindow *window =
-        meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor));
-
-      surface = window->surface;
-    }
+  if (META_IS_SURFACE_ACTOR_WAYLAND (actor))
+    surface = meta_surface_actor_wayland_get_surface (META_SURFACE_ACTOR_WAYLAND (actor));
 
   pointer->current = surface;
   if (surface != pointer->focus_surface)

src/wayland/meta-wayland-seat.h

@@ -43,12 +43,6 @@ 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

src/wayland/meta-wayland-surface.c

@@ -44,11 +44,11 @@
 #include "meta-wayland-private.h"
 #include "meta-xwayland-private.h"
 #include "meta-wayland-stage.h"
-#include "meta-surface-actor.h"
 #include "meta-wayland-seat.h"
 #include "meta-wayland-keyboard.h"
 #include "meta-wayland-pointer.h"
 #include "meta-wayland-data-device.h"
+
 #include "meta-cursor-tracker-private.h"
 #include "display-private.h"
 #include "window-private.h"
@@ -58,6 +58,9 @@
 #include "meta-idle-monitor-private.h"
 #include "monitor-private.h"
 
+#include "meta-surface-actor.h"
+#include "meta-surface-actor-wayland.h"
+
 typedef enum
 {
   META_WAYLAND_SUBSURFACE_PLACEMENT_ABOVE,
@@ -79,7 +82,6 @@ surface_handle_buffer_destroy (struct wl_listener *listener, void *data)
   wl_resource_post_error (surface->resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
                           "Destroyed buffer while it was attached to the surface");
   surface->buffer = NULL;
-  wl_list_remove (&surface->buffer_destroy_listener.link);
 }
 
 static void
@@ -114,8 +116,8 @@ surface_process_damage (MetaWaylandSurface *surface,
     {
       cairo_rectangle_int_t rect;
       cairo_region_get_rectangle (region, i, &rect);
-      meta_surface_actor_damage_area (surface->surface_actor,
-                                      rect.x, rect.y, rect.width, rect.height);
+      meta_surface_actor_process_damage (surface->surface_actor,
+                                         rect.x, rect.y, rect.width, rect.height);
     }
 }
 
@@ -259,9 +261,6 @@ ensure_buffer_texture (MetaWaylandBuffer *buffer)
   CoglError *catch_error = NULL;
   CoglTexture *texture;
 
-  if (!buffer)
-    return;
-
   texture = COGL_TEXTURE (cogl_wayland_texture_2d_new_from_buffer (ctx,
                                                                    buffer->resource,
                                                                    &catch_error));
@@ -273,8 +272,6 @@ ensure_buffer_texture (MetaWaylandBuffer *buffer)
     }
 
   buffer->texture = texture;
-  buffer->width = cogl_texture_get_width (texture);
-  buffer->height = cogl_texture_get_height (texture);
 }
 
 static void
@@ -294,10 +291,10 @@ actor_surface_commit (MetaWaylandSurface             *surface,
   MetaSurfaceActor *surface_actor = surface->surface_actor;
   MetaWaylandBuffer *buffer = pending->buffer;
 
-  if (buffer_changed)
+  if (buffer_changed && buffer)
     {
       ensure_buffer_texture (buffer);
-      meta_surface_actor_attach_wayland_buffer (surface_actor, buffer);
+      meta_surface_actor_wayland_set_buffer (META_SURFACE_ACTOR_WAYLAND (surface->surface_actor), buffer);
     }
 
   surface_process_damage (surface, pending->damage);
@@ -324,11 +321,11 @@ toplevel_surface_commit (MetaWaylandSurface             *surface,
       /* We resize X based surfaces according to X events */
       if (buffer != NULL && window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
         {
-          int new_width;
-          int new_height;
+          int new_width, new_height;
+
+          new_width = cogl_texture_get_width (buffer->texture);
+          new_height = cogl_texture_get_height (buffer->texture);
 
-          new_width = surface->buffer->width;
-          new_height = surface->buffer->height;
           if (new_width != window->rect.width ||
               new_height != window->rect.height ||
               pending->dx != 0 ||
@@ -555,34 +552,30 @@ const struct wl_surface_interface meta_wayland_surface_interface = {
   meta_wayland_surface_set_buffer_scale
 };
 
-static void
-unparent_actor (MetaWaylandSurface *surface)
+void
+meta_wayland_surface_make_toplevel (MetaWaylandSurface *surface)
 {
-  ClutterActor *parent_actor;
-
-  parent_actor = clutter_actor_get_parent (CLUTTER_ACTOR (surface->surface_actor));
-  clutter_actor_remove_child (parent_actor, CLUTTER_ACTOR (surface->surface_actor));
+  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), TRUE);
 }
 
 void
 meta_wayland_surface_window_unmanaged (MetaWaylandSurface *surface)
 {
-  /* The window is being unmanaged. Unparent our surface actor
-   * before the window actor is destroyed, as we need to hold
-   * onto it... */
-  unparent_actor (surface);
-
+  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), FALSE);
   surface->window = NULL;
 }
 
 static void
 destroy_window (MetaWaylandSurface *surface)
 {
-  MetaDisplay *display = meta_get_display ();
-  guint32 timestamp = meta_display_get_current_time_roundtrip (display);
+  if (surface->window)
+    {
+      MetaDisplay *display = meta_get_display ();
+      guint32 timestamp = meta_display_get_current_time_roundtrip (display);
+
+      meta_window_unmanage (surface->window, timestamp);
+    }
 
-  g_assert (surface->window != NULL);
-  meta_window_unmanage (surface->window, timestamp);
   g_assert (surface->window == NULL);
 }
 
@@ -592,18 +585,17 @@ wl_surface_destructor (struct wl_resource *resource)
   MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
   MetaWaylandCompositor *compositor = surface->compositor;
 
-  /* At the time when the wl_surface is destroyed, we should
-   * no longer have a window, unless we're an XWayland window
-   * in which case we received the wl_surface.destroy before
-   * the UnmapNotify/DestroyNotify. */
-  g_assert (surface->window == NULL || surface->window->client_type == META_WINDOW_CLIENT_TYPE_X11);
+  /* If we still have a window at the time of destruction, that means that
+   * the client is disconnecting, as the resources are destroyed in a random
+   * order. Simply destroy the window in this case. */
+  if (surface->window)
+    destroy_window (surface);
 
   compositor->surfaces = g_list_remove (compositor->surfaces, surface);
 
   surface_set_buffer (surface, NULL);
   double_buffered_state_destroy (&surface->pending);
 
-  clutter_actor_destroy (CLUTTER_ACTOR (surface->surface_actor));
   g_object_unref (surface->surface_actor);
 
   if (surface->resource)
@@ -627,28 +619,18 @@ meta_wayland_surface_create (MetaWaylandCompositor *compositor,
   wl_resource_set_implementation (surface->resource, &meta_wayland_surface_interface, surface, wl_surface_destructor);
 
   surface->buffer_destroy_listener.notify = surface_handle_buffer_destroy;
-  surface->surface_actor = g_object_ref_sink (meta_surface_actor_new ());
+  surface->surface_actor = g_object_ref_sink (meta_surface_actor_wayland_new (surface));
 
   double_buffered_state_init (&surface->pending);
-
   return surface;
 }
 
 static void
 destroy_surface_extension (MetaWaylandSurfaceExtension *extension)
 {
-  wl_list_remove (&extension->surface_destroy_listener.link);
   extension->resource = NULL;
 }
 
-static void
-extension_handle_surface_destroy (struct wl_listener *listener,
-				  void *data)
-{
-  MetaWaylandSurfaceExtension *extension = wl_container_of (listener, extension, surface_destroy_listener);
-  wl_resource_destroy (extension->resource);
-}
-
 static int
 get_resource_version (struct wl_resource *master_resource,
                       int                 max_version)
@@ -658,23 +640,22 @@ get_resource_version (struct wl_resource *master_resource,
 
 static gboolean
 create_surface_extension (MetaWaylandSurfaceExtension *extension,
-                          struct wl_client            *client,
-                          struct wl_resource          *master_resource,
-                          struct wl_resource          *surface_resource,
-                          guint32                      id,
                           int                          max_version,
                           const struct wl_interface   *interface,
                           const void                  *implementation,
-                          wl_resource_destroy_func_t   destructor)
+                          wl_resource_destroy_func_t   destructor,
+                          MetaWaylandSurface          *surface,
+                          struct wl_resource          *master_resource,
+                          guint32                      id)
 {
+  struct wl_client *client;
+
   if (extension->resource != NULL)
     return FALSE;
 
+  client = wl_resource_get_client (surface->resource);
   extension->resource = wl_resource_create (client, interface, get_resource_version (master_resource, max_version), id);
-  wl_resource_set_implementation (extension->resource, implementation, extension, destructor);
-
-  extension->surface_destroy_listener.notify = extension_handle_surface_destroy;
-  wl_resource_add_destroy_listener (surface_resource, &extension->surface_destroy_listener);
+  wl_resource_set_implementation (extension->resource, implementation, surface, destructor);
 
   return TRUE;
 }
@@ -701,11 +682,10 @@ xdg_shell_pong (struct wl_client *client,
 static void
 xdg_surface_destructor (struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   destroy_window (surface);
-  destroy_surface_extension (xdg_surface);
+  destroy_surface_extension (&surface->xdg_surface);
 }
 
 static void
@@ -720,8 +700,7 @@ xdg_surface_set_transient_for (struct wl_client *client,
                                struct wl_resource *resource,
                                struct wl_resource *parent_resource)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
   MetaWindow *transient_for = NULL;
 
   if (parent_resource)
@@ -741,8 +720,7 @@ xdg_surface_set_margin (struct wl_client *client,
                         int32_t top_margin,
                         int32_t bottom_margin)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   surface->pending.frame_extents_changed = TRUE;
   surface->pending.frame_extents.left = left_margin;
@@ -756,8 +734,7 @@ xdg_surface_set_title (struct wl_client *client,
                        struct wl_resource *resource,
                        const char *title)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   meta_window_set_title (surface->window, title);
 }
@@ -767,12 +744,54 @@ xdg_surface_set_app_id (struct wl_client *client,
                         struct wl_resource *resource,
                         const char *app_id)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   meta_window_set_wm_class (surface->window, app_id, app_id);
 }
 
+static MetaWindowType
+window_type_from_surface_type (uint32_t surface_type)
+{
+  switch (surface_type)
+    {
+    case XDG_SURFACE_SURFACE_TYPE_NORMAL:
+      return META_WINDOW_NORMAL;
+    case XDG_SURFACE_SURFACE_TYPE_MODAL_DIALOG:
+      return META_WINDOW_MODAL_DIALOG;
+    default:
+      g_warning ("Unknown surface type: %d\n", surface_type);
+      return META_WINDOW_NORMAL;
+    }
+}
+
+static void
+xdg_surface_set_surface_type (struct wl_client *client,
+                              struct wl_resource *resource,
+                              uint32_t surface_type)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  meta_window_set_type (surface->window,
+                        window_type_from_surface_type (surface_type));
+}
+
+static void
+xdg_surface_show_window_menu (struct wl_client *client,
+                              struct wl_resource *resource,
+                              struct wl_resource *seat_resource,
+                              uint32_t serial)
+{
+  MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  if (seat->pointer.button_count == 0 ||
+      seat->pointer.grab_serial != serial ||
+      seat->pointer.focus_surface != surface)
+    return;
+
+  meta_window_show_menu (surface->window);
+}
+
 static gboolean
 begin_grab_op_on_surface (MetaWaylandSurface *surface,
                           MetaWaylandSeat    *seat,
@@ -803,8 +822,7 @@ xdg_surface_move (struct wl_client *client,
                   guint32 serial)
 {
   MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   if (seat->pointer.button_count == 0 ||
       seat->pointer.grab_serial != serial ||
@@ -815,7 +833,7 @@ xdg_surface_move (struct wl_client *client,
 }
 
 static MetaGrabOp
-grab_op_for_edge (int edge)
+grab_op_for_xdg_surface_resize_edge (int edge)
 {
   switch (edge)
     {
@@ -849,15 +867,14 @@ xdg_surface_resize (struct wl_client *client,
                     guint32 edges)
 {
   MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   if (seat->pointer.button_count == 0 ||
       seat->pointer.grab_serial != serial ||
       seat->pointer.focus_surface != surface)
     return;
 
-  begin_grab_op_on_surface (surface, seat, grab_op_for_edge (edges));
+  begin_grab_op_on_surface (surface, seat, grab_op_for_xdg_surface_resize_edge (edges));
 }
 
 static void
@@ -875,20 +892,19 @@ xdg_surface_request_change_state (struct wl_client *client,
                                   uint32_t value,
                                   uint32_t serial)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   surface->state_changed_serial = serial;
 
   switch (state_type)
     {
-    case XDG_SURFACE_STATE_TYPE_MAXIMIZED:
+    case XDG_SURFACE_STATE_MAXIMIZED:
       if (value)
-        meta_window_maximize (surface->window, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+        meta_window_maximize (surface->window, META_MAXIMIZE_BOTH);
       else
-        meta_window_unmaximize (surface->window, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+        meta_window_unmaximize (surface->window, META_MAXIMIZE_BOTH);
       break;
-    case XDG_SURFACE_STATE_TYPE_FULLSCREEN:
+    case XDG_SURFACE_STATE_FULLSCREEN:
       if (value)
         meta_window_make_fullscreen (surface->window);
       else
@@ -914,8 +930,7 @@ static void
 xdg_surface_set_minimized (struct wl_client *client,
                            struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *xdg_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_surface, surface, xdg_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   meta_window_minimize (surface->window);
 }
@@ -926,6 +941,8 @@ static const struct xdg_surface_interface meta_wayland_xdg_surface_interface = {
   xdg_surface_set_margin,
   xdg_surface_set_title,
   xdg_surface_set_app_id,
+  xdg_surface_set_surface_type,
+  xdg_surface_show_window_menu,
   xdg_surface_move,
   xdg_surface_resize,
   xdg_surface_set_output,
@@ -942,11 +959,12 @@ xdg_shell_get_xdg_surface (struct wl_client *client,
 {
   MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
 
-  if (!create_surface_extension (&surface->xdg_surface, client, surface_resource, resource, id,
+  if (!create_surface_extension (&surface->xdg_surface,
                                  META_XDG_SURFACE_VERSION,
                                  &xdg_surface_interface,
                                  &meta_wayland_xdg_surface_interface,
-                                 xdg_surface_destructor))
+                                 xdg_surface_destructor,
+                                 surface, resource, id))
     {
       wl_resource_post_error (surface_resource,
                               WL_DISPLAY_ERROR_INVALID_OBJECT,
@@ -954,17 +972,17 @@ xdg_shell_get_xdg_surface (struct wl_client *client,
       return;
     }
 
+  meta_wayland_surface_make_toplevel (surface);
   surface->window = meta_window_wayland_new (meta_get_display (), surface);
 }
 
 static void
 xdg_popup_destructor (struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *xdg_popup = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (xdg_popup, surface, xdg_popup);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   destroy_window (surface);
-  destroy_surface_extension (xdg_popup);
+  destroy_surface_extension (&surface->xdg_popup);
 }
 
 static void
@@ -993,18 +1011,16 @@ xdg_shell_get_xdg_popup (struct wl_client *client,
   MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
   MetaWaylandSurface *parent_surf = wl_resource_get_user_data (parent_resource);
   MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
-  MetaRectangle parent_rect;
 
   if (parent_surf == NULL || parent_surf->window == NULL)
     return;
 
-  meta_window_get_rect (parent_surf->window, &parent_rect);
-
-  if (!create_surface_extension (&surface->xdg_popup, client, surface_resource, resource, id,
+  if (!create_surface_extension (&surface->xdg_popup,
                                  META_XDG_POPUP_VERSION,
                                  &xdg_popup_interface,
                                  &meta_wayland_xdg_popup_interface,
-                                 xdg_popup_destructor))
+                                 xdg_popup_destructor,
+                                 surface, resource, id))
     {
       wl_resource_post_error (surface_resource,
                               WL_DISPLAY_ERROR_INVALID_OBJECT,
@@ -1012,15 +1028,15 @@ xdg_shell_get_xdg_popup (struct wl_client *client,
       return;
     }
 
+  meta_wayland_surface_make_toplevel (surface);
   surface->window = meta_window_wayland_new (meta_get_display (), surface);
-  surface->window->rect.x = parent_rect.x + x;
-  surface->window->rect.y = parent_rect.y + y;
+  surface->window->rect.x = parent_surf->window->rect.x + x;
+  surface->window->rect.y = parent_surf->window->rect.y + y;
   surface->window->showing_for_first_time = FALSE;
   surface->window->placed = TRUE;
   meta_window_set_transient_for (surface->window, parent_surf->window);
 
-  surface->window->type = META_WINDOW_DROPDOWN_MENU;
-  meta_window_type_changed (surface->window);
+  meta_window_set_type (surface->window, META_WINDOW_DROPDOWN_MENU);
 
   meta_wayland_pointer_start_popup_grab (&seat->pointer, surface);
 }
@@ -1086,13 +1102,264 @@ bind_xdg_shell (struct wl_client *client,
   wl_client_add_destroy_listener (client, &xdg_shell->client_destroy_listener);
 }
 
+static void
+wl_shell_surface_destructor (struct wl_resource *resource)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  destroy_surface_extension (&surface->wl_shell_surface);
+}
+
+static void
+wl_shell_surface_pong (struct wl_client *client,
+                       struct wl_resource *resource,
+                       uint32_t serial)
+{
+  MetaDisplay *display = meta_get_display ();
+
+  meta_display_pong_for_serial (display, serial);
+}
+
+static void
+wl_shell_surface_move (struct wl_client *client,
+                       struct wl_resource *resource,
+                       struct wl_resource *seat_resource,
+                       uint32_t serial)
+{
+  MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  if (seat->pointer.button_count == 0 ||
+      seat->pointer.grab_serial != serial ||
+      seat->pointer.focus_surface != surface)
+    return;
+
+  begin_grab_op_on_surface (surface, seat, META_GRAB_OP_MOVING);
+}
+
+static MetaGrabOp
+grab_op_for_wl_shell_surface_resize_edge (int edge)
+{
+  switch (edge)
+    {
+    case WL_SHELL_SURFACE_RESIZE_TOP_LEFT:
+      return META_GRAB_OP_RESIZING_NW;
+    case WL_SHELL_SURFACE_RESIZE_TOP:
+      return META_GRAB_OP_RESIZING_N;
+    case WL_SHELL_SURFACE_RESIZE_TOP_RIGHT:
+      return META_GRAB_OP_RESIZING_NE;
+    case WL_SHELL_SURFACE_RESIZE_RIGHT:
+      return META_GRAB_OP_RESIZING_E;
+    case WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT:
+      return META_GRAB_OP_RESIZING_SE;
+    case WL_SHELL_SURFACE_RESIZE_BOTTOM:
+      return META_GRAB_OP_RESIZING_S;
+    case WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT:
+      return META_GRAB_OP_RESIZING_SW;
+    case WL_SHELL_SURFACE_RESIZE_LEFT:
+      return META_GRAB_OP_RESIZING_W;
+    default:
+      g_warning ("invalid edge: %d", edge);
+      return META_GRAB_OP_NONE;
+    }
+}
+
+static void
+wl_shell_surface_resize (struct wl_client *client,
+                         struct wl_resource *resource,
+                         struct wl_resource *seat_resource,
+                         uint32_t serial,
+                         uint32_t edges)
+{
+  MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  if (seat->pointer.button_count == 0 ||
+      seat->pointer.grab_serial != serial ||
+      seat->pointer.focus_surface != surface)
+    return;
+
+  begin_grab_op_on_surface (surface, seat, grab_op_for_wl_shell_surface_resize_edge (edges));
+}
+
+typedef enum {
+  SURFACE_STATE_TOPLEVEL,
+  SURFACE_STATE_FULLSCREEN,
+  SURFACE_STATE_MAXIMIZED,
+} SurfaceState;
+
+static void
+wl_shell_surface_set_state (MetaWaylandSurface *surface,
+                            SurfaceState        state)
+{
+  if (state == SURFACE_STATE_FULLSCREEN)
+    meta_window_make_fullscreen (surface->window);
+  else
+    meta_window_unmake_fullscreen (surface->window);
+
+  if (state == SURFACE_STATE_MAXIMIZED)
+    meta_window_maximize (surface->window, META_MAXIMIZE_BOTH);
+  else
+    meta_window_unmaximize (surface->window, META_MAXIMIZE_BOTH);
+}
+
+static void
+wl_shell_surface_set_toplevel (struct wl_client *client,
+                               struct wl_resource *resource)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  wl_shell_surface_set_state (surface, SURFACE_STATE_TOPLEVEL);
+}
+
+static void
+wl_shell_surface_set_transient (struct wl_client *client,
+                                struct wl_resource *resource,
+                                struct wl_resource *parent_resource,
+                                int32_t x,
+                                int32_t y,
+                                uint32_t flags)
+{
+  MetaWaylandSurface *parent_surf = wl_resource_get_user_data (parent_resource);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  wl_shell_surface_set_state (surface, SURFACE_STATE_TOPLEVEL);
+
+  meta_window_set_transient_for (surface->window, parent_surf->window);
+  meta_window_move (surface->window, FALSE,
+                    parent_surf->window->rect.x + x,
+                    parent_surf->window->rect.y + y);
+  surface->window->placed = TRUE;
+}
+
+static void
+wl_shell_surface_set_fullscreen (struct wl_client *client,
+                                 struct wl_resource *resource,
+                                 uint32_t method,
+                                 uint32_t framerate,
+                                 struct wl_resource *output)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  wl_shell_surface_set_state (surface, SURFACE_STATE_FULLSCREEN);
+}
+
+static void
+wl_shell_surface_set_popup (struct wl_client *client,
+                            struct wl_resource *resource,
+                            struct wl_resource *seat_resource,
+                            uint32_t serial,
+                            struct wl_resource *parent_resource,
+                            int32_t x,
+                            int32_t y,
+                            uint32_t flags)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+  MetaWaylandSurface *parent_surf = wl_resource_get_user_data (parent_resource);
+  MetaWaylandSeat *seat = wl_resource_get_user_data (seat_resource);
+
+  wl_shell_surface_set_state (surface, SURFACE_STATE_TOPLEVEL);
+
+  meta_window_set_transient_for (surface->window, parent_surf->window);
+  meta_window_move (surface->window, FALSE,
+                    parent_surf->window->rect.x + x,
+                    parent_surf->window->rect.y + y);
+  surface->window->placed = TRUE;
+
+  meta_wayland_pointer_start_popup_grab (&seat->pointer, surface);
+}
+
+static void
+wl_shell_surface_set_maximized (struct wl_client *client,
+                                struct wl_resource *resource,
+                                struct wl_resource *output)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  wl_shell_surface_set_state (surface, SURFACE_STATE_MAXIMIZED);
+}
+
+static void
+wl_shell_surface_set_title (struct wl_client *client,
+                            struct wl_resource *resource,
+                            const char *title)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  meta_window_set_title (surface->window, title);
+}
+
+static void
+wl_shell_surface_set_class (struct wl_client *client,
+                            struct wl_resource *resource,
+                            const char *class_)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
+  meta_window_set_wm_class (surface->window, class_, class_);
+}
+
+static const struct wl_shell_surface_interface meta_wayland_wl_shell_surface_interface = {
+  wl_shell_surface_pong,
+  wl_shell_surface_move,
+  wl_shell_surface_resize,
+  wl_shell_surface_set_toplevel,
+  wl_shell_surface_set_transient,
+  wl_shell_surface_set_fullscreen,
+  wl_shell_surface_set_popup,
+  wl_shell_surface_set_maximized,
+  wl_shell_surface_set_title,
+  wl_shell_surface_set_class,
+};
+
+static void
+wl_shell_get_shell_surface (struct wl_client *client,
+                            struct wl_resource *resource,
+                            uint32_t id,
+                            struct wl_resource *surface_resource)
+{
+  MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
+
+  if (!create_surface_extension (&surface->wl_shell_surface,
+                                 META_WL_SHELL_SURFACE_VERSION,
+                                 &wl_shell_surface_interface,
+                                 &meta_wayland_wl_shell_surface_interface,
+                                 wl_shell_surface_destructor,
+                                 surface, resource, id))
+    {
+      wl_resource_post_error (surface_resource,
+                              WL_DISPLAY_ERROR_INVALID_OBJECT,
+                              "wl_shell::get_shell_surface already requested");
+      return;
+    }
+
+  meta_wayland_surface_make_toplevel (surface);
+  surface->window = meta_window_wayland_new (meta_get_display (), surface);
+}
+
+static const struct wl_shell_interface meta_wayland_wl_shell_interface = {
+  wl_shell_get_shell_surface,
+};
+
+static void
+bind_wl_shell (struct wl_client *client,
+               void             *data,
+               uint32_t          version,
+               uint32_t          id)
+{
+  struct wl_resource *resource;
+
+  resource = wl_resource_create (client, &wl_shell_interface,
+                                 MIN (META_WL_SHELL_VERSION, version), id);
+  wl_resource_set_implementation (resource, &meta_wayland_wl_shell_interface, data, NULL);
+}
+
 static void
 gtk_surface_destructor (struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *gtk_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (gtk_surface, surface, gtk_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
-  destroy_surface_extension (gtk_surface);
+  destroy_surface_extension (&surface->gtk_surface);
 }
 
 static void
@@ -1105,8 +1372,7 @@ set_dbus_properties (struct wl_client   *client,
 		     const char         *application_object_path,
 		     const char         *unique_bus_name)
 {
-  MetaWaylandSurfaceExtension *gtk_surface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (gtk_surface, surface, gtk_surface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   /* Broken client, let it die instead of us */
   if (!surface->window)
@@ -1136,11 +1402,12 @@ get_gtk_surface (struct wl_client *client,
 {
   MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
 
-  if (!create_surface_extension (&surface->gtk_surface, client, surface_resource, resource, id,
+  if (!create_surface_extension (&surface->gtk_surface,
                                  META_GTK_SURFACE_VERSION,
                                  &gtk_surface_interface,
                                  &meta_wayland_gtk_surface_interface,
-                                 gtk_surface_destructor))
+                                 gtk_surface_destructor,
+                                 surface, resource, id))
     {
       wl_resource_post_error (surface_resource,
                               WL_DISPLAY_ERROR_INVALID_OBJECT,
@@ -1222,15 +1489,20 @@ 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
+unparent_actor (MetaWaylandSurface *surface)
+{
+  ClutterActor *parent_actor;
+  parent_actor = clutter_actor_get_parent (CLUTTER_ACTOR (surface->surface_actor));
+  clutter_actor_remove_child (parent_actor, CLUTTER_ACTOR (surface->surface_actor));
 }
 
 static void
 wl_subsurface_destructor (struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *subsurface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (subsurface, surface, subsurface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   if (surface->sub.parent)
     {
@@ -1242,7 +1514,7 @@ wl_subsurface_destructor (struct wl_resource *resource)
     }
 
   double_buffered_state_destroy (&surface->sub.pending_surface_state);
-  destroy_surface_extension (subsurface);
+  destroy_surface_extension (&surface->subsurface);
 }
 
 static void
@@ -1258,8 +1530,7 @@ wl_subsurface_set_position (struct wl_client *client,
                             int32_t x,
                             int32_t y)
 {
-  MetaWaylandSurfaceExtension *subsurface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (subsurface, surface, subsurface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   surface->sub.pending_x = x;
   surface->sub.pending_y = y;
@@ -1309,8 +1580,7 @@ wl_subsurface_place_above (struct wl_client *client,
                            struct wl_resource *resource,
                            struct wl_resource *sibling_resource)
 {
-  MetaWaylandSurfaceExtension *subsurface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (subsurface, surface, subsurface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
   MetaWaylandSurface *sibling = wl_resource_get_user_data (sibling_resource);
 
   if (!is_valid_sibling (surface, sibling))
@@ -1332,8 +1602,7 @@ wl_subsurface_place_below (struct wl_client *client,
                            struct wl_resource *resource,
                            struct wl_resource *sibling_resource)
 {
-  MetaWaylandSurfaceExtension *subsurface = wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface = wl_container_of (subsurface, surface, subsurface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
   MetaWaylandSurface *sibling = wl_resource_get_user_data (sibling_resource);
 
   if (!is_valid_sibling (surface, sibling))
@@ -1354,10 +1623,7 @@ static void
 wl_subsurface_set_sync (struct wl_client *client,
                         struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *subsurface =
-    wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface =
-    wl_container_of (subsurface, surface, subsurface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   surface->sub.synchronous = TRUE;
 }
@@ -1366,10 +1632,7 @@ static void
 wl_subsurface_set_desync (struct wl_client *client,
                           struct wl_resource *resource)
 {
-  MetaWaylandSurfaceExtension *subsurface =
-    wl_resource_get_user_data (resource);
-  MetaWaylandSurface *surface =
-    wl_container_of (subsurface, surface, subsurface);
+  MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
 
   if (surface->sub.synchronous)
     subsurface_parent_surface_committed (surface);
@@ -1415,11 +1678,12 @@ wl_subcompositor_get_subsurface (struct wl_client *client,
   MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
   MetaWaylandSurface *parent = wl_resource_get_user_data (parent_resource);
 
-  if (!create_surface_extension (&surface->subsurface, client, surface_resource, resource, id,
+  if (!create_surface_extension (&surface->subsurface,
                                  META_GTK_SURFACE_VERSION,
                                  &wl_subsurface_interface,
                                  &meta_wayland_subsurface_interface,
-                                 wl_subsurface_destructor))
+                                 wl_subsurface_destructor,
+                                 surface, resource, id))
     {
       wl_resource_post_error (surface_resource,
                               WL_DISPLAY_ERROR_INVALID_OBJECT,
@@ -1465,6 +1729,11 @@ meta_wayland_init_shell (MetaWaylandCompositor *compositor)
 			compositor, bind_xdg_shell) == NULL)
     g_error ("Failed to register a global xdg-shell object");
 
+  if (wl_global_create (compositor->wayland_display,
+			&wl_shell_interface, 1,
+			compositor, bind_wl_shell) == NULL)
+    g_error ("Failed to register a global wl-shell object");
+
   if (wl_global_create (compositor->wayland_display,
 			&gtk_shell_interface,
 			META_GTK_SHELL_VERSION,
@@ -1486,6 +1755,9 @@ meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
   if (surface->xdg_surface.resource)
     xdg_surface_send_configure (surface->xdg_surface.resource,
                                 new_width, new_height);
+  else if (surface->wl_shell_surface.resource)
+    wl_shell_surface_send_configure (surface->wl_shell_surface.resource,
+                                     0, new_width, new_height);
 }
 
 static void
@@ -1516,25 +1788,25 @@ send_change_state (MetaWaylandSurface *surface,
 void
 meta_wayland_surface_send_maximized (MetaWaylandSurface *surface)
 {
-  send_change_state (surface, XDG_SURFACE_STATE_TYPE_MAXIMIZED, TRUE);
+  send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, TRUE);
 }
 
 void
 meta_wayland_surface_send_unmaximized (MetaWaylandSurface *surface)
 {
-  send_change_state (surface, XDG_SURFACE_STATE_TYPE_MAXIMIZED, FALSE);
+  send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, FALSE);
 }
 
 void
 meta_wayland_surface_send_fullscreened (MetaWaylandSurface *surface)
 {
-  send_change_state (surface, XDG_SURFACE_STATE_TYPE_FULLSCREEN, TRUE);
+  send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, TRUE);
 }
 
 void
 meta_wayland_surface_send_unfullscreened (MetaWaylandSurface *surface)
 {
-  send_change_state (surface, XDG_SURFACE_STATE_TYPE_FULLSCREEN, FALSE);
+  send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, FALSE);
 }
 
 void
@@ -1555,16 +1827,23 @@ void
 meta_wayland_surface_ping (MetaWaylandSurface *surface,
                            guint32             serial)
 {
-  struct wl_client *client = wl_resource_get_client (surface->resource);
-  struct wl_resource *xdg_shell = get_xdg_shell_for_client (client);
-
-  if (xdg_shell == NULL)
+  if (surface->xdg_surface.resource)
     {
-      g_warning ("Trying to ping a surface without an xdg_shell bound. How does this happen?");
-      return;
-    }
+      struct wl_client *client = wl_resource_get_client (surface->resource);
+      struct wl_resource *xdg_shell = get_xdg_shell_for_client (client);
 
-  xdg_shell_send_ping (xdg_shell, serial);
+      if (xdg_shell == NULL)
+        {
+          g_warning ("Trying to ping a surface without an xdg_shell bound. How does this happen?");
+          return;
+        }
+
+      xdg_shell_send_ping (xdg_shell, serial);
+    }
+  else if (surface->wl_shell_surface.resource)
+    {
+      wl_shell_surface_send_ping (surface->wl_shell_surface.resource, serial);
+    }
 }
 
 void
@@ -1573,3 +1852,16 @@ meta_wayland_surface_delete (MetaWaylandSurface *surface)
   if (surface->xdg_surface.resource)
     xdg_surface_send_delete (surface->xdg_surface.resource);
 }
+
+void
+meta_wayland_surface_popup_done (MetaWaylandSurface *surface)
+{
+  struct wl_client *client = wl_resource_get_client (surface->resource);
+  struct wl_display *display = wl_client_get_display (client);
+  uint32_t serial = wl_display_next_serial (display);
+
+  if (surface->xdg_popup.resource)
+    xdg_popup_send_popup_done (surface->xdg_popup.resource, serial);
+  else if (surface->wl_shell_surface.resource)
+    wl_shell_surface_send_popup_done (surface->wl_shell_surface.resource);
+}

src/wayland/meta-wayland-surface.h

@@ -38,7 +38,6 @@ struct _MetaWaylandBuffer
   struct wl_listener destroy_listener;
 
   CoglTexture *texture;
-  int32_t width, height;
   uint32_t ref_count;
 };
 
@@ -67,7 +66,6 @@ typedef struct
 typedef struct
 {
   struct wl_resource *resource;
-  struct wl_listener surface_destroy_listener;
 } MetaWaylandSurfaceExtension;
 
 struct _MetaWaylandSurface
@@ -78,6 +76,7 @@ struct _MetaWaylandSurface
   MetaWindow *window;
   MetaWaylandSurfaceExtension xdg_surface;
   MetaWaylandSurfaceExtension xdg_popup;
+  MetaWaylandSurfaceExtension wl_shell_surface;
   MetaWaylandSurfaceExtension gtk_surface;
   MetaWaylandSurfaceExtension subsurface;
 
@@ -112,6 +111,7 @@ MetaWaylandSurface *meta_wayland_surface_create (MetaWaylandCompositor *composit
 						 guint32                id,
 						 guint32                version);
 
+void                meta_wayland_surface_make_toplevel (MetaWaylandSurface *surface);
 void                meta_wayland_surface_window_unmanaged (MetaWaylandSurface *surface);
 
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
@@ -129,4 +129,7 @@ void                meta_wayland_surface_ping (MetaWaylandSurface *surface,
                                                guint32             serial);
 void                meta_wayland_surface_delete (MetaWaylandSurface *surface);
 
+void                meta_wayland_surface_popup_done (MetaWaylandSurface *surface);
+
+
 #endif

src/wayland/meta-wayland-versions.h

@@ -37,6 +37,7 @@
 /* Global/master objects (version exported by wl_registry and negotiated through bind) */
 #define META_WL_COMPOSITOR_VERSION          3
 #define META_WL_DATA_DEVICE_MANAGER_VERSION 1
+#define META_WL_SHELL_VERSION               1
 #define META_WL_SEAT_VERSION                2 /* 3 not implemented yet */
 #define META_WL_OUTPUT_VERSION              2
 #define META_XSERVER_VERSION                1
@@ -52,9 +53,10 @@
 #define META_WL_KEYBOARD_VERSION            2 /* from wl_seat; 3 not implemented yet */
 #define META_WL_TOUCH_VERSION               0 /* from wl_seat; wl_touch not supported */
 #define META_WL_REGION_VERSION              1 /* from wl_compositor */
-#define META_GTK_SURFACE_VERSION            1 /* from gtk_shell */
 #define META_XDG_SURFACE_VERSION            1 /* from xdg_shell */
 #define META_XDG_POPUP_VERSION              1 /* from xdg_shell */
+#define META_WL_SHELL_SURFACE_VERSION       1 /* from wl_shell */
+#define META_GTK_SURFACE_VERSION            1 /* from gtk_shell */
 #define META_WL_SUBSURFACE_VERSION          1 /* from wl_subcompositor */
 
 /* The first version to implement a specific event */

src/wayland/meta-wayland.c

@@ -52,7 +52,7 @@
 #include <meta/main.h>
 #include "frame.h"
 #include "meta-idle-monitor-private.h"
-#include "meta-weston-launch.h"
+#include "meta-login1.h"
 #include "monitor-private.h"
 
 static MetaWaylandCompositor _meta_wayland_compositor;
@@ -643,25 +643,16 @@ 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 logind. */
 #if defined(CLUTTER_WINDOWING_EGL)
   if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
-    compositor->launcher = meta_launcher_new ();
+    compositor->login1 = meta_login1_new ();
 #endif
 
   if (clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS)
     g_error ("Failed to initialize Clutter");
 
-#if defined(CLUTTER_WINDOWING_EGL)
-  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL))
-    {
-      ClutterBackend *backend = clutter_get_default_backend ();
-      CoglContext *cogl_context = clutter_backend_get_cogl_context (backend);
-      CoglRenderer *cogl_renderer = cogl_display_get_renderer (cogl_context_get_display (cogl_context));
-      int drm_fd = cogl_kms_renderer_get_kms_fd (cogl_renderer);
-      meta_launcher_set_drm_fd (compositor->launcher, drm_fd, NULL);
-    }
-#endif
-
   meta_monitor_manager_initialize ();
   monitors = meta_monitor_manager_get ();
   g_signal_connect (monitors, "monitors-changed",
@@ -713,8 +704,8 @@ meta_wayland_finalize (void)
 
   meta_xwayland_stop (&compositor->xwayland_manager);
 
-  if (compositor->launcher)
-    meta_launcher_free (compositor->launcher);
+  if (compositor->login1)
+    meta_login1_free (compositor->login1);
 }
 
 gboolean
@@ -722,13 +713,28 @@ meta_wayland_compositor_activate_vt (MetaWaylandCompositor  *compositor,
                                      int                     vt,
                                      GError                **error)
 {
-  if (compositor->launcher)
+  if (compositor->login1)
     {
-      return meta_launcher_activate_vt (compositor->launcher, vt, error);
+      return meta_login1_activate_vt (compositor->login1, vt, error);
     }
   else
     {
-      g_debug ("Ignoring VT switch keybinding, not running as VT manager");
+      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->login1)
+    {
+      return meta_login1_activate_session (compositor->login1, error);
+    }
+  else
+    {
+      g_debug ("Ignoring activate_session, not running as display server");
       return TRUE;
     }
 }

src/wayland/meta-wayland.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2014 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by:
+ *     Jasper St. Pierre <jstpierre@mecheye.net>
+ */
+
+#ifndef META_WAYLAND_H
+#define META_WAYLAND_H
+
+#include "meta-wayland-types.h"
+
+void                    meta_wayland_init                       (void);
+void                    meta_wayland_finalize                   (void);
+
+/* We maintain a singleton MetaWaylandCompositor which can be got at via this
+ * API after meta_wayland_init() has been called. */
+MetaWaylandCompositor  *meta_wayland_compositor_get_default     (void);
+
+void                    meta_wayland_compositor_repick          (MetaWaylandCompositor *compositor);
+
+void                    meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
+                                                                 MetaWindow            *window);
+gboolean                meta_wayland_compositor_handle_event    (MetaWaylandCompositor *compositor,
+                                                                 const ClutterEvent    *event);
+
+void                    meta_wayland_compositor_update          (MetaWaylandCompositor *compositor,
+                                                                 const ClutterEvent    *event);
+void                    meta_wayland_compositor_paint_finished  (MetaWaylandCompositor *compositor);
+
+gboolean                meta_wayland_compositor_activate_vt     (MetaWaylandCompositor  *compositor,
+                                                                 int                     vt,
+                                                                 GError                **error);
+gboolean                meta_wayland_compositor_activate_session (MetaWaylandCompositor  *compositor,
+                                                                  GError                **error);
+
+#endif
+

src/wayland/meta-weston-launch.c

@@ -1,401 +0,0 @@
-/*
- * Copyright (C) 2013 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- */
-
-#include <config.h>
-
-#include <gio/gio.h>
-#include <gio/gunixfdmessage.h>
-
-#include <clutter/clutter.h>
-#include <clutter/evdev/clutter-evdev.h>
-
-#include <glib.h>
-#include <sys/time.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <stdlib.h>
-#include <sys/wait.h>
-
-#include <drm.h>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
-#include "meta-weston-launch.h"
-
-struct _MetaLauncher
-{
-  GSocket *weston_launch;
-
-  gboolean vt_switched;
-
-  GMainContext *nested_context;
-  GMainLoop *nested_loop;
-
-  GSource *inner_source;
-  GSource *outer_source;
-};
-
-static void handle_request_vt_switch (MetaLauncher *self);
-
-static gboolean
-request_vt_switch_idle (gpointer user_data)
-{
-  handle_request_vt_switch (user_data);
-
-  return FALSE;
-}
-
-static gboolean
-send_message_to_wl (MetaLauncher           *self,
-		    void                   *message,
-		    gsize                   size,
-		    GSocketControlMessage  *out_cmsg,
-		    GSocketControlMessage **in_cmsg,
-		    GError                **error)
-{
-  struct weston_launcher_reply reply;
-  GInputVector in_iov = { &reply, sizeof (reply) };
-  GOutputVector out_iov = { message, size };
-  GSocketControlMessage *out_all_cmsg[2];
-  GSocketControlMessage **in_all_cmsg;
-  int flags = 0;
-  int i;
-
-  out_all_cmsg[0] = out_cmsg;
-  out_all_cmsg[1] = NULL;
-  if (g_socket_send_message (self->weston_launch, NULL,
-			     &out_iov, 1,
-			     out_all_cmsg, -1,
-			     flags, NULL, error) != (gssize)size)
-    return FALSE;
-
-  if (g_socket_receive_message (self->weston_launch, NULL,
-				&in_iov, 1,
-			        &in_all_cmsg, NULL,
-				&flags, NULL, error) != sizeof (reply))
-    return FALSE;
-
-  while (reply.header.opcode != ((struct weston_launcher_message*)message)->opcode)
-    {
-      /* There were events queued */
-      g_assert ((reply.header.opcode & WESTON_LAUNCHER_EVENT) == WESTON_LAUNCHER_EVENT);
-
-      /* This can never happen, because the only time mutter-launch can queue
-         this event is after confirming a VT switch, and we don't make requests
-         during that time.
-
-         Note that getting this event would be really bad, because we would be
-         in the wrong loop/context.
-      */
-      g_assert (reply.header.opcode != WESTON_LAUNCHER_SERVER_VT_ENTER);
-
-      switch (reply.header.opcode)
-	{
-	case WESTON_LAUNCHER_SERVER_REQUEST_VT_SWITCH:
-	  g_idle_add (request_vt_switch_idle, self);
-	  break;
-
-	default:
-	  g_assert_not_reached ();
-	}
-
-      if (g_socket_receive_message (self->weston_launch, NULL,
-				    &in_iov, 1,
-				    NULL, NULL,
-				    &flags, NULL, error) != sizeof (reply))
-	return FALSE;
-    }
-
-  if (reply.ret != 0)
-    {
-      if (reply.ret == -1)
-	g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
-		     "Got failure from weston-launch");
-      else
-	g_set_error (error, G_IO_ERROR, g_io_error_from_errno (-reply.ret),
-		     "Got failure from weston-launch: %s", strerror (-reply.ret));
-
-      for (i = 0; in_all_cmsg && in_all_cmsg[i]; i++)
-	g_object_unref (in_all_cmsg[i]);
-      g_free (in_all_cmsg);
-
-      return FALSE;
-    }
-
-  if (in_all_cmsg && in_all_cmsg[0])
-    {
-      for (i = 1; in_all_cmsg[i]; i++)
-	g_object_unref (in_all_cmsg[i]);
-      *in_cmsg = in_all_cmsg[0];
-    }
-
-  g_free (in_all_cmsg);
-  return TRUE;
-}
-
-gboolean
-meta_launcher_set_drm_fd (MetaLauncher  *self,
-			  int            drm_fd,
-			  GError       **error)
-{
-  struct weston_launcher_message message;
-  GSocketControlMessage *cmsg;
-  gboolean ok;
-
-  message.opcode = WESTON_LAUNCHER_DRM_SET_FD;
-
-  cmsg = g_unix_fd_message_new ();
-  if (g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (cmsg),
-				   drm_fd, error) == FALSE)
-    {
-      g_object_unref (cmsg);
-      return FALSE;
-    }
-
-  ok = send_message_to_wl (self, &message, sizeof message, cmsg, NULL, error);
-
-  g_object_unref (cmsg);
-  return ok;
-}
-
-int
-meta_launcher_open_input_device (MetaLauncher  *self,
-				 const char    *name,
-				 int            flags,
-				 GError       **error)
-{
-  struct weston_launcher_open *message;
-  GSocketControlMessage *cmsg;
-  gboolean ok;
-  gsize size;
-  int *fds, n_fd;
-  int ret;
-
-  size = sizeof (struct weston_launcher_open) + strlen (name) + 1;
-  message = g_malloc (size);
-  message->header.opcode = WESTON_LAUNCHER_OPEN;
-  message->flags = flags;
-  strcpy (message->path, name);
-  message->path[strlen(name)] = 0;
-
-  ok = send_message_to_wl (self, message, size, NULL, &cmsg, error);
-
-  if (ok)
-    {
-      g_assert (G_IS_UNIX_FD_MESSAGE (cmsg));
-
-      fds = g_unix_fd_message_steal_fds (G_UNIX_FD_MESSAGE (cmsg), &n_fd);
-      g_assert (n_fd == 1);
-
-      ret = fds[0];
-      g_free (fds);
-      g_object_unref (cmsg);
-    }
-  else
-    ret = -1;
-
-  g_free (message);
-  return ret;
-}
-
-static void
-meta_launcher_enter (MetaLauncher *launcher)
-{
-  ClutterBackend *backend;
-  CoglContext *cogl_context;
-  CoglDisplay *cogl_display;
-
-  backend = clutter_get_default_backend ();
-  cogl_context = clutter_backend_get_cogl_context (backend);
-  cogl_display = cogl_context_get_display (cogl_context);
-  cogl_kms_display_queue_modes_reset (cogl_display);
-
-  clutter_evdev_reclaim_devices ();
-}
-
-static void
-meta_launcher_leave (MetaLauncher *launcher)
-{
-  clutter_evdev_release_devices ();
-}
-
-static int
-on_evdev_device_open (const char  *path,
-		      int          flags,
-		      gpointer     user_data,
-		      GError     **error)
-{
-  MetaLauncher *launcher = user_data;
-
-  return meta_launcher_open_input_device (launcher, path, flags, error);
-}
-
-static void
-handle_vt_enter (MetaLauncher *launcher)
-{
-  g_assert (launcher->vt_switched);
-
-  g_main_loop_quit (launcher->nested_loop);
-}
-
-static void
-handle_request_vt_switch (MetaLauncher *launcher)
-{
-  struct weston_launcher_message message;
-  GError *error;
-  gboolean ok;
-
-  meta_launcher_leave (launcher);
-
-  message.opcode = WESTON_LAUNCHER_CONFIRM_VT_SWITCH;
-
-  error = NULL;
-  ok = send_message_to_wl (launcher, &message, sizeof (message), NULL, NULL, &error);
-  if (!ok) {
-    g_warning ("Failed to acknowledge VT switch: %s", error->message);
-    g_error_free (error);
-
-    return;
-  }
-
-  g_assert (!launcher->vt_switched);
-  launcher->vt_switched = TRUE;
-
-  /* We can't do anything at this point, because we don't
-     have input devices and we don't have the DRM master,
-     so let's run a nested busy loop until the VT is reentered */
-  g_main_loop_run (launcher->nested_loop);
-
-  g_assert (launcher->vt_switched);
-  launcher->vt_switched = FALSE;
-
-  meta_launcher_enter (launcher);
-}
-
-static gboolean
-on_socket_readable (GSocket      *socket,
-		    GIOCondition  condition,
-		    gpointer      user_data)
-{
-  MetaLauncher *launcher = user_data;
-  struct weston_launcher_event event;
-  gssize read;
-  GError *error;
-
-  if ((condition & G_IO_IN) == 0)
-    return TRUE;
-
-  error = NULL;
-  read = g_socket_receive (socket, (char*)&event, sizeof(event), NULL, &error);
-  if (read < (gssize)sizeof(event))
-    {
-      g_warning ("Error reading from weston-launcher socket: %s", error->message);
-      g_error_free (error);
-      return TRUE;
-    }
-
-  switch (event.header.opcode)
-    {
-    case WESTON_LAUNCHER_SERVER_REQUEST_VT_SWITCH:
-      handle_request_vt_switch (launcher);
-      break;
-
-    case WESTON_LAUNCHER_SERVER_VT_ENTER:
-      handle_vt_enter (launcher);
-      break;
-    }
-
-  return TRUE;
-}
-
-static int
-env_get_fd (const char *env)
-{
-  const char *value;
-
-  value = g_getenv (env);
-
-  if (value == NULL)
-    return -1;
-  else
-    return g_ascii_strtoll (value, NULL, 10);
-}
-
-MetaLauncher *
-meta_launcher_new (void)
-{
-  MetaLauncher *self = g_slice_new0 (MetaLauncher);
-  int launch_fd;
-
-  launch_fd = env_get_fd ("WESTON_LAUNCHER_SOCK");
-  if (launch_fd < 0)
-    g_error ("Invalid mutter-launch socket");
-
-  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);
-
-  self->outer_source = g_socket_create_source (self->weston_launch, G_IO_IN, NULL);
-  g_source_set_callback (self->outer_source, (GSourceFunc)on_socket_readable, self, NULL);
-  g_source_attach (self->outer_source, NULL);
-  g_source_unref (self->outer_source);
-
-  self->inner_source = g_socket_create_source (self->weston_launch, G_IO_IN, NULL);
-  g_source_set_callback (self->inner_source, (GSourceFunc)on_socket_readable, self, NULL);
-  g_source_attach (self->inner_source, self->nested_context);
-  g_source_unref (self->inner_source);
-
-  return self;
-}
-
-void
-meta_launcher_free (MetaLauncher *launcher)
-{
-  g_source_destroy (launcher->outer_source);
-  g_source_destroy (launcher->inner_source);
-
-  g_main_loop_unref (launcher->nested_loop);
-  g_main_context_unref (launcher->nested_context);
-
-  g_object_unref (launcher->weston_launch);
-
-  g_slice_free (MetaLauncher, launcher);
-}
-
-gboolean
-meta_launcher_activate_vt (MetaLauncher  *launcher,
-			   int            vt,
-			   GError       **error)
-{
-  struct weston_launcher_activate_vt message;
-
-  message.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
-  message.vt = vt;
-
-  return send_message_to_wl (launcher, &message, sizeof (message), NULL, NULL, error);
-}
-

src/wayland/meta-weston-launch.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2013 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- */
-
-#ifndef META_WESTON_LAUNCH_H
-#define META_WESTON_LAUNCH_H
-
-#include <glib-object.h>
-#include "weston-launch.h"
-
-typedef struct _MetaLauncher MetaLauncher;
-
-MetaLauncher     *meta_launcher_new                     (void);
-void              meta_launcher_free                    (MetaLauncher  *self);
-
-gboolean          meta_launcher_activate_vt             (MetaLauncher  *self,
-							 int            number,
-							 GError       **error);
-
-gboolean          meta_launcher_set_drm_fd              (MetaLauncher  *self,
-							 int            drm_fd,
-							 GError       **error);
-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

src/wayland/meta-xwayland.c

@@ -47,10 +47,19 @@ 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;
   window->surface = surface;
 
-  meta_window_set_surface_mapped (window, TRUE);
+  meta_compositor_window_surface_changed (display->compositor, window);
 }
 
 static const struct xserver_interface xserver_implementation = {

src/wayland/weston-launch.c

@@ -1,788 +0,0 @@
-/*
- * Copyright © 2012 Benjamin Franzke
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "config.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <poll.h>
-#include <errno.h>
-
-#include <error.h>
-#include <getopt.h>
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/signalfd.h>
-#include <signal.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <limits.h>
-
-#include <termios.h>
-#include <linux/vt.h>
-#include <linux/major.h>
-#include <linux/kd.h>
-
-#include <pwd.h>
-#include <grp.h>
-
-#include <xf86drm.h>
-
-#include <systemd/sd-login.h>
-
-#include "weston-launch.h"
-
-#define MAX_ARGV_SIZE 256
-#define DRM_MAJOR     226
-
-enum vt_state {
-	VT_HAS_VT,
-	VT_PENDING_CONFIRM,
-	VT_NOT_HAVE_VT,
-};
-
-struct weston_launch {
-	int tty;
-	int ttynr;
-	int sock[2];
-	struct passwd *pw;
-
-	int signalfd;
-
-	pid_t child;
-	int verbose;
-
-	struct termios terminal_attributes;
-	int kb_mode;
-	enum vt_state vt_state;
-
-        int drm_fd;
-};
-
-union cmsg_data { unsigned char b[4]; int fd; };
-
-static void quit (struct weston_launch *wl, int status);
-
-static int
-weston_launch_allowed(struct weston_launch *wl)
-{
-	char *session, *seat;
-	int err;
-
-	if (getuid() == 0)
-		return 1;
-
-	err = sd_pid_get_session(getpid(), &session);
-	if (err == 0 && session) {
-		if (sd_session_is_active(session) &&
-		    sd_session_get_seat(session, &seat) == 0) {
-			free(seat);
-			free(session);
-			return 1;
-		}
-		free(session);
-	}
-	
-	return 0;
-}
-
-static int
-setup_launcher_socket(struct weston_launch *wl)
-{
-	if (socketpair(AF_LOCAL, SOCK_DGRAM, 0, wl->sock) < 0)
-		error(1, errno, "socketpair failed");
-	
-	fcntl(wl->sock[0], F_SETFD, O_CLOEXEC);
-
-	return 0;
-}
-
-static int
-setup_signals(struct weston_launch *wl)
-{
-	int ret;
-	sigset_t mask;
-	struct sigaction sa;
-
-	memset(&sa, 0, sizeof sa);
-	sa.sa_handler = SIG_DFL;
-	sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
-	ret = sigaction(SIGCHLD, &sa, NULL);
-	assert(ret == 0);
-
-	sa.sa_handler = SIG_IGN;
-	sa.sa_flags = 0;
-	sigaction(SIGHUP, &sa, NULL);
-
-	ret = sigemptyset(&mask);
-	assert(ret == 0);
-	sigaddset(&mask, SIGCHLD);
-	sigaddset(&mask, SIGINT);
-	sigaddset(&mask, SIGTERM);
-	sigaddset(&mask, SIGUSR1);
-	ret = sigprocmask(SIG_BLOCK, &mask, NULL);
-	assert(ret == 0);
-
-	wl->signalfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
-	if (wl->signalfd < 0)
-		return -errno;
-
-	return 0;
-}
-
-static void
-setenv_fd(const char *env, int fd)
-{
-	char buf[32];
-
-	snprintf(buf, sizeof buf, "%d", fd);
-	setenv(env, buf, 1);
-}
-
-static int
-handle_setdrmfd(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
-{
-        struct weston_launcher_reply reply;
-	struct cmsghdr *cmsg;
-	union cmsg_data *data;
-	struct stat s;
-
-	reply.header.opcode = WESTON_LAUNCHER_DRM_SET_FD;
-	reply.ret = -1;
-
-	if (wl->drm_fd != -1) {
-		error(0, 0, "DRM FD already set");
-		reply.ret = -EINVAL;
-		goto out;
-	}
-
-	cmsg = CMSG_FIRSTHDR(msg);
-	if (!cmsg ||
-	    cmsg->cmsg_level != SOL_SOCKET ||
-	    cmsg->cmsg_type != SCM_RIGHTS) {
-		error(0, 0, "invalid control message");
-		reply.ret = -EINVAL;
-		goto out;
-	}
-
-	data = (union cmsg_data *) CMSG_DATA(cmsg);
-	if (data->fd < 0) {
-		error(0, 0, "missing drm fd in socket request");
-		reply.ret = -EINVAL;
-		goto out;
-	}
-
-	if (fstat(data->fd, &s) < 0) {
-		reply.ret = -errno;
-		goto out;
-	}
-
-	if (major(s.st_rdev) != DRM_MAJOR) {
-		fprintf(stderr, "FD is not for DRM\n");
-		reply.ret = -EPERM;
-		goto out;
-	}
-
-	wl->drm_fd = data->fd;
-	reply.ret = drmSetMaster(data->fd);
-	if (reply.ret < 0)
-		reply.ret = -errno;
-
-	if (wl->verbose)
-		fprintf(stderr, "mutter-launch: set drm FD, ret: %d, fd: %d\n",
-			reply.ret, data->fd);
-
-out:
-	do {
-		len = send(wl->sock[0], &reply, sizeof reply, 0);
-	} while (len < 0 && errno == EINTR);
-	if (len < 0)
-		return -1;
-
-	return 0;
-}
-
-static int
-handle_confirm_vt_switch(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
-{
-        struct weston_launcher_reply reply;
-
-	reply.header.opcode = WESTON_LAUNCHER_CONFIRM_VT_SWITCH;
-	reply.ret = -1;
-
-	if (wl->vt_state != VT_PENDING_CONFIRM) {
-		error(0, 0, "unexpected CONFIRM_VT_SWITCH");
-		goto out;
-	}
-
-	if (wl->drm_fd != -1) {
-		int ret;
-
-		ret = drmDropMaster(wl->drm_fd);
-		if (ret < 0) {
-			fprintf(stderr, "failed to drop DRM master: %m\n");
-		} else if (wl->verbose) {
-			fprintf(stderr, "dropped DRM master for VT switch\n");
-		}
-	}
-
-	wl->vt_state = VT_NOT_HAVE_VT;
-	ioctl(wl->tty, VT_RELDISP, 1);
-
-	if (wl->verbose)
-		fprintf(stderr, "mutter-launcher: confirmed VT switch\n");
-
-	reply.ret = 0;
-
-out:
-	do {
-		len = send(wl->sock[0], &reply, sizeof reply, 0);
-	} while (len < 0 && errno == EINTR);
-	if (len < 0)
-		return -1;
-
-	return 0;
-}
-
-static int
-handle_activate_vt(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
-{
-        struct weston_launcher_reply reply;
-	struct weston_launcher_activate_vt *message;
-
-	reply.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
-	reply.ret = -1;
-
-	if (len != sizeof(*message)) {
-		error(0, 0, "missing value in activate_vt request");
-		goto out;
-	}
-
-	message = msg->msg_iov->iov_base;
-
-	reply.ret = ioctl(wl->tty, VT_ACTIVATE, message->vt);
-	if (reply.ret < 0)
-		reply.ret = -errno;
-
-	if (wl->verbose)
-		fprintf(stderr, "mutter-launch: activate VT, ret: %d\n", reply.ret);
-
-out:
-	do {
-		len = send(wl->sock[0], &reply, sizeof reply, 0);
-	} while (len < 0 && errno == EINTR);
-	if (len < 0)
-		return -1;
-
-	return 0;
-}
-
-
-static int
-handle_open(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
-{
-        struct weston_launcher_reply reply;
-	int fd = -1;
-	char control[CMSG_SPACE(sizeof(fd))];
-	struct cmsghdr *cmsg;
-	struct stat s;
-	struct msghdr nmsg;
-	struct iovec iov;
-	struct weston_launcher_open *message;
-	union cmsg_data *data;
-
-	reply.header.opcode = WESTON_LAUNCHER_OPEN;
-	reply.ret = -1;
-
-	message = msg->msg_iov->iov_base;
-	if ((size_t)len < sizeof(*message))
-		goto err0;
-
-	/* Ensure path is null-terminated */
-	((char *) message)[len-1] = '\0';
-
-	if (stat(message->path, &s) < 0) {
-		reply.ret = -errno;
-		goto err0;
-	}
-
-	fd = open(message->path, message->flags);
-	if (fd < 0) {
-		fprintf(stderr, "Error opening device %s: %m\n",
-			message->path);
-		reply.ret = -errno;
-		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;
-	nmsg.msg_iovlen = 1;
-	if (fd != -1) {
-		nmsg.msg_control = control;
-		nmsg.msg_controllen = sizeof control;
-		cmsg = CMSG_FIRSTHDR(&nmsg);
-		cmsg->cmsg_level = SOL_SOCKET;
-		cmsg->cmsg_type = SCM_RIGHTS;
-		cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
-		data = (union cmsg_data *) CMSG_DATA(cmsg);
-		data->fd = fd;
-		nmsg.msg_controllen = cmsg->cmsg_len;
-		reply.ret = 0;
-	}
-	iov.iov_base = &reply;
-	iov.iov_len = sizeof reply;
-
-	if (wl->verbose)
-		fprintf(stderr, "mutter-launch: opened %s: ret: %d, fd: %d\n",
-			message->path, reply.ret, fd);
-	do {
-		len = sendmsg(wl->sock[0], &nmsg, 0);
-	} while (len < 0 && errno == EINTR);
-
-	close(fd);
-
-	if (len < 0)
-		return -1;
-
-	return 0;
-}
-
-static int
-handle_socket_msg(struct weston_launch *wl)
-{
-	char control[CMSG_SPACE(sizeof(int))];
-	char buf[BUFSIZ];
-	struct msghdr msg;
-	struct iovec iov;
-	int ret = -1;
-	ssize_t len;
-	struct weston_launcher_message *message;
-
-	memset(&msg, 0, sizeof(msg));
-	iov.iov_base = buf;
-	iov.iov_len  = sizeof buf;
-	msg.msg_iov = &iov;
-	msg.msg_iovlen = 1;
-	msg.msg_control = control;
-	msg.msg_controllen = sizeof control;
-
-	do {
-		len = recvmsg(wl->sock[0], &msg, 0);
-	} while (len < 0 && errno == EINTR);
-
-	if (len < 1)
-		return -1;
-
-	message = (void *) buf;
-	switch (message->opcode) {
-	case WESTON_LAUNCHER_OPEN:
-		ret = handle_open(wl, &msg, len);
-		break;
-	case WESTON_LAUNCHER_DRM_SET_FD:
-		ret = handle_setdrmfd(wl, &msg, len);
-		break;
-	case WESTON_LAUNCHER_CONFIRM_VT_SWITCH:
-		ret = handle_confirm_vt_switch(wl, &msg, len);
-		break;
-	case WESTON_LAUNCHER_ACTIVATE_VT:
-		ret = handle_activate_vt(wl, &msg, len);
-		break;
-	}
-
-	return ret;
-}
-
-static void
-tty_reset(struct weston_launch *wl)
-{
-	struct vt_mode mode = { 0 };
-
-	if (ioctl(wl->tty, KDSKBMODE, wl->kb_mode))
-		fprintf(stderr, "failed to restore keyboard mode: %m\n");
-
-	if (ioctl(wl->tty, KDSETMODE, KD_TEXT))
-		fprintf(stderr, "failed to set KD_TEXT mode on tty: %m\n");
-
-	if (tcsetattr(wl->tty, TCSANOW, &wl->terminal_attributes) < 0)
-		fprintf(stderr, "could not restore terminal to canonical mode\n");
-
-	mode.mode = VT_AUTO;
-	if (ioctl(wl->tty, VT_SETMODE, &mode) < 0)
-		fprintf(stderr, "could not reset vt handling\n");
-}
-
-static void
-quit(struct weston_launch *wl, int status)
-{
-	if (wl->child > 0)
-		kill(wl->child, SIGKILL);
-
-	close(wl->signalfd);
-	close(wl->sock[0]);
-
-	if (wl->drm_fd > 0)
-		close(wl->drm_fd);
-
-	tty_reset(wl);
-
-	exit(status);
-}
-
-static int
-handle_vt_switch(struct weston_launch *wl)
-{
-	struct weston_launcher_event message;
-	ssize_t len;
-
-	if (wl->vt_state == VT_HAS_VT) {
-		wl->vt_state = VT_PENDING_CONFIRM;
-		message.header.opcode = WESTON_LAUNCHER_SERVER_REQUEST_VT_SWITCH;
-	} else if (wl->vt_state == VT_NOT_HAVE_VT) {
-		wl->vt_state = VT_HAS_VT;
-		ioctl(wl->tty, VT_RELDISP, VT_ACKACQ);
-
-		if (wl->drm_fd != -1) {
-			int ret;
-
-			ret = drmSetMaster(wl->drm_fd);
-			if (ret < 0) {
-				fprintf(stderr, "failed to become DRM master: %m\n");
-				/* This is very, very bad, and the compositor will crash soon,
-				   but oh well... */
-			} else if (wl->verbose) {
-				fprintf(stderr, "became DRM master after VT switch\n");
-			}
-		}
-
-		message.header.opcode = WESTON_LAUNCHER_SERVER_VT_ENTER;
-	} else
-		return -1;
-
-	message.detail = 0;
-
-	do {
-		len = send(wl->sock[0], &message, sizeof(message), 0);
-	} while (len < 0 && errno == EINTR);
-
-	return 0;
-}
-
-
-static int
-handle_signal(struct weston_launch *wl)
-{
-	struct signalfd_siginfo sig;
-	int pid, status, ret;
-
-	if (read(wl->signalfd, &sig, sizeof sig) != sizeof sig) {
-		error(0, errno, "reading signalfd failed");
-		return -1;
-	}
-
-	switch (sig.ssi_signo) {
-	case SIGCHLD:
-		pid = waitpid(-1, &status, 0);
-		if (pid == wl->child) {
-			wl->child = 0;
-			if (WIFEXITED(status))
-				ret = WEXITSTATUS(status);
-			else if (WIFSIGNALED(status))
-				/*
-				 * If weston dies because of signal N, we
-				 * return 10+N. This is distinct from
-				 * weston-launch dying because of a signal
-				 * (128+N).
-				 */
-				ret = 10 + WTERMSIG(status);
-			else
-				ret = 0;
-			quit(wl, ret);
-		}
-		break;
-	case SIGTERM:
-	case SIGINT:
-		if (wl->child)
-			kill(wl->child, sig.ssi_signo);
-		break;
-	case SIGUSR1:
-		return handle_vt_switch(wl);
-	default:
-		return -1;
-	}
-
-	return 0;
-}
-
-static int
-setup_tty(struct weston_launch *wl)
-{
-	struct stat buf;
-	struct termios raw_attributes;
-	struct vt_mode mode = { 0 };
-	char *session, *tty;
-	char path[PATH_MAX];
-	int ok;
-
-	ok = sd_pid_get_session(getpid(), &session);
-	if (ok < 0)
-	  error(1, -ok, "could not determine current session");
-
-	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.
-
-		   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");
-
-	if (fstat(wl->tty, &buf) < 0)
-		error(1, errno, "stat %s failed", path);
-
-	if (major(buf.st_rdev) != TTY_MAJOR)
-		error(1, 0, "invalid tty device: %s", path);
-
-	wl->ttynr = minor(buf.st_rdev);
-
-	if (tcgetattr(wl->tty, &wl->terminal_attributes) < 0)
-		error(1, errno, "could not get terminal attributes");
-
-	/* Ignore control characters and disable echo */
-	raw_attributes = wl->terminal_attributes;
-	cfmakeraw(&raw_attributes);
-
-	/* Fix up line endings to be normal (cfmakeraw hoses them) */
-	raw_attributes.c_oflag |= OPOST | OCRNL;
-	/* Don't generate ttou signals */
-	raw_attributes.c_oflag &= ~TOSTOP;
-
-	if (tcsetattr(wl->tty, TCSANOW, &raw_attributes) < 0)
-	        error(1, errno, "could not put terminal into raw mode");
-
-	ioctl(wl->tty, KDGKBMODE, &wl->kb_mode);
-	ok = ioctl(wl->tty, KDSKBMODE, K_OFF);
-	if (ok < 0) {
-		ok = ioctl(wl->tty, KDSKBMODE, K_RAW);
-		if (ok < 0)
-			error(1, errno, "failed to set keyboard mode on tty");
-	}
-
-	ok = ioctl(wl->tty, KDSETMODE, KD_GRAPHICS);
-	if (ok < 0)
-		error(1, errno, "failed to set KD_GRAPHICS mode on tty");
-
-	wl->vt_state = VT_HAS_VT;
-	mode.mode = VT_PROCESS;
-	mode.relsig = SIGUSR1;
-	mode.acqsig = SIGUSR1;
-	ok = ioctl(wl->tty, VT_SETMODE, &mode);
-	if (ok < 0)
-		error(1, errno, "failed to take control of vt handling");
-
-	return 0;
-}
-
-static void
-drop_privileges(struct weston_launch *wl)
-{
-	if (setgid(wl->pw->pw_gid) < 0 ||
-#ifdef HAVE_INITGROUPS
-	    initgroups(wl->pw->pw_name, wl->pw->pw_gid) < 0 ||
-#endif
-	    setuid(wl->pw->pw_uid) < 0)
-		error(1, errno, "dropping privileges failed");
-}
-
-static void
-launch_compositor(struct weston_launch *wl, int argc, char *argv[])
-{
-	char command[PATH_MAX];
-	char *child_argv[MAX_ARGV_SIZE];
-	sigset_t mask;
-	int i;
-
-	if (wl->verbose)
-		printf("weston-launch: spawned weston with pid: %d\n", getpid());
-
-	drop_privileges(wl);
-
-	setenv_fd("WESTON_LAUNCHER_SOCK", wl->sock[1]);
-	setenv("LD_LIBRARY_PATH", LIBDIR, 1);
-	unsetenv("DISPLAY");
-
-	/* Do not give our signal mask to the new process. */
-	sigemptyset(&mask);
-	sigaddset(&mask, SIGTERM);
-	sigaddset(&mask, SIGCHLD);
-	sigaddset(&mask, SIGINT);
-	sigaddset(&mask, SIGUSR1);
-	sigprocmask(SIG_UNBLOCK, &mask, NULL);
-
-	snprintf (command, PATH_MAX, "%s \"$@\"", argv[0]);
-
-	child_argv[0] = wl->pw->pw_shell;
-	child_argv[1] = "-l";
-	child_argv[2] = "-c";
-	child_argv[3] = command;
-	for (i = 0; i < argc; ++i)
-		child_argv[4 + i] = argv[i];
-	child_argv[4 + i] = NULL;
-
-	execv(child_argv[0], child_argv);
-	error(1, errno, "exec failed");
-}
-
-static void
-help(const char *name)
-{
-	fprintf(stderr, "Usage: %s [args...] [-- [weston args..]]\n", name);
-	fprintf(stderr, "  -u, --user      Start session as specified username\n");
-	fprintf(stderr, "  -v, --verbose   Be verbose\n");
-	fprintf(stderr, "  -h, --help      Display this help message\n");
-}
-
-int
-main(int argc, char *argv[])
-{
-	struct weston_launch wl;
-	int i, c;
-	struct option opts[] = {
-		{ "verbose", no_argument,       NULL, 'v' },
-		{ "help",    no_argument,       NULL, 'h' },
-		{ 0,         0,                 NULL,  0  }
-	};	
-
-	memset(&wl, 0, sizeof wl);
-	wl.drm_fd = -1;
-
-	while ((c = getopt_long(argc, argv, "u:t::vh", opts, &i)) != -1) {
-		switch (c) {
-		case 'v':
-			wl.verbose = 1;
-			break;
-		case 'h':
-			help("mutter-launch");
-			exit(EXIT_FAILURE);
-		}
-	}
-
-	if ((argc - optind) > (MAX_ARGV_SIZE - 6))
-		error(1, E2BIG, "Too many arguments to pass to weston");
-
-	if (optind >= argc)
-		error(1, 0, "Expected program argument");
-
-	wl.pw = getpwuid(getuid());
-	if (wl.pw == NULL)
-		error(1, errno, "failed to get username");
-
-	if (!weston_launch_allowed(&wl))
-		error(1, 0, "Permission denied. You must run from an active and local (systemd) session.");
-
-	if (setup_tty(&wl) < 0)
-		exit(EXIT_FAILURE);
-
-	if (setup_launcher_socket(&wl) < 0)
-		exit(EXIT_FAILURE);
-
-	if (setup_signals(&wl) < 0)
-		exit(EXIT_FAILURE);
-
-	wl.child = fork();
-	if (wl.child == -1) {
-		error(1, errno, "fork failed");
-		exit(EXIT_FAILURE);
-	}
-
-	if (wl.child == 0)
-		launch_compositor(&wl, argc - optind, argv + optind);
-
-	close(wl.sock[1]);
-
-	while (1) {
-		struct pollfd fds[2];
-		int n;
-
-		fds[0].fd = wl.sock[0];
-		fds[0].events = POLLIN;
-		fds[1].fd = wl.signalfd;
-		fds[1].events = POLLIN;
-
-		n = poll(fds, 2, -1);
-		if (n < 0)
-			error(0, errno, "poll failed");
-		if (fds[0].revents & POLLIN)
-			handle_socket_msg(&wl);
-		if (fds[1].revents)
-			handle_signal(&wl);
-	}
-
-	return 0;
-}

src/wayland/weston-launch.h

@@ -1,69 +0,0 @@
-/*
- * Copyright © 2012 Benjamin Franzke
- *             2013 Red Hat, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software and
- * its documentation for any purpose is hereby granted without fee, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of the copyright holders not be used in
- * advertising or publicity pertaining to distribution of the software
- * without specific, written prior permission.  The copyright holders make
- * no representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef _WESTON_LAUNCH_H_
-#define _WESTON_LAUNCH_H_
-
-enum weston_launcher_message_type {
-	WESTON_LAUNCHER_REQUEST,
-	WESTON_LAUNCHER_EVENT,
-};
-
-enum weston_launcher_opcode {
-	WESTON_LAUNCHER_OPEN              = (1 << 1 | WESTON_LAUNCHER_REQUEST),
-	WESTON_LAUNCHER_DRM_SET_FD        = (2 << 1 | WESTON_LAUNCHER_REQUEST),
-	WESTON_LAUNCHER_ACTIVATE_VT       = (3 << 1 | WESTON_LAUNCHER_REQUEST),
-	WESTON_LAUNCHER_CONFIRM_VT_SWITCH = (4 << 1 | WESTON_LAUNCHER_REQUEST),
-};
-
-enum weston_launcher_server_opcode {
-	WESTON_LAUNCHER_SERVER_REQUEST_VT_SWITCH = (1 << 1 | WESTON_LAUNCHER_EVENT),
-	WESTON_LAUNCHER_SERVER_VT_ENTER          = (2 << 1 | WESTON_LAUNCHER_EVENT),
-};
-
-struct weston_launcher_message {
-	int opcode;
-};
-
-struct weston_launcher_open {
-	struct weston_launcher_message header;
-	int flags;
-	char path[0];
-};
-
-struct weston_launcher_activate_vt {
-	struct weston_launcher_message header;
-	int vt;
-};
-
-struct weston_launcher_reply {
-	struct weston_launcher_message header;
-	int ret;
-};
-
-struct weston_launcher_event {
-	struct weston_launcher_message header;
-	int detail; /* unused, but makes sure replies and events are serialized the same */
-};
-
-#endif