wayland: support xdg-shell as a fallback

Support the xdg-shell wayland protocol as a fallback in case the
wlr-layer-shell-unstable-v1 protocol is not present. This allows running
dunst on wayland compositors not supporting the layer shell protocol.

Note that the xdg-shell protocol doesn't allow dunst to specify where
it should be displayed on the screen. Therefore it is only chosen, when
the layer-shell protocol is not available.

Author: pslldq

src/wayland/wl.c

@@ -40,7 +40,7 @@ struct window_wl {
         cairo_t * c_ctx;
 };
 
-struct wl_ctx ctx;
+struct wl_ctx ctx = { 0 };
 
 static void surface_handle_enter(void *data, struct wl_surface *surface,
                 struct wl_output *wl_output) {
@@ -83,13 +83,36 @@ static void layer_surface_handle_configure(void *data,
         send_frame();
 }
 
-static void layer_surface_handle_closed(void *data,
-                struct zwlr_layer_surface_v1 *surface) {
-        LOG_I("Destroying layer");
-        if (ctx.layer_surface)
-                zwlr_layer_surface_v1_destroy(ctx.layer_surface);
-        ctx.layer_surface = NULL;
+static void xdg_surface_handle_configure(void *data,
+                struct xdg_surface *surface,
+                uint32_t serial) {
+        xdg_surface_ack_configure(ctx.xdg_surface, serial);
+
+        if (ctx.configured) {
+                wl_surface_commit(ctx.surface);
+                return;
+        }
+
+        ctx.configured = true;
+
+        send_frame();
+}
+
+static void xdg_toplevel_handle_configure(void *data,
+        struct xdg_toplevel *xdg_toplevel,
+        int32_t width,
+        int32_t height,
+        struct wl_array *states) {
+        if (width == ctx.width && height == ctx.height) {
+                return;
+        }
+
+        ctx.configured = false;
+        ctx.width = width;
+        ctx.height = height;
+}
 
+static void surface_handle_closed(void) {
         if (ctx.surface)
                 wl_surface_destroy(ctx.surface);
         ctx.surface = NULL;
@@ -111,11 +134,53 @@ static void layer_surface_handle_closed(void *data,
         }
 }
 
+static void layer_surface_handle_closed(void *data,
+                struct zwlr_layer_surface_v1 *surface) {
+        LOG_I("Destroying layer");
+        if (ctx.layer_surface)
+                zwlr_layer_surface_v1_destroy(ctx.layer_surface);
+        ctx.layer_surface = NULL;
+
+        surface_handle_closed();
+}
+
+static void xdg_toplevel_handle_close(void *data,
+                struct xdg_toplevel *surface) {
+        LOG_I("Destroying layer");
+        if (ctx.xdg_toplevel)
+                xdg_toplevel_destroy(ctx.xdg_toplevel);
+        ctx.xdg_toplevel = NULL;
+        if (ctx.xdg_surface)
+                xdg_surface_destroy(ctx.xdg_surface);
+        ctx.xdg_surface = NULL;
+
+        surface_handle_closed();
+}
+
+static void xdg_wm_base_handle_ping(void *data,
+                struct xdg_wm_base *xdg_wm_base,
+                uint32_t serial) {
+        xdg_wm_base_pong(ctx.xdg_shell, serial);
+}
+
 static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
         .configure = layer_surface_handle_configure,
         .closed = layer_surface_handle_closed,
 };
 
+static const struct xdg_wm_base_listener xdg_wm_base_listener = {
+        .ping = xdg_wm_base_handle_ping,
+};
+
+static const struct xdg_surface_listener xdg_surface_listener = {
+        .configure = xdg_surface_handle_configure,
+};
+
+static const struct xdg_toplevel_listener xdg_toplevel_listener = {
+        .configure = xdg_toplevel_handle_configure,
+        .close = xdg_toplevel_handle_close,
+};
+
 // Warning, can return NULL
 static struct dunst_output *get_configured_output(void) {
         int n = 0;
@@ -164,6 +229,10 @@ static void handle_global(void *data, struct wl_registry *registry,
         } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
                 ctx.layer_shell = wl_registry_bind(registry, name,
                                 &zwlr_layer_shell_v1_interface, 1);
+        } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
+                ctx.xdg_shell = wl_registry_bind(registry, name,
+                                &xdg_wm_base_interface, 1);
+                xdg_wm_base_add_listener(ctx.xdg_shell, &xdg_wm_base_listener, NULL);
         } else if (strcmp(interface, wl_seat_interface.name) == 0) {
                 create_seat(registry, name, version);
                 LOG_D("Binding to seat %i", name);
@@ -262,8 +331,12 @@ bool wl_init(void) {
                 return false;
         }
         if (ctx.layer_shell == NULL) {
-                LOG_W("compositor doesn't support zwlr_layer_shell_v1");
-                return false;
+                if (ctx.xdg_shell == NULL) {
+                        LOG_W("compositor doesn't support zwlr_layer_shell_v1 or xdg_shell");
+                        return false;
+                } else {
+                        LOG_W("compositor doesn't support zwlr_layer_shell_v1, falling back to xdg_shell. Notification window position will be set by the compositor.");
+                }
         }
         if (wl_list_empty(&ctx.seats)) {
                 LOG_W("no seat was found, so dunst cannot see input");
@@ -334,6 +407,12 @@ void wl_deinit(void) {
         if (ctx.layer_surface != NULL) {
                 g_clear_pointer(&ctx.layer_surface, zwlr_layer_surface_v1_destroy);
         }
+        if (ctx.xdg_toplevel != NULL) {
+                g_clear_pointer(&ctx.xdg_toplevel, xdg_toplevel_destroy);
+        }
+        if (ctx.xdg_surface != NULL) {
+                g_clear_pointer(&ctx.xdg_surface, xdg_surface_destroy);
+        }
         if (ctx.surface != NULL) {
                 g_clear_pointer(&ctx.surface, wl_surface_destroy);
         }
@@ -371,6 +450,9 @@ void wl_deinit(void) {
         if (ctx.layer_shell)
                 g_clear_pointer(&ctx.layer_shell, zwlr_layer_shell_v1_destroy);
 
+        if (ctx.xdg_shell)
+                g_clear_pointer(&ctx.xdg_shell, xdg_wm_base_destroy);
+
         if (ctx.compositor)
                 g_clear_pointer(&ctx.compositor, wl_compositor_destroy);
 
@@ -393,8 +475,6 @@ static void schedule_frame_and_commit(void);
 
 // Draw and commit a new frame.
 static void send_frame(void) {
-        int scale = wl_get_scale();
-
         if (wl_list_empty(&ctx.outputs)) {
                 ctx.dirty = false;
                 return;
@@ -411,6 +491,14 @@ static void send_frame(void) {
                         zwlr_layer_surface_v1_destroy(ctx.layer_surface);
                         ctx.layer_surface = NULL;
                 }
+                if (ctx.xdg_toplevel != NULL) {
+                        xdg_toplevel_destroy(ctx.xdg_toplevel);
+                        ctx.xdg_toplevel = NULL;
+                }
+                if (ctx.xdg_surface != NULL) {
+                        xdg_surface_destroy(ctx.xdg_surface);
+                        ctx.xdg_surface = NULL;
+                }
                 if (ctx.surface != NULL) {
                         wl_surface_destroy(ctx.surface);
                         ctx.surface = NULL;
@@ -443,20 +531,32 @@ static void send_frame(void) {
         // If we've made it here, there is something to draw. If the surface
         // doesn't exist (this is the first notification, or we moved to a
         // different output), we need to create it.
-        if (ctx.layer_surface == NULL) {
-                struct wl_output *wl_output = NULL;
-                if (output != NULL) {
-                        wl_output = output->wl_output;
-                }
+        if (ctx.layer_surface == NULL && ctx.xdg_surface == NULL) {
                 ctx.layer_surface_output = output;
                 ctx.surface = wl_compositor_create_surface(ctx.compositor);
                 wl_surface_add_listener(ctx.surface, &surface_listener, NULL);
 
-                ctx.layer_surface = zwlr_layer_shell_v1_get_layer_surface(
-                        ctx.layer_shell, ctx.surface, wl_output,
-                        settings.layer, "notifications");
-                zwlr_layer_surface_v1_add_listener(ctx.layer_surface,
-                        &layer_surface_listener, NULL);
+                if (ctx.layer_shell) {
+                        struct wl_output *wl_output = NULL;
+                        if (output != NULL) {
+                                wl_output = output->wl_output;
+                        }
+
+                        ctx.layer_surface = zwlr_layer_shell_v1_get_layer_surface(
+                                ctx.layer_shell, ctx.surface, wl_output,
+                                settings.layer, "notifications");
+                        zwlr_layer_surface_v1_add_listener(ctx.layer_surface,
+                                &layer_surface_listener, NULL);
+                } else {
+                        ctx.xdg_surface = xdg_wm_base_get_xdg_surface(
+                                ctx.xdg_shell, ctx.surface);
+                        xdg_surface_add_listener(ctx.xdg_surface, &xdg_surface_listener, NULL);
+
+                        ctx.xdg_toplevel = xdg_surface_get_toplevel(ctx.xdg_surface);
+                        xdg_toplevel_set_title(ctx.xdg_toplevel, "Dunst");
+                        xdg_toplevel_set_app_id(ctx.xdg_toplevel, "org.knopwob.dunst");
+                        xdg_toplevel_add_listener(ctx.xdg_toplevel, &xdg_toplevel_listener, NULL);
+                }
 
                 // Because we're creating a new surface, we aren't going to draw
                 // anything into it during this call. We don't know what size the
@@ -468,56 +568,55 @@ static void send_frame(void) {
                 // block to let it set the size for us.
         }
 
-        assert(ctx.layer_surface);
+        assert(ctx.layer_surface || ctx.xdg_surface);
 
         // We now want to resize the surface if it isn't the right size. If the
         // surface is brand new, it doesn't even have a size yet. If it already
         // exists, we might need to resize if the list of notifications has changed
         // since the last time we drew.
         if (ctx.height != height || ctx.width != width) {
                 struct dimensions dim = ctx.cur_dim;
-                // Set window size
-                zwlr_layer_surface_v1_set_size(ctx.layer_surface,
+                if (ctx.layer_surface) {
+                        // Set window size
+                        zwlr_layer_surface_v1_set_size(ctx.layer_surface,
                                 dim.w, dim.h);
 
-                // Put the window at the right position
-                zwlr_layer_surface_v1_set_anchor(ctx.layer_surface,
-                        settings.origin);
-                zwlr_layer_surface_v1_set_margin(ctx.layer_surface,
-                                // Offsets where no anchors are specified are
-                                // ignored. We can safely assume the offset is
-                                // positive.
-                                settings.offset.y, // top
-                                settings.offset.x, // right
-                                settings.offset.y, // bottom
-                                settings.offset.x);// left
-
-                wl_surface_commit(ctx.surface);
+                        // Put the window at the right position
+                        zwlr_layer_surface_v1_set_anchor(ctx.layer_surface,
+                                settings.origin);
+                        zwlr_layer_surface_v1_set_margin(ctx.layer_surface,
+                                        // Offsets where no anchors are specified are
+                                        // ignored. We can safely assume the offset is
+                                        // positive.
+                                        settings.offset.y, // top
+                                        settings.offset.x, // right
+                                        settings.offset.y, // bottom
+                                        settings.offset.x);// left
+                } else {
+                        // Just set the window size, as positioning is not part of the xdg-shell protocol
+                        xdg_surface_set_window_geometry(ctx.xdg_surface, 0, 0, dim.w, dim.h);
+                }
 
-                // Now we're going to bail without drawing anything. This gives the
-                // compositor a chance to create the surface and tell us what size we
-                // were actually granted, which may be smaller than what we asked for
-                // depending on the screen size and layout of other layer surfaces.
-                // This information is provided in layer_surface_handle_configure,
-                // which will then call send_frame again. When that call happens, the
-                // layer surface will exist and the height will hopefully match what
-                // we asked for. That means we won't return here, and will actually
-                // draw into the surface down below.
-                // TODO: If the compositor doesn't send a configure with the size we
-                // requested, we'll enter an infinite loop. We need to keep track of
-                // the fact that a request was sent separately from what height we are.
-                wl_display_roundtrip(ctx.display);
-                return;
+                if(!ctx.configured) {
+                        wl_surface_commit(ctx.surface);
+
+                        LOG_W("Doing a roundtrip");
+                        // Now we're going to bail without drawing anything. This gives the
+                        // compositor a chance to create the surface and tell us what size we
+                        // were actually granted, which may be smaller than what we asked for
+                        // depending on the screen size and layout of other layer surfaces.
+                        // This information is provided in layer_surface_handle_configure,
+                        // which will then call send_frame again. When that call happens, the
+                        // layer surface will exist and the height will hopefully match what
+                        // we asked for. That means we won't return here, and will actually
+                        // draw into the surface down below.
+                        wl_display_roundtrip(ctx.display);
+                        return;
+                }
         }
 
         assert(ctx.configured);
 
-        // Yay we can finally draw something!
-        wl_surface_set_buffer_scale(ctx.surface, scale);
-        wl_surface_damage_buffer(ctx.surface, 0, 0, INT32_MAX, INT32_MAX);
-        wl_surface_attach(ctx.surface, ctx.current_buffer->buffer, 0, 0);
-        ctx.current_buffer->busy = true;
-
         // Schedule a frame in case the state becomes dirty again
         schedule_frame_and_commit();
 
@@ -540,14 +639,25 @@ static const struct wl_callback_listener frame_listener = {
 };
 
 static void schedule_frame_and_commit(void) {
+        int scale = wl_get_scale();
+
         if (ctx.frame_callback) {
+                // don't commit, as it probably won't make it to the display and
+                // therefore waste resources
                 return;
         }
         if (ctx.surface == NULL) {
                 // We don't yet have a surface, create it immediately
                 send_frame();
                 return;
         }
+
+        // Yay we can finally draw something!
+        wl_surface_set_buffer_scale(ctx.surface, scale);
+        wl_surface_damage_buffer(ctx.surface, 0, 0, INT32_MAX, INT32_MAX);
+        wl_surface_attach(ctx.surface, ctx.current_buffer->buffer, 0, 0);
+        ctx.current_buffer->busy = true;
+
         ctx.frame_callback = wl_surface_frame(ctx.surface);
         wl_callback_add_listener(ctx.frame_callback, &frame_listener, NULL);
         wl_surface_commit(ctx.surface);

src/wayland/wl_ctx.h

@@ -20,13 +20,16 @@ struct wl_ctx {
         struct wl_compositor *compositor;
         struct wl_shm *shm;
         struct zwlr_layer_shell_v1 *layer_shell;
+        struct xdg_wm_base *xdg_shell;
 
         struct wl_list outputs; /* list of struct dunst_output */
         struct wl_list seats; /* list of struct dunst_seat */
 
         struct wl_surface *surface;
         struct dunst_output *surface_output;
         struct zwlr_layer_surface_v1 *layer_surface;
+        struct xdg_surface *xdg_surface;
+        struct xdg_toplevel *xdg_toplevel;
         struct dunst_output *layer_surface_output;
         struct wl_callback *frame_callback;
         struct org_kde_kwin_idle *idle_handler;