src/compositor-wayland.c

   1 /*
   2  * Copyright © 2010-2011 Benjamin Franzke
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stddef.h>
  28 #define _GNU_SOURCE
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <sys/mman.h>
  35
  36 #include <wayland-client.h>
  37 #include <wayland-egl.h>
  38
  39 #include "compositor.h"
  40 #include "gl-renderer.h"
  41 #include "../shared/image-loader.h"
  42 #include "../shared/os-compatibility.h"
  43
  44 struct wayland_compositor {
  45         struct weston_compositor         base;
  46
  47         struct {
  48                 struct wl_display *wl_display;
  49                 struct wl_registry *registry;
  50                 struct wl_compositor *compositor;
  51                 struct wl_shell *shell;
  52                 struct wl_output *output;
  53                 struct wl_shm *shm;
  54
  55                 struct {
  56                         int32_t x, y, width, height;
  57                 } screen_allocation;
  58
  59                 struct wl_event_source *wl_source;
  60                 uint32_t event_mask;
  61         } parent;
  62
  63         struct {
  64                 int32_t top, bottom, left, right;
  65         } border;
  66
  67         struct wl_list input_list;
  68 };
  69
  70 struct wayland_output {
  71         struct weston_output    base;
  72         struct {
  73                 int                      draw_initial_frame;
  74                 struct wl_surface       *surface;
  75                 struct wl_shell_surface *shell_surface;
  76                 struct wl_egl_window    *egl_window;
  77         } parent;
  78         struct weston_mode      mode;
  79 };
  80
  81 struct wayland_input {
  82         struct weston_seat base;
  83         struct wayland_compositor *compositor;
  84         struct wl_seat *seat;
  85         struct wl_pointer *pointer;
  86         struct wl_keyboard *keyboard;
  87         struct wl_touch *touch;
  88         struct wl_list link;
  89         uint32_t key_serial;
  90         uint32_t enter_serial;
  91         int focus;
  92         struct wayland_output *output;
  93 };
  94
  95 static void
  96 create_border(struct wayland_compositor *c)
  97 {
  98         pixman_image_t *image;
  99         int32_t edges[4];
 100
 101         image = load_image(DATADIR "/weston/border.png");
 102         if (!image) {
 103                 weston_log("could'nt load border image\n");
 104                 return;
 105         }
 106
 107         edges[0] = c->border.left;
 108         edges[1] = c->border.right;
 109         edges[2] = c->border.top;
 110         edges[3] = c->border.bottom;
 111
 112         gl_renderer_set_border(&c->base, pixman_image_get_width(image),
 113                 pixman_image_get_height(image),
 114                 pixman_image_get_data(image), edges);
 115
 116         pixman_image_unref(image);
 117 }
 118
 119 static void
 120 frame_done(void *data, struct wl_callback *callback, uint32_t time)
 121 {
 122         struct weston_output *output = data;
 123
 124         wl_callback_destroy(callback);
 125         weston_output_finish_frame(output, time);
 126 }
 127
 128 static const struct wl_callback_listener frame_listener = {
 129         frame_done
 130 };
 131
 132 static void
 133 buffer_release(void *data, struct wl_buffer *buffer)
 134 {
 135         wl_buffer_destroy(buffer);
 136 }
 137
 138 static const struct wl_buffer_listener buffer_listener = {
 139         buffer_release
 140 };
 141
 142 static void
 143 draw_initial_frame(struct wayland_output *output)
 144 {
 145         struct wayland_compositor *c =
 146                 (struct wayland_compositor *) output->base.compositor;
 147         struct wl_shm *shm = c->parent.shm;
 148         struct wl_surface *surface = output->parent.surface;
 149         struct wl_shm_pool *pool;
 150         struct wl_buffer *buffer;
 151
 152         int width, height, stride;
 153         int size;
 154         int fd;
 155         void *data;
 156
 157         width = output->mode.width + c->border.left + c->border.right;
 158         height = output->mode.height + c->border.top + c->border.bottom;
 159         stride = width * 4;
 160         size = height * stride;
 161
 162         fd = os_create_anonymous_file(size);
 163         if (fd < 0) {
 164                 perror("os_create_anonymous_file");
 165                 return;
 166         }
 167
 168         data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 169         if (data == MAP_FAILED) {
 170                 perror("mmap");
 171                 close(fd);
 172                 return;
 173         }
 174
 175         pool = wl_shm_create_pool(shm, fd, size);
 176
 177         buffer = wl_shm_pool_create_buffer(pool, 0,
 178                                            width, height,
 179                                            stride,
 180                                            WL_SHM_FORMAT_ARGB8888);
 181         wl_buffer_add_listener(buffer, &buffer_listener, buffer);
 182         wl_shm_pool_destroy(pool);
 183         close(fd);
 184
 185         memset(data, 0, size);
 186
 187         wl_surface_attach(surface, buffer, 0, 0);
 188
 189         /* We only need to damage some part, as its only transparant
 190          * pixels anyway. */
 191         wl_surface_damage(surface, 0, 0, 1, 1);
 192 }
 193
 194 static void
 195 wayland_output_start_repaint_loop(struct weston_output *output_base)
 196 {
 197         struct wayland_output *output = (struct wayland_output *) output_base;
 198         struct wl_callback *callback;
 199
 200         /* If this is the initial frame, we need to attach a buffer so that
 201          * the compositor can map the surface and include it in its render
 202          * loop. If the surface doesn't end up in the render loop, the frame
 203          * callback won't be invoked. The buffer is transparent and of the
 204          * same size as the future real output buffer. */
 205         if (output->parent.draw_initial_frame) {
 206                 output->parent.draw_initial_frame = 0;
 207
 208                 draw_initial_frame(output);
 209         }
 210
 211         callback = wl_surface_frame(output->parent.surface);
 212         wl_callback_add_listener(callback, &frame_listener, output);
 213         wl_surface_commit(output->parent.surface);
 214 }
 215
 216 static void
 217 wayland_output_repaint(struct weston_output *output_base,
 218                        pixman_region32_t *damage)
 219 {
 220         struct wayland_output *output = (struct wayland_output *) output_base;
 221         struct weston_compositor *ec = output->base.compositor;
 222         struct wl_callback *callback;
 223
 224         callback = wl_surface_frame(output->parent.surface);
 225         wl_callback_add_listener(callback, &frame_listener, output);
 226
 227         ec->renderer->repaint_output(&output->base, damage);
 228
 229         pixman_region32_subtract(&ec->primary_plane.damage,
 230                                  &ec->primary_plane.damage, damage);
 231
 232 }
 233
 234 static void
 235 wayland_output_destroy(struct weston_output *output_base)
 236 {
 237         struct wayland_output *output = (struct wayland_output *) output_base;
 238
 239         gl_renderer_output_destroy(output_base);
 240
 241         wl_egl_window_destroy(output->parent.egl_window);
 242         free(output);
 243
 244         return;
 245 }
 246
 247 static const struct wl_shell_surface_listener shell_surface_listener;
 248
 249 static int
 250 wayland_compositor_create_output(struct wayland_compositor *c,
 251                                  int width, int height)
 252 {
 253         struct wayland_output *output;
 254
 255         output = malloc(sizeof *output);
 256         if (output == NULL)
 257                 return -1;
 258         memset(output, 0, sizeof *output);
 259
 260         output->mode.flags =
 261                 WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
 262         output->mode.width = width;
 263         output->mode.height = height;
 264         output->mode.refresh = 60;
 265         wl_list_init(&output->base.mode_list);
 266         wl_list_insert(&output->base.mode_list, &output->mode.link);
 267
 268         output->base.current = &output->mode;
 269         weston_output_init(&output->base, &c->base, 0, 0, width, height,
 270                                                 WL_OUTPUT_TRANSFORM_NORMAL);
 271
 272         output->base.make = "waywayland";
 273         output->base.model = "none";
 274
 275         weston_output_move(&output->base, 0, 0);
 276
 277         output->parent.surface =
 278                 wl_compositor_create_surface(c->parent.compositor);
 279         wl_surface_set_user_data(output->parent.surface, output);
 280
 281         output->parent.egl_window =
 282                 wl_egl_window_create(output->parent.surface,
 283                                      width + c->border.left + c->border.right,
 284                                      height + c->border.top + c->border.bottom);
 285         if (!output->parent.egl_window) {
 286                 weston_log("failure to create wl_egl_window\n");
 287                 goto cleanup_output;
 288         }
 289
 290         if (gl_renderer_output_create(&output->base,
 291                         output->parent.egl_window) < 0)
 292                 goto cleanup_window;
 293
 294         output->parent.draw_initial_frame = 1;
 295         output->parent.shell_surface =
 296                 wl_shell_get_shell_surface(c->parent.shell,
 297                                            output->parent.surface);
 298         wl_shell_surface_add_listener(output->parent.shell_surface,
 299                                       &shell_surface_listener, output);
 300         wl_shell_surface_set_toplevel(output->parent.shell_surface);
 301
 302         output->base.origin = output->base.current;
 303         output->base.start_repaint_loop = wayland_output_start_repaint_loop;
 304         output->base.repaint = wayland_output_repaint;
 305         output->base.destroy = wayland_output_destroy;
 306         output->base.assign_planes = NULL;
 307         output->base.set_backlight = NULL;
 308         output->base.set_dpms = NULL;
 309         output->base.switch_mode = NULL;
 310
 311         wl_list_insert(c->base.output_list.prev, &output->base.link);
 312
 313         return 0;
 314
 315 cleanup_window:
 316         wl_egl_window_destroy(output->parent.egl_window);
 317 cleanup_output:
 318         /* FIXME: cleanup weston_output */
 319         free(output);
 320
 321         return -1;
 322 }
 323
 324 static void
 325 shell_surface_ping(void *data, struct wl_shell_surface *shell_surface,
 326                    uint32_t serial)
 327 {
 328         wl_shell_surface_pong(shell_surface, serial);
 329 }
 330
 331 static void
 332 shell_surface_configure(void *data, struct wl_shell_surface *shell_surface,
 333                         uint32_t edges, int32_t width, int32_t height)
 334 {
 335         /* FIXME: implement resizing */
 336 }
 337
 338 static void
 339 shell_surface_popup_done(void *data, struct wl_shell_surface *shell_surface)
 340 {
 341 }
 342
 343 static const struct wl_shell_surface_listener shell_surface_listener = {
 344         shell_surface_ping,
 345         shell_surface_configure,
 346         shell_surface_popup_done
 347 };
 348
 349 /* Events received from the wayland-server this compositor is client of: */
 350
 351 /* parent output interface */
 352 static void
 353 display_handle_geometry(void *data,
 354                         struct wl_output *wl_output,
 355                         int x,
 356                         int y,
 357                         int physical_width,
 358                         int physical_height,
 359                         int subpixel,
 360                         const char *make,
 361                         const char *model,
 362                         int transform)
 363 {
 364         struct wayland_compositor *c = data;
 365
 366         c->parent.screen_allocation.x = x;
 367         c->parent.screen_allocation.y = y;
 368 }
 369
 370 static void
 371 display_handle_mode(void *data,
 372                     struct wl_output *wl_output,
 373                     uint32_t flags,
 374                     int width,
 375                     int height,
 376                     int refresh)
 377 {
 378         struct wayland_compositor *c = data;
 379
 380         c->parent.screen_allocation.width = width;
 381         c->parent.screen_allocation.height = height;
 382 }
 383
 384 static const struct wl_output_listener output_listener = {
 385         display_handle_geometry,
 386         display_handle_mode
 387 };
 388
 389 static void
 390 check_focus(struct wayland_input *input, wl_fixed_t x, wl_fixed_t y)
 391 {
 392         struct wayland_compositor *c = input->compositor;
 393         int width, height, inside;
 394
 395         width = input->output->mode.width;
 396         height = input->output->mode.height;
 397
 398         inside = c->border.left <= wl_fixed_to_int(x) &&
 399                 wl_fixed_to_int(x) < width + c->border.left &&
 400                 c->border.top <= wl_fixed_to_int(y) &&
 401                 wl_fixed_to_int(y) < height + c->border.top;
 402
 403         if (!input->focus && inside) {
 404                 notify_pointer_focus(&input->base, &input->output->base,
 405                                      x - wl_fixed_from_int(c->border.left),
 406                                      y = wl_fixed_from_int(c->border.top));
 407                 wl_pointer_set_cursor(input->pointer,
 408                                       input->enter_serial, NULL, 0, 0);
 409         } else if (input->focus && !inside) {
 410                 notify_pointer_focus(&input->base, NULL, 0, 0);
 411                 /* FIXME: Should set default cursor here. */
 412         }
 413
 414         input->focus = inside;
 415 }
 416
 417 /* parent input interface */
 418 static void
 419 input_handle_pointer_enter(void *data, struct wl_pointer *pointer,
 420                            uint32_t serial, struct wl_surface *surface,
 421                            wl_fixed_t x, wl_fixed_t y)
 422 {
 423         struct wayland_input *input = data;
 424
 425         /* XXX: If we get a modifier event immediately before the focus,
 426          *      we should try to keep the same serial. */
 427         input->enter_serial = serial;
 428         input->output = wl_surface_get_user_data(surface);
 429         check_focus(input, x, y);
 430 }
 431
 432 static void
 433 input_handle_pointer_leave(void *data, struct wl_pointer *pointer,
 434                            uint32_t serial, struct wl_surface *surface)
 435 {
 436         struct wayland_input *input = data;
 437
 438         notify_pointer_focus(&input->base, NULL, 0, 0);
 439         input->output = NULL;
 440         input->focus = 0;
 441 }
 442
 443 static void
 444 input_handle_motion(void *data, struct wl_pointer *pointer,
 445                     uint32_t time, wl_fixed_t x, wl_fixed_t y)
 446 {
 447         struct wayland_input *input = data;
 448         struct wayland_compositor *c = input->compositor;
 449
 450         check_focus(input, x, y);
 451         if (input->focus)
 452                 notify_motion(&input->base, time,
 453                               x - wl_fixed_from_int(c->border.left) -
 454                               input->base.seat.pointer->x,
 455                               y - wl_fixed_from_int(c->border.top) -
 456                               input->base.seat.pointer->y);
 457 }
 458
 459 static void
 460 input_handle_button(void *data, struct wl_pointer *pointer,
 461                     uint32_t serial, uint32_t time, uint32_t button,
 462                     uint32_t state_w)
 463 {
 464         struct wayland_input *input = data;
 465         enum wl_pointer_button_state state = state_w;
 466
 467         notify_button(&input->base, time, button, state);
 468 }
 469
 470 static void
 471 input_handle_axis(void *data, struct wl_pointer *pointer,
 472                   uint32_t time, uint32_t axis, wl_fixed_t value)
 473 {
 474         struct wayland_input *input = data;
 475
 476         notify_axis(&input->base, time, axis, value);
 477 }
 478
 479 static const struct wl_pointer_listener pointer_listener = {
 480         input_handle_pointer_enter,
 481         input_handle_pointer_leave,
 482         input_handle_motion,
 483         input_handle_button,
 484         input_handle_axis,
 485 };
 486
 487 static void
 488 input_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format,
 489                     int fd, uint32_t size)
 490 {
 491         struct wayland_input *input = data;
 492         struct xkb_keymap *keymap;
 493         char *map_str;
 494
 495         if (!data) {
 496                 close(fd);
 497                 return;
 498         }
 499
 500         if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
 501                 close(fd);
 502                 return;
 503         }
 504
 505         map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
 506         if (map_str == MAP_FAILED) {
 507                 close(fd);
 508                 return;
 509         }
 510
 511         keymap = xkb_map_new_from_string(input->compositor->base.xkb_context,
 512                                          map_str,
 513                                          XKB_KEYMAP_FORMAT_TEXT_V1,
 514                                          0);
 515         munmap(map_str, size);
 516         close(fd);
 517
 518         if (!keymap) {
 519                 weston_log("failed to compile keymap\n");
 520                 return;
 521         }
 522
 523         weston_seat_init_keyboard(&input->base, keymap);
 524         xkb_map_unref(keymap);
 525 }
 526
 527 static void
 528 input_handle_keyboard_enter(void *data,
 529                             struct wl_keyboard *keyboard,
 530                             uint32_t serial,
 531                             struct wl_surface *surface,
 532                             struct wl_array *keys)
 533 {
 534         struct wayland_input *input = data;
 535
 536         /* XXX: If we get a modifier event immediately before the focus,
 537          *      we should try to keep the same serial. */
 538         notify_keyboard_focus_in(&input->base, keys,
 539                                  STATE_UPDATE_AUTOMATIC);
 540 }
 541
 542 static void
 543 input_handle_keyboard_leave(void *data,
 544                             struct wl_keyboard *keyboard,
 545                             uint32_t serial,
 546                             struct wl_surface *surface)
 547 {
 548         struct wayland_input *input = data;
 549
 550         notify_keyboard_focus_out(&input->base);
 551 }
 552
 553 static void
 554 input_handle_key(void *data, struct wl_keyboard *keyboard,
 555                  uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
 556 {
 557         struct wayland_input *input = data;
 558
 559         input->key_serial = serial;
 560         notify_key(&input->base, time, key,
 561                    state ? WL_KEYBOARD_KEY_STATE_PRESSED :
 562                            WL_KEYBOARD_KEY_STATE_RELEASED,
 563                    STATE_UPDATE_NONE);
 564 }
 565
 566 static void
 567 input_handle_modifiers(void *data, struct wl_keyboard *keyboard,
 568                        uint32_t serial_in, uint32_t mods_depressed,
 569                        uint32_t mods_latched, uint32_t mods_locked,
 570                        uint32_t group)
 571 {
 572         struct wayland_input *input = data;
 573         struct wayland_compositor *c = input->compositor;
 574         uint32_t serial_out;
 575
 576         /* If we get a key event followed by a modifier event with the
 577          * same serial number, then we try to preserve those semantics by
 578          * reusing the same serial number on the way out too. */
 579         if (serial_in == input->key_serial)
 580                 serial_out = wl_display_get_serial(c->base.wl_display);
 581         else
 582                 serial_out = wl_display_next_serial(c->base.wl_display);
 583
 584         xkb_state_update_mask(input->base.xkb_state.state,
 585                               mods_depressed, mods_latched,
 586                               mods_locked, 0, 0, group);
 587         notify_modifiers(&input->base, serial_out);
 588 }
 589
 590 static const struct wl_keyboard_listener keyboard_listener = {
 591         input_handle_keymap,
 592         input_handle_keyboard_enter,
 593         input_handle_keyboard_leave,
 594         input_handle_key,
 595         input_handle_modifiers,
 596 };
 597
 598 static void
 599 input_handle_capabilities(void *data, struct wl_seat *seat,
 600                           enum wl_seat_capability caps)
 601 {
 602         struct wayland_input *input = data;
 603
 604         if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
 605                 input->pointer = wl_seat_get_pointer(seat);
 606                 wl_pointer_set_user_data(input->pointer, input);
 607                 wl_pointer_add_listener(input->pointer, &pointer_listener,
 608                                         input);
 609                 weston_seat_init_pointer(&input->base);
 610         } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) {
 611                 wl_pointer_destroy(input->pointer);
 612                 input->pointer = NULL;
 613         }
 614
 615         if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) {
 616                 input->keyboard = wl_seat_get_keyboard(seat);
 617                 wl_keyboard_set_user_data(input->keyboard, input);
 618                 wl_keyboard_add_listener(input->keyboard, &keyboard_listener,
 619                                          input);
 620         } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) {
 621                 wl_keyboard_destroy(input->keyboard);
 622                 input->keyboard = NULL;
 623         }
 624 }
 625
 626 static const struct wl_seat_listener seat_listener = {
 627         input_handle_capabilities,
 628 };
 629
 630 static void
 631 display_add_seat(struct wayland_compositor *c, uint32_t id)
 632 {
 633         struct wayland_input *input;
 634
 635         input = malloc(sizeof *input);
 636         if (input == NULL)
 637                 return;
 638
 639         memset(input, 0, sizeof *input);
 640
 641         weston_seat_init(&input->base, &c->base);
 642         input->compositor = c;
 643         input->seat = wl_registry_bind(c->parent.registry, id,
 644                                        &wl_seat_interface, 1);
 645         wl_list_insert(c->input_list.prev, &input->link);
 646
 647         wl_seat_add_listener(input->seat, &seat_listener, input);
 648         wl_seat_set_user_data(input->seat, input);
 649 }
 650
 651 static void
 652 registry_handle_global(void *data, struct wl_registry *registry, uint32_t name,
 653                        const char *interface, uint32_t version)
 654 {
 655         struct wayland_compositor *c = data;
 656
 657         if (strcmp(interface, "wl_compositor") == 0) {
 658                 c->parent.compositor =
 659                         wl_registry_bind(registry, name,
 660                                          &wl_compositor_interface, 1);
 661         } else if (strcmp(interface, "wl_output") == 0) {
 662                 c->parent.output =
 663                         wl_registry_bind(registry, name,
 664                                          &wl_output_interface, 1);
 665                 wl_output_add_listener(c->parent.output, &output_listener, c);
 666         } else if (strcmp(interface, "wl_shell") == 0) {
 667                 c->parent.shell =
 668                         wl_registry_bind(registry, name,
 669                                          &wl_shell_interface, 1);
 670         } else if (strcmp(interface, "wl_seat") == 0) {
 671                 display_add_seat(c, name);
 672         } else if (strcmp(interface, "wl_shm") == 0) {
 673                 c->parent.shm =
 674                         wl_registry_bind(registry, name, &wl_shm_interface, 1);
 675         }
 676 }
 677
 678 static const struct wl_registry_listener registry_listener = {
 679         registry_handle_global
 680 };
 681
 682 static int
 683 wayland_compositor_handle_event(int fd, uint32_t mask, void *data)
 684 {
 685         struct wayland_compositor *c = data;
 686         int count = 0;
 687
 688         if (mask & WL_EVENT_READABLE)
 689                 count = wl_display_dispatch(c->parent.wl_display);
 690         if (mask & WL_EVENT_WRITABLE)
 691                 wl_display_flush(c->parent.wl_display);
 692
 693         if (mask == 0) {
 694                 count = wl_display_dispatch_pending(c->parent.wl_display);
 695                 wl_display_flush(c->parent.wl_display);
 696         }
 697
 698         return count;
 699 }
 700
 701 static void
 702 wayland_restore(struct weston_compositor *ec)
 703 {
 704 }
 705
 706 static void
 707 wayland_destroy(struct weston_compositor *ec)
 708 {
 709         struct wayland_compositor *c = (struct wayland_compositor *) ec;
 710
 711         ec->renderer->destroy(ec);
 712
 713         weston_compositor_shutdown(ec);
 714
 715         if (c->parent.shm)
 716                 wl_shm_destroy(c->parent.shm);
 717
 718         free(ec);
 719 }
 720
 721 static struct weston_compositor *
 722 wayland_compositor_create(struct wl_display *display,
 723                           int width, int height, const char *display_name,
 724                           int *argc, char *argv[], const char *config_file)
 725 {
 726         struct wayland_compositor *c;
 727         struct wl_event_loop *loop;
 728         int fd;
 729
 730         c = malloc(sizeof *c);
 731         if (c == NULL)
 732                 return NULL;
 733
 734         memset(c, 0, sizeof *c);
 735
 736         if (weston_compositor_init(&c->base, display, argc, argv,
 737                                    config_file) < 0)
 738                 goto err_free;
 739
 740         c->parent.wl_display = wl_display_connect(display_name);
 741
 742         if (c->parent.wl_display == NULL) {
 743                 weston_log("failed to create display: %m\n");
 744                 goto err_compositor;
 745         }
 746
 747         wl_list_init(&c->input_list);
 748         c->parent.registry = wl_display_get_registry(c->parent.wl_display);
 749         wl_registry_add_listener(c->parent.registry, &registry_listener, c);
 750         wl_display_dispatch(c->parent.wl_display);
 751
 752         c->base.wl_display = display;
 753         if (gl_renderer_create(&c->base, c->parent.wl_display,
 754                         gl_renderer_alpha_attribs,
 755                         NULL) < 0)
 756                 goto err_display;
 757
 758         c->base.destroy = wayland_destroy;
 759         c->base.restore = wayland_restore;
 760
 761         c->border.top = 30;
 762         c->border.bottom = 24;
 763         c->border.left = 25;
 764         c->border.right = 26;
 765
 766         /* requires border fields */
 767         if (wayland_compositor_create_output(c, width, height) < 0)
 768                 goto err_gl;
 769
 770         /* requires gl_renderer_output_state_create called
 771          * by wayland_compositor_create_output */
 772         create_border(c);
 773
 774         loop = wl_display_get_event_loop(c->base.wl_display);
 775
 776         fd = wl_display_get_fd(c->parent.wl_display);
 777         c->parent.wl_source =
 778                 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
 779                                      wayland_compositor_handle_event, c);
 780         if (c->parent.wl_source == NULL)
 781                 goto err_gl;
 782
 783         wl_event_source_check(c->parent.wl_source);
 784
 785         return &c->base;
 786
 787 err_gl:
 788         c->base.renderer->destroy(&c->base);
 789 err_display:
 790         wl_display_disconnect(c->parent.wl_display);
 791 err_compositor:
 792         weston_compositor_shutdown(&c->base);
 793 err_free:
 794         free(c);
 795         return NULL;
 796 }
 797
 798 WL_EXPORT struct weston_compositor *
 799 backend_init(struct wl_display *display, int *argc, char *argv[],
 800              const char *config_file)
 801 {
 802         int width = 1024, height = 640;
 803         char *display_name = NULL;
 804
 805         const struct weston_option wayland_options[] = {
 806                 { WESTON_OPTION_INTEGER, "width", 0, &width },
 807                 { WESTON_OPTION_INTEGER, "height", 0, &height },
 808                 { WESTON_OPTION_STRING, "display", 0, &display_name },
 809         };
 810
 811         parse_options(wayland_options,
 812                       ARRAY_LENGTH(wayland_options), argc, argv);
 813
 814         return wayland_compositor_create(display, width, height, display_name,
 815                                          argc, argv, config_file);
 816 }