mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
glfwGetWaylandCurrentMonitorFractionalScale() looped on wl_display_roundtrip() until every monitor had received xdg_output logical size and position, with no limit. Compositors do not send these for an xdg_output created on an output whose global has just been removed, so kitty would hang forever when creating a new OS window after output churn. Bound the wait to a few roundtrips and remember monitors for which we gave up so we dont wait on them again. Re-lookup monitors after each roundtrip, since a dispatched global_remove can free them. Also track outputs that have been bound but not yet announced via wl_output.done, so that a global_remove arriving before done frees them instead of the dead output being announced later and living in the monitor list forever.
465 lines
17 KiB
C
Vendored
465 lines
17 KiB
C
Vendored
//========================================================================
|
|
// GLFW 3.4 Wayland - www.glfw.org
|
|
//------------------------------------------------------------------------
|
|
// Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
|
|
//
|
|
// This software is provided 'as-is', without any express or implied
|
|
// warranty. In no event will the authors be held liable for any damages
|
|
// arising from the use of this software.
|
|
//
|
|
// Permission is granted to anyone to use this software for any purpose,
|
|
// including commercial applications, and to alter it and redistribute it
|
|
// freely, subject to the following restrictions:
|
|
//
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
|
// claim that you wrote the original software. If you use this software
|
|
// in a product, an acknowledgment in the product documentation would
|
|
// be appreciated but is not required.
|
|
//
|
|
// 2. Altered source versions must be plainly marked as such, and must not
|
|
// be misrepresented as being the original software.
|
|
//
|
|
// 3. This notice may not be removed or altered from any source
|
|
// distribution.
|
|
//
|
|
//========================================================================
|
|
// It is fine to use C99 in this file because it will not be built with VS
|
|
//========================================================================
|
|
|
|
#include "internal.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <assert.h>
|
|
|
|
|
|
static void
|
|
outputHandleGeometry(
|
|
void *data,
|
|
struct wl_output *output UNUSED,
|
|
int32_t x,
|
|
int32_t y,
|
|
int32_t physicalWidth,
|
|
int32_t physicalHeight,
|
|
int32_t subpixel UNUSED,
|
|
const char *make UNUSED,
|
|
const char *model UNUSED,
|
|
int32_t transform) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
monitor->wl.x = x;
|
|
monitor->wl.y = y;
|
|
monitor->widthMM = physicalWidth;
|
|
monitor->heightMM = physicalHeight;
|
|
monitor->wl.transform = transform;
|
|
}
|
|
|
|
static void
|
|
outputHandleMode(void *data, struct wl_output *output UNUSED, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
GLFWvidmode mode;
|
|
|
|
mode.width = width;
|
|
mode.height = height;
|
|
mode.redBits = 8;
|
|
mode.greenBits = 8;
|
|
mode.blueBits = 8;
|
|
mode.refreshRate = (int)round(refresh / 1000.0);
|
|
|
|
monitor->modeCount++;
|
|
monitor->modes = realloc(monitor->modes, monitor->modeCount * sizeof(GLFWvidmode));
|
|
monitor->modes[monitor->modeCount - 1] = mode;
|
|
|
|
if (flags & WL_OUTPUT_MODE_CURRENT) monitor->wl.currentMode = monitor->modeCount - 1;
|
|
}
|
|
|
|
static bool
|
|
removePendingMonitor(_GLFWmonitor *monitor) {
|
|
for (int i = 0; i < _glfw.wl.pending_monitors.count; i++) {
|
|
if (_glfw.wl.pending_monitors.array[i] == monitor) {
|
|
remove_i_from_array(_glfw.wl.pending_monitors.array, i, _glfw.wl.pending_monitors.count);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void
|
|
outputHandleDone(void *data, struct wl_output *output UNUSED) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
// Only monitors still pending need to be announced, done is re-sent
|
|
// whenever output properties change.
|
|
if (removePendingMonitor(monitor)) _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
|
|
}
|
|
|
|
static void
|
|
outputHandleScale(void *data, struct wl_output *output UNUSED, int32_t factor) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
if (factor > 0 && factor < 24) monitor->wl.scale = factor;
|
|
}
|
|
|
|
static void
|
|
outputHandleName(void *data, struct wl_output *output UNUSED, const char *name) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
if (name) {
|
|
if (monitor->name) free((void *)monitor->name);
|
|
monitor->name = _glfw_strdup(name);
|
|
}
|
|
}
|
|
|
|
static void
|
|
outputHandleDescription(void *data, struct wl_output *output UNUSED, const char *description) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
if (description) {
|
|
if (monitor->description) free((void *)monitor->description);
|
|
monitor->description = _glfw_strdup(description);
|
|
}
|
|
}
|
|
|
|
static const struct wl_output_listener outputListener = {
|
|
outputHandleGeometry,
|
|
outputHandleMode,
|
|
outputHandleDone,
|
|
outputHandleScale,
|
|
outputHandleName,
|
|
outputHandleDescription,
|
|
};
|
|
|
|
|
|
static void
|
|
xdgOutputHandleLogicalPosition(void *data, struct zxdg_output_v1 *xdg_output UNUSED, int32_t x, int32_t y) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
monitor->wl.x = x;
|
|
monitor->wl.y = y;
|
|
monitor->wl.xdg_position_received = true;
|
|
}
|
|
|
|
static void
|
|
xdgOutputHandleLogicalSize(void *data, struct zxdg_output_v1 *xdg_output UNUSED, int32_t width, int32_t height) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
monitor->wl.xdg_logical_width = width;
|
|
monitor->wl.xdg_logical_height = height;
|
|
monitor->wl.xdg_size_received = true;
|
|
}
|
|
|
|
static void
|
|
computeXdgFractionalScale(struct _GLFWmonitor *monitor) {
|
|
if (monitor->wl.xdg_logical_width <= 0 || monitor->wl.xdg_logical_height <= 0) return;
|
|
if (monitor->modeCount == 0 || monitor->wl.currentMode < 0) return;
|
|
GLFWvidmode *mode = &monitor->modes[monitor->wl.currentMode];
|
|
if (mode->width <= 0 || mode->height <= 0) return;
|
|
|
|
// For 90° and 270° rotations the compositor maps physical width↔height,
|
|
// so use the swapped axis when dividing by the logical size.
|
|
int phys_w = mode->width, phys_h = mode->height;
|
|
int32_t t = monitor->wl.transform;
|
|
if (t == WL_OUTPUT_TRANSFORM_90 || t == WL_OUTPUT_TRANSFORM_270 || t == WL_OUTPUT_TRANSFORM_FLIPPED_90 || t == WL_OUTPUT_TRANSFORM_FLIPPED_270) {
|
|
int tmp = phys_w;
|
|
phys_w = phys_h;
|
|
phys_h = tmp;
|
|
}
|
|
|
|
double sx = (double)phys_w / monitor->wl.xdg_logical_width;
|
|
double sy = (double)phys_h / monitor->wl.xdg_logical_height;
|
|
// Use the average in case of minor rounding differences between axes.
|
|
monitor->wl.fractional_scale = (sx + sy) * 0.5;
|
|
}
|
|
|
|
static void
|
|
xdgOutputHandleDone(void *data, struct zxdg_output_v1 *xdg_output UNUSED) {
|
|
struct _GLFWmonitor *monitor = data;
|
|
computeXdgFractionalScale(monitor);
|
|
}
|
|
|
|
static void
|
|
xdgOutputHandleName(void *data, struct zxdg_output_v1 *xdg_output UNUSED, const char *name) {
|
|
// wl_output already provides the name; skip to avoid duplicate frees.
|
|
(void)data;
|
|
(void)name;
|
|
}
|
|
|
|
static void
|
|
xdgOutputHandleDescription(void *data, struct zxdg_output_v1 *xdg_output UNUSED, const char *description) {
|
|
(void)data;
|
|
(void)description;
|
|
}
|
|
|
|
static const struct zxdg_output_v1_listener xdgOutputListener = {
|
|
xdgOutputHandleLogicalPosition,
|
|
xdgOutputHandleLogicalSize,
|
|
xdgOutputHandleDone,
|
|
xdgOutputHandleName,
|
|
xdgOutputHandleDescription,
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
////// GLFW internal API //////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void
|
|
_glfwCreateXdgOutputWayland(_GLFWmonitor *monitor) {
|
|
if (!_glfw.wl.xdg_output_manager || monitor->wl.xdg_output) return;
|
|
monitor->wl.xdg_output = zxdg_output_manager_v1_get_xdg_output(_glfw.wl.xdg_output_manager, monitor->wl.output);
|
|
if (monitor->wl.xdg_output) zxdg_output_v1_add_listener(monitor->wl.xdg_output, &xdgOutputListener, monitor);
|
|
}
|
|
|
|
void
|
|
_glfwAddOutputWayland(uint32_t name, uint32_t version) {
|
|
_GLFWmonitor *monitor;
|
|
struct wl_output *output;
|
|
|
|
if (version < 2) {
|
|
_glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: Unsupported output interface version");
|
|
return;
|
|
}
|
|
|
|
// The actual name of this output will be set in the handlers.
|
|
monitor = _glfwAllocMonitor("unnamed", 0, 0);
|
|
|
|
output = wl_registry_bind(_glfw.wl.registry, name, &wl_output_interface, MIN(version, (unsigned)WL_OUTPUT_NAME_SINCE_VERSION));
|
|
if (!output) {
|
|
_glfwFreeMonitor(monitor);
|
|
return;
|
|
}
|
|
|
|
monitor->wl.scale = 1;
|
|
monitor->wl.output = output;
|
|
monitor->wl.name = name;
|
|
|
|
_GLFWmonitor **pending = realloc(_glfw.wl.pending_monitors.array, sizeof(pending[0]) * ((size_t)_glfw.wl.pending_monitors.count + 1));
|
|
if (!pending) {
|
|
_glfwInputError(GLFW_OUT_OF_MEMORY, "Wayland: Out of memory while adding output");
|
|
_glfwFreeMonitor(monitor);
|
|
return;
|
|
}
|
|
_glfw.wl.pending_monitors.array = pending;
|
|
_glfw.wl.pending_monitors.array[_glfw.wl.pending_monitors.count++] = monitor;
|
|
|
|
wl_output_add_listener(output, &outputListener, monitor);
|
|
_glfwCreateXdgOutputWayland(monitor);
|
|
}
|
|
|
|
// Handle removal of the wl_output global with the specified registry name.
|
|
// Returns true if an output was found and removed.
|
|
bool
|
|
_glfwRemoveOutputWayland(uint32_t name) {
|
|
// The global may be removed before wl_output.done is received, for
|
|
// example when an output is unplugged right after being plugged in. Such
|
|
// monitors were never announced, so just free them, otherwise they would
|
|
// be announced on a later done event despite being dead.
|
|
for (int i = 0; i < _glfw.wl.pending_monitors.count; i++) {
|
|
_GLFWmonitor *monitor = _glfw.wl.pending_monitors.array[i];
|
|
if (monitor->wl.name == name) {
|
|
remove_i_from_array(_glfw.wl.pending_monitors.array, i, _glfw.wl.pending_monitors.count);
|
|
_glfwFreeMonitor(monitor);
|
|
return true;
|
|
}
|
|
}
|
|
for (int i = 0; i < _glfw.monitorCount; ++i) {
|
|
_GLFWmonitor *monitor = _glfw.monitors[i];
|
|
if (monitor->wl.name == name) {
|
|
for (_GLFWwindow *window = _glfw.windowListHead; window; window = window->next) {
|
|
bool was_on_monitor = false;
|
|
for (int m = window->wl.monitorsCount - 1; m >= 0; m--) {
|
|
if (window->wl.monitors[m] == monitor) {
|
|
remove_i_from_array(window->wl.monitors, m, window->wl.monitorsCount);
|
|
was_on_monitor = true;
|
|
}
|
|
}
|
|
if (was_on_monitor) _glfwWaylandSurfaceOutputsChanged(window);
|
|
}
|
|
_glfwInputMonitor(monitor, GLFW_DISCONNECTED, 0);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
_glfwFreePendingOutputsWayland(void) {
|
|
for (int i = 0; i < _glfw.wl.pending_monitors.count; i++) _glfwFreeMonitor(_glfw.wl.pending_monitors.array[i]);
|
|
free(_glfw.wl.pending_monitors.array);
|
|
_glfw.wl.pending_monitors.array = NULL;
|
|
_glfw.wl.pending_monitors.count = 0;
|
|
}
|
|
|
|
void
|
|
_glfwCreateXdgOutputsWayland(void) {
|
|
for (int i = 0; i < _glfw.monitorCount; i++) _glfwCreateXdgOutputWayland(_glfw.monitors[i]);
|
|
for (int i = 0; i < _glfw.wl.pending_monitors.count; i++) _glfwCreateXdgOutputWayland(_glfw.wl.pending_monitors.array[i]);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
////// GLFW platform API //////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void
|
|
_glfwPlatformFreeMonitor(_GLFWmonitor *monitor) {
|
|
if (monitor->wl.xdg_output) zxdg_output_v1_destroy(monitor->wl.xdg_output);
|
|
if (monitor->wl.output) wl_output_destroy(monitor->wl.output);
|
|
}
|
|
|
|
void
|
|
_glfwPlatformGetMonitorPos(_GLFWmonitor *monitor, int *xpos, int *ypos) {
|
|
if (xpos) *xpos = monitor->wl.x;
|
|
if (ypos) *ypos = monitor->wl.y;
|
|
}
|
|
|
|
void
|
|
_glfwPlatformGetMonitorContentScale(_GLFWmonitor *monitor, float *xscale, float *yscale) {
|
|
float scale = monitor->wl.fractional_scale > 0.0 ? (float)monitor->wl.fractional_scale : (float)monitor->wl.scale;
|
|
if (xscale) *xscale = scale;
|
|
if (yscale) *yscale = scale;
|
|
}
|
|
|
|
void
|
|
_glfwPlatformGetMonitorWorkarea(_GLFWmonitor *monitor, int *xpos, int *ypos, int *width, int *height) {
|
|
if (xpos) *xpos = monitor->wl.x;
|
|
if (ypos) *ypos = monitor->wl.y;
|
|
if (width) *width = monitor->modes[monitor->wl.currentMode].width;
|
|
if (height) *height = monitor->modes[monitor->wl.currentMode].height;
|
|
}
|
|
|
|
GLFWvidmode *
|
|
_glfwPlatformGetVideoModes(_GLFWmonitor *monitor, int *found) {
|
|
*found = monitor->modeCount;
|
|
return monitor->modes;
|
|
}
|
|
|
|
bool
|
|
_glfwPlatformGetVideoMode(_GLFWmonitor *monitor, GLFWvidmode *mode) {
|
|
if (monitor->modeCount > monitor->wl.currentMode) {
|
|
*mode = monitor->modes[monitor->wl.currentMode];
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
_glfwPlatformGetGammaRamp(_GLFWmonitor *monitor UNUSED, GLFWgammaramp *ramp UNUSED) {
|
|
_glfwInputError(GLFW_FEATURE_UNAVAILABLE, "Wayland: Gamma ramp access is not available");
|
|
return false;
|
|
}
|
|
|
|
void
|
|
_glfwPlatformSetGammaRamp(_GLFWmonitor *monitor UNUSED, const GLFWgammaramp *ramp UNUSED) {
|
|
_glfwInputError(GLFW_FEATURE_UNAVAILABLE, "Wayland: Gamma ramp access is not available");
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
////// GLFW native API //////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
GLFWAPI struct wl_output *
|
|
glfwGetWaylandMonitor(GLFWmonitor *handle) {
|
|
_GLFWmonitor *monitor = (_GLFWmonitor *)handle;
|
|
assert(monitor != NULL);
|
|
|
|
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
return monitor->wl.output;
|
|
}
|
|
|
|
static _GLFWmonitor *
|
|
monitorForRegistryName(uint32_t name) {
|
|
for (int i = 0; i < _glfw.monitorCount; i++) {
|
|
if (_glfw.monitors[i]->wl.name == name) return _glfw.monitors[i];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static bool
|
|
needsXdgGeometry(const _GLFWmonitor *m) {
|
|
return m->wl.xdg_output && !m->wl.xdg_geometry_wait_abandoned && !(m->wl.xdg_size_received && m->wl.xdg_position_received);
|
|
}
|
|
|
|
// The compositor sends xdg_output logical geometry in response to
|
|
// get_xdg_output, so it is guaranteed to have arrived after a roundtrip,
|
|
// unless the compositor never sends it at all, for instance for an
|
|
// xdg_output created on an output that has just been removed. Use a few
|
|
// extra roundtrips for robustness, but never wait indefinitely.
|
|
#define MAX_XDG_GEOMETRY_ROUNDTRIPS 4
|
|
|
|
// Wait for xdg_output geometry for all monitors, or just the monitor with the
|
|
// specified registry name if only_name is non-zero. Monitors can be freed by
|
|
// events dispatched during a roundtrip, so they are looked up afresh after
|
|
// every roundtrip rather than holding pointers across them.
|
|
static void
|
|
waitForXdgGeometry(uint32_t only_name) {
|
|
for (int roundtrips = 0;; roundtrips++) {
|
|
bool waiting = false;
|
|
for (int i = 0; i < _glfw.monitorCount && !waiting; i++) {
|
|
_GLFWmonitor *m = _glfw.monitors[i];
|
|
if ((!only_name || m->wl.name == only_name) && needsXdgGeometry(m)) waiting = true;
|
|
}
|
|
if (!waiting) return;
|
|
if (roundtrips >= MAX_XDG_GEOMETRY_ROUNDTRIPS || wl_display_roundtrip(_glfw.wl.display) < 0) break;
|
|
}
|
|
for (int i = 0; i < _glfw.monitorCount; i++) {
|
|
_GLFWmonitor *m = _glfw.monitors[i];
|
|
if ((!only_name || m->wl.name == only_name) && needsXdgGeometry(m)) {
|
|
m->wl.xdg_geometry_wait_abandoned = true;
|
|
_glfwInputError(
|
|
GLFW_PLATFORM_ERROR,
|
|
"Wayland: compositor did not send xdg_output logical geometry for output %s, ignoring it",
|
|
m->name ? m->name : "(unnamed)");
|
|
}
|
|
}
|
|
}
|
|
|
|
GLFWAPI double
|
|
glfwGetWaylandCurrentMonitorFractionalScale(void) {
|
|
_GLFW_REQUIRE_INIT_OR_RETURN(1.0);
|
|
if (!_glfw.wl.xdg_output_manager || _glfw.monitorCount == 0) return 1.0;
|
|
|
|
// Use the monitor of the currently focused window, then the most recently
|
|
// focused window, then fall back to the primary monitor.
|
|
_GLFWmonitor *monitor = NULL;
|
|
GLFWid focus_ids[2] = {_glfw.wl.keyboardFocusId, _glfw.wl.lastKeyboardFocusId};
|
|
for (int i = 0; i < 2 && !monitor; i++) {
|
|
if (!focus_ids[i]) continue;
|
|
_GLFWwindow *window = _glfwWindowForId(focus_ids[i]);
|
|
if (window && window->wl.monitorsCount > 0) monitor = window->wl.monitors[0];
|
|
}
|
|
if (!monitor) {
|
|
// No focused window to key off of (typically the first window at
|
|
// startup). Prefer the output at the logical origin (0, 0): the
|
|
// compositor's top-left/primary output is a better guess for where a
|
|
// new window will be placed than registry order. Fall back to the
|
|
// first output if no output reports position (0, 0).
|
|
//
|
|
// xdg_output geometry arrives asynchronously and x/y remain zero until
|
|
// it does, so wait for every monitor's logical geometry before trusting
|
|
// the reported positions (otherwise an as-yet-unpositioned output would
|
|
// spuriously match (0, 0)).
|
|
waitForXdgGeometry(0);
|
|
for (int i = 0; i < _glfw.monitorCount; i++) {
|
|
_GLFWmonitor *m = _glfw.monitors[i];
|
|
if (m->wl.xdg_output && m->wl.xdg_size_received && m->wl.xdg_position_received && m->wl.x == 0 && m->wl.y == 0) {
|
|
monitor = m;
|
|
break;
|
|
}
|
|
}
|
|
if (!monitor) {
|
|
// Monitors may have been removed during the roundtrips
|
|
if (_glfw.monitorCount == 0) return 1.0;
|
|
monitor = _glfw.monitors[0];
|
|
}
|
|
}
|
|
|
|
if (!monitor->wl.xdg_output) return monitor->wl.scale > 0 ? (double)monitor->wl.scale : 1.0;
|
|
|
|
// Wait for the compositor to deliver xdg_output logical size and position.
|
|
// The monitor may be removed while waiting, so look it up again afterwards.
|
|
const uint32_t name = monitor->wl.name;
|
|
const int fallback_scale = monitor->wl.scale > 0 ? monitor->wl.scale : 1;
|
|
waitForXdgGeometry(name);
|
|
monitor = monitorForRegistryName(name);
|
|
if (!monitor) return (double)fallback_scale;
|
|
|
|
if (monitor->wl.fractional_scale <= 0.0) computeXdgFractionalScale(monitor);
|
|
|
|
return monitor->wl.fractional_scale > 0.0 ? monitor->wl.fractional_scale : (monitor->wl.scale > 0 ? (double)monitor->wl.scale : 1.0);
|
|
}
|