src/compositor.c

   1 /*
   2  * Copyright © 2010-2011 Intel Corporation
   3  * Copyright © 2008-2011 Kristian Høgsberg
   4  * Copyright © 2012 Collabora, Ltd.
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and
   7  * its documentation for any purpose is hereby granted without fee, provided
   8  * that the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of the copyright holders not be used in
  11  * advertising or publicity pertaining to distribution of the software
  12  * without specific, written prior permission.  The copyright holders make
  13  * no representations about the suitability of this software for any
  14  * purpose.  It is provided "as is" without express or implied warranty.
  15  *
  16  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  18  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  19  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  20  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  21  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23  */
  24
  25 #define _GNU_SOURCE
  26
  27 #include "config.h"
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <stdint.h>
  33 #include <limits.h>
  34 #include <stdarg.h>
  35 #include <assert.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/wait.h>
  38 #include <sys/types.h>
  39 #include <sys/socket.h>
  40 #include <fcntl.h>
  41 #include <unistd.h>
  42 #include <math.h>
  43 #include <linux/input.h>
  44 #include <dlfcn.h>
  45 #include <signal.h>
  46 #include <setjmp.h>
  47 #include <execinfo.h>
  48
  49 #include <wayland-server.h>
  50 #include "compositor.h"
  51
  52 static struct wl_list child_process_list;
  53 static jmp_buf segv_jmp_buf;
  54
  55 static int
  56 sigchld_handler(int signal_number, void *data)
  57 {
  58         struct weston_process *p;
  59         int status;
  60         pid_t pid;
  61
  62         pid = waitpid(-1, &status, WNOHANG);
  63         if (!pid)
  64                 return 1;
  65
  66         wl_list_for_each(p, &child_process_list, link) {
  67                 if (p->pid == pid)
  68                         break;
  69         }
  70
  71         if (&p->link == &child_process_list) {
  72                 fprintf(stderr, "unknown child process exited\n");
  73                 return 1;
  74         }
  75
  76         wl_list_remove(&p->link);
  77         p->cleanup(p, status);
  78
  79         return 1;
  80 }
  81
  82 WL_EXPORT int
  83 weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode)
  84 {
  85         if (!output->switch_mode)
  86                 return -1;
  87
  88         return output->switch_mode(output, mode);
  89 }
  90
  91 WL_EXPORT void
  92 weston_watch_process(struct weston_process *process)
  93 {
  94         wl_list_insert(&child_process_list, &process->link);
  95 }
  96
  97 static void
  98 child_client_exec(int sockfd, const char *path)
  99 {
 100         int clientfd;
 101         char s[32];
 102         sigset_t allsigs;
 103
 104         /* do not give our signal mask to the new process */
 105         sigfillset(&allsigs);
 106         sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
 107
 108         /* Launch clients as the user. */
 109         seteuid(getuid());
 110
 111         /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
 112          * non-CLOEXEC fd to pass through exec. */
 113         clientfd = dup(sockfd);
 114         if (clientfd == -1) {
 115                 fprintf(stderr, "compositor: dup failed: %m\n");
 116                 return;
 117         }
 118
 119         snprintf(s, sizeof s, "%d", clientfd);
 120         setenv("WAYLAND_SOCKET", s, 1);
 121
 122         if (execl(path, path, NULL) < 0)
 123                 fprintf(stderr, "compositor: executing '%s' failed: %m\n",
 124                         path);
 125 }
 126
 127 WL_EXPORT struct wl_client *
 128 weston_client_launch(struct weston_compositor *compositor,
 129                      struct weston_process *proc,
 130                      const char *path,
 131                      weston_process_cleanup_func_t cleanup)
 132 {
 133         int sv[2];
 134         pid_t pid;
 135         struct wl_client *client;
 136
 137         if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
 138                 fprintf(stderr, "weston_client_launch: "
 139                         "socketpair failed while launching '%s': %m\n",
 140                         path);
 141                 return NULL;
 142         }
 143
 144         pid = fork();
 145         if (pid == -1) {
 146                 close(sv[0]);
 147                 close(sv[1]);
 148                 fprintf(stderr,  "weston_client_launch: "
 149                         "fork failed while launching '%s': %m\n", path);
 150                 return NULL;
 151         }
 152
 153         if (pid == 0) {
 154                 child_client_exec(sv[1], path);
 155                 exit(-1);
 156         }
 157
 158         close(sv[1]);
 159
 160         client = wl_client_create(compositor->wl_display, sv[0]);
 161         if (!client) {
 162                 close(sv[0]);
 163                 fprintf(stderr, "weston_client_launch: "
 164                         "wl_client_create failed while launching '%s'.\n",
 165                         path);
 166                 return NULL;
 167         }
 168
 169         proc->pid = pid;
 170         proc->cleanup = cleanup;
 171         weston_watch_process(proc);
 172
 173         return client;
 174 }
 175
 176 static void
 177 surface_handle_buffer_destroy(struct wl_listener *listener, void *data)
 178 {
 179         struct weston_surface *es =
 180                 container_of(listener, struct weston_surface,
 181                              buffer_destroy_listener);
 182
 183         es->buffer = NULL;
 184 }
 185
 186 static const pixman_region32_data_t undef_region_data;
 187
 188 static void
 189 undef_region(pixman_region32_t *region)
 190 {
 191         pixman_region32_fini(region);
 192         region->data = (pixman_region32_data_t *) &undef_region_data;
 193 }
 194
 195 static int
 196 region_is_undefined(pixman_region32_t *region)
 197 {
 198         return region->data == &undef_region_data;
 199 }
 200
 201 static void
 202 empty_region(pixman_region32_t *region)
 203 {
 204         if (!region_is_undefined(region))
 205                 pixman_region32_fini(region);
 206
 207         pixman_region32_init(region);
 208 }
 209
 210 WL_EXPORT struct weston_surface *
 211 weston_surface_create(struct weston_compositor *compositor)
 212 {
 213         struct weston_surface *surface;
 214
 215         surface = calloc(1, sizeof *surface);
 216         if (surface == NULL)
 217                 return NULL;
 218
 219         wl_signal_init(&surface->surface.resource.destroy_signal);
 220
 221         wl_list_init(&surface->link);
 222         wl_list_init(&surface->layer_link);
 223
 224         surface->surface.resource.client = NULL;
 225
 226         surface->compositor = compositor;
 227         surface->image = EGL_NO_IMAGE_KHR;
 228         surface->alpha = 255;
 229         surface->brightness = 255;
 230         surface->saturation = 255;
 231         surface->pitch = 1;
 232
 233         surface->buffer = NULL;
 234         surface->output = NULL;
 235
 236         pixman_region32_init(&surface->damage);
 237         pixman_region32_init(&surface->opaque);
 238         pixman_region32_init(&surface->clip);
 239         undef_region(&surface->input);
 240         pixman_region32_init(&surface->transform.opaque);
 241         wl_list_init(&surface->frame_callback_list);
 242
 243         surface->buffer_destroy_listener.notify =
 244                 surface_handle_buffer_destroy;
 245
 246         wl_list_init(&surface->geometry.transformation_list);
 247         wl_list_insert(&surface->geometry.transformation_list,
 248                        &surface->transform.position.link);
 249         weston_matrix_init(&surface->transform.position.matrix);
 250         pixman_region32_init(&surface->transform.boundingbox);
 251         surface->geometry.dirty = 1;
 252
 253         return surface;
 254 }
 255
 256 WL_EXPORT void
 257 weston_surface_set_color(struct weston_surface *surface,
 258                  GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 259 {
 260         surface->color[0] = red;
 261         surface->color[1] = green;
 262         surface->color[2] = blue;
 263         surface->color[3] = alpha;
 264         surface->shader = &surface->compositor->solid_shader;
 265 }
 266
 267 static void
 268 surface_to_global_float(struct weston_surface *surface,
 269                         GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
 270 {
 271         if (surface->transform.enabled) {
 272                 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
 273
 274                 weston_matrix_transform(&surface->transform.matrix, &v);
 275
 276                 if (fabsf(v.f[3]) < 1e-6) {
 277                         fprintf(stderr, "warning: numerical instability in "
 278                                 "weston_surface_to_global(), divisor = %g\n",
 279                                 v.f[3]);
 280                         *x = 0;
 281                         *y = 0;
 282                         return;
 283                 }
 284
 285                 *x = v.f[0] / v.f[3];
 286                 *y = v.f[1] / v.f[3];
 287         } else {
 288                 *x = sx + surface->geometry.x;
 289                 *y = sy + surface->geometry.y;
 290         }
 291 }
 292
 293 WL_EXPORT void
 294 weston_surface_damage_below(struct weston_surface *surface)
 295 {
 296         struct weston_compositor *compositor = surface->compositor;
 297         pixman_region32_t damage;
 298
 299         pixman_region32_init(&damage);
 300         pixman_region32_subtract(&damage, &surface->transform.boundingbox,
 301                                  &surface->clip);
 302         pixman_region32_union(&compositor->damage,
 303                               &compositor->damage, &damage);
 304         pixman_region32_fini(&damage);
 305 }
 306
 307 static void
 308 surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
 309                      int32_t width, int32_t height,
 310                      pixman_region32_t *bbox)
 311 {
 312         GLfloat min_x = HUGE_VALF,  min_y = HUGE_VALF;
 313         GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
 314         int32_t s[4][2] = {
 315                 { sx,         sy },
 316                 { sx,         sy + height },
 317                 { sx + width, sy },
 318                 { sx + width, sy + height }
 319         };
 320         GLfloat int_x, int_y;
 321         int i;
 322
 323         for (i = 0; i < 4; ++i) {
 324                 GLfloat x, y;
 325                 surface_to_global_float(surface, s[i][0], s[i][1], &x, &y);
 326                 if (x < min_x)
 327                         min_x = x;
 328                 if (x > max_x)
 329                         max_x = x;
 330                 if (y < min_y)
 331                         min_y = y;
 332                 if (y > max_y)
 333                         max_y = y;
 334         }
 335
 336         int_x = floorf(min_x);
 337         int_y = floorf(min_y);
 338         pixman_region32_init_rect(bbox, int_x, int_y,
 339                                   ceilf(max_x) - int_x, ceilf(max_y) - int_y);
 340 }
 341
 342 static void
 343 weston_surface_update_transform_disable(struct weston_surface *surface)
 344 {
 345         surface->transform.enabled = 0;
 346
 347         /* round off fractions when not transformed */
 348         surface->geometry.x = roundf(surface->geometry.x);
 349         surface->geometry.y = roundf(surface->geometry.y);
 350
 351         pixman_region32_init_rect(&surface->transform.boundingbox,
 352                                   surface->geometry.x,
 353                                   surface->geometry.y,
 354                                   surface->geometry.width,
 355                                   surface->geometry.height);
 356
 357         if (surface->alpha == 255) {
 358                 pixman_region32_copy(&surface->transform.opaque,
 359                                      &surface->opaque);
 360                 pixman_region32_translate(&surface->transform.opaque,
 361                                           surface->geometry.x,
 362                                           surface->geometry.y);
 363         }
 364 }
 365
 366 static int
 367 weston_surface_update_transform_enable(struct weston_surface *surface)
 368 {
 369         struct weston_matrix *matrix = &surface->transform.matrix;
 370         struct weston_matrix *inverse = &surface->transform.inverse;
 371         struct weston_transform *tform;
 372
 373         surface->transform.enabled = 1;
 374
 375         /* Otherwise identity matrix, but with x and y translation. */
 376         surface->transform.position.matrix.d[12] = surface->geometry.x;
 377         surface->transform.position.matrix.d[13] = surface->geometry.y;
 378
 379         weston_matrix_init(matrix);
 380         wl_list_for_each(tform, &surface->geometry.transformation_list, link)
 381                 weston_matrix_multiply(matrix, &tform->matrix);
 382
 383         if (weston_matrix_invert(inverse, matrix) < 0) {
 384                 /* Oops, bad total transformation, not invertible */
 385                 fprintf(stderr, "error: weston_surface %p"
 386                         " transformation not invertible.\n", surface);
 387                 return -1;
 388         }
 389
 390         surface_compute_bbox(surface, 0, 0, surface->geometry.width,
 391                              surface->geometry.height,
 392                              &surface->transform.boundingbox);
 393
 394         return 0;
 395 }
 396
 397 WL_EXPORT void
 398 weston_surface_update_transform(struct weston_surface *surface)
 399 {
 400         if (!surface->geometry.dirty)
 401                 return;
 402
 403         surface->geometry.dirty = 0;
 404
 405         weston_surface_damage_below(surface);
 406
 407         pixman_region32_fini(&surface->transform.boundingbox);
 408         pixman_region32_fini(&surface->transform.opaque);
 409         pixman_region32_init(&surface->transform.opaque);
 410
 411         if (region_is_undefined(&surface->input))
 412                 pixman_region32_init_rect(&surface->input, 0, 0,
 413                                           surface->geometry.width,
 414                                           surface->geometry.height);
 415
 416         /* transform.position is always in transformation_list */
 417         if (surface->geometry.transformation_list.next ==
 418             &surface->transform.position.link &&
 419             surface->geometry.transformation_list.prev ==
 420             &surface->transform.position.link) {
 421                 weston_surface_update_transform_disable(surface);
 422         } else {
 423                 if (weston_surface_update_transform_enable(surface) < 0)
 424                         weston_surface_update_transform_disable(surface);
 425         }
 426
 427         /* weston_surface_damage() without update */
 428         pixman_region32_union(&surface->damage, &surface->damage,
 429                               &surface->transform.boundingbox);
 430
 431         if (weston_surface_is_mapped(surface))
 432                 weston_surface_assign_output(surface);
 433
 434         weston_compositor_schedule_repaint(surface->compositor);
 435 }
 436
 437 WL_EXPORT void
 438 weston_surface_to_global_float(struct weston_surface *surface,
 439                                GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
 440 {
 441         surface_to_global_float(surface, sx, sy, x, y);
 442 }
 443
 444 WL_EXPORT void
 445 weston_surface_to_global_fixed(struct weston_surface *surface,
 446                                wl_fixed_t sx, wl_fixed_t sy,
 447                                wl_fixed_t *x, wl_fixed_t *y)
 448 {
 449         GLfloat xf, yf;
 450
 451         weston_surface_to_global_float(surface,
 452                                        wl_fixed_to_double(sx),
 453                                        wl_fixed_to_double(sy),
 454                                        &xf, &yf);
 455         *x = wl_fixed_from_double(xf);
 456         *y = wl_fixed_from_double(yf);
 457 }
 458
 459 WL_EXPORT void
 460 weston_surface_to_global(struct weston_surface *surface,
 461                          int32_t sx, int32_t sy, int32_t *x, int32_t *y)
 462 {
 463         GLfloat xf, yf;
 464
 465         weston_surface_to_global_float(surface, sx, sy, &xf, &yf);
 466         *x = floorf(xf);
 467         *y = floorf(yf);
 468 }
 469
 470 static void
 471 surface_from_global_float(struct weston_surface *surface,
 472                           GLfloat x, GLfloat y, GLfloat *sx, GLfloat *sy)
 473 {
 474         if (surface->transform.enabled) {
 475                 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
 476
 477                 weston_matrix_transform(&surface->transform.inverse, &v);
 478
 479                 if (fabsf(v.f[3]) < 1e-6) {
 480                         fprintf(stderr, "warning: numerical instability in "
 481                                 "weston_surface_from_global(), divisor = %g\n",
 482                                 v.f[3]);
 483                         *sx = 0;
 484                         *sy = 0;
 485                         return;
 486                 }
 487
 488                 *sx = v.f[0] / v.f[3];
 489                 *sy = v.f[1] / v.f[3];
 490         } else {
 491                 *sx = x - surface->geometry.x;
 492                 *sy = y - surface->geometry.y;
 493         }
 494 }
 495
 496 WL_EXPORT void
 497 weston_surface_from_global_fixed(struct weston_surface *surface,
 498                                  wl_fixed_t x, wl_fixed_t y,
 499                                  wl_fixed_t *sx, wl_fixed_t *sy)
 500 {
 501         GLfloat sxf, syf;
 502
 503         surface_from_global_float(surface,
 504                                   wl_fixed_to_double(x),
 505                                   wl_fixed_to_double(y),
 506                                   &sxf, &syf);
 507         *sx = wl_fixed_from_double(sxf);
 508         *sy = wl_fixed_from_double(syf);
 509 }
 510
 511 WL_EXPORT void
 512 weston_surface_from_global(struct weston_surface *surface,
 513                            int32_t x, int32_t y, int32_t *sx, int32_t *sy)
 514 {
 515         GLfloat sxf, syf;
 516
 517         surface_from_global_float(surface, x, y, &sxf, &syf);
 518         *sx = floorf(sxf);
 519         *sy = floorf(syf);
 520 }
 521
 522 static void
 523 weston_surface_damage_rectangle(struct weston_surface *surface,
 524                                 int32_t sx, int32_t sy,
 525                                 int32_t width, int32_t height)
 526 {
 527         if (surface->transform.enabled) {
 528                 pixman_region32_t box;
 529                 surface_compute_bbox(surface, sx, sy, width, height, &box);
 530                 pixman_region32_union(&surface->damage, &surface->damage,
 531                                       &box);
 532                 pixman_region32_fini(&box);
 533         } else {
 534                 pixman_region32_union_rect(&surface->damage, &surface->damage,
 535                                            surface->geometry.x + sx,
 536                                            surface->geometry.y + sy,
 537                                            width, height);
 538         }
 539
 540         weston_compositor_schedule_repaint(surface->compositor);
 541 }
 542
 543 WL_EXPORT void
 544 weston_surface_damage(struct weston_surface *surface)
 545 {
 546         pixman_region32_union(&surface->damage, &surface->damage,
 547                               &surface->transform.boundingbox);
 548
 549         weston_compositor_schedule_repaint(surface->compositor);
 550 }
 551
 552 WL_EXPORT void
 553 weston_surface_configure(struct weston_surface *surface,
 554                          GLfloat x, GLfloat y, int width, int height)
 555 {
 556         surface->geometry.x = x;
 557         surface->geometry.y = y;
 558         surface->geometry.width = width;
 559         surface->geometry.height = height;
 560         surface->geometry.dirty = 1;
 561 }
 562
 563 WL_EXPORT void
 564 weston_surface_set_position(struct weston_surface *surface,
 565                             GLfloat x, GLfloat y)
 566 {
 567         surface->geometry.x = x;
 568         surface->geometry.y = y;
 569         surface->geometry.dirty = 1;
 570 }
 571
 572 WL_EXPORT int
 573 weston_surface_is_mapped(struct weston_surface *surface)
 574 {
 575         if (surface->output)
 576                 return 1;
 577         else
 578                 return 0;
 579 }
 580
 581 WL_EXPORT uint32_t
 582 weston_compositor_get_time(void)
 583 {
 584        struct timeval tv;
 585
 586        gettimeofday(&tv, NULL);
 587
 588        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
 589 }
 590
 591 static struct weston_surface *
 592 weston_compositor_pick_surface(struct weston_compositor *compositor,
 593                                wl_fixed_t x, wl_fixed_t y,
 594                                wl_fixed_t *sx, wl_fixed_t *sy)
 595 {
 596         struct weston_surface *surface;
 597
 598         wl_list_for_each(surface, &compositor->surface_list, link) {
 599                 weston_surface_from_global_fixed(surface, x, y, sx, sy);
 600                 if (pixman_region32_contains_point(&surface->input,
 601                                                    wl_fixed_to_int(*sx),
 602                                                    wl_fixed_to_int(*sy),
 603                                                    NULL))
 604                         return surface;
 605         }
 606
 607         return NULL;
 608 }
 609
 610 static void
 611 weston_device_repick(struct wl_input_device *device)
 612 {
 613         struct weston_input_device *wd = (struct weston_input_device *) device;
 614         const struct wl_pointer_grab_interface *interface;
 615         struct weston_surface *surface, *focus;
 616
 617         surface = weston_compositor_pick_surface(wd->compositor,
 618                                                  device->x, device->y,
 619                                                  &device->current_x,
 620                                                  &device->current_y);
 621
 622         if (&surface->surface != device->current) {
 623                 interface = device->pointer_grab->interface;
 624                 interface->focus(device->pointer_grab, &surface->surface,
 625                                  device->current_x, device->current_y);
 626                 device->current = &surface->surface;
 627         }
 628
 629         focus = (struct weston_surface *) device->pointer_grab->focus;
 630         if (focus)
 631                 weston_surface_from_global_fixed(focus, device->x, device->y,
 632                                                  &device->pointer_grab->x,
 633                                                  &device->pointer_grab->y);
 634 }
 635
 636 WL_EXPORT void
 637 weston_compositor_repick(struct weston_compositor *compositor)
 638 {
 639         struct weston_input_device *device;
 640
 641         if (!compositor->focus)
 642                 return;
 643
 644         wl_list_for_each(device, &compositor->input_device_list, link)
 645                 weston_device_repick(&device->input_device);
 646 }
 647
 648 static void
 649 weston_surface_unmap(struct weston_surface *surface)
 650 {
 651         struct wl_input_device *device = surface->compositor->input_device;
 652
 653         weston_surface_damage_below(surface);
 654         surface->output = NULL;
 655         wl_list_remove(&surface->link);
 656         wl_list_remove(&surface->layer_link);
 657
 658         if (device->keyboard_focus == &surface->surface)
 659                 wl_input_device_set_keyboard_focus(device, NULL);
 660         if (device->pointer_focus == &surface->surface)
 661                 wl_input_device_set_pointer_focus(device, NULL,
 662                                                   wl_fixed_from_int(0),
 663                                                   wl_fixed_from_int(0));
 664
 665         weston_compositor_schedule_repaint(surface->compositor);
 666 }
 667
 668 static void
 669 destroy_surface(struct wl_resource *resource)
 670 {
 671         struct weston_surface *surface =
 672                 container_of(resource,
 673                              struct weston_surface, surface.resource);
 674         struct weston_compositor *compositor = surface->compositor;
 675
 676         if (weston_surface_is_mapped(surface))
 677                 weston_surface_unmap(surface);
 678
 679         if (surface->texture)
 680                 glDeleteTextures(1, &surface->texture);
 681
 682         if (surface->buffer)
 683                 wl_list_remove(&surface->buffer_destroy_listener.link);
 684
 685         if (surface->image != EGL_NO_IMAGE_KHR)
 686                 compositor->destroy_image(compositor->display,
 687                                           surface->image);
 688
 689         pixman_region32_fini(&surface->transform.boundingbox);
 690         pixman_region32_fini(&surface->damage);
 691         pixman_region32_fini(&surface->opaque);
 692         pixman_region32_fini(&surface->clip);
 693         if (!region_is_undefined(&surface->input))
 694                 pixman_region32_fini(&surface->input);
 695
 696         free(surface);
 697 }
 698
 699 WL_EXPORT void
 700 weston_surface_destroy(struct weston_surface *surface)
 701 {
 702         /* Not a valid way to destroy a client surface */
 703         assert(surface->surface.resource.client == NULL);
 704
 705         destroy_surface(&surface->surface.resource);
 706 }
 707
 708 static void
 709 weston_surface_attach(struct wl_surface *surface, struct wl_buffer *buffer)
 710 {
 711         struct weston_surface *es = (struct weston_surface *) surface;
 712         struct weston_compositor *ec = es->compositor;
 713
 714         if (es->buffer) {
 715                 weston_buffer_post_release(es->buffer);
 716                 wl_list_remove(&es->buffer_destroy_listener.link);
 717         }
 718
 719         es->buffer = buffer;
 720
 721         if (!buffer) {
 722                 if (weston_surface_is_mapped(es))
 723                         weston_surface_unmap(es);
 724                 return;
 725         }
 726
 727         buffer->busy_count++;
 728         wl_signal_add(&es->buffer->resource.destroy_signal,
 729                       &es->buffer_destroy_listener);
 730
 731         if (es->geometry.width != buffer->width ||
 732             es->geometry.height != buffer->height) {
 733                 undef_region(&es->input);
 734                 pixman_region32_fini(&es->opaque);
 735                 pixman_region32_init(&es->opaque);
 736         }
 737
 738         if (!es->texture) {
 739                 glGenTextures(1, &es->texture);
 740                 glBindTexture(GL_TEXTURE_2D, es->texture);
 741                 glTexParameteri(GL_TEXTURE_2D,
 742                                 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 743                 glTexParameteri(GL_TEXTURE_2D,
 744                                 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 745                 es->shader = &ec->texture_shader;
 746         } else {
 747                 glBindTexture(GL_TEXTURE_2D, es->texture);
 748         }
 749
 750         if (wl_buffer_is_shm(buffer)) {
 751                 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
 752                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
 753                              es->pitch, es->buffer->height, 0,
 754                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
 755         } else {
 756                 if (es->image != EGL_NO_IMAGE_KHR)
 757                         ec->destroy_image(ec->display, es->image);
 758                 es->image = ec->create_image(ec->display, NULL,
 759                                              EGL_WAYLAND_BUFFER_WL,
 760                                              buffer, NULL);
 761
 762                 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
 763
 764                 es->pitch = buffer->width;
 765         }
 766 }
 767
 768 static int
 769 texture_region(struct weston_surface *es, pixman_region32_t *region)
 770 {
 771         struct weston_compositor *ec = es->compositor;
 772         GLfloat *v, inv_width, inv_height;
 773         GLfloat sx, sy;
 774         pixman_box32_t *rectangles;
 775         unsigned int *p;
 776         int i, n;
 777
 778         rectangles = pixman_region32_rectangles(region, &n);
 779         v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
 780         p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
 781         inv_width = 1.0 / es->pitch;
 782         inv_height = 1.0 / es->geometry.height;
 783
 784         for (i = 0; i < n; i++, v += 16, p += 6) {
 785                 surface_from_global_float(es, rectangles[i].x1,
 786                                           rectangles[i].y1, &sx, &sy);
 787                 v[ 0] = rectangles[i].x1;
 788                 v[ 1] = rectangles[i].y1;
 789                 v[ 2] = sx * inv_width;
 790                 v[ 3] = sy * inv_height;
 791
 792                 surface_from_global_float(es, rectangles[i].x1,
 793                                           rectangles[i].y2, &sx, &sy);
 794                 v[ 4] = rectangles[i].x1;
 795                 v[ 5] = rectangles[i].y2;
 796                 v[ 6] = sx * inv_width;
 797                 v[ 7] = sy * inv_height;
 798
 799                 surface_from_global_float(es, rectangles[i].x2,
 800                                           rectangles[i].y1, &sx, &sy);
 801                 v[ 8] = rectangles[i].x2;
 802                 v[ 9] = rectangles[i].y1;
 803                 v[10] = sx * inv_width;
 804                 v[11] = sy * inv_height;
 805
 806                 surface_from_global_float(es, rectangles[i].x2,
 807                                           rectangles[i].y2, &sx, &sy);
 808                 v[12] = rectangles[i].x2;
 809                 v[13] = rectangles[i].y2;
 810                 v[14] = sx * inv_width;
 811                 v[15] = sy * inv_height;
 812
 813                 p[0] = i * 4 + 0;
 814                 p[1] = i * 4 + 1;
 815                 p[2] = i * 4 + 2;
 816                 p[3] = i * 4 + 2;
 817                 p[4] = i * 4 + 1;
 818                 p[5] = i * 4 + 3;
 819         }
 820
 821         return n;
 822 }
 823
 824 WL_EXPORT void
 825 weston_surface_draw(struct weston_surface *es, struct weston_output *output,
 826                     pixman_region32_t *damage)
 827 {
 828         struct weston_compositor *ec = es->compositor;
 829         GLfloat *v;
 830         pixman_region32_t repaint;
 831         GLint filter;
 832         int n;
 833
 834         pixman_region32_init(&repaint);
 835         pixman_region32_intersect(&repaint,
 836                                   &es->transform.boundingbox, damage);
 837         pixman_region32_subtract(&repaint, &repaint, &es->clip);
 838
 839         if (!pixman_region32_not_empty(&repaint))
 840                 goto out;
 841
 842         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 843         glEnable(GL_BLEND);
 844
 845         if (ec->current_shader != es->shader) {
 846                 glUseProgram(es->shader->program);
 847                 ec->current_shader = es->shader;
 848         }
 849
 850         glUniformMatrix4fv(es->shader->proj_uniform,
 851                            1, GL_FALSE, output->matrix.d);
 852         glUniform1i(es->shader->tex_uniform, 0);
 853         glUniform4fv(es->shader->color_uniform, 1, es->color);
 854         glUniform1f(es->shader->alpha_uniform, es->alpha / 255.0);
 855         glUniform1f(es->shader->brightness_uniform, es->brightness / 255.0);
 856         glUniform1f(es->shader->saturation_uniform, es->saturation / 255.0);
 857         glUniform1f(es->shader->texwidth_uniform,
 858                     (GLfloat)es->geometry.width / es->pitch);
 859
 860         if (es->transform.enabled || output->zoom.active)
 861                 filter = GL_LINEAR;
 862         else
 863                 filter = GL_NEAREST;
 864
 865         n = texture_region(es, &repaint);
 866
 867         glBindTexture(GL_TEXTURE_2D, es->texture);
 868         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
 869         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
 870
 871         v = ec->vertices.data;
 872         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
 873         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
 874         glEnableVertexAttribArray(0);
 875         glEnableVertexAttribArray(1);
 876
 877         glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
 878
 879         glDisableVertexAttribArray(1);
 880         glDisableVertexAttribArray(0);
 881
 882         ec->vertices.size = 0;
 883         ec->indices.size = 0;
 884
 885 out:
 886         pixman_region32_fini(&repaint);
 887 }
 888
 889 WL_EXPORT void
 890 weston_surface_restack(struct weston_surface *surface, struct wl_list *below)
 891 {
 892         wl_list_remove(&surface->layer_link);
 893         wl_list_insert(below, &surface->layer_link);
 894         weston_surface_damage_below(surface);
 895         weston_surface_damage(surface);
 896 }
 897
 898 WL_EXPORT void
 899 weston_compositor_damage_all(struct weston_compositor *compositor)
 900 {
 901         struct weston_output *output;
 902
 903         wl_list_for_each(output, &compositor->output_list, link)
 904                 weston_output_damage(output);
 905 }
 906
 907 WL_EXPORT void
 908 weston_buffer_post_release(struct wl_buffer *buffer)
 909 {
 910         if (--buffer->busy_count > 0)
 911                 return;
 912
 913         assert(buffer->resource.client != NULL);
 914         wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
 915 }
 916
 917 WL_EXPORT void
 918 weston_output_damage(struct weston_output *output)
 919 {
 920         struct weston_compositor *compositor = output->compositor;
 921
 922         pixman_region32_union(&compositor->damage,
 923                               &compositor->damage, &output->region);
 924         weston_compositor_schedule_repaint(compositor);
 925 }
 926
 927 static void
 928 fade_frame(struct weston_animation *animation,
 929            struct weston_output *output, uint32_t msecs)
 930 {
 931         struct weston_compositor *compositor =
 932                 container_of(animation,
 933                              struct weston_compositor, fade.animation);
 934         struct weston_surface *surface;
 935
 936         surface = compositor->fade.surface;
 937         weston_spring_update(&compositor->fade.spring, msecs);
 938         weston_surface_set_color(surface, 0.0, 0.0, 0.0,
 939                                  compositor->fade.spring.current);
 940         weston_surface_damage(surface);
 941
 942         if (weston_spring_done(&compositor->fade.spring)) {
 943                 compositor->fade.spring.current =
 944                         compositor->fade.spring.target;
 945                 wl_list_remove(&animation->link);
 946                 wl_list_init(&animation->link);
 947
 948                 if (compositor->fade.spring.current < 0.001) {
 949                         destroy_surface(&surface->surface.resource);
 950                         compositor->fade.surface = NULL;
 951                 } else if (compositor->fade.spring.current > 0.999) {
 952                         compositor->state = WESTON_COMPOSITOR_SLEEPING;
 953                         wl_signal_emit(&compositor->lock_signal, compositor);
 954                 }
 955         }
 956 }
 957
 958 struct weston_frame_callback {
 959         struct wl_resource resource;
 960         struct wl_list link;
 961 };
 962
 963 static void
 964 weston_output_repaint(struct weston_output *output, int msecs)
 965 {
 966         struct weston_compositor *ec = output->compositor;
 967         struct weston_surface *es;
 968         struct weston_layer *layer;
 969         struct weston_animation *animation, *next;
 970         struct weston_frame_callback *cb, *cnext;
 971         pixman_region32_t opaque, new_damage, output_damage;
 972         int32_t width, height;
 973
 974         weston_compositor_update_drag_surfaces(ec);
 975
 976         width = output->current->width +
 977                 output->border.left + output->border.right;
 978         height = output->current->height +
 979                 output->border.top + output->border.bottom;
 980         glViewport(0, 0, width, height);
 981
 982         /* Rebuild the surface list and update surface transforms up front. */
 983         wl_list_init(&ec->surface_list);
 984         wl_list_for_each(layer, &ec->layer_list, link) {
 985                 wl_list_for_each(es, &layer->surface_list, layer_link) {
 986                         weston_surface_update_transform(es);
 987                         wl_list_insert(ec->surface_list.prev, &es->link);
 988                 }
 989         }
 990
 991         if (output->assign_planes)
 992                 /*
 993                  * This will queue flips for the fbs and sprites where
 994                  * applicable and clear the damage for those surfaces.
 995                  * The repaint loop below will repaint everything
 996                  * else.
 997                  */
 998                 output->assign_planes(output);
 999
1000         pixman_region32_init(&new_damage);
1001         pixman_region32_init(&opaque);
1002
1003         wl_list_for_each(es, &ec->surface_list, link) {
1004                 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
1005                 pixman_region32_union(&new_damage, &new_damage, &es->damage);
1006                 empty_region(&es->damage);
1007                 pixman_region32_copy(&es->clip, &opaque);
1008                 pixman_region32_union(&opaque, &opaque, &es->transform.opaque);
1009         }
1010
1011         pixman_region32_union(&ec->damage, &ec->damage, &new_damage);
1012
1013         pixman_region32_init(&output_damage);
1014         pixman_region32_union(&output_damage,
1015                               &ec->damage, &output->previous_damage);
1016         pixman_region32_copy(&output->previous_damage, &ec->damage);
1017         pixman_region32_intersect(&output_damage,
1018                                   &output_damage, &output->region);
1019         pixman_region32_subtract(&ec->damage, &ec->damage, &output->region);
1020
1021         pixman_region32_fini(&opaque);
1022         pixman_region32_fini(&new_damage);
1023
1024         if (output->dirty)
1025                 weston_output_update_matrix(output);
1026
1027         output->repaint(output, &output_damage);
1028
1029         pixman_region32_fini(&output_damage);
1030
1031         output->repaint_needed = 0;
1032
1033         weston_compositor_repick(ec);
1034         wl_event_loop_dispatch(ec->input_loop, 0);
1035
1036         wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
1037                 wl_callback_send_done(&cb->resource, msecs);
1038                 wl_resource_destroy(&cb->resource);
1039         }
1040
1041         wl_list_for_each_safe(animation, next, &ec->animation_list, link)
1042                 animation->frame(animation, output, msecs);
1043 }
1044
1045 static int
1046 weston_compositor_read_input(int fd, uint32_t mask, void *data)
1047 {
1048         struct weston_compositor *compositor = data;
1049
1050         wl_event_loop_dispatch(compositor->input_loop, 0);
1051
1052         return 1;
1053 }
1054
1055 WL_EXPORT void
1056 weston_output_finish_frame(struct weston_output *output, int msecs)
1057 {
1058         struct weston_compositor *compositor = output->compositor;
1059         struct wl_event_loop *loop =
1060                 wl_display_get_event_loop(compositor->wl_display);
1061         int fd;
1062
1063         if (output->repaint_needed) {
1064                 weston_output_repaint(output, msecs);
1065                 return;
1066         }
1067
1068         output->repaint_scheduled = 0;
1069         if (compositor->input_loop_source)
1070                 return;
1071
1072         fd = wl_event_loop_get_fd(compositor->input_loop);
1073         compositor->input_loop_source =
1074                 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1075                                      weston_compositor_read_input, compositor);
1076 }
1077
1078 static void
1079 idle_repaint(void *data)
1080 {
1081         struct weston_output *output = data;
1082
1083         weston_output_finish_frame(output, weston_compositor_get_time());
1084 }
1085
1086 WL_EXPORT void
1087 weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1088 {
1089         wl_list_init(&layer->surface_list);
1090         wl_list_insert(below, &layer->link);
1091 }
1092
1093 WL_EXPORT void
1094 weston_compositor_schedule_repaint(struct weston_compositor *compositor)
1095 {
1096         struct weston_output *output;
1097         struct wl_event_loop *loop;
1098
1099         if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
1100                 return;
1101
1102         loop = wl_display_get_event_loop(compositor->wl_display);
1103         wl_list_for_each(output, &compositor->output_list, link) {
1104                 output->repaint_needed = 1;
1105                 if (output->repaint_scheduled)
1106                         continue;
1107
1108                 wl_event_loop_add_idle(loop, idle_repaint, output);
1109                 output->repaint_scheduled = 1;
1110         }
1111
1112         if (compositor->input_loop_source) {
1113                 wl_event_source_remove(compositor->input_loop_source);
1114                 compositor->input_loop_source = NULL;
1115         }
1116 }
1117
1118 WL_EXPORT void
1119 weston_compositor_fade(struct weston_compositor *compositor, float tint)
1120 {
1121         struct weston_surface *surface;
1122         int done;
1123
1124         done = weston_spring_done(&compositor->fade.spring);
1125         compositor->fade.spring.target = tint;
1126         if (weston_spring_done(&compositor->fade.spring))
1127                 return;
1128
1129         if (done)
1130                 compositor->fade.spring.timestamp =
1131                         weston_compositor_get_time();
1132
1133         if (compositor->fade.surface == NULL) {
1134                 surface = weston_surface_create(compositor);
1135                 weston_surface_configure(surface, 0, 0, 8192, 8192);
1136                 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
1137                 wl_list_insert(&compositor->fade_layer.surface_list,
1138                                &surface->layer_link);
1139                 weston_surface_assign_output(surface);
1140                 compositor->fade.surface = surface;
1141                 pixman_region32_init(&surface->input);
1142         }
1143
1144         weston_surface_damage(compositor->fade.surface);
1145         if (wl_list_empty(&compositor->fade.animation.link))
1146                 wl_list_insert(compositor->animation_list.prev,
1147                                &compositor->fade.animation.link);
1148 }
1149
1150 static void
1151 surface_destroy(struct wl_client *client, struct wl_resource *resource)
1152 {
1153         wl_resource_destroy(resource);
1154 }
1155
1156 static struct wl_resource *
1157 find_resource_for_client(struct wl_list *list, struct wl_client *client)
1158 {
1159         struct wl_resource *r;
1160
1161         wl_list_for_each(r, list, link) {
1162                 if (r->client == client)
1163                         return r;
1164         }
1165
1166         return NULL;
1167 }
1168
1169 static void
1170 weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
1171 {
1172         uint32_t different = es->output_mask ^ mask;
1173         uint32_t entered = mask & different;
1174         uint32_t left = es->output_mask & different;
1175         struct weston_output *output;
1176         struct wl_resource *resource;
1177         struct wl_client *client = es->surface.resource.client;
1178
1179         if (es->surface.resource.client == NULL)
1180                 return;
1181         if (different == 0)
1182                 return;
1183
1184         es->output_mask = mask;
1185         wl_list_for_each(output, &es->compositor->output_list, link) {
1186                 if (1 << output->id & different)
1187                         resource =
1188                                 find_resource_for_client(&output->resource_list,
1189                                                          client);
1190                 if (1 << output->id & entered)
1191                         wl_surface_send_enter(&es->surface.resource, resource);
1192                 if (1 << output->id & left)
1193                         wl_surface_send_leave(&es->surface.resource, resource);
1194         }
1195 }
1196
1197 WL_EXPORT void
1198 weston_surface_assign_output(struct weston_surface *es)
1199 {
1200         struct weston_compositor *ec = es->compositor;
1201         struct weston_output *output, *new_output;
1202         pixman_region32_t region;
1203         uint32_t max, area, mask;
1204         pixman_box32_t *e;
1205
1206         new_output = NULL;
1207         max = 0;
1208         mask = 0;
1209         pixman_region32_init(&region);
1210         wl_list_for_each(output, &ec->output_list, link) {
1211                 pixman_region32_intersect(&region, &es->transform.boundingbox,
1212                                           &output->region);
1213
1214                 e = pixman_region32_extents(&region);
1215                 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1216
1217                 if (area > 0)
1218                         mask |= 1 << output->id;
1219
1220                 if (area >= max) {
1221                         new_output = output;
1222                         max = area;
1223                 }
1224         }
1225         pixman_region32_fini(&region);
1226
1227         es->output = new_output;
1228         weston_surface_update_output_mask(es, mask);
1229
1230         if (!wl_list_empty(&es->frame_callback_list)) {
1231                 wl_list_insert_list(new_output->frame_callback_list.prev,
1232                                     &es->frame_callback_list);
1233                 wl_list_init(&es->frame_callback_list);
1234         }
1235 }
1236
1237 static void
1238 surface_attach(struct wl_client *client,
1239                struct wl_resource *resource,
1240                struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1241 {
1242         struct weston_surface *es = resource->data;
1243         struct wl_buffer *buffer = NULL;
1244
1245         if (buffer_resource)
1246                 buffer = buffer_resource->data;
1247
1248         weston_surface_attach(&es->surface, buffer);
1249
1250         if (buffer && es->configure)
1251                 es->configure(es, sx, sy);
1252 }
1253
1254 static void
1255 texture_set_subimage(struct weston_surface *surface,
1256                      int32_t x, int32_t y, int32_t width, int32_t height)
1257 {
1258         glBindTexture(GL_TEXTURE_2D, surface->texture);
1259
1260 #ifdef GL_UNPACK_ROW_LENGTH
1261         /* Mesa does not define GL_EXT_unpack_subimage */
1262
1263         if (surface->compositor->has_unpack_subimage) {
1264                 glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->pitch);
1265                 glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
1266                 glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
1267
1268                 glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height,
1269                                 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1270                                 wl_shm_buffer_get_data(surface->buffer));
1271                 return;
1272         }
1273 #endif
1274
1275         glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1276                      surface->pitch, surface->buffer->height, 0,
1277                      GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1278                      wl_shm_buffer_get_data(surface->buffer));
1279 }
1280
1281 static void
1282 surface_damage(struct wl_client *client,
1283                struct wl_resource *resource,
1284                int32_t x, int32_t y, int32_t width, int32_t height)
1285 {
1286         struct weston_surface *es = resource->data;
1287
1288         weston_surface_damage_rectangle(es, x, y, width, height);
1289
1290         if (es->buffer && wl_buffer_is_shm(es->buffer))
1291                 texture_set_subimage(es, x, y, width, height);
1292 }
1293
1294 static void
1295 destroy_frame_callback(struct wl_resource *resource)
1296 {
1297         struct weston_frame_callback *cb = resource->data;
1298
1299         wl_list_remove(&cb->link);
1300         free(cb);
1301 }
1302
1303 static void
1304 surface_frame(struct wl_client *client,
1305               struct wl_resource *resource, uint32_t callback)
1306 {
1307         struct weston_frame_callback *cb;
1308         struct weston_surface *es = resource->data;
1309
1310         cb = malloc(sizeof *cb);
1311         if (cb == NULL) {
1312                 wl_resource_post_no_memory(resource);
1313                 return;
1314         }
1315
1316         cb->resource.object.interface = &wl_callback_interface;
1317         cb->resource.object.id = callback;
1318         cb->resource.destroy = destroy_frame_callback;
1319         cb->resource.client = client;
1320         cb->resource.data = cb;
1321
1322         wl_client_add_resource(client, &cb->resource);
1323
1324         if (es->output) {
1325                 wl_list_insert(es->output->frame_callback_list.prev,
1326                                &cb->link);
1327         } else {
1328                 wl_list_insert(es->frame_callback_list.prev, &cb->link);
1329         }
1330 }
1331
1332 static void
1333 surface_set_opaque_region(struct wl_client *client,
1334                           struct wl_resource *resource,
1335                           struct wl_resource *region_resource)
1336 {
1337         struct weston_surface *surface = resource->data;
1338         struct weston_region *region;
1339
1340         pixman_region32_fini(&surface->opaque);
1341
1342         if (region_resource) {
1343                 region = region_resource->data;
1344                 pixman_region32_init_rect(&surface->opaque, 0, 0,
1345                                           surface->geometry.width,
1346                                           surface->geometry.height);
1347                 pixman_region32_intersect(&surface->opaque,
1348                                           &surface->opaque, &region->region);
1349         } else {
1350                 pixman_region32_init(&surface->opaque);
1351         }
1352
1353         surface->geometry.dirty = 1;
1354 }
1355
1356 static void
1357 surface_set_input_region(struct wl_client *client,
1358                          struct wl_resource *resource,
1359                          struct wl_resource *region_resource)
1360 {
1361         struct weston_surface *surface = resource->data;
1362         struct weston_region *region;
1363
1364         if (region_resource) {
1365                 region = region_resource->data;
1366                 pixman_region32_init_rect(&surface->input, 0, 0,
1367                                           surface->geometry.width,
1368                                           surface->geometry.height);
1369                 pixman_region32_intersect(&surface->input,
1370                                           &surface->input, &region->region);
1371         } else {
1372                 pixman_region32_init_rect(&surface->input, 0, 0,
1373                                           surface->geometry.width,
1374                                           surface->geometry.height);
1375         }
1376
1377         weston_compositor_schedule_repaint(surface->compositor);
1378 }
1379
1380 static const struct wl_surface_interface surface_interface = {
1381         surface_destroy,
1382         surface_attach,
1383         surface_damage,
1384         surface_frame,
1385         surface_set_opaque_region,
1386         surface_set_input_region
1387 };
1388
1389 static void
1390 compositor_create_surface(struct wl_client *client,
1391                           struct wl_resource *resource, uint32_t id)
1392 {
1393         struct weston_compositor *ec = resource->data;
1394         struct weston_surface *surface;
1395
1396         surface = weston_surface_create(ec);
1397         if (surface == NULL) {
1398                 wl_resource_post_no_memory(resource);
1399                 return;
1400         }
1401
1402         surface->surface.resource.destroy = destroy_surface;
1403
1404         surface->surface.resource.object.id = id;
1405         surface->surface.resource.object.interface = &wl_surface_interface;
1406         surface->surface.resource.object.implementation =
1407                 (void (**)(void)) &surface_interface;
1408         surface->surface.resource.data = surface;
1409
1410         wl_client_add_resource(client, &surface->surface.resource);
1411 }
1412
1413 static void
1414 destroy_region(struct wl_resource *resource)
1415 {
1416         struct weston_region *region =
1417                 container_of(resource, struct weston_region, resource);
1418
1419         pixman_region32_fini(&region->region);
1420         free(region);
1421 }
1422
1423 static void
1424 region_destroy(struct wl_client *client, struct wl_resource *resource)
1425 {
1426         wl_resource_destroy(resource);
1427 }
1428
1429 static void
1430 region_add(struct wl_client *client, struct wl_resource *resource,
1431            int32_t x, int32_t y, int32_t width, int32_t height)
1432 {
1433         struct weston_region *region = resource->data;
1434
1435         pixman_region32_union_rect(&region->region, &region->region,
1436                                    x, y, width, height);
1437 }
1438
1439 static void
1440 region_subtract(struct wl_client *client, struct wl_resource *resource,
1441                 int32_t x, int32_t y, int32_t width, int32_t height)
1442 {
1443         struct weston_region *region = resource->data;
1444         pixman_region32_t rect;
1445
1446         pixman_region32_init_rect(&rect, x, y, width, height);
1447         pixman_region32_subtract(&region->region, &region->region, &rect);
1448         pixman_region32_fini(&rect);
1449 }
1450
1451 static const struct wl_region_interface region_interface = {
1452         region_destroy,
1453         region_add,
1454         region_subtract
1455 };
1456
1457 static void
1458 compositor_create_region(struct wl_client *client,
1459                          struct wl_resource *resource, uint32_t id)
1460 {
1461         struct weston_region *region;
1462
1463         region = malloc(sizeof *region);
1464         if (region == NULL) {
1465                 wl_resource_post_no_memory(resource);
1466                 return;
1467         }
1468
1469         region->resource.destroy = destroy_region;
1470
1471         region->resource.object.id = id;
1472         region->resource.object.interface = &wl_region_interface;
1473         region->resource.object.implementation =
1474                 (void (**)(void)) &region_interface;
1475         region->resource.data = region;
1476
1477         pixman_region32_init(&region->region);
1478
1479         wl_client_add_resource(client, &region->resource);
1480 }
1481
1482 static const struct wl_compositor_interface compositor_interface = {
1483         compositor_create_surface,
1484         compositor_create_region
1485 };
1486
1487 WL_EXPORT void
1488 weston_compositor_wake(struct weston_compositor *compositor)
1489 {
1490         compositor->state = WESTON_COMPOSITOR_ACTIVE;
1491         weston_compositor_fade(compositor, 0.0);
1492
1493         wl_event_source_timer_update(compositor->idle_source,
1494                                      compositor->idle_time * 1000);
1495 }
1496
1497 static void
1498 weston_compositor_dpms_on(struct weston_compositor *compositor)
1499 {
1500         struct weston_output *output;
1501
1502         wl_list_for_each(output, &compositor->output_list, link)
1503                 if (output->set_dpms)
1504                         output->set_dpms(output, WESTON_DPMS_ON);
1505 }
1506
1507 WL_EXPORT void
1508 weston_compositor_activity(struct weston_compositor *compositor)
1509 {
1510         if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1511                 weston_compositor_wake(compositor);
1512         } else {
1513                 weston_compositor_dpms_on(compositor);
1514                 wl_signal_emit(&compositor->unlock_signal, compositor);
1515         }
1516 }
1517
1518 static void
1519 weston_compositor_idle_inhibit(struct weston_compositor *compositor)
1520 {
1521         weston_compositor_activity(compositor);
1522         compositor->idle_inhibit++;
1523 }
1524
1525 static void
1526 weston_compositor_idle_release(struct weston_compositor *compositor)
1527 {
1528         compositor->idle_inhibit--;
1529         weston_compositor_activity(compositor);
1530 }
1531
1532 static int
1533 idle_handler(void *data)
1534 {
1535         struct weston_compositor *compositor = data;
1536
1537         if (compositor->idle_inhibit)
1538                 return 1;
1539
1540         weston_compositor_fade(compositor, 1.0);
1541
1542         return 1;
1543 }
1544
1545 static  void
1546 weston_input_update_drag_surface(struct wl_input_device *input_device,
1547                                  int dx, int dy);
1548
1549 static void
1550 clip_pointer_motion(struct weston_input_device *device,
1551                     wl_fixed_t *fx, wl_fixed_t *fy)
1552 {
1553         struct weston_compositor *ec = device->compositor;
1554         struct weston_output *output, *prev = NULL;
1555         int x, y, old_x, old_y, valid = 0;
1556
1557         x = wl_fixed_to_int(*fx);
1558         y = wl_fixed_to_int(*fy);
1559         old_x = wl_fixed_to_int(device->input_device.x);
1560         old_y = wl_fixed_to_int(device->input_device.y);
1561
1562         wl_list_for_each(output, &ec->output_list, link) {
1563                 if (pixman_region32_contains_point(&output->region,
1564                                                    x, y, NULL))
1565                         valid = 1;
1566                 if (pixman_region32_contains_point(&output->region,
1567                                                    old_x, old_y, NULL))
1568                         prev = output;
1569         }
1570
1571         if (!valid) {
1572                 if (x < prev->x)
1573                         *fx = wl_fixed_from_int(prev->x);
1574                 else if (x >= prev->x + prev->current->width)
1575                         *fx = wl_fixed_from_int(prev->x +
1576                                                 prev->current->width - 1);
1577                 if (y < prev->y)
1578                         *fy = wl_fixed_from_int(prev->y);
1579                 else if (y >= prev->y + prev->current->height)
1580                         *fy = wl_fixed_from_int(prev->y +
1581                                                 prev->current->height - 1);
1582         }
1583 }
1584
1585 WL_EXPORT void
1586 notify_motion(struct wl_input_device *device,
1587               uint32_t time, wl_fixed_t x, wl_fixed_t y)
1588 {
1589         const struct wl_pointer_grab_interface *interface;
1590         struct weston_input_device *wd = (struct weston_input_device *) device;
1591         struct weston_compositor *ec = wd->compositor;
1592         struct weston_output *output;
1593         int32_t ix, iy;
1594
1595         weston_compositor_activity(ec);
1596
1597         clip_pointer_motion(wd, &x, &y);
1598
1599         weston_input_update_drag_surface(device,
1600                                          x - device->x, y - device->y);
1601
1602         device->x = x;
1603         device->y = y;
1604
1605         ix = wl_fixed_to_int(x);
1606         iy = wl_fixed_to_int(y);
1607
1608         wl_list_for_each(output, &ec->output_list, link)
1609                 if (output->zoom.active &&
1610                     pixman_region32_contains_point(&output->region,
1611                                                    ix, iy, NULL))
1612                         weston_output_update_zoom(output, x, y);
1613
1614         weston_device_repick(device);
1615         interface = device->pointer_grab->interface;
1616         interface->motion(device->pointer_grab, time,
1617                           device->pointer_grab->x, device->pointer_grab->y);
1618
1619         if (wd->sprite) {
1620                 weston_surface_set_position(wd->sprite,
1621                                             ix - wd->hotspot_x,
1622                                             iy - wd->hotspot_y);
1623                 weston_compositor_schedule_repaint(ec);
1624         }
1625 }
1626
1627 WL_EXPORT void
1628 weston_surface_activate(struct weston_surface *surface,
1629                         struct weston_input_device *device)
1630 {
1631         struct weston_compositor *compositor = device->compositor;
1632
1633         wl_input_device_set_keyboard_focus(&device->input_device,
1634                                            &surface->surface);
1635         wl_data_device_set_keyboard_focus(&device->input_device);
1636
1637         wl_signal_emit(&compositor->activate_signal, surface);
1638 }
1639
1640 WL_EXPORT void
1641 notify_button(struct wl_input_device *device,
1642               uint32_t time, int32_t button, uint32_t state)
1643 {
1644         struct weston_input_device *wd = (struct weston_input_device *) device;
1645         struct weston_compositor *compositor = wd->compositor;
1646         struct weston_surface *focus = (struct weston_surface *) device->pointer_focus;
1647         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1648
1649         if (state) {
1650                 if (compositor->ping_handler && focus)
1651                         compositor->ping_handler(focus, serial);
1652                 weston_compositor_idle_inhibit(compositor);
1653                 if (device->button_count == 0) {
1654                         device->grab_button = button;
1655                         device->grab_time = time;
1656                         device->grab_x = device->x;
1657                         device->grab_y = device->y;
1658                 }
1659                 device->button_count++;
1660         } else {
1661                 weston_compositor_idle_release(compositor);
1662                 device->button_count--;
1663         }
1664
1665         weston_compositor_run_binding(compositor, wd, time, 0, button, 0, state);
1666
1667         device->pointer_grab->interface->button(device->pointer_grab, time, button, state);
1668
1669         if (device->button_count == 1)
1670                 device->grab_serial =
1671                         wl_display_get_serial(compositor->wl_display);
1672 }
1673
1674 WL_EXPORT void
1675 notify_axis(struct wl_input_device *device,
1676               uint32_t time, uint32_t axis, int32_t value)
1677 {
1678         struct weston_input_device *wd = (struct weston_input_device *) device;
1679         struct weston_compositor *compositor = wd->compositor;
1680         struct weston_surface *focus = (struct weston_surface *) device->pointer_focus;
1681         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1682
1683         if (compositor->ping_handler && focus)
1684                 compositor->ping_handler(focus, serial);
1685
1686         weston_compositor_activity(compositor);
1687
1688         if (value)
1689                 weston_compositor_run_binding(compositor, wd,
1690                                                 time, 0, 0, axis, value);
1691         else
1692                 return;
1693
1694         if (device->pointer_focus_resource)
1695                 wl_resource_post_event(device->pointer_focus_resource,
1696                                 WL_INPUT_DEVICE_AXIS, time, axis, value);
1697 }
1698
1699 static void
1700 update_modifier_state(struct weston_input_device *device,
1701                       uint32_t key, uint32_t state)
1702 {
1703         uint32_t modifier;
1704
1705         switch (key) {
1706         case KEY_LEFTCTRL:
1707         case KEY_RIGHTCTRL:
1708                 modifier = MODIFIER_CTRL;
1709                 break;
1710
1711         case KEY_LEFTALT:
1712         case KEY_RIGHTALT:
1713                 modifier = MODIFIER_ALT;
1714                 break;
1715
1716         case KEY_LEFTMETA:
1717         case KEY_RIGHTMETA:
1718                 modifier = MODIFIER_SUPER;
1719                 break;
1720
1721         default:
1722                 modifier = 0;
1723                 break;
1724         }
1725
1726         if (state)
1727                 device->modifier_state |= modifier;
1728         else
1729                 device->modifier_state &= ~modifier;
1730 }
1731
1732 WL_EXPORT void
1733 notify_key(struct wl_input_device *device,
1734            uint32_t time, uint32_t key, uint32_t state)
1735 {
1736         struct weston_input_device *wd = (struct weston_input_device *) device;
1737         struct weston_compositor *compositor = wd->compositor;
1738         struct weston_surface *focus = (struct weston_surface *) device->pointer_focus;
1739         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1740         uint32_t *k, *end;
1741
1742         if (state) {
1743                 if (compositor->ping_handler && focus)
1744                         compositor->ping_handler(focus, serial);
1745
1746                 weston_compositor_idle_inhibit(compositor);
1747                 device->grab_key = key;
1748                 device->grab_time = time;
1749         } else {
1750                 weston_compositor_idle_release(compositor);
1751         }
1752
1753         update_modifier_state(wd, key, state);
1754         end = device->keys.data + device->keys.size;
1755         for (k = device->keys.data; k < end; k++) {
1756                 if (*k == key)
1757                         *k = *--end;
1758         }
1759         device->keys.size = (void *) end - device->keys.data;
1760         if (state) {
1761                 k = wl_array_add(&device->keys, sizeof *k);
1762                 *k = key;
1763         }
1764
1765         if (device->keyboard_grab == &device->default_keyboard_grab)
1766                 weston_compositor_run_binding(compositor, wd,
1767                                               time, key, 0, 0, state);
1768
1769         device->keyboard_grab->interface->key(device->keyboard_grab,
1770                                               time, key, state);
1771 }
1772
1773 WL_EXPORT void
1774 notify_pointer_focus(struct wl_input_device *device,
1775                      struct weston_output *output, wl_fixed_t x, wl_fixed_t y)
1776 {
1777         struct weston_input_device *wd = (struct weston_input_device *) device;
1778         struct weston_compositor *compositor = wd->compositor;
1779
1780         if (output) {
1781                 weston_input_update_drag_surface(device,
1782                                                  x - device->x, y - device->y);
1783
1784                 device->x = x;
1785                 device->y = y;
1786                 compositor->focus = 1;
1787                 weston_compositor_repick(compositor);
1788         } else {
1789                 compositor->focus = 0;
1790                 weston_compositor_repick(compositor);
1791         }
1792 }
1793
1794 static void
1795 destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
1796 {
1797         struct weston_input_device *wd;
1798
1799         wd = container_of(listener, struct weston_input_device,
1800                           saved_kbd_focus_listener);
1801
1802         wd->saved_kbd_focus = NULL;
1803 }
1804
1805 WL_EXPORT void
1806 notify_keyboard_focus(struct wl_input_device *device, struct wl_array *keys)
1807 {
1808         struct weston_input_device *wd =
1809                 (struct weston_input_device *) device;
1810         struct weston_compositor *compositor = wd->compositor;
1811         struct wl_surface *surface;
1812         uint32_t *k;
1813
1814         if (keys) {
1815                 wl_array_copy(&wd->input_device.keys, keys);
1816                 wd->modifier_state = 0;
1817                 wl_array_for_each(k, &device->keys) {
1818                         weston_compositor_idle_inhibit(compositor);
1819                         update_modifier_state(wd, *k, 1);
1820                 }
1821
1822                 surface = wd->saved_kbd_focus;
1823
1824                 if (surface) {
1825                         wl_list_remove(&wd->saved_kbd_focus_listener.link);
1826                         wl_input_device_set_keyboard_focus(&wd->input_device,
1827                                                            surface);
1828                         wd->saved_kbd_focus = NULL;
1829                 }
1830         } else {
1831                 wl_array_for_each(k, &device->keys)
1832                         weston_compositor_idle_release(compositor);
1833
1834                 wd->modifier_state = 0;
1835
1836                 surface = wd->input_device.keyboard_focus;
1837
1838                 if (surface) {
1839                         wd->saved_kbd_focus = surface;
1840                         wd->saved_kbd_focus_listener.notify =
1841                                 destroy_device_saved_kbd_focus;
1842                         wl_signal_add(&surface->resource.destroy_signal,
1843                                       &wd->saved_kbd_focus_listener);
1844                 }
1845
1846                 wl_input_device_set_keyboard_focus(&wd->input_device, NULL);
1847                 /* FIXME: We really need keyboard grab cancel here to
1848                  * let the grab shut down properly.  As it is we leak
1849                  * the grab data. */
1850                 wl_input_device_end_keyboard_grab(&wd->input_device);
1851         }
1852 }
1853
1854 static void
1855 lose_touch_focus_resource(struct wl_listener *listener, void *data)
1856 {
1857         struct weston_input_device *device =
1858                 container_of(listener, struct weston_input_device,
1859                              touch_focus_resource_listener);
1860
1861         device->touch_focus_resource = NULL;
1862 }
1863
1864 static void
1865 lose_touch_focus(struct wl_listener *listener, void *data)
1866 {
1867         struct weston_input_device *device =
1868                 container_of(listener, struct weston_input_device,
1869                              touch_focus_listener);
1870
1871         device->touch_focus = NULL;
1872 }
1873
1874 static void
1875 touch_set_focus(struct weston_input_device *device,
1876                 struct wl_surface *surface)
1877 {
1878         struct wl_input_device *input_device = &device->input_device;
1879         struct wl_resource *resource;
1880
1881         if (device->touch_focus == surface)
1882                 return;
1883
1884         if (surface) {
1885                 resource =
1886                         find_resource_for_client(&input_device->resource_list,
1887                                                  surface->resource.client);
1888                 if (!resource) {
1889                         fprintf(stderr, "couldn't find resource\n");
1890                         return;
1891                 }
1892
1893                 device->touch_focus_resource_listener.notify =
1894                         lose_touch_focus_resource;
1895                 wl_signal_add(&resource->destroy_signal,
1896                               &device->touch_focus_resource_listener);
1897                 device->touch_focus_listener.notify = lose_touch_focus;
1898                 wl_signal_add(&surface->resource.destroy_signal,
1899                                &device->touch_focus_listener);
1900
1901                 device->touch_focus = surface;
1902                 device->touch_focus_resource = resource;
1903         } else {
1904                 if (device->touch_focus)
1905                         wl_list_remove(&device->touch_focus_listener.link);
1906                 if (device->touch_focus_resource)
1907                         wl_list_remove(&device->touch_focus_resource_listener.link);
1908                 device->touch_focus = NULL;
1909                 device->touch_focus_resource = NULL;
1910         }
1911 }
1912
1913 /**
1914  * notify_touch - emulates button touches and notifies surfaces accordingly.
1915  *
1916  * It assumes always the correct cycle sequence until it gets here: touch_down
1917  * → touch_update → ... → touch_update → touch_end. The driver is responsible
1918  * for sending along such order.
1919  *
1920  */
1921 WL_EXPORT void
1922 notify_touch(struct wl_input_device *device, uint32_t time, int touch_id,
1923              wl_fixed_t x, wl_fixed_t y, int touch_type)
1924 {
1925         struct weston_input_device *wd = (struct weston_input_device *) device;
1926         struct weston_compositor *ec = wd->compositor;
1927         struct weston_surface *es;
1928         wl_fixed_t sx, sy;
1929         uint32_t serial = 0;
1930
1931         switch (touch_type) {
1932         case WL_INPUT_DEVICE_TOUCH_DOWN:
1933                 weston_compositor_idle_inhibit(ec);
1934
1935                 wd->num_tp++;
1936
1937                 /* the first finger down picks the surface, and all further go
1938                  * to that surface for the remainder of the touch session i.e.
1939                  * until all touch points are up again. */
1940                 if (wd->num_tp == 1) {
1941                         es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
1942                         touch_set_focus(wd, &es->surface);
1943                 } else if (wd->touch_focus) {
1944                         es = (struct weston_surface *) wd->touch_focus;
1945                         weston_surface_from_global_fixed(es, x, y, &sx, &sy);
1946                 }
1947
1948                 if (wd->touch_focus_resource && wd->touch_focus)
1949                         wl_input_device_send_touch_down(wd->touch_focus_resource,
1950                                                         serial, time,
1951                                                         &wd->touch_focus->resource,
1952                                                         touch_id, sx, sy);
1953                 break;
1954         case WL_INPUT_DEVICE_TOUCH_MOTION:
1955                 es = (struct weston_surface *) wd->touch_focus;
1956                 if (!es)
1957                         break;
1958
1959                 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
1960                 if (wd->touch_focus_resource)
1961                         wl_input_device_send_touch_motion(wd->touch_focus_resource,
1962                                                           time, touch_id, sx, sy);
1963                 break;
1964         case WL_INPUT_DEVICE_TOUCH_UP:
1965                 weston_compositor_idle_release(ec);
1966                 wd->num_tp--;
1967
1968                 if (wd->touch_focus_resource)
1969                         wl_input_device_send_touch_up(wd->touch_focus_resource,
1970                                                       serial, time, touch_id);
1971                 if (wd->num_tp == 0)
1972                         touch_set_focus(wd, NULL);
1973                 break;
1974         }
1975 }
1976
1977 static void
1978 input_device_attach(struct wl_client *client,
1979                     struct wl_resource *resource,
1980                     uint32_t serial,
1981                     struct wl_resource *buffer_resource, int32_t x, int32_t y)
1982 {
1983         struct weston_input_device *device = resource->data;
1984         struct weston_compositor *compositor = device->compositor;
1985         struct wl_buffer *buffer = NULL;
1986
1987         if (serial < device->input_device.pointer_focus_serial)
1988                 return;
1989         if (device->input_device.pointer_focus == NULL)
1990                 return;
1991         if (device->input_device.pointer_focus->resource.client != client)
1992                 return;
1993
1994         if (buffer_resource)
1995                 buffer = buffer_resource->data;
1996
1997         weston_surface_attach(&device->sprite->surface, buffer);
1998         empty_region(&device->sprite->input);
1999
2000         if (!buffer)
2001                 return;
2002
2003         if (!weston_surface_is_mapped(device->sprite)) {
2004                 wl_list_insert(&compositor->cursor_layer.surface_list,
2005                                &device->sprite->layer_link);
2006                 weston_surface_assign_output(device->sprite);
2007         }
2008
2009
2010         device->hotspot_x = x;
2011         device->hotspot_y = y;
2012         weston_surface_configure(device->sprite,
2013                                  wl_fixed_to_int(device->input_device.x) - x,
2014                                  wl_fixed_to_int(device->input_device.y) - y,
2015                                  buffer->width, buffer->height);
2016
2017         surface_damage(NULL, &device->sprite->surface.resource,
2018                        0, 0, buffer->width, buffer->height);
2019 }
2020
2021 static const struct wl_input_device_interface input_device_interface = {
2022         input_device_attach,
2023 };
2024
2025 static void
2026 handle_drag_surface_destroy(struct wl_listener *listener, void *data)
2027 {
2028         struct weston_input_device *device;
2029
2030         device = container_of(listener, struct weston_input_device,
2031                               drag_surface_destroy_listener);
2032
2033         device->drag_surface = NULL;
2034 }
2035
2036 static void unbind_resource(struct wl_resource *resource)
2037 {
2038         wl_list_remove(&resource->link);
2039         free(resource);
2040 }
2041
2042 static void
2043 bind_input_device(struct wl_client *client,
2044                   void *data, uint32_t version, uint32_t id)
2045 {
2046         struct wl_input_device *device = data;
2047         struct wl_resource *resource;
2048
2049         resource = wl_client_add_object(client, &wl_input_device_interface,
2050                                         &input_device_interface, id, data);
2051         wl_list_insert(&device->resource_list, &resource->link);
2052         resource->destroy = unbind_resource;
2053 }
2054
2055 static void
2056 device_handle_new_drag_icon(struct wl_listener *listener, void *data)
2057 {
2058         struct weston_input_device *device;
2059
2060         device = container_of(listener, struct weston_input_device,
2061                               new_drag_icon_listener);
2062
2063         weston_input_update_drag_surface(&device->input_device, 0, 0);
2064 }
2065
2066 WL_EXPORT void
2067 weston_input_device_init(struct weston_input_device *device,
2068                          struct weston_compositor *ec)
2069 {
2070         wl_input_device_init(&device->input_device);
2071
2072         wl_display_add_global(ec->wl_display, &wl_input_device_interface,
2073                               device, bind_input_device);
2074
2075         device->sprite = weston_surface_create(ec);
2076         device->sprite->surface.resource.data = device->sprite;
2077
2078         device->compositor = ec;
2079         device->hotspot_x = 16;
2080         device->hotspot_y = 16;
2081         device->modifier_state = 0;
2082         device->num_tp = 0;
2083
2084         device->drag_surface_destroy_listener.notify =
2085                 handle_drag_surface_destroy;
2086
2087         wl_list_insert(ec->input_device_list.prev, &device->link);
2088
2089         device->new_drag_icon_listener.notify = device_handle_new_drag_icon;
2090         wl_signal_add(&device->input_device.drag_icon_signal,
2091                       &device->new_drag_icon_listener);
2092 }
2093
2094 WL_EXPORT void
2095 weston_input_device_release(struct weston_input_device *device)
2096 {
2097         wl_list_remove(&device->link);
2098         /* The global object is destroyed at wl_display_destroy() time. */
2099
2100         if (device->sprite)
2101                 destroy_surface(&device->sprite->surface.resource);
2102
2103         wl_input_device_release(&device->input_device);
2104 }
2105
2106 static void
2107 drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2108 {
2109         weston_surface_configure(es,
2110                                  es->geometry.x + sx, es->geometry.y + sy,
2111                                  es->buffer->width, es->buffer->height);
2112 }
2113
2114 static int
2115 device_setup_new_drag_surface(struct weston_input_device *device,
2116                               struct weston_surface *surface)
2117 {
2118         struct wl_input_device *input_device = &device->input_device;
2119
2120         if (surface->configure) {
2121                 wl_resource_post_error(&surface->surface.resource,
2122                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
2123                                        "surface->configure already set");
2124                 return 0;
2125         }
2126
2127         device->drag_surface = surface;
2128
2129         weston_surface_set_position(device->drag_surface,
2130                                     wl_fixed_to_double(input_device->x),
2131                                     wl_fixed_to_double(input_device->y));
2132
2133         surface->configure = drag_surface_configure;
2134
2135         wl_signal_add(&surface->surface.resource.destroy_signal,
2136                        &device->drag_surface_destroy_listener);
2137
2138         return 1;
2139 }
2140
2141 static void
2142 device_release_drag_surface(struct weston_input_device *device)
2143 {
2144         device->drag_surface->configure = NULL;
2145         undef_region(&device->drag_surface->input);
2146         wl_list_remove(&device->drag_surface_destroy_listener.link);
2147         device->drag_surface = NULL;
2148 }
2149
2150 static void
2151 device_map_drag_surface(struct weston_input_device *device)
2152 {
2153         if (weston_surface_is_mapped(device->drag_surface) ||
2154             !device->drag_surface->buffer)
2155                 return;
2156
2157         wl_list_insert(&device->sprite->layer_link,
2158                        &device->drag_surface->layer_link);
2159         weston_surface_assign_output(device->drag_surface);
2160         empty_region(&device->drag_surface->input);
2161 }
2162
2163 static  void
2164 weston_input_update_drag_surface(struct wl_input_device *input_device,
2165                                  int dx, int dy)
2166 {
2167         int surface_changed = 0;
2168         struct weston_input_device *device = (struct weston_input_device *)
2169                 input_device;
2170
2171         if (!device->drag_surface && !input_device->drag_surface)
2172                 return;
2173
2174         if (device->drag_surface && input_device->drag_surface &&
2175             (&device->drag_surface->surface.resource !=
2176              &input_device->drag_surface->resource))
2177                 /* between calls to this funcion we got a new drag_surface */
2178                 surface_changed = 1;
2179
2180         if (!input_device->drag_surface || surface_changed) {
2181                 device_release_drag_surface(device);
2182                 if (!surface_changed)
2183                         return;
2184         }
2185
2186         if (!device->drag_surface || surface_changed) {
2187                 struct weston_surface *surface = (struct weston_surface *)
2188                         input_device->drag_surface;
2189                 if (!device_setup_new_drag_surface(device, surface))
2190                         return;
2191         }
2192
2193         /* the client may not have attached a buffer to the drag surface
2194          * when we setup it up, so check if map is needed on every update */
2195         device_map_drag_surface(device);
2196
2197         /* the client may have attached a buffer with a different size to
2198          * the drag surface, causing the input region to be reset */
2199         if (region_is_undefined(&device->drag_surface->input))
2200                 empty_region(&device->drag_surface->input);
2201
2202         if (!dx && !dy)
2203                 return;
2204
2205         weston_surface_set_position(device->drag_surface,
2206                                     device->drag_surface->geometry.x + wl_fixed_to_double(dx),
2207                                     device->drag_surface->geometry.y + wl_fixed_to_double(dy));
2208 }
2209
2210 WL_EXPORT void
2211 weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
2212 {
2213         weston_input_update_drag_surface(compositor->input_device, 0, 0);
2214 }
2215
2216 static void
2217 bind_output(struct wl_client *client,
2218             void *data, uint32_t version, uint32_t id)
2219 {
2220         struct weston_output *output = data;
2221         struct weston_mode *mode;
2222         struct wl_resource *resource;
2223
2224         resource = wl_client_add_object(client,
2225                                         &wl_output_interface, NULL, id, data);
2226
2227         wl_list_insert(&output->resource_list, &resource->link);
2228         resource->destroy = unbind_resource;
2229
2230         wl_output_send_geometry(resource,
2231                                 output->x,
2232                                 output->y,
2233                                 output->mm_width,
2234                                 output->mm_height,
2235                                 output->subpixel,
2236                                 output->make, output->model);
2237
2238         wl_list_for_each (mode, &output->mode_list, link) {
2239                 wl_output_send_mode(resource,
2240                                     mode->flags,
2241                                     mode->width,
2242                                     mode->height,
2243                                     mode->refresh);
2244         }
2245 }
2246
2247 static const char vertex_shader[] =
2248         "uniform mat4 proj;\n"
2249         "attribute vec2 position;\n"
2250         "attribute vec2 texcoord;\n"
2251         "varying vec2 v_texcoord;\n"
2252         "void main()\n"
2253         "{\n"
2254         "   gl_Position = proj * vec4(position, 0.0, 1.0);\n"
2255         "   v_texcoord = texcoord;\n"
2256         "}\n";
2257
2258 static const char texture_fragment_shader[] =
2259         "precision mediump float;\n"
2260         "varying vec2 v_texcoord;\n"
2261         "uniform sampler2D tex;\n"
2262         "uniform float alpha;\n"
2263         "uniform float bright;\n"
2264         "uniform float saturation;\n"
2265         "uniform float texwidth;\n"
2266         "void main()\n"
2267         "{\n"
2268         "   if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
2269         "       v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
2270         "      discard;\n"
2271         "   gl_FragColor = texture2D(tex, v_texcoord)\n;"
2272         "   float gray = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
2273         "   vec3 range = (gl_FragColor.rgb - vec3 (gray, gray, gray)) * saturation;\n"
2274         "   gl_FragColor = vec4(vec3(gray + range), gl_FragColor.a);\n"
2275         "   gl_FragColor = vec4(vec3(bright, bright, bright) * gl_FragColor.rgb, gl_FragColor.a);\n"
2276         "   gl_FragColor = alpha * gl_FragColor;\n"
2277         "}\n";
2278
2279 static const char solid_fragment_shader[] =
2280         "precision mediump float;\n"
2281         "uniform vec4 color;\n"
2282         "uniform float alpha;\n"
2283         "void main()\n"
2284         "{\n"
2285         "   gl_FragColor = alpha * color\n;"
2286         "}\n";
2287
2288 static int
2289 compile_shader(GLenum type, const char *source)
2290 {
2291         GLuint s;
2292         char msg[512];
2293         GLint status;
2294
2295         s = glCreateShader(type);
2296         glShaderSource(s, 1, &source, NULL);
2297         glCompileShader(s);
2298         glGetShaderiv(s, GL_COMPILE_STATUS, &status);
2299         if (!status) {
2300                 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
2301                 fprintf(stderr, "shader info: %s\n", msg);
2302                 return GL_NONE;
2303         }
2304
2305         return s;
2306 }
2307
2308 static int
2309 weston_shader_init(struct weston_shader *shader,
2310                    const char *vertex_source, const char *fragment_source)
2311 {
2312         char msg[512];
2313         GLint status;
2314
2315         shader->vertex_shader =
2316                 compile_shader(GL_VERTEX_SHADER, vertex_source);
2317         shader->fragment_shader =
2318                 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2319
2320         shader->program = glCreateProgram();
2321         glAttachShader(shader->program, shader->vertex_shader);
2322         glAttachShader(shader->program, shader->fragment_shader);
2323         glBindAttribLocation(shader->program, 0, "position");
2324         glBindAttribLocation(shader->program, 1, "texcoord");
2325
2326         glLinkProgram(shader->program);
2327         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
2328         if (!status) {
2329                 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
2330                 fprintf(stderr, "link info: %s\n", msg);
2331                 return -1;
2332         }
2333
2334         shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
2335         shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
2336         shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
2337         shader->brightness_uniform = glGetUniformLocation(shader->program, "bright");
2338         shader->saturation_uniform = glGetUniformLocation(shader->program, "saturation");
2339         shader->color_uniform = glGetUniformLocation(shader->program, "color");
2340         shader->texwidth_uniform = glGetUniformLocation(shader->program,
2341                                                         "texwidth");
2342
2343         return 0;
2344 }
2345
2346 WL_EXPORT void
2347 weston_output_destroy(struct weston_output *output)
2348 {
2349         struct weston_compositor *c = output->compositor;
2350
2351         pixman_region32_fini(&output->region);
2352         pixman_region32_fini(&output->previous_damage);
2353         output->compositor->output_id_pool &= ~(1 << output->id);
2354
2355         wl_display_remove_global(c->wl_display, output->global);
2356 }
2357
2358 WL_EXPORT void
2359 weston_output_update_zoom(struct weston_output *output, wl_fixed_t fx, wl_fixed_t fy)
2360 {
2361         float ratio;
2362         int32_t x, y;
2363
2364         if (output->zoom.level <= 0)
2365                 return;
2366
2367         x = wl_fixed_to_int(fx);
2368         y = wl_fixed_to_int(fy);
2369
2370         output->zoom.magnification = 1 / output->zoom.level;
2371         ratio = 1 - (1 / output->zoom.magnification);
2372
2373         output->zoom.trans_x = (((float)(x - output->x) / output->current->width) * (ratio * 2)) - ratio;
2374         output->zoom.trans_y = (((float)(y - output->y) / output->current->height) * (ratio * 2)) - ratio;
2375
2376         output->dirty = 1;
2377         weston_output_damage(output);
2378 }
2379
2380 WL_EXPORT void
2381 weston_output_update_matrix(struct weston_output *output)
2382 {
2383         int flip;
2384         struct weston_matrix camera;
2385         struct weston_matrix modelview;
2386
2387         weston_matrix_init(&output->matrix);
2388         weston_matrix_translate(&output->matrix,
2389                                 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2390                                 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
2391
2392         flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
2393         weston_matrix_scale(&output->matrix,
2394                             2.0 / (output->current->width + output->border.left + output->border.right),
2395                             flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
2396         if (output->zoom.active) {
2397                 weston_matrix_init(&camera);
2398                 weston_matrix_init(&modelview);
2399                 weston_matrix_translate(&camera, output->zoom.trans_x, flip * output->zoom.trans_y, 0);
2400                 weston_matrix_invert(&modelview, &camera);
2401                 weston_matrix_scale(&modelview, output->zoom.magnification, output->zoom.magnification, 1.0);
2402                 weston_matrix_multiply(&output->matrix, &modelview);
2403         }
2404
2405         output->dirty = 0;
2406 }
2407
2408 WL_EXPORT void
2409 weston_output_move(struct weston_output *output, int x, int y)
2410 {
2411         output->x = x;
2412         output->y = y;
2413
2414         pixman_region32_init(&output->previous_damage);
2415         pixman_region32_init_rect(&output->region, x, y,
2416                                   output->current->width,
2417                                   output->current->height);
2418 }
2419
2420 WL_EXPORT void
2421 weston_output_init(struct weston_output *output, struct weston_compositor *c,
2422                    int x, int y, int width, int height, uint32_t flags)
2423 {
2424         output->compositor = c;
2425         output->x = x;
2426         output->y = y;
2427         output->border.top = 0;
2428         output->border.bottom = 0;
2429         output->border.left = 0;
2430         output->border.right = 0;
2431         output->mm_width = width;
2432         output->mm_height = height;
2433         output->dirty = 1;
2434         wl_list_init(&output->read_pixels_list);
2435
2436         output->zoom.active = 0;
2437         output->zoom.increment = 0.05;
2438         output->zoom.level = 1.0;
2439         output->zoom.magnification = 1.0;
2440         output->zoom.trans_x = 0.0;
2441         output->zoom.trans_y = 0.0;
2442
2443         output->flags = flags;
2444         weston_output_move(output, x, y);
2445         weston_output_damage(output);
2446
2447         wl_list_init(&output->frame_callback_list);
2448         wl_list_init(&output->resource_list);
2449
2450         output->id = ffs(~output->compositor->output_id_pool) - 1;
2451         output->compositor->output_id_pool |= 1 << output->id;
2452
2453         output->global =
2454                 wl_display_add_global(c->wl_display, &wl_output_interface,
2455                                       output, bind_output);
2456 }
2457
2458 WL_EXPORT void
2459 weston_output_do_read_pixels(struct weston_output *output)
2460 {
2461         struct weston_read_pixels *r, *next;
2462
2463         glPixelStorei(GL_PACK_ALIGNMENT, 1);
2464         wl_list_for_each_safe(r, next, &output->read_pixels_list, link) {
2465                 glReadPixels(r->x, r->y, r->width, r->height,
2466                              output->compositor->read_format,
2467                              GL_UNSIGNED_BYTE, r->data);
2468                 r->done(r, output);
2469         }
2470 }
2471
2472 static void
2473 compositor_bind(struct wl_client *client,
2474                 void *data, uint32_t version, uint32_t id)
2475 {
2476         struct weston_compositor *compositor = data;
2477
2478         wl_client_add_object(client, &wl_compositor_interface,
2479                              &compositor_interface, id, compositor);
2480 }
2481
2482 WL_EXPORT int
2483 weston_compositor_init(struct weston_compositor *ec, struct wl_display *display)
2484 {
2485         struct wl_event_loop *loop;
2486         const char *extensions;
2487
2488         ec->wl_display = display;
2489         wl_signal_init(&ec->destroy_signal);
2490         wl_signal_init(&ec->activate_signal);
2491         wl_signal_init(&ec->lock_signal);
2492         wl_signal_init(&ec->unlock_signal);
2493         ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
2494
2495         ec->output_id_pool = 0;
2496
2497         if (!wl_display_add_global(display, &wl_compositor_interface,
2498                                    ec, compositor_bind))
2499                 return -1;
2500
2501         wl_display_init_shm(display);
2502
2503         ec->image_target_texture_2d =
2504                 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2505         ec->image_target_renderbuffer_storage = (void *)
2506                 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2507         ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2508         ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2509         ec->bind_display =
2510                 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2511         ec->unbind_display =
2512                 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2513
2514         extensions = (const char *) glGetString(GL_EXTENSIONS);
2515         if (!extensions) {
2516                 fprintf(stderr, "Retrieving GL extension string failed.\n");
2517                 return -1;
2518         }
2519
2520         if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2521                 fprintf(stderr,
2522                         "GL_EXT_texture_format_BGRA8888 not available\n");
2523                 return -1;
2524         }
2525
2526         if (strstr(extensions, "GL_EXT_read_format_bgra"))
2527                 ec->read_format = GL_BGRA_EXT;
2528         else
2529                 ec->read_format = GL_RGBA;
2530
2531         if (strstr(extensions, "GL_EXT_unpack_subimage"))
2532                 ec->has_unpack_subimage = 1;
2533
2534         extensions =
2535                 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2536         if (!extensions) {
2537                 fprintf(stderr, "Retrieving EGL extension string failed.\n");
2538                 return -1;
2539         }
2540
2541         if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2542                 ec->has_bind_display = 1;
2543         if (ec->has_bind_display)
2544                 ec->bind_display(ec->display, ec->wl_display);
2545
2546         wl_list_init(&ec->surface_list);
2547         wl_list_init(&ec->layer_list);
2548         wl_list_init(&ec->input_device_list);
2549         wl_list_init(&ec->output_list);
2550         wl_list_init(&ec->binding_list);
2551         wl_list_init(&ec->animation_list);
2552         weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
2553         ec->fade.animation.frame = fade_frame;
2554         wl_list_init(&ec->fade.animation.link);
2555
2556         weston_layer_init(&ec->fade_layer, &ec->layer_list);
2557         weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
2558
2559         screenshooter_create(ec);
2560
2561         ec->ping_handler = NULL;
2562
2563         wl_data_device_manager_init(ec->wl_display);
2564
2565         glActiveTexture(GL_TEXTURE0);
2566
2567         if (weston_shader_init(&ec->texture_shader,
2568                              vertex_shader, texture_fragment_shader) < 0)
2569                 return -1;
2570         if (weston_shader_init(&ec->solid_shader,
2571                              vertex_shader, solid_fragment_shader) < 0)
2572                 return -1;
2573
2574         loop = wl_display_get_event_loop(ec->wl_display);
2575         ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
2576         wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
2577
2578         ec->input_loop = wl_event_loop_create();
2579
2580         weston_compositor_schedule_repaint(ec);
2581
2582         return 0;
2583 }
2584
2585 WL_EXPORT void
2586 weston_compositor_shutdown(struct weston_compositor *ec)
2587 {
2588         struct weston_output *output, *next;
2589
2590         wl_event_source_remove(ec->idle_source);
2591         if (ec->input_loop_source)
2592                 wl_event_source_remove(ec->input_loop_source);
2593
2594         /* Destroy all outputs associated with this compositor */
2595         wl_list_for_each_safe(output, next, &ec->output_list, link)
2596                 output->destroy(output);
2597
2598         weston_binding_list_destroy_all(&ec->binding_list);
2599
2600         wl_array_release(&ec->vertices);
2601         wl_array_release(&ec->indices);
2602
2603         wl_event_loop_destroy(ec->input_loop);
2604 }
2605
2606 static int weston_compositor_xkb_init(struct weston_compositor *ec,
2607                                       struct xkb_rule_names *names)
2608 {
2609         ec->xkb_info.context = xkb_context_new(0);
2610         if (ec->xkb_info.context == NULL) {
2611                 fprintf(stderr, "failed to create XKB context\n");
2612                 return -1;
2613         }
2614
2615         ec->xkb_info.names = *names;
2616         if (!ec->xkb_info.names.rules)
2617                 ec->xkb_info.names.rules = strdup("evdev");
2618         if (!ec->xkb_info.names.model)
2619                 ec->xkb_info.names.model = strdup("pc105");
2620         if (!ec->xkb_info.names.layout)
2621                 ec->xkb_info.names.layout = strdup("us");
2622
2623         ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_info.context,
2624                                                      &ec->xkb_info.names, 0);
2625         if (ec->xkb_info.keymap == NULL) {
2626                 fprintf(stderr, "failed to compile XKB keymap\n");
2627                 return -1;
2628         }
2629
2630         ec->xkb_info.state = xkb_state_new(ec->xkb_info.keymap);
2631         if (ec->xkb_info.state == NULL) {
2632                 fprintf(stderr, "failed to initialise XKB state\n");
2633                 return -1;
2634         }
2635
2636         return 0;
2637 }
2638
2639 static void weston_compositor_xkb_destroy(struct weston_compositor *ec)
2640 {
2641         xkb_state_unref(ec->xkb_info.state);
2642         xkb_map_unref(ec->xkb_info.keymap);
2643         xkb_context_unref(ec->xkb_info.context);
2644
2645         free((char *) ec->xkb_info.names.rules);
2646         free((char *) ec->xkb_info.names.model);
2647         free((char *) ec->xkb_info.names.layout);
2648         free((char *) ec->xkb_info.names.variant);
2649         free((char *) ec->xkb_info.names.options);
2650 }
2651
2652 static int on_term_signal(int signal_number, void *data)
2653 {
2654         struct wl_display *display = data;
2655
2656         fprintf(stderr, "caught signal %d\n", signal_number);
2657         wl_display_terminate(display);
2658
2659         return 1;
2660 }
2661
2662 static void
2663 on_segv_signal(int s, siginfo_t *siginfo, void *context)
2664 {
2665         void *buffer[32];
2666         int i, count;
2667         Dl_info info;
2668
2669         fprintf(stderr, "caught segv\n");
2670
2671         count = backtrace(buffer, ARRAY_LENGTH(buffer));
2672         for (i = 0; i < count; i++) {
2673                 dladdr(buffer[i], &info);
2674                 fprintf(stderr, "  [%016lx]  %s  (%s)\n",
2675                         (long) buffer[i],
2676                         info.dli_sname ? info.dli_sname : "--",
2677                         info.dli_fname);
2678         }
2679
2680         longjmp(segv_jmp_buf, 1);
2681 }
2682
2683
2684 static void *
2685 load_module(const char *name, const char *entrypoint, void **handle)
2686 {
2687         char path[PATH_MAX];
2688         void *module, *init;
2689
2690         if (name[0] != '/')
2691                 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2692         else
2693                 snprintf(path, sizeof path, "%s", name);
2694
2695         module = dlopen(path, RTLD_LAZY);
2696         if (!module) {
2697                 fprintf(stderr,
2698                         "failed to load module '%s': %s\n", path, dlerror());
2699                 return NULL;
2700         }
2701
2702         init = dlsym(module, entrypoint);
2703         if (!init) {
2704                 fprintf(stderr,
2705                         "failed to lookup init function in '%s': %s\n",
2706                         path, dlerror());
2707                 return NULL;
2708         }
2709
2710         return init;
2711 }
2712
2713 int main(int argc, char *argv[])
2714 {
2715         struct wl_display *display;
2716         struct weston_compositor *ec;
2717         struct wl_event_source *signals[4];
2718         struct wl_event_loop *loop;
2719         struct sigaction segv_action;
2720         void *shell_module, *backend_module, *xserver_module;
2721         int (*module_init)(struct weston_compositor *ec);
2722         struct weston_compositor
2723                 *(*backend_init)(struct wl_display *display,
2724                                  int argc, char *argv[]);
2725         int i;
2726         char *backend = NULL;
2727         char *shell = NULL;
2728         char *module = NULL;
2729         int32_t idle_time = 300;
2730         int32_t xserver = 0;
2731         char *socket_name = NULL;
2732         char *config_file;
2733         struct xkb_rule_names xkb_names;
2734
2735         const struct config_key shell_config_keys[] = {
2736                 { "type", CONFIG_KEY_STRING, &shell },
2737         };
2738
2739         const struct config_key keyboard_config_keys[] = {
2740                 { "keymap_rules", CONFIG_KEY_STRING, &xkb_names.rules },
2741                 { "keymap_model", CONFIG_KEY_STRING, &xkb_names.model },
2742                 { "keymap_layout", CONFIG_KEY_STRING, &xkb_names.layout },
2743                 { "keymap_variant", CONFIG_KEY_STRING, &xkb_names.variant },
2744                 { "keymap_options", CONFIG_KEY_STRING, &xkb_names.options },
2745         };
2746
2747         const struct config_section cs[] = {
2748                 { "shell",
2749                   shell_config_keys, ARRAY_LENGTH(shell_config_keys) },
2750                 { "keyboard",
2751                   keyboard_config_keys, ARRAY_LENGTH(keyboard_config_keys) },
2752         };
2753
2754         const struct weston_option core_options[] = {
2755                 { WESTON_OPTION_STRING, "backend", 'B', &backend },
2756                 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
2757                 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
2758                 { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
2759                 { WESTON_OPTION_STRING, "module", 0, &module },
2760         };
2761
2762         memset(&xkb_names, 0, sizeof(xkb_names));
2763
2764         argc = parse_options(core_options,
2765                              ARRAY_LENGTH(core_options), argc, argv);
2766
2767         display = wl_display_create();
2768
2769         loop = wl_display_get_event_loop(display);
2770         signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
2771                                               display);
2772         signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
2773                                               display);
2774         signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
2775                                               display);
2776
2777         wl_list_init(&child_process_list);
2778         signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
2779                                               NULL);
2780
2781         segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
2782         segv_action.sa_sigaction = on_segv_signal;
2783         sigemptyset(&segv_action.sa_mask);
2784         sigaction(SIGSEGV, &segv_action, NULL);
2785
2786         if (!backend) {
2787                 if (getenv("WAYLAND_DISPLAY"))
2788                         backend = "wayland-backend.so";
2789                 else if (getenv("DISPLAY"))
2790                         backend = "x11-backend.so";
2791                 else if (getenv("OPENWFD"))
2792                         backend = "openwfd-backend.so";
2793                 else
2794                         backend = "drm-backend.so";
2795         }
2796
2797         config_file = config_file_path("weston.ini");
2798         parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
2799         free(config_file);
2800
2801         backend_init = load_module(backend, "backend_init", &backend_module);
2802         if (!backend_init)
2803                 exit(EXIT_FAILURE);
2804
2805         ec = backend_init(display, argc, argv);
2806         if (ec == NULL) {
2807                 fprintf(stderr, "failed to create compositor\n");
2808                 exit(EXIT_FAILURE);
2809         }
2810
2811         for (i = 1; argv[i]; i++)
2812                 fprintf(stderr, "unhandled option: %s\n", argv[i]);
2813         if (argv[1])
2814                 exit(EXIT_FAILURE);
2815
2816         if (weston_compositor_xkb_init(ec, &xkb_names) == -1) {
2817                 fprintf(stderr, "failed to initialise keyboard support\n");
2818                 exit(EXIT_FAILURE);
2819         }
2820
2821         ec->option_idle_time = idle_time;
2822         ec->idle_time = idle_time;
2823
2824         module_init = NULL;
2825         if (xserver)
2826                 module_init = load_module("xserver-launcher.so",
2827                                           "weston_xserver_init",
2828                                           &xserver_module);
2829         if (module_init && module_init(ec) < 0)
2830                 exit(EXIT_FAILURE);
2831
2832         if (!shell)
2833                 shell = "desktop-shell.so";
2834         module_init = load_module(shell, "shell_init", &shell_module);
2835         if (!module_init || module_init(ec) < 0)
2836                 exit(EXIT_FAILURE);
2837
2838
2839         module_init = NULL;
2840         if (module)
2841                 module_init = load_module(module, "module_init", NULL);
2842         if (module_init && module_init(ec) < 0)
2843                 exit(EXIT_FAILURE);
2844
2845         if (wl_display_add_socket(display, socket_name)) {
2846                 fprintf(stderr, "failed to add socket: %m\n");
2847                 exit(EXIT_FAILURE);
2848         }
2849
2850         weston_compositor_dpms_on(ec);
2851         weston_compositor_wake(ec);
2852         if (setjmp(segv_jmp_buf) == 0)
2853                 wl_display_run(display);
2854
2855         /* prevent further rendering while shutting down */
2856         ec->state = WESTON_COMPOSITOR_SLEEPING;
2857
2858         wl_signal_emit(&ec->destroy_signal, ec);
2859
2860         if (ec->has_bind_display)
2861                 ec->unbind_display(ec->display, display);
2862
2863         for (i = ARRAY_LENGTH(signals); i;)
2864                 wl_event_source_remove(signals[--i]);
2865
2866         weston_compositor_xkb_destroy(ec);
2867
2868         ec->destroy(ec);
2869         wl_display_destroy(display);
2870
2871         return 0;
2872 }