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 <fcntl.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33 #include <stdint.h>
  34 #include <limits.h>
  35 #include <stdarg.h>
  36 #include <assert.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/mman.h>
  39 #include <sys/wait.h>
  40 #include <sys/socket.h>
  41 #include <sys/utsname.h>
  42 #include <sys/stat.h>
  43 #include <unistd.h>
  44 #include <math.h>
  45 #include <linux/input.h>
  46 #include <dlfcn.h>
  47 #include <signal.h>
  48 #include <setjmp.h>
  49 #include <sys/time.h>
  50 #include <time.h>
  51 #include <ctype.h>
  52
  53 #include <wayland-server.h>
  54 #include "compositor.h"
  55 #include "../shared/os-compatibility.h"
  56 #include "git-version.h"
  57
  58 static struct wl_list child_process_list;
  59 static struct weston_compositor *segv_compositor;
  60
  61 static int
  62 sigchld_handler(int signal_number, void *data)
  63 {
  64         struct weston_process *p;
  65         int status;
  66         pid_t pid;
  67
  68         pid = waitpid(-1, &status, WNOHANG);
  69         if (!pid)
  70                 return 1;
  71
  72         wl_list_for_each(p, &child_process_list, link) {
  73                 if (p->pid == pid)
  74                         break;
  75         }
  76
  77         if (&p->link == &child_process_list) {
  78                 weston_log("unknown child process exited\n");
  79                 return 1;
  80         }
  81
  82         wl_list_remove(&p->link);
  83         p->cleanup(p, status);
  84
  85         return 1;
  86 }
  87
  88 WL_EXPORT int
  89 weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode)
  90 {
  91         if (!output->switch_mode)
  92                 return -1;
  93
  94         return output->switch_mode(output, mode);
  95 }
  96
  97 WL_EXPORT void
  98 weston_watch_process(struct weston_process *process)
  99 {
 100         wl_list_insert(&child_process_list, &process->link);
 101 }
 102
 103 static void
 104 child_client_exec(int sockfd, const char *path)
 105 {
 106         int clientfd;
 107         char s[32];
 108         sigset_t allsigs;
 109
 110         /* do not give our signal mask to the new process */
 111         sigfillset(&allsigs);
 112         sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
 113
 114         /* Launch clients as the user. */
 115         seteuid(getuid());
 116
 117         /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
 118          * non-CLOEXEC fd to pass through exec. */
 119         clientfd = dup(sockfd);
 120         if (clientfd == -1) {
 121                 weston_log("compositor: dup failed: %m\n");
 122                 return;
 123         }
 124
 125         snprintf(s, sizeof s, "%d", clientfd);
 126         setenv("WAYLAND_SOCKET", s, 1);
 127
 128         if (execl(path, path, NULL) < 0)
 129                 weston_log("compositor: executing '%s' failed: %m\n",
 130                         path);
 131 }
 132
 133 WL_EXPORT struct wl_client *
 134 weston_client_launch(struct weston_compositor *compositor,
 135                      struct weston_process *proc,
 136                      const char *path,
 137                      weston_process_cleanup_func_t cleanup)
 138 {
 139         int sv[2];
 140         pid_t pid;
 141         struct wl_client *client;
 142
 143         weston_log("launching '%s'\n", path);
 144
 145         if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
 146                 weston_log("weston_client_launch: "
 147                         "socketpair failed while launching '%s': %m\n",
 148                         path);
 149                 return NULL;
 150         }
 151
 152         pid = fork();
 153         if (pid == -1) {
 154                 close(sv[0]);
 155                 close(sv[1]);
 156                 weston_log("weston_client_launch: "
 157                         "fork failed while launching '%s': %m\n", path);
 158                 return NULL;
 159         }
 160
 161         if (pid == 0) {
 162                 child_client_exec(sv[1], path);
 163                 exit(-1);
 164         }
 165
 166         close(sv[1]);
 167
 168         client = wl_client_create(compositor->wl_display, sv[0]);
 169         if (!client) {
 170                 close(sv[0]);
 171                 weston_log("weston_client_launch: "
 172                         "wl_client_create failed while launching '%s'.\n",
 173                         path);
 174                 return NULL;
 175         }
 176
 177         proc->pid = pid;
 178         proc->cleanup = cleanup;
 179         weston_watch_process(proc);
 180
 181         return client;
 182 }
 183
 184 static void
 185 update_shm_texture(struct weston_surface *surface);
 186
 187 static void
 188 surface_handle_buffer_destroy(struct wl_listener *listener, void *data)
 189 {
 190         struct weston_surface *es =
 191                 container_of(listener, struct weston_surface,
 192                              buffer_destroy_listener);
 193
 194         if (es->buffer && wl_buffer_is_shm(es->buffer))
 195                 update_shm_texture(es);
 196
 197         es->buffer = NULL;
 198 }
 199
 200 static const pixman_region32_data_t undef_region_data;
 201
 202 static void
 203 undef_region(pixman_region32_t *region)
 204 {
 205         if (region->data != &undef_region_data)
 206                 pixman_region32_fini(region);
 207         region->data = (pixman_region32_data_t *) &undef_region_data;
 208 }
 209
 210 static int
 211 region_is_undefined(pixman_region32_t *region)
 212 {
 213         return region->data == &undef_region_data;
 214 }
 215
 216 static void
 217 empty_region(pixman_region32_t *region)
 218 {
 219         if (!region_is_undefined(region))
 220                 pixman_region32_fini(region);
 221
 222         pixman_region32_init(region);
 223 }
 224
 225 WL_EXPORT struct weston_surface *
 226 weston_surface_create(struct weston_compositor *compositor)
 227 {
 228         struct weston_surface *surface;
 229
 230         surface = calloc(1, sizeof *surface);
 231         if (surface == NULL)
 232                 return NULL;
 233
 234         wl_signal_init(&surface->surface.resource.destroy_signal);
 235
 236         wl_list_init(&surface->link);
 237         wl_list_init(&surface->layer_link);
 238
 239         surface->surface.resource.client = NULL;
 240
 241         surface->compositor = compositor;
 242         surface->alpha = 1.0;
 243         surface->blend = 1;
 244         surface->opaque_rect[0] = 0.0;
 245         surface->opaque_rect[1] = 0.0;
 246         surface->opaque_rect[2] = 0.0;
 247         surface->opaque_rect[3] = 0.0;
 248         surface->pitch = 1;
 249
 250         surface->num_textures = 0;
 251         surface->num_images = 0;
 252
 253         surface->buffer = NULL;
 254         surface->output = NULL;
 255         surface->plane = &compositor->primary_plane;
 256
 257         pixman_region32_init(&surface->damage);
 258         pixman_region32_init(&surface->opaque);
 259         pixman_region32_init(&surface->clip);
 260         undef_region(&surface->input);
 261         pixman_region32_init(&surface->transform.opaque);
 262         wl_list_init(&surface->frame_callback_list);
 263
 264         surface->buffer_destroy_listener.notify =
 265                 surface_handle_buffer_destroy;
 266
 267         wl_list_init(&surface->geometry.transformation_list);
 268         wl_list_insert(&surface->geometry.transformation_list,
 269                        &surface->transform.position.link);
 270         weston_matrix_init(&surface->transform.position.matrix);
 271         pixman_region32_init(&surface->transform.boundingbox);
 272         surface->geometry.dirty = 1;
 273
 274         return surface;
 275 }
 276
 277 WL_EXPORT void
 278 weston_surface_set_color(struct weston_surface *surface,
 279                  GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 280 {
 281         surface->color[0] = red;
 282         surface->color[1] = green;
 283         surface->color[2] = blue;
 284         surface->color[3] = alpha;
 285         surface->shader = &surface->compositor->solid_shader;
 286 }
 287
 288 WL_EXPORT void
 289 weston_surface_to_global_float(struct weston_surface *surface,
 290                                GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
 291 {
 292         if (surface->transform.enabled) {
 293                 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
 294
 295                 weston_matrix_transform(&surface->transform.matrix, &v);
 296
 297                 if (fabsf(v.f[3]) < 1e-6) {
 298                         weston_log("warning: numerical instability in "
 299                                 "weston_surface_to_global(), divisor = %g\n",
 300                                 v.f[3]);
 301                         *x = 0;
 302                         *y = 0;
 303                         return;
 304                 }
 305
 306                 *x = v.f[0] / v.f[3];
 307                 *y = v.f[1] / v.f[3];
 308         } else {
 309                 *x = sx + surface->geometry.x;
 310                 *y = sy + surface->geometry.y;
 311         }
 312 }
 313
 314 WL_EXPORT void
 315 weston_surface_move_to_plane(struct weston_surface *surface,
 316                              struct weston_plane *plane)
 317 {
 318         if (surface->plane == plane)
 319                 return;
 320
 321         weston_surface_damage_below(surface);
 322         surface->plane = plane;
 323         weston_surface_damage(surface);
 324 }
 325
 326 WL_EXPORT void
 327 weston_surface_damage_below(struct weston_surface *surface)
 328 {
 329         pixman_region32_t damage;
 330
 331         pixman_region32_init(&damage);
 332         pixman_region32_subtract(&damage, &surface->transform.boundingbox,
 333                                  &surface->clip);
 334         pixman_region32_union(&surface->plane->damage,
 335                               &surface->plane->damage, &damage);
 336         pixman_region32_fini(&damage);
 337 }
 338
 339 static void
 340 surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
 341                      int32_t width, int32_t height,
 342                      pixman_region32_t *bbox)
 343 {
 344         GLfloat min_x = HUGE_VALF,  min_y = HUGE_VALF;
 345         GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
 346         int32_t s[4][2] = {
 347                 { sx,         sy },
 348                 { sx,         sy + height },
 349                 { sx + width, sy },
 350                 { sx + width, sy + height }
 351         };
 352         GLfloat int_x, int_y;
 353         int i;
 354
 355         for (i = 0; i < 4; ++i) {
 356                 GLfloat x, y;
 357                 weston_surface_to_global_float(surface,
 358                                                s[i][0], s[i][1], &x, &y);
 359                 if (x < min_x)
 360                         min_x = x;
 361                 if (x > max_x)
 362                         max_x = x;
 363                 if (y < min_y)
 364                         min_y = y;
 365                 if (y > max_y)
 366                         max_y = y;
 367         }
 368
 369         int_x = floorf(min_x);
 370         int_y = floorf(min_y);
 371         pixman_region32_init_rect(bbox, int_x, int_y,
 372                                   ceilf(max_x) - int_x, ceilf(max_y) - int_y);
 373 }
 374
 375 static void
 376 weston_surface_update_transform_disable(struct weston_surface *surface)
 377 {
 378         surface->transform.enabled = 0;
 379
 380         /* round off fractions when not transformed */
 381         surface->geometry.x = roundf(surface->geometry.x);
 382         surface->geometry.y = roundf(surface->geometry.y);
 383
 384         pixman_region32_init_rect(&surface->transform.boundingbox,
 385                                   surface->geometry.x,
 386                                   surface->geometry.y,
 387                                   surface->geometry.width,
 388                                   surface->geometry.height);
 389
 390         if (surface->alpha == 1.0) {
 391                 pixman_region32_copy(&surface->transform.opaque,
 392                                      &surface->opaque);
 393                 pixman_region32_translate(&surface->transform.opaque,
 394                                           surface->geometry.x,
 395                                           surface->geometry.y);
 396         }
 397 }
 398
 399 static int
 400 weston_surface_update_transform_enable(struct weston_surface *surface)
 401 {
 402         struct weston_matrix *matrix = &surface->transform.matrix;
 403         struct weston_matrix *inverse = &surface->transform.inverse;
 404         struct weston_transform *tform;
 405
 406         surface->transform.enabled = 1;
 407
 408         /* Otherwise identity matrix, but with x and y translation. */
 409         surface->transform.position.matrix.d[12] = surface->geometry.x;
 410         surface->transform.position.matrix.d[13] = surface->geometry.y;
 411
 412         weston_matrix_init(matrix);
 413         wl_list_for_each(tform, &surface->geometry.transformation_list, link)
 414                 weston_matrix_multiply(matrix, &tform->matrix);
 415
 416         if (weston_matrix_invert(inverse, matrix) < 0) {
 417                 /* Oops, bad total transformation, not invertible */
 418                 weston_log("error: weston_surface %p"
 419                         " transformation not invertible.\n", surface);
 420                 return -1;
 421         }
 422
 423         surface_compute_bbox(surface, 0, 0, surface->geometry.width,
 424                              surface->geometry.height,
 425                              &surface->transform.boundingbox);
 426
 427         return 0;
 428 }
 429
 430 WL_EXPORT void
 431 weston_surface_update_transform(struct weston_surface *surface)
 432 {
 433         if (!surface->geometry.dirty)
 434                 return;
 435
 436         surface->geometry.dirty = 0;
 437
 438         weston_surface_damage_below(surface);
 439
 440         pixman_region32_fini(&surface->transform.boundingbox);
 441         pixman_region32_fini(&surface->transform.opaque);
 442         pixman_region32_init(&surface->transform.opaque);
 443
 444         if (region_is_undefined(&surface->input))
 445                 pixman_region32_init_rect(&surface->input, 0, 0,
 446                                           surface->geometry.width,
 447                                           surface->geometry.height);
 448
 449         /* transform.position is always in transformation_list */
 450         if (surface->geometry.transformation_list.next ==
 451             &surface->transform.position.link &&
 452             surface->geometry.transformation_list.prev ==
 453             &surface->transform.position.link) {
 454                 weston_surface_update_transform_disable(surface);
 455         } else {
 456                 if (weston_surface_update_transform_enable(surface) < 0)
 457                         weston_surface_update_transform_disable(surface);
 458         }
 459
 460         weston_surface_damage_below(surface);
 461
 462         if (weston_surface_is_mapped(surface))
 463                 weston_surface_assign_output(surface);
 464 }
 465
 466 WL_EXPORT void
 467 weston_surface_to_global_fixed(struct weston_surface *surface,
 468                                wl_fixed_t sx, wl_fixed_t sy,
 469                                wl_fixed_t *x, wl_fixed_t *y)
 470 {
 471         GLfloat xf, yf;
 472
 473         weston_surface_to_global_float(surface,
 474                                        wl_fixed_to_double(sx),
 475                                        wl_fixed_to_double(sy),
 476                                        &xf, &yf);
 477         *x = wl_fixed_from_double(xf);
 478         *y = wl_fixed_from_double(yf);
 479 }
 480
 481 static void
 482 surface_from_global_float(struct weston_surface *surface,
 483                           GLfloat x, GLfloat y, GLfloat *sx, GLfloat *sy)
 484 {
 485         if (surface->transform.enabled) {
 486                 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
 487
 488                 weston_matrix_transform(&surface->transform.inverse, &v);
 489
 490                 if (fabsf(v.f[3]) < 1e-6) {
 491                         weston_log("warning: numerical instability in "
 492                                 "weston_surface_from_global(), divisor = %g\n",
 493                                 v.f[3]);
 494                         *sx = 0;
 495                         *sy = 0;
 496                         return;
 497                 }
 498
 499                 *sx = v.f[0] / v.f[3];
 500                 *sy = v.f[1] / v.f[3];
 501         } else {
 502                 *sx = x - surface->geometry.x;
 503                 *sy = y - surface->geometry.y;
 504         }
 505 }
 506
 507 WL_EXPORT void
 508 weston_surface_from_global_fixed(struct weston_surface *surface,
 509                                  wl_fixed_t x, wl_fixed_t y,
 510                                  wl_fixed_t *sx, wl_fixed_t *sy)
 511 {
 512         GLfloat sxf, syf;
 513
 514         surface_from_global_float(surface,
 515                                   wl_fixed_to_double(x),
 516                                   wl_fixed_to_double(y),
 517                                   &sxf, &syf);
 518         *sx = wl_fixed_from_double(sxf);
 519         *sy = wl_fixed_from_double(syf);
 520 }
 521
 522 WL_EXPORT void
 523 weston_surface_from_global(struct weston_surface *surface,
 524                            int32_t x, int32_t y, int32_t *sx, int32_t *sy)
 525 {
 526         GLfloat sxf, syf;
 527
 528         surface_from_global_float(surface, x, y, &sxf, &syf);
 529         *sx = floorf(sxf);
 530         *sy = floorf(syf);
 531 }
 532
 533 WL_EXPORT void
 534 weston_surface_schedule_repaint(struct weston_surface *surface)
 535 {
 536         struct weston_output *output;
 537
 538         wl_list_for_each(output, &surface->compositor->output_list, link)
 539                 if (surface->output_mask & (1 << output->id))
 540                         weston_output_schedule_repaint(output);
 541 }
 542
 543 WL_EXPORT void
 544 weston_surface_damage(struct weston_surface *surface)
 545 {
 546         pixman_region32_union_rect(&surface->damage, &surface->damage,
 547                                    0, 0, surface->geometry.width,
 548                                    surface->geometry.height);
 549
 550         weston_surface_schedule_repaint(surface);
 551 }
 552
 553 WL_EXPORT void
 554 weston_surface_configure(struct weston_surface *surface,
 555                          GLfloat x, GLfloat y, int width, int height)
 556 {
 557         surface->geometry.x = x;
 558         surface->geometry.y = y;
 559         surface->geometry.width = width;
 560         surface->geometry.height = height;
 561         surface->geometry.dirty = 1;
 562 }
 563
 564 WL_EXPORT void
 565 weston_surface_set_position(struct weston_surface *surface,
 566                             GLfloat x, GLfloat y)
 567 {
 568         surface->geometry.x = x;
 569         surface->geometry.y = y;
 570         surface->geometry.dirty = 1;
 571 }
 572
 573 WL_EXPORT int
 574 weston_surface_is_mapped(struct weston_surface *surface)
 575 {
 576         if (surface->output)
 577                 return 1;
 578         else
 579                 return 0;
 580 }
 581
 582 WL_EXPORT uint32_t
 583 weston_compositor_get_time(void)
 584 {
 585        struct timeval tv;
 586
 587        gettimeofday(&tv, NULL);
 588
 589        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
 590 }
 591
 592 static struct weston_surface *
 593 weston_compositor_pick_surface(struct weston_compositor *compositor,
 594                                wl_fixed_t x, wl_fixed_t y,
 595                                wl_fixed_t *sx, wl_fixed_t *sy)
 596 {
 597         struct weston_surface *surface;
 598
 599         wl_list_for_each(surface, &compositor->surface_list, link) {
 600                 weston_surface_from_global_fixed(surface, x, y, sx, sy);
 601                 if (pixman_region32_contains_point(&surface->input,
 602                                                    wl_fixed_to_int(*sx),
 603                                                    wl_fixed_to_int(*sy),
 604                                                    NULL))
 605                         return surface;
 606         }
 607
 608         return NULL;
 609 }
 610
 611 static void
 612 weston_device_repick(struct wl_seat *seat)
 613 {
 614         struct weston_seat *ws = (struct weston_seat *) seat;
 615         const struct wl_pointer_grab_interface *interface;
 616         struct weston_surface *surface, *focus;
 617
 618         if (!seat->pointer)
 619                 return;
 620
 621         surface = weston_compositor_pick_surface(ws->compositor,
 622                                                  seat->pointer->x,
 623                                                  seat->pointer->y,
 624                                                  &seat->pointer->current_x,
 625                                                  &seat->pointer->current_y);
 626
 627         if (&surface->surface != seat->pointer->current) {
 628                 interface = seat->pointer->grab->interface;
 629                 seat->pointer->current = &surface->surface;
 630                 interface->focus(seat->pointer->grab, &surface->surface,
 631                                  seat->pointer->current_x,
 632                                  seat->pointer->current_y);
 633         }
 634
 635         focus = (struct weston_surface *) seat->pointer->grab->focus;
 636         if (focus)
 637                 weston_surface_from_global_fixed(focus,
 638                                                  seat->pointer->x,
 639                                                  seat->pointer->y,
 640                                                  &seat->pointer->grab->x,
 641                                                  &seat->pointer->grab->y);
 642 }
 643
 644 static void
 645 weston_compositor_repick(struct weston_compositor *compositor)
 646 {
 647         struct weston_seat *seat;
 648
 649         if (!compositor->focus)
 650                 return;
 651
 652         wl_list_for_each(seat, &compositor->seat_list, link)
 653                 weston_device_repick(&seat->seat);
 654 }
 655
 656 WL_EXPORT void
 657 weston_surface_unmap(struct weston_surface *surface)
 658 {
 659         struct weston_seat *seat;
 660
 661         weston_surface_damage_below(surface);
 662         surface->output = NULL;
 663         wl_list_remove(&surface->layer_link);
 664
 665         wl_list_for_each(seat, &surface->compositor->seat_list, link) {
 666                 if (seat->seat.keyboard &&
 667                     seat->seat.keyboard->focus == &surface->surface)
 668                         wl_keyboard_set_focus(seat->seat.keyboard, NULL);
 669                 if (seat->seat.pointer &&
 670                     seat->seat.pointer->focus == &surface->surface)
 671                         wl_pointer_set_focus(seat->seat.pointer,
 672                                              NULL,
 673                                              wl_fixed_from_int(0),
 674                                              wl_fixed_from_int(0));
 675         }
 676
 677         weston_surface_schedule_repaint(surface);
 678 }
 679
 680 struct weston_frame_callback {
 681         struct wl_resource resource;
 682         struct wl_list link;
 683 };
 684
 685 static void
 686 destroy_surface(struct wl_resource *resource)
 687 {
 688         int i;
 689
 690         struct weston_surface *surface =
 691                 container_of(resource,
 692                              struct weston_surface, surface.resource);
 693         struct weston_compositor *compositor = surface->compositor;
 694         struct weston_frame_callback *cb, *next;
 695
 696         if (weston_surface_is_mapped(surface))
 697                 weston_surface_unmap(surface);
 698
 699         glDeleteTextures(surface->num_textures, surface->textures);
 700
 701         if (surface->buffer)
 702                 wl_list_remove(&surface->buffer_destroy_listener.link);
 703
 704         for (i = 0; i < surface->num_images; i++)
 705                 compositor->destroy_image(compositor->egl_display,
 706                                           surface->images[i]);
 707
 708         pixman_region32_fini(&surface->transform.boundingbox);
 709         pixman_region32_fini(&surface->damage);
 710         pixman_region32_fini(&surface->opaque);
 711         pixman_region32_fini(&surface->clip);
 712         if (!region_is_undefined(&surface->input))
 713                 pixman_region32_fini(&surface->input);
 714
 715         wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link)
 716                 wl_resource_destroy(&cb->resource);
 717
 718         free(surface);
 719 }
 720
 721 WL_EXPORT void
 722 weston_surface_destroy(struct weston_surface *surface)
 723 {
 724         /* Not a valid way to destroy a client surface */
 725         assert(surface->surface.resource.client == NULL);
 726
 727         wl_signal_emit(&surface->surface.resource.destroy_signal,
 728                        &surface->surface.resource);
 729         destroy_surface(&surface->surface.resource);
 730 }
 731
 732 static void
 733 ensure_textures(struct weston_surface *es, int num_textures)
 734 {
 735         int i;
 736
 737         if (num_textures <= es->num_textures)
 738                 return;
 739
 740         for (i = es->num_textures; i < num_textures; i++) {
 741                 glGenTextures(1, &es->textures[i]);
 742                 glBindTexture(GL_TEXTURE_2D, es->textures[i]);
 743                 glTexParameteri(GL_TEXTURE_2D,
 744                                 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 745                 glTexParameteri(GL_TEXTURE_2D,
 746                                 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 747         }
 748         es->num_textures = num_textures;
 749         glBindTexture(GL_TEXTURE_2D, 0);
 750 }
 751
 752 static void
 753 weston_surface_attach(struct wl_surface *surface, struct wl_buffer *buffer)
 754 {
 755         struct weston_surface *es = (struct weston_surface *) surface;
 756         struct weston_compositor *ec = es->compositor;
 757         EGLint attribs[3], format;
 758         int i, num_planes;
 759
 760         if (es->buffer) {
 761                 weston_buffer_post_release(es->buffer);
 762                 wl_list_remove(&es->buffer_destroy_listener.link);
 763         }
 764
 765         es->buffer = buffer;
 766
 767         if (!buffer) {
 768                 if (weston_surface_is_mapped(es))
 769                         weston_surface_unmap(es);
 770                 for (i = 0; i < es->num_images; i++) {
 771                         ec->destroy_image(ec->egl_display, es->images[i]);
 772                         es->images[i] = NULL;
 773                 }
 774                 es->num_images = 0;
 775                 glDeleteTextures(es->num_textures, es->textures);
 776                 es->num_textures = 0;
 777                 return;
 778         }
 779
 780         buffer->busy_count++;
 781         wl_signal_add(&es->buffer->resource.destroy_signal,
 782                       &es->buffer_destroy_listener);
 783
 784         if (es->geometry.width != buffer->width ||
 785             es->geometry.height != buffer->height) {
 786                 undef_region(&es->input);
 787                 pixman_region32_fini(&es->opaque);
 788                 pixman_region32_init(&es->opaque);
 789         }
 790
 791         if (wl_buffer_is_shm(buffer)) {
 792                 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
 793                 es->shader = &ec->texture_shader_rgba;
 794
 795                 ensure_textures(es, 1);
 796                 glBindTexture(GL_TEXTURE_2D, es->textures[0]);
 797                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
 798                              es->pitch, es->buffer->height, 0,
 799                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
 800                 if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888)
 801                         es->blend = 0;
 802                 else
 803                         es->blend = 1;
 804         } else if (ec->query_buffer(ec->egl_display, buffer,
 805                                     EGL_TEXTURE_FORMAT, &format)) {
 806                 for (i = 0; i < es->num_images; i++)
 807                         ec->destroy_image(ec->egl_display, es->images[i]);
 808                 es->num_images = 0;
 809
 810                 switch (format) {
 811                 case EGL_TEXTURE_RGB:
 812                 case EGL_TEXTURE_RGBA:
 813                 default:
 814                         num_planes = 1;
 815                         es->shader = &ec->texture_shader_rgba;
 816                         break;
 817                 case EGL_TEXTURE_Y_UV_WL:
 818                         num_planes = 2;
 819                         es->shader = &ec->texture_shader_y_uv;
 820                         break;
 821                 case EGL_TEXTURE_Y_U_V_WL:
 822                         num_planes = 3;
 823                         es->shader = &ec->texture_shader_y_u_v;
 824                         break;
 825                 case EGL_TEXTURE_Y_XUXV_WL:
 826                         num_planes = 2;
 827                         es->shader = &ec->texture_shader_y_xuxv;
 828                         break;
 829                 }
 830
 831                 ensure_textures(es, num_planes);
 832                 for (i = 0; i < num_planes; i++) {
 833                         attribs[0] = EGL_WAYLAND_PLANE_WL;
 834                         attribs[1] = i;
 835                         attribs[2] = EGL_NONE;
 836                         es->images[i] = ec->create_image(ec->egl_display,
 837                                                          NULL,
 838                                                          EGL_WAYLAND_BUFFER_WL,
 839                                                          buffer, attribs);
 840                         if (!es->images[i])
 841                                 continue;
 842                         es->num_images++;
 843
 844                         glActiveTexture(GL_TEXTURE0 + i);
 845                         glBindTexture(GL_TEXTURE_2D, es->textures[i]);
 846                         ec->image_target_texture_2d(GL_TEXTURE_2D,
 847                                                     es->images[i]);
 848                 }
 849
 850                 es->pitch = buffer->width;
 851         } else {
 852                 /* unhandled buffer type */
 853         }
 854 }
 855
 856 static int
 857 texture_region(struct weston_surface *es, pixman_region32_t *region)
 858 {
 859         struct weston_compositor *ec = es->compositor;
 860         GLfloat *v, inv_width, inv_height;
 861         GLfloat sx, sy;
 862         pixman_box32_t *rectangles;
 863         unsigned int *p;
 864         int i, n;
 865
 866         rectangles = pixman_region32_rectangles(region, &n);
 867         v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
 868         p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
 869         inv_width = 1.0 / es->pitch;
 870         inv_height = 1.0 / es->geometry.height;
 871
 872         for (i = 0; i < n; i++, v += 16, p += 6) {
 873                 surface_from_global_float(es, rectangles[i].x1,
 874                                           rectangles[i].y1, &sx, &sy);
 875                 v[ 0] = rectangles[i].x1;
 876                 v[ 1] = rectangles[i].y1;
 877                 v[ 2] = sx * inv_width;
 878                 v[ 3] = sy * inv_height;
 879
 880                 surface_from_global_float(es, rectangles[i].x1,
 881                                           rectangles[i].y2, &sx, &sy);
 882                 v[ 4] = rectangles[i].x1;
 883                 v[ 5] = rectangles[i].y2;
 884                 v[ 6] = sx * inv_width;
 885                 v[ 7] = sy * inv_height;
 886
 887                 surface_from_global_float(es, rectangles[i].x2,
 888                                           rectangles[i].y1, &sx, &sy);
 889                 v[ 8] = rectangles[i].x2;
 890                 v[ 9] = rectangles[i].y1;
 891                 v[10] = sx * inv_width;
 892                 v[11] = sy * inv_height;
 893
 894                 surface_from_global_float(es, rectangles[i].x2,
 895                                           rectangles[i].y2, &sx, &sy);
 896                 v[12] = rectangles[i].x2;
 897                 v[13] = rectangles[i].y2;
 898                 v[14] = sx * inv_width;
 899                 v[15] = sy * inv_height;
 900
 901                 p[0] = i * 4 + 0;
 902                 p[1] = i * 4 + 1;
 903                 p[2] = i * 4 + 2;
 904                 p[3] = i * 4 + 2;
 905                 p[4] = i * 4 + 1;
 906                 p[5] = i * 4 + 3;
 907         }
 908
 909         return n;
 910 }
 911
 912 WL_EXPORT void
 913 weston_surface_draw(struct weston_surface *es, struct weston_output *output,
 914                     pixman_region32_t *damage)
 915 {
 916         GLfloat surface_rect[4] = { 0.0, 1.0, 0.0, 1.0 };
 917         struct weston_compositor *ec = es->compositor;
 918         GLfloat *v;
 919         pixman_region32_t repaint;
 920         GLint filter;
 921         int i, n;
 922
 923         pixman_region32_init(&repaint);
 924         pixman_region32_intersect(&repaint,
 925                                   &es->transform.boundingbox, damage);
 926         pixman_region32_subtract(&repaint, &repaint, &es->clip);
 927
 928         if (!pixman_region32_not_empty(&repaint))
 929                 goto out;
 930
 931         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 932         if (es->blend || es->alpha < 1.0)
 933                 glEnable(GL_BLEND);
 934         else
 935                 glDisable(GL_BLEND);
 936
 937         if (ec->current_shader != es->shader) {
 938                 glUseProgram(es->shader->program);
 939                 ec->current_shader = es->shader;
 940         }
 941
 942         glUniformMatrix4fv(es->shader->proj_uniform,
 943                            1, GL_FALSE, output->matrix.d);
 944         glUniform4fv(es->shader->color_uniform, 1, es->color);
 945         glUniform1f(es->shader->alpha_uniform, es->alpha);
 946         glUniform1f(es->shader->texwidth_uniform,
 947                     (GLfloat)es->geometry.width / es->pitch);
 948         if (es->blend)
 949                 glUniform4fv(es->shader->opaque_uniform, 1, es->opaque_rect);
 950         else
 951                 glUniform4fv(es->shader->opaque_uniform, 1, surface_rect);
 952
 953         if (es->transform.enabled || output->zoom.active)
 954                 filter = GL_LINEAR;
 955         else
 956                 filter = GL_NEAREST;
 957
 958         n = texture_region(es, &repaint);
 959
 960         for (i = 0; i < es->num_textures; i++) {
 961                 glUniform1i(es->shader->tex_uniforms[i], i);
 962                 glActiveTexture(GL_TEXTURE0 + i);
 963                 glBindTexture(GL_TEXTURE_2D, es->textures[i]);
 964                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
 965                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
 966         }
 967
 968         v = ec->vertices.data;
 969         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
 970         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
 971         glEnableVertexAttribArray(0);
 972         glEnableVertexAttribArray(1);
 973
 974         glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
 975
 976         glDisableVertexAttribArray(1);
 977         glDisableVertexAttribArray(0);
 978
 979         ec->vertices.size = 0;
 980         ec->indices.size = 0;
 981
 982 out:
 983         pixman_region32_fini(&repaint);
 984 }
 985
 986 WL_EXPORT void
 987 weston_surface_restack(struct weston_surface *surface, struct wl_list *below)
 988 {
 989         wl_list_remove(&surface->layer_link);
 990         wl_list_insert(below, &surface->layer_link);
 991         weston_surface_damage_below(surface);
 992         weston_surface_damage(surface);
 993 }
 994
 995 WL_EXPORT void
 996 weston_compositor_damage_all(struct weston_compositor *compositor)
 997 {
 998         struct weston_output *output;
 999
1000         wl_list_for_each(output, &compositor->output_list, link)
1001                 weston_output_damage(output);
1002 }
1003
1004 WL_EXPORT void
1005 weston_buffer_post_release(struct wl_buffer *buffer)
1006 {
1007         if (--buffer->busy_count > 0)
1008                 return;
1009
1010         assert(buffer->resource.client != NULL);
1011         wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
1012 }
1013
1014 WL_EXPORT void
1015 weston_output_damage(struct weston_output *output)
1016 {
1017         struct weston_compositor *compositor = output->compositor;
1018
1019         pixman_region32_union(&compositor->primary_plane.damage,
1020                               &compositor->primary_plane.damage,
1021                               &output->region);
1022         weston_output_schedule_repaint(output);
1023 }
1024
1025 static void
1026 fade_frame(struct weston_animation *animation,
1027            struct weston_output *output, uint32_t msecs)
1028 {
1029         struct weston_compositor *compositor =
1030                 container_of(animation,
1031                              struct weston_compositor, fade.animation);
1032         struct weston_surface *surface;
1033
1034         if (animation->frame_counter <= 1)
1035                 compositor->fade.spring.timestamp = msecs;
1036
1037         surface = compositor->fade.surface;
1038         weston_spring_update(&compositor->fade.spring, msecs);
1039         weston_surface_set_color(surface, 0.0, 0.0, 0.0,
1040                                  compositor->fade.spring.current);
1041         weston_surface_damage(surface);
1042
1043         if (weston_spring_done(&compositor->fade.spring)) {
1044                 compositor->fade.spring.current =
1045                         compositor->fade.spring.target;
1046                 wl_list_remove(&animation->link);
1047                 wl_list_init(&animation->link);
1048
1049                 if (compositor->fade.spring.current < 0.001) {
1050                         destroy_surface(&surface->surface.resource);
1051                         compositor->fade.surface = NULL;
1052                 } else if (compositor->fade.spring.current > 0.999) {
1053                         compositor->state = WESTON_COMPOSITOR_SLEEPING;
1054                         wl_signal_emit(&compositor->lock_signal, compositor);
1055                 }
1056         }
1057 }
1058
1059 static void
1060 update_shm_texture(struct weston_surface *surface)
1061 {
1062 #ifdef GL_UNPACK_ROW_LENGTH
1063         pixman_box32_t *rectangles;
1064         void *data;
1065         int i, n;
1066 #endif
1067
1068         glBindTexture(GL_TEXTURE_2D, surface->textures[0]);
1069
1070         if (!surface->compositor->has_unpack_subimage) {
1071                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1072                              surface->pitch, surface->buffer->height, 0,
1073                              GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1074                              wl_shm_buffer_get_data(surface->buffer));
1075
1076                 return;
1077         }
1078
1079 #ifdef GL_UNPACK_ROW_LENGTH
1080         /* Mesa does not define GL_EXT_unpack_subimage */
1081         glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->pitch);
1082         data = wl_shm_buffer_get_data(surface->buffer);
1083         rectangles = pixman_region32_rectangles(&surface->damage, &n);
1084         for (i = 0; i < n; i++) {
1085                 glPixelStorei(GL_UNPACK_SKIP_PIXELS, rectangles[i].x1);
1086                 glPixelStorei(GL_UNPACK_SKIP_ROWS, rectangles[i].y1);
1087                 glTexSubImage2D(GL_TEXTURE_2D, 0,
1088                                 rectangles[i].x1, rectangles[i].y1,
1089                                 rectangles[i].x2 - rectangles[i].x1,
1090                                 rectangles[i].y2 - rectangles[i].y1,
1091                                 GL_BGRA_EXT, GL_UNSIGNED_BYTE, data);
1092         }
1093 #endif
1094 }
1095
1096 static void
1097 surface_accumulate_damage(struct weston_surface *surface,
1098                           pixman_region32_t *opaque)
1099 {
1100         if (surface->buffer && wl_buffer_is_shm(surface->buffer))
1101                 update_shm_texture(surface);
1102
1103         if (surface->transform.enabled) {
1104                 pixman_box32_t *extents;
1105
1106                 extents = pixman_region32_extents(&surface->damage);
1107                 surface_compute_bbox(surface, extents->x1, extents->y1,
1108                                      extents->x2 - extents->x1,
1109                                      extents->y2 - extents->y1,
1110                                      &surface->damage);
1111                 pixman_region32_translate(&surface->damage,
1112                                           -surface->plane->x,
1113                                           -surface->plane->y);
1114         } else {
1115                 pixman_region32_translate(&surface->damage,
1116                                           surface->geometry.x - surface->plane->x,
1117                                           surface->geometry.y - surface->plane->y);
1118         }
1119
1120         pixman_region32_subtract(&surface->damage, &surface->damage, opaque);
1121         pixman_region32_union(&surface->plane->damage,
1122                               &surface->plane->damage, &surface->damage);
1123         empty_region(&surface->damage);
1124         pixman_region32_copy(&surface->clip, opaque);
1125         if (surface->plane == &surface->compositor->primary_plane)
1126                 pixman_region32_union(opaque, opaque, &surface->transform.opaque);
1127 }
1128
1129 static void
1130 weston_output_repaint(struct weston_output *output, uint32_t msecs)
1131 {
1132         struct weston_compositor *ec = output->compositor;
1133         struct weston_surface *es;
1134         struct weston_layer *layer;
1135         struct weston_animation *animation, *next;
1136         struct weston_frame_callback *cb, *cnext;
1137         struct wl_list frame_callback_list;
1138         pixman_region32_t opaque, output_damage;
1139         int32_t width, height;
1140
1141         weston_compositor_update_drag_surfaces(ec);
1142
1143         width = output->current->width +
1144                 output->border.left + output->border.right;
1145         height = output->current->height +
1146                 output->border.top + output->border.bottom;
1147         glViewport(0, 0, width, height);
1148
1149         /* Rebuild the surface list and update surface transforms up front. */
1150         wl_list_init(&ec->surface_list);
1151         wl_list_init(&frame_callback_list);
1152         wl_list_for_each(layer, &ec->layer_list, link) {
1153                 wl_list_for_each(es, &layer->surface_list, layer_link) {
1154                         weston_surface_update_transform(es);
1155                         wl_list_insert(ec->surface_list.prev, &es->link);
1156                         if (es->output == output) {
1157                                 wl_list_insert_list(&frame_callback_list,
1158                                                     &es->frame_callback_list);
1159                                 wl_list_init(&es->frame_callback_list);
1160                         }
1161                 }
1162         }
1163
1164         if (output->assign_planes && !output->disable_planes)
1165                 output->assign_planes(output);
1166         else
1167                 wl_list_for_each(es, &ec->surface_list, link)
1168                         weston_surface_move_to_plane(es, &ec->primary_plane);
1169
1170
1171         pixman_region32_init(&opaque);
1172
1173         wl_list_for_each(es, &ec->surface_list, link)
1174                 surface_accumulate_damage(es, &opaque);
1175
1176         pixman_region32_init(&output_damage);
1177         pixman_region32_union(&output_damage, &ec->primary_plane.damage,
1178                               &output->previous_damage);
1179         pixman_region32_copy(&output->previous_damage,
1180                              &ec->primary_plane.damage);
1181         pixman_region32_intersect(&output_damage,
1182                                   &output_damage, &output->region);
1183         pixman_region32_subtract(&ec->primary_plane.damage,
1184                                  &ec->primary_plane.damage, &output->region);
1185
1186         pixman_region32_fini(&opaque);
1187
1188         if (output->dirty)
1189                 weston_output_update_matrix(output);
1190
1191         output->repaint(output, &output_damage);
1192
1193         pixman_region32_fini(&output_damage);
1194
1195         output->repaint_needed = 0;
1196
1197         weston_compositor_repick(ec);
1198         wl_event_loop_dispatch(ec->input_loop, 0);
1199
1200         wl_list_for_each_safe(cb, cnext, &frame_callback_list, link) {
1201                 wl_callback_send_done(&cb->resource, msecs);
1202                 wl_resource_destroy(&cb->resource);
1203         }
1204         wl_list_init(&frame_callback_list);
1205
1206         wl_list_for_each_safe(animation, next, &output->animation_list, link) {
1207                 animation->frame_counter++;
1208                 animation->frame(animation, output, msecs);
1209         }
1210 }
1211
1212 static int
1213 weston_compositor_read_input(int fd, uint32_t mask, void *data)
1214 {
1215         struct weston_compositor *compositor = data;
1216
1217         wl_event_loop_dispatch(compositor->input_loop, 0);
1218
1219         return 1;
1220 }
1221
1222 WL_EXPORT void
1223 weston_output_finish_frame(struct weston_output *output, uint32_t msecs)
1224 {
1225         struct weston_compositor *compositor = output->compositor;
1226         struct wl_event_loop *loop =
1227                 wl_display_get_event_loop(compositor->wl_display);
1228         int fd;
1229
1230         output->frame_time = msecs;
1231         if (output->repaint_needed) {
1232                 weston_output_repaint(output, msecs);
1233                 return;
1234         }
1235
1236         output->repaint_scheduled = 0;
1237         if (compositor->input_loop_source)
1238                 return;
1239
1240         fd = wl_event_loop_get_fd(compositor->input_loop);
1241         compositor->input_loop_source =
1242                 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1243                                      weston_compositor_read_input, compositor);
1244 }
1245
1246 static void
1247 idle_repaint(void *data)
1248 {
1249         struct weston_output *output = data;
1250
1251         weston_output_finish_frame(output, weston_compositor_get_time());
1252 }
1253
1254 WL_EXPORT void
1255 weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1256 {
1257         wl_list_init(&layer->surface_list);
1258         if (below != NULL)
1259                 wl_list_insert(below, &layer->link);
1260 }
1261
1262 WL_EXPORT void
1263 weston_output_schedule_repaint(struct weston_output *output)
1264 {
1265         struct weston_compositor *compositor = output->compositor;
1266         struct wl_event_loop *loop;
1267
1268         if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
1269                 return;
1270
1271         loop = wl_display_get_event_loop(compositor->wl_display);
1272         output->repaint_needed = 1;
1273         if (output->repaint_scheduled)
1274                 return;
1275
1276         wl_event_loop_add_idle(loop, idle_repaint, output);
1277         output->repaint_scheduled = 1;
1278
1279         if (compositor->input_loop_source) {
1280                 wl_event_source_remove(compositor->input_loop_source);
1281                 compositor->input_loop_source = NULL;
1282         }
1283 }
1284
1285 WL_EXPORT void
1286 weston_compositor_schedule_repaint(struct weston_compositor *compositor)
1287 {
1288         struct weston_output *output;
1289
1290         wl_list_for_each(output, &compositor->output_list, link)
1291                 weston_output_schedule_repaint(output);
1292 }
1293
1294 WL_EXPORT void
1295 weston_compositor_fade(struct weston_compositor *compositor, float tint)
1296 {
1297         struct weston_output *output;
1298         struct weston_surface *surface;
1299
1300         output = container_of(compositor->output_list.next,
1301                              struct weston_output, link);
1302
1303         compositor->fade.spring.target = tint;
1304         if (weston_spring_done(&compositor->fade.spring))
1305                 return;
1306
1307         if (compositor->fade.surface == NULL) {
1308                 surface = weston_surface_create(compositor);
1309                 weston_surface_configure(surface, 0, 0, 8192, 8192);
1310                 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
1311                 wl_list_insert(&compositor->fade_layer.surface_list,
1312                                &surface->layer_link);
1313                 weston_surface_assign_output(surface);
1314                 compositor->fade.surface = surface;
1315                 pixman_region32_init(&surface->input);
1316         }
1317
1318         weston_surface_damage(compositor->fade.surface);
1319         if (wl_list_empty(&compositor->fade.animation.link)) {
1320                 compositor->fade.animation.frame_counter = 0;
1321                 wl_list_insert(output->animation_list.prev,
1322                                &compositor->fade.animation.link);
1323         }
1324 }
1325
1326 static void
1327 surface_destroy(struct wl_client *client, struct wl_resource *resource)
1328 {
1329         wl_resource_destroy(resource);
1330 }
1331
1332 static struct wl_resource *
1333 find_resource_for_client(struct wl_list *list, struct wl_client *client)
1334 {
1335         struct wl_resource *r;
1336
1337         wl_list_for_each(r, list, link) {
1338                 if (r->client == client)
1339                         return r;
1340         }
1341
1342         return NULL;
1343 }
1344
1345 static void
1346 weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
1347 {
1348         uint32_t different = es->output_mask ^ mask;
1349         uint32_t entered = mask & different;
1350         uint32_t left = es->output_mask & different;
1351         struct weston_output *output;
1352         struct wl_resource *resource = NULL;
1353         struct wl_client *client = es->surface.resource.client;
1354
1355         es->output_mask = mask;
1356         if (es->surface.resource.client == NULL)
1357                 return;
1358         if (different == 0)
1359                 return;
1360
1361         wl_list_for_each(output, &es->compositor->output_list, link) {
1362                 if (1 << output->id & different)
1363                         resource =
1364                                 find_resource_for_client(&output->resource_list,
1365                                                          client);
1366                 if (resource == NULL)
1367                         continue;
1368                 if (1 << output->id & entered)
1369                         wl_surface_send_enter(&es->surface.resource, resource);
1370                 if (1 << output->id & left)
1371                         wl_surface_send_leave(&es->surface.resource, resource);
1372         }
1373 }
1374
1375 WL_EXPORT void
1376 weston_surface_assign_output(struct weston_surface *es)
1377 {
1378         struct weston_compositor *ec = es->compositor;
1379         struct weston_output *output, *new_output;
1380         pixman_region32_t region;
1381         uint32_t max, area, mask;
1382         pixman_box32_t *e;
1383
1384         new_output = NULL;
1385         max = 0;
1386         mask = 0;
1387         pixman_region32_init(&region);
1388         wl_list_for_each(output, &ec->output_list, link) {
1389                 pixman_region32_intersect(&region, &es->transform.boundingbox,
1390                                           &output->region);
1391
1392                 e = pixman_region32_extents(&region);
1393                 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1394
1395                 if (area > 0)
1396                         mask |= 1 << output->id;
1397
1398                 if (area >= max) {
1399                         new_output = output;
1400                         max = area;
1401                 }
1402         }
1403         pixman_region32_fini(&region);
1404
1405         es->output = new_output;
1406         weston_surface_update_output_mask(es, mask);
1407 }
1408
1409 static void
1410 surface_attach(struct wl_client *client,
1411                struct wl_resource *resource,
1412                struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1413 {
1414         struct weston_surface *es = resource->data;
1415         struct wl_buffer *buffer = NULL;
1416
1417         if (buffer_resource)
1418                 buffer = buffer_resource->data;
1419
1420         weston_surface_attach(&es->surface, buffer);
1421
1422         if (buffer && es->configure)
1423                 es->configure(es, sx, sy);
1424 }
1425
1426 static void
1427 surface_damage(struct wl_client *client,
1428                struct wl_resource *resource,
1429                int32_t x, int32_t y, int32_t width, int32_t height)
1430 {
1431         struct weston_surface *es = resource->data;
1432
1433         pixman_region32_union_rect(&es->damage, &es->damage,
1434                                    x, y, width, height);
1435         weston_surface_schedule_repaint(es);
1436 }
1437
1438 static void
1439 destroy_frame_callback(struct wl_resource *resource)
1440 {
1441         struct weston_frame_callback *cb = resource->data;
1442
1443         wl_list_remove(&cb->link);
1444         free(cb);
1445 }
1446
1447 static void
1448 surface_frame(struct wl_client *client,
1449               struct wl_resource *resource, uint32_t callback)
1450 {
1451         struct weston_frame_callback *cb;
1452         struct weston_surface *es = resource->data;
1453
1454         cb = malloc(sizeof *cb);
1455         if (cb == NULL) {
1456                 wl_resource_post_no_memory(resource);
1457                 return;
1458         }
1459
1460         cb->resource.object.interface = &wl_callback_interface;
1461         cb->resource.object.id = callback;
1462         cb->resource.destroy = destroy_frame_callback;
1463         cb->resource.client = client;
1464         cb->resource.data = cb;
1465
1466         wl_client_add_resource(client, &cb->resource);
1467         wl_list_insert(es->frame_callback_list.prev, &cb->link);
1468 }
1469
1470 static void
1471 surface_set_opaque_region(struct wl_client *client,
1472                           struct wl_resource *resource,
1473                           struct wl_resource *region_resource)
1474 {
1475         struct weston_surface *surface = resource->data;
1476         struct weston_region *region;
1477
1478         pixman_region32_fini(&surface->opaque);
1479
1480         if (region_resource) {
1481                 region = region_resource->data;
1482                 pixman_region32_init_rect(&surface->opaque, 0, 0,
1483                                           surface->geometry.width,
1484                                           surface->geometry.height);
1485                 pixman_region32_intersect(&surface->opaque,
1486                                           &surface->opaque, &region->region);
1487         } else {
1488                 pixman_region32_init(&surface->opaque);
1489         }
1490
1491         surface->geometry.dirty = 1;
1492 }
1493
1494 static void
1495 surface_set_input_region(struct wl_client *client,
1496                          struct wl_resource *resource,
1497                          struct wl_resource *region_resource)
1498 {
1499         struct weston_surface *surface = resource->data;
1500         struct weston_region *region;
1501
1502         if (region_resource) {
1503                 region = region_resource->data;
1504                 pixman_region32_init_rect(&surface->input, 0, 0,
1505                                           surface->geometry.width,
1506                                           surface->geometry.height);
1507                 pixman_region32_intersect(&surface->input,
1508                                           &surface->input, &region->region);
1509         } else {
1510                 pixman_region32_init_rect(&surface->input, 0, 0,
1511                                           surface->geometry.width,
1512                                           surface->geometry.height);
1513         }
1514
1515         weston_surface_schedule_repaint(surface);
1516 }
1517
1518 static const struct wl_surface_interface surface_interface = {
1519         surface_destroy,
1520         surface_attach,
1521         surface_damage,
1522         surface_frame,
1523         surface_set_opaque_region,
1524         surface_set_input_region
1525 };
1526
1527 static void
1528 compositor_create_surface(struct wl_client *client,
1529                           struct wl_resource *resource, uint32_t id)
1530 {
1531         struct weston_compositor *ec = resource->data;
1532         struct weston_surface *surface;
1533
1534         surface = weston_surface_create(ec);
1535         if (surface == NULL) {
1536                 wl_resource_post_no_memory(resource);
1537                 return;
1538         }
1539
1540         surface->surface.resource.destroy = destroy_surface;
1541
1542         surface->surface.resource.object.id = id;
1543         surface->surface.resource.object.interface = &wl_surface_interface;
1544         surface->surface.resource.object.implementation =
1545                 (void (**)(void)) &surface_interface;
1546         surface->surface.resource.data = surface;
1547
1548         wl_client_add_resource(client, &surface->surface.resource);
1549 }
1550
1551 static void
1552 destroy_region(struct wl_resource *resource)
1553 {
1554         struct weston_region *region =
1555                 container_of(resource, struct weston_region, resource);
1556
1557         pixman_region32_fini(&region->region);
1558         free(region);
1559 }
1560
1561 static void
1562 region_destroy(struct wl_client *client, struct wl_resource *resource)
1563 {
1564         wl_resource_destroy(resource);
1565 }
1566
1567 static void
1568 region_add(struct wl_client *client, struct wl_resource *resource,
1569            int32_t x, int32_t y, int32_t width, int32_t height)
1570 {
1571         struct weston_region *region = resource->data;
1572
1573         pixman_region32_union_rect(&region->region, &region->region,
1574                                    x, y, width, height);
1575 }
1576
1577 static void
1578 region_subtract(struct wl_client *client, struct wl_resource *resource,
1579                 int32_t x, int32_t y, int32_t width, int32_t height)
1580 {
1581         struct weston_region *region = resource->data;
1582         pixman_region32_t rect;
1583
1584         pixman_region32_init_rect(&rect, x, y, width, height);
1585         pixman_region32_subtract(&region->region, &region->region, &rect);
1586         pixman_region32_fini(&rect);
1587 }
1588
1589 static const struct wl_region_interface region_interface = {
1590         region_destroy,
1591         region_add,
1592         region_subtract
1593 };
1594
1595 static void
1596 compositor_create_region(struct wl_client *client,
1597                          struct wl_resource *resource, uint32_t id)
1598 {
1599         struct weston_region *region;
1600
1601         region = malloc(sizeof *region);
1602         if (region == NULL) {
1603                 wl_resource_post_no_memory(resource);
1604                 return;
1605         }
1606
1607         region->resource.destroy = destroy_region;
1608
1609         region->resource.object.id = id;
1610         region->resource.object.interface = &wl_region_interface;
1611         region->resource.object.implementation =
1612                 (void (**)(void)) &region_interface;
1613         region->resource.data = region;
1614
1615         pixman_region32_init(&region->region);
1616
1617         wl_client_add_resource(client, &region->resource);
1618 }
1619
1620 static const struct wl_compositor_interface compositor_interface = {
1621         compositor_create_surface,
1622         compositor_create_region
1623 };
1624
1625 WL_EXPORT void
1626 weston_compositor_wake(struct weston_compositor *compositor)
1627 {
1628         compositor->state = WESTON_COMPOSITOR_ACTIVE;
1629         weston_compositor_fade(compositor, 0.0);
1630
1631         wl_event_source_timer_update(compositor->idle_source,
1632                                      compositor->idle_time * 1000);
1633 }
1634
1635 static void
1636 weston_compositor_dpms_on(struct weston_compositor *compositor)
1637 {
1638         struct weston_output *output;
1639
1640         wl_list_for_each(output, &compositor->output_list, link)
1641                 if (output->set_dpms)
1642                         output->set_dpms(output, WESTON_DPMS_ON);
1643 }
1644
1645 WL_EXPORT void
1646 weston_compositor_activity(struct weston_compositor *compositor)
1647 {
1648         if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1649                 weston_compositor_wake(compositor);
1650         } else {
1651                 weston_compositor_dpms_on(compositor);
1652                 wl_signal_emit(&compositor->unlock_signal, compositor);
1653         }
1654 }
1655
1656 static void
1657 weston_compositor_idle_inhibit(struct weston_compositor *compositor)
1658 {
1659         weston_compositor_activity(compositor);
1660         compositor->idle_inhibit++;
1661 }
1662
1663 static void
1664 weston_compositor_idle_release(struct weston_compositor *compositor)
1665 {
1666         compositor->idle_inhibit--;
1667         weston_compositor_activity(compositor);
1668 }
1669
1670 static int
1671 idle_handler(void *data)
1672 {
1673         struct weston_compositor *compositor = data;
1674
1675         if (compositor->idle_inhibit)
1676                 return 1;
1677
1678         weston_compositor_fade(compositor, 1.0);
1679
1680         return 1;
1681 }
1682
1683 WL_EXPORT void
1684 weston_plane_init(struct weston_plane *plane, int32_t x, int32_t y)
1685 {
1686         pixman_region32_init(&plane->damage);
1687         plane->x = x;
1688         plane->y = y;
1689 }
1690
1691 WL_EXPORT void
1692 weston_plane_release(struct weston_plane *plane)
1693 {
1694         pixman_region32_fini(&plane->damage);
1695 }
1696
1697 static  void
1698 weston_seat_update_drag_surface(struct wl_seat *seat, int dx, int dy);
1699
1700 static void
1701 clip_pointer_motion(struct weston_seat *seat, wl_fixed_t *fx, wl_fixed_t *fy)
1702 {
1703         struct weston_compositor *ec = seat->compositor;
1704         struct weston_output *output, *prev = NULL;
1705         int x, y, old_x, old_y, valid = 0;
1706
1707         x = wl_fixed_to_int(*fx);
1708         y = wl_fixed_to_int(*fy);
1709         old_x = wl_fixed_to_int(seat->seat.pointer->x);
1710         old_y = wl_fixed_to_int(seat->seat.pointer->y);
1711
1712         wl_list_for_each(output, &ec->output_list, link) {
1713                 if (pixman_region32_contains_point(&output->region,
1714                                                    x, y, NULL))
1715                         valid = 1;
1716                 if (pixman_region32_contains_point(&output->region,
1717                                                    old_x, old_y, NULL))
1718                         prev = output;
1719         }
1720
1721         if (!valid) {
1722                 if (x < prev->x)
1723                         *fx = wl_fixed_from_int(prev->x);
1724                 else if (x >= prev->x + prev->current->width)
1725                         *fx = wl_fixed_from_int(prev->x +
1726                                                 prev->current->width - 1);
1727                 if (y < prev->y)
1728                         *fy = wl_fixed_from_int(prev->y);
1729                 else if (y >= prev->y + prev->current->height)
1730                         *fy = wl_fixed_from_int(prev->y +
1731                                                 prev->current->height - 1);
1732         }
1733 }
1734
1735 WL_EXPORT void
1736 notify_motion(struct wl_seat *seat, uint32_t time, wl_fixed_t x, wl_fixed_t y)
1737 {
1738         const struct wl_pointer_grab_interface *interface;
1739         struct weston_seat *ws = (struct weston_seat *) seat;
1740         struct weston_compositor *ec = ws->compositor;
1741         struct weston_output *output;
1742         int32_t ix, iy;
1743
1744         weston_compositor_activity(ec);
1745
1746         clip_pointer_motion(ws, &x, &y);
1747
1748         weston_seat_update_drag_surface(seat,
1749                                         x - seat->pointer->x,
1750                                         y - seat->pointer->y);
1751
1752         seat->pointer->x = x;
1753         seat->pointer->y = y;
1754
1755         ix = wl_fixed_to_int(x);
1756         iy = wl_fixed_to_int(y);
1757
1758         wl_list_for_each(output, &ec->output_list, link)
1759                 if (output->zoom.active &&
1760                     pixman_region32_contains_point(&output->region,
1761                                                    ix, iy, NULL))
1762                         weston_output_update_zoom(output, ZOOM_FOCUS_POINTER);
1763
1764         weston_device_repick(seat);
1765         interface = seat->pointer->grab->interface;
1766         interface->motion(seat->pointer->grab, time,
1767                           seat->pointer->grab->x, seat->pointer->grab->y);
1768
1769         if (ws->sprite) {
1770                 weston_surface_set_position(ws->sprite,
1771                                             ix - ws->hotspot_x,
1772                                             iy - ws->hotspot_y);
1773                 weston_surface_schedule_repaint(ws->sprite);
1774         }
1775 }
1776
1777 WL_EXPORT void
1778 weston_surface_activate(struct weston_surface *surface,
1779                         struct weston_seat *seat)
1780 {
1781         struct weston_compositor *compositor = seat->compositor;
1782
1783         if (seat->seat.keyboard) {
1784                 wl_keyboard_set_focus(seat->seat.keyboard, &surface->surface);
1785                 wl_data_device_set_keyboard_focus(&seat->seat);
1786         }
1787
1788         wl_signal_emit(&compositor->activate_signal, surface);
1789 }
1790
1791 WL_EXPORT void
1792 notify_button(struct wl_seat *seat, uint32_t time, int32_t button,
1793               enum wl_pointer_button_state state)
1794 {
1795         struct weston_seat *ws = (struct weston_seat *) seat;
1796         struct weston_compositor *compositor = ws->compositor;
1797         struct weston_surface *focus =
1798                 (struct weston_surface *) seat->pointer->focus;
1799         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1800
1801         if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
1802                 if (compositor->ping_handler && focus)
1803                         compositor->ping_handler(focus, serial);
1804                 weston_compositor_idle_inhibit(compositor);
1805                 if (seat->pointer->button_count == 0) {
1806                         seat->pointer->grab_button = button;
1807                         seat->pointer->grab_time = time;
1808                         seat->pointer->grab_x = seat->pointer->x;
1809                         seat->pointer->grab_y = seat->pointer->y;
1810                 }
1811                 seat->pointer->button_count++;
1812         } else {
1813                 weston_compositor_idle_release(compositor);
1814                 seat->pointer->button_count--;
1815         }
1816
1817         weston_compositor_run_button_binding(compositor, ws, time, button,
1818                                              state);
1819
1820         seat->pointer->grab->interface->button(seat->pointer->grab, time,
1821                                                button, state);
1822
1823         if (seat->pointer->button_count == 1)
1824                 seat->pointer->grab_serial =
1825                         wl_display_get_serial(compositor->wl_display);
1826 }
1827
1828 WL_EXPORT void
1829 notify_axis(struct wl_seat *seat, uint32_t time, uint32_t axis,
1830             wl_fixed_t value)
1831 {
1832         struct weston_seat *ws = (struct weston_seat *) seat;
1833         struct weston_compositor *compositor = ws->compositor;
1834         struct weston_surface *focus =
1835                 (struct weston_surface *) seat->pointer->focus;
1836         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1837
1838         if (compositor->ping_handler && focus)
1839                 compositor->ping_handler(focus, serial);
1840
1841         weston_compositor_activity(compositor);
1842
1843         if (value)
1844                 weston_compositor_run_axis_binding(compositor, ws, time, axis,
1845                                                    value);
1846         else
1847                 return;
1848
1849         if (seat->pointer->focus_resource)
1850                 wl_pointer_send_axis(seat->pointer->focus_resource, time, axis,
1851                                      value);
1852 }
1853
1854 WL_EXPORT void
1855 notify_modifiers(struct wl_seat *wl_seat, uint32_t serial)
1856 {
1857         struct weston_seat *seat = (struct weston_seat *) wl_seat;
1858         struct wl_keyboard *keyboard = &seat->keyboard;
1859         struct wl_keyboard_grab *grab = keyboard->grab;
1860         uint32_t mods_depressed, mods_latched, mods_locked, group;
1861         uint32_t mods_lookup;
1862         enum weston_led leds = 0;
1863         int changed = 0;
1864
1865         /* Serialize and update our internal state, checking to see if it's
1866          * different to the previous state. */
1867         mods_depressed = xkb_state_serialize_mods(seat->xkb_state.state,
1868                                                   XKB_STATE_DEPRESSED);
1869         mods_latched = xkb_state_serialize_mods(seat->xkb_state.state,
1870                                                 XKB_STATE_LATCHED);
1871         mods_locked = xkb_state_serialize_mods(seat->xkb_state.state,
1872                                                XKB_STATE_LOCKED);
1873         group = xkb_state_serialize_group(seat->xkb_state.state,
1874                                           XKB_STATE_EFFECTIVE);
1875
1876         if (mods_depressed != seat->seat.keyboard->modifiers.mods_depressed ||
1877             mods_latched != seat->seat.keyboard->modifiers.mods_latched ||
1878             mods_locked != seat->seat.keyboard->modifiers.mods_locked ||
1879             group != seat->seat.keyboard->modifiers.group)
1880                 changed = 1;
1881
1882         seat->seat.keyboard->modifiers.mods_depressed = mods_depressed;
1883         seat->seat.keyboard->modifiers.mods_latched = mods_latched;
1884         seat->seat.keyboard->modifiers.mods_locked = mods_locked;
1885         seat->seat.keyboard->modifiers.group = group;
1886
1887         /* And update the modifier_state for bindings. */
1888         mods_lookup = mods_depressed | mods_latched;
1889         seat->modifier_state = 0;
1890         if (mods_lookup & (1 << seat->xkb_info.ctrl_mod))
1891                 seat->modifier_state |= MODIFIER_CTRL;
1892         if (mods_lookup & (1 << seat->xkb_info.alt_mod))
1893                 seat->modifier_state |= MODIFIER_ALT;
1894         if (mods_lookup & (1 << seat->xkb_info.super_mod))
1895                 seat->modifier_state |= MODIFIER_SUPER;
1896         if (mods_lookup & (1 << seat->xkb_info.shift_mod))
1897                 seat->modifier_state |= MODIFIER_SHIFT;
1898
1899         /* Finally, notify the compositor that LEDs have changed. */
1900         if (xkb_state_led_index_is_active(seat->xkb_state.state,
1901                                           seat->xkb_info.num_led))
1902                 leds |= LED_NUM_LOCK;
1903         if (xkb_state_led_index_is_active(seat->xkb_state.state,
1904                                           seat->xkb_info.caps_led))
1905                 leds |= LED_CAPS_LOCK;
1906         if (xkb_state_led_index_is_active(seat->xkb_state.state,
1907                                           seat->xkb_info.scroll_led))
1908                 leds |= LED_SCROLL_LOCK;
1909         if (leds != seat->xkb_state.leds && seat->led_update)
1910                 seat->led_update(seat, leds);
1911         seat->xkb_state.leds = leds;
1912
1913         if (changed) {
1914                 grab->interface->modifiers(grab,
1915                                            serial,
1916                                            keyboard->modifiers.mods_depressed,
1917                                            keyboard->modifiers.mods_latched,
1918                                            keyboard->modifiers.mods_locked,
1919                                            keyboard->modifiers.group);
1920         }
1921 }
1922
1923 static void
1924 update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
1925                       enum wl_keyboard_key_state state)
1926 {
1927         enum xkb_key_direction direction;
1928
1929         if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1930                 direction = XKB_KEY_DOWN;
1931         else
1932                 direction = XKB_KEY_UP;
1933
1934         /* Offset the keycode by 8, as the evdev XKB rules reflect X's
1935          * broken keycode system, which starts at 8. */
1936         xkb_state_update_key(seat->xkb_state.state, key + 8, direction);
1937
1938         notify_modifiers(&seat->seat, serial);
1939 }
1940
1941 WL_EXPORT void
1942 notify_key(struct wl_seat *seat, uint32_t time, uint32_t key,
1943            enum wl_keyboard_key_state state,
1944            enum weston_key_state_update update_state)
1945 {
1946         struct weston_seat *ws = (struct weston_seat *) seat;
1947         struct weston_compositor *compositor = ws->compositor;
1948         struct weston_surface *focus =
1949                 (struct weston_surface *) seat->keyboard->focus;
1950         struct wl_keyboard_grab *grab = seat->keyboard->grab;
1951         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1952         uint32_t *k, *end;
1953
1954         if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1955                 if (compositor->ping_handler && focus)
1956                         compositor->ping_handler(focus, serial);
1957
1958                 weston_compositor_idle_inhibit(compositor);
1959                 seat->keyboard->grab_key = key;
1960                 seat->keyboard->grab_time = time;
1961         } else {
1962                 weston_compositor_idle_release(compositor);
1963         }
1964
1965         end = seat->keyboard->keys.data + seat->keyboard->keys.size;
1966         for (k = seat->keyboard->keys.data; k < end; k++) {
1967                 if (*k == key) {
1968                         /* Ignore server-generated repeats. */
1969                         if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1970                                 return;
1971                         *k = *--end;
1972                 }
1973         }
1974         seat->keyboard->keys.size = (void *) end - seat->keyboard->keys.data;
1975         if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1976                 k = wl_array_add(&seat->keyboard->keys, sizeof *k);
1977                 *k = key;
1978         }
1979
1980         if (grab == &seat->keyboard->default_grab) {
1981                 weston_compositor_run_key_binding(compositor, ws, time, key,
1982                                                   state);
1983                 grab = seat->keyboard->grab;
1984         }
1985
1986         grab->interface->key(grab, time, key, state);
1987
1988         if (update_state == STATE_UPDATE_AUTOMATIC) {
1989                 update_modifier_state(ws,
1990                                       wl_display_get_serial(compositor->wl_display),
1991                                       key,
1992                                       state);
1993         }
1994 }
1995
1996 WL_EXPORT void
1997 notify_pointer_focus(struct wl_seat *seat, struct weston_output *output,
1998                      wl_fixed_t x, wl_fixed_t y)
1999 {
2000         struct weston_seat *ws = (struct weston_seat *) seat;
2001         struct weston_compositor *compositor = ws->compositor;
2002
2003         if (output) {
2004                 weston_seat_update_drag_surface(seat,
2005                                                 x - seat->pointer->x,
2006                                                 y - seat->pointer->y);
2007
2008                 seat->pointer->x = x;
2009                 seat->pointer->y = y;
2010                 compositor->focus = 1;
2011                 weston_compositor_repick(compositor);
2012         } else {
2013                 compositor->focus = 0;
2014                 /* FIXME: We should call wl_pointer_set_focus(seat,
2015                  * NULL) here, but somehow that breaks re-entry... */
2016         }
2017 }
2018
2019 static void
2020 destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
2021 {
2022         struct weston_seat *ws;
2023
2024         ws = container_of(listener, struct weston_seat,
2025                           saved_kbd_focus_listener);
2026
2027         ws->saved_kbd_focus = NULL;
2028 }
2029
2030 WL_EXPORT void
2031 notify_keyboard_focus_in(struct wl_seat *seat, struct wl_array *keys,
2032                          enum weston_key_state_update update_state)
2033 {
2034         struct weston_seat *ws = (struct weston_seat *) seat;
2035         struct weston_compositor *compositor = ws->compositor;
2036         struct wl_surface *surface;
2037         uint32_t *k, serial;
2038
2039         serial = wl_display_next_serial(compositor->wl_display);
2040         wl_array_copy(&seat->keyboard->keys, keys);
2041         wl_array_for_each(k, &seat->keyboard->keys) {
2042                 weston_compositor_idle_inhibit(compositor);
2043                 if (update_state == STATE_UPDATE_AUTOMATIC)
2044                         update_modifier_state(ws, serial, *k,
2045                                               WL_KEYBOARD_KEY_STATE_PRESSED);
2046         }
2047
2048         /* Run key bindings after we've updated the state. */
2049         wl_array_for_each(k, &seat->keyboard->keys) {
2050                 weston_compositor_run_key_binding(compositor, ws, 0, *k,
2051                                                   WL_KEYBOARD_KEY_STATE_PRESSED);
2052         }
2053
2054         surface = ws->saved_kbd_focus;
2055
2056         if (surface) {
2057                 wl_list_remove(&ws->saved_kbd_focus_listener.link);
2058                 wl_keyboard_set_focus(ws->seat.keyboard, surface);
2059                 ws->saved_kbd_focus = NULL;
2060         }
2061 }
2062
2063 WL_EXPORT void
2064 notify_keyboard_focus_out(struct wl_seat *seat)
2065 {
2066         struct weston_seat *ws = (struct weston_seat *) seat;
2067         struct weston_compositor *compositor = ws->compositor;
2068         struct wl_surface *surface;
2069         uint32_t *k, serial;
2070
2071         serial = wl_display_next_serial(compositor->wl_display);
2072         wl_array_for_each(k, &seat->keyboard->keys) {
2073                 weston_compositor_idle_release(compositor);
2074                 update_modifier_state(ws, serial, *k,
2075                                       WL_KEYBOARD_KEY_STATE_RELEASED);
2076         }
2077
2078         ws->modifier_state = 0;
2079
2080         surface = ws->seat.keyboard->focus;
2081
2082         if (surface) {
2083                 ws->saved_kbd_focus = surface;
2084                 ws->saved_kbd_focus_listener.notify =
2085                         destroy_device_saved_kbd_focus;
2086                 wl_signal_add(&surface->resource.destroy_signal,
2087                               &ws->saved_kbd_focus_listener);
2088         }
2089
2090         wl_keyboard_set_focus(ws->seat.keyboard, NULL);
2091         /* FIXME: We really need keyboard grab cancel here to
2092          * let the grab shut down properly.  As it is we leak
2093          * the grab data. */
2094         wl_keyboard_end_grab(ws->seat.keyboard);
2095 }
2096
2097 static void
2098 touch_set_focus(struct weston_seat *ws, struct wl_surface *surface)
2099 {
2100         struct wl_seat *seat = &ws->seat;
2101         struct wl_resource *resource;
2102
2103         if (seat->touch->focus == surface)
2104                 return;
2105
2106         if (seat->touch->focus_resource)
2107                 wl_list_remove(&seat->touch->focus_listener.link);
2108         seat->touch->focus = NULL;
2109         seat->touch->focus_resource = NULL;
2110
2111         if (surface) {
2112                 resource =
2113                         find_resource_for_client(&seat->touch->resource_list,
2114                                                  surface->resource.client);
2115                 if (!resource) {
2116                         weston_log("couldn't find resource\n");
2117                         return;
2118                 }
2119
2120                 seat->touch->focus = surface;
2121                 seat->touch->focus_resource = resource;
2122                 wl_signal_add(&resource->destroy_signal,
2123                               &seat->touch->focus_listener);
2124         }
2125 }
2126
2127 /**
2128  * notify_touch - emulates button touches and notifies surfaces accordingly.
2129  *
2130  * It assumes always the correct cycle sequence until it gets here: touch_down
2131  * → touch_update → ... → touch_update → touch_end. The driver is responsible
2132  * for sending along such order.
2133  *
2134  */
2135 WL_EXPORT void
2136 notify_touch(struct wl_seat *seat, uint32_t time, int touch_id,
2137              wl_fixed_t x, wl_fixed_t y, int touch_type)
2138 {
2139         struct weston_seat *ws = (struct weston_seat *) seat;
2140         struct weston_compositor *ec = ws->compositor;
2141         struct weston_surface *es;
2142         wl_fixed_t sx, sy;
2143         uint32_t serial = 0;
2144
2145         switch (touch_type) {
2146         case WL_TOUCH_DOWN:
2147                 weston_compositor_idle_inhibit(ec);
2148
2149                 ws->num_tp++;
2150
2151                 /* the first finger down picks the surface, and all further go
2152                  * to that surface for the remainder of the touch session i.e.
2153                  * until all touch points are up again. */
2154                 if (ws->num_tp == 1) {
2155                         es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
2156                         touch_set_focus(ws, &es->surface);
2157                 } else if (seat->touch->focus) {
2158                         es = (struct weston_surface *)seat->touch->focus;
2159                         weston_surface_from_global_fixed(es, x, y, &sx, &sy);
2160                 }
2161
2162                 if (seat->touch->focus_resource && seat->touch->focus)
2163                         wl_touch_send_down(seat->touch->focus_resource,
2164                                            serial, time,
2165                                            &seat->touch->focus->resource,
2166                                            touch_id, sx, sy);
2167                 break;
2168         case WL_TOUCH_MOTION:
2169                 es = (struct weston_surface *)seat->touch->focus;
2170                 if (!es)
2171                         break;
2172
2173                 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
2174                 if (seat->touch->focus_resource)
2175                         wl_touch_send_motion(seat->touch->focus_resource,
2176                                              time, touch_id, sx, sy);
2177                 break;
2178         case WL_TOUCH_UP:
2179                 weston_compositor_idle_release(ec);
2180                 ws->num_tp--;
2181
2182                 if (seat->touch->focus_resource)
2183                         wl_touch_send_up(seat->touch->focus_resource,
2184                                          serial, time, touch_id);
2185                 if (ws->num_tp == 0)
2186                         touch_set_focus(ws, NULL);
2187                 break;
2188         }
2189 }
2190
2191 static void
2192 pointer_handle_sprite_destroy(struct wl_listener *listener, void *data)
2193 {
2194         struct weston_seat *seat = container_of(listener, struct weston_seat,
2195                                                 sprite_destroy_listener);
2196
2197         seat->sprite = NULL;
2198 }
2199
2200 static void
2201 pointer_cursor_surface_configure(struct weston_surface *es,
2202                                  int32_t dx, int32_t dy)
2203 {
2204         struct weston_seat *seat = es->private;
2205         int x, y;
2206
2207         assert(es == seat->sprite);
2208
2209         seat->hotspot_x -= dx;
2210         seat->hotspot_y -= dy;
2211
2212         x = wl_fixed_to_int(seat->seat.pointer->x) - seat->hotspot_x;
2213         y = wl_fixed_to_int(seat->seat.pointer->y) - seat->hotspot_y;
2214
2215         weston_surface_configure(seat->sprite, x, y,
2216                                  es->buffer->width, es->buffer->height);
2217
2218         empty_region(&es->input);
2219
2220         if (!weston_surface_is_mapped(es)) {
2221                 wl_list_insert(&es->compositor->cursor_layer.surface_list,
2222                                &es->layer_link);
2223                 weston_surface_assign_output(es);
2224         }
2225 }
2226
2227 static void
2228 pointer_unmap_sprite(struct weston_seat *seat)
2229 {
2230         if (weston_surface_is_mapped(seat->sprite))
2231                 weston_surface_unmap(seat->sprite);
2232
2233         wl_list_remove(&seat->sprite_destroy_listener.link);
2234         seat->sprite->configure = NULL;
2235         seat->sprite->private = NULL;
2236         seat->sprite = NULL;
2237 }
2238
2239 static void
2240 pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
2241                    uint32_t serial, struct wl_resource *surface_resource,
2242                    int32_t x, int32_t y)
2243 {
2244         struct weston_seat *seat = resource->data;
2245         struct weston_surface *surface = NULL;
2246
2247         if (surface_resource)
2248                 surface = container_of(surface_resource->data,
2249                                        struct weston_surface, surface);
2250
2251         if (seat->seat.pointer->focus == NULL)
2252                 return;
2253         if (seat->seat.pointer->focus->resource.client != client)
2254                 return;
2255         if (seat->seat.pointer->focus_serial - serial > UINT32_MAX / 2)
2256                 return;
2257
2258         if (surface && surface != seat->sprite) {
2259                 if (surface->configure) {
2260                         wl_resource_post_error(&surface->surface.resource,
2261                                                WL_DISPLAY_ERROR_INVALID_OBJECT,
2262                                                "surface->configure already "
2263                                                "set");
2264                         return;
2265                 }
2266         }
2267
2268         if (seat->sprite)
2269                 pointer_unmap_sprite(seat);
2270
2271         if (!surface)
2272                 return;
2273
2274         wl_signal_add(&surface->surface.resource.destroy_signal,
2275                       &seat->sprite_destroy_listener);
2276
2277         surface->configure = pointer_cursor_surface_configure;
2278         surface->private = seat;
2279         empty_region(&surface->input);
2280
2281         seat->sprite = surface;
2282         seat->hotspot_x = x;
2283         seat->hotspot_y = y;
2284
2285         weston_surface_set_position(surface,
2286                                     wl_fixed_to_int(seat->seat.pointer->x) - x,
2287                                     wl_fixed_to_int(seat->seat.pointer->y) - y);
2288 }
2289
2290 static const struct wl_pointer_interface pointer_interface = {
2291         pointer_set_cursor
2292 };
2293
2294 static void
2295 handle_drag_surface_destroy(struct wl_listener *listener, void *data)
2296 {
2297         struct weston_seat *seat;
2298
2299         seat = container_of(listener, struct weston_seat,
2300                             drag_surface_destroy_listener);
2301
2302         seat->drag_surface = NULL;
2303 }
2304
2305 static void unbind_resource(struct wl_resource *resource)
2306 {
2307         wl_list_remove(&resource->link);
2308         free(resource);
2309 }
2310
2311 static void
2312 seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
2313                  uint32_t id)
2314 {
2315         struct weston_seat *seat = resource->data;
2316         struct wl_resource *cr;
2317
2318         if (!seat->seat.pointer)
2319                 return;
2320
2321         cr = wl_client_add_object(client, &wl_pointer_interface,
2322                                   &pointer_interface, id, seat);
2323         wl_list_insert(&seat->seat.pointer->resource_list, &cr->link);
2324         cr->destroy = unbind_resource;
2325
2326         if (seat->seat.pointer->focus &&
2327             seat->seat.pointer->focus->resource.client == client) {
2328                 struct weston_surface *surface;
2329                 wl_fixed_t sx, sy;
2330
2331                 surface = (struct weston_surface *) seat->seat.pointer->focus;
2332                 weston_surface_from_global_fixed(surface,
2333                                                  seat->seat.pointer->x,
2334                                                  seat->seat.pointer->y,
2335                                                  &sx,
2336                                                  &sy);
2337                 wl_pointer_set_focus(seat->seat.pointer,
2338                                      seat->seat.pointer->focus,
2339                                      sx,
2340                                      sy);
2341         }
2342 }
2343
2344 static void
2345 seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
2346                   uint32_t id)
2347 {
2348         struct weston_seat *seat = resource->data;
2349         struct wl_resource *cr;
2350
2351         if (!seat->seat.keyboard)
2352                 return;
2353
2354         cr = wl_client_add_object(client, &wl_keyboard_interface, NULL, id,
2355                                   seat);
2356         wl_list_insert(&seat->seat.keyboard->resource_list, &cr->link);
2357         cr->destroy = unbind_resource;
2358
2359         wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
2360                                 seat->xkb_info.keymap_fd,
2361                                 seat->xkb_info.keymap_size);
2362
2363         if (seat->seat.keyboard->focus &&
2364             seat->seat.keyboard->focus->resource.client == client) {
2365                 wl_keyboard_set_focus(seat->seat.keyboard,
2366                                       seat->seat.keyboard->focus);
2367         }
2368 }
2369
2370 static void
2371 seat_get_touch(struct wl_client *client, struct wl_resource *resource,
2372                uint32_t id)
2373 {
2374         struct weston_seat *seat = resource->data;
2375         struct wl_resource *cr;
2376
2377         if (!seat->seat.touch)
2378                 return;
2379
2380         cr = wl_client_add_object(client, &wl_touch_interface, NULL, id, seat);
2381         wl_list_insert(&seat->seat.touch->resource_list, &cr->link);
2382         cr->destroy = unbind_resource;
2383 }
2384
2385 static const struct wl_seat_interface seat_interface = {
2386         seat_get_pointer,
2387         seat_get_keyboard,
2388         seat_get_touch,
2389 };
2390
2391 static void
2392 bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
2393 {
2394         struct wl_seat *seat = data;
2395         struct wl_resource *resource;
2396         enum wl_seat_capability caps = 0;
2397
2398         resource = wl_client_add_object(client, &wl_seat_interface,
2399                                         &seat_interface, id, data);
2400         wl_list_insert(&seat->base_resource_list, &resource->link);
2401         resource->destroy = unbind_resource;
2402
2403         if (seat->pointer)
2404                 caps |= WL_SEAT_CAPABILITY_POINTER;
2405         if (seat->keyboard)
2406                 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
2407         if (seat->touch)
2408                 caps |= WL_SEAT_CAPABILITY_TOUCH;
2409
2410         wl_seat_send_capabilities(resource, caps);
2411 }
2412
2413 static void
2414 device_handle_new_drag_icon(struct wl_listener *listener, void *data)
2415 {
2416         struct weston_seat *seat;
2417
2418         seat = container_of(listener, struct weston_seat,
2419                             new_drag_icon_listener);
2420
2421         weston_seat_update_drag_surface(&seat->seat, 0, 0);
2422 }
2423
2424 static void weston_compositor_xkb_init(struct weston_compositor *ec,
2425                                        struct xkb_rule_names *names)
2426 {
2427         if (ec->xkb_context == NULL) {
2428                 ec->xkb_context = xkb_context_new(0);
2429                 if (ec->xkb_context == NULL) {
2430                         weston_log("failed to create XKB context\n");
2431                         exit(1);
2432                 }
2433         }
2434
2435         if (names)
2436                 ec->xkb_names = *names;
2437         if (!ec->xkb_names.rules)
2438                 ec->xkb_names.rules = strdup("evdev");
2439         if (!ec->xkb_names.model)
2440                 ec->xkb_names.model = strdup("pc105");
2441         if (!ec->xkb_names.layout)
2442                 ec->xkb_names.layout = strdup("us");
2443 }
2444
2445 static void xkb_info_destroy(struct weston_xkb_info *xkb_info)
2446 {
2447         if (xkb_info->keymap)
2448                 xkb_map_unref(xkb_info->keymap);
2449
2450         if (xkb_info->keymap_area)
2451                 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
2452         if (xkb_info->keymap_fd >= 0)
2453                 close(xkb_info->keymap_fd);
2454 }
2455
2456 static void weston_compositor_xkb_destroy(struct weston_compositor *ec)
2457 {
2458         free((char *) ec->xkb_names.rules);
2459         free((char *) ec->xkb_names.model);
2460         free((char *) ec->xkb_names.layout);
2461         free((char *) ec->xkb_names.variant);
2462         free((char *) ec->xkb_names.options);
2463
2464         xkb_info_destroy(&ec->xkb_info);
2465         xkb_context_unref(ec->xkb_context);
2466 }
2467
2468 static void
2469 weston_xkb_info_new_keymap(struct weston_xkb_info *xkb_info)
2470 {
2471         char *keymap_str;
2472
2473         xkb_info->shift_mod = xkb_map_mod_get_index(xkb_info->keymap,
2474                                                     XKB_MOD_NAME_SHIFT);
2475         xkb_info->caps_mod = xkb_map_mod_get_index(xkb_info->keymap,
2476                                                    XKB_MOD_NAME_CAPS);
2477         xkb_info->ctrl_mod = xkb_map_mod_get_index(xkb_info->keymap,
2478                                                    XKB_MOD_NAME_CTRL);
2479         xkb_info->alt_mod = xkb_map_mod_get_index(xkb_info->keymap,
2480                                                   XKB_MOD_NAME_ALT);
2481         xkb_info->mod2_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod2");
2482         xkb_info->mod3_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod3");
2483         xkb_info->super_mod = xkb_map_mod_get_index(xkb_info->keymap,
2484                                                     XKB_MOD_NAME_LOGO);
2485         xkb_info->mod5_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod5");
2486
2487         xkb_info->num_led = xkb_map_led_get_index(xkb_info->keymap,
2488                                                   XKB_LED_NAME_NUM);
2489         xkb_info->caps_led = xkb_map_led_get_index(xkb_info->keymap,
2490                                                    XKB_LED_NAME_CAPS);
2491         xkb_info->scroll_led = xkb_map_led_get_index(xkb_info->keymap,
2492                                                      XKB_LED_NAME_SCROLL);
2493
2494         keymap_str = xkb_map_get_as_string(xkb_info->keymap);
2495         if (keymap_str == NULL) {
2496                 weston_log("failed to get string version of keymap\n");
2497                 exit(EXIT_FAILURE);
2498         }
2499         xkb_info->keymap_size = strlen(keymap_str) + 1;
2500
2501         xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
2502         if (xkb_info->keymap_fd < 0) {
2503                 weston_log("creating a keymap file for %lu bytes failed: %m\n",
2504                         (unsigned long) xkb_info->keymap_size);
2505                 goto err_keymap_str;
2506         }
2507
2508         xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
2509                                      PROT_READ | PROT_WRITE,
2510                                      MAP_SHARED, xkb_info->keymap_fd, 0);
2511         if (xkb_info->keymap_area == MAP_FAILED) {
2512                 weston_log("failed to mmap() %lu bytes\n",
2513                         (unsigned long) xkb_info->keymap_size);
2514                 goto err_dev_zero;
2515         }
2516         strcpy(xkb_info->keymap_area, keymap_str);
2517         free(keymap_str);
2518
2519         return;
2520
2521 err_dev_zero:
2522         close(xkb_info->keymap_fd);
2523         xkb_info->keymap_fd = -1;
2524 err_keymap_str:
2525         free(keymap_str);
2526         exit(EXIT_FAILURE);
2527 }
2528
2529 static void
2530 weston_compositor_build_global_keymap(struct weston_compositor *ec)
2531 {
2532         if (ec->xkb_info.keymap != NULL)
2533                 return;
2534
2535         ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_context,
2536                                                      &ec->xkb_names,
2537                                                      0);
2538         if (ec->xkb_info.keymap == NULL) {
2539                 weston_log("failed to compile global XKB keymap\n");
2540                 weston_log("  tried rules %s, model %s, layout %s, variant %s, "
2541                         "options %s",
2542                         ec->xkb_names.rules, ec->xkb_names.model,
2543                         ec->xkb_names.layout, ec->xkb_names.variant,
2544                         ec->xkb_names.options);
2545                 exit(1);
2546         }
2547
2548         weston_xkb_info_new_keymap(&ec->xkb_info);
2549 }
2550
2551 WL_EXPORT void
2552 weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
2553 {
2554         if (seat->has_keyboard)
2555                 return;
2556
2557         if (keymap != NULL) {
2558                 seat->xkb_info.keymap = xkb_map_ref(keymap);
2559                 weston_xkb_info_new_keymap(&seat->xkb_info);
2560         }
2561         else {
2562                 weston_compositor_build_global_keymap(seat->compositor);
2563                 seat->xkb_info = seat->compositor->xkb_info;
2564                 seat->xkb_info.keymap = xkb_map_ref(seat->xkb_info.keymap);
2565         }
2566
2567         seat->xkb_state.state = xkb_state_new(seat->xkb_info.keymap);
2568         if (seat->xkb_state.state == NULL) {
2569                 weston_log("failed to initialise XKB state\n");
2570                 exit(1);
2571         }
2572
2573         seat->xkb_state.leds = 0;
2574
2575         wl_keyboard_init(&seat->keyboard);
2576         wl_seat_set_keyboard(&seat->seat, &seat->keyboard);
2577
2578         seat->has_keyboard = 1;
2579 }
2580
2581 WL_EXPORT void
2582 weston_seat_init_pointer(struct weston_seat *seat)
2583 {
2584         if (seat->has_pointer)
2585                 return;
2586
2587         wl_pointer_init(&seat->pointer);
2588         wl_seat_set_pointer(&seat->seat, &seat->pointer);
2589
2590         seat->has_pointer = 1;
2591 }
2592
2593 WL_EXPORT void
2594 weston_seat_init_touch(struct weston_seat *seat)
2595 {
2596         if (seat->has_touch)
2597                 return;
2598
2599         wl_touch_init(&seat->touch);
2600         wl_seat_set_touch(&seat->seat, &seat->touch);
2601
2602         seat->has_touch = 1;
2603 }
2604
2605 WL_EXPORT void
2606 weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec)
2607 {
2608         wl_seat_init(&seat->seat);
2609         seat->has_pointer = 0;
2610         seat->has_keyboard = 0;
2611         seat->has_touch = 0;
2612
2613         wl_display_add_global(ec->wl_display, &wl_seat_interface, seat,
2614                               bind_seat);
2615
2616         seat->sprite = NULL;
2617         seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
2618
2619         seat->compositor = ec;
2620         seat->hotspot_x = 16;
2621         seat->hotspot_y = 16;
2622         seat->modifier_state = 0;
2623         seat->num_tp = 0;
2624
2625         seat->drag_surface_destroy_listener.notify =
2626                 handle_drag_surface_destroy;
2627
2628         wl_list_insert(ec->seat_list.prev, &seat->link);
2629
2630         seat->new_drag_icon_listener.notify = device_handle_new_drag_icon;
2631         wl_signal_add(&seat->seat.drag_icon_signal,
2632                       &seat->new_drag_icon_listener);
2633
2634         clipboard_create(seat);
2635 }
2636
2637 WL_EXPORT void
2638 weston_seat_release(struct weston_seat *seat)
2639 {
2640         wl_list_remove(&seat->link);
2641         /* The global object is destroyed at wl_display_destroy() time. */
2642
2643         if (seat->sprite)
2644                 pointer_unmap_sprite(seat);
2645
2646         if (seat->xkb_state.state != NULL)
2647                 xkb_state_unref(seat->xkb_state.state);
2648         xkb_info_destroy(&seat->xkb_info);
2649
2650         wl_seat_release(&seat->seat);
2651 }
2652
2653 static void
2654 drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2655 {
2656         weston_surface_configure(es,
2657                                  es->geometry.x + sx, es->geometry.y + sy,
2658                                  es->buffer->width, es->buffer->height);
2659 }
2660
2661 static int
2662 device_setup_new_drag_surface(struct weston_seat *ws,
2663                               struct weston_surface *surface)
2664 {
2665         struct wl_seat *seat = &ws->seat;
2666
2667         if (surface->configure) {
2668                 wl_resource_post_error(&surface->surface.resource,
2669                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
2670                                        "surface->configure already set");
2671                 return 0;
2672         }
2673
2674         ws->drag_surface = surface;
2675
2676         weston_surface_set_position(ws->drag_surface,
2677                                     wl_fixed_to_double(seat->pointer->x),
2678                                     wl_fixed_to_double(seat->pointer->y));
2679
2680         surface->configure = drag_surface_configure;
2681
2682         wl_signal_add(&surface->surface.resource.destroy_signal,
2683                        &ws->drag_surface_destroy_listener);
2684
2685         return 1;
2686 }
2687
2688 static void
2689 device_release_drag_surface(struct weston_seat *seat)
2690 {
2691         seat->drag_surface->configure = NULL;
2692         undef_region(&seat->drag_surface->input);
2693         wl_list_remove(&seat->drag_surface_destroy_listener.link);
2694         seat->drag_surface = NULL;
2695 }
2696
2697 static void
2698 device_map_drag_surface(struct weston_seat *seat)
2699 {
2700         struct wl_list *list;
2701
2702         if (weston_surface_is_mapped(seat->drag_surface) ||
2703             !seat->drag_surface->buffer)
2704                 return;
2705
2706         if (seat->sprite && weston_surface_is_mapped(seat->sprite))
2707                 list = &seat->sprite->layer_link;
2708         else
2709                 list = &seat->compositor->cursor_layer.surface_list;
2710
2711         wl_list_insert(list, &seat->drag_surface->layer_link);
2712         weston_surface_assign_output(seat->drag_surface);
2713         empty_region(&seat->drag_surface->input);
2714 }
2715
2716 static  void
2717 weston_seat_update_drag_surface(struct wl_seat *seat,
2718                                 int dx, int dy)
2719 {
2720         int surface_changed = 0;
2721         struct weston_seat *ws = (struct weston_seat *) seat;
2722
2723         if (!ws->drag_surface && !seat->drag_surface)
2724                 return;
2725
2726         if (ws->drag_surface && seat->drag_surface &&
2727             (&ws->drag_surface->surface.resource !=
2728              &seat->drag_surface->resource))
2729                 /* between calls to this funcion we got a new drag_surface */
2730                 surface_changed = 1;
2731
2732         if (!seat->drag_surface || surface_changed) {
2733                 device_release_drag_surface(ws);
2734                 if (!surface_changed)
2735                         return;
2736         }
2737
2738         if (!ws->drag_surface || surface_changed) {
2739                 struct weston_surface *surface = (struct weston_surface *)
2740                         seat->drag_surface;
2741                 if (!device_setup_new_drag_surface(ws, surface))
2742                         return;
2743         }
2744
2745         /* the client may not have attached a buffer to the drag surface
2746          * when we setup it up, so check if map is needed on every update */
2747         device_map_drag_surface(ws);
2748
2749         /* the client may have attached a buffer with a different size to
2750          * the drag surface, causing the input region to be reset */
2751         if (region_is_undefined(&ws->drag_surface->input))
2752                 empty_region(&ws->drag_surface->input);
2753
2754         if (!dx && !dy)
2755                 return;
2756
2757         weston_surface_set_position(ws->drag_surface,
2758                                     ws->drag_surface->geometry.x + wl_fixed_to_double(dx),
2759                                     ws->drag_surface->geometry.y + wl_fixed_to_double(dy));
2760 }
2761
2762 WL_EXPORT void
2763 weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
2764 {
2765         struct weston_seat *seat;
2766
2767         wl_list_for_each(seat, &compositor->seat_list, link)
2768                 weston_seat_update_drag_surface(&seat->seat, 0, 0);
2769 }
2770
2771 static void
2772 bind_output(struct wl_client *client,
2773             void *data, uint32_t version, uint32_t id)
2774 {
2775         struct weston_output *output = data;
2776         struct weston_mode *mode;
2777         struct wl_resource *resource;
2778
2779         resource = wl_client_add_object(client,
2780                                         &wl_output_interface, NULL, id, data);
2781
2782         wl_list_insert(&output->resource_list, &resource->link);
2783         resource->destroy = unbind_resource;
2784
2785         wl_output_send_geometry(resource,
2786                                 output->x,
2787                                 output->y,
2788                                 output->mm_width,
2789                                 output->mm_height,
2790                                 output->subpixel,
2791                                 output->make, output->model,
2792                                 output->transform);
2793
2794         wl_list_for_each (mode, &output->mode_list, link) {
2795                 wl_output_send_mode(resource,
2796                                     mode->flags,
2797                                     mode->width,
2798                                     mode->height,
2799                                     mode->refresh);
2800         }
2801 }
2802
2803 static const char vertex_shader[] =
2804         "uniform mat4 proj;\n"
2805         "attribute vec2 position;\n"
2806         "attribute vec2 texcoord;\n"
2807         "varying vec2 v_texcoord;\n"
2808         "void main()\n"
2809         "{\n"
2810         "   gl_Position = proj * vec4(position, 0.0, 1.0);\n"
2811         "   v_texcoord = texcoord;\n"
2812         "}\n";
2813
2814 /* Declare common fragment shader uniforms */
2815 #define FRAGMENT_SHADER_UNIFORMS                \
2816         "uniform float alpha;\n"                \
2817         "uniform float texwidth;\n"             \
2818         "uniform vec4 opaque;\n"
2819
2820 /* Common fragment shader init code (check texture bounds) */
2821 #define FRAGMENT_SHADER_INIT                                            \
2822         "   if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"     \
2823         "       v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"            \
2824         "      discard;\n"
2825
2826 #define FRAGMENT_SHADER_EXIT                                            \
2827         "   if (opaque.x <= v_texcoord.x && v_texcoord.x < opaque.y &&\n" \
2828         "       opaque.z <= v_texcoord.y && v_texcoord.y < opaque.w)\n" \
2829         "      gl_FragColor.a = 1.0;\n"                                 \
2830         "   gl_FragColor = alpha * gl_FragColor;\n"
2831
2832 #define FRAGMENT_CONVERT_YUV                                            \
2833         "  gl_FragColor.r = y + 1.59602678 * v;\n"                      \
2834         "  gl_FragColor.g = y - 0.39176229 * u - 0.81296764 * v;\n"     \
2835         "  gl_FragColor.b = y + 2.01723214 * u;\n"                      \
2836         "  gl_FragColor.a = 1.0;\n"
2837
2838 static const char texture_fragment_shader_rgba[] =
2839         "precision mediump float;\n"
2840         "varying vec2 v_texcoord;\n"
2841         "uniform sampler2D tex;\n"
2842         FRAGMENT_SHADER_UNIFORMS
2843         "void main()\n"
2844         "{\n"
2845         FRAGMENT_SHADER_INIT
2846         "   gl_FragColor = texture2D(tex, v_texcoord)\n;"
2847         FRAGMENT_SHADER_EXIT
2848         "}\n";
2849
2850 static const char texture_fragment_shader_y_uv[] =
2851         "precision mediump float;\n"
2852         "uniform sampler2D tex;\n"
2853         "uniform sampler2D tex1;\n"
2854         "varying vec2 v_texcoord;\n"
2855         FRAGMENT_SHADER_UNIFORMS
2856         "void main() {\n"
2857         FRAGMENT_SHADER_INIT
2858         "  float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
2859         "  float u = texture2D(tex1, v_texcoord).r - 0.5;\n"
2860         "  float v = texture2D(tex1, v_texcoord).g - 0.5;\n"
2861         FRAGMENT_CONVERT_YUV
2862         FRAGMENT_SHADER_EXIT
2863         "}\n";
2864
2865 static const char texture_fragment_shader_y_u_v[] =
2866         "precision mediump float;\n"
2867         "uniform sampler2D tex;\n"
2868         "uniform sampler2D tex1;\n"
2869         "uniform sampler2D tex2;\n"
2870         "varying vec2 v_texcoord;\n"
2871         FRAGMENT_SHADER_UNIFORMS
2872         "void main() {\n"
2873         FRAGMENT_SHADER_INIT
2874         "  float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
2875         "  float u = texture2D(tex1, v_texcoord).x - 0.5;\n"
2876         "  float v = texture2D(tex2, v_texcoord).x - 0.5;\n"
2877         FRAGMENT_CONVERT_YUV
2878         FRAGMENT_SHADER_EXIT
2879         "}\n";
2880
2881 static const char texture_fragment_shader_y_xuxv[] =
2882         "precision mediump float;\n"
2883         "uniform sampler2D tex;\n"
2884         "uniform sampler2D tex1;\n"
2885         "varying vec2 v_texcoord;\n"
2886         FRAGMENT_SHADER_UNIFORMS
2887         "void main() {\n"
2888         FRAGMENT_SHADER_INIT
2889         "  float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
2890         "  float u = texture2D(tex1, v_texcoord).g - 0.5;\n"
2891         "  float v = texture2D(tex1, v_texcoord).a - 0.5;\n"
2892         FRAGMENT_CONVERT_YUV
2893         FRAGMENT_SHADER_EXIT
2894         "}\n";
2895
2896 static const char solid_fragment_shader[] =
2897         "precision mediump float;\n"
2898         "uniform vec4 color;\n"
2899         "uniform float alpha;\n"
2900         "void main()\n"
2901         "{\n"
2902         "   gl_FragColor = alpha * color\n;"
2903         "}\n";
2904
2905 static int
2906 compile_shader(GLenum type, const char *source)
2907 {
2908         GLuint s;
2909         char msg[512];
2910         GLint status;
2911
2912         s = glCreateShader(type);
2913         glShaderSource(s, 1, &source, NULL);
2914         glCompileShader(s);
2915         glGetShaderiv(s, GL_COMPILE_STATUS, &status);
2916         if (!status) {
2917                 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
2918                 weston_log("shader info: %s\n", msg);
2919                 return GL_NONE;
2920         }
2921
2922         return s;
2923 }
2924
2925 static int
2926 weston_shader_init(struct weston_shader *shader,
2927                    const char *vertex_source, const char *fragment_source)
2928 {
2929         char msg[512];
2930         GLint status;
2931
2932         shader->vertex_shader =
2933                 compile_shader(GL_VERTEX_SHADER, vertex_source);
2934         shader->fragment_shader =
2935                 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2936
2937         shader->program = glCreateProgram();
2938         glAttachShader(shader->program, shader->vertex_shader);
2939         glAttachShader(shader->program, shader->fragment_shader);
2940         glBindAttribLocation(shader->program, 0, "position");
2941         glBindAttribLocation(shader->program, 1, "texcoord");
2942
2943         glLinkProgram(shader->program);
2944         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
2945         if (!status) {
2946                 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
2947                 weston_log("link info: %s\n", msg);
2948                 return -1;
2949         }
2950
2951         shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
2952         shader->tex_uniforms[0] = glGetUniformLocation(shader->program, "tex");
2953         shader->tex_uniforms[1] = glGetUniformLocation(shader->program, "tex1");
2954         shader->tex_uniforms[2] = glGetUniformLocation(shader->program, "tex2");
2955         shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
2956         shader->color_uniform = glGetUniformLocation(shader->program, "color");
2957         shader->texwidth_uniform = glGetUniformLocation(shader->program, "texwidth");
2958         shader->opaque_uniform = glGetUniformLocation(shader->program, "opaque");
2959
2960         return 0;
2961 }
2962
2963 WL_EXPORT void
2964 weston_output_destroy(struct weston_output *output)
2965 {
2966         struct weston_compositor *c = output->compositor;
2967
2968         pixman_region32_fini(&output->region);
2969         pixman_region32_fini(&output->previous_damage);
2970         output->compositor->output_id_pool &= ~(1 << output->id);
2971
2972         wl_display_remove_global(c->wl_display, output->global);
2973 }
2974
2975 WL_EXPORT void
2976 weston_output_update_matrix(struct weston_output *output)
2977 {
2978         float magnification;
2979         struct weston_matrix camera;
2980         struct weston_matrix modelview;
2981
2982         weston_matrix_init(&output->matrix);
2983         weston_matrix_translate(&output->matrix,
2984                                 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2985                                 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
2986
2987         weston_matrix_scale(&output->matrix,
2988                             2.0 / (output->current->width + output->border.left + output->border.right),
2989                             -2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
2990
2991         if (output->zoom.active) {
2992                 magnification = 1 / (1 - output->zoom.spring_z.current);
2993                 weston_matrix_init(&camera);
2994                 weston_matrix_init(&modelview);
2995                 weston_output_update_zoom(output, output->zoom.type);
2996                 weston_matrix_translate(&camera, output->zoom.trans_x,
2997                                         -output->zoom.trans_y, 0);
2998                 weston_matrix_invert(&modelview, &camera);
2999                 weston_matrix_scale(&modelview, magnification, magnification, 1.0);
3000                 weston_matrix_multiply(&output->matrix, &modelview);
3001         }
3002
3003         output->dirty = 0;
3004 }
3005
3006 WL_EXPORT void
3007 weston_output_move(struct weston_output *output, int x, int y)
3008 {
3009         output->x = x;
3010         output->y = y;
3011
3012         pixman_region32_init(&output->previous_damage);
3013         pixman_region32_init_rect(&output->region, x, y,
3014                                   output->current->width,
3015                                   output->current->height);
3016 }
3017
3018 WL_EXPORT void
3019 weston_output_init(struct weston_output *output, struct weston_compositor *c,
3020                    int x, int y, int width, int height)
3021 {
3022         output->compositor = c;
3023         output->x = x;
3024         output->y = y;
3025         output->border.top = 0;
3026         output->border.bottom = 0;
3027         output->border.left = 0;
3028         output->border.right = 0;
3029         output->mm_width = width;
3030         output->mm_height = height;
3031         output->dirty = 1;
3032         output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
3033
3034         weston_output_init_zoom(output);
3035
3036         weston_output_move(output, x, y);
3037         weston_output_damage(output);
3038
3039         wl_signal_init(&output->frame_signal);
3040         wl_list_init(&output->animation_list);
3041         wl_list_init(&output->resource_list);
3042
3043         output->id = ffs(~output->compositor->output_id_pool) - 1;
3044         output->compositor->output_id_pool |= 1 << output->id;
3045
3046         output->global =
3047                 wl_display_add_global(c->wl_display, &wl_output_interface,
3048                                       output, bind_output);
3049 }
3050
3051 static void
3052 compositor_bind(struct wl_client *client,
3053                 void *data, uint32_t version, uint32_t id)
3054 {
3055         struct weston_compositor *compositor = data;
3056
3057         wl_client_add_object(client, &wl_compositor_interface,
3058                              &compositor_interface, id, compositor);
3059 }
3060
3061 static void
3062 log_uname(void)
3063 {
3064         struct utsname usys;
3065
3066         uname(&usys);
3067
3068         weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
3069                                                 usys.version, usys.machine);
3070 }
3071
3072 static void
3073 log_extensions(const char *name, const char *extensions)
3074 {
3075         const char *p, *end;
3076         int l;
3077         int len;
3078
3079         l = weston_log("%s:", name);
3080         p = extensions;
3081         while (*p) {
3082                 end = strchrnul(p, ' ');
3083                 len = end - p;
3084                 if (l + len > 78)
3085                         l = weston_log_continue("\n" STAMP_SPACE "%.*s",
3086                                                 len, p);
3087                 else
3088                         l += weston_log_continue(" %.*s", len, p);
3089                 for (p = end; isspace(*p); p++)
3090                         ;
3091         }
3092         weston_log_continue("\n");
3093 }
3094
3095 static void
3096 log_egl_gl_info(EGLDisplay egldpy)
3097 {
3098         const char *str;
3099
3100         str = eglQueryString(egldpy, EGL_VERSION);
3101         weston_log("EGL version: %s\n", str ? str : "(null)");
3102
3103         str = eglQueryString(egldpy, EGL_VENDOR);
3104         weston_log("EGL vendor: %s\n", str ? str : "(null)");
3105
3106         str = eglQueryString(egldpy, EGL_CLIENT_APIS);
3107         weston_log("EGL client APIs: %s\n", str ? str : "(null)");
3108
3109         str = eglQueryString(egldpy, EGL_EXTENSIONS);
3110         log_extensions("EGL extensions", str ? str : "(null)");
3111
3112         str = (char *)glGetString(GL_VERSION);
3113         weston_log("GL version: %s\n", str ? str : "(null)");
3114
3115         str = (char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
3116         weston_log("GLSL version: %s\n", str ? str : "(null)");
3117
3118         str = (char *)glGetString(GL_VENDOR);
3119         weston_log("GL vendor: %s\n", str ? str : "(null)");
3120
3121         str = (char *)glGetString(GL_RENDERER);
3122         weston_log("GL renderer: %s\n", str ? str : "(null)");
3123
3124         str = (char *)glGetString(GL_EXTENSIONS);
3125         log_extensions("GL extensions", str ? str : "(null)");
3126 }
3127
3128 WL_EXPORT int
3129 weston_compositor_init(struct weston_compositor *ec,
3130                        struct wl_display *display,
3131                        int argc,
3132                        char *argv[],
3133                        const char *config_file)
3134 {
3135         struct wl_event_loop *loop;
3136         struct xkb_rule_names xkb_names;
3137         const struct config_key keyboard_config_keys[] = {
3138                 { "keymap_rules", CONFIG_KEY_STRING, &xkb_names.rules },
3139                 { "keymap_model", CONFIG_KEY_STRING, &xkb_names.model },
3140                 { "keymap_layout", CONFIG_KEY_STRING, &xkb_names.layout },
3141                 { "keymap_variant", CONFIG_KEY_STRING, &xkb_names.variant },
3142                 { "keymap_options", CONFIG_KEY_STRING, &xkb_names.options },
3143         };
3144         const struct config_section cs[] = {
3145                 { "keyboard",
3146                   keyboard_config_keys, ARRAY_LENGTH(keyboard_config_keys) },
3147         };
3148
3149         memset(&xkb_names, 0, sizeof(xkb_names));
3150         parse_config_file(config_file, cs, ARRAY_LENGTH(cs), ec);
3151
3152         ec->wl_display = display;
3153         wl_signal_init(&ec->destroy_signal);
3154         wl_signal_init(&ec->activate_signal);
3155         wl_signal_init(&ec->lock_signal);
3156         wl_signal_init(&ec->unlock_signal);
3157         wl_signal_init(&ec->show_input_panel_signal);
3158         wl_signal_init(&ec->hide_input_panel_signal);
3159         ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
3160
3161         ec->output_id_pool = 0;
3162
3163         if (!wl_display_add_global(display, &wl_compositor_interface,
3164                                    ec, compositor_bind))
3165                 return -1;
3166
3167         wl_list_init(&ec->surface_list);
3168         wl_list_init(&ec->layer_list);
3169         wl_list_init(&ec->seat_list);
3170         wl_list_init(&ec->output_list);
3171         wl_list_init(&ec->key_binding_list);
3172         wl_list_init(&ec->button_binding_list);
3173         wl_list_init(&ec->axis_binding_list);
3174         wl_list_init(&ec->fade.animation.link);
3175
3176         weston_plane_init(&ec->primary_plane, 0, 0);
3177
3178         weston_compositor_xkb_init(ec, &xkb_names);
3179
3180         ec->ping_handler = NULL;
3181
3182         screenshooter_create(ec);
3183         text_cursor_position_notifier_create(ec);
3184         input_method_create(ec);
3185
3186         wl_data_device_manager_init(ec->wl_display);
3187
3188         wl_display_init_shm(display);
3189
3190         loop = wl_display_get_event_loop(ec->wl_display);
3191         ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
3192         wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
3193
3194         ec->input_loop = wl_event_loop_create();
3195
3196         return 0;
3197 }
3198
3199 WL_EXPORT int
3200 weston_compositor_init_gl(struct weston_compositor *ec)
3201 {
3202         const char *extensions;
3203
3204         log_egl_gl_info(ec->egl_display);
3205
3206         ec->image_target_texture_2d =
3207                 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
3208         ec->image_target_renderbuffer_storage = (void *)
3209                 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
3210         ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
3211         ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
3212         ec->bind_display =
3213                 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
3214         ec->unbind_display =
3215                 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
3216         ec->query_buffer =
3217                 (void *) eglGetProcAddress("eglQueryWaylandBufferWL");
3218
3219         extensions = (const char *) glGetString(GL_EXTENSIONS);
3220         if (!extensions) {
3221                 weston_log("Retrieving GL extension string failed.\n");
3222                 return -1;
3223         }
3224
3225         if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
3226                 weston_log("GL_EXT_texture_format_BGRA8888 not available\n");
3227                 return -1;
3228         }
3229
3230         if (strstr(extensions, "GL_EXT_read_format_bgra"))
3231                 ec->read_format = GL_BGRA_EXT;
3232         else
3233                 ec->read_format = GL_RGBA;
3234
3235         if (strstr(extensions, "GL_EXT_unpack_subimage"))
3236                 ec->has_unpack_subimage = 1;
3237
3238         extensions =
3239                 (const char *) eglQueryString(ec->egl_display, EGL_EXTENSIONS);
3240         if (!extensions) {
3241                 weston_log("Retrieving EGL extension string failed.\n");
3242                 return -1;
3243         }
3244
3245         if (strstr(extensions, "EGL_WL_bind_wayland_display"))
3246                 ec->has_bind_display = 1;
3247         if (ec->has_bind_display)
3248                 ec->bind_display(ec->egl_display, ec->wl_display);
3249
3250         weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
3251         ec->fade.animation.frame = fade_frame;
3252
3253         weston_layer_init(&ec->fade_layer, &ec->layer_list);
3254         weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
3255
3256         glActiveTexture(GL_TEXTURE0);
3257
3258         if (weston_shader_init(&ec->texture_shader_rgba,
3259                              vertex_shader, texture_fragment_shader_rgba) < 0)
3260                 return -1;
3261         if (weston_shader_init(&ec->texture_shader_y_uv,
3262                                vertex_shader, texture_fragment_shader_y_uv) < 0)
3263                 return -1;
3264         if (weston_shader_init(&ec->texture_shader_y_u_v,
3265                                vertex_shader, texture_fragment_shader_y_u_v) < 0)
3266                 return -1;
3267         if (weston_shader_init(&ec->texture_shader_y_xuxv,
3268                                vertex_shader, texture_fragment_shader_y_xuxv) < 0)
3269                 return -1;
3270         if (weston_shader_init(&ec->solid_shader,
3271                              vertex_shader, solid_fragment_shader) < 0)
3272                 return -1;
3273
3274         weston_compositor_schedule_repaint(ec);
3275
3276         return 0;
3277 }
3278
3279 WL_EXPORT void
3280 weston_compositor_shutdown(struct weston_compositor *ec)
3281 {
3282         struct weston_output *output, *next;
3283
3284         wl_event_source_remove(ec->idle_source);
3285         if (ec->input_loop_source)
3286                 wl_event_source_remove(ec->input_loop_source);
3287
3288         /* Destroy all outputs associated with this compositor */
3289         wl_list_for_each_safe(output, next, &ec->output_list, link)
3290                 output->destroy(output);
3291
3292         weston_binding_list_destroy_all(&ec->key_binding_list);
3293         weston_binding_list_destroy_all(&ec->button_binding_list);
3294         weston_binding_list_destroy_all(&ec->axis_binding_list);
3295
3296         weston_plane_release(&ec->primary_plane);
3297
3298         wl_array_release(&ec->vertices);
3299         wl_array_release(&ec->indices);
3300
3301         wl_event_loop_destroy(ec->input_loop);
3302 }
3303
3304 static int on_term_signal(int signal_number, void *data)
3305 {
3306         struct wl_display *display = data;
3307
3308         weston_log("caught signal %d\n", signal_number);
3309         wl_display_terminate(display);
3310
3311         return 1;
3312 }
3313
3314 static void
3315 on_segv_signal(int s, siginfo_t *siginfo, void *context)
3316 {
3317         void *buffer[32];
3318         int i, count;
3319         Dl_info info;
3320
3321         /* This SIGSEGV handler will do a best-effort backtrace, and
3322          * then call the backend restore function, which will switch
3323          * back to the vt we launched from or ungrab X etc and then
3324          * raise SIGTRAP.  If we run weston under gdb from X or a
3325          * different vt, and tell gdb "handle SIGSEGV nostop", this
3326          * will allow weston to switch back to gdb on crash and then
3327          * gdb will catch the crash with SIGTRAP. */
3328
3329         weston_log("caught segv\n");
3330
3331         count = backtrace(buffer, ARRAY_LENGTH(buffer));
3332         for (i = 0; i < count; i++) {
3333                 dladdr(buffer[i], &info);
3334                 weston_log("  [%016lx]  %s  (%s)\n",
3335                         (long) buffer[i],
3336                         info.dli_sname ? info.dli_sname : "--",
3337                         info.dli_fname);
3338         }
3339
3340         segv_compositor->restore(segv_compositor);
3341
3342         raise(SIGTRAP);
3343 }
3344
3345
3346 static void *
3347 load_module(const char *name, const char *entrypoint, void **handle)
3348 {
3349         char path[PATH_MAX];
3350         void *module, *init;
3351
3352         if (name[0] != '/')
3353                 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
3354         else
3355                 snprintf(path, sizeof path, "%s", name);
3356
3357         weston_log("Loading module '%s'\n", path);
3358         module = dlopen(path, RTLD_NOW);
3359         if (!module) {
3360                 weston_log("Failed to load module: %s\n", dlerror());
3361                 return NULL;
3362         }
3363
3364         init = dlsym(module, entrypoint);
3365         if (!init) {
3366                 weston_log("Failed to lookup init function: %s\n", dlerror());
3367                 return NULL;
3368         }
3369
3370         return init;
3371 }
3372
3373 static const char xdg_error_message[] =
3374         "fatal: environment variable XDG_RUNTIME_DIR is not set.\n";
3375
3376 static const char xdg_wrong_message[] =
3377         "fatal: environment variable XDG_RUNTIME_DIR\n"
3378         "is set to \"%s\", which is not a directory.\n";
3379
3380 static const char xdg_wrong_mode_message[] =
3381         "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n"
3382         "correctly.  Unix access mode must be 0700 but is %o,\n"
3383         "and XDG_RUNTIME_DIR must be owned by the user, but is\n"
3384         "owned by UID %d.\n";
3385
3386 static const char xdg_detail_message[] =
3387         "Refer to your distribution on how to get it, or\n"
3388         "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
3389         "on how to implement it.\n";
3390
3391 static void
3392 verify_xdg_runtime_dir(void)
3393 {
3394         char *dir = getenv("XDG_RUNTIME_DIR");
3395         struct stat s;
3396
3397         if (!dir) {
3398                 weston_log(xdg_error_message);
3399                 weston_log_continue(xdg_detail_message);
3400                 exit(EXIT_FAILURE);
3401         }
3402
3403         if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
3404                 weston_log(xdg_wrong_message, dir);
3405                 weston_log_continue(xdg_detail_message);
3406                 exit(EXIT_FAILURE);
3407         }
3408
3409         if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) {
3410                 weston_log(xdg_wrong_mode_message,
3411                            dir, s.st_mode & 0777, s.st_uid);
3412                 weston_log_continue(xdg_detail_message);
3413         }
3414 }
3415
3416 static int
3417 usage(int error_code)
3418 {
3419         fprintf(stderr,
3420                 "Usage: weston [OPTIONS]\n\n"
3421                 "This is weston version " VERSION ", the Wayland reference compositor.\n"
3422                 "Weston supports multiple backends, and depending on which backend is in use\n"
3423                 "different options will be accepted.\n\n"
3424
3425
3426                 "Core options:\n\n"
3427                 "  -B, --backend=MODULE\tBackend module, one of drm-backend.so,\n"
3428                 "\t\t\t\tx11-backend.so or wayland-backend.so\n"
3429                 "  -S, --socket=NAME\tName of socket to listen on\n"
3430                 "  -i, --idle-time=SECS\tIdle time in seconds\n"
3431                 "  --xserver\t\tEnable X server integration\n"
3432                 "  --module\t\tLoad the specified module\n"
3433                 "  --log==FILE\t\tLog to the given file\n"
3434                 "  -h, --help\t\tThis help message\n\n");
3435
3436         fprintf(stderr,
3437                 "Options for drm-backend.so:\n\n"
3438                 "  --connector=ID\tBring up only this connector\n"
3439                 "  --seat=SEAT\t\tThe seat that weston should run on\n"
3440                 "  --tty=TTY\t\tThe tty to use\n"
3441                 "  --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n");
3442
3443         fprintf(stderr,
3444                 "Options for x11-backend.so:\n\n"
3445                 "  --width=WIDTH\t\tWidth of X window\n"
3446                 "  --height=HEIGHT\tHeight of X window\n"
3447                 "  --fullscreen\t\tRun in fullscreen mode\n"
3448                 "  --output-count=COUNT\tCreate multiple outputs\n"
3449                 "  --no-input\t\tDont create input devices\n\n");
3450
3451         fprintf(stderr,
3452                 "Options for wayland-backend.so:\n\n"
3453                 "  --width=WIDTH\t\tWidth of Wayland surface\n"
3454                 "  --height=HEIGHT\tHeight of Wayland surface\n"
3455                 "  --display=DISPLAY\tWayland display to connect to\n\n");
3456
3457         exit(error_code);
3458 }
3459
3460 int main(int argc, char *argv[])
3461 {
3462         int ret = EXIT_SUCCESS;
3463         struct wl_display *display;
3464         struct weston_compositor *ec;
3465         struct wl_event_source *signals[4];
3466         struct wl_event_loop *loop;
3467         struct sigaction segv_action;
3468         void *shell_module, *backend_module, *xserver_module;
3469         int (*module_init)(struct weston_compositor *ec);
3470         struct weston_compositor
3471                 *(*backend_init)(struct wl_display *display,
3472                                  int argc, char *argv[], const char *config_file);
3473         int i;
3474         char *backend = NULL;
3475         char *shell = NULL;
3476         char *module = NULL;
3477         char *log = NULL;
3478         int32_t idle_time = 300;
3479         int32_t xserver = 0;
3480         int32_t help = 0;
3481         char *socket_name = NULL;
3482         char *config_file;
3483
3484         const struct config_key shell_config_keys[] = {
3485                 { "type", CONFIG_KEY_STRING, &shell },
3486         };
3487
3488         const struct config_section cs[] = {
3489                 { "shell",
3490                   shell_config_keys, ARRAY_LENGTH(shell_config_keys) },
3491         };
3492
3493         const struct weston_option core_options[] = {
3494                 { WESTON_OPTION_STRING, "backend", 'B', &backend },
3495                 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
3496                 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
3497                 { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
3498                 { WESTON_OPTION_STRING, "module", 0, &module },
3499                 { WESTON_OPTION_STRING, "log", 0, &log },
3500                 { WESTON_OPTION_BOOLEAN, "help", 'h', &help },
3501         };
3502
3503         argc = parse_options(core_options,
3504                              ARRAY_LENGTH(core_options), argc, argv);
3505
3506         if (help)
3507                 usage(EXIT_SUCCESS);
3508
3509         weston_log_file_open(log);
3510
3511         weston_log("%s\n"
3512                    STAMP_SPACE "%s\n"
3513                    STAMP_SPACE "Bug reports to: %s\n"
3514                    STAMP_SPACE "Build: %s\n",
3515                    PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
3516                    BUILD_ID);
3517         log_uname();
3518
3519         verify_xdg_runtime_dir();
3520
3521         display = wl_display_create();
3522
3523         loop = wl_display_get_event_loop(display);
3524         signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
3525                                               display);
3526         signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
3527                                               display);
3528         signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
3529                                               display);
3530
3531         wl_list_init(&child_process_list);
3532         signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
3533                                               NULL);
3534
3535         if (!backend) {
3536                 if (getenv("WAYLAND_DISPLAY"))
3537                         backend = "wayland-backend.so";
3538                 else if (getenv("DISPLAY"))
3539                         backend = "x11-backend.so";
3540                 else
3541                         backend = "drm-backend.so";
3542         }
3543
3544         config_file = config_file_path("weston.ini");
3545         parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
3546         if (socket_name)
3547                 setenv("WAYLAND_DISPLAY", socket_name, 1);
3548
3549         backend_init = load_module(backend, "backend_init", &backend_module);
3550         if (!backend_init)
3551                 exit(EXIT_FAILURE);
3552
3553         ec = backend_init(display, argc, argv, config_file);
3554         if (ec == NULL) {
3555                 weston_log("fatal: failed to create compositor\n");
3556                 exit(EXIT_FAILURE);
3557         }
3558
3559         segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
3560         segv_action.sa_sigaction = on_segv_signal;
3561         sigemptyset(&segv_action.sa_mask);
3562         sigaction(SIGSEGV, &segv_action, NULL);
3563         segv_compositor = ec;
3564
3565         for (i = 1; argv[i]; i++)
3566                 weston_log("fatal: unhandled option: %s\n", argv[i]);
3567         if (argv[1]) {
3568                 ret = EXIT_FAILURE;
3569                 goto out;
3570         }
3571
3572         free(config_file);
3573
3574         ec->option_idle_time = idle_time;
3575         ec->idle_time = idle_time;
3576
3577         module_init = NULL;
3578         if (xserver)
3579                 module_init = load_module("xwayland.so",
3580                                           "weston_xserver_init",
3581                                           &xserver_module);
3582         if (module_init && module_init(ec) < 0) {
3583                 ret = EXIT_FAILURE;
3584                 goto out;
3585         }
3586
3587         if (!shell)
3588                 shell = "desktop-shell.so";
3589         module_init = load_module(shell, "shell_init", &shell_module);
3590         if (!module_init || module_init(ec) < 0) {
3591                 ret = EXIT_FAILURE;
3592                 goto out;
3593         }
3594
3595
3596         module_init = NULL;
3597         if (module)
3598                 module_init = load_module(module, "module_init", NULL);
3599         if (module_init && module_init(ec) < 0) {
3600                 ret = EXIT_FAILURE;
3601                 goto out;
3602         }
3603
3604         if (wl_display_add_socket(display, socket_name)) {
3605                 weston_log("fatal: failed to add socket: %m\n");
3606                 ret = EXIT_FAILURE;
3607                 goto out;
3608         }
3609
3610         weston_compositor_dpms_on(ec);
3611         weston_compositor_wake(ec);
3612
3613         wl_display_run(display);
3614
3615  out:
3616         /* prevent further rendering while shutting down */
3617         ec->state = WESTON_COMPOSITOR_SLEEPING;
3618
3619         wl_signal_emit(&ec->destroy_signal, ec);
3620
3621         if (ec->has_bind_display)
3622                 ec->unbind_display(ec->egl_display, display);
3623
3624         for (i = ARRAY_LENGTH(signals); i;)
3625                 wl_event_source_remove(signals[--i]);
3626
3627         weston_compositor_xkb_destroy(ec);
3628
3629         ec->destroy(ec);
3630         wl_display_destroy(display);
3631
3632         weston_log_file_close();
3633
3634         return ret;
3635 }