src/wlt_toolkit.c

   1 /*
   2  * wlt - Toolkit Helper
   3  *
   4  * Copyright (c) 2012 David Herrmann <dh.herrmann@googlemail.com>
   5  *
   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:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  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.
  24  */
  25
  26 /*
  27  * Wayland Terminal toolkit helpers
  28  */
  29
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <sys/mman.h>
  35 #include <unistd.h>
  36 #include <wayland-client.h>
  37 #include <wayland-cursor.h>
  38 #include <xkbcommon/xkbcommon.h>
  39 #include "eloop.h"
  40 #include "log.h"
  41 #include "shl_array.h"
  42 #include "shl_dlist.h"
  43 #include "shl_hook.h"
  44 #include "shl_misc.h"
  45 #include "tsm_vte.h"
  46 #include "wlt_main.h"
  47 #include "wlt_toolkit.h"
  48
  49 #define LOG_SUBSYSTEM "wlt_toolkit"
  50
  51 struct wlt_pool {
  52         struct wl_shm_pool *w_pool;
  53         size_t size;
  54         uint8_t *data;
  55 };
  56
  57 enum {
  58         STATE_INIT = 0,
  59         STATE_RUNNING,
  60         STATE_HUP,
  61 };
  62
  63 struct data_offer {
  64         unsigned long ref;
  65         struct wl_data_offer *w_offer;
  66         struct wlt_display *disp;
  67         struct shl_array *types;
  68 };
  69
  70 struct wlt_display {
  71         unsigned long ref;
  72         struct ev_eloop *eloop;
  73         struct wl_display *dp;
  74         struct ev_fd *dp_fd;
  75         struct wl_global_listener *dp_listener;
  76         struct shl_hook *listeners;
  77         unsigned int state;
  78
  79         struct shl_dlist window_list;
  80
  81         struct wl_compositor *w_comp;
  82         struct wl_seat *w_seat;
  83         struct wl_shell *w_shell;
  84         struct wl_shm *w_shm;
  85
  86         uint32_t last_serial;
  87         uint32_t pointer_enter_serial;
  88         struct wl_pointer *w_pointer;
  89         struct wlt_window *pointer_focus;
  90
  91         uint32_t cursor_serial;
  92         unsigned int current_cursor;
  93         struct wl_surface *w_cursor_surface;
  94         struct wl_cursor_theme *cursor_theme;
  95         struct wl_cursor *cursors[WLT_CURSOR_NUM];
  96
  97         struct wl_keyboard *w_keyboard;
  98         struct xkb_context *xkb_ctx;
  99         struct xkb_keymap *xkb_keymap;
 100         struct xkb_state *xkb_state;
 101         struct wlt_window *keyboard_focus;
 102         struct ev_timer *repeat_timer;
 103         uint32_t repeat_sym;
 104
 105         struct wl_data_device_manager *w_manager;
 106         struct wl_data_device *w_data_dev;
 107         struct data_offer *drag_offer;
 108         struct data_offer *selection_offer;
 109 };
 110
 111 struct wlt_window {
 112         unsigned long ref;
 113         struct shl_dlist list;
 114         void *data;
 115         wlt_window_close_cb close_cb;
 116         bool close_pending;
 117         struct wlt_display *disp;
 118         struct wlt_pool *pool;
 119
 120         struct wl_surface *w_surface;
 121         struct wl_shell_surface *w_shell_surface;
 122         struct wl_buffer *w_buffer;
 123
 124         bool buffer_attached;
 125         bool skip_damage;
 126         bool need_resize;
 127         bool need_redraw;
 128         bool need_frame;
 129         bool idle_pending;
 130         unsigned int new_width;
 131         unsigned int new_height;
 132         unsigned int saved_width;
 133         unsigned int saved_height;
 134         unsigned int resize_edges;
 135         bool maximized;
 136         bool fullscreen;
 137         struct wlt_shm_buffer buffer;
 138         struct wl_callback *w_frame;
 139
 140         struct shl_dlist widget_list;
 141 };
 142
 143 struct wlt_widget {
 144         struct shl_dlist list;
 145         struct wlt_window *wnd;
 146         void *data;
 147         wlt_widget_redraw_cb redraw_cb;
 148         wlt_widget_destroy_cb destroy_cb;
 149         wlt_widget_prepare_resize_cb prepare_resize_cb;
 150         wlt_widget_resize_cb resize_cb;
 151         wlt_widget_pointer_enter_cb pointer_enter_cb;
 152         wlt_widget_pointer_leave_cb pointer_leave_cb;
 153         wlt_widget_pointer_motion_cb pointer_motion_cb;
 154         wlt_widget_pointer_button_cb pointer_button_cb;
 155         wlt_widget_keyboard_cb keyboard_cb;
 156 };
 157
 158 static int wlt_pool_new(struct wlt_pool **out, struct wlt_display *disp,
 159                         size_t size)
 160 {
 161         static const char template[] = "/wlterm-shared-XXXXXX";
 162         struct wlt_pool *pool;
 163         int fd, ret;
 164         const char *path;
 165         char *name;
 166
 167         path = getenv("XDG_RUNTIME_DIR");
 168         if (!path) {
 169                 log_error("XDG_RUNTIME_DIR not set");
 170                 return -EFAULT;
 171         }
 172
 173         pool = malloc(sizeof(*pool));
 174         if (!pool)
 175                 return -ENOMEM;
 176         memset(pool, 0, sizeof(*pool));
 177         pool->size = size;
 178
 179         name = malloc(strlen(path) + sizeof(template));
 180         if (!name) {
 181                 ret = -ENOMEM;
 182                 goto err_free;
 183         }
 184         strcpy(name, path);
 185         strcat(name, template);
 186
 187         fd = mkostemp(name, O_CLOEXEC);
 188         if (fd < 0) {
 189                 log_error("cannot create temporary file %s via mkostemp() (%d): %m",
 190                           name, errno);
 191                 ret = -EFAULT;
 192                 free(name);
 193                 goto err_free;
 194         }
 195
 196         ret = unlink(name);
 197         if (ret)
 198                 log_warning("cannot unlink temporary file %s (%d): %m",
 199                             name, errno);
 200         free(name);
 201
 202         ret = ftruncate(fd, size);
 203         if (ret) {
 204                 log_error("cannot truncate temporary file to length %lu (%d): %m",
 205                           size, errno);
 206                 ret = -EFAULT;
 207                 goto err_close;
 208         }
 209
 210         pool->data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
 211                           fd, 0);
 212         if (pool->data == MAP_FAILED) {
 213                 log_error("cannot mmap temporary file (%d): %m", errno);
 214                 ret = -EFAULT;
 215                 goto err_close;
 216         }
 217
 218         pool->w_pool = wl_shm_create_pool(disp->w_shm, fd, size);
 219         if (!pool->w_pool) {
 220                 log_error("cannot create wayland shm pool object");
 221                 ret = -EFAULT;
 222                 goto err_map;
 223         }
 224
 225         close(fd);
 226         *out = pool;
 227         return 0;
 228
 229 err_map:
 230         munmap(pool->data, size);
 231 err_close:
 232         close(fd);
 233 err_free:
 234         free(pool);
 235         return ret;
 236 }
 237
 238 static void wlt_pool_free(struct wlt_pool *pool)
 239 {
 240         munmap(pool->data, pool->size);
 241         wl_shm_pool_destroy(pool->w_pool);
 242         free(pool);
 243 }
 244
 245 /*
 246  * These cursor-names are based on:
 247  *   https://bugs.kde.org/attachment.cgi?id=67313
 248  */
 249
 250 static char *(*cursors[])[] = {
 251         [WLT_CURSOR_NONE] = &(char*[]) {
 252                 NULL,
 253         },
 254         [WLT_CURSOR_TOP] = &(char*[]) {
 255                 "top_side",
 256                 "n-resize",
 257                 NULL,
 258         },
 259         [WLT_CURSOR_BOTTOM] = &(char*[]) {
 260                 "bottom_side",
 261                 "s-resize",
 262                 NULL,
 263         },
 264         [WLT_CURSOR_LEFT] = &(char*[]) {
 265                 "left_side",
 266                 "w-resize",
 267                 NULL,
 268         },
 269         [WLT_CURSOR_RIGHT] = &(char*[]) {
 270                 "right_side",
 271                 "e-resize",
 272                 NULL,
 273         },
 274         [WLT_CURSOR_TOP_LEFT] = &(char*[]) {
 275                 "top_left_corner",
 276                 "nw-resize",
 277                 NULL,
 278         },
 279         [WLT_CURSOR_TOP_RIGHT] = &(char*[]) {
 280                 "top_right_corner",
 281                 "ne-resize",
 282                 NULL,
 283         },
 284         [WLT_CURSOR_BOTTOM_LEFT] = &(char*[]) {
 285                 "bottom_left_corner",
 286                 "sw-resize",
 287                 NULL,
 288         },
 289         [WLT_CURSOR_BOTTOM_RIGHT] = &(char*[]) {
 290                 "bottom_right_corner",
 291                 "se-resize",
 292                 NULL,
 293         },
 294         [WLT_CURSOR_DRAGGING] = &(char*[]) {
 295                 "grabbing",
 296                 "closedhand",
 297                 "208530c400c041818281048008011002",
 298                 NULL,
 299         },
 300         [WLT_CURSOR_LEFT_PTR] = &(char*[]) {
 301                 "left_ptr",
 302                 "default",
 303                 "top_left_arrow",
 304                 "left-arrow",
 305                 NULL,
 306         },
 307         [WLT_CURSOR_IBEAM] = &(char*[]) {
 308                 "xterm",
 309                 "ibeam",
 310                 "text",
 311                 NULL,
 312         },
 313 };
 314
 315 static int load_cursors(struct wlt_display *disp)
 316 {
 317         unsigned int i, j;
 318         size_t size = sizeof(cursors) / sizeof(*cursors);
 319         struct wl_cursor *cursor;
 320
 321         disp->w_cursor_surface = wl_compositor_create_surface(disp->w_comp);
 322
 323         disp->cursor_theme = wl_cursor_theme_load(NULL, 32, disp->w_shm);
 324         if (!disp->cursor_theme) {
 325                 log_warning("cannot load curdor theme");
 326                 return -EFAULT;
 327         }
 328
 329         for (i = 0; i < WLT_CURSOR_NUM; ++i) {
 330                 cursor = NULL;
 331                 if (i < size && cursors[i]) {
 332                         for (j = 0; (*cursors[i])[j]; ++j) {
 333                                 cursor = wl_cursor_theme_get_cursor(
 334                                                         disp->cursor_theme,
 335                                                         (*cursors[i])[j]);
 336                                 if (cursor)
 337                                         break;
 338                         }
 339                 }
 340
 341                 if (!cursor && i != WLT_CURSOR_NONE)
 342                         log_warning("cannot load cursor for ID %d", i);
 343
 344                 disp->cursors[i] = cursor;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static void unload_cursors(struct wlt_display *disp)
 351 {
 352         if (disp->cursor_theme)
 353                 wl_cursor_theme_destroy(disp->cursor_theme);
 354         if (disp->w_cursor_surface)
 355                 wl_surface_destroy(disp->w_cursor_surface);
 356 }
 357
 358 static void set_cursor(struct wlt_display *disp, unsigned int cursor)
 359 {
 360         bool force = false;
 361         struct wl_cursor *cur;
 362         struct wl_cursor_image *image;
 363         struct wl_buffer *buffer;
 364
 365         if (cursor >= WLT_CURSOR_NUM)
 366                 cursor = WLT_CURSOR_LEFT_PTR;
 367
 368         if (disp->pointer_enter_serial > disp->cursor_serial)
 369                 force = true;
 370
 371         if (!force && cursor == disp->current_cursor)
 372                 return;
 373
 374         disp->current_cursor = cursor;
 375         disp->cursor_serial = disp->pointer_enter_serial;
 376
 377         cur = disp->cursors[cursor];
 378         if (!cur) {
 379                 wl_pointer_set_cursor(disp->w_pointer,
 380                                       disp->pointer_enter_serial,
 381                                       NULL, 0, 0);
 382                 return;
 383         }
 384
 385         image = cur->images[0];
 386         buffer = wl_cursor_image_get_buffer(image);
 387         if (!buffer) {
 388                 log_error("cannot load buffer for cursor image");
 389                 return;
 390         }
 391
 392         wl_pointer_set_cursor(disp->w_pointer,
 393                               disp->pointer_enter_serial,
 394                               disp->w_cursor_surface,
 395                               image->hotspot_x, image->hotspot_y);
 396         wl_surface_attach(disp->w_cursor_surface, buffer, 0, 0);
 397         wl_surface_damage(disp->w_cursor_surface, 0, 0,
 398                           image->width, image->height);
 399 }
 400
 401 static int dp_mask_update(uint32_t mask, void *data)
 402 {
 403         struct wlt_display *disp = data;
 404         int ret;
 405         int mode;
 406
 407         if (!disp->dp_fd)
 408                 return 0;
 409
 410         mode = 0;
 411         if (mask & WL_DISPLAY_READABLE)
 412                 mode |= EV_READABLE;
 413         if (mask & WL_DISPLAY_WRITABLE)
 414                 mode |= EV_WRITEABLE;
 415
 416         ret = ev_fd_update(disp->dp_fd, mode);
 417         if (ret)
 418                 log_warning("cannot update wayland-fd event-polling modes (%d)",
 419                             ret);
 420
 421         return 0;
 422 }
 423
 424 static void dp_event(struct ev_fd *fd, int mask, void *data)
 425 {
 426         struct wlt_display *disp = data;
 427         int mode;
 428
 429         if (mask & (EV_HUP | EV_ERR)) {
 430                 log_warning("HUP/ERR on wayland socket");
 431                 disp->state = STATE_HUP;
 432                 shl_hook_call(disp->listeners, disp, (void*)WLT_DISPLAY_HUP);
 433                 ev_eloop_rm_fd(disp->dp_fd);
 434                 disp->dp_fd = NULL;
 435                 return;
 436         }
 437
 438         mode = 0;
 439         if (mask & EV_READABLE)
 440                 mode |= WL_DISPLAY_READABLE;
 441         if (mask & EV_WRITEABLE)
 442                 mode |= WL_DISPLAY_WRITABLE;
 443
 444         if (mode)
 445                 wl_display_iterate(disp->dp, mode);
 446 }
 447
 448 static void pointer_enter(void *data, struct wl_pointer *w_pointer,
 449                           uint32_t serial, struct wl_surface *w_surface,
 450                           wl_fixed_t x, wl_fixed_t y)
 451 {
 452         struct wlt_display *disp = data;
 453         struct shl_dlist *iter;
 454         struct wlt_window *wnd;
 455         struct wlt_widget *widget;
 456
 457         if (!w_surface)
 458                 return;
 459
 460         shl_dlist_for_each(iter, &disp->window_list) {
 461                 wnd = shl_dlist_entry(iter, struct wlt_window, list);
 462                 if (wnd->w_surface == w_surface)
 463                         break;
 464         }
 465
 466         if (iter == &disp->window_list) {
 467                 log_debug("unknown surface");
 468                 return;
 469         }
 470
 471         disp->pointer_enter_serial = serial;
 472         disp->last_serial = serial;
 473         disp->pointer_focus = wnd;
 474         shl_dlist_for_each(iter, &wnd->widget_list) {
 475                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
 476                 if (widget->pointer_enter_cb)
 477                         widget->pointer_enter_cb(widget, x >> 8, y >> 8,
 478                                                  widget->data);
 479         }
 480 }
 481
 482 static void pointer_leave(void *data, struct wl_pointer *w_pointer,
 483                           uint32_t serial, struct wl_surface *w_surface)
 484 {
 485         struct wlt_display *disp = data;
 486         struct shl_dlist *iter;
 487         struct wlt_window *wnd;
 488         struct wlt_widget *widget;
 489
 490         wnd = disp->pointer_focus;
 491         disp->pointer_focus = NULL;
 492         disp->last_serial = serial;
 493
 494         if (!wnd)
 495                 return;
 496
 497         shl_dlist_for_each(iter, &wnd->widget_list) {
 498                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
 499                 if (widget->pointer_leave_cb)
 500                         widget->pointer_leave_cb(widget, widget->data);
 501         }
 502 }
 503
 504 static void pointer_motion(void *data, struct wl_pointer *w_pointer,
 505                            uint32_t time, wl_fixed_t x, wl_fixed_t y)
 506 {
 507         struct wlt_display *disp = data;
 508         struct shl_dlist *iter;
 509         struct wlt_window *wnd;
 510         struct wlt_widget *widget;
 511
 512         wnd = disp->pointer_focus;
 513         if (!wnd)
 514                 return;
 515
 516         shl_dlist_for_each(iter, &wnd->widget_list) {
 517                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
 518                 if (widget->pointer_motion_cb)
 519                         widget->pointer_motion_cb(widget, x >> 8, y >> 8,
 520                                                   widget->data);
 521         }
 522 }
 523
 524 static void pointer_button(void *data, struct wl_pointer *w_pointer,
 525                            uint32_t serial, uint32_t time, uint32_t button,
 526                            uint32_t state)
 527 {
 528         struct wlt_display *disp = data;
 529         struct shl_dlist *iter;
 530         struct wlt_window *wnd;
 531         struct wlt_widget *widget;
 532
 533         wnd = disp->pointer_focus;
 534         disp->last_serial = serial;
 535
 536         if (!wnd)
 537                 return;
 538
 539         shl_dlist_for_each(iter, &wnd->widget_list) {
 540                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
 541                 if (widget->pointer_button_cb)
 542                         widget->pointer_button_cb(widget, button, state,
 543                                                   widget->data);
 544         }
 545 }
 546
 547 static void pointer_axis(void *data, struct wl_pointer *w_pointer,
 548                          uint32_t time, uint32_t axis, wl_fixed_t value)
 549 {
 550 }
 551
 552 static const struct wl_pointer_listener pointer_listener = {
 553         .enter = pointer_enter,
 554         .leave = pointer_leave,
 555         .motion = pointer_motion,
 556         .button = pointer_button,
 557         .axis = pointer_axis,
 558 };
 559
 560 static void keyboard_keymap(void *data, struct wl_keyboard *keyboard,
 561                             uint32_t format, int fd, uint32_t size)
 562 {
 563         struct wlt_display *disp = data;
 564         char *map;
 565
 566         if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
 567                 log_error("invalid keyboard format");
 568                 close(fd);
 569                 return;
 570         }
 571
 572         map = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
 573         if (map == MAP_FAILED) {
 574                 log_error("cannot mmap keyboard keymap");
 575                 close(fd);
 576                 return;
 577         }
 578
 579         disp->xkb_keymap = xkb_map_new_from_string(disp->xkb_ctx, map,
 580                                                    XKB_KEYMAP_FORMAT_TEXT_V1,
 581                                                    0);
 582         munmap(map, size);
 583         close(fd);
 584
 585         if (!disp->xkb_keymap) {
 586                 log_error("cannot create xkb keymap");
 587                 return;
 588         }
 589
 590         disp->xkb_state = xkb_state_new(disp->xkb_keymap);
 591         if (!disp->xkb_state) {
 592                 log_error("cannot create XKB state object");
 593                 xkb_map_unref(disp->xkb_keymap);
 594                 disp->xkb_keymap = NULL;
 595                 return;
 596         }
 597 }
 598
 599 static void keyboard_enter(void *data, struct wl_keyboard *keyboard,
 600                            uint32_t serial, struct wl_surface *w_surface,
 601                            struct wl_array *keys)
 602 {
 603         struct wlt_display *disp = data;
 604         struct shl_dlist *iter;
 605         struct wlt_window *wnd;
 606
 607         disp->last_serial = serial;
 608         if (!disp->xkb_state)
 609                 return;
 610
 611         if (!w_surface)
 612                 return;
 613
 614         shl_dlist_for_each(iter, &disp->window_list) {
 615                 wnd = shl_dlist_entry(iter, struct wlt_window, list);
 616                 if (wnd->w_surface == w_surface)
 617                         break;
 618         }
 619
 620         if (iter == &disp->window_list)
 621                 return;
 622
 623         disp->keyboard_focus = wnd;
 624 }
 625
 626 static void keyboard_leave(void *data, struct wl_keyboard *keyboard,
 627                            uint32_t serial, struct wl_surface *surface)
 628 {
 629         struct wlt_display *disp = data;
 630
 631         disp->last_serial = serial;
 632         disp->keyboard_focus = NULL;
 633         ev_timer_update(disp->repeat_timer, NULL);
 634 }
 635
 636 static void keyboard_key(void *data, struct wl_keyboard *keyboard,
 637                          uint32_t serial, uint32_t time, uint32_t key,
 638                          uint32_t state_w)
 639 {
 640         struct wlt_display *disp = data;
 641         struct wlt_window *wnd = disp->keyboard_focus;
 642         uint32_t code, num_syms;
 643         unsigned int mask;
 644         enum wl_keyboard_key_state state = state_w;
 645         const xkb_keysym_t *syms;
 646         xkb_keysym_t sym;
 647         struct shl_dlist *iter;
 648         struct wlt_widget *widget;
 649         struct itimerspec spec;
 650         bool handled;
 651
 652         disp->last_serial = serial;
 653         if (!disp->xkb_state)
 654                 return;
 655
 656         code = key + 8;
 657         if (!wnd)
 658                 return;
 659
 660         mask = shl_get_xkb_mods(disp->xkb_state);
 661         num_syms = xkb_key_get_syms(disp->xkb_state, code, &syms);
 662         sym = XKB_KEY_NoSymbol;
 663         if (num_syms == 1)
 664                 sym = syms[0];
 665
 666         handled = false;
 667         shl_dlist_for_each(iter, &wnd->widget_list) {
 668                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
 669                 if (widget->keyboard_cb) {
 670                         if (widget->keyboard_cb(widget, mask, sym, state,
 671                                                 handled, widget->data))
 672                                 handled = true;
 673                 }
 674         }
 675
 676         if (state == WL_KEYBOARD_KEY_STATE_RELEASED &&
 677             sym == disp->repeat_sym) {
 678                 ev_timer_update(disp->repeat_timer, NULL);
 679         } else if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
 680                 disp->repeat_sym = sym;
 681                 spec.it_interval.tv_sec = 0;
 682                 spec.it_interval.tv_nsec = wlt_conf.xkb_repeat_rate * 1000000;
 683                 spec.it_value.tv_sec = 0;
 684                 spec.it_value.tv_nsec = wlt_conf.xkb_repeat_delay * 1000000;
 685                 ev_timer_update(disp->repeat_timer, &spec);
 686         }
 687 }
 688
 689 static void repeat_event(struct ev_timer *timer, uint64_t num, void *data)
 690 {
 691         struct wlt_display *disp = data;
 692         struct wlt_window *wnd = disp->keyboard_focus;
 693         struct wlt_widget *widget;
 694         struct shl_dlist *iter;
 695         unsigned int mask;
 696         bool handled;
 697
 698         if (!wnd)
 699                 return;
 700
 701         mask = shl_get_xkb_mods(disp->xkb_state);
 702         handled = false;
 703         shl_dlist_for_each(iter, &wnd->widget_list) {
 704                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
 705                 if (widget->keyboard_cb) {
 706                         if (widget->keyboard_cb(widget, mask, disp->repeat_sym,
 707                                                 WL_KEYBOARD_KEY_STATE_PRESSED,
 708                                                 handled, widget->data))
 709                                 handled = true;
 710                 }
 711         }
 712 }
 713
 714 static void keyboard_modifiers(void *data, struct wl_keyboard *keyboard,
 715                                uint32_t serial, uint32_t mods_depressed,
 716                                uint32_t mods_latched, uint32_t mods_locked,
 717                                uint32_t group)
 718 {
 719         struct wlt_display *disp = data;
 720
 721         disp->last_serial = serial;
 722         if (!disp->xkb_state)
 723                 return;
 724
 725         xkb_state_update_mask(disp->xkb_state, mods_depressed, mods_latched,
 726                               mods_locked, 0, 0, group);
 727 }
 728
 729 static const struct wl_keyboard_listener keyboard_listener = {
 730         .keymap = keyboard_keymap,
 731         .enter = keyboard_enter,
 732         .leave = keyboard_leave,
 733         .key = keyboard_key,
 734         .modifiers = keyboard_modifiers,
 735 };
 736
 737 static void data_offer_unref(struct data_offer *offer)
 738 {
 739         unsigned int i, len;
 740
 741         if (!offer || !offer->ref || --offer->ref)
 742                 return;
 743
 744         len = shl_array_get_length(offer->types);
 745         for (i = 0; i < len; ++i)
 746                 free(*SHL_ARRAY_AT(offer->types, char*, i));
 747         shl_array_free(offer->types);
 748         wl_data_offer_destroy(offer->w_offer);
 749         free(offer);
 750 }
 751
 752 static void data_offer_offer(void *data, struct wl_data_offer *w_offer,
 753                              const char *type)
 754 {
 755         char *tmp;
 756         int ret;
 757         struct data_offer *offer = wl_data_offer_get_user_data(w_offer);
 758
 759         tmp = strdup(type);
 760         if (!tmp)
 761                 return;
 762
 763         ret = shl_array_push(offer->types, &tmp);
 764         if (ret) {
 765                 free(tmp);
 766                 return;
 767         }
 768 }
 769
 770 static const struct wl_data_offer_listener data_offer_listener = {
 771         .offer = data_offer_offer,
 772 };
 773
 774 static void data_dev_data_offer(void *data, struct wl_data_device *w_dev,
 775                                 struct wl_data_offer *w_offer)
 776 {
 777         struct data_offer *offer;
 778         struct wlt_display *disp = data;
 779         int ret;
 780
 781         offer = malloc(sizeof(*offer));
 782         if (!offer) {
 783                 wl_data_offer_destroy(w_offer);
 784                 return;
 785         }
 786         memset(offer, 0, sizeof(*offer));
 787         offer->ref = 1;
 788         offer->w_offer = w_offer;
 789         offer->disp = disp;
 790
 791         ret = shl_array_new(&offer->types, sizeof(char*), 4);
 792         if (ret) {
 793                 wl_data_offer_destroy(w_offer);
 794                 free(offer);
 795                 return;
 796         }
 797
 798         wl_data_offer_add_listener(w_offer, &data_offer_listener, offer);
 799         wl_data_offer_set_user_data(w_offer, offer);
 800 }
 801
 802 static void data_dev_enter(void *data, struct wl_data_device *w_dev,
 803                            uint32_t serial, struct wl_surface *w_surface,
 804                            wl_fixed_t x, wl_fixed_t y,
 805                            struct wl_data_offer *w_offer)
 806 {
 807         struct wlt_display *disp = data;
 808
 809         if (disp->drag_offer) {
 810                 data_offer_unref(disp->drag_offer);
 811                 disp->drag_offer = NULL;
 812         }
 813
 814         if (!w_offer)
 815                 return;
 816
 817         disp->drag_offer = wl_data_offer_get_user_data(w_offer);
 818 }
 819
 820 static void data_dev_leave(void *data, struct wl_data_device *w_dev)
 821 {
 822         struct wlt_display *disp = data;
 823
 824         if (disp->drag_offer) {
 825                 data_offer_unref(disp->drag_offer);
 826                 disp->drag_offer = NULL;
 827         }
 828 }
 829
 830 static void data_dev_motion(void *data, struct wl_data_device *w_dev,
 831                             uint32_t time, wl_fixed_t x, wl_fixed_t y)
 832 {
 833 }
 834
 835 static void data_dev_drop(void *data, struct wl_data_device *w_dev)
 836 {
 837 }
 838
 839 static void data_dev_selection(void *data, struct wl_data_device *w_dev,
 840                                struct wl_data_offer *w_offer)
 841 {
 842         struct wlt_display *disp = data;
 843
 844         if (disp->selection_offer) {
 845                 data_offer_unref(disp->selection_offer);
 846                 disp->selection_offer = NULL;
 847         }
 848
 849         if (!w_offer)
 850                 return;
 851
 852         disp->selection_offer = wl_data_offer_get_user_data(w_offer);
 853 }
 854
 855 int wlt_display_get_selection_to_fd(struct wlt_display *disp, const char *mime,
 856                                     int output_fd)
 857 {
 858         unsigned int i, num;
 859         struct data_offer *offer;
 860
 861         if (!disp || !mime)
 862                 return -EINVAL;
 863         if (!disp->selection_offer)
 864                 return -ENOENT;
 865
 866         offer = disp->selection_offer;
 867         num = shl_array_get_length(offer->types);
 868         for (i = 0; i < num; ++i) {
 869                 if (!strcmp(mime, *SHL_ARRAY_AT(offer->types, char*, i)))
 870                         break;
 871         }
 872
 873         if (i == num)
 874                 return -EAGAIN;
 875
 876         wl_data_offer_receive(offer->w_offer, mime, output_fd);
 877         return 0;
 878 }
 879
 880 int wlt_display_get_selection_fd(struct wlt_display *disp, const char *mime)
 881 {
 882         int p[2], ret;
 883
 884         if (pipe2(p, O_CLOEXEC | O_NONBLOCK))
 885                 return -EFAULT;
 886
 887         ret = wlt_display_get_selection_to_fd(disp, mime, p[1]);
 888         close(p[1]);
 889
 890         if (ret) {
 891                 close(p[0]);
 892                 return ret;
 893         }
 894
 895         return p[0];
 896 }
 897
 898 int wlt_display_new_data_source(struct wlt_display *disp,
 899                                 struct wl_data_source **out)
 900 {
 901         struct wl_data_source *src;
 902
 903         if (!disp)
 904                 return -EINVAL;
 905
 906         src = wl_data_device_manager_create_data_source(disp->w_manager);
 907         if (!src)
 908                 return -EFAULT;
 909
 910         *out = src;
 911         return 0;
 912 }
 913
 914 void wlt_display_set_selection(struct wlt_display *disp,
 915                                struct wl_data_source *selection)
 916 {
 917         if (!disp)
 918                 return;
 919
 920         wl_data_device_set_selection(disp->w_data_dev, selection,
 921                                      disp->last_serial);
 922 }
 923
 924 static const struct wl_data_device_listener data_dev_listener = {
 925         .data_offer = data_dev_data_offer,
 926         .enter = data_dev_enter,
 927         .leave = data_dev_leave,
 928         .motion = data_dev_motion,
 929         .drop = data_dev_drop,
 930         .selection = data_dev_selection,
 931 };
 932
 933 static void check_ready(struct wlt_display *disp)
 934 {
 935         if (disp->state > STATE_INIT)
 936                 return;
 937
 938         if (disp->w_comp &&
 939             disp->w_seat &&
 940             disp->w_shell &&
 941             disp->w_shm &&
 942             disp->w_pointer &&
 943             disp->w_keyboard &&
 944             disp->w_manager) {
 945                 log_debug("wayland display initialized");
 946                 load_cursors(disp);
 947
 948                 disp->w_data_dev = wl_data_device_manager_get_data_device(
 949                                                 disp->w_manager, disp->w_seat);
 950                 wl_data_device_add_listener(disp->w_data_dev,
 951                                             &data_dev_listener,
 952                                             disp);
 953
 954                 disp->state = STATE_RUNNING;
 955                 shl_hook_call(disp->listeners, disp, (void*)WLT_DISPLAY_READY);
 956         }
 957 }
 958
 959 static void seat_capabilities(void *data, struct wl_seat *seat,
 960                               enum wl_seat_capability caps)
 961 {
 962         struct wlt_display *disp = data;
 963
 964         if (caps & WL_SEAT_CAPABILITY_POINTER && !disp->w_pointer) {
 965                 disp->w_pointer = wl_seat_get_pointer(seat);
 966                 wl_pointer_add_listener(disp->w_pointer, &pointer_listener,
 967                                         disp);
 968         }
 969
 970         if (caps & WL_SEAT_CAPABILITY_KEYBOARD && !disp->w_keyboard) {
 971                 disp->w_keyboard = wl_seat_get_keyboard(seat);
 972                 wl_keyboard_add_listener(disp->w_keyboard, &keyboard_listener,
 973                                          disp);
 974         }
 975
 976         check_ready(disp);
 977 }
 978
 979 static const struct wl_seat_listener seat_listener = {
 980         .capabilities = seat_capabilities,
 981 };
 982
 983 static void dp_global(struct wl_display *dp, uint32_t id, const char *iface,
 984                       uint32_t version, void *data)
 985 {
 986         struct wlt_display *disp = data;
 987
 988         if (!strcmp(iface, "wl_display")) {
 989                 log_debug("new wl_display global");
 990                 return;
 991         } else if (!strcmp(iface, "wl_compositor")) {
 992                 if (disp->w_comp) {
 993                         log_error("global wl_compositor advertised twice");
 994                         return;
 995                 }
 996                 disp->w_comp = wl_display_bind(disp->dp,
 997                                                id,
 998                                                &wl_compositor_interface);
 999                 if (!disp->w_comp) {
1000                         log_error("cannot bind wl_compositor object");
1001                         return;
1002                 }
1003         } else if (!strcmp(iface, "wl_seat")) {
1004                 if (disp->w_seat) {
1005                         log_error("global wl_seat advertised twice");
1006                         return;
1007                 }
1008                 disp->w_seat = wl_display_bind(disp->dp,
1009                                                id,
1010                                                &wl_seat_interface);
1011                 if (!disp->w_seat) {
1012                         log_error("cannot bind wl_seat object");
1013                         return;
1014                 }
1015
1016                 wl_seat_add_listener(disp->w_seat, &seat_listener, disp);
1017         } else if (!strcmp(iface, "wl_shell")) {
1018                 if (disp->w_shell) {
1019                         log_error("global wl_shell advertised twice");
1020                         return;
1021                 }
1022                 disp->w_shell = wl_display_bind(disp->dp,
1023                                                 id,
1024                                                 &wl_shell_interface);
1025                 if (!disp->w_shell) {
1026                         log_error("cannot bind wl_shell object");
1027                         return;
1028                 }
1029         } else if (!strcmp(iface, "wl_shm")) {
1030                 if (disp->w_shm) {
1031                         log_error("global wl_shm advertised twice");
1032                         return;
1033                 }
1034                 disp->w_shm = wl_display_bind(disp->dp,
1035                                               id,
1036                                               &wl_shm_interface);
1037                 if (!disp->w_shm) {
1038                         log_error("cannot bind wl_shm object");
1039                         return;
1040                 }
1041         } else if (!strcmp(iface, "wl_data_device_manager")) {
1042                 if (disp->w_manager) {
1043                         log_error("global wl_data_device_manager advertised twice");
1044                         return;
1045                 }
1046                 disp->w_manager = wl_display_bind(disp->dp, id,
1047                                                   &wl_data_device_manager_interface);
1048                 if (!disp->w_manager) {
1049                         log_error("cannot bind wl_data_device_manager_object");
1050                         return;
1051                 }
1052         } else {
1053                 log_debug("ignoring new unknown global %s", iface);
1054                 return;
1055         }
1056
1057         log_debug("new global %s", iface);
1058
1059         check_ready(disp);
1060 }
1061
1062 int wlt_display_new(struct wlt_display **out,
1063                     struct ev_eloop *eloop)
1064 {
1065         struct wlt_display *disp;
1066         int ret;
1067
1068         if (!out || !eloop)
1069                 return -EINVAL;
1070
1071         log_debug("creating new wlt-display");
1072
1073         disp = malloc(sizeof(*disp));
1074         if (!disp)
1075                 return -ENOMEM;
1076         memset(disp, 0, sizeof(*disp));
1077         disp->ref = 1;
1078         disp->eloop = eloop;
1079         shl_dlist_init(&disp->window_list);
1080
1081         ret = shl_hook_new(&disp->listeners);
1082         if (ret) {
1083                 log_error("cannot create listeners hook");
1084                 goto err_free;
1085         }
1086
1087         disp->dp = wl_display_connect(NULL);
1088         if (!disp->dp) {
1089                 log_error("cannot connect to wayland socket (%d): %m", errno);
1090                 ret = -EFAULT;
1091                 goto err_listener;
1092         }
1093
1094         ret = ev_eloop_new_fd(eloop,
1095                               &disp->dp_fd,
1096                               wl_display_get_fd(disp->dp,
1097                                                 dp_mask_update,
1098                                                 disp),
1099                               EV_READABLE,
1100                               dp_event,
1101                               disp);
1102         if (ret) {
1103                 log_error("cannot create event-fd for wayland display (%d)",
1104                           ret);
1105                 goto err_dp;
1106         }
1107
1108         ret = ev_eloop_new_timer(eloop, &disp->repeat_timer, NULL,
1109                                  repeat_event, disp);
1110         if (ret) {
1111                 log_error("cannot create repeat-timer");
1112                 goto err_dp_fd;
1113         }
1114
1115         disp->dp_listener = wl_display_add_global_listener(disp->dp,
1116                                                            dp_global,
1117                                                            disp);
1118         if (!disp->dp_listener) {
1119                 log_error("cannot add wayland global listener (%d)", errno);
1120                 goto err_timer;
1121         }
1122
1123         disp->xkb_ctx = xkb_context_new(0);
1124         if (!disp->xkb_ctx) {
1125                 log_error("cannot create XKB context");
1126                 goto err_timer;
1127         }
1128
1129         log_debug("wlt-display waiting for globals...");
1130
1131         ev_eloop_ref(disp->eloop);
1132         *out = disp;
1133         return 0;
1134
1135 err_timer:
1136         ev_eloop_rm_timer(disp->repeat_timer);
1137 err_dp_fd:
1138         ev_eloop_rm_fd(disp->dp_fd);
1139 err_dp:
1140         wl_display_disconnect(disp->dp);
1141 err_listener:
1142         shl_hook_free(disp->listeners);
1143 err_free:
1144         free(disp);
1145         return ret;
1146 }
1147
1148 void wlt_display_ref(struct wlt_display *disp)
1149 {
1150         if (!disp || !disp->ref)
1151                 return;
1152
1153         ++disp->ref;
1154 }
1155
1156 void wlt_display_unref(struct wlt_display *disp)
1157 {
1158         if (!disp || !disp->ref || --disp->ref)
1159                 return;
1160
1161         unload_cursors(disp);
1162         wl_display_remove_global_listener(disp->dp, disp->dp_listener);
1163         wl_display_flush(disp->dp);
1164         wl_display_disconnect(disp->dp);
1165         ev_eloop_rm_timer(disp->repeat_timer);
1166         ev_eloop_rm_fd(disp->dp_fd);
1167         xkb_context_unref(disp->xkb_ctx);
1168         shl_hook_free(disp->listeners);
1169         ev_eloop_unref(disp->eloop);
1170         free(disp);
1171 }
1172
1173 int wlt_display_register_cb(struct wlt_display *disp,
1174                             wlt_display_cb cb, void *data)
1175 {
1176         if (!disp)
1177                 return -EINVAL;
1178
1179         return shl_hook_add_cast(disp->listeners, cb, data);
1180 }
1181
1182 void wlt_display_unregister_cb(struct wlt_display *disp,
1183                                wlt_display_cb cb, void *data)
1184 {
1185         if (!disp)
1186                 return;
1187
1188         shl_hook_rm_cast(disp->listeners, cb, data);
1189 }
1190
1191 static void shell_surface_ping(void *data, struct wl_shell_surface *s,
1192                                uint32_t serial)
1193 {
1194         wl_shell_surface_pong(s, serial);
1195 }
1196
1197 static void wlt_window_do_redraw(struct wlt_window *wnd,
1198                                  unsigned int oldw,
1199                                  unsigned int oldh)
1200 {
1201         struct shl_dlist *iter;
1202         struct wlt_widget *widget;
1203         unsigned int x, y, flags;
1204         struct wlt_rect alloc;
1205
1206         flags = 0;
1207         if (wnd->maximized)
1208                 flags |= WLT_WINDOW_MAXIMIZED;
1209         if (wnd->fullscreen)
1210                 flags |= WLT_WINDOW_FULLSCREEN;
1211
1212         alloc.x = 0;
1213         alloc.y = 0;
1214         alloc.width = wnd->buffer.width;
1215         alloc.height = wnd->buffer.height;
1216         shl_dlist_for_each(iter, &wnd->widget_list) {
1217                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
1218                 if (widget->resize_cb)
1219                         widget->resize_cb(widget, flags, &alloc, widget->data);
1220         }
1221
1222         memset(wnd->buffer.data, 0,
1223                wnd->buffer.stride * wnd->buffer.height);
1224
1225         wnd->skip_damage = true;
1226         shl_dlist_for_each(iter, &wnd->widget_list) {
1227                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
1228                 if (widget->redraw_cb)
1229                         widget->redraw_cb(widget, flags, widget->data);
1230         }
1231         wnd->skip_damage = false;
1232
1233         if (!wnd->buffer_attached) {
1234                 wnd->buffer_attached = true;
1235                 if (wnd->resize_edges & WL_SHELL_SURFACE_RESIZE_LEFT)
1236                         x = (int)oldw - wnd->buffer.width;
1237                 else
1238                         x = 0;
1239                 if (wnd->resize_edges & WL_SHELL_SURFACE_RESIZE_TOP)
1240                         y = (int)oldh - wnd->buffer.height;
1241                 else
1242                         y = 0;
1243                 wl_surface_attach(wnd->w_surface, wnd->w_buffer, x, y);
1244                 wnd->resize_edges = 0;
1245         }
1246
1247         wl_surface_damage(wnd->w_surface, 0, 0, wnd->buffer.width,
1248                           wnd->buffer.height);
1249 }
1250
1251 static int resize_window(struct wlt_window *wnd, unsigned int width,
1252                          unsigned int height, bool force_redraw)
1253 {
1254         struct shl_dlist *iter;
1255         struct wlt_widget *widget;
1256         struct wl_buffer *old_buffer = NULL;
1257         struct wlt_pool *old_pool = NULL;
1258         size_t nsize;
1259         int ret;
1260         unsigned int oldw, oldh, neww, newh, minw, minh, flags;
1261
1262         if (!width)
1263                 width = wnd->buffer.width;
1264         if (!height)
1265                 height = wnd->buffer.height;
1266
1267         if (!width || !height)
1268                 return -EINVAL;
1269
1270         flags = 0;
1271         if (wnd->maximized)
1272                 flags |= WLT_WINDOW_MAXIMIZED;
1273         if (wnd->fullscreen)
1274                 flags |= WLT_WINDOW_FULLSCREEN;
1275
1276         neww = 0;
1277         newh = 0;
1278         minw = 0;
1279         minh = 0;
1280         shl_dlist_for_each(iter, &wnd->widget_list) {
1281                 widget = shl_dlist_entry(iter, struct wlt_widget, list);
1282                 if (widget->prepare_resize_cb)
1283                         widget->prepare_resize_cb(widget,
1284                                                   flags,
1285                                                   width, height,
1286                                                   &minw, &minh,
1287                                                   &neww, &newh,
1288                                                   widget->data);
1289         }
1290
1291         if (neww)
1292                 width = neww;
1293         if (newh)
1294                 height = newh;
1295
1296         if (width == wnd->buffer.width &&
1297             height == wnd->buffer.height) {
1298                 if (force_redraw)
1299                         wlt_window_do_redraw(wnd, width, height);
1300                 return 0;
1301         }
1302
1303         oldw = wnd->buffer.width;
1304         oldh = wnd->buffer.height;
1305
1306         nsize = width * height * 4;
1307         if (wnd->pool && wnd->pool->size >= nsize) {
1308                 old_buffer = wnd->w_buffer;
1309                 wnd->w_buffer = wl_shm_pool_create_buffer(wnd->pool->w_pool,
1310                                                 0, width, height,
1311                                                 width * 4,
1312                                                 WL_SHM_FORMAT_ARGB8888);
1313                 if (!wnd->w_buffer) {
1314                         log_error("cannot create wayland shm buffer");
1315                         wnd->w_buffer = old_buffer;
1316                         return -ENOMEM;
1317                 }
1318         } else {
1319                 old_pool = wnd->pool;
1320                 ret = wlt_pool_new(&wnd->pool, wnd->disp, nsize);
1321                 if (ret) {
1322                         log_error("cannot create memory pool");
1323                         wnd->pool = old_pool;
1324                         return ret;
1325                 }
1326
1327                 old_buffer = wnd->w_buffer;
1328                 wnd->w_buffer = wl_shm_pool_create_buffer(wnd->pool->w_pool,
1329                                                 0, width, height,
1330                                                 width * 4,
1331                                                 WL_SHM_FORMAT_ARGB8888);
1332                 if (!wnd->w_buffer) {
1333                         log_error("cannot create wayland shm buffer");
1334                         wnd->w_buffer = old_buffer;
1335                         wlt_pool_free(wnd->pool);
1336                         wnd->pool = old_pool;
1337                         return -ENOMEM;
1338                 }
1339         }
1340
1341         wnd->buffer.data = wnd->pool->data;
1342         wnd->buffer.width = width;
1343         wnd->buffer.height = height;
1344         wnd->buffer.stride = width * 4;
1345         wnd->buffer_attached = false;
1346
1347         wlt_window_do_redraw(wnd, oldw, oldh);
1348
1349         if (old_buffer)
1350                 wl_buffer_destroy(old_buffer);
1351         if (old_pool)
1352                 wlt_pool_free(old_pool);
1353
1354         return 0;
1355 }
1356
1357 static void frame_callback(void *data, struct wl_callback *w_callback,
1358                            uint32_t time);
1359 static void idle_frame(struct ev_eloop *eloop, void *unused, void *data);
1360
1361 static const struct wl_callback_listener frame_callback_listener = {
1362         .done = frame_callback,
1363 };
1364
1365 static void do_frame(struct wlt_window *wnd)
1366 {
1367         bool force;
1368
1369         wnd->idle_pending = false;
1370         ev_eloop_unregister_idle_cb(wnd->disp->eloop, idle_frame, wnd);
1371
1372         if (wnd->need_resize) {
1373                 force = wnd->need_redraw;
1374                 wnd->need_frame = true;
1375                 wnd->need_resize = false;
1376                 wnd->need_redraw = false;
1377                 resize_window(wnd, wnd->new_width, wnd->new_height, force);
1378         }
1379
1380         if (wnd->need_redraw) {
1381                 wnd->need_frame = true;
1382                 wnd->need_redraw = false;
1383                 wlt_window_do_redraw(wnd, wnd->buffer.width,
1384                                      wnd->buffer.height);
1385         }
1386
1387         if (wnd->need_frame) {
1388                 wnd->w_frame = wl_surface_frame(wnd->w_surface);
1389                 wl_callback_add_listener(wnd->w_frame,
1390                                          &frame_callback_listener, wnd);
1391         }
1392 }
1393
1394 static void frame_callback(void *data, struct wl_callback *w_callback,
1395                            uint32_t time)
1396 {
1397         struct wlt_window *wnd = data;
1398
1399         wl_callback_destroy(w_callback);
1400         wnd->w_frame = NULL;
1401         wnd->need_frame = false;
1402
1403         do_frame(wnd);
1404 }
1405
1406 static void idle_frame(struct ev_eloop *eloop, void *unused, void *data)
1407 {
1408         struct wlt_window *wnd = data;
1409
1410         do_frame(wnd);
1411 }
1412
1413 /*
1414  * Buffer Handling and Frame Scheduling
1415  * We use wl_shm for buffer allocation. This means, we have a single buffer
1416  * client side and the server loads it into its backbuffer for rendering. If the
1417  * server does not do this, we are screwed anyway, but that's on behalf of the
1418  * server, so we don't care.
1419  *
1420  * However, this means, when we create a buffer, we need to notify the
1421  * compositor and then wait until the compositor has created its back-buffer,
1422  * before we continue using this buffer. We can use the "frame" callback to get
1423  * notified about this.
1424  *
1425  * The logic we have is:
1426  * You set the boolean flags what action is needed in wlt_window and then call
1427  * "schedule_frame()". If we didn't already do any buffer operations in this
1428  * frame, then this function schedules an idle-callback which then performs
1429  * the requested functions (flags in wlt_window). Afterwards, it sets a marker
1430  * that this frame was already used and schedules a frame-callback.
1431  * If during this time another call to schedule_frame() is made, we do nothing
1432  * but wait for the frame-callback. It will then directly perform all the
1433  * requested functions and reschedule a frame-callback.
1434  * If nothing was schedule for one frame, we have no more interest in
1435  * frame-callbacks and thus we set "need_frame" to false again and don't
1436  * schedule any more frame-callbacks.
1437  */
1438 static void schedule_frame(struct wlt_window *wnd)
1439 {
1440         int ret;
1441
1442         if (!wnd || wnd->w_frame)
1443                 return;
1444
1445         if (wnd->need_frame || wnd->idle_pending)
1446                 return;
1447
1448         ret = ev_eloop_register_idle_cb(wnd->disp->eloop, idle_frame, wnd);
1449         if (ret)
1450                 log_error("cannot schedule idle callback: %d", ret);
1451         else
1452                 wnd->idle_pending = true;
1453 }
1454
1455 static void shell_surface_configure(void *data, struct wl_shell_surface *s,
1456                                     uint32_t edges, int32_t width,
1457                                     int32_t height)
1458 {
1459         struct wlt_window *wnd = data;
1460
1461         if (width <= 0)
1462                 width = 1;
1463         if (height <= 0)
1464                 height = 1;
1465
1466         wnd->resize_edges = edges;
1467         wlt_window_set_size(wnd, width, height);
1468 }
1469
1470 static void shell_surface_popup_done(void *data, struct wl_shell_surface *s)
1471 {
1472 }
1473
1474 static const struct wl_shell_surface_listener shell_surface_listener = {
1475         .ping = shell_surface_ping,
1476         .configure = shell_surface_configure,
1477         .popup_done = shell_surface_popup_done,
1478 };
1479
1480 static void close_window(struct ev_eloop *eloop, void *unused, void *data)
1481 {
1482         struct wlt_window *wnd = data;
1483
1484         ev_eloop_unregister_idle_cb(eloop, close_window, wnd);
1485         wnd->close_pending = false;
1486
1487         if (wnd->close_cb)
1488                 wnd->close_cb(wnd, wnd->data);
1489 }
1490
1491 int wlt_display_create_window(struct wlt_display *disp,
1492                               struct wlt_window **out,
1493                               unsigned int width,
1494                               unsigned int height,
1495                               void *data)
1496 {
1497         struct wlt_window *wnd;
1498         int ret;
1499
1500         if (!disp || !out || !width || !height)
1501                 return -EINVAL;
1502
1503         if (disp->state != STATE_RUNNING) {
1504                 log_error("cannot create window, display is not running but in state %u",
1505                           disp->state);
1506                 return -EBUSY;
1507         }
1508
1509         wnd = malloc(sizeof(*wnd));
1510         if (!wnd)
1511                 return -ENOMEM;
1512         memset(wnd, 0, sizeof(*wnd));
1513         wnd->ref = 1;
1514         wnd->disp = disp;
1515         wnd->data = data;
1516         shl_dlist_init(&wnd->widget_list);
1517
1518         wnd->w_surface = wl_compositor_create_surface(disp->w_comp);
1519         if (!wnd->w_surface) {
1520                 log_error("cannot create wayland surface");
1521                 ret = -EFAULT;
1522                 goto err_free;
1523         }
1524
1525         wnd->w_shell_surface = wl_shell_get_shell_surface(disp->w_shell,
1526                                                           wnd->w_surface);
1527         if (!wnd->w_shell_surface) {
1528                 log_error("cannot retrieve shell-surface for wayland surface");
1529                 ret = -EFAULT;
1530                 goto err_surface;
1531         }
1532
1533         wl_shell_surface_add_listener(wnd->w_shell_surface,
1534                                       &shell_surface_listener, wnd);
1535         wl_shell_surface_set_toplevel(wnd->w_shell_surface);
1536
1537         ret = resize_window(wnd, width, height, true);
1538         if (ret)
1539                 goto err_shell_surface;
1540
1541         wlt_display_ref(disp);
1542         shl_dlist_link(&disp->window_list, &wnd->list);
1543         *out = wnd;
1544         return 0;
1545
1546 err_shell_surface:
1547         wl_shell_surface_destroy(wnd->w_shell_surface);
1548 err_surface:
1549         wl_surface_destroy(wnd->w_surface);
1550 err_free:
1551         free(wnd);
1552         return ret;
1553 }
1554
1555 void wlt_window_ref(struct wlt_window *wnd)
1556 {
1557         if (!wnd || !wnd->ref)
1558                 return;
1559
1560         ++wnd->ref;
1561 }
1562
1563 void wlt_window_unref(struct wlt_window *wnd)
1564 {
1565         struct wlt_widget *widget;
1566
1567         if (!wnd || !wnd->ref || --wnd->ref)
1568                 return;
1569
1570         while (!shl_dlist_empty(&wnd->widget_list)) {
1571                 widget = shl_dlist_entry(wnd->widget_list.next,
1572                                          struct wlt_widget, list);
1573                 wlt_widget_destroy(widget);
1574         }
1575
1576         if (wnd->close_pending)
1577                 ev_eloop_unregister_idle_cb(wnd->disp->eloop, close_window,
1578                                             wnd);
1579         if (wnd->idle_pending)
1580                 ev_eloop_unregister_idle_cb(wnd->disp->eloop, idle_frame, wnd);
1581         shl_dlist_unlink(&wnd->list);
1582         if (wnd->w_frame)
1583                 wl_callback_destroy(wnd->w_frame);
1584         if (wnd->w_buffer)
1585                 wl_buffer_destroy(wnd->w_buffer);
1586         if (wnd->pool)
1587                 wlt_pool_free(wnd->pool);
1588         wl_shell_surface_destroy(wnd->w_shell_surface);
1589         wl_surface_destroy(wnd->w_surface);
1590         wlt_display_unref(wnd->disp);
1591         free(wnd);
1592 }
1593
1594 int wlt_window_create_widget(struct wlt_window *wnd,
1595                              struct wlt_widget **out,
1596                              void *data)
1597 {
1598         struct wlt_widget *widget;
1599
1600         if (!wnd || !out)
1601                 return -EINVAL;
1602
1603         widget = malloc(sizeof(*widget));
1604         if (!widget)
1605                 return -ENOMEM;
1606         memset(widget, 0, sizeof(*widget));
1607         widget->wnd = wnd;
1608         widget->data = data;
1609
1610         wlt_window_set_size(wnd, wnd->buffer.width, wnd->buffer.height);
1611         shl_dlist_link_tail(&wnd->widget_list, &widget->list);
1612         *out = widget;
1613         return 0;
1614 }
1615
1616 void wlt_window_schedule_redraw(struct wlt_window *wnd)
1617 {
1618         if (!wnd)
1619                 return;
1620
1621         wnd->need_redraw = true;
1622         schedule_frame(wnd);
1623 }
1624
1625 void wlt_window_damage(struct wlt_window *wnd,
1626                        struct wlt_rect *damage)
1627 {
1628         if (!wnd || !damage || wnd->skip_damage)
1629                 return;
1630
1631         wl_surface_damage(wnd->w_surface, damage->x, damage->y,
1632                           damage->width, damage->height);
1633 }
1634
1635 void wlt_window_get_buffer(struct wlt_window *wnd,
1636                            const struct wlt_rect *alloc,
1637                            struct wlt_shm_buffer *buf)
1638 {
1639         struct wlt_shm_buffer *rbuf;
1640
1641         if (!wnd || !buf)
1642                 return;
1643
1644         rbuf = &wnd->buffer;
1645
1646         if (!alloc) {
1647                 memcpy(buf, rbuf, sizeof(*buf));
1648                 return;
1649         }
1650
1651         if (alloc->x >= rbuf->width ||
1652             alloc->y >= rbuf->height) {
1653                 memset(buf, 0, sizeof(*buf));
1654                 return;
1655         }
1656
1657         /* set width */
1658         if (alloc->x + alloc->width > rbuf->width)
1659                 buf->width = rbuf->width - alloc->x;
1660         else
1661                 buf->width = alloc->width;
1662
1663         /* set height */
1664         if (alloc->y + alloc->height > rbuf->height)
1665                 buf->height = rbuf->height - alloc->y;
1666         else
1667                 buf->height = alloc->height;
1668
1669         /* set stride */
1670         buf->stride  = rbuf->stride;
1671
1672         /* set data */
1673         buf->data  = rbuf->data;
1674         buf->data += alloc->y * rbuf->stride;
1675         buf->data += alloc->x * 4;
1676 }
1677
1678 void wlt_window_move(struct wlt_window *wnd)
1679 {
1680         if (!wnd)
1681                 return;
1682
1683         wl_shell_surface_move(wnd->w_shell_surface,
1684                               wnd->disp->w_seat,
1685                               wnd->disp->last_serial);
1686 }
1687
1688 void wlt_window_resize(struct wlt_window *wnd, uint32_t edges)
1689 {
1690         if (!wnd)
1691                 return;
1692
1693         wl_shell_surface_resize(wnd->w_shell_surface,
1694                                 wnd->disp->w_seat,
1695                                 wnd->disp->last_serial,
1696                                 edges);
1697 }
1698
1699 int wlt_window_set_size(struct wlt_window *wnd,
1700                         unsigned int width, unsigned int height)
1701 {
1702         if (!wnd)
1703                 return -EINVAL;
1704
1705         wnd->new_width = width;
1706         wnd->new_height = height;
1707         wnd->need_resize = true;
1708         schedule_frame(wnd);
1709
1710         return 0;
1711 }
1712
1713 void wlt_window_set_cursor(struct wlt_window *wnd, unsigned int cursor)
1714 {
1715         if (!wnd)
1716                 return;
1717
1718         set_cursor(wnd->disp, cursor);
1719 }
1720
1721 void wlt_window_set_close_cb(struct wlt_window *wnd,
1722                              wlt_window_close_cb cb)
1723 {
1724         if (!wnd)
1725                 return;
1726
1727         wnd->close_cb = cb;
1728 }
1729
1730 void wlt_window_close(struct wlt_window *wnd)
1731 {
1732         if (!wnd)
1733                 return;
1734
1735         wnd->close_pending = true;
1736         ev_eloop_register_idle_cb(wnd->disp->eloop, close_window, wnd);
1737 }
1738
1739 void wlt_window_toggle_maximize(struct wlt_window *wnd)
1740 {
1741         if (!wnd)
1742                 return;
1743
1744         if (wnd->maximized) {
1745                 if (!wnd->fullscreen) {
1746                         wl_shell_surface_set_toplevel(wnd->w_shell_surface);
1747                         wlt_window_set_size(wnd, wnd->saved_width,
1748                                             wnd->saved_height);
1749                 }
1750         } else {
1751                 if (!wnd->fullscreen) {
1752                         wnd->saved_width = wnd->buffer.width;
1753                         wnd->saved_height = wnd->buffer.height;
1754                         wl_shell_surface_set_maximized(wnd->w_shell_surface,
1755                                                        NULL);
1756                 }
1757         }
1758
1759         wnd->maximized = !wnd->maximized;
1760 }
1761
1762 void wlt_window_toggle_fullscreen(struct wlt_window *wnd)
1763 {
1764         if (!wnd)
1765                 return;
1766
1767         if (wnd->fullscreen) {
1768                 if (wnd->maximized) {
1769                         wl_shell_surface_set_maximized(wnd->w_shell_surface,
1770                                                        NULL);
1771                 } else {
1772                         wl_shell_surface_set_toplevel(wnd->w_shell_surface);
1773                         wlt_window_set_size(wnd, wnd->saved_width,
1774                                             wnd->saved_height);
1775                 }
1776         } else {
1777                 if (!wnd->maximized) {
1778                         wnd->saved_width = wnd->buffer.width;
1779                         wnd->saved_height = wnd->buffer.height;
1780                 }
1781                 wl_shell_surface_set_fullscreen(wnd->w_shell_surface,
1782                                 WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
1783                                 0, NULL);
1784         }
1785
1786         wnd->fullscreen = !wnd->fullscreen;
1787 }
1788
1789 struct ev_eloop *wlt_window_get_eloop(struct wlt_window *wnd)
1790 {
1791         if (!wnd)
1792                 return NULL;
1793
1794         return wnd->disp->eloop;
1795 }
1796
1797 struct wlt_display *wlt_window_get_display(struct wlt_window *wnd)
1798 {
1799         if (!wnd)
1800                 return NULL;
1801
1802         return wnd->disp;
1803 }
1804
1805 void wlt_widget_destroy(struct wlt_widget *widget)
1806 {
1807         if (!widget)
1808                 return;
1809
1810         if (widget->destroy_cb)
1811                 widget->destroy_cb(widget, widget->data);
1812         shl_dlist_unlink(&widget->list);
1813         free(widget);
1814 }
1815
1816 struct wlt_window *wlt_widget_get_window(struct wlt_widget *widget)
1817 {
1818         if (!widget)
1819                 return NULL;
1820
1821         return widget->wnd;
1822 }
1823
1824 void wlt_widget_set_redraw_cb(struct wlt_widget *widget,
1825                               wlt_widget_redraw_cb cb)
1826 {
1827         if (!widget)
1828                 return;
1829
1830         widget->redraw_cb = cb;
1831 }
1832
1833 void wlt_widget_set_destroy_cb(struct wlt_widget *widget,
1834                                wlt_widget_destroy_cb cb)
1835 {
1836         if (!widget)
1837                 return;
1838
1839         widget->destroy_cb = cb;
1840 }
1841
1842 void wlt_widget_set_resize_cb(struct wlt_widget *widget,
1843                               wlt_widget_prepare_resize_cb prepare_cb,
1844                               wlt_widget_resize_cb cb)
1845 {
1846         if (!widget)
1847                 return;
1848
1849         widget->prepare_resize_cb = prepare_cb;
1850         widget->resize_cb = cb;
1851 }
1852
1853 void wlt_widget_set_pointer_cb(struct wlt_widget *widget,
1854                                wlt_widget_pointer_enter_cb enter_cb,
1855                                wlt_widget_pointer_leave_cb leave_cb,
1856                                wlt_widget_pointer_motion_cb motion_cb,
1857                                wlt_widget_pointer_button_cb button_cb)
1858 {
1859         if (!widget)
1860                 return;
1861
1862         widget->pointer_enter_cb = enter_cb;
1863         widget->pointer_leave_cb = leave_cb;
1864         widget->pointer_motion_cb = motion_cb;
1865         widget->pointer_button_cb = button_cb;
1866 }
1867
1868 void wlt_widget_set_keyboard_cb(struct wlt_widget *widget,
1869                                 wlt_widget_keyboard_cb cb)
1870 {
1871         if (!widget)
1872                 return;
1873
1874         widget->keyboard_cb = cb;
1875 }