mirror of
https://github.com/kovidgoyal/kitty.git
synced 2024-09-20 19:19:41 +03:00
f3b9ff5f9f
The time is stored in a signed 64 bit integer with nanosecond accuracy. This eliminates the possibility of floating-point inaccuracies. `monotonic_t` can currently hold values large enough to work correctly for more than 200 years into the future. Using a typedef instead of directly using `int64_t` everywhere will also allow easily changing the datatype in the future should the need arise for more precise or bigger time values.
882 lines
30 KiB
C
Vendored
882 lines
30 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
|
||
//========================================================================
|
||
|
||
#define _GNU_SOURCE
|
||
#include "internal.h"
|
||
#include "backend_utils.h"
|
||
#include "../kitty/monotonic.h"
|
||
|
||
#include <assert.h>
|
||
#include <errno.h>
|
||
#include <limits.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/mman.h>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <wayland-client.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
|
||
|
||
|
||
static inline int min(int n1, int n2)
|
||
{
|
||
return n1 < n2 ? n1 : n2;
|
||
}
|
||
|
||
static _GLFWwindow* findWindowFromDecorationSurface(struct wl_surface* surface,
|
||
int* which)
|
||
{
|
||
int focus;
|
||
_GLFWwindow* window = _glfw.windowListHead;
|
||
if (!which)
|
||
which = &focus;
|
||
while (window)
|
||
{
|
||
if (surface == window->wl.decorations.top.surface)
|
||
{
|
||
*which = topDecoration;
|
||
break;
|
||
}
|
||
if (surface == window->wl.decorations.left.surface)
|
||
{
|
||
*which = leftDecoration;
|
||
break;
|
||
}
|
||
if (surface == window->wl.decorations.right.surface)
|
||
{
|
||
*which = rightDecoration;
|
||
break;
|
||
}
|
||
if (surface == window->wl.decorations.bottom.surface)
|
||
{
|
||
*which = bottomDecoration;
|
||
break;
|
||
}
|
||
window = window->next;
|
||
}
|
||
return window;
|
||
}
|
||
|
||
static void pointerHandleEnter(void* data UNUSED,
|
||
struct wl_pointer* pointer UNUSED,
|
||
uint32_t serial,
|
||
struct wl_surface* surface,
|
||
wl_fixed_t sx UNUSED,
|
||
wl_fixed_t sy UNUSED)
|
||
{
|
||
// Happens in the case we just destroyed the surface.
|
||
if (!surface)
|
||
return;
|
||
|
||
int focus = 0;
|
||
_GLFWwindow* window = wl_surface_get_user_data(surface);
|
||
if (!window)
|
||
{
|
||
window = findWindowFromDecorationSurface(surface, &focus);
|
||
if (!window)
|
||
return;
|
||
}
|
||
|
||
window->wl.decorations.focus = focus;
|
||
_glfw.wl.pointerSerial = serial;
|
||
_glfw.wl.pointerFocus = window;
|
||
|
||
window->wl.hovered = true;
|
||
|
||
_glfwPlatformSetCursor(window, window->wl.currentCursor);
|
||
_glfwInputCursorEnter(window, true);
|
||
}
|
||
|
||
static void pointerHandleLeave(void* data UNUSED,
|
||
struct wl_pointer* pointer UNUSED,
|
||
uint32_t serial,
|
||
struct wl_surface* surface UNUSED)
|
||
{
|
||
_GLFWwindow* window = _glfw.wl.pointerFocus;
|
||
|
||
if (!window)
|
||
return;
|
||
|
||
window->wl.hovered = false;
|
||
|
||
_glfw.wl.pointerSerial = serial;
|
||
_glfw.wl.pointerFocus = NULL;
|
||
_glfwInputCursorEnter(window, false);
|
||
}
|
||
|
||
static void setCursor(GLFWCursorShape shape)
|
||
{
|
||
struct wl_buffer* buffer;
|
||
struct wl_cursor* cursor;
|
||
struct wl_cursor_image* image;
|
||
struct wl_surface* surface = _glfw.wl.cursorSurface;
|
||
|
||
cursor = _glfwLoadCursor(shape);
|
||
if (!cursor) return;
|
||
// TODO: handle animated cursors too.
|
||
image = cursor->images[0];
|
||
|
||
if (!image)
|
||
return;
|
||
|
||
buffer = wl_cursor_image_get_buffer(image);
|
||
if (!buffer)
|
||
return;
|
||
wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.pointerSerial,
|
||
surface,
|
||
image->hotspot_x,
|
||
image->hotspot_y);
|
||
wl_surface_attach(surface, buffer, 0, 0);
|
||
wl_surface_damage(surface, 0, 0,
|
||
image->width, image->height);
|
||
wl_surface_commit(surface);
|
||
}
|
||
|
||
static void pointerHandleMotion(void* data UNUSED,
|
||
struct wl_pointer* pointer UNUSED,
|
||
uint32_t time UNUSED,
|
||
wl_fixed_t sx,
|
||
wl_fixed_t sy)
|
||
{
|
||
_GLFWwindow* window = _glfw.wl.pointerFocus;
|
||
GLFWCursorShape cursorShape = GLFW_ARROW_CURSOR;
|
||
|
||
if (!window)
|
||
return;
|
||
|
||
if (window->cursorMode == GLFW_CURSOR_DISABLED)
|
||
return;
|
||
window->wl.cursorPosX = wl_fixed_to_double(sx);
|
||
window->wl.cursorPosY = wl_fixed_to_double(sy);
|
||
|
||
switch (window->wl.decorations.focus)
|
||
{
|
||
case mainWindow:
|
||
_glfwInputCursorPos(window,
|
||
window->wl.cursorPosX, window->wl.cursorPosY);
|
||
return;
|
||
case topDecoration:
|
||
if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
|
||
cursorShape = GLFW_VRESIZE_CURSOR;
|
||
else
|
||
cursorShape = GLFW_ARROW_CURSOR;
|
||
break;
|
||
case leftDecoration:
|
||
if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
|
||
cursorShape = GLFW_NW_RESIZE_CURSOR;
|
||
else
|
||
cursorShape = GLFW_HRESIZE_CURSOR;
|
||
break;
|
||
case rightDecoration:
|
||
if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
|
||
cursorShape = GLFW_NE_RESIZE_CURSOR;
|
||
else
|
||
cursorShape = GLFW_HRESIZE_CURSOR;
|
||
break;
|
||
case bottomDecoration:
|
||
if (window->wl.cursorPosX < _GLFW_DECORATION_WIDTH)
|
||
cursorShape = GLFW_SW_RESIZE_CURSOR;
|
||
else if (window->wl.cursorPosX > window->wl.width + _GLFW_DECORATION_WIDTH)
|
||
cursorShape = GLFW_SE_RESIZE_CURSOR;
|
||
else
|
||
cursorShape = GLFW_VRESIZE_CURSOR;
|
||
break;
|
||
default:
|
||
assert(0);
|
||
}
|
||
setCursor(cursorShape);
|
||
}
|
||
|
||
static void pointerHandleButton(void* data UNUSED,
|
||
struct wl_pointer* pointer UNUSED,
|
||
uint32_t serial,
|
||
uint32_t time UNUSED,
|
||
uint32_t button,
|
||
uint32_t state)
|
||
{
|
||
_GLFWwindow* window = _glfw.wl.pointerFocus;
|
||
int glfwButton;
|
||
uint32_t edges = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
|
||
|
||
if (!window)
|
||
return;
|
||
if (button == BTN_LEFT)
|
||
{
|
||
switch (window->wl.decorations.focus)
|
||
{
|
||
case mainWindow:
|
||
break;
|
||
case topDecoration:
|
||
if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
|
||
else
|
||
{
|
||
if (window->wl.xdg.toplevel)
|
||
xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
|
||
}
|
||
break;
|
||
case leftDecoration:
|
||
if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
|
||
else
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
|
||
break;
|
||
case rightDecoration:
|
||
if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
|
||
else
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
|
||
break;
|
||
case bottomDecoration:
|
||
if (window->wl.cursorPosX < _GLFW_DECORATION_WIDTH)
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
|
||
else if (window->wl.cursorPosX > window->wl.width + _GLFW_DECORATION_WIDTH)
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
|
||
else
|
||
edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
|
||
break;
|
||
default:
|
||
assert(0);
|
||
}
|
||
if (edges != XDG_TOPLEVEL_RESIZE_EDGE_NONE)
|
||
{
|
||
xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat,
|
||
serial, edges);
|
||
}
|
||
}
|
||
else if (button == BTN_RIGHT)
|
||
{
|
||
if (window->wl.decorations.focus != mainWindow && window->wl.xdg.toplevel)
|
||
{
|
||
xdg_toplevel_show_window_menu(window->wl.xdg.toplevel,
|
||
_glfw.wl.seat, serial,
|
||
window->wl.cursorPosX,
|
||
window->wl.cursorPosY);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Don’t pass the button to the user if it was related to a decoration.
|
||
if (window->wl.decorations.focus != mainWindow)
|
||
return;
|
||
|
||
_glfw.wl.pointerSerial = serial;
|
||
|
||
/* Makes left, right and middle 0, 1 and 2. Overall order follows evdev
|
||
* codes. */
|
||
glfwButton = button - BTN_LEFT;
|
||
|
||
_glfwInputMouseClick(window,
|
||
glfwButton,
|
||
state == WL_POINTER_BUTTON_STATE_PRESSED
|
||
? GLFW_PRESS
|
||
: GLFW_RELEASE,
|
||
_glfw.wl.xkb.states.modifiers);
|
||
}
|
||
|
||
static void pointerHandleAxis(void* data UNUSED,
|
||
struct wl_pointer* pointer UNUSED,
|
||
uint32_t time UNUSED,
|
||
uint32_t axis,
|
||
wl_fixed_t value)
|
||
{
|
||
_GLFWwindow* window = _glfw.wl.pointerFocus;
|
||
double x = 0.0, y = 0.0;
|
||
if (!window)
|
||
return;
|
||
|
||
assert(axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL ||
|
||
axis == WL_POINTER_AXIS_VERTICAL_SCROLL);
|
||
|
||
if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL)
|
||
x = wl_fixed_to_double(value) * -1;
|
||
else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
|
||
y = wl_fixed_to_double(value) * -1;
|
||
|
||
_glfwInputScroll(window, x, y, 1);
|
||
}
|
||
|
||
static const struct wl_pointer_listener pointerListener = {
|
||
pointerHandleEnter,
|
||
pointerHandleLeave,
|
||
pointerHandleMotion,
|
||
pointerHandleButton,
|
||
pointerHandleAxis,
|
||
};
|
||
|
||
static void keyboardHandleKeymap(void* data UNUSED,
|
||
struct wl_keyboard* keyboard UNUSED,
|
||
uint32_t format,
|
||
int fd,
|
||
uint32_t size)
|
||
{
|
||
char* mapStr;
|
||
|
||
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
|
||
{
|
||
close(fd);
|
||
return;
|
||
}
|
||
|
||
mapStr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
|
||
if (mapStr == MAP_FAILED) {
|
||
close(fd);
|
||
return;
|
||
}
|
||
glfw_xkb_compile_keymap(&_glfw.wl.xkb, mapStr);
|
||
munmap(mapStr, size);
|
||
close(fd);
|
||
|
||
}
|
||
|
||
static void keyboardHandleEnter(void* data UNUSED,
|
||
struct wl_keyboard* keyboard UNUSED,
|
||
uint32_t serial UNUSED,
|
||
struct wl_surface* surface,
|
||
struct wl_array* keys UNUSED)
|
||
{
|
||
// Happens in the case we just destroyed the surface.
|
||
if (!surface)
|
||
return;
|
||
|
||
_GLFWwindow* window = wl_surface_get_user_data(surface);
|
||
if (!window)
|
||
{
|
||
window = findWindowFromDecorationSurface(surface, NULL);
|
||
if (!window)
|
||
return;
|
||
}
|
||
|
||
_glfw.wl.keyboardFocus = window;
|
||
_glfwInputWindowFocus(window, true);
|
||
}
|
||
|
||
static void keyboardHandleLeave(void* data UNUSED,
|
||
struct wl_keyboard* keyboard UNUSED,
|
||
uint32_t serial UNUSED,
|
||
struct wl_surface* surface UNUSED)
|
||
{
|
||
_GLFWwindow* window = _glfw.wl.keyboardFocus;
|
||
|
||
if (!window)
|
||
return;
|
||
|
||
_glfw.wl.keyboardFocus = NULL;
|
||
_glfwInputWindowFocus(window, false);
|
||
}
|
||
|
||
static void
|
||
dispatchPendingKeyRepeats(id_type timer_id UNUSED, void *data UNUSED) {
|
||
if (_glfw.wl.keyRepeatInfo.keyboardFocus != _glfw.wl.keyboardFocus || _glfw.wl.keyboardRepeatRate == 0) return;
|
||
glfw_xkb_handle_key_event(_glfw.wl.keyRepeatInfo.keyboardFocus, &_glfw.wl.xkb, _glfw.wl.keyRepeatInfo.key, GLFW_REPEAT);
|
||
changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, (s_to_monotonic_t(1ll) / (monotonic_t)_glfw.wl.keyboardRepeatRate));
|
||
toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, 1);
|
||
}
|
||
|
||
|
||
static void keyboardHandleKey(void* data UNUSED,
|
||
struct wl_keyboard* keyboard UNUSED,
|
||
uint32_t serial UNUSED,
|
||
uint32_t time UNUSED,
|
||
uint32_t key,
|
||
uint32_t state)
|
||
{
|
||
_GLFWwindow* window = _glfw.wl.keyboardFocus;
|
||
if (!window)
|
||
return;
|
||
int action = state == WL_KEYBOARD_KEY_STATE_PRESSED ? GLFW_PRESS : GLFW_RELEASE;
|
||
glfw_xkb_handle_key_event(window, &_glfw.wl.xkb, key, action);
|
||
bool repeatable = false;
|
||
|
||
if (action == GLFW_PRESS && _glfw.wl.keyboardRepeatRate > 0 && glfw_xkb_should_repeat(&_glfw.wl.xkb, key))
|
||
{
|
||
_glfw.wl.keyRepeatInfo.key = key;
|
||
repeatable = true;
|
||
_glfw.wl.keyRepeatInfo.keyboardFocus = window;
|
||
}
|
||
if (repeatable) {
|
||
changeTimerInterval(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, _glfw.wl.keyboardRepeatDelay);
|
||
}
|
||
toggleTimer(&_glfw.wl.eventLoopData, _glfw.wl.keyRepeatInfo.keyRepeatTimer, repeatable ? 1 : 0);
|
||
}
|
||
|
||
static void keyboardHandleModifiers(void* data UNUSED,
|
||
struct wl_keyboard* keyboard UNUSED,
|
||
uint32_t serial UNUSED,
|
||
uint32_t modsDepressed,
|
||
uint32_t modsLatched,
|
||
uint32_t modsLocked,
|
||
uint32_t group)
|
||
{
|
||
glfw_xkb_update_modifiers(&_glfw.wl.xkb, modsDepressed, modsLatched, modsLocked, 0, 0, group);
|
||
}
|
||
|
||
static void keyboardHandleRepeatInfo(void* data UNUSED,
|
||
struct wl_keyboard* keyboard,
|
||
int32_t rate,
|
||
int32_t delay)
|
||
{
|
||
if (keyboard != _glfw.wl.keyboard)
|
||
return;
|
||
|
||
_glfw.wl.keyboardRepeatRate = rate;
|
||
_glfw.wl.keyboardRepeatDelay = ms_to_monotonic_t(delay);
|
||
}
|
||
|
||
static const struct wl_keyboard_listener keyboardListener = {
|
||
keyboardHandleKeymap,
|
||
keyboardHandleEnter,
|
||
keyboardHandleLeave,
|
||
keyboardHandleKey,
|
||
keyboardHandleModifiers,
|
||
keyboardHandleRepeatInfo,
|
||
};
|
||
|
||
static void seatHandleCapabilities(void* data UNUSED,
|
||
struct wl_seat* seat,
|
||
enum wl_seat_capability caps)
|
||
{
|
||
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !_glfw.wl.pointer)
|
||
{
|
||
_glfw.wl.pointer = wl_seat_get_pointer(seat);
|
||
wl_pointer_add_listener(_glfw.wl.pointer, &pointerListener, NULL);
|
||
}
|
||
else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && _glfw.wl.pointer)
|
||
{
|
||
wl_pointer_destroy(_glfw.wl.pointer);
|
||
_glfw.wl.pointer = NULL;
|
||
}
|
||
|
||
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !_glfw.wl.keyboard)
|
||
{
|
||
_glfw.wl.keyboard = wl_seat_get_keyboard(seat);
|
||
wl_keyboard_add_listener(_glfw.wl.keyboard, &keyboardListener, NULL);
|
||
}
|
||
else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && _glfw.wl.keyboard)
|
||
{
|
||
wl_keyboard_destroy(_glfw.wl.keyboard);
|
||
_glfw.wl.keyboard = NULL;
|
||
}
|
||
}
|
||
|
||
static void seatHandleName(void* data UNUSED,
|
||
struct wl_seat* seat UNUSED,
|
||
const char* name UNUSED)
|
||
{
|
||
}
|
||
|
||
static const struct wl_seat_listener seatListener = {
|
||
seatHandleCapabilities,
|
||
seatHandleName,
|
||
};
|
||
|
||
static void wmBaseHandlePing(void* data UNUSED,
|
||
struct xdg_wm_base* wmBase,
|
||
uint32_t serial)
|
||
{
|
||
xdg_wm_base_pong(wmBase, serial);
|
||
}
|
||
|
||
static const struct xdg_wm_base_listener wmBaseListener = {
|
||
wmBaseHandlePing
|
||
};
|
||
|
||
static void registryHandleGlobal(void* data UNUSED,
|
||
struct wl_registry* registry,
|
||
uint32_t name,
|
||
const char* interface,
|
||
uint32_t version)
|
||
{
|
||
if (strcmp(interface, "wl_compositor") == 0)
|
||
{
|
||
_glfw.wl.compositorVersion = min(3, version);
|
||
_glfw.wl.compositor =
|
||
wl_registry_bind(registry, name, &wl_compositor_interface,
|
||
_glfw.wl.compositorVersion);
|
||
}
|
||
else if (strcmp(interface, "wl_subcompositor") == 0)
|
||
{
|
||
_glfw.wl.subcompositor =
|
||
wl_registry_bind(registry, name, &wl_subcompositor_interface, 1);
|
||
}
|
||
else if (strcmp(interface, "wl_shm") == 0)
|
||
{
|
||
_glfw.wl.shm =
|
||
wl_registry_bind(registry, name, &wl_shm_interface, 1);
|
||
}
|
||
else if (strcmp(interface, "wl_output") == 0)
|
||
{
|
||
_glfwAddOutputWayland(name, version);
|
||
}
|
||
else if (strcmp(interface, "wl_seat") == 0)
|
||
{
|
||
if (!_glfw.wl.seat)
|
||
{
|
||
_glfw.wl.seatVersion = min(4, version);
|
||
_glfw.wl.seat =
|
||
wl_registry_bind(registry, name, &wl_seat_interface,
|
||
_glfw.wl.seatVersion);
|
||
wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
|
||
}
|
||
if (_glfw.wl.seat) {
|
||
if (_glfw.wl.dataDeviceManager && !_glfw.wl.dataDevice) _glfwSetupWaylandDataDevice();
|
||
if (_glfw.wl.primarySelectionDeviceManager && !_glfw.wl.primarySelectionDevice) {
|
||
_glfwSetupWaylandPrimarySelectionDevice();
|
||
}
|
||
}
|
||
}
|
||
else if (strcmp(interface, "xdg_wm_base") == 0)
|
||
{
|
||
_glfw.wl.wmBase =
|
||
wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
|
||
xdg_wm_base_add_listener(_glfw.wl.wmBase, &wmBaseListener, NULL);
|
||
}
|
||
else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0)
|
||
{
|
||
_glfw.wl.decorationManager =
|
||
wl_registry_bind(registry, name,
|
||
&zxdg_decoration_manager_v1_interface, 1);
|
||
}
|
||
else if (strcmp(interface, "wp_viewporter") == 0)
|
||
{
|
||
_glfw.wl.viewporter =
|
||
wl_registry_bind(registry, name, &wp_viewporter_interface, 1);
|
||
}
|
||
else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0)
|
||
{
|
||
_glfw.wl.relativePointerManager =
|
||
wl_registry_bind(registry, name,
|
||
&zwp_relative_pointer_manager_v1_interface,
|
||
1);
|
||
}
|
||
else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0)
|
||
{
|
||
_glfw.wl.pointerConstraints =
|
||
wl_registry_bind(registry, name,
|
||
&zwp_pointer_constraints_v1_interface,
|
||
1);
|
||
}
|
||
else if (strcmp(interface, "zwp_idle_inhibit_manager_v1") == 0)
|
||
{
|
||
_glfw.wl.idleInhibitManager =
|
||
wl_registry_bind(registry, name,
|
||
&zwp_idle_inhibit_manager_v1_interface,
|
||
1);
|
||
}
|
||
else if (strcmp(interface, "wl_data_device_manager") == 0)
|
||
{
|
||
_glfw.wl.dataDeviceManager =
|
||
wl_registry_bind(registry, name,
|
||
&wl_data_device_manager_interface,
|
||
1);
|
||
if (_glfw.wl.seat && _glfw.wl.dataDeviceManager && !_glfw.wl.dataDevice) {
|
||
_glfwSetupWaylandDataDevice();
|
||
}
|
||
}
|
||
else if (strcmp(interface, "zwp_primary_selection_device_manager_v1") == 0 ||
|
||
strcmp(interface, "gtk_primary_selection_device_manager") == 0)
|
||
{
|
||
_glfw.wl.primarySelectionDeviceManager =
|
||
wl_registry_bind(registry, name,
|
||
&zwp_primary_selection_device_manager_v1_interface,
|
||
1);
|
||
if (_glfw.wl.seat && _glfw.wl.primarySelectionDeviceManager && !_glfw.wl.primarySelectionDevice) {
|
||
_glfwSetupWaylandPrimarySelectionDevice();
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
static void registryHandleGlobalRemove(void *data UNUSED,
|
||
struct wl_registry *registry UNUSED,
|
||
uint32_t name)
|
||
{
|
||
_GLFWmonitor* monitor;
|
||
|
||
for (int i = 0; i < _glfw.monitorCount; ++i)
|
||
{
|
||
monitor = _glfw.monitors[i];
|
||
if (monitor->wl.name == name)
|
||
{
|
||
for (_GLFWwindow *window = _glfw.windowListHead; window; window = window->next) {
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
_glfwInputMonitor(monitor, GLFW_DISCONNECTED, 0);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static const struct wl_registry_listener registryListener = {
|
||
registryHandleGlobal,
|
||
registryHandleGlobalRemove
|
||
};
|
||
|
||
|
||
|
||
static void registry_handle_global(void* data,
|
||
struct wl_registry* registry UNUSED,
|
||
uint32_t name UNUSED,
|
||
const char* interface,
|
||
uint32_t version UNUSED) {
|
||
if (strcmp(interface, "zxdg_decoration_manager_v1") == 0) {
|
||
bool *has_ssd = (bool*)data;
|
||
if (has_ssd) *has_ssd = true;
|
||
}
|
||
}
|
||
|
||
static void registry_handle_global_remove(void *data UNUSED,
|
||
struct wl_registry *registry UNUSED,
|
||
uint32_t name UNUSED) {}
|
||
GLFWAPI const char*
|
||
glfwWaylandCheckForServerSideDecorations(void) {
|
||
struct wl_display *display = wl_display_connect(NULL);
|
||
if (!display) return "ERR: Failed to connect to Wayland display";
|
||
static const struct wl_registry_listener rl = {
|
||
registry_handle_global, registry_handle_global_remove
|
||
};
|
||
struct wl_registry *registry = wl_display_get_registry(display);
|
||
bool has_ssd = false;
|
||
wl_registry_add_listener(registry, &rl, &has_ssd);
|
||
wl_display_roundtrip(display);
|
||
|
||
wl_registry_destroy(registry);
|
||
wl_display_flush(display);
|
||
wl_display_flush(display);
|
||
return has_ssd ? "YES" : "NO";
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
////// GLFW platform API //////
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
int _glfwPlatformInit(void)
|
||
{
|
||
_glfw.wl.cursor.handle = _glfw_dlopen("libwayland-cursor.so.0");
|
||
if (!_glfw.wl.cursor.handle)
|
||
{
|
||
_glfwInputError(GLFW_PLATFORM_ERROR,
|
||
"Wayland: Failed to open libwayland-cursor");
|
||
return false;
|
||
}
|
||
|
||
glfw_dlsym(_glfw.wl.cursor.theme_load, _glfw.wl.cursor.handle, "wl_cursor_theme_load");
|
||
glfw_dlsym(_glfw.wl.cursor.theme_destroy, _glfw.wl.cursor.handle, "wl_cursor_theme_destroy");
|
||
glfw_dlsym(_glfw.wl.cursor.theme_get_cursor, _glfw.wl.cursor.handle, "wl_cursor_theme_get_cursor");
|
||
glfw_dlsym(_glfw.wl.cursor.image_get_buffer, _glfw.wl.cursor.handle, "wl_cursor_image_get_buffer");
|
||
|
||
_glfw.wl.egl.handle = _glfw_dlopen("libwayland-egl.so.1");
|
||
if (!_glfw.wl.egl.handle)
|
||
{
|
||
_glfwInputError(GLFW_PLATFORM_ERROR,
|
||
"Wayland: Failed to open libwayland-egl");
|
||
return false;
|
||
}
|
||
|
||
glfw_dlsym(_glfw.wl.egl.window_create, _glfw.wl.egl.handle, "wl_egl_window_create");
|
||
glfw_dlsym(_glfw.wl.egl.window_destroy, _glfw.wl.egl.handle, "wl_egl_window_destroy");
|
||
glfw_dlsym(_glfw.wl.egl.window_resize, _glfw.wl.egl.handle, "wl_egl_window_resize");
|
||
|
||
_glfw.wl.display = wl_display_connect(NULL);
|
||
if (!_glfw.wl.display)
|
||
{
|
||
_glfwInputError(GLFW_PLATFORM_ERROR,
|
||
"Wayland: Failed to connect to display");
|
||
return false;
|
||
}
|
||
if (!initPollData(&_glfw.wl.eventLoopData, wl_display_get_fd(_glfw.wl.display))) {
|
||
_glfwInputError(GLFW_PLATFORM_ERROR,
|
||
"Wayland: Failed to initialize event loop data");
|
||
}
|
||
glfw_dbus_init(&_glfw.wl.dbus, &_glfw.wl.eventLoopData);
|
||
_glfw.wl.keyRepeatInfo.keyRepeatTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-key-repeat", ms_to_monotonic_t(500ll), 0, true, dispatchPendingKeyRepeats, NULL, NULL);
|
||
_glfw.wl.cursorAnimationTimer = addTimer(&_glfw.wl.eventLoopData, "wayland-cursor-animation", ms_to_monotonic_t(500ll), 0, true, animateCursorImage, NULL, NULL);
|
||
|
||
_glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
|
||
wl_registry_add_listener(_glfw.wl.registry, ®istryListener, NULL);
|
||
|
||
if (!glfw_xkb_create_context(&_glfw.wl.xkb)) return false;
|
||
|
||
// Sync so we got all registry objects
|
||
wl_display_roundtrip(_glfw.wl.display);
|
||
|
||
// Sync so we got all initial output events
|
||
wl_display_roundtrip(_glfw.wl.display);
|
||
|
||
#ifdef __linux__
|
||
if (_glfw.hints.init.enableJoysticks) {
|
||
if (!_glfwInitJoysticksLinux())
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
_glfwInitTimerPOSIX();
|
||
if (!_glfw.wl.wmBase)
|
||
{
|
||
_glfwInputError(GLFW_PLATFORM_ERROR,
|
||
"Wayland: Failed to find xdg-shell in your compositor");
|
||
return false;
|
||
}
|
||
|
||
if (_glfw.wl.shm)
|
||
{
|
||
const char *cursorTheme = getenv("XCURSOR_THEME"), *cursorSizeStr = getenv("XCURSOR_SIZE");
|
||
char *cursorSizeEnd;
|
||
int cursorSize = 32;
|
||
if (cursorSizeStr)
|
||
{
|
||
errno = 0;
|
||
long cursorSizeLong = strtol(cursorSizeStr, &cursorSizeEnd, 10);
|
||
if (!*cursorSizeEnd && !errno && cursorSizeLong > 0 && cursorSizeLong <= INT_MAX)
|
||
cursorSize = (int)cursorSizeLong;
|
||
}
|
||
_glfw.wl.cursorTheme = wl_cursor_theme_load(cursorTheme, cursorSize, _glfw.wl.shm);
|
||
if (!_glfw.wl.cursorTheme)
|
||
{
|
||
_glfwInputError(GLFW_PLATFORM_ERROR,
|
||
"Wayland: Unable to load default cursor theme");
|
||
return false;
|
||
}
|
||
_glfw.wl.cursorSurface =
|
||
wl_compositor_create_surface(_glfw.wl.compositor);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void _glfwPlatformTerminate(void)
|
||
{
|
||
#ifdef __linux__
|
||
_glfwTerminateJoysticksLinux();
|
||
#endif
|
||
_glfwTerminateEGL();
|
||
if (_glfw.wl.egl.handle)
|
||
{
|
||
_glfw_dlclose(_glfw.wl.egl.handle);
|
||
_glfw.wl.egl.handle = NULL;
|
||
}
|
||
|
||
glfw_xkb_release(&_glfw.wl.xkb);
|
||
glfw_dbus_terminate(&_glfw.wl.dbus);
|
||
|
||
if (_glfw.wl.cursorTheme)
|
||
wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
|
||
if (_glfw.wl.cursor.handle)
|
||
{
|
||
_glfw_dlclose(_glfw.wl.cursor.handle);
|
||
_glfw.wl.cursor.handle = NULL;
|
||
}
|
||
|
||
if (_glfw.wl.cursorSurface)
|
||
wl_surface_destroy(_glfw.wl.cursorSurface);
|
||
if (_glfw.wl.subcompositor)
|
||
wl_subcompositor_destroy(_glfw.wl.subcompositor);
|
||
if (_glfw.wl.compositor)
|
||
wl_compositor_destroy(_glfw.wl.compositor);
|
||
if (_glfw.wl.shm)
|
||
wl_shm_destroy(_glfw.wl.shm);
|
||
if (_glfw.wl.viewporter)
|
||
wp_viewporter_destroy(_glfw.wl.viewporter);
|
||
if (_glfw.wl.decorationManager)
|
||
zxdg_decoration_manager_v1_destroy(_glfw.wl.decorationManager);
|
||
if (_glfw.wl.wmBase)
|
||
xdg_wm_base_destroy(_glfw.wl.wmBase);
|
||
if (_glfw.wl.pointer)
|
||
wl_pointer_destroy(_glfw.wl.pointer);
|
||
if (_glfw.wl.keyboard)
|
||
wl_keyboard_destroy(_glfw.wl.keyboard);
|
||
if (_glfw.wl.seat)
|
||
wl_seat_destroy(_glfw.wl.seat);
|
||
if (_glfw.wl.relativePointerManager)
|
||
zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
|
||
if (_glfw.wl.pointerConstraints)
|
||
zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
|
||
if (_glfw.wl.idleInhibitManager)
|
||
zwp_idle_inhibit_manager_v1_destroy(_glfw.wl.idleInhibitManager);
|
||
if (_glfw.wl.dataSourceForClipboard)
|
||
wl_data_source_destroy(_glfw.wl.dataSourceForClipboard);
|
||
for (size_t doi=0; doi < arraysz(_glfw.wl.dataOffers); doi++) {
|
||
if (_glfw.wl.dataOffers[doi].id) {
|
||
wl_data_offer_destroy(_glfw.wl.dataOffers[doi].id);
|
||
}
|
||
}
|
||
if (_glfw.wl.dataDevice)
|
||
wl_data_device_destroy(_glfw.wl.dataDevice);
|
||
if (_glfw.wl.dataDeviceManager)
|
||
wl_data_device_manager_destroy(_glfw.wl.dataDeviceManager);
|
||
if (_glfw.wl.primarySelectionDevice)
|
||
zwp_primary_selection_device_v1_destroy(_glfw.wl.primarySelectionDevice);
|
||
if (_glfw.wl.primarySelectionDeviceManager)
|
||
zwp_primary_selection_device_manager_v1_destroy(_glfw.wl.primarySelectionDeviceManager);
|
||
if (_glfw.wl.registry)
|
||
wl_registry_destroy(_glfw.wl.registry);
|
||
if (_glfw.wl.display)
|
||
{
|
||
wl_display_flush(_glfw.wl.display);
|
||
wl_display_disconnect(_glfw.wl.display);
|
||
}
|
||
finalizePollData(&_glfw.wl.eventLoopData);
|
||
free(_glfw.wl.clipboardString); _glfw.wl.clipboardString = NULL;
|
||
free(_glfw.wl.primarySelectionString); _glfw.wl.primarySelectionString = NULL;
|
||
free(_glfw.wl.pasteString); _glfw.wl.pasteString = NULL;
|
||
|
||
}
|
||
|
||
const char* _glfwPlatformGetVersionString(void)
|
||
{
|
||
return _GLFW_VERSION_NUMBER " Wayland EGL OSMesa"
|
||
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
|
||
" clock_gettime"
|
||
#else
|
||
" gettimeofday"
|
||
#endif
|
||
" evdev"
|
||
#if defined(_GLFW_BUILD_DLL)
|
||
" shared"
|
||
#endif
|
||
;
|
||
}
|
||
|
||
#define GLFW_LOOP_BACKEND wl
|
||
#include "main_loop.h"
|