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