1 /*
2 * Copyright © 2012 Collabora, Ltd.
3 * Copyright © 2013 Ran Benita <[email protected]>
4 * Copyright © 2016 Daniel Stone <[email protected]>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
15 * Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
24 */
25
26 #include "config.h"
27
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <locale.h>
31 #include <stdbool.h>
32 #include <stdint.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <sys/mman.h>
36 #include <unistd.h>
37
38 #include "xkbcommon/xkbcommon.h"
39 #include "tools-common.h"
40
41 #include <wayland-client.h>
42 #include "xdg-shell-client-protocol.h"
43 #include <wayland-util.h>
44
45 #define MAX(a, b) ((a) > (b) ? (a) : (b))
46
47 struct interactive_dpy {
48 struct wl_display *dpy;
49 struct wl_compositor *compositor;
50 struct xdg_wm_base *shell;
51 struct wl_shm *shm;
52 uint32_t shm_format;
53
54 struct xkb_context *ctx;
55
56 struct wl_surface *wl_surf;
57 struct xdg_surface *xdg_surf;
58 struct xdg_toplevel *xdg_top;
59
60 struct wl_list seats;
61 };
62
63 struct interactive_seat {
64 struct interactive_dpy *inter;
65
66 struct wl_seat *wl_seat;
67 struct wl_keyboard *wl_kbd;
68 struct wl_pointer *wl_pointer;
69 uint32_t version; /* ... of wl_seat */
70 uint32_t global_name; /* an ID of sorts */
71 char *name_str; /* a descriptor */
72
73 struct xkb_keymap *keymap;
74 struct xkb_state *state;
75
76 struct wl_list link;
77 };
78
79 static bool terminate;
80
81 #ifdef HAVE_MKOSTEMP
82 static int
create_tmpfile_cloexec(char * tmpname)83 create_tmpfile_cloexec(char *tmpname)
84 {
85 int fd = mkostemp(tmpname, O_CLOEXEC);
86 if (fd >= 0)
87 unlink(tmpname);
88 return fd;
89 }
90 #else
91 /* The following utility functions are taken from Weston's
92 * shared/os-compatibility.c. */
93 static int
os_fd_set_cloexec(int fd)94 os_fd_set_cloexec(int fd)
95 {
96 long flags;
97
98 if (fd == -1)
99 return -1;
100
101 flags = fcntl(fd, F_GETFD);
102 if (flags == -1)
103 return -1;
104
105 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
106 return -1;
107
108 return 0;
109 }
110
111 static int
set_cloexec_or_close(int fd)112 set_cloexec_or_close(int fd)
113 {
114 if (os_fd_set_cloexec(fd) != 0) {
115 close(fd);
116 return -1;
117 }
118 return fd;
119 }
120
121 static int
create_tmpfile_cloexec(char * tmpname)122 create_tmpfile_cloexec(char *tmpname)
123 {
124 int fd = mkstemp(tmpname);
125 if (fd >= 0) {
126 fd = set_cloexec_or_close(fd);
127 unlink(tmpname);
128 }
129 return fd;
130 }
131 #endif
132
133 static int
os_resize_anonymous_file(int fd,off_t size)134 os_resize_anonymous_file(int fd, off_t size)
135 {
136 int ret;
137 #ifdef HAVE_POSIX_FALLOCATE
138 ret = posix_fallocate(fd, 0, size);
139 if (ret == 0)
140 return 0;
141 /*
142 * Filesystems that do support fallocate will return EINVAL
143 * or EOPNOTSUPP, fallback to ftruncate() then.
144 */
145 if (ret != EINVAL && ret != EOPNOTSUPP)
146 return ret;
147 #endif
148 ret = ftruncate(fd, size);
149 if (ret != 0)
150 return errno;
151 return 0;
152 }
153
154 /*
155 * Create a new, unique, anonymous file of the given size, and
156 * return the file descriptor for it. The file descriptor is set
157 * CLOEXEC. The file is immediately suitable for mmap()'ing
158 * the given size at offset zero.
159 *
160 * The file should not have a permanent backing store like a disk,
161 * but may have if XDG_RUNTIME_DIR is not properly implemented in OS.
162 *
163 * The file name is deleted from the file system.
164 *
165 * The file is suitable for buffer sharing between processes by
166 * transmitting the file descriptor over Unix sockets using the
167 * SCM_RIGHTS methods.
168 *
169 * If the C library implements posix_fallocate(), it is used to
170 * guarantee that disk space is available for the file at the
171 * given size. If disk space is insufficent, errno is set to ENOSPC.
172 * If posix_fallocate() is not supported, program will fallback
173 * to ftruncate() instead.
174 */
175 static int
os_create_anonymous_file(off_t size)176 os_create_anonymous_file(off_t size)
177 {
178 static const char template[] = "/weston-shared-XXXXXX";
179 const char *path;
180 char *name;
181 int fd;
182 int ret;
183
184 path = getenv("XDG_RUNTIME_DIR");
185 if (!path) {
186 errno = ENOENT;
187 return -1;
188 }
189
190 name = malloc(strlen(path) + sizeof(template));
191 if (!name)
192 return -1;
193
194 strcpy(name, path);
195 strcat(name, template);
196
197 fd = create_tmpfile_cloexec(name);
198
199 free(name);
200
201 if (fd < 0)
202 return -1;
203
204 ret = os_resize_anonymous_file(fd, size);
205 if (ret != 0) {
206 close(fd);
207 errno = ret;
208 return -1;
209 }
210
211 return fd;
212 }
213
214 static void
buffer_release(void * data,struct wl_buffer * buffer)215 buffer_release(void *data, struct wl_buffer *buffer)
216 {
217 wl_buffer_destroy(buffer);
218 }
219
220 static const struct wl_buffer_listener buffer_listener = {
221 buffer_release
222 };
223
224 static void
buffer_create(struct interactive_dpy * inter,uint32_t width,uint32_t height)225 buffer_create(struct interactive_dpy *inter, uint32_t width, uint32_t height)
226 {
227 struct wl_shm_pool *pool;
228 struct wl_buffer *buf;
229 struct wl_region *opaque;
230 uint32_t stride;
231 size_t size;
232 void *map;
233 int fd;
234
235 switch (inter->shm_format) {
236 case WL_SHM_FORMAT_ARGB8888:
237 case WL_SHM_FORMAT_XRGB8888:
238 case WL_SHM_FORMAT_ABGR8888:
239 case WL_SHM_FORMAT_XBGR8888:
240 stride = width * 4;
241 break;
242 case WL_SHM_FORMAT_RGB565:
243 case WL_SHM_FORMAT_BGR565:
244 stride = width * 2;
245 break;
246 default:
247 fprintf(stderr, "Unsupported SHM format %d\n", inter->shm_format);
248 exit(1);
249 }
250
251 size = stride * height;
252 fd = os_create_anonymous_file(size);
253 if (fd < 0) {
254 fprintf(stderr, "Couldn't create surface buffer\n");
255 exit(1);
256 }
257
258 map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
259 if (map == MAP_FAILED) {
260 fprintf(stderr, "Couldn't mmap surface buffer\n");
261 exit(1);
262 }
263 memset(map, 0xff, size);
264 munmap(map, size);
265
266 pool = wl_shm_create_pool(inter->shm, fd, size);
267 buf = wl_shm_pool_create_buffer(pool, 0, width, height, stride,
268 inter->shm_format);
269 wl_buffer_add_listener(buf, &buffer_listener, inter);
270
271 wl_surface_attach(inter->wl_surf, buf, 0, 0);
272 wl_surface_damage(inter->wl_surf, 0, 0, width, height);
273
274 opaque = wl_compositor_create_region(inter->compositor);
275 wl_region_add(opaque, 0, 0, width, height);
276 wl_surface_set_opaque_region(inter->wl_surf, opaque);
277 wl_region_destroy(opaque);
278
279 wl_shm_pool_destroy(pool);
280 close(fd);
281 }
282
283 static void
surface_configure(void * data,struct xdg_surface * surface,uint32_t serial)284 surface_configure(void *data, struct xdg_surface *surface,
285 uint32_t serial)
286 {
287 struct interactive_dpy *inter = data;
288
289 xdg_surface_ack_configure(inter->xdg_surf, serial);
290 wl_surface_commit(inter->wl_surf);
291 }
292
293 static const struct xdg_surface_listener surface_listener = {
294 surface_configure,
295 };
296
297 static void
toplevel_configure(void * data,struct xdg_toplevel * toplevel,int32_t width,int32_t height,struct wl_array * states)298 toplevel_configure(void *data, struct xdg_toplevel *toplevel,
299 int32_t width, int32_t height, struct wl_array *states)
300 {
301 struct interactive_dpy *inter = data;
302
303 if (width == 0)
304 width = 200;
305 if (height == 0)
306 height = 200;
307
308 buffer_create(inter, width, height);
309 }
310
311 static void
toplevel_close(void * data,struct xdg_toplevel * toplevel)312 toplevel_close(void *data, struct xdg_toplevel *toplevel)
313 {
314 terminate = true;
315 }
316
317 static const struct xdg_toplevel_listener toplevel_listener = {
318 toplevel_configure,
319 toplevel_close
320 };
321
surface_create(struct interactive_dpy * inter)322 static void surface_create(struct interactive_dpy *inter)
323 {
324 inter->wl_surf = wl_compositor_create_surface(inter->compositor);
325 inter->xdg_surf = xdg_wm_base_get_xdg_surface(inter->shell, inter->wl_surf);
326 xdg_surface_add_listener(inter->xdg_surf, &surface_listener, inter);
327 inter->xdg_top = xdg_surface_get_toplevel(inter->xdg_surf);
328 xdg_toplevel_add_listener(inter->xdg_top, &toplevel_listener, inter);
329 xdg_toplevel_set_title(inter->xdg_top, "xkbcommon event tester");
330 xdg_toplevel_set_app_id(inter->xdg_top,
331 "org.xkbcommon.test.interactive-wayland");
332 wl_surface_commit(inter->wl_surf);
333 }
334
335 static void
shell_ping(void * data,struct xdg_wm_base * shell,uint32_t serial)336 shell_ping(void *data, struct xdg_wm_base *shell, uint32_t serial)
337 {
338 xdg_wm_base_pong(shell, serial);
339 }
340
341 static const struct xdg_wm_base_listener shell_listener = {
342 shell_ping
343 };
344
345 static void
kbd_keymap(void * data,struct wl_keyboard * wl_kbd,uint32_t format,int fd,uint32_t size)346 kbd_keymap(void *data, struct wl_keyboard *wl_kbd, uint32_t format,
347 int fd, uint32_t size)
348 {
349 struct interactive_seat *seat = data;
350 void *buf;
351
352 buf = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
353 if (buf == MAP_FAILED) {
354 fprintf(stderr, "Failed to mmap keymap: %d\n", errno);
355 close(fd);
356 return;
357 }
358
359 seat->keymap = xkb_keymap_new_from_buffer(seat->inter->ctx, buf, size - 1,
360 XKB_KEYMAP_FORMAT_TEXT_V1,
361 XKB_KEYMAP_COMPILE_NO_FLAGS);
362 munmap(buf, size);
363 close(fd);
364 if (!seat->keymap) {
365 fprintf(stderr, "Failed to compile keymap!\n");
366 return;
367 }
368
369 seat->state = xkb_state_new(seat->keymap);
370 if (!seat->state) {
371 fprintf(stderr, "Failed to create XKB state!\n");
372 return;
373 }
374 }
375
376 static void
kbd_enter(void * data,struct wl_keyboard * wl_kbd,uint32_t serial,struct wl_surface * surf,struct wl_array * keys)377 kbd_enter(void *data, struct wl_keyboard *wl_kbd, uint32_t serial,
378 struct wl_surface *surf, struct wl_array *keys)
379 {
380 }
381
382 static void
kbd_leave(void * data,struct wl_keyboard * wl_kbd,uint32_t serial,struct wl_surface * surf)383 kbd_leave(void *data, struct wl_keyboard *wl_kbd, uint32_t serial,
384 struct wl_surface *surf)
385 {
386 }
387
388 static void
kbd_key(void * data,struct wl_keyboard * wl_kbd,uint32_t serial,uint32_t time,uint32_t key,uint32_t state)389 kbd_key(void *data, struct wl_keyboard *wl_kbd, uint32_t serial, uint32_t time,
390 uint32_t key, uint32_t state)
391 {
392 struct interactive_seat *seat = data;
393
394 if (state != WL_KEYBOARD_KEY_STATE_PRESSED)
395 return;
396
397 printf("%s: ", seat->name_str);
398 tools_print_keycode_state(seat->state, NULL, key + 8,
399 XKB_CONSUMED_MODE_XKB);
400
401 /* Exit on ESC. */
402 if (xkb_state_key_get_one_sym(seat->state, key + 8) == XKB_KEY_Escape)
403 terminate = true;
404 }
405
406 static void
kbd_modifiers(void * data,struct wl_keyboard * wl_kbd,uint32_t serial,uint32_t mods_depressed,uint32_t mods_latched,uint32_t mods_locked,uint32_t group)407 kbd_modifiers(void *data, struct wl_keyboard *wl_kbd, uint32_t serial,
408 uint32_t mods_depressed, uint32_t mods_latched,
409 uint32_t mods_locked, uint32_t group)
410 {
411 struct interactive_seat *seat = data;
412
413 xkb_state_update_mask(seat->state, mods_depressed, mods_latched,
414 mods_locked, 0, 0, group);
415 }
416
417 static void
kbd_repeat_info(void * data,struct wl_keyboard * wl_kbd,int32_t rate,int32_t delay)418 kbd_repeat_info(void *data, struct wl_keyboard *wl_kbd, int32_t rate,
419 int32_t delay)
420 {
421 }
422
423 static const struct wl_keyboard_listener kbd_listener = {
424 kbd_keymap,
425 kbd_enter,
426 kbd_leave,
427 kbd_key,
428 kbd_modifiers,
429 kbd_repeat_info
430 };
431
432 static void
pointer_enter(void * data,struct wl_pointer * wl_pointer,uint32_t serial,struct wl_surface * surf,wl_fixed_t fsx,wl_fixed_t fsy)433 pointer_enter(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
434 struct wl_surface *surf, wl_fixed_t fsx, wl_fixed_t fsy)
435 {
436 }
437
438 static void
pointer_leave(void * data,struct wl_pointer * wl_pointer,uint32_t serial,struct wl_surface * surf)439 pointer_leave(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
440 struct wl_surface *surf)
441 {
442 }
443
444 static void
pointer_motion(void * data,struct wl_pointer * wl_pointer,uint32_t time,wl_fixed_t fsx,wl_fixed_t fsy)445 pointer_motion(void *data, struct wl_pointer *wl_pointer, uint32_t time,
446 wl_fixed_t fsx, wl_fixed_t fsy)
447 {
448 }
449
450 static void
pointer_button(void * data,struct wl_pointer * wl_pointer,uint32_t serial,uint32_t time,uint32_t button,uint32_t state)451 pointer_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
452 uint32_t time, uint32_t button, uint32_t state)
453 {
454 struct interactive_seat *seat = data;
455
456 xdg_toplevel_move(seat->inter->xdg_top, seat->wl_seat, serial);
457 }
458
459 static void
pointer_axis(void * data,struct wl_pointer * wl_pointer,uint32_t time,uint32_t axis,wl_fixed_t value)460 pointer_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time,
461 uint32_t axis, wl_fixed_t value)
462 {
463 }
464
465 static void
pointer_frame(void * data,struct wl_pointer * wl_pointer)466 pointer_frame(void *data, struct wl_pointer *wl_pointer)
467 {
468 }
469
470 static void
pointer_axis_source(void * data,struct wl_pointer * wl_pointer,uint32_t source)471 pointer_axis_source(void *data, struct wl_pointer *wl_pointer, uint32_t source)
472 {
473 }
474
475 static void
pointer_axis_stop(void * data,struct wl_pointer * wl_pointer,uint32_t time,uint32_t axis)476 pointer_axis_stop(void *data, struct wl_pointer *wl_pointer, uint32_t time,
477 uint32_t axis)
478 {
479 }
480
481 static void
pointer_axis_discrete(void * data,struct wl_pointer * wl_pointer,uint32_t time,int32_t discrete)482 pointer_axis_discrete(void *data, struct wl_pointer *wl_pointer, uint32_t time,
483 int32_t discrete)
484 {
485 }
486
487 static const struct wl_pointer_listener pointer_listener = {
488 pointer_enter,
489 pointer_leave,
490 pointer_motion,
491 pointer_button,
492 pointer_axis,
493 pointer_frame,
494 pointer_axis_source,
495 pointer_axis_stop,
496 pointer_axis_discrete
497 };
498
499 static void
seat_capabilities(void * data,struct wl_seat * wl_seat,uint32_t caps)500 seat_capabilities(void *data, struct wl_seat *wl_seat, uint32_t caps)
501 {
502 struct interactive_seat *seat = data;
503
504 if (!seat->wl_kbd && (caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
505 seat->wl_kbd = wl_seat_get_keyboard(seat->wl_seat);
506 wl_keyboard_add_listener(seat->wl_kbd, &kbd_listener, seat);
507 }
508 else if (seat->wl_kbd && !(caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
509 if (seat->version >= WL_SEAT_RELEASE_SINCE_VERSION)
510 wl_keyboard_release(seat->wl_kbd);
511 else
512 wl_keyboard_destroy(seat->wl_kbd);
513
514 xkb_state_unref(seat->state);
515 xkb_keymap_unref(seat->keymap);
516
517 seat->state = NULL;
518 seat->keymap = NULL;
519 seat->wl_kbd = NULL;
520 }
521
522 if (!seat->wl_pointer && (caps & WL_SEAT_CAPABILITY_POINTER)) {
523 seat->wl_pointer = wl_seat_get_pointer(seat->wl_seat);
524 wl_pointer_add_listener(seat->wl_pointer, &pointer_listener,
525 seat);
526 }
527 else if (seat->wl_pointer && !(caps & WL_SEAT_CAPABILITY_POINTER)) {
528 if (seat->version >= WL_SEAT_RELEASE_SINCE_VERSION)
529 wl_pointer_release(seat->wl_pointer);
530 else
531 wl_pointer_destroy(seat->wl_pointer);
532 seat->wl_pointer = NULL;
533 }
534 }
535
536 static void
seat_name(void * data,struct wl_seat * wl_seat,const char * name)537 seat_name(void *data, struct wl_seat *wl_seat, const char *name)
538 {
539 struct interactive_seat *seat = data;
540
541 free(seat->name_str);
542 seat->name_str = strdup(name);
543 }
544
545 static const struct wl_seat_listener seat_listener = {
546 seat_capabilities,
547 seat_name
548 };
549
550 static void
seat_create(struct interactive_dpy * inter,struct wl_registry * registry,uint32_t name,uint32_t version)551 seat_create(struct interactive_dpy *inter, struct wl_registry *registry,
552 uint32_t name, uint32_t version)
553 {
554 int ret;
555 struct interactive_seat *seat = calloc(1, sizeof(*seat));
556
557 seat->global_name = name;
558 seat->inter = inter;
559 seat->wl_seat = wl_registry_bind(registry, name, &wl_seat_interface,
560 MAX(version, 5));
561 wl_seat_add_listener(seat->wl_seat, &seat_listener, seat);
562 ret = asprintf(&seat->name_str, "seat:%d",
563 wl_proxy_get_id((struct wl_proxy *) seat->wl_seat));
564 assert(ret >= 0);
565 wl_list_insert(&inter->seats, &seat->link);
566 }
567
568 static void
seat_destroy(struct interactive_seat * seat)569 seat_destroy(struct interactive_seat *seat)
570 {
571 if (seat->wl_kbd) {
572 if (seat->version >= WL_SEAT_RELEASE_SINCE_VERSION)
573 wl_keyboard_release(seat->wl_kbd);
574 else
575 wl_keyboard_destroy(seat->wl_kbd);
576
577 xkb_state_unref(seat->state);
578 xkb_keymap_unref(seat->keymap);
579 }
580
581 if (seat->wl_pointer) {
582 if (seat->version >= WL_SEAT_RELEASE_SINCE_VERSION)
583 wl_pointer_release(seat->wl_pointer);
584 else
585 wl_pointer_destroy(seat->wl_pointer);
586 }
587
588 if (seat->version >= WL_SEAT_RELEASE_SINCE_VERSION)
589 wl_seat_release(seat->wl_seat);
590 else
591 wl_seat_destroy(seat->wl_seat);
592
593 free(seat->name_str);
594 wl_list_remove(&seat->link);
595 free(seat);
596 }
597
598 static void
registry_global(void * data,struct wl_registry * registry,uint32_t name,const char * interface,uint32_t version)599 registry_global(void *data, struct wl_registry *registry, uint32_t name,
600 const char *interface, uint32_t version)
601 {
602 struct interactive_dpy *inter = data;
603
604 if (strcmp(interface, "wl_seat") == 0) {
605 seat_create(inter, registry, name, version);
606 }
607 else if (strcmp(interface, "xdg_wm_base") == 0) {
608 inter->shell = wl_registry_bind(registry, name,
609 &xdg_wm_base_interface,
610 MAX(version, 2));
611 xdg_wm_base_add_listener(inter->shell, &shell_listener, inter);
612 }
613 else if (strcmp(interface, "wl_compositor") == 0) {
614 inter->compositor = wl_registry_bind(registry, name,
615 &wl_compositor_interface,
616 MAX(version, 1));
617 }
618 else if (strcmp(interface, "wl_shm") == 0) {
619 inter->shm = wl_registry_bind(registry, name, &wl_shm_interface,
620 MAX(version, 1));
621 }
622 }
623
624 static void
registry_delete(void * data,struct wl_registry * registry,uint32_t name)625 registry_delete(void *data, struct wl_registry *registry, uint32_t name)
626 {
627 struct interactive_dpy *inter = data;
628 struct interactive_seat *seat, *tmp;
629
630 wl_list_for_each_safe(seat, tmp, &inter->seats, link) {
631 if (seat->global_name != name)
632 continue;
633
634 seat_destroy(seat);
635 }
636 }
637
638 static const struct wl_registry_listener registry_listener = {
639 registry_global,
640 registry_delete
641 };
642
643 static void
dpy_disconnect(struct interactive_dpy * inter)644 dpy_disconnect(struct interactive_dpy *inter)
645 {
646 struct interactive_seat *seat, *tmp;
647
648 wl_list_for_each_safe(seat, tmp, &inter->seats, link)
649 seat_destroy(seat);
650
651 if (inter->xdg_surf)
652 xdg_surface_destroy(inter->xdg_surf);
653 if (inter->xdg_top)
654 xdg_toplevel_destroy(inter->xdg_top);
655 if (inter->wl_surf)
656 wl_surface_destroy(inter->wl_surf);
657 if (inter->shell)
658 xdg_wm_base_destroy(inter->shell);
659 if (inter->compositor)
660 wl_compositor_destroy(inter->compositor);
661 if (inter->shm)
662 wl_shm_destroy(inter->shm);
663
664 /* Do one last roundtrip to try to destroy our wl_buffer. */
665 wl_display_roundtrip(inter->dpy);
666
667 xkb_context_unref(inter->ctx);
668 wl_display_disconnect(inter->dpy);
669 }
670
671 int
main(int argc,char * argv[])672 main(int argc, char *argv[])
673 {
674 int ret;
675 struct interactive_dpy inter;
676 struct wl_registry *registry;
677
678 if (argc != 1) {
679 ret = strcmp(argv[1], "--help");
680 fprintf(ret ? stderr : stdout, "Usage: %s [--help]\n", argv[0]);
681 if (ret)
682 fprintf(stderr, "unrecognized option: %s\n", argv[1]);
683 return ret ? EXIT_INVALID_USAGE : EXIT_SUCCESS;
684 }
685
686 setlocale(LC_ALL, "");
687
688 memset(&inter, 0, sizeof(inter));
689 wl_list_init(&inter.seats);
690
691 inter.dpy = wl_display_connect(NULL);
692 if (!inter.dpy) {
693 fprintf(stderr, "Couldn't connect to Wayland server\n");
694 ret = -1;
695 goto err_out;
696 }
697
698 inter.ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
699 if (!inter.ctx) {
700 ret = -1;
701 fprintf(stderr, "Couldn't create xkb context\n");
702 goto err_out;
703 }
704
705 registry = wl_display_get_registry(inter.dpy);
706 wl_registry_add_listener(registry, ®istry_listener, &inter);
707
708 /* The first roundtrip gets the list of advertised globals. */
709 wl_display_roundtrip(inter.dpy);
710
711 /* The second roundtrip dispatches the events sent after binding, e.g.
712 * after binding to wl_seat globals in the first roundtrip, we will get
713 * the wl_seat::capabilities event in this roundtrip. */
714 wl_display_roundtrip(inter.dpy);
715
716 if (!inter.shell || !inter.shm || !inter.compositor) {
717 fprintf(stderr, "Required Wayland interfaces %s%s%s unsupported\n",
718 (inter.shell) ? "" : "xdg_shell ",
719 (inter.shm) ? "" : "wl_shm",
720 (inter.compositor) ? "" : "wl_compositor");
721 ret = -1;
722 goto err_conn;
723 }
724
725 surface_create(&inter);
726
727 tools_disable_stdin_echo();
728 do {
729 ret = wl_display_dispatch(inter.dpy);
730 } while (ret >= 0 && !terminate);
731 tools_enable_stdin_echo();
732
733 wl_registry_destroy(registry);
734 err_conn:
735 dpy_disconnect(&inter);
736 err_out:
737 exit(ret >= 0 ? EXIT_SUCCESS : EXIT_FAILURE);
738 }
739