clients/window.c

   1 /*
   2  * Copyright © 2008 Kristian Høgsberg
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #define _GNU_SOURCE
  24
  25 #include "../config.h"
  26
  27 #include <stdint.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33 #include <math.h>
  34 #include <assert.h>
  35 #include <time.h>
  36 #include <cairo.h>
  37 #include <sys/mman.h>
  38 #include <sys/epoll.h>
  39 #include <sys/timerfd.h>
  40
  41 #include <pixman.h>
  42
  43 #include <wayland-egl.h>
  44
  45 #ifdef USE_CAIRO_GLESV2
  46 #include <GLES2/gl2.h>
  47 #include <GLES2/gl2ext.h>
  48 #else
  49 #include <GL/gl.h>
  50 #endif
  51 #include <EGL/egl.h>
  52 #include <EGL/eglext.h>
  53
  54 #ifdef HAVE_CAIRO_EGL
  55 #include <cairo-gl.h>
  56 #endif
  57
  58 #include <xkbcommon/xkbcommon.h>
  59 #include <wayland-cursor.h>
  60
  61 #include <linux/input.h>
  62 #include <wayland-client.h>
  63 #include "../shared/cairo-util.h"
  64 #include "text-cursor-position-client-protocol.h"
  65 #include "../shared/os-compatibility.h"
  66
  67 #include "window.h"
  68
  69 struct shm_pool;
  70
  71 struct display {
  72         struct wl_display *display;
  73         struct wl_compositor *compositor;
  74         struct wl_shell *shell;
  75         struct wl_shm *shm;
  76         struct wl_data_device_manager *data_device_manager;
  77         struct text_cursor_position *text_cursor_position;
  78         EGLDisplay dpy;
  79         EGLConfig argb_config;
  80         EGLContext argb_ctx;
  81         cairo_device_t *argb_device;
  82         uint32_t serial;
  83
  84         int display_fd;
  85         uint32_t mask;
  86         struct task display_task;
  87
  88         int epoll_fd;
  89         struct wl_list deferred_list;
  90
  91         int running;
  92
  93         struct wl_list window_list;
  94         struct wl_list input_list;
  95         struct wl_list output_list;
  96
  97         struct theme *theme;
  98
  99         struct {
 100                 struct xkb_rule_names names;
 101                 struct xkb_keymap *keymap;
 102                 struct xkb_state *state;
 103                 struct xkb_context *context;
 104                 xkb_mod_mask_t control_mask;
 105                 xkb_mod_mask_t alt_mask;
 106                 xkb_mod_mask_t shift_mask;
 107         } xkb;
 108
 109         struct wl_cursor_theme *cursor_theme;
 110         struct wl_cursor **cursors;
 111
 112         PFNGLEGLIMAGETARGETTEXTURE2DOESPROC image_target_texture_2d;
 113         PFNEGLCREATEIMAGEKHRPROC create_image;
 114         PFNEGLDESTROYIMAGEKHRPROC destroy_image;
 115
 116         display_output_handler_t output_configure_handler;
 117
 118         void *user_data;
 119 };
 120
 121 enum {
 122         TYPE_NONE,
 123         TYPE_TOPLEVEL,
 124         TYPE_FULLSCREEN,
 125         TYPE_MAXIMIZED,
 126         TYPE_TRANSIENT,
 127         TYPE_MENU,
 128         TYPE_CUSTOM
 129 };
 130
 131 struct window_output {
 132         struct output *output;
 133         struct wl_list link;
 134 };
 135
 136 struct window {
 137         struct display *display;
 138         struct window *parent;
 139         struct wl_list window_output_list;
 140         struct wl_surface *surface;
 141         struct wl_shell_surface *shell_surface;
 142         struct wl_region *input_region;
 143         struct wl_region *opaque_region;
 144         char *title;
 145         struct rectangle allocation, saved_allocation, server_allocation;
 146         struct rectangle pending_allocation;
 147         int x, y;
 148         int resize_edges;
 149         int redraw_scheduled;
 150         int redraw_needed;
 151         struct task redraw_task;
 152         int resize_needed;
 153         int type;
 154         int transparent;
 155         int send_cursor_position;
 156         struct input *keyboard_device;
 157         enum window_buffer_type buffer_type;
 158
 159         cairo_surface_t *cairo_surface;
 160
 161         struct shm_pool *pool;
 162
 163         window_key_handler_t key_handler;
 164         window_keyboard_focus_handler_t keyboard_focus_handler;
 165         window_data_handler_t data_handler;
 166         window_drop_handler_t drop_handler;
 167         window_close_handler_t close_handler;
 168
 169         struct frame *frame;
 170         struct widget *widget;
 171
 172         void *user_data;
 173         struct wl_list link;
 174 };
 175
 176 struct widget {
 177         struct window *window;
 178         struct tooltip *tooltip;
 179         struct wl_list child_list;
 180         struct wl_list link;
 181         struct rectangle allocation;
 182         widget_resize_handler_t resize_handler;
 183         widget_redraw_handler_t redraw_handler;
 184         widget_enter_handler_t enter_handler;
 185         widget_leave_handler_t leave_handler;
 186         widget_motion_handler_t motion_handler;
 187         widget_button_handler_t button_handler;
 188         void *user_data;
 189         int opaque;
 190         int tooltip_count;
 191 };
 192
 193 struct input {
 194         struct display *display;
 195         struct wl_seat *seat;
 196         struct wl_pointer *pointer;
 197         struct wl_keyboard *keyboard;
 198         struct window *pointer_focus;
 199         struct window *keyboard_focus;
 200         int current_cursor;
 201         uint32_t modifiers;
 202         uint32_t pointer_enter_serial;
 203         float sx, sy;
 204         struct wl_list link;
 205
 206         struct widget *focus_widget;
 207         struct widget *grab;
 208         uint32_t grab_button;
 209
 210         struct wl_data_device *data_device;
 211         struct data_offer *drag_offer;
 212         struct data_offer *selection_offer;
 213 };
 214
 215 struct output {
 216         struct display *display;
 217         struct wl_output *output;
 218         struct rectangle allocation;
 219         struct wl_list link;
 220
 221         display_output_handler_t destroy_handler;
 222         void *user_data;
 223 };
 224
 225 enum frame_button_action {
 226         FRAME_BUTTON_NULL = 0,
 227         FRAME_BUTTON_ICON = 1,
 228         FRAME_BUTTON_CLOSE = 2,
 229         FRAME_BUTTON_MINIMIZE = 3,
 230         FRAME_BUTTON_MAXIMIZE = 4,
 231 };
 232
 233 enum frame_button_pointer {
 234         FRAME_BUTTON_DEFAULT = 0,
 235         FRAME_BUTTON_OVER = 1,
 236         FRAME_BUTTON_ACTIVE = 2,
 237 };
 238
 239 enum frame_button_align {
 240         FRAME_BUTTON_RIGHT = 0,
 241         FRAME_BUTTON_LEFT = 1,
 242 };
 243
 244 enum frame_button_decoration {
 245         FRAME_BUTTON_NONE = 0,
 246         FRAME_BUTTON_FANCY = 1,
 247 };
 248
 249 struct frame_button {
 250         struct widget *widget;
 251         struct frame *frame;
 252         cairo_surface_t *icon;
 253         enum frame_button_action type;
 254         enum frame_button_pointer state;
 255         struct wl_list link;    /* buttons_list */
 256         enum frame_button_align align;
 257         enum frame_button_decoration decoration;
 258 };
 259
 260 struct frame {
 261         struct widget *widget;
 262         struct widget *child;
 263         struct wl_list buttons_list;
 264 };
 265
 266 struct menu {
 267         struct window *window;
 268         struct widget *widget;
 269         struct input *input;
 270         const char **entries;
 271         uint32_t time;
 272         int current;
 273         int count;
 274         menu_func_t func;
 275 };
 276
 277 struct tooltip {
 278         struct widget *parent;
 279         struct window *window;
 280         struct widget *widget;
 281         char *entry;
 282         struct task tooltip_task;
 283         int tooltip_fd;
 284         float x, y;
 285 };
 286
 287 struct shm_pool {
 288         struct wl_shm_pool *pool;
 289         size_t size;
 290         size_t used;
 291         void *data;
 292 };
 293
 294 enum {
 295         CURSOR_DEFAULT = 100,
 296         CURSOR_UNSET
 297 };
 298
 299 enum window_location {
 300         WINDOW_INTERIOR = 0,
 301         WINDOW_RESIZING_TOP = 1,
 302         WINDOW_RESIZING_BOTTOM = 2,
 303         WINDOW_RESIZING_LEFT = 4,
 304         WINDOW_RESIZING_TOP_LEFT = 5,
 305         WINDOW_RESIZING_BOTTOM_LEFT = 6,
 306         WINDOW_RESIZING_RIGHT = 8,
 307         WINDOW_RESIZING_TOP_RIGHT = 9,
 308         WINDOW_RESIZING_BOTTOM_RIGHT = 10,
 309         WINDOW_RESIZING_MASK = 15,
 310         WINDOW_EXTERIOR = 16,
 311         WINDOW_TITLEBAR = 17,
 312         WINDOW_CLIENT_AREA = 18,
 313 };
 314
 315 const char *option_xkb_layout = "us";
 316 const char *option_xkb_variant = "";
 317 const char *option_xkb_options = "";
 318
 319 static const struct weston_option xkb_options[] = {
 320         { WESTON_OPTION_STRING, "xkb-layout", 0, &option_xkb_layout },
 321         { WESTON_OPTION_STRING, "xkb-variant", 0, &option_xkb_variant },
 322         { WESTON_OPTION_STRING, "xkb-options", 0, &option_xkb_options },
 323 };
 324
 325 static const cairo_user_data_key_t surface_data_key;
 326 struct surface_data {
 327         struct wl_buffer *buffer;
 328 };
 329
 330 #define MULT(_d,c,a,t) \
 331         do { t = c * a + 0x7f; _d = ((t >> 8) + t) >> 8; } while (0)
 332
 333 #ifdef HAVE_CAIRO_EGL
 334
 335 struct egl_window_surface_data {
 336         struct display *display;
 337         struct wl_surface *surface;
 338         struct wl_egl_window *window;
 339         EGLSurface surf;
 340 };
 341
 342 static void
 343 egl_window_surface_data_destroy(void *p)
 344 {
 345         struct egl_window_surface_data *data = p;
 346         struct display *d = data->display;
 347
 348         eglDestroySurface(d->dpy, data->surf);
 349         wl_egl_window_destroy(data->window);
 350         data->surface = NULL;
 351
 352         free(p);
 353 }
 354
 355 static cairo_surface_t *
 356 display_create_egl_window_surface(struct display *display,
 357                                   struct wl_surface *surface,
 358                                   uint32_t flags,
 359                                   struct rectangle *rectangle)
 360 {
 361         cairo_surface_t *cairo_surface;
 362         struct egl_window_surface_data *data;
 363         EGLConfig config;
 364         cairo_device_t *device;
 365
 366         data = malloc(sizeof *data);
 367         if (data == NULL)
 368                 return NULL;
 369
 370         data->display = display;
 371         data->surface = surface;
 372
 373         config = display->argb_config;
 374         device = display->argb_device;
 375
 376         data->window = wl_egl_window_create(surface,
 377                                             rectangle->width,
 378                                             rectangle->height);
 379
 380         data->surf = eglCreateWindowSurface(display->dpy, config,
 381                                             data->window, NULL);
 382
 383         cairo_surface = cairo_gl_surface_create_for_egl(device,
 384                                                         data->surf,
 385                                                         rectangle->width,
 386                                                         rectangle->height);
 387
 388         cairo_surface_set_user_data(cairo_surface, &surface_data_key,
 389                                     data, egl_window_surface_data_destroy);
 390
 391         return cairo_surface;
 392 }
 393
 394 #endif
 395
 396 struct wl_buffer *
 397 display_get_buffer_for_surface(struct display *display,
 398                                cairo_surface_t *surface)
 399 {
 400         struct surface_data *data;
 401
 402         data = cairo_surface_get_user_data (surface, &surface_data_key);
 403
 404         return data->buffer;
 405 }
 406
 407 struct shm_surface_data {
 408         struct surface_data data;
 409         struct shm_pool *pool;
 410 };
 411
 412 static void
 413 shm_pool_destroy(struct shm_pool *pool);
 414
 415 static void
 416 shm_surface_data_destroy(void *p)
 417 {
 418         struct shm_surface_data *data = p;
 419
 420         wl_buffer_destroy(data->data.buffer);
 421         if (data->pool)
 422                 shm_pool_destroy(data->pool);
 423 }
 424
 425 static struct wl_shm_pool *
 426 make_shm_pool(struct display *display, int size, void **data)
 427 {
 428         char filename[] = "/tmp/wayland-shm-XXXXXX";
 429         struct wl_shm_pool *pool;
 430         int fd;
 431
 432         fd = mkstemp(filename);
 433         if (fd < 0) {
 434                 fprintf(stderr, "open %s failed: %m\n", filename);
 435                 return NULL;
 436         }
 437         if (ftruncate(fd, size) < 0) {
 438                 fprintf(stderr, "ftruncate failed: %m\n");
 439                 close(fd);
 440                 return NULL;
 441         }
 442
 443         *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 444         unlink(filename);
 445
 446         if (*data == MAP_FAILED) {
 447                 fprintf(stderr, "mmap failed: %m\n");
 448                 close(fd);
 449                 return NULL;
 450         }
 451
 452         pool = wl_shm_create_pool(display->shm, fd, size);
 453
 454         close(fd);
 455
 456         return pool;
 457 }
 458
 459 static struct shm_pool *
 460 shm_pool_create(struct display *display, size_t size)
 461 {
 462         struct shm_pool *pool = malloc(sizeof *pool);
 463
 464         if (!pool)
 465                 return NULL;
 466
 467         pool->pool = make_shm_pool(display, size, &pool->data);
 468         if (!pool->pool) {
 469                 free(pool);
 470                 return NULL;
 471         }
 472
 473         pool->size = size;
 474         pool->used = 0;
 475
 476         return pool;
 477 }
 478
 479 static void *
 480 shm_pool_allocate(struct shm_pool *pool, size_t size, int *offset)
 481 {
 482         if (pool->used + size > pool->size)
 483                 return NULL;
 484
 485         *offset = pool->used;
 486         pool->used += size;
 487
 488         return (char *) pool->data + *offset;
 489 }
 490
 491 /* destroy the pool. this does not unmap the memory though */
 492 static void
 493 shm_pool_destroy(struct shm_pool *pool)
 494 {
 495         munmap(pool->data, pool->size);
 496         wl_shm_pool_destroy(pool->pool);
 497         free(pool);
 498 }
 499
 500 /* Start allocating from the beginning of the pool again */
 501 static void
 502 shm_pool_reset(struct shm_pool *pool)
 503 {
 504         pool->used = 0;
 505 }
 506
 507 static int
 508 data_length_for_shm_surface(struct rectangle *rect)
 509 {
 510         int stride;
 511
 512         stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32,
 513                                                 rect->width);
 514         return stride * rect->height;
 515 }
 516
 517 static cairo_surface_t *
 518 display_create_shm_surface_from_pool(struct display *display,
 519                                      struct rectangle *rectangle,
 520                                      uint32_t flags, struct shm_pool *pool)
 521 {
 522         struct shm_surface_data *data;
 523         uint32_t format;
 524         cairo_surface_t *surface;
 525         int stride, length, offset;
 526         void *map;
 527
 528         data = malloc(sizeof *data);
 529         if (data == NULL)
 530                 return NULL;
 531
 532         stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32,
 533                                                 rectangle->width);
 534         length = stride * rectangle->height;
 535         data->pool = NULL;
 536         map = shm_pool_allocate(pool, length, &offset);
 537
 538         if (!map) {
 539                 free(data);
 540                 return NULL;
 541         }
 542
 543         surface = cairo_image_surface_create_for_data (map,
 544                                                        CAIRO_FORMAT_ARGB32,
 545                                                        rectangle->width,
 546                                                        rectangle->height,
 547                                                        stride);
 548
 549         cairo_surface_set_user_data (surface, &surface_data_key,
 550                                      data, shm_surface_data_destroy);
 551
 552         if (flags & SURFACE_OPAQUE)
 553                 format = WL_SHM_FORMAT_XRGB8888;
 554         else
 555                 format = WL_SHM_FORMAT_ARGB8888;
 556
 557         data->data.buffer = wl_shm_pool_create_buffer(pool->pool, offset,
 558                                                       rectangle->width,
 559                                                       rectangle->height,
 560                                                       stride, format);
 561
 562         return surface;
 563 }
 564
 565 static cairo_surface_t *
 566 display_create_shm_surface(struct display *display,
 567                            struct rectangle *rectangle, uint32_t flags,
 568                            struct window *window)
 569 {
 570         struct shm_surface_data *data;
 571         struct shm_pool *pool;
 572         cairo_surface_t *surface;
 573
 574         if (window && window->pool) {
 575                 shm_pool_reset(window->pool);
 576                 surface = display_create_shm_surface_from_pool(display,
 577                                                                rectangle,
 578                                                                flags,
 579                                                                window->pool);
 580                 if (surface)
 581                         return surface;
 582         }
 583
 584         pool = shm_pool_create(display,
 585                                data_length_for_shm_surface(rectangle));
 586         if (!pool)
 587                 return NULL;
 588
 589         surface =
 590                 display_create_shm_surface_from_pool(display, rectangle,
 591                                                      flags, pool);
 592
 593         if (!surface) {
 594                 shm_pool_destroy(pool);
 595                 return NULL;
 596         }
 597
 598         /* make sure we destroy the pool when the surface is destroyed */
 599         data = cairo_surface_get_user_data(surface, &surface_data_key);
 600         data->pool = pool;
 601
 602         return surface;
 603 }
 604
 605 static int
 606 check_size(struct rectangle *rect)
 607 {
 608         if (rect->width && rect->height)
 609                 return 0;
 610
 611         fprintf(stderr, "tried to create surface of "
 612                 "width: %d, height: %d\n", rect->width, rect->height);
 613         return -1;
 614 }
 615
 616 cairo_surface_t *
 617 display_create_surface(struct display *display,
 618                        struct wl_surface *surface,
 619                        struct rectangle *rectangle,
 620                        uint32_t flags)
 621 {
 622         if (check_size(rectangle) < 0)
 623                 return NULL;
 624 #ifdef HAVE_CAIRO_EGL
 625         if (display->dpy && !(flags & SURFACE_SHM))
 626                 return display_create_egl_window_surface(display,
 627                                                          surface,
 628                                                          flags,
 629                                                          rectangle);
 630 #endif
 631         return display_create_shm_surface(display, rectangle, flags, NULL);
 632 }
 633
 634 static const char *cursors[] = {
 635         "bottom_left_corner",
 636         "bottom_right_corner",
 637         "bottom_side",
 638         "grabbing",
 639         "left_ptr",
 640         "left_side",
 641         "right_side",
 642         "top_left_corner",
 643         "top_right_corner",
 644         "top_side",
 645         "xterm",
 646         "hand1",
 647 };
 648
 649 static void
 650 create_cursors(struct display *display)
 651 {
 652         unsigned int i;
 653
 654         display->cursor_theme = wl_cursor_theme_load(NULL, 32, display->shm);
 655         display->cursors =
 656                 malloc(ARRAY_LENGTH(cursors) * sizeof display->cursors[0]);
 657
 658         for (i = 0; i < ARRAY_LENGTH(cursors); i++)
 659                 display->cursors[i] =
 660                         wl_cursor_theme_get_cursor(display->cursor_theme,
 661                                                    cursors[i]);
 662 }
 663
 664 static void
 665 destroy_cursors(struct display *display)
 666 {
 667         wl_cursor_theme_destroy(display->cursor_theme);
 668         free(display->cursors);
 669 }
 670
 671 struct wl_cursor_image *
 672 display_get_pointer_image(struct display *display, int pointer)
 673 {
 674         struct wl_cursor *cursor =
 675                 wl_cursor_theme_get_cursor(display->cursor_theme,
 676                                            cursors[pointer]);
 677
 678         return cursor ? cursor->images[0] : NULL;
 679 }
 680
 681 static void
 682 window_get_resize_dx_dy(struct window *window, int *x, int *y)
 683 {
 684         if (window->resize_edges & WINDOW_RESIZING_LEFT)
 685                 *x = window->server_allocation.width - window->allocation.width;
 686         else
 687                 *x = 0;
 688
 689         if (window->resize_edges & WINDOW_RESIZING_TOP)
 690                 *y = window->server_allocation.height -
 691                         window->allocation.height;
 692         else
 693                 *y = 0;
 694
 695         window->resize_edges = 0;
 696 }
 697
 698 static void
 699 window_attach_surface(struct window *window)
 700 {
 701         struct display *display = window->display;
 702         struct wl_buffer *buffer;
 703 #ifdef HAVE_CAIRO_EGL
 704         struct egl_window_surface_data *data;
 705 #endif
 706         int32_t x, y;
 707
 708         if (window->type == TYPE_NONE) {
 709                 window->type = TYPE_TOPLEVEL;
 710                 if (display->shell)
 711                         wl_shell_surface_set_toplevel(window->shell_surface);
 712         }
 713
 714         switch (window->buffer_type) {
 715 #ifdef HAVE_CAIRO_EGL
 716         case WINDOW_BUFFER_TYPE_EGL_WINDOW:
 717                 data = cairo_surface_get_user_data(window->cairo_surface,
 718                                                    &surface_data_key);
 719
 720                 cairo_gl_surface_swapbuffers(window->cairo_surface);
 721                 wl_egl_window_get_attached_size(data->window,
 722                                 &window->server_allocation.width,
 723                                 &window->server_allocation.height);
 724                 break;
 725 #endif
 726         case WINDOW_BUFFER_TYPE_SHM:
 727                 buffer =
 728                         display_get_buffer_for_surface(display,
 729                                                        window->cairo_surface);
 730
 731                 window_get_resize_dx_dy(window, &x, &y);
 732                 wl_surface_attach(window->surface, buffer, x, y);
 733                 wl_surface_damage(window->surface, 0, 0,
 734                                   window->allocation.width,
 735                                   window->allocation.height);
 736                 window->server_allocation = window->allocation;
 737                 cairo_surface_destroy(window->cairo_surface);
 738                 window->cairo_surface = NULL;
 739                 break;
 740         default:
 741                 return;
 742         }
 743
 744         if (window->input_region) {
 745                 wl_surface_set_input_region(window->surface,
 746                                             window->input_region);
 747                 wl_region_destroy(window->input_region);
 748                 window->input_region = NULL;
 749         }
 750
 751         if (window->opaque_region) {
 752                 wl_surface_set_opaque_region(window->surface,
 753                                              window->opaque_region);
 754                 wl_region_destroy(window->opaque_region);
 755                 window->opaque_region = NULL;
 756         }
 757 }
 758
 759 void
 760 window_flush(struct window *window)
 761 {
 762         if (window->cairo_surface)
 763                 window_attach_surface(window);
 764 }
 765
 766 void
 767 window_set_surface(struct window *window, cairo_surface_t *surface)
 768 {
 769         cairo_surface_reference(surface);
 770
 771         if (window->cairo_surface != NULL)
 772                 cairo_surface_destroy(window->cairo_surface);
 773
 774         window->cairo_surface = surface;
 775 }
 776
 777 #ifdef HAVE_CAIRO_EGL
 778 static void
 779 window_resize_cairo_window_surface(struct window *window)
 780 {
 781         struct egl_window_surface_data *data;
 782         int x, y;
 783
 784         data = cairo_surface_get_user_data(window->cairo_surface,
 785                                            &surface_data_key);
 786
 787         window_get_resize_dx_dy(window, &x, &y),
 788         wl_egl_window_resize(data->window,
 789                              window->allocation.width,
 790                              window->allocation.height,
 791                              x,y);
 792
 793         cairo_gl_surface_set_size(window->cairo_surface,
 794                                   window->allocation.width,
 795                                   window->allocation.height);
 796 }
 797 #endif
 798
 799 struct display *
 800 window_get_display(struct window *window)
 801 {
 802         return window->display;
 803 }
 804
 805 void
 806 window_create_surface(struct window *window)
 807 {
 808         cairo_surface_t *surface;
 809         uint32_t flags = 0;
 810
 811         if (!window->transparent)
 812                 flags = SURFACE_OPAQUE;
 813
 814         switch (window->buffer_type) {
 815 #ifdef HAVE_CAIRO_EGL
 816         case WINDOW_BUFFER_TYPE_EGL_WINDOW:
 817                 if (window->cairo_surface) {
 818                         window_resize_cairo_window_surface(window);
 819                         return;
 820                 }
 821                 surface = display_create_surface(window->display,
 822                                                  window->surface,
 823                                                  &window->allocation, flags);
 824                 break;
 825 #endif
 826         case WINDOW_BUFFER_TYPE_SHM:
 827                 surface = display_create_shm_surface(window->display,
 828                                                      &window->allocation,
 829                                                      flags, window);
 830                 break;
 831         default:
 832                 surface = NULL;
 833                 break;
 834         }
 835
 836         window_set_surface(window, surface);
 837         cairo_surface_destroy(surface);
 838 }
 839
 840 static void frame_destroy(struct frame *frame);
 841
 842 void
 843 window_destroy(struct window *window)
 844 {
 845         struct display *display = window->display;
 846         struct input *input;
 847         struct window_output *window_output;
 848         struct window_output *window_output_tmp;
 849
 850         if (window->redraw_scheduled)
 851                 wl_list_remove(&window->redraw_task.link);
 852
 853         wl_list_for_each(input, &display->input_list, link) {
 854                 if (input->pointer_focus == window)
 855                         input->pointer_focus = NULL;
 856                 if (input->keyboard_focus == window)
 857                         input->keyboard_focus = NULL;
 858                 if (input->focus_widget &&
 859                     input->focus_widget->window == window)
 860                         input->focus_widget = NULL;
 861         }
 862
 863         wl_list_for_each_safe(window_output, window_output_tmp,
 864                               &window->window_output_list, link) {
 865                 free (window_output);
 866         }
 867
 868         if (window->input_region)
 869                 wl_region_destroy(window->input_region);
 870         if (window->opaque_region)
 871                 wl_region_destroy(window->opaque_region);
 872
 873         if (window->frame)
 874                 frame_destroy(window->frame);
 875
 876         if (window->shell_surface)
 877                 wl_shell_surface_destroy(window->shell_surface);
 878         wl_surface_destroy(window->surface);
 879         wl_list_remove(&window->link);
 880
 881         if (window->cairo_surface != NULL)
 882                 cairo_surface_destroy(window->cairo_surface);
 883
 884         free(window->title);
 885         free(window);
 886 }
 887
 888 static struct widget *
 889 widget_find_widget(struct widget *widget, int32_t x, int32_t y)
 890 {
 891         struct widget *child, *target;
 892
 893         wl_list_for_each(child, &widget->child_list, link) {
 894                 target = widget_find_widget(child, x, y);
 895                 if (target)
 896                         return target;
 897         }
 898
 899         if (widget->allocation.x <= x &&
 900             x < widget->allocation.x + widget->allocation.width &&
 901             widget->allocation.y <= y &&
 902             y < widget->allocation.y + widget->allocation.height) {
 903                 return widget;
 904         }
 905
 906         return NULL;
 907 }
 908
 909 static struct widget *
 910 widget_create(struct window *window, void *data)
 911 {
 912         struct widget *widget;
 913
 914         widget = malloc(sizeof *widget);
 915         memset(widget, 0, sizeof *widget);
 916         widget->window = window;
 917         widget->user_data = data;
 918         widget->allocation = window->allocation;
 919         wl_list_init(&widget->child_list);
 920         widget->opaque = 0;
 921         widget->tooltip = NULL;
 922         widget->tooltip_count = 0;
 923
 924         return widget;
 925 }
 926
 927 struct widget *
 928 window_add_widget(struct window *window, void *data)
 929 {
 930         window->widget = widget_create(window, data);
 931         wl_list_init(&window->widget->link);
 932
 933         return window->widget;
 934 }
 935
 936 struct widget *
 937 widget_add_widget(struct widget *parent, void *data)
 938 {
 939         struct widget *widget;
 940
 941         widget = widget_create(parent->window, data);
 942         wl_list_insert(parent->child_list.prev, &widget->link);
 943
 944         return widget;
 945 }
 946
 947 void
 948 widget_destroy(struct widget *widget)
 949 {
 950         struct display *display = widget->window->display;
 951         struct input *input;
 952
 953         if (widget->tooltip) {
 954                 free(widget->tooltip);
 955                 widget->tooltip = NULL;
 956         }
 957
 958         wl_list_for_each(input, &display->input_list, link) {
 959                 if (input->focus_widget == widget)
 960                         input->focus_widget = NULL;
 961         }
 962
 963         wl_list_remove(&widget->link);
 964         free(widget);
 965 }
 966
 967 void
 968 widget_get_allocation(struct widget *widget, struct rectangle *allocation)
 969 {
 970         *allocation = widget->allocation;
 971 }
 972
 973 void
 974 widget_set_size(struct widget *widget, int32_t width, int32_t height)
 975 {
 976         widget->allocation.width = width;
 977         widget->allocation.height = height;
 978 }
 979
 980 void
 981 widget_set_allocation(struct widget *widget,
 982                       int32_t x, int32_t y, int32_t width, int32_t height)
 983 {
 984         widget->allocation.x = x;
 985         widget->allocation.y = y;
 986         widget_set_size(widget, width, height);
 987 }
 988
 989 void
 990 widget_set_transparent(struct widget *widget, int transparent)
 991 {
 992         widget->opaque = !transparent;
 993 }
 994
 995 void *
 996 widget_get_user_data(struct widget *widget)
 997 {
 998         return widget->user_data;
 999 }
