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