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