Support xdg-toplevel-icon protocol

This patch also changes the semantics of scaled_icon_buffer: rather than
calling scaled_icon_buffer_set_app_id() every time an app_id is set, we
can now call scaled_icon_buffer_set_view() just once so that multiple
scaled_icon_buffers bound to a window are automatically updated when an
app_id is set or new icon is set via xdg-toplevel-icon-v1.
This commit is contained in:
tokyo4j 2025-05-30 20:58:48 +09:00 committed by Hiroaki Yamamoto
parent 649773b4f8
commit fb077c0095
12 changed files with 247 additions and 57 deletions

View file

@ -2,6 +2,8 @@
#define _POSIX_C_SOURCE 200809L
#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-icon-buffer.h"
@ -12,6 +14,35 @@
#include "desktop-entry.h"
#include "img/img.h"
#include "node.h"
#include "view.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_MIN;
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;
}
#endif /* HAVE_LIBSFDO */
static struct lab_data_buffer *
_create_buffer(struct scaled_scene_buffer *scaled_buffer, double scale)
@ -24,10 +55,29 @@ _create_buffer(struct scaled_scene_buffer *scaled_buffer, double scale)
if (self->icon_name) {
img = desktop_entry_load_icon(self->server,
self->icon_name, icon_size, scale);
} else if (self->app_id) {
img = desktop_entry_load_icon_from_app_id(self->server,
self->app_id, icon_size, scale);
} else if (self->view) {
if (self->view_icon_name) {
wlr_log(WLR_DEBUG, "loading icon by name: %s",
self->view_icon_name);
img = desktop_entry_load_icon(self->server,
self->view_icon_name, icon_size, scale);
}
if (!img) {
struct lab_data_buffer *buffer =
choose_best_icon_buffer(self, icon_size, scale);
if (buffer) {
wlr_log(WLR_DEBUG, "loading icon by buffer");
return buffer_resize(buffer,
self->width, self->height, scale);
}
}
if (!img) {
wlr_log(WLR_DEBUG, "loading icon by app_id");
img = desktop_entry_load_icon_from_app_id(self->server,
self->view_app_id, icon_size, scale);
}
if (!img) {
wlr_log(WLR_DEBUG, "loading fallback icon");
img = desktop_entry_load_icon(self->server,
rc.fallback_app_icon_name, icon_size, scale);
}
@ -44,18 +94,53 @@ _create_buffer(struct scaled_scene_buffer *scaled_buffer, double scale)
return buffer;
#else
return NULL;
#endif
#endif /* HAVE_LIBSFDO */
}
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;
free(self->app_id);
if (self->view) {
wl_list_remove(&self->on_view.set_icon.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)
@ -63,7 +148,9 @@ _equal(struct scaled_scene_buffer *scaled_buffer_a,
struct scaled_icon_buffer *a = scaled_buffer_a->data;
struct scaled_icon_buffer *b = scaled_buffer_b->data;
return str_equal(a->app_id, b->app_id)
return str_equal(a->view_app_id, b->view_app_id)
&& 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;
@ -96,15 +183,54 @@ scaled_icon_buffer_create(struct wlr_scene_tree *parent, struct server *server,
return self;
}
void
scaled_icon_buffer_set_app_id(struct scaled_icon_buffer *self,
const char *app_id)
static void
handle_view_set_icon(struct wl_listener *listener, void *data)
{
assert(app_id);
if (str_equal(self->app_id, app_id)) {
struct scaled_icon_buffer *self =
wl_container_of(listener, self, on_view.set_icon);
/* view_get_string_prop() never returns NULL */
xstrdup_replace(self->view_app_id, view_get_string_prop(self->view, "app_id"));
zfree(self->view_icon_name);
if (self->view->icon.name) {
self->view_icon_name = xstrdup(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_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);
self->view = NULL;
}
void
scaled_icon_buffer_set_view(struct scaled_icon_buffer *self, struct view *view)
{
assert(view);
if (self->view == view) {
return;
}
xstrdup_replace(self->app_id, app_id);
if (self->view) {
wl_list_remove(&self->on_view.set_icon.link);
wl_list_remove(&self->on_view.destroy.link);
}
self->view = view;
if (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.destroy.notify = handle_view_destroy;
wl_signal_add(&view->events.destroy, &self->on_view.destroy);
}
scaled_scene_buffer_request_update(self->scaled_buffer, self->width, self->height);
}