libweston/compositor-wayland.c

   1 /*
   2  * Copyright © 2010-2011 Benjamin Franzke
   3  * Copyright © 2013 Jason Ekstrand
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  21  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  22  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <assert.h>
  30 #include <stddef.h>
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <sys/mman.h>
  38 #include <linux/input.h>
  39
  40 #include <wayland-client.h>
  41 #include <wayland-egl.h>
  42 #include <wayland-cursor.h>
  43
  44 #include "compositor.h"
  45 #include "compositor-wayland.h"
  46 #include "gl-renderer.h"
  47 #include "weston-egl-ext.h"
  48 #include "pixman-renderer.h"
  49 #include "shared/helpers.h"
  50 #include "shared/image-loader.h"
  51 #include "shared/os-compatibility.h"
  52 #include "shared/cairo-util.h"
  53 #include "fullscreen-shell-unstable-v1-client-protocol.h"
  54 #include "presentation-time-server-protocol.h"
  55 #include "linux-dmabuf.h"
  56 #include "windowed-output-api.h"
  57
  58 #define WINDOW_TITLE "Weston Compositor"
  59
  60 struct wayland_backend {
  61         struct weston_backend base;
  62         struct weston_compositor *compositor;
  63
  64         struct {
  65                 struct wl_display *wl_display;
  66                 struct wl_registry *registry;
  67                 struct wl_compositor *compositor;
  68                 struct wl_shell *shell;
  69                 struct zwp_fullscreen_shell_v1 *fshell;
  70                 struct wl_shm *shm;
  71
  72                 struct wl_list output_list;
  73
  74                 struct wl_event_source *wl_source;
  75                 uint32_t event_mask;
  76         } parent;
  77
  78         bool use_pixman;
  79         bool sprawl_across_outputs;
  80         bool fullscreen;
  81
  82         struct theme *theme;
  83         cairo_device_t *frame_device;
  84         struct wl_cursor_theme *cursor_theme;
  85         struct wl_cursor *cursor;
  86
  87         struct wl_list input_list;
  88 };
  89
  90 struct wayland_output {
  91         struct weston_output base;
  92
  93         struct {
  94                 bool draw_initial_frame;
  95                 struct wl_surface *surface;
  96
  97                 struct wl_output *output;
  98                 uint32_t global_id;
  99
 100                 struct wl_shell_surface *shell_surface;
 101                 int configure_width, configure_height;
 102         } parent;
 103
 104         int keyboard_count;
 105
 106         char *name;
 107         struct frame *frame;
 108
 109         struct {
 110                 struct wl_egl_window *egl_window;
 111                 struct {
 112                         cairo_surface_t *top;
 113                         cairo_surface_t *left;
 114                         cairo_surface_t *right;
 115                         cairo_surface_t *bottom;
 116                 } border;
 117         } gl;
 118
 119         struct {
 120                 struct wl_list buffers;
 121                 struct wl_list free_buffers;
 122         } shm;
 123
 124         struct weston_mode mode;
 125         uint32_t scale;
 126 };
 127
 128 struct wayland_parent_output {
 129         struct wayland_output *output;
 130         struct wl_list link;
 131
 132         struct wl_output *global;
 133         uint32_t id;
 134
 135         struct {
 136                 char *make;
 137                 char *model;
 138                 int32_t width, height;
 139                 uint32_t subpixel;
 140         } physical;
 141
 142         int32_t x, y;
 143         uint32_t transform;
 144         uint32_t scale;
 145
 146         struct wl_list mode_list;
 147         struct weston_mode *preferred_mode;
 148         struct weston_mode *current_mode;
 149 };
 150
 151 struct wayland_shm_buffer {
 152         struct wayland_output *output;
 153         struct wl_list link;
 154         struct wl_list free_link;
 155
 156         struct wl_buffer *buffer;
 157         void *data;
 158         size_t size;
 159         pixman_region32_t damage;
 160         int frame_damaged;
 161
 162         pixman_image_t *pm_image;
 163         cairo_surface_t *c_surface;
 164 };
 165
 166 struct wayland_input {
 167         struct weston_seat base;
 168         struct wayland_backend *backend;
 169         struct wl_list link;
 170
 171         struct {
 172                 struct wl_seat *seat;
 173                 struct wl_pointer *pointer;
 174                 struct wl_keyboard *keyboard;
 175                 struct wl_touch *touch;
 176
 177                 struct {
 178                         struct wl_surface *surface;
 179                         int32_t hx, hy;
 180                 } cursor;
 181         } parent;
 182
 183         enum weston_key_state_update keyboard_state_update;
 184         uint32_t key_serial;
 185         uint32_t enter_serial;
 186         uint32_t touch_points;
 187         bool touch_active;
 188         bool has_focus;
 189         int seat_version;
 190
 191         struct wayland_output *output;
 192         struct wayland_output *touch_focus;
 193         struct wayland_output *keyboard_focus;
 194
 195         struct weston_pointer_axis_event vert, horiz;
 196 };
 197
 198 struct gl_renderer_interface *gl_renderer;
 199
 200 static inline struct wayland_output *
 201 to_wayland_output(struct weston_output *base)
 202 {
 203         return container_of(base, struct wayland_output, base);
 204 }
 205
 206 static inline struct wayland_backend *
 207 to_wayland_backend(struct weston_compositor *base)
 208 {
 209         return container_of(base->backend, struct wayland_backend, base);
 210 }
 211
 212 static void
 213 wayland_shm_buffer_destroy(struct wayland_shm_buffer *buffer)
 214 {
 215         cairo_surface_destroy(buffer->c_surface);
 216         pixman_image_unref(buffer->pm_image);
 217
 218         wl_buffer_destroy(buffer->buffer);
 219         munmap(buffer->data, buffer->size);
 220
 221         pixman_region32_fini(&buffer->damage);
 222
 223         wl_list_remove(&buffer->link);
 224         wl_list_remove(&buffer->free_link);
 225         free(buffer);
 226 }
 227
 228 static void
 229 buffer_release(void *data, struct wl_buffer *buffer)
 230 {
 231         struct wayland_shm_buffer *sb = data;
 232
 233         if (sb->output) {
 234                 wl_list_insert(&sb->output->shm.free_buffers, &sb->free_link);
 235         } else {
 236                 wayland_shm_buffer_destroy(sb);
 237         }
 238 }
 239
 240 static const struct wl_buffer_listener buffer_listener = {
 241         buffer_release
 242 };
 243
 244 static struct wayland_shm_buffer *
 245 wayland_output_get_shm_buffer(struct wayland_output *output)
 246 {
 247         struct wayland_backend *b =
 248                 to_wayland_backend(output->base.compositor);
 249         struct wl_shm *shm = b->parent.shm;
 250         struct wayland_shm_buffer *sb;
 251
 252         struct wl_shm_pool *pool;
 253         int width, height, stride;
 254         int32_t fx, fy;
 255         int fd;
 256         unsigned char *data;
 257
 258         if (!wl_list_empty(&output->shm.free_buffers)) {
 259                 sb = container_of(output->shm.free_buffers.next,
 260                                   struct wayland_shm_buffer, free_link);
 261                 wl_list_remove(&sb->free_link);
 262                 wl_list_init(&sb->free_link);
 263
 264                 return sb;
 265         }
 266
 267         if (output->frame) {
 268                 width = frame_width(output->frame);
 269                 height = frame_height(output->frame);
 270         } else {
 271                 width = output->base.current_mode->width;
 272                 height = output->base.current_mode->height;
 273         }
 274
 275         stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
 276
 277         fd = os_create_anonymous_file(height * stride);
 278         if (fd < 0) {
 279                 weston_log("could not create an anonymous file buffer: %m\n");
 280                 return NULL;
 281         }
 282
 283         data = mmap(NULL, height * stride, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 284         if (data == MAP_FAILED) {
 285                 weston_log("could not mmap %d memory for data: %m\n", height * stride);
 286                 close(fd);
 287                 return NULL;
 288         }
 289
 290         sb = zalloc(sizeof *sb);
 291         if (sb == NULL) {
 292                 weston_log("could not zalloc %zu memory for sb: %m\n", sizeof *sb);
 293                 close(fd);
 294                 free(data);
 295                 return NULL;
 296         }
 297
 298         sb->output = output;
 299         wl_list_init(&sb->free_link);
 300         wl_list_insert(&output->shm.buffers, &sb->link);
 301
 302         pixman_region32_init_rect(&sb->damage, 0, 0,
 303                                   output->base.width, output->base.height);
 304         sb->frame_damaged = 1;
 305
 306         sb->data = data;
 307         sb->size = height * stride;
 308
 309         pool = wl_shm_create_pool(shm, fd, sb->size);
 310
 311         sb->buffer = wl_shm_pool_create_buffer(pool, 0,
 312                                                width, height,
 313                                                stride,
 314                                                WL_SHM_FORMAT_ARGB8888);
 315         wl_buffer_add_listener(sb->buffer, &buffer_listener, sb);
 316         wl_shm_pool_destroy(pool);
 317         close(fd);
 318
 319         memset(data, 0, sb->size);
 320
 321         sb->c_surface =
 322                 cairo_image_surface_create_for_data(data, CAIRO_FORMAT_ARGB32,
 323                                                     width, height, stride);
 324
 325         fx = 0;
 326         fy = 0;
 327         if (output->frame)
 328                 frame_interior(output->frame, &fx, &fy, 0, 0);
 329         sb->pm_image =
 330                 pixman_image_create_bits(PIXMAN_a8r8g8b8, width, height,
 331                                          (uint32_t *)(data + fy * stride) + fx,
 332                                          stride);
 333
 334         return sb;
 335 }
 336
 337 static void
 338 frame_done(void *data, struct wl_callback *callback, uint32_t time)
 339 {
 340         struct weston_output *output = data;
 341         struct timespec ts;
 342
 343         wl_callback_destroy(callback);
 344
 345         /* XXX: use the presentation extension for proper timings */
 346
 347         /*
 348          * This is the fallback case, where Presentation extension is not
 349          * available from the parent compositor. We do not know the base for
 350          * 'time', so we cannot feed it to finish_frame(). Do the only thing
 351          * we can, and pretend finish_frame time is when we process this
 352          * event.
 353          */
 354         weston_compositor_read_presentation_clock(output->compositor, &ts);
 355         weston_output_finish_frame(output, &ts, 0);
 356 }
 357
 358 static const struct wl_callback_listener frame_listener = {
 359         frame_done
 360 };
 361
 362 static void
 363 draw_initial_frame(struct wayland_output *output)
 364 {
 365         struct wayland_shm_buffer *sb;
 366
 367         sb = wayland_output_get_shm_buffer(output);
 368
 369         /* If we are rendering with GL, then orphan it so that it gets
 370          * destroyed immediately */
 371         if (output->gl.egl_window)
 372                 sb->output = NULL;
 373
 374         wl_surface_attach(output->parent.surface, sb->buffer, 0, 0);
 375         wl_surface_damage(output->parent.surface, 0, 0,
 376                           output->base.current_mode->width,
 377                           output->base.current_mode->height);
 378 }
 379
 380 static void
 381 wayland_output_update_gl_border(struct wayland_output *output)
 382 {
 383         int32_t ix, iy, iwidth, iheight, fwidth, fheight;
 384         cairo_t *cr;
 385
 386         if (!output->frame)
 387                 return;
 388         if (!(frame_status(output->frame) & FRAME_STATUS_REPAINT))
 389                 return;
 390
 391         fwidth = frame_width(output->frame);
 392         fheight = frame_height(output->frame);
 393         frame_interior(output->frame, &ix, &iy, &iwidth, &iheight);
 394
 395         if (!output->gl.border.top)
 396                 output->gl.border.top =
 397                         cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 398                                                    fwidth, iy);
 399         cr = cairo_create(output->gl.border.top);
 400         frame_repaint(output->frame, cr);
 401         cairo_destroy(cr);
 402         gl_renderer->output_set_border(&output->base, GL_RENDERER_BORDER_TOP,
 403                                        fwidth, iy,
 404                                        cairo_image_surface_get_stride(output->gl.border.top) / 4,
 405                                        cairo_image_surface_get_data(output->gl.border.top));
 406
 407
 408         if (!output->gl.border.left)
 409                 output->gl.border.left =
 410                         cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 411                                                    ix, 1);
 412         cr = cairo_create(output->gl.border.left);
 413         cairo_translate(cr, 0, -iy);
 414         frame_repaint(output->frame, cr);
 415         cairo_destroy(cr);
 416         gl_renderer->output_set_border(&output->base, GL_RENDERER_BORDER_LEFT,
 417                                        ix, 1,
 418                                        cairo_image_surface_get_stride(output->gl.border.left) / 4,
 419                                        cairo_image_surface_get_data(output->gl.border.left));
 420
 421
 422         if (!output->gl.border.right)
 423                 output->gl.border.right =
 424                         cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 425                                                    fwidth - (ix + iwidth), 1);
 426         cr = cairo_create(output->gl.border.right);
 427         cairo_translate(cr, -(iwidth + ix), -iy);
 428         frame_repaint(output->frame, cr);
 429         cairo_destroy(cr);
 430         gl_renderer->output_set_border(&output->base, GL_RENDERER_BORDER_RIGHT,
 431                                        fwidth - (ix + iwidth), 1,
 432                                        cairo_image_surface_get_stride(output->gl.border.right) / 4,
 433                                        cairo_image_surface_get_data(output->gl.border.right));
 434
 435
 436         if (!output->gl.border.bottom)
 437                 output->gl.border.bottom =
 438                         cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 439                                                    fwidth, fheight - (iy + iheight));
 440         cr = cairo_create(output->gl.border.bottom);
 441         cairo_translate(cr, 0, -(iy + iheight));
 442         frame_repaint(output->frame, cr);
 443         cairo_destroy(cr);
 444         gl_renderer->output_set_border(&output->base, GL_RENDERER_BORDER_BOTTOM,
 445                                        fwidth, fheight - (iy + iheight),
 446                                        cairo_image_surface_get_stride(output->gl.border.bottom) / 4,
 447                                        cairo_image_surface_get_data(output->gl.border.bottom));
 448 }
 449
 450 static void
 451 wayland_output_start_repaint_loop(struct weston_output *output_base)
 452 {
 453         struct wayland_output *output = to_wayland_output(output_base);
 454         struct wayland_backend *wb =
 455                 to_wayland_backend(output->base.compositor);
 456         struct wl_callback *callback;
 457
 458         /* If this is the initial frame, we need to attach a buffer so that
 459          * the compositor can map the surface and include it in its render
 460          * loop. If the surface doesn't end up in the render loop, the frame
 461          * callback won't be invoked. The buffer is transparent and of the
 462          * same size as the future real output buffer. */
 463         if (output->parent.draw_initial_frame) {
 464                 output->parent.draw_initial_frame = false;
 465
 466                 draw_initial_frame(output);
 467         }
 468
 469         callback = wl_surface_frame(output->parent.surface);
 470         wl_callback_add_listener(callback, &frame_listener, output);
 471         wl_surface_commit(output->parent.surface);
 472         wl_display_flush(wb->parent.wl_display);
 473 }
 474
 475 static int
 476 wayland_output_repaint_gl(struct weston_output *output_base,
 477                           pixman_region32_t *damage)
 478 {
 479         struct wayland_output *output = to_wayland_output(output_base);
 480         struct weston_compositor *ec = output->base.compositor;
 481         struct wl_callback *callback;
 482
 483         callback = wl_surface_frame(output->parent.surface);
 484         wl_callback_add_listener(callback, &frame_listener, output);
 485
 486         wayland_output_update_gl_border(output);
 487
 488         ec->renderer->repaint_output(&output->base, damage);
 489
 490         pixman_region32_subtract(&ec->primary_plane.damage,
 491                                  &ec->primary_plane.damage, damage);
 492         return 0;
 493 }
 494
 495 static void
 496 wayland_output_update_shm_border(struct wayland_shm_buffer *buffer)
 497 {
 498         int32_t ix, iy, iwidth, iheight, fwidth, fheight;
 499         cairo_t *cr;
 500
 501         if (!buffer->output->frame || !buffer->frame_damaged)
 502                 return;
 503
 504         cr = cairo_create(buffer->c_surface);
 505
 506         frame_interior(buffer->output->frame, &ix, &iy, &iwidth, &iheight);
 507         fwidth = frame_width(buffer->output->frame);
 508         fheight = frame_height(buffer->output->frame);
 509
 510         /* Set the clip so we don't unnecisaraly damage the surface */
 511         cairo_move_to(cr, ix, iy);
 512         cairo_rel_line_to(cr, iwidth, 0);
 513         cairo_rel_line_to(cr, 0, iheight);
 514         cairo_rel_line_to(cr, -iwidth, 0);
 515         cairo_line_to(cr, ix, iy);
 516         cairo_line_to(cr, 0, iy);
 517         cairo_line_to(cr, 0, fheight);
 518         cairo_line_to(cr, fwidth, fheight);
 519         cairo_line_to(cr, fwidth, 0);
 520         cairo_line_to(cr, 0, 0);
 521         cairo_line_to(cr, 0, iy);
 522         cairo_close_path(cr);
 523         cairo_clip(cr);
 524
 525         /* Draw using a pattern so that the final result gets clipped */
 526         cairo_push_group(cr);
 527         frame_repaint(buffer->output->frame, cr);
 528         cairo_pop_group_to_source(cr);
 529         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
 530         cairo_paint(cr);
 531
 532         cairo_destroy(cr);
 533 }
 534
 535 static void
 536 wayland_shm_buffer_attach(struct wayland_shm_buffer *sb)
 537 {
 538         pixman_region32_t damage;
 539         pixman_box32_t *rects;
 540         int32_t ix, iy, iwidth, iheight, fwidth, fheight;
 541         int i, n;
 542
 543         pixman_region32_init(&damage);
 544         weston_transformed_region(sb->output->base.width,
 545                                   sb->output->base.height,
 546                                   sb->output->base.transform,
 547                                   sb->output->base.current_scale,
 548                                   &sb->damage, &damage);
 549
 550         if (sb->output->frame) {
 551                 frame_interior(sb->output->frame, &ix, &iy, &iwidth, &iheight);
 552                 fwidth = frame_width(sb->output->frame);
 553                 fheight = frame_height(sb->output->frame);
 554
 555                 pixman_region32_translate(&damage, ix, iy);
 556
 557                 if (sb->frame_damaged) {
 558                         pixman_region32_union_rect(&damage, &damage,
 559                                                    0, 0, fwidth, iy);
 560                         pixman_region32_union_rect(&damage, &damage,
 561                                                    0, iy, ix, iheight);
 562                         pixman_region32_union_rect(&damage, &damage,
 563                                                    ix + iwidth, iy,
 564                                                    fwidth - (ix + iwidth), iheight);
 565                         pixman_region32_union_rect(&damage, &damage,
 566                                                    0, iy + iheight,
 567                                                    fwidth, fheight - (iy + iheight));
 568                 }
 569         }
 570
 571         rects = pixman_region32_rectangles(&damage, &n);
 572         wl_surface_attach(sb->output->parent.surface, sb->buffer, 0, 0);
 573         for (i = 0; i < n; ++i)
 574                 wl_surface_damage(sb->output->parent.surface, rects[i].x1,
 575                                   rects[i].y1, rects[i].x2 - rects[i].x1,
 576                                   rects[i].y2 - rects[i].y1);
 577
 578         if (sb->output->frame)
 579                 pixman_region32_fini(&damage);
 580 }
 581
 582 static int
 583 wayland_output_repaint_pixman(struct weston_output *output_base,
 584                               pixman_region32_t *damage)
 585 {
 586         struct wayland_output *output = to_wayland_output(output_base);
 587         struct wayland_backend *b =
 588                 to_wayland_backend(output->base.compositor);
 589         struct wl_callback *callback;
 590         struct wayland_shm_buffer *sb;
 591
 592         if (output->frame) {
 593                 if (frame_status(output->frame) & FRAME_STATUS_REPAINT)
 594                         wl_list_for_each(sb, &output->shm.buffers, link)
 595                                 sb->frame_damaged = 1;
 596         }
 597
 598         wl_list_for_each(sb, &output->shm.buffers, link)
 599                 pixman_region32_union(&sb->damage, &sb->damage, damage);
 600
 601         sb = wayland_output_get_shm_buffer(output);
 602
 603         wayland_output_update_shm_border(sb);
 604         pixman_renderer_output_set_buffer(output_base, sb->pm_image);
 605         b->compositor->renderer->repaint_output(output_base, &sb->damage);
 606
 607         wayland_shm_buffer_attach(sb);
 608
 609         callback = wl_surface_frame(output->parent.surface);
 610         wl_callback_add_listener(callback, &frame_listener, output);
 611         wl_surface_commit(output->parent.surface);
 612         wl_display_flush(b->parent.wl_display);
 613
 614         pixman_region32_fini(&sb->damage);
 615         pixman_region32_init(&sb->damage);
 616         sb->frame_damaged = 0;
 617
 618         pixman_region32_subtract(&b->compositor->primary_plane.damage,
 619                                  &b->compositor->primary_plane.damage, damage);
 620         return 0;
 621 }
 622
 623 static void
 624 wayland_backend_destroy_output_surface(struct wayland_output *output)
 625 {
 626         if (output->parent.shell_surface)
 627                 wl_shell_surface_destroy(output->parent.shell_surface);
 628
 629         wl_surface_destroy(output->parent.surface);
 630 }
 631
 632 static int
 633 wayland_output_disable(struct weston_output *base)
 634 {
 635         struct wayland_output *output = to_wayland_output(base);
 636         struct wayland_backend *b = to_wayland_backend(base->compositor);
 637
 638         if (!output->base.enabled)
 639                 return 0;
 640
 641         if (b->use_pixman) {
 642                 pixman_renderer_output_destroy(&output->base);
 643         } else {
 644                 gl_renderer->output_destroy(&output->base);
 645                 wl_egl_window_destroy(output->gl.egl_window);
 646         }
 647
 648         /* Done on output->enable when not fullscreen, otherwise
 649          * done in output_create, to get the proper mode */
 650         if (!b->fullscreen)
 651                 wayland_backend_destroy_output_surface(output);
 652
 653         if (output->frame)
 654                 frame_destroy(output->frame);
 655
 656         cairo_surface_destroy(output->gl.border.top);
 657         cairo_surface_destroy(output->gl.border.left);
 658         cairo_surface_destroy(output->gl.border.right);
 659         cairo_surface_destroy(output->gl.border.bottom);
 660
 661         return 0;
 662 }
 663
 664 static void
 665 wayland_output_destroy(struct weston_output *base)
 666 {
 667         struct wayland_output *output = to_wayland_output(base);
 668         struct wayland_backend *b = to_wayland_backend(base->compositor);
 669
 670         wayland_output_disable(&output->base);
 671
 672         if (b->fullscreen)
 673                 wayland_backend_destroy_output_surface(output);
 674
 675         weston_output_destroy(&output->base);
 676
 677         free(output);
 678 }
 679
 680 static const struct wl_shell_surface_listener shell_surface_listener;
 681
 682 static int
 683 wayland_output_init_gl_renderer(struct wayland_output *output)
 684 {
 685         int32_t fwidth = 0, fheight = 0;
 686
 687         if (output->frame) {
 688                 fwidth = frame_width(output->frame);
 689                 fheight = frame_height(output->frame);
 690         } else {
 691                 fwidth = output->base.current_mode->width;
 692                 fheight = output->base.current_mode->height;
 693         }
 694
 695         output->gl.egl_window =
 696                 wl_egl_window_create(output->parent.surface,
 697                                      fwidth, fheight);
 698         if (!output->gl.egl_window) {
 699                 weston_log("failure to create wl_egl_window\n");
 700                 return -1;
 701         }
 702
 703         if (gl_renderer->output_create(&output->base,
 704                                        output->gl.egl_window,
 705                                        output->gl.egl_window,
 706                                        gl_renderer->alpha_attribs,
 707                                        NULL,
 708                                        0) < 0)
 709                 goto cleanup_window;
 710
 711         return 0;
 712
 713 cleanup_window:
 714         wl_egl_window_destroy(output->gl.egl_window);
 715         return -1;
 716 }
 717
 718 static int
 719 wayland_output_init_pixman_renderer(struct wayland_output *output)
 720 {
 721         return pixman_renderer_output_create(&output->base);
 722 }
 723
 724 static void
 725 wayland_output_resize_surface(struct wayland_output *output)
 726 {
 727         struct wayland_backend *b =
 728                 to_wayland_backend(output->base.compositor);
 729         struct wayland_shm_buffer *buffer, *next;
 730         int32_t ix, iy, iwidth, iheight;
 731         int32_t width, height;
 732         struct wl_region *region;
 733
 734         width = output->base.current_mode->width;
 735         height = output->base.current_mode->height;
 736
 737         if (output->frame) {
 738                 frame_resize_inside(output->frame, width, height);
 739
 740                 frame_input_rect(output->frame, &ix, &iy, &iwidth, &iheight);
 741                 region = wl_compositor_create_region(b->parent.compositor);
 742                 wl_region_add(region, ix, iy, iwidth, iheight);
 743                 wl_surface_set_input_region(output->parent.surface, region);
 744                 wl_region_destroy(region);
 745
 746                 frame_opaque_rect(output->frame, &ix, &iy, &iwidth, &iheight);
 747                 region = wl_compositor_create_region(b->parent.compositor);
 748                 wl_region_add(region, ix, iy, iwidth, iheight);
 749                 wl_surface_set_opaque_region(output->parent.surface, region);
 750                 wl_region_destroy(region);
 751
 752                 width = frame_width(output->frame);
 753                 height = frame_height(output->frame);
 754         } else {
 755                 region = wl_compositor_create_region(b->parent.compositor);
 756                 wl_region_add(region, 0, 0, width, height);
 757                 wl_surface_set_input_region(output->parent.surface, region);
 758                 wl_region_destroy(region);
 759
 760                 region = wl_compositor_create_region(b->parent.compositor);
 761                 wl_region_add(region, 0, 0, width, height);
 762                 wl_surface_set_opaque_region(output->parent.surface, region);
 763                 wl_region_destroy(region);
 764         }
 765
 766         if (output->gl.egl_window) {
 767                 wl_egl_window_resize(output->gl.egl_window,
 768                                      width, height, 0, 0);
 769
 770                 /* These will need to be re-created due to the resize */
 771                 gl_renderer->output_set_border(&output->base,
 772                                                GL_RENDERER_BORDER_TOP,
 773                                                0, 0, 0, NULL);
 774                 cairo_surface_destroy(output->gl.border.top);
 775                 output->gl.border.top = NULL;
 776                 gl_renderer->output_set_border(&output->base,
 777                                                GL_RENDERER_BORDER_LEFT,
 778                                                0, 0, 0, NULL);
 779                 cairo_surface_destroy(output->gl.border.left);
 780                 output->gl.border.left = NULL;
 781                 gl_renderer->output_set_border(&output->base,
 782                                                GL_RENDERER_BORDER_RIGHT,
 783                                                0, 0, 0, NULL);
 784                 cairo_surface_destroy(output->gl.border.right);
 785                 output->gl.border.right = NULL;
 786                 gl_renderer->output_set_border(&output->base,
 787                                                GL_RENDERER_BORDER_BOTTOM,
 788                                                0, 0, 0, NULL);
 789                 cairo_surface_destroy(output->gl.border.bottom);
 790                 output->gl.border.bottom = NULL;
 791         }
 792
 793         /* Throw away any remaining SHM buffers */
 794         wl_list_for_each_safe(buffer, next, &output->shm.free_buffers, free_link)
 795                 wayland_shm_buffer_destroy(buffer);
 796         /* These will get thrown away when they get released */
 797         wl_list_for_each(buffer, &output->shm.buffers, link)
 798                 buffer->output = NULL;
 799 }
 800
 801 static int
 802 wayland_output_set_windowed(struct wayland_output *output)
 803 {
 804         struct wayland_backend *b =
 805                 to_wayland_backend(output->base.compositor);
 806         int tlen;
 807         char *title;
 808
 809         if (output->frame)
 810                 return 0;
 811
 812         if (output->name) {
 813                 tlen = strlen(output->name) + strlen(WINDOW_TITLE " - ");
 814                 title = malloc(tlen + 1);
 815                 if (!title)
 816                         return -1;
 817
 818                 snprintf(title, tlen + 1, WINDOW_TITLE " - %s", output->name);
 819         } else {
 820                 title = strdup(WINDOW_TITLE);
 821         }
 822
 823         if (!b->theme) {
 824                 b->theme = theme_create();
 825                 if (!b->theme) {
 826                         free(title);
 827                         return -1;
 828                 }
 829         }
 830         output->frame = frame_create(b->theme, 100, 100,
 831                                      FRAME_BUTTON_CLOSE, title);
 832         free(title);
 833         if (!output->frame)
 834                 return -1;
 835
 836         if (output->keyboard_count)
 837                 frame_set_flag(output->frame, FRAME_FLAG_ACTIVE);
 838
 839         wayland_output_resize_surface(output);
 840
 841         wl_shell_surface_set_toplevel(output->parent.shell_surface);
 842
 843         return 0;
 844 }
 845
 846 static void
 847 wayland_output_set_fullscreen(struct wayland_output *output,
 848                               enum wl_shell_surface_fullscreen_method method,
 849                               uint32_t framerate, struct wl_output *target)
 850 {
 851         struct wayland_backend *b =
 852                 to_wayland_backend(output->base.compositor);
 853
 854         if (output->frame) {
 855                 frame_destroy(output->frame);
 856                 output->frame = NULL;
 857         }
 858
 859         wayland_output_resize_surface(output);
 860
 861         if (output->parent.shell_surface) {
 862                 wl_shell_surface_set_fullscreen(output->parent.shell_surface,
 863                                                 method, framerate, target);
 864         } else if (b->parent.fshell) {
 865                 zwp_fullscreen_shell_v1_present_surface(b->parent.fshell,
 866                                                         output->parent.surface,
 867                                                         method, target);
 868         }
 869 }
 870
 871 static struct weston_mode *
 872 wayland_output_choose_mode(struct wayland_output *output,
 873                            struct weston_mode *ref_mode)
 874 {
 875         struct weston_mode *mode;
 876
 877         /* First look for an exact match */
 878         wl_list_for_each(mode, &output->base.mode_list, link)
 879                 if (mode->width == ref_mode->width &&
 880                     mode->height == ref_mode->height &&
 881                     mode->refresh == ref_mode->refresh)
 882                         return mode;
 883
 884         /* If we can't find an exact match, ignore refresh and try again */
 885         wl_list_for_each(mode, &output->base.mode_list, link)
 886                 if (mode->width == ref_mode->width &&
 887                     mode->height == ref_mode->height)
 888                         return mode;
 889
 890         /* Yeah, we failed */
 891         return NULL;
 892 }
 893
 894 enum mode_status {
 895         MODE_STATUS_UNKNOWN,
 896         MODE_STATUS_SUCCESS,
 897         MODE_STATUS_FAIL,
 898         MODE_STATUS_CANCEL,
 899 };
 900
 901 static void
 902 mode_feedback_successful(void *data,
 903                          struct zwp_fullscreen_shell_mode_feedback_v1 *fb)
 904 {
 905         enum mode_status *value = data;
 906
 907         printf("Mode switch successful\n");
 908
 909         *value = MODE_STATUS_SUCCESS;
 910 }
 911
 912 static void
 913 mode_feedback_failed(void *data, struct zwp_fullscreen_shell_mode_feedback_v1 *fb)
 914 {
 915         enum mode_status *value = data;
 916
 917         printf("Mode switch failed\n");
 918
 919         *value = MODE_STATUS_FAIL;
 920 }
 921
 922 static void
 923 mode_feedback_cancelled(void *data, struct zwp_fullscreen_shell_mode_feedback_v1 *fb)
 924 {
 925         enum mode_status *value = data;
 926
 927         printf("Mode switch cancelled\n");
 928
 929         *value = MODE_STATUS_CANCEL;
 930 }
 931
 932 struct zwp_fullscreen_shell_mode_feedback_v1_listener mode_feedback_listener = {
 933         mode_feedback_successful,
 934         mode_feedback_failed,
 935         mode_feedback_cancelled,
 936 };
 937
 938 static int
 939 wayland_output_switch_mode(struct weston_output *output_base,
 940                            struct weston_mode *mode)
 941 {
 942         struct wayland_output *output = to_wayland_output(output_base);
 943         struct wayland_backend *b;
 944         struct wl_surface *old_surface;
 945         struct weston_mode *old_mode;
 946         struct zwp_fullscreen_shell_mode_feedback_v1 *mode_feedback;
 947         enum mode_status mode_status;
 948         int ret = 0;
 949
 950         if (output_base == NULL) {
 951                 weston_log("output is NULL.\n");
 952                 return -1;
 953         }
 954
 955         if (mode == NULL) {
 956                 weston_log("mode is NULL.\n");
 957                 return -1;
 958         }
 959
 960         b = to_wayland_backend(output_base->compositor);
 961
 962         if (output->parent.shell_surface || !b->parent.fshell)
 963                 return -1;
 964
 965         mode = wayland_output_choose_mode(output, mode);
 966         if (mode == NULL)
 967                 return -1;
 968
 969         if (output->base.current_mode == mode)
 970                 return 0;
 971
 972         old_mode = output->base.current_mode;
 973         old_surface = output->parent.surface;
 974         output->base.current_mode = mode;
 975         output->parent.surface =
 976                 wl_compositor_create_surface(b->parent.compositor);
 977         wl_surface_set_user_data(output->parent.surface, output);
 978
 979         /* Blow the old buffers because we changed size/surfaces */
 980         wayland_output_resize_surface(output);
 981
 982         mode_feedback =
 983                 zwp_fullscreen_shell_v1_present_surface_for_mode(b->parent.fshell,
 984                                                                  output->parent.surface,
 985                                                                  output->parent.output,
 986                                                                  mode->refresh);
 987         zwp_fullscreen_shell_mode_feedback_v1_add_listener(mode_feedback,
 988                                                            &mode_feedback_listener,
 989                                                            &mode_status);
 990
 991         /* This should kick-start things again */
 992         output->parent.draw_initial_frame = true;
 993         wayland_output_start_repaint_loop(&output->base);
 994
 995         mode_status = MODE_STATUS_UNKNOWN;
 996         while (mode_status == MODE_STATUS_UNKNOWN && ret >= 0)
 997                 ret = wl_display_dispatch(b->parent.wl_display);
 998
 999         zwp_fullscreen_shell_mode_feedback_v1_destroy(mode_feedback);
1000
1001         if (mode_status == MODE_STATUS_FAIL) {
1002                 output->base.current_mode = old_mode;
1003                 wl_surface_destroy(output->parent.surface);
1004                 output->parent.surface = old_surface;
1005                 wayland_output_resize_surface(output);
1006
1007                 return -1;
1008         }
1009
1010         old_mode->flags &= ~WL_OUTPUT_MODE_CURRENT;
1011         output->base.current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
1012
1013         if (b->use_pixman) {
1014                 pixman_renderer_output_destroy(output_base);
1015                 if (wayland_output_init_pixman_renderer(output) < 0)
1016                         goto err_output;
1017         } else {
1018                 gl_renderer->output_destroy(output_base);
1019                 wl_egl_window_destroy(output->gl.egl_window);
1020                 if (wayland_output_init_gl_renderer(output) < 0)
1021                         goto err_output;
1022         }
1023         wl_surface_destroy(old_surface);
1024
1025         weston_output_schedule_repaint(&output->base);
1026
1027         return 0;
1028
1029 err_output:
1030         /* XXX */
1031         return -1;
1032 }
1033
1034 static int
1035 wayland_backend_create_output_surface(struct wayland_output *output)
1036 {
1037         struct wayland_backend *b = to_wayland_backend(output->base.compositor);
1038
1039         output->parent.surface =
1040                 wl_compositor_create_surface(b->parent.compositor);
1041         if (!output->parent.surface)
1042                 return -1;
1043
1044         wl_surface_set_user_data(output->parent.surface, output);
1045
1046         output->parent.draw_initial_frame = true;
1047
1048         if (b->parent.shell) {
1049                 output->parent.shell_surface =
1050                         wl_shell_get_shell_surface(b->parent.shell,
1051                                                    output->parent.surface);
1052                 if (!output->parent.shell_surface) {
1053                         wl_surface_destroy(output->parent.surface);
1054                         return -1;
1055                 }
1056
1057                 wl_shell_surface_add_listener(output->parent.shell_surface,
1058                                               &shell_surface_listener, output);
1059         }
1060
1061         return 0;
1062 }
1063
1064 static int
1065 wayland_output_enable(struct weston_output *base)
1066 {
1067         struct wayland_output *output = to_wayland_output(base);
1068         struct wayland_backend *b = to_wayland_backend(base->compositor);
1069         int ret = 0;
1070
1071
1072         weston_log("Creating %dx%d wayland output at (%d, %d)\n",
1073                    output->base.current_mode->width,
1074                    output->base.current_mode->height,
1075                    output->base.x, output->base.y);
1076
1077         /* If fullscreen was specified, this needs to be done before
1078          * enable to get the proper mode */
1079         if (!b->fullscreen)
1080                 ret = wayland_backend_create_output_surface(output);
1081
1082         if (ret < 0)
1083                 return -1;
1084
1085         wl_list_init(&output->shm.buffers);
1086         wl_list_init(&output->shm.free_buffers);
1087
1088         if (b->use_pixman) {
1089                 if (wayland_output_init_pixman_renderer(output) < 0)
1090                         goto err_output;
1091         } else {
1092                 if (wayland_output_init_gl_renderer(output) < 0)
1093                         goto err_output;
1094         }
1095
1096         if (b->sprawl_across_outputs) {
1097                 wayland_output_set_fullscreen(output,
1098                                               WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER,
1099                                               output->mode.refresh, output->parent.output);
1100
1101                 if (output->parent.shell_surface) {
1102                         wl_shell_surface_set_fullscreen(output->parent.shell_surface,
1103                                                         WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER,
1104                                                         output->mode.refresh, output->parent.output);
1105                 } else if (b->parent.fshell) {
1106                         zwp_fullscreen_shell_v1_present_surface(b->parent.fshell,
1107                                                                 output->parent.surface,
1108                                                                 ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_CENTER,
1109                                                                 output->parent.output);
1110                         zwp_fullscreen_shell_mode_feedback_v1_destroy(
1111                                 zwp_fullscreen_shell_v1_present_surface_for_mode(b->parent.fshell,
1112                                                                                  output->parent.surface,
1113                                                                                  output->parent.output,
1114                                                                                  output->mode.refresh));
1115                 }
1116         } else if (b->fullscreen) {
1117                 wayland_output_set_fullscreen(output, 0, 0, NULL);
1118         } else {
1119                 wayland_output_set_windowed(output);
1120         }
1121
1122         return 0;
1123
1124 err_output:
1125         if (!b->fullscreen)
1126                 wayland_backend_destroy_output_surface(output);
1127
1128         return -1;
1129 }
1130
1131 static struct wayland_output *
1132 wayland_output_create_common(void)
1133 {
1134         struct wayland_output *output;
1135
1136         output = zalloc(sizeof *output);
1137         if (output == NULL) {
1138                 perror("zalloc");
1139                 return NULL;
1140         }
1141
1142         output->base.destroy = wayland_output_destroy;
1143         output->base.disable = wayland_output_disable;
1144         output->base.enable = wayland_output_enable;
1145
1146         return output;
1147 }
1148
1149 static int
1150 wayland_output_create(struct weston_compositor *compositor, const char *name)
1151 {
1152         struct wayland_output *output = wayland_output_create_common();
1153
1154         /* name can't be NULL. */
1155         assert(name);
1156
1157         output->base.name = strdup(name);
1158
1159         weston_output_init(&output->base, compositor);
1160         weston_compositor_add_pending_output(&output->base, compositor);
1161
1162         return 0;
1163 }
1164
1165 static int
1166 wayland_output_set_size(struct weston_output *base, int width, int height)
1167 {
1168         struct wayland_output *output = to_wayland_output(base);
1169         struct wayland_backend *b = to_wayland_backend(base->compositor);
1170         int output_width, output_height;
1171
1172         /* We can only be called once. */
1173         assert(!output->base.current_mode);
1174
1175         /* Make sure we have scale set. */
1176         assert(output->base.scale);
1177
1178         if (width < 1) {
1179                 weston_log("Invalid width \"%d\" for output %s\n",
1180                            width, output->base.name);
1181                 return -1;
1182         }
1183
1184         if (height < 1) {
1185                 weston_log("Invalid height \"%d\" for output %s\n",
1186                            height, output->base.name);
1187                 return -1;
1188         }
1189
1190         output_width = width * output->base.scale;
1191         output_height = height * output->base.scale;
1192
1193         output->mode.flags =
1194                 WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
1195
1196         output->mode.width = output_width;
1197         output->mode.height = output_height;
1198         output->mode.refresh = 60000;
1199         output->scale = output->base.scale;
1200         wl_list_init(&output->base.mode_list);
1201         wl_list_insert(&output->base.mode_list, &output->mode.link);
1202
1203         output->base.current_mode = &output->mode;
1204         output->base.make = "wayland";
1205         output->base.model = "none";
1206
1207         /* XXX: Calculate proper size. */
1208         output->base.mm_width = width;
1209         output->base.mm_height = height;
1210
1211         if (b->use_pixman)
1212                 output->base.repaint = wayland_output_repaint_pixman;
1213         else
1214                 output->base.repaint = wayland_output_repaint_gl;
1215
1216         output->base.start_repaint_loop = wayland_output_start_repaint_loop;
1217         output->base.assign_planes = NULL;
1218         output->base.set_backlight = NULL;
1219         output->base.set_dpms = NULL;
1220         output->base.switch_mode = wayland_output_switch_mode;
1221
1222         return 0;
1223 }
1224
1225 static int
1226 wayland_output_create_for_parent_output(struct wayland_backend *b,
1227                                         struct wayland_parent_output *poutput)
1228 {
1229         struct wayland_output *output = wayland_output_create_common();
1230         struct weston_mode *mode;
1231
1232         output->base.name = strdup("wlparent");
1233
1234         if (poutput->current_mode) {
1235                 mode = poutput->current_mode;
1236         } else if (poutput->preferred_mode) {
1237                 mode = poutput->preferred_mode;
1238         } else if (!wl_list_empty(&poutput->mode_list)) {
1239                 mode = container_of(poutput->mode_list.next,
1240                                     struct weston_mode, link);
1241         } else {
1242                 weston_log("No valid modes found. Skipping output.\n");
1243                 goto out;
1244         }
1245
1246         weston_output_init(&output->base, b->compositor);
1247
1248         output->base.scale = 1;
1249         output->base.transform = WL_OUTPUT_TRANSFORM_NORMAL;
1250
1251         if (wayland_output_set_size(&output->base, mode->width, mode->height) < 0)
1252                 goto out;
1253
1254         output->mode = *mode;
1255         output->parent.output = poutput->global;
1256
1257         output->base.make = poutput->physical.make;
1258         output->base.model = poutput->physical.model;
1259
1260         /* XXX: Clear previously added values */
1261         wl_list_init(&output->base.mode_list);
1262         wl_list_insert_list(&output->base.mode_list, &poutput->mode_list);
1263         wl_list_init(&poutput->mode_list);
1264
1265         weston_compositor_add_pending_output(&output->base, b->compositor);
1266
1267         return 0;
1268
1269 out:
1270         free(output->name);
1271         free(output);
1272
1273         return -1;
1274 }
1275
1276 static int
1277 wayland_output_create_fullscreen(struct wayland_backend *b)
1278 {
1279         struct wayland_output *output = wayland_output_create_common();
1280         int width = 0, height = 0;
1281
1282         output->base.name = strdup("wayland-fullscreen");
1283
1284         weston_output_init(&output->base, b->compositor);
1285
1286         output->base.scale = 1;
1287         output->base.transform = WL_OUTPUT_TRANSFORM_NORMAL;
1288
1289         if (wayland_backend_create_output_surface(output) < 0)
1290                 goto err_surface;
1291
1292         /* What should size be set if conditional is false? */
1293         if (b->parent.shell) {
1294                 wl_shell_surface_set_fullscreen(output->parent.shell_surface,
1295                                                 0, 0, NULL);
1296                 wl_display_roundtrip(b->parent.wl_display);
1297
1298                 width = output->parent.configure_width;
1299                 height = output->parent.configure_height;
1300         }
1301
1302         if (wayland_output_set_size(&output->base, width, height) < 0)
1303                 goto err_set_size;
1304
1305         weston_compositor_add_pending_output(&output->base, b->compositor);
1306
1307         return 0;
1308
1309 err_set_size:
1310         wayland_backend_destroy_output_surface(output);
1311 err_surface:
1312         free(output->name);
1313         free(output);
1314
1315         return -1;
1316 }
1317
1318 static void
1319 shell_surface_ping(void *data, struct wl_shell_surface *shell_surface,
1320                    uint32_t serial)
1321 {
1322         wl_shell_surface_pong(shell_surface, serial);
1323 }
1324
1325 static void
1326 shell_surface_configure(void *data, struct wl_shell_surface *shell_surface,
1327                         uint32_t edges, int32_t width, int32_t height)
1328 {
1329         struct wayland_output *output = data;
1330
1331         output->parent.configure_width = width;
1332         output->parent.configure_height = height;
1333
1334         /* FIXME: implement resizing */
1335 }
1336
1337 static void
1338 shell_surface_popup_done(void *data, struct wl_shell_surface *shell_surface)
1339 {
1340 }
1341
1342 static const struct wl_shell_surface_listener shell_surface_listener = {
1343         shell_surface_ping,
1344         shell_surface_configure,
1345         shell_surface_popup_done
1346 };
1347
1348 /* Events received from the wayland-server this compositor is client of: */
1349
1350 /* parent input interface */
1351 static void
1352 input_set_cursor(struct wayland_input *input)
1353 {
1354
1355         struct wl_buffer *buffer;
1356         struct wl_cursor_image *image;
1357
1358         if (!input->backend->cursor)
1359                 return; /* Couldn't load the cursor. Can't set it */
1360
1361         image = input->backend->cursor->images[0];
1362         buffer = wl_cursor_image_get_buffer(image);
1363         if (!buffer)
1364                 return;
1365
1366         wl_pointer_set_cursor(input->parent.pointer, input->enter_serial,
1367                               input->parent.cursor.surface,
1368                               image->hotspot_x, image->hotspot_y);
1369
1370         wl_surface_attach(input->parent.cursor.surface, buffer, 0, 0);
1371         wl_surface_damage(input->parent.cursor.surface, 0, 0,
1372                           image->width, image->height);
1373         wl_surface_commit(input->parent.cursor.surface);
1374 }
1375
1376 static void
1377 input_handle_pointer_enter(void *data, struct wl_pointer *pointer,
1378                            uint32_t serial, struct wl_surface *surface,
1379                            wl_fixed_t fixed_x, wl_fixed_t fixed_y)
1380 {
1381         struct wayland_input *input = data;
1382         int32_t fx, fy;
1383         enum theme_location location;
1384         double x, y;
1385
1386         x = wl_fixed_to_double(fixed_x);
1387         y = wl_fixed_to_double(fixed_y);
1388
1389         /* XXX: If we get a modifier event immediately before the focus,
1390          *      we should try to keep the same serial. */
1391         input->enter_serial = serial;
1392         input->output = wl_surface_get_user_data(surface);
1393
1394         if (input->output->frame) {
1395                 location = frame_pointer_enter(input->output->frame, input,
1396                                                x, y);
1397                 frame_interior(input->output->frame, &fx, &fy, NULL, NULL);
1398                 x -= fx;
1399                 y -= fy;
1400
1401                 if (frame_status(input->output->frame) & FRAME_STATUS_REPAINT)
1402                         weston_output_schedule_repaint(&input->output->base);
1403         } else {
1404                 location = THEME_LOCATION_CLIENT_AREA;
1405         }
1406
1407         weston_output_transform_coordinate(&input->output->base, x, y, &x, &y);
1408
1409         if (location == THEME_LOCATION_CLIENT_AREA) {
1410                 input->has_focus = true;
1411                 notify_pointer_focus(&input->base, &input->output->base, x, y);
1412                 wl_pointer_set_cursor(input->parent.pointer,
1413                                       input->enter_serial, NULL, 0, 0);
1414         } else {
1415                 input->has_focus = false;
1416                 notify_pointer_focus(&input->base, NULL, 0, 0);
1417                 input_set_cursor(input);
1418         }
1419 }
1420
1421 static void
1422 input_handle_pointer_leave(void *data, struct wl_pointer *pointer,
1423                            uint32_t serial, struct wl_surface *surface)
1424 {
1425         struct wayland_input *input = data;
1426
1427         if (!input->output)
1428                 return;
1429
1430         if (input->output->frame) {
1431                 frame_pointer_leave(input->output->frame, input);
1432
1433                 if (frame_status(input->output->frame) & FRAME_STATUS_REPAINT)
1434                         weston_output_schedule_repaint(&input->output->base);
1435         }
1436
1437         notify_pointer_focus(&input->base, NULL, 0, 0);
1438         input->output = NULL;
1439         input->has_focus = false;
1440 }
1441
1442 static void
1443 input_handle_motion(void *data, struct wl_pointer *pointer,
1444                     uint32_t time, wl_fixed_t fixed_x, wl_fixed_t fixed_y)
1445 {
1446         struct wayland_input *input = data;
1447         int32_t fx, fy;
1448         enum theme_location location;
1449         bool want_frame = false;
1450         double x, y;
1451
1452         if (!input->output)
1453                 return;
1454
1455         x = wl_fixed_to_double(fixed_x);
1456         y = wl_fixed_to_double(fixed_y);
1457
1458         if (input->output->frame) {
1459                 location = frame_pointer_motion(input->output->frame, input,
1460                                                 x, y);
1461                 frame_interior(input->output->frame, &fx, &fy, NULL, NULL);
1462                 x -= fx;
1463                 y -= fy;
1464
1465                 if (frame_status(input->output->frame) & FRAME_STATUS_REPAINT)
1466                         weston_output_schedule_repaint(&input->output->base);
1467         } else {
1468                 location = THEME_LOCATION_CLIENT_AREA;
1469         }
1470
1471         weston_output_transform_coordinate(&input->output->base, x, y, &x, &y);
1472
1473         if (input->has_focus && location != THEME_LOCATION_CLIENT_AREA) {
1474                 input_set_cursor(input);
1475                 notify_pointer_focus(&input->base, NULL, 0, 0);
1476                 input->has_focus = false;
1477                 want_frame = true;
1478         } else if (!input->has_focus &&
1479                    location == THEME_LOCATION_CLIENT_AREA) {
1480                 wl_pointer_set_cursor(input->parent.pointer,
1481                                       input->enter_serial, NULL, 0, 0);
1482                 notify_pointer_focus(&input->base, &input->output->base, x, y);
1483                 input->has_focus = true;
1484                 want_frame = true;
1485         }
1486
1487         if (location == THEME_LOCATION_CLIENT_AREA) {
1488                 notify_motion_absolute(&input->base, time, x, y);
1489                 want_frame = true;
1490         }
1491
1492         if (want_frame && input->seat_version < WL_POINTER_FRAME_SINCE_VERSION)
1493                 notify_pointer_frame(&input->base);
1494 }
1495
1496 static void
1497 input_handle_button(void *data, struct wl_pointer *pointer,
1498                     uint32_t serial, uint32_t time, uint32_t button,
1499                     enum wl_pointer_button_state state)
1500 {
1501         struct wayland_input *input = data;
1502         enum theme_location location;
1503
1504         if (!input->output)
1505                 return;
1506
1507         if (input->output->frame) {
1508                 location = frame_pointer_button(input->output->frame, input,
1509                                                 button, state);
1510
1511                 if (frame_status(input->output->frame) & FRAME_STATUS_MOVE) {
1512
1513                         wl_shell_surface_move(input->output->parent.shell_surface,
1514                                               input->parent.seat, serial);
1515                         frame_status_clear(input->output->frame,
1516                                            FRAME_STATUS_MOVE);
1517                         return;
1518                 }
1519
1520                 if (frame_status(input->output->frame) & FRAME_STATUS_CLOSE) {
1521                         wayland_output_destroy(&input->output->base);
1522                         input->output = NULL;
1523                         input->keyboard_focus = NULL;
1524
1525                         if (wl_list_empty(&input->backend->compositor->output_list))
1526                                 weston_compositor_exit(input->backend->compositor);
1527
1528                         return;
1529                 }
1530
1531                 if (frame_status(input->output->frame) & FRAME_STATUS_REPAINT)
1532                         weston_output_schedule_repaint(&input->output->base);
1533         } else {
1534                 location = THEME_LOCATION_CLIENT_AREA;
1535         }
1536
1537         if (location == THEME_LOCATION_CLIENT_AREA) {
1538                 notify_button(&input->base, time, button, state);
1539                 if (input->seat_version < WL_POINTER_FRAME_SINCE_VERSION)
1540                         notify_pointer_frame(&input->base);
1541         }
1542 }
1543
1544 static void
1545 input_handle_axis(void *data, struct wl_pointer *pointer,
1546                   uint32_t time, uint32_t axis, wl_fixed_t value)
1547 {
1548         struct wayland_input *input = data;
1549         struct weston_pointer_axis_event weston_event;
1550
1551         weston_event.axis = axis;
1552         weston_event.value = wl_fixed_to_double(value);
1553
1554         if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL &&
1555             input->vert.has_discrete) {
1556                 weston_event.has_discrete = true;
1557                 weston_event.discrete = input->vert.discrete;
1558                 input->vert.has_discrete = false;
1559         } else if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL &&
1560                    input->horiz.has_discrete) {
1561                 weston_event.has_discrete = true;
1562                 weston_event.discrete = input->horiz.discrete;
1563                 input->horiz.has_discrete = false;
1564         }
1565
1566         notify_axis(&input->base, time, &weston_event);
1567
1568         if (input->seat_version < WL_POINTER_FRAME_SINCE_VERSION)
1569                 notify_pointer_frame(&input->base);
1570 }
1571
1572 static void
1573 input_handle_frame(void *data, struct wl_pointer *pointer)
1574 {
1575         struct wayland_input *input = data;
1576
1577         notify_pointer_frame(&input->base);
1578 }
1579
1580 static void
1581 input_handle_axis_source(void *data, struct wl_pointer *pointer,
1582                          uint32_t source)
1583 {
1584         struct wayland_input *input = data;
1585
1586         notify_axis_source(&input->base, source);
1587 }
1588
1589 static void
1590 input_handle_axis_stop(void *data, struct wl_pointer *pointer,
1591                        uint32_t time, uint32_t axis)
1592 {
1593         struct wayland_input *input = data;
1594         struct weston_pointer_axis_event weston_event;
1595
1596         weston_event.axis = axis;
1597         weston_event.value = 0;
1598
1599         notify_axis(&input->base, time, &weston_event);
1600 }
1601
1602 static void
1603 input_handle_axis_discrete(void *data, struct wl_pointer *pointer,
1604                            uint32_t axis, int32_t discrete)
1605 {
1606         struct wayland_input *input = data;
1607
1608         if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL) {
1609                 input->vert.has_discrete = true;
1610                 input->vert.discrete = discrete;
1611         } else if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL) {
1612                 input->horiz.has_discrete = true;
1613                 input->horiz.discrete = discrete;
1614         }
1615 }
1616
1617 static const struct wl_pointer_listener pointer_listener = {
1618         input_handle_pointer_enter,
1619         input_handle_pointer_leave,
1620         input_handle_motion,
1621         input_handle_button,
1622         input_handle_axis,
1623         input_handle_frame,
1624         input_handle_axis_source,
1625         input_handle_axis_stop,
1626         input_handle_axis_discrete,
1627 };
1628
1629 static void
1630 input_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format,
1631                     int fd, uint32_t size)
1632 {
1633         struct wayland_input *input = data;
1634         struct xkb_keymap *keymap;
1635         char *map_str;
1636
1637         if (!data) {
1638                 close(fd);
1639                 return;
1640         }
1641
1642         if (format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
1643                 map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
1644                 if (map_str == MAP_FAILED) {
1645                         weston_log("mmap failed: %m\n");
1646                         goto error;
1647                 }
1648
1649                 keymap = xkb_keymap_new_from_string(input->backend->compositor->xkb_context,
1650                                                     map_str,
1651                                                     XKB_KEYMAP_FORMAT_TEXT_V1,
1652                                                     0);
1653                 munmap(map_str, size);
1654
1655                 if (!keymap) {
1656                         weston_log("failed to compile keymap\n");
1657                         goto error;
1658                 }
1659
1660                 input->keyboard_state_update = STATE_UPDATE_NONE;
1661         } else if (format == WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP) {
1662                 weston_log("No keymap provided; falling back to defalt\n");
1663                 keymap = NULL;
1664                 input->keyboard_state_update = STATE_UPDATE_AUTOMATIC;
1665         } else {
1666                 weston_log("Invalid keymap\n");
1667                 goto error;
1668         }
1669
1670         close(fd);
1671
1672         if (weston_seat_get_keyboard(&input->base))
1673                 weston_seat_update_keymap(&input->base, keymap);
1674         else
1675                 weston_seat_init_keyboard(&input->base, keymap);
1676
1677         xkb_keymap_unref(keymap);
1678
1679         return;
1680
1681 error:
1682         wl_keyboard_release(input->parent.keyboard);
1683         close(fd);
1684 }
1685
1686 static void
1687 input_handle_keyboard_enter(void *data,
1688                             struct wl_keyboard *keyboard,
1689                             uint32_t serial,
1690                             struct wl_surface *surface,
1691                             struct wl_array *keys)
1692 {
1693         struct wayland_input *input = data;
1694         struct wayland_output *focus;
1695
1696         focus = input->keyboard_focus;
1697         if (focus) {
1698                 /* This shouldn't happen */
1699                 focus->keyboard_count--;
1700                 if (!focus->keyboard_count && focus->frame)
1701                         frame_unset_flag(focus->frame, FRAME_FLAG_ACTIVE);
1702                 if (frame_status(focus->frame) & FRAME_STATUS_REPAINT)
1703                         weston_output_schedule_repaint(&focus->base);
1704         }
1705
1706         input->keyboard_focus = wl_surface_get_user_data(surface);
1707         input->keyboard_focus->keyboard_count++;
1708
1709         focus = input->keyboard_focus;
1710         if (focus->frame) {
1711                 frame_set_flag(focus->frame, FRAME_FLAG_ACTIVE);
1712                 if (frame_status(focus->frame) & FRAME_STATUS_REPAINT)
1713                         weston_output_schedule_repaint(&focus->base);
1714         }
1715
1716
1717         /* XXX: If we get a modifier event immediately before the focus,
1718          *      we should try to keep the same serial. */
1719         notify_keyboard_focus_in(&input->base, keys,
1720                                  STATE_UPDATE_AUTOMATIC);
1721 }
1722
1723 static void
1724 input_handle_keyboard_leave(void *data,
1725                             struct wl_keyboard *keyboard,
1726                             uint32_t serial,
1727                             struct wl_surface *surface)
1728 {
1729         struct wayland_input *input = data;
1730         struct wayland_output *focus;
1731
1732         notify_keyboard_focus_out(&input->base);
1733
1734         focus = input->keyboard_focus;
1735         if (!focus)
1736                 return;
1737
1738         focus->keyboard_count--;
1739         if (!focus->keyboard_count && focus->frame) {
1740                 frame_unset_flag(focus->frame, FRAME_FLAG_ACTIVE);
1741                 if (frame_status(focus->frame) & FRAME_STATUS_REPAINT)
1742                         weston_output_schedule_repaint(&focus->base);
1743         }
1744
1745         input->keyboard_focus = NULL;
1746 }
1747
1748 static void
1749 input_handle_key(void *data, struct wl_keyboard *keyboard,
1750                  uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
1751 {
1752         struct wayland_input *input = data;
1753
1754         input->key_serial = serial;
1755         notify_key(&input->base, time, key,
1756                    state ? WL_KEYBOARD_KEY_STATE_PRESSED :
1757                            WL_KEYBOARD_KEY_STATE_RELEASED,
1758                    input->keyboard_state_update);
1759 }
1760
1761 static void
1762 input_handle_modifiers(void *data, struct wl_keyboard *wl_keyboard,
1763                        uint32_t serial_in, uint32_t mods_depressed,
1764                        uint32_t mods_latched, uint32_t mods_locked,
1765                        uint32_t group)
1766 {
1767         struct weston_keyboard *keyboard;
1768         struct wayland_input *input = data;
1769         struct wayland_backend *b = input->backend;
1770         uint32_t serial_out;
1771
1772         /* If we get a key event followed by a modifier event with the
1773          * same serial number, then we try to preserve those semantics by
1774          * reusing the same serial number on the way out too. */
1775         if (serial_in == input->key_serial)
1776                 serial_out = wl_display_get_serial(b->compositor->wl_display);
1777         else
1778                 serial_out = wl_display_next_serial(b->compositor->wl_display);
1779
1780         keyboard = weston_seat_get_keyboard(&input->base);
1781         xkb_state_update_mask(keyboard->xkb_state.state,
1782                               mods_depressed, mods_latched,
1783                               mods_locked, 0, 0, group);
1784         notify_modifiers(&input->base, serial_out);
1785 }
1786
1787 static void
1788 input_handle_repeat_info(void *data, struct wl_keyboard *keyboard,
1789                          int32_t rate, int32_t delay)
1790 {
1791         struct wayland_input *input = data;
1792         struct wayland_backend *b = input->backend;
1793
1794         b->compositor->kb_repeat_rate = rate;
1795         b->compositor->kb_repeat_delay = delay;
1796 }
1797
1798 static const struct wl_keyboard_listener keyboard_listener = {
1799         input_handle_keymap,
1800         input_handle_keyboard_enter,
1801         input_handle_keyboard_leave,
1802         input_handle_key,
1803         input_handle_modifiers,
1804         input_handle_repeat_info,
1805 };
1806
1807 static void
1808 input_handle_touch_down(void *data, struct wl_touch *wl_touch,
1809                         uint32_t serial, uint32_t time,
1810                         struct wl_surface *surface, int32_t id,
1811                         wl_fixed_t fixed_x, wl_fixed_t fixed_y)
1812 {
1813         struct wayland_input *input = data;
1814         struct wayland_output *output;
1815         enum theme_location location;
1816         bool first_touch;
1817         int32_t fx, fy;
1818         double x, y;
1819
1820         x = wl_fixed_to_double(fixed_x);
1821         y = wl_fixed_to_double(fixed_y);
1822
1823         first_touch = (input->touch_points == 0);
1824         input->touch_points++;
1825
1826         input->touch_focus = wl_surface_get_user_data(surface);
1827         output = input->touch_focus;
1828         if (!first_touch && !input->touch_active)
1829                 return;
1830
1831         if (output->frame) {
1832                 location = frame_touch_down(output->frame, input, id, x, y);
1833
1834                 frame_interior(output->frame, &fx, &fy, NULL, NULL);
1835                 x -= fx;
1836                 y -= fy;
1837
1838                 if (frame_status(output->frame) & FRAME_STATUS_REPAINT)
1839                         weston_output_schedule_repaint(&output->base);
1840
1841                 if (first_touch && (frame_status(output->frame) & FRAME_STATUS_MOVE)) {
1842                         input->touch_points--;
1843                         wl_shell_surface_move(output->parent.shell_surface,
1844                                               input->parent.seat, serial);
1845                         frame_status_clear(output->frame,
1846                                            FRAME_STATUS_MOVE);
1847                         return;
1848                 }
1849
1850                 if (first_touch && location != THEME_LOCATION_CLIENT_AREA)
1851                         return;
1852         }
1853
1854         weston_output_transform_coordinate(&output->base, x, y, &x, &y);
1855
1856         notify_touch(&input->base, time, id, x, y, WL_TOUCH_DOWN);
1857         input->touch_active = true;
1858 }
1859
1860 static void
1861 input_handle_touch_up(void *data, struct wl_touch *wl_touch,
1862                       uint32_t serial, uint32_t time, int32_t id)
1863 {
1864         struct wayland_input *input = data;
1865         struct wayland_output *output = input->touch_focus;
1866         bool active = input->touch_active;
1867
1868         input->touch_points--;
1869         if (input->touch_points == 0) {
1870                 input->touch_focus = NULL;
1871                 input->touch_active = false;
1872         }
1873
1874         if (!output)
1875                 return;
1876
1877         if (output->frame) {
1878                 frame_touch_up(output->frame, input, id);
1879
1880                 if (frame_status(output->frame) & FRAME_STATUS_CLOSE) {
1881                         wayland_output_destroy(&output->base);
1882                         input->touch_focus = NULL;
1883                         input->keyboard_focus = NULL;
1884                         if (wl_list_empty(&input->backend->compositor->output_list))
1885                                 weston_compositor_exit(input->backend->compositor);
1886
1887                         return;
1888                 }
1889                 if (frame_status(output->frame) & FRAME_STATUS_REPAINT)
1890                         weston_output_schedule_repaint(&output->base);
1891         }
1892
1893         if (active)
1894                 notify_touch(&input->base, time, id, 0, 0, WL_TOUCH_UP);
1895 }
1896
1897 static void
1898 input_handle_touch_motion(void *data, struct wl_touch *wl_touch,
1899                         uint32_t time, int32_t id,
1900                         wl_fixed_t fixed_x, wl_fixed_t fixed_y)
1901 {
1902         struct wayland_input *input = data;
1903         struct wayland_output *output = input->touch_focus;
1904         int32_t fx, fy;
1905         double x, y;
1906
1907         x = wl_fixed_to_double(fixed_x);
1908         y = wl_fixed_to_double(fixed_y);
1909
1910         if (!output || !input->touch_active)
1911                 return;
1912
1913         if (output->frame) {
1914                 frame_interior(output->frame, &fx, &fy, NULL, NULL);
1915                 x -= fx;
1916                 y -= fy;
1917         }
1918
1919         weston_output_transform_coordinate(&output->base, x, y, &x, &y);
1920
1921         notify_touch(&input->base, time, id, x, y, WL_TOUCH_MOTION);
1922 }
1923
1924 static void
1925 input_handle_touch_frame(void *data, struct wl_touch *wl_touch)
1926 {
1927         struct wayland_input *input = data;
1928
1929         if (!input->touch_focus || !input->touch_active)
1930                 return;
1931
1932         notify_touch_frame(&input->base);
1933 }
1934
1935 static void
1936 input_handle_touch_cancel(void *data, struct wl_touch *wl_touch)
1937 {
1938         struct wayland_input *input = data;
1939
1940         if (!input->touch_focus || !input->touch_active)
1941                 return;
1942
1943         notify_touch_cancel(&input->base);
1944 }
1945
1946 static const struct wl_touch_listener touch_listener = {
1947         input_handle_touch_down,
1948         input_handle_touch_up,
1949         input_handle_touch_motion,
1950         input_handle_touch_frame,
1951         input_handle_touch_cancel,
1952 };
1953
1954
1955 static void
1956 input_handle_capabilities(void *data, struct wl_seat *seat,
1957                           enum wl_seat_capability caps)
1958 {
1959         struct wayland_input *input = data;
1960
1961         if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->parent.pointer) {
1962                 input->parent.pointer = wl_seat_get_pointer(seat);
1963                 wl_pointer_set_user_data(input->parent.pointer, input);
1964                 wl_pointer_add_listener(input->parent.pointer,
1965                                         &pointer_listener, input);
1966                 weston_seat_init_pointer(&input->base);
1967         } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->parent.pointer) {
1968                 if (input->seat_version >= WL_POINTER_RELEASE_SINCE_VERSION)
1969                         wl_pointer_release(input->parent.pointer);
1970                 else
1971                         wl_pointer_destroy(input->parent.pointer);
1972                 input->parent.pointer = NULL;
1973                 weston_seat_release_pointer(&input->base);
1974         }
1975
1976         if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->parent.keyboard) {
1977                 input->parent.keyboard = wl_seat_get_keyboard(seat);
1978                 wl_keyboard_set_user_data(input->parent.keyboard, input);
1979                 wl_keyboard_add_listener(input->parent.keyboard,
1980                                          &keyboard_listener, input);
1981         } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->parent.keyboard) {
1982                 if (input->seat_version >= WL_KEYBOARD_RELEASE_SINCE_VERSION)
1983                         wl_keyboard_release(input->parent.keyboard);
1984                 else
1985                         wl_keyboard_destroy(input->parent.keyboard);
1986                 input->parent.keyboard = NULL;
1987                 weston_seat_release_keyboard(&input->base);
1988         }
1989
1990         if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !input->parent.touch) {
1991                 input->parent.touch = wl_seat_get_touch(seat);
1992                 wl_touch_set_user_data(input->parent.touch, input);
1993                 wl_touch_add_listener(input->parent.touch,
1994                                       &touch_listener, input);
1995                 weston_seat_init_touch(&input->base);
1996         } else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && input->parent.touch) {
1997                 if (input->seat_version >= WL_TOUCH_RELEASE_SINCE_VERSION)
1998                         wl_touch_release(input->parent.touch);
1999                 else
2000                         wl_touch_destroy(input->parent.touch);
2001                 input->parent.touch = NULL;
2002                 weston_seat_release_touch(&input->base);
2003         }
2004 }
2005
2006 static void
2007 input_handle_name(void *data, struct wl_seat *seat,
2008                   const char *name)
2009 {
2010 }
2011
2012 static const struct wl_seat_listener seat_listener = {
2013         input_handle_capabilities,
2014         input_handle_name,
2015 };
2016
2017 static void
2018 display_add_seat(struct wayland_backend *b, uint32_t id, uint32_t available_version)
2019 {
2020         struct wayland_input *input;
2021         uint32_t version = MIN(available_version, 4);
2022
2023         input = zalloc(sizeof *input);
2024         if (input == NULL)
2025                 return;
2026
2027         weston_seat_init(&input->base, b->compositor, "default");
2028         input->backend = b;
2029         input->parent.seat = wl_registry_bind(b->parent.registry, id,
2030                                               &wl_seat_interface, version);
2031         input->seat_version = version;
2032         wl_list_insert(b->input_list.prev, &input->link);
2033
2034         wl_seat_add_listener(input->parent.seat, &seat_listener, input);
2035         wl_seat_set_user_data(input->parent.seat, input);
2036
2037         input->parent.cursor.surface =
2038                 wl_compositor_create_surface(b->parent.compositor);
2039
2040         input->vert.axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
2041         input->horiz.axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
2042 }
2043
2044 static void
2045 wayland_parent_output_geometry(void *data, struct wl_output *output_proxy,
2046                                int32_t x, int32_t y,
2047                                int32_t physical_width, int32_t physical_height,
2048                                int32_t subpixel, const char *make,
2049                                const char *model, int32_t transform)
2050 {
2051         struct wayland_parent_output *output = data;
2052
2053         output->x = x;
2054         output->y = y;
2055         output->physical.width = physical_width;
2056         output->physical.height = physical_height;
2057         output->physical.subpixel = subpixel;
2058
2059         free(output->physical.make);
2060         output->physical.make = strdup(make);
2061         free(output->physical.model);
2062         output->physical.model = strdup(model);
2063
2064         output->transform = transform;
2065 }
2066
2067 static struct weston_mode *
2068 find_mode(struct wl_list *list, int32_t width, int32_t height, uint32_t refresh)
2069 {
2070         struct weston_mode *mode;
2071
2072         wl_list_for_each(mode, list, link) {
2073                 if (mode->width == width && mode->height == height &&
2074                     mode->refresh == refresh)
2075                         return mode;
2076         }
2077
2078         mode = zalloc(sizeof *mode);
2079         if (!mode)
2080                 return NULL;
2081
2082         mode->width = width;
2083         mode->height = height;
2084         mode->refresh = refresh;
2085         wl_list_insert(list, &mode->link);
2086
2087         return mode;
2088 }
2089
2090 static void
2091 wayland_parent_output_mode(void *data, struct wl_output *wl_output_proxy,
2092                            uint32_t flags, int32_t width, int32_t height,
2093                            int32_t refresh)
2094 {
2095         struct wayland_parent_output *output = data;
2096         struct weston_mode *mode;
2097
2098         if (output->output) {
2099                 mode = find_mode(&output->output->base.mode_list,
2100                                  width, height, refresh);
2101                 if (!mode)
2102                         return;
2103                 mode->flags = flags;
2104                 /* Do a mode-switch on current mode change? */
2105         } else {
2106                 mode = find_mode(&output->mode_list, width, height, refresh);
2107                 if (!mode)
2108                         return;
2109                 mode->flags = flags;
2110                 if (flags & WL_OUTPUT_MODE_CURRENT)
2111                         output->current_mode = mode;
2112                 if (flags & WL_OUTPUT_MODE_PREFERRED)
2113                         output->preferred_mode = mode;
2114         }
2115 }
2116
2117 static const struct wl_output_listener output_listener = {
2118         wayland_parent_output_geometry,
2119         wayland_parent_output_mode
2120 };
2121
2122 static void
2123 wayland_backend_register_output(struct wayland_backend *b, uint32_t id)
2124 {
2125         struct wayland_parent_output *output;
2126
2127         output = zalloc(sizeof *output);
2128         if (!output)
2129                 return;
2130
2131         output->id = id;
2132         output->global = wl_registry_bind(b->parent.registry, id,
2133                                           &wl_output_interface, 1);
2134         if (!output->global) {
2135                 free(output);
2136                 return;
2137         }
2138
2139         wl_output_add_listener(output->global, &output_listener, output);
2140
2141         output->scale = 0;
2142         output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
2143         output->physical.subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
2144         wl_list_init(&output->mode_list);
2145         wl_list_insert(&b->parent.output_list, &output->link);
2146
2147         if (b->sprawl_across_outputs) {
2148                 wl_display_roundtrip(b->parent.wl_display);
2149                 wayland_output_create_for_parent_output(b, output);
2150         }
2151 }
2152
2153 static void
2154 wayland_parent_output_destroy(struct wayland_parent_output *output)
2155 {
2156         struct weston_mode *mode, *next;
2157
2158         if (output->output)
2159                 wayland_output_destroy(&output->output->base);
2160
2161         wl_output_destroy(output->global);
2162         free(output->physical.make);
2163         free(output->physical.model);
2164
2165         wl_list_for_each_safe(mode, next, &output->mode_list, link) {
2166                 wl_list_remove(&mode->link);
2167                 free(mode);
2168         }
2169 }
2170
2171 static void
2172 registry_handle_global(void *data, struct wl_registry *registry, uint32_t name,
2173                        const char *interface, uint32_t version)
2174 {
2175         struct wayland_backend *b = data;
2176
2177         if (strcmp(interface, "wl_compositor") == 0) {
2178                 b->parent.compositor =
2179                         wl_registry_bind(registry, name,
2180                                          &wl_compositor_interface, 1);
2181         } else if (strcmp(interface, "wl_shell") == 0) {
2182                 b->parent.shell =
2183                         wl_registry_bind(registry, name,
2184                                          &wl_shell_interface, 1);
2185         } else if (strcmp(interface, "zwp_fullscreen_shell_v1") == 0) {
2186                 b->parent.fshell =
2187                         wl_registry_bind(registry, name,
2188                                          &zwp_fullscreen_shell_v1_interface, 1);
2189         } else if (strcmp(interface, "wl_seat") == 0) {
2190                 display_add_seat(b, name, version);
2191         } else if (strcmp(interface, "wl_output") == 0) {
2192                 wayland_backend_register_output(b, name);
2193         } else if (strcmp(interface, "wl_shm") == 0) {
2194                 b->parent.shm =
2195                         wl_registry_bind(registry, name, &wl_shm_interface, 1);
2196         }
2197 }
2198
2199 static void
2200 registry_handle_global_remove(void *data, struct wl_registry *registry,
2201                               uint32_t name)
2202 {
2203         struct wayland_backend *b = data;
2204         struct wayland_parent_output *output;
2205
2206         wl_list_for_each(output, &b->parent.output_list, link)
2207                 if (output->id == name)
2208                         wayland_parent_output_destroy(output);
2209 }
2210
2211 static const struct wl_registry_listener registry_listener = {
2212         registry_handle_global,
2213         registry_handle_global_remove
2214 };
2215
2216 static int
2217 wayland_backend_handle_event(int fd, uint32_t mask, void *data)
2218 {
2219         struct wayland_backend *b = data;
2220         int count = 0;
2221
2222         if ((mask & WL_EVENT_HANGUP) || (mask & WL_EVENT_ERROR)) {
2223                 weston_compositor_exit(b->compositor);
2224                 return 0;
2225         }
2226
2227         if (mask & WL_EVENT_READABLE)
2228                 count = wl_display_dispatch(b->parent.wl_display);
2229         if (mask & WL_EVENT_WRITABLE)
2230                 wl_display_flush(b->parent.wl_display);
2231
2232         if (mask == 0) {
2233                 count = wl_display_dispatch_pending(b->parent.wl_display);
2234                 wl_display_flush(b->parent.wl_display);
2235         }
2236
2237         return count;
2238 }
2239
2240 static void
2241 wayland_restore(struct weston_compositor *ec)
2242 {
2243 }
2244
2245 static void
2246 wayland_destroy(struct weston_compositor *ec)
2247 {
2248         struct wayland_backend *b = to_wayland_backend(ec);
2249
2250         weston_compositor_shutdown(ec);
2251
2252         if (b->parent.shm)
2253                 wl_shm_destroy(b->parent.shm);
2254
2255         free(b);
2256 }
2257
2258 static const char *left_ptrs[] = {
2259         "left_ptr",
2260         "default",
2261         "top_left_arrow",
2262         "left-arrow"
2263 };
2264
2265 static void
2266 create_cursor(struct wayland_backend *b,
2267               struct weston_wayland_backend_config *config)
2268 {
2269         unsigned int i;
2270
2271         b->cursor_theme = wl_cursor_theme_load(config->cursor_theme,
2272                                                config->cursor_size,
2273                                                b->parent.shm);
2274         if (!b->cursor_theme) {
2275                 fprintf(stderr, "could not load cursor theme\n");
2276                 return;
2277         }
2278
2279         b->cursor = NULL;
2280         for (i = 0; !b->cursor && i < ARRAY_LENGTH(left_ptrs); ++i)
2281                 b->cursor = wl_cursor_theme_get_cursor(b->cursor_theme,
2282                                                        left_ptrs[i]);
2283         if (!b->cursor) {
2284                 fprintf(stderr, "could not load left cursor\n");
2285                 return;
2286         }
2287 }
2288
2289 static void
2290 fullscreen_binding(struct weston_keyboard *keyboard, uint32_t time,
2291                    uint32_t key, void *data)
2292 {
2293         struct wayland_backend *b = data;
2294         struct wayland_input *input = NULL;
2295
2296         wl_list_for_each(input, &b->input_list, link)
2297                 if (&input->base == keyboard->seat)
2298                         break;
2299
2300         if (!input || !input->output)
2301                 return;
2302
2303         if (input->output->frame)
2304                 wayland_output_set_fullscreen(input->output, 0, 0, NULL);
2305         else
2306                 wayland_output_set_windowed(input->output);
2307
2308         weston_output_schedule_repaint(&input->output->base);
2309 }
2310
2311 static struct wayland_backend *
2312 wayland_backend_create(struct weston_compositor *compositor,
2313                        struct weston_wayland_backend_config *new_config)
2314 {
2315         struct wayland_backend *b;
2316         struct wl_event_loop *loop;
2317         int fd;
2318
2319         b = zalloc(sizeof *b);
2320         if (b == NULL)
2321                 return NULL;
2322
2323         b->compositor = compositor;
2324         if (weston_compositor_set_presentation_clock_software(compositor) < 0)
2325                 goto err_compositor;
2326
2327         b->parent.wl_display = wl_display_connect(new_config->display_name);
2328         if (b->parent.wl_display == NULL) {
2329                 weston_log("failed to create display: %m\n");
2330                 goto err_compositor;
2331         }
2332
2333         wl_list_init(&b->parent.output_list);
2334         wl_list_init(&b->input_list);
2335         b->parent.registry = wl_display_get_registry(b->parent.wl_display);
2336         wl_registry_add_listener(b->parent.registry, &registry_listener, b);
2337         wl_display_roundtrip(b->parent.wl_display);
2338
2339         create_cursor(b, new_config);
2340
2341         b->use_pixman = new_config->use_pixman;
2342         b->fullscreen = new_config->fullscreen;
2343
2344         if (!b->use_pixman) {
2345                 gl_renderer = weston_load_module("gl-renderer.so",
2346                                                  "gl_renderer_interface");
2347                 if (!gl_renderer)
2348                         b->use_pixman = true;
2349         }
2350
2351         if (!b->use_pixman) {
2352                 if (gl_renderer->display_create(compositor,
2353                                                 EGL_PLATFORM_WAYLAND_KHR,
2354                                                 b->parent.wl_display,
2355                                                 gl_renderer->alpha_attribs,
2356                                                 NULL,
2357                                                 0) < 0) {
2358                         weston_log("Failed to initialize the GL renderer; "
2359                                    "falling back to pixman.\n");
2360                         b->use_pixman = true;
2361                 }
2362         }
2363
2364         if (b->use_pixman) {
2365                 if (pixman_renderer_init(compositor) < 0) {
2366                         weston_log("Failed to initialize pixman renderer\n");
2367                         goto err_display;
2368                 }
2369         }
2370
2371         b->base.destroy = wayland_destroy;
2372         b->base.restore = wayland_restore;
2373
2374         loop = wl_display_get_event_loop(compositor->wl_display);
2375
2376         fd = wl_display_get_fd(b->parent.wl_display);
2377         b->parent.wl_source =
2378                 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
2379                                      wayland_backend_handle_event, b);
2380         if (b->parent.wl_source == NULL)
2381                 goto err_display;
2382
2383         wl_event_source_check(b->parent.wl_source);
2384
2385         if (compositor->renderer->import_dmabuf) {
2386                 if (linux_dmabuf_setup(compositor) < 0)
2387                         weston_log("Error: initializing dmabuf "
2388                                    "support failed.\n");
2389         }
2390
2391         compositor->backend = &b->base;
2392         return b;
2393 err_display:
2394         wl_display_disconnect(b->parent.wl_display);
2395 err_compositor:
2396         weston_compositor_shutdown(compositor);
2397         free(b);
2398         return NULL;
2399 }
2400
2401 static void
2402 wayland_backend_destroy(struct wayland_backend *b)
2403 {
2404         wl_display_disconnect(b->parent.wl_display);
2405
2406         if (b->theme)
2407                 theme_destroy(b->theme);
2408         if (b->frame_device)
2409                 cairo_device_destroy(b->frame_device);
2410         wl_cursor_theme_destroy(b->cursor_theme);
2411
2412         weston_compositor_shutdown(b->compositor);
2413         free(b);
2414 }
2415
2416 static const struct weston_windowed_output_api windowed_api = {
2417         wayland_output_set_size,
2418         wayland_output_create,
2419 };
2420
2421 static void
2422 config_init_to_defaults(struct weston_wayland_backend_config *config)
2423 {
2424 }
2425
2426 WL_EXPORT int
2427 backend_init(struct weston_compositor *compositor,
2428              struct weston_backend_config *config_base)
2429 {
2430         struct wayland_backend *b;
2431         struct wayland_parent_output *poutput;
2432         struct weston_wayland_backend_config new_config;
2433         int ret;
2434
2435         if (config_base == NULL ||
2436             config_base->struct_version != WESTON_WAYLAND_BACKEND_CONFIG_VERSION ||
2437             config_base->struct_size > sizeof(struct weston_wayland_backend_config)) {
2438                 weston_log("wayland backend config structure is invalid\n");
2439                 return -1;
2440         }
2441
2442         config_init_to_defaults(&new_config);
2443         memcpy(&new_config, config_base, config_base->struct_size);
2444
2445         b = wayland_backend_create(compositor, &new_config);
2446
2447         if (!b)
2448                 return -1;
2449
2450         if (new_config.sprawl || b->parent.fshell) {
2451                 b->sprawl_across_outputs = true;
2452                 wl_display_roundtrip(b->parent.wl_display);
2453
2454                 wl_list_for_each(poutput, &b->parent.output_list, link)
2455                         wayland_output_create_for_parent_output(b, poutput);
2456
2457                 return 0;
2458         }
2459
2460         if (new_config.fullscreen) {
2461                 if (wayland_output_create_fullscreen(b) < 0) {
2462                         weston_log("Unable to create a fullscreen output.\n");
2463                         goto err_outputs;
2464                 }
2465
2466                 return 0;
2467         }
2468
2469         ret = weston_plugin_api_register(compositor, WESTON_WINDOWED_OUTPUT_API_NAME,
2470                                          &windowed_api, sizeof(windowed_api));
2471
2472         if (ret < 0) {
2473                 weston_log("Failed to register output API.\n");
2474                 wayland_backend_destroy(b);
2475                 return -1;
2476         }
2477
2478         weston_compositor_add_key_binding(compositor, KEY_F,
2479                                           MODIFIER_CTRL | MODIFIER_ALT,
2480                                           fullscreen_binding, b);
2481         return 0;
2482
2483 err_outputs:
2484         wayland_backend_destroy(b);
2485         return -1;
2486 }