compositor/compositor.c

   1 /*
   2  * Copyright © 2010-2011 Intel Corporation
   3  * Copyright © 2008-2011 Kristian Høgsberg
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and
   6  * its documentation for any purpose is hereby granted without fee, provided
   7  * that the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of the copyright holders not be used in
  10  * advertising or publicity pertaining to distribution of the software
  11  * without specific, written prior permission.  The copyright holders make
  12  * no representations about the suitability of this software for any
  13  * purpose.  It is provided "as is" without express or implied warranty.
  14  *
  15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  16  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  18  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  19  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  20  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  */
  23
  24 #define _GNU_SOURCE
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <stdint.h>
  32 #include <limits.h>
  33 #include <stdarg.h>
  34 #include <assert.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/wait.h>
  37 #include <fcntl.h>
  38 #include <unistd.h>
  39 #include <math.h>
  40 #include <linux/input.h>
  41 #include <dlfcn.h>
  42 #include <getopt.h>
  43 #include <signal.h>
  44
  45 #include "wayland-server.h"
  46 #include "compositor.h"
  47
  48 /* The plan here is to generate a random anonymous socket name and
  49  * advertise that through a service on the session dbus.
  50  */
  51 static const char *option_socket_name = NULL;
  52 static int option_idle_time = 300;
  53
  54 static struct wl_list child_process_list;
  55
  56 static int
  57 sigchld_handler(int signal_number, void *data)
  58 {
  59         struct wlsc_process *p;
  60         int status;
  61         pid_t pid;
  62
  63         pid = wait(&status);
  64         wl_list_for_each(p, &child_process_list, link) {
  65                 if (p->pid == pid)
  66                         break;
  67         }
  68
  69         if (&p->link == &child_process_list) {
  70                 fprintf(stderr, "unknown child process exited\n");
  71                 return 1;
  72         }
  73
  74         wl_list_remove(&p->link);
  75         p->cleanup(p, status);
  76
  77         return 1;
  78 }
  79
  80 WL_EXPORT void
  81 wlsc_watch_process(struct wlsc_process *process)
  82 {
  83         wl_list_insert(&child_process_list, &process->link);
  84 }
  85
  86 WL_EXPORT void
  87 wlsc_matrix_init(struct wlsc_matrix *matrix)
  88 {
  89         static const struct wlsc_matrix identity = {
  90                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1 }
  91         };
  92
  93         memcpy(matrix, &identity, sizeof identity);
  94 }
  95
  96 static void
  97 wlsc_matrix_multiply(struct wlsc_matrix *m, const struct wlsc_matrix *n)
  98 {
  99         struct wlsc_matrix tmp;
 100         const GLfloat *row, *column;
 101         div_t d;
 102         int i, j;
 103
 104         for (i = 0; i < 16; i++) {
 105                 tmp.d[i] = 0;
 106                 d = div(i, 4);
 107                 row = m->d + d.quot * 4;
 108                 column = n->d + d.rem;
 109                 for (j = 0; j < 4; j++)
 110                         tmp.d[i] += row[j] * column[j * 4];
 111         }
 112         memcpy(m, &tmp, sizeof tmp);
 113 }
 114
 115 WL_EXPORT void
 116 wlsc_matrix_translate(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
 117 {
 118         struct wlsc_matrix translate = {
 119                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 }
 120         };
 121
 122         wlsc_matrix_multiply(matrix, &translate);
 123 }
 124
 125 WL_EXPORT void
 126 wlsc_matrix_scale(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
 127 {
 128         struct wlsc_matrix scale = {
 129                 { x, 0, 0, 0,  0, y, 0, 0,  0, 0, z, 0,  0, 0, 0, 1 }
 130         };
 131
 132         wlsc_matrix_multiply(matrix, &scale);
 133 }
 134
 135 static void
 136 wlsc_matrix_transform(struct wlsc_matrix *matrix, struct wlsc_vector *v)
 137 {
 138         int i, j;
 139         struct wlsc_vector t;
 140
 141         for (i = 0; i < 4; i++) {
 142                 t.f[i] = 0;
 143                 for (j = 0; j < 4; j++)
 144                         t.f[i] += v->f[j] * matrix->d[i + j * 4];
 145         }
 146
 147         *v = t;
 148 }
 149
 150 WL_EXPORT void
 151 wlsc_spring_init(struct wlsc_spring *spring,
 152                  double k, double current, double target)
 153 {
 154         spring->k = k;
 155         spring->friction = 100.0;
 156         spring->current = current;
 157         spring->previous = current;
 158         spring->target = target;
 159 }
 160
 161 WL_EXPORT void
 162 wlsc_spring_update(struct wlsc_spring *spring, uint32_t msec)
 163 {
 164         double force, v, current, step;
 165
 166         step = (msec - spring->timestamp) / 300.0;
 167         spring->timestamp = msec;
 168
 169         current = spring->current;
 170         v = current - spring->previous;
 171         force = spring->k * (spring->target - current) / 10.0 +
 172                 (spring->previous - current) - v * spring->friction;
 173
 174         spring->current =
 175                 current + (current - spring->previous) + force * step * step;
 176         spring->previous = current;
 177
 178 #if 0
 179         if (spring->current >= 1.0) {
 180 #ifdef TWEENER_BOUNCE
 181                 spring->current = 2.0 - spring->current;
 182                 spring->previous = 2.0 - spring->previous;
 183 #else
 184                 spring->current = 1.0;
 185                 spring->previous = 1.0;
 186 #endif
 187         }
 188
 189         if (spring->current <= 0.0) {
 190                 spring->current = 0.0;
 191                 spring->previous = 0.0;
 192         }
 193 #endif
 194 }
 195
 196 WL_EXPORT int
 197 wlsc_spring_done(struct wlsc_spring *spring)
 198 {
 199         return fabs(spring->previous - spring->target) < 0.0002 &&
 200                 fabs(spring->current - spring->target) < 0.0002;
 201 }
 202
 203 static void
 204 surface_handle_buffer_destroy(struct wl_listener *listener,
 205                               struct wl_resource *resource, uint32_t time)
 206 {
 207         struct wlsc_surface *es = container_of(listener, struct wlsc_surface,
 208                                                buffer_destroy_listener);
 209         struct wl_buffer *buffer = (struct wl_buffer *) resource;
 210
 211         if (es->buffer == buffer)
 212                 es->buffer = NULL;
 213 }
 214
 215 static void
 216 output_handle_scanout_buffer_destroy(struct wl_listener *listener,
 217                                      struct wl_resource *resource,
 218                                      uint32_t time)
 219 {
 220         struct wlsc_output *output =
 221                 container_of(listener, struct wlsc_output,
 222                              scanout_buffer_destroy_listener);
 223         struct wl_buffer *buffer = (struct wl_buffer *) resource;
 224
 225         if (output->scanout_buffer == buffer)
 226                 output->scanout_buffer = NULL;
 227 }
 228
 229 WL_EXPORT struct wlsc_surface *
 230 wlsc_surface_create(struct wlsc_compositor *compositor,
 231                     int32_t x, int32_t y, int32_t width, int32_t height)
 232 {
 233         struct wlsc_surface *surface;
 234
 235         surface = malloc(sizeof *surface);
 236         if (surface == NULL)
 237                 return NULL;
 238
 239         wl_list_init(&surface->link);
 240         wl_list_init(&surface->buffer_link);
 241         surface->map_type = WLSC_SURFACE_MAP_UNMAPPED;
 242
 243         glGenTextures(1, &surface->texture);
 244         glBindTexture(GL_TEXTURE_2D, surface->texture);
 245         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 246         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 247
 248         surface->surface.resource.client = NULL;
 249
 250         surface->compositor = compositor;
 251         surface->visual = WLSC_NONE_VISUAL;
 252         surface->image = EGL_NO_IMAGE_KHR;
 253         surface->saved_texture = 0;
 254         surface->x = x;
 255         surface->y = y;
 256         surface->width = width;
 257         surface->height = height;
 258
 259         surface->buffer = NULL;
 260         surface->output = NULL;
 261
 262         pixman_region32_init(&surface->damage);
 263         pixman_region32_init(&surface->opaque);
 264
 265         surface->buffer_destroy_listener.func = surface_handle_buffer_destroy;
 266         wl_list_init(&surface->buffer_destroy_listener.link);
 267
 268         surface->transform = NULL;
 269
 270         return surface;
 271 }
 272
 273 WL_EXPORT void
 274 wlsc_surface_damage_rectangle(struct wlsc_surface *surface,
 275                               int32_t x, int32_t y,
 276                               int32_t width, int32_t height)
 277 {
 278         struct wlsc_compositor *compositor = surface->compositor;
 279
 280         pixman_region32_union_rect(&surface->damage,
 281                                    &surface->damage,
 282                                    surface->x + x, surface->y + y,
 283                                    width, height);
 284         wlsc_compositor_schedule_repaint(compositor);
 285 }
 286
 287 WL_EXPORT void
 288 wlsc_surface_damage(struct wlsc_surface *surface)
 289 {
 290         wlsc_surface_damage_rectangle(surface, 0, 0,
 291                                       surface->width, surface->height);
 292 }
 293
 294 WL_EXPORT void
 295 wlsc_surface_damage_below(struct wlsc_surface *surface)
 296 {
 297         struct wlsc_surface *below;
 298
 299         if (surface->link.next == &surface->compositor->surface_list)
 300                 return;
 301
 302         below = container_of(surface->link.next, struct wlsc_surface, link);
 303
 304         pixman_region32_union_rect(&below->damage,
 305                                    &below->damage,
 306                                    surface->x, surface->y,
 307                                    surface->width, surface->height);
 308         wlsc_compositor_schedule_repaint(surface->compositor);
 309 }
 310
 311 WL_EXPORT void
 312 wlsc_surface_configure(struct wlsc_surface *surface,
 313                        int x, int y, int width, int height)
 314 {
 315         wlsc_surface_damage_below(surface);
 316
 317         surface->x = x;
 318         surface->y = y;
 319         surface->width = width;
 320         surface->height = height;
 321
 322         wlsc_surface_assign_output(surface);
 323         wlsc_surface_damage(surface);
 324
 325         pixman_region32_fini(&surface->opaque);
 326         if (surface->visual == WLSC_RGB_VISUAL)
 327                 pixman_region32_init_rect(&surface->opaque,
 328                                           surface->x, surface->y,
 329                                           surface->width, surface->height);
 330         else
 331                 pixman_region32_init(&surface->opaque);
 332 }
 333
 334 WL_EXPORT uint32_t
 335 wlsc_compositor_get_time(void)
 336 {
 337         struct timeval tv;
 338
 339         gettimeofday(&tv, NULL);
 340
 341         return tv.tv_sec * 1000 + tv.tv_usec / 1000;
 342 }
 343
 344 static void
 345 wlsc_compositor_repick(struct wlsc_compositor *compositor)
 346 {
 347         struct wlsc_input_device *device;
 348         struct wlsc_surface *surface;
 349         int32_t sx, sy;
 350         uint32_t time;
 351
 352         time = wlsc_compositor_get_time();
 353         wl_list_for_each(device, &compositor->input_device_list, link) {
 354                 surface = pick_surface(&device->input_device, &sx, &sy);
 355                 wl_input_device_set_pointer_focus(&device->input_device,
 356                                                   &surface->surface,
 357                                                   time,
 358                                                   device->input_device.x,
 359                                                   device->input_device.y,
 360                                                   sx, sy);
 361         }
 362 }
 363
 364 static void
 365 destroy_surface(struct wl_resource *resource)
 366 {
 367         struct wlsc_surface *surface =
 368                 container_of(resource, struct wlsc_surface, surface.resource);
 369         struct wlsc_compositor *compositor = surface->compositor;
 370
 371         wlsc_surface_damage_below(surface);
 372
 373         wl_list_remove(&surface->link);
 374         wlsc_compositor_repick(compositor);
 375
 376         if (surface->saved_texture == 0)
 377                 glDeleteTextures(1, &surface->texture);
 378         else
 379                 glDeleteTextures(1, &surface->saved_texture);
 380
 381         if (surface->buffer)
 382                 wl_list_remove(&surface->buffer_destroy_listener.link);
 383
 384         if (surface->image != EGL_NO_IMAGE_KHR)
 385                 compositor->destroy_image(compositor->display,
 386                                           surface->image);
 387
 388         wl_list_remove(&surface->buffer_link);
 389
 390         free(surface);
 391 }
 392
 393 static void
 394 wlsc_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
 395 {
 396         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 397         struct wlsc_compositor *ec = es->compositor;
 398         struct wl_list *surfaces_attached_to;
 399
 400         if (es->saved_texture != 0)
 401                 es->texture = es->saved_texture;
 402
 403         glBindTexture(GL_TEXTURE_2D, es->texture);
 404
 405         if (wl_buffer_is_shm(buffer)) {
 406                 /* Unbind any EGLImage texture that may be bound, so we don't
 407                  * overwrite it.*/
 408                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
 409                              0, 0, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
 410                 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
 411                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
 412                              es->pitch, buffer->height, 0,
 413                              GL_BGRA_EXT, GL_UNSIGNED_BYTE,
 414                              wl_shm_buffer_get_data(buffer));
 415
 416                 switch (wl_shm_buffer_get_format(buffer)) {
 417                 case WL_SHM_FORMAT_ARGB32:
 418                         es->visual = WLSC_ARGB_VISUAL;
 419                         break;
 420                 case WL_SHM_FORMAT_PREMULTIPLIED_ARGB32:
 421                         es->visual = WLSC_PREMUL_ARGB_VISUAL;
 422                         break;
 423                 case WL_SHM_FORMAT_XRGB32:
 424                         es->visual = WLSC_RGB_VISUAL;
 425                         break;
 426                 }
 427
 428                 surfaces_attached_to = buffer->user_data;
 429
 430                 wl_list_remove(&es->buffer_link);
 431                 wl_list_insert(surfaces_attached_to, &es->buffer_link);
 432         } else {
 433                 if (es->image != EGL_NO_IMAGE_KHR)
 434                         ec->destroy_image(ec->display, es->image);
 435                 es->image = ec->create_image(ec->display, NULL,
 436                                              EGL_WAYLAND_BUFFER_WL,
 437                                              buffer, NULL);
 438
 439                 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
 440
 441                 /* FIXME: we need to get the visual from the wl_buffer */
 442                 es->visual = WLSC_PREMUL_ARGB_VISUAL;
 443                 es->pitch = es->width;
 444         }
 445 }
 446
 447 static void
 448 wlsc_sprite_attach(struct wlsc_sprite *sprite, struct wl_surface *surface)
 449 {
 450         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 451         struct wlsc_compositor *ec = es->compositor;
 452
 453         es->pitch = es->width;
 454         es->image = sprite->image;
 455         if (sprite->image != EGL_NO_IMAGE_KHR) {
 456                 glBindTexture(GL_TEXTURE_2D, es->texture);
 457                 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
 458         } else {
 459                 if (es->saved_texture == 0)
 460                         es->saved_texture = es->texture;
 461                 es->texture = sprite->texture;
 462         }
 463
 464         es->visual = sprite->visual;
 465
 466         if (es->buffer)
 467                 es->buffer = NULL;
 468 }
 469
 470 enum sprite_usage {
 471         SPRITE_USE_CURSOR = (1 << 0),
 472 };
 473
 474 static struct wlsc_sprite *
 475 create_sprite_from_png(struct wlsc_compositor *ec,
 476                        const char *filename, uint32_t usage)
 477 {
 478         uint32_t *pixels;
 479         struct wlsc_sprite *sprite;
 480         int32_t width, height;
 481         uint32_t stride;
 482
 483         pixels = wlsc_load_image(filename, &width, &height, &stride);
 484         if (pixels == NULL)
 485                 return NULL;
 486
 487         sprite = malloc(sizeof *sprite);
 488         if (sprite == NULL) {
 489                 free(pixels);
 490                 return NULL;
 491         }
 492
 493         sprite->visual = WLSC_PREMUL_ARGB_VISUAL;
 494         sprite->width = width;
 495         sprite->height = height;
 496         sprite->image = EGL_NO_IMAGE_KHR;
 497
 498         if (usage & SPRITE_USE_CURSOR && ec->create_cursor_image != NULL)
 499                 sprite->image = ec->create_cursor_image(ec, width, height);
 500
 501         glGenTextures(1, &sprite->texture);
 502         glBindTexture(GL_TEXTURE_2D, sprite->texture);
 503         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 504         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 505         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 506         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 507
 508         if (sprite->image != EGL_NO_IMAGE_KHR) {
 509                 ec->image_target_texture_2d(GL_TEXTURE_2D, sprite->image);
 510                 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,
 511                                 GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
 512         } else {
 513                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 514                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
 515         }
 516
 517         free(pixels);
 518
 519         return sprite;
 520 }
 521
 522 static const struct {
 523         const char *filename;
 524         int hotspot_x, hotspot_y;
 525 } pointer_images[] = {
 526         { DATADIR "/wayland/bottom_left_corner.png",     6, 30 },
 527         { DATADIR "/wayland/bottom_right_corner.png",   28, 28 },
 528         { DATADIR "/wayland/bottom_side.png",           16, 20 },
 529         { DATADIR "/wayland/grabbing.png",              20, 17 },
 530         { DATADIR "/wayland/left_ptr.png",              10,  5 },
 531         { DATADIR "/wayland/left_side.png",             10, 20 },
 532         { DATADIR "/wayland/right_side.png",            30, 19 },
 533         { DATADIR "/wayland/top_left_corner.png",        8,  8 },
 534         { DATADIR "/wayland/top_right_corner.png",      26,  8 },
 535         { DATADIR "/wayland/top_side.png",              18,  8 },
 536         { DATADIR "/wayland/xterm.png",                 15, 15 }
 537 };
 538
 539 static void
 540 create_pointer_images(struct wlsc_compositor *ec)
 541 {
 542         int i, count;
 543
 544         count = ARRAY_LENGTH(pointer_images);
 545         ec->pointer_sprites = malloc(count * sizeof *ec->pointer_sprites);
 546         for (i = 0; i < count; i++) {
 547                 ec->pointer_sprites[i] =
 548                         create_sprite_from_png(ec,
 549                                                pointer_images[i].filename,
 550                                                SPRITE_USE_CURSOR);
 551         }
 552 }
 553
 554 static int
 555 texture_region(struct wlsc_surface *es, pixman_region32_t *region)
 556 {
 557         struct wlsc_compositor *ec = es->compositor;
 558         GLfloat *v, inv_width, inv_height;
 559         pixman_box32_t *rectangles;
 560         unsigned int *p;
 561         int i, n;
 562
 563         rectangles = pixman_region32_rectangles(region, &n);
 564         v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
 565         p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
 566         inv_width = 1.0 / es->pitch;
 567         inv_height = 1.0 / es->height;
 568
 569         for (i = 0; i < n; i++, v += 16, p += 6) {
 570                 v[ 0] = rectangles[i].x1;
 571                 v[ 1] = rectangles[i].y1;
 572                 v[ 2] = (GLfloat) (rectangles[i].x1 - es->x) * inv_width;
 573                 v[ 3] = (GLfloat) (rectangles[i].y1 - es->y) * inv_height;
 574
 575                 v[ 4] = rectangles[i].x1;
 576                 v[ 5] = rectangles[i].y2;
 577                 v[ 6] = v[ 2];
 578                 v[ 7] = (GLfloat) (rectangles[i].y2 - es->y) * inv_height;
 579
 580                 v[ 8] = rectangles[i].x2;
 581                 v[ 9] = rectangles[i].y1;
 582                 v[10] = (GLfloat) (rectangles[i].x2 - es->x) * inv_width;
 583                 v[11] = v[ 3];
 584
 585                 v[12] = rectangles[i].x2;
 586                 v[13] = rectangles[i].y2;
 587                 v[14] = v[10];
 588                 v[15] = v[ 7];
 589
 590                 p[0] = i * 4 + 0;
 591                 p[1] = i * 4 + 1;
 592                 p[2] = i * 4 + 2;
 593                 p[3] = i * 4 + 2;
 594                 p[4] = i * 4 + 1;
 595                 p[5] = i * 4 + 3;
 596         }
 597
 598         return n;
 599 }
 600
 601 static void
 602 transform_vertex(struct wlsc_surface *surface,
 603                  GLfloat x, GLfloat y, GLfloat u, GLfloat v, GLfloat *r)
 604 {
 605         struct wlsc_vector t;
 606
 607         t.f[0] = x;
 608         t.f[1] = y;
 609         t.f[2] = 0.0;
 610         t.f[3] = 1.0;
 611
 612         wlsc_matrix_transform(&surface->transform->matrix, &t);
 613
 614         r[ 0] = t.f[0];
 615         r[ 1] = t.f[1];
 616         r[ 2] = u;
 617         r[ 3] = v;
 618 }
 619
 620 static int
 621 texture_transformed_surface(struct wlsc_surface *es)
 622 {
 623         struct wlsc_compositor *ec = es->compositor;
 624         GLfloat *v;
 625         unsigned int *p;
 626
 627         v = wl_array_add(&ec->vertices, 16 * sizeof *v);
 628         p = wl_array_add(&ec->indices, 6 * sizeof *p);
 629
 630         transform_vertex(es, es->x, es->y, 0.0, 0.0, &v[0]);
 631         transform_vertex(es, es->x, es->y + es->height, 0.0, 1.0, &v[4]);
 632         transform_vertex(es, es->x + es->width, es->y, 1.0, 0.0, &v[8]);
 633         transform_vertex(es, es->x + es->width, es->y + es->height,
 634                          1.0, 1.0, &v[12]);
 635
 636         p[0] = 0;
 637         p[1] = 1;
 638         p[2] = 2;
 639         p[3] = 2;
 640         p[4] = 1;
 641         p[5] = 3;
 642
 643         return 1;
 644 }
 645
 646 static void
 647 wlsc_surface_draw(struct wlsc_surface *es,
 648                   struct wlsc_output *output, pixman_region32_t *clip)
 649 {
 650         struct wlsc_compositor *ec = es->compositor;
 651         GLfloat *v;
 652         pixman_region32_t repaint;
 653         GLint filter;
 654         int n;
 655
 656         pixman_region32_init_rect(&repaint,
 657                                   es->x, es->y, es->width, es->height);
 658         pixman_region32_intersect(&repaint, &repaint, clip);
 659         if (!pixman_region32_not_empty(&repaint))
 660                 return;
 661
 662         switch (es->visual) {
 663         case WLSC_ARGB_VISUAL:
 664                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 665                 glEnable(GL_BLEND);
 666                 break;
 667         case WLSC_PREMUL_ARGB_VISUAL:
 668                 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 669                 glEnable(GL_BLEND);
 670                 break;
 671         case WLSC_RGB_VISUAL:
 672                 glDisable(GL_BLEND);
 673                 break;
 674         default:
 675                 fprintf(stderr, "bogus visual\n");
 676                 break;
 677         }
 678
 679         if (es->transform == NULL) {
 680                 filter = GL_NEAREST;
 681                 n = texture_region(es, &repaint);
 682         } else {
 683                 filter = GL_LINEAR;
 684                 n = texture_transformed_surface(es);
 685         }
 686
 687         glBindTexture(GL_TEXTURE_2D, es->texture);
 688         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
 689         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
 690
 691         v = ec->vertices.data;
 692         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
 693         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
 694         glEnableVertexAttribArray(0);
 695         glEnableVertexAttribArray(1);
 696         glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
 697
 698         ec->vertices.size = 0;
 699         ec->indices.size = 0;
 700         pixman_region32_fini(&repaint);
 701 }
 702
 703 static void
 704 wlsc_surface_raise(struct wlsc_surface *surface)
 705 {
 706         struct wlsc_compositor *compositor = surface->compositor;
 707
 708         wl_list_remove(&surface->link);
 709         wl_list_insert(&compositor->surface_list, &surface->link);
 710         wlsc_compositor_repick(compositor);
 711         wlsc_surface_damage(surface);
 712 }
 713
 714 WL_EXPORT void
 715 wlsc_compositor_damage_all(struct wlsc_compositor *compositor)
 716 {
 717         struct wlsc_output *output;
 718
 719         wl_list_for_each(output, &compositor->output_list, link)
 720                 wlsc_output_damage(output);
 721 }
 722
 723 static inline void
 724 wlsc_buffer_post_release(struct wl_buffer *buffer)
 725 {
 726         if (buffer == NULL || --buffer->busy_count > 0)
 727                 return;
 728
 729         assert(buffer->resource.client != NULL);
 730         wl_resource_post_event(&buffer->resource, WL_BUFFER_RELEASE);
 731 }
 732
 733 WL_EXPORT void
 734 wlsc_output_damage(struct wlsc_output *output)
 735 {
 736         struct wlsc_compositor *compositor = output->compositor;
 737
 738         pixman_region32_union(&compositor->damage,
 739                               &compositor->damage, &output->region);
 740         wlsc_compositor_schedule_repaint(compositor);
 741 }
 742
 743 static void
 744 fade_frame(struct wlsc_animation *animation,
 745            struct wlsc_output *output, uint32_t msecs)
 746 {
 747         struct wlsc_compositor *compositor =
 748                 container_of(animation,
 749                              struct wlsc_compositor, fade.animation);
 750
 751         wlsc_spring_update(&compositor->fade.spring, msecs);
 752         if (wlsc_spring_done(&compositor->fade.spring)) {
 753                 if (compositor->fade.spring.current > 0.999) {
 754                         compositor->state = WLSC_COMPOSITOR_SLEEPING;
 755                         compositor->shell->lock(compositor->shell);
 756                 }
 757                 compositor->fade.spring.current =
 758                         compositor->fade.spring.target;
 759                 wl_list_remove(&animation->link);
 760                 wl_list_init(&animation->link);
 761         }
 762
 763         wlsc_output_damage(output);
 764 }
 765
 766 static void
 767 fade_output(struct wlsc_output *output,
 768             GLfloat tint, pixman_region32_t *region)
 769 {
 770         struct wlsc_compositor *compositor = output->compositor;
 771         struct wlsc_surface surface;
 772         GLfloat color[4] = { 0.0, 0.0, 0.0, tint };
 773
 774         surface.compositor = compositor;
 775         surface.x = output->x;
 776         surface.y = output->y;
 777         surface.pitch = output->current->width;
 778         surface.width = output->current->width;
 779         surface.height = output->current->height;
 780         surface.texture = GL_NONE;
 781         surface.transform = NULL;
 782
 783         if (tint <= 1.0)
 784                 surface.visual = WLSC_PREMUL_ARGB_VISUAL;
 785         else
 786                 surface.visual = WLSC_RGB_VISUAL;
 787
 788         glUseProgram(compositor->solid_shader.program);
 789         glUniformMatrix4fv(compositor->solid_shader.proj_uniform,
 790                            1, GL_FALSE, output->matrix.d);
 791         glUniform4fv(compositor->solid_shader.color_uniform, 1, color);
 792         wlsc_surface_draw(&surface, output, region);
 793 }
 794
 795 static void
 796 wlsc_output_set_cursor(struct wlsc_output *output,
 797                        struct wl_input_device *dev, int force_sw)
 798 {
 799         struct wlsc_compositor *ec = output->compositor;
 800         struct wlsc_input_device *device = (struct wlsc_input_device *) dev;
 801         pixman_region32_t cursor_region;
 802         int use_hardware_cursor = 1, prior_was_hardware;
 803
 804         pixman_region32_init_rect(&cursor_region,
 805                                   device->sprite->x, device->sprite->y,
 806                                   device->sprite->width,
 807                                   device->sprite->height);
 808
 809         pixman_region32_intersect(&cursor_region, &cursor_region, &output->region);
 810
 811         if (!pixman_region32_not_empty(&cursor_region)) {
 812                 output->set_hardware_cursor(output, NULL);
 813                 goto out;
 814         }
 815
 816         prior_was_hardware = wl_list_empty(&device->sprite->link);
 817         if (force_sw || output->set_hardware_cursor(output, device) < 0) {
 818                 if (prior_was_hardware) {
 819                         wlsc_surface_damage(device->sprite);
 820                         output->set_hardware_cursor(output, NULL);
 821                 }
 822                 use_hardware_cursor = 0;
 823         } else if (!prior_was_hardware) {
 824                 wlsc_surface_damage_below(device->sprite);
 825         }
 826
 827         /* Remove always to be on top. */
 828         wl_list_remove(&device->sprite->link);
 829         if (!use_hardware_cursor && ec->focus)
 830                 wl_list_insert(&ec->surface_list, &device->sprite->link);
 831         else
 832                 wl_list_init(&device->sprite->link);
 833
 834 out:
 835         pixman_region32_fini(&cursor_region);
 836 }
 837
 838 static void
 839 wlsc_output_repaint(struct wlsc_output *output)
 840 {
 841         struct wlsc_compositor *ec = output->compositor;
 842         struct wlsc_surface *es;
 843         pixman_region32_t opaque, new_damage, total_damage, repaint;
 844
 845         output->prepare_render(output);
 846
 847         glViewport(0, 0, output->current->width, output->current->height);
 848
 849         glUseProgram(ec->texture_shader.program);
 850         glUniformMatrix4fv(ec->texture_shader.proj_uniform,
 851                            1, GL_FALSE, output->matrix.d);
 852         glUniform1i(ec->texture_shader.tex_uniform, 0);
 853
 854         wlsc_output_set_cursor(output, ec->input_device,
 855                                ec->fade.spring.current >= 0.001);
 856
 857         pixman_region32_init(&new_damage);
 858         pixman_region32_copy(&new_damage, &ec->damage);
 859         pixman_region32_init(&opaque);
 860
 861         wl_list_for_each(es, &ec->surface_list, link) {
 862                 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
 863                 pixman_region32_union(&new_damage, &new_damage, &es->damage);
 864                 pixman_region32_union(&opaque, &opaque, &es->opaque);
 865         }
 866
 867         pixman_region32_subtract(&ec->damage, &ec->damage, &output->region);
 868
 869         pixman_region32_init(&total_damage);
 870         pixman_region32_union(&total_damage, &new_damage,
 871                               &output->previous_damage);
 872         pixman_region32_intersect(&output->previous_damage,
 873                                   &new_damage, &output->region);
 874
 875         pixman_region32_fini(&opaque);
 876         pixman_region32_fini(&new_damage);
 877
 878         es = container_of(ec->surface_list.next, struct wlsc_surface, link);
 879
 880         if (es->visual == WLSC_RGB_VISUAL &&
 881             output->prepare_scanout_surface(output, es) == 0) {
 882                 /* We're drawing nothing now,
 883                  * draw the damaged regions later. */
 884                 pixman_region32_union(&ec->damage, &ec->damage, &total_damage);
 885
 886                 output->scanout_buffer = es->buffer;
 887                 output->scanout_buffer->busy_count++;
 888
 889                 wl_list_remove(&output->scanout_buffer_destroy_listener.link);
 890                 wl_list_insert(output->scanout_buffer->resource.destroy_listener_list.prev,
 891                                &output->scanout_buffer_destroy_listener.link);
 892
 893                 return;
 894         }
 895
 896         if (es->fullscreen_output == output) {
 897                 if (es->width < output->current->width ||
 898                     es->height < output->current->height)
 899                         glClear(GL_COLOR_BUFFER_BIT);
 900                 wlsc_surface_draw(es, output, &total_damage);
 901         } else {
 902                 wl_list_for_each(es, &ec->surface_list, link) {
 903                         pixman_region32_copy(&es->damage, &total_damage);
 904                         pixman_region32_subtract(&total_damage, &total_damage, &es->opaque);
 905                 }
 906
 907                 wl_list_for_each_reverse(es, &ec->surface_list, link) {
 908                         pixman_region32_init(&repaint);
 909                         pixman_region32_intersect(&repaint, &output->region,
 910                                                   &es->damage);
 911                         wlsc_surface_draw(es, output, &repaint);
 912                         pixman_region32_subtract(&es->damage,
 913                                                  &es->damage, &output->region);
 914                 }
 915         }
 916
 917         if (ec->fade.spring.current > 0.001)
 918                 fade_output(output, ec->fade.spring.current, &total_damage);
 919 }
 920
 921 struct wlsc_frame_callback {
 922         struct wl_resource resource;
 923         struct wl_list link;
 924 };
 925
 926 static void
 927 repaint(void *data, int msecs)
 928 {
 929         struct wlsc_output *output = data;
 930         struct wlsc_compositor *compositor = output->compositor;
 931         struct wlsc_animation *animation, *next;
 932         struct wlsc_frame_callback *cb, *cnext;
 933
 934         wlsc_output_repaint(output);
 935         output->repaint_needed = 0;
 936         output->repaint_scheduled = 1;
 937         output->present(output);
 938
 939         wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
 940                 wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs);
 941                 wl_resource_destroy(&cb->resource, 0);
 942         }
 943
 944         wl_list_for_each_safe(animation, next,
 945                               &compositor->animation_list, link)
 946                 animation->frame(animation, output, msecs);
 947 }
 948
 949 static void
 950 idle_repaint(void *data)
 951 {
 952         repaint(data, wlsc_compositor_get_time());
 953 }
 954
 955 WL_EXPORT void
 956 wlsc_output_finish_frame(struct wlsc_output *output, int msecs)
 957 {
 958         wlsc_buffer_post_release(output->scanout_buffer);
 959         output->scanout_buffer = NULL;
 960         output->repaint_scheduled = 0;
 961
 962         if (output->repaint_needed)
 963                 repaint(output, msecs);
 964 }
 965
 966 WL_EXPORT void
 967 wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor)
 968 {
 969         struct wlsc_output *output;
 970         struct wl_event_loop *loop;
 971
 972         if (compositor->state == WLSC_COMPOSITOR_SLEEPING)
 973                 return;
 974
 975         loop = wl_display_get_event_loop(compositor->wl_display);
 976         wl_list_for_each(output, &compositor->output_list, link) {
 977                 output->repaint_needed = 1;
 978                 if (output->repaint_scheduled)
 979                         continue;
 980
 981                 wl_event_loop_add_idle(loop, idle_repaint, output);
 982                 output->repaint_scheduled = 1;
 983         }
 984 }
 985
 986 WL_EXPORT void
 987 wlsc_compositor_fade(struct wlsc_compositor *compositor, float tint)
 988 {
 989         int done;
 990
 991         done = wlsc_spring_done(&compositor->fade.spring);
 992         compositor->fade.spring.target = tint;
 993         if (wlsc_spring_done(&compositor->fade.spring))
 994                 return;
 995
 996         if (done)
 997                 compositor->fade.spring.timestamp =
 998                         wlsc_compositor_get_time();
 999
1000         wlsc_compositor_damage_all(compositor);
1001         if (wl_list_empty(&compositor->fade.animation.link))
1002                 wl_list_insert(compositor->animation_list.prev,
1003                                &compositor->fade.animation.link);
1004 }
1005
1006 static void
1007 surface_destroy(struct wl_client *client, struct wl_resource *resource)
1008 {
1009         wl_resource_destroy(resource, wlsc_compositor_get_time());
1010 }
1011
1012 WL_EXPORT void
1013 wlsc_surface_assign_output(struct wlsc_surface *es)
1014 {
1015         struct wlsc_compositor *ec = es->compositor;
1016         struct wlsc_output *output;
1017         pixman_region32_t region;
1018         uint32_t max, area;
1019         pixman_box32_t *e;
1020
1021         max = 0;
1022         wl_list_for_each(output, &ec->output_list, link) {
1023                 pixman_region32_init_rect(&region,
1024                                           es->x, es->y, es->width, es->height);
1025                 pixman_region32_intersect(&region, &region, &output->region);
1026
1027                 e = pixman_region32_extents(&region);
1028                 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1029
1030                 if (area >= max) {
1031                         es->output = output;
1032                         max = area;
1033                 }
1034         }
1035 }
1036
1037 static void
1038 surface_attach(struct wl_client *client,
1039                struct wl_resource *resource,
1040                struct wl_resource *buffer_resource, int32_t x, int32_t y)
1041 {
1042         struct wlsc_surface *es = resource->data;
1043         struct wl_buffer *buffer = buffer_resource->data;
1044         int repick = 0;
1045
1046         buffer->busy_count++;
1047         wlsc_buffer_post_release(es->buffer);
1048
1049         es->buffer = buffer;
1050         wl_list_remove(&es->buffer_destroy_listener.link);
1051         wl_list_insert(es->buffer->resource.destroy_listener_list.prev,
1052                        &es->buffer_destroy_listener.link);
1053
1054         if (es->visual == WLSC_NONE_VISUAL) {
1055                 wl_list_insert(&es->compositor->surface_list, &es->link);
1056                 repick = 1;
1057         }
1058
1059         if (x != 0 || y != 0 ||
1060             es->width != buffer->width || es->height != buffer->height) {
1061                 wlsc_surface_configure(es, es->x + x, es->y + y,
1062                                        buffer->width, buffer->height);
1063                 repick = 1;
1064         }
1065
1066         wlsc_buffer_attach(buffer, &es->surface);
1067
1068         es->compositor->shell->attach(es->compositor->shell, es);
1069
1070         if (repick)
1071                 wlsc_compositor_repick(es->compositor);
1072 }
1073
1074 static void
1075 surface_damage(struct wl_client *client,
1076                struct wl_resource *resource,
1077                int32_t x, int32_t y, int32_t width, int32_t height)
1078 {
1079         struct wlsc_surface *es = resource->data;
1080
1081         wlsc_surface_damage_rectangle(es, x, y, width, height);
1082 }
1083
1084 static void
1085 destroy_frame_callback(struct wl_resource *resource)
1086 {
1087         struct wlsc_frame_callback *cb = resource->data;
1088
1089         wl_list_remove(&cb->link);
1090         free(resource);
1091 }
1092
1093 static void
1094 surface_frame(struct wl_client *client,
1095               struct wl_resource *resource, uint32_t callback)
1096 {
1097         struct wlsc_frame_callback *cb;
1098         struct wlsc_surface *es = resource->data;
1099
1100         cb = malloc(sizeof *cb);
1101         if (cb == NULL) {
1102                 wl_resource_post_no_memory(resource);
1103                 return;
1104         }
1105
1106         cb->resource.object.interface = &wl_callback_interface;
1107         cb->resource.object.id = callback;
1108         cb->resource.destroy = destroy_frame_callback;
1109         cb->resource.client = client;
1110         cb->resource.data = cb;
1111
1112         wl_client_add_resource(client, &cb->resource);
1113
1114         if (es->output) {
1115                 wl_list_insert(es->output->frame_callback_list.prev,
1116                                &cb->link);
1117         } else {
1118                 wl_list_init(&cb->link);
1119                 wl_resource_destroy(&cb->resource, 0);
1120         }
1121 }
1122
1123 const static struct wl_surface_interface surface_interface = {
1124         surface_destroy,
1125         surface_attach,
1126         surface_damage,
1127         surface_frame
1128 };
1129
1130 static void
1131 wlsc_input_device_attach(struct wlsc_input_device *device,
1132                          int x, int y, int width, int height)
1133 {
1134         wlsc_surface_damage_below(device->sprite);
1135
1136         device->hotspot_x = x;
1137         device->hotspot_y = y;
1138
1139         device->sprite->x = device->input_device.x - device->hotspot_x;
1140         device->sprite->y = device->input_device.y - device->hotspot_y;
1141         device->sprite->width = width;
1142         device->sprite->height = height;
1143
1144         wlsc_surface_damage(device->sprite);
1145 }
1146
1147 static void
1148 wlsc_input_device_attach_buffer(struct wlsc_input_device *device,
1149                                 struct wl_buffer *buffer, int x, int y)
1150 {
1151         wlsc_buffer_attach(buffer, &device->sprite->surface);
1152         wlsc_input_device_attach(device, x, y, buffer->width, buffer->height);
1153 }
1154
1155 static void
1156 wlsc_input_device_attach_sprite(struct wlsc_input_device *device,
1157                                 struct wlsc_sprite *sprite, int x, int y)
1158 {
1159         wlsc_sprite_attach(sprite, &device->sprite->surface);
1160         wlsc_input_device_attach(device, x, y, sprite->width, sprite->height);
1161 }
1162
1163 WL_EXPORT void
1164 wlsc_input_device_set_pointer_image(struct wlsc_input_device *device,
1165                                     enum wlsc_pointer_type type)
1166 {
1167         struct wlsc_compositor *compositor =
1168                 (struct wlsc_compositor *) device->input_device.compositor;
1169
1170         wlsc_input_device_attach_sprite(device,
1171                                         compositor->pointer_sprites[type],
1172                                         pointer_images[type].hotspot_x,
1173                                         pointer_images[type].hotspot_y);
1174 }
1175
1176 static void
1177 compositor_create_surface(struct wl_client *client,
1178                           struct wl_resource *resource, uint32_t id)
1179 {
1180         struct wlsc_compositor *ec = resource->data;
1181         struct wlsc_surface *surface;
1182
1183         surface = wlsc_surface_create(ec, 0, 0, 0, 0);
1184         if (surface == NULL) {
1185                 wl_resource_post_no_memory(resource);
1186                 return;
1187         }
1188
1189         surface->surface.resource.destroy = destroy_surface;
1190
1191         surface->surface.resource.object.id = id;
1192         surface->surface.resource.object.interface = &wl_surface_interface;
1193         surface->surface.resource.object.implementation =
1194                 (void (**)(void)) &surface_interface;
1195         surface->surface.resource.data = surface;
1196
1197         wl_client_add_resource(client, &surface->surface.resource);
1198 }
1199
1200 const static struct wl_compositor_interface compositor_interface = {
1201         compositor_create_surface,
1202 };
1203
1204 static void
1205 wlsc_surface_transform(struct wlsc_surface *surface,
1206                        int32_t x, int32_t y, int32_t *sx, int32_t *sy)
1207 {
1208         *sx = x - surface->x;
1209         *sy = y - surface->y;
1210 }
1211
1212 WL_EXPORT struct wlsc_surface *
1213 pick_surface(struct wl_input_device *device, int32_t *sx, int32_t *sy)
1214 {
1215         struct wlsc_compositor *ec =
1216                 (struct wlsc_compositor *) device->compositor;
1217         struct wlsc_surface *es;
1218
1219         wl_list_for_each(es, &ec->surface_list, link) {
1220                 if (es->surface.resource.client == NULL)
1221                         continue;
1222                 wlsc_surface_transform(es, device->x, device->y, sx, sy);
1223                 if (0 <= *sx && *sx < es->width &&
1224                     0 <= *sy && *sy < es->height)
1225                         return es;
1226         }
1227
1228         return NULL;
1229 }
1230
1231
1232 static void
1233 implicit_grab_motion(struct wl_grab *grab,
1234                      uint32_t time, int32_t x, int32_t y)
1235 {
1236         struct wlsc_input_device *device =
1237                 (struct wlsc_input_device *) grab->input_device;
1238         struct wlsc_surface *es =
1239                 (struct wlsc_surface *) device->input_device.pointer_focus;
1240         int32_t sx, sy;
1241         struct wl_resource *resource;
1242
1243         resource = grab->input_device->pointer_focus_resource;
1244         if (resource) {
1245                 wlsc_surface_transform(es, x, y, &sx, &sy);
1246                 wl_resource_post_event(resource, WL_INPUT_DEVICE_MOTION,
1247                                        time, x, y, sx, sy);
1248         }
1249 }
1250
1251 static void
1252 implicit_grab_button(struct wl_grab *grab,
1253                      uint32_t time, int32_t button, int32_t state)
1254 {
1255         struct wl_resource *resource;
1256
1257         resource = grab->input_device->pointer_focus_resource;
1258         if (resource)
1259                 wl_resource_post_event(resource, WL_INPUT_DEVICE_BUTTON,
1260                                        time, button, state);
1261 }
1262
1263 static void
1264 implicit_grab_end(struct wl_grab *grab, uint32_t time)
1265 {
1266 }
1267
1268 static const struct wl_grab_interface implicit_grab_interface = {
1269         implicit_grab_motion,
1270         implicit_grab_button,
1271         implicit_grab_end
1272 };
1273
1274 WL_EXPORT void
1275 wlsc_compositor_wake(struct wlsc_compositor *compositor)
1276 {
1277         if (compositor->idle_inhibit)
1278                 return;
1279
1280         wlsc_compositor_fade(compositor, 0.0);
1281         compositor->state = WLSC_COMPOSITOR_ACTIVE;
1282
1283         wl_event_source_timer_update(compositor->idle_source,
1284                                      option_idle_time * 1000);
1285 }
1286
1287 static void
1288 wlsc_compositor_idle_inhibit(struct wlsc_compositor *compositor)
1289 {
1290         wlsc_compositor_wake(compositor);
1291         compositor->idle_inhibit++;
1292 }
1293
1294 static void
1295 wlsc_compositor_idle_release(struct wlsc_compositor *compositor)
1296 {
1297         compositor->idle_inhibit--;
1298         wlsc_compositor_wake(compositor);
1299 }
1300
1301 static int
1302 idle_handler(void *data)
1303 {
1304         struct wlsc_compositor *compositor = data;
1305
1306         if (compositor->idle_inhibit)
1307                 return 1;
1308
1309         wlsc_compositor_fade(compositor, 1.0);
1310
1311         return 1;
1312 }
1313
1314 WL_EXPORT void
1315 notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
1316 {
1317         struct wlsc_surface *es;
1318         struct wlsc_compositor *ec =
1319                 (struct wlsc_compositor *) device->compositor;
1320         struct wlsc_output *output;
1321         const struct wl_grab_interface *interface;
1322         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1323         int32_t sx, sy;
1324         int x_valid = 0, y_valid = 0;
1325         int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN;
1326
1327         wlsc_compositor_wake(ec);
1328
1329         wl_list_for_each(output, &ec->output_list, link) {
1330                 if (output->x <= x && x <= output->x + output->current->width)
1331                         x_valid = 1;
1332
1333                 if (output->y <= y && y <= output->y + output->current->height)
1334                         y_valid = 1;
1335
1336                 /* FIXME: calculate this only on output addition/deletion */
1337                 if (output->x < min_x)
1338                         min_x = output->x;
1339                 if (output->y < min_y)
1340                         min_y = output->y;
1341
1342                 if (output->x + output->current->width > max_x)
1343                         max_x = output->x + output->current->width;
1344                 if (output->y + output->current->height > max_y)
1345                         max_y = output->y + output->current->height;
1346         }
1347
1348         if (!x_valid) {
1349                 if (x < min_x)
1350                         x = min_x;
1351                 else if (x >= max_x)
1352                         x = max_x;
1353         }
1354         if (!y_valid) {
1355                 if (y < min_y)
1356                         y = min_y;
1357                 else  if (y >= max_y)
1358                         y = max_y;
1359         }
1360
1361         device->x = x;
1362         device->y = y;
1363
1364         if (device->grab) {
1365                 interface = device->grab->interface;
1366                 interface->motion(device->grab, time, x, y);
1367         } else {
1368                 es = pick_surface(device, &sx, &sy);
1369                 wl_input_device_set_pointer_focus(device,
1370                                                   &es->surface,
1371                                                   time, x, y, sx, sy);
1372                 if (device->pointer_focus_resource)
1373                         wl_resource_post_event(device->pointer_focus_resource,
1374                                                WL_INPUT_DEVICE_MOTION,
1375                                                time, x, y, sx, sy);
1376         }
1377
1378         wlsc_surface_damage_below(wd->sprite);
1379
1380         wd->sprite->x = device->x - wd->hotspot_x;
1381         wd->sprite->y = device->y - wd->hotspot_y;
1382
1383         wlsc_surface_damage(wd->sprite);
1384 }
1385
1386 WL_EXPORT void
1387 wlsc_surface_activate(struct wlsc_surface *surface,
1388                       struct wlsc_input_device *device, uint32_t time)
1389 {
1390         struct wlsc_shell *shell = surface->compositor->shell;
1391
1392         wlsc_surface_raise(surface);
1393         if (device->selection)
1394                 shell->set_selection_focus(shell,
1395                                            device->selection,
1396                                            &surface->surface, time);
1397
1398         wl_input_device_set_keyboard_focus(&device->input_device,
1399                                            &surface->surface,
1400                                            time);
1401 }
1402
1403 struct wlsc_binding {
1404         uint32_t key;
1405         uint32_t button;
1406         uint32_t modifier;
1407         wlsc_binding_handler_t handler;
1408         void *data;
1409         struct wl_list link;
1410 };
1411
1412 WL_EXPORT void
1413 notify_button(struct wl_input_device *device,
1414               uint32_t time, int32_t button, int32_t state)
1415 {
1416         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1417         struct wlsc_compositor *compositor =
1418                 (struct wlsc_compositor *) device->compositor;
1419         struct wlsc_binding *b;
1420         struct wlsc_surface *surface =
1421                 (struct wlsc_surface *) device->pointer_focus;
1422         int32_t sx, sy;
1423
1424         if (state)
1425                 wlsc_compositor_idle_inhibit(compositor);
1426         else
1427                 wlsc_compositor_idle_release(compositor);
1428
1429         if (state && surface && device->grab == NULL) {
1430                 compositor->shell->activate(compositor->shell,
1431                                             surface, wd, time);
1432                 wl_input_device_start_grab(device,
1433                                            &device->implicit_grab,
1434                                            button, time);
1435         }
1436
1437         wl_list_for_each(b, &compositor->binding_list, link) {
1438                 if (b->button == button &&
1439                     b->modifier == wd->modifier_state && state) {
1440                         b->handler(&wd->input_device,
1441                                    time, 0, button, state, b->data);
1442                         break;
1443                 }
1444         }
1445
1446         if (device->grab)
1447                 device->grab->interface->button(device->grab, time,
1448                                                 button, state);
1449
1450         if (!state && device->grab && device->grab_button == button) {
1451                 wl_input_device_end_grab(device, time);
1452                 surface = pick_surface(device, &sx, &sy);
1453                 wl_input_device_set_pointer_focus(device, &surface->surface,
1454                                                   time, device->x, device->y,
1455                                                   sx, sy);
1456         }
1457 }
1458
1459 static void
1460 terminate_binding(struct wl_input_device *device, uint32_t time,
1461                   uint32_t key, uint32_t button, uint32_t state, void *data)
1462 {
1463         struct wlsc_compositor *compositor = data;
1464
1465         if (state)
1466                 wl_display_terminate(compositor->wl_display);
1467 }
1468
1469 WL_EXPORT struct wlsc_binding *
1470 wlsc_compositor_add_binding(struct wlsc_compositor *compositor,
1471                             uint32_t key, uint32_t button, uint32_t modifier,
1472                             wlsc_binding_handler_t handler, void *data)
1473 {
1474         struct wlsc_binding *binding;
1475
1476         binding = malloc(sizeof *binding);
1477         if (binding == NULL)
1478                 return NULL;
1479
1480         binding->key = key;
1481         binding->button = button;
1482         binding->modifier = modifier;
1483         binding->handler = handler;
1484         binding->data = data;
1485         wl_list_insert(compositor->binding_list.prev, &binding->link);
1486
1487         return binding;
1488 }
1489
1490 WL_EXPORT void
1491 wlsc_binding_destroy(struct wlsc_binding *binding)
1492 {
1493         wl_list_remove(&binding->link);
1494         free(binding);
1495 }
1496
1497 static void
1498 update_modifier_state(struct wlsc_input_device *device,
1499                       uint32_t key, uint32_t state)
1500 {
1501         uint32_t modifier;
1502
1503         switch (key) {
1504         case KEY_LEFTCTRL:
1505         case KEY_RIGHTCTRL:
1506                 modifier = MODIFIER_CTRL;
1507                 break;
1508
1509         case KEY_LEFTALT:
1510         case KEY_RIGHTALT:
1511                 modifier = MODIFIER_ALT;
1512                 break;
1513
1514         case KEY_LEFTMETA:
1515         case KEY_RIGHTMETA:
1516                 modifier = MODIFIER_SUPER;
1517                 break;
1518
1519         default:
1520                 modifier = 0;
1521                 break;
1522         }
1523
1524         if (state)
1525                 device->modifier_state |= modifier;
1526         else
1527                 device->modifier_state &= ~modifier;
1528 }
1529
1530 WL_EXPORT void
1531 notify_key(struct wl_input_device *device,
1532            uint32_t time, uint32_t key, uint32_t state)
1533 {
1534         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1535         struct wlsc_compositor *compositor =
1536                 (struct wlsc_compositor *) device->compositor;
1537         uint32_t *k, *end;
1538         struct wlsc_binding *b;
1539
1540         if (state)
1541                 wlsc_compositor_idle_inhibit(compositor);
1542         else
1543                 wlsc_compositor_idle_release(compositor);
1544
1545         wl_list_for_each(b, &compositor->binding_list, link) {
1546                 if (b->key == key &&
1547                     b->modifier == wd->modifier_state) {
1548                         b->handler(&wd->input_device,
1549                                    time, key, 0, state, b->data);
1550                         break;
1551                 }
1552         }
1553
1554         update_modifier_state(wd, key, state);
1555         end = device->keys.data + device->keys.size;
1556         for (k = device->keys.data; k < end; k++) {
1557                 if (*k == key)
1558                         *k = *--end;
1559         }
1560         device->keys.size = (void *) end - device->keys.data;
1561         if (state) {
1562                 k = wl_array_add(&device->keys, sizeof *k);
1563                 *k = key;
1564         }
1565
1566         if (device->keyboard_focus_resource)
1567                 wl_resource_post_event(device->keyboard_focus_resource,
1568                                        WL_INPUT_DEVICE_KEY, time, key, state);
1569 }
1570
1571 WL_EXPORT void
1572 notify_pointer_focus(struct wl_input_device *device,
1573                      uint32_t time, struct wlsc_output *output,
1574                      int32_t x, int32_t y)
1575 {
1576         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1577         struct wlsc_compositor *compositor =
1578                 (struct wlsc_compositor *) device->compositor;
1579         struct wlsc_surface *es;
1580         int32_t sx, sy;
1581
1582         if (output) {
1583                 device->x = x;
1584                 device->y = y;
1585                 es = pick_surface(device, &sx, &sy);
1586                 wl_input_device_set_pointer_focus(device,
1587                                                   &es->surface,
1588                                                   time, x, y, sx, sy);
1589
1590                 compositor->focus = 1;
1591
1592                 wd->sprite->x = device->x - wd->hotspot_x;
1593                 wd->sprite->y = device->y - wd->hotspot_y;
1594         } else {
1595                 wl_input_device_set_pointer_focus(device, NULL,
1596                                                   time, 0, 0, 0, 0);
1597                 compositor->focus = 0;
1598         }
1599
1600         wlsc_surface_damage(wd->sprite);
1601 }
1602
1603 WL_EXPORT void
1604 notify_keyboard_focus(struct wl_input_device *device,
1605                       uint32_t time, struct wlsc_output *output,
1606                       struct wl_array *keys)
1607 {
1608         struct wlsc_input_device *wd =
1609                 (struct wlsc_input_device *) device;
1610         struct wlsc_compositor *compositor =
1611                 (struct wlsc_compositor *) device->compositor;
1612         struct wlsc_surface *es;
1613         uint32_t *k, *end;
1614
1615         if (!wl_list_empty(&compositor->surface_list))
1616                 es = container_of(compositor->surface_list.next,
1617                                   struct wlsc_surface, link);
1618         else
1619                 es = NULL;
1620
1621         if (output) {
1622                 wl_array_copy(&wd->input_device.keys, keys);
1623                 wd->modifier_state = 0;
1624                 end = device->keys.data + device->keys.size;
1625                 for (k = device->keys.data; k < end; k++) {
1626                         wlsc_compositor_idle_inhibit(compositor);
1627                         update_modifier_state(wd, *k, 1);
1628                 }
1629
1630                 if (es && es->surface.resource.client)
1631                         wl_input_device_set_keyboard_focus(&wd->input_device,
1632                                                            &es->surface, time);
1633         } else {
1634                 end = device->keys.data + device->keys.size;
1635                 for (k = device->keys.data; k < end; k++)
1636                         wlsc_compositor_idle_release(compositor);
1637
1638                 wd->modifier_state = 0;
1639                 wl_input_device_set_keyboard_focus(&wd->input_device,
1640                                                    NULL, time);
1641         }
1642 }
1643
1644
1645 static void
1646 input_device_attach(struct wl_client *client,
1647                     struct wl_resource *resource,
1648                     uint32_t time,
1649                     struct wl_resource *buffer_resource, int32_t x, int32_t y)
1650 {
1651         struct wlsc_input_device *device = resource->data;
1652         struct wl_buffer *buffer;
1653
1654         if (time < device->input_device.pointer_focus_time)
1655                 return;
1656         if (device->input_device.pointer_focus == NULL)
1657                 return;
1658         if (device->input_device.pointer_focus->resource.client != client)
1659                 return;
1660
1661         if (buffer_resource) {
1662                 buffer = buffer_resource->data;
1663                 wlsc_input_device_attach_buffer(device, buffer, x, y);
1664         } else {
1665                 wlsc_input_device_set_pointer_image(device,
1666                                                     WLSC_POINTER_LEFT_PTR);
1667                 return;
1668         }
1669 }
1670
1671 const static struct wl_input_device_interface input_device_interface = {
1672         input_device_attach,
1673 };
1674
1675 static void unbind_input_device(struct wl_resource *resource)
1676 {
1677         wl_list_remove(&resource->link);
1678         free(resource);
1679 }
1680
1681 static void
1682 bind_input_device(struct wl_client *client,
1683                   void *data, uint32_t version, uint32_t id)
1684 {
1685         struct wl_input_device *device = data;
1686         struct wl_resource *resource;
1687
1688         resource = wl_client_add_object(client, &wl_input_device_interface,
1689                                         &input_device_interface, id, data);
1690         wl_list_insert(&device->resource_list, &resource->link);
1691         resource->destroy = unbind_input_device;
1692 }
1693
1694 WL_EXPORT void
1695 wlsc_input_device_init(struct wlsc_input_device *device,
1696                        struct wlsc_compositor *ec)
1697 {
1698         wl_input_device_init(&device->input_device, &ec->compositor);
1699
1700         wl_display_add_global(ec->wl_display, &wl_input_device_interface,
1701                               device, bind_input_device);
1702
1703         device->sprite = wlsc_surface_create(ec,
1704                                              device->input_device.x,
1705                                              device->input_device.y, 32, 32);
1706         wl_list_insert(&ec->surface_list, &device->sprite->link);
1707
1708         device->hotspot_x = 16;
1709         device->hotspot_y = 16;
1710         device->modifier_state = 0;
1711
1712         device->input_device.implicit_grab.interface = &implicit_grab_interface;
1713
1714         wl_list_insert(ec->input_device_list.prev, &device->link);
1715
1716         wlsc_input_device_set_pointer_image(device, WLSC_POINTER_LEFT_PTR);
1717 }
1718
1719 static void
1720 bind_output(struct wl_client *client,
1721             void *data, uint32_t version, uint32_t id)
1722 {
1723         struct wlsc_output *output = data;
1724         struct wlsc_mode *mode;
1725         struct wl_resource *resource;
1726
1727         resource = wl_client_add_object(client,
1728                                         &wl_output_interface, NULL, id, data);
1729
1730         wl_resource_post_event(resource,
1731                                WL_OUTPUT_GEOMETRY,
1732                                output->x,
1733                                output->y,
1734                                output->mm_width,
1735                                output->mm_height,
1736                                output->subpixel,
1737                                output->make, output->model);
1738
1739         wl_list_for_each (mode, &output->mode_list, link) {
1740                 wl_resource_post_event(resource,
1741                                        WL_OUTPUT_MODE,
1742                                        mode->flags,
1743                                        mode->width,
1744                                        mode->height,
1745                                        mode->refresh);
1746         }
1747 }
1748
1749 static const char vertex_shader[] =
1750         "uniform mat4 proj;\n"
1751         "attribute vec2 position;\n"
1752         "attribute vec2 texcoord;\n"
1753         "varying vec2 v_texcoord;\n"
1754         "void main()\n"
1755         "{\n"
1756         "   gl_Position = proj * vec4(position, 0.0, 1.0);\n"
1757         "   v_texcoord = texcoord;\n"
1758         "}\n";
1759
1760 static const char texture_fragment_shader[] =
1761         "precision mediump float;\n"
1762         "varying vec2 v_texcoord;\n"
1763         "uniform sampler2D tex;\n"
1764         "void main()\n"
1765         "{\n"
1766         "   gl_FragColor = texture2D(tex, v_texcoord)\n;"
1767         "}\n";
1768
1769 static const char solid_fragment_shader[] =
1770         "precision mediump float;\n"
1771         "uniform vec4 color;\n"
1772         "void main()\n"
1773         "{\n"
1774         "   gl_FragColor = color\n;"
1775         "}\n";
1776
1777 static int
1778 compile_shader(GLenum type, const char *source)
1779 {
1780         GLuint s;
1781         char msg[512];
1782         GLint status;
1783
1784         s = glCreateShader(type);
1785         glShaderSource(s, 1, &source, NULL);
1786         glCompileShader(s);
1787         glGetShaderiv(s, GL_COMPILE_STATUS, &status);
1788         if (!status) {
1789                 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
1790                 fprintf(stderr, "shader info: %s\n", msg);
1791                 return GL_NONE;
1792         }
1793
1794         return s;
1795 }
1796
1797 static int
1798 wlsc_shader_init(struct wlsc_shader *shader,
1799                  const char *vertex_source, const char *fragment_source)
1800 {
1801         char msg[512];
1802         GLint status;
1803
1804         shader->vertex_shader =
1805                 compile_shader(GL_VERTEX_SHADER, vertex_source);
1806         shader->fragment_shader =
1807                 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1808
1809         shader->program = glCreateProgram();
1810         glAttachShader(shader->program, shader->vertex_shader);
1811         glAttachShader(shader->program, shader->fragment_shader);
1812         glBindAttribLocation(shader->program, 0, "position");
1813         glBindAttribLocation(shader->program, 1, "texcoord");
1814
1815         glLinkProgram(shader->program);
1816         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
1817         if (!status) {
1818                 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
1819                 fprintf(stderr, "link info: %s\n", msg);
1820                 return -1;
1821         }
1822
1823         shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1824         shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
1825
1826         return 0;
1827 }
1828
1829 static int
1830 init_solid_shader(struct wlsc_shader *shader,
1831                   GLuint vertex_shader, const char *fragment_source)
1832 {
1833         GLint status;
1834         char msg[512];
1835
1836         shader->vertex_shader = vertex_shader;
1837         shader->fragment_shader =
1838                 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1839
1840         shader->program = glCreateProgram();
1841         glAttachShader(shader->program, shader->vertex_shader);
1842         glAttachShader(shader->program, shader->fragment_shader);
1843         glBindAttribLocation(shader->program, 0, "position");
1844         glBindAttribLocation(shader->program, 1, "texcoord");
1845
1846         glLinkProgram(shader->program);
1847         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
1848         if (!status) {
1849                 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
1850                 fprintf(stderr, "link info: %s\n", msg);
1851                 return -1;
1852         }
1853
1854         shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1855         shader->color_uniform = glGetUniformLocation(shader->program, "color");
1856
1857         return 0;
1858 }
1859
1860 WL_EXPORT void
1861 wlsc_output_destroy(struct wlsc_output *output)
1862 {
1863         pixman_region32_fini(&output->region);
1864         pixman_region32_fini(&output->previous_damage);
1865 }
1866
1867 WL_EXPORT void
1868 wlsc_output_move(struct wlsc_output *output, int x, int y)
1869 {
1870         struct wlsc_compositor *c = output->compositor;
1871         int flip;
1872
1873         output->x = x;
1874         output->y = y;
1875
1876         pixman_region32_init(&output->previous_damage);
1877         pixman_region32_init_rect(&output->region, x, y,
1878                                   output->current->width,
1879                                   output->current->height);
1880
1881         wlsc_matrix_init(&output->matrix);
1882         wlsc_matrix_translate(&output->matrix,
1883                               -output->x - output->current->width / 2.0,
1884                               -output->y - output->current->height / 2.0, 0);
1885
1886         flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
1887         wlsc_matrix_scale(&output->matrix,
1888                           2.0 / output->current->width,
1889                           flip * 2.0 / output->current->height, 1);
1890
1891         pixman_region32_union(&c->damage, &c->damage, &output->region);
1892 }
1893
1894 WL_EXPORT void
1895 wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c,
1896                  int x, int y, int width, int height, uint32_t flags)
1897 {
1898         output->compositor = c;
1899         output->x = x;
1900         output->y = y;
1901         output->mm_width = width;
1902         output->mm_height = height;
1903
1904         output->flags = flags;
1905         wlsc_output_move(output, x, y);
1906
1907         output->scanout_buffer_destroy_listener.func =
1908                 output_handle_scanout_buffer_destroy;
1909         wl_list_init(&output->scanout_buffer_destroy_listener.link);
1910         wl_list_init(&output->frame_callback_list);
1911
1912         output->resource.object.interface = &wl_output_interface;
1913         wl_display_add_global(c->wl_display,
1914                               &wl_output_interface, output, bind_output);
1915 }
1916
1917 static void
1918 shm_buffer_created(struct wl_buffer *buffer)
1919 {
1920         struct wl_list *surfaces_attached_to;
1921
1922         surfaces_attached_to = malloc(sizeof *surfaces_attached_to);
1923         if (!surfaces_attached_to) {
1924                 buffer->user_data = NULL;
1925                 return;
1926         }
1927
1928         wl_list_init(surfaces_attached_to);
1929
1930         buffer->user_data = surfaces_attached_to;
1931 }
1932
1933 static void
1934 shm_buffer_damaged(struct wl_buffer *buffer,
1935                    int32_t x, int32_t y, int32_t width, int32_t height)
1936 {
1937         struct wl_list *surfaces_attached_to = buffer->user_data;
1938         struct wlsc_surface *es;
1939         GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4;
1940
1941         wl_list_for_each(es, surfaces_attached_to, buffer_link) {
1942                 glBindTexture(GL_TEXTURE_2D, es->texture);
1943                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1944                              tex_width, buffer->height, 0,
1945                              GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1946                              wl_shm_buffer_get_data(buffer));
1947                 /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't
1948                  * support any unpack attributes except GL_UNPACK_ALIGNMENT. */
1949         }
1950 }
1951
1952 static void
1953 shm_buffer_destroyed(struct wl_buffer *buffer)
1954 {
1955         struct wl_list *surfaces_attached_to = buffer->user_data;
1956         struct wlsc_surface *es, *next;
1957
1958         wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) {
1959                 wl_list_remove(&es->buffer_link);
1960                 wl_list_init(&es->buffer_link);
1961         }
1962
1963         free(surfaces_attached_to);
1964 }
1965
1966 const static struct wl_shm_callbacks shm_callbacks = {
1967         shm_buffer_created,
1968         shm_buffer_damaged,
1969         shm_buffer_destroyed
1970 };
1971
1972 WL_EXPORT int
1973 wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display)
1974 {
1975         struct wl_event_loop *loop;
1976         const char *extensions;
1977
1978         ec->wl_display = display;
1979
1980         wl_compositor_init(&ec->compositor, &compositor_interface, display);
1981
1982         ec->shm = wl_shm_init(display, &shm_callbacks);
1983
1984         ec->image_target_texture_2d =
1985                 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
1986         ec->image_target_renderbuffer_storage = (void *)
1987                 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
1988         ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
1989         ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
1990         ec->bind_display =
1991                 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
1992         ec->unbind_display =
1993                 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
1994
1995         extensions = (const char *) glGetString(GL_EXTENSIONS);
1996         if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
1997                 fprintf(stderr,
1998                         "GL_EXT_texture_format_BGRA8888 not available\n");
1999                 return -1;
2000         }
2001
2002         extensions =
2003                 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2004         if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2005                 ec->has_bind_display = 1;
2006         if (ec->has_bind_display)
2007                 ec->bind_display(ec->display, ec->wl_display);
2008
2009         wl_list_init(&ec->surface_list);
2010         wl_list_init(&ec->input_device_list);
2011         wl_list_init(&ec->output_list);
2012         wl_list_init(&ec->binding_list);
2013         wl_list_init(&ec->animation_list);
2014         wlsc_spring_init(&ec->fade.spring, 0.8, 0.0, 0.0);
2015         ec->fade.animation.frame = fade_frame;
2016         wl_list_init(&ec->fade.animation.link);
2017
2018         wlsc_compositor_add_binding(ec, KEY_BACKSPACE, 0,
2019                                     MODIFIER_CTRL | MODIFIER_ALT,
2020                                     terminate_binding, ec);
2021
2022         create_pointer_images(ec);
2023
2024         screenshooter_create(ec);
2025
2026         glActiveTexture(GL_TEXTURE0);
2027
2028         if (wlsc_shader_init(&ec->texture_shader,
2029                              vertex_shader, texture_fragment_shader) < 0)
2030                 return -1;
2031         if (init_solid_shader(&ec->solid_shader,
2032                               ec->texture_shader.vertex_shader,
2033                               solid_fragment_shader) < 0)
2034                 return -1;
2035
2036         loop = wl_display_get_event_loop(ec->wl_display);
2037         ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
2038         wl_event_source_timer_update(ec->idle_source, option_idle_time * 1000);
2039
2040         pixman_region32_init(&ec->damage);
2041         wlsc_compositor_schedule_repaint(ec);
2042
2043         return 0;
2044 }
2045
2046 WL_EXPORT void
2047 wlsc_compositor_shutdown(struct wlsc_compositor *ec)
2048 {
2049         struct wlsc_output *output;
2050
2051         /* Destroy all outputs associated with this compositor */
2052         wl_list_for_each(output, &ec->output_list, link)
2053                 output->destroy(output);
2054 }
2055
2056 static int on_term_signal(int signal_number, void *data)
2057 {
2058         struct wl_display *display = data;
2059
2060         fprintf(stderr, "caught signal %d\n", signal_number);
2061         wl_display_terminate(display);
2062
2063         return 1;
2064 }
2065
2066 static void *
2067 load_module(const char *name, const char *entrypoint, void **handle)
2068 {
2069         char path[PATH_MAX];
2070         void *module, *init;
2071
2072         if (name[0] != '/')
2073                 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2074         else
2075                 snprintf(path, sizeof path, "%s", name);
2076
2077         module = dlopen(path, RTLD_LAZY);
2078         if (!module) {
2079                 fprintf(stderr,
2080                         "failed to load module: %s\n", dlerror());
2081                 return NULL;
2082         }
2083
2084         init = dlsym(module, entrypoint);
2085         if (!init) {
2086                 fprintf(stderr,
2087                         "failed to lookup init function: %s\n", dlerror());
2088                 return NULL;
2089         }
2090
2091         return init;
2092 }
2093
2094 int main(int argc, char *argv[])
2095 {
2096         struct wl_display *display;
2097         struct wlsc_compositor *ec;
2098         struct wl_event_loop *loop;
2099         int o, xserver = 0;
2100         void *shell_module, *backend_module;
2101         int (*shell_init)(struct wlsc_compositor *ec);
2102         struct wlsc_compositor
2103                 *(*backend_init)(struct wl_display *display, char *options);
2104         char *backend = NULL;
2105         char *backend_options = "";
2106         char *shell = NULL;
2107         char *p;
2108
2109         static const char opts[] = "B:b:o:S:i:s:x";
2110         static const struct option longopts[ ] = {
2111                 { "backend", 1, NULL, 'B' },
2112                 { "backend-options", 1, NULL, 'o' },
2113                 { "socket", 1, NULL, 'S' },
2114                 { "idle-time", 1, NULL, 'i' },
2115                 { "shell", 1, NULL, 's' },
2116                 { "xserver", 0, NULL, 'x' },
2117                 { NULL, }
2118         };
2119
2120         while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
2121                 switch (o) {
2122                 case 'B':
2123                         backend = optarg;
2124                         break;
2125                 case 'o':
2126                         backend_options = optarg;
2127                         break;
2128                 case 'S':
2129                         option_socket_name = optarg;
2130                         break;
2131                 case 'i':
2132                         option_idle_time = strtol(optarg, &p, 0);
2133                         if (*p != '\0') {
2134                                 fprintf(stderr,
2135                                         "invalid idle time option: %s\n",
2136                                         optarg);
2137                                 exit(EXIT_FAILURE);
2138                         }
2139                         break;
2140                 case 's':
2141                         shell = optarg;
2142                         break;
2143                 case 'x':
2144                         xserver = 1;
2145                         break;
2146                 }
2147         }
2148
2149         display = wl_display_create();
2150
2151         loop = wl_display_get_event_loop(display);
2152         wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, display);
2153         wl_event_loop_add_signal(loop, SIGINT, on_term_signal, display);
2154         wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal, display);
2155
2156         wl_list_init(&child_process_list);
2157         wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler, NULL);
2158
2159         if (!backend) {
2160                 if (getenv("WAYLAND_DISPLAY"))
2161                         backend = "wayland-backend.so";
2162                 else if (getenv("DISPLAY"))
2163                         backend = "x11-backend.so";
2164                 else if (getenv("OPENWFD"))
2165                         backend = "openwfd-backend.so";
2166                 else
2167                         backend = "drm-backend.so";
2168         }
2169
2170         if (!shell)
2171                 shell = "desktop-shell.so";
2172
2173         backend_init = load_module(backend, "backend_init", &backend_module);
2174         if (!backend_init)
2175                 exit(EXIT_FAILURE);
2176
2177         shell_init = load_module(shell, "shell_init", &shell_module);
2178         if (!shell_init)
2179                 exit(EXIT_FAILURE);
2180
2181         ec = backend_init(display, backend_options);
2182         if (ec == NULL) {
2183                 fprintf(stderr, "failed to create compositor\n");
2184                 exit(EXIT_FAILURE);
2185         }
2186
2187         if (shell_init(ec) < 0)
2188                 exit(EXIT_FAILURE);
2189
2190         if (xserver)
2191                 wlsc_xserver_init(ec);
2192
2193         if (wl_display_add_socket(display, option_socket_name)) {
2194                 fprintf(stderr, "failed to add socket: %m\n");
2195                 exit(EXIT_FAILURE);
2196         }
2197
2198         wl_display_run(display);
2199
2200         if (xserver)
2201                 wlsc_xserver_destroy(ec);
2202
2203         if (ec->has_bind_display)
2204                 ec->unbind_display(ec->display, display);
2205         wl_display_destroy(display);
2206
2207         ec->destroy(ec);
2208
2209         return 0;
2210 }