Implement wlr-layer-shell.

Very WIP, experimenting mainly with nemo-desktop for now.

Author: mtwebster

src/compositor/compositor.c

@@ -998,8 +998,13 @@ sync_actor_stacking (MetaCompositor *compositor)
       children = clutter_actor_get_children (priv->bottom_window_group);
       for (tmp = children; tmp != NULL; tmp = tmp->next)
         {
-          MetaWindowActor *child = tmp->data;
-          MetaWindow *mw = meta_window_actor_get_meta_window (child);
+          ClutterActor *child = tmp->data;
+          MetaWindow *mw;
+
+          if (!META_IS_WINDOW_ACTOR (child))
+            continue;
+
+          mw = meta_window_actor_get_meta_window (META_WINDOW_ACTOR (child));
 
           if (mw != NULL)
             {

src/compositor/meta-surface-actor.c

@@ -94,7 +94,7 @@ get_scaled_region (MetaSurfaceActor     *surface_actor,
   float x, y;
 
   window_actor = meta_window_actor_from_actor (CLUTTER_ACTOR (surface_actor));
-  geometry_scale = meta_window_actor_get_geometry_scale (window_actor);
+  geometry_scale = window_actor ? meta_window_actor_get_geometry_scale (window_actor) : 1;
 
   clutter_actor_get_position (CLUTTER_ACTOR (surface_actor), &x, &y);
   cairo_region_translate (region, x, y);
@@ -331,7 +331,7 @@ meta_surface_actor_is_untransformed (MetaCullable *cullable)
   clutter_actor_get_abs_allocation_vertices (actor, verts);
 
   window_actor = meta_window_actor_from_actor (actor);
-  geometry_scale = meta_window_actor_get_geometry_scale (window_actor);
+  geometry_scale = window_actor ? meta_window_actor_get_geometry_scale (window_actor) : 1;
 
   return meta_actor_vertices_are_untransformed (verts,
                                                 width * geometry_scale,

src/core/constraints.c

@@ -853,7 +853,7 @@ constrain_custom_rule (MetaWindow         *window,
     return TRUE;
 
   parent = meta_window_get_transient_for (window);
-  if (window->placement.state == META_PLACEMENT_STATE_CONSTRAINED_FINISHED)
+  if (parent && window->placement.state == META_PLACEMENT_STATE_CONSTRAINED_FINISHED)
     {
       placement_rule->parent_rect.x = parent->rect.x;
       placement_rule->parent_rect.y = parent->rect.y;
@@ -880,8 +880,8 @@ constrain_custom_rule (MetaWindow         *window,
     case META_PLACEMENT_STATE_CONSTRAINED_FINISHED:
     case META_PLACEMENT_STATE_INVALIDATED:
       temporary_rect = (MetaRectangle) {
-        .x = parent->rect.x + window->placement.current.rel_x,
-        .y = parent->rect.y + window->placement.current.rel_y,
+        .x = (parent ? parent->rect.x : parent_x) + window->placement.current.rel_x,
+        .y = (parent ? parent->rect.y : parent_y) + window->placement.current.rel_y,
         .width = info->current.width,
         .height = info->current.height,
       };

src/core/window.c

@@ -1820,17 +1820,23 @@ gboolean
 meta_window_should_be_showing (MetaWindow  *window)
 {
   MetaWorkspaceManager *workspace_manager = window->display->workspace_manager;
+  gboolean has_buffer, on_workspace, showing_on_workspace;
 
 #ifdef HAVE_WAYLAND
   if (window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND &&
       !meta_wayland_surface_get_buffer (window->surface))
     return FALSE;
+  has_buffer = TRUE;
+#else
+  has_buffer = TRUE;
 #endif
 
+  on_workspace = meta_window_located_on_workspace (window, workspace_manager->active_workspace);
+  showing_on_workspace = meta_window_showing_on_its_workspace (window);
+
   /* Windows should be showing if they're located on the
    * active workspace and they're showing on their own workspace. */
-  return (meta_window_located_on_workspace (window, workspace_manager->active_workspace) &&
-          meta_window_showing_on_its_workspace (window));
+  return (on_workspace && showing_on_workspace);
 }
 
 static void
@@ -4542,6 +4548,25 @@ meta_window_move_resize_internal (MetaWindow          *window,
 
   constrained_rect = unconstrained_rect;
   temporary_rect = window->rect;
+
+  /* If the window doesn't have a monitor yet but has a placement rule
+   * (e.g., for popups from layer-shell surfaces), try to determine the
+   * monitor from the placement rule's parent rect so constraints can be applied. */
+  if (!window->monitor && window->placement.rule)
+    {
+      MetaBackend *backend = meta_get_backend ();
+      MetaMonitorManager *monitor_manager =
+        meta_backend_get_monitor_manager (backend);
+      MetaLogicalMonitor *logical_monitor;
+      MetaRectangle *parent_rect = &window->placement.rule->parent_rect;
+
+      logical_monitor =
+        meta_monitor_manager_get_logical_monitor_from_rect (monitor_manager,
+                                                            parent_rect);
+      if (logical_monitor)
+        window->monitor = logical_monitor;
+    }
+
   if (flags & (META_MOVE_RESIZE_MOVE_ACTION | META_MOVE_RESIZE_RESIZE_ACTION) &&
       !(flags & META_MOVE_RESIZE_WAYLAND_FINISH_MOVE_RESIZE) &&
       window->monitor)

src/core/workspace-private.h

@@ -62,6 +62,7 @@ struct _MetaWorkspace
   GList  *screen_edges;
   GList  *monitor_edges;
   GSList *builtin_struts;
+  GSList *layer_shell_struts;
   GSList *all_struts;
   guint work_areas_invalid : 1;
 
@@ -88,6 +89,14 @@ void meta_workspace_get_work_area_for_logical_monitor (MetaWorkspace      *works
 
 void meta_workspace_invalidate_work_area (MetaWorkspace *workspace);
 
+void meta_workspace_set_layer_shell_struts (MetaWorkspace *workspace,
+                                            GSList        *struts);
+
+void meta_workspace_get_work_area_for_logical_monitor_excluding_layer_shell (
+                                                       MetaWorkspace      *workspace,
+                                                       MetaLogicalMonitor *logical_monitor,
+                                                       MetaRectangle      *area);
+
 GList* meta_workspace_get_onscreen_region       (MetaWorkspace *workspace);
 GList * meta_workspace_get_onmonitor_region (MetaWorkspace      *workspace,
                                              MetaLogicalMonitor *logical_monitor);

src/core/workspace.c

@@ -302,6 +302,22 @@ workspace_free_builtin_struts (MetaWorkspace *workspace)
   workspace->builtin_struts = NULL;
 }
 
+/**
+ * workspace_free_layer_shell_struts:
+ * @workspace: The workspace.
+ *
+ * Frees the struts list set with meta_workspace_set_layer_shell_struts
+ */
+static void
+workspace_free_layer_shell_struts (MetaWorkspace *workspace)
+{
+  if (workspace->layer_shell_struts == NULL)
+    return;
+
+  g_slist_free_full (workspace->layer_shell_struts, g_free);
+  workspace->layer_shell_struts = NULL;
+}
+
 /* Ensure that the workspace is empty by making sure that
  * all of our windows are on-all-workspaces. */
 static void
@@ -333,6 +349,7 @@ meta_workspace_remove (MetaWorkspace *workspace)
   g_list_free (workspace->list_containing_self);
 
   workspace_free_builtin_struts (workspace);
+  workspace_free_layer_shell_struts (workspace);
 
   /* screen.c:update_num_workspaces(), which calls us, removes windows from
    * workspaces first, which can cause the workareas on the workspace to be
@@ -899,6 +916,16 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
 
   workspace->all_struts = copy_strut_list (workspace->builtin_struts);
 
+  /* Add layer-shell struts */
+  {
+    GSList *s_iter;
+    for (s_iter = workspace->layer_shell_struts; s_iter != NULL; s_iter = s_iter->next)
+      {
+        workspace->all_struts = g_slist_prepend (workspace->all_struts,
+                                                 copy_strut (s_iter->data));
+      }
+  }
+
   windows = meta_workspace_list_windows (workspace);
   for (tmp = windows; tmp != NULL; tmp = tmp->next)
     {
@@ -1161,6 +1188,28 @@ meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
   meta_workspace_invalidate_work_area (workspace);
 }
 
+/**
+ * meta_workspace_set_layer_shell_struts:
+ * @workspace: a #MetaWorkspace
+ * @struts: (element-type Meta.Strut) (transfer none): list of #MetaStrut
+ *
+ * Sets a list of struts from layer-shell surfaces that will be used
+ * in addition to the builtin struts and window struts when computing
+ * the work area of the workspace.
+ */
+void
+meta_workspace_set_layer_shell_struts (MetaWorkspace *workspace,
+                                       GSList        *struts)
+{
+  if (strut_lists_equal (struts, workspace->layer_shell_struts))
+    return;
+
+  workspace_free_layer_shell_struts (workspace);
+  workspace->layer_shell_struts = copy_strut_list (struts);
+
+  meta_workspace_invalidate_work_area (workspace);
+}
+
 void
 meta_workspace_get_work_area_for_logical_monitor (MetaWorkspace      *workspace,
                                                   MetaLogicalMonitor *logical_monitor,
@@ -1171,6 +1220,56 @@ meta_workspace_get_work_area_for_logical_monitor (MetaWorkspace      *workspace,
                                             area);
 }
 
+/**
+ * meta_workspace_get_work_area_for_logical_monitor_excluding_layer_shell:
+ * @workspace: a #MetaWorkspace
+ * @logical_monitor: a #MetaLogicalMonitor
+ * @area: (out): location to store the work area
+ *
+ * Computes work area for @logical_monitor using only builtin struts,
+ * excluding layer-shell struts. This is used for positioning layer-shell
+ * surfaces so they don't get pushed by their own struts.
+ */
+void
+meta_workspace_get_work_area_for_logical_monitor_excluding_layer_shell (
+                                                       MetaWorkspace      *workspace,
+                                                       MetaLogicalMonitor *logical_monitor,
+                                                       MetaRectangle      *area)
+{
+  GList *tmp;
+  GList *monitor_region;
+  GSList *struts_for_calculation = NULL;
+  GSList *s_iter;
+
+  g_return_if_fail (logical_monitor != NULL);
+  g_return_if_fail (area != NULL);
+
+  /* Start with builtin struts only */
+  for (s_iter = workspace->builtin_struts; s_iter != NULL; s_iter = s_iter->next)
+    {
+      MetaStrut *strut = s_iter->data;
+      MetaStrut *copy = g_new0 (MetaStrut, 1);
+      *copy = *strut;
+      struts_for_calculation = g_slist_prepend (struts_for_calculation, copy);
+    }
+
+  /* Calculate region for this monitor using only builtin struts */
+  monitor_region =
+    meta_rectangle_get_minimal_spanning_set_for_region (&logical_monitor->rect,
+                                                        struts_for_calculation);
+
+  /* Find work area from the region */
+  *area = logical_monitor->rect;
+  for (tmp = monitor_region; tmp != NULL; tmp = tmp->next)
+    {
+      MetaRectangle *rect = tmp->data;
+      meta_rectangle_intersect (area, rect, area);
+    }
+
+  g_list_free_full (monitor_region, g_free);
+  g_slist_free_full (struts_for_calculation, g_free);
+}
+
 /**
  * meta_workspace_get_work_area_for_monitor:
  * @workspace: a #MetaWorkspace

src/meson.build

@@ -520,6 +520,8 @@ if have_wayland
     'wayland/meta-wayland-dnd-surface.h',
     'wayland/meta-wayland-gtk-shell.c',
     'wayland/meta-wayland-gtk-shell.h',
+    'wayland/meta-wayland-layer-shell.c',
+    'wayland/meta-wayland-layer-shell.h',
     'wayland/meta-wayland.h',
     'wayland/meta-wayland-idle-inhibit.c',
     'wayland/meta-wayland-idle-inhibit.h',
@@ -808,6 +810,7 @@ if have_wayland
   wayland_protocols = [
     ['cursor-shape-v1', 'private', ],
     ['gtk-shell', 'private', ],
+    ['wlr-layer-shell-unstable-v1', 'private', ],
     ['idle-inhibit', 'unstable', 'v1', ],
     ['keyboard-shortcuts-inhibit', 'unstable', 'v1', ],
     ['linux-dmabuf', 'unstable', 'v1', ],

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

@@ -182,6 +182,7 @@ meta_wayland_actor_surface_real_sync_actor_state (MetaWaylandActorSurface *actor
   stex = meta_surface_actor_get_texture (surface_actor);
 
   buffer = surface->buffer_ref.buffer;
+
   if (buffer)
     {
       CoglSnippet *snippet;