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