csd-background: Use gtk-layer-shell if available to run under

wayland.

Current csd-background runs as an xwayland client and has special
handling built in to muffin to 'make it work'.

This will allow it to run as a native client, if muffin has the
capability, and if csd-background has been built with support.

ref:
linuxmint/muffin#784
linuxmint/nemo#3684

Author: mtwebster

debian/control

@@ -14,6 +14,7 @@ Build-Depends:
  libfontconfig1-dev,
  libglib2.0-dev (>= 2.37.3),
  libgtk-3-dev (>= 3.9.10),
+ libgtk-layer-shell-dev,
  libgudev-1.0-dev [linux-any],
  liblcms2-dev,
  libnotify-dev (>= 0.7.0),
@@ -24,6 +25,7 @@ Build-Depends:
  libsystemd-dev [linux-any],
  libupower-glib-dev (>= 0.99.11),
  libwacom-dev (>= 0.4) [!s390x !hurd-any !kfreebsd-any],
+ libwayland-dev,
  libx11-dev,
  libxext-dev,
  libxi-dev,

debian/rules

@@ -15,6 +15,7 @@ DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
 override_dh_auto_configure:
 	dh_auto_configure -- \
 	    --libexecdir=/usr/libexec \
+		-D gtk_layer_shell=true \
 	    $(CONFFLAGS)
 
 

meson.build

@@ -89,6 +89,14 @@ if not get_option('use_logind').disabled()
     endif
 endif
 
+gtk_layer_shell_enabled = get_option('gtk_layer_shell')
+gtk_layer_shell = dependency('', required: false)
+wayland_client = dependency('', required: false)
+if gtk_layer_shell_enabled
+    gtk_layer_shell = dependency('gtk-layer-shell-0', version: '>= 0.8', required: true)
+    wayland_client = dependency('wayland-client', required: true)
+endif
+
 cc = meson.get_compiler('c')
 math = cc.find_library('m', required: false)
 
@@ -105,6 +113,9 @@ csd_conf.set_quoted('LIBEXECDIR', join_paths(prefix, libexecdir))
 csd_conf.set_quoted('SYSCONFDIR', sysconfdir)
 csd_conf.set_quoted('LIBDIR', libdir)
 csd_conf.set10('HAVE_TIMERFD', has_timerfd_create)
+if gtk_layer_shell_enabled
+    csd_conf.set('HAVE_GTK_LAYER_SHELL', 1)
+endif
 
 if gudev.found()
     cargs += '-DHAVE_GUDEV'

meson_options.txt

@@ -70,3 +70,9 @@ option(
     value: '/usr/share/zoneinfo/zone.tab',
     description: 'Path to tzdata zone.tab or zone1970.tab'
 )
+option(
+    'gtk_layer_shell',
+    type: 'boolean',
+    value: false,
+    description: 'Use gtk-layer-shell for native Wayland background windows'
+)

plugins/background/csd-background-manager.c

@@ -59,11 +59,14 @@ struct CsdBackgroundManagerPrivate
         guint        proxy_signal_id;
 
         GPtrArray   *mbs;
+
+        guint        screen_changed_id;
 };
 
 static void     csd_background_manager_finalize    (GObject             *object);
 
 static void setup_bg (CsdBackgroundManager *manager);
+static void setup_monitors (CsdBackgroundManager *manager);
 static void connect_screen_signals (CsdBackgroundManager *manager);
 
 G_DEFINE_TYPE (CsdBackgroundManager, csd_background_manager, G_TYPE_OBJECT)
@@ -177,12 +180,31 @@ settings_change_event_cb (GSettings            *settings,
         return FALSE;
 }
 
+static gboolean
+on_screen_changed_idle (gpointer user_data)
+{
+        CsdBackgroundManager *manager = CSD_BACKGROUND_MANAGER (user_data);
+
+        manager->priv->screen_changed_id = 0;
+
+        if (session_is_wayland ()) {
+                setup_monitors (manager);
+        }
+
+        draw_background (manager);
+
+        return G_SOURCE_REMOVE;
+}
+
 static void
 on_screen_size_changed (GdkScreen            *screen,
                         CsdBackgroundManager *manager)
 {
+        if (manager->priv->screen_changed_id != 0)
+                return;
 
-        draw_background (manager);
+        manager->priv->screen_changed_id =
+                g_timeout_add (250, on_screen_changed_idle, manager);
 }
 
 static void
@@ -396,6 +418,8 @@ csd_background_manager_stop (CsdBackgroundManager *manager)
 
         g_debug ("Stopping background manager");
 
