mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
Some checks are pending
CI / Linux (python=3.14 cc=clang sanitize=1) (push) Waiting to run
CI / Linux (python=3.12 cc=gcc sanitize=0) (push) Waiting to run
CI / Linux (python=3.13 cc=gcc sanitize=1) (push) Waiting to run
CI / Linux package (push) Waiting to run
CI / Bundle test (macos-latest) (push) Waiting to run
CI / Bundle test (ubuntu-latest) (push) Waiting to run
CI / macOS Brew (push) Waiting to run
CI / Test ./dev.sh and benchmark (push) Waiting to run
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run
The focus state of the decorations comes only from keyboard enter/leave events, but the decorations were only re-rendered on configure events and title changes. So they showed a stale focus state whenever focus changed without a following configure, for example, when switching between tabbed windows in niri, which keeps all tabs activated. Re-render the decorations on keyboard enter/leave, looking up the window again after the focus callbacks have run, since they can close it. Also: - Ignore the activated state in the change detection, as focus is tracked separately, to avoid rendering twice per focus change. - Never create decoration surfaces in ensure_csd_resources() for windows that should not be decorated, such as fullscreen windows. Title changes while fullscreen could previously create them from a stale state. - Recreate the decoration surfaces when they are missing even if the window state is unchanged, otherwise the resize borders were not restored after leaving fullscreen with hide_window_decorations titlebar-only. Based on the patch by Ole Jørgen Brønner. Closes #10873
1210 lines
53 KiB
C
Vendored
1210 lines
53 KiB
C
Vendored
/*
|
|
* wl_client_side_decorations.c
|
|
* Copyright (C) 2021 Kovid Goyal <kovid at kovidgoyal.net>
|
|
*
|
|
* Distributed under terms of the GPL3 license.
|
|
*/
|
|
|
|
#include "wl_client_side_decorations.h"
|
|
#include "linux_desktop_settings.h"
|
|
|
|
#include "backend_utils.h"
|
|
#include <sys/mman.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
// Needed for the BTN_* defines
|
|
#ifdef __has_include
|
|
#if __has_include(<linux/input.h>)
|
|
#include <linux/input.h>
|
|
#elif __has_include(<dev/evdev/input.h>)
|
|
#include <dev/evdev/input.h>
|
|
#endif
|
|
#else
|
|
#include <linux/input.h>
|
|
#endif
|
|
|
|
#define decs window->wl.decorations
|
|
#define debug debug_rendering
|
|
#define decoration_touch _glfw.wl.decoration_touch
|
|
|
|
#define ARGB(a, r, g, b) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
|
|
#define A(x) (((x) >> 24) & 0xff)
|
|
#define R(x) (((x) >> 16) & 0xff)
|
|
#define G(x) (((x) >> 8) & 0xff)
|
|
#define B(x) ((x) & 0xff)
|
|
#define SWAP(x, y) \
|
|
do { \
|
|
__typeof__(x) SWAP = x; \
|
|
x = y; \
|
|
y = SWAP; \
|
|
} while (0)
|
|
|
|
// shadow tile {{{
|
|
typedef float kernel_type;
|
|
|
|
static void
|
|
build_blur_kernel(kernel_type *blur_kernel, const size_t size, kernel_type sigma) {
|
|
// 1D Normalized Gaussian
|
|
const kernel_type half = size / (kernel_type)2;
|
|
kernel_type sum = 0;
|
|
for (size_t i = 0; i < size; i++) {
|
|
kernel_type f = (i - half);
|
|
blur_kernel[i] = (kernel_type)exp(-f * f / sigma);
|
|
sum += blur_kernel[i];
|
|
}
|
|
for (size_t i = 0; i < size; i++) blur_kernel[i] /= sum;
|
|
}
|
|
|
|
static void
|
|
blur_mask(
|
|
kernel_type *image_data,
|
|
ssize_t width,
|
|
ssize_t height,
|
|
ssize_t kernel_size,
|
|
kernel_type sigma,
|
|
kernel_type *scratch,
|
|
kernel_type *blur_kernel,
|
|
ssize_t margin) {
|
|
(void)margin;
|
|
build_blur_kernel(blur_kernel, kernel_size, sigma);
|
|
const size_t half = kernel_size / 2;
|
|
|
|
for (ssize_t y = 0; y < height; y++) {
|
|
kernel_type *s = image_data + y * width, *d = scratch + y * width;
|
|
for (ssize_t x = 0; x < width; x++) {
|
|
kernel_type a = 0;
|
|
for (ssize_t k = 0; k < kernel_size; k++) {
|
|
const ssize_t px = x + k - half;
|
|
if (0 <= px && px < width) a += s[px] * blur_kernel[k];
|
|
}
|
|
d[x] = a;
|
|
}
|
|
}
|
|
|
|
for (ssize_t y = 0; y < height; y++) {
|
|
kernel_type *d = image_data + y * width;
|
|
for (ssize_t x = 0; x < width; x++) {
|
|
kernel_type a = 0;
|
|
for (ssize_t k = 0; k < kernel_size; k++) {
|
|
const ssize_t py = y + k - half;
|
|
if (0 <= py && py < height) {
|
|
kernel_type *s = scratch + py * width;
|
|
a += s[x] * blur_kernel[k];
|
|
}
|
|
}
|
|
d[x] = a;
|
|
}
|
|
}
|
|
}
|
|
|
|
static kernel_type *
|
|
create_shadow_mask(size_t width, size_t height, size_t margin, size_t kernel_size, kernel_type base_alpha, kernel_type sigma, double radius) {
|
|
kernel_type *mask = calloc(2 * width * height + kernel_size, sizeof(kernel_type));
|
|
if (!mask) return NULL;
|
|
for (size_t y = margin; y < height - margin; y++) {
|
|
kernel_type *row = mask + y * width;
|
|
for (size_t x = margin; x < width - margin; x++) {
|
|
double dx = fmax(margin + radius - x - .5, x + .5 - (width - margin - radius));
|
|
double dy = margin + radius - y - .5;
|
|
row[x] = radius > 0 && dx > 0 && dy > 0 ? base_alpha * (kernel_type)fmax(0, fmin(1, radius - hypot(dx, dy) + .5)) : base_alpha;
|
|
}
|
|
}
|
|
blur_mask(mask, width, height, kernel_size, sigma, mask + width * height, (kernel_type *)(mask + 2 * width * height), margin);
|
|
return mask;
|
|
}
|
|
|
|
#define st decs.shadow_tile
|
|
|
|
static size_t
|
|
create_shadow_tile(_GLFWwindow *window) {
|
|
const size_t margin = (size_t)round(decs.metrics.width * decs.for_window_state.fscale);
|
|
if (st.data && st.for_decoration_size == margin) return margin;
|
|
st.for_decoration_size = margin;
|
|
if (!margin) { // absurdly small scale, no shadows
|
|
free(st.data);
|
|
st.data = NULL;
|
|
return 0;
|
|
}
|
|
st.segments = 7;
|
|
st.stride = st.segments * margin;
|
|
st.corner_size = margin * (st.segments - 1) / 2;
|
|
kernel_type *mask = create_shadow_mask(st.stride, st.stride, margin, 2 * margin + 1, (kernel_type)0.46, 32 * margin, !decs.titlebar_hidden ? margin : 0);
|
|
free(st.data);
|
|
st.data = NULL;
|
|
if (!mask) return margin;
|
|
// Fill a local buffer and only publish it to st.data once complete, this
|
|
// also avoids a false positive use-after-free warning from CodeQL
|
|
uint32_t *data = malloc(sizeof(data[0]) * st.stride * st.stride);
|
|
if (data)
|
|
for (size_t y = 0; y < st.stride; y++)
|
|
for (size_t x = 0; x < st.stride; x++) {
|
|
double alpha = mask[y * st.stride + x];
|
|
// The blur has finite buffers. Fade to a rounded outer envelope
|
|
// instead of exposing their rectangular edges on the desktop.
|
|
const double feather = fmax(1, 3 * decs.for_window_state.fscale);
|
|
const bool upper = y < st.stride / 2;
|
|
const double radius = margin * (upper && !decs.titlebar_hidden ? 2. : 1.);
|
|
const double dx = fmax(radius - x - .5, x + .5 - (st.stride - radius));
|
|
const double dy = upper ? radius - y - .5 : y + .5 - (st.stride - radius);
|
|
double distance = fmin(fmin(x + .5, st.stride - x - .5), fmin(y + .5, st.stride - y - .5));
|
|
if (dx > 0 && dy > 0) distance = radius - hypot(dx, dy);
|
|
double coverage = fmax(0, fmin(1, distance / feather));
|
|
alpha *= coverage * coverage * (3 - 2 * coverage);
|
|
data[y * st.stride + x] = ((uint32_t)(alpha * 255)) << 24;
|
|
}
|
|
free(mask);
|
|
st.data = data;
|
|
return margin;
|
|
}
|
|
|
|
|
|
// }}}
|
|
|
|
static bool
|
|
window_needs_shadows(_GLFWwindow *w) {
|
|
return !(w->wl.current.toplevel_states & TOPLEVEL_STATE_DOCKED);
|
|
}
|
|
|
|
static void
|
|
swap_buffers(_GLFWWaylandBufferPair *pair) {
|
|
SWAP(pair->front, pair->back);
|
|
SWAP(pair->data.front, pair->data.back);
|
|
}
|
|
|
|
static size_t
|
|
init_buffer_pair(_GLFWWaylandBufferPair *pair, size_t width, size_t height, double scale) {
|
|
memset(pair, 0, sizeof(_GLFWWaylandBufferPair));
|
|
// wl_shm buffers must have non-zero size
|
|
pair->width = MAX(1, (int)round(width * scale));
|
|
pair->height = MAX(1, (int)round(height * scale));
|
|
pair->viewport_width = width;
|
|
pair->viewport_height = height;
|
|
pair->stride = 4 * pair->width;
|
|
pair->size_in_bytes = pair->stride * pair->height;
|
|
return 2 * pair->size_in_bytes;
|
|
}
|
|
|
|
#define all_shadow_surfaces(Q) \
|
|
Q(shadow_left); \
|
|
Q(shadow_top); \
|
|
Q(shadow_right); \
|
|
Q(shadow_bottom); \
|
|
Q(shadow_upper_left); \
|
|
Q(shadow_upper_right); \
|
|
Q(shadow_lower_left); \
|
|
Q(shadow_lower_right);
|
|
#define all_surfaces(Q) \
|
|
Q(titlebar); \
|
|
all_shadow_surfaces(Q);
|
|
|
|
static bool
|
|
mark_buffer_released(_GLFWwindow *window, struct wl_buffer *q) {
|
|
#define Q(which) \
|
|
if (decs.which.buffer.a == q) { \
|
|
decs.which.buffer.a_busy = false; \
|
|
return true; \
|
|
} \
|
|
if (decs.which.buffer.b == q) { \
|
|
decs.which.buffer.b_busy = false; \
|
|
return true; \
|
|
}
|
|
all_surfaces(Q);
|
|
#undef Q
|
|
return false;
|
|
}
|
|
|
|
static void on_titlebar_buffer_released(_GLFWwindow *window);
|
|
|
|
static void
|
|
buffer_release_event(void *data, struct wl_buffer *buffer) {
|
|
_GLFWwindow *window = _glfwWindowForId((uintptr_t)data);
|
|
if (!window || !mark_buffer_released(window, buffer)) {
|
|
// A buffer that was busy when the buffers it belonged to were freed
|
|
wl_buffer_destroy(buffer);
|
|
return;
|
|
}
|
|
if (buffer == decs.titlebar.buffer.back) on_titlebar_buffer_released(window);
|
|
}
|
|
|
|
static struct wl_buffer_listener handle_buffer_events = {.release = buffer_release_event};
|
|
|
|
static void
|
|
alloc_buffer_pair(uintptr_t window_id, _GLFWWaylandBufferPair *pair, struct wl_shm_pool *pool, uint8_t *data, size_t *offset) {
|
|
pair->data.a = data + *offset;
|
|
pair->a = wl_shm_pool_create_buffer(pool, *offset, pair->width, pair->height, pair->stride, WL_SHM_FORMAT_ARGB8888);
|
|
wl_buffer_add_listener(pair->a, &handle_buffer_events, (void *)window_id);
|
|
*offset += pair->size_in_bytes;
|
|
pair->data.b = data + *offset;
|
|
pair->b = wl_shm_pool_create_buffer(pool, *offset, pair->width, pair->height, pair->stride, WL_SHM_FORMAT_ARGB8888);
|
|
wl_buffer_add_listener(pair->b, &handle_buffer_events, (void *)window_id);
|
|
*offset += pair->size_in_bytes;
|
|
pair->front = pair->a;
|
|
pair->back = pair->b;
|
|
pair->data.front = pair->data.a;
|
|
pair->data.back = pair->data.b;
|
|
}
|
|
|
|
void
|
|
csd_initialize_metrics(_GLFWwindow *window) {
|
|
decs.metrics.width = 12;
|
|
decs.metrics.top = decs.metrics.width + glfw_current_titlebar_height();
|
|
decs.metrics.visible_titlebar_height = decs.metrics.top - decs.metrics.width;
|
|
decs.metrics.horizontal = 2 * decs.metrics.width;
|
|
decs.metrics.vertical = decs.metrics.width + decs.metrics.top;
|
|
}
|
|
|
|
// All geometry is in logical pixels; coverage is evaluated in buffer pixels.
|
|
static uint32_t
|
|
coverage_pixel(uint32_t color, double coverage) {
|
|
unsigned a = (unsigned)(255 * fmax(0, fmin(1, coverage)));
|
|
return ARGB(a, R(color) * a / 255, G(color) * a / 255, B(color) * a / 255);
|
|
}
|
|
|
|
static double
|
|
segment_distance(double x, double y, double ax, double ay, double bx, double by) {
|
|
double dx = bx - ax, dy = by - ay;
|
|
double t = fmax(0, fmin(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy)));
|
|
return hypot(x - ax - t * dx, y - ay - t * dy);
|
|
}
|
|
|
|
static uint32_t
|
|
blend_colors(uint32_t a, uint32_t b, double t) {
|
|
t = fmax(0, fmin(1, t));
|
|
return ARGB(255u, (unsigned)(R(a) * (1 - t) + R(b) * t), (unsigned)(G(a) * (1 - t) + G(b) * t), (unsigned)(B(a) * (1 - t) + B(b) * t));
|
|
}
|
|
|
|
typedef struct {
|
|
uint32_t bg, fg, button, hovered_button, pressed_button;
|
|
} TitlebarColors;
|
|
|
|
static TitlebarColors
|
|
titlebar_colors(_GLFWwindow *window) {
|
|
static const uint32_t dark_bg = 0xff303030, light_bg = 0xffebebeb;
|
|
TitlebarColors ans;
|
|
const GLFWColorScheme appearance = glfwGetCurrentSystemColorTheme(false);
|
|
bool dark = appearance == GLFW_COLOR_SCHEME_DARK;
|
|
ans.bg = dark ? dark_bg : light_bg;
|
|
if (decs.use_custom_titlebar_color || appearance == GLFW_COLOR_SCHEME_NO_PREFERENCE) {
|
|
// When using system colors and the desktop has no preference, follow
|
|
// the background color of the active kitty window.
|
|
const uint32_t color = 0xff000000 | (decs.titlebar_color & 0xffffff);
|
|
dark = .2126 * R(color) + .7152 * G(color) + .0722 * B(color) < 128;
|
|
ans.bg = decs.use_custom_titlebar_color ? color : (dark ? dark_bg : light_bg);
|
|
}
|
|
const bool focused = window->id == _glfw.focusedWindowId;
|
|
ans.fg = dark ? (focused ? 0xffeeeeee : 0xffaaaaaa) : (focused ? 0xff333333 : 0xff888888);
|
|
// Button backgrounds are tints of the titlebar background so that they
|
|
// fit in with custom titlebar colors as well.
|
|
static const double dark_tints[3] = {.116, .232, .31}, light_tints[3] = {.09, .187, .277};
|
|
const double *tints = dark ? dark_tints : light_tints;
|
|
const uint32_t tint = dark ? 0xffffffff : 0xff000000;
|
|
ans.button = blend_colors(ans.bg, tint, tints[0]);
|
|
ans.hovered_button = blend_colors(ans.bg, tint, tints[1]);
|
|
ans.pressed_button = blend_colors(ans.bg, tint, tints[2]);
|
|
return ans;
|
|
}
|
|
|
|
typedef struct {
|
|
GLFWTitlebarButton which;
|
|
int left;
|
|
} PlacedTitlebarButton;
|
|
|
|
static bool
|
|
is_titlebar_button_available(_GLFWwindow *window, GLFWTitlebarButton which) {
|
|
switch (which) {
|
|
case TITLEBAR_BUTTON_CLOSE: return true;
|
|
case TITLEBAR_BUTTON_MAXIMIZE: return window->wl.wm_capabilities.maximize;
|
|
case TITLEBAR_BUTTON_MINIMIZE: return window->wl.wm_capabilities.minimize;
|
|
case TITLEBAR_BUTTON_NONE:
|
|
case TITLEBAR_BUTTON_COUNT: break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Only x is checked so that a mouse button pressed on a titlebar button
|
|
// still activates it when released after the pointer is dragged out of the
|
|
// titlebar, vertically.
|
|
static GLFWTitlebarButton
|
|
titlebar_button_at_x(_GLFWwindow *window, double sx) {
|
|
const int scaled_x = (int)round(decs.for_window_state.fscale * sx);
|
|
#define button_at(which, value) \
|
|
if (decs.which.left <= scaled_x && scaled_x < decs.which.left + decs.which.width) return value;
|
|
button_at(close, TITLEBAR_BUTTON_CLOSE);
|
|
button_at(maximize, TITLEBAR_BUTTON_MAXIMIZE);
|
|
button_at(minimize, TITLEBAR_BUTTON_MINIMIZE);
|
|
#undef button_at
|
|
return TITLEBAR_BUTTON_NONE;
|
|
}
|
|
|
|
static GLFWTitlebarButton
|
|
titlebar_button_at(_GLFWwindow *window, double sx, double sy) {
|
|
if (sy < 0 || sy >= decs.metrics.visible_titlebar_height) return TITLEBAR_BUTTON_NONE;
|
|
return titlebar_button_at_x(window, sx);
|
|
}
|
|
|
|
static void
|
|
activate_titlebar_button(_GLFWwindow *window, GLFWTitlebarButton button) {
|
|
switch (button) {
|
|
case TITLEBAR_BUTTON_CLOSE: _glfwInputWindowCloseRequest(window); break;
|
|
case TITLEBAR_BUTTON_MINIMIZE: _glfwPlatformIconifyWindow(window); break;
|
|
case TITLEBAR_BUTTON_MAXIMIZE:
|
|
if (window->wl.current.toplevel_states & TOPLEVEL_STATE_MAXIMIZED) _glfwPlatformRestoreWindow(window);
|
|
else _glfwPlatformMaximizeWindow(window);
|
|
break;
|
|
case TITLEBAR_BUTTON_NONE:
|
|
case TITLEBAR_BUTTON_COUNT: break;
|
|
}
|
|
}
|
|
|
|
static _GLFWCSDSurface
|
|
decoration_surface(_GLFWwindow *window, struct wl_surface *surface) {
|
|
#define surface_at(which) \
|
|
if (surface && surface == decs.which.surface) return CSD_##which;
|
|
all_surfaces(surface_at);
|
|
#undef surface_at
|
|
return CENTRAL_WINDOW;
|
|
}
|
|
|
|
static uint32_t
|
|
decoration_resize_edges(_GLFWCSDSurface surface) {
|
|
switch (surface) {
|
|
case CSD_shadow_left: return XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
|
|
case CSD_shadow_upper_left: return XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
|
|
case CSD_shadow_right: return XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
|
|
case CSD_shadow_upper_right: return XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
|
|
case CSD_shadow_top: return XDG_TOPLEVEL_RESIZE_EDGE_TOP;
|
|
case CSD_shadow_lower_left: return XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
|
|
case CSD_shadow_bottom: return XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
|
|
case CSD_shadow_lower_right: return XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
|
|
case CENTRAL_WINDOW:
|
|
case CSD_titlebar: return XDG_TOPLEVEL_RESIZE_EDGE_NONE;
|
|
}
|
|
return XDG_TOPLEVEL_RESIZE_EDGE_NONE;
|
|
}
|
|
|
|
// Places the buttons from the desktop button layout on the left and right
|
|
// sides of the titlebar, returns the number of buttons placed.
|
|
static unsigned
|
|
layout_titlebar_buttons(_GLFWwindow *window, int width, int slot, int pad, PlacedTitlebarButton *ans, int *side_margin) {
|
|
const GLFWTitlebarButtonLayout *layout = glfw_current_titlebar_button_layout();
|
|
bool visible[TITLEBAR_BUTTON_COUNT] = {0};
|
|
unsigned count = 0;
|
|
for (unsigned side = 0; side < 2; side++) {
|
|
const GLFWTitlebarButton *buttons = side ? layout->right : layout->left;
|
|
const unsigned n = side ? layout->right_count : layout->left_count;
|
|
for (unsigned i = 0; i < n; i++) {
|
|
if (!visible[buttons[i]] && is_titlebar_button_available(window, buttons[i])) {
|
|
visible[buttons[i]] = true;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
// Hide buttons that dont fit in narrow windows, close is hidden last
|
|
const unsigned capacity = width > 2 * pad ? (unsigned)((width - 2 * pad) / slot) : 0;
|
|
static const GLFWTitlebarButton hide_order[] = {TITLEBAR_BUTTON_MINIMIZE, TITLEBAR_BUTTON_MAXIMIZE, TITLEBAR_BUTTON_CLOSE};
|
|
for (unsigned i = 0; i < arraysz(hide_order) && count > capacity; i++) {
|
|
if (visible[hide_order[i]]) {
|
|
visible[hide_order[i]] = false;
|
|
count--;
|
|
}
|
|
}
|
|
unsigned used = 0;
|
|
int side_count[2] = {0};
|
|
for (unsigned side = 0; side < 2; side++) {
|
|
const GLFWTitlebarButton *buttons = side ? layout->right : layout->left;
|
|
const unsigned n = side ? layout->right_count : layout->left_count;
|
|
for (unsigned i = 0; i < n; i++)
|
|
if (visible[buttons[i]]) side_count[side]++;
|
|
int left = side ? width - pad - side_count[side] * slot : pad;
|
|
for (unsigned i = 0; i < n; i++) {
|
|
if (visible[buttons[i]]) {
|
|
visible[buttons[i]] = false; // guard against duplicates
|
|
ans[used].which = buttons[i];
|
|
ans[used++].left = left;
|
|
left += slot;
|
|
}
|
|
}
|
|
}
|
|
*side_margin = pad + MAX(side_count[0], side_count[1]) * slot;
|
|
return used;
|
|
}
|
|
|
|
static void
|
|
render_titlebar_button(
|
|
uint32_t *pixels,
|
|
int width,
|
|
int height,
|
|
int left,
|
|
int slot,
|
|
double scale,
|
|
GLFWTitlebarButton which,
|
|
bool maximized,
|
|
uint32_t fill,
|
|
uint32_t fg,
|
|
uint32_t bg) {
|
|
for (int y = 0; y < height; y++)
|
|
for (int x = left; x < left + slot; x++) {
|
|
const double lx = (x + .5 - left - slot / 2.) / scale, ly = (y + .5 - height / 2.) / scale;
|
|
// a circle of radius 12 with the icon drawn as lines of width 1
|
|
const double coverage = fmax(0, fmin(1, (12 - hypot(lx, ly)) * scale + .5));
|
|
double d;
|
|
switch (which) {
|
|
case TITLEBAR_BUTTON_CLOSE: d = fmin(segment_distance(lx, ly, -4, -4, 4, 4), segment_distance(lx, ly, -4, 4, 4, -4)); break;
|
|
case TITLEBAR_BUTTON_MINIMIZE: d = segment_distance(lx, ly, -4, 3, 4, 3); break;
|
|
default: {
|
|
const double bx = fabs(lx) - 3.5, by = fabs(ly) - 3.5;
|
|
d = (bx > 0 || by > 0) ? hypot(fmax(0, bx), fmax(0, by)) : fmin(-bx, -by);
|
|
if (maximized && fmin(segment_distance(lx, ly, -1, -5, 5, -5), segment_distance(lx, ly, 5, -5, 5, 1)) < .75) d = 0;
|
|
} break;
|
|
}
|
|
const double ink = (.5 - d) * scale + .5;
|
|
pixels[y * width + x] = blend_colors(bg, blend_colors(fill, fg, ink), coverage);
|
|
}
|
|
}
|
|
|
|
// Rounds the upper corners of the titlebar, filling the cutouts with the
|
|
// shadow, so that it matches the shadow in the adjacent subsurfaces.
|
|
static void
|
|
render_titlebar_corners(_GLFWwindow *window, uint32_t *pixels, int width, int height, double scale, bool focused) {
|
|
const size_t shadow_margin = create_shadow_tile(window);
|
|
const double radius = fmin(12 * scale, fmin(width / 2., height));
|
|
for (int y = 0; y < (int)ceil(radius); y++)
|
|
for (int x = 0; x < width; x++) {
|
|
const double dx = x < width / 2 ? radius - x - .5 : x + .5 - (width - radius);
|
|
if (dx <= 0) continue;
|
|
const double coverage = fmax(0, fmin(1, radius - hypot(dx, radius - y - .5) + .5));
|
|
uint32_t color = coverage_pixel(pixels[y * width + x], coverage);
|
|
// Distance from the nearest vertical edge of the titlebar
|
|
const size_t corner_x = x < width / 2 ? (size_t)x : (size_t)(width - x);
|
|
if (decs.shadow_tile.data && shadow_margin + corner_x < decs.shadow_tile.stride && shadow_margin + (size_t)y < decs.shadow_tile.stride) {
|
|
const size_t sx = x < width / 2 ? shadow_margin + corner_x : decs.shadow_tile.stride - shadow_margin - corner_x;
|
|
const size_t sy = shadow_margin + y;
|
|
unsigned shadow_alpha = A(decs.shadow_tile.data[sy * decs.shadow_tile.stride + sx]);
|
|
if (!focused) shadow_alpha /= 2;
|
|
const unsigned alpha = A(color) + (unsigned)(shadow_alpha * (1 - coverage));
|
|
color = (color & 0xffffff) | (alpha << 24);
|
|
}
|
|
pixels[y * width + x] = color;
|
|
}
|
|
}
|
|
|
|
static void
|
|
render_title_bar(_GLFWwindow *window, bool to_front_buffer) {
|
|
uint32_t *pixels = (uint32_t *)(to_front_buffer ? decs.titlebar.buffer.data.front : decs.titlebar.buffer.data.back);
|
|
const int width = decs.titlebar.buffer.width, height = decs.titlebar.buffer.height;
|
|
if (width <= 0 || height <= 0) return;
|
|
const double scale = decs.for_window_state.fscale;
|
|
const bool focused = window->id == _glfw.focusedWindowId;
|
|
const bool docked = window->wl.current.toplevel_states & TOPLEVEL_STATE_DOCKED;
|
|
const bool maximized = window->wl.current.toplevel_states & TOPLEVEL_STATE_MAXIMIZED;
|
|
const TitlebarColors colors = titlebar_colors(window);
|
|
for (int i = 0; i < width * height; i++) pixels[i] = colors.bg;
|
|
|
|
const int slot = MAX(1, (int)round(36 * scale));
|
|
const int pad = MAX(0, MIN((int)round(6 * scale), (width - slot) / 2));
|
|
PlacedTitlebarButton buttons[TITLEBAR_BUTTON_COUNT];
|
|
int margin;
|
|
const unsigned num_buttons = layout_titlebar_buttons(window, width, slot, pad, buttons, &margin);
|
|
if (width > 2 * margin && window->wl.title && _glfw.callbacks.draw_text)
|
|
_glfw.callbacks.draw_text((GLFWwindow *)window, window->wl.title, colors.fg, colors.bg, (uint8_t *)pixels, width, height, margin, 0, margin, false);
|
|
|
|
decs.minimize.width = decs.maximize.width = decs.close.width = 0;
|
|
for (unsigned i = 0; i < num_buttons; i++) {
|
|
__typeof__(decs.close) *state = buttons[i].which == TITLEBAR_BUTTON_CLOSE ? &decs.close
|
|
: buttons[i].which == TITLEBAR_BUTTON_MAXIMIZE ? &decs.maximize
|
|
: &decs.minimize;
|
|
state->left = buttons[i].left;
|
|
state->width = slot;
|
|
uint32_t fill = colors.button;
|
|
if (state->hovered) fill = decs.pressed_button == (int)buttons[i].which ? colors.pressed_button : colors.hovered_button;
|
|
// The geometry of the buttons after this one is not set yet, but
|
|
// buttons do not overlap, so only this button can contain the touch
|
|
if (decoration_touch.active && decoration_touch.window_id == window->id && decoration_touch.button == (int)buttons[i].which &&
|
|
titlebar_button_at(window, decoration_touch.x, decoration_touch.y) == buttons[i].which)
|
|
fill = colors.pressed_button;
|
|
render_titlebar_button(pixels, width, height, buttons[i].left, slot, scale, buttons[i].which, maximized, fill, colors.fg, colors.bg);
|
|
}
|
|
if (!decs.close.width) decs.close.hovered = false;
|
|
if (!decs.maximize.width) decs.maximize.hovered = false;
|
|
if (!decs.minimize.width) decs.minimize.hovered = false;
|
|
// The terminal owns the bottom corners, only the separate header is rounded
|
|
if (!docked) render_titlebar_corners(window, pixels, width, height, scale, focused);
|
|
}
|
|
|
|
static bool
|
|
update_title_bar(_GLFWwindow *window) {
|
|
// Never render into a buffer the compositor might still be reading from,
|
|
// instead render when it is released.
|
|
_GLFWWaylandBufferPair *pair = &decs.titlebar.buffer;
|
|
if (pair->back == pair->a ? pair->a_busy : pair->b_busy) {
|
|
pair->has_pending_update = true;
|
|
return false;
|
|
}
|
|
pair->has_pending_update = false;
|
|
render_title_bar(window, false);
|
|
swap_buffers(pair);
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
render_horizontal_shadow(_GLFWwindow *window, ssize_t scaled_shadow_size, ssize_t src_y_offset, ssize_t y, _GLFWWaylandBufferPair *buf) {
|
|
// left region
|
|
ssize_t src_y = src_y_offset + y;
|
|
const ssize_t src_leftover_corner = st.corner_size - scaled_shadow_size;
|
|
uint32_t *src = st.data + st.stride * src_y + scaled_shadow_size;
|
|
uint32_t *d_start = (uint32_t *)(buf->data.front + y * buf->stride);
|
|
uint32_t *d_end = (uint32_t *)(buf->data.front + (y + 1) * buf->stride);
|
|
uint32_t *left_region_end = d_start + MIN(d_end - d_start, src_leftover_corner);
|
|
memcpy(d_start, src, sizeof(uint32_t) * (left_region_end - d_start));
|
|
// right region
|
|
uint32_t *right_region_start = MAX(d_start, d_end - src_leftover_corner);
|
|
src = st.data + st.stride * (src_y + 1) - st.corner_size;
|
|
memcpy(right_region_start, src, sizeof(uint32_t) * MIN(src_leftover_corner, d_end - right_region_start));
|
|
src = st.data + st.stride * src_y + st.corner_size;
|
|
// middle region
|
|
for (uint32_t *d = left_region_end; d < right_region_start; d += scaled_shadow_size)
|
|
memcpy(d, src, sizeof(uint32_t) * MIN(right_region_start - d, scaled_shadow_size));
|
|
}
|
|
|
|
static void
|
|
copy_vertical_region(
|
|
_GLFWwindow *window, ssize_t src_y_start, ssize_t src_y_limit, ssize_t y_start, ssize_t y_limit, ssize_t src_x_offset, _GLFWWaylandBufferPair *buf) {
|
|
for (ssize_t dy = y_start, sy = src_y_start; dy < y_limit && sy < src_y_limit; dy++, sy++)
|
|
memcpy(buf->data.front + dy * buf->stride, st.data + sy * st.stride + src_x_offset, sizeof(uint32_t) * buf->width);
|
|
}
|
|
|
|
static void
|
|
render_shadows(_GLFWwindow *window) {
|
|
if (!window_needs_shadows(window)) return;
|
|
const ssize_t scaled_shadow_size = create_shadow_tile(window);
|
|
if (!st.data || !scaled_shadow_size) return; // out of memory
|
|
// upper and lower shadows
|
|
for (ssize_t y = 0; y < scaled_shadow_size; y++) {
|
|
_GLFWWaylandBufferPair *buf = &decs.shadow_upper_left.buffer;
|
|
uint32_t *src = st.data + st.stride * y;
|
|
uint32_t *d = (uint32_t *)(buf->data.front + y * buf->stride);
|
|
memcpy(d, src, sizeof(uint32_t) * scaled_shadow_size);
|
|
|
|
buf = &decs.shadow_upper_right.buffer;
|
|
src += st.stride - scaled_shadow_size;
|
|
d = (uint32_t *)(buf->data.front + y * buf->stride);
|
|
memcpy(d, src, sizeof(uint32_t) * scaled_shadow_size);
|
|
|
|
const size_t tile_bottom_start = st.stride - scaled_shadow_size;
|
|
buf = &decs.shadow_lower_left.buffer;
|
|
src = st.data + (tile_bottom_start + y) * st.stride;
|
|
d = (uint32_t *)(buf->data.front + y * buf->stride);
|
|
memcpy(d, src, sizeof(uint32_t) * scaled_shadow_size);
|
|
|
|
buf = &decs.shadow_lower_right.buffer;
|
|
src += st.stride - scaled_shadow_size;
|
|
d = (uint32_t *)(buf->data.front + y * buf->stride);
|
|
memcpy(d, src, sizeof(uint32_t) * scaled_shadow_size);
|
|
|
|
render_horizontal_shadow(window, scaled_shadow_size, 0, y, &decs.shadow_top.buffer);
|
|
render_horizontal_shadow(window, scaled_shadow_size, st.stride - scaled_shadow_size, y, &decs.shadow_bottom.buffer);
|
|
}
|
|
// side shadows
|
|
// top region
|
|
const ssize_t src_leftover_corner = st.corner_size - scaled_shadow_size;
|
|
ssize_t y_start = 0, y_end = decs.shadow_left.buffer.height, top_end = MIN(y_end, src_leftover_corner);
|
|
ssize_t right_src_start = st.stride - scaled_shadow_size;
|
|
#define c(src_y_start, src_y_limit, dest_y_start, dest_y_limit) \
|
|
{ \
|
|
copy_vertical_region(window, src_y_start, src_y_limit, dest_y_start, dest_y_limit, 0, &decs.shadow_left.buffer); \
|
|
copy_vertical_region(window, src_y_start, src_y_limit, dest_y_start, dest_y_limit, right_src_start, &decs.shadow_right.buffer); \
|
|
}
|
|
c(scaled_shadow_size, st.corner_size, y_start, top_end);
|
|
// bottom region
|
|
ssize_t bottom_start = MAX(0, y_end - src_leftover_corner);
|
|
c(st.stride - st.corner_size, st.stride - scaled_shadow_size, bottom_start, y_end);
|
|
// middle region
|
|
for (ssize_t dest_y = top_end; dest_y < bottom_start; dest_y += scaled_shadow_size)
|
|
c(st.corner_size, st.corner_size + scaled_shadow_size, dest_y, MIN(dest_y + scaled_shadow_size, bottom_start));
|
|
#undef c
|
|
|
|
#define copy(which) \
|
|
for (uint32_t *src = (uint32_t *)decs.which.buffer.data.front, *dest = (uint32_t *)decs.which.buffer.data.back; \
|
|
src < (uint32_t *)(decs.which.buffer.data.front + decs.which.buffer.size_in_bytes); \
|
|
src++, dest++) \
|
|
*dest = (A(*src) / 2) << 24;
|
|
all_shadow_surfaces(copy);
|
|
#undef copy
|
|
}
|
|
#undef st
|
|
|
|
static bool
|
|
create_shm_buffers(_GLFWwindow *window) {
|
|
decs.mapping.size = 0;
|
|
const bool has_titlebar = !decs.titlebar_hidden;
|
|
const int side_height = window->wl.height + (has_titlebar ? decs.metrics.visible_titlebar_height : 0);
|
|
#define bp(which, width, height) decs.mapping.size += init_buffer_pair(&decs.which.buffer, width, height, decs.for_window_state.fscale);
|
|
if (has_titlebar) bp(titlebar, window->wl.width, decs.metrics.visible_titlebar_height);
|
|
bp(shadow_top, window->wl.width, decs.metrics.width);
|
|
bp(shadow_bottom, window->wl.width, decs.metrics.width);
|
|
bp(shadow_left, decs.metrics.width, side_height);
|
|
bp(shadow_right, decs.metrics.width, side_height);
|
|
bp(shadow_upper_left, decs.metrics.width, decs.metrics.width);
|
|
bp(shadow_upper_right, decs.metrics.width, decs.metrics.width);
|
|
bp(shadow_lower_left, decs.metrics.width, decs.metrics.width);
|
|
bp(shadow_lower_right, decs.metrics.width, decs.metrics.width);
|
|
#undef bp
|
|
|
|
int fd = createAnonymousFile(decs.mapping.size);
|
|
if (fd < 0) {
|
|
_glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: Creating a buffer file for %zu B failed: %s", decs.mapping.size, strerror(errno));
|
|
return false;
|
|
}
|
|
decs.mapping.data = mmap(NULL, decs.mapping.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
|
if (decs.mapping.data == MAP_FAILED) {
|
|
_glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: mmap failed: %s", strerror(errno));
|
|
close(fd);
|
|
return false;
|
|
}
|
|
struct wl_shm_pool *pool = wl_shm_create_pool(_glfw.wl.shm, fd, decs.mapping.size);
|
|
close(fd);
|
|
size_t offset = 0;
|
|
#define Q(which) alloc_buffer_pair(window->id, &decs.which.buffer, pool, decs.mapping.data, &offset)
|
|
if (has_titlebar) Q(titlebar);
|
|
all_shadow_surfaces(Q);
|
|
#undef Q
|
|
wl_shm_pool_destroy(pool);
|
|
if (has_titlebar) render_title_bar(window, true);
|
|
render_shadows(window);
|
|
debug("Created decoration buffers at scale: %f\n", decs.for_window_state.fscale);
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
free_csd_surface(_GLFWWaylandCSDSurface *s) {
|
|
if (decoration_touch.active && decoration_touch.surface == s->surface) memset(&decoration_touch, 0, sizeof(decoration_touch));
|
|
if (s->subsurface) wl_subsurface_destroy(s->subsurface);
|
|
s->subsurface = NULL;
|
|
if (s->wp_viewport) wp_viewport_destroy(s->wp_viewport);
|
|
s->wp_viewport = NULL;
|
|
if (s->surface) wl_surface_destroy(s->surface);
|
|
s->surface = NULL;
|
|
}
|
|
|
|
static void
|
|
free_csd_surfaces(_GLFWwindow *window) {
|
|
#define Q(which) free_csd_surface(&decs.which)
|
|
all_surfaces(Q);
|
|
#undef Q
|
|
}
|
|
|
|
static void
|
|
free_csd_buffers(_GLFWwindow *window) {
|
|
#define Q(which) \
|
|
{ \
|
|
/* Busy buffers are destroyed when released, as destroying them now */ \
|
|
/* causes flicker. Mutter never releases buffers that are not busy. */ \
|
|
if (decs.which.buffer.a && !decs.which.buffer.a_busy) wl_buffer_destroy(decs.which.buffer.a); \
|
|
if (decs.which.buffer.b && !decs.which.buffer.b_busy) wl_buffer_destroy(decs.which.buffer.b); \
|
|
memset(&decs.which.buffer, 0, sizeof(_GLFWWaylandBufferPair)); \
|
|
}
|
|
all_surfaces(Q);
|
|
#undef Q
|
|
if (decs.mapping.data) munmap(decs.mapping.data, decs.mapping.size);
|
|
decs.mapping.data = NULL;
|
|
decs.mapping.size = 0;
|
|
}
|
|
|
|
static void
|
|
position_csd_surface(_GLFWWaylandCSDSurface *s, int x, int y) {
|
|
if (s->surface) {
|
|
wl_surface_set_buffer_scale(s->surface, 1);
|
|
s->x = x;
|
|
s->y = y;
|
|
wl_subsurface_set_position(s->subsurface, s->x, s->y);
|
|
}
|
|
}
|
|
|
|
static void
|
|
create_csd_surfaces(_GLFWwindow *window, _GLFWWaylandCSDSurface *s) {
|
|
if (s->surface) wl_surface_destroy(s->surface);
|
|
s->surface = wl_compositor_create_surface(_glfw.wl.compositor);
|
|
wl_surface_set_user_data(s->surface, window);
|
|
if (s->subsurface) wl_subsurface_destroy(s->subsurface);
|
|
s->subsurface = wl_subcompositor_get_subsurface(_glfw.wl.subcompositor, s->surface, window->wl.surface);
|
|
if (_glfw.wl.wp_viewporter) {
|
|
if (s->wp_viewport) wp_viewport_destroy(s->wp_viewport);
|
|
s->wp_viewport = wp_viewporter_get_viewport(_glfw.wl.wp_viewporter, s->surface);
|
|
}
|
|
}
|
|
|
|
#define damage_csd(which, xbuffer) \
|
|
if (decs.which.surface) { \
|
|
wl_surface_attach(decs.which.surface, (xbuffer), 0, 0); \
|
|
if (decs.which.wp_viewport) wp_viewport_set_destination(decs.which.wp_viewport, decs.which.buffer.viewport_width, decs.which.buffer.viewport_height); \
|
|
wl_surface_damage(decs.which.surface, 0, 0, decs.which.buffer.width, decs.which.buffer.height); \
|
|
wl_surface_commit(decs.which.surface); \
|
|
if (decs.which.buffer.a == (xbuffer)) { \
|
|
decs.which.buffer.a_busy = true; \
|
|
} else { \
|
|
decs.which.buffer.b_busy = true; \
|
|
} \
|
|
}
|
|
|
|
static bool
|
|
window_is_csd_capable(_GLFWwindow *window) {
|
|
return window->decorated && !decs.serverSide && window->wl.xdg.toplevel;
|
|
}
|
|
|
|
bool
|
|
csd_should_window_be_decorated(_GLFWwindow *window) {
|
|
return window_is_csd_capable(window) && window->monitor == NULL && (window->wl.current.toplevel_states & TOPLEVEL_STATE_FULLSCREEN) == 0;
|
|
}
|
|
|
|
static bool
|
|
ensure_csd_resources(_GLFWwindow *window) {
|
|
// Never create decorations for windows that should not have them, such
|
|
// as fullscreen windows, even if the stored state is stale
|
|
if (!csd_should_window_be_decorated(window)) return false;
|
|
const bool has_titlebar = !decs.titlebar_hidden;
|
|
const bool is_focused = window->id == _glfw.focusedWindowId;
|
|
const bool focus_changed = is_focused != decs.for_window_state.focused;
|
|
const double current_scale = _glfwWaylandWindowScale(window);
|
|
const bool size_changed =
|
|
(decs.for_window_state.width != window->wl.width || decs.for_window_state.height != window->wl.height ||
|
|
decs.for_window_state.fscale != current_scale || !decs.mapping.data ||
|
|
(has_titlebar && decs.titlebar.buffer.viewport_height != decs.metrics.visible_titlebar_height));
|
|
// The activated state is ignored as focus is tracked separately via
|
|
// keyboard focus, otherwise every focus change would render the
|
|
// decorations twice, once for keyboard focus and once for the configure
|
|
const uint32_t ignored_states = TOPLEVEL_STATE_ACTIVATED;
|
|
const bool state_changed = (decs.for_window_state.toplevel_states & ~ignored_states) != (window->wl.current.toplevel_states & ~ignored_states);
|
|
const bool titlebar_state_changed = (has_titlebar && !decs.titlebar.surface) || (!has_titlebar && decs.titlebar.surface);
|
|
// The surfaces are destroyed when the decorations are hidden, for example,
|
|
// when going fullscreen, without the state above changing
|
|
const bool surfaces_missing = !decs.shadow_top.surface;
|
|
const bool needs_update = focus_changed || size_changed || titlebar_state_changed || state_changed || surfaces_missing;
|
|
debug(
|
|
"CSD: old.size: %dx%d new.size: %dx%d needs_update: %d size_changed: %d state_changed: %d\n",
|
|
decs.for_window_state.width,
|
|
decs.for_window_state.height,
|
|
window->wl.width,
|
|
window->wl.height,
|
|
needs_update,
|
|
size_changed,
|
|
state_changed);
|
|
if (!needs_update) return false;
|
|
decs.for_window_state.fscale = current_scale; // used in create_shm_buffers
|
|
if (size_changed || titlebar_state_changed) {
|
|
if (titlebar_state_changed) {
|
|
free(decs.shadow_tile.data);
|
|
decs.shadow_tile.data = NULL;
|
|
}
|
|
free_csd_buffers(window);
|
|
if (!create_shm_buffers(window)) return false;
|
|
}
|
|
|
|
const int top_y = has_titlebar ? -(int)decs.metrics.visible_titlebar_height : 0;
|
|
|
|
#define setup_surface(which, x, y) \
|
|
if (!decs.which.surface) create_csd_surfaces(window, &decs.which); \
|
|
position_csd_surface(&decs.which, x, y);
|
|
|
|
if (has_titlebar) {
|
|
setup_surface(titlebar, 0, -decs.metrics.visible_titlebar_height);
|
|
} else {
|
|
free_csd_surface(&decs.titlebar);
|
|
if (decs.focus == CSD_titlebar) {
|
|
decs.focus = CENTRAL_WINDOW;
|
|
decs.dragging = false;
|
|
}
|
|
}
|
|
setup_surface(shadow_top, 0, top_y - decs.metrics.width);
|
|
setup_surface(shadow_bottom, 0, window->wl.height);
|
|
setup_surface(shadow_left, -decs.metrics.width, top_y);
|
|
setup_surface(shadow_right, window->wl.width, decs.shadow_left.y);
|
|
setup_surface(shadow_upper_left, decs.shadow_left.x, decs.shadow_top.y);
|
|
setup_surface(shadow_upper_right, decs.shadow_right.x, decs.shadow_top.y);
|
|
setup_surface(shadow_lower_left, decs.shadow_left.x, decs.shadow_bottom.y);
|
|
setup_surface(shadow_lower_right, decs.shadow_right.x, decs.shadow_bottom.y);
|
|
|
|
if (has_titlebar) {
|
|
if (focus_changed || state_changed) update_title_bar(window);
|
|
damage_csd(titlebar, decs.titlebar.buffer.front);
|
|
}
|
|
#define d(which) damage_csd(which, is_focused ? decs.which.buffer.front : decs.which.buffer.back);
|
|
d(shadow_left);
|
|
d(shadow_right);
|
|
d(shadow_top);
|
|
d(shadow_bottom);
|
|
d(shadow_upper_left);
|
|
d(shadow_upper_right);
|
|
d(shadow_lower_left);
|
|
d(shadow_lower_right);
|
|
#undef d
|
|
|
|
decs.for_window_state.width = window->wl.width;
|
|
decs.for_window_state.height = window->wl.height;
|
|
decs.for_window_state.focused = is_focused;
|
|
decs.for_window_state.toplevel_states = window->wl.current.toplevel_states;
|
|
return true;
|
|
}
|
|
|
|
void
|
|
csd_set_visible(_GLFWwindow *window, bool visible) {
|
|
// When setting to visible will only take effect if window currently has
|
|
// CSD and will also ensure CSD is of correct size and type for current window.
|
|
// When hiding CSD simply destroys all CSD surfaces.
|
|
if (visible) ensure_csd_resources(window);
|
|
else free_csd_surfaces(window);
|
|
}
|
|
|
|
void
|
|
csd_free_all_resources(_GLFWwindow *window) {
|
|
free_csd_surfaces(window);
|
|
free_csd_buffers(window);
|
|
if (decs.shadow_tile.data) free(decs.shadow_tile.data);
|
|
decs.shadow_tile.data = NULL;
|
|
}
|
|
|
|
bool
|
|
csd_change_title(_GLFWwindow *window) {
|
|
if (!window_is_csd_capable(window)) return false;
|
|
if (ensure_csd_resources(window)) return true; // CSD were re-rendered for other reasons
|
|
if (decs.titlebar.surface) {
|
|
update_title_bar(window);
|
|
damage_csd(titlebar, decs.titlebar.buffer.front);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
csd_handle_focus_change(_GLFWwindow *window) {
|
|
// Keyboard focus changes are not necessarily accompanied by a configure
|
|
// event, which is what usually causes the decorations to be re-rendered.
|
|
// Returns true if the window surface needs to be committed.
|
|
return ensure_csd_resources(window);
|
|
}
|
|
|
|
static void
|
|
on_titlebar_buffer_released(_GLFWwindow *window) {
|
|
if (!decs.titlebar.buffer.has_pending_update || !decs.titlebar.surface || !window_is_csd_capable(window)) return;
|
|
if (update_title_bar(window)) {
|
|
damage_csd(titlebar, decs.titlebar.buffer.front);
|
|
if (!window->wl.waiting_for_swap_to_commit) wl_surface_commit(window->wl.surface);
|
|
}
|
|
}
|
|
|
|
void
|
|
csd_set_window_geometry(_GLFWwindow *window, int32_t *width, int32_t *height) {
|
|
const bool include_space_for_csd = csd_should_window_be_decorated(window);
|
|
const bool has_titlebar = include_space_for_csd && !decs.titlebar_hidden;
|
|
bool size_specified_by_compositor = *width > 0 && *height > 0;
|
|
if (!size_specified_by_compositor) {
|
|
*width = window->wl.user_requested_content_size.width;
|
|
*height = window->wl.user_requested_content_size.height;
|
|
if (window->wl.xdg.top_level_bounds.width > 0) *width = MIN(*width, window->wl.xdg.top_level_bounds.width);
|
|
if (window->wl.xdg.top_level_bounds.height > 0) *height = MIN(*height, window->wl.xdg.top_level_bounds.height);
|
|
if (has_titlebar) *height += decs.metrics.visible_titlebar_height;
|
|
}
|
|
decs.geometry.x = 0;
|
|
decs.geometry.y = 0;
|
|
decs.geometry.width = *width;
|
|
decs.geometry.height = *height;
|
|
if (has_titlebar) {
|
|
decs.geometry.y = -decs.metrics.visible_titlebar_height;
|
|
*height -= decs.metrics.visible_titlebar_height;
|
|
}
|
|
}
|
|
|
|
bool
|
|
csd_set_titlebar_color(_GLFWwindow *window, uint32_t color, bool use_system_color) {
|
|
bool use_custom_color = !use_system_color;
|
|
decs.use_custom_titlebar_color = use_custom_color;
|
|
decs.titlebar_color = color;
|
|
return csd_change_title(window);
|
|
}
|
|
|
|
#define x window->wl.allCursorPosX
|
|
#define y window->wl.allCursorPosY
|
|
|
|
static void
|
|
set_cursor(GLFWCursorShape shape, _GLFWwindow *window) {
|
|
if (_glfw.wl.wp_cursor_shape_device_v1) {
|
|
wayland_cursor_shape s = glfw_cursor_shape_to_wayland_cursor_shape(shape);
|
|
if (s.which > -1) {
|
|
debug("Changing cursor shape to: %s with serial: %u\n", s.name, _glfw.wl.pointer_enter_serial);
|
|
wp_cursor_shape_device_v1_set_shape(_glfw.wl.wp_cursor_shape_device_v1, _glfw.wl.pointer_enter_serial, (uint32_t)s.which);
|
|
return;
|
|
}
|
|
}
|
|
|
|
struct wl_buffer *buffer;
|
|
struct wl_cursor *cursor;
|
|
struct wl_cursor_image *image;
|
|
struct wl_surface *surface = _glfw.wl.cursorSurface;
|
|
const int scale = _glfwWaylandIntegerWindowScale(window);
|
|
|
|
struct wl_cursor_theme *theme = glfw_wlc_theme_for_scale(scale);
|
|
if (!theme) return;
|
|
cursor = _glfwLoadCursor(shape, theme);
|
|
if (!cursor || !cursor->images) return;
|
|
image = cursor->images[0];
|
|
if (!image) return;
|
|
if (image->width % scale || image->height % scale) {
|
|
static uint32_t warned_width = 0, warned_height = 0;
|
|
if (warned_width != image->width || warned_height != image->height) {
|
|
_glfwInputError(
|
|
GLFW_PLATFORM_ERROR,
|
|
"WARNING: Cursor image size: %dx%d is not a multiple of window scale: %d. This will"
|
|
" cause some compositors such as GNOME to crash. See https://github.com/kovidgoyal/kitty/issues/4878",
|
|
image->width,
|
|
image->height,
|
|
scale);
|
|
warned_width = image->width;
|
|
warned_height = image->height;
|
|
}
|
|
}
|
|
|
|
buffer = wl_cursor_image_get_buffer(image);
|
|
if (!buffer) return;
|
|
debug("Calling wl_pointer_set_cursor in set_cursor with surface: %p\n", (void *)surface);
|
|
wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.serial, surface, image->hotspot_x / scale, image->hotspot_y / scale);
|
|
wl_surface_set_buffer_scale(surface, scale);
|
|
wl_surface_attach(surface, buffer, 0, 0);
|
|
wl_surface_damage(surface, 0, 0, image->width, image->height);
|
|
wl_surface_commit(surface);
|
|
_glfw.wl.cursorPreviousShape = shape;
|
|
}
|
|
|
|
|
|
static bool
|
|
update_hovered_button(_GLFWwindow *window) {
|
|
const GLFWTitlebarButton hovered = titlebar_button_at_x(window, x);
|
|
#define c(which, button) \
|
|
if (hovered == button) { \
|
|
if (!decs.which.hovered) { \
|
|
decs.titlebar_needs_update = true; \
|
|
decs.which.hovered = true; \
|
|
} \
|
|
} else if (decs.which.hovered) { \
|
|
decs.titlebar_needs_update = true; \
|
|
decs.which.hovered = false; \
|
|
}
|
|
|
|
c(minimize, TITLEBAR_BUTTON_MINIMIZE);
|
|
c(maximize, TITLEBAR_BUTTON_MAXIMIZE);
|
|
c(close, TITLEBAR_BUTTON_CLOSE);
|
|
#undef c
|
|
return hovered != TITLEBAR_BUTTON_NONE;
|
|
}
|
|
|
|
static bool
|
|
has_hovered_button(_GLFWwindow *window) {
|
|
return decs.minimize.hovered || decs.maximize.hovered || decs.close.hovered;
|
|
}
|
|
|
|
static void
|
|
handle_pointer_leave(_GLFWwindow *window, struct wl_surface *surface) {
|
|
#define c(which) \
|
|
if (decs.which.hovered) { \
|
|
decs.titlebar_needs_update = true; \
|
|
decs.which.hovered = false; \
|
|
}
|
|
if (surface == decs.titlebar.surface) {
|
|
c(minimize);
|
|
c(maximize);
|
|
c(close);
|
|
}
|
|
#undef c
|
|
decs.focus = CENTRAL_WINDOW;
|
|
decs.pressed_button = TITLEBAR_BUTTON_NONE;
|
|
decs.dragging = false;
|
|
}
|
|
|
|
|
|
static void
|
|
handle_pointer_move(_GLFWwindow *window) {
|
|
GLFWCursorShape cursorShape = GLFW_DEFAULT_CURSOR;
|
|
switch (decs.focus) {
|
|
case CENTRAL_WINDOW: break;
|
|
case CSD_titlebar: {
|
|
if (decs.dragging) {
|
|
if (window->wl.xdg.toplevel) xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, _glfw.wl.pointer_serial);
|
|
} else if (update_hovered_button(window)) cursorShape = GLFW_POINTER_CURSOR;
|
|
} break;
|
|
case CSD_shadow_top: cursorShape = GLFW_N_RESIZE_CURSOR; break;
|
|
case CSD_shadow_bottom: cursorShape = GLFW_S_RESIZE_CURSOR; break;
|
|
case CSD_shadow_left: cursorShape = GLFW_W_RESIZE_CURSOR; break;
|
|
case CSD_shadow_right: cursorShape = GLFW_E_RESIZE_CURSOR; break;
|
|
case CSD_shadow_upper_left: cursorShape = GLFW_NW_RESIZE_CURSOR; break;
|
|
case CSD_shadow_upper_right: cursorShape = GLFW_NE_RESIZE_CURSOR; break;
|
|
case CSD_shadow_lower_left: cursorShape = GLFW_SW_RESIZE_CURSOR; break;
|
|
case CSD_shadow_lower_right: cursorShape = GLFW_SE_RESIZE_CURSOR; break;
|
|
}
|
|
if (_glfw.wl.cursorPreviousShape != cursorShape) set_cursor(cursorShape, window);
|
|
}
|
|
|
|
static void
|
|
handle_pointer_enter(_GLFWwindow *window, struct wl_surface *surface) {
|
|
decs.focus = decoration_surface(window, surface);
|
|
if (decs.focus != CENTRAL_WINDOW) handle_pointer_move(window);
|
|
else decs.dragging = false;
|
|
}
|
|
|
|
static void
|
|
perform_titlebar_action(_GLFWwindow *window, GLFWTitlebarAction action) {
|
|
switch (action) {
|
|
case TITLEBAR_ACTION_MENU:
|
|
if (!window->wl.xdg.toplevel) break;
|
|
if (window->wl.wm_capabilities.window_menu)
|
|
xdg_toplevel_show_window_menu(window->wl.xdg.toplevel, _glfw.wl.seat, _glfw.wl.pointer_serial, (int32_t)x, (int32_t)y - decs.metrics.top);
|
|
else _glfwInputError(GLFW_PLATFORM_ERROR, "Wayland compositor does not support showing window menu");
|
|
break;
|
|
case TITLEBAR_ACTION_MAXIMIZE:
|
|
if (window->wl.wm_capabilities.maximize) {
|
|
if (window->wl.current.toplevel_states & TOPLEVEL_STATE_MAXIMIZED) _glfwPlatformRestoreWindow(window);
|
|
else _glfwPlatformMaximizeWindow(window);
|
|
}
|
|
break;
|
|
case TITLEBAR_ACTION_MINIMIZE:
|
|
if (window->wl.wm_capabilities.minimize) _glfwPlatformIconifyWindow(window);
|
|
break;
|
|
case TITLEBAR_ACTION_NONE: break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
handle_pointer_button(_GLFWwindow *window, uint32_t button, uint32_t state) {
|
|
uint32_t edges = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
|
|
if (button == BTN_LEFT) {
|
|
switch (decs.focus) {
|
|
case CENTRAL_WINDOW: break;
|
|
case CSD_titlebar:
|
|
if (has_hovered_button(window) || decs.pressed_button) {
|
|
const GLFWTitlebarButton hovered = titlebar_button_at_x(window, x);
|
|
decs.dragging = false;
|
|
decs.titlebar_needs_update = true;
|
|
decs.last_click_on_top_decoration_at = 0;
|
|
if (state == WL_POINTER_BUTTON_STATE_PRESSED) decs.pressed_button = hovered;
|
|
else {
|
|
const GLFWTitlebarButton pressed = decs.pressed_button;
|
|
decs.pressed_button = TITLEBAR_BUTTON_NONE;
|
|
if (pressed == hovered) activate_titlebar_button(window, pressed);
|
|
}
|
|
break;
|
|
}
|
|
if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
|
|
monotonic_t last_click_at = decs.last_click_on_top_decoration_at;
|
|
decs.last_click_on_top_decoration_at = monotonic();
|
|
if (decs.last_click_on_top_decoration_at - last_click_at <= _glfwPlatformGetDoubleClickInterval(window)) {
|
|
decs.last_click_on_top_decoration_at = 0;
|
|
perform_titlebar_action(window, glfw_current_titlebar_action(TITLEBAR_GESTURE_DOUBLE_CLICK));
|
|
return;
|
|
}
|
|
}
|
|
decs.dragging = !has_hovered_button(window);
|
|
break;
|
|
default: edges = decoration_resize_edges(decs.focus); break;
|
|
}
|
|
if (edges != XDG_TOPLEVEL_RESIZE_EDGE_NONE) xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat, _glfw.wl.pointer_serial, edges);
|
|
} else if ((button == BTN_RIGHT || button == BTN_MIDDLE) && state == WL_POINTER_BUTTON_STATE_PRESSED) {
|
|
if (decs.focus == CSD_titlebar)
|
|
perform_titlebar_action(window, glfw_current_titlebar_action(button == BTN_MIDDLE ? TITLEBAR_GESTURE_MIDDLE_CLICK : TITLEBAR_GESTURE_RIGHT_CLICK));
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
commit_titlebar_update(_GLFWwindow *window) {
|
|
csd_change_title(window);
|
|
if (!window->wl.waiting_for_swap_to_commit) wl_surface_commit(window->wl.surface);
|
|
}
|
|
|
|
void
|
|
csd_handle_pointer_event(_GLFWwindow *window, int button, int state, struct wl_surface *surface) {
|
|
if (!window_is_csd_capable(window)) return;
|
|
decs.titlebar_needs_update = false;
|
|
switch (button) {
|
|
case -1: handle_pointer_move(window); break;
|
|
case -2: handle_pointer_enter(window, surface); break;
|
|
case -3: handle_pointer_leave(window, surface); break;
|
|
default: handle_pointer_button(window, button, state); break;
|
|
}
|
|
if (decs.titlebar_needs_update) commit_titlebar_update(window);
|
|
}
|
|
#undef x
|
|
#undef y
|
|
|
|
// Called for every touch down, wherever it lands. A contact id is only reused
|
|
// after its previous sequence ended, so a tracked contact with this id is
|
|
// stale, its up was never delivered.
|
|
void
|
|
csd_drop_stale_touch(int32_t id) {
|
|
if (decoration_touch.active && decoration_touch.id == id) csd_handle_touch_cancel();
|
|
}
|
|
|
|
bool
|
|
csd_is_tracking_touch(int32_t id) {
|
|
return decoration_touch.active && decoration_touch.id == id;
|
|
}
|
|
|
|
bool
|
|
csd_handle_touch_down(_GLFWwindow *window, struct wl_surface *surface, int32_t id, uint32_t serial, double sx, double sy) {
|
|
if (!csd_should_window_be_decorated(window) || !window->wl.xdg.toplevel) return false;
|
|
const _GLFWCSDSurface which = decoration_surface(window, surface);
|
|
if (which == CENTRAL_WINDOW) return false;
|
|
const GLFWTitlebarButton button = which == CSD_titlebar ? titlebar_button_at(window, sx, sy) : TITLEBAR_BUTTON_NONE;
|
|
if (button == TITLEBAR_BUTTON_NONE) {
|
|
// Interactive requests require this contact's original down serial.
|
|
// The contact is not tracked as the compositor takes it over and need
|
|
// not send its up event to us.
|
|
const uint32_t edges = decoration_resize_edges(which);
|
|
if (edges != XDG_TOPLEVEL_RESIZE_EDGE_NONE) xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat, serial, edges);
|
|
else xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
|
|
return true;
|
|
}
|
|
// Only one titlebar button press is tracked at a time, other button
|
|
// presses are ignored while it is down
|
|
if (decoration_touch.active) return true;
|
|
decoration_touch.active = true;
|
|
decoration_touch.id = id;
|
|
decoration_touch.window_id = window->id;
|
|
decoration_touch.surface = surface;
|
|
decoration_touch.x = sx;
|
|
decoration_touch.y = sy;
|
|
decoration_touch.button = button;
|
|
commit_titlebar_update(window);
|
|
return true;
|
|
}
|
|
|
|
void
|
|
csd_handle_touch_motion(int32_t id, double sx, double sy) {
|
|
if (!csd_is_tracking_touch(id)) return;
|
|
_GLFWwindow *window = _glfwWindowForId(decoration_touch.window_id);
|
|
if (!window) {
|
|
memset(&decoration_touch, 0, sizeof(decoration_touch));
|
|
return;
|
|
}
|
|
const GLFWTitlebarButton button = decoration_touch.button;
|
|
const bool was_on_button = titlebar_button_at(window, decoration_touch.x, decoration_touch.y) == button;
|
|
decoration_touch.x = sx;
|
|
decoration_touch.y = sy;
|
|
if (was_on_button != (titlebar_button_at(window, sx, sy) == button)) commit_titlebar_update(window);
|
|
}
|
|
|
|
void
|
|
csd_handle_touch_cancel(void) {
|
|
if (!decoration_touch.active) return;
|
|
_GLFWwindow *window = _glfwWindowForId(decoration_touch.window_id);
|
|
memset(&decoration_touch, 0, sizeof(decoration_touch));
|
|
if (window) commit_titlebar_update(window);
|
|
}
|
|
|
|
void
|
|
csd_handle_touch_up(int32_t id) {
|
|
if (!csd_is_tracking_touch(id)) return;
|
|
_GLFWwindow *window = _glfwWindowForId(decoration_touch.window_id);
|
|
const GLFWTitlebarButton pressed = decoration_touch.button;
|
|
const bool activate = window && csd_should_window_be_decorated(window) && pressed == titlebar_button_at(window, decoration_touch.x, decoration_touch.y);
|
|
// The close callback can destroy the window. Clear the contact first.
|
|
csd_handle_touch_cancel();
|
|
if (activate) activate_titlebar_button(window, pressed);
|
|
}
|