kitty/glfw/x11_init.c
Kovid Goyal 8e73e474b0
X11: Use a single process wide X error handler
Replace the grab/release error handler pattern with a process wide
handler that is installed for the lifetime of the display. Errors are
captured by nestable traps identified by request serial numbers, so
traps only capture errors from requests made while they are open, and
errors from requests not covered by any trap are reported rather than
exiting the process.

Requests to windows owned by other clients (selection requestors, drag
and drop peers) are trapped individually, without waiting for a round
trip to the server, and without covering calls into the application.

Also fix reading uninitialized memory when handling a MULTIPLE
selection request whose requestor window has been destroyed, trap
errors when replying to drag sources, report failure to deliver drag
data, and fix detectEWMH() leaving the error handler installed on an
early return.
2026-11-09 09:01:19 +05:30

940 lines
38 KiB
C
Vendored

//========================================================================
// GLFW 3.4 X11 - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
//
// 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
//========================================================================
#define _GNU_SOURCE
#include "internal.h"
#include "backend_utils.h"
#include "linux_desktop_settings.h"
#include <X11/Xresource.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include <locale.h>
#include <fcntl.h>
#include <unistd.h>
// Return the atom ID only if it is listed in the specified array
//
static Atom
getAtomIfSupported(Atom *supportedAtoms, unsigned long atomCount, const Atom atom) {
for (unsigned long i = 0; i < atomCount; i++) {
if (supportedAtoms[i] == atom) return atom;
}
return None;
}
// Check whether the running window manager is EWMH-compliant
//
static void
detectEWMH(void) {
// First we read the _NET_SUPPORTING_WM_CHECK property on the root window
Window *windowFromRoot = NULL;
if (!_glfwGetWindowPropertyX11(_glfw.x11.root, _glfw.x11.NET_SUPPORTING_WM_CHECK, XA_WINDOW, (unsigned char **)&windowFromRoot)) { return; }
// If it exists, it should be the XID of a top-level window
// Then we look for the same property on that window. The window may be
// stale, _glfwGetWindowPropertyX11() handles the resulting BadWindow.
Window *windowFromChild = NULL;
if (!_glfwGetWindowPropertyX11(*windowFromRoot, _glfw.x11.NET_SUPPORTING_WM_CHECK, XA_WINDOW, (unsigned char **)&windowFromChild)) {
XFree(windowFromRoot);
return;
}
// If the property exists, it should contain the XID of the window
if (*windowFromRoot != *windowFromChild) {
XFree(windowFromRoot);
XFree(windowFromChild);
return;
}
XFree(windowFromRoot);
XFree(windowFromChild);
// We are now fairly sure that an EWMH-compliant WM is currently running
// We can now start querying the WM about what features it supports by
// looking in the _NET_SUPPORTED property on the root window
// It should contain a list of supported EWMH protocol and state atoms
Atom *supportedAtoms = NULL;
const unsigned long atomCount = _glfwGetWindowPropertyX11(_glfw.x11.root, _glfw.x11.NET_SUPPORTED, XA_ATOM, (unsigned char **)&supportedAtoms);
if (!supportedAtoms) return;
// See which of the atoms we support that are supported by the WM
#define ALL_ATOMS \
S(NET_WM_STATE) \
S(NET_WM_STATE_ABOVE) \
S(NET_WM_STATE_BELOW) \
S(NET_WM_STATE_FULLSCREEN) \
S(NET_WM_STATE_MAXIMIZED_VERT) \
S(NET_WM_STATE_MAXIMIZED_HORZ) \
S(NET_WM_STATE_DEMANDS_ATTENTION) \
S(NET_WM_STATE_SKIP_TASKBAR) \
S(NET_WM_STATE_SKIP_PAGER) \
S(NET_WM_STATE_STICKY) \
\
S(NET_WM_FULLSCREEN_MONITORS) \
S(NET_WM_STRUT_PARTIAL) \
\
S(NET_WM_WINDOW_TYPE) \
S(NET_WM_WINDOW_TYPE_NORMAL) \
S(NET_WM_WINDOW_TYPE_DOCK) \
S(NET_WM_WINDOW_TYPE_DESKTOP) \
S(NET_WM_WINDOW_TYPE_UTILITY) \
S(NET_WM_WINDOW_TYPE_SPLASH) \
S(NET_WM_WINDOW_TYPE_DIALOG) \
S(NET_WM_WINDOW_TYPE_MENU) \
S(NET_WM_WINDOW_TYPE_NOTIFICATION) \
\
S(NET_WORKAREA) \
S(NET_CURRENT_DESKTOP) \
S(NET_ACTIVE_WINDOW) \
S(NET_FRAME_EXTENTS) \
S(NET_REQUEST_FRAME_EXTENTS) \
\
S(NET_WM_ALLOWED_ACTIONS) \
S(NET_WM_ACTION_MOVE) \
S(NET_WM_ACTION_RESIZE) \
S(NET_WM_ACTION_MINIMIZE) \
S(NET_WM_ACTION_SHADE) \
S(NET_WM_ACTION_STICK) \
S(NET_WM_ACTION_MAXIMIZE_HORZ) \
S(NET_WM_ACTION_MAXIMIZE_VERT) \
S(NET_WM_ACTION_FULLSCREEN) \
S(NET_WM_ACTION_CHANGE_DESKTOP) \
S(NET_WM_ACTION_CLOSE) \
S(NET_WM_ACTION_ABOVE) \
S(NET_WM_ACTION_BELOW) \
S(NET_WM_ACTION_ABOVE_BELOW)
static const char *atom_names[40] = {
#define S(x) "_" #x,
ALL_ATOMS};
#undef S
Atom atoms[arraysz(atom_names)];
XInternAtoms(_glfw.x11.display, (char **)atom_names, arraysz(atom_names), False, atoms);
unsigned i = 0;
#define S(name) _glfw.x11.name = getAtomIfSupported(supportedAtoms, atomCount, atoms[i++]);
ALL_ATOMS
#undef S
#undef ALL_ATOMS
XFree(supportedAtoms);
}
void
read_xi_scroll_devices(void) {
#define xi _glfw.x11.xi
xi.num_scroll_devices = 0;
// Require XI2.1 or later for smooth scrolling
if (!xi.available || xi.major < 2 || (xi.major == 2 && xi.minor < 1) || !xi.LIBINPUT_SCROLL_METHOD_ENABLED) return;
#undef xi
int deviceCount;
// A device can be removed between the XIQueryDevice and XIGetProperty
// calls, the resulting XI_BadDevice errors are expected
_glfwPushErrorTrapX11();
XIDeviceInfo *devices = XIQueryDevice(_glfw.x11.display, XIAllDevices, &deviceCount);
if (!devices) {
_glfwPopErrorTrapIgnoredX11();
return;
}
for (int i = 0; i < deviceCount; i++) {
XIDeviceInfo *device = &devices[i];
if (device->use == XIMasterPointer) _glfw.x11.xi.master_pointer_id = device->deviceid;
if (device->use != XISlavePointer || !device->enabled) continue;
Atom actual_type;
int actual_format;
unsigned long nitems, bytes_after;
unsigned char *data = NULL;
bool is_highres = false;
XIGetProperty(
_glfw.x11.display,
device->deviceid,
_glfw.x11.xi.LIBINPUT_SCROLL_METHOD_ENABLED,
0,
2,
False,
XA_INTEGER,
&actual_type,
&actual_format,
&nitems,
&bytes_after,
&data);
if (data) {
if (nitems > 1) is_highres = data[0] || data[1];
XFree(data);
}
// Detect if this is a finger-based device (touchpad/touchscreen)
bool is_finger_based = false;
// Method 1: Check for libinput tapping support (touchpads only)
if (_glfw.x11.xi.LIBINPUT_TAPPING != None) {
Atom tapping_type;
int tapping_format;
unsigned long tapping_nitems, tapping_bytes;
unsigned char *tapping_data = NULL;
if (XIGetProperty(
_glfw.x11.display,
device->deviceid,
_glfw.x11.xi.LIBINPUT_TAPPING,
0,
1,
False,
AnyPropertyType,
&tapping_type,
&tapping_format,
&tapping_nitems,
&tapping_bytes,
&tapping_data) == Success) {
if (tapping_data) {
if (tapping_nitems > 0) is_finger_based = true;
XFree(tapping_data);
}
}
}
// Method 2: Check for touch class (touchscreens/touchpads)
if (!is_finger_based) {
for (int j = 0; j < device->num_classes; j++) {
if (device->classes[j]->type == XITouchClass) {
is_finger_based = true;
break;
}
}
}
for (int j = 0; j < device->num_classes; j++) {
if (device->classes[j]->type != XIScrollClass) continue;
XIScrollClassInfo *scroll = (XIScrollClassInfo *)device->classes[j];
XIScrollDevice *d = NULL;
for (unsigned k = 0; k < _glfw.x11.xi.num_scroll_devices; k++) {
XIScrollDevice *t = _glfw.x11.xi.scroll_devices + k;
if (t->deviceid == device->deviceid && t->sourceid == scroll->sourceid) {
d = t;
break;
}
}
if (!d) {
if (_glfw.x11.xi.num_scroll_devices >= arraysz(_glfw.x11.xi.scroll_devices)) continue;
d = &_glfw.x11.xi.scroll_devices[_glfw.x11.xi.num_scroll_devices++];
*d = (XIScrollDevice){
.is_finger_based = is_finger_based,
.deviceid = device->deviceid,
.sourceid = scroll->sourceid,
};
if (is_highres) {
d->type_detected = true;
d->offset_type = GLFW_SCROLL_OFFEST_HIGHRES;
}
memcpy(d->name, device->name, MIN(sizeof(d->name) - 1, strlen(device->name)));
}
if (d->num_valuators >= arraysz(d->valuators)) continue;
XIScrollValuator *v = d->valuators + d->num_valuators++;
*v = (XIScrollValuator){
.number = scroll->number,
.is_vertical = scroll->scroll_type == XIScrollTypeVertical,
.increment = scroll->increment,
};
}
for (int j = 0; j < device->num_classes; j++) {
if (device->classes[j]->type != XIValuatorClass) continue;
XIValuatorClassInfo *vi = (XIValuatorClassInfo *)device->classes[j];
XIScrollDevice *d = NULL;
for (unsigned k = 0; k < _glfw.x11.xi.num_scroll_devices; k++) {
XIScrollDevice *t = _glfw.x11.xi.scroll_devices + k;
if (t->deviceid == device->deviceid && t->sourceid == vi->sourceid) {
d = t;
break;
}
}
if (!d) continue;
XIScrollValuator *v = NULL;
for (unsigned k = 0; k < d->num_valuators; k++) {
XIScrollValuator *t = d->valuators + k;
if (t->number == vi->number) {
v = t;
break;
}
}
if (!v) continue;
v->value = vi->value;
v->mode = vi->mode;
v->resolution = vi->resolution;
v->min = vi->min;
v->max = vi->max;
v->initialized = true;
}
}
XIFreeDeviceInfo(devices);
_glfwPopErrorTrapIgnoredX11();
}
// Look for and initialize supported X11 extensions
//
static bool
initExtensions(void) {
_glfw.x11.vidmode.handle = _glfw_dlopen("libXxf86vm.so.1");
if (_glfw.x11.vidmode.handle) {
glfw_dlsym(_glfw.x11.vidmode.QueryExtension, _glfw.x11.vidmode.handle, "XF86VidModeQueryExtension");
glfw_dlsym(_glfw.x11.vidmode.GetGammaRamp, _glfw.x11.vidmode.handle, "XF86VidModeGetGammaRamp");
glfw_dlsym(_glfw.x11.vidmode.SetGammaRamp, _glfw.x11.vidmode.handle, "XF86VidModeSetGammaRamp");
glfw_dlsym(_glfw.x11.vidmode.GetGammaRampSize, _glfw.x11.vidmode.handle, "XF86VidModeGetGammaRampSize");
_glfw.x11.vidmode.available = XF86VidModeQueryExtension(_glfw.x11.display, &_glfw.x11.vidmode.eventBase, &_glfw.x11.vidmode.errorBase);
}
#if defined(__CYGWIN__)
_glfw.x11.xi.handle = _glfw_dlopen("libXi-6.so");
#else
_glfw.x11.xi.handle = _glfw_dlopen("libXi.so.6");
#endif
if (_glfw.x11.xi.handle) {
glfw_dlsym(_glfw.x11.xi.QueryVersion, _glfw.x11.xi.handle, "XIQueryVersion");
glfw_dlsym(_glfw.x11.xi.SelectEvents, _glfw.x11.xi.handle, "XISelectEvents");
glfw_dlsym(_glfw.x11.xi.QueryDevice, _glfw.x11.xi.handle, "XIQueryDevice");
glfw_dlsym(_glfw.x11.xi.FreeDeviceInfo, _glfw.x11.xi.handle, "XIFreeDeviceInfo");
glfw_dlsym(_glfw.x11.xi.GetProperty, _glfw.x11.xi.handle, "XIGetProperty");
if (XQueryExtension(_glfw.x11.display, "XInputExtension", &_glfw.x11.xi.majorOpcode, &_glfw.x11.xi.eventBase, &_glfw.x11.xi.errorBase)) {
_glfw.x11.xi.major = 2;
_glfw.x11.xi.minor = 1;
if (XIQueryVersion(_glfw.x11.display, &_glfw.x11.xi.major, &_glfw.x11.xi.minor) == Success) { _glfw.x11.xi.available = true; }
}
}
#if defined(__CYGWIN__)
_glfw.x11.randr.handle = _glfw_dlopen("libXrandr-2.so");
#else
_glfw.x11.randr.handle = _glfw_dlopen("libXrandr.so.2");
#endif
if (_glfw.x11.randr.handle) {
glfw_dlsym(_glfw.x11.randr.AllocGamma, _glfw.x11.randr.handle, "XRRAllocGamma");
glfw_dlsym(_glfw.x11.randr.FreeGamma, _glfw.x11.randr.handle, "XRRFreeGamma");
glfw_dlsym(_glfw.x11.randr.FreeCrtcInfo, _glfw.x11.randr.handle, "XRRFreeCrtcInfo");
glfw_dlsym(_glfw.x11.randr.FreeGamma, _glfw.x11.randr.handle, "XRRFreeGamma");
glfw_dlsym(_glfw.x11.randr.FreeOutputInfo, _glfw.x11.randr.handle, "XRRFreeOutputInfo");
glfw_dlsym(_glfw.x11.randr.FreeScreenResources, _glfw.x11.randr.handle, "XRRFreeScreenResources");
glfw_dlsym(_glfw.x11.randr.GetCrtcGamma, _glfw.x11.randr.handle, "XRRGetCrtcGamma");
glfw_dlsym(_glfw.x11.randr.GetCrtcGammaSize, _glfw.x11.randr.handle, "XRRGetCrtcGammaSize");
glfw_dlsym(_glfw.x11.randr.GetCrtcInfo, _glfw.x11.randr.handle, "XRRGetCrtcInfo");
glfw_dlsym(_glfw.x11.randr.GetOutputInfo, _glfw.x11.randr.handle, "XRRGetOutputInfo");
glfw_dlsym(_glfw.x11.randr.GetOutputPrimary, _glfw.x11.randr.handle, "XRRGetOutputPrimary");
glfw_dlsym(_glfw.x11.randr.GetScreenResourcesCurrent, _glfw.x11.randr.handle, "XRRGetScreenResourcesCurrent");
glfw_dlsym(_glfw.x11.randr.QueryExtension, _glfw.x11.randr.handle, "XRRQueryExtension");
glfw_dlsym(_glfw.x11.randr.QueryVersion, _glfw.x11.randr.handle, "XRRQueryVersion");
glfw_dlsym(_glfw.x11.randr.SelectInput, _glfw.x11.randr.handle, "XRRSelectInput");
glfw_dlsym(_glfw.x11.randr.SetCrtcConfig, _glfw.x11.randr.handle, "XRRSetCrtcConfig");
glfw_dlsym(_glfw.x11.randr.SetCrtcGamma, _glfw.x11.randr.handle, "XRRSetCrtcGamma");
glfw_dlsym(_glfw.x11.randr.UpdateConfiguration, _glfw.x11.randr.handle, "XRRUpdateConfiguration");
if (XRRQueryExtension(_glfw.x11.display, &_glfw.x11.randr.eventBase, &_glfw.x11.randr.errorBase)) {
if (XRRQueryVersion(_glfw.x11.display, &_glfw.x11.randr.major, &_glfw.x11.randr.minor)) {
// The GLFW RandR path requires at least version 1.3
if (_glfw.x11.randr.major > 1 || _glfw.x11.randr.minor >= 3) _glfw.x11.randr.available = true;
} else {
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to query RandR version");
}
}
}
if (_glfw.x11.randr.available) {
XRRScreenResources *sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
if (!sr->ncrtc || !XRRGetCrtcGammaSize(_glfw.x11.display, sr->crtcs[0])) {
// This is likely an older Nvidia driver with broken gamma support
// Flag it as useless and fall back to xf86vm gamma, if available
_glfw.x11.randr.gammaBroken = true;
}
if (!sr->ncrtc) {
// A system without CRTCs is likely a system with broken RandR
// Disable the RandR monitor path and fall back to core functions
_glfw.x11.randr.monitorBroken = true;
}
XRRFreeScreenResources(sr);
}
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken) { XRRSelectInput(_glfw.x11.display, _glfw.x11.root, RROutputChangeNotifyMask); }
#if defined(__CYGWIN__)
_glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor-1.so");
#else
_glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor.so.1");
#endif
if (_glfw.x11.xcursor.handle) {
glfw_dlsym(_glfw.x11.xcursor.ImageCreate, _glfw.x11.xcursor.handle, "XcursorImageCreate");
glfw_dlsym(_glfw.x11.xcursor.ImageDestroy, _glfw.x11.xcursor.handle, "XcursorImageDestroy");
glfw_dlsym(_glfw.x11.xcursor.ImageLoadCursor, _glfw.x11.xcursor.handle, "XcursorImageLoadCursor");
}
#if defined(__CYGWIN__)
_glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama-1.so");
#else
_glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama.so.1");
#endif
if (_glfw.x11.xinerama.handle) {
glfw_dlsym(_glfw.x11.xinerama.IsActive, _glfw.x11.xinerama.handle, "XineramaIsActive");
glfw_dlsym(_glfw.x11.xinerama.QueryExtension, _glfw.x11.xinerama.handle, "XineramaQueryExtension");
glfw_dlsym(_glfw.x11.xinerama.QueryScreens, _glfw.x11.xinerama.handle, "XineramaQueryScreens");
if (XineramaQueryExtension(_glfw.x11.display, &_glfw.x11.xinerama.major, &_glfw.x11.xinerama.minor)) {
if (XineramaIsActive(_glfw.x11.display)) _glfw.x11.xinerama.available = true;
}
}
#if defined(__CYGWIN__)
_glfw.x11.xrender.handle = _glfw_dlopen("libXrender-1.so");
#else
_glfw.x11.xrender.handle = _glfw_dlopen("libXrender.so.1");
#endif
if (_glfw.x11.xrender.handle) {
glfw_dlsym(_glfw.x11.xrender.QueryExtension, _glfw.x11.xrender.handle, "XRenderQueryExtension");
glfw_dlsym(_glfw.x11.xrender.QueryVersion, _glfw.x11.xrender.handle, "XRenderQueryVersion");
glfw_dlsym(_glfw.x11.xrender.FindVisualFormat, _glfw.x11.xrender.handle, "XRenderFindVisualFormat");
if (XRenderQueryExtension(_glfw.x11.display, &_glfw.x11.xrender.errorBase, &_glfw.x11.xrender.eventBase)) {
if (XRenderQueryVersion(_glfw.x11.display, &_glfw.x11.xrender.major, &_glfw.x11.xrender.minor)) { _glfw.x11.xrender.available = true; }
}
}
#if defined(__CYGWIN__)
_glfw.x11.xshape.handle = _glfw_dlopen("libXext-6.so");
#else
_glfw.x11.xshape.handle = _glfw_dlopen("libXext.so.6");
#endif
if (_glfw.x11.xshape.handle) {
glfw_dlsym(_glfw.x11.xshape.QueryExtension, _glfw.x11.xshape.handle, "XShapeQueryExtension");
glfw_dlsym(_glfw.x11.xshape.ShapeCombineRegion, _glfw.x11.xshape.handle, "XShapeCombineRegion");
glfw_dlsym(_glfw.x11.xshape.QueryVersion, _glfw.x11.xshape.handle, "XShapeQueryVersion");
if (XShapeQueryExtension(_glfw.x11.display, &_glfw.x11.xshape.errorBase, &_glfw.x11.xshape.eventBase)) {
if (XShapeQueryVersion(_glfw.x11.display, &_glfw.x11.xshape.major, &_glfw.x11.xshape.minor)) { _glfw.x11.xshape.available = true; }
}
}
_glfw.x11.xkb.major = 1;
_glfw.x11.xkb.minor = 0;
_glfw.x11.xkb.available = XkbQueryExtension(
_glfw.x11.display, &_glfw.x11.xkb.majorOpcode, &_glfw.x11.xkb.eventBase, &_glfw.x11.xkb.errorBase, &_glfw.x11.xkb.major, &_glfw.x11.xkb.minor);
if (!_glfw.x11.xkb.available) {
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to load Xkb extension");
return false;
}
Bool supported;
if (XkbSetDetectableAutoRepeat(_glfw.x11.display, True, &supported)) {
if (supported) _glfw.x11.xkb.detectable = true;
}
if (!glfw_xkb_set_x11_events_mask()) return false;
if (!glfw_xkb_create_context(&_glfw.x11.xkb)) return false;
if (!glfw_xkb_update_x11_keyboard_id(&_glfw.x11.xkb)) return false;
if (!glfw_xkb_compile_keymap(&_glfw.x11.xkb, NULL)) return false;
// String format atoms
_glfw.x11.NULL_ = XInternAtom(_glfw.x11.display, "NULL", False);
_glfw.x11.UTF8_STRING = XInternAtom(_glfw.x11.display, "UTF8_STRING", False);
_glfw.x11.ATOM_PAIR = XInternAtom(_glfw.x11.display, "ATOM_PAIR", False);
// Custom selection property atom
_glfw.x11.GLFW_SELECTION = XInternAtom(_glfw.x11.display, "GLFW_SELECTION", False);
// ICCCM standard clipboard atoms
_glfw.x11.TARGETS = XInternAtom(_glfw.x11.display, "TARGETS", False);
_glfw.x11.MULTIPLE = XInternAtom(_glfw.x11.display, "MULTIPLE", False);
_glfw.x11.PRIMARY = XInternAtom(_glfw.x11.display, "PRIMARY", False);
_glfw.x11.INCR = XInternAtom(_glfw.x11.display, "INCR", False);
_glfw.x11.CLIPBOARD = XInternAtom(_glfw.x11.display, "CLIPBOARD", False);
// Clipboard manager atoms
_glfw.x11.CLIPBOARD_MANAGER = XInternAtom(_glfw.x11.display, "CLIPBOARD_MANAGER", False);
_glfw.x11.SAVE_TARGETS = XInternAtom(_glfw.x11.display, "SAVE_TARGETS", False);
// Xdnd (drag and drop) atoms
_glfw.x11.XdndAware = XInternAtom(_glfw.x11.display, "XdndAware", False);
_glfw.x11.XdndEnter = XInternAtom(_glfw.x11.display, "XdndEnter", False);
_glfw.x11.XdndPosition = XInternAtom(_glfw.x11.display, "XdndPosition", False);
_glfw.x11.XdndStatus = XInternAtom(_glfw.x11.display, "XdndStatus", False);
_glfw.x11.XdndActionCopy = XInternAtom(_glfw.x11.display, "XdndActionCopy", False);
_glfw.x11.XdndActionMove = XInternAtom(_glfw.x11.display, "XdndActionMove", False);
_glfw.x11.XdndActionLink = XInternAtom(_glfw.x11.display, "XdndActionLink", False);
_glfw.x11.XdndDrop = XInternAtom(_glfw.x11.display, "XdndDrop", False);
_glfw.x11.XdndFinished = XInternAtom(_glfw.x11.display, "XdndFinished", False);
_glfw.x11.XdndSelection = XInternAtom(_glfw.x11.display, "XdndSelection", False);
_glfw.x11.XdndTypeList = XInternAtom(_glfw.x11.display, "XdndTypeList", False);
_glfw.x11.XdndActionList = XInternAtom(_glfw.x11.display, "XdndActionList", False);
_glfw.x11.XdndActionAsk = XInternAtom(_glfw.x11.display, "XdndActionAsk", False);
_glfw.x11.XdndLeave = XInternAtom(_glfw.x11.display, "XdndLeave", False);
_glfw.x11.XdndProxy = XInternAtom(_glfw.x11.display, "XdndProxy", False);
// ICCCM, EWMH and Motif window property atoms
// These can be set safely even without WM support
// The EWMH atoms that require WM support are handled in detectEWMH
_glfw.x11.WM_PROTOCOLS = XInternAtom(_glfw.x11.display, "WM_PROTOCOLS", False);
_glfw.x11.WM_STATE = XInternAtom(_glfw.x11.display, "WM_STATE", False);
_glfw.x11.WM_DELETE_WINDOW = XInternAtom(_glfw.x11.display, "WM_DELETE_WINDOW", False);
_glfw.x11.NET_SUPPORTED = XInternAtom(_glfw.x11.display, "_NET_SUPPORTED", False);
_glfw.x11.NET_SUPPORTING_WM_CHECK = XInternAtom(_glfw.x11.display, "_NET_SUPPORTING_WM_CHECK", False);
_glfw.x11.NET_WM_ICON = XInternAtom(_glfw.x11.display, "_NET_WM_ICON", False);
_glfw.x11.NET_WM_PING = XInternAtom(_glfw.x11.display, "_NET_WM_PING", False);
_glfw.x11.NET_WM_PID = XInternAtom(_glfw.x11.display, "_NET_WM_PID", False);
_glfw.x11.NET_WM_NAME = XInternAtom(_glfw.x11.display, "_NET_WM_NAME", False);
_glfw.x11.NET_WM_ICON_NAME = XInternAtom(_glfw.x11.display, "_NET_WM_ICON_NAME", False);
_glfw.x11.NET_WM_BYPASS_COMPOSITOR = XInternAtom(_glfw.x11.display, "_NET_WM_BYPASS_COMPOSITOR", False);
_glfw.x11.NET_WM_WINDOW_OPACITY = XInternAtom(_glfw.x11.display, "_NET_WM_WINDOW_OPACITY", False);
_glfw.x11.MOTIF_WM_HINTS = XInternAtom(_glfw.x11.display, "_MOTIF_WM_HINTS", False);
_glfw.x11.xi.LIBINPUT_SCROLL_METHOD_ENABLED = XInternAtom(_glfw.x11.display, "libinput Scroll Method Enabled", False);
_glfw.x11.xi.LIBINPUT_TAPPING = XInternAtom(_glfw.x11.display, "libinput Tapping Enabled", False);
read_xi_scroll_devices();
// Select XI_HierarchyChanged events to detect device add/remove
if (_glfw.x11.xi.available) {
XIEventMask em;
unsigned char mask[XIMaskLen(XI_HierarchyChanged)] = {0};
em.deviceid = XIAllDevices;
em.mask_len = sizeof(mask);
em.mask = mask;
XISetMask(mask, XI_HierarchyChanged);
XISelectEvents(_glfw.x11.display, _glfw.x11.root, &em, 1);
}
// The compositing manager selection name contains the screen number
{
char name[32];
snprintf(name, sizeof(name), "_NET_WM_CM_S%u", _glfw.x11.screen);
_glfw.x11.NET_WM_CM_Sx = XInternAtom(_glfw.x11.display, name, False);
}
// Detect whether an EWMH-conformant window manager is running
detectEWMH();
return true;
}
// Retrieve system content scale via folklore heuristics
//
void
_glfwGetSystemContentScaleX11(float *xscale, float *yscale, bool bypass_cache) {
// Start by assuming the default X11 DPI
// NOTE: Some desktop environments (KDE) may remove the Xft.dpi field when it
// would be set to 96, so assume that is the case if we cannot find it
float xdpi = 96.f, ydpi = 96.f;
// NOTE: Basing the scale on Xft.dpi where available should provide the most
// consistent user experience (matches Qt, Gtk, etc), although not
// always the most accurate one
char *rms = NULL;
char *owned_rms = NULL;
if (bypass_cache) {
_glfwGetWindowPropertyX11(_glfw.x11.root, _glfw.x11.RESOURCE_MANAGER, XA_STRING, (unsigned char **)&owned_rms);
rms = owned_rms;
} else {
rms = XResourceManagerString(_glfw.x11.display);
}
if (rms) {
XrmDatabase db = XrmGetStringDatabase(rms);
if (db) {
XrmValue value;
char *type = NULL;
if (XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value)) {
if (type && strcmp(type, "String") == 0) xdpi = ydpi = (float)atof(value.addr);
}
XrmDestroyDatabase(db);
}
XFree(owned_rms);
}
*xscale = xdpi / 96.f;
*yscale = ydpi / 96.f;
}
// Create a blank cursor for hidden and disabled cursor modes
//
static Cursor
createHiddenCursor(void) {
unsigned char pixels[16 * 16 * 4] = {0};
GLFWimage image = {16, 16, pixels};
return _glfwCreateCursorX11(&image, 0, 0);
}
// Create a helper window for IPC
//
static Window
createHelperWindow(void) {
XSetWindowAttributes wa;
wa.event_mask = PropertyChangeMask;
return XCreateWindow(_glfw.x11.display, _glfw.x11.root, 0, 0, 1, 1, 0, 0, InputOnly, DefaultVisual(_glfw.x11.display, _glfw.x11.screen), CWEventMask, &wa);
}
// X error handling {{{
//
// A single error handler is installed for the lifetime of the display. Xlib's
// default handler exits the process on any error, which is never acceptable
// as many requests legitimately fail, for instance because they reference a
// window owned by another client that has destroyed it.
//
// Code that expects errors brackets the relevant requests with
// _glfwPushErrorTrapX11() and _glfwPopErrorTrapX11() or
// _glfwPopErrorTrapIgnoredX11(). Traps are identified by request serial
// numbers so they nest correctly and only capture errors from requests made
// while they were open. Errors from requests not covered by any trap indicate
// bugs and are reported, but do not exit the process.
#define traps _glfw.x11.error_traps
static void
remove_error_trap(size_t idx) {
traps.count--;
if (idx < traps.count) memmove(traps.items + idx, traps.items + idx + 1, (traps.count - idx) * sizeof(traps.items[0]));
}
// Remove closed traps whose requests have all been processed by the server,
// as no more errors can arrive for them
static void
prune_error_traps(void) {
const unsigned long processed = XLastKnownRequestProcessed(_glfw.x11.display);
for (size_t i = traps.count; i-- > 0;) {
if (traps.items[i].closed && traps.items[i].end_serial <= processed) remove_error_trap(i);
}
}
static int
errorHandler(Display *display, XErrorEvent *event) {
if (_glfw.x11.display != display) { return traps.previous_handler ? traps.previous_handler(display, event) : 0; }
// Search innermost first, nested traps cover a subset of their parent's range
for (size_t i = traps.count; i-- > 0;) {
_GLFWerrortrapX11 *t = traps.items + i;
if (event->serial >= t->start_serial && (!t->closed || event->serial <= t->end_serial)) {
if (t->error_code == Success) t->error_code = event->error_code;
return 0;
}
}
char buffer[_GLFW_MESSAGE_SIZE];
XGetErrorText(display, event->error_code, buffer, sizeof(buffer));
_glfwInputError(
GLFW_PLATFORM_ERROR,
"X11: Unhandled X error: %s (request: %u.%u, resource: 0x%lx, serial: %lu)",
buffer,
(unsigned)event->request_code,
(unsigned)event->minor_code,
event->resourceid,
event->serial);
return 0;
}
static void
install_error_handler(void) {
traps.previous_handler = XSetErrorHandler(errorHandler);
}
static void
uninstall_error_handler(void) {
XSetErrorHandler(traps.previous_handler);
traps.previous_handler = NULL;
free(traps.items);
traps.items = NULL;
traps.count = 0;
traps.capacity = 0;
}
// Closes the innermost open trap, returning its index or traps.count if there
// is no open trap
static size_t
close_error_trap(void) {
for (size_t i = traps.count; i-- > 0;) {
if (!traps.items[i].closed) {
traps.items[i].closed = true;
traps.items[i].end_serial = XNextRequest(_glfw.x11.display) - 1;
return i;
}
}
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: Popping an X error trap that was never pushed, this is a bug");
return traps.count;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
// Starts capturing X errors caused by subsequent requests. Every call must be
// matched by a call to _glfwPopErrorTrapX11() or _glfwPopErrorTrapIgnoredX11().
//
void
_glfwPushErrorTrapX11(void) {
prune_error_traps();
if (traps.count >= traps.capacity) {
const size_t capacity = traps.capacity ? traps.capacity * 2 : 16;
_GLFWerrortrapX11 *items = realloc(traps.items, capacity * sizeof(traps.items[0]));
if (!items) {
// Callers rely on every push being matched by a pop, so there is
// no way to recover from this
_glfwInputError(GLFW_OUT_OF_MEMORY, "X11: Failed to allocate memory for X error trap");
abort();
}
traps.items = items;
traps.capacity = capacity;
}
traps.items[traps.count++] = (_GLFWerrortrapX11){.start_serial = XNextRequest(_glfw.x11.display)};
}
// Stops capturing X errors for the innermost trap, waiting for the server to
// process its requests if needed. Returns the code of the first error caused
// by a request made while the trap was open, or Success.
//
int
_glfwPopErrorTrapX11(void) {
const size_t i = close_error_trap();
if (i >= traps.count) return Success;
// Requests that return a reply are processed synchronously, so a round
// trip is only needed if the trap covers requests without one
if (traps.items[i].end_serial >= traps.items[i].start_serial && XLastKnownRequestProcessed(_glfw.x11.display) < traps.items[i].end_serial) {
XSync(_glfw.x11.display, False);
}
const int code = traps.items[i].error_code;
remove_error_trap(i);
return code;
}
// Stops capturing X errors for the innermost trap, discarding any errors
// caused by its requests without waiting for the server to process them. Use
// it for requests whose failure is expected and harmless, such as replies to
// windows owned by other clients, which may have been destroyed.
//
void
_glfwPopErrorTrapIgnoredX11(void) {
close_error_trap();
prune_error_traps();
}
#undef traps
// Reports the specified error, appending a description of the specified X error
//
void
_glfwInputErrorX11(int error, int x_error_code, const char *message) {
char buffer[_GLFW_MESSAGE_SIZE];
XGetErrorText(_glfw.x11.display, x_error_code, buffer, sizeof(buffer));
_glfwInputError(error, "%s: %s", message, buffer);
}
// }}}
// Creates a native cursor object from the specified image and hotspot
//
Cursor
_glfwCreateCursorX11(const GLFWimage *image, int xhot, int yhot) {
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle) return None;
XcursorImage *native = XcursorImageCreate(image->width, image->height);
if (native == NULL) return None;
native->xhot = xhot;
native->yhot = yhot;
unsigned char *source = (unsigned char *)image->pixels;
XcursorPixel *target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4) {
unsigned int alpha = source[3];
*target = (alpha << 24) | ((unsigned char)((source[0] * alpha) / 255) << 16) | ((unsigned char)((source[1] * alpha) / 255) << 8) |
((unsigned char)((source[2] * alpha) / 255) << 0);
}
cursor = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
return cursor;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
GLFWAPI GLFWColorScheme
glfwGetCurrentSystemColorTheme(bool query_if_unintialized) {
return glfw_current_system_color_theme(query_if_unintialized);
}
void
_glfwPlatformInputColorScheme(GLFWColorScheme appearance UNUSED) {}
int
_glfwPlatformInit(bool *supports_window_occlusion) {
*supports_window_occlusion = false;
XInitThreads();
XrmInitialize();
_glfw.x11.display = XOpenDisplay(NULL);
if (!_glfw.x11.display) {
const char *display = getenv("DISPLAY");
if (display && display[0]) {
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to open display %s", display);
} else {
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: The DISPLAY environment variable is missing");
}
return false;
}
install_error_handler();
if (!initPollData(&_glfw.x11.eventLoopData, ConnectionNumber(_glfw.x11.display))) {
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to initialize event loop data");
}
glfw_dbus_init(&_glfw.x11.dbus, &_glfw.x11.eventLoopData);
glfw_initialize_desktop_settings(); // needed for color scheme change notification
_glfw.x11.screen = DefaultScreen(_glfw.x11.display);
_glfw.x11.root = RootWindow(_glfw.x11.display, _glfw.x11.screen);
_glfw.x11.context = XUniqueContext();
_glfw.x11.RESOURCE_MANAGER = XInternAtom(_glfw.x11.display, "RESOURCE_MANAGER", True);
_glfw.x11._KDE_NET_WM_BLUR_BEHIND_REGION = None;
XSelectInput(_glfw.x11.display, _glfw.x11.root, PropertyChangeMask);
_glfwGetSystemContentScaleX11(&_glfw.x11.contentScaleX, &_glfw.x11.contentScaleY, false);
if (!initExtensions()) return false;
_glfw.x11.helperWindowHandle = createHelperWindow();
_glfw.x11.hiddenCursorHandle = createHiddenCursor();
_glfwPollMonitorsX11();
return true;
}
void
_glfwPlatformTerminate(void) {
removeAllTimers(&_glfw.x11.eventLoopData);
if (_glfw.x11.helperWindowHandle) {
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) == _glfw.x11.helperWindowHandle) { _glfwPushSelectionToManagerX11(); }
XDestroyWindow(_glfw.x11.display, _glfw.x11.helperWindowHandle);
_glfw.x11.helperWindowHandle = None;
}
if (_glfw.x11.hiddenCursorHandle) {
XFreeCursor(_glfw.x11.display, _glfw.x11.hiddenCursorHandle);
_glfw.x11.hiddenCursorHandle = (Cursor)0;
}
glfw_xkb_release(&_glfw.x11.xkb);
glfw_dbus_terminate(&_glfw.x11.dbus);
if (_glfw.x11.mime_atoms.array) {
for (size_t i = 0; i < _glfw.x11.mime_atoms.sz; i++) { free((void *)_glfw.x11.mime_atoms.array[i].mime); }
free(_glfw.x11.mime_atoms.array);
}
if (_glfw.x11.clipboard_atoms.array) { free(_glfw.x11.clipboard_atoms.array); }
if (_glfw.x11.primary_atoms.array) { free(_glfw.x11.primary_atoms.array); }
free_dnd_data();
if (_glfw.x11.display) {
XCloseDisplay(_glfw.x11.display);
_glfw.x11.display = NULL;
uninstall_error_handler();
_glfw.x11.eventLoopData.fds[0].fd = -1;
}
if (_glfw.x11.xcursor.handle) {
_glfw_dlclose(_glfw.x11.xcursor.handle);
_glfw.x11.xcursor.handle = NULL;
}
if (_glfw.x11.randr.handle) {
_glfw_dlclose(_glfw.x11.randr.handle);
_glfw.x11.randr.handle = NULL;
}
if (_glfw.x11.xinerama.handle) {
_glfw_dlclose(_glfw.x11.xinerama.handle);
_glfw.x11.xinerama.handle = NULL;
}
if (_glfw.x11.xrender.handle) {
_glfw_dlclose(_glfw.x11.xrender.handle);
_glfw.x11.xrender.handle = NULL;
}
if (_glfw.x11.vidmode.handle) {
_glfw_dlclose(_glfw.x11.vidmode.handle);
_glfw.x11.vidmode.handle = NULL;
}
if (_glfw.x11.xi.handle) {
_glfw_dlclose(_glfw.x11.xi.handle);
_glfw.x11.xi.handle = NULL;
}
// NOTE: These need to be unloaded after XCloseDisplay, as they register
// cleanup callbacks that get called by that function
_glfwTerminateEGL();
_glfwTerminateGLX();
finalizePollData(&_glfw.x11.eventLoopData);
}
const char *
_glfwPlatformGetVersionString(void) {
return _GLFW_VERSION_NUMBER " X11 GLX EGL OSMesa"
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
#else
" gettimeofday"
#endif
#if defined(__linux__)
" evdev"
#endif
#if defined(_GLFW_BUILD_DLL)
" shared"
#endif
;
}
#include "main_loop.h"