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