4 * Copyright (c) 2012 David Herrmann <dh.herrmann@googlemail.com>
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files
8 * (the "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sublicense, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
21 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Wayland Terminal toolkit helpers
36 #include <wayland-client.h>
37 #include <wayland-cursor.h>
38 #include <xkbcommon/xkbcommon.h>
41 #include "shl_dlist.h"
44 #include "wlt_toolkit.h"
46 #define LOG_SUBSYSTEM "wlt_toolkit"
49 struct wl_shm_pool *w_pool;
62 struct ev_eloop *eloop;
63 struct wl_display *dp;
65 struct wl_global_listener *dp_listener;
66 struct shl_hook *listeners;
69 struct shl_dlist window_list;
71 struct wl_compositor *w_comp;
72 struct wl_seat *w_seat;
73 struct wl_shell *w_shell;
77 uint32_t pointer_enter_serial;
78 struct wl_pointer *w_pointer;
79 struct wlt_window *pointer_focus;
81 uint32_t cursor_serial;
82 unsigned int current_cursor;
83 struct wl_surface *w_cursor_surface;
84 struct wl_cursor_theme *cursor_theme;
85 struct wl_cursor *cursors[WLT_CURSOR_NUM];
87 struct wl_keyboard *w_keyboard;
88 struct xkb_context *xkb_ctx;
89 struct xkb_keymap *xkb_keymap;
90 struct xkb_state *xkb_state;
91 struct wlt_window *keyboard_focus;
96 struct shl_dlist list;
98 wlt_window_close_cb close_cb;
100 struct wlt_display *disp;
101 struct wlt_pool *pool;
103 struct wl_surface *w_surface;
104 struct wl_shell_surface *w_shell_surface;
105 struct wl_buffer *w_buffer;
107 bool buffer_attached;
113 unsigned int new_width;
114 unsigned int new_height;
115 unsigned int resize_edges;
116 struct wlt_shm_buffer buffer;
117 struct wl_callback *w_frame;
119 struct shl_dlist widget_list;
123 struct shl_dlist list;
124 struct wlt_window *wnd;
126 wlt_widget_redraw_cb redraw_cb;
127 wlt_widget_destroy_cb destroy_cb;
128 wlt_widget_prepare_resize_cb prepare_resize_cb;
129 wlt_widget_resize_cb resize_cb;
130 wlt_widget_pointer_enter_cb pointer_enter_cb;
131 wlt_widget_pointer_leave_cb pointer_leave_cb;
132 wlt_widget_pointer_motion_cb pointer_motion_cb;
133 wlt_widget_pointer_button_cb pointer_button_cb;
134 wlt_widget_keyboard_cb keyboard_cb;
137 static int wlt_pool_new(struct wlt_pool **out, struct wlt_display *disp,
140 static const char template[] = "/wlterm-shared-XXXXXX";
141 struct wlt_pool *pool;
146 path = getenv("XDG_RUNTIME_DIR");
148 log_error("XDG_RUNTIME_DIR not set");
152 pool = malloc(sizeof(*pool));
155 memset(pool, 0, sizeof(*pool));
158 name = malloc(strlen(path) + sizeof(template));
164 strcat(name, template);
166 fd = mkostemp(name, O_CLOEXEC);
168 log_error("cannot create temporary file %s via mkostemp() (%d): %m",
177 log_warning("cannot unlink temporary file %s (%d): %m",
181 ret = ftruncate(fd, size);
183 log_error("cannot truncate temporary file to length %lu (%d): %m",
189 pool->data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
191 if (pool->data == MAP_FAILED) {
192 log_error("cannot mmap temporary file (%d): %m", errno);
197 pool->w_pool = wl_shm_create_pool(disp->w_shm, fd, size);
199 log_error("cannot create wayland shm pool object");
209 munmap(pool->data, size);
217 static void wlt_pool_free(struct wlt_pool *pool)
219 munmap(pool->data, pool->size);
220 wl_shm_pool_destroy(pool->w_pool);
225 * These cursor-names are based on:
226 * https://bugs.kde.org/attachment.cgi?id=67313
229 static char *(*cursors[])[] = {
230 [WLT_CURSOR_NONE] = &(char*[]) {
233 [WLT_CURSOR_TOP] = &(char*[]) {
238 [WLT_CURSOR_BOTTOM] = &(char*[]) {
243 [WLT_CURSOR_LEFT] = &(char*[]) {
248 [WLT_CURSOR_RIGHT] = &(char*[]) {
253 [WLT_CURSOR_TOP_LEFT] = &(char*[]) {
258 [WLT_CURSOR_TOP_RIGHT] = &(char*[]) {
263 [WLT_CURSOR_BOTTOM_LEFT] = &(char*[]) {
264 "bottom_left_corner",
268 [WLT_CURSOR_BOTTOM_RIGHT] = &(char*[]) {
269 "bottom_right_corner",
273 [WLT_CURSOR_DRAGGING] = &(char*[]) {
276 "208530c400c041818281048008011002",
279 [WLT_CURSOR_LEFT_PTR] = &(char*[]) {
286 [WLT_CURSOR_IBEAM] = &(char*[]) {
294 static int load_cursors(struct wlt_display *disp)
297 size_t size = sizeof(cursors) / sizeof(*cursors);
298 struct wl_cursor *cursor;
300 disp->w_cursor_surface = wl_compositor_create_surface(disp->w_comp);
302 disp->cursor_theme = wl_cursor_theme_load(NULL, 32, disp->w_shm);
303 if (!disp->cursor_theme) {
304 log_warning("cannot load curdor theme");
308 for (i = 0; i < WLT_CURSOR_NUM; ++i) {
310 if (i < size && cursors[i]) {
311 for (j = 0; (*cursors[i])[j]; ++j) {
312 cursor = wl_cursor_theme_get_cursor(
320 if (!cursor && i != WLT_CURSOR_NONE)
321 log_warning("cannot load cursor for ID %d", i);
323 disp->cursors[i] = cursor;
329 static void unload_cursors(struct wlt_display *disp)
331 if (disp->cursor_theme)
332 wl_cursor_theme_destroy(disp->cursor_theme);
333 if (disp->w_cursor_surface)
334 wl_surface_destroy(disp->w_cursor_surface);
337 static void set_cursor(struct wlt_display *disp, unsigned int cursor)
340 struct wl_cursor *cur;
341 struct wl_cursor_image *image;
342 struct wl_buffer *buffer;
344 if (cursor >= WLT_CURSOR_NUM)
345 cursor = WLT_CURSOR_LEFT_PTR;
347 if (disp->pointer_enter_serial > disp->cursor_serial)
350 if (!force && cursor == disp->current_cursor)
353 disp->current_cursor = cursor;
354 disp->cursor_serial = disp->pointer_enter_serial;
356 cur = disp->cursors[cursor];
358 wl_pointer_set_cursor(disp->w_pointer,
359 disp->pointer_enter_serial,
364 image = cur->images[0];
365 buffer = wl_cursor_image_get_buffer(image);
367 log_error("cannot load buffer for cursor image");
371 wl_pointer_set_cursor(disp->w_pointer,
372 disp->pointer_enter_serial,
373 disp->w_cursor_surface,
374 image->hotspot_x, image->hotspot_y);
375 wl_surface_attach(disp->w_cursor_surface, buffer, 0, 0);
376 wl_surface_damage(disp->w_cursor_surface, 0, 0,
377 image->width, image->height);
380 static int dp_mask_update(uint32_t mask, void *data)
382 struct wlt_display *disp = data;
390 if (mask & WL_DISPLAY_READABLE)
392 if (mask & WL_DISPLAY_WRITABLE)
393 mode |= EV_WRITEABLE;
395 ret = ev_fd_update(disp->dp_fd, mode);
397 log_warning("cannot update wayland-fd event-polling modes (%d)",
403 static void dp_event(struct ev_fd *fd, int mask, void *data)
405 struct wlt_display *disp = data;
408 if (mask & (EV_HUP | EV_ERR)) {
409 log_warning("HUP/ERR on wayland socket");
410 disp->state = STATE_HUP;
411 shl_hook_call(disp->listeners, disp, (void*)WLT_DISPLAY_HUP);
412 ev_eloop_rm_fd(disp->dp_fd);
418 if (mask & EV_READABLE)
419 mode |= WL_DISPLAY_READABLE;
420 if (mask & EV_WRITEABLE)
421 mode |= WL_DISPLAY_WRITABLE;
424 wl_display_iterate(disp->dp, mode);
427 static void pointer_enter(void *data, struct wl_pointer *w_pointer,
428 uint32_t serial, struct wl_surface *w_surface,
429 wl_fixed_t x, wl_fixed_t y)
431 struct wlt_display *disp = data;
432 struct shl_dlist *iter;
433 struct wlt_window *wnd;
434 struct wlt_widget *widget;
439 shl_dlist_for_each(iter, &disp->window_list) {
440 wnd = shl_dlist_entry(iter, struct wlt_window, list);
441 if (wnd->w_surface == w_surface)
445 if (iter == &disp->window_list) {
446 log_debug("unknown surface");
450 disp->pointer_enter_serial = serial;
451 disp->last_serial = serial;
452 disp->pointer_focus = wnd;
453 shl_dlist_for_each(iter, &wnd->widget_list) {
454 widget = shl_dlist_entry(iter, struct wlt_widget, list);
455 if (widget->pointer_enter_cb)
456 widget->pointer_enter_cb(widget, x >> 8, y >> 8,
461 static void pointer_leave(void *data, struct wl_pointer *w_pointer,
462 uint32_t serial, struct wl_surface *w_surface)
464 struct wlt_display *disp = data;
465 struct shl_dlist *iter;
466 struct wlt_window *wnd;
467 struct wlt_widget *widget;
469 wnd = disp->pointer_focus;
470 disp->pointer_focus = NULL;
471 disp->last_serial = serial;
476 shl_dlist_for_each(iter, &wnd->widget_list) {
477 widget = shl_dlist_entry(iter, struct wlt_widget, list);
478 if (widget->pointer_leave_cb)
479 widget->pointer_leave_cb(widget, widget->data);
483 static void pointer_motion(void *data, struct wl_pointer *w_pointer,
484 uint32_t time, wl_fixed_t x, wl_fixed_t y)
486 struct wlt_display *disp = data;
487 struct shl_dlist *iter;
488 struct wlt_window *wnd;
489 struct wlt_widget *widget;
491 wnd = disp->pointer_focus;
495 shl_dlist_for_each(iter, &wnd->widget_list) {
496 widget = shl_dlist_entry(iter, struct wlt_widget, list);
497 if (widget->pointer_motion_cb)
498 widget->pointer_motion_cb(widget, x >> 8, y >> 8,
503 static void pointer_button(void *data, struct wl_pointer *w_pointer,
504 uint32_t serial, uint32_t time, uint32_t button,
507 struct wlt_display *disp = data;
508 struct shl_dlist *iter;
509 struct wlt_window *wnd;
510 struct wlt_widget *widget;
512 wnd = disp->pointer_focus;
513 disp->last_serial = serial;
518 shl_dlist_for_each(iter, &wnd->widget_list) {
519 widget = shl_dlist_entry(iter, struct wlt_widget, list);
520 if (widget->pointer_button_cb)
521 widget->pointer_button_cb(widget, button, state,
526 static void pointer_axis(void *data, struct wl_pointer *w_pointer,
527 uint32_t time, uint32_t axis, wl_fixed_t value)
531 static const struct wl_pointer_listener pointer_listener = {
532 .enter = pointer_enter,
533 .leave = pointer_leave,
534 .motion = pointer_motion,
535 .button = pointer_button,
536 .axis = pointer_axis,
539 static void keyboard_keymap(void *data, struct wl_keyboard *keyboard,
540 uint32_t format, int fd, uint32_t size)
542 struct wlt_display *disp = data;
545 if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
546 log_error("invalid keyboard format");
551 map = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
552 if (map == MAP_FAILED) {
553 log_error("cannot mmap keyboard keymap");
558 disp->xkb_keymap = xkb_map_new_from_string(disp->xkb_ctx, map,
559 XKB_KEYMAP_FORMAT_TEXT_V1,
564 if (!disp->xkb_keymap) {
565 log_error("cannot create xkb keymap");
569 disp->xkb_state = xkb_state_new(disp->xkb_keymap);
570 if (!disp->xkb_state) {
571 log_error("cannot create XKB state object");
572 xkb_map_unref(disp->xkb_keymap);
573 disp->xkb_keymap = NULL;
578 static void keyboard_enter(void *data, struct wl_keyboard *keyboard,
579 uint32_t serial, struct wl_surface *w_surface,
580 struct wl_array *keys)
582 struct wlt_display *disp = data;
583 struct shl_dlist *iter;
584 struct wlt_window *wnd;
586 disp->last_serial = serial;
587 if (!disp->xkb_state)
593 shl_dlist_for_each(iter, &disp->window_list) {
594 wnd = shl_dlist_entry(iter, struct wlt_window, list);
595 if (wnd->w_surface == w_surface)
599 if (iter == &disp->window_list)
602 disp->keyboard_focus = wnd;
605 static void keyboard_leave(void *data, struct wl_keyboard *keyboard,
606 uint32_t serial, struct wl_surface *surface)
608 struct wlt_display *disp = data;
610 disp->last_serial = serial;
611 disp->keyboard_focus = NULL;
614 static unsigned int get_effective_modmask(struct xkb_state *state)
616 unsigned int mods = 0;
618 if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_SHIFT,
619 XKB_STATE_EFFECTIVE))
620 mods |= TSM_SHIFT_MASK;
621 if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
622 XKB_STATE_EFFECTIVE))
623 mods |= TSM_LOCK_MASK;
624 if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
625 XKB_STATE_EFFECTIVE))
626 mods |= TSM_CONTROL_MASK;
627 if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
628 XKB_STATE_EFFECTIVE))
629 mods |= TSM_MOD1_MASK;
630 if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_LOGO,
631 XKB_STATE_EFFECTIVE))
632 mods |= TSM_MOD4_MASK;
637 static void keyboard_key(void *data, struct wl_keyboard *keyboard,
638 uint32_t serial, uint32_t time, uint32_t key,
641 struct wlt_display *disp = data;
642 struct wlt_window *wnd = disp->keyboard_focus;
643 uint32_t code, num_syms;
645 enum wl_keyboard_key_state state = state_w;
646 const xkb_keysym_t *syms;
648 struct shl_dlist *iter;
649 struct wlt_widget *widget;
651 disp->last_serial = serial;
652 if (!disp->xkb_state)
659 mask = get_effective_modmask(disp->xkb_state);
660 num_syms = xkb_key_get_syms(disp->xkb_state, code, &syms);
661 sym = XKB_KEY_NoSymbol;
665 shl_dlist_for_each(iter, &wnd->widget_list) {
666 widget = shl_dlist_entry(iter, struct wlt_widget, list);
667 if (widget->keyboard_cb)
668 widget->keyboard_cb(widget, mask, sym, state,
673 static void keyboard_modifiers(void *data, struct wl_keyboard *keyboard,
674 uint32_t serial, uint32_t mods_depressed,
675 uint32_t mods_latched, uint32_t mods_locked,
678 struct wlt_display *disp = data;
680 disp->last_serial = serial;
681 if (!disp->xkb_state)
684 xkb_state_update_mask(disp->xkb_state, mods_depressed, mods_latched,
685 mods_locked, 0, 0, group);
688 static const struct wl_keyboard_listener keyboard_listener = {
689 .keymap = keyboard_keymap,
690 .enter = keyboard_enter,
691 .leave = keyboard_leave,
693 .modifiers = keyboard_modifiers,
696 static void check_ready(struct wlt_display *disp)
698 if (disp->state > STATE_INIT)
707 log_debug("wayland display initialized");
710 disp->state = STATE_RUNNING;
711 shl_hook_call(disp->listeners, disp, (void*)WLT_DISPLAY_READY);
715 static void seat_capabilities(void *data, struct wl_seat *seat,
716 enum wl_seat_capability caps)
718 struct wlt_display *disp = data;
720 if (caps & WL_SEAT_CAPABILITY_POINTER && !disp->w_pointer) {
721 disp->w_pointer = wl_seat_get_pointer(seat);
722 wl_pointer_add_listener(disp->w_pointer, &pointer_listener,
726 if (caps & WL_SEAT_CAPABILITY_KEYBOARD && !disp->w_keyboard) {
727 disp->w_keyboard = wl_seat_get_keyboard(seat);
728 wl_keyboard_add_listener(disp->w_keyboard, &keyboard_listener,
735 static const struct wl_seat_listener seat_listener = {
736 .capabilities = seat_capabilities,
739 static void dp_global(struct wl_display *dp, uint32_t id, const char *iface,
740 uint32_t version, void *data)
742 struct wlt_display *disp = data;
744 if (!strcmp(iface, "wl_display")) {
745 log_debug("new wl_display global");
747 } else if (!strcmp(iface, "wl_compositor")) {
749 log_error("global wl_compositor advertised twice");
752 disp->w_comp = wl_display_bind(disp->dp,
754 &wl_compositor_interface);
756 log_error("cannot bind wl_compositor object");
759 } else if (!strcmp(iface, "wl_seat")) {
761 log_error("global wl_seat advertised twice");
764 disp->w_seat = wl_display_bind(disp->dp,
768 log_error("cannot bind wl_seat object");
772 wl_seat_add_listener(disp->w_seat, &seat_listener, disp);
773 } else if (!strcmp(iface, "wl_shell")) {
775 log_error("global wl_shell advertised twice");
778 disp->w_shell = wl_display_bind(disp->dp,
780 &wl_shell_interface);
781 if (!disp->w_shell) {
782 log_error("cannot bind wl_shell object");
785 } else if (!strcmp(iface, "wl_shm")) {
787 log_error("global wl_shm advertised twice");
790 disp->w_shm = wl_display_bind(disp->dp,
794 log_error("cannot bind wl_shm object");
798 log_debug("ignoring new unknown global %s", iface);
802 log_debug("new global %s", iface);
807 int wlt_display_new(struct wlt_display **out,
808 struct ev_eloop *eloop)
810 struct wlt_display *disp;
816 log_debug("creating new wlt-display");
818 disp = malloc(sizeof(*disp));
821 memset(disp, 0, sizeof(*disp));
824 shl_dlist_init(&disp->window_list);
826 ret = shl_hook_new(&disp->listeners);
828 log_error("cannot create listeners hook");
832 disp->dp = wl_display_connect(NULL);
834 log_error("cannot connect to wayland socket (%d): %m", errno);
839 ret = ev_eloop_new_fd(eloop,
841 wl_display_get_fd(disp->dp,
848 log_error("cannot create event-fd for wayland display (%d)",
853 disp->dp_listener = wl_display_add_global_listener(disp->dp,
856 if (!disp->dp_listener) {
857 log_error("cannot add wayland global listener (%d)");
861 disp->xkb_ctx = xkb_context_new(0);
862 if (!disp->xkb_ctx) {
863 log_error("cannot create XKB context");
867 log_debug("wlt-display waiting for globals...");
869 ev_eloop_ref(disp->eloop);
874 ev_eloop_rm_fd(disp->dp_fd);
876 wl_display_disconnect(disp->dp);
878 shl_hook_free(disp->listeners);
884 void wlt_display_ref(struct wlt_display *disp)
886 if (!disp || !disp->ref)
892 void wlt_display_unref(struct wlt_display *disp)
894 if (!disp || !disp->ref || --disp->ref)
897 unload_cursors(disp);
898 wl_display_remove_global_listener(disp->dp, disp->dp_listener);
899 ev_eloop_rm_fd(disp->dp_fd);
900 wl_display_flush(disp->dp);
901 wl_display_disconnect(disp->dp);
902 xkb_context_unref(disp->xkb_ctx);
903 shl_hook_free(disp->listeners);
904 ev_eloop_unref(disp->eloop);
908 int wlt_display_register_cb(struct wlt_display *disp,
909 wlt_display_cb cb, void *data)
914 return shl_hook_add_cast(disp->listeners, cb, data);
917 void wlt_display_unregister_cb(struct wlt_display *disp,
918 wlt_display_cb cb, void *data)
923 shl_hook_rm_cast(disp->listeners, cb, data);
926 static void shell_surface_ping(void *data, struct wl_shell_surface *s,
929 wl_shell_surface_pong(s, serial);
932 static void wlt_window_do_redraw(struct wlt_window *wnd,
936 struct shl_dlist *iter;
937 struct wlt_widget *widget;
939 struct wlt_rect alloc;
943 alloc.width = wnd->buffer.width;
944 alloc.height = wnd->buffer.height;
945 shl_dlist_for_each(iter, &wnd->widget_list) {
946 widget = shl_dlist_entry(iter, struct wlt_widget, list);
947 if (widget->resize_cb)
948 widget->resize_cb(widget, &alloc, widget->data);
951 memset(wnd->buffer.data, 0,
952 wnd->buffer.stride * wnd->buffer.height);
954 wnd->skip_damage = true;
955 shl_dlist_for_each(iter, &wnd->widget_list) {
956 widget = shl_dlist_entry(iter, struct wlt_widget, list);
957 if (widget->redraw_cb)
958 widget->redraw_cb(widget, widget->data);
960 wnd->skip_damage = false;
962 if (!wnd->buffer_attached) {
963 wnd->buffer_attached = true;
964 if (wnd->resize_edges & WL_SHELL_SURFACE_RESIZE_LEFT)
965 x = (int)oldw - wnd->buffer.width;
968 if (wnd->resize_edges & WL_SHELL_SURFACE_RESIZE_TOP)
969 y = (int)oldh - wnd->buffer.height;
972 wl_surface_attach(wnd->w_surface, wnd->w_buffer, x, y);
973 wnd->resize_edges = 0;
976 wl_surface_damage(wnd->w_surface, 0, 0, wnd->buffer.width,
980 static int resize_window(struct wlt_window *wnd, unsigned int width,
983 struct shl_dlist *iter;
984 struct wlt_widget *widget;
985 struct wl_buffer *old_buffer = NULL;
986 struct wlt_pool *old_pool = NULL;
989 unsigned int oldw, oldh;
991 if (!wnd || !width || !height)
994 shl_dlist_for_each(iter, &wnd->widget_list) {
995 widget = shl_dlist_entry(iter, struct wlt_widget, list);
996 if (widget->prepare_resize_cb)
997 widget->prepare_resize_cb(widget, &width, &height,
1001 if (width == wnd->buffer.width &&
1002 height == wnd->buffer.height)
1005 oldw = wnd->buffer.width;
1006 oldh = wnd->buffer.height;
1008 nsize = width * height * 4;
1009 if (wnd->pool && wnd->pool->size >= nsize) {
1010 old_buffer = wnd->w_buffer;
1011 wnd->w_buffer = wl_shm_pool_create_buffer(wnd->pool->w_pool,
1014 WL_SHM_FORMAT_ARGB8888);
1015 if (!wnd->w_buffer) {
1016 log_error("cannot create wayland shm buffer");
1017 wnd->w_buffer = old_buffer;
1021 old_pool = wnd->pool;
1022 ret = wlt_pool_new(&wnd->pool, wnd->disp, nsize);
1024 log_error("cannot create memory pool");
1025 wnd->pool = old_pool;
1029 old_buffer = wnd->w_buffer;
1030 wnd->w_buffer = wl_shm_pool_create_buffer(wnd->pool->w_pool,
1033 WL_SHM_FORMAT_ARGB8888);
1034 if (!wnd->w_buffer) {
1035 log_error("cannot create wayland shm buffer");
1036 wnd->w_buffer = old_buffer;
1037 wlt_pool_free(wnd->pool);
1038 wnd->pool = old_pool;
1043 wnd->buffer.data = wnd->pool->data;
1044 wnd->buffer.width = width;
1045 wnd->buffer.height = height;
1046 wnd->buffer.stride = width * 4;
1047 wnd->buffer_attached = false;
1049 wlt_window_do_redraw(wnd, oldw, oldh);
1052 wl_buffer_destroy(old_buffer);
1054 wlt_pool_free(old_pool);
1059 static void idle_frame(struct ev_eloop *eloop, void *unused, void *data);
1061 static void do_frame(struct wlt_window *wnd)
1063 wnd->idle_pending = false;
1064 ev_eloop_unregister_idle_cb(wnd->disp->eloop, idle_frame, wnd);
1066 if (wnd->need_resize) {
1067 wnd->need_resize = false;
1068 wnd->need_redraw = false;
1069 resize_window(wnd, wnd->new_width, wnd->new_height);
1072 if (wnd->need_redraw) {
1073 wnd->need_redraw = false;
1074 wlt_window_do_redraw(wnd, wnd->buffer.width,
1075 wnd->buffer.height);
1079 static void frame_callback(void *data, struct wl_callback *w_callback,
1082 struct wlt_window *wnd = data;
1084 wl_callback_destroy(w_callback);
1085 wnd->w_frame = NULL;
1086 wnd->need_frame = false;
1091 static void idle_frame(struct ev_eloop *eloop, void *unused, void *data)
1093 struct wlt_window *wnd = data;
1095 wnd->need_frame = true;
1099 static const struct wl_callback_listener frame_callback_listener = {
1100 .done = frame_callback,
1103 static void schedule_frame(struct wlt_window *wnd)
1105 if (!wnd || wnd->w_frame)
1108 if (!wnd->need_frame && !wnd->idle_pending) {
1109 wnd->idle_pending = true;
1110 ev_eloop_register_idle_cb(wnd->disp->eloop,
1112 wnd->w_frame = wl_surface_frame(wnd->w_surface);
1113 wl_callback_add_listener(wnd->w_frame,
1114 &frame_callback_listener, wnd);
1118 static void shell_surface_configure(void *data, struct wl_shell_surface *s,
1119 uint32_t edges, int32_t width,
1122 struct wlt_window *wnd = data;
1129 wnd->resize_edges = edges;
1130 wlt_window_set_size(wnd, width, height);
1133 static void shell_surface_popup_done(void *data, struct wl_shell_surface *s)
1137 static const struct wl_shell_surface_listener shell_surface_listener = {
1138 .ping = shell_surface_ping,
1139 .configure = shell_surface_configure,
1140 .popup_done = shell_surface_popup_done,
1143 static void close_window(struct ev_eloop *eloop, void *unused, void *data)
1145 struct wlt_window *wnd = data;
1147 ev_eloop_unregister_idle_cb(eloop, close_window, wnd);
1148 wnd->close_pending = false;
1151 wnd->close_cb(wnd, wnd->data);
1154 int wlt_display_create_window(struct wlt_display *disp,
1155 struct wlt_window **out,
1157 unsigned int height,
1160 struct wlt_window *wnd;
1163 if (!disp || !out || !width || !height)
1166 if (disp->state != STATE_RUNNING) {
1167 log_error("cannot create window, display is not running but in state %u",
1172 wnd = malloc(sizeof(*wnd));
1175 memset(wnd, 0, sizeof(*wnd));
1179 shl_dlist_init(&wnd->widget_list);
1181 wnd->w_surface = wl_compositor_create_surface(disp->w_comp);
1182 if (!wnd->w_surface) {
1183 log_error("cannot create wayland surface");
1188 wnd->w_shell_surface = wl_shell_get_shell_surface(disp->w_shell,
1190 if (!wnd->w_shell_surface) {
1191 log_error("cannot retrieve shell-surface for wayland surface");
1196 wl_shell_surface_add_listener(wnd->w_shell_surface,
1197 &shell_surface_listener, wnd);
1198 wl_shell_surface_set_toplevel(wnd->w_shell_surface);
1200 ret = resize_window(wnd, width, height);
1202 goto err_shell_surface;
1204 wlt_display_ref(disp);
1205 shl_dlist_link(&disp->window_list, &wnd->list);
1210 wl_shell_surface_destroy(wnd->w_shell_surface);
1212 wl_surface_destroy(wnd->w_surface);
1218 void wlt_window_ref(struct wlt_window *wnd)
1220 if (!wnd || !wnd->ref)
1226 void wlt_window_unref(struct wlt_window *wnd)
1228 struct wlt_widget *widget;
1230 if (!wnd || !wnd->ref || --wnd->ref)
1233 while (!shl_dlist_empty(&wnd->widget_list)) {
1234 widget = shl_dlist_entry(wnd->widget_list.next,
1235 struct wlt_widget, list);
1236 wlt_widget_destroy(widget);
1239 if (wnd->close_pending)
1240 ev_eloop_unregister_idle_cb(wnd->disp->eloop, close_window,
1242 if (wnd->idle_pending)
1243 ev_eloop_unregister_idle_cb(wnd->disp->eloop, idle_frame, wnd);
1244 shl_dlist_unlink(&wnd->list);
1246 wl_callback_destroy(wnd->w_frame);
1248 wl_buffer_destroy(wnd->w_buffer);
1250 wlt_pool_free(wnd->pool);
1251 wl_shell_surface_destroy(wnd->w_shell_surface);
1252 wl_surface_destroy(wnd->w_surface);
1253 wlt_display_unref(wnd->disp);
1257 int wlt_window_create_widget(struct wlt_window *wnd,
1258 struct wlt_widget **out,
1261 struct wlt_widget *widget;
1266 widget = malloc(sizeof(*widget));
1269 memset(widget, 0, sizeof(*widget));
1271 widget->data = data;
1273 wlt_window_schedule_redraw(wnd);
1274 shl_dlist_link_tail(&wnd->widget_list, &widget->list);
1279 void wlt_window_schedule_redraw(struct wlt_window *wnd)
1284 wnd->need_redraw = true;
1285 schedule_frame(wnd);
1288 void wlt_window_damage(struct wlt_window *wnd,
1289 struct wlt_rect *damage)
1291 if (!wnd || !damage || wnd->skip_damage)
1294 wl_surface_damage(wnd->w_surface, damage->x, damage->y,
1295 damage->width, damage->height);
1298 void wlt_window_get_buffer(struct wlt_window *wnd,
1299 const struct wlt_rect *alloc,
1300 struct wlt_shm_buffer *buf)
1302 struct wlt_shm_buffer *rbuf;
1307 rbuf = &wnd->buffer;
1310 memcpy(buf, rbuf, sizeof(*buf));
1314 if (alloc->x >= rbuf->width ||
1315 alloc->y >= rbuf->height) {
1316 memset(buf, 0, sizeof(*buf));
1321 if (alloc->x + alloc->width > rbuf->width)
1322 buf->width = rbuf->width - alloc->x;
1324 buf->width = alloc->width;
1327 if (alloc->y + alloc->height > rbuf->height)
1328 buf->height = rbuf->height - alloc->y;
1330 buf->height = alloc->height;
1333 buf->stride = rbuf->stride;
1336 buf->data = rbuf->data;
1337 buf->data += alloc->y * rbuf->stride;
1338 buf->data += alloc->x * 4;
1341 void wlt_window_move(struct wlt_window *wnd)
1346 wl_shell_surface_move(wnd->w_shell_surface,
1348 wnd->disp->last_serial);
1351 void wlt_window_resize(struct wlt_window *wnd, uint32_t edges)
1356 wl_shell_surface_resize(wnd->w_shell_surface,
1358 wnd->disp->last_serial,
1362 int wlt_window_set_size(struct wlt_window *wnd,
1363 unsigned int width, unsigned int height)
1365 if (!wnd || !width || !height)
1368 wnd->new_width = width;
1369 wnd->new_height = height;
1370 wnd->need_resize = true;
1371 schedule_frame(wnd);
1376 void wlt_window_set_cursor(struct wlt_window *wnd, unsigned int cursor)
1381 set_cursor(wnd->disp, cursor);
1384 void wlt_window_set_close_cb(struct wlt_window *wnd,
1385 wlt_window_close_cb cb)
1393 void wlt_window_close(struct wlt_window *wnd)
1398 wnd->close_pending = true;
1399 ev_eloop_register_idle_cb(wnd->disp->eloop, close_window, wnd);
1402 struct ev_eloop *wlt_window_get_eloop(struct wlt_window *wnd)
1407 return wnd->disp->eloop;
1410 void wlt_widget_destroy(struct wlt_widget *widget)
1415 if (widget->destroy_cb)
1416 widget->destroy_cb(widget, widget->data);
1417 shl_dlist_unlink(&widget->list);
1421 struct wlt_window *wlt_widget_get_window(struct wlt_widget *widget)
1429 void wlt_widget_set_redraw_cb(struct wlt_widget *widget,
1430 wlt_widget_redraw_cb cb)
1435 widget->redraw_cb = cb;
1438 void wlt_widget_set_destroy_cb(struct wlt_widget *widget,
1439 wlt_widget_destroy_cb cb)
1444 widget->destroy_cb = cb;
1447 void wlt_widget_set_resize_cb(struct wlt_widget *widget,
1448 wlt_widget_prepare_resize_cb prepare_cb,
1449 wlt_widget_resize_cb cb)
1454 widget->prepare_resize_cb = prepare_cb;
1455 widget->resize_cb = cb;
1458 void wlt_widget_set_pointer_cb(struct wlt_widget *widget,
1459 wlt_widget_pointer_enter_cb enter_cb,
1460 wlt_widget_pointer_leave_cb leave_cb,
1461 wlt_widget_pointer_motion_cb motion_cb,
1462 wlt_widget_pointer_button_cb button_cb)
1467 widget->pointer_enter_cb = enter_cb;
1468 widget->pointer_leave_cb = leave_cb;
1469 widget->pointer_motion_cb = motion_cb;
1470 widget->pointer_button_cb = button_cb;
1473 void wlt_widget_set_keyboard_cb(struct wlt_widget *widget,
1474 wlt_widget_keyboard_cb cb)
1479 widget->keyboard_cb = cb;