compositor/compositor.c

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