suwako / ShaderPlayground

master
ブランチ master
ShaderPlayground / deps / glfw / src / wl_init.c
45.2 KB、1324行 生 Blame 履歴
1//========================================================================
2// GLFW 3.3 Wayland - www.glfw.org
3//------------------------------------------------------------------------
4// Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
5//
6// This software is provided 'as-is', without any express or implied
7// warranty. In no event will the authors be held liable for any damages
8// arising from the use of this software.
9//
10// Permission is granted to anyone to use this software for any purpose,
11// including commercial applications, and to alter it and redistribute it
12// freely, subject to the following restrictions:
13//
14// 1. The origin of this software must not be misrepresented; you must not
15// claim that you wrote the original software. If you use this software
16// in a product, an acknowledgment in the product documentation would
17// be appreciated but is not required.
18//
19// 2. Altered source versions must be plainly marked as such, and must not
20// be misrepresented as being the original software.
21//
22// 3. This notice may not be removed or altered from any source
23// distribution.
24//
25//========================================================================
26// It is fine to use C99 in this file because it will not be built with VS
27//========================================================================
28
29#include "internal.h"
30
31#include <assert.h>
32#include <errno.h>
33#include <limits.h>
34#include <linux/input.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38#include <sys/mman.h>
39#include <sys/timerfd.h>
40#include <unistd.h>
41#include <wayland-client.h>
42
43
44static inline int min(int n1, int n2)
45{
46 return n1 < n2 ? n1 : n2;
47}
48
49static _GLFWwindow* findWindowFromDecorationSurface(struct wl_surface* surface,
50 int* which)
51{
52 int focus;
53 _GLFWwindow* window = _glfw.windowListHead;
54 if (!which)
55 which = &focus;
56 while (window)
57 {
58 if (surface == window->wl.decorations.top.surface)
59 {
60 *which = topDecoration;
61 break;
62 }
63 if (surface == window->wl.decorations.left.surface)
64 {
65 *which = leftDecoration;
66 break;
67 }
68 if (surface == window->wl.decorations.right.surface)
69 {
70 *which = rightDecoration;
71 break;
72 }
73 if (surface == window->wl.decorations.bottom.surface)
74 {
75 *which = bottomDecoration;
76 break;
77 }
78 window = window->next;
79 }
80 return window;
81}
82
83static void pointerHandleEnter(void* data,
84 struct wl_pointer* pointer,
85 uint32_t serial,
86 struct wl_surface* surface,
87 wl_fixed_t sx,
88 wl_fixed_t sy)
89{
90 // Happens in the case we just destroyed the surface.
91 if (!surface)
92 return;
93
94 int focus = 0;
95 _GLFWwindow* window = wl_surface_get_user_data(surface);
96 if (!window)
97 {
98 window = findWindowFromDecorationSurface(surface, &focus);
99 if (!window)
100 return;
101 }
102
103 window->wl.decorations.focus = focus;
104 _glfw.wl.serial = serial;
105 _glfw.wl.pointerFocus = window;
106
107 window->wl.hovered = GLFW_TRUE;
108
109 _glfwPlatformSetCursor(window, window->wl.currentCursor);
110 _glfwInputCursorEnter(window, GLFW_TRUE);
111}
112
113static void pointerHandleLeave(void* data,
114 struct wl_pointer* pointer,
115 uint32_t serial,
116 struct wl_surface* surface)
117{
118 _GLFWwindow* window = _glfw.wl.pointerFocus;
119
120 if (!window)
121 return;
122
123 window->wl.hovered = GLFW_FALSE;
124
125 _glfw.wl.serial = serial;
126 _glfw.wl.pointerFocus = NULL;
127 _glfwInputCursorEnter(window, GLFW_FALSE);
128 _glfw.wl.cursorPreviousName = NULL;
129}
130
131static void setCursor(_GLFWwindow* window, const char* name)
132{
133 struct wl_buffer* buffer;
134 struct wl_cursor* cursor;
135 struct wl_cursor_image* image;
136 struct wl_surface* surface = _glfw.wl.cursorSurface;
137 struct wl_cursor_theme* theme = _glfw.wl.cursorTheme;
138 int scale = 1;
139
140 if (window->wl.scale > 1 && _glfw.wl.cursorThemeHiDPI)
141 {
142 // We only support up to scale=2 for now, since libwayland-cursor
143 // requires us to load a different theme for each size.
144 scale = 2;
145 theme = _glfw.wl.cursorThemeHiDPI;
146 }
147
148 cursor = wl_cursor_theme_get_cursor(theme, name);
149 if (!cursor)
150 {
151 _glfwInputError(GLFW_PLATFORM_ERROR,
152 "Wayland: Standard cursor not found");
153 return;
154 }
155 // TODO: handle animated cursors too.
156 image = cursor->images[0];
157
158 if (!image)
159 return;
160
161 buffer = wl_cursor_image_get_buffer(image);
162 if (!buffer)
163 return;
164 wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.serial,
165 surface,
166 image->hotspot_x / scale,
167 image->hotspot_y / scale);
168 wl_surface_set_buffer_scale(surface, scale);
169 wl_surface_attach(surface, buffer, 0, 0);
170 wl_surface_damage(surface, 0, 0,
171 image->width, image->height);
172 wl_surface_commit(surface);
173 _glfw.wl.cursorPreviousName = name;
174}
175
176static void pointerHandleMotion(void* data,
177 struct wl_pointer* pointer,
178 uint32_t time,
179 wl_fixed_t sx,
180 wl_fixed_t sy)
181{
182 _GLFWwindow* window = _glfw.wl.pointerFocus;
183 const char* cursorName = NULL;
184 double x, y;
185
186 if (!window)
187 return;
188
189 if (window->cursorMode == GLFW_CURSOR_DISABLED)
190 return;
191 x = wl_fixed_to_double(sx);
192 y = wl_fixed_to_double(sy);
193
194 switch (window->wl.decorations.focus)
195 {
196 case mainWindow:
197 window->wl.cursorPosX = x;
198 window->wl.cursorPosY = y;
199 _glfwInputCursorPos(window, x, y);
200 _glfw.wl.cursorPreviousName = NULL;
201 return;
202 case topDecoration:
203 if (y < _GLFW_DECORATION_WIDTH)
204 cursorName = "n-resize";
205 else
206 cursorName = "left_ptr";
207 break;
208 case leftDecoration:
209 if (y < _GLFW_DECORATION_WIDTH)
210 cursorName = "nw-resize";
211 else
212 cursorName = "w-resize";
213 break;
214 case rightDecoration:
215 if (y < _GLFW_DECORATION_WIDTH)
216 cursorName = "ne-resize";
217 else
218 cursorName = "e-resize";
219 break;
220 case bottomDecoration:
221 if (x < _GLFW_DECORATION_WIDTH)
222 cursorName = "sw-resize";
223 else if (x > window->wl.width + _GLFW_DECORATION_WIDTH)
224 cursorName = "se-resize";
225 else
226 cursorName = "s-resize";
227 break;
228 default:
229 assert(0);
230 }
231 if (_glfw.wl.cursorPreviousName != cursorName)
232 setCursor(window, cursorName);
233}
234
235static void pointerHandleButton(void* data,
236 struct wl_pointer* pointer,
237 uint32_t serial,
238 uint32_t time,
239 uint32_t button,
240 uint32_t state)
241{
242 _GLFWwindow* window = _glfw.wl.pointerFocus;
243 int glfwButton;
244
245 // Both xdg-shell and wl_shell use the same values.
246 uint32_t edges = WL_SHELL_SURFACE_RESIZE_NONE;
247
248 if (!window)
249 return;
250 if (button == BTN_LEFT)
251 {
252 switch (window->wl.decorations.focus)
253 {
254 case mainWindow:
255 break;
256 case topDecoration:
257 if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
258 edges = WL_SHELL_SURFACE_RESIZE_TOP;
259 else
260 {
261 if (window->wl.xdg.toplevel)
262 xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
263 else
264 wl_shell_surface_move(window->wl.shellSurface, _glfw.wl.seat, serial);
265 }
266 break;
267 case leftDecoration:
268 if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
269 edges = WL_SHELL_SURFACE_RESIZE_TOP_LEFT;
270 else
271 edges = WL_SHELL_SURFACE_RESIZE_LEFT;
272 break;
273 case rightDecoration:
274 if (window->wl.cursorPosY < _GLFW_DECORATION_WIDTH)
275 edges = WL_SHELL_SURFACE_RESIZE_TOP_RIGHT;
276 else
277 edges = WL_SHELL_SURFACE_RESIZE_RIGHT;
278 break;
279 case bottomDecoration:
280 if (window->wl.cursorPosX < _GLFW_DECORATION_WIDTH)
281 edges = WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT;
282 else if (window->wl.cursorPosX > window->wl.width + _GLFW_DECORATION_WIDTH)
283 edges = WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT;
284 else
285 edges = WL_SHELL_SURFACE_RESIZE_BOTTOM;
286 break;
287 default:
288 assert(0);
289 }
290 if (edges != WL_SHELL_SURFACE_RESIZE_NONE)
291 {
292 if (window->wl.xdg.toplevel)
293 xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat,
294 serial, edges);
295 else
296 wl_shell_surface_resize(window->wl.shellSurface, _glfw.wl.seat,
297 serial, edges);
298 }
299 }
300 else if (button == BTN_RIGHT)
301 {
302 if (window->wl.decorations.focus != mainWindow && window->wl.xdg.toplevel)
303 {
304 xdg_toplevel_show_window_menu(window->wl.xdg.toplevel,
305 _glfw.wl.seat, serial,
306 window->wl.cursorPosX,
307 window->wl.cursorPosY);
308 return;
309 }
310 }
311
312 // Don’t pass the button to the user if it was related to a decoration.
313 if (window->wl.decorations.focus != mainWindow)
314 return;
315
316 _glfw.wl.serial = serial;
317
318 /* Makes left, right and middle 0, 1 and 2. Overall order follows evdev
319 * codes. */
320 glfwButton = button - BTN_LEFT;
321
322 _glfwInputMouseClick(window,
323 glfwButton,
324 state == WL_POINTER_BUTTON_STATE_PRESSED
325 ? GLFW_PRESS
326 : GLFW_RELEASE,
327 _glfw.wl.xkb.modifiers);
328}
329
330static void pointerHandleAxis(void* data,
331 struct wl_pointer* pointer,
332 uint32_t time,
333 uint32_t axis,
334 wl_fixed_t value)
335{
336 _GLFWwindow* window = _glfw.wl.pointerFocus;
337 double x = 0.0, y = 0.0;
338 // Wayland scroll events are in pointer motion coordinate space (think two
339 // finger scroll). The factor 10 is commonly used to convert to "scroll
340 // step means 1.0.
341 const double scrollFactor = 1.0 / 10.0;
342
343 if (!window)
344 return;
345
346 assert(axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL ||
347 axis == WL_POINTER_AXIS_VERTICAL_SCROLL);
348
349 if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL)
350 x = wl_fixed_to_double(value) * scrollFactor;
351 else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
352 y = wl_fixed_to_double(value) * scrollFactor;
353
354 _glfwInputScroll(window, x, y);
355}
356
357static const struct wl_pointer_listener pointerListener = {
358 pointerHandleEnter,
359 pointerHandleLeave,
360 pointerHandleMotion,
361 pointerHandleButton,
362 pointerHandleAxis,
363};
364
365static void keyboardHandleKeymap(void* data,
366 struct wl_keyboard* keyboard,
367 uint32_t format,
368 int fd,
369 uint32_t size)
370{
371 struct xkb_keymap* keymap;
372 struct xkb_state* state;
373
374#ifdef HAVE_XKBCOMMON_COMPOSE_H
375 struct xkb_compose_table* composeTable;
376 struct xkb_compose_state* composeState;
377#endif
378
379 char* mapStr;
380 const char* locale;
381
382 if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
383 {
384 close(fd);
385 return;
386 }
387
388 mapStr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
389 if (mapStr == MAP_FAILED) {
390 close(fd);
391 return;
392 }
393
394 keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
395 mapStr,
396 XKB_KEYMAP_FORMAT_TEXT_V1,
397 0);
398 munmap(mapStr, size);
399 close(fd);
400
401 if (!keymap)
402 {
403 _glfwInputError(GLFW_PLATFORM_ERROR,
404 "Wayland: Failed to compile keymap");
405 return;
406 }
407
408 state = xkb_state_new(keymap);
409 if (!state)
410 {
411 _glfwInputError(GLFW_PLATFORM_ERROR,
412 "Wayland: Failed to create XKB state");
413 xkb_keymap_unref(keymap);
414 return;
415 }
416
417 // Look up the preferred locale, falling back to "C" as default.
418 locale = getenv("LC_ALL");
419 if (!locale)
420 locale = getenv("LC_CTYPE");
421 if (!locale)
422 locale = getenv("LANG");
423 if (!locale)
424 locale = "C";
425
426#ifdef HAVE_XKBCOMMON_COMPOSE_H
427 composeTable =
428 xkb_compose_table_new_from_locale(_glfw.wl.xkb.context, locale,
429 XKB_COMPOSE_COMPILE_NO_FLAGS);
430 if (composeTable)
431 {
432 composeState =
433 xkb_compose_state_new(composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
434 xkb_compose_table_unref(composeTable);
435 if (composeState)
436 _glfw.wl.xkb.composeState = composeState;
437 else
438 _glfwInputError(GLFW_PLATFORM_ERROR,
439 "Wayland: Failed to create XKB compose state");
440 }
441 else
442 {
443 _glfwInputError(GLFW_PLATFORM_ERROR,
444 "Wayland: Failed to create XKB compose table");
445 }
446#endif
447
448 xkb_keymap_unref(_glfw.wl.xkb.keymap);
449 xkb_state_unref(_glfw.wl.xkb.state);
450 _glfw.wl.xkb.keymap = keymap;
451 _glfw.wl.xkb.state = state;
452
453 _glfw.wl.xkb.controlMask =
454 1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Control");
455 _glfw.wl.xkb.altMask =
456 1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
457 _glfw.wl.xkb.shiftMask =
458 1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
459 _glfw.wl.xkb.superMask =
460 1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
461 _glfw.wl.xkb.capsLockMask =
462 1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Lock");
463 _glfw.wl.xkb.numLockMask =
464 1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod2");
465}
466
467static void keyboardHandleEnter(void* data,
468 struct wl_keyboard* keyboard,
469 uint32_t serial,
470 struct wl_surface* surface,
471 struct wl_array* keys)
472{
473 // Happens in the case we just destroyed the surface.
474 if (!surface)
475 return;
476
477 _GLFWwindow* window = wl_surface_get_user_data(surface);
478 if (!window)
479 {
480 window = findWindowFromDecorationSurface(surface, NULL);
481 if (!window)
482 return;
483 }
484
485 _glfw.wl.serial = serial;
486 _glfw.wl.keyboardFocus = window;
487 _glfwInputWindowFocus(window, GLFW_TRUE);
488}
489
490static void keyboardHandleLeave(void* data,
491 struct wl_keyboard* keyboard,
492 uint32_t serial,
493 struct wl_surface* surface)
494{
495 _GLFWwindow* window = _glfw.wl.keyboardFocus;
496
497 if (!window)
498 return;
499
500 _glfw.wl.serial = serial;
501 _glfw.wl.keyboardFocus = NULL;
502 _glfwInputWindowFocus(window, GLFW_FALSE);
503}
504
505static int toGLFWKeyCode(uint32_t key)
506{
507 if (key < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
508 return _glfw.wl.keycodes[key];
509
510 return GLFW_KEY_UNKNOWN;
511}
512
513#ifdef HAVE_XKBCOMMON_COMPOSE_H
514static xkb_keysym_t composeSymbol(xkb_keysym_t sym)
515{
516 if (sym == XKB_KEY_NoSymbol || !_glfw.wl.xkb.composeState)
517 return sym;
518 if (xkb_compose_state_feed(_glfw.wl.xkb.composeState, sym)
519 != XKB_COMPOSE_FEED_ACCEPTED)
520 return sym;
521 switch (xkb_compose_state_get_status(_glfw.wl.xkb.composeState))
522 {
523 case XKB_COMPOSE_COMPOSED:
524 return xkb_compose_state_get_one_sym(_glfw.wl.xkb.composeState);
525 case XKB_COMPOSE_COMPOSING:
526 case XKB_COMPOSE_CANCELLED:
527 return XKB_KEY_NoSymbol;
528 case XKB_COMPOSE_NOTHING:
529 default:
530 return sym;
531 }
532}
533#endif
534
535static GLFWbool inputChar(_GLFWwindow* window, uint32_t key)
536{
537 uint32_t code, numSyms;
538 long cp;
539 const xkb_keysym_t *syms;
540 xkb_keysym_t sym;
541
542 code = key + 8;
543 numSyms = xkb_state_key_get_syms(_glfw.wl.xkb.state, code, &syms);
544
545 if (numSyms == 1)
546 {
547#ifdef HAVE_XKBCOMMON_COMPOSE_H
548 sym = composeSymbol(syms[0]);
549#else
550 sym = syms[0];
551#endif
552 cp = _glfwKeySym2Unicode(sym);
553 if (cp != -1)
554 {
555 const int mods = _glfw.wl.xkb.modifiers;
556 const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
557 _glfwInputChar(window, cp, mods, plain);
558 }
559 }
560
561 return xkb_keymap_key_repeats(_glfw.wl.xkb.keymap, syms[0]);
562}
563
564static void keyboardHandleKey(void* data,
565 struct wl_keyboard* keyboard,
566 uint32_t serial,
567 uint32_t time,
568 uint32_t key,
569 uint32_t state)
570{
571 int keyCode;
572 int action;
573 _GLFWwindow* window = _glfw.wl.keyboardFocus;
574 GLFWbool shouldRepeat;
575 struct itimerspec timer = {};
576
577 if (!window)
578 return;
579
580 keyCode = toGLFWKeyCode(key);
581 action = state == WL_KEYBOARD_KEY_STATE_PRESSED
582 ? GLFW_PRESS : GLFW_RELEASE;
583
584 _glfw.wl.serial = serial;
585 _glfwInputKey(window, keyCode, key, action,
586 _glfw.wl.xkb.modifiers);
587
588 if (action == GLFW_PRESS)
589 {
590 shouldRepeat = inputChar(window, key);
591
592 if (shouldRepeat && _glfw.wl.keyboardRepeatRate > 0)
593 {
594 _glfw.wl.keyboardLastKey = keyCode;
595 _glfw.wl.keyboardLastScancode = key;
596 if (_glfw.wl.keyboardRepeatRate > 1)
597 timer.it_interval.tv_nsec = 1000000000 / _glfw.wl.keyboardRepeatRate;
598 else
599 timer.it_interval.tv_sec = 1;
600 timer.it_value.tv_sec = _glfw.wl.keyboardRepeatDelay / 1000;
601 timer.it_value.tv_nsec = (_glfw.wl.keyboardRepeatDelay % 1000) * 1000000;
602 }
603 }
604 timerfd_settime(_glfw.wl.timerfd, 0, &timer, NULL);
605}
606
607static void keyboardHandleModifiers(void* data,
608 struct wl_keyboard* keyboard,
609 uint32_t serial,
610 uint32_t modsDepressed,
611 uint32_t modsLatched,
612 uint32_t modsLocked,
613 uint32_t group)
614{
615 xkb_mod_mask_t mask;
616 unsigned int modifiers = 0;
617
618 _glfw.wl.serial = serial;
619
620 if (!_glfw.wl.xkb.keymap)
621 return;
622
623 xkb_state_update_mask(_glfw.wl.xkb.state,
624 modsDepressed,
625 modsLatched,
626 modsLocked,
627 0,
628 0,
629 group);
630
631 mask = xkb_state_serialize_mods(_glfw.wl.xkb.state,
632 XKB_STATE_MODS_DEPRESSED |
633 XKB_STATE_LAYOUT_DEPRESSED |
634 XKB_STATE_MODS_LATCHED |
635 XKB_STATE_LAYOUT_LATCHED);
636 if (mask & _glfw.wl.xkb.controlMask)
637 modifiers |= GLFW_MOD_CONTROL;
638 if (mask & _glfw.wl.xkb.altMask)
639 modifiers |= GLFW_MOD_ALT;
640 if (mask & _glfw.wl.xkb.shiftMask)
641 modifiers |= GLFW_MOD_SHIFT;
642 if (mask & _glfw.wl.xkb.superMask)
643 modifiers |= GLFW_MOD_SUPER;
644 if (mask & _glfw.wl.xkb.capsLockMask)
645 modifiers |= GLFW_MOD_CAPS_LOCK;
646 if (mask & _glfw.wl.xkb.numLockMask)
647 modifiers |= GLFW_MOD_NUM_LOCK;
648 _glfw.wl.xkb.modifiers = modifiers;
649}
650
651#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
652static void keyboardHandleRepeatInfo(void* data,
653 struct wl_keyboard* keyboard,
654 int32_t rate,
655 int32_t delay)
656{
657 if (keyboard != _glfw.wl.keyboard)
658 return;
659
660 _glfw.wl.keyboardRepeatRate = rate;
661 _glfw.wl.keyboardRepeatDelay = delay;
662}
663#endif
664
665static const struct wl_keyboard_listener keyboardListener = {
666 keyboardHandleKeymap,
667 keyboardHandleEnter,
668 keyboardHandleLeave,
669 keyboardHandleKey,
670 keyboardHandleModifiers,
671#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
672 keyboardHandleRepeatInfo,
673#endif
674};
675
676static void seatHandleCapabilities(void* data,
677 struct wl_seat* seat,
678 enum wl_seat_capability caps)
679{
680 if ((caps & WL_SEAT_CAPABILITY_POINTER) && !_glfw.wl.pointer)
681 {
682 _glfw.wl.pointer = wl_seat_get_pointer(seat);
683 wl_pointer_add_listener(_glfw.wl.pointer, &pointerListener, NULL);
684 }
685 else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && _glfw.wl.pointer)
686 {
687 wl_pointer_destroy(_glfw.wl.pointer);
688 _glfw.wl.pointer = NULL;
689 }
690
691 if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !_glfw.wl.keyboard)
692 {
693 _glfw.wl.keyboard = wl_seat_get_keyboard(seat);
694 wl_keyboard_add_listener(_glfw.wl.keyboard, &keyboardListener, NULL);
695 }
696 else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && _glfw.wl.keyboard)
697 {
698 wl_keyboard_destroy(_glfw.wl.keyboard);
699 _glfw.wl.keyboard = NULL;
700 }
701}
702
703static void seatHandleName(void* data,
704 struct wl_seat* seat,
705 const char* name)
706{
707}
708
709static const struct wl_seat_listener seatListener = {
710 seatHandleCapabilities,
711 seatHandleName,
712};
713
714static void dataOfferHandleOffer(void* data,
715 struct wl_data_offer* dataOffer,
716 const char* mimeType)
717{
718}
719
720static const struct wl_data_offer_listener dataOfferListener = {
721 dataOfferHandleOffer,
722};
723
724static void dataDeviceHandleDataOffer(void* data,
725 struct wl_data_device* dataDevice,
726 struct wl_data_offer* id)
727{
728 if (_glfw.wl.dataOffer)
729 wl_data_offer_destroy(_glfw.wl.dataOffer);
730
731 _glfw.wl.dataOffer = id;
732 wl_data_offer_add_listener(_glfw.wl.dataOffer, &dataOfferListener, NULL);
733}
734
735static void dataDeviceHandleEnter(void* data,
736 struct wl_data_device* dataDevice,
737 uint32_t serial,
738 struct wl_surface *surface,
739 wl_fixed_t x,
740 wl_fixed_t y,
741 struct wl_data_offer *id)
742{
743}
744
745static void dataDeviceHandleLeave(void* data,
746 struct wl_data_device* dataDevice)
747{
748}
749
750static void dataDeviceHandleMotion(void* data,
751 struct wl_data_device* dataDevice,
752 uint32_t time,
753 wl_fixed_t x,
754 wl_fixed_t y)
755{
756}
757
758static void dataDeviceHandleDrop(void* data,
759 struct wl_data_device* dataDevice)
760{
761}
762
763static void dataDeviceHandleSelection(void* data,
764 struct wl_data_device* dataDevice,
765 struct wl_data_offer* id)
766{
767}
768
769static const struct wl_data_device_listener dataDeviceListener = {
770 dataDeviceHandleDataOffer,
771 dataDeviceHandleEnter,
772 dataDeviceHandleLeave,
773 dataDeviceHandleMotion,
774 dataDeviceHandleDrop,
775 dataDeviceHandleSelection,
776};
777
778static void wmBaseHandlePing(void* data,
779 struct xdg_wm_base* wmBase,
780 uint32_t serial)
781{
782 xdg_wm_base_pong(wmBase, serial);
783}
784
785static const struct xdg_wm_base_listener wmBaseListener = {
786 wmBaseHandlePing
787};
788
789static void registryHandleGlobal(void* data,
790 struct wl_registry* registry,
791 uint32_t name,
792 const char* interface,
793 uint32_t version)
794{
795 if (strcmp(interface, "wl_compositor") == 0)
796 {
797 _glfw.wl.compositorVersion = min(3, version);
798 _glfw.wl.compositor =
799 wl_registry_bind(registry, name, &wl_compositor_interface,
800 _glfw.wl.compositorVersion);
801 }
802 else if (strcmp(interface, "wl_subcompositor") == 0)
803 {
804 _glfw.wl.subcompositor =
805 wl_registry_bind(registry, name, &wl_subcompositor_interface, 1);
806 }
807 else if (strcmp(interface, "wl_shm") == 0)
808 {
809 _glfw.wl.shm =
810 wl_registry_bind(registry, name, &wl_shm_interface, 1);
811 }
812 else if (strcmp(interface, "wl_shell") == 0)
813 {
814 _glfw.wl.shell =
815 wl_registry_bind(registry, name, &wl_shell_interface, 1);
816 }
817 else if (strcmp(interface, "wl_output") == 0)
818 {
819 _glfwAddOutputWayland(name, version);
820 }
821 else if (strcmp(interface, "wl_seat") == 0)
822 {
823 if (!_glfw.wl.seat)
824 {
825 _glfw.wl.seatVersion = min(4, version);
826 _glfw.wl.seat =
827 wl_registry_bind(registry, name, &wl_seat_interface,
828 _glfw.wl.seatVersion);
829 wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
830 }
831 }
832 else if (strcmp(interface, "wl_data_device_manager") == 0)
833 {
834 if (!_glfw.wl.dataDeviceManager)
835 {
836 _glfw.wl.dataDeviceManager =
837 wl_registry_bind(registry, name,
838 &wl_data_device_manager_interface, 1);
839 }
840 }
841 else if (strcmp(interface, "xdg_wm_base") == 0)
842 {
843 _glfw.wl.wmBase =
844 wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
845 xdg_wm_base_add_listener(_glfw.wl.wmBase, &wmBaseListener, NULL);
846 }
847 else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0)
848 {
849 _glfw.wl.decorationManager =
850 wl_registry_bind(registry, name,
851 &zxdg_decoration_manager_v1_interface,
852 1);
853 }
854 else if (strcmp(interface, "wp_viewporter") == 0)
855 {
856 _glfw.wl.viewporter =
857 wl_registry_bind(registry, name, &wp_viewporter_interface, 1);
858 }
859 else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0)
860 {
861 _glfw.wl.relativePointerManager =
862 wl_registry_bind(registry, name,
863 &zwp_relative_pointer_manager_v1_interface,
864 1);
865 }
866 else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0)
867 {
868 _glfw.wl.pointerConstraints =
869 wl_registry_bind(registry, name,
870 &zwp_pointer_constraints_v1_interface,
871 1);
872 }
873 else if (strcmp(interface, "zwp_idle_inhibit_manager_v1") == 0)
874 {
875 _glfw.wl.idleInhibitManager =
876 wl_registry_bind(registry, name,
877 &zwp_idle_inhibit_manager_v1_interface,
878 1);
879 }
880}
881
882static void registryHandleGlobalRemove(void *data,
883 struct wl_registry *registry,
884 uint32_t name)
885{
886 int i;
887 _GLFWmonitor* monitor;
888
889 for (i = 0; i < _glfw.monitorCount; ++i)
890 {
891 monitor = _glfw.monitors[i];
892 if (monitor->wl.name == name)
893 {
894 _glfwInputMonitor(monitor, GLFW_DISCONNECTED, 0);
895 return;
896 }
897 }
898}
899
900
901static const struct wl_registry_listener registryListener = {
902 registryHandleGlobal,
903 registryHandleGlobalRemove
904};
905
906// Create key code translation tables
907//
908static void createKeyTables(void)
909{
910 int scancode;
911
912 memset(_glfw.wl.keycodes, -1, sizeof(_glfw.wl.keycodes));
913 memset(_glfw.wl.scancodes, -1, sizeof(_glfw.wl.scancodes));
914
915 _glfw.wl.keycodes[KEY_GRAVE] = GLFW_KEY_GRAVE_ACCENT;
916 _glfw.wl.keycodes[KEY_1] = GLFW_KEY_1;
917 _glfw.wl.keycodes[KEY_2] = GLFW_KEY_2;
918 _glfw.wl.keycodes[KEY_3] = GLFW_KEY_3;
919 _glfw.wl.keycodes[KEY_4] = GLFW_KEY_4;
920 _glfw.wl.keycodes[KEY_5] = GLFW_KEY_5;
921 _glfw.wl.keycodes[KEY_6] = GLFW_KEY_6;
922 _glfw.wl.keycodes[KEY_7] = GLFW_KEY_7;
923 _glfw.wl.keycodes[KEY_8] = GLFW_KEY_8;
924 _glfw.wl.keycodes[KEY_9] = GLFW_KEY_9;
925 _glfw.wl.keycodes[KEY_0] = GLFW_KEY_0;
926 _glfw.wl.keycodes[KEY_SPACE] = GLFW_KEY_SPACE;
927 _glfw.wl.keycodes[KEY_MINUS] = GLFW_KEY_MINUS;
928 _glfw.wl.keycodes[KEY_EQUAL] = GLFW_KEY_EQUAL;
929 _glfw.wl.keycodes[KEY_Q] = GLFW_KEY_Q;
930 _glfw.wl.keycodes[KEY_W] = GLFW_KEY_W;
931 _glfw.wl.keycodes[KEY_E] = GLFW_KEY_E;
932 _glfw.wl.keycodes[KEY_R] = GLFW_KEY_R;
933 _glfw.wl.keycodes[KEY_T] = GLFW_KEY_T;
934 _glfw.wl.keycodes[KEY_Y] = GLFW_KEY_Y;
935 _glfw.wl.keycodes[KEY_U] = GLFW_KEY_U;
936 _glfw.wl.keycodes[KEY_I] = GLFW_KEY_I;
937 _glfw.wl.keycodes[KEY_O] = GLFW_KEY_O;
938 _glfw.wl.keycodes[KEY_P] = GLFW_KEY_P;
939 _glfw.wl.keycodes[KEY_LEFTBRACE] = GLFW_KEY_LEFT_BRACKET;
940 _glfw.wl.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
941 _glfw.wl.keycodes[KEY_A] = GLFW_KEY_A;
942 _glfw.wl.keycodes[KEY_S] = GLFW_KEY_S;
943 _glfw.wl.keycodes[KEY_D] = GLFW_KEY_D;
944 _glfw.wl.keycodes[KEY_F] = GLFW_KEY_F;
945 _glfw.wl.keycodes[KEY_G] = GLFW_KEY_G;
946 _glfw.wl.keycodes[KEY_H] = GLFW_KEY_H;
947 _glfw.wl.keycodes[KEY_J] = GLFW_KEY_J;
948 _glfw.wl.keycodes[KEY_K] = GLFW_KEY_K;
949 _glfw.wl.keycodes[KEY_L] = GLFW_KEY_L;
950 _glfw.wl.keycodes[KEY_SEMICOLON] = GLFW_KEY_SEMICOLON;
951 _glfw.wl.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
952 _glfw.wl.keycodes[KEY_Z] = GLFW_KEY_Z;
953 _glfw.wl.keycodes[KEY_X] = GLFW_KEY_X;
954 _glfw.wl.keycodes[KEY_C] = GLFW_KEY_C;
955 _glfw.wl.keycodes[KEY_V] = GLFW_KEY_V;
956 _glfw.wl.keycodes[KEY_B] = GLFW_KEY_B;
957 _glfw.wl.keycodes[KEY_N] = GLFW_KEY_N;
958 _glfw.wl.keycodes[KEY_M] = GLFW_KEY_M;
959 _glfw.wl.keycodes[KEY_COMMA] = GLFW_KEY_COMMA;
960 _glfw.wl.keycodes[KEY_DOT] = GLFW_KEY_PERIOD;
961 _glfw.wl.keycodes[KEY_SLASH] = GLFW_KEY_SLASH;
962 _glfw.wl.keycodes[KEY_BACKSLASH] = GLFW_KEY_BACKSLASH;
963 _glfw.wl.keycodes[KEY_ESC] = GLFW_KEY_ESCAPE;
964 _glfw.wl.keycodes[KEY_TAB] = GLFW_KEY_TAB;
965 _glfw.wl.keycodes[KEY_LEFTSHIFT] = GLFW_KEY_LEFT_SHIFT;
966 _glfw.wl.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
967 _glfw.wl.keycodes[KEY_LEFTCTRL] = GLFW_KEY_LEFT_CONTROL;
968 _glfw.wl.keycodes[KEY_RIGHTCTRL] = GLFW_KEY_RIGHT_CONTROL;
969 _glfw.wl.keycodes[KEY_LEFTALT] = GLFW_KEY_LEFT_ALT;
970 _glfw.wl.keycodes[KEY_RIGHTALT] = GLFW_KEY_RIGHT_ALT;
971 _glfw.wl.keycodes[KEY_LEFTMETA] = GLFW_KEY_LEFT_SUPER;
972 _glfw.wl.keycodes[KEY_RIGHTMETA] = GLFW_KEY_RIGHT_SUPER;
973 _glfw.wl.keycodes[KEY_MENU] = GLFW_KEY_MENU;
974 _glfw.wl.keycodes[KEY_NUMLOCK] = GLFW_KEY_NUM_LOCK;
975 _glfw.wl.keycodes[KEY_CAPSLOCK] = GLFW_KEY_CAPS_LOCK;
976 _glfw.wl.keycodes[KEY_PRINT] = GLFW_KEY_PRINT_SCREEN;
977 _glfw.wl.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
978 _glfw.wl.keycodes[KEY_PAUSE] = GLFW_KEY_PAUSE;
979 _glfw.wl.keycodes[KEY_DELETE] = GLFW_KEY_DELETE;
980 _glfw.wl.keycodes[KEY_BACKSPACE] = GLFW_KEY_BACKSPACE;
981 _glfw.wl.keycodes[KEY_ENTER] = GLFW_KEY_ENTER;
982 _glfw.wl.keycodes[KEY_HOME] = GLFW_KEY_HOME;
983 _glfw.wl.keycodes[KEY_END] = GLFW_KEY_END;
984 _glfw.wl.keycodes[KEY_PAGEUP] = GLFW_KEY_PAGE_UP;
985 _glfw.wl.keycodes[KEY_PAGEDOWN] = GLFW_KEY_PAGE_DOWN;
986 _glfw.wl.keycodes[KEY_INSERT] = GLFW_KEY_INSERT;
987 _glfw.wl.keycodes[KEY_LEFT] = GLFW_KEY_LEFT;
988 _glfw.wl.keycodes[KEY_RIGHT] = GLFW_KEY_RIGHT;
989 _glfw.wl.keycodes[KEY_DOWN] = GLFW_KEY_DOWN;
990 _glfw.wl.keycodes[KEY_UP] = GLFW_KEY_UP;
991 _glfw.wl.keycodes[KEY_F1] = GLFW_KEY_F1;
992 _glfw.wl.keycodes[KEY_F2] = GLFW_KEY_F2;
993 _glfw.wl.keycodes[KEY_F3] = GLFW_KEY_F3;
994 _glfw.wl.keycodes[KEY_F4] = GLFW_KEY_F4;
995 _glfw.wl.keycodes[KEY_F5] = GLFW_KEY_F5;
996 _glfw.wl.keycodes[KEY_F6] = GLFW_KEY_F6;
997 _glfw.wl.keycodes[KEY_F7] = GLFW_KEY_F7;
998 _glfw.wl.keycodes[KEY_F8] = GLFW_KEY_F8;
999 _glfw.wl.keycodes[KEY_F9] = GLFW_KEY_F9;
1000 _glfw.wl.keycodes[KEY_F10] = GLFW_KEY_F10;
1001 _glfw.wl.keycodes[KEY_F11] = GLFW_KEY_F11;
1002 _glfw.wl.keycodes[KEY_F12] = GLFW_KEY_F12;
1003 _glfw.wl.keycodes[KEY_F13] = GLFW_KEY_F13;
1004 _glfw.wl.keycodes[KEY_F14] = GLFW_KEY_F14;
1005 _glfw.wl.keycodes[KEY_F15] = GLFW_KEY_F15;
1006 _glfw.wl.keycodes[KEY_F16] = GLFW_KEY_F16;
1007 _glfw.wl.keycodes[KEY_F17] = GLFW_KEY_F17;
1008 _glfw.wl.keycodes[KEY_F18] = GLFW_KEY_F18;
1009 _glfw.wl.keycodes[KEY_F19] = GLFW_KEY_F19;
1010 _glfw.wl.keycodes[KEY_F20] = GLFW_KEY_F20;
1011 _glfw.wl.keycodes[KEY_F21] = GLFW_KEY_F21;
1012 _glfw.wl.keycodes[KEY_F22] = GLFW_KEY_F22;
1013 _glfw.wl.keycodes[KEY_F23] = GLFW_KEY_F23;
1014 _glfw.wl.keycodes[KEY_F24] = GLFW_KEY_F24;
1015 _glfw.wl.keycodes[KEY_KPSLASH] = GLFW_KEY_KP_DIVIDE;
1016 _glfw.wl.keycodes[KEY_KPDOT] = GLFW_KEY_KP_MULTIPLY;
1017 _glfw.wl.keycodes[KEY_KPMINUS] = GLFW_KEY_KP_SUBTRACT;
1018 _glfw.wl.keycodes[KEY_KPPLUS] = GLFW_KEY_KP_ADD;
1019 _glfw.wl.keycodes[KEY_KP0] = GLFW_KEY_KP_0;
1020 _glfw.wl.keycodes[KEY_KP1] = GLFW_KEY_KP_1;
1021 _glfw.wl.keycodes[KEY_KP2] = GLFW_KEY_KP_2;
1022 _glfw.wl.keycodes[KEY_KP3] = GLFW_KEY_KP_3;
1023 _glfw.wl.keycodes[KEY_KP4] = GLFW_KEY_KP_4;
1024 _glfw.wl.keycodes[KEY_KP5] = GLFW_KEY_KP_5;
1025 _glfw.wl.keycodes[KEY_KP6] = GLFW_KEY_KP_6;
1026 _glfw.wl.keycodes[KEY_KP7] = GLFW_KEY_KP_7;
1027 _glfw.wl.keycodes[KEY_KP8] = GLFW_KEY_KP_8;
1028 _glfw.wl.keycodes[KEY_KP9] = GLFW_KEY_KP_9;
1029 _glfw.wl.keycodes[KEY_KPCOMMA] = GLFW_KEY_KP_DECIMAL;
1030 _glfw.wl.keycodes[KEY_KPEQUAL] = GLFW_KEY_KP_EQUAL;
1031 _glfw.wl.keycodes[KEY_KPENTER] = GLFW_KEY_KP_ENTER;
1032
1033 for (scancode = 0; scancode < 256; scancode++)
1034 {
1035 if (_glfw.wl.keycodes[scancode] > 0)
1036 _glfw.wl.scancodes[_glfw.wl.keycodes[scancode]] = scancode;
1037 }
1038}
1039
1040
1041//////////////////////////////////////////////////////////////////////////
1042////// GLFW platform API //////
1043//////////////////////////////////////////////////////////////////////////
1044
1045int _glfwPlatformInit(void)
1046{
1047 const char *cursorTheme;
1048 const char *cursorSizeStr;
1049 char *cursorSizeEnd;
1050 long cursorSizeLong;
1051 int cursorSize;
1052
1053 _glfw.wl.cursor.handle = _glfw_dlopen("libwayland-cursor.so.0");
1054 if (!_glfw.wl.cursor.handle)
1055 {
1056 _glfwInputError(GLFW_PLATFORM_ERROR,
1057 "Wayland: Failed to open libwayland-cursor");
1058 return GLFW_FALSE;
1059 }
1060
1061 _glfw.wl.cursor.theme_load = (PFN_wl_cursor_theme_load)
1062 _glfw_dlsym(_glfw.wl.cursor.handle, "wl_cursor_theme_load");
1063 _glfw.wl.cursor.theme_destroy = (PFN_wl_cursor_theme_destroy)
1064 _glfw_dlsym(_glfw.wl.cursor.handle, "wl_cursor_theme_destroy");
1065 _glfw.wl.cursor.theme_get_cursor = (PFN_wl_cursor_theme_get_cursor)
1066 _glfw_dlsym(_glfw.wl.cursor.handle, "wl_cursor_theme_get_cursor");
1067 _glfw.wl.cursor.image_get_buffer = (PFN_wl_cursor_image_get_buffer)
1068 _glfw_dlsym(_glfw.wl.cursor.handle, "wl_cursor_image_get_buffer");
1069
1070 _glfw.wl.egl.handle = _glfw_dlopen("libwayland-egl.so.1");
1071 if (!_glfw.wl.egl.handle)
1072 {
1073 _glfwInputError(GLFW_PLATFORM_ERROR,
1074 "Wayland: Failed to open libwayland-egl");
1075 return GLFW_FALSE;
1076 }
1077
1078 _glfw.wl.egl.window_create = (PFN_wl_egl_window_create)
1079 _glfw_dlsym(_glfw.wl.egl.handle, "wl_egl_window_create");
1080 _glfw.wl.egl.window_destroy = (PFN_wl_egl_window_destroy)
1081 _glfw_dlsym(_glfw.wl.egl.handle, "wl_egl_window_destroy");
1082 _glfw.wl.egl.window_resize = (PFN_wl_egl_window_resize)
1083 _glfw_dlsym(_glfw.wl.egl.handle, "wl_egl_window_resize");
1084
1085 _glfw.wl.xkb.handle = _glfw_dlopen("libxkbcommon.so.0");
1086 if (!_glfw.wl.xkb.handle)
1087 {
1088 _glfwInputError(GLFW_PLATFORM_ERROR,
1089 "Wayland: Failed to open libxkbcommon");
1090 return GLFW_FALSE;
1091 }
1092
1093 _glfw.wl.xkb.context_new = (PFN_xkb_context_new)
1094 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_context_new");
1095 _glfw.wl.xkb.context_unref = (PFN_xkb_context_unref)
1096 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_context_unref");
1097 _glfw.wl.xkb.keymap_new_from_string = (PFN_xkb_keymap_new_from_string)
1098 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_new_from_string");
1099 _glfw.wl.xkb.keymap_unref = (PFN_xkb_keymap_unref)
1100 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_unref");
1101 _glfw.wl.xkb.keymap_mod_get_index = (PFN_xkb_keymap_mod_get_index)
1102 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_mod_get_index");
1103 _glfw.wl.xkb.keymap_key_repeats = (PFN_xkb_keymap_key_repeats)
1104 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_keymap_key_repeats");
1105 _glfw.wl.xkb.state_new = (PFN_xkb_state_new)
1106 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_new");
1107 _glfw.wl.xkb.state_unref = (PFN_xkb_state_unref)
1108 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_unref");
1109 _glfw.wl.xkb.state_key_get_syms = (PFN_xkb_state_key_get_syms)
1110 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_key_get_syms");
1111 _glfw.wl.xkb.state_update_mask = (PFN_xkb_state_update_mask)
1112 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_update_mask");
1113 _glfw.wl.xkb.state_serialize_mods = (PFN_xkb_state_serialize_mods)
1114 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_state_serialize_mods");
1115
1116#ifdef HAVE_XKBCOMMON_COMPOSE_H
1117 _glfw.wl.xkb.compose_table_new_from_locale = (PFN_xkb_compose_table_new_from_locale)
1118 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_table_new_from_locale");
1119 _glfw.wl.xkb.compose_table_unref = (PFN_xkb_compose_table_unref)
1120 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_table_unref");
1121 _glfw.wl.xkb.compose_state_new = (PFN_xkb_compose_state_new)
1122 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_new");
1123 _glfw.wl.xkb.compose_state_unref = (PFN_xkb_compose_state_unref)
1124 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_unref");
1125 _glfw.wl.xkb.compose_state_feed = (PFN_xkb_compose_state_feed)
1126 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_feed");
1127 _glfw.wl.xkb.compose_state_get_status = (PFN_xkb_compose_state_get_status)
1128 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_get_status");
1129 _glfw.wl.xkb.compose_state_get_one_sym = (PFN_xkb_compose_state_get_one_sym)
1130 _glfw_dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_get_one_sym");
1131#endif
1132
1133 _glfw.wl.display = wl_display_connect(NULL);
1134 if (!_glfw.wl.display)
1135 {
1136 _glfwInputError(GLFW_PLATFORM_ERROR,
1137 "Wayland: Failed to connect to display");
1138 return GLFW_FALSE;
1139 }
1140
1141 _glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
1142 wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
1143
1144 createKeyTables();
1145
1146 _glfw.wl.xkb.context = xkb_context_new(0);
1147 if (!_glfw.wl.xkb.context)
1148 {
1149 _glfwInputError(GLFW_PLATFORM_ERROR,
1150 "Wayland: Failed to initialize xkb context");
1151 return GLFW_FALSE;
1152 }
1153
1154 // Sync so we got all registry objects
1155 wl_display_roundtrip(_glfw.wl.display);
1156
1157 // Sync so we got all initial output events
1158 wl_display_roundtrip(_glfw.wl.display);
1159
1160#ifdef __linux__
1161 if (!_glfwInitJoysticksLinux())
1162 return GLFW_FALSE;
1163#endif
1164
1165 _glfwInitTimerPOSIX();
1166
1167 _glfw.wl.timerfd = -1;
1168 if (_glfw.wl.seatVersion >= 4)
1169 _glfw.wl.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
1170
1171 if (_glfw.wl.pointer && _glfw.wl.shm)
1172 {
1173 cursorTheme = getenv("XCURSOR_THEME");
1174 cursorSizeStr = getenv("XCURSOR_SIZE");
1175 cursorSize = 32;
1176 if (cursorSizeStr)
1177 {
1178 errno = 0;
1179 cursorSizeLong = strtol(cursorSizeStr, &cursorSizeEnd, 10);
1180 if (!*cursorSizeEnd && !errno && cursorSizeLong > 0 && cursorSizeLong <= INT_MAX)
1181 cursorSize = (int)cursorSizeLong;
1182 }
1183 _glfw.wl.cursorTheme =
1184 wl_cursor_theme_load(cursorTheme, cursorSize, _glfw.wl.shm);
1185 if (!_glfw.wl.cursorTheme)
1186 {
1187 _glfwInputError(GLFW_PLATFORM_ERROR,
1188 "Wayland: Unable to load default cursor theme");
1189 return GLFW_FALSE;
1190 }
1191 // If this happens to be NULL, we just fallback to the scale=1 version.
1192 _glfw.wl.cursorThemeHiDPI =
1193 wl_cursor_theme_load(cursorTheme, 2 * cursorSize, _glfw.wl.shm);
1194 _glfw.wl.cursorSurface =
1195 wl_compositor_create_surface(_glfw.wl.compositor);
1196 _glfw.wl.cursorTimerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
1197 }
1198
1199 if (_glfw.wl.seat && _glfw.wl.dataDeviceManager)
1200 {
1201 _glfw.wl.dataDevice =
1202 wl_data_device_manager_get_data_device(_glfw.wl.dataDeviceManager,
1203 _glfw.wl.seat);
1204 wl_data_device_add_listener(_glfw.wl.dataDevice, &dataDeviceListener, NULL);
1205 _glfw.wl.clipboardString = malloc(4096);
1206 if (!_glfw.wl.clipboardString)
1207 {
1208 _glfwInputError(GLFW_PLATFORM_ERROR,
1209 "Wayland: Unable to allocate clipboard memory");
1210 return GLFW_FALSE;
1211 }
1212 _glfw.wl.clipboardSize = 4096;
1213 }
1214
1215 return GLFW_TRUE;
1216}
1217
1218void _glfwPlatformTerminate(void)
1219{
1220#ifdef __linux__
1221 _glfwTerminateJoysticksLinux();
1222#endif
1223 _glfwTerminateEGL();
1224 if (_glfw.wl.egl.handle)
1225 {
1226 _glfw_dlclose(_glfw.wl.egl.handle);
1227 _glfw.wl.egl.handle = NULL;
1228 }
1229
1230#ifdef HAVE_XKBCOMMON_COMPOSE_H
1231 if (_glfw.wl.xkb.composeState)
1232 xkb_compose_state_unref(_glfw.wl.xkb.composeState);
1233#endif
1234 if (_glfw.wl.xkb.keymap)
1235 xkb_keymap_unref(_glfw.wl.xkb.keymap);
1236 if (_glfw.wl.xkb.state)
1237 xkb_state_unref(_glfw.wl.xkb.state);
1238 if (_glfw.wl.xkb.context)
1239 xkb_context_unref(_glfw.wl.xkb.context);
1240 if (_glfw.wl.xkb.handle)
1241 {
1242 _glfw_dlclose(_glfw.wl.xkb.handle);
1243 _glfw.wl.xkb.handle = NULL;
1244 }
1245
1246 if (_glfw.wl.cursorTheme)
1247 wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
1248 if (_glfw.wl.cursorThemeHiDPI)
1249 wl_cursor_theme_destroy(_glfw.wl.cursorThemeHiDPI);
1250 if (_glfw.wl.cursor.handle)
1251 {
1252 _glfw_dlclose(_glfw.wl.cursor.handle);
1253 _glfw.wl.cursor.handle = NULL;
1254 }
1255
1256 if (_glfw.wl.cursorSurface)
1257 wl_surface_destroy(_glfw.wl.cursorSurface);
1258 if (_glfw.wl.subcompositor)
1259 wl_subcompositor_destroy(_glfw.wl.subcompositor);
1260 if (_glfw.wl.compositor)
1261 wl_compositor_destroy(_glfw.wl.compositor);
1262 if (_glfw.wl.shm)
1263 wl_shm_destroy(_glfw.wl.shm);
1264 if (_glfw.wl.shell)
1265 wl_shell_destroy(_glfw.wl.shell);
1266 if (_glfw.wl.viewporter)
1267 wp_viewporter_destroy(_glfw.wl.viewporter);
1268 if (_glfw.wl.decorationManager)
1269 zxdg_decoration_manager_v1_destroy(_glfw.wl.decorationManager);
1270 if (_glfw.wl.wmBase)
1271 xdg_wm_base_destroy(_glfw.wl.wmBase);
1272 if (_glfw.wl.dataSource)
1273 wl_data_source_destroy(_glfw.wl.dataSource);
1274 if (_glfw.wl.dataDevice)
1275 wl_data_device_destroy(_glfw.wl.dataDevice);
1276 if (_glfw.wl.dataOffer)
1277 wl_data_offer_destroy(_glfw.wl.dataOffer);
1278 if (_glfw.wl.dataDeviceManager)
1279 wl_data_device_manager_destroy(_glfw.wl.dataDeviceManager);
1280 if (_glfw.wl.pointer)
1281 wl_pointer_destroy(_glfw.wl.pointer);
1282 if (_glfw.wl.keyboard)
1283 wl_keyboard_destroy(_glfw.wl.keyboard);
1284 if (_glfw.wl.seat)
1285 wl_seat_destroy(_glfw.wl.seat);
1286 if (_glfw.wl.relativePointerManager)
1287 zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
1288 if (_glfw.wl.pointerConstraints)
1289 zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
1290 if (_glfw.wl.idleInhibitManager)
1291 zwp_idle_inhibit_manager_v1_destroy(_glfw.wl.idleInhibitManager);
1292 if (_glfw.wl.registry)
1293 wl_registry_destroy(_glfw.wl.registry);
1294 if (_glfw.wl.display)
1295 {
1296 wl_display_flush(_glfw.wl.display);
1297 wl_display_disconnect(_glfw.wl.display);
1298 }
1299
1300 if (_glfw.wl.timerfd >= 0)
1301 close(_glfw.wl.timerfd);
1302 if (_glfw.wl.cursorTimerfd >= 0)
1303 close(_glfw.wl.cursorTimerfd);
1304
1305 if (_glfw.wl.clipboardString)
1306 free(_glfw.wl.clipboardString);
1307 if (_glfw.wl.clipboardSendString)
1308 free(_glfw.wl.clipboardSendString);
1309}
1310
1311const char* _glfwPlatformGetVersionString(void)
1312{
1313 return _GLFW_VERSION_NUMBER " Wayland EGL OSMesa"
1314#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
1315 " clock_gettime"
1316#else
1317 " gettimeofday"
1318#endif
1319 " evdev"
1320#if defined(_GLFW_BUILD_DLL)
1321 " shared"
1322#endif
1323 ;
1324}