mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-14 10:34:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
0f5b095042
glfw/src/wl_window.c

2753 lines
83 KiB
C
Raw Normal View History

Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
//========================================================================
Start 3.4
2019-04-16 12:43:29 +00:00
// GLFW 3.4 Wayland - www.glfw.org
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
//------------------------------------------------------------------------
// 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.
//
//========================================================================
Add C dialect reminders to each source file Files built for Win32 must use C89 style declarations for compatibility with VS 2010 and 2012, which are still supported by GLFW.
2019-05-20 13:24:14 +00:00
// It is fine to use C99 in this file because it will not be built with VS
//========================================================================
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
wayland: Clean up anonymous file creation It was a copy paste without fully updating the coding style. There were also some autotools macros that were no longer valid. So far its assumed that the needed functions exist. If better portability is needed, there needs to be some detction added to the cmake build script.
2014-09-28 19:47:18 +00:00
#define _GNU_SOURCE
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
#include "internal.h"
#include <stdio.h>
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
#include <stdlib.h>
#include <errno.h>
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
#include <assert.h>
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
Wayland: Use a timerfd for key repeat
2018-01-30 15:22:25 +00:00
#include <sys/timerfd.h>
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
#include <poll.h>
Removed duplicate inclusion of client header.
2014-09-09 14:43:24 +00:00
Wayland: Make libwayland-client dynamically loaded The insight to use wayland.xml to resolve the difficult-to-redirect interface symbols was gleaned from SDL. Instead of compiling the code output of wayland-scanner separately it is made part of the wl_init compilation unit. This lets us do things like transparently rename our copies of Wayland globals. The OS version of wayland-client-protocol.h is no longer used by GLFW, but it is presumably ABI compatible with the output of wayland-scanner. Closes #1174. Closes #1338. Related to #1655. Closes #1943.
2021-07-13 16:12:43 +00:00
#include "wayland-client-protocol.h"
#include "wayland-xdg-shell-client-protocol.h"
#include "wayland-xdg-decoration-client-protocol.h"
#include "wayland-viewporter-client-protocol.h"
#include "wayland-relative-pointer-unstable-v1-client-protocol.h"
#include "wayland-pointer-constraints-unstable-v1-client-protocol.h"
#include "wayland-idle-inhibit-unstable-v1-client-protocol.h"
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
#define GLFW_BORDER_SIZE 4
#define GLFW_CAPTION_HEIGHT 24
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
Wayland: Split long lines for function declaration
2018-09-29 16:11:11 +00:00
static int createTmpfileCloexec(char* tmpname)
Implement window decorations
2017-12-19 19:58:03 +00:00
{
int fd;
fd = mkostemp(tmpname, O_CLOEXEC);
if (fd >= 0)
unlink(tmpname);
return fd;
}
/*
* Create a new, unique, anonymous file of the given size, and
* return the file descriptor for it. The file descriptor is set
* CLOEXEC. The file is immediately suitable for mmap()'ing
* the given size at offset zero.
*
* The file should not have a permanent backing store like a disk,
* but may have if XDG_RUNTIME_DIR is not properly implemented in OS.
*
* The file name is deleted from the file system.
*
* The file is suitable for buffer sharing between processes by
* transmitting the file descriptor over Unix sockets using the
* SCM_RIGHTS methods.
*
* posix_fallocate() is used to guarantee that disk space is available
Fix typos Found via `codespell -q 3 -S ./deps -L fo,numer,te,uint,wille`
2019-08-12 10:52:31 +00:00
* for the file at the given size. If disk space is insufficient, errno
Implement window decorations
2017-12-19 19:58:03 +00:00
* is set to ENOSPC. If posix_fallocate() is not supported, program may
* receive SIGBUS on accessing mmap()'ed file contents instead.
*/
Wayland: Split long lines for function declaration
2018-09-29 16:11:11 +00:00
static int createAnonymousFile(off_t size)
Implement window decorations
2017-12-19 19:58:03 +00:00
{
static const char template[] = "/glfw-shared-XXXXXX";
const char* path;
char* name;
int fd;
int ret;
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
#ifdef HAVE_MEMFD_CREATE
fd = memfd_create("glfw-shared", MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (fd >= 0)
Implement window decorations
2017-12-19 19:58:03 +00:00
{
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
// We can add this seal before calling posix_fallocate(), as the file
// is currently zero-sized anyway.
//
// There is also no need to check for the return value, we couldn’t do
// anything with it anyway.
fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_SEAL);
Implement window decorations
2017-12-19 19:58:03 +00:00
}
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
else
Wayland: use SHM_ANON on FreeBSD This works like memfd on Linux.
2018-12-22 13:10:06 +00:00
#elif defined(SHM_ANON)
fd = shm_open(SHM_ANON, O_RDWR | O_CLOEXEC, 0600);
if (fd < 0)
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
#endif
{
path = getenv("XDG_RUNTIME_DIR");
if (!path)
{
errno = ENOENT;
return -1;
}
Implement window decorations
2017-12-19 19:58:03 +00:00
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
name = _glfw_calloc(strlen(path) + sizeof(template), 1);
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
strcpy(name, path);
strcat(name, template);
Implement window decorations
2017-12-19 19:58:03 +00:00
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
fd = createTmpfileCloexec(name);
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(name);
Wayland: Use memfd_create() and seals if available This allows the compositor to avoid having to setup and teardown a SIGBUS signal handler whenever it needs to read from this surface, as it knows we won’t be able to shrink the file and so doesn’t have to protect against that. This codepath will only be used on Linux ≥ 3.17 with glibc ≥ 2.27, and possibly other kernels and libc. The former code will continue to be used as a fallback, either if memfd_create() fails or if it isn’t available.
2018-09-29 20:35:32 +00:00
if (fd < 0)
return -1;
}
Implement window decorations
2017-12-19 19:58:03 +00:00
Wayland: use SHM_ANON on FreeBSD This works like memfd on Linux.
2018-12-22 13:10:06 +00:00
#if defined(SHM_ANON)
// posix_fallocate does not work on SHM descriptors
ret = ftruncate(fd, size);
#else
Implement window decorations
2017-12-19 19:58:03 +00:00
ret = posix_fallocate(fd, 0, size);
Wayland: use SHM_ANON on FreeBSD This works like memfd on Linux.
2018-12-22 13:10:06 +00:00
#endif
Implement window decorations
2017-12-19 19:58:03 +00:00
if (ret != 0)
{
close(fd);
errno = ret;
return -1;
}
return fd;
}
static struct wl_buffer* createShmBuffer(const GLFWimage* image)
{
struct wl_shm_pool* pool;
struct wl_buffer* buffer;
int stride = image->width * 4;
int length = image->width * image->height * 4;
void* data;
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
const int fd = createAnonymousFile(length);
Implement window decorations
2017-12-19 19:58:03 +00:00
if (fd < 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: Failed to create buffer file of size %d: %s",
Replace %m conversion specifier with %s and strerror() When compiling with `-Wall` and `-pedantic-errors`, gcc complains with ``` warning: ISO C does not support the '%m' gnu_printf format [-Wformat=] ``` because the `%m` conversion specifier is a GNU extension. Closes #1702.
2020-05-25 13:42:52 +00:00
length, strerror(errno));
Wayland: Check for buffer creation failure This prevents unusable decoration objects from being created, and invalid cursors from being returned to the user.
2018-09-29 20:59:00 +00:00
return NULL;
Implement window decorations
2017-12-19 19:58:03 +00:00
}
data = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (data == MAP_FAILED)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: Failed to map file: %s", strerror(errno));
Implement window decorations
2017-12-19 19:58:03 +00:00
close(fd);
Wayland: Check for buffer creation failure This prevents unusable decoration objects from being created, and invalid cursors from being returned to the user.
2018-09-29 20:59:00 +00:00
return NULL;
Implement window decorations
2017-12-19 19:58:03 +00:00
}
pool = wl_shm_create_pool(_glfw.wl.shm, fd, length);
close(fd);
unsigned char* source = (unsigned char*) image->pixels;
unsigned char* target = data;
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int i = 0; i < image->width * image->height; i++, source += 4)
Implement window decorations
2017-12-19 19:58:03 +00:00
{
unsigned int alpha = source[3];
*target++ = (unsigned char) ((source[2] * alpha) / 255);
*target++ = (unsigned char) ((source[1] * alpha) / 255);
*target++ = (unsigned char) ((source[0] * alpha) / 255);
*target++ = (unsigned char) alpha;
}
buffer =
wl_shm_pool_create_buffer(pool, 0,
image->width,
image->height,
stride, WL_SHM_FORMAT_ARGB8888);
munmap(data, length);
wl_shm_pool_destroy(pool);
return buffer;
}
static void createDecoration(_GLFWdecorationWayland* decoration,
struct wl_surface* parent,
Wayland: Remove unused code path
2022-06-12 16:47:30 +00:00
struct wl_buffer* buffer,
Set decorations as opaque, to optimise composition
2017-12-26 19:07:29 +00:00
int x, int y,
Implement window decorations
2017-12-19 19:58:03 +00:00
int width, int height)
{
decoration->surface = wl_compositor_create_surface(_glfw.wl.compositor);
decoration->subsurface =
wl_subcompositor_get_subsurface(_glfw.wl.subcompositor,
decoration->surface, parent);
wl_subsurface_set_position(decoration->subsurface, x, y);
decoration->viewport = wp_viewporter_get_viewport(_glfw.wl.viewporter,
decoration->surface);
wp_viewport_set_destination(decoration->viewport, width, height);
wl_surface_attach(decoration->surface, buffer, 0, 0);
Set decorations as opaque, to optimise composition
2017-12-26 19:07:29 +00:00
Wayland: Remove unused code path
2022-06-12 16:47:30 +00:00
struct wl_region* region = wl_compositor_create_region(_glfw.wl.compositor);
wl_region_add(region, 0, 0, width, height);
wl_surface_set_opaque_region(decoration->surface, region);
wl_surface_commit(decoration->surface);
wl_region_destroy(region);
Implement window decorations
2017-12-19 19:58:03 +00:00
}
static void createDecorations(_GLFWwindow* window)
{
unsigned char data[] = { 224, 224, 224, 255 };
const GLFWimage image = { 1, 1, data };
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
if (!_glfw.wl.viewporter || !window->decorated || window->wl.decorations.serverSide)
Only create decorations if wp_viewporter is supported
2017-12-22 16:29:25 +00:00
return;
Do not leak the 1×1 buffer used for decorations
2017-12-26 19:06:33 +00:00
if (!window->wl.decorations.buffer)
window->wl.decorations.buffer = createShmBuffer(&image);
Wayland: Check for buffer creation failure This prevents unusable decoration objects from being created, and invalid cursors from being returned to the user.
2018-09-29 20:59:00 +00:00
if (!window->wl.decorations.buffer)
return;
Implement window decorations
2017-12-19 19:58:03 +00:00
Do not leak the 1×1 buffer used for decorations
2017-12-26 19:06:33 +00:00
createDecoration(&window->wl.decorations.top, window->wl.surface,
Wayland: Remove unused code path
2022-06-12 16:47:30 +00:00
window->wl.decorations.buffer,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
0, -GLFW_CAPTION_HEIGHT,
window->wl.width, GLFW_CAPTION_HEIGHT);
Do not leak the 1×1 buffer used for decorations
2017-12-26 19:06:33 +00:00
createDecoration(&window->wl.decorations.left, window->wl.surface,
Wayland: Remove unused code path
2022-06-12 16:47:30 +00:00
window->wl.decorations.buffer,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
-GLFW_BORDER_SIZE, -GLFW_CAPTION_HEIGHT,
GLFW_BORDER_SIZE, window->wl.height + GLFW_CAPTION_HEIGHT);
Do not leak the 1×1 buffer used for decorations
2017-12-26 19:06:33 +00:00
createDecoration(&window->wl.decorations.right, window->wl.surface,
Wayland: Remove unused code path
2022-06-12 16:47:30 +00:00
window->wl.decorations.buffer,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
window->wl.width, -GLFW_CAPTION_HEIGHT,
GLFW_BORDER_SIZE, window->wl.height + GLFW_CAPTION_HEIGHT);
Do not leak the 1×1 buffer used for decorations
2017-12-26 19:06:33 +00:00
createDecoration(&window->wl.decorations.bottom, window->wl.surface,
Wayland: Remove unused code path
2022-06-12 16:47:30 +00:00
window->wl.decorations.buffer,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
-GLFW_BORDER_SIZE, window->wl.height,
window->wl.width + GLFW_BORDER_SIZE * 2, GLFW_BORDER_SIZE);
Implement window decorations
2017-12-19 19:58:03 +00:00
}
Correctly destroy subsurfaces on window destroy
2017-12-19 20:32:31 +00:00
static void destroyDecoration(_GLFWdecorationWayland* decoration)
{
if (decoration->subsurface)
wl_subsurface_destroy(decoration->subsurface);
Wayland: Fix destroying CSDs in the correct order On Wayland we implement Client-Side Decorations if the compositors do not implement SSDs. In that case, the destructors of the surfaces were called in the wrong order, leading to a dereference of an already freed object. We need to first destroy the subsurface before destroying the parent surface. Related PR on kitty: https://github.com/kovidgoyal/kitty/pull/3066 Related issue on kitty: https://github.com/kovidgoyal/kitty/issues/3051 Closes #1798.
2020-10-28 18:23:28 +00:00
if (decoration->surface)
wl_surface_destroy(decoration->surface);
Correctly destroy subsurfaces on window destroy
2017-12-19 20:32:31 +00:00
if (decoration->viewport)
wp_viewport_destroy(decoration->viewport);
Fix _glfwPlatformSetWindowMonitor to correctly destroy/recreate decorations
2017-12-26 15:15:11 +00:00
decoration->surface = NULL;
decoration->subsurface = NULL;
decoration->viewport = NULL;
Correctly destroy subsurfaces on window destroy
2017-12-19 20:32:31 +00:00
}
static void destroyDecorations(_GLFWwindow* window)
{
destroyDecoration(&window->wl.decorations.top);
destroyDecoration(&window->wl.decorations.left);
destroyDecoration(&window->wl.decorations.right);
destroyDecoration(&window->wl.decorations.bottom);
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void xdgDecorationHandleConfigure(void* userData,
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
struct zxdg_toplevel_decoration_v1* decoration,
uint32_t mode)
{
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
_GLFWwindow* window = userData;
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
window->wl.decorations.serverSide = (mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
if (!window->wl.decorations.serverSide)
createDecorations(window);
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct zxdg_toplevel_decoration_v1_listener xdgDecorationListener =
{
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
xdgDecorationHandleConfigure,
};
Handle scaling factor (hidpi) correctly
2017-12-22 17:22:36 +00:00
// Makes the surface considered as XRGB instead of ARGB.
static void setOpaqueRegion(_GLFWwindow* window)
Implement window decorations
2017-12-19 19:58:03 +00:00
{
Handle scaling factor (hidpi) correctly
2017-12-22 17:22:36 +00:00
struct wl_region* region;
region = wl_compositor_create_region(_glfw.wl.compositor);
if (!region)
return;
wl_region_add(region, 0, 0, window->wl.width, window->wl.height);
wl_surface_set_opaque_region(window->wl.surface, region);
wl_surface_commit(window->wl.surface);
wl_region_destroy(region);
}
static void resizeWindow(_GLFWwindow* window)
{
int scale = window->wl.scale;
int scaledWidth = window->wl.width * scale;
int scaledHeight = window->wl.height * scale;
wl_egl_window_resize(window->wl.native, scaledWidth, scaledHeight, 0, 0);
if (!window->wl.transparent)
setOpaqueRegion(window);
_glfwInputFramebufferSize(window, scaledWidth, scaledHeight);
Implement window decorations
2017-12-19 19:58:03 +00:00
Fix window size calculation when wp_viewporter isn’t supported
2017-12-22 17:56:06 +00:00
if (!window->wl.decorations.top.surface)
Only create decorations if wp_viewporter is supported
2017-12-22 16:29:25 +00:00
return;
Handle scaling factor (hidpi) correctly
2017-12-22 17:22:36 +00:00
wp_viewport_set_destination(window->wl.decorations.top.viewport,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
window->wl.width, GLFW_CAPTION_HEIGHT);
Implement window decorations
2017-12-19 19:58:03 +00:00
wl_surface_commit(window->wl.decorations.top.surface);
wp_viewport_set_destination(window->wl.decorations.left.viewport,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
GLFW_BORDER_SIZE, window->wl.height + GLFW_CAPTION_HEIGHT);
Implement window decorations
2017-12-19 19:58:03 +00:00
wl_surface_commit(window->wl.decorations.left.surface);
wl_subsurface_set_position(window->wl.decorations.right.subsurface,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
window->wl.width, -GLFW_CAPTION_HEIGHT);
Implement window decorations
2017-12-19 19:58:03 +00:00
wp_viewport_set_destination(window->wl.decorations.right.viewport,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
GLFW_BORDER_SIZE, window->wl.height + GLFW_CAPTION_HEIGHT);
Implement window decorations
2017-12-19 19:58:03 +00:00
wl_surface_commit(window->wl.decorations.right.surface);
wl_subsurface_set_position(window->wl.decorations.bottom.subsurface,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
-GLFW_BORDER_SIZE, window->wl.height);
Implement window decorations
2017-12-19 19:58:03 +00:00
wp_viewport_set_destination(window->wl.decorations.bottom.viewport,
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
window->wl.width + GLFW_BORDER_SIZE * 2, GLFW_BORDER_SIZE);
Implement window decorations
2017-12-19 19:58:03 +00:00
wl_surface_commit(window->wl.decorations.bottom.surface);
}
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
static void checkScaleChange(_GLFWwindow* window)
{
Wayland: Use named constants for version checks The wayland-scanner output provides really nice, self-documenting version macros, so we should use them whenever possible.
2022-06-10 13:46:24 +00:00
if (_glfw.wl.compositorVersion < WL_SURFACE_SET_BUFFER_SCALE_SINCE_VERSION)
wayland: Only set surface buffer scale when supported Although very unlikely, the wl_compositor version might not support wl_surface.set_buffer_scale while the wl_output emits a wl_output.scale that is larger than 1. So for correctness, bail on changing the buffer scale if we won't be able to set it later.
2015-12-27 02:42:45 +00:00
return;
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
// Get the scale factor from the highest scale monitor.
Wayland: Clean up monitor scale update
2022-01-01 19:18:33 +00:00
int maxScale = 1;
for (int i = 0; i < window->wl.monitorsCount; i++)
Add shared min and max functions for int
2022-03-14 15:01:34 +00:00
maxScale = _glfw_max(window->wl.monitors[i]->wl.scale, maxScale);
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
// Only change the framebuffer size if the scale changed.
Wayland: Clean up monitor scale update
2022-01-01 19:18:33 +00:00
if (window->wl.scale != maxScale)
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
{
Wayland: Clean up monitor scale update
2022-01-01 19:18:33 +00:00
window->wl.scale = maxScale;
wl_surface_set_buffer_scale(window->wl.surface, maxScale);
Wayland: Fix duplicate window content scale events The window content scale event was emitted every time the window content area was resized, even if its scale had not changed.
2022-06-10 12:19:13 +00:00
_glfwInputWindowContentScale(window, maxScale, maxScale);
Handle scaling factor (hidpi) correctly
2017-12-22 17:22:36 +00:00
resizeWindow(window);
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
}
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void surfaceHandleEnter(void* userData,
Wayland: Clean up pointer declarations Adapt style to match the rest of the project.
2022-03-23 17:55:22 +00:00
struct wl_surface* surface,
struct wl_output* output)
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
{
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
_GLFWwindow* window = userData;
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
_GLFWmonitor* monitor = wl_output_get_user_data(output);
if (window->wl.monitorsCount + 1 > window->wl.monitorsSize)
{
++window->wl.monitorsSize;
window->wl.monitors =
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_realloc(window->wl.monitors,
window->wl.monitorsSize * sizeof(_GLFWmonitor*));
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
}
window->wl.monitors[window->wl.monitorsCount++] = monitor;
checkScaleChange(window);
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void surfaceHandleLeave(void* userData,
Wayland: Clean up pointer declarations Adapt style to match the rest of the project.
2022-03-23 17:55:22 +00:00
struct wl_surface* surface,
struct wl_output* output)
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
{
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
_GLFWwindow* window = userData;
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
_GLFWmonitor* monitor = wl_output_get_user_data(output);
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
GLFWbool found = GLFW_FALSE;
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
Limit scope of some loop counters in C99 files
2021-02-16 19:12:19 +00:00
for (int i = 0; i < window->wl.monitorsCount - 1; ++i)
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
{
if (monitor == window->wl.monitors[i])
found = GLFW_TRUE;
if (found)
window->wl.monitors[i] = window->wl.monitors[i + 1];
}
window->wl.monitors[--window->wl.monitorsCount] = NULL;
checkScaleChange(window);
}
Wayland: Cleanup
2022-06-10 16:53:22 +00:00
static const struct wl_surface_listener surfaceListener =
{
Wayland: Rename handlers for more unicity
2018-09-29 19:01:03 +00:00
surfaceHandleEnter,
surfaceHandleLeave
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
};
Wayland: Add support for the idle-inhibit protocol Closes #955.
2017-02-17 15:52:50 +00:00
static void setIdleInhibitor(_GLFWwindow* window, GLFWbool enable)
{
if (enable && !window->wl.idleInhibitor && _glfw.wl.idleInhibitManager)
{
window->wl.idleInhibitor =
zwp_idle_inhibit_manager_v1_create_inhibitor(
_glfw.wl.idleInhibitManager, window->wl.surface);
if (!window->wl.idleInhibitor)
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: Failed to create idle inhibitor");
Wayland: Add support for the idle-inhibit protocol Closes #955.
2017-02-17 15:52:50 +00:00
}
else if (!enable && window->wl.idleInhibitor)
{
zwp_idle_inhibitor_v1_destroy(window->wl.idleInhibitor);
window->wl.idleInhibitor = NULL;
}
}
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
// Make the specified window and its video mode active on its monitor
//
static void acquireMonitor(_GLFWwindow* window)
Factorise moving to fullscreen
2017-12-22 16:42:00 +00:00
{
if (window->wl.xdg.toplevel)
{
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
xdg_toplevel_set_fullscreen(window->wl.xdg.toplevel,
window->monitor->wl.output);
Factorise moving to fullscreen
2017-12-22 16:42:00 +00:00
}
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
Factorise moving to fullscreen
2017-12-22 16:42:00 +00:00
setIdleInhibitor(window, GLFW_TRUE);
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
if (!window->wl.decorations.serverSide)
destroyDecorations(window);
Factorise moving to fullscreen
2017-12-22 16:42:00 +00:00
}
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
// Remove the window and restore the original video mode
//
static void releaseMonitor(_GLFWwindow* window)
{
if (window->wl.xdg.toplevel)
xdg_toplevel_unset_fullscreen(window->wl.xdg.toplevel);
setIdleInhibitor(window, GLFW_FALSE);
if (!_glfw.wl.decorationManager)
createDecorations(window);
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void xdgToplevelHandleConfigure(void* userData,
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
struct xdg_toplevel* toplevel,
int32_t width,
int32_t height,
struct wl_array* states)
{
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
_GLFWwindow* window = userData;
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
uint32_t* state;
GLFWbool maximized = GLFW_FALSE;
GLFWbool fullscreen = GLFW_FALSE;
GLFWbool activated = GLFW_FALSE;
wl_array_for_each(state, states)
{
switch (*state)
{
case XDG_TOPLEVEL_STATE_MAXIMIZED:
maximized = GLFW_TRUE;
break;
case XDG_TOPLEVEL_STATE_FULLSCREEN:
fullscreen = GLFW_TRUE;
break;
case XDG_TOPLEVEL_STATE_RESIZING:
break;
case XDG_TOPLEVEL_STATE_ACTIVATED:
activated = GLFW_TRUE;
break;
}
}
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
if (window->wl.activated && !activated)
Wayland: Fix auto-iconify on kwin_wayland We now keep track of the fullscreen and activated state and only iconify if we were previously fullscreen and now we are either not fullscreen or not activated anymore. This is the proper way to do it, compared to the previous hack where we didn’t iconify only if it was the first configure event received.
2019-02-15 17:12:06 +00:00
{
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
if (window->monitor && window->autoIconify)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwIconifyWindowWayland(window);
Wayland: Fix auto-iconify on kwin_wayland We now keep track of the fullscreen and activated state and only iconify if we were previously fullscreen and now we are either not fullscreen or not activated anymore. This is the proper way to do it, compared to the previous hack where we didn’t iconify only if it was the first configure event received.
2019-02-15 17:12:06 +00:00
}
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
Wayland: Fix maximization by user being ignored The internal maximization state was not updated when an event was received that the user had changed the maximization state of a window, and no maximization events were emitted. This affected both the GLFW_MAXIMIZED attribute and glfwRestoreWindow.
2022-06-10 11:29:24 +00:00
if (window->wl.maximized && !maximized)
_glfwInputWindowMaximize(window, GLFW_FALSE);
else if (maximized && !window->wl.maximized)
_glfwInputWindowMaximize(window, GLFW_TRUE);
Wayland: Add tracking of XDG fullscreen state
2022-06-10 16:36:16 +00:00
window->wl.activated = activated;
window->wl.maximized = maximized;
window->wl.fullscreen = fullscreen;
Wayland: Fix resize events before ack_configure The surface was resized and the size event was emitted before we had sent xdg_surface::ack_configure. If user code then called some GLFW function that commited the surface, those changes would all get applied to the wrong configure event. This postpones size changes until after the ack.
2022-06-10 16:38:06 +00:00
if (width && height)
{
Wayland: Fix erratic fallback decoration behavior The handler for xdg_toplevel::configure treated the provided size as the content area size when instead it is the size of the bounding rectangle of the wl_surface and all its subsurfaces. This caused the fallback decorations to try positioning themselves outside themselves, causing feedback loops during interactive resizing. Fixes #1991 Fixes #2115 Closes #2127 Related to #1914
2022-06-15 23:36:55 +00:00
if (window->wl.decorations.top.surface)
{
window->wl.pending.width = _glfw_max(0, width - GLFW_BORDER_SIZE * 2);
window->wl.pending.height =
_glfw_max(0, height - GLFW_BORDER_SIZE - GLFW_CAPTION_HEIGHT);
}
else
{
window->wl.pending.width = width;
window->wl.pending.height = height;
}
Wayland: Fix resize events before ack_configure The surface was resized and the size event was emitted before we had sent xdg_surface::ack_configure. If user code then called some GLFW function that commited the surface, those changes would all get applied to the wrong configure event. This postpones size changes until after the ack.
2022-06-10 16:38:06 +00:00
}
else
{
window->wl.pending.width = window->wl.width;
window->wl.pending.height = window->wl.height;
}
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void xdgToplevelHandleClose(void* userData,
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
struct xdg_toplevel* toplevel)
{
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
_GLFWwindow* window = userData;
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
_glfwInputWindowCloseRequest(window);
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct xdg_toplevel_listener xdgToplevelListener =
{
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
xdgToplevelHandleConfigure,
xdgToplevelHandleClose
};
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void xdgSurfaceHandleConfigure(void* userData,
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
struct xdg_surface* surface,
uint32_t serial)
{
Wayland: Fix resize events before ack_configure The surface was resized and the size event was emitted before we had sent xdg_surface::ack_configure. If user code then called some GLFW function that commited the surface, those changes would all get applied to the wrong configure event. This postpones size changes until after the ack.
2022-06-10 16:38:06 +00:00
_GLFWwindow* window = userData;
int width = window->wl.pending.width;
int height = window->wl.pending.height;
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
xdg_surface_ack_configure(surface, serial);
Wayland: Fix resize events before ack_configure The surface was resized and the size event was emitted before we had sent xdg_surface::ack_configure. If user code then called some GLFW function that commited the surface, those changes would all get applied to the wrong configure event. This postpones size changes until after the ack.
2022-06-10 16:38:06 +00:00
if (!window->wl.maximized && !window->wl.fullscreen)
{
if (window->numer != GLFW_DONT_CARE && window->denom != GLFW_DONT_CARE)
{
const float aspectRatio = (float) width / (float) height;
const float targetRatio = (float) window->numer / (float) window->denom;
if (aspectRatio < targetRatio)
height = width / targetRatio;
else if (aspectRatio > targetRatio)
width = height * targetRatio;
}
}
if (width != window->wl.width || height != window->wl.height)
{
window->wl.width = width;
window->wl.height = height;
resizeWindow(window);
_glfwInputWindowSize(window, width, height);
_glfwInputWindowDamage(window);
}
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
}
Wayland: Cleanup
2022-06-10 16:53:22 +00:00
static const struct xdg_surface_listener xdgSurfaceListener =
{
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
xdgSurfaceHandleConfigure
};
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
static void setXdgDecorations(_GLFWwindow* window)
{
if (_glfw.wl.decorationManager)
{
window->wl.xdg.decoration =
zxdg_decoration_manager_v1_get_toplevel_decoration(
_glfw.wl.decorationManager, window->wl.xdg.toplevel);
zxdg_toplevel_decoration_v1_add_listener(window->wl.xdg.decoration,
&xdgDecorationListener,
window);
zxdg_toplevel_decoration_v1_set_mode(
window->wl.xdg.decoration,
ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
}
else
{
window->wl.decorations.serverSide = GLFW_FALSE;
createDecorations(window);
}
}
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
static GLFWbool createXdgSurface(_GLFWwindow* window)
{
window->wl.xdg.surface = xdg_wm_base_get_xdg_surface(_glfw.wl.wmBase,
window->wl.surface);
if (!window->wl.xdg.surface)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: Failed to create xdg-surface for window");
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
return GLFW_FALSE;
}
xdg_surface_add_listener(window->wl.xdg.surface,
&xdgSurfaceListener,
window);
window->wl.xdg.toplevel = xdg_surface_get_toplevel(window->wl.xdg.surface);
if (!window->wl.xdg.toplevel)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: Failed to create xdg-toplevel for window");
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
return GLFW_FALSE;
}
xdg_toplevel_add_listener(window->wl.xdg.toplevel,
&xdgToplevelListener,
window);
if (window->wl.title)
xdg_toplevel_set_title(window->wl.xdg.toplevel, window->wl.title);
Don’t set min/max size on GLFW_DONT_CARE
2018-01-04 20:54:29 +00:00
if (window->minwidth != GLFW_DONT_CARE && window->minheight != GLFW_DONT_CARE)
xdg_toplevel_set_min_size(window->wl.xdg.toplevel,
window->minwidth, window->minheight);
if (window->maxwidth != GLFW_DONT_CARE && window->maxheight != GLFW_DONT_CARE)
xdg_toplevel_set_max_size(window->wl.xdg.toplevel,
window->maxwidth, window->maxheight);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
if (window->monitor)
{
xdg_toplevel_set_fullscreen(window->wl.xdg.toplevel,
window->monitor->wl.output);
setIdleInhibitor(window, GLFW_TRUE);
}
else if (window->wl.maximized)
{
xdg_toplevel_set_maximized(window->wl.xdg.toplevel);
setIdleInhibitor(window, GLFW_FALSE);
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
setXdgDecorations(window);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
}
else
{
setIdleInhibitor(window, GLFW_FALSE);
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
setXdgDecorations(window);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
}
wl_surface_commit(window->wl.surface);
Add a roundtrip after creating the xdg-surface The specification says we must not attach a buffer until we’ve received a configure event.
2018-01-04 20:56:01 +00:00
wl_display_roundtrip(_glfw.wl.display);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
Wayland: Move surface creation function This needs to be after createXdgSurface, which it will soon be calling.
2021-12-27 17:10:52 +00:00
return GLFW_TRUE;
}
static GLFWbool createSurface(_GLFWwindow* window,
Wayland: Gather framebuffer transparency logic
2021-12-27 17:13:51 +00:00
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
Wayland: Move surface creation function This needs to be after createXdgSurface, which it will soon be calling.
2021-12-27 17:10:52 +00:00
{
window->wl.surface = wl_compositor_create_surface(_glfw.wl.compositor);
if (!window->wl.surface)
return GLFW_FALSE;
wl_surface_add_listener(window->wl.surface,
&surfaceListener,
window);
wl_surface_set_user_data(window->wl.surface, window);
window->wl.native = wl_egl_window_create(window->wl.surface,
wndconfig->width,
wndconfig->height);
if (!window->wl.native)
return GLFW_FALSE;
window->wl.width = wndconfig->width;
window->wl.height = wndconfig->height;
window->wl.scale = 1;
Wayland: Move window title cloning to creation
2021-12-27 17:16:37 +00:00
window->wl.title = _glfw_strdup(wndconfig->title);
Wayland: Move surface creation function This needs to be after createXdgSurface, which it will soon be calling.
2021-12-27 17:10:52 +00:00
Wayland: Gather framebuffer transparency logic
2021-12-27 17:13:51 +00:00
window->wl.transparent = fbconfig->transparent;
Wayland: Move surface creation function This needs to be after createXdgSurface, which it will soon be calling.
2021-12-27 17:10:52 +00:00
if (!window->wl.transparent)
setOpaqueRegion(window);
Wayland: Fix GLFW_VISIBLE affecting full screen Full screen window creation was not ignoring the GLFW_VISIBLE hint.
2021-12-28 14:33:58 +00:00
if (window->monitor || wndconfig->visible)
Wayland: Fix window not visible after initial swap A window created with GLFW_VISIBLE set was not made visible by the initial buffer swap during context attribute refresh. Regression introduced by @elmindreda in 094aa6d3c721397825cb1095c156353463ecafb5.
2021-12-28 00:20:19 +00:00
{
if (!createXdgSurface(window))
return GLFW_FALSE;
window->wl.visible = GLFW_TRUE;
}
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
return GLFW_TRUE;
}
Wayland: Split long lines for function declaration
2018-09-29 16:11:11 +00:00
static void setCursorImage(_GLFWwindow* window,
_GLFWcursorWayland* cursorWayland)
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
{
struct itimerspec timer = {};
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
struct wl_cursor* wlCursor = cursorWayland->cursor;
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
struct wl_cursor_image* image;
struct wl_buffer* buffer;
struct wl_surface* surface = _glfw.wl.cursorSurface;
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
int scale = 1;
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
if (!wlCursor)
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
buffer = cursorWayland->buffer;
else
{
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
if (window->wl.scale > 1 && cursorWayland->cursorHiDPI)
{
wlCursor = cursorWayland->cursorHiDPI;
scale = 2;
}
image = wlCursor->images[cursorWayland->currentImage];
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
buffer = wl_cursor_image_get_buffer(image);
if (!buffer)
return;
timer.it_value.tv_sec = image->delay / 1000;
timer.it_value.tv_nsec = (image->delay % 1000) * 1000000;
timerfd_settime(_glfw.wl.cursorTimerfd, 0, &timer, NULL);
cursorWayland->width = image->width;
cursorWayland->height = image->height;
cursorWayland->xhot = image->hotspot_x;
cursorWayland->yhot = image->hotspot_y;
}
Wayland: Fix cursor offset when shape changes The Wayland protocol spec[1] states that set_cursor must be called with the serial number of the enter event. However, GLFW is passing in the serial number of the latest received event, which does not meet the protocol spec. [1] https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_pointer As a result, set_cursor calls were simply ignored by the compositor. This fix complies with the protocol more closely by specifically caching the enter event serial, and using it for all set_cursor calls. Fixes #1706 Closes #1899
2021-05-12 07:30:14 +00:00
wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.pointerEnterSerial,
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
surface,
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
cursorWayland->xhot / scale,
cursorWayland->yhot / scale);
wl_surface_set_buffer_scale(surface, scale);
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
wl_surface_attach(surface, buffer, 0, 0);
wl_surface_damage(surface, 0, 0,
cursorWayland->width, cursorWayland->height);
wl_surface_commit(surface);
}
Wayland: Split long lines for function declaration
2018-09-29 16:11:11 +00:00
static void incrementCursorImage(_GLFWwindow* window)
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
{
_GLFWcursor* cursor;
if (!window || window->wl.decorations.focus != mainWindow)
return;
cursor = window->wl.currentCursor;
if (cursor && cursor->wl.cursor)
{
cursor->wl.currentImage += 1;
cursor->wl.currentImage %= cursor->wl.cursor->image_count;
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
setCursorImage(window, &cursor->wl);
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
}
}
Wayland: Fix potential incomplete display flushing The flushing of a Wayland display may need to be done in several steps, signalled by it failing with EAGAIN.
2022-03-03 15:23:00 +00:00
static GLFWbool flushDisplay(void)
{
while (wl_display_flush(_glfw.wl.display) == -1)
{
if (errno != EAGAIN)
return GLFW_FALSE;
struct pollfd fd = { wl_display_get_fd(_glfw.wl.display), POLLOUT };
while (poll(&fd, 1, -1) == -1)
{
if (errno != EINTR && errno != EAGAIN)
return GLFW_FALSE;
}
}
return GLFW_TRUE;
}
Share X11 fd polling logic with Wayland This moves the X11 polling implementation to a separate file where it can be used by either the X11 or Wayland backend or both. This code should be POSIX compatible where necessary but will use the lower latency but non-standard polling functions ppoll or pollts where those are available. This commit is based on work by OlivierSohn and kovidgoyal. Fixes #1281 Closes #1285
2022-03-03 20:26:11 +00:00
static void handleEvents(double* timeout)
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
{
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
GLFWbool event = GLFW_FALSE;
Wayland: Clean up event pump Adapt style to the rest of the project.
2021-12-26 21:01:32 +00:00
struct pollfd fds[] =
{
{ wl_display_get_fd(_glfw.wl.display), POLLIN },
Wayland: Use a timerfd for key repeat
2018-01-30 15:22:25 +00:00
{ _glfw.wl.timerfd, POLLIN },
Wayland: Add a timerfd for animated cursors
2018-09-08 18:01:04 +00:00
{ _glfw.wl.cursorTimerfd, POLLIN },
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
};
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
while (!event)
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
{
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
while (wl_display_prepare_read(_glfw.wl.display) != 0)
wl_display_dispatch_pending(_glfw.wl.display);
Wayland: Cancel display fd read before callbacks Cancel the prepared-to-read state on the calling thread before starting to call back to user code. Emitting close requests here is not a good choice but that is for a future commit to address.
2022-03-03 15:28:44 +00:00
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
// If an error other than EAGAIN happens, we have likely been disconnected
// from the Wayland session; try to handle that the best we can.
if (!flushDisplay())
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
{
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
wl_display_cancel_read(_glfw.wl.display);
_GLFWwindow* window = _glfw.windowListHead;
while (window)
{
_glfwInputWindowCloseRequest(window);
window = window->next;
}
return;
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
}
Wayland: Clean up event pump Adapt style to the rest of the project.
2021-12-26 21:01:32 +00:00
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
if (!_glfwPollPOSIX(fds, 3, timeout))
{
wl_display_cancel_read(_glfw.wl.display);
return;
}
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
Wayland: Use a timerfd for key repeat
2018-01-30 15:22:25 +00:00
if (fds[0].revents & POLLIN)
{
Wayland: Clean up event pump Adapt style to the rest of the project.
2021-12-26 21:01:32 +00:00
wl_display_read_events(_glfw.wl.display);
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
if (wl_display_dispatch_pending(_glfw.wl.display) > 0)
event = GLFW_TRUE;
Wayland: Use a timerfd for key repeat
2018-01-30 15:22:25 +00:00
}
else
Wayland: Clean up event pump Adapt style to the rest of the project.
2021-12-26 21:01:32 +00:00
wl_display_cancel_read(_glfw.wl.display);
Wayland: Use a timerfd for key repeat
2018-01-30 15:22:25 +00:00
if (fds[1].revents & POLLIN)
{
Wayland: Clean up event pump Adapt style to the rest of the project.
2021-12-26 21:01:32 +00:00
uint64_t repeats;
if (read(_glfw.wl.timerfd, &repeats, sizeof(repeats)) == 8)
Wayland: Fix repeated keys reported to NULL window This fixes a race between the key repeat logic and the surface leave event handler, which could result in repeated keys being reported with a window of NULL. Fixes #1704.
2020-06-02 17:54:30 +00:00
{
Wayland: Control key repeat via timerfd state The key repeat logic is now controlled only via the key repeat timerfd.
2021-12-26 23:52:24 +00:00
for (uint64_t i = 0; i < repeats; i++)
Wayland: Fix repeated keys reported to NULL window This fixes a race between the key repeat logic and the surface leave event handler, which could result in repeated keys being reported with a window of NULL. Fixes #1704.
2020-06-02 17:54:30 +00:00
{
Wayland: Control key repeat via timerfd state The key repeat logic is now controlled only via the key repeat timerfd.
2021-12-26 23:52:24 +00:00
_glfwInputKey(_glfw.wl.keyboardFocus,
_glfw.wl.keyboardLastKey,
_glfw.wl.keyboardLastScancode,
Wayland: Fix repeated key not released on defocus Platform code should not generate key events with GLFW_REPEAT. GLFW_PRESS is translated into GLFW_REPEAT by shared code based on the key state cache. This confused the automatic key release logic into not generating an event with GLFW_RELEASE for a key being repeated when the window lost input focus.
2021-12-26 21:51:20 +00:00
GLFW_PRESS,
Wayland: Control key repeat via timerfd state The key repeat logic is now controlled only via the key repeat timerfd.
2021-12-26 23:52:24 +00:00
_glfw.wl.xkb.modifiers);
Wayland: Fix text input not following key repeat The manual key repeat implementation did not call text input.
2021-12-30 20:09:23 +00:00
_glfwInputTextWayland(_glfw.wl.keyboardFocus,
_glfw.wl.keyboardLastScancode);
Wayland: Fix repeated keys reported to NULL window This fixes a race between the key repeat logic and the surface leave event handler, which could result in repeated keys being reported with a window of NULL. Fixes #1704.
2020-06-02 17:54:30 +00:00
}
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
event = GLFW_TRUE;
Wayland: Fix repeated keys reported to NULL window This fixes a race between the key repeat logic and the surface leave event handler, which could result in repeated keys being reported with a window of NULL. Fixes #1704.
2020-06-02 17:54:30 +00:00
}
Wayland: Use a timerfd for key repeat
2018-01-30 15:22:25 +00:00
}
Wayland: Add a timerfd for animated cursors
2018-09-08 18:01:04 +00:00
if (fds[2].revents & POLLIN)
{
Wayland: Clean up event pump Adapt style to the rest of the project.
2021-12-26 21:01:32 +00:00
uint64_t repeats;
if (read(_glfw.wl.cursorTimerfd, &repeats, sizeof(repeats)) == 8)
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
{
Wayland: Continue poll() if timerfd can’t be read In the case the key repeat timerfd was interrupted before read(), the cursor timerfd wasn’t read at all even when it could. Related to #1711
2021-12-14 08:29:01 +00:00
incrementCursorImage(_glfw.wl.pointerFocus);
Wayland: Improve event processing with timeout If the polling was interrupted by a signal or by incomplete or unrelated data on any file descriptor, handleEvents could return before the full timeout had elapsed. This retries the Wayland prepare-to-read and poll until the full timeout has elapsed or until any event was processed. Unfortunately, due to how the Wayland client API is designed, this also includes the delete_id for the frame callback created by eglSwapBuffers. This means glfwWaitEvents* are still not fully functional on Wayland. See #1911 for more details.
2022-03-03 21:41:36 +00:00
event = GLFW_TRUE;
}
Wayland: Add a timerfd for animated cursors
2018-09-08 18:01:04 +00:00
}
wayland: Handle disconnect properly Merge code for PollEvents and WaitEvents, and handle disconnect properly.
2015-03-18 18:50:14 +00:00
}
}
Wayland: Make data offer reading a generic utility This will be needed for drag and drop reception as well.
2022-03-29 17:00:18 +00:00
// Reads the specified data offer as the specified MIME type
//
static char* readDataOfferAsString(struct wl_data_offer* offer, const char* mimeType)
{
int fds[2];
if (pipe2(fds, O_CLOEXEC) == -1)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create pipe for data offer: %s",
strerror(errno));
return NULL;
}
wl_data_offer_receive(offer, mimeType, fds[1]);
flushDisplay();
close(fds[1]);
char* string = NULL;
size_t size = 0;
size_t length = 0;
for (;;)
{
const size_t readSize = 4096;
const size_t requiredSize = length + readSize + 1;
if (requiredSize > size)
{
char* longer = _glfw_realloc(string, requiredSize);
if (!longer)
{
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
close(fds[0]);
return NULL;
}
string = longer;
size = requiredSize;
}
const ssize_t result = read(fds[0], string + length, readSize);
if (result == 0)
break;
else if (result == -1)
{
if (errno == EINTR)
continue;
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to read from data offer pipe: %s",
strerror(errno));
close(fds[0]);
return NULL;
}
length += result;
}
close(fds[0]);
string[length] = '\0';
return string;
}
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
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* userData,
struct wl_pointer* pointer,
uint32_t serial,
struct wl_surface* surface,
wl_fixed_t sx,
wl_fixed_t sy)
{
// 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.serial = serial;
_glfw.wl.pointerEnterSerial = serial;
_glfw.wl.pointerFocus = window;
window->wl.hovered = GLFW_TRUE;
_glfwSetCursorWayland(window, window->wl.currentCursor);
_glfwInputCursorEnter(window, GLFW_TRUE);
}
static void pointerHandleLeave(void* userData,
struct wl_pointer* pointer,
uint32_t serial,
struct wl_surface* surface)
{
_GLFWwindow* window = _glfw.wl.pointerFocus;
if (!window)
return;
window->wl.hovered = GLFW_FALSE;
_glfw.wl.serial = serial;
_glfw.wl.pointerFocus = NULL;
_glfwInputCursorEnter(window, GLFW_FALSE);
_glfw.wl.cursorPreviousName = NULL;
}
static void setCursor(_GLFWwindow* window, const char* name)
{
struct wl_buffer* buffer;
struct wl_cursor* cursor;
struct wl_cursor_image* image;
struct wl_surface* surface = _glfw.wl.cursorSurface;
struct wl_cursor_theme* theme = _glfw.wl.cursorTheme;
int scale = 1;
if (window->wl.scale > 1 && _glfw.wl.cursorThemeHiDPI)
{
// We only support up to scale=2 for now, since libwayland-cursor
// requires us to load a different theme for each size.
scale = 2;
theme = _glfw.wl.cursorThemeHiDPI;
}
cursor = wl_cursor_theme_get_cursor(theme, name);
if (!cursor)
{
_glfwInputError(GLFW_CURSOR_UNAVAILABLE,
"Wayland: Standard cursor shape unavailable");
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.pointerEnterSerial,
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.cursorPreviousName = name;
}
static void pointerHandleMotion(void* userData,
struct wl_pointer* pointer,
uint32_t time,
wl_fixed_t sx,
wl_fixed_t sy)
{
_GLFWwindow* window = _glfw.wl.pointerFocus;
const char* cursorName = NULL;
double x, y;
if (!window)
return;
if (window->cursorMode == GLFW_CURSOR_DISABLED)
return;
x = wl_fixed_to_double(sx);
y = wl_fixed_to_double(sy);
window->wl.cursorPosX = x;
window->wl.cursorPosY = y;
switch (window->wl.decorations.focus)
{
case mainWindow:
_glfwInputCursorPos(window, x, y);
_glfw.wl.cursorPreviousName = NULL;
return;
case topDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (y < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
cursorName = "n-resize";
else
cursorName = "left_ptr";
break;
case leftDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (y < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
cursorName = "nw-resize";
else
cursorName = "w-resize";
break;
case rightDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (y < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
cursorName = "ne-resize";
else
cursorName = "e-resize";
break;
case bottomDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (x < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
cursorName = "sw-resize";
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
else if (x > window->wl.width + GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
cursorName = "se-resize";
else
cursorName = "s-resize";
break;
default:
assert(0);
}
if (_glfw.wl.cursorPreviousName != cursorName)
setCursor(window, cursorName);
}
static void pointerHandleButton(void* userData,
struct wl_pointer* pointer,
uint32_t serial,
uint32_t time,
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:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (window->wl.cursorPosY < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
else
xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
break;
case leftDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (window->wl.cursorPosY < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
else
edges = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
break;
case rightDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (window->wl.cursorPosY < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
else
edges = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
break;
case bottomDecoration:
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
if (window->wl.cursorPosX < GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
else if (window->wl.cursorPosX > window->wl.width + GLFW_BORDER_SIZE)
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
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);
return;
}
}
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.serial = 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.modifiers);
}
static void pointerHandleAxis(void* userData,
struct wl_pointer* pointer,
uint32_t time,
uint32_t axis,
wl_fixed_t value)
{
_GLFWwindow* window = _glfw.wl.pointerFocus;
double x = 0.0, y = 0.0;
// Wayland scroll events are in pointer motion coordinate space (think two
// finger scroll). The factor 10 is commonly used to convert to "scroll
// step means 1.0.
const double scrollFactor = 1.0 / 10.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) * scrollFactor;
else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
y = -wl_fixed_to_double(value) * scrollFactor;
_glfwInputScroll(window, x, y);
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct wl_pointer_listener pointerListener =
{
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
pointerHandleEnter,
pointerHandleLeave,
pointerHandleMotion,
pointerHandleButton,
pointerHandleAxis,
};
static void keyboardHandleKeymap(void* userData,
struct wl_keyboard* keyboard,
uint32_t format,
int fd,
uint32_t size)
{
struct xkb_keymap* keymap;
struct xkb_state* state;
struct xkb_compose_table* composeTable;
struct xkb_compose_state* composeState;
char* mapStr;
const char* locale;
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;
}
keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
mapStr,
XKB_KEYMAP_FORMAT_TEXT_V1,
0);
munmap(mapStr, size);
close(fd);
if (!keymap)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to compile keymap");
return;
}
state = xkb_state_new(keymap);
if (!state)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB state");
xkb_keymap_unref(keymap);
return;
}
// Look up the preferred locale, falling back to "C" as default.
locale = getenv("LC_ALL");
if (!locale)
locale = getenv("LC_CTYPE");
if (!locale)
locale = getenv("LANG");
if (!locale)
locale = "C";
composeTable =
xkb_compose_table_new_from_locale(_glfw.wl.xkb.context, locale,
XKB_COMPOSE_COMPILE_NO_FLAGS);
if (composeTable)
{
composeState =
xkb_compose_state_new(composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
xkb_compose_table_unref(composeTable);
if (composeState)
_glfw.wl.xkb.composeState = composeState;
else
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB compose state");
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB compose table");
}
xkb_keymap_unref(_glfw.wl.xkb.keymap);
xkb_state_unref(_glfw.wl.xkb.state);
_glfw.wl.xkb.keymap = keymap;
_glfw.wl.xkb.state = state;
Wayland: Fix missing lock key modifier bits The modifier bits for lock keys were only set when the corresponding key was reported as held down or latched, but not when it was released and locked.
2022-06-08 17:14:13 +00:00
_glfw.wl.xkb.controlIndex = xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Control");
_glfw.wl.xkb.altIndex = xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
_glfw.wl.xkb.shiftIndex = xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
_glfw.wl.xkb.superIndex = xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
_glfw.wl.xkb.capsLockIndex = xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Lock");
_glfw.wl.xkb.numLockIndex = xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod2");
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
}
static void keyboardHandleEnter(void* userData,
struct wl_keyboard* keyboard,
uint32_t serial,
struct wl_surface* surface,
struct wl_array* keys)
{
// 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.serial = serial;
_glfw.wl.keyboardFocus = window;
_glfwInputWindowFocus(window, GLFW_TRUE);
}
static void keyboardHandleLeave(void* userData,
struct wl_keyboard* keyboard,
uint32_t serial,
struct wl_surface* surface)
{
_GLFWwindow* window = _glfw.wl.keyboardFocus;
if (!window)
return;
struct itimerspec timer = {};
timerfd_settime(_glfw.wl.timerfd, 0, &timer, NULL);
_glfw.wl.serial = serial;
_glfw.wl.keyboardFocus = NULL;
_glfwInputWindowFocus(window, GLFW_FALSE);
}
static int translateKey(uint32_t scancode)
{
if (scancode < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
return _glfw.wl.keycodes[scancode];
return GLFW_KEY_UNKNOWN;
}
static xkb_keysym_t composeSymbol(xkb_keysym_t sym)
{
if (sym == XKB_KEY_NoSymbol || !_glfw.wl.xkb.composeState)
return sym;
if (xkb_compose_state_feed(_glfw.wl.xkb.composeState, sym)
!= XKB_COMPOSE_FEED_ACCEPTED)
return sym;
switch (xkb_compose_state_get_status(_glfw.wl.xkb.composeState))
{
case XKB_COMPOSE_COMPOSED:
return xkb_compose_state_get_one_sym(_glfw.wl.xkb.composeState);
case XKB_COMPOSE_COMPOSING:
case XKB_COMPOSE_CANCELLED:
return XKB_KEY_NoSymbol;
case XKB_COMPOSE_NOTHING:
default:
return sym;
}
}
GLFWbool _glfwInputTextWayland(_GLFWwindow* window, uint32_t scancode)
{
const xkb_keysym_t* keysyms;
const xkb_keycode_t keycode = scancode + 8;
if (xkb_state_key_get_syms(_glfw.wl.xkb.state, keycode, &keysyms) == 1)
{
const xkb_keysym_t keysym = composeSymbol(keysyms[0]);
const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
if (codepoint != GLFW_INVALID_CODEPOINT)
{
const int mods = _glfw.wl.xkb.modifiers;
const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
_glfwInputChar(window, codepoint, mods, plain);
}
}
return xkb_keymap_key_repeats(_glfw.wl.xkb.keymap, keycode);
}
static void keyboardHandleKey(void* userData,
struct wl_keyboard* keyboard,
uint32_t serial,
uint32_t time,
uint32_t scancode,
uint32_t state)
{
_GLFWwindow* window = _glfw.wl.keyboardFocus;
if (!window)
return;
const int key = translateKey(scancode);
const int action =
state == WL_KEYBOARD_KEY_STATE_PRESSED ? GLFW_PRESS : GLFW_RELEASE;
_glfw.wl.serial = serial;
_glfwInputKey(window, key, scancode, action, _glfw.wl.xkb.modifiers);
struct itimerspec timer = {};
if (action == GLFW_PRESS)
{
const GLFWbool shouldRepeat = _glfwInputTextWayland(window, scancode);
if (shouldRepeat && _glfw.wl.keyboardRepeatRate > 0)
{
_glfw.wl.keyboardLastKey = key;
_glfw.wl.keyboardLastScancode = scancode;
if (_glfw.wl.keyboardRepeatRate > 1)
timer.it_interval.tv_nsec = 1000000000 / _glfw.wl.keyboardRepeatRate;
else
timer.it_interval.tv_sec = 1;
timer.it_value.tv_sec = _glfw.wl.keyboardRepeatDelay / 1000;
timer.it_value.tv_nsec = (_glfw.wl.keyboardRepeatDelay % 1000) * 1000000;
}
}
timerfd_settime(_glfw.wl.timerfd, 0, &timer, NULL);
}
static void keyboardHandleModifiers(void* userData,
struct wl_keyboard* keyboard,
uint32_t serial,
uint32_t modsDepressed,
uint32_t modsLatched,
uint32_t modsLocked,
uint32_t group)
{
_glfw.wl.serial = serial;
if (!_glfw.wl.xkb.keymap)
return;
xkb_state_update_mask(_glfw.wl.xkb.state,
modsDepressed,
modsLatched,
modsLocked,
0,
0,
group);
Wayland: Cleanup
2022-06-16 11:32:31 +00:00
_glfw.wl.xkb.modifiers = 0;
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
Wayland: Cleanup
2022-06-16 11:32:31 +00:00
struct
Wayland: Fix missing lock key modifier bits The modifier bits for lock keys were only set when the corresponding key was reported as held down or latched, but not when it was released and locked.
2022-06-08 17:14:13 +00:00
{
Wayland: Cleanup
2022-06-16 11:32:31 +00:00
xkb_mod_index_t index;
unsigned int bit;
} modifiers[] =
Wayland: Fix missing lock key modifier bits The modifier bits for lock keys were only set when the corresponding key was reported as held down or latched, but not when it was released and locked.
2022-06-08 17:14:13 +00:00
{
Wayland: Cleanup
2022-06-16 11:32:31 +00:00
{ _glfw.wl.xkb.controlIndex, GLFW_MOD_CONTROL },
{ _glfw.wl.xkb.altIndex, GLFW_MOD_ALT },
{ _glfw.wl.xkb.shiftIndex, GLFW_MOD_SHIFT },
{ _glfw.wl.xkb.superIndex, GLFW_MOD_SUPER },
{ _glfw.wl.xkb.capsLockIndex, GLFW_MOD_CAPS_LOCK },
{ _glfw.wl.xkb.numLockIndex, GLFW_MOD_NUM_LOCK }
};
Wayland: Fix missing lock key modifier bits The modifier bits for lock keys were only set when the corresponding key was reported as held down or latched, but not when it was released and locked.
2022-06-08 17:14:13 +00:00
Wayland: Cleanup
2022-06-16 11:32:31 +00:00
for (size_t i = 0; i < sizeof(modifiers) / sizeof(modifiers[0]); i++)
Wayland: Fix missing lock key modifier bits The modifier bits for lock keys were only set when the corresponding key was reported as held down or latched, but not when it was released and locked.
2022-06-08 17:14:13 +00:00
{
Wayland: Cleanup
2022-06-16 11:32:31 +00:00
if (xkb_state_mod_index_is_active(_glfw.wl.xkb.state,
modifiers[i].index,
XKB_STATE_MODS_EFFECTIVE) == 1)
{
_glfw.wl.xkb.modifiers |= modifiers[i].bit;
}
Wayland: Fix missing lock key modifier bits The modifier bits for lock keys were only set when the corresponding key was reported as held down or latched, but not when it was released and locked.
2022-06-08 17:14:13 +00:00
}
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
}
#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
static void keyboardHandleRepeatInfo(void* userData,
struct wl_keyboard* keyboard,
int32_t rate,
int32_t delay)
{
if (keyboard != _glfw.wl.keyboard)
return;
_glfw.wl.keyboardRepeatRate = rate;
_glfw.wl.keyboardRepeatDelay = delay;
}
#endif
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct wl_keyboard_listener keyboardListener =
{
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
keyboardHandleKeymap,
keyboardHandleEnter,
keyboardHandleLeave,
keyboardHandleKey,
keyboardHandleModifiers,
#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
keyboardHandleRepeatInfo,
#endif
};
static void seatHandleCapabilities(void* userData,
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* userData,
struct wl_seat* seat,
const char* name)
{
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct wl_seat_listener seatListener =
{
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
seatHandleCapabilities,
seatHandleName,
};
static void dataOfferHandleOffer(void* userData,
struct wl_data_offer* offer,
const char* mimeType)
{
for (unsigned int i = 0; i < _glfw.wl.offerCount; i++)
{
if (_glfw.wl.offers[i].offer == offer)
{
if (strcmp(mimeType, "text/plain;charset=utf-8") == 0)
_glfw.wl.offers[i].text_plain_utf8 = GLFW_TRUE;
Wayland: Add support for file drop events This adds support for file path drop events in text/uri-list format. It is based on work by Pilzschaf in #2040. Closes #2040
2022-03-31 17:56:48 +00:00
else if (strcmp(mimeType, "text/uri-list") == 0)
_glfw.wl.offers[i].text_uri_list = GLFW_TRUE;
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
break;
}
}
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct wl_data_offer_listener dataOfferListener =
{
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
dataOfferHandleOffer
};
static void dataDeviceHandleDataOffer(void* userData,
struct wl_data_device* device,
struct wl_data_offer* offer)
{
_GLFWofferWayland* offers =
_glfw_realloc(_glfw.wl.offers, _glfw.wl.offerCount + 1);
if (!offers)
{
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
return;
}
_glfw.wl.offers = offers;
_glfw.wl.offerCount++;
_glfw.wl.offers[_glfw.wl.offerCount - 1] = (_GLFWofferWayland) { offer };
wl_data_offer_add_listener(offer, &dataOfferListener, NULL);
}
static void dataDeviceHandleEnter(void* userData,
struct wl_data_device* device,
uint32_t serial,
struct wl_surface* surface,
wl_fixed_t x,
wl_fixed_t y,
struct wl_data_offer* offer)
{
Wayland: Add support for file drop events This adds support for file path drop events in text/uri-list format. It is based on work by Pilzschaf in #2040. Closes #2040
2022-03-31 17:56:48 +00:00
if (_glfw.wl.dragOffer)
{
wl_data_offer_destroy(_glfw.wl.dragOffer);
_glfw.wl.dragOffer = NULL;
_glfw.wl.dragFocus = NULL;
}
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
for (unsigned int i = 0; i < _glfw.wl.offerCount; i++)
{
if (_glfw.wl.offers[i].offer == offer)
{
Wayland: Add support for file drop events This adds support for file path drop events in text/uri-list format. It is based on work by Pilzschaf in #2040. Closes #2040
2022-03-31 17:56:48 +00:00
_GLFWwindow* window = NULL;
if (surface)
window = wl_surface_get_user_data(surface);
if (window && _glfw.wl.offers[i].text_uri_list)
{
_glfw.wl.dragOffer = offer;
_glfw.wl.dragFocus = window;
_glfw.wl.dragSerial = serial;
}
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
_glfw.wl.offers[i] = _glfw.wl.offers[_glfw.wl.offerCount - 1];
_glfw.wl.offerCount--;
break;
}
}
Wayland: Add support for file drop events This adds support for file path drop events in text/uri-list format. It is based on work by Pilzschaf in #2040. Closes #2040
2022-03-31 17:56:48 +00:00
if (_glfw.wl.dragOffer)
wl_data_offer_accept(offer, serial, "text/uri-list");
else
{
wl_data_offer_accept(offer, serial, NULL);
wl_data_offer_destroy(offer);
}
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
}
static void dataDeviceHandleLeave(void* userData,
struct wl_data_device* device)
{
Wayland: Add support for file drop events This adds support for file path drop events in text/uri-list format. It is based on work by Pilzschaf in #2040. Closes #2040
2022-03-31 17:56:48 +00:00
if (_glfw.wl.dragOffer)
{
wl_data_offer_destroy(_glfw.wl.dragOffer);
_glfw.wl.dragOffer = NULL;
_glfw.wl.dragFocus = NULL;
}
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
}
static void dataDeviceHandleMotion(void* userData,
struct wl_data_device* device,
uint32_t time,
wl_fixed_t x,
wl_fixed_t y)
{
}
static void dataDeviceHandleDrop(void* userData,
struct wl_data_device* device)
{
Wayland: Add support for file drop events This adds support for file path drop events in text/uri-list format. It is based on work by Pilzschaf in #2040. Closes #2040
2022-03-31 17:56:48 +00:00
if (!_glfw.wl.dragOffer)
return;
char* string = readDataOfferAsString(_glfw.wl.dragOffer, "text/uri-list");
if (string)
{
int count;
char** paths = _glfwParseUriList(string, &count);
if (paths)
_glfwInputDrop(_glfw.wl.dragFocus, count, (const char**) paths);
for (int i = 0; i < count; i++)
_glfw_free(paths[i]);
_glfw_free(paths);
}
_glfw_free(string);
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
}
static void dataDeviceHandleSelection(void* userData,
struct wl_data_device* device,
struct wl_data_offer* offer)
{
if (_glfw.wl.selectionOffer)
{
wl_data_offer_destroy(_glfw.wl.selectionOffer);
_glfw.wl.selectionOffer = NULL;
}
for (unsigned int i = 0; i < _glfw.wl.offerCount; i++)
{
if (_glfw.wl.offers[i].offer == offer)
{
if (_glfw.wl.offers[i].text_plain_utf8)
_glfw.wl.selectionOffer = offer;
else
wl_data_offer_destroy(offer);
_glfw.wl.offers[i] = _glfw.wl.offers[_glfw.wl.offerCount - 1];
_glfw.wl.offerCount--;
break;
}
}
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
const struct wl_data_device_listener dataDeviceListener =
{
Wayland: Move window related code to window module The Wayland backend was the only one where half the window and input related code was in the init module. As those bits want to share more utility code with the window module, the interface between them grows. To prevent that, this gathers nearly all window and input related code into the window module.
2022-03-29 16:32:05 +00:00
dataDeviceHandleDataOffer,
dataDeviceHandleEnter,
dataDeviceHandleLeave,
dataDeviceHandleMotion,
dataDeviceHandleDrop,
dataDeviceHandleSelection,
};
void _glfwAddSeatListenerWayland(struct wl_seat* seat)
{
wl_seat_add_listener(seat, &seatListener, NULL);
}
void _glfwAddDataDeviceListenerWayland(struct wl_data_device* device)
{
wl_data_device_add_listener(device, &dataDeviceListener, NULL);
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwCreateWindowWayland(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Wayland: Gather framebuffer transparency logic
2021-12-27 17:13:51 +00:00
if (!createSurface(window, wndconfig, fbconfig))
Wayland: Create the surface before the context This fixes a regression introduced in 496f559c where a context would be created for a NULL egl_surface, which subsequently fails. Fixes #633.
2015-11-02 00:39:52 +00:00
return GLFW_FALSE;
Add run-time context creation API selection Fixes #145.
2016-03-28 11:19:31 +00:00
if (ctxconfig->client != GLFW_NO_API)
Add GLFW_NO_API for creating context-less windows
2015-06-18 12:03:02 +00:00
{
Wayland: Fix broken build Regression caused by e9560ef021c101def23a5c3b383d057b2a0e58d3.
2017-03-03 17:51:40 +00:00
if (ctxconfig->source == GLFW_EGL_CONTEXT_API ||
ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
{
if (!_glfwInitEGL())
return GLFW_FALSE;
if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
{
if (!_glfwInitOSMesa())
return GLFW_FALSE;
if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
Move last bits of window setup to platform code This avoids glfwCreateWindow emitting GLFW_FEATURE_UNAVAILABLE or GLFW_FEATURE_UNIMPLEMENTED on Wayland because shared code was calling unimplemented or unavailable platform functions during final setup. It also makes it consistent with the final setup of full screen windows.
2022-04-06 19:13:48 +00:00
if (!_glfwRefreshContextAttribs(window, ctxconfig))
return GLFW_FALSE;
Add GLFW_NO_API for creating context-less windows
2015-06-18 12:03:02 +00:00
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
Move last bits of window setup to platform code This avoids glfwCreateWindow emitting GLFW_FEATURE_UNAVAILABLE or GLFW_FEATURE_UNIMPLEMENTED on Wayland because shared code was calling unimplemented or unavailable platform functions during final setup. It also makes it consistent with the final setup of full screen windows.
2022-04-06 19:13:48 +00:00
if (wndconfig->mousePassthrough)
_glfwSetWindowMousePassthroughWayland(window, GLFW_TRUE);
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_TRUE;
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwDestroyWindowWayland(_GLFWwindow* window)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
wayland: Release input focus when window is destroyed This fixes a seg. fault on the reopen test because events might occur after the window is destroyed (for example leave events).
2014-07-26 20:55:43 +00:00
if (window == _glfw.wl.pointerFocus)
{
_glfw.wl.pointerFocus = NULL;
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
_glfwInputCursorEnter(window, GLFW_FALSE);
wayland: Release input focus when window is destroyed This fixes a seg. fault on the reopen test because events might occur after the window is destroyed (for example leave events).
2014-07-26 20:55:43 +00:00
}
if (window == _glfw.wl.keyboardFocus)
{
_glfw.wl.keyboardFocus = NULL;
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
_glfwInputWindowFocus(window, GLFW_FALSE);
wayland: Release input focus when window is destroyed This fixes a seg. fault on the reopen test because events might occur after the window is destroyed (for example leave events).
2014-07-26 20:55:43 +00:00
}
Wayland: Add support for the idle-inhibit protocol Closes #955.
2017-02-17 15:52:50 +00:00
if (window->wl.idleInhibitor)
zwp_idle_inhibitor_v1_destroy(window->wl.idleInhibitor);
Fix potential context resource leaks There is a gap between the creation of the context and the call to _glfwRefreshContextAttribs.
2016-08-05 09:22:55 +00:00
if (window->context.destroy)
Cleanup
2016-05-25 12:43:51 +00:00
window->context.destroy(window);
wayland: Destroy window context before clearing the egl surface
2014-07-10 21:08:28 +00:00
Correctly destroy subsurfaces on window destroy
2017-12-19 20:32:31 +00:00
destroyDecorations(window);
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
if (window->wl.xdg.decoration)
zxdg_toplevel_decoration_v1_destroy(window->wl.xdg.decoration);
Do not leak the 1×1 buffer used for decorations
2017-12-26 19:06:33 +00:00
if (window->wl.decorations.buffer)
wl_buffer_destroy(window->wl.decorations.buffer);
Correctly destroy subsurfaces on window destroy
2017-12-19 20:32:31 +00:00
Shortened Wayland platform prefix.
2014-03-19 15:20:32 +00:00
if (window->wl.native)
wl_egl_window_destroy(window->wl.native);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
if (window->wl.xdg.toplevel)
xdg_toplevel_destroy(window->wl.xdg.toplevel);
if (window->wl.xdg.surface)
xdg_surface_destroy(window->wl.xdg.surface);
Shortened Wayland platform prefix.
2014-03-19 15:20:32 +00:00
if (window->wl.surface)
wl_surface_destroy(window->wl.surface);
Wayland: Implement HiDPI support Windows now keep track of the monitors they are on, so we can calculate the best scaling factor for them, by using the maximum of each of the monitors. The compositor scales down the buffer automatically when it is on a lower density monitor, instead of the previous way where it was scaling up the buffer on higher density monitors, which makes the application look much better on those ones.
2015-10-10 15:35:06 +00:00
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(window->wl.title);
_glfw_free(window->wl.monitors);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowTitleWayland(_GLFWwindow* window, const char* title)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
wayland: Handle hidden window as no shell surface
2016-04-08 23:51:48 +00:00
if (window->wl.title)
Add pluggable heap allocator This adds the glfwInitAllocator function for specifying a custom memory allocator to use instead of the C runtime library. The allocator is a struct of type GLFWallocator with fields corresponding to malloc, realloc and free, while the internal API corresponds to calloc, realloc and free. Heap allocation calls are filtered before reaching the user-provided functions, so deallocation of NULL and allocations of zero bytes are not passed on, reallocating NULL is transformed into an allocation and reallocating to size zero is transformed into deallocation. The clearing of a new block to zero is performed by the internal calloc-like function. Closes #544. Fixes #1628. Closes #1947.
2021-08-03 18:53:48 +00:00
_glfw_free(window->wl.title);
Remove use of non-standard function strdup Related to #873.
2018-01-17 10:56:35 +00:00
window->wl.title = _glfw_strdup(title);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
if (window->wl.xdg.toplevel)
xdg_toplevel_set_title(window->wl.xdg.toplevel, title);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowIconWayland(_GLFWwindow* window,
int count, const GLFWimage* images)
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
{
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNAVAILABLE,
"Wayland: The platform does not support setting the window icon");
Add glfwSetWindowIcon Adds support for setting window icons programmatically on platforms where this makes sense. Fixes #453. Closes #467.
2016-03-07 13:55:30 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowPosWayland(_GLFWwindow* window, int* xpos, int* ypos)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Removed duplicate window position clearing.
2014-08-26 12:46:02 +00:00
// A Wayland client is not aware of its position, so just warn and leave it
// as (0, 0)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNAVAILABLE,
"Wayland: The platform does not provide the window position");
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowPosWayland(_GLFWwindow* window, int xpos, int ypos)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Formatting and cleanup.
2014-03-19 15:11:19 +00:00
// A Wayland client can not set its position, so just warn
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNAVAILABLE,
"Wayland: The platform does not support setting the window position");
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowSizeWayland(_GLFWwindow* window, int* width, int* height)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
if (width)
Shortened Wayland platform prefix.
2014-03-19 15:20:32 +00:00
*width = window->wl.width;
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
if (height)
Shortened Wayland platform prefix.
2014-03-19 15:20:32 +00:00
*height = window->wl.height;
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowSizeWayland(_GLFWwindow* window, int width, int height)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Wayland: Fix glfwSetWindowSize resizing fs windows glfwSetWindowSize would change the size of fullscreen mode windows as if they were windowed mode.
2022-06-10 12:10:25 +00:00
if (window->monitor)
{
// Video mode setting is not available on Wayland
}
else
{
window->wl.width = width;
window->wl.height = height;
resizeWindow(window);
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowSizeLimitsWayland(_GLFWwindow* window,
int minwidth, int minheight,
int maxwidth, int maxheight)
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
{
Wayland: Remove wl_shell support This protocol is part of the core Wayland, but it is pretty badly designed and is missing quite a few features, and is in the process of being phased out in compositors. Its support in GLFW requires duplicating pretty much every single window management codepath. This bumps the required compositor versions to the ones which have implemented xdg-shell, approximately two years ago, which seems sensible to me.
2019-03-01 17:46:06 +00:00
if (window->wl.xdg.toplevel)
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
{
Wayland: Remove wl_shell support This protocol is part of the core Wayland, but it is pretty badly designed and is missing quite a few features, and is in the process of being phased out in compositors. Its support in GLFW requires duplicating pretty much every single window management codepath. This bumps the required compositor versions to the ones which have implemented xdg-shell, approximately two years ago, which seems sensible to me.
2019-03-01 17:46:06 +00:00
if (minwidth == GLFW_DONT_CARE || minheight == GLFW_DONT_CARE)
minwidth = minheight = 0;
if (maxwidth == GLFW_DONT_CARE || maxheight == GLFW_DONT_CARE)
maxwidth = maxheight = 0;
xdg_toplevel_set_min_size(window->wl.xdg.toplevel, minwidth, minheight);
xdg_toplevel_set_max_size(window->wl.xdg.toplevel, maxwidth, maxheight);
wl_surface_commit(window->wl.surface);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
}
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowAspectRatioWayland(_GLFWwindow* window, int numer, int denom)
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
{
wayland: Implement size limits and aspect ratio
2016-04-08 23:42:58 +00:00
// TODO: find out how to trigger a resize.
Wayland: Remove wl_shell support This protocol is part of the core Wayland, but it is pretty badly designed and is missing quite a few features, and is in the process of being phased out in compositors. Its support in GLFW requires duplicating pretty much every single window management codepath. This bumps the required compositor versions to the ones which have implemented xdg-shell, approximately two years ago, which seems sensible to me.
2019-03-01 17:46:06 +00:00
// The actual limits are checked in the xdg_toplevel::configure handler.
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNIMPLEMENTED,
"Wayland: Window aspect ratio not yet implemented");
Add size limits and aspect ratio functions Fixes #555.
2014-02-13 01:57:59 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetFramebufferSizeWayland(_GLFWwindow* window, int* width, int* height)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwGetWindowSizeWayland(window, width, height);
Wayland: Fix partial framebuffer size retrieval
2020-07-15 19:56:52 +00:00
if (width)
*width *= window->wl.scale;
if (height)
*height *= window->wl.scale;
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowFrameSizeWayland(_GLFWwindow* window,
int* left, int* top,
int* right, int* bottom)
Added missing function stub.
2014-05-04 09:51:40 +00:00
{
Wayland: Add support for xdg-decoration This allows compositors which prefer to draw the decorations around clients to do so, rather than letting GLFW draw its own decorations. The appearance is thus entirely subject to the compositor used, but should generally be better than the current solid colour decorations we have, which we continue to use when the compositor doesn’t support this protocol or tells us to draw the decorations ourselves. This new protocol has been tested against wlroots’s rootston compositor. Fixes #1257.
2018-10-01 13:05:55 +00:00
if (window->decorated && !window->monitor && !window->wl.decorations.serverSide)
Remove decorations when fullscreen
2017-12-22 16:47:07 +00:00
{
if (top)
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
*top = GLFW_CAPTION_HEIGHT;
Remove decorations when fullscreen
2017-12-22 16:47:07 +00:00
if (left)
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
*left = GLFW_BORDER_SIZE;
Remove decorations when fullscreen
2017-12-22 16:47:07 +00:00
if (right)
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
*right = GLFW_BORDER_SIZE;
Remove decorations when fullscreen
2017-12-22 16:47:07 +00:00
if (bottom)
Wayland: Rename window frame size constants
2022-06-15 23:35:59 +00:00
*bottom = GLFW_BORDER_SIZE;
Remove decorations when fullscreen
2017-12-22 16:47:07 +00:00
}
Added missing function stub.
2014-05-04 09:51:40 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetWindowContentScaleWayland(_GLFWwindow* window,
float* xscale, float* yscale)
Add content scale queries This adds glfwGetWindowContentScale and glfwGetMonitorContentScale for querying the recommended drawing scale factor for DPI-aware rendering. Parts of this patch are based on code by @ferreiradaselva. Fixes #235. Fixes #439. Fixes #677. Fixes #845. Fixes #898.
2017-08-29 17:19:00 +00:00
{
if (xscale)
*xscale = (float) window->wl.scale;
if (yscale)
*yscale = (float) window->wl.scale;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwIconifyWindowWayland(_GLFWwindow* window)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Wayland: Remove wl_shell support This protocol is part of the core Wayland, but it is pretty badly designed and is missing quite a few features, and is in the process of being phased out in compositors. Its support in GLFW requires duplicating pretty much every single window management codepath. This bumps the required compositor versions to the ones which have implemented xdg-shell, approximately two years ago, which seems sensible to me.
2019-03-01 17:46:06 +00:00
if (window->wl.xdg.toplevel)
xdg_toplevel_set_minimized(window->wl.xdg.toplevel);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwRestoreWindowWayland(_GLFWwindow* window)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Wayland: Fix missing fullscreen code path glfwRestoreWindow assumed it was only called in windowed mode.
2022-06-19 16:30:03 +00:00
if (window->monitor)
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
{
// There is no way to unset minimized, or even to know if we are
Wayland: Remove wl_shell support This protocol is part of the core Wayland, but it is pretty badly designed and is missing quite a few features, and is in the process of being phased out in compositors. Its support in GLFW requires duplicating pretty much every single window management codepath. This bumps the required compositor versions to the ones which have implemented xdg-shell, approximately two years ago, which seems sensible to me.
2019-03-01 17:46:06 +00:00
// minimized, so there is nothing to do in this case.
wayland: Implement maximized state
2016-04-08 23:54:23 +00:00
}
Wayland: Fix missing fullscreen code path glfwRestoreWindow assumed it was only called in windowed mode.
2022-06-19 16:30:03 +00:00
else
{
// We assume we are not minimized and acto only on maximization
if (window->wl.xdg.toplevel)
{
if (window->wl.maximized)
xdg_toplevel_unset_maximized(window->wl.xdg.toplevel);
}
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwMaximizeWindowWayland(_GLFWwindow* window)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
if (window->wl.xdg.toplevel)
xdg_toplevel_set_maximized(window->wl.xdg.toplevel);
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwShowWindowWayland(_GLFWwindow* window)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Ignore _glfwPlatformShowWindow when already visible
2018-01-04 20:55:36 +00:00
if (!window->wl.visible)
{
Wayland: Fix window hiding Corrects the protocol violation when creating an xdg_surface from a wl_surface that already has a buffer due to EGL buffer swaps. This commit is based on PR #1731 by @ghost, but adapted and altered: - The XDG surface and role are now only created when a window is shown to prevent application lists from showing command-line applications with off-screen-only windows - The special case of Wayland+EGL buffer swap is now in the EGL code to mirror how X11 is handled - Adaption to run-time platform selection and separate credits file Fixes #1492 Closes #1731
2020-07-13 00:47:50 +00:00
// NOTE: The XDG surface and role are created here so command-line applications
// with off-screen windows do not appear in for example the Unity dock
if (!window->wl.xdg.toplevel)
createXdgSurface(window);
Ignore _glfwPlatformShowWindow when already visible
2018-01-04 20:55:36 +00:00
window->wl.visible = GLFW_TRUE;
Wayland: Fix missing damage event on window show By definition a hidden window on Wayland does not have valid framebuffer contents. This adds a window damage (refresh) event when a window is shown, to request an initial frame for the now visible window.
2021-12-28 00:39:06 +00:00
_glfwInputWindowDamage(window);
Ignore _glfwPlatformShowWindow when already visible
2018-01-04 20:55:36 +00:00
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwHideWindowWayland(_GLFWwindow* window)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Wayland: Fix window hiding Corrects the protocol violation when creating an xdg_surface from a wl_surface that already has a buffer due to EGL buffer swaps. This commit is based on PR #1731 by @ghost, but adapted and altered: - The XDG surface and role are now only created when a window is shown to prevent application lists from showing command-line applications with off-screen-only windows - The special case of Wayland+EGL buffer swap is now in the EGL code to mirror how X11 is handled - Adaption to run-time platform selection and separate credits file Fixes #1492 Closes #1731
2020-07-13 00:47:50 +00:00
if (window->wl.visible)
wayland: Handle hidden window as no shell surface
2016-04-08 23:51:48 +00:00
{
Wayland: Fix window hiding Corrects the protocol violation when creating an xdg_surface from a wl_surface that already has a buffer due to EGL buffer swaps. This commit is based on PR #1731 by @ghost, but adapted and altered: - The XDG surface and role are now only created when a window is shown to prevent application lists from showing command-line applications with off-screen-only windows - The special case of Wayland+EGL buffer swap is now in the EGL code to mirror how X11 is handled - Adaption to run-time platform selection and separate credits file Fixes #1492 Closes #1731
2020-07-13 00:47:50 +00:00
window->wl.visible = GLFW_FALSE;
wl_surface_attach(window->wl.surface, NULL, 0, 0);
wl_surface_commit(window->wl.surface);
Wayland: Add an alternate surface role using xdg-shell This protocol matches desktops much better than the deprecated wl_shell, fixing a bunch of race conditions, removing undefined behaviour, adding missing features, and generally providing a much more user-friendly experience. Since most compositors don’t support it yet, the wl_shell_surface role is kept as fallback for now.
2017-12-03 03:08:54 +00:00
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwRequestWindowAttentionWayland(_GLFWwindow* window)
Add glfwRequestWindowAttention Related to #988.
2017-03-21 13:02:57 +00:00
{
Cleanup Closes #988.
2017-05-11 12:36:56 +00:00
// TODO
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNIMPLEMENTED,
Cleanup Closes #988.
2017-05-11 12:36:56 +00:00
"Wayland: Window attention request not implemented yet");
Add glfwRequestWindowAttention Related to #988.
2017-03-21 13:02:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwFocusWindowWayland(_GLFWwindow* window)
Add glfwFocusWindow This removes the (undocumented) behavior where glfwShowWindow would bring the window to front and set input focus. That function now does what it says.
2016-02-21 14:42:49 +00:00
{
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNAVAILABLE,
"Wayland: The platform does not support setting the input focus");
Add glfwFocusWindow This removes the (undocumented) behavior where glfwShowWindow would bring the window to front and set input focus. That function now does what it says.
2016-02-21 14:42:49 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowMonitorWayland(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
{
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
if (window->monitor == monitor)
wayland: Implement glfwSetWindowMonitor
2016-04-08 23:53:03 +00:00
{
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
if (!monitor)
_glfwSetWindowSizeWayland(window, width, height);
return;
wayland: Implement glfwSetWindowMonitor
2016-04-08 23:53:03 +00:00
}
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
if (window->monitor)
releaseMonitor(window);
Cleanup
2017-10-26 16:05:56 +00:00
_glfwInputWindowMonitor(window, monitor);
Wayland: Fix behavior of leaving full screen mode These changes make GLFW fullscreen more consistent, but unfortunately also make GLFW even more oblivious to user-initiated XDG shell fullscreen changes. Fixes #1995
2022-06-09 19:31:44 +00:00
if (window->monitor)
acquireMonitor(window);
else
_glfwSetWindowSizeWayland(window, width, height);
Add glfwSetWindowMonitor This adds the ability to switch between windowed and full screen modes, move a full screen window between monitors and update its desired resolution and refresh rate. Fixes #43.
2016-02-23 11:26:42 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowFocusedWayland(_GLFWwindow* window)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
wayland: Implement remaining attribute getters
2016-04-08 23:55:03 +00:00
return _glfw.wl.keyboardFocus == window;
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowIconifiedWayland(_GLFWwindow* window)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
Wayland: Remove wl_shell support This protocol is part of the core Wayland, but it is pretty badly designed and is missing quite a few features, and is in the process of being phased out in compositors. Its support in GLFW requires duplicating pretty much every single window management codepath. This bumps the required compositor versions to the ones which have implemented xdg-shell, approximately two years ago, which seems sensible to me.
2019-03-01 17:46:06 +00:00
// xdg-shell doesn’t give any way to request whether a surface is
// iconified.
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_FALSE;
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowVisibleWayland(_GLFWwindow* window)
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
{
wayland: Handle hidden window as no shell surface
2016-04-08 23:51:48 +00:00
return window->wl.visible;
Changed state attribs to direct access. Changed the window states (focused, iconified and visible) to query the system directly. THIS IS A BREAKING CHANGE, although a fairly obscure one. It affects applications that both care about telling actual key events from synthetic ones, and are implemented in a non-self-synchronizing way, and that poll the GLFW_FOCUSED window attribute instead of using the window focus callback. If you maintain one of these, please feel free to drop me an email and I'll help any way I can to transition your application to 3.1. Fixes #189. Fixes #204.
2014-12-26 11:25:48 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowMaximizedWayland(_GLFWwindow* window)
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
{
wayland: Implement maximized state
2016-04-08 23:54:23 +00:00
return window->wl.maximized;
Add glfwMaximizeWindow and GLFW_MAXIMIZED Fixes #266.
2015-10-13 10:50:59 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwWindowHoveredWayland(_GLFWwindow* window)
Add GLFW_HOVERED for polling cursor hover state This window attribute corresponds to the cursor enter/leave callback. Fixes #1166.
2018-01-04 12:50:58 +00:00
{
return window->wl.hovered;
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwFramebufferTransparentWayland(_GLFWwindow* window)
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
{
Wayland: Add transparency support Closes #788.
2017-10-01 00:38:00 +00:00
return window->wl.transparent;
Add GLFW_TRANSPARENT attribute and documentation This completes support for window framebuffer transparency on Windows, macOS and X11. Note that the hint/attribute may be renamed before release to clarify its relationship to GLFW_OPACITY. Fixes #197. Closes #1079. Related to #663. Related to #715. Related to #723. Related to #1078.
2017-09-18 16:10:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowResizableWayland(_GLFWwindow* window, GLFWbool enabled)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
// TODO
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNIMPLEMENTED,
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
"Wayland: Window attribute setting not implemented yet");
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowDecoratedWayland(_GLFWwindow* window, GLFWbool enabled)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
Remove decorations when fullscreen
2017-12-22 16:47:07 +00:00
if (!window->monitor)
{
if (enabled)
createDecorations(window);
else
destroyDecorations(window);
}
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowFloatingWayland(_GLFWwindow* window, GLFWbool enabled)
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
{
// TODO
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNIMPLEMENTED,
Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.
2016-09-29 23:52:22 +00:00
"Wayland: Window attribute setting not implemented yet");
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowMousePassthroughWayland(_GLFWwindow* window, GLFWbool enabled)
Add support for mouse input transparency This adds the GLFW_MOUSE_PASSTHROUGH window hint and attribute for controlling whether mouse input passes through the window to whatever window is behind it. Fixes #1236. Closes #1568.
2019-09-30 12:44:43 +00:00
{
if (enabled)
{
struct wl_region* region = wl_compositor_create_region(_glfw.wl.compositor);
wl_surface_set_input_region(window->wl.surface, region);
wl_region_destroy(region);
}
else
wl_surface_set_input_region(window->wl.surface, 0);
wl_surface_commit(window->wl.surface);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
float _glfwGetWindowOpacityWayland(_GLFWwindow* window)
Add glfwGetWindowOpacity and glfwSetWindowOpacity This adds support for setting the opacity of the whole window, including any decorations. Fixes #1089.
2017-09-25 21:14:45 +00:00
{
return 1.f;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetWindowOpacityWayland(_GLFWwindow* window, float opacity)
Add glfwGetWindowOpacity and glfwSetWindowOpacity This adds support for setting the opacity of the whole window, including any decorations. Fixes #1089.
2017-09-25 21:14:45 +00:00
{
Add feature available/implemented errors This adds two new error codes: GLFW_FEATURE_UNAVAILABLE for when a GLFW feature cannot be reasonably implemented on that platform, and GLFW_FEATURE_UNIMPLEMENTED for when it can be but has not been yet. This replaces the current situation where the Wayland code emitted GLFW_PLATFORM_ERROR in both cases while the macOS code silently did nothing. If your application exits on any GLFW error, these error codes should at least be easy to filter out from that behavior. Ideally, GLFW_FEATURE_UNAVAILABLE should be rare and GLFW_FEATURE_UNIMPLEMENTED should never be emitted at all. Fixes #1692.
2020-05-20 16:02:58 +00:00
_glfwInputError(GLFW_FEATURE_UNAVAILABLE,
"Wayland: The platform does not support setting the window opacity");
Add glfwGetWindowOpacity and glfwSetWindowOpacity This adds support for setting the opacity of the whole window, including any decorations. Fixes #1089.
2017-09-25 21:14:45 +00:00
}
Wayland: Clean up pointer declarations Adapt style to match the rest of the project.
2022-03-23 17:55:22 +00:00
void _glfwSetRawMouseMotionWayland(_GLFWwindow* window, GLFWbool enabled)
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
{
Wayland: Implement raw mouse motion control Related to #1400. Related to #1401.
2019-02-22 13:48:46 +00:00
// This is handled in relativePointerHandleRelativeMotion
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
GLFWbool _glfwRawMouseMotionSupportedWayland(void)
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
{
Wayland: Implement raw mouse motion control Related to #1400. Related to #1401.
2019-02-22 13:48:46 +00:00
return GLFW_TRUE;
Add GLFW_RAW_INPUT and glfwRawInputSupported This adds runtime per-window control of whether accelerated or raw mouse motion is provided when the cursor is disabled. Fixes #1400. Closes #1401.
2018-12-14 02:08:25 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwPollEventsWayland(void)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Share X11 fd polling logic with Wayland This moves the X11 polling implementation to a separate file where it can be used by either the X11 or Wayland backend or both. This code should be POSIX compatible where necessary but will use the lower latency but non-standard polling functions ppoll or pollts where those are available. This commit is based on work by OlivierSohn and kovidgoyal. Fixes #1281 Closes #1285
2022-03-03 20:26:11 +00:00
double timeout = 0.0;
handleEvents(&timeout);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwWaitEventsWayland(void)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Share X11 fd polling logic with Wayland This moves the X11 polling implementation to a separate file where it can be used by either the X11 or Wayland backend or both. This code should be POSIX compatible where necessary but will use the lower latency but non-standard polling functions ppoll or pollts where those are available. This commit is based on work by OlivierSohn and kovidgoyal. Fixes #1281 Closes #1285
2022-03-03 20:26:11 +00:00
handleEvents(NULL);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwWaitEventsTimeoutWayland(double timeout)
Add glfwWaitEventsTimeout This function will put the calling thread to sleep until an event arrives or until the specified timeout has elapsed.
2016-02-02 20:11:16 +00:00
{
Share X11 fd polling logic with Wayland This moves the X11 polling implementation to a separate file where it can be used by either the X11 or Wayland backend or both. This code should be POSIX compatible where necessary but will use the lower latency but non-standard polling functions ppoll or pollts where those are available. This commit is based on work by OlivierSohn and kovidgoyal. Fixes #1281 Closes #1285
2022-03-03 20:26:11 +00:00
handleEvents(&timeout);
Add glfwWaitEventsTimeout This function will put the calling thread to sleep until an event arrives or until the specified timeout has elapsed.
2016-02-02 20:11:16 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwPostEmptyEventWayland(void)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Shortened Wayland platform prefix.
2014-03-19 15:20:32 +00:00
wl_display_sync(_glfw.wl.display);
Wayland: Fix glfwPostEmptyEvent not always working The display sync requests in glfwPostEmptyEvent could just accumulate as the display was never flushed on secondary threads. This adds a proper flush after each sync request. Fixes #1520 Closes #1521
2022-03-03 20:46:50 +00:00
flushDisplay();
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetCursorPosWayland(_GLFWwindow* window, double* xpos, double* ypos)
Fixed broken Mir and Wayland builds. Fixes #411.
2015-01-06 00:23:10 +00:00
{
wayland: Implement glfwGetCursorPos Closes #499.
2015-04-15 16:18:42 +00:00
if (xpos)
wayland: Fix typo introduced in e253beaa. Closes #502.
2015-04-19 16:54:04 +00:00
*xpos = window->wl.cursorPosX;
wayland: Implement glfwGetCursorPos Closes #499.
2015-04-15 16:18:42 +00:00
if (ypos)
wayland: Fix typo introduced in e253beaa. Closes #502.
2015-04-19 16:54:04 +00:00
*ypos = window->wl.cursorPosY;
Fixed broken Mir and Wayland builds. Fixes #411.
2015-01-06 00:23:10 +00:00
}
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
static GLFWbool isPointerLocked(_GLFWwindow* window);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetCursorPosWayland(_GLFWwindow* window, double x, double y)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
if (isPointerLocked(window))
{
zwp_locked_pointer_v1_set_cursor_position_hint(
window->wl.pointerLock.lockedPointer,
wl_fixed_from_double(x), wl_fixed_from_double(y));
wl_surface_commit(window->wl.surface);
}
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetCursorModeWayland(_GLFWwindow* window, int mode)
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
{
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
_glfwSetCursorWayland(window, window->wl.currentCursor);
Introduce experimental Wayland backend This patch introduces a new backend that enables GLFW applications to run on Wayland. For now, only output is supported (windowed and fullscreen). Pointer cursor management, input devices, clipboard etc are not supported yet. There are some concepts that can not be supported, more specifically glfwSetWindowPos, glfwGetWindowPos and glfwSetCursorPos, as they are not supported by Wayland. This patch also changes the time and joystick implementations used by the X11 backend to be shared between the Wayland backend and the X11 backend.
2014-03-17 21:53:43 +00:00
}
Formatting and cleanup.
2014-03-19 15:11:19 +00:00
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
const char* _glfwGetScancodeNameWayland(int scancode)
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
{
Wayland: Implement key name support
2021-12-29 22:45:06 +00:00
if (scancode < 0 || scancode > 255 ||
_glfw.wl.keycodes[scancode] == GLFW_KEY_UNKNOWN)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Wayland: Invalid scancode %i",
scancode);
return NULL;
}
const int key = _glfw.wl.keycodes[scancode];
const xkb_keycode_t keycode = scancode + 8;
const xkb_layout_index_t layout =
xkb_state_key_get_layout(_glfw.wl.xkb.state, keycode);
if (layout == XKB_LAYOUT_INVALID)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to retrieve layout for key name");
return NULL;
}
const xkb_keysym_t* keysyms = NULL;
xkb_keymap_key_get_syms_by_level(_glfw.wl.xkb.keymap,
keycode,
layout,
0,
&keysyms);
if (keysyms == NULL)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to retrieve keysym for key name");
return NULL;
}
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
const uint32_t codepoint = _glfwKeySym2Unicode(keysyms[0]);
if (codepoint == GLFW_INVALID_CODEPOINT)
Wayland: Implement key name support
2021-12-29 22:45:06 +00:00
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to retrieve codepoint for key name");
return NULL;
}
Clean up internal Unicode code point handling Call code points by their name and store them as uint32_t.
2021-12-30 18:09:53 +00:00
const size_t count = _glfwEncodeUTF8(_glfw.wl.keynames[key], codepoint);
Wayland: Implement key name support
2021-12-29 22:45:06 +00:00
if (count == 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to encode codepoint for key name");
return NULL;
}
_glfw.wl.keynames[key][count] = '\0';
return _glfw.wl.keynames[key];
Add glfwGetKeyName Fixes #464.
2015-07-02 12:24:50 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
int _glfwGetKeyScancodeWayland(int key)
Add glfwGetKeyScancode Allows retrieval of platform scancode from GLFW_KEY_*. Implemented for Win32, Cocoa and X11. Stubs for Mir and Wayland. Closes #830.
2016-08-11 17:11:40 +00:00
{
Cleanup
2016-09-07 13:43:39 +00:00
return _glfw.wl.scancodes[key];
Add glfwGetKeyScancode Allows retrieval of platform scancode from GLFW_KEY_*. Implemented for Win32, Cocoa and X11. Stubs for Mir and Wayland. Closes #830.
2016-08-11 17:11:40 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwCreateCursorWayland(_GLFWcursor* cursor,
const GLFWimage* image,
int xhot, int yhot)
Added cursor stubs to Wayland backend.
2014-03-27 16:29:22 +00:00
{
Split shm buffer creation out of _glfwPlatformCreateCursor
2017-12-19 16:25:00 +00:00
cursor->wl.buffer = createShmBuffer(image);
Wayland: Check for buffer creation failure This prevents unusable decoration objects from being created, and invalid cursors from being returned to the user.
2018-09-29 20:59:00 +00:00
if (!cursor->wl.buffer)
return GLFW_FALSE;
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
cursor->wl.width = image->width;
cursor->wl.height = image->height;
cursor->wl.xhot = xhot;
cursor->wl.yhot = yhot;
Replace GL booleans with public macros
2015-08-23 17:30:04 +00:00
return GLFW_TRUE;
Added cursor stubs to Wayland backend.
2014-03-27 16:29:22 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwCreateStandardCursorWayland(_GLFWcursor* cursor, int shape)
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
{
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
const char* name = NULL;
// Try the XDG names first
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
switch (shape)
{
case GLFW_ARROW_CURSOR:
name = "default";
break;
case GLFW_IBEAM_CURSOR:
name = "text";
break;
case GLFW_CROSSHAIR_CURSOR:
name = "crosshair";
break;
case GLFW_POINTING_HAND_CURSOR:
name = "pointer";
break;
case GLFW_RESIZE_EW_CURSOR:
name = "ew-resize";
break;
case GLFW_RESIZE_NS_CURSOR:
name = "ns-resize";
break;
case GLFW_RESIZE_NWSE_CURSOR:
name = "nwse-resize";
break;
case GLFW_RESIZE_NESW_CURSOR:
name = "nesw-resize";
break;
case GLFW_RESIZE_ALL_CURSOR:
name = "all-scroll";
break;
case GLFW_NOT_ALLOWED_CURSOR:
name = "not-allowed";
break;
}
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
cursor->wl.cursor = wl_cursor_theme_get_cursor(_glfw.wl.cursorTheme, name);
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
if (_glfw.wl.cursorThemeHiDPI)
Cleanup
2015-10-24 21:40:02 +00:00
{
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
cursor->wl.cursorHiDPI =
wl_cursor_theme_get_cursor(_glfw.wl.cursorThemeHiDPI, name);
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
}
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
if (!cursor->wl.cursor)
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
{
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
// Fall back to the core X11 names
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
switch (shape)
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
{
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_ARROW_CURSOR:
name = "left_ptr";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_IBEAM_CURSOR:
name = "xterm";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_CROSSHAIR_CURSOR:
name = "crosshair";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_POINTING_HAND_CURSOR:
name = "hand2";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_RESIZE_EW_CURSOR:
name = "sb_h_double_arrow";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_RESIZE_NS_CURSOR:
name = "sb_v_double_arrow";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
case GLFW_RESIZE_ALL_CURSOR:
name = "fleur";
Wayland: Fix standard cursor name selection Regression introduced by 08e5a1706318e4fd32366a88d0778a9f545175af.
2021-09-02 16:30:41 +00:00
break;
Use switch statement instead of if-else-chain for cursor shapes Closes #1739.
2020-07-23 16:22:23 +00:00
default:
_glfwInputError(GLFW_CURSOR_UNAVAILABLE,
"Wayland: Standard cursor shape unavailable");
return GLFW_FALSE;
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
}
cursor->wl.cursor = wl_cursor_theme_get_cursor(_glfw.wl.cursorTheme, name);
if (!cursor->wl.cursor)
{
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
_glfwInputError(GLFW_CURSOR_UNAVAILABLE,
Add more standard cursors This adds the standard cursors for diagonal and omnidirectional resize/move and operation-not-allowed. It also adds new (better?) names for the horizontal and vertical resize/move and pointing hand cursors. References: - https://developer.apple.com/documentation/appkit/nscursor - https://stackoverflow.com/questions/10733228/ - https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setsystemcursor - https://freedesktop.org/wiki/Specifications/cursor-spec/ - https://tronche.com/gui/x/xlib/appendix/b/ Related to #427.
2019-05-07 18:40:37 +00:00
"Wayland: Failed to create standard cursor \"%s\"",
name);
return GLFW_FALSE;
}
if (_glfw.wl.cursorThemeHiDPI)
{
if (!cursor->wl.cursorHiDPI)
{
cursor->wl.cursorHiDPI =
wl_cursor_theme_get_cursor(_glfw.wl.cursorThemeHiDPI, name);
}
}
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
}
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
return GLFW_TRUE;
Added glfwCreateStandardCursor. This function allows the creation of cursor objects using one of several standard cursor shapes from the current system cursor theme.
2014-09-02 14:52:16 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwDestroyCursorWayland(_GLFWcursor* cursor)
Added cursor stubs to Wayland backend.
2014-03-27 16:29:22 +00:00
{
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
// If it's a standard cursor we don't need to do anything here
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
if (cursor->wl.cursor)
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
return;
Wayland: Make sure the cursor buffer is valid Fixes #645.
2015-11-16 21:57:36 +00:00
if (cursor->wl.buffer)
wl_buffer_destroy(cursor->wl.buffer);
Added cursor stubs to Wayland backend.
2014-03-27 16:29:22 +00:00
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void relativePointerHandleRelativeMotion(void* userData,
Wayland: Rename handlers for more unicity
2018-09-29 19:01:03 +00:00
struct zwp_relative_pointer_v1* pointer,
uint32_t timeHi,
uint32_t timeLo,
wl_fixed_t dx,
wl_fixed_t dy,
wl_fixed_t dxUnaccel,
wl_fixed_t dyUnaccel)
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
{
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
_GLFWwindow* window = userData;
Wayland: Implement raw mouse motion control Related to #1400. Related to #1401.
2019-02-22 13:48:46 +00:00
double xpos = window->virtualCursorPosX;
double ypos = window->virtualCursorPosY;
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
if (window->cursorMode != GLFW_CURSOR_DISABLED)
return;
Wayland: Implement raw mouse motion control Related to #1400. Related to #1401.
2019-02-22 13:48:46 +00:00
if (window->rawMouseMotion)
{
xpos += wl_fixed_to_double(dxUnaccel);
ypos += wl_fixed_to_double(dyUnaccel);
}
else
{
xpos += wl_fixed_to_double(dx);
ypos += wl_fixed_to_double(dy);
}
_glfwInputCursorPos(window, xpos, ypos);
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct zwp_relative_pointer_v1_listener relativePointerListener =
{
Wayland: Rename handlers for more unicity
2018-09-29 19:01:03 +00:00
relativePointerHandleRelativeMotion
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
};
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void lockedPointerHandleLocked(void* userData,
Wayland: Rename handlers for more unicity
2018-09-29 19:01:03 +00:00
struct zwp_locked_pointer_v1* lockedPointer)
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
{
}
static void unlockPointer(_GLFWwindow* window)
{
struct zwp_relative_pointer_v1* relativePointer =
window->wl.pointerLock.relativePointer;
struct zwp_locked_pointer_v1* lockedPointer =
window->wl.pointerLock.lockedPointer;
zwp_relative_pointer_v1_destroy(relativePointer);
zwp_locked_pointer_v1_destroy(lockedPointer);
window->wl.pointerLock.relativePointer = NULL;
window->wl.pointerLock.lockedPointer = NULL;
}
static void lockPointer(_GLFWwindow* window);
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void lockedPointerHandleUnlocked(void* userData,
Wayland: Rename handlers for more unicity
2018-09-29 19:01:03 +00:00
struct zwp_locked_pointer_v1* lockedPointer)
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
{
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct zwp_locked_pointer_v1_listener lockedPointerListener =
{
Wayland: Rename handlers for more unicity
2018-09-29 19:01:03 +00:00
lockedPointerHandleLocked,
lockedPointerHandleUnlocked
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
};
static void lockPointer(_GLFWwindow* window)
{
struct zwp_relative_pointer_v1* relativePointer;
struct zwp_locked_pointer_v1* lockedPointer;
if (!_glfw.wl.relativePointerManager)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: no relative pointer manager");
return;
}
relativePointer =
zwp_relative_pointer_manager_v1_get_relative_pointer(
_glfw.wl.relativePointerManager,
_glfw.wl.pointer);
zwp_relative_pointer_v1_add_listener(relativePointer,
&relativePointerListener,
window);
lockedPointer =
zwp_pointer_constraints_v1_lock_pointer(
_glfw.wl.pointerConstraints,
window->wl.surface,
_glfw.wl.pointer,
NULL,
ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT);
zwp_locked_pointer_v1_add_listener(lockedPointer,
&lockedPointerListener,
window);
window->wl.pointerLock.relativePointer = relativePointer;
window->wl.pointerLock.lockedPointer = lockedPointer;
Wayland: Fix cursor offset when shape changes The Wayland protocol spec[1] states that set_cursor must be called with the serial number of the enter event. However, GLFW is passing in the serial number of the latest received event, which does not meet the protocol spec. [1] https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_pointer As a result, set_cursor calls were simply ignored by the compositor. This fix complies with the protocol more closely by specifically caching the enter event serial, and using it for all set_cursor calls. Fixes #1706 Closes #1899
2021-05-12 07:30:14 +00:00
wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.pointerEnterSerial,
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
NULL, 0, 0);
}
static GLFWbool isPointerLocked(_GLFWwindow* window)
{
return window->wl.pointerLock.lockedPointer != NULL;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetCursorWayland(_GLFWwindow* window, _GLFWcursor* cursor)
Added cursor stubs to Wayland backend.
2014-03-27 16:29:22 +00:00
{
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
struct wl_cursor* defaultCursor;
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
struct wl_cursor* defaultCursorHiDPI = NULL;
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
if (!_glfw.wl.pointer)
return;
window->wl.currentCursor = cursor;
// If we're not in the correct window just save the cursor
// the next time the pointer enters the window the cursor will change
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
if (window != _glfw.wl.pointerFocus || window->wl.decorations.focus != mainWindow)
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
return;
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
// Unlock possible pointer lock if no longer disabled.
if (window->cursorMode != GLFW_CURSOR_DISABLED && isPointerLocked(window))
unlockPointer(window);
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
Cleanup
2015-10-24 21:40:02 +00:00
if (cursor)
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
setCursorImage(window, &cursor->wl);
Cleanup
2015-10-24 21:40:02 +00:00
else
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
{
Implement glfwCreateStandardCursor for Wayland Closes #620.
2015-10-22 23:28:16 +00:00
defaultCursor = wl_cursor_theme_get_cursor(_glfw.wl.cursorTheme,
"left_ptr");
if (!defaultCursor)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Standard cursor not found");
return;
}
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
if (_glfw.wl.cursorThemeHiDPI)
defaultCursorHiDPI =
wl_cursor_theme_get_cursor(_glfw.wl.cursorThemeHiDPI,
"left_ptr");
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
_GLFWcursorWayland cursorWayland = {
defaultCursor,
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
defaultCursorHiDPI,
Wayland: Add support for animated standard cursors
2018-09-08 18:05:40 +00:00
NULL,
0, 0,
0, 0,
0
};
Wayland: Use HiDPI cursors for standard cursors
2018-09-11 12:24:43 +00:00
setCursorImage(window, &cursorWayland);
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
}
}
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
else if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
if (!isPointerLocked(window))
lockPointer(window);
}
else if (window->cursorMode == GLFW_CURSOR_HIDDEN)
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
{
Wayland: Fix cursor offset when shape changes The Wayland protocol spec[1] states that set_cursor must be called with the serial number of the enter event. However, GLFW is passing in the serial number of the latest received event, which does not meet the protocol spec. [1] https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_pointer As a result, set_cursor calls were simply ignored by the compositor. This fix complies with the protocol more closely by specifically caching the enter event serial, and using it for all set_cursor calls. Fixes #1706 Closes #1899
2021-05-12 07:30:14 +00:00
wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.pointerEnterSerial, NULL, 0, 0);
wayland: Support for setting a cursor image Closes #346.
2014-09-09 14:37:55 +00:00
}
Added cursor stubs to Wayland backend.
2014-03-27 16:29:22 +00:00
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void dataSourceHandleTarget(void* userData,
Wayland: Rename data transfer parameters No rationale beyond personal preference.
2022-03-23 17:52:06 +00:00
struct wl_data_source* source,
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
const char* mimeType)
{
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
if (_glfw.wl.selectionSource != source)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unknown clipboard data source");
return;
}
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void dataSourceHandleSend(void* userData,
Wayland: Rename data transfer parameters No rationale beyond personal preference.
2022-03-23 17:52:06 +00:00
struct wl_data_source* source,
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
const char* mimeType,
int fd)
{
Wayland: Remove error reporting of external bugs Not sure that GLFW should be reporting that another client has made an invalid receive request.
2022-03-24 19:45:00 +00:00
// Ignore it if this is an outdated or invalid request
if (_glfw.wl.selectionSource != source ||
strcmp(mimeType, "text/plain;charset=utf-8") != 0)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
Wayland: Fix error paths not closing sending fd Whatever error happens on our end, we should still close the fd so the other end can move on.
2022-03-23 19:08:12 +00:00
close(fd);
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
return;
}
Wayland: Clean up clipboard writing
2022-03-24 19:34:04 +00:00
char* string = _glfw.wl.clipboardString;
size_t length = strlen(string);
while (length > 0)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
Wayland: Clean up clipboard writing
2022-03-24 19:34:04 +00:00
const ssize_t result = write(fd, string, length);
if (result == -1)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
Wayland: Clean up clipboard writing
2022-03-24 19:34:04 +00:00
if (errno == EINTR)
continue;
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Add strerror output to error descriptions
2022-03-24 18:04:58 +00:00
"Wayland: Error while writing the clipboard: %s",
strerror(errno));
Wayland: Clean up clipboard writing
2022-03-24 19:34:04 +00:00
break;
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
}
Wayland: Clean up clipboard writing
2022-03-24 19:34:04 +00:00
length -= result;
string += result;
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
}
Wayland: Clean up clipboard writing
2022-03-24 19:34:04 +00:00
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
close(fd);
}
Wayland: Rename listener user data parameters
2022-03-23 17:58:08 +00:00
static void dataSourceHandleCancelled(void* userData,
Wayland: Rename data transfer parameters No rationale beyond personal preference.
2022-03-23 17:52:06 +00:00
struct wl_data_source* source)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
Wayland: Rename data transfer parameters No rationale beyond personal preference.
2022-03-23 17:52:06 +00:00
wl_data_source_destroy(source);
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
if (_glfw.wl.selectionSource != source)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
return;
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
_glfw.wl.selectionSource = NULL;
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
}
Wayland: Clean up listener struct initialization Adapt style to match the rest of the project.
2022-03-31 20:17:08 +00:00
static const struct wl_data_source_listener dataSourceListener =
{
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
dataSourceHandleTarget,
dataSourceHandleSend,
dataSourceHandleCancelled,
};
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwSetClipboardStringWayland(const char* string)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
if (_glfw.wl.selectionSource)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
wl_data_source_destroy(_glfw.wl.selectionSource);
_glfw.wl.selectionSource = NULL;
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
}
Wayland: Make data offer reading a generic utility This will be needed for drag and drop reception as well.
2022-03-29 17:00:18 +00:00
char* copy = _glfw_strdup(string);
if (!copy)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
Wayland: Make data offer reading a generic utility This will be needed for drag and drop reception as well.
2022-03-29 17:00:18 +00:00
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
return;
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
}
Wayland: Fix handling of clipboard set to self Passing any part of the result of glfwGetClipboardString to glfwSetClipboardString would result in, at best, a use-after-free error.
2022-03-22 17:46:57 +00:00
Wayland: Make data offer reading a generic utility This will be needed for drag and drop reception as well.
2022-03-29 17:00:18 +00:00
_glfw_free(_glfw.wl.clipboardString);
_glfw.wl.clipboardString = copy;
Wayland: Fix handling of clipboard set to self Passing any part of the result of glfwGetClipboardString to glfwSetClipboardString would result in, at best, a use-after-free error.
2022-03-22 17:46:57 +00:00
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
_glfw.wl.selectionSource =
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
wl_data_device_manager_create_data_source(_glfw.wl.dataDeviceManager);
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
if (!_glfw.wl.selectionSource)
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
{
_glfwInputError(GLFW_PLATFORM_ERROR,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: Failed to create clipboard data source");
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
return;
}
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
wl_data_source_add_listener(_glfw.wl.selectionSource,
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
&dataSourceListener,
NULL);
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
wl_data_source_offer(_glfw.wl.selectionSource, "text/plain;charset=utf-8");
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
wl_data_device_set_selection(_glfw.wl.dataDevice,
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
_glfw.wl.selectionSource,
Wayland: Implement clipboard copy
2018-10-10 18:31:26 +00:00
_glfw.wl.serial);
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
const char* _glfwGetClipboardStringWayland(void)
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
{
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
if (!_glfw.wl.selectionOffer)
Wayland: Implement clipboard paste
2018-10-10 17:21:26 +00:00
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
Wayland: Fix phrasing and type of error messages
2022-03-22 18:30:43 +00:00
"Wayland: No clipboard data available");
Wayland: Implement clipboard paste
2018-10-10 17:21:26 +00:00
return NULL;
}
Wayland: Improve handling of pending data offers The code assumed that all data offers were selections that supported plaintext UTF-8. The initial data offer events are now handled almost tolerably. Only selection data offers are used for clipboard string and only if they provide plaintext UTF-8. Drag and drop data offers are now rejected as soon as they enter a surface. Related to #2040
2022-03-23 18:58:33 +00:00
if (_glfw.wl.selectionSource)
Wayland: Simplify clipboard string allocation
2022-03-24 17:02:48 +00:00
return _glfw.wl.clipboardString;
Wayland: Return our clipboard without roundtrips
2022-03-24 13:51:24 +00:00
Wayland: Make data offer reading a generic utility This will be needed for drag and drop reception as well.
2022-03-29 17:00:18 +00:00
_glfw_free(_glfw.wl.clipboardString);
_glfw.wl.clipboardString =
readDataOfferAsString(_glfw.wl.selectionOffer, "text/plain;charset=utf-8");
Wayland: Implement clipboard paste
2018-10-10 17:21:26 +00:00
return _glfw.wl.clipboardString;
Merged clipboard code into input.
2014-09-09 14:26:57 +00:00
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
EGLenum _glfwGetEGLPlatformWayland(EGLint** attribs)
EGL: Add support for EGL_EXT_platform_base This adds support for EGL_EXT_platform_base and its associated X11 and Wayland extensions, allowing us to explicitly tell EGL which window system we are using. This is based on work by @linkmauve in #1691. Closes #1691.
2020-06-03 20:02:25 +00:00
{
if (_glfw.egl.EXT_platform_base && _glfw.egl.EXT_platform_wayland)
return EGL_PLATFORM_WAYLAND_EXT;
else
return 0;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
EGLNativeDisplayType _glfwGetEGLNativeDisplayWayland(void)
EGL: Replace native handle macros with functions This change is in preparation both for EGL_EXT_platform_base and runtime GLFW platform selection. Related to #1691.
2020-06-03 18:49:36 +00:00
{
return _glfw.wl.display;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
EGLNativeWindowType _glfwGetEGLNativeWindowWayland(_GLFWwindow* window)
EGL: Replace native handle macros with functions This change is in preparation both for EGL_EXT_platform_base and runtime GLFW platform selection. Related to #1691.
2020-06-03 18:49:36 +00:00
{
return window->wl.native;
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
void _glfwGetRequiredInstanceExtensionsWayland(char** extensions)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_wayland_surface)
return;
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
Simplify Vulkan extension checks Related to #478.
2016-08-22 18:25:52 +00:00
extensions[0] = "VK_KHR_surface";
extensions[1] = "VK_KHR_wayland_surface";
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
}
Fix return type of functions returning bool values
2022-05-22 12:40:00 +00:00
GLFWbool _glfwGetPhysicalDevicePresentationSupportWayland(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
Cleanup Break up some overly long lines.
2017-09-17 12:39:17 +00:00
PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
vkGetPhysicalDeviceWaylandPresentationSupportKHR =
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
(PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
if (!vkGetPhysicalDeviceWaylandPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Wayland: Vulkan instance missing VK_KHR_wayland_surface extension");
return VK_NULL_HANDLE;
}
return vkGetPhysicalDeviceWaylandPresentationSupportKHR(device,
queuefamily,
_glfw.wl.display);
}
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
VkResult _glfwCreateWindowSurfaceWayland(VkInstance instance,
_GLFWwindow* window,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
Add basic Vulkan support Added GLFW_INCLUDE_VULKAN. Added glfwVulkanSupported, glfwGetRequiredInstanceExtensions, glfwGetInstanceProcAddress, glfwGetPhysicalDevicePresentationSupport and glfwCreateWindowSurface. Added port of LunarG SDK tri example.
2015-08-10 18:19:04 +00:00
{
VkResult err;
VkWaylandSurfaceCreateInfoKHR sci;
PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
vkCreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR");
if (!vkCreateWaylandSurfaceKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Wayland: Vulkan instance missing VK_KHR_wayland_surface extension");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
sci.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
sci.display = _glfw.wl.display;
sci.surface = window->wl.surface;
err = vkCreateWaylandSurfaceKHR(instance, &sci, allocator, surface);
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create Vulkan surface: %s",
_glfwGetVulkanResultString(err));
}
return err;
}
Add native Wayland and Mir functions Fixes #419.
2015-08-16 20:02:31 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
GLFWAPI struct wl_display* glfwGetWaylandDisplay(void)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE,
"Wayland: Platform not initialized");
return NULL;
}
Add native Wayland and Mir functions Fixes #419.
2015-08-16 20:02:31 +00:00
return _glfw.wl.display;
}
GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE,
"Wayland: Platform not initialized");
return NULL;
}
Add native Wayland and Mir functions Fixes #419.
2015-08-16 20:02:31 +00:00
return window->wl.surface;
}
Reference in New Issue Copy Permalink