src/compositor.c

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