Navy.gif/glfw
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e6a32db7b9
glfw/src/wl_init.c

668 lines
22 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 22:53:43 +01:00
//========================================================================
Start 3.3
2016-08-18 23:42:15 +02:00
// GLFW 3.3 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 22:53:43 +01: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.
//
//========================================================================
#include "internal.h"
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
#include <linux/input.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 22:53:43 +01:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
#include <sys/mman.h>
#include <unistd.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 22:53:43 +01:00
#include <wayland-client.h>
#include <wayland-cursor.h>
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 17:35:06 +02:00
static inline int min(int n1, int n2)
{
return n1 < n2 ? n1 : n2;
}
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
static void pointerHandleEnter(void* data,
struct wl_pointer* pointer,
uint32_t serial,
struct wl_surface* surface,
wl_fixed_t sx,
wl_fixed_t sy)
{
_GLFWwindow* window = wl_surface_get_user_data(surface);
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
_glfw.wl.pointerSerial = serial;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
_glfw.wl.pointerFocus = window;
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
_glfwPlatformSetCursor(window, window->wl.currentCursor);
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
_glfwInputCursorEnter(window, GLFW_TRUE);
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void pointerHandleLeave(void* data,
struct wl_pointer* pointer,
uint32_t serial,
struct wl_surface* surface)
{
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 22:55:43 +02:00
_GLFWwindow* window = _glfw.wl.pointerFocus;
if (!window)
return;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
_glfw.wl.pointerSerial = serial;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
_glfw.wl.pointerFocus = NULL;
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
_glfwInputCursorEnter(window, GLFW_FALSE);
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void pointerHandleMotion(void* data,
struct wl_pointer* pointer,
uint32_t time,
wl_fixed_t sx,
wl_fixed_t sy)
{
_GLFWwindow* window = _glfw.wl.pointerFocus;
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 22:55:43 +02:00
if (!window)
return;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
if (window->cursorMode == GLFW_CURSOR_DISABLED)
return;
wayland: Implement glfwGetCursorPos Closes #499.
2015-04-15 18:18:42 +02:00
else
{
window->wl.cursorPosX = wl_fixed_to_double(sx);
window->wl.cursorPosY = wl_fixed_to_double(sy);
}
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
Move all cursor positioning to platform code Due to Wayland, shared code cannot rely on cursor positioning being supported by the underlying platform. This implicitly fixes #617 as it moves cursor centering into _glfwPlatformSetCursorMode, thus separating it from the stale value of _glfw.cursorWindow. Fixes #617.
2016-05-25 14:06:02 +02:00
_glfwInputCursorPos(window,
wl_fixed_to_double(sx),
wl_fixed_to_double(sy));
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void pointerHandleButton(void* data,
struct wl_pointer* wl_pointer,
uint32_t serial,
uint32_t time,
uint32_t button,
uint32_t state)
{
_GLFWwindow* window = _glfw.wl.pointerFocus;
int glfwButton;
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 22:55:43 +02:00
if (!window)
return;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
/* 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,
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
_glfw.wl.xkb.modifiers);
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void pointerHandleAxis(void* data,
struct wl_pointer* wl_pointer,
uint32_t time,
uint32_t axis,
wl_fixed_t value)
{
_GLFWwindow* window = _glfw.wl.pointerFocus;
double scroll_factor;
double x, y;
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 22:55:43 +02:00
if (!window)
return;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
/* 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. */
scroll_factor = 1.0/10.0;
switch (axis)
{
case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
x = wl_fixed_to_double(value) * scroll_factor;
y = 0.0;
break;
case WL_POINTER_AXIS_VERTICAL_SCROLL:
x = 0.0;
y = wl_fixed_to_double(value) * scroll_factor;
break;
default:
break;
}
_glfwInputScroll(window, x, y);
}
static const struct wl_pointer_listener pointerListener = {
pointerHandleEnter,
pointerHandleLeave,
pointerHandleMotion,
pointerHandleButton,
pointerHandleAxis,
};
static void keyboardHandleKeymap(void* data,
struct wl_keyboard* keyboard,
uint32_t format,
int fd,
uint32_t size)
{
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
struct xkb_keymap* keymap;
struct xkb_state* state;
char* mapStr;
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
{
close(fd);
return;
}
mapStr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (mapStr == MAP_FAILED) {
close(fd);
return;
}
keymap = xkb_map_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_map_unref(keymap);
return;
}
xkb_keymap_unref(_glfw.wl.xkb.keymap);
xkb_state_unref(_glfw.wl.xkb.state);
_glfw.wl.xkb.keymap = keymap;
_glfw.wl.xkb.state = state;
_glfw.wl.xkb.control_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Control");
_glfw.wl.xkb.alt_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
_glfw.wl.xkb.shift_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
_glfw.wl.xkb.super_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void keyboardHandleEnter(void* data,
struct wl_keyboard* keyboard,
uint32_t serial,
struct wl_surface* surface,
struct wl_array* keys)
{
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
_GLFWwindow* window = wl_surface_get_user_data(surface);
_glfw.wl.keyboardFocus = window;
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
_glfwInputWindowFocus(window, GLFW_TRUE);
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void keyboardHandleLeave(void* data,
struct wl_keyboard* keyboard,
uint32_t serial,
struct wl_surface* surface)
{
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
_GLFWwindow* window = _glfw.wl.keyboardFocus;
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 22:55:43 +02:00
if (!window)
return;
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
_glfw.wl.keyboardFocus = NULL;
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
_glfwInputWindowFocus(window, GLFW_FALSE);
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
}
static int toGLFWKeyCode(uint32_t key)
{
Cleanup
2016-09-07 15:43:39 +02:00
if (key < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
return _glfw.wl.keycodes[key];
Make Wayland and Mir backends use key LUTs
2015-11-12 15:06:46 +01:00
return GLFW_KEY_UNKNOWN;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void keyboardHandleKey(void* data,
struct wl_keyboard* keyboard,
uint32_t serial,
uint32_t time,
uint32_t key,
uint32_t state)
{
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
uint32_t code, num_syms;
wayland: Follow _glfwInputChar() type change
2014-06-30 09:07:36 +02:00
long cp;
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
int keyCode;
int action;
const xkb_keysym_t *syms;
_GLFWwindow* window = _glfw.wl.keyboardFocus;
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 22:55:43 +02:00
if (!window)
return;
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
keyCode = toGLFWKeyCode(key);
action = state == WL_KEYBOARD_KEY_STATE_PRESSED
? GLFW_PRESS : GLFW_RELEASE;
_glfwInputKey(window, keyCode, key, action,
_glfw.wl.xkb.modifiers);
code = key + 8;
num_syms = xkb_key_get_syms(_glfw.wl.xkb.state, code, &syms);
if (num_syms == 1)
{
wayland: Follow _glfwInputChar() type change
2014-06-30 09:07:36 +02:00
cp = _glfwKeySym2Unicode(syms[0]);
if (cp != -1)
{
const int mods = _glfw.wl.xkb.modifiers;
const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
_glfwInputChar(window, cp, mods, plain);
}
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
}
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static void keyboardHandleModifiers(void* data,
struct wl_keyboard* keyboard,
uint32_t serial,
uint32_t modsDepressed,
uint32_t modsLatched,
uint32_t modsLocked,
uint32_t group)
{
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
xkb_mod_mask_t mask;
unsigned int modifiers = 0;
if (!_glfw.wl.xkb.keymap)
return;
xkb_state_update_mask(_glfw.wl.xkb.state,
modsDepressed,
modsLatched,
modsLocked,
0,
0,
group);
mask = xkb_state_serialize_mods(_glfw.wl.xkb.state,
XKB_STATE_DEPRESSED |
XKB_STATE_LATCHED);
if (mask & _glfw.wl.xkb.control_mask)
modifiers |= GLFW_MOD_CONTROL;
if (mask & _glfw.wl.xkb.alt_mask)
modifiers |= GLFW_MOD_ALT;
if (mask & _glfw.wl.xkb.shift_mask)
modifiers |= GLFW_MOD_SHIFT;
if (mask & _glfw.wl.xkb.super_mask)
modifiers |= GLFW_MOD_SUPER;
_glfw.wl.xkb.modifiers = modifiers;
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
}
static const struct wl_keyboard_listener keyboardListener = {
keyboardHandleKeymap,
keyboardHandleEnter,
keyboardHandleLeave,
keyboardHandleKey,
keyboardHandleModifiers,
};
static void seatHandleCapabilities(void* data,
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 const struct wl_seat_listener seatListener = {
seatHandleCapabilities
};
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 22:53:43 +01:00
static void registryHandleGlobal(void* data,
struct wl_registry* registry,
uint32_t name,
const char* interface,
uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0)
{
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 03:42:45 +01:00
_glfw.wl.wl_compositor_version = min(3, version);
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
_glfw.wl.compositor =
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 17:35:06 +02:00
wl_registry_bind(registry, name, &wl_compositor_interface,
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 03:42:45 +01:00
_glfw.wl.wl_compositor_version);
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 22:53:43 +01:00
}
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
else if (strcmp(interface, "wl_shm") == 0)
{
_glfw.wl.shm =
wl_registry_bind(registry, name, &wl_shm_interface, 1);
}
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 22:53:43 +01:00
else if (strcmp(interface, "wl_shell") == 0)
{
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
_glfw.wl.shell =
wayland: Fix indentation
2014-06-29 12:22:23 +02:00
wl_registry_bind(registry, name, &wl_shell_interface, 1);
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 22:53:43 +01:00
}
else if (strcmp(interface, "wl_output") == 0)
{
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 18:16:46 +01:00
_glfwAddOutputWayland(name, version);
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 22:53:43 +01:00
}
wayland: Add basic input support
2014-06-29 12:29:00 +02:00
else if (strcmp(interface, "wl_seat") == 0)
{
if (!_glfw.wl.seat)
{
_glfw.wl.seat =
wl_registry_bind(registry, name, &wl_seat_interface, 1);
wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
}
}
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 08:29:37 +01:00
else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0)
{
_glfw.wl.relativePointerManager =
wl_registry_bind(registry, name,
&zwp_relative_pointer_manager_v1_interface,
1);
}
else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0)
{
_glfw.wl.pointerConstraints =
wl_registry_bind(registry, name,
&zwp_pointer_constraints_v1_interface,
1);
}
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 22:53:43 +01:00
}
static void registryHandleGlobalRemove(void *data,
struct wl_registry *registry,
uint32_t name)
{
}
static const struct wl_registry_listener registryListener = {
registryHandleGlobal,
registryHandleGlobalRemove
};
Make Wayland and Mir backends use key LUTs
2015-11-12 15:06:46 +01:00
// Create key code translation tables
//
static void createKeyTables(void)
{
Add scancode arrays for Wayland and Mir Related to #830.
2016-08-14 14:42:47 +02:00
int scancode;
Cleanup
2016-09-07 15:43:39 +02:00
memset(_glfw.wl.keycodes, -1, sizeof(_glfw.wl.keycodes));
memset(_glfw.wl.scancodes, -1, sizeof(_glfw.wl.scancodes));
_glfw.wl.keycodes[KEY_GRAVE] = GLFW_KEY_GRAVE_ACCENT;
_glfw.wl.keycodes[KEY_1] = GLFW_KEY_1;
_glfw.wl.keycodes[KEY_2] = GLFW_KEY_2;
_glfw.wl.keycodes[KEY_3] = GLFW_KEY_3;
_glfw.wl.keycodes[KEY_4] = GLFW_KEY_4;
_glfw.wl.keycodes[KEY_5] = GLFW_KEY_5;
_glfw.wl.keycodes[KEY_6] = GLFW_KEY_6;
_glfw.wl.keycodes[KEY_7] = GLFW_KEY_7;
_glfw.wl.keycodes[KEY_8] = GLFW_KEY_8;
_glfw.wl.keycodes[KEY_9] = GLFW_KEY_9;
_glfw.wl.keycodes[KEY_0] = GLFW_KEY_0;
_glfw.wl.keycodes[KEY_MINUS] = GLFW_KEY_MINUS;
_glfw.wl.keycodes[KEY_EQUAL] = GLFW_KEY_EQUAL;
_glfw.wl.keycodes[KEY_Q] = GLFW_KEY_Q;
_glfw.wl.keycodes[KEY_W] = GLFW_KEY_W;
_glfw.wl.keycodes[KEY_E] = GLFW_KEY_E;
_glfw.wl.keycodes[KEY_R] = GLFW_KEY_R;
_glfw.wl.keycodes[KEY_T] = GLFW_KEY_T;
_glfw.wl.keycodes[KEY_Y] = GLFW_KEY_Y;
_glfw.wl.keycodes[KEY_U] = GLFW_KEY_U;
_glfw.wl.keycodes[KEY_I] = GLFW_KEY_I;
_glfw.wl.keycodes[KEY_O] = GLFW_KEY_O;
_glfw.wl.keycodes[KEY_P] = GLFW_KEY_P;
_glfw.wl.keycodes[KEY_LEFTBRACE] = GLFW_KEY_LEFT_BRACKET;
_glfw.wl.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
_glfw.wl.keycodes[KEY_A] = GLFW_KEY_A;
_glfw.wl.keycodes[KEY_S] = GLFW_KEY_S;
_glfw.wl.keycodes[KEY_D] = GLFW_KEY_D;
_glfw.wl.keycodes[KEY_F] = GLFW_KEY_F;
_glfw.wl.keycodes[KEY_G] = GLFW_KEY_G;
_glfw.wl.keycodes[KEY_H] = GLFW_KEY_H;
_glfw.wl.keycodes[KEY_J] = GLFW_KEY_J;
_glfw.wl.keycodes[KEY_K] = GLFW_KEY_K;
_glfw.wl.keycodes[KEY_L] = GLFW_KEY_L;
_glfw.wl.keycodes[KEY_SEMICOLON] = GLFW_KEY_SEMICOLON;
_glfw.wl.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
_glfw.wl.keycodes[KEY_Z] = GLFW_KEY_Z;
_glfw.wl.keycodes[KEY_X] = GLFW_KEY_X;
_glfw.wl.keycodes[KEY_C] = GLFW_KEY_C;
_glfw.wl.keycodes[KEY_V] = GLFW_KEY_V;
_glfw.wl.keycodes[KEY_B] = GLFW_KEY_B;
_glfw.wl.keycodes[KEY_N] = GLFW_KEY_N;
_glfw.wl.keycodes[KEY_M] = GLFW_KEY_M;
_glfw.wl.keycodes[KEY_COMMA] = GLFW_KEY_COMMA;
_glfw.wl.keycodes[KEY_DOT] = GLFW_KEY_PERIOD;
_glfw.wl.keycodes[KEY_SLASH] = GLFW_KEY_SLASH;
_glfw.wl.keycodes[KEY_BACKSLASH] = GLFW_KEY_BACKSLASH;
_glfw.wl.keycodes[KEY_ESC] = GLFW_KEY_ESCAPE;
_glfw.wl.keycodes[KEY_TAB] = GLFW_KEY_TAB;
_glfw.wl.keycodes[KEY_LEFTSHIFT] = GLFW_KEY_LEFT_SHIFT;
_glfw.wl.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
_glfw.wl.keycodes[KEY_LEFTCTRL] = GLFW_KEY_LEFT_CONTROL;
_glfw.wl.keycodes[KEY_RIGHTCTRL] = GLFW_KEY_RIGHT_CONTROL;
_glfw.wl.keycodes[KEY_LEFTALT] = GLFW_KEY_LEFT_ALT;
_glfw.wl.keycodes[KEY_RIGHTALT] = GLFW_KEY_RIGHT_ALT;
_glfw.wl.keycodes[KEY_LEFTMETA] = GLFW_KEY_LEFT_SUPER;
_glfw.wl.keycodes[KEY_RIGHTMETA] = GLFW_KEY_RIGHT_SUPER;
_glfw.wl.keycodes[KEY_MENU] = GLFW_KEY_MENU;
_glfw.wl.keycodes[KEY_NUMLOCK] = GLFW_KEY_NUM_LOCK;
_glfw.wl.keycodes[KEY_CAPSLOCK] = GLFW_KEY_CAPS_LOCK;
_glfw.wl.keycodes[KEY_PRINT] = GLFW_KEY_PRINT_SCREEN;
_glfw.wl.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
_glfw.wl.keycodes[KEY_PAUSE] = GLFW_KEY_PAUSE;
_glfw.wl.keycodes[KEY_DELETE] = GLFW_KEY_DELETE;
_glfw.wl.keycodes[KEY_BACKSPACE] = GLFW_KEY_BACKSPACE;
_glfw.wl.keycodes[KEY_ENTER] = GLFW_KEY_ENTER;
_glfw.wl.keycodes[KEY_HOME] = GLFW_KEY_HOME;
_glfw.wl.keycodes[KEY_END] = GLFW_KEY_END;
_glfw.wl.keycodes[KEY_PAGEUP] = GLFW_KEY_PAGE_UP;
_glfw.wl.keycodes[KEY_PAGEDOWN] = GLFW_KEY_PAGE_DOWN;
_glfw.wl.keycodes[KEY_INSERT] = GLFW_KEY_INSERT;
_glfw.wl.keycodes[KEY_LEFT] = GLFW_KEY_LEFT;
_glfw.wl.keycodes[KEY_RIGHT] = GLFW_KEY_RIGHT;
_glfw.wl.keycodes[KEY_DOWN] = GLFW_KEY_DOWN;
_glfw.wl.keycodes[KEY_UP] = GLFW_KEY_UP;
_glfw.wl.keycodes[KEY_F1] = GLFW_KEY_F1;
_glfw.wl.keycodes[KEY_F2] = GLFW_KEY_F2;
_glfw.wl.keycodes[KEY_F3] = GLFW_KEY_F3;
_glfw.wl.keycodes[KEY_F4] = GLFW_KEY_F4;
_glfw.wl.keycodes[KEY_F5] = GLFW_KEY_F5;
_glfw.wl.keycodes[KEY_F6] = GLFW_KEY_F6;
_glfw.wl.keycodes[KEY_F7] = GLFW_KEY_F7;
_glfw.wl.keycodes[KEY_F8] = GLFW_KEY_F8;
_glfw.wl.keycodes[KEY_F9] = GLFW_KEY_F9;
_glfw.wl.keycodes[KEY_F10] = GLFW_KEY_F10;
_glfw.wl.keycodes[KEY_F11] = GLFW_KEY_F11;
_glfw.wl.keycodes[KEY_F12] = GLFW_KEY_F12;
_glfw.wl.keycodes[KEY_F13] = GLFW_KEY_F13;
_glfw.wl.keycodes[KEY_F14] = GLFW_KEY_F14;
_glfw.wl.keycodes[KEY_F15] = GLFW_KEY_F15;
_glfw.wl.keycodes[KEY_F16] = GLFW_KEY_F16;
_glfw.wl.keycodes[KEY_F17] = GLFW_KEY_F17;
_glfw.wl.keycodes[KEY_F18] = GLFW_KEY_F18;
_glfw.wl.keycodes[KEY_F19] = GLFW_KEY_F19;
_glfw.wl.keycodes[KEY_F20] = GLFW_KEY_F20;
_glfw.wl.keycodes[KEY_F21] = GLFW_KEY_F21;
_glfw.wl.keycodes[KEY_F22] = GLFW_KEY_F22;
_glfw.wl.keycodes[KEY_F23] = GLFW_KEY_F23;
_glfw.wl.keycodes[KEY_F24] = GLFW_KEY_F24;
_glfw.wl.keycodes[KEY_KPSLASH] = GLFW_KEY_KP_DIVIDE;
_glfw.wl.keycodes[KEY_KPDOT] = GLFW_KEY_KP_MULTIPLY;
_glfw.wl.keycodes[KEY_KPMINUS] = GLFW_KEY_KP_SUBTRACT;
_glfw.wl.keycodes[KEY_KPPLUS] = GLFW_KEY_KP_ADD;
_glfw.wl.keycodes[KEY_KP0] = GLFW_KEY_KP_0;
_glfw.wl.keycodes[KEY_KP1] = GLFW_KEY_KP_1;
_glfw.wl.keycodes[KEY_KP2] = GLFW_KEY_KP_2;
_glfw.wl.keycodes[KEY_KP3] = GLFW_KEY_KP_3;
_glfw.wl.keycodes[KEY_KP4] = GLFW_KEY_KP_4;
_glfw.wl.keycodes[KEY_KP5] = GLFW_KEY_KP_5;
_glfw.wl.keycodes[KEY_KP6] = GLFW_KEY_KP_6;
_glfw.wl.keycodes[KEY_KP7] = GLFW_KEY_KP_7;
_glfw.wl.keycodes[KEY_KP8] = GLFW_KEY_KP_8;
_glfw.wl.keycodes[KEY_KP9] = GLFW_KEY_KP_9;
_glfw.wl.keycodes[KEY_KPCOMMA] = GLFW_KEY_KP_DECIMAL;
_glfw.wl.keycodes[KEY_KPEQUAL] = GLFW_KEY_KP_EQUAL;
_glfw.wl.keycodes[KEY_KPENTER] = GLFW_KEY_KP_ENTER;
Add scancode arrays for Wayland and Mir Related to #830.
2016-08-14 14:42:47 +02:00
for (scancode = 0; scancode < 256; scancode++)
{
Cleanup
2016-09-07 15:43:39 +02:00
if (_glfw.wl.keycodes[scancode] > 0)
_glfw.wl.scancodes[_glfw.wl.keycodes[scancode]] = scancode;
Add scancode arrays for Wayland and Mir Related to #830.
2016-08-14 14:42:47 +02:00
}
Make Wayland and Mir backends use key LUTs
2015-11-12 15:06:46 +01: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 22:53:43 +01:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
int _glfwPlatformInit(void)
{
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
_glfw.wl.display = wl_display_connect(NULL);
if (!_glfw.wl.display)
Wayland error reporting work.
2014-03-19 16:32:50 +01:00
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to connect to display");
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
return GLFW_FALSE;
Wayland error reporting work.
2014-03-19 16:32:50 +01: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 22:53:43 +01:00
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
_glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
wl_registry_add_listener(_glfw.wl.registry, &registryListener, 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 22:53:43 +01:00
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
_glfw.wl.monitors = calloc(4, sizeof(_GLFWmonitor*));
_glfw.wl.monitorsSize = 4;
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 22:53:43 +01:00
Make Wayland and Mir backends use key LUTs
2015-11-12 15:06:46 +01:00
createKeyTables();
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
_glfw.wl.xkb.context = xkb_context_new(0);
if (!_glfw.wl.xkb.context)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to initialize xkb context");
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
return GLFW_FALSE;
wayland: Add keyboard support Adds libxkbcommon as a dependency when enabling the Wayland backend.
2014-06-29 23:09:21 +02:00
}
Formatting and cleanup.
2014-03-19 16:11:19 +01:00
// Sync so we got all registry objects
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
wl_display_roundtrip(_glfw.wl.display);
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 22:53:43 +01:00
Formatting and cleanup.
2014-03-19 16:11:19 +01:00
// Sync so we got all initial output events
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
wl_display_roundtrip(_glfw.wl.display);
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 22:53:43 +01:00
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 18:16:46 +01:00
if (!_glfwInitThreadLocalStoragePOSIX())
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
return GLFW_FALSE;
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 22:53:43 +01:00
Check Linux joystick init on Wayland and Mir
2015-12-10 17:02:35 +01:00
if (!_glfwInitJoysticksLinux())
return GLFW_FALSE;
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 18:16:46 +01:00
_glfwInitTimerPOSIX();
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 22:53:43 +01:00
wayland: Coding style cleanup Fixes * positioning, indentation and newline inconsistencies.
2014-09-28 21:54:09 +02:00
if (_glfw.wl.pointer && _glfw.wl.shm)
{
wayland: Default to 32 cursor image size This is the default across various toolkits (weston, GTK+ for example) so lets stick to that.
2014-09-28 21:51:12 +02:00
_glfw.wl.cursorTheme = wl_cursor_theme_load(NULL, 32, _glfw.wl.shm);
wayland: Coding style cleanup Fixes * positioning, indentation and newline inconsistencies.
2014-09-28 21:54:09 +02:00
if (!_glfw.wl.cursorTheme)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unable to load default cursor theme\n");
Replace GL booleans with public macros
2015-08-23 19:30:04 +02:00
return GLFW_FALSE;
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
}
wayland: Coding style cleanup Fixes * positioning, indentation and newline inconsistencies.
2014-09-28 21:54:09 +02:00
_glfw.wl.cursorSurface =
wl_compositor_create_surface(_glfw.wl.compositor);
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
}
Replace GL booleans with public macros
2015-08-23 19:30:04 +02: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 22:53:43 +01:00
}
void _glfwPlatformTerminate(void)
{
Add suffixes to platform specific helper functions Also merge win32_tls.h into win32_platform.h.
2015-12-03 18:16:46 +01:00
_glfwTerminateEGL();
_glfwTerminateJoysticksLinux();
_glfwTerminateThreadLocalStoragePOSIX();
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 22:53:43 +01:00
wayland: Support for setting a cursor image Closes #346.
2014-09-09 16:37:55 +02:00
if (_glfw.wl.cursorTheme)
wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
if (_glfw.wl.cursorSurface)
wl_surface_destroy(_glfw.wl.cursorSurface);
Shortened Wayland platform prefix.
2014-03-19 16:20:32 +01:00
if (_glfw.wl.registry)
wl_registry_destroy(_glfw.wl.registry);
if (_glfw.wl.display)
wl_display_flush(_glfw.wl.display);
if (_glfw.wl.display)
wl_display_disconnect(_glfw.wl.display);
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 22:53:43 +01:00
}
const char* _glfwPlatformGetVersionString(void)
{
Simplified version string functions.
2015-06-01 20:50:10 +02:00
return _GLFW_VERSION_NUMBER " Wayland EGL"
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 22:53:43 +01:00
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
Added missing entries to Linux version strings.
2015-06-01 19:15:55 +02:00
#else
" gettimeofday"
#endif
#if defined(__linux__)
" /dev/js"
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 22:53:43 +01:00
#endif
#if defined(_GLFW_BUILD_DLL)
" shared"
#endif
;
}
Formatting and cleanup.
2014-03-19 16:11:19 +01:00
Reference in New Issue Copy Permalink