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