mirror of
https://github.com/labwc/labwc.git
synced 2025-11-08 13:30:00 -05:00
scaled-scene-buffer: restructure source files
Some checks failed
labwc.github.io / notify (push) Has been cancelled
Some checks failed
labwc.github.io / notify (push) Has been cancelled
- Rename `scaled_scene_buffer` to `scaled_buffer`. This makes it clear
that `scaled_{font,img,icon}_buffers` are implementations of it.
- Move the files from `src/common` to `src/scaled-buffer` as
`scaled_icon_buffer` heavily depends on `server` and `view` etc.
This commit is contained in:
tokyo4j
Johan Malm
parent
02be24bf59
commit
074b27fd47
22 changed files with 128 additions and 125 deletions
|
|
@ -14,10 +14,6 @@ labwc_sources += files(
|
|||
'nodename.c',
|
||||
'parse-bool.c',
|
||||
'parse-double.c',
|
||||
'scaled-font-buffer.c',
|
||||
'scaled-icon-buffer.c',
|
||||
'scaled-img-buffer.c',
|
||||
'scaled-scene-buffer.c',
|
||||
'scene-helpers.c',
|
||||
'set.c',
|
||||
'surface-helpers.c',
|
||||
|
|
|
|||
|
|
@ -1,157 +0,0 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include "common/scaled-font-buffer.h"
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <wayland-server-core.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include "buffer.h"
|
||||
#include "common/font.h"
|
||||
#include "common/graphic-helpers.h"
|
||||
#include "common/mem.h"
|
||||
#include "common/scaled-scene-buffer.h"
|
||||
#include "common/string-helpers.h"
|
||||
|
||||
static struct lab_data_buffer *
|
||||
_create_buffer(struct scaled_scene_buffer *scaled_buffer, double scale)
|
||||
{
|
||||
struct lab_data_buffer *buffer = NULL;
|
||||
struct scaled_font_buffer *self = scaled_buffer->data;
|
||||
cairo_pattern_t *bg_pattern = self->bg_pattern;
|
||||
cairo_pattern_t *solid_bg_pattern = NULL;
|
||||
|
||||
if (!bg_pattern) {
|
||||
solid_bg_pattern = color_to_pattern(self->bg_color);
|
||||
bg_pattern = solid_bg_pattern;
|
||||
}
|
||||
|
||||
/* Buffer gets free'd automatically along the backing wlr_buffer */
|
||||
font_buffer_create(&buffer, self->max_width, self->height, self->text,
|
||||
&self->font, self->color, bg_pattern, scale);
|
||||
|
||||
if (!buffer) {
|
||||
wlr_log(WLR_ERROR, "font_buffer_create() failed");
|
||||
}
|
||||
|
||||
zfree_pattern(solid_bg_pattern);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static void
|
||||
_destroy(struct scaled_scene_buffer *scaled_buffer)
|
||||
{
|
||||
struct scaled_font_buffer *self = scaled_buffer->data;
|
||||
scaled_buffer->data = NULL;
|
||||
|
||||
zfree(self->text);
|
||||
zfree(self->font.name);
|
||||
zfree_pattern(self->bg_pattern);
|
||||
free(self);
|
||||
}
|
||||
|
||||
static bool
|
||||
_equal(struct scaled_scene_buffer *scaled_buffer_a,
|
||||
struct scaled_scene_buffer *scaled_buffer_b)
|
||||
{
|
||||
struct scaled_font_buffer *a = scaled_buffer_a->data;
|
||||
struct scaled_font_buffer *b = scaled_buffer_b->data;
|
||||
|
||||
return str_equal(a->text, b->text)
|
||||
&& a->max_width == b->max_width
|
||||
&& str_equal(a->font.name, b->font.name)
|
||||
&& a->font.size == b->font.size
|
||||
&& a->font.slant == b->font.slant
|
||||
&& a->font.weight == b->font.weight
|
||||
&& !memcmp(a->color, b->color, sizeof(a->color))
|
||||
&& !memcmp(a->bg_color, b->bg_color, sizeof(a->bg_color))
|
||||
&& a->fixed_height == b->fixed_height
|
||||
&& a->bg_pattern == b->bg_pattern;
|
||||
}
|
||||
|
||||
static const struct scaled_scene_buffer_impl impl = {
|
||||
.create_buffer = _create_buffer,
|
||||
.destroy = _destroy,
|
||||
.equal = _equal,
|
||||
};
|
||||
|
||||
/* Public API */
|
||||
struct scaled_font_buffer *
|
||||
scaled_font_buffer_create(struct wlr_scene_tree *parent)
|
||||
{
|
||||
assert(parent);
|
||||
struct scaled_font_buffer *self = znew(*self);
|
||||
struct scaled_scene_buffer *scaled_buffer = scaled_scene_buffer_create(
|
||||
parent, &impl, /* drop_buffer */ true);
|
||||
if (!scaled_buffer) {
|
||||
free(self);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
scaled_buffer->data = self;
|
||||
self->scaled_buffer = scaled_buffer;
|
||||
self->scene_buffer = scaled_buffer->scene_buffer;
|
||||
return self;
|
||||
}
|
||||
|
||||
struct scaled_font_buffer *
|
||||
scaled_font_buffer_create_for_titlebar(struct wlr_scene_tree *parent,
|
||||
int fixed_height, cairo_pattern_t *bg_pattern)
|
||||
{
|
||||
struct scaled_font_buffer *self = scaled_font_buffer_create(parent);
|
||||
if (self) {
|
||||
self->fixed_height = fixed_height;
|
||||
self->bg_pattern = cairo_pattern_reference(bg_pattern);
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
void
|
||||
scaled_font_buffer_update(struct scaled_font_buffer *self, const char *text,
|
||||
int max_width, struct font *font, const float *color,
|
||||
const float *bg_color)
|
||||
{
|
||||
assert(self);
|
||||
assert(text);
|
||||
assert(font);
|
||||
assert(color);
|
||||
|
||||
/* Clean up old internal state */
|
||||
zfree(self->text);
|
||||
zfree(self->font.name);
|
||||
|
||||
/* Update internal state */
|
||||
self->text = xstrdup(text);
|
||||
self->max_width = max_width;
|
||||
if (font->name) {
|
||||
self->font.name = xstrdup(font->name);
|
||||
}
|
||||
self->font.size = font->size;
|
||||
self->font.slant = font->slant;
|
||||
self->font.weight = font->weight;
|
||||
memcpy(self->color, color, sizeof(self->color));
|
||||
memcpy(self->bg_color, bg_color, sizeof(self->bg_color));
|
||||
|
||||
/* Calculate the size of font buffer and request re-rendering */
|
||||
int computed_height;
|
||||
font_get_buffer_size(self->max_width, self->text, &self->font,
|
||||
&self->width, &computed_height);
|
||||
self->height = (self->fixed_height > 0) ?
|
||||
self->fixed_height : computed_height;
|
||||
scaled_scene_buffer_request_update(self->scaled_buffer,
|
||||
self->width, self->height);
|
||||
}
|
||||
|
||||
void
|
||||
scaled_font_buffer_set_max_width(struct scaled_font_buffer *self, int max_width)
|
||||
{
|
||||
self->max_width = max_width;
|
||||
|
||||
int computed_height;
|
||||
font_get_buffer_size(self->max_width, self->text, &self->font,
|
||||
&self->width, &computed_height);
|
||||
self->height = (self->fixed_height > 0) ?
|
||||
self->fixed_height : computed_height;
|
||||
scaled_scene_buffer_request_update(self->scaled_buffer,
|
||||
self->width, self->height);
|
||||
}
|
||||
|
|
@ -1,361 +0,0 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include "common/scaled-icon-buffer.h"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include "buffer.h"
|
||||
#include "common/macros.h"
|
||||
#include "common/mem.h"
|
||||
#include "common/scaled-scene-buffer.h"
|
||||
#include "common/string-helpers.h"
|
||||
#include "config.h"
|
||||
#include "config/rcxml.h"
|
||||
#include "desktop-entry.h"
|
||||
#include "img/img.h"
|
||||
#include "node.h"
|
||||
#include "view.h"
|
||||
#include "window-rules.h"
|
||||
|
||||
#if HAVE_LIBSFDO
|
||||
|
||||
static struct lab_data_buffer *
|
||||
choose_best_icon_buffer(struct scaled_icon_buffer *self, int icon_size, double scale)
|
||||
{
|
||||
int best_dist = -INT_MAX;
|
||||
struct lab_data_buffer *best_buffer = NULL;
|
||||
|
||||
struct lab_data_buffer **buffer;
|
||||
wl_array_for_each(buffer, &self->view_icon_buffers) {
|
||||
int curr_dist = (*buffer)->base.width - (int)(icon_size * scale);
|
||||
bool curr_is_better;
|
||||
if ((curr_dist < 0 && best_dist > 0)
|
||||
|| (curr_dist > 0 && best_dist < 0)) {
|
||||
/* prefer too big icon over too small icon */
|
||||
curr_is_better = curr_dist > 0;
|
||||
} else {
|
||||
curr_is_better = abs(curr_dist) < abs(best_dist);
|
||||
}
|
||||
if (curr_is_better) {
|
||||
best_dist = curr_dist;
|
||||
best_buffer = *buffer;
|
||||
}
|
||||
}
|
||||
return best_buffer;
|
||||
}
|
||||
|
||||
static struct lab_data_buffer *
|
||||
img_to_buffer(struct lab_img *img, int width, int height, double scale)
|
||||
{
|
||||
struct lab_data_buffer *buffer = lab_img_render(img, width, height, scale);
|
||||
lab_img_destroy(img);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/*
|
||||
* Load an icon from application-supplied icon name or buffers.
|
||||
* Wayland apps can provide icon names and buffers via xdg-toplevel-icon protocol.
|
||||
* X11 apps can provide icon buffers via _NET_WM_ICON property.
|
||||
*/
|
||||
static struct lab_data_buffer *
|
||||
load_client_icon(struct scaled_icon_buffer *self, int icon_size, double scale)
|
||||
{
|
||||
struct lab_img *img = desktop_entry_load_icon(self->server,
|
||||
self->view_icon_name, icon_size, scale);
|
||||
if (img) {
|
||||
wlr_log(WLR_DEBUG, "loaded icon from client icon name");
|
||||
return img_to_buffer(img, self->width, self->height, scale);
|
||||
}
|
||||
|
||||
struct lab_data_buffer *buffer = choose_best_icon_buffer(self, icon_size, scale);
|
||||
if (buffer) {
|
||||
wlr_log(WLR_DEBUG, "loaded icon from client buffer");
|
||||
return buffer_resize(buffer, self->width, self->height, scale);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Load an icon by a view's app_id. For example, if the app_id is 'firefox', then
|
||||
* libsfdo will parse firefox.desktop to get the Icon name and then find that icon
|
||||
* based on the icon theme specified in rc.xml.
|
||||
*/
|
||||
static struct lab_data_buffer *
|
||||
load_server_icon(struct scaled_icon_buffer *self, int icon_size, double scale)
|
||||
{
|
||||
struct lab_img *img = desktop_entry_load_icon_from_app_id(self->server,
|
||||
self->view_app_id, icon_size, scale);
|
||||
if (img) {
|
||||
wlr_log(WLR_DEBUG, "loaded icon by app_id");
|
||||
return img_to_buffer(img, self->width, self->height, scale);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#endif /* HAVE_LIBSFDO */
|
||||
|
||||
static struct lab_data_buffer *
|
||||
_create_buffer(struct scaled_scene_buffer *scaled_buffer, double scale)
|
||||
{
|
||||
#if HAVE_LIBSFDO
|
||||
struct scaled_icon_buffer *self = scaled_buffer->data;
|
||||
int icon_size = MIN(self->width, self->height);
|
||||
struct lab_img *img = NULL;
|
||||
struct lab_data_buffer *buffer = NULL;
|
||||
|
||||
if (self->icon_name) {
|
||||
/* generic icon (e.g. menu icons) */
|
||||
img = desktop_entry_load_icon(self->server, self->icon_name,
|
||||
icon_size, scale);
|
||||
if (img) {
|
||||
wlr_log(WLR_DEBUG, "loaded icon by icon name");
|
||||
return img_to_buffer(img, self->width, self->height, scale);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* window icon */
|
||||
if (self->view_icon_prefer_client) {
|
||||
buffer = load_client_icon(self, icon_size, scale);
|
||||
if (buffer) {
|
||||
return buffer;
|
||||
}
|
||||
buffer = load_server_icon(self, icon_size, scale);
|
||||
if (buffer) {
|
||||
return buffer;
|
||||
}
|
||||
} else {
|
||||
buffer = load_server_icon(self, icon_size, scale);
|
||||
if (buffer) {
|
||||
return buffer;
|
||||
}
|
||||
buffer = load_client_icon(self, icon_size, scale);
|
||||
if (buffer) {
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
/* If both client and server icons are unavailable, use the fallback icon */
|
||||
img = desktop_entry_load_icon(self->server, rc.fallback_app_icon_name,
|
||||
icon_size, scale);
|
||||
if (img) {
|
||||
wlr_log(WLR_DEBUG, "loaded fallback icon");
|
||||
return img_to_buffer(img, self->width, self->height, scale);
|
||||
}
|
||||
#endif /* HAVE_LIBSFDO */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
set_icon_buffers(struct scaled_icon_buffer *self, struct wl_array *buffers)
|
||||
{
|
||||
struct lab_data_buffer **icon_buffer;
|
||||
wl_array_for_each(icon_buffer, &self->view_icon_buffers) {
|
||||
wlr_buffer_unlock(&(*icon_buffer)->base);
|
||||
}
|
||||
wl_array_release(&self->view_icon_buffers);
|
||||
wl_array_init(&self->view_icon_buffers);
|
||||
|
||||
if (!buffers) {
|
||||
return;
|
||||
}
|
||||
|
||||
wl_array_for_each(icon_buffer, buffers) {
|
||||
wlr_buffer_lock(&(*icon_buffer)->base);
|
||||
}
|
||||
wl_array_copy(&self->view_icon_buffers, buffers);
|
||||
}
|
||||
|
||||
static void
|
||||
_destroy(struct scaled_scene_buffer *scaled_buffer)
|
||||
{
|
||||
struct scaled_icon_buffer *self = scaled_buffer->data;
|
||||
if (self->view) {
|
||||
wl_list_remove(&self->on_view.set_icon.link);
|
||||
wl_list_remove(&self->on_view.new_title.link);
|
||||
wl_list_remove(&self->on_view.new_app_id.link);
|
||||
wl_list_remove(&self->on_view.destroy.link);
|
||||
}
|
||||
free(self->view_app_id);
|
||||
free(self->view_icon_name);
|
||||
set_icon_buffers(self, NULL);
|
||||
free(self->icon_name);
|
||||
free(self);
|
||||
}
|
||||
|
||||
static bool
|
||||
icon_buffers_equal(struct wl_array *a, struct wl_array *b)
|
||||
{
|
||||
if (a->size != b->size) {
|
||||
return false;
|
||||
}
|
||||
return a->size == 0 || !memcmp(a->data, b->data, a->size);
|
||||
}
|
||||
|
||||
static bool
|
||||
_equal(struct scaled_scene_buffer *scaled_buffer_a,
|
||||
struct scaled_scene_buffer *scaled_buffer_b)
|
||||
{
|
||||
struct scaled_icon_buffer *a = scaled_buffer_a->data;
|
||||
struct scaled_icon_buffer *b = scaled_buffer_b->data;
|
||||
|
||||
return str_equal(a->view_app_id, b->view_app_id)
|
||||
&& a->view_icon_prefer_client == b->view_icon_prefer_client
|
||||
&& str_equal(a->view_icon_name, b->view_icon_name)
|
||||
&& icon_buffers_equal(&a->view_icon_buffers, &b->view_icon_buffers)
|
||||
&& str_equal(a->icon_name, b->icon_name)
|
||||
&& a->width == b->width
|
||||
&& a->height == b->height;
|
||||
}
|
||||
|
||||
static struct scaled_scene_buffer_impl impl = {
|
||||
.create_buffer = _create_buffer,
|
||||
.destroy = _destroy,
|
||||
.equal = _equal,
|
||||
};
|
||||
|
||||
struct scaled_icon_buffer *
|
||||
scaled_icon_buffer_create(struct wlr_scene_tree *parent, struct server *server,
|
||||
int width, int height)
|
||||
{
|
||||
assert(parent);
|
||||
assert(width >= 0 && height >= 0);
|
||||
|
||||
struct scaled_scene_buffer *scaled_buffer = scaled_scene_buffer_create(
|
||||
parent, &impl, /* drop_buffer */ true);
|
||||
struct scaled_icon_buffer *self = znew(*self);
|
||||
self->scaled_buffer = scaled_buffer;
|
||||
self->scene_buffer = scaled_buffer->scene_buffer;
|
||||
self->server = server;
|
||||
self->width = width;
|
||||
self->height = height;
|
||||
|
||||
scaled_buffer->data = self;
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
static void
|
||||
handle_view_set_icon(struct wl_listener *listener, void *data)
|
||||
{
|
||||
struct scaled_icon_buffer *self =
|
||||
wl_container_of(listener, self, on_view.set_icon);
|
||||
|
||||
bool icon_name_equal = str_equal(self->view_icon_name, self->view->icon.name);
|
||||
if (icon_name_equal && icon_buffers_equal(&self->view_icon_buffers,
|
||||
&self->view->icon.buffers)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!icon_name_equal) {
|
||||
zfree(self->view_icon_name);
|
||||
if (self->view->icon.name) {
|
||||
xstrdup_replace(self->view_icon_name, self->view->icon.name);
|
||||
}
|
||||
}
|
||||
|
||||
set_icon_buffers(self, &self->view->icon.buffers);
|
||||
scaled_scene_buffer_request_update(self->scaled_buffer,
|
||||
self->width, self->height);
|
||||
}
|
||||
|
||||
static void
|
||||
handle_view_new_title(struct wl_listener *listener, void *data)
|
||||
{
|
||||
struct scaled_icon_buffer *self =
|
||||
wl_container_of(listener, self, on_view.new_title);
|
||||
|
||||
bool prefer_client = window_rules_get_property(
|
||||
self->view, "iconPreferClient") == LAB_PROP_TRUE;
|
||||
if (prefer_client == self->view_icon_prefer_client) {
|
||||
return;
|
||||
}
|
||||
self->view_icon_prefer_client = prefer_client;
|
||||
scaled_scene_buffer_request_update(self->scaled_buffer,
|
||||
self->width, self->height);
|
||||
}
|
||||
|
||||
static void
|
||||
handle_view_new_app_id(struct wl_listener *listener, void *data)
|
||||
{
|
||||
struct scaled_icon_buffer *self =
|
||||
wl_container_of(listener, self, on_view.new_app_id);
|
||||
|
||||
const char *app_id = view_get_string_prop(self->view, "app_id");
|
||||
if (str_equal(app_id, self->view_app_id)) {
|
||||
return;
|
||||
}
|
||||
|
||||
xstrdup_replace(self->view_app_id, app_id);
|
||||
self->view_icon_prefer_client = window_rules_get_property(
|
||||
self->view, "iconPreferClient") == LAB_PROP_TRUE;
|
||||
scaled_scene_buffer_request_update(self->scaled_buffer,
|
||||
self->width, self->height);
|
||||
}
|
||||
|
||||
static void
|
||||
handle_view_destroy(struct wl_listener *listener, void *data)
|
||||
{
|
||||
struct scaled_icon_buffer *self =
|
||||
wl_container_of(listener, self, on_view.destroy);
|
||||
wl_list_remove(&self->on_view.destroy.link);
|
||||
wl_list_remove(&self->on_view.set_icon.link);
|
||||
wl_list_remove(&self->on_view.new_title.link);
|
||||
wl_list_remove(&self->on_view.new_app_id.link);
|
||||
self->view = NULL;
|
||||
}
|
||||
|
||||
void
|
||||
scaled_icon_buffer_set_view(struct scaled_icon_buffer *self, struct view *view)
|
||||
{
|
||||
assert(view);
|
||||
if (self->view == view) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (self->view) {
|
||||
wl_list_remove(&self->on_view.set_icon.link);
|
||||
wl_list_remove(&self->on_view.new_title.link);
|
||||
wl_list_remove(&self->on_view.new_app_id.link);
|
||||
wl_list_remove(&self->on_view.destroy.link);
|
||||
}
|
||||
self->view = view;
|
||||
|
||||
self->on_view.set_icon.notify = handle_view_set_icon;
|
||||
wl_signal_add(&view->events.set_icon, &self->on_view.set_icon);
|
||||
|
||||
self->on_view.new_title.notify = handle_view_new_title;
|
||||
wl_signal_add(&view->events.new_title, &self->on_view.new_title);
|
||||
|
||||
self->on_view.new_app_id.notify = handle_view_new_app_id;
|
||||
wl_signal_add(&view->events.new_app_id, &self->on_view.new_app_id);
|
||||
|
||||
self->on_view.destroy.notify = handle_view_destroy;
|
||||
wl_signal_add(&view->events.destroy, &self->on_view.destroy);
|
||||
|
||||
handle_view_set_icon(&self->on_view.set_icon, NULL);
|
||||
handle_view_new_app_id(&self->on_view.new_app_id, NULL);
|
||||
handle_view_new_title(&self->on_view.new_title, NULL);
|
||||
}
|
||||
|
||||
void
|
||||
scaled_icon_buffer_set_icon_name(struct scaled_icon_buffer *self,
|
||||
const char *icon_name)
|
||||
{
|
||||
assert(icon_name);
|
||||
if (str_equal(self->icon_name, icon_name)) {
|
||||
return;
|
||||
}
|
||||
xstrdup_replace(self->icon_name, icon_name);
|
||||
scaled_scene_buffer_request_update(self->scaled_buffer, self->width, self->height);
|
||||
}
|
||||
|
||||
struct scaled_icon_buffer *
|
||||
scaled_icon_buffer_from_node(struct wlr_scene_node *node)
|
||||
{
|
||||
struct scaled_scene_buffer *scaled_buffer =
|
||||
node_scaled_scene_buffer_from_node(node);
|
||||
assert(scaled_buffer->impl == &impl);
|
||||
return scaled_buffer->data;
|
||||
}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include "common/scaled-img-buffer.h"
|
||||
#include <assert.h>
|
||||
#include <wayland-server-core.h>
|
||||
#include <wlr/types/wlr_scene.h>
|
||||
#include "buffer.h"
|
||||
#include "common/mem.h"
|
||||
#include "common/scaled-scene-buffer.h"
|
||||
#include "img/img.h"
|
||||
#include "node.h"
|
||||
|
||||
static struct lab_data_buffer *
|
||||
_create_buffer(struct scaled_scene_buffer *scaled_buffer, double scale)
|
||||
{
|
||||
struct scaled_img_buffer *self = scaled_buffer->data;
|
||||
struct lab_data_buffer *buffer = lab_img_render(self->img,
|
||||
self->width, self->height, scale);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static void
|
||||
_destroy(struct scaled_scene_buffer *scaled_buffer)
|
||||
{
|
||||
struct scaled_img_buffer *self = scaled_buffer->data;
|
||||
lab_img_destroy(self->img);
|
||||
free(self);
|
||||
}
|
||||
|
||||
static bool
|
||||
_equal(struct scaled_scene_buffer *scaled_buffer_a,
|
||||
struct scaled_scene_buffer *scaled_buffer_b)
|
||||
{
|
||||
struct scaled_img_buffer *a = scaled_buffer_a->data;
|
||||
struct scaled_img_buffer *b = scaled_buffer_b->data;
|
||||
|
||||
return lab_img_equal(a->img, b->img)
|
||||
&& a->width == b->width
|
||||
&& a->height == b->height;
|
||||
}
|
||||
|
||||
static struct scaled_scene_buffer_impl impl = {
|
||||
.create_buffer = _create_buffer,
|
||||
.destroy = _destroy,
|
||||
.equal = _equal,
|
||||
};
|
||||
|
||||
struct scaled_img_buffer *
|
||||
scaled_img_buffer_create(struct wlr_scene_tree *parent, struct lab_img *img,
|
||||
int width, int height)
|
||||
{
|
||||
assert(parent);
|
||||
assert(img);
|
||||
assert(width >= 0 && height >= 0);
|
||||
|
||||
struct scaled_scene_buffer *scaled_buffer = scaled_scene_buffer_create(
|
||||
parent, &impl, /* drop_buffer */ true);
|
||||
struct scaled_img_buffer *self = znew(*self);
|
||||
self->scaled_buffer = scaled_buffer;
|
||||
self->scene_buffer = scaled_buffer->scene_buffer;
|
||||
self->img = lab_img_copy(img);
|
||||
self->width = width;
|
||||
self->height = height;
|
||||
|
||||
scaled_buffer->data = self;
|
||||
|
||||
scaled_scene_buffer_request_update(scaled_buffer, width, height);
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
struct scaled_img_buffer *
|
||||
scaled_img_buffer_from_node(struct wlr_scene_node *node)
|
||||
{
|
||||
struct scaled_scene_buffer *scaled_buffer =
|
||||
node_scaled_scene_buffer_from_node(node);
|
||||
assert(scaled_buffer->impl == &impl);
|
||||
return scaled_buffer->data;
|
||||
}
|
||||
|
|
@ -1,266 +0,0 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include "common/scaled-scene-buffer.h"
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <wayland-server-core.h>
|
||||
#include <wlr/types/wlr_buffer.h>
|
||||
#include <wlr/types/wlr_output.h>
|
||||
#include <wlr/types/wlr_scene.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include "buffer.h"
|
||||
#include "common/list.h"
|
||||
#include "common/macros.h"
|
||||
#include "common/mem.h"
|
||||
#include "node.h"
|
||||
|
||||
/*
|
||||
* This holds all the scaled_scene_buffers from all the implementers.
|
||||
* This is used to share visually duplicated buffers found via impl->equal().
|
||||
*/
|
||||
static struct wl_list all_scaled_buffers = WL_LIST_INIT(&all_scaled_buffers);
|
||||
|
||||
/* Internal API */
|
||||
static void
|
||||
_cache_entry_destroy(struct scaled_scene_buffer_cache_entry *cache_entry, bool drop_buffer)
|
||||
{
|
||||
wl_list_remove(&cache_entry->link);
|
||||
if (cache_entry->buffer) {
|
||||
/* Allow the buffer to get dropped if there are no further consumers */
|
||||
if (drop_buffer && !cache_entry->buffer->dropped) {
|
||||
wlr_buffer_drop(cache_entry->buffer);
|
||||
}
|
||||
wlr_buffer_unlock(cache_entry->buffer);
|
||||
}
|
||||
free(cache_entry);
|
||||
}
|
||||
|
||||
static struct scaled_scene_buffer_cache_entry *
|
||||
find_cache_for_scale(struct scaled_scene_buffer *scene_buffer, double scale)
|
||||
{
|
||||
struct scaled_scene_buffer_cache_entry *cache_entry;
|
||||
wl_list_for_each(cache_entry, &scene_buffer->cache, link) {
|
||||
if (cache_entry->scale == scale) {
|
||||
return cache_entry;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
_update_buffer(struct scaled_scene_buffer *self, double scale)
|
||||
{
|
||||
self->active_scale = scale;
|
||||
|
||||
/* Search for cached buffer of specified scale */
|
||||
struct scaled_scene_buffer_cache_entry *cache_entry =
|
||||
find_cache_for_scale(self, scale);
|
||||
if (cache_entry) {
|
||||
/* LRU cache, recently used in front */
|
||||
wl_list_remove(&cache_entry->link);
|
||||
wl_list_insert(&self->cache, &cache_entry->link);
|
||||
wlr_scene_buffer_set_buffer(self->scene_buffer, cache_entry->buffer);
|
||||
/*
|
||||
* If found in our local cache,
|
||||
* - self->width and self->height are already set
|
||||
* - wlr_scene_buffer_set_dest_size() has already been called
|
||||
*/
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_buffer *wlr_buffer = NULL;
|
||||
|
||||
if (self->impl->equal) {
|
||||
/* Search from other cached scaled-scene-buffers */
|
||||
struct scaled_scene_buffer *scene_buffer;
|
||||
wl_list_for_each(scene_buffer, &all_scaled_buffers, link) {
|
||||
if (scene_buffer == self) {
|
||||
continue;
|
||||
}
|
||||
if (self->impl != scene_buffer->impl) {
|
||||
continue;
|
||||
}
|
||||
if (!self->impl->equal(self, scene_buffer)) {
|
||||
continue;
|
||||
}
|
||||
cache_entry = find_cache_for_scale(scene_buffer, scale);
|
||||
if (!cache_entry) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Ensure self->width and self->height are set correctly */
|
||||
self->width = scene_buffer->width;
|
||||
self->height = scene_buffer->height;
|
||||
wlr_buffer = cache_entry->buffer;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!wlr_buffer) {
|
||||
/*
|
||||
* Create new buffer, will get destroyed along the backing
|
||||
* wlr_buffer
|
||||
*/
|
||||
struct lab_data_buffer *buffer =
|
||||
self->impl->create_buffer(self, scale);
|
||||
if (buffer) {
|
||||
self->width = buffer->logical_width;
|
||||
self->height = buffer->logical_height;
|
||||
wlr_buffer = &buffer->base;
|
||||
} else {
|
||||
self->width = 0;
|
||||
self->height = 0;
|
||||
}
|
||||
}
|
||||
if (wlr_buffer) {
|
||||
/* Ensure the buffer doesn't get deleted behind our back */
|
||||
wlr_buffer_lock(wlr_buffer);
|
||||
}
|
||||
|
||||
/* Create or reuse cache entry */
|
||||
if (wl_list_length(&self->cache) < LAB_SCALED_BUFFER_MAX_CACHE) {
|
||||
cache_entry = znew(*cache_entry);
|
||||
} else {
|
||||
cache_entry = wl_container_of(self->cache.prev, cache_entry, link);
|
||||
if (cache_entry->buffer) {
|
||||
/* Allow the old buffer to get dropped if there are no further consumers */
|
||||
if (self->drop_buffer && !cache_entry->buffer->dropped) {
|
||||
wlr_buffer_drop(cache_entry->buffer);
|
||||
}
|
||||
wlr_buffer_unlock(cache_entry->buffer);
|
||||
}
|
||||
wl_list_remove(&cache_entry->link);
|
||||
}
|
||||
|
||||
/* Update the cache entry */
|
||||
cache_entry->scale = scale;
|
||||
cache_entry->buffer = wlr_buffer;
|
||||
wl_list_insert(&self->cache, &cache_entry->link);
|
||||
|
||||
/* And finally update the wlr_scene_buffer itself */
|
||||
wlr_scene_buffer_set_buffer(self->scene_buffer, cache_entry->buffer);
|
||||
wlr_scene_buffer_set_dest_size(self->scene_buffer, self->width, self->height);
|
||||
}
|
||||
|
||||
/* Internal event handlers */
|
||||
static void
|
||||
_handle_node_destroy(struct wl_listener *listener, void *data)
|
||||
{
|
||||
struct scaled_scene_buffer_cache_entry *cache_entry, *cache_entry_tmp;
|
||||
struct scaled_scene_buffer *self = wl_container_of(listener, self, destroy);
|
||||
|
||||
wl_list_remove(&self->destroy.link);
|
||||
wl_list_remove(&self->outputs_update.link);
|
||||
|
||||
wl_list_for_each_safe(cache_entry, cache_entry_tmp, &self->cache, link) {
|
||||
_cache_entry_destroy(cache_entry, self->drop_buffer);
|
||||
}
|
||||
assert(wl_list_empty(&self->cache));
|
||||
|
||||
if (self->impl->destroy) {
|
||||
self->impl->destroy(self);
|
||||
}
|
||||
wl_list_remove(&self->link);
|
||||
free(self);
|
||||
}
|
||||
|
||||
static void
|
||||
_handle_outputs_update(struct wl_listener *listener, void *data)
|
||||
{
|
||||
struct scaled_scene_buffer *self =
|
||||
wl_container_of(listener, self, outputs_update);
|
||||
|
||||
double max_scale = 0;
|
||||
struct wlr_scene_outputs_update_event *event = data;
|
||||
for (size_t i = 0; i < event->size; i++) {
|
||||
max_scale = MAX(max_scale, event->active[i]->output->scale);
|
||||
}
|
||||
if (max_scale && self->active_scale != max_scale) {
|
||||
_update_buffer(self, max_scale);
|
||||
}
|
||||
}
|
||||
|
||||
/* Public API */
|
||||
struct scaled_scene_buffer *
|
||||
scaled_scene_buffer_create(struct wlr_scene_tree *parent,
|
||||
const struct scaled_scene_buffer_impl *impl,
|
||||
bool drop_buffer)
|
||||
{
|
||||
assert(parent);
|
||||
assert(impl);
|
||||
assert(impl->create_buffer);
|
||||
|
||||
struct scaled_scene_buffer *self = znew(*self);
|
||||
self->scene_buffer = wlr_scene_buffer_create(parent, NULL);
|
||||
if (!self->scene_buffer) {
|
||||
wlr_log(WLR_ERROR, "Failed to create scene buffer");
|
||||
free(self);
|
||||
return NULL;
|
||||
}
|
||||
node_descriptor_create(&self->scene_buffer->node,
|
||||
LAB_NODE_DESC_SCALED_SCENE_BUFFER, self);
|
||||
|
||||
self->impl = impl;
|
||||
/*
|
||||
* Set active scale to zero so that we always render a new buffer when
|
||||
* entering the first output
|
||||
*/
|
||||
self->active_scale = 0;
|
||||
self->drop_buffer = drop_buffer;
|
||||
wl_list_init(&self->cache);
|
||||
|
||||
wl_list_insert(&all_scaled_buffers, &self->link);
|
||||
|
||||
/* Listen to outputs_update so we get notified about scale changes */
|
||||
self->outputs_update.notify = _handle_outputs_update;
|
||||
wl_signal_add(&self->scene_buffer->events.outputs_update, &self->outputs_update);
|
||||
|
||||
/* Let it destroy automatically when the scene node destroys */
|
||||
self->destroy.notify = _handle_node_destroy;
|
||||
wl_signal_add(&self->scene_buffer->node.events.destroy, &self->destroy);
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
void
|
||||
scaled_scene_buffer_request_update(struct scaled_scene_buffer *self,
|
||||
int width, int height)
|
||||
{
|
||||
assert(self);
|
||||
assert(width >= 0);
|
||||
assert(height >= 0);
|
||||
|
||||
struct scaled_scene_buffer_cache_entry *cache_entry, *cache_entry_tmp;
|
||||
wl_list_for_each_safe(cache_entry, cache_entry_tmp, &self->cache, link) {
|
||||
_cache_entry_destroy(cache_entry, self->drop_buffer);
|
||||
}
|
||||
assert(wl_list_empty(&self->cache));
|
||||
|
||||
/*
|
||||
* Tell wlroots about the buffer size so we can receive output_enter
|
||||
* events even when the actual backing buffer is not set yet.
|
||||
* The buffer size set here is updated when the backing buffer is
|
||||
* created in _update_buffer().
|
||||
*/
|
||||
wlr_scene_buffer_set_dest_size(self->scene_buffer, width, height);
|
||||
self->width = width;
|
||||
self->height = height;
|
||||
|
||||
/*
|
||||
* Skip re-rendering if the buffer is not shown yet
|
||||
* TODO: don't re-render also when the buffer is temporarily invisible
|
||||
*/
|
||||
if (self->active_scale > 0) {
|
||||
_update_buffer(self, self->active_scale);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
scaled_scene_buffer_invalidate_sharing(void)
|
||||
{
|
||||
struct scaled_scene_buffer *scene_buffer, *tmp;
|
||||
wl_list_for_each_safe(scene_buffer, tmp, &all_scaled_buffers, link) {
|
||||
wl_list_remove(&scene_buffer->link);
|
||||
wl_list_init(&scene_buffer->link);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue