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