1000
1001 void
1002 widget_set_resize_handler(struct widget *widget,
1003                           widget_resize_handler_t handler)
1004 {
1005         widget->resize_handler = handler;
1006 }
1007
1008 void
1009 widget_set_redraw_handler(struct widget *widget,
1010                           widget_redraw_handler_t handler)
1011 {
1012         widget->redraw_handler = handler;
1013 }
1014
1015 void
1016 widget_set_enter_handler(struct widget *widget, widget_enter_handler_t handler)
1017 {
1018         widget->enter_handler = handler;
1019 }
1020
1021 void
1022 widget_set_leave_handler(struct widget *widget, widget_leave_handler_t handler)
1023 {
1024         widget->leave_handler = handler;
1025 }
1026
1027 void
1028 widget_set_motion_handler(struct widget *widget,
1029                           widget_motion_handler_t handler)
1030 {
1031         widget->motion_handler = handler;
1032 }
1033
1034 void
1035 widget_set_button_handler(struct widget *widget,
1036                           widget_button_handler_t handler)
1037 {
1038         widget->button_handler = handler;
1039 }
1040
1041 void
1042 widget_schedule_redraw(struct widget *widget)
1043 {
1044         window_schedule_redraw(widget->window);
1045 }
1046
1047 cairo_surface_t *
1048 window_get_surface(struct window *window)
1049 {
1050         return cairo_surface_reference(window->cairo_surface);
1051 }
1052
1053 struct wl_surface *
1054 window_get_wl_surface(struct window *window)
1055 {
1056         return window->surface;
1057 }
1058
1059 struct wl_shell_surface *
1060 window_get_wl_shell_surface(struct window *window)
1061 {
1062         return window->shell_surface;
1063 }
1064
1065 static void
1066 tooltip_redraw_handler(struct widget *widget, void *data)
1067 {
1068         cairo_t *cr;
1069         const int32_t r = 3;
1070         struct tooltip *tooltip = data;
1071         int32_t width, height;
1072         struct window *window = widget->window;
1073
1074         cr = cairo_create(window->cairo_surface);
1075         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
1076         cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0);
1077         cairo_paint(cr);
1078
1079         width = window->allocation.width;
1080         height = window->allocation.height;
1081         rounded_rect(cr, 0, 0, width, height, r);
1082
1083         cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
1084         cairo_set_source_rgba(cr, 0.0, 0.0, 0.4, 0.8);
1085         cairo_fill(cr);
1086
1087         cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
1088         cairo_move_to(cr, 10, 16);
1089         cairo_show_text(cr, tooltip->entry);
1090         cairo_destroy(cr);
1091 }
1092
1093 static cairo_text_extents_t
1094 get_text_extents(struct tooltip *tooltip)
1095 {
1096         struct window *window;
1097         cairo_t *cr;
1098         cairo_text_extents_t extents;
1099
1100         /* we borrow cairo_surface from the parent cause tooltip's wasn't
1101          * created yet */
1102         window = tooltip->widget->window->parent;
1103         cr = cairo_create(window->cairo_surface);
1104         cairo_text_extents(cr, tooltip->entry, &extents);
1105         cairo_destroy(cr);
1106
1107         return extents;
1108 }
1109
1110 static int
1111 window_create_tooltip(struct tooltip *tooltip)
1112 {
1113         struct widget *parent = tooltip->parent;
1114         struct display *display = parent->window->display;
1115         struct window *window;
1116         const int offset_y = 27;
1117         const int margin = 3;
1118         cairo_text_extents_t extents;
1119
1120         if (tooltip->widget)
1121                 return 0;
1122
1123         window = window_create_transient(display, parent->window, tooltip->x,
1124                                          tooltip->y + offset_y,
1125                                          WL_SHELL_SURFACE_TRANSIENT_INACTIVE);
1126         if (!window)
1127                 return -1;
1128
1129         tooltip->window = window;
1130         tooltip->widget = window_add_widget(tooltip->window, tooltip);
1131
1132         extents = get_text_extents(tooltip);
1133         widget_set_redraw_handler(tooltip->widget, tooltip_redraw_handler);
1134         window_schedule_resize(window, extents.width + 20, 20 + margin * 2);
1135
1136         return 0;
1137 }
1138
1139 void
1140 widget_destroy_tooltip(struct widget *parent)
1141 {
1142         struct tooltip *tooltip = parent->tooltip;
1143
1144         parent->tooltip_count = 0;
1145         if (!tooltip)
1146                 return;
1147
1148         if (tooltip->widget) {
1149                 widget_destroy(tooltip->widget);
1150                 window_destroy(tooltip->window);
1151                 tooltip->widget = NULL;
1152                 tooltip->window = NULL;
1153         }
1154
1155         close(tooltip->tooltip_fd);
1156         free(tooltip->entry);
1157         free(tooltip);
1158         parent->tooltip = NULL;
1159 }
1160
1161 static void
1162 tooltip_func(struct task *task, uint32_t events)
1163 {
1164         struct tooltip *tooltip =
1165                 container_of(task, struct tooltip, tooltip_task);
1166         uint64_t exp;
1167
1168         read(tooltip->tooltip_fd, &exp, sizeof (uint64_t));
1169         window_create_tooltip(tooltip);
1170 }
1171
1172 #define TOOLTIP_TIMEOUT 500
1173 static int
1174 tooltip_timer_reset(struct tooltip *tooltip)
1175 {
1176         struct itimerspec its;
1177
1178         its.it_interval.tv_sec = 0;
1179         its.it_interval.tv_nsec = 0;
1180         its.it_value.tv_sec = TOOLTIP_TIMEOUT / 1000;
1181         its.it_value.tv_nsec = (TOOLTIP_TIMEOUT % 1000) * 1000 * 1000;
1182         if (timerfd_settime(tooltip->tooltip_fd, 0, &its, NULL) < 0) {
1183                 fprintf(stderr, "could not set timerfd\n: %m");
1184                 return -1;
1185         }
1186
1187         return 0;
1188 }
1189
1190 int
1191 widget_set_tooltip(struct widget *parent, char *entry, float x, float y)
1192 {
1193         struct tooltip *tooltip = parent->tooltip;
1194
1195         parent->tooltip_count++;
1196         if (tooltip) {
1197                 tooltip->x = x;
1198                 tooltip->y = y;
1199                 tooltip_timer_reset(tooltip);
1200                 return 0;
1201         }
1202
1203         /* the handler might be triggered too fast via input device motion, so
1204          * we need this check here to make sure tooltip is fully initialized */
1205         if (parent->tooltip_count > 1)
1206                 return 0;
1207
1208         tooltip = malloc(sizeof *tooltip);
1209         if (!tooltip)
1210                 return -1;
1211
1212         parent->tooltip = tooltip;
1213         tooltip->parent = parent;
1214         tooltip->widget = NULL;
1215         tooltip->window = NULL;
1216         tooltip->x = x;
1217         tooltip->y = y;
1218         tooltip->entry = strdup(entry);
1219         tooltip->tooltip_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
1220         if (tooltip->tooltip_fd < 0) {
1221                 fprintf(stderr, "could not create timerfd\n: %m");
1222                 return -1;
1223         }
1224
1225         tooltip->tooltip_task.run = tooltip_func;
1226         display_watch_fd(parent->window->display, tooltip->tooltip_fd,
1227                          EPOLLIN, &tooltip->tooltip_task);
1228         tooltip_timer_reset(tooltip);
1229
1230         return 0;
1231 }
1232
1233 static void
1234 frame_resize_handler(struct widget *widget,
1235                      int32_t width, int32_t height, void *data)
1236 {
1237         struct frame *frame = data;
1238         struct widget *child = frame->child;
1239         struct rectangle allocation;
1240         struct display *display = widget->window->display;
1241         struct frame_button * button;
1242         struct theme *t = display->theme;
1243         int x_l, x_r, y, w, h;
1244         int decoration_width, decoration_height;
1245         int opaque_margin;
1246
1247         if (widget->window->type != TYPE_FULLSCREEN) {
1248                 decoration_width = (t->width + t->margin) * 2;
1249                 decoration_height = t->width +
1250                         t->titlebar_height + t->margin * 2;
1251
1252                 allocation.x = t->width + t->margin;
1253                 allocation.y = t->titlebar_height + t->margin;
1254                 allocation.width = width - decoration_width;
1255                 allocation.height = height - decoration_height;
1256
1257                 opaque_margin = t->margin + t->frame_radius;
1258
1259                 wl_list_for_each(button, &frame->buttons_list, link)
1260                         button->widget->opaque = 0;
1261         } else {
1262                 decoration_width = 0;
1263                 decoration_height = 0;
1264
1265                 allocation.x = 0;
1266                 allocation.y = 0;
1267                 allocation.width = width;
1268                 allocation.height = height;
1269                 opaque_margin = 0;
1270
1271                 wl_list_for_each(button, &frame->buttons_list, link)
1272                         button->widget->opaque = 1;
1273         }
1274
1275         widget_set_allocation(child, allocation.x, allocation.y,
1276                               allocation.width, allocation.height);
1277
1278         if (child->resize_handler)
1279                 child->resize_handler(child,
1280                                       allocation.width,
1281                                       allocation.height,
1282                                       child->user_data);
1283
1284         width = child->allocation.width + decoration_width;
1285         height = child->allocation.height + decoration_height;
1286
1287         widget->window->input_region =
1288                       wl_compositor_create_region(display->compositor);
1289         wl_region_add(widget->window->input_region,
1290                       t->margin, t->margin,
1291                       width - 2 * t->margin,
1292                       height - 2 * t->margin);
1293
1294         widget_set_allocation(widget, 0, 0, width, height);
1295
1296         if (child->opaque) {
1297                 widget->window->opaque_region =
1298                         wl_compositor_create_region(display->compositor);
1299                 wl_region_add(widget->window->opaque_region,
1300                               opaque_margin, opaque_margin,
1301                               widget->allocation.width - 2 * opaque_margin,
1302                               widget->allocation.height - 2 * opaque_margin);
1303         }
1304
1305         /* frame internal buttons */
1306         x_r = frame->widget->allocation.width - t->width - t->margin;
1307         x_l = t->width + t->margin;
1308         y = t->width + t->margin;
1309         wl_list_for_each(button, &frame->buttons_list, link) {
1310                 const int button_padding = 4;
1311                 w = cairo_image_surface_get_width(button->icon);
1312                 h = cairo_image_surface_get_height(button->icon);
1313
1314                 if (button->decoration == FRAME_BUTTON_FANCY)
1315                         w += 10;
1316
1317                 if (button->align == FRAME_BUTTON_LEFT) {
1318                         widget_set_allocation(button->widget,
1319                                               x_l, y , w + 1, h + 1);
1320                         x_l += w;
1321                         x_l += button_padding;
1322                 } else {
1323                         x_r -= w;
1324                         widget_set_allocation(button->widget,
1325                                               x_r, y , w + 1, h + 1);
1326                         x_r -= button_padding;
1327                 }
1328         }
1329 }
1330
1331 static int
1332 frame_button_enter_handler(struct widget *widget,
1333                            struct input *input, float x, float y, void *data)
1334 {
1335         struct frame_button *frame_button = data;
1336
1337         widget_schedule_redraw(frame_button->widget);
1338         frame_button->state = FRAME_BUTTON_OVER;
1339
1340         return CURSOR_LEFT_PTR;
1341 }
1342
1343 static void
1344 frame_button_leave_handler(struct widget *widget, struct input *input, void *data)
1345 {
1346         struct frame_button *frame_button = data;
1347
1348         widget_schedule_redraw(frame_button->widget);
1349         frame_button->state = FRAME_BUTTON_DEFAULT;
1350 }
1351
1352 static void
1353 frame_button_button_handler(struct widget *widget,
1354                             struct input *input, uint32_t time,
1355                             uint32_t button, uint32_t state, void *data)
1356 {
1357         struct frame_button *frame_button = data;
1358         struct window *window = widget->window;
1359
1360         if (button != BTN_LEFT)
1361                 return;
1362
1363         switch (state) {
1364         case 1:
1365                 frame_button->state = FRAME_BUTTON_ACTIVE;
1366                 widget_schedule_redraw(frame_button->widget);
1367
1368                 if (frame_button->type == FRAME_BUTTON_ICON)
1369                         window_show_frame_menu(window, input, time);
1370                 return;
1371         case 0:
1372                 frame_button->state = FRAME_BUTTON_DEFAULT;
1373                 widget_schedule_redraw(frame_button->widget);
1374                 break;
1375         }
1376
1377         switch (frame_button->type) {
1378         case FRAME_BUTTON_CLOSE:
1379                 if (window->close_handler)
1380                         window->close_handler(window->parent,
1381                                               window->user_data);
1382                 else
1383                         display_exit(window->display);
1384                 break;
1385         case FRAME_BUTTON_MINIMIZE:
1386                 fprintf(stderr,"Minimize stub\n");
1387                 break;
1388         case FRAME_BUTTON_MAXIMIZE:
1389                 window_set_maximized(window, window->type != TYPE_MAXIMIZED);
1390                 break;
1391         default:
1392                 /* Unknown operation */
1393                 break;
1394         }
1395 }
1396
1397 static void
1398 frame_button_redraw_handler(struct widget *widget, void *data)
1399 {
1400         struct frame_button *frame_button = data;
1401         cairo_t *cr;
1402         int width, height, x, y;
1403         struct window *window = widget->window;
1404
1405         x = widget->allocation.x;
1406         y = widget->allocation.y;
1407         width = widget->allocation.width;
1408         height = widget->allocation.height;
1409
1410         if (!width)
1411                 return;
1412         if (!height)
1413                 return;
1414         if (widget->opaque)
1415                 return;
1416
1417         cr = cairo_create(window->cairo_surface);
1418
1419         if (frame_button->decoration == FRAME_BUTTON_FANCY) {
1420                 cairo_set_line_width(cr, 1);
1421
1422                 cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
1423                 cairo_rectangle (cr, x, y, 25, 16);
1424
1425                 cairo_stroke_preserve(cr);
1426
1427                 switch (frame_button->state) {
1428                 case FRAME_BUTTON_DEFAULT:
1429                         cairo_set_source_rgb(cr, 0.88, 0.88, 0.88);
1430                         break;
1431                 case FRAME_BUTTON_OVER:
1432                         cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
1433                         break;
1434                 case FRAME_BUTTON_ACTIVE:
1435                         cairo_set_source_rgb(cr, 0.7, 0.7, 0.7);
1436                         break;
1437                 }
1438
1439                 cairo_fill (cr);
1440
1441                 x += 4;
1442         }
1443
1444         cairo_set_source_surface(cr, frame_button->icon, x, y);
1445         cairo_paint(cr);
1446
1447         cairo_destroy(cr);
1448 }
1449
1450 static struct widget *
1451 frame_button_create(struct frame *frame, void *data, enum frame_button_action type,
1452         enum frame_button_align align, enum frame_button_decoration style)
1453 {
1454         struct frame_button *frame_button;
1455         const char *icon = data;
1456
1457         frame_button = malloc (sizeof *frame_button);
1458         memset(frame_button, 0, sizeof *frame_button);
1459
1460         frame_button->icon = cairo_image_surface_create_from_png(icon);
1461         frame_button->widget = widget_add_widget(frame->widget, frame_button);
1462         frame_button->frame = frame;
1463         frame_button->type = type;
1464         frame_button->align = align;
1465         frame_button->decoration = style;
1466
1467         wl_list_insert(frame->buttons_list.prev, &frame_button->link);
1468
1469         widget_set_redraw_handler(frame_button->widget, frame_button_redraw_handler);
1470         widget_set_enter_handler(frame_button->widget, frame_button_enter_handler);
1471         widget_set_leave_handler(frame_button->widget, frame_button_leave_handler);
1472         widget_set_button_handler(frame_button->widget, frame_button_button_handler);
1473         return frame_button->widget;
1474 }
1475
1476 static void
1477 frame_button_destroy(struct frame_button *frame_button)
1478 {
1479         widget_destroy(frame_button->widget);
1480         wl_list_remove(&frame_button->link);
1481         cairo_surface_destroy(frame_button->icon);
1482         free(frame_button);
1483
1484         return;
1485 }
1486
1487 static void
1488 frame_redraw_handler(struct widget *widget, void *data)
1489 {
1490         cairo_t *cr;
1491         struct window *window = widget->window;
1492         struct theme *t = window->display->theme;
1493         uint32_t flags = 0;
1494
1495         if (window->type == TYPE_FULLSCREEN)
1496                 return;
1497
1498         cr = cairo_create(window->cairo_surface);
1499
1500         if (window->keyboard_device)
1501                 flags |= THEME_FRAME_ACTIVE;
1502         theme_render_frame(t, cr, widget->allocation.width,
1503                            widget->allocation.height, window->title, flags);
1504
1505         cairo_destroy(cr);
1506 }
1507
1508 static int
1509 frame_get_pointer_image_for_location(struct frame *frame, struct input *input)
1510 {
1511         struct theme *t = frame->widget->window->display->theme;
1512         int location;
1513
1514         location = theme_get_location(t, input->sx, input->sy,
1515                                       frame->widget->allocation.width,
1516                                       frame->widget->allocation.height);
1517
1518         switch (location) {
1519         case THEME_LOCATION_RESIZING_TOP:
1520                 return CURSOR_TOP;
1521         case THEME_LOCATION_RESIZING_BOTTOM:
1522                 return CURSOR_BOTTOM;
1523         case THEME_LOCATION_RESIZING_LEFT:
1524                 return CURSOR_LEFT;
1525         case THEME_LOCATION_RESIZING_RIGHT:
1526                 return CURSOR_RIGHT;
1527         case THEME_LOCATION_RESIZING_TOP_LEFT:
1528                 return CURSOR_TOP_LEFT;
1529         case THEME_LOCATION_RESIZING_TOP_RIGHT:
1530                 return CURSOR_TOP_RIGHT;
1531         case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
1532                 return CURSOR_BOTTOM_LEFT;
1533         case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
1534                 return CURSOR_BOTTOM_RIGHT;
1535         case THEME_LOCATION_EXTERIOR:
1536         case THEME_LOCATION_TITLEBAR:
1537         default:
1538                 return CURSOR_LEFT_PTR;
1539         }
1540 }
1541
1542 static void
1543 frame_menu_func(struct window *window, int index, void *data)
1544 {
1545         switch (index) {
1546         case 0: /* close */
1547                 if (window->close_handler)
1548                         window->close_handler(window->parent,
1549                                               window->user_data);
1550                 else
1551                         display_exit(window->display);
1552                 break;
1553         case 1: /* fullscreen */
1554                 /* we don't have a way to get out of fullscreen for now */
1555                 window_set_fullscreen(window, 1);
1556                 break;
1557         case 2: /* rotate */
1558         case 3: /* scale */
1559                 break;
1560         }
1561 }
1562
1563 void
1564 window_show_frame_menu(struct window *window,
1565                        struct input *input, uint32_t time)
1566 {
1567         int32_t x, y;
1568
1569         static const char *entries[] = {
1570                 "Close", "Fullscreen", "Rotate", "Scale"
1571         };
1572
1573         input_get_position(input, &x, &y);
1574         window_show_menu(window->display, input, time, window,
1575                          x - 10, y - 10, frame_menu_func, entries, 4);
1576 }
1577
1578 static int
1579 frame_enter_handler(struct widget *widget,
1580                     struct input *input, float x, float y, void *data)
1581 {
1582         return frame_get_pointer_image_for_location(data, input);
1583 }
1584
1585 static int
1586 frame_motion_handler(struct widget *widget,
1587                      struct input *input, uint32_t time,
1588                      float x, float y, void *data)
1589 {
1590         return frame_get_pointer_image_for_location(data, input);
1591 }
1592
1593 static void
1594 frame_button_handler(struct widget *widget,
1595                      struct input *input, uint32_t time,
1596                      uint32_t button, uint32_t state, void *data)
1597
1598 {
1599         struct frame *frame = data;
1600         struct window *window = widget->window;
1601         struct display *display = window->display;
1602         int location;
1603
1604         location = theme_get_location(display->theme, input->sx, input->sy,
1605                                       frame->widget->allocation.width,
1606                                       frame->widget->allocation.height);
1607
1608         if (window->display->shell && button == BTN_LEFT && state == 1) {
1609                 switch (location) {
1610                 case THEME_LOCATION_TITLEBAR:
1611                         if (!window->shell_surface)
1612                                 break;
1613                         input_set_pointer_image(input, time, CURSOR_DRAGGING);
1614                         input_ungrab(input);
1615                         wl_shell_surface_move(window->shell_surface,
1616                                               input_get_seat(input),
1617                                               display->serial);
1618                         break;
1619                 case THEME_LOCATION_RESIZING_TOP:
1620                 case THEME_LOCATION_RESIZING_BOTTOM:
1621                 case THEME_LOCATION_RESIZING_LEFT:
1622                 case THEME_LOCATION_RESIZING_RIGHT:
1623                 case THEME_LOCATION_RESIZING_TOP_LEFT:
1624                 case THEME_LOCATION_RESIZING_TOP_RIGHT:
1625                 case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
1626                 case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
1627                         if (!window->shell_surface)
1628                                 break;
1629                         input_ungrab(input);
1630
1631                         if (!display->dpy) {
1632                                 /* If we're using shm, allocate a big
1633                                    pool to create buffers out of while
1634                                    we resize.  We should probably base
1635                                    this number on the size of the output. */
1636                                 window->pool =
1637                                         shm_pool_create(display, 6 * 1024 * 1024);
1638                         }
1639
1640                         wl_shell_surface_resize(window->shell_surface,
1641                                                 input_get_seat(input),
1642                                                 display->serial, location);
1643                         break;
1644                 }
1645         } else if (button == BTN_RIGHT && state == 1) {
1646                 window_show_frame_menu(window, input, time);
1647         }
1648 }
1649
1650 struct widget *
1651 frame_create(struct window *window, void *data)
1652 {
1653         struct frame *frame;
1654
1655         frame = malloc(sizeof *frame);
1656         memset(frame, 0, sizeof *frame);
1657
1658         frame->widget = window_add_widget(window, frame);
1659         frame->child = widget_add_widget(frame->widget, data);
1660
1661         widget_set_redraw_handler(frame->widget, frame_redraw_handler);
1662         widget_set_resize_handler(frame->widget, frame_resize_handler);
1663         widget_set_enter_handler(frame->widget, frame_enter_handler);
1664         widget_set_motion_handler(frame->widget, frame_motion_handler);
1665         widget_set_button_handler(frame->widget, frame_button_handler);
1666
1667         /* Create empty list for frame buttons */
1668         wl_list_init(&frame->buttons_list);
1669
1670         frame_button_create(frame, DATADIR "/weston/icon_window.png",
1671                 FRAME_BUTTON_ICON, FRAME_BUTTON_LEFT, FRAME_BUTTON_NONE);
1672
1673         frame_button_create(frame, DATADIR "/weston/sign_close.png",
1674                 FRAME_BUTTON_CLOSE, FRAME_BUTTON_RIGHT, FRAME_BUTTON_FANCY);
1675
1676         frame_button_create(frame, DATADIR "/weston/sign_maximize.png",
1677                 FRAME_BUTTON_MAXIMIZE, FRAME_BUTTON_RIGHT, FRAME_BUTTON_FANCY);
1678
1679         frame_button_create(frame, DATADIR "/weston/sign_minimize.png",
1680                 FRAME_BUTTON_MINIMIZE, FRAME_BUTTON_RIGHT, FRAME_BUTTON_FANCY);
1681
1682         window->frame = frame;
1683
1684         return frame->child;
1685 }
1686
1687 static void
1688 frame_destroy(struct frame *frame)
1689 {
1690         struct frame_button *button, *tmp;
1691
1692         wl_list_for_each_safe(button, tmp, &frame->buttons_list, link)
1693                 frame_button_destroy(button);
1694
1695         /* frame->child must be destroyed by the application */
1696         widget_destroy(frame->widget);
1697         free(frame);
1698 }
1699
1700 static void
1701 input_set_focus_widget(struct input *input, struct widget *focus,
1702                        float x, float y)
1703 {
1704         struct widget *old, *widget;
1705         int pointer = CURSOR_LEFT_PTR;
1706
1707         if (focus == input->focus_widget)
1708                 return;
1709
1710         old = input->focus_widget;
1711         if (old) {
1712                 widget = old;
1713                 if (input->grab)
1714                         widget = input->grab;
1715                 if (widget->leave_handler)
1716                         widget->leave_handler(old, input, widget->user_data);
1717                 input->focus_widget = NULL;
1718         }
1719
1720         if (focus) {
1721                 widget = focus;
1722                 if (input->grab)
1723                         widget = input->grab;
1724                 if (widget->enter_handler)
1725                         pointer = widget->enter_handler(focus, input, x, y,
1726                                                         widget->user_data);
1727                 input->focus_widget = focus;
1728
1729                 input_set_pointer_image(input, input->pointer_enter_serial,
1730                                         pointer);
1731         }
1732 }
1733
1734 static void
1735 pointer_handle_motion(void *data, struct wl_pointer *pointer,
1736                       uint32_t time, wl_fixed_t sx_w, wl_fixed_t sy_w)
1737 {
1738         struct input *input = data;
1739         struct window *window = input->pointer_focus;
1740         struct widget *widget;
1741         int cursor = CURSOR_LEFT_PTR;
1742         float sx = wl_fixed_to_double(sx_w);
1743         float sy = wl_fixed_to_double(sy_w);
1744
1745         input->sx = sx;
1746         input->sy = sy;
1747
1748         if (!(input->grab && input->grab_button)) {
1749                 widget = widget_find_widget(window->widget, sx, sy);
1750                 input_set_focus_widget(input, widget, sx, sy);
1751         }
1752
1753         if (input->grab)
1754                 widget = input->grab;
1755         else
1756                 widget = input->focus_widget;
1757         if (widget && widget->motion_handler)
1758                 cursor = widget->motion_handler(input->focus_widget,
1759                                                 input, time, sx, sy,
1760                                                 widget->user_data);
1761
1762         input_set_pointer_image(input, time, cursor);
1763 }
1764
1765 void
1766 input_grab(struct input *input, struct widget *widget, uint32_t button)
1767 {
1768         input->grab = widget;
1769         input->grab_button = button;
1770 }
1771
1772 void
1773 input_ungrab(struct input *input)
1774 {
1775         struct widget *widget;
1776
1777         input->grab = NULL;
1778         if (input->pointer_focus) {
1779                 widget = widget_find_widget(input->pointer_focus->widget,
1780                                             input->sx, input->sy);
1781                 input_set_focus_widget(input, widget, input->sx, input->sy);
1782         }
1783 }
1784
1785 static void
1786 pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial,
1787                       uint32_t time, uint32_t button, uint32_t state)
1788 {
1789         struct input *input = data;
1790         struct widget *widget;
1791
1792         input->display->serial = serial;
1793         if (input->focus_widget && input->grab == NULL && state)
1794                 input_grab(input, input->focus_widget, button);
1795
1796         widget = input->grab;
1797         if (widget && widget->button_handler)
1798                 (*widget->button_handler)(widget,
1799                                           input, time,
1800                                           button, state,
1801                                           input->grab->user_data);
1802
1803         if (input->grab && input->grab_button == button && !state)
1804                 input_ungrab(input);
1805 }
1806
1807 static void
1808 pointer_handle_axis(void *data, struct wl_pointer *pointer,
1809                     uint32_t time, uint32_t axis, int32_t value)
1810 {
1811 }
1812
1813 static void
1814 keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
1815                     uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
1816 {
1817         struct input *input = data;
1818         struct window *window = input->keyboard_focus;
1819         struct display *d = input->display;
1820         uint32_t code, num_syms;
1821         const xkb_keysym_t *syms;
1822         xkb_keysym_t sym;
1823         xkb_mod_mask_t mask;
1824
1825         input->display->serial = serial;
1826         code = key + 8;
1827         if (!window || window->keyboard_device != input)
1828                 return;
1829
1830         if (state)
1831                 window->send_cursor_position = 1;
1832
1833         num_syms = xkb_key_get_syms(d->xkb.state, code, &syms);
1834
1835         mask = xkb_state_serialize_mods(d->xkb.state,
1836                                         XKB_STATE_DEPRESSED |
1837                                         XKB_STATE_LATCHED);
1838         input->modifiers = 0;
1839         if (mask & input->display->xkb.control_mask)
1840                 input->modifiers |= MOD_CONTROL_MASK;
1841         if (mask & input->display->xkb.alt_mask)
1842                 input->modifiers |= MOD_ALT_MASK;
1843         if (mask & input->display->xkb.shift_mask)
1844                 input->modifiers |= MOD_SHIFT_MASK;
1845
1846         if (num_syms == 1 && syms[0] == XKB_KEY_F5 &&
1847             input->modifiers == MOD_ALT_MASK) {
1848                 if (state)
1849                         window_set_maximized(window,
1850                                              window->type != TYPE_MAXIMIZED);
1851         } else if (window->key_handler) {
1852                 if (num_syms == 1)
1853                         sym = syms[0];
1854                 else
1855                         sym = XKB_KEY_NoSymbol;
1856
1857                 (*window->key_handler)(window, input, time, key,
1858                                        sym, state, window->user_data);
1859         }
1860 }
1861
1862 static void
1863 keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
1864                           uint32_t serial, uint32_t mods_depressed,
1865                           uint32_t mods_latched, uint32_t mods_locked,
1866                           uint32_t group)
1867 {
1868         struct input *input = data;
1869
1870         xkb_state_update_mask(input->display->xkb.state,
1871                               mods_depressed,
1872                               mods_latched,
1873                               mods_locked,
1874                               0,
1875                               0,
1876                               group);
1877 }
1878
1879 static void
1880 input_remove_pointer_focus(struct input *input)
1881 {
1882         struct window *window = input->pointer_focus;
1883
1884         if (!window)
1885                 return;
1886
1887         input_set_focus_widget(input, NULL, 0, 0);
1888
1889         input->pointer_focus = NULL;
1890         input->current_cursor = CURSOR_UNSET;
1891 }
1892
1893 static void
1894 pointer_handle_enter(void *data, struct wl_pointer *pointer,
1895                      uint32_t serial, struct wl_surface *surface,
1896                      wl_fixed_t sx_w, wl_fixed_t sy_w)
1897 {
1898         struct input *input = data;
1899         struct window *window;
1900         struct widget *widget;
1901         float sx = wl_fixed_to_double(sx_w);
1902         float sy = wl_fixed_to_double(sy_w);
1903
1904         if (!surface) {
1905                 /* enter event for a window we've just destroyed */
1906                 return;
1907         }
1908
1909         input->display->serial = serial;
1910         input->pointer_enter_serial = serial;
1911         input->pointer_focus = wl_surface_get_user_data(surface);
1912         window = input->pointer_focus;
1913
1914         if (window->pool) {
1915                 shm_pool_destroy(window->pool);
1916                 window->pool = NULL;
1917                 /* Schedule a redraw to free the pool */
1918                 window_schedule_redraw(window);
1919         }
1920
1921         input->sx = sx;
1922         input->sy = sy;
1923
1924         widget = widget_find_widget(window->widget, sx, sy);
1925         input_set_focus_widget(input, widget, sx, sy);
1926 }
1927
1928 static void
1929 pointer_handle_leave(void *data, struct wl_pointer *pointer,
1930                      uint32_t serial, struct wl_surface *surface)
1931 {
1932         struct input *input = data;
1933
1934         input->display->serial = serial;
1935         input_remove_pointer_focus(input);
1936 }
1937
1938 static void
1939 input_remove_keyboard_focus(struct input *input)
1940 {
1941         struct window *window = input->keyboard_focus;
1942
1943         if (!window)
1944                 return;
1945
1946         window->keyboard_device = NULL;
1947         if (window->keyboard_focus_handler)
1948                 (*window->keyboard_focus_handler)(window, NULL,
1949                                                   window->user_data);
1950
1951         input->keyboard_focus = NULL;
1952 }
1953
1954 static void
1955 keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
1956                       uint32_t serial, struct wl_surface *surface,
1957                       struct wl_array *keys)
1958 {
1959         struct input *input = data;
1960         struct window *window;
1961
1962         input->display->serial = serial;
1963         input->keyboard_focus = wl_surface_get_user_data(surface);
1964
1965         window = input->keyboard_focus;
1966         window->keyboard_device = input;
1967         if (window->keyboard_focus_handler)
1968                 (*window->keyboard_focus_handler)(window,
1969                                                   window->keyboard_device,
1970                                                   window->user_data);
1971 }
1972
1973 static void
1974 keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
1975                       uint32_t serial, struct wl_surface *surface)
1976 {
1977         struct input *input = data;
1978
1979         input->display->serial = serial;
1980         input_remove_keyboard_focus(input);
1981 }
1982
1983 static const struct wl_pointer_listener pointer_listener = {
1984         pointer_handle_enter,
1985         pointer_handle_leave,
1986         pointer_handle_motion,
1987         pointer_handle_button,
1988         pointer_handle_axis,
1989 };
1990
1991 static const struct wl_keyboard_listener keyboard_listener = {
1992         keyboard_handle_enter,
1993         keyboard_handle_leave,
1994         keyboard_handle_key,
1995         keyboard_handle_modifiers,
1996 };
1997
1998 static void
1999 seat_handle_capabilities(void *data, struct wl_seat *seat,
2000                          enum wl_seat_capability caps)
2001 {
2002         struct input *input = data;
2003
2004         if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
2005                 input->pointer = wl_seat_get_pointer(seat);
2006                 wl_pointer_set_user_data(input->pointer, input);
2007                 wl_pointer_add_listener(input->pointer, &pointer_listener,
2008                                         input);
2009         } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) {
2010                 wl_pointer_destroy(input->pointer);
2011                 input->pointer = NULL;
2012         }
2013
2014         if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) {
2015                 input->keyboard = wl_seat_get_keyboard(seat);
2016                 wl_keyboard_set_user_data(input->keyboard, input);
2017                 wl_keyboard_add_listener(input->keyboard, &keyboard_listener,
2018                                          input);
2019         } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) {
2020                 wl_keyboard_destroy(input->keyboard);
2021                 input->keyboard = NULL;
2022         }
2023 }
2024
2025 static const struct wl_seat_listener seat_listener = {
2026         seat_handle_capabilities,
2027 };
2028
2029 void
2030 input_get_position(struct input *input, int32_t *x, int32_t *y)
2031 {
2032         *x = input->sx;
2033         *y = input->sy;
2034 }
2035
2036 struct wl_seat *
2037 input_get_seat(struct input *input)
2038 {
2039         return input->seat;
2040 }
2041
2042 uint32_t
2043 input_get_modifiers(struct input *input)
2044 {
2045         return input->modifiers;
2046 }
2047
2048 struct widget *
2049 input_get_focus_widget(struct input *input)
2050 {
2051         return input->focus_widget;
2052 }
2053
2054 struct data_offer {
2055         struct wl_data_offer *offer;
2056         struct input *input;
2057         struct wl_array types;
2058         int refcount;
2059
2060         struct task io_task;
2061         int fd;
2062         data_func_t func;
2063         int32_t x, y;
2064         void *user_data;
2065 };
2066
2067 static void
2068 data_offer_offer(void *data, struct wl_data_offer *wl_data_offer, const char *type)
2069 {
2070         struct data_offer *offer = data;
2071         char **p;
2072
2073         p = wl_array_add(&offer->types, sizeof *p);
2074         *p = strdup(type);
2075 }
2076
2077 static const struct wl_data_offer_listener data_offer_listener = {
2078         data_offer_offer,
2079 };
2080
2081 static void
2082 data_offer_destroy(struct data_offer *offer)
2083 {
2084         char **p;
2085
2086         offer->refcount--;
2087         if (offer->refcount == 0) {
2088                 wl_data_offer_destroy(offer->offer);
2089                 for (p = offer->types.data; *p; p++)
2090                         free(*p);
2091                 wl_array_release(&offer->types);
2092                 free(offer);
2093         }
2094 }
2095
2096 static void
2097 data_device_data_offer(void *data,
2098                        struct wl_data_device *data_device, uint32_t id)
2099 {
2100         struct data_offer *offer;
2101
2102         offer = malloc(sizeof *offer);
2103
2104         wl_array_init(&offer->types);
2105         offer->refcount = 1;
2106         offer->input = data;
2107
2108         /* FIXME: Generate typesafe wrappers for this */
2109         offer->offer = (struct wl_data_offer *)
2110                 wl_proxy_create_for_id((struct wl_proxy *) data_device,
2111                                        id, &wl_data_offer_interface);
2112
2113         wl_data_offer_add_listener(offer->offer,
2114                                    &data_offer_listener, offer);
2115 }
2116
2117 static void
2118 data_device_enter(void *data, struct wl_data_device *data_device,
2119                   uint32_t serial, struct wl_surface *surface,
2120                   wl_fixed_t x_w, wl_fixed_t y_w,
2121                   struct wl_data_offer *offer)
2122 {
2123         struct input *input = data;
2124         struct window *window;
2125         void *types_data;
2126         float x = wl_fixed_to_double(x_w);
2127         float y = wl_fixed_to_double(y_w);
2128         char **p;
2129
2130         input->pointer_enter_serial = serial;
2131         window = wl_surface_get_user_data(surface);
2132         input->pointer_focus = window;
2133
2134         if (offer) {
2135                 input->drag_offer = wl_data_offer_get_user_data(offer);
2136
2137                 p = wl_array_add(&input->drag_offer->types, sizeof *p);
2138                 *p = NULL;
2139
2140                 types_data = input->drag_offer->types.data;
2141         } else {
2142                 input->drag_offer = NULL;
2143                 types_data = NULL;
2144         }
2145
2146         window = input->pointer_focus;
2147         if (window->data_handler)
2148                 window->data_handler(window, input, x, y, types_data,
2149                                      window->user_data);
2150 }
2151
2152 static void
2153 data_device_leave(void *data, struct wl_data_device *data_device)
2154 {
2155         struct input *input = data;
2156
2157         if (input->drag_offer) {
2158                 data_offer_destroy(input->drag_offer);
2159                 input->drag_offer = NULL;
2160         }
2161 }
2162
2163 static void
2164 data_device_motion(void *data, struct wl_data_device *data_device,
2165                    uint32_t time, wl_fixed_t x_w, wl_fixed_t y_w)
2166 {
2167         struct input *input = data;
2168         struct window *window = input->pointer_focus;
2169         float x = wl_fixed_to_double(x_w);
2170         float y = wl_fixed_to_double(y_w);
2171         void *types_data;
2172
2173         input->sx = x;
2174         input->sy = y;
2175
2176         if (input->drag_offer)
2177                 types_data = input->drag_offer->types.data;
2178         else
2179                 types_data = NULL;
2180
2181         if (window->data_handler)
2182                 window->data_handler(window, input, x, y, types_data,
2183                                      window->user_data);
2184 }
2185
2186 static void
2187 data_device_drop(void *data, struct wl_data_device *data_device)
2188 {
2189         struct input *input = data;
2190         struct window *window = input->pointer_focus;
2191
2192         if (window->drop_handler)
2193                 window->drop_handler(window, input,
2194                                      input->sx, input->sy, window->user_data);
2195 }
2196
2197 static void
2198 data_device_selection(void *data,
2199                       struct wl_data_device *wl_data_device,
2200                       struct wl_data_offer *offer)
2201 {
2202         struct input *input = data;
2203         char **p;
2204
2205         if (input->selection_offer)
2206                 data_offer_destroy(input->selection_offer);
2207
2208         if (offer) {
2209                 input->selection_offer = wl_data_offer_get_user_data(offer);
2210                 p = wl_array_add(&input->selection_offer->types, sizeof *p);
2211                 *p = NULL;
2212         }
2213 }
2214
2215 static const struct wl_data_device_listener data_device_listener = {
2216         data_device_data_offer,
2217         data_device_enter,
2218         data_device_leave,
2219         data_device_motion,
2220         data_device_drop,
2221         data_device_selection
2222 };
2223
2224 void
2225 input_set_pointer_image(struct input *input, uint32_t time, int pointer)
2226 {
2227         struct wl_buffer *buffer;
2228         struct wl_cursor *cursor;
2229         struct wl_cursor_image *image;
2230
2231         if (pointer == input->current_cursor)
2232                 return;
2233
2234         cursor = input->display->cursors[pointer];
2235         if (!cursor)
2236                 return;
2237
2238         image = cursor->images[0];
2239         buffer = wl_cursor_image_get_buffer(image);
2240         if (!buffer)
2241                 return;
2242
2243         input->current_cursor = pointer;
2244         wl_pointer_attach(input->pointer, time, buffer,
2245                           image->hotspot_x, image->hotspot_y);
2246 }
2247
2248 struct wl_data_device *
2249 input_get_data_device(struct input *input)
2250 {
2251         return input->data_device;
2252 }
2253
2254 void
2255 input_set_selection(struct input *input,
2256                     struct wl_data_source *source, uint32_t time)
2257 {
2258         wl_data_device_set_selection(input->data_device, source, time);
2259 }
2260
2261 void
2262 input_accept(struct input *input, const char *type)
2263 {
2264         wl_data_offer_accept(input->drag_offer->offer,
2265                              input->pointer_enter_serial, type);
2266 }
2267
2268 static void
2269 offer_io_func(struct task *task, uint32_t events)
2270 {
2271         struct data_offer *offer =
2272                 container_of(task, struct data_offer, io_task);
2273         unsigned int len;
2274         char buffer[4096];
2275
2276         len = read(offer->fd, buffer, sizeof buffer);
2277         offer->func(buffer, len,
2278                     offer->x, offer->y, offer->user_data);
2279
2280         if (len == 0) {
2281                 close(offer->fd);
2282                 data_offer_destroy(offer);
2283         }
2284 }
2285
2286 static void
2287 data_offer_receive_data(struct data_offer *offer, const char *mime_type,
2288                         data_func_t func, void *user_data)
2289 {
2290         int p[2];
2291
2292         if (pipe2(p, O_CLOEXEC) == -1)
2293                 return;
2294
2295         wl_data_offer_receive(offer->offer, mime_type, p[1]);
2296         close(p[1]);
2297
2298         offer->io_task.run = offer_io_func;
2299         offer->fd = p[0];
2300         offer->func = func;
2301         offer->refcount++;
2302         offer->user_data = user_data;
2303
2304         display_watch_fd(offer->input->display,
2305                          offer->fd, EPOLLIN, &offer->io_task);
2306 }
2307
2308 void
2309 input_receive_drag_data(struct input *input, const char *mime_type,
2310                         data_func_t func, void *data)
2311 {
2312         data_offer_receive_data(input->drag_offer, mime_type, func, data);
2313         input->drag_offer->x = input->sx;
2314         input->drag_offer->y = input->sy;
2315 }
2316
2317 int
2318 input_receive_selection_data(struct input *input, const char *mime_type,
2319                              data_func_t func, void *data)
2320 {
2321         char **p;
2322
2323         if (input->selection_offer == NULL)
2324                 return -1;
2325
2326         for (p = input->selection_offer->types.data; *p; p++)
2327                 if (strcmp(mime_type, *p) == 0)
2328                         break;
2329
2330         if (*p == NULL)
2331                 return -1;
2332
2333         data_offer_receive_data(input->selection_offer,
2334                                 mime_type, func, data);
2335         return 0;
2336 }
2337
2338 int
2339 input_receive_selection_data_to_fd(struct input *input,
2340                                    const char *mime_type, int fd)
2341 {
2342         wl_data_offer_receive(input->selection_offer->offer, mime_type, fd);
2343
2344         return 0;
2345 }
2346
2347 void
2348 window_move(struct window *window, struct input *input, uint32_t serial)
2349 {
2350         if (!window->shell_surface)
2351                 return;
2352
2353         wl_shell_surface_move(window->shell_surface, input->seat, serial);
2354 }
2355
2356 static void
2357 idle_resize(struct window *window)
2358 {
2359         struct widget *widget;
2360
2361         window->resize_needed = 0;
2362         widget = window->widget;
2363         widget_set_allocation(widget,
2364                               window->pending_allocation.x,
2365                               window->pending_allocation.y,
2366                               window->pending_allocation.width,
2367                               window->pending_allocation.height);
2368
2369         if (window->input_region) {
2370                 wl_region_destroy(window->input_region);
2371                 window->input_region = NULL;
2372         }
2373
2374         if (window->opaque_region) {
2375                 wl_region_destroy(window->opaque_region);
2376                 window->opaque_region = NULL;
2377         }
2378
2379         if (widget->resize_handler)
2380                 widget->resize_handler(widget,
2381                                        widget->allocation.width,
2382                                        widget->allocation.height,
2383                                        widget->user_data);
2384
2385         if (window->allocation.width != widget->allocation.width ||
2386             window->allocation.height != widget->allocation.height) {
2387                 window->allocation = widget->allocation;
2388                 window_schedule_redraw(window);
2389         }
2390 }
2391
2392 void
2393 window_schedule_resize(struct window *window, int width, int height)
2394 {
2395         window->pending_allocation.x = 0;
2396         window->pending_allocation.y = 0;
2397         window->pending_allocation.width = width;
2398         window->pending_allocation.height = height;
2399
2400         window->resize_needed = 1;
2401         window_schedule_redraw(window);
2402 }
2403
2404 void
2405 widget_schedule_resize(struct widget *widget, int32_t width, int32_t height)
2406 {
2407         window_schedule_resize(widget->window, width, height);
2408 }
2409
2410 static void
2411 handle_ping(void *data, struct wl_shell_surface *shell_surface,
2412                                                         uint32_t serial)
2413 {
2414         wl_shell_surface_pong(shell_surface, serial);
2415 }
2416
2417 static void
2418 handle_configure(void *data, struct wl_shell_surface *shell_surface,
2419                  uint32_t edges, int32_t width, int32_t height)
2420 {
2421         struct window *window = data;
2422
2423         if (width <= 0 || height <= 0)
2424                 return;
2425
2426         window->resize_edges = edges;
2427         window_schedule_resize(window, width, height);
2428 }
2429
2430 static void
2431 menu_destroy(struct menu *menu)
2432 {
2433         widget_destroy(menu->widget);
2434         window_destroy(menu->window);
2435         free(menu);
2436 }
2437
2438 static void
2439 handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
2440 {
2441         struct window *window = data;
2442         struct menu *menu = window->widget->user_data;
2443
2444         /* FIXME: Need more context in this event, at least the input
2445          * device.  Or just use wl_callback.  And this really needs to
2446          * be a window vfunc that the menu can set.  And we need the
2447          * time. */
2448
2449         menu->func(window->parent, menu->current, window->parent->user_data);
2450         input_ungrab(menu->input);
2451         menu_destroy(menu);
2452 }
2453
2454 static const struct wl_shell_surface_listener shell_surface_listener = {
2455         handle_ping,
2456         handle_configure,
2457         handle_popup_done
2458 };
2459
2460 void
2461 window_get_allocation(struct window *window,
2462                       struct rectangle *allocation)
2463 {
2464         *allocation = window->allocation;
2465 }
2466
2467 static void
2468 widget_redraw(struct widget *widget)
2469 {
2470         struct widget *child;
2471
2472         if (widget->redraw_handler)
2473                 widget->redraw_handler(widget, widget->user_data);
2474         wl_list_for_each(child, &widget->child_list, link)
2475                 widget_redraw(child);
2476 }
2477
2478 static void
2479 frame_callback(void *data, struct wl_callback *callback, uint32_t time)
2480 {
2481         struct window *window = data;
2482
2483         wl_callback_destroy(callback);
2484         window->redraw_scheduled = 0;
2485         if (window->redraw_needed)
2486                 window_schedule_redraw(window);
2487 }
2488
2489 static const struct wl_callback_listener listener = {
2490         frame_callback
2491 };
2492
2493 static void
2494 idle_redraw(struct task *task, uint32_t events)
2495 {
2496         struct window *window = container_of(task, struct window, redraw_task);
2497         struct wl_callback *callback;
2498
2499         if (window->resize_needed)
2500                 idle_resize(window);
2501
2502         window_create_surface(window);
2503         widget_redraw(window->widget);
2504         window_flush(window);
2505         window->redraw_needed = 0;
2506         wl_list_init(&window->redraw_task.link);
2507
2508         callback = wl_surface_frame(window->surface);
2509         wl_callback_add_listener(callback, &listener, window);
2510 }
2511
2512 void
2513 window_schedule_redraw(struct window *window)
2514 {
2515         window->redraw_needed = 1;
2516         if (!window->redraw_scheduled) {
2517                 window->redraw_task.run = idle_redraw;
2518                 display_defer(window->display, &window->redraw_task);
2519                 window->redraw_scheduled = 1;
2520         }
2521 }
2522
2523 void
2524 window_set_custom(struct window *window)
2525 {
2526         window->type = TYPE_CUSTOM;
2527 }
2528
2529 void
2530 window_set_fullscreen(struct window *window, int fullscreen)
2531 {
2532         if (!window->display->shell)
2533                 return;
2534
2535         if ((window->type == TYPE_FULLSCREEN) == fullscreen)
2536                 return;
2537
2538         if (fullscreen) {
2539                 window->type = TYPE_FULLSCREEN;
2540                 window->saved_allocation = window->allocation;
2541                 wl_shell_surface_set_fullscreen(window->shell_surface,
2542                                                 WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
2543                                                 0, NULL);
2544         } else {
2545                 window->type = TYPE_TOPLEVEL;
2546                 wl_shell_surface_set_toplevel(window->shell_surface);
2547                 window_schedule_resize(window,
2548                                        window->saved_allocation.width,
2549                                        window->saved_allocation.height);
2550         }
2551 }
2552
2553 void
2554 window_set_maximized(struct window *window, int maximized)
2555 {
2556         if (!window->display->shell)
2557                 return;
2558
2559         if ((window->type == TYPE_MAXIMIZED) == maximized)
2560                 return;
2561
2562         if (window->type == TYPE_TOPLEVEL) {
2563                 window->saved_allocation = window->allocation;
2564                 wl_shell_surface_set_maximized(window->shell_surface, NULL);
2565                 window->type = TYPE_MAXIMIZED;
2566         } else {
2567                 wl_shell_surface_set_toplevel(window->shell_surface);
2568                 window->type = TYPE_TOPLEVEL;
2569                 window_schedule_resize(window,
2570                                        window->saved_allocation.width,
2571                                        window->saved_allocation.height);
2572         }
2573 }
2574
2575 void
2576 window_set_user_data(struct window *window, void *data)
2577 {
2578         window->user_data = data;
2579 }
2580
2581 void *
2582 window_get_user_data(struct window *window)
2583 {
2584         return window->user_data;
2585 }
2586
2587 void
2588 window_set_key_handler(struct window *window,
2589                        window_key_handler_t handler)
2590 {
2591         window->key_handler = handler;
2592 }
2593
2594 void
2595 window_set_keyboard_focus_handler(struct window *window,
2596                                   window_keyboard_focus_handler_t handler)
2597 {
2598         window->keyboard_focus_handler = handler;
2599 }
2600
2601 void
2602 window_set_data_handler(struct window *window, window_data_handler_t handler)
2603 {
2604         window->data_handler = handler;
2605 }
2606
2607 void
2608 window_set_drop_handler(struct window *window, window_drop_handler_t handler)
2609 {
2610         window->drop_handler = handler;
2611 }
2612
2613 void
2614 window_set_close_handler(struct window *window,
2615                          window_close_handler_t handler)
2616 {
2617         window->close_handler = handler;
2618 }
2619
2620 void
2621 window_set_title(struct window *window, const char *title)
2622 {
2623         free(window->title);
2624         window->title = strdup(title);
2625         if (window->shell_surface)
2626                 wl_shell_surface_set_title(window->shell_surface, title);
2627 }
2628
2629 const char *
2630 window_get_title(struct window *window)
2631 {
2632         return window->title;
2633 }
2634
2635 void
2636 window_set_text_cursor_position(struct window *window, int32_t x, int32_t y)
2637 {
2638         struct text_cursor_position *text_cursor_position =
2639                                         window->display->text_cursor_position;
2640
2641         if (!window->send_cursor_position || !text_cursor_position)
2642                 return;
2643
2644         text_cursor_position_notify(text_cursor_position,
2645                                                 window->surface, x, y);
2646
2647         window->send_cursor_position = 0;
2648 }
2649
2650 void
2651 window_damage(struct window *window, int32_t x, int32_t y,
2652               int32_t width, int32_t height)
2653 {
2654         wl_surface_damage(window->surface, x, y, width, height);
2655 }
2656
2657 static void
2658 surface_enter(void *data,
2659               struct wl_surface *wl_surface, struct wl_output *wl_output)
2660 {
2661         struct window *window = data;
2662         struct output *output;
2663         struct output *output_found = NULL;
2664         struct window_output *window_output;
2665
2666         wl_list_for_each(output, &window->display->output_list, link) {
2667                 if (output->output == wl_output) {
2668                         output_found = output;
2669                         break;
2670                 }
2671         }
2672
2673         if (!output_found)
2674                 return;
2675
2676         window_output = malloc (sizeof *window_output);
2677         window_output->output = output_found;
2678
2679         wl_list_insert (&window->window_output_list, &window_output->link);
2680 }
2681
2682 static void
2683 surface_leave(void *data,
2684               struct wl_surface *wl_surface, struct wl_output *output)
2685 {
2686         struct window *window = data;
2687         struct window_output *window_output;
2688         struct window_output *window_output_found = NULL;
2689
2690         wl_list_for_each(window_output, &window->window_output_list, link) {
2691                 if (window_output->output->output == output) {
2692                         window_output_found = window_output;
2693                         break;
2694                 }
2695         }
2696
2697         if (window_output_found) {
2698                 wl_list_remove(&window_output_found->link);
2699                 free(window_output_found);
2700         }
2701 }
2702
2703 static const struct wl_surface_listener surface_listener = {
2704         surface_enter,
2705         surface_leave
2706 };
2707
2708 static struct window *
2709 window_create_internal(struct display *display, struct window *parent)
2710 {
2711         struct window *window;
2712
2713         window = malloc(sizeof *window);
2714         if (window == NULL)
2715                 return NULL;
2716
2717         memset(window, 0, sizeof *window);
2718         window->display = display;
2719         window->parent = parent;
2720         window->surface = wl_compositor_create_surface(display->compositor);
2721         wl_surface_add_listener(window->surface, &surface_listener, window);
2722         if (display->shell) {
2723                 window->shell_surface =
2724                         wl_shell_get_shell_surface(display->shell,
2725                                                    window->surface);
2726                 if (window->title)
2727                         wl_shell_surface_set_title(window->shell_surface,
2728                                                    window->title);
2729         }
2730         window->allocation.x = 0;
2731         window->allocation.y = 0;
2732         window->allocation.width = 0;
2733         window->allocation.height = 0;
2734         window->saved_allocation = window->allocation;
2735         window->transparent = 1;
2736         window->send_cursor_position = 0;
2737         window->type = TYPE_NONE;
2738         window->input_region = NULL;
2739         window->opaque_region = NULL;
2740
2741         if (display->dpy)
2742 #ifdef HAVE_CAIRO_EGL
2743                 window->buffer_type = WINDOW_BUFFER_TYPE_EGL_WINDOW;
2744 #else
2745                 window->buffer_type = WINDOW_BUFFER_TYPE_SHM;
2746 #endif
2747         else
2748                 window->buffer_type = WINDOW_BUFFER_TYPE_SHM;
2749
2750         wl_surface_set_user_data(window->surface, window);
2751         wl_list_insert(display->window_list.prev, &window->link);
2752         wl_list_init(&window->redraw_task.link);
2753
2754         if (window->shell_surface) {
2755                 wl_shell_surface_set_user_data(window->shell_surface, window);
2756                 wl_shell_surface_add_listener(window->shell_surface,
2757                                               &shell_surface_listener, window);
2758         }
2759
2760         wl_list_init (&window->window_output_list);
2761
2762         return window;
2763 }
2764
2765 struct window *
2766 window_create(struct display *display)
2767 {
2768         struct window *window;
2769
2770         window = window_create_internal(display, NULL);
2771         if (!window)
2772                 return NULL;
2773
2774         return window;
2775 }
2776
2777 struct window *
2778 window_create_transient(struct display *display, struct window *parent,
2779                         int32_t x, int32_t y, uint32_t flags)
2780 {
2781         struct window *window;
2782
2783         window = window_create_internal(parent->display, parent);
2784         if (!window)
2785                 return NULL;
2786
2787         window->type = TYPE_TRANSIENT;
2788         window->x = x;
2789         window->y = y;
2790
2791         if (display->shell)
2792                 wl_shell_surface_set_transient(window->shell_surface,
2793                                                window->parent->shell_surface,
2794                                                window->x, window->y, flags);
2795
2796         return window;
2797 }
2798
2799 static void
2800 menu_set_item(struct menu *menu, int sy)
2801 {
2802         int next;
2803
2804         next = (sy - 8) / 20;
2805         if (menu->current != next) {
2806                 menu->current = next;
2807                 widget_schedule_redraw(menu->widget);
2808         }
2809 }
2810
2811 static int
2812 menu_motion_handler(struct widget *widget,
2813                     struct input *input, uint32_t time,
2814                     float x, float y, void *data)
2815 {
2816         struct menu *menu = data;
2817
2818         if (widget == menu->widget)
2819                 menu_set_item(data, y);
2820
2821         return CURSOR_LEFT_PTR;
2822 }
2823
2824 static int
2825 menu_enter_handler(struct widget *widget,
2826                    struct input *input, float x, float y, void *data)
2827 {
2828         struct menu *menu = data;
2829
2830         if (widget == menu->widget)
2831                 menu_set_item(data, y);
2832
2833         return CURSOR_LEFT_PTR;
2834 }
2835
2836 static void
2837 menu_leave_handler(struct widget *widget, struct input *input, void *data)
2838 {
2839         struct menu *menu = data;
2840
2841         if (widget == menu->widget)
2842                 menu_set_item(data, -200);
2843 }
2844
2845 static void
2846 menu_button_handler(struct widget *widget,
2847                     struct input *input, uint32_t time,
2848                     uint32_t button, uint32_t state, void *data)
2849
2850 {
2851         struct menu *menu = data;
2852
2853         if (state == 0 && time - menu->time > 500) {
2854                 /* Either relase after press-drag-release or
2855                  * click-motion-click. */
2856                 menu->func(menu->window->parent,
2857                            menu->current, menu->window->parent->user_data);
2858                 input_ungrab(input);
2859                 menu_destroy(menu);
2860         }
2861 }
2862
2863 static void
2864 menu_redraw_handler(struct widget *widget, void *data)
2865 {
2866         cairo_t *cr;
2867         const int32_t r = 3, margin = 3;
2868         struct menu *menu = data;
2869         int32_t width, height, i;
2870         struct window *window = widget->window;
2871
2872         cr = cairo_create(window->cairo_surface);
2873         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
2874         cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0);
2875         cairo_paint(cr);
2876
2877         width = window->allocation.width;
2878         height = window->allocation.height;
2879         rounded_rect(cr, 0, 0, width, height, r);
2880
2881         cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
2882         cairo_set_source_rgba(cr, 0.0, 0.0, 0.4, 0.8);
2883         cairo_fill(cr);
2884
2885         for (i = 0; i < menu->count; i++) {
2886                 if (i == menu->current) {
2887                         cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
2888                         cairo_rectangle(cr, margin, i * 20 + margin,
2889                                         width - 2 * margin, 20);
2890                         cairo_fill(cr);
2891                         cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
2892                         cairo_move_to(cr, 10, i * 20 + 16);
2893                         cairo_show_text(cr, menu->entries[i]);
2894                 } else {
2895                         cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
2896                         cairo_move_to(cr, 10, i * 20 + 16);
2897                         cairo_show_text(cr, menu->entries[i]);
2898                 }
2899         }
2900
2901         cairo_destroy(cr);
2902 }
2903
2904 void
2905 window_show_menu(struct display *display,
2906                  struct input *input, uint32_t time, struct window *parent,
2907                  int32_t x, int32_t y,
2908                  menu_func_t func, const char **entries, int count)
2909 {
2910         struct window *window;
2911         struct menu *menu;
2912         const int32_t margin = 3;
2913
2914         menu = malloc(sizeof *menu);
2915         if (!menu)
2916                 return;
2917
2918         window = window_create_internal(parent->display, parent);
2919         if (!window)
2920                 return;
2921
2922         menu->window = window;
2923         menu->widget = window_add_widget(menu->window, menu);
2924         menu->entries = entries;
2925         menu->count = count;
2926         menu->current = -1;
2927         menu->time = time;
2928         menu->func = func;
2929         menu->input = input;
2930         window->type = TYPE_MENU;
2931         window->x = x;
2932         window->y = y;
2933
2934         input_ungrab(input);
2935         wl_shell_surface_set_popup(window->shell_surface, input->seat,
2936                                    display_get_serial(window->display),
2937                                    window->parent->shell_surface,
2938                                    window->x, window->y, 0);
2939
2940         widget_set_redraw_handler(menu->widget, menu_redraw_handler);
2941         widget_set_enter_handler(menu->widget, menu_enter_handler);
2942         widget_set_leave_handler(menu->widget, menu_leave_handler);
2943         widget_set_motion_handler(menu->widget, menu_motion_handler);
2944         widget_set_button_handler(menu->widget, menu_button_handler);
2945
2946         input_grab(input, menu->widget, 0);
2947         window_schedule_resize(window, 200, count * 20 + margin * 2);
2948 }
2949
2950 void
2951 window_set_buffer_type(struct window *window, enum window_buffer_type type)
2952 {
2953         window->buffer_type = type;
2954 }
2955
2956
2957 static void
2958 display_handle_geometry(void *data,
2959                         struct wl_output *wl_output,
2960                         int x, int y,
2961                         int physical_width,
2962                         int physical_height,
2963                         int subpixel,
2964                         const char *make,
2965                         const char *model)
2966 {
2967         struct output *output = data;
2968
2969         output->allocation.x = x;
2970         output->allocation.y = y;
2971 }
2972
2973 static void
2974 display_handle_mode(void *data,
2975                     struct wl_output *wl_output,
2976                     uint32_t flags,
2977                     int width,
2978                     int height,
2979                     int refresh)
2980 {
2981         struct output *output = data;
2982         struct display *display = output->display;
2983
2984         if (flags & WL_OUTPUT_MODE_CURRENT) {
2985                 output->allocation.width = width;
2986                 output->allocation.height = height;
2987                 if (display->output_configure_handler)
2988                         (*display->output_configure_handler)(
2989                                                 output, display->user_data);
2990         }
2991 }
2992
2993 static const struct wl_output_listener output_listener = {
2994         display_handle_geometry,
2995         display_handle_mode
2996 };
2997
2998 static void
2999 display_add_output(struct display *d, uint32_t id)
3000 {
3001         struct output *output;
3002
3003         output = malloc(sizeof *output);
3004         if (output == NULL)
3005                 return;
3006
3007         memset(output, 0, sizeof *output);
3008         output->display = d;
3009         output->output =
3010                 wl_display_bind(d->display, id, &wl_output_interface);
3011         wl_list_insert(d->output_list.prev, &output->link);
3012
3013         wl_output_add_listener(output->output, &output_listener, output);
3014 }
3015
3016 static void
3017 output_destroy(struct output *output)
3018 {
3019         if (output->destroy_handler)
3020                 (*output->destroy_handler)(output, output->user_data);
3021
3022         wl_output_destroy(output->output);
3023         wl_list_remove(&output->link);
3024         free(output);
3025 }
3026
3027 void
3028 display_set_output_configure_handler(struct display *display,
3029                                      display_output_handler_t handler)
3030 {
3031         struct output *output;
3032
3033         display->output_configure_handler = handler;
3034         if (!handler)
3035                 return;
3036
3037         wl_list_for_each(output, &display->output_list, link)
3038                 (*display->output_configure_handler)(output,
3039                                                      display->user_data);
3040 }
3041
3042 void
3043 output_set_user_data(struct output *output, void *data)
3044 {
3045         output->user_data = data;
3046 }
3047
3048 void *
3049 output_get_user_data(struct output *output)
3050 {
3051         return output->user_data;
3052 }
3053
3054 void
3055 output_set_destroy_handler(struct output *output,
3056                            display_output_handler_t handler)
3057 {
3058         output->destroy_handler = handler;
3059         /* FIXME: implement this, once we have way to remove outputs */
3060 }
3061
3062 void
3063 output_get_allocation(struct output *output, struct rectangle *allocation)
3064 {
3065         *allocation = output->allocation;
3066 }
3067
3068 struct wl_output *
3069 output_get_wl_output(struct output *output)
3070 {
3071         return output->output;
3072 }
3073
3074 static void
3075 display_add_input(struct display *d, uint32_t id)
3076 {
3077         struct input *input;
3078
3079         input = malloc(sizeof *input);
3080         if (input == NULL)
3081                 return;
3082
3083         memset(input, 0, sizeof *input);
3084         input->display = d;
3085         input->seat = wl_display_bind(d->display, id, &wl_seat_interface);
3086         input->pointer_focus = NULL;
3087         input->keyboard_focus = NULL;
3088         wl_list_insert(d->input_list.prev, &input->link);
3089
3090         wl_seat_add_listener(input->seat, &seat_listener, input);
3091         wl_seat_set_user_data(input->seat, input);
3092
3093         input->data_device =
3094                 wl_data_device_manager_get_data_device(d->data_device_manager,
3095                                                        input->seat);
3096         wl_data_device_add_listener(input->data_device, &data_device_listener,
3097                                     input);
3098 }
3099
3100 static void
3101 input_destroy(struct input *input)
3102 {
3103         input_remove_keyboard_focus(input);
3104         input_remove_pointer_focus(input);
3105
3106         if (input->drag_offer)
3107                 data_offer_destroy(input->drag_offer);
3108
3109         if (input->selection_offer)
3110                 data_offer_destroy(input->selection_offer);
3111
3112         wl_data_device_destroy(input->data_device);
3113         wl_list_remove(&input->link);
3114         wl_seat_destroy(input->seat);
3115         free(input);
3116 }
3117
3118 static void
3119 display_handle_global(struct wl_display *display, uint32_t id,
3120                       const char *interface, uint32_t version, void *data)
3121 {
3122         struct display *d = data;
3123
3124         if (strcmp(interface, "wl_compositor") == 0) {
3125                 d->compositor =
3126                         wl_display_bind(display, id, &wl_compositor_interface);
3127         } else if (strcmp(interface, "wl_output") == 0) {
3128                 display_add_output(d, id);
3129         } else if (strcmp(interface, "wl_seat") == 0) {
3130                 display_add_input(d, id);
3131         } else if (strcmp(interface, "wl_shell") == 0) {
3132                 d->shell = wl_display_bind(display, id, &wl_shell_interface);
3133         } else if (strcmp(interface, "wl_shm") == 0) {
3134                 d->shm = wl_display_bind(display, id, &wl_shm_interface);
3135         } else if (strcmp(interface, "wl_data_device_manager") == 0) {
3136                 d->data_device_manager =
3137                         wl_display_bind(display, id,
3138                                         &wl_data_device_manager_interface);
3139         } else if (strcmp(interface, "text_cursor_position") == 0) {
3140                 d->text_cursor_position =
3141                         wl_display_bind(display, id,
3142                                         &text_cursor_position_interface);
3143         }
3144 }
3145
3146 static void
3147 init_xkb(struct display *d)
3148 {
3149         d->xkb.names.rules = "evdev";
3150         d->xkb.names.model = "pc105";
3151         d->xkb.names.layout = (char *) option_xkb_layout;
3152         d->xkb.names.variant = (char *) option_xkb_variant;
3153         d->xkb.names.options = (char *) option_xkb_options;
3154
3155         d->xkb.context = xkb_context_new(0);
3156         if (!d->xkb.context) {
3157                 fprintf(stderr, "Failed to create XKB context\n");
3158                 exit(1);
3159         }
3160
3161         d->xkb.keymap = xkb_map_new_from_names(d->xkb.context, &d->xkb.names, 0);
3162         if (!d->xkb.keymap) {
3163                 fprintf(stderr, "Failed to compile keymap\n");
3164                 exit(1);
3165         }
3166
3167         d->xkb.state = xkb_state_new(d->xkb.keymap);
3168         if (!d->xkb.state) {
3169                 fprintf(stderr, "Failed to create XKB state\n");
3170                 exit(1);
3171         }
3172
3173         d->xkb.control_mask =
3174                 1 << xkb_map_mod_get_index(d->xkb.keymap, "Control");
3175         d->xkb.alt_mask =
3176                 1 << xkb_map_mod_get_index(d->xkb.keymap, "Mod1");
3177         d->xkb.shift_mask =
3178                 1 << xkb_map_mod_get_index(d->xkb.keymap, "Shift");
3179
3180 }
3181
3182 static void
3183 fini_xkb(struct display *display)
3184 {
3185         xkb_state_unref(display->xkb.state);
3186         xkb_map_unref(display->xkb.keymap);
3187         xkb_context_unref(display->xkb.context);
3188 }
3189
3190 #ifdef HAVE_CAIRO_EGL
3191 static int
3192 init_egl(struct display *d)
3193 {
3194         EGLint major, minor;
3195         EGLint n;
3196
3197 #ifdef USE_CAIRO_GLESV2
3198 #  define GL_BIT EGL_OPENGL_ES2_BIT
3199 #else
3200 #  define GL_BIT EGL_OPENGL_BIT
3201 #endif
3202
3203         static const EGLint argb_cfg_attribs[] = {
3204                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PIXMAP_BIT,
3205                 EGL_RED_SIZE, 1,
3206                 EGL_GREEN_SIZE, 1,
3207                 EGL_BLUE_SIZE, 1,
3208                 EGL_ALPHA_SIZE, 1,
3209                 EGL_DEPTH_SIZE, 1,
3210                 EGL_RENDERABLE_TYPE, GL_BIT,
3211                 EGL_NONE
3212         };
3213
3214 #ifdef USE_CAIRO_GLESV2
3215         static const EGLint context_attribs[] = {
3216                 EGL_CONTEXT_CLIENT_VERSION, 2,
3217                 EGL_NONE
3218         };
3219         EGLint api = EGL_OPENGL_ES_API;
3220 #else
3221         EGLint *context_attribs = NULL;
3222         EGLint api = EGL_OPENGL_API;
3223 #endif
3224
3225         d->dpy = eglGetDisplay(d->display);
3226         if (!eglInitialize(d->dpy, &major, &minor)) {
3227                 fprintf(stderr, "failed to initialize display\n");
3228                 return -1;
3229         }
3230
3231         if (!eglBindAPI(api)) {
3232                 fprintf(stderr, "failed to bind api EGL_OPENGL_API\n");
3233                 return -1;
3234         }
3235
3236         if (!eglChooseConfig(d->dpy, argb_cfg_attribs,
3237                              &d->argb_config, 1, &n) || n != 1) {
3238                 fprintf(stderr, "failed to choose argb config\n");
3239                 return -1;
3240         }
3241
3242         d->argb_ctx = eglCreateContext(d->dpy, d->argb_config,
3243                                        EGL_NO_CONTEXT, context_attribs);
3244         if (d->argb_ctx == NULL) {
3245                 fprintf(stderr, "failed to create context\n");
3246                 return -1;
3247         }
3248
3249         if (!eglMakeCurrent(d->dpy, NULL, NULL, d->argb_ctx)) {
3250                 fprintf(stderr, "failed to make context current\n");
3251                 return -1;
3252         }
3253
3254 #ifdef HAVE_CAIRO_EGL
3255         d->argb_device = cairo_egl_device_create(d->dpy, d->argb_ctx);
3256         if (cairo_device_status(d->argb_device) != CAIRO_STATUS_SUCCESS) {
3257                 fprintf(stderr, "failed to get cairo egl argb device\n");
3258                 return -1;
3259         }
3260 #endif
3261
3262         return 0;
3263 }
3264
3265 static void
3266 fini_egl(struct display *display)
3267 {
3268 #ifdef HAVE_CAIRO_EGL
3269         cairo_device_destroy(display->argb_device);
3270 #endif
3271
3272         eglMakeCurrent(display->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE,
3273                        EGL_NO_CONTEXT);
3274
3275         eglTerminate(display->dpy);
3276         eglReleaseThread();
3277 }
3278 #endif
3279
3280 static int
3281 event_mask_update(uint32_t mask, void *data)
3282 {
3283         struct display *d = data;
3284
3285         d->mask = mask;
3286
3287         return 0;
3288 }
3289
3290 static void
3291 handle_display_data(struct task *task, uint32_t events)
3292 {
3293         struct display *display =
3294                 container_of(task, struct display, display_task);
3295
3296         wl_display_iterate(display->display, display->mask);
3297 }
3298
3299 struct display *
3300 display_create(int argc, char *argv[])
3301 {
3302         struct display *d;
3303
3304         argc = parse_options(xkb_options,
3305                              ARRAY_LENGTH(xkb_options), argc, argv);
3306
3307         d = malloc(sizeof *d);
3308         if (d == NULL)
3309                 return NULL;
3310
3311         memset(d, 0, sizeof *d);
3312
3313         d->display = wl_display_connect(NULL);
3314         if (d->display == NULL) {
3315                 fprintf(stderr, "failed to create display: %m\n");
3316                 return NULL;
3317         }
3318
3319         d->epoll_fd = os_epoll_create_cloexec();
3320         d->display_fd = wl_display_get_fd(d->display, event_mask_update, d);
3321         d->display_task.run = handle_display_data;
3322         display_watch_fd(d, d->display_fd, EPOLLIN, &d->display_task);
3323
3324         wl_list_init(&d->deferred_list);
3325         wl_list_init(&d->input_list);
3326         wl_list_init(&d->output_list);
3327
3328         /* Set up listener so we'll catch all events. */
3329         wl_display_add_global_listener(d->display,
3330                                        display_handle_global, d);
3331
3332         /* Process connection events. */
3333         wl_display_iterate(d->display, WL_DISPLAY_READABLE);
3334 #ifdef HAVE_CAIRO_EGL
3335         if (init_egl(d) < 0)
3336                 return NULL;
3337 #endif
3338
3339         d->image_target_texture_2d =
3340                 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
3341         d->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
3342         d->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
3343
3344         create_cursors(d);
3345
3346         d->theme = theme_create();
3347
3348         wl_list_init(&d->window_list);
3349
3350         init_xkb(d);
3351
3352         return d;
3353 }
3354
3355 static void
3356 display_destroy_outputs(struct display *display)
3357 {
3358         struct output *tmp;
3359         struct output *output;
3360
3361         wl_list_for_each_safe(output, tmp, &display->output_list, link)
3362                 output_destroy(output);
3363 }
3364
3365 static void
3366 display_destroy_inputs(struct display *display)
3367 {
3368         struct input *tmp;
3369         struct input *input;
3370
3371         wl_list_for_each_safe(input, tmp, &display->input_list, link)
3372                 input_destroy(input);
3373 }
3374
3375 void
3376 display_destroy(struct display *display)
3377 {
3378         if (!wl_list_empty(&display->window_list))
3379                 fprintf(stderr, "toytoolkit warning: windows exist.\n");
3380
3381         if (!wl_list_empty(&display->deferred_list))
3382                 fprintf(stderr, "toytoolkit warning: deferred tasks exist.\n");
3383
3384         display_destroy_outputs(display);
3385         display_destroy_inputs(display);
3386
3387         fini_xkb(display);
3388
3389         theme_destroy(display->theme);
3390         destroy_cursors(display);
3391
3392 #ifdef HAVE_CAIRO_EGL
3393         fini_egl(display);
3394 #endif
3395
3396         if (display->shell)
3397                 wl_shell_destroy(display->shell);
3398
3399         if (display->shm)
3400                 wl_shm_destroy(display->shm);
3401
3402         if (display->data_device_manager)
3403                 wl_data_device_manager_destroy(display->data_device_manager);
3404
3405         wl_compositor_destroy(display->compositor);
3406
3407         close(display->epoll_fd);
3408
3409         wl_display_flush(display->display);
3410         wl_display_disconnect(display->display);
3411         free(display);
3412 }
3413
3414 void
3415 display_set_user_data(struct display *display, void *data)
3416 {
3417         display->user_data = data;
3418 }
3419
3420 void *
3421 display_get_user_data(struct display *display)
3422 {
3423         return display->user_data;
3424 }
3425
3426 struct wl_display *
3427 display_get_display(struct display *display)
3428 {
3429         return display->display;
3430 }
3431
3432 struct output *
3433 display_get_output(struct display *display)
3434 {
3435         return container_of(display->output_list.next, struct output, link);
3436 }
3437
3438 struct wl_compositor *
3439 display_get_compositor(struct display *display)
3440 {
3441         return display->compositor;
3442 }
3443
3444 uint32_t
3445 display_get_serial(struct display *display)
3446 {
3447         return display->serial;
3448 }
3449
3450 EGLDisplay
3451 display_get_egl_display(struct display *d)
3452 {
3453         return d->dpy;
3454 }
3455
3456 struct wl_data_source *
3457 display_create_data_source(struct display *display)
3458 {
3459         return wl_data_device_manager_create_data_source(display->data_device_manager);
3460 }
3461
3462 EGLConfig
3463 display_get_argb_egl_config(struct display *d)
3464 {
3465         return d->argb_config;
3466 }
3467
3468 struct wl_shell *
3469 display_get_shell(struct display *display)
3470 {
3471         return display->shell;
3472 }
3473
3474 int
3475 display_acquire_window_surface(struct display *display,
3476                                struct window *window,
3477                                EGLContext ctx)
3478 {
3479 #ifdef HAVE_CAIRO_EGL
3480         struct egl_window_surface_data *data;
3481         cairo_device_t *device;
3482
3483         if (!window->cairo_surface)
3484                 return -1;
3485         device = cairo_surface_get_device(window->cairo_surface);
3486         if (!device)
3487                 return -1;
3488
3489         if (!ctx) {
3490                 if (device == display->argb_device)
3491                         ctx = display->argb_ctx;
3492                 else
3493                         assert(0);
3494         }
3495
3496         data = cairo_surface_get_user_data(window->cairo_surface,
3497                                            &surface_data_key);
3498
3499         cairo_device_flush(device);
3500         cairo_device_acquire(device);
3501         if (!eglMakeCurrent(display->dpy, data->surf, data->surf, ctx))
3502                 fprintf(stderr, "failed to make surface current\n");
3503
3504         return 0;
3505 #else
3506         return -1;
3507 #endif
3508 }
3509
3510 void
3511 display_release_window_surface(struct display *display,
3512                                struct window *window)
3513 {
3514 #ifdef HAVE_CAIRO_EGL
3515         cairo_device_t *device;
3516
3517         device = cairo_surface_get_device(window->cairo_surface);
3518         if (!device)
3519                 return;
3520
3521         if (!eglMakeCurrent(display->dpy, NULL, NULL, display->argb_ctx))
3522                 fprintf(stderr, "failed to make context current\n");
3523         cairo_device_release(device);
3524 #endif
3525 }
3526
3527 void
3528 display_defer(struct display *display, struct task *task)
3529 {
3530         wl_list_insert(&display->deferred_list, &task->link);
3531 }
3532
3533 void
3534 display_watch_fd(struct display *display,
3535                  int fd, uint32_t events, struct task *task)
3536 {
3537         struct epoll_event ep;
3538
3539         ep.events = events;
3540         ep.data.ptr = task;
3541         epoll_ctl(display->epoll_fd, EPOLL_CTL_ADD, fd, &ep);
3542 }
3543
3544 void
3545 display_run(struct display *display)
3546 {
3547         struct task *task;
3548         struct epoll_event ep[16];
3549         int i, count;
3550
3551         display->running = 1;
3552         while (1) {
3553                 wl_display_flush(display->display);
3554
3555                 while (!wl_list_empty(&display->deferred_list)) {
3556                         task = container_of(display->deferred_list.next,
3557                                             struct task, link);
3558                         wl_list_remove(&task->link);
3559                         task->run(task, 0);
3560                 }
3561
3562                 if (!display->running)
3563                         break;
3564
3565                 wl_display_flush(display->display);
3566
3567                 count = epoll_wait(display->epoll_fd,
3568                                    ep, ARRAY_LENGTH(ep), -1);
3569                 for (i = 0; i < count; i++) {
3570                         task = ep[i].data.ptr;
3571                         task->run(task, ep[i].events);
3572                 }
3573         }
3574 }
3575
3576 void
3577 display_exit(struct display *display)
3578 {
3579         display->running = 0;
3580 }