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         struct weston_surface *focus = (struct weston_surface *) device->pointer_focus;
1561         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1562
1563         if (state) {
1564                 if (compositor->ping_handler && focus)
1565                         compositor->ping_handler(focus, serial);
1566                 weston_compositor_idle_inhibit(compositor);
1567                 if (device->button_count == 0) {
1568                         device->grab_button = button;
1569                         device->grab_time = time;
1570                         device->grab_x = device->x;
1571                         device->grab_y = device->y;
1572                 }
1573                 device->button_count++;
1574         } else {
1575                 weston_compositor_idle_release(compositor);
1576                 device->button_count--;
1577         }
1578
1579         weston_compositor_run_binding(compositor, wd, time, 0, button, 0, state);
1580
1581         device->pointer_grab->interface->button(device->pointer_grab, time, button, state);
1582
1583         if (device->button_count == 1)
1584                 device->grab_serial =
1585                         wl_display_get_serial(compositor->wl_display);
1586 }
1587
1588 WL_EXPORT void
1589 notify_axis(struct wl_input_device *device,
1590               uint32_t time, uint32_t axis, int32_t value)
1591 {
1592         struct weston_input_device *wd = (struct weston_input_device *) device;
1593         struct weston_compositor *compositor = wd->compositor;
1594         struct weston_surface *focus = (struct weston_surface *) device->pointer_focus;
1595         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1596
1597         if (compositor->ping_handler && focus)
1598                 compositor->ping_handler(focus, serial);
1599
1600         weston_compositor_activity(compositor);
1601
1602         if (value)
1603                 weston_compositor_run_binding(compositor, wd,
1604                                                 time, 0, 0, axis, value);
1605         else
1606                 return;
1607
1608         if (device->pointer_focus_resource)
1609                 wl_resource_post_event(device->pointer_focus_resource,
1610                                 WL_INPUT_DEVICE_AXIS, time, axis, value);
1611 }
1612
1613 static void
1614 update_modifier_state(struct weston_input_device *device,
1615                       uint32_t key, uint32_t state)
1616 {
1617         uint32_t modifier;
1618
1619         switch (key) {
1620         case KEY_LEFTCTRL:
1621         case KEY_RIGHTCTRL:
1622                 modifier = MODIFIER_CTRL;
1623                 break;
1624
1625         case KEY_LEFTALT:
1626         case KEY_RIGHTALT:
1627                 modifier = MODIFIER_ALT;
1628                 break;
1629
1630         case KEY_LEFTMETA:
1631         case KEY_RIGHTMETA:
1632                 modifier = MODIFIER_SUPER;
1633                 break;
1634
1635         default:
1636                 modifier = 0;
1637                 break;
1638         }
1639
1640         if (state)
1641                 device->modifier_state |= modifier;
1642         else
1643                 device->modifier_state &= ~modifier;
1644 }
1645
1646 WL_EXPORT void
1647 notify_key(struct wl_input_device *device,
1648            uint32_t time, uint32_t key, uint32_t state)
1649 {
1650         struct weston_input_device *wd = (struct weston_input_device *) device;
1651         struct weston_compositor *compositor = wd->compositor;
1652         struct weston_surface *focus = (struct weston_surface *) device->pointer_focus;
1653         uint32_t serial = wl_display_next_serial(compositor->wl_display);
1654         uint32_t *k, *end;
1655
1656         if (state) {
1657                 if (compositor->ping_handler && focus)
1658                         compositor->ping_handler(focus, serial);
1659
1660                 weston_compositor_idle_inhibit(compositor);
1661                 device->grab_key = key;
1662                 device->grab_time = time;
1663         } else {
1664                 weston_compositor_idle_release(compositor);
1665         }
1666
1667         update_modifier_state(wd, key, state);
1668         end = device->keys.data + device->keys.size;
1669         for (k = device->keys.data; k < end; k++) {
1670                 if (*k == key)
1671                         *k = *--end;
1672         }
1673         device->keys.size = (void *) end - device->keys.data;
1674         if (state) {
1675                 k = wl_array_add(&device->keys, sizeof *k);
1676                 *k = key;
1677         }
1678
1679         if (device->keyboard_grab == &device->default_keyboard_grab)
1680                 weston_compositor_run_binding(compositor, wd,
1681                                               time, key, 0, 0, state);
1682
1683         device->keyboard_grab->interface->key(device->keyboard_grab,
1684                                               time, key, state);
1685 }
1686
1687 WL_EXPORT void
1688 notify_pointer_focus(struct wl_input_device *device,
1689                      struct weston_output *output, int32_t x, int32_t y)
1690 {
1691         struct weston_input_device *wd = (struct weston_input_device *) device;
1692         struct weston_compositor *compositor = wd->compositor;
1693
1694         if (output) {
1695                 weston_input_update_drag_surface(device, x - device->x,
1696                                                  y - device->y);
1697
1698                 device->x = x;
1699                 device->y = y;
1700                 compositor->focus = 1;
1701                 weston_compositor_repick(compositor);
1702         } else {
1703                 compositor->focus = 0;
1704                 weston_compositor_repick(compositor);
1705         }
1706 }
1707
1708 static void
1709 destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
1710 {
1711         struct weston_input_device *wd;
1712
1713         wd = container_of(listener, struct weston_input_device,
1714                           saved_kbd_focus_listener);
1715
1716         wd->saved_kbd_focus = NULL;
1717 }
1718
1719 WL_EXPORT void
1720 notify_keyboard_focus(struct wl_input_device *device, struct wl_array *keys)
1721 {
1722         struct weston_input_device *wd =
1723                 (struct weston_input_device *) device;
1724         struct weston_compositor *compositor = wd->compositor;
1725         struct wl_surface *surface;
1726         uint32_t *k;
1727
1728         if (keys) {
1729                 wl_array_copy(&wd->input_device.keys, keys);
1730                 wd->modifier_state = 0;
1731                 wl_array_for_each(k, &device->keys) {
1732                         weston_compositor_idle_inhibit(compositor);
1733                         update_modifier_state(wd, *k, 1);
1734                 }
1735
1736                 surface = wd->saved_kbd_focus;
1737
1738                 if (surface) {
1739                         wl_list_remove(&wd->saved_kbd_focus_listener.link);
1740                         wl_input_device_set_keyboard_focus(&wd->input_device,
1741                                                            surface);
1742                         wd->saved_kbd_focus = NULL;
1743                 }
1744         } else {
1745                 wl_array_for_each(k, &device->keys)
1746                         weston_compositor_idle_release(compositor);
1747
1748                 wd->modifier_state = 0;
1749
1750                 surface = wd->input_device.keyboard_focus;
1751
1752                 if (surface) {
1753                         wd->saved_kbd_focus = surface;
1754                         wd->saved_kbd_focus_listener.notify =
1755                                 destroy_device_saved_kbd_focus;
1756                         wl_signal_add(&surface->resource.destroy_signal,
1757                                       &wd->saved_kbd_focus_listener);
1758                 }
1759
1760                 wl_input_device_set_keyboard_focus(&wd->input_device, NULL);
1761                 /* FIXME: We really need keyboard grab cancel here to
1762                  * let the grab shut down properly.  As it is we leak
1763                  * the grab data. */
1764                 wl_input_device_end_keyboard_grab(&wd->input_device);
1765         }
1766 }
1767
1768 /* TODO: share this function with wayland-server.c */
1769 static struct wl_resource *
1770 find_resource_for_surface(struct wl_list *list, struct wl_surface *surface)
1771 {
1772         struct wl_resource *r;
1773
1774         if (!surface)
1775                 return NULL;
1776
1777         wl_list_for_each(r, list, link) {
1778                 if (r->client == surface->resource.client)
1779                         return r;
1780         }
1781
1782         return NULL;
1783 }
1784
1785 static void
1786 lose_touch_focus_resource(struct wl_listener *listener, void *data)
1787 {
1788         struct weston_input_device *device =
1789                 container_of(listener, struct weston_input_device,
1790                              touch_focus_resource_listener);
1791
1792         device->touch_focus_resource = NULL;
1793 }
1794
1795 static void
1796 lose_touch_focus(struct wl_listener *listener, void *data)
1797 {
1798         struct weston_input_device *device =
1799                 container_of(listener, struct weston_input_device,
1800                              touch_focus_listener);
1801
1802         device->touch_focus = NULL;
1803 }
1804
1805 static void
1806 touch_set_focus(struct weston_input_device *device,
1807                 struct wl_surface *surface)
1808 {
1809         struct wl_input_device *input_device = &device->input_device;
1810         struct wl_resource *resource;
1811
1812         if (device->touch_focus == surface)
1813                 return;
1814
1815         if (surface) {
1816                 resource =
1817                         find_resource_for_surface(&input_device->resource_list,
1818                                                   surface);
1819                 if (!resource) {
1820                         fprintf(stderr, "couldn't find resource\n");
1821                         return;
1822                 }
1823
1824                 device->touch_focus_resource_listener.notify =
1825                         lose_touch_focus_resource;
1826                 wl_signal_add(&resource->destroy_signal,
1827                               &device->touch_focus_resource_listener);
1828                 device->touch_focus_listener.notify = lose_touch_focus;
1829                 wl_signal_add(&surface->resource.destroy_signal,
1830                                &device->touch_focus_listener);
1831
1832                 device->touch_focus = surface;
1833                 device->touch_focus_resource = resource;
1834         } else {
1835                 if (device->touch_focus)
1836                         wl_list_remove(&device->touch_focus_listener.link);
1837                 if (device->touch_focus_resource)
1838                         wl_list_remove(&device->touch_focus_resource_listener.link);
1839                 device->touch_focus = NULL;
1840                 device->touch_focus_resource = NULL;
1841         }
1842 }
1843
1844 /**
1845  * notify_touch - emulates button touches and notifies surfaces accordingly.
1846  *
1847  * It assumes always the correct cycle sequence until it gets here: touch_down
1848  * → touch_update → ... → touch_update → touch_end. The driver is responsible
1849  * for sending along such order.
1850  *
1851  */
1852 WL_EXPORT void
1853 notify_touch(struct wl_input_device *device, uint32_t time, int touch_id,
1854              int x, int y, int touch_type)
1855 {
1856         struct weston_input_device *wd = (struct weston_input_device *) device;
1857         struct weston_compositor *ec = wd->compositor;
1858         struct weston_surface *es;
1859         int32_t sx, sy;
1860         uint32_t serial = 0;
1861
1862         switch (touch_type) {
1863         case WL_INPUT_DEVICE_TOUCH_DOWN:
1864                 weston_compositor_idle_inhibit(ec);
1865
1866                 wd->num_tp++;
1867
1868                 /* the first finger down picks the surface, and all further go
1869                  * to that surface for the remainder of the touch session i.e.
1870                  * until all touch points are up again. */
1871                 if (wd->num_tp == 1) {
1872                         es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
1873                         touch_set_focus(wd, &es->surface);
1874                 } else if (wd->touch_focus) {
1875                         es = (struct weston_surface *) wd->touch_focus;
1876                         weston_surface_from_global(es, x, y, &sx, &sy);
1877                 }
1878
1879                 if (wd->touch_focus_resource && wd->touch_focus)
1880                         wl_input_device_send_touch_down(wd->touch_focus_resource,
1881                                                         serial, time, &wd->touch_focus->resource,
1882                                                         touch_id, sx, sy);
1883                 break;
1884         case WL_INPUT_DEVICE_TOUCH_MOTION:
1885                 es = (struct weston_surface *) wd->touch_focus;
1886                 if (!es)
1887                         break;
1888
1889                 weston_surface_from_global(es, x, y, &sx, &sy);
1890                 if (wd->touch_focus_resource)
1891                         wl_input_device_send_touch_motion(wd->touch_focus_resource,
1892                                                           time, touch_id, sx, sy);
1893                 break;
1894         case WL_INPUT_DEVICE_TOUCH_UP:
1895                 weston_compositor_idle_release(ec);
1896                 wd->num_tp--;
1897
1898                 if (wd->touch_focus_resource)
1899                         wl_input_device_send_touch_up(wd->touch_focus_resource,
1900                                                       serial, time, touch_id);
1901                 if (wd->num_tp == 0)
1902                         touch_set_focus(wd, NULL);
1903                 break;
1904         }
1905 }
1906
1907 static void
1908 input_device_attach(struct wl_client *client,
1909                     struct wl_resource *resource,
1910                     uint32_t serial,
1911                     struct wl_resource *buffer_resource, int32_t x, int32_t y)
1912 {
1913         struct weston_input_device *device = resource->data;
1914         struct weston_compositor *compositor = device->compositor;
1915         struct wl_buffer *buffer = NULL;
1916
1917         if (serial < device->input_device.pointer_focus_serial)
1918                 return;
1919         if (device->input_device.pointer_focus == NULL)
1920                 return;
1921         if (device->input_device.pointer_focus->resource.client != client)
1922                 return;
1923
1924         if (buffer_resource)
1925                 buffer = buffer_resource->data;
1926
1927         weston_surface_attach(&device->sprite->surface, buffer);
1928
1929         if (!buffer)
1930                 return;
1931
1932         if (!weston_surface_is_mapped(device->sprite)) {
1933                 wl_list_insert(&compositor->cursor_layer.surface_list,
1934                                &device->sprite->layer_link);
1935                 weston_surface_assign_output(device->sprite);
1936         }
1937
1938
1939         device->hotspot_x = x;
1940         device->hotspot_y = y;
1941         weston_surface_configure(device->sprite,
1942                                  device->input_device.x - device->hotspot_x,
1943                                  device->input_device.y - device->hotspot_y,
1944                                  buffer->width, buffer->height);
1945
1946         surface_damage(NULL, &device->sprite->surface.resource,
1947                        0, 0, buffer->width, buffer->height);
1948 }
1949
1950 static const struct wl_input_device_interface input_device_interface = {
1951         input_device_attach,
1952 };
1953
1954 static void
1955 handle_drag_surface_destroy(struct wl_listener *listener, void *data)
1956 {
1957         struct weston_input_device *device;
1958
1959         device = container_of(listener, struct weston_input_device,
1960                               drag_surface_destroy_listener);
1961
1962         device->drag_surface = NULL;
1963 }
1964
1965 static void unbind_input_device(struct wl_resource *resource)
1966 {
1967         wl_list_remove(&resource->link);
1968         free(resource);
1969 }
1970
1971 static void
1972 bind_input_device(struct wl_client *client,
1973                   void *data, uint32_t version, uint32_t id)
1974 {
1975         struct wl_input_device *device = data;
1976         struct wl_resource *resource;
1977
1978         resource = wl_client_add_object(client, &wl_input_device_interface,
1979                                         &input_device_interface, id, data);
1980         wl_list_insert(&device->resource_list, &resource->link);
1981         resource->destroy = unbind_input_device;
1982 }
1983
1984 static void
1985 device_handle_new_drag_icon(struct wl_listener *listener, void *data)
1986 {
1987         struct weston_input_device *device;
1988
1989         device = container_of(listener, struct weston_input_device,
1990                               new_drag_icon_listener);
1991
1992         weston_input_update_drag_surface(&device->input_device, 0, 0);
1993 }
1994
1995 WL_EXPORT void
1996 weston_input_device_init(struct weston_input_device *device,
1997                          struct weston_compositor *ec)
1998 {
1999         wl_input_device_init(&device->input_device);
2000
2001         wl_display_add_global(ec->wl_display, &wl_input_device_interface,
2002                               device, bind_input_device);
2003
2004         device->sprite = weston_surface_create(ec);
2005         device->sprite->surface.resource.data = device->sprite;
2006
2007         device->compositor = ec;
2008         device->hotspot_x = 16;
2009         device->hotspot_y = 16;
2010         device->modifier_state = 0;
2011         device->num_tp = 0;
2012
2013         device->drag_surface_destroy_listener.notify =
2014                 handle_drag_surface_destroy;
2015
2016         wl_list_insert(ec->input_device_list.prev, &device->link);
2017
2018         device->new_drag_icon_listener.notify = device_handle_new_drag_icon;
2019         wl_signal_add(&device->input_device.drag_icon_signal,
2020                       &device->new_drag_icon_listener);
2021 }
2022
2023 WL_EXPORT void
2024 weston_input_device_release(struct weston_input_device *device)
2025 {
2026         wl_list_remove(&device->link);
2027         /* The global object is destroyed at wl_display_destroy() time. */
2028
2029         if (device->sprite)
2030                 destroy_surface(&device->sprite->surface.resource);
2031
2032         wl_input_device_release(&device->input_device);
2033 }
2034
2035 static void
2036 drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2037 {
2038         weston_surface_configure(es,
2039                                  es->geometry.x + sx, es->geometry.y + sy,
2040                                  es->buffer->width, es->buffer->height);
2041 }
2042
2043 static int
2044 device_setup_new_drag_surface(struct weston_input_device *device,
2045                               struct weston_surface *surface)
2046 {
2047         struct wl_input_device *input_device = &device->input_device;
2048
2049         if (surface->configure) {
2050                 wl_resource_post_error(&surface->surface.resource,
2051                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
2052                                        "surface->configure already set");
2053                 return 0;
2054         }
2055
2056         device->drag_surface = surface;
2057
2058         weston_surface_set_position(device->drag_surface,
2059                                     input_device->x, input_device->y);
2060
2061         surface->configure = drag_surface_configure;
2062
2063         wl_signal_add(&surface->surface.resource.destroy_signal,
2064                        &device->drag_surface_destroy_listener);
2065
2066         return 1;
2067 }
2068
2069 static void
2070 device_release_drag_surface(struct weston_input_device *device)
2071 {
2072         device->drag_surface->configure = NULL;
2073         undef_region(&device->drag_surface->input);
2074         wl_list_remove(&device->drag_surface_destroy_listener.link);
2075         device->drag_surface = NULL;
2076 }
2077
2078 static void
2079 device_map_drag_surface(struct weston_input_device *device)
2080 {
2081         if (weston_surface_is_mapped(device->drag_surface) ||
2082             !device->drag_surface->buffer)
2083                 return;
2084
2085         wl_list_insert(&device->sprite->layer_link,
2086                        &device->drag_surface->layer_link);
2087         weston_surface_assign_output(device->drag_surface);
2088         empty_region(&device->drag_surface->input);
2089 }
2090
2091 static  void
2092 weston_input_update_drag_surface(struct wl_input_device *input_device,
2093                                  int dx, int dy)
2094 {
2095         int surface_changed = 0;
2096         struct weston_input_device *device = (struct weston_input_device *)
2097                 input_device;
2098
2099         if (!device->drag_surface && !input_device->drag_surface)
2100                 return;
2101
2102         if (device->drag_surface && input_device->drag_surface &&
2103             (&device->drag_surface->surface.resource !=
2104              &input_device->drag_surface->resource))
2105                 /* between calls to this funcion we got a new drag_surface */
2106                 surface_changed = 1;
2107
2108         if (!input_device->drag_surface || surface_changed) {
2109                 device_release_drag_surface(device);
2110                 if (!surface_changed)
2111                         return;
2112         }
2113
2114         if (!device->drag_surface || surface_changed) {
2115                 struct weston_surface *surface = (struct weston_surface *)
2116                         input_device->drag_surface;
2117                 if (!device_setup_new_drag_surface(device, surface))
2118                         return;
2119         }
2120
2121         /* the client may not have attached a buffer to the drag surface
2122          * when we setup it up, so check if map is needed on every update */
2123         device_map_drag_surface(device);
2124
2125         /* the client may have attached a buffer with a different size to
2126          * the drag surface, causing the input region to be reset */
2127         if (region_is_undefined(&device->drag_surface->input))
2128                 empty_region(&device->drag_surface->input);
2129
2130         if (!dx && !dy)
2131                 return;
2132
2133         weston_surface_set_position(device->drag_surface,
2134                                     device->drag_surface->geometry.x + dx,
2135                                     device->drag_surface->geometry.y + dy);
2136 }
2137
2138 WL_EXPORT void
2139 weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
2140 {
2141         weston_input_update_drag_surface(compositor->input_device, 0, 0);
2142 }
2143
2144 static void
2145 bind_output(struct wl_client *client,
2146             void *data, uint32_t version, uint32_t id)
2147 {
2148         struct weston_output *output = data;
2149         struct weston_mode *mode;
2150         struct wl_resource *resource;
2151
2152         resource = wl_client_add_object(client,
2153                                         &wl_output_interface, NULL, id, data);
2154
2155         wl_output_send_geometry(resource,
2156                                 output->x,
2157                                 output->y,
2158                                 output->mm_width,
2159                                 output->mm_height,
2160                                 output->subpixel,
2161                                 output->make, output->model);
2162
2163         wl_list_for_each (mode, &output->mode_list, link) {
2164                 wl_output_send_mode(resource,
2165                                     mode->flags,
2166                                     mode->width,
2167                                     mode->height,
2168                                     mode->refresh);
2169         }
2170 }
2171
2172 static const char vertex_shader[] =
2173         "uniform mat4 proj;\n"
2174         "attribute vec2 position;\n"
2175         "attribute vec2 texcoord;\n"
2176         "varying vec2 v_texcoord;\n"
2177         "void main()\n"
2178         "{\n"
2179         "   gl_Position = proj * vec4(position, 0.0, 1.0);\n"
2180         "   v_texcoord = texcoord;\n"
2181         "}\n";
2182
2183 static const char texture_fragment_shader[] =
2184         "precision mediump float;\n"
2185         "varying vec2 v_texcoord;\n"
2186         "uniform sampler2D tex;\n"
2187         "uniform float alpha;\n"
2188         "uniform float texwidth;\n"
2189         "void main()\n"
2190         "{\n"
2191         "   if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
2192         "       v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
2193         "      discard;\n"
2194         "   gl_FragColor = texture2D(tex, v_texcoord)\n;"
2195         "   gl_FragColor = alpha * gl_FragColor;\n"
2196         "}\n";
2197
2198 static const char solid_fragment_shader[] =
2199         "precision mediump float;\n"
2200         "uniform vec4 color;\n"
2201         "uniform float alpha;\n"
2202         "void main()\n"
2203         "{\n"
2204         "   gl_FragColor = alpha * color\n;"
2205         "}\n";
2206
2207 static int
2208 compile_shader(GLenum type, const char *source)
2209 {
2210         GLuint s;
2211         char msg[512];
2212         GLint status;
2213
2214         s = glCreateShader(type);
2215         glShaderSource(s, 1, &source, NULL);
2216         glCompileShader(s);
2217         glGetShaderiv(s, GL_COMPILE_STATUS, &status);
2218         if (!status) {
2219                 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
2220                 fprintf(stderr, "shader info: %s\n", msg);
2221                 return GL_NONE;
2222         }
2223
2224         return s;
2225 }
2226
2227 static int
2228 weston_shader_init(struct weston_shader *shader,
2229                    const char *vertex_source, const char *fragment_source)
2230 {
2231         char msg[512];
2232         GLint status;
2233
2234         shader->vertex_shader =
2235                 compile_shader(GL_VERTEX_SHADER, vertex_source);
2236         shader->fragment_shader =
2237                 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2238
2239         shader->program = glCreateProgram();
2240         glAttachShader(shader->program, shader->vertex_shader);
2241         glAttachShader(shader->program, shader->fragment_shader);
2242         glBindAttribLocation(shader->program, 0, "position");
2243         glBindAttribLocation(shader->program, 1, "texcoord");
2244
2245         glLinkProgram(shader->program);
2246         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
2247         if (!status) {
2248                 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
2249                 fprintf(stderr, "link info: %s\n", msg);
2250                 return -1;
2251         }
2252
2253         shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
2254         shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
2255         shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
2256         shader->color_uniform = glGetUniformLocation(shader->program, "color");
2257         shader->texwidth_uniform = glGetUniformLocation(shader->program,
2258                                                         "texwidth");
2259
2260         return 0;
2261 }
2262
2263 WL_EXPORT void
2264 weston_output_destroy(struct weston_output *output)
2265 {
2266         struct weston_compositor *c = output->compositor;
2267
2268         pixman_region32_fini(&output->region);
2269         pixman_region32_fini(&output->previous_damage);
2270
2271         wl_display_remove_global(c->wl_display, output->global);
2272 }
2273
2274 WL_EXPORT void
2275 weston_output_update_zoom(struct weston_output *output, int x, int y)
2276 {
2277         float ratio;
2278
2279         if (output->zoom.level <= 0)
2280                 return;
2281
2282         output->zoom.magnification = 1 / output->zoom.level;
2283         ratio = 1 - (1 / output->zoom.magnification);
2284
2285         output->zoom.trans_x = (((float)(x - output->x) / output->current->width) * (ratio * 2)) - ratio;
2286         output->zoom.trans_y = (((float)(y - output->y) / output->current->height) * (ratio * 2)) - ratio;
2287
2288         output->dirty = 1;
2289         weston_output_damage(output);
2290 }
2291
2292 WL_EXPORT void
2293 weston_output_update_matrix(struct weston_output *output)
2294 {
2295         int flip;
2296         struct weston_matrix camera;
2297         struct weston_matrix modelview;
2298
2299         weston_matrix_init(&output->matrix);
2300         weston_matrix_translate(&output->matrix,
2301                                 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2302                                 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
2303
2304         flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
2305         weston_matrix_scale(&output->matrix,
2306                             2.0 / (output->current->width + output->border.left + output->border.right),
2307                             flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
2308         if (output->zoom.active) {
2309                 weston_matrix_init(&camera);
2310                 weston_matrix_init(&modelview);
2311                 weston_matrix_translate(&camera, output->zoom.trans_x, flip * output->zoom.trans_y, 0);
2312                 weston_matrix_invert(&modelview, &camera);
2313                 weston_matrix_scale(&modelview, output->zoom.magnification, output->zoom.magnification, 1.0);
2314                 weston_matrix_multiply(&output->matrix, &modelview);
2315         }
2316
2317         output->dirty = 0;
2318 }
2319
2320 WL_EXPORT void
2321 weston_output_move(struct weston_output *output, int x, int y)
2322 {
2323         output->x = x;
2324         output->y = y;
2325
2326         pixman_region32_init(&output->previous_damage);
2327         pixman_region32_init_rect(&output->region, x, y,
2328                                   output->current->width,
2329                                   output->current->height);
2330 }
2331
2332 WL_EXPORT void
2333 weston_output_init(struct weston_output *output, struct weston_compositor *c,
2334                    int x, int y, int width, int height, uint32_t flags)
2335 {
2336         output->compositor = c;
2337         output->x = x;
2338         output->y = y;
2339         output->border.top = 0;
2340         output->border.bottom = 0;
2341         output->border.left = 0;
2342         output->border.right = 0;
2343         output->mm_width = width;
2344         output->mm_height = height;
2345         output->dirty = 1;
2346
2347         output->zoom.active = 0;
2348         output->zoom.increment = 0.05;
2349         output->zoom.level = 1.0;
2350         output->zoom.magnification = 1.0;
2351         output->zoom.trans_x = 0.0;
2352         output->zoom.trans_y = 0.0;
2353
2354         output->flags = flags;
2355         weston_output_move(output, x, y);
2356         weston_output_damage(output);
2357
2358         wl_list_init(&output->frame_callback_list);
2359
2360         output->global =
2361                 wl_display_add_global(c->wl_display, &wl_output_interface,
2362                                       output, bind_output);
2363 }
2364
2365 static void
2366 compositor_bind(struct wl_client *client,
2367                 void *data, uint32_t version, uint32_t id)
2368 {
2369         struct weston_compositor *compositor = data;
2370
2371         wl_client_add_object(client, &wl_compositor_interface,
2372                              &compositor_interface, id, compositor);
2373 }
2374
2375 WL_EXPORT int
2376 weston_compositor_init(struct weston_compositor *ec, struct wl_display *display)
2377 {
2378         struct wl_event_loop *loop;
2379         const char *extensions;
2380
2381         ec->wl_display = display;
2382         wl_signal_init(&ec->destroy_signal);
2383         wl_signal_init(&ec->activate_signal);
2384         wl_signal_init(&ec->lock_signal);
2385         wl_signal_init(&ec->unlock_signal);
2386         ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
2387
2388         if (!wl_display_add_global(display, &wl_compositor_interface,
2389                                    ec, compositor_bind))
2390                 return -1;
2391
2392         wl_display_init_shm(display);
2393
2394         ec->image_target_texture_2d =
2395                 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2396         ec->image_target_renderbuffer_storage = (void *)
2397                 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2398         ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2399         ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2400         ec->bind_display =
2401                 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2402         ec->unbind_display =
2403                 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2404
2405         extensions = (const char *) glGetString(GL_EXTENSIONS);
2406         if (!extensions) {
2407                 fprintf(stderr, "Retrieving GL extension string failed.\n");
2408                 return -1;
2409         }
2410
2411         if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2412                 fprintf(stderr,
2413                         "GL_EXT_texture_format_BGRA8888 not available\n");
2414                 return -1;
2415         }
2416
2417         if (strstr(extensions, "GL_EXT_read_format_bgra"))
2418                 ec->read_format = GL_BGRA_EXT;
2419         else
2420                 ec->read_format = GL_RGBA;
2421
2422         if (strstr(extensions, "GL_EXT_unpack_subimage"))
2423                 ec->has_unpack_subimage = 1;
2424
2425         extensions =
2426                 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2427         if (!extensions) {
2428                 fprintf(stderr, "Retrieving EGL extension string failed.\n");
2429                 return -1;
2430         }
2431
2432         if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2433                 ec->has_bind_display = 1;
2434         if (ec->has_bind_display)
2435                 ec->bind_display(ec->display, ec->wl_display);
2436
2437         wl_list_init(&ec->surface_list);
2438         wl_list_init(&ec->layer_list);
2439         wl_list_init(&ec->input_device_list);
2440         wl_list_init(&ec->output_list);
2441         wl_list_init(&ec->binding_list);
2442         wl_list_init(&ec->animation_list);
2443         weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
2444         ec->fade.animation.frame = fade_frame;
2445         wl_list_init(&ec->fade.animation.link);
2446
2447         weston_layer_init(&ec->fade_layer, &ec->layer_list);
2448         weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
2449
2450         screenshooter_create(ec);
2451
2452         ec->ping_handler = NULL;
2453
2454         wl_data_device_manager_init(ec->wl_display);
2455
2456         glActiveTexture(GL_TEXTURE0);
2457
2458         if (weston_shader_init(&ec->texture_shader,
2459                              vertex_shader, texture_fragment_shader) < 0)
2460                 return -1;
2461         if (weston_shader_init(&ec->solid_shader,
2462                              vertex_shader, solid_fragment_shader) < 0)
2463                 return -1;
2464
2465         loop = wl_display_get_event_loop(ec->wl_display);
2466         ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
2467         wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
2468
2469         ec->input_loop = wl_event_loop_create();
2470
2471         weston_compositor_schedule_repaint(ec);
2472
2473         return 0;
2474 }
2475
2476 WL_EXPORT void
2477 weston_compositor_shutdown(struct weston_compositor *ec)
2478 {
2479         struct weston_output *output, *next;
2480
2481         wl_event_source_remove(ec->idle_source);
2482         if (ec->input_loop_source)
2483                 wl_event_source_remove(ec->input_loop_source);
2484
2485         /* Destroy all outputs associated with this compositor */
2486         wl_list_for_each_safe(output, next, &ec->output_list, link)
2487                 output->destroy(output);
2488
2489         weston_binding_list_destroy_all(&ec->binding_list);
2490
2491         wl_array_release(&ec->vertices);
2492         wl_array_release(&ec->indices);
2493
2494         wl_event_loop_destroy(ec->input_loop);
2495 }
2496
2497 static int on_term_signal(int signal_number, void *data)
2498 {
2499         struct wl_display *display = data;
2500
2501         fprintf(stderr, "caught signal %d\n", signal_number);
2502         wl_display_terminate(display);
2503
2504         return 1;
2505 }
2506
2507 static void
2508 on_segv_signal(int s, siginfo_t *siginfo, void *context)
2509 {
2510         void *buffer[32];
2511         int i, count;
2512         Dl_info info;
2513
2514         fprintf(stderr, "caught segv\n");
2515
2516         count = backtrace(buffer, ARRAY_LENGTH(buffer));
2517         for (i = 0; i < count; i++) {
2518                 dladdr(buffer[i], &info);
2519                 fprintf(stderr, "  [%016lx]  %s  (%s)\n",
2520                         (long) buffer[i],
2521                         info.dli_sname ? info.dli_sname : "--",
2522                         info.dli_fname);
2523         }
2524
2525         longjmp(segv_jmp_buf, 1);
2526 }
2527
2528
2529 static void *
2530 load_module(const char *name, const char *entrypoint, void **handle)
2531 {
2532         char path[PATH_MAX];
2533         void *module, *init;
2534
2535         if (name[0] != '/')
2536                 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2537         else
2538                 snprintf(path, sizeof path, "%s", name);
2539
2540         module = dlopen(path, RTLD_LAZY);
2541         if (!module) {
2542                 fprintf(stderr,
2543                         "failed to load module: %s\n", dlerror());
2544                 return NULL;
2545         }
2546
2547         init = dlsym(module, entrypoint);
2548         if (!init) {
2549                 fprintf(stderr,
2550                         "failed to lookup init function: %s\n", dlerror());
2551                 return NULL;
2552         }
2553
2554         return init;
2555 }
2556
2557 int main(int argc, char *argv[])
2558 {
2559         struct wl_display *display;
2560         struct weston_compositor *ec;
2561         struct wl_event_source *signals[4];
2562         struct wl_event_loop *loop;
2563         struct sigaction segv_action;
2564         void *shell_module, *backend_module, *xserver_module;
2565         int (*shell_init)(struct weston_compositor *ec);
2566         int (*xserver_init)(struct weston_compositor *ec);
2567         struct weston_compositor
2568                 *(*backend_init)(struct wl_display *display,
2569                                  int argc, char *argv[]);
2570         int i;
2571         char *backend = NULL;
2572         char *shell = NULL;
2573         int32_t idle_time = 300;
2574         int32_t xserver;
2575         char *socket_name = NULL;
2576         char *config_file;
2577
2578         const struct config_key shell_config_keys[] = {
2579                 { "type", CONFIG_KEY_STRING, &shell },
2580         };
2581
2582         const struct config_section cs[] = {
2583                 { "shell",
2584                   shell_config_keys, ARRAY_LENGTH(shell_config_keys) },
2585         };
2586
2587         const struct weston_option core_options[] = {
2588                 { WESTON_OPTION_STRING, "backend", 'B', &backend },
2589                 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
2590                 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
2591                 { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
2592         };
2593
2594         argc = parse_options(core_options,
2595                              ARRAY_LENGTH(core_options), argc, argv);
2596
2597         display = wl_display_create();
2598
2599         loop = wl_display_get_event_loop(display);
2600         signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
2601                                               display);
2602         signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
2603                                               display);
2604         signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
2605                                               display);
2606
2607         wl_list_init(&child_process_list);
2608         signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
2609                                               NULL);
2610
2611         segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
2612         segv_action.sa_sigaction = on_segv_signal;
2613         sigemptyset(&segv_action.sa_mask);
2614         sigaction(SIGSEGV, &segv_action, NULL);
2615
2616         if (!backend) {
2617                 if (getenv("WAYLAND_DISPLAY"))
2618                         backend = "wayland-backend.so";
2619                 else if (getenv("DISPLAY"))
2620                         backend = "x11-backend.so";
2621                 else if (getenv("OPENWFD"))
2622                         backend = "openwfd-backend.so";
2623                 else
2624                         backend = "drm-backend.so";
2625         }
2626
2627         config_file = config_file_path("weston.ini");
2628         parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
2629         free(config_file);
2630
2631         if (!shell)
2632                 shell = "desktop-shell.so";
2633
2634         backend_init = load_module(backend, "backend_init", &backend_module);
2635         if (!backend_init)
2636                 exit(EXIT_FAILURE);
2637
2638         shell_init = load_module(shell, "shell_init", &shell_module);
2639         if (!shell_init)
2640                 exit(EXIT_FAILURE);
2641
2642         ec = backend_init(display, argc, argv);
2643         if (ec == NULL) {
2644                 fprintf(stderr, "failed to create compositor\n");
2645                 exit(EXIT_FAILURE);
2646         }
2647
2648         for (i = 1; argv[i]; i++)
2649                 fprintf(stderr, "unhandled option: %s\n", argv[i]);
2650         if (argv[1])
2651                 exit(EXIT_FAILURE);
2652
2653         ec->option_idle_time = idle_time;
2654         ec->idle_time = idle_time;
2655
2656         xserver_init = NULL;
2657         if (xserver)
2658                 xserver_init = load_module("xserver-launcher.so",
2659                                            "weston_xserver_init",
2660                                            &xserver_module);
2661         if (xserver_init)
2662                 xserver_init(ec);
2663
2664         if (shell_init(ec) < 0)
2665                 exit(EXIT_FAILURE);
2666
2667         if (wl_display_add_socket(display, socket_name)) {
2668                 fprintf(stderr, "failed to add socket: %m\n");
2669                 exit(EXIT_FAILURE);
2670         }
2671
2672         weston_compositor_dpms_on(ec);
2673         weston_compositor_wake(ec);
2674         if (setjmp(segv_jmp_buf) == 0)
2675                 wl_display_run(display);
2676
2677         /* prevent further rendering while shutting down */
2678         ec->state = WESTON_COMPOSITOR_SLEEPING;
2679
2680         wl_signal_emit(&ec->destroy_signal, ec);
2681
2682         if (ec->has_bind_display)
2683                 ec->unbind_display(ec->display, display);
2684
2685         for (i = ARRAY_LENGTH(signals); i;)
2686                 wl_event_source_remove(signals[--i]);
2687
2688         ec->destroy(ec);
2689         wl_display_destroy(display);
2690
2691         return 0;
2692 }