+        g_clear_handle_id (&manager->priv->screen_changed_id, g_source_remove);
+
         disconnect_screen_signals (manager);
 
         if (manager->priv->proxy) {

plugins/background/main.c

@@ -1,3 +1,8 @@
+#include "config.h"
+
+#include <glib.h>
+#include <gdk/gdk.h>
+
 #define NEW csd_background_manager_new
 #define START csd_background_manager_start
 #define STOP csd_background_manager_stop
@@ -12,8 +17,34 @@
 // Setting this to TRUE makes the plugin force GDK_SCALE=1
 #define FORCE_GDK_SCALE TRUE
 
-// This plugin must run under x11/xwayland
+// When gtk-layer-shell is available, check at runtime if the compositor
+// supports wlr-layer-shell. If not, fall back to X11/XWayland.
+#ifdef HAVE_GTK_LAYER_SHELL
+#include "wayland-utils.h"
+
+static void
+pre_gtk_init (void)
+{
+    if (csd_check_layer_shell_support ()) {
+        g_message ("csd-background: using Wayland backend, gtk-layer-shell supported");
+    } else {
+        g_message ("csd-background: not a Wayland session or wlr-layer-shell protocol not supported, using X11 backend");
+        gdk_set_allowed_backends ("x11");
+    }
+}
+
+#define PRE_GTK_INIT pre_gtk_init
+#define FORCE_X11_BACKEND FALSE
+#else
+static void
+pre_gtk_init (void)
+{
+    g_message ("csd-background: gtk-layer-shell not built, using X11 backend");
+}
+
+#define PRE_GTK_INIT pre_gtk_init
 #define FORCE_X11_BACKEND TRUE
+#endif
 
 #include "csd-background-manager.h"
 

plugins/background/meson.build

@@ -13,6 +13,10 @@ background_deps = [
     libnotify,
 ]
 
+if gtk_layer_shell_enabled
+    background_deps += gtk_layer_shell
+endif
+
 executable(
     'csd-background',
     background_sources,

plugins/background/monitor-background.c

@@ -11,40 +11,14 @@
 #include <glib/gstdio.h>
 #include <gtk/gtk.h>
 
+#ifdef HAVE_GTK_LAYER_SHELL
+#include <gtk-layer-shell/gtk-layer-shell.h>
+#endif
+
 #include "monitor-background.h"
 
 G_DEFINE_TYPE (MonitorBackground, monitor_background, G_TYPE_OBJECT)
 
-enum {
-    INVALIDATED,
-    N_SIGNALS
-};
-
-static guint signals[N_SIGNALS] = { 0 };
-
-static void
-invalidate_mb (MonitorBackground *mb)
-{
-    mb->valid = FALSE;
-
-    g_signal_emit (mb, signals[INVALIDATED], 0);
-}
-
-static void
-on_gdk_monitor_dispose (gpointer data,
-                        GObject *monitor)
-{
-    MonitorBackground *mb = MONITOR_BACKGROUND (data);
-    invalidate_mb (mb);
-}
-
-static void
-on_gdk_monitor_invalidate (gpointer data)
-{
-    MonitorBackground *mb = MONITOR_BACKGROUND (data);
-    invalidate_mb (mb);
-}
-
 static void
 on_window_realized (GtkWidget *widget,
                     gpointer   user_data)
@@ -60,14 +34,33 @@ static void
 build_monitor_background (MonitorBackground *mb)
 {
     GdkRectangle geometry;
+#ifdef HAVE_GTK_LAYER_SHELL
+    gboolean use_layer_shell = gtk_layer_is_supported ();
+#else
+    gboolean use_layer_shell = FALSE;
+#endif
 
     mb->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-    gtk_window_set_type_hint (GTK_WINDOW (mb->window), GDK_WINDOW_TYPE_HINT_DESKTOP);
     gtk_window_set_decorated (GTK_WINDOW (mb->window), FALSE);
 
-    // Set keep below so muffin recognizes the backgrounds and keeps them
-    // at the bottom of the bottom window layer (under file managers, etc..)
-    gtk_window_set_keep_below (GTK_WINDOW (mb->window), TRUE);
+#ifdef HAVE_GTK_LAYER_SHELL
+    if (use_layer_shell) {
+        gtk_layer_init_for_window (GTK_WINDOW (mb->window));
+        gtk_layer_set_layer (GTK_WINDOW (mb->window), GTK_LAYER_SHELL_LAYER_BACKGROUND);
+        gtk_layer_set_namespace (GTK_WINDOW (mb->window), "csd-background");
+        gtk_layer_set_keyboard_mode (GTK_WINDOW (mb->window), GTK_LAYER_SHELL_KEYBOARD_MODE_NONE);
+        gtk_layer_set_exclusive_zone (GTK_WINDOW (mb->window), -1);
+        gtk_layer_set_anchor (GTK_WINDOW (mb->window), GTK_LAYER_SHELL_EDGE_TOP, TRUE);
+        gtk_layer_set_anchor (GTK_WINDOW (mb->window), GTK_LAYER_SHELL_EDGE_BOTTOM, TRUE);
+        gtk_layer_set_anchor (GTK_WINDOW (mb->window), GTK_LAYER_SHELL_EDGE_LEFT, TRUE);
+        gtk_layer_set_anchor (GTK_WINDOW (mb->window), GTK_LAYER_SHELL_EDGE_RIGHT, TRUE);
+        gtk_layer_set_monitor (GTK_WINDOW (mb->window), mb->monitor);
+    } else
+#endif
+    {
+        gtk_window_set_type_hint (GTK_WINDOW (mb->window), GDK_WINDOW_TYPE_HINT_DESKTOP);
+        gtk_window_set_keep_below (GTK_WINDOW (mb->window), TRUE);
+    }
 
     mb->stack = gtk_stack_new ();
     g_object_set (mb->stack,
@@ -81,22 +74,25 @@ build_monitor_background (MonitorBackground *mb)
     mb->width = geometry.width;
     mb->height = geometry.height;
 
-    gtk_window_set_default_size (GTK_WINDOW (mb->window), geometry.width, geometry.height);
+    if (!use_layer_shell) {
+        gtk_window_set_default_size (GTK_WINDOW (mb->window), geometry.width, geometry.height);
+        g_signal_connect (mb->window, "realize", G_CALLBACK (on_window_realized), mb);
+    }
 
-    g_signal_connect (mb->window, "realize", G_CALLBACK (on_window_realized), mb);
     gtk_widget_show_all (mb->window);
 }
 
 static void
 monitor_background_init (MonitorBackground *mb)
 {
-    mb->valid = TRUE;
 }
 
 static void
 monitor_background_dispose (GObject *object)
 {
-    g_debug ("MonitorBackground dispose (%p)", object);
+    MonitorBackground *mb = MONITOR_BACKGROUND (object);
+
+    g_clear_pointer (&mb->window, gtk_widget_destroy);
 
     G_OBJECT_CLASS (monitor_background_parent_class)->dispose (object);
 }
@@ -117,13 +113,6 @@ monitor_background_class_init (MonitorBackgroundClass *klass)
 
     gobject_class->dispose = monitor_background_dispose;
     gobject_class->finalize = monitor_background_finalize;
-
-    signals[INVALIDATED] = g_signal_new ("invalidated",
-                                         G_OBJECT_CLASS_TYPE (gobject_class),
-                                         G_SIGNAL_RUN_LAST,
-                                         0,
-                                         NULL, NULL, NULL,
-                                         G_TYPE_NONE, 0);
 }
 
 MonitorBackground *
@@ -133,9 +122,6 @@ monitor_background_new (gint index, GdkMonitor *monitor)
     mb->monitor_index = index;
     mb->monitor = monitor;
 
-    g_object_weak_ref (G_OBJECT (monitor), (GWeakNotify) on_gdk_monitor_dispose, mb);
-    g_signal_connect_swapped (monitor, "invalidate", G_CALLBACK (on_gdk_monitor_invalidate), mb);
-
     build_monitor_background (mb);
 
     return mb;
@@ -144,12 +130,6 @@ monitor_background_new (gint index, GdkMonitor *monitor)
 GtkImage *
 monitor_background_get_pending_image (MonitorBackground *mb)
 {
-    if (!mb->valid)
-    {
-        g_warning ("Asked for pending image when monitor is no longer valid");
-        return NULL;
-    }
-
     if (!mb->pending)
     {
         mb->pending = gtk_image_new ();
@@ -165,12 +145,6 @@ monitor_background_show_next_image (MonitorBackground *mb)
 {
     g_return_if_fail (mb->pending != NULL);
 
-    if (!mb->valid)
-    {
-        g_warning ("Asked for pending image when monitor is no longer valid");
-        return;
-    }
-
     GtkWidget *tmp;
 
     tmp = mb->current;

plugins/background/monitor-background.h

@@ -20,8 +20,6 @@ struct _MonitorBackground
     GtkWidget *current;
     GtkWidget *pending;
 
-    gboolean valid;
-
     gint monitor_index;
     gint width;
     gint height;

plugins/common/daemon-skeleton-gtk.h

@@ -31,6 +31,10 @@
 #define INIT_LIBNOTIFY FALSE
 #endif
 
+#ifndef PRE_GTK_INIT
+#define PRE_GTK_INIT()
+#endif
+
 #define GNOME_SESSION_DBUS_NAME           "org.gnome.SessionManager"
 #define GNOME_SESSION_DBUS_PATH           "/org/gnome/SessionManager"
 #define GNOME_SESSION_CLIENT_PRIVATE_NAME "org.gnome.SessionManager.ClientPrivate"
@@ -210,6 +214,8 @@ main (int argc, char **argv)
         g_type_ensure (G_TYPE_DBUS_CONNECTION);
         g_type_ensure (G_TYPE_DBUS_PROXY);
 
+        PRE_GTK_INIT();
+
         if (FORCE_X11_BACKEND) {
             const gchar *setup_display = getenv ("GNOME_SETUP_DISPLAY");
             if (setup_display && *setup_display != '\0')