Merge pull request #1638 from swaywm/swaybg-layers

Reimplement swaybg using surface layers

2 files changed, 290 insertions, 173 deletions

diff --git a/swaybg/main.c b/swaybg/main.c
index 2fdd4220..f431526c 100644
--- a/swaybg/main.c
+++ b/swaybg/main.c
@@ -1,44 +1,61 @@
-#include "wayland-desktop-shell-client-protocol.h"
+#include <assert.h>
+#include <ctype.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <ctype.h>
-#include <wayland-client.h>
-#include <time.h>
 #include <string.h>
-#include "client/window.h"
-#include "client/registry.h"
-#include "client/cairo.h"
-#include "log.h"
-#include "list.h"
+#include <time.h>
+#include <wayland-client.h>
+#include <wlr/util/log.h>
+#include "pool-buffer.h"
+#include "cairo.h"
 #include "util.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
 
-list_t *surfaces;
-struct registry *registry;
+enum background_mode {
+        BACKGROUND_MODE_STRETCH,
+        BACKGROUND_MODE_FILL,
+        BACKGROUND_MODE_FIT,
+        BACKGROUND_MODE_CENTER,
+        BACKGROUND_MODE_TILE,
+        BACKGROUND_MODE_SOLID_COLOR,
+};
 
-enum scaling_mode {
-        SCALING_MODE_STRETCH,
-        SCALING_MODE_FILL,
-        SCALING_MODE_FIT,
-        SCALING_MODE_CENTER,
-        SCALING_MODE_TILE,
+struct swaybg_args {
+        int output_idx;
+        const char *path;
+        enum background_mode mode;
 };
 
-void sway_terminate(int exit_code) {
-        int i;
-        for (i = 0; i < surfaces->length; ++i) {
-                struct window *window = surfaces->items[i];
-                window_teardown(window);
-        }
-        list_free(surfaces);
-        registry_teardown(registry);
-        exit(exit_code);
-}
+struct swaybg_context {
+        uint32_t color;
+        cairo_surface_t *image;
+};
+
+struct swaybg_state {
+        const struct swaybg_args *args;
+        struct swaybg_context context;
+
+        struct wl_display *display;
+        struct wl_compositor *compositor;
+        struct zwlr_layer_shell_v1 *layer_shell;
+        struct wl_shm *shm;
+
+        struct wl_output *output;
+        struct wl_surface *surface;
+        struct zwlr_layer_surface_v1 *layer_surface;
+
+        bool run_display;
+        uint32_t width, height;
+        struct pool_buffer buffers[2];
+        struct pool_buffer *current_buffer;
+};
 
 bool is_valid_color(const char *color) {
         int len = strlen(color);
         if (len != 7 || color[0] != '#') {
-                sway_log(L_ERROR, "%s is not a valid color for swaybg. Color should be specified as #rrggbb (no alpha).", color);
+                wlr_log(L_ERROR, "%s is not a valid color for swaybg. "
+                                "Color should be specified as #rrggbb (no alpha).", color);
                 return false;
         }
 
@@ -52,163 +69,245 @@ bool is_valid_color(const char *color) {
         return true;
 }
 
-int main(int argc, const char **argv) {
-        init_log(L_INFO);
-        surfaces = create_list();
-        registry = registry_poll();
+static void render_image(struct swaybg_state *state) {
+        cairo_t *cairo = state->current_buffer->cairo;
+        cairo_surface_t *image = state->context.image;
+        double width = cairo_image_surface_get_width(image);
+        double height = cairo_image_surface_get_height(image);
+        int wwidth = state->width;
+        int wheight = state->height;
 
-        if (argc != 4) {
-                sway_abort("Do not run this program manually. See man 5 sway and look for output options.");
-        }
+        switch (state->args->mode) {
+        case BACKGROUND_MODE_STRETCH:
+                cairo_scale(cairo, (double)wwidth / width, (double)wheight / height);
+                cairo_set_source_surface(cairo, image, 0, 0);
+                break;
+        case BACKGROUND_MODE_FILL: {
+                double window_ratio = (double)wwidth / wheight;
+                double bg_ratio = width / height;
 
-        if (!registry->desktop_shell) {
-                sway_abort("swaybg requires the compositor to support the desktop-shell extension.");
+                if (window_ratio > bg_ratio) {
+                        double scale = (double)wwidth / width;
+                        cairo_scale(cairo, scale, scale);
+                        cairo_set_source_surface(cairo, image,
+                                        0, (double)wheight / 2 / scale - height / 2);
+                } else {
+                        double scale = (double)wheight / height;
+                        cairo_scale(cairo, scale, scale);
+                        cairo_set_source_surface(cairo, image,
+                                        (double)wwidth / 2 / scale - width / 2, 0);
+                }
+                break;
         }
+        case BACKGROUND_MODE_FIT: {
+                double window_ratio = (double)wwidth / wheight;
+                double bg_ratio = width / height;
 
-        int desired_output = atoi(argv[1]);
-        sway_log(L_INFO, "Using output %d of %d", desired_output, registry->outputs->length);
-        int i;
-        struct output_state *output = registry->outputs->items[desired_output];
-        struct window *window = window_setup(registry,
-                        output->width, output->height, output->scale, false);
-        if (!window) {
-                sway_abort("Failed to create surfaces.");
-        }
-        desktop_shell_set_background(registry->desktop_shell, output->output, window->surface);
-        window_make_shell(window);
-        list_add(surfaces, window);
-
-        if (strcmp(argv[3], "solid_color") == 0 && is_valid_color(argv[2])) {
-                cairo_set_source_u32(window->cairo, parse_color(argv[2]));
-                cairo_paint(window->cairo);
-                window_render(window);
-        } else {
-#ifdef WITH_GDK_PIXBUF
-                GError *err = NULL;
-                GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(argv[2], &err);
-                if (!pixbuf) {
-                        sway_abort("Failed to load background image.");
-                }
-                cairo_surface_t *image = gdk_cairo_image_surface_create_from_pixbuf(pixbuf);
-                g_object_unref(pixbuf);
-#else
-                cairo_surface_t *image = cairo_image_surface_create_from_png(argv[2]);
-#endif //WITH_GDK_PIXBUF
-                if (!image) {
-                        sway_abort("Failed to read background image.");
-                }
-                if (cairo_surface_status(image) != CAIRO_STATUS_SUCCESS) {
-                        sway_abort("Failed to read background image: %s."
-#ifndef WITH_GDK_PIXBUF
-                                        "\nSway was compiled without gdk_pixbuf support, so only"
-                                        "\nPNG images can be loaded. This is the likely cause."
-#endif //WITH_GDK_PIXBUF
-                                        , cairo_status_to_string(cairo_surface_status(image)));
-                }
-                double width = cairo_image_surface_get_width(image);
-                double height = cairo_image_surface_get_height(image);
-
-                const char *scaling_mode_str = argv[3];
-                enum scaling_mode scaling_mode = SCALING_MODE_STRETCH;
-                if (strcmp(scaling_mode_str, "stretch") == 0) {
-                        scaling_mode = SCALING_MODE_STRETCH;
-                } else if (strcmp(scaling_mode_str, "fill") == 0) {
-                        scaling_mode = SCALING_MODE_FILL;
-                } else if (strcmp(scaling_mode_str, "fit") == 0) {
-                        scaling_mode = SCALING_MODE_FIT;
-                } else if (strcmp(scaling_mode_str, "center") == 0) {
-                        scaling_mode = SCALING_MODE_CENTER;
-                } else if (strcmp(scaling_mode_str, "tile") == 0) {
-                        scaling_mode = SCALING_MODE_TILE;
+                if (window_ratio > bg_ratio) {
+                        double scale = (double)wheight / height;
+                        cairo_scale(cairo, scale, scale);
+                        cairo_set_source_surface(cairo, image,
+                                        (double)wwidth / 2 / scale - width / 2, 0);
                 } else {
-                        sway_abort("Unsupported scaling mode: %s", scaling_mode_str);
+                        double scale = (double)wwidth / width;
+                        cairo_scale(cairo, scale, scale);
+                        cairo_set_source_surface(cairo, image,
+                                        0, (double)wheight / 2 / scale - height / 2);
                 }
+                break;
+        }
+        case BACKGROUND_MODE_CENTER:
+                cairo_set_source_surface(cairo, image,
+                                (double)wwidth / 2 - width / 2,
+                                (double)wheight / 2 - height / 2);
+                break;
+        case BACKGROUND_MODE_TILE: {
+                cairo_pattern_t *pattern = cairo_pattern_create_for_surface(image);
+                cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
+                cairo_set_source(cairo, pattern);
+                break;
+        }
+        case BACKGROUND_MODE_SOLID_COLOR:
+                assert(0);
+                break;
+        }
+        cairo_paint(cairo);
+}
+
+static void render_frame(struct swaybg_state *state) {
+        state->current_buffer = get_next_buffer(state->shm,
+                        state->buffers, state->width, state->height);
+        cairo_t *cairo = state->current_buffer->cairo;
+
+        switch (state->args->mode) {
+        case BACKGROUND_MODE_SOLID_COLOR:
+                cairo_set_source_u32(cairo, state->context.color);
+                cairo_paint(cairo);
+                break;
+        default:
+                render_image(state);
+                break;
+        }
+
+        wl_surface_attach(state->surface, state->current_buffer->buffer, 0, 0);
+        wl_surface_damage(state->surface, 0, 0, state->width, state->height);
+        wl_surface_commit(state->surface);
+}
 
-                int wwidth = window->width * window->scale;
-                int wheight = window->height * window->scale;
-
-                for (i = 0; i < surfaces->length; ++i) {
-                        struct window *window = surfaces->items[i];
-                        if (window_prerender(window) && window->cairo) {
-                                switch (scaling_mode) {
-                                case SCALING_MODE_STRETCH:
-                                        cairo_scale(window->cairo,
-                                                        (double) wwidth / width,
-                                                        (double) wheight / height);
-                                        cairo_set_source_surface(window->cairo, image, 0, 0);
-                                        break;
-                                case SCALING_MODE_FILL:
-                                {
-                                        double window_ratio = (double) wwidth / wheight;
-                                        double bg_ratio = width / height;
-
-                                        if (window_ratio > bg_ratio) {
-                                                double scale = (double) wwidth / width;
-                                                cairo_scale(window->cairo, scale, scale);
-                                                cairo_set_source_surface(window->cairo, image,
-                                                                0,
-                                                                (double) wheight/2 / scale - height/2);
-                                        } else {
-                                                double scale = (double) wheight / height;
-                                                cairo_scale(window->cairo, scale, scale);
-                                                cairo_set_source_surface(window->cairo, image,
-                                                                (double) wwidth/2 / scale - width/2,
-                                                                0);
-                                        }
-                                        break;
-                                }
-                                case SCALING_MODE_FIT:
-                                {
-                                        double window_ratio = (double) wwidth / wheight;
-                                        double bg_ratio = width / height;
-
-                                        if (window_ratio > bg_ratio) {
-                                                double scale = (double) wheight / height;
-                                                cairo_scale(window->cairo, scale, scale);
-                                                cairo_set_source_surface(window->cairo, image,
-                                                                (double) wwidth/2 / scale - width/2,
-                                                                0);
-                                        } else {
-                                                double scale = (double) wwidth / width;
-                                                cairo_scale(window->cairo, scale, scale);
-                                                cairo_set_source_surface(window->cairo, image,
-                                                                0,
-                                                                (double) wheight/2 / scale - height/2);
-                                        }
-                                        break;
-                                }
-                                case SCALING_MODE_CENTER:
-                                        cairo_set_source_surface(window->cairo, image,
-                                                        (double) wwidth/2 - width/2,
-                                                        (double) wheight/2 - height/2);
-                                        break;
-                                case SCALING_MODE_TILE:
-                                {
-                                        cairo_pattern_t *pattern = cairo_pattern_create_for_surface(image);
-                                        cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
-                                        cairo_set_source(window->cairo, pattern);
-                                        break;
-                                }
-                                default:
-                                        sway_abort("Scaling mode '%s' not implemented yet!", scaling_mode_str);
-                                }
-
-                                cairo_paint(window->cairo);
-
-                                window_render(window);
-                        }
+static bool prepare_context(struct swaybg_state *state) {
+        if (state->args->mode == BACKGROUND_MODE_SOLID_COLOR) {
+                state->context.color = parse_color(state->args->path);
+                return is_valid_color(state->args->path);
+        }
+#ifdef HAVE_GDK_PIXBUF
+        GError *err = NULL;
+        GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(state->args->path, &err);
+        if (!pixbuf) {
+                wlr_log(L_ERROR, "Failed to load background image.");
+                return false;
+        }
+        state->context.image = gdk_cairo_image_surface_create_from_pixbuf(pixbuf);
+        g_object_unref(pixbuf);
+#else
+        state->context.image = cairo_image_surface_create_from_png(
+                        state->args->path);
+#endif //HAVE_GDK_PIXBUF
+        if (!state->context.image) {
+                wlr_log(L_ERROR, "Failed to read background image.");
+                return false;
+        }
+        if (cairo_surface_status(state->context.image) != CAIRO_STATUS_SUCCESS) {
+                wlr_log(L_ERROR, "Failed to read background image: %s."
+#ifndef HAVE_GDK_PIXBUF
+                                "\nSway was compiled without gdk_pixbuf support, so only"
+                                "\nPNG images can be loaded. This is the likely cause."
+#endif //HAVE_GDK_PIXBUF
+                                , cairo_status_to_string(
+                                cairo_surface_status(state->context.image)));
+                return false;
+        }
+        return true;
+}
+
+static void layer_surface_configure(void *data,
+                struct zwlr_layer_surface_v1 *surface,
+                uint32_t serial, uint32_t width, uint32_t height) {
+        struct swaybg_state *state = data;
+        state->width = width;
+        state->height = height;
+        zwlr_layer_surface_v1_ack_configure(surface, serial);
+        render_frame(state);
+}
+
+static void layer_surface_closed(void *data,
+                struct zwlr_layer_surface_v1 *surface) {
+        struct swaybg_state *state = data;
+        zwlr_layer_surface_v1_destroy(state->layer_surface);
+        wl_surface_destroy(state->surface);
+        state->run_display = false;
+}
+
+struct zwlr_layer_surface_v1_listener layer_surface_listener = {
+        .configure = layer_surface_configure,
+        .closed = layer_surface_closed,
+};
+
+static void handle_global(void *data, struct wl_registry *registry,
+                uint32_t name, const char *interface, uint32_t version) {
+        struct swaybg_state *state = data;
+        if (strcmp(interface, wl_compositor_interface.name) == 0) {
+                state->compositor = wl_registry_bind(registry, name,
+                                &wl_compositor_interface, 1);
+        } else if (strcmp(interface, wl_shm_interface.name) == 0) {
+                state->shm = wl_registry_bind(registry, name,
+                                &wl_shm_interface, 1);
+        } else if (strcmp(interface, wl_output_interface.name) == 0) {
+                static int output_idx = 0;
+                if (output_idx == state->args->output_idx) {
+                        state->output = wl_registry_bind(registry, name,
+                                        &wl_output_interface, 1);
                 }
+                output_idx++;
+        } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
+                state->layer_shell = wl_registry_bind(
+                                registry, name, &zwlr_layer_shell_v1_interface, 1);
+        }
+}
+
+static void handle_global_remove(void *data, struct wl_registry *registry,
+                uint32_t name) {
+        // who cares
+}
+
+static const struct wl_registry_listener registry_listener = {
+        .global = handle_global,
+        .global_remove = handle_global_remove,
+};
 
-                cairo_surface_destroy(image);
+int main(int argc, const char **argv) {
+        struct swaybg_args args = {0};
+        struct swaybg_state state = {0};
+        state.args = &args;
+        wlr_log_init(L_DEBUG, NULL);
+
+        if (argc != 4) {
+                wlr_log(L_ERROR, "Do not run this program manually. "
+                                "See man 5 sway and look for output options.");
+                return 1;
         }
+        args.output_idx = atoi(argv[1]);
+        args.path = argv[2];
+
+        args.mode = BACKGROUND_MODE_STRETCH;
+        if (strcmp(argv[3], "stretch") == 0) {
+                args.mode = BACKGROUND_MODE_STRETCH;
+        } else if (strcmp(argv[3], "fill") == 0) {
+                args.mode = BACKGROUND_MODE_FILL;
+        } else if (strcmp(argv[3], "fit") == 0) {
+                args.mode = BACKGROUND_MODE_FIT;
+        } else if (strcmp(argv[3], "center") == 0) {
+                args.mode = BACKGROUND_MODE_CENTER;
+        } else if (strcmp(argv[3], "tile") == 0) {
+                args.mode = BACKGROUND_MODE_TILE;
+        } else if (strcmp(argv[3], "solid_color") == 0) {
+                args.mode = BACKGROUND_MODE_SOLID_COLOR;
+        } else {
+                wlr_log(L_ERROR, "Unsupported background mode: %s", argv[3]);
+                return 1;
+        }
+
+        if (!prepare_context(&state)) {
+                return 1;
+        }
+
+        assert(state.display = wl_display_connect(NULL));
+
+        struct wl_registry *registry = wl_display_get_registry(state.display);
+        wl_registry_add_listener(registry, &registry_listener, &state);
+        wl_display_roundtrip(state.display);
+        assert(state.compositor && state.layer_shell && state.output && state.shm);
+
+        assert(state.surface = wl_compositor_create_surface(state.compositor));
+
+        state.layer_surface = zwlr_layer_shell_v1_get_layer_surface(
+                        state.layer_shell, state.surface, state.output,
+                        ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "wallpaper");
+        assert(state.layer_surface);
 
-        while (wl_display_dispatch(registry->display) != -1);
+        zwlr_layer_surface_v1_set_size(state.layer_surface, 0, 0);
+        zwlr_layer_surface_v1_set_anchor(state.layer_surface,
+                        ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+                        ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+                        ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM |
+                        ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT);
+        zwlr_layer_surface_v1_add_listener(state.layer_surface,
+                        &layer_surface_listener, &state);
+        state.run_display = true;
+        wl_surface_commit(state.surface);
+        wl_display_roundtrip(state.display);
 
-        for (i = 0; i < surfaces->length; ++i) {
-                struct window *window = surfaces->items[i];
-                window_teardown(window);
+        while (wl_display_dispatch(state.display) != -1 && state.run_display) {
+                // This space intentionally left blank
         }
-        list_free(surfaces);
-        registry_teardown(registry);
         return 0;
 }
diff --git a/swaybg/meson.build b/swaybg/meson.build
new file mode 100644
index 00000000..5e10f3c7
--- /dev/null
+++ b/swaybg/meson.build
@@ -0,0 +1,18 @@
+executable(
+        'swaybg',
+        'main.c',
+        include_directories: [sway_inc],
+        dependencies: [
+                cairo,
+                gdk_pixbuf,
+                jsonc,
+                math,
+                pango,
+                pangocairo,
+                sway_protos,
+                wayland_client,
+                wlroots,
+        ],
+        link_with: [lib_sway_common, lib_sway_client],
+        install: true
+)