Replace _ with - in source file names

include/common/scaled-scene-buffer.h

@@ -0,0 +1,94 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+#ifndef LABWC_SCALED_SCENE_BUFFER_H
+#define LABWC_SCALED_SCENE_BUFFER_H
+
+#include <wayland-server-core.h>
+
+#define LAB_SCALED_BUFFER_MAX_CACHE 2
+
+struct wlr_buffer;
+struct wlr_scene_tree;
+struct lab_data_buffer;
+struct scaled_scene_buffer;
+
+struct scaled_scene_buffer_impl {
+	/* Return a new buffer optimized for the new scale */
+	struct lab_data_buffer *(*create_buffer)
+		(struct scaled_scene_buffer *scaled_buffer, double scale);
+	/* Might be NULL or used for cleaning up */
+	void (*destroy)(struct scaled_scene_buffer *scaled_buffer);
+};
+
+struct scaled_scene_buffer {
+	struct wlr_scene_buffer *scene_buffer;
+	int width;   /* unscaled, read only */
+	int height;  /* unscaled, read only */
+	void *data;  /* opaque user data */
+
+	/* Private */
+	bool drop_buffer;
+	double active_scale;
+	struct wl_list cache;  /* struct scaled_buffer_cache_entry.link */
+	struct wl_listener destroy;
+	struct wl_listener output_enter;
+	struct wl_listener output_leave;
+	const struct scaled_scene_buffer_impl *impl;
+};
+
+/**
+ * Create an auto scaling buffer that creates a wlr_scene_buffer
+ * and subscribes to its output_enter and output_leave signals.
+ *
+ * If the maximal scale changes, it either sets an already existing buffer
+ * that was rendered for the current scale or - if there is none - calls
+ * implementation->create_buffer(self, scale) to get a new lab_data_buffer
+ * optimized for the new scale.
+ *
+ * Up to LAB_SCALED_BUFFER_MAX_CACHE (2) buffers are cached in an LRU fashion
+ * to handle the majority of use cases where a view is moved between no more
+ * than two different scales.
+ *
+ * scaled_scene_buffer will clean up automatically once the internal
+ * wlr_scene_buffer is being destroyed. If implementation->destroy is set
+ * it will also get called so a consumer of this API may clean up its own
+ * allocations.
+ *
+ * All requested lab_data_buffers via impl->create_buffer() will be locked
+ * during the lifetime of the buffer in the internal cache and unlocked
+ * when being evacuated from the cache (due to LAB_SCALED_BUFFER_MAX_CACHE
+ * or the internal wlr_scene_buffer being destroyed).
+ *
+ * If drop_buffer was set during creation of the scaled_scene_buffer, the
+ * backing wlr_buffer behind a lab_data_buffer will also get dropped
+ * (via wlr_buffer_drop). If there are no more locks (consumers) of the
+ * respective buffer this will then cause the lab_data_buffer to be free'd.
+ *
+ * In the case of the buffer provider dropping the buffer itself (due to
+ * for example a Reconfigure event) the lock prevents the buffer from being
+ * destroyed until the buffer is evacuated from the internal cache and thus
+ * unlocked.
+ *
+ * This allows using scaled_scene_buffer for an autoscaling font_buffer
+ * (which gets free'd automatically) and also for theme components like
+ * rounded corner images or button icons whose buffers only exist once but
+ * are references by multiple windows with their own scaled_scene_buffers.
+ *
+ * The rough idea is: use drop_buffer = true for one-shot buffers and false
+ * for buffers that should outlive the scaled_scene_buffer instance itself.
+ */
+struct scaled_scene_buffer *scaled_scene_buffer_create(
+	struct wlr_scene_tree *parent,
+	const struct scaled_scene_buffer_impl *implementation,
+	bool drop_buffer);
+
+/* Clear the cache of existing buffers, useful in case the content changes */
+void scaled_scene_buffer_invalidate_cache(struct scaled_scene_buffer *self);
+
+/* Private */
+struct scaled_scene_buffer_cache_entry {
+	struct wl_list link;   /* struct scaled_scene_buffer.cache */
+	struct wlr_buffer *buffer;
+	double scale;
+};
+
+#endif /* LABWC_SCALED_SCENE_BUFFER_H */