compositor: add hooks for fullscreen and unfullscreen animations

https://bugzilla.gnome.org/show_bug.cgi?id=707248

src/compositor/compositor.c

@@ -779,7 +779,7 @@ meta_compositor_size_change_window (MetaCompositor    *compositor,
                                     MetaRectangle     *old_buffer_rect)
 {
   MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  meta_window_actor_size_change (window_actor, META_SIZE_CHANGE_MAXIMIZE, old_frame_rect, old_buffer_rect);
+  meta_window_actor_size_change (window_actor, which_change, old_frame_rect, old_buffer_rect);
 }
 
 void

src/compositor/meta-window-actor.c

@@ -832,21 +832,23 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
     return TRUE;
 
   /*
-   * Do not add shadows to non-opaque windows; eventually we should generate
-   * a shadow from the input shape for such windows.
+   * Do not add shadows to non-opaque (ARGB32) windows, as we can't easily
+   * generate shadows for them.
    */
   if (is_non_opaque (self))
     return FALSE;
 
   /*
-   * Add shadows to override redirect windows on X11 unless the toolkit
-   * indicates that it is handling shadows itself (e.g., Gtk menus).
+   * If a window specifies that it has custom frame extents, that likely
+   * means that it is drawing a shadow itself. Don't draw our own.
    */
-  if (priv->window->override_redirect &&
-      !priv->window->has_custom_frame_extents)
-    return TRUE;
+  if (priv->window->has_custom_frame_extents)
+    return FALSE;
 
-  return FALSE;
+  /*
+   * Generate shadows for all other windows.
+   */
+  return TRUE;
 }
 
 /**

src/core/display.c

@@ -1963,9 +1963,12 @@ meta_display_end_grab_op (MetaDisplay *display,
   meta_topic (META_DEBUG_WINDOW_OPS,
               "Ending grab op %u at time %u\n", grab_op, timestamp);
 
-  if (display->event_route == META_EVENT_ROUTE_NORMAL)
+  if (display->event_route == META_EVENT_ROUTE_NORMAL ||
+      display->event_route == META_EVENT_ROUTE_COMPOSITOR_GRAB)
     return;
 
+  g_assert (grab_window != NULL);
+
   g_signal_emit (display, display_signals[GRAB_OP_END], 0,
                  display->screen, grab_window, grab_op);
 

src/core/prefs.c

@@ -96,6 +96,10 @@ static gboolean bell_is_audible = TRUE;
 static gboolean gnome_accessibility = FALSE;
 static gboolean gnome_animations = TRUE;
 static char *cursor_theme = NULL;
+/* cursor_size will, when running as an X11 compositing window manager, be the
+ * actual cursor size, multiplied with the global window scaling factor. On
+ * Wayland, it will be the actual cursor size retrieved from gsettings.
+ */
 static int   cursor_size = 24;
 static int   draggable_border_width = 10;
 static int   drag_threshold;
@@ -123,6 +127,9 @@ static gboolean update_binding         (MetaKeyPref *binding,
 static gboolean update_key_binding     (const char  *key,
                                         gchar      **strokes);
 
+static void wayland_settings_changed (GSettings      *settings,
+                                      gchar          *key,
+                                      gpointer        data);
 static void settings_changed (GSettings      *settings,
                               gchar          *key,
                               gpointer        data);
@@ -134,9 +141,10 @@ static void shell_shows_app_menu_changed (GtkSettings *settings,
                                           GParamSpec  *pspec,
                                           gpointer     data);
 
-static void update_cursor_size (GtkSettings *settings,
-                                GParamSpec *pspec,
-                                gpointer data);
+static void update_cursor_size_from_gtk (GtkSettings *settings,
+                                         GParamSpec *pspec,
+                                         gpointer data);
+static void update_cursor_size (void);
 
 static void queue_changed (MetaPreference  pref);
 
@@ -963,14 +971,18 @@ meta_prefs_init (void)
                     G_CALLBACK (settings_changed), NULL);
   g_signal_connect (settings, "changed::" KEY_GNOME_CURSOR_THEME,
                     G_CALLBACK (settings_changed), NULL);
+  if (meta_is_wayland_compositor ())
+    g_signal_connect (settings, "changed::cursor-size",
+                      G_CALLBACK (wayland_settings_changed), NULL);
   g_hash_table_insert (settings_schemas, g_strdup (SCHEMA_INTERFACE), settings);
 
   g_signal_connect (gtk_settings_get_default (),
                     "notify::gtk-shell-shows-app-menu",
                     G_CALLBACK (shell_shows_app_menu_changed), NULL);
 
-  g_signal_connect (gtk_settings_get_default (), "notify::gtk-cursor-theme-size",
-                    G_CALLBACK (update_cursor_size), NULL);
+  if (!meta_is_wayland_compositor ())
+    g_signal_connect (gtk_settings_get_default (), "notify::gtk-cursor-theme-size",
+                      G_CALLBACK (update_cursor_size_from_gtk), NULL);
 
   settings = g_settings_new (SCHEMA_INPUT_SOURCES);
   g_signal_connect (settings, "changed::" KEY_XKB_OPTIONS,
@@ -992,7 +1004,7 @@ meta_prefs_init (void)
   handle_preference_init_string_array ();
   handle_preference_init_int ();
 
-  update_cursor_size (gtk_settings_get_default (), NULL, NULL);
+  update_cursor_size ();
   shell_shows_app_menu_changed (gtk_settings_get_default (), NULL, NULL);
 
   init_bindings ();
@@ -1133,6 +1145,20 @@ meta_prefs_override_preference_schema (const char *key, const char *schema)
 /****************************************************************************/
 
 
+static void
+wayland_settings_changed (GSettings      *settings,
+                          gchar          *key,
+                          gpointer        data)
+{
+  GVariant *value = g_settings_get_value (settings, key);
+  const GVariantType *type = g_variant_get_type (value);
+
+  g_return_if_fail (g_variant_type_equal (type, G_VARIANT_TYPE_INT32));
+  g_return_if_fail (g_str_equal (key, "cursor-size"));
+
+  update_cursor_size ();
+}
+
 static void
 settings_changed (GSettings *settings,
                   gchar *key,
@@ -1216,9 +1242,29 @@ shell_shows_app_menu_changed (GtkSettings *settings,
 }
 
 static void
-update_cursor_size (GtkSettings *settings,
-                    GParamSpec *pspec,
-                    gpointer data)
+update_cursor_size (void)
+{
+  if (meta_is_wayland_compositor ())
+    {
+      /* When running as a Wayland compositor, since we size of the cursor
+       * depends on what output it is on, we cannot use the GTK+
+       * "gtk-cursor-theme-size" setting because it has already been multiplied
+       * by the primary monitor scale. So, instead get the non-premultiplied
+       * cursor size value directly from gsettings instead.
+       */
+      cursor_size =
+        g_settings_get_int (SETTINGS (SCHEMA_INTERFACE), "cursor-size");
+    }
+  else
+    {
+      update_cursor_size_from_gtk (gtk_settings_get_default (), NULL, NULL);
+    }
+}
+
+static void
+update_cursor_size_from_gtk (GtkSettings *settings,
+                             GParamSpec *pspec,
+                             gpointer data)
 {
   GdkScreen *screen = gdk_screen_get_default ();
   GValue value = G_VALUE_INIT;

src/core/stack.c

@@ -1055,7 +1055,7 @@ stack_sync_to_xserver (MetaStack *stack)
   all_root_children_stacked = g_array_new (FALSE, FALSE, sizeof (guint64));
   x11_hidden_stack_ids = g_array_new (FALSE, FALSE, sizeof (guint64));
 
-  meta_topic (META_DEBUG_STACK, "Top to bottom: ");
+  meta_topic (META_DEBUG_STACK, "Bottom to top: ");
   meta_push_no_msg_prefix ();
 
   for (tmp = g_list_last(stack->sorted); tmp != NULL; tmp = tmp->prev)

src/core/window.c

@@ -763,10 +763,22 @@ meta_window_update_desc (MetaWindow *window)
 {
   g_clear_pointer (&window->desc, g_free);
 
-  if (window->title)
-    window->desc = g_strdup_printf ("0x%lx (%.10s)", window->xwindow, window->title);
+  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
+    {
+      if (window->title)
+        window->desc = g_strdup_printf ("0x%lx (%.10s)", window->xwindow, window->title);
+      else
+        window->desc = g_strdup_printf ("0x%lx", window->xwindow);
+    }
   else
-    window->desc = g_strdup_printf ("0x%lx", window->xwindow);
+    {
+      guint64 small_stamp = window->stamp - G_GUINT64_CONSTANT(0x100000000);
+
+      if (window->title)
+        window->desc = g_strdup_printf ("W%" G_GUINT64_FORMAT " (%.10s)", small_stamp, window->title);
+      else
+        window->desc = g_strdup_printf ("W%" G_GUINT64_FORMAT , small_stamp);
+    }
 }
 
 static void
@@ -3183,12 +3195,23 @@ meta_window_make_fullscreen (MetaWindow  *window)
 
   if (!window->fullscreen)
     {
-      meta_window_make_fullscreen_internal (window);
+      MetaRectangle old_frame_rect, old_buffer_rect;
 
+      meta_window_get_frame_rect (window, &old_frame_rect);
+      meta_window_get_buffer_rect (window, &old_buffer_rect);
+
+      meta_window_make_fullscreen_internal (window);
       meta_window_move_resize_internal (window,
-                                        META_MOVE_RESIZE_MOVE_ACTION | META_MOVE_RESIZE_RESIZE_ACTION | META_MOVE_RESIZE_STATE_CHANGED,
+                                        (META_MOVE_RESIZE_MOVE_ACTION |
+                                         META_MOVE_RESIZE_RESIZE_ACTION |
+                                         META_MOVE_RESIZE_STATE_CHANGED |
+                                         META_MOVE_RESIZE_DONT_SYNC_COMPOSITOR),
                                         NorthWestGravity,
                                         window->unconstrained_rect);
+
+      meta_compositor_size_change_window (window->display->compositor,
+                                          window, META_SIZE_CHANGE_FULLSCREEN,
+                                          &old_frame_rect, &old_buffer_rect);
     }
 }
 
@@ -3199,7 +3222,7 @@ meta_window_unmake_fullscreen (MetaWindow  *window)
 
   if (window->fullscreen)
     {
-      MetaRectangle target_rect;
+      MetaRectangle old_frame_rect, old_buffer_rect, target_rect;
 
       meta_topic (META_DEBUG_WINDOW_OPS,
                   "Unfullscreening %s\n", window->desc);
@@ -3208,6 +3231,8 @@ meta_window_unmake_fullscreen (MetaWindow  *window)
       target_rect = window->saved_rect;
 
       meta_window_frame_size_changed (window);
+      meta_window_get_frame_rect (window, &old_frame_rect);
+      meta_window_get_buffer_rect (window, &old_buffer_rect);
 
       /* Window's size hints may have changed while maximized, making
        * saved_rect invalid.  #329152
@@ -3222,10 +3247,17 @@ meta_window_unmake_fullscreen (MetaWindow  *window)
       set_net_wm_state (window);
 
       meta_window_move_resize_internal (window,
-                                        META_MOVE_RESIZE_MOVE_ACTION | META_MOVE_RESIZE_RESIZE_ACTION | META_MOVE_RESIZE_STATE_CHANGED,
+                                        (META_MOVE_RESIZE_MOVE_ACTION |
+                                         META_MOVE_RESIZE_RESIZE_ACTION |
+                                         META_MOVE_RESIZE_STATE_CHANGED |
+                                         META_MOVE_RESIZE_DONT_SYNC_COMPOSITOR),
                                         NorthWestGravity,
                                         target_rect);
 
+      meta_compositor_size_change_window (window->display->compositor,
+                                          window, META_SIZE_CHANGE_UNFULLSCREEN,
+                                          &old_frame_rect, &old_buffer_rect);
+
       meta_window_update_layer (window);
 
       g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_FULLSCREEN]);

src/meta/compositor.h

@@ -57,6 +57,8 @@ typedef enum
 typedef enum {
   META_SIZE_CHANGE_MAXIMIZE,
   META_SIZE_CHANGE_UNMAXIMIZE,
+  META_SIZE_CHANGE_FULLSCREEN,
+  META_SIZE_CHANGE_UNFULLSCREEN
 } MetaSizeChange;
 
 MetaCompositor *meta_compositor_new     (MetaDisplay    *display);

src/ui/theme.c

@@ -915,11 +915,9 @@ meta_theme_get_default (void)
       switch (frame_type)
         {
         case META_FRAME_TYPE_NORMAL:
-          break;
         case META_FRAME_TYPE_DIALOG:
         case META_FRAME_TYPE_MODAL_DIALOG:
         case META_FRAME_TYPE_ATTACHED:
-          layout->hide_buttons = TRUE;
           break;
         case META_FRAME_TYPE_MENU:
         case META_FRAME_TYPE_UTILITY:

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

@@ -912,6 +912,12 @@ meta_wayland_data_device_set_keyboard_focus (MetaWaylandDataDevice *data_device)
   MetaWaylandDataSource *source;
 
   focus_client = meta_wayland_keyboard_get_focus_client (&seat->keyboard);
+
+  if (focus_client == data_device->focus_client)
+    return;
+
+  data_device->focus_client = focus_client;
+
   if (!focus_client)
     return;
 

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

@@ -55,6 +55,7 @@ struct _MetaWaylandDataDevice
   struct wl_listener selection_data_source_listener;
   struct wl_list resource_list;
   MetaWaylandDragGrab *current_grab;
+  struct wl_client *focus_client;
 
   struct wl_signal selection_ownership_signal;
   struct wl_signal dnd_ownership_signal;

src/wayland/meta-wayland-pointer.c

@@ -53,6 +53,7 @@
 #include "meta-wayland-private.h"
 #include "meta-wayland-surface.h"
 #include "meta-wayland-buffer.h"
+#include "meta-xwayland.h"
 #include "meta-cursor.h"
 #include "meta-cursor-tracker-private.h"
 #include "meta-surface-actor-wayland.h"
@@ -819,9 +820,12 @@ cursor_sprite_prepare_at (MetaCursorSprite *cursor_sprite,
   MetaScreen *screen = display->screen;
   const MetaMonitorInfo *monitor;
 
-  monitor = meta_screen_get_monitor_for_point (screen, x, y);
-  meta_cursor_sprite_set_texture_scale (cursor_sprite,
-                                        (float)monitor->scale / surface->scale);
+  if (!meta_xwayland_is_xwayland_surface (surface))
+    {
+      monitor = meta_screen_get_monitor_for_point (screen, x, y);
+      meta_cursor_sprite_set_texture_scale (cursor_sprite,
+                                            (float)monitor->scale / surface->scale);
+    }
   meta_wayland_surface_update_outputs (surface);
 }
 

src/wayland/meta-wayland-surface.c

@@ -351,12 +351,6 @@ toplevel_surface_commit (MetaWaylandSurfaceRole  *surface_role,
           return;
         }
     }
-  else if (META_IS_WAYLAND_SURFACE_ROLE_XDG_POPUP (surface->role))
-    {
-      /* Ignore commits if we couldn't grab the pointer */
-      if (!window)
-        return;
-    }
   else
     {
       if (surface->buffer == NULL)
@@ -369,10 +363,11 @@ toplevel_surface_commit (MetaWaylandSurfaceRole  *surface_role,
         }
     }
 
-  g_assert (window != NULL);
-
-  /* We resize X based surfaces according to X events */
-  if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
+  /* Update the state of the MetaWindow if we still have one. We might not if
+   * the window was unmanaged (for example popup destroyed, NULL buffer attached to
+   * wl_shell_surface wl_surface, xdg_surface object was destroyed, etc).
+   */
+  if (window && window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
     {
       MetaRectangle geom = { 0 };
 

src/wayland/meta-xwayland-selection.c

@@ -410,27 +410,33 @@ x11_data_write_cb (GObject      *object,
   MetaSelectionBridge *selection = user_data;
   X11SelectionData *data = selection->x11_selection;
   GError *error = NULL;
+  gboolean success = TRUE;
 
   g_output_stream_write_finish (G_OUTPUT_STREAM (object), res, &error);
 
-  if (data->incr)
+  if (error)
+    {
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_error_free (error);
+          return;
+        }
+
+      g_warning ("Error writing from X11 selection: %s\n", error->message);
+      g_error_free (error);
+      success = FALSE;
+    }
+
+  if (success && data->incr)
     {
       Display *xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
       XDeleteProperty (xdisplay, selection->window,
                        gdk_x11_get_xatom_by_name ("_META_SELECTION"));
     }
-
-  if (error)
+  else
     {
-      if (error->domain != G_IO_ERROR ||
-          error->code != G_IO_ERROR_CANCELLED)
-        g_warning ("Error writing from X11 selection: %s\n", error->message);
-
-      g_error_free (error);
+      x11_selection_data_finish (selection, success);
     }
-
-  if (!data->incr)
-    x11_selection_data_finish (selection, TRUE);
 }
 
 static void

src/wayland/meta-xwayland.c

@@ -174,6 +174,15 @@ meta_xwayland_handle_wl_surface_id (MetaWindow *window,
     }
 }
 
+gboolean
+meta_xwayland_is_xwayland_surface (MetaWaylandSurface *surface)
+{
+  MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
+  MetaXWaylandManager *manager = &compositor->xwayland_manager;
+
+  return wl_resource_get_client (surface->resource) == manager->client;
+}
+
 static gboolean
 try_display (int    display,
              char **filename_out,

src/wayland/meta-xwayland.h

@@ -28,8 +28,13 @@
 #include <glib.h>
 #include <meta/types.h>
 
+#include "wayland/meta-wayland-types.h"
+
 void
 meta_xwayland_handle_wl_surface_id (MetaWindow *window,
                                     guint32     surface_id);
 
+gboolean
+meta_xwayland_is_xwayland_surface (MetaWaylandSurface *surface);
+
 #endif /* META_XWAYLAND_H */

src/x11/window-x11.c

@@ -2000,12 +2000,16 @@ meta_window_move_resize_request (MetaWindow *window,
   if (flags & (META_MOVE_RESIZE_MOVE_ACTION | META_MOVE_RESIZE_RESIZE_ACTION))
     {
       MetaRectangle rect, monitor_rect;
+      MetaRectangle old_frame_rect, old_buffer_rect;
+      gboolean legacy_fullscreen;
 
       rect.x = x;
       rect.y = y;
       rect.width = width;
       rect.height = height;
 
+      meta_window_get_frame_rect (window, &old_frame_rect);
+      meta_window_get_buffer_rect (window, &old_buffer_rect);
       meta_screen_get_monitor_geometry (window->screen, window->monitor->number, &monitor_rect);
 
       /* Workaround braindead legacy apps that don't know how to
@@ -2015,12 +2019,14 @@ meta_window_move_resize_request (MetaWindow *window,
        * if there are no struts making the workarea smaller than
        * the monitor.
        */
-      if (meta_prefs_get_force_fullscreen() &&
-          !window->hide_titlebar_when_maximized &&
-          (window->decorated || !meta_window_is_client_decorated (window)) &&
-          meta_rectangle_equal (&rect, &monitor_rect) &&
-          window->has_fullscreen_func &&
-          !window->fullscreen)
+      legacy_fullscreen = (meta_prefs_get_force_fullscreen() &&
+                           !window->hide_titlebar_when_maximized &&
+                           (window->decorated || !meta_window_is_client_decorated (window)) &&
+                           meta_rectangle_equal (&rect, &monitor_rect) &&
+                           window->has_fullscreen_func &&
+                           !window->fullscreen);
+
+      if (legacy_fullscreen)
         {
           /*
           meta_topic (META_DEBUG_GEOMETRY,
@@ -2030,11 +2036,17 @@ meta_window_move_resize_request (MetaWindow *window,
                       "fullscreen request\n",
                       window->desc);
           meta_window_make_fullscreen_internal (window);
+          flags |= META_MOVE_RESIZE_DONT_SYNC_COMPOSITOR;
         }
 
       adjust_for_gravity (window, TRUE, gravity, &rect);
       meta_window_client_rect_to_frame_rect (window, &rect, &rect);
       meta_window_move_resize_internal (window, flags, gravity, rect);
+
+      if (legacy_fullscreen)
+        meta_compositor_size_change_window (window->display->compositor,
+                                            window, META_SIZE_CHANGE_FULLSCREEN,
+                                            &old_frame_rect, &old_buffer_rect);
     }
 }
 

src/x11/xprops.c

@@ -507,7 +507,7 @@ window_from_results (GetPropertyResults *results,
   if (!validate_or_free_results (results, 32, XA_WINDOW, TRUE))
     return FALSE;
 
-  *window_p = *(Window*) results->prop;
+  *window_p = *(uint32_t *) results->prop;
   g_free (results->prop);
   results->prop = NULL;
 
@@ -523,7 +523,7 @@ counter_from_results (GetPropertyResults *results,
                                  TRUE))
     return FALSE;
 
-  *counter_p = *(XSyncCounter*) results->prop;
+  *counter_p = *(uint32_t *) results->prop;
   g_free (results->prop);
   results->prop = NULL;