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 <gdk-pixbuf/gdk-pixbuf.h>
  33 #include <math.h>
  34 #include <linux/input.h>
  35
  36 #include "wayland-server.h"
  37 #include "compositor.h"
  38
  39 /* The plan here is to generate a random anonymous socket name and
  40  * advertise that through a service on the session dbus.
  41  */
  42 static const char *option_socket_name = NULL;
  43 static const char *option_background = "background.jpg";
  44 static const char *option_geometry = "1024x640";
  45 static int option_connector = 0;
  46
  47 static const GOptionEntry option_entries[] = {
  48         { "background", 'b', 0, G_OPTION_ARG_STRING,
  49           &option_background, "Background image" },
  50         { "connector", 'c', 0, G_OPTION_ARG_INT,
  51           &option_connector, "KMS connector" },
  52         { "geometry", 'g', 0, G_OPTION_ARG_STRING,
  53           &option_geometry, "Geometry" },
  54         { "socket", 's', 0, G_OPTION_ARG_STRING,
  55           &option_socket_name, "Socket Name" },
  56         { NULL }
  57 };
  58
  59 static void
  60 wlsc_matrix_init(struct wlsc_matrix *matrix)
  61 {
  62         static const struct wlsc_matrix identity = {
  63                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1 }
  64         };
  65
  66         memcpy(matrix, &identity, sizeof identity);
  67 }
  68
  69 static void
  70 wlsc_matrix_multiply(struct wlsc_matrix *m, const struct wlsc_matrix *n)
  71 {
  72         struct wlsc_matrix tmp;
  73         const GLfloat *row, *column;
  74         div_t d;
  75         int i, j;
  76
  77         for (i = 0; i < 16; i++) {
  78                 tmp.d[i] = 0;
  79                 d = div(i, 4);
  80                 row = m->d + d.quot * 4;
  81                 column = n->d + d.rem;
  82                 for (j = 0; j < 4; j++)
  83                         tmp.d[i] += row[j] * column[j * 4];
  84         }
  85         memcpy(m, &tmp, sizeof tmp);
  86 }
  87
  88 static void
  89 wlsc_matrix_translate(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
  90 {
  91         struct wlsc_matrix translate = {
  92                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 }
  93         };
  94
  95         wlsc_matrix_multiply(matrix, &translate);
  96 }
  97
  98 static void
  99 wlsc_matrix_scale(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
 100 {
 101         struct wlsc_matrix scale = {
 102                 { x, 0, 0, 0,  0, y, 0, 0,  0, 0, z, 0,  0, 0, 0, 1 }
 103         };
 104
 105         wlsc_matrix_multiply(matrix, &scale);
 106 }
 107
 108 static void
 109 wlsc_matrix_transform(struct wlsc_matrix *matrix, struct wlsc_vector *v)
 110 {
 111         int i, j;
 112         struct wlsc_vector t;
 113
 114         for (i = 0; i < 4; i++) {
 115                 t.f[i] = 0;
 116                 for (j = 0; j < 4; j++)
 117                         t.f[i] += v->f[j] * matrix->d[i + j * 4];
 118         }
 119
 120         *v = t;
 121 }
 122
 123 struct wlsc_surface *
 124 wlsc_surface_create(struct wlsc_compositor *compositor,
 125                     int32_t x, int32_t y, int32_t width, int32_t height)
 126 {
 127         struct wlsc_surface *surface;
 128
 129         surface = malloc(sizeof *surface);
 130         if (surface == NULL)
 131                 return NULL;
 132
 133         wl_list_init(&surface->surface.destroy_listener_list);
 134         wl_list_init(&surface->link);
 135         wl_list_init(&surface->buffer_link);
 136         surface->map_type = WLSC_SURFACE_MAP_UNMAPPED;
 137
 138         glGenTextures(1, &surface->texture);
 139         glBindTexture(GL_TEXTURE_2D, surface->texture);
 140         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 141         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 142         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 143         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 144
 145         surface->compositor = compositor;
 146         surface->visual = NULL;
 147         surface->image = EGL_NO_IMAGE_KHR;
 148         surface->saved_texture = 0;
 149         surface->buffer = NULL;
 150         surface->x = x;
 151         surface->y = y;
 152         surface->width = width;
 153         surface->height = height;
 154         wlsc_matrix_init(&surface->matrix);
 155         wlsc_matrix_scale(&surface->matrix, width, height, 1);
 156         wlsc_matrix_translate(&surface->matrix, x, y, 0);
 157
 158         wlsc_matrix_init(&surface->matrix_inv);
 159         wlsc_matrix_translate(&surface->matrix_inv, -x, -y, 0);
 160         wlsc_matrix_scale(&surface->matrix_inv, 1.0 / width, 1.0 / height, 1);
 161
 162         return surface;
 163 }
 164
 165 void
 166 wlsc_surface_damage_rectangle(struct wlsc_surface *surface,
 167                               int32_t x, int32_t y,
 168                               int32_t width, int32_t height)
 169 {
 170         struct wlsc_compositor *compositor = surface->compositor;
 171
 172         pixman_region32_union_rect(&compositor->damage_region,
 173                                    &compositor->damage_region,
 174                                    surface->x + x, surface->y + y,
 175                                    width, height);
 176         wlsc_compositor_schedule_repaint(compositor);
 177 }
 178
 179 void
 180 wlsc_surface_damage(struct wlsc_surface *surface)
 181 {
 182         wlsc_surface_damage_rectangle(surface, 0, 0,
 183                                       surface->width, surface->height);
 184 }
 185
 186 uint32_t
 187 get_time(void)
 188 {
 189         struct timeval tv;
 190
 191         gettimeofday(&tv, NULL);
 192
 193         return tv.tv_sec * 1000 + tv.tv_usec / 1000;
 194 }
 195
 196 static void
 197 destroy_surface(struct wl_resource *resource, struct wl_client *client)
 198 {
 199         struct wlsc_surface *surface =
 200                 container_of(resource, struct wlsc_surface, surface.resource);
 201         struct wl_listener *l, *next;
 202         uint32_t time;
 203
 204         wlsc_surface_damage(surface);
 205
 206         wl_list_remove(&surface->link);
 207         if (surface->saved_texture == 0)
 208                 glDeleteTextures(1, &surface->texture);
 209         else
 210                 glDeleteTextures(1, &surface->saved_texture);
 211
 212
 213         if (surface->image != EGL_NO_IMAGE_KHR)
 214                 eglDestroyImageKHR(surface->compositor->display,
 215                                    surface->image);
 216
 217         wl_list_remove(&surface->buffer_link);
 218
 219         time = get_time();
 220         wl_list_for_each_safe(l, next,
 221                               &surface->surface.destroy_listener_list, link)
 222                 l->func(l, &surface->surface, time);
 223
 224         free(surface);
 225 }
 226
 227 uint32_t *
 228 wlsc_load_image(const char *filename, int width, int height)
 229 {
 230         GdkPixbuf *pixbuf;
 231         GError *error = NULL;
 232         int stride, i, n_channels;
 233         unsigned char *pixels, *end, *argb_pixels, *s, *d;
 234
 235         pixbuf = gdk_pixbuf_new_from_file_at_scale(filename,
 236                                                    width, height,
 237                                                    FALSE, &error);
 238         if (error != NULL) {
 239                 fprintf(stderr, "failed to load image: %s\n", error->message);
 240                 g_error_free(error);
 241                 return NULL;
 242         }
 243
 244         stride = gdk_pixbuf_get_rowstride(pixbuf);
 245         pixels = gdk_pixbuf_get_pixels(pixbuf);
 246         n_channels = gdk_pixbuf_get_n_channels(pixbuf);
 247
 248         argb_pixels = malloc (height * width * 4);
 249         if (argb_pixels == NULL) {
 250                 g_object_unref(pixbuf);
 251                 return NULL;
 252         }
 253
 254         if (n_channels == 4) {
 255                 for (i = 0; i < height; i++) {
 256                         s = pixels + i * stride;
 257                         end = s + width * 4;
 258                         d = argb_pixels + i * width * 4;
 259                         while (s < end) {
 260                                 unsigned int t;
 261
 262 #define MULT(_d,c,a,t) \
 263         do { t = c * a + 0x7f; _d = ((t >> 8) + t) >> 8; } while (0)
 264
 265                                 MULT(d[0], s[2], s[3], t);
 266                                 MULT(d[1], s[1], s[3], t);
 267                                 MULT(d[2], s[0], s[3], t);
 268                                 d[3] = s[3];
 269                                 s += 4;
 270                                 d += 4;
 271                         }
 272                 }
 273         } else if (n_channels == 3) {
 274                 for (i = 0; i < height; i++) {
 275                         s = pixels + i * stride;
 276                         end = s + width * 3;
 277                         d = argb_pixels + i * width * 4;
 278                         while (s < end) {
 279                                 d[0] = s[2];
 280                                 d[1] = s[1];
 281                                 d[2] = s[0];
 282                                 d[3] = 0xff;
 283                                 s += 3;
 284                                 d += 4;
 285                         }
 286                 }
 287         }
 288
 289         g_object_unref(pixbuf);
 290
 291         return (uint32_t *) argb_pixels;
 292 }
 293
 294 static void
 295 wlsc_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
 296 {
 297         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 298         struct wlsc_compositor *ec = es->compositor;
 299
 300         if (wlsc_is_shm_buffer(buffer)) {
 301                 wlsc_shm_buffer_attach(buffer, surface);
 302         } else {
 303                 es->image = eglCreateImageKHR(ec->display, NULL,
 304                                               EGL_WAYLAND_BUFFER_WL,
 305                                               buffer, NULL);
 306
 307                 if (es->saved_texture != 0)
 308                         es->texture = es->saved_texture;
 309                 glBindTexture(GL_TEXTURE_2D, es->texture);
 310                 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, es->image);
 311                 es->visual = buffer->visual;
 312         }
 313 }
 314
 315 static void
 316 wlsc_sprite_attach(struct wlsc_sprite *sprite, struct wl_surface *surface)
 317 {
 318         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 319
 320         es->image = sprite->image;
 321         if (sprite->image != EGL_NO_IMAGE_KHR) {
 322                 glBindTexture(GL_TEXTURE_2D, es->texture);
 323                 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, es->image);
 324         } else {
 325                 if (es->saved_texture == 0)
 326                         es->saved_texture = es->texture;
 327                 es->texture = sprite->texture;
 328         }
 329
 330         es->visual = sprite->visual;
 331 }
 332
 333 enum sprite_usage {
 334         SPRITE_USE_CURSOR = (1 << 0),
 335 };
 336
 337 static struct wlsc_sprite *
 338 create_sprite_from_png(struct wlsc_compositor *ec,
 339                        const char *filename, int width, int height,
 340                        uint32_t usage)
 341 {
 342         uint32_t *pixels;
 343         struct wlsc_sprite *sprite;
 344
 345         pixels = wlsc_load_image(filename, width, height);
 346         if(pixels == NULL)
 347                 return NULL;
 348
 349         sprite = malloc(sizeof *sprite);
 350         if (sprite == NULL) {
 351                 free(pixels);
 352                 return NULL;
 353         }
 354
 355         sprite->visual = &ec->compositor.premultiplied_argb_visual;
 356         sprite->width = width;
 357         sprite->height = height;
 358         sprite->image = EGL_NO_IMAGE_KHR;
 359
 360         if (usage & SPRITE_USE_CURSOR && ec->create_cursor_image != NULL)
 361                 sprite->image = ec->create_cursor_image(ec, width, height);
 362
 363         glGenTextures(1, &sprite->texture);
 364         glBindTexture(GL_TEXTURE_2D, sprite->texture);
 365         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 366         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 367         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 368         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 369
 370         if (sprite->image != EGL_NO_IMAGE_KHR) {
 371                 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, sprite->image);
 372                 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,
 373                                 GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
 374         } else {
 375                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 376                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
 377         }
 378
 379         free(pixels);
 380
 381         return sprite;
 382 }
 383
 384 static const struct {
 385         const char *filename;
 386         int hotspot_x, hotspot_y;
 387 } pointer_images[] = {
 388         { DATADIR "/wayland/bottom_left_corner.png",     6, 30 },
 389         { DATADIR "/wayland/bottom_right_corner.png",   28, 28 },
 390         { DATADIR "/wayland/bottom_side.png",           16, 20 },
 391         { DATADIR "/wayland/grabbing.png",              20, 17 },
 392         { DATADIR "/wayland/left_ptr.png",              10,  5 },
 393         { DATADIR "/wayland/left_side.png",             10, 20 },
 394         { DATADIR "/wayland/right_side.png",            30, 19 },
 395         { DATADIR "/wayland/top_left_corner.png",        8,  8 },
 396         { DATADIR "/wayland/top_right_corner.png",      26,  8 },
 397         { DATADIR "/wayland/top_side.png",              18,  8 },
 398         { DATADIR "/wayland/xterm.png",                 15, 15 }
 399 };
 400
 401 static void
 402 create_pointer_images(struct wlsc_compositor *ec)
 403 {
 404         int i, count;
 405         const int width = 32, height = 32;
 406
 407         count = ARRAY_LENGTH(pointer_images);
 408         ec->pointer_sprites = malloc(count * sizeof *ec->pointer_sprites);
 409         for (i = 0; i < count; i++) {
 410                 ec->pointer_sprites[i] =
 411                         create_sprite_from_png(ec,
 412                                                pointer_images[i].filename,
 413                                                width, height,
 414                                                SPRITE_USE_CURSOR);
 415         }
 416 }
 417
 418 static struct wlsc_surface *
 419 background_create(struct wlsc_output *output, const char *filename)
 420 {
 421         struct wlsc_surface *background;
 422         struct wlsc_sprite *sprite;
 423
 424         background = wlsc_surface_create(output->compositor,
 425                                          output->x, output->y,
 426                                          output->width, output->height);
 427         if (background == NULL)
 428                 return NULL;
 429
 430         sprite = create_sprite_from_png(output->compositor, filename,
 431                                         output->width, output->height, 0);
 432         if (sprite == NULL) {
 433                 free(background);
 434                 return NULL;
 435         }
 436
 437         wlsc_sprite_attach(sprite, &background->surface);
 438
 439         return background;
 440 }
 441
 442 static void
 443 wlsc_surface_draw(struct wlsc_surface *es,
 444                   struct wlsc_output *output, pixman_region32_t *clip)
 445 {
 446         struct wlsc_compositor *ec = es->compositor;
 447         GLfloat *v, inv_width, inv_height;
 448         unsigned int *p;
 449         pixman_region32_t repaint;
 450         pixman_box32_t *rectangles;
 451         int i, n;
 452
 453         pixman_region32_init_rect(&repaint,
 454                                   es->x, es->y, es->width, es->height);
 455         pixman_region32_intersect(&repaint, &repaint, clip);
 456         if (!pixman_region32_not_empty(&repaint))
 457                 return;
 458
 459         if (es->visual == &ec->compositor.argb_visual) {
 460                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 461                 glEnable(GL_BLEND);
 462         } else if (es->visual == &ec->compositor.premultiplied_argb_visual) {
 463                 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 464                 glEnable(GL_BLEND);
 465         } else {
 466                 glDisable(GL_BLEND);
 467         }
 468
 469         rectangles = pixman_region32_rectangles(&repaint, &n);
 470         v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
 471         p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
 472         inv_width = 1.0 / es->width;
 473         inv_height = 1.0 / es->height;
 474         for (i = 0; i < n; i++, v += 16, p += 6) {
 475                 v[ 0] = rectangles[i].x1;
 476                 v[ 1] = rectangles[i].y1;
 477                 v[ 2] = (GLfloat) (rectangles[i].x1 - es->x) * inv_width;
 478                 v[ 3] = (GLfloat) (rectangles[i].y1 - es->y) * inv_height;
 479
 480                 v[ 4] = rectangles[i].x1;
 481                 v[ 5] = rectangles[i].y2;
 482                 v[ 6] = v[ 2];
 483                 v[ 7] = (GLfloat) (rectangles[i].y2 - es->y) * inv_height;
 484
 485                 v[ 8] = rectangles[i].x2;
 486                 v[ 9] = rectangles[i].y1;
 487                 v[10] = (GLfloat) (rectangles[i].x2 - es->x) * inv_width;
 488                 v[11] = v[ 3];
 489
 490                 v[12] = rectangles[i].x2;
 491                 v[13] = rectangles[i].y2;
 492                 v[14] = v[10];
 493                 v[15] = v[ 7];
 494
 495                 p[0] = i * 4 + 0;
 496                 p[1] = i * 4 + 1;
 497                 p[2] = i * 4 + 2;
 498                 p[3] = i * 4 + 2;
 499                 p[4] = i * 4 + 1;
 500                 p[5] = i * 4 + 3;
 501         }
 502
 503         glBindTexture(GL_TEXTURE_2D, es->texture);
 504         v = ec->vertices.data;
 505         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
 506         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
 507         glEnableVertexAttribArray(0);
 508         glEnableVertexAttribArray(1);
 509         glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
 510
 511         ec->vertices.size = 0;
 512         ec->indices.size = 0;
 513         pixman_region32_fini(&repaint);
 514 }
 515
 516 static void
 517 wlsc_surface_raise(struct wlsc_surface *surface)
 518 {
 519         struct wlsc_compositor *compositor = surface->compositor;
 520
 521         wl_list_remove(&surface->link);
 522         wl_list_insert(&compositor->surface_list, &surface->link);
 523 }
 524
 525 void
 526 wlsc_surface_update_matrix(struct wlsc_surface *es)
 527 {
 528         wlsc_matrix_init(&es->matrix);
 529         wlsc_matrix_scale(&es->matrix, es->width, es->height, 1);
 530         wlsc_matrix_translate(&es->matrix, es->x, es->y, 0);
 531
 532         wlsc_matrix_init(&es->matrix_inv);
 533         wlsc_matrix_translate(&es->matrix_inv, -es->x, -es->y, 0);
 534         wlsc_matrix_scale(&es->matrix_inv,
 535                           1.0 / es->width, 1.0 / es->height, 1);
 536 }
 537
 538 void
 539 wlsc_output_finish_frame(struct wlsc_output *output, int msecs)
 540 {
 541         struct wlsc_compositor *compositor = output->compositor;
 542         struct wlsc_surface *es;
 543
 544         wl_list_for_each(es, &compositor->surface_list, link) {
 545                 if (es->output == output) {
 546                         wl_display_post_frame(compositor->wl_display,
 547                                               &es->surface, msecs);
 548                 }
 549         }
 550
 551         output->finished = 1;
 552
 553         wl_event_source_timer_update(compositor->timer_source, 5);
 554         compositor->repaint_on_timeout = 1;
 555 }
 556
 557 static void
 558 wlsc_output_repaint(struct wlsc_output *output)
 559 {
 560         struct wlsc_compositor *ec = output->compositor;
 561         struct wlsc_surface *es;
 562         struct wlsc_input_device *eid;
 563         pixman_region32_t new_damage, total_damage, repaint;
 564         int using_hardware_cursor = 1;
 565
 566         output->prepare_render(output);
 567
 568         glViewport(0, 0, output->width, output->height);
 569
 570         glUniformMatrix4fv(ec->proj_uniform, 1, GL_FALSE, output->matrix.d);
 571         glUniform1i(ec->tex_uniform, 0);
 572
 573         pixman_region32_init(&new_damage);
 574         pixman_region32_init(&total_damage);
 575         pixman_region32_intersect_rect(&new_damage,
 576                                        &ec->damage_region,
 577                                        output->x, output->y,
 578                                        output->width, output->height);
 579         pixman_region32_subtract(&ec->damage_region,
 580                                  &ec->damage_region, &new_damage);
 581         pixman_region32_union(&total_damage, &new_damage,
 582                               &output->previous_damage_region);
 583         pixman_region32_copy(&output->previous_damage_region, &new_damage);
 584
 585         if (ec->focus)
 586                 if (output->set_hardware_cursor(output, ec->input_device) < 0)
 587                         using_hardware_cursor = 0;
 588
 589         es = container_of(ec->surface_list.next, struct wlsc_surface, link);
 590         if (es->map_type == WLSC_SURFACE_MAP_FULLSCREEN &&
 591             es->fullscreen_output == output) {
 592                 if (es->visual == &ec->compositor.rgb_visual &&
 593                     using_hardware_cursor) {
 594                         if (output->prepare_scanout_surface(output, es) == 0) {
 595                                 /* We're drawing nothing now,
 596                                  * draw the damaged regions later. */
 597                                 pixman_region32_union(&ec->damage_region,
 598                                                       &ec->damage_region,
 599                                                       &total_damage);
 600                                 return;
 601                         }
 602                 }
 603
 604                 if (es->width < output->width ||
 605                     es->height < output->height)
 606                         glClear(GL_COLOR_BUFFER_BIT);
 607                 wlsc_surface_draw(es, output, &total_damage);
 608         } else {
 609                 wl_list_for_each(es, &ec->surface_list, link) {
 610                         if (es->visual != &ec->compositor.rgb_visual)
 611                                 continue;
 612
 613                         pixman_region32_init_rect(&repaint,
 614                                                   es->x, es->y,
 615                                                   es->width, es->height);
 616                         wlsc_surface_draw(es, output, &total_damage);
 617                         pixman_region32_subtract(&total_damage,
 618                                                  &total_damage, &repaint);
 619                 }
 620
 621                 if (output->background)
 622                         wlsc_surface_draw(output->background,
 623                                           output, &total_damage);
 624                 else
 625                         glClear(GL_COLOR_BUFFER_BIT);
 626
 627                 wl_list_for_each_reverse(es, &ec->surface_list, link) {
 628                         if (ec->overlay == es)
 629                                 continue;
 630
 631                         if (es->visual == &ec->compositor.rgb_visual) {
 632                                 pixman_region32_union_rect(&total_damage,
 633                                                            &total_damage,
 634                                                            es->x, es->y,
 635                                                            es->width, es->height);
 636                                 continue;
 637                         }
 638
 639                         wlsc_surface_draw(es, output, &total_damage);
 640                 }
 641         }
 642
 643         if (ec->overlay)
 644                 wlsc_surface_draw(ec->overlay, output, &total_damage);
 645
 646         if (ec->focus)
 647                 wl_list_for_each(eid, &ec->input_device_list, link) {
 648                         if (&eid->input_device != ec->input_device ||
 649                             !using_hardware_cursor)
 650                                 wlsc_surface_draw(eid->sprite, output,
 651                                                   &total_damage);
 652                 }
 653 }
 654
 655 static void
 656 repaint(void *data)
 657 {
 658         struct wlsc_compositor *ec = data;
 659         struct wlsc_output *output;
 660         int repainted_all_outputs = 1;
 661
 662         wl_list_for_each(output, &ec->output_list, link) {
 663                 if (!output->repaint_needed)
 664                         continue;
 665
 666                 if (!output->finished) {
 667                         repainted_all_outputs = 0;
 668                         continue;
 669                 }
 670
 671                 wlsc_output_repaint(output);
 672                 output->finished = 0;
 673                 output->repaint_needed = 0;
 674                 output->present(output);
 675         }
 676
 677         if (repainted_all_outputs)
 678                 ec->repaint_on_timeout = 0;
 679         else
 680                 wl_event_source_timer_update(ec->timer_source, 1);
 681 }
 682
 683 void
 684 wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor)
 685 {
 686         struct wlsc_output *output;
 687
 688         wl_list_for_each(output, &compositor->output_list, link)
 689                 output->repaint_needed = 1;
 690
 691         if (compositor->repaint_on_timeout)
 692                 return;
 693
 694         wl_event_source_timer_update(compositor->timer_source, 1);
 695         compositor->repaint_on_timeout = 1;
 696 }
 697
 698 static void
 699 surface_destroy(struct wl_client *client,
 700                 struct wl_surface *surface)
 701 {
 702         wl_resource_destroy(&surface->resource, client);
 703 }
 704
 705 void
 706 wlsc_surface_assign_output(struct wlsc_surface *es)
 707 {
 708         struct wlsc_compositor *ec = es->compositor;
 709         struct wlsc_output *output;
 710
 711         struct wlsc_output *tmp = es->output;
 712         es->output = NULL;
 713
 714         wl_list_for_each(output, &ec->output_list, link) {
 715                 if (output->x < es->x && es->x < output->x + output->width &&
 716                     output->y < es->y && es->y < output->y + output->height) {
 717                         if (output != tmp)
 718                                 printf("assiging surface %p to output %p\n",
 719                                        es, output);
 720                         es->output = output;
 721                 }
 722         }
 723
 724         if (es->output == NULL) {
 725                 printf("no output found\n");
 726                 es->output = container_of(ec->output_list.next,
 727                                           struct wlsc_output, link);
 728         }
 729 }
 730
 731 static void
 732 surface_attach(struct wl_client *client,
 733                struct wl_surface *surface, struct wl_buffer *buffer,
 734                int32_t x, int32_t y)
 735 {
 736         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 737
 738         /* FIXME: This damages the entire old surface, but we should
 739          * really just damage the part that's no longer covered by the
 740          * surface.  Anything covered by the new surface will be
 741          * damaged by the client. */
 742         wlsc_surface_damage(es);
 743
 744         wlsc_buffer_attach(buffer, surface);
 745
 746         es->buffer = buffer;
 747         es->x += x;
 748         es->y += y;
 749         es->width = buffer->width;
 750         es->height = buffer->height;
 751         if (x != 0 || y != 0)
 752                 wlsc_surface_assign_output(es);
 753         wlsc_surface_update_matrix(es);
 754 }
 755
 756 static void
 757 surface_map_toplevel(struct wl_client *client,
 758                      struct wl_surface *surface)
 759 {
 760         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 761         struct wlsc_compositor *ec = es->compositor;
 762
 763         switch (es->map_type) {
 764         case WLSC_SURFACE_MAP_UNMAPPED:
 765                 es->x = 10 + random() % 400;
 766                 es->y = 10 + random() % 400;
 767                 wlsc_surface_update_matrix(es);
 768                 /* assign to first output */
 769                 es->output = container_of(ec->output_list.next,
 770                                           struct wlsc_output, link);
 771                 wl_list_insert(&es->compositor->surface_list, &es->link);
 772                 break;
 773         case WLSC_SURFACE_MAP_TOPLEVEL:
 774                 return;
 775         case WLSC_SURFACE_MAP_FULLSCREEN:
 776                 es->fullscreen_output = NULL;
 777                 es->x = es->saved_x;
 778                 es->y = es->saved_y;
 779                 wlsc_surface_update_matrix(es);
 780                 break;
 781         default:
 782                 break;
 783         }
 784
 785         wlsc_surface_damage(es);
 786         es->map_type = WLSC_SURFACE_MAP_TOPLEVEL;
 787 }
 788
 789 static void
 790 surface_map_transient(struct wl_client *client,
 791                       struct wl_surface *surface, struct wl_surface *parent,
 792                       int x, int y, uint32_t flags)
 793 {
 794         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 795         struct wlsc_surface *pes = (struct wlsc_surface *) parent;
 796
 797         switch (es->map_type) {
 798         case WLSC_SURFACE_MAP_UNMAPPED:
 799                 wl_list_insert(&es->compositor->surface_list, &es->link);
 800                 /* assign to parents output  */
 801                 es->output = pes->output;
 802                 break;
 803         case WLSC_SURFACE_MAP_FULLSCREEN:
 804                 es->fullscreen_output = NULL;
 805                 break;
 806         default:
 807                 break;
 808         }
 809
 810         es->x = pes->x + x;
 811         es->y = pes->y + y;
 812
 813         wlsc_surface_update_matrix(es);
 814         wlsc_surface_damage(es);
 815         es->map_type = WLSC_SURFACE_MAP_TRANSIENT;
 816 }
 817
 818 static void
 819 surface_map_fullscreen(struct wl_client *client, struct wl_surface *surface)
 820 {
 821         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 822         struct wlsc_output *output;
 823
 824         /* FIXME: Fullscreen on first output */
 825         /* FIXME: Handle output going away */
 826         output = container_of(es->compositor->output_list.next,
 827                               struct wlsc_output, link);
 828
 829         switch (es->map_type) {
 830         case WLSC_SURFACE_MAP_UNMAPPED:
 831                 es->x = 10 + random() % 400;
 832                 es->y = 10 + random() % 400;
 833                 /* assign to first output */
 834                 es->output = output;
 835                 wl_list_insert(&es->compositor->surface_list, &es->link);
 836                 break;
 837         case WLSC_SURFACE_MAP_FULLSCREEN:
 838                 return;
 839         default:
 840                 break;
 841         }
 842
 843         es->saved_x = es->x;
 844         es->saved_y = es->y;
 845         es->x = (output->width - es->width) / 2;
 846         es->y = (output->height - es->height) / 2;
 847         es->fullscreen_output = output;
 848         wlsc_surface_update_matrix(es);
 849         wlsc_surface_damage(es);
 850         es->map_type = WLSC_SURFACE_MAP_FULLSCREEN;
 851 }
 852
 853 static void
 854 surface_damage(struct wl_client *client,
 855                struct wl_surface *surface,
 856                int32_t x, int32_t y, int32_t width, int32_t height)
 857 {
 858         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 859
 860         wlsc_surface_damage_rectangle(es, x, y, width, height);
 861 }
 862
 863 const static struct wl_surface_interface surface_interface = {
 864         surface_destroy,
 865         surface_attach,
 866         surface_map_toplevel,
 867         surface_map_transient,
 868         surface_map_fullscreen,
 869         surface_damage
 870 };
 871
 872 static void
 873 wlsc_input_device_attach(struct wlsc_input_device *device,
 874                          int x, int y, int width, int height)
 875 {
 876         wlsc_surface_damage(device->sprite);
 877
 878         device->hotspot_x = x;
 879         device->hotspot_y = y;
 880
 881         device->sprite->x = device->input_device.x - device->hotspot_x;
 882         device->sprite->y = device->input_device.y - device->hotspot_y;
 883         device->sprite->width = width;
 884         device->sprite->height = height;
 885         wlsc_surface_update_matrix(device->sprite);
 886
 887         wlsc_surface_damage(device->sprite);
 888 }
 889
 890 static void
 891 wlsc_input_device_attach_buffer(struct wlsc_input_device *device,
 892                                 struct wl_buffer *buffer, int x, int y)
 893 {
 894         wlsc_buffer_attach(buffer, &device->sprite->surface);
 895         wlsc_input_device_attach(device, x, y, buffer->width, buffer->height);
 896 }
 897
 898 static void
 899 wlsc_input_device_attach_sprite(struct wlsc_input_device *device,
 900                                 struct wlsc_sprite *sprite, int x, int y)
 901 {
 902         wlsc_sprite_attach(sprite, &device->sprite->surface);
 903         wlsc_input_device_attach(device, x, y, sprite->width, sprite->height);
 904 }
 905
 906 void
 907 wlsc_input_device_set_pointer_image(struct wlsc_input_device *device,
 908                                     enum wlsc_pointer_type type)
 909 {
 910         struct wlsc_compositor *compositor =
 911                 (struct wlsc_compositor *) device->input_device.compositor;
 912
 913         wlsc_input_device_attach_sprite(device,
 914                                         compositor->pointer_sprites[type],
 915                                         pointer_images[type].hotspot_x,
 916                                         pointer_images[type].hotspot_y);
 917 }
 918
 919 static void
 920 compositor_create_surface(struct wl_client *client,
 921                           struct wl_compositor *compositor, uint32_t id)
 922 {
 923         struct wlsc_compositor *ec = (struct wlsc_compositor *) compositor;
 924         struct wlsc_surface *surface;
 925
 926         surface = wlsc_surface_create(ec, 0, 0, 0, 0);
 927         if (surface == NULL) {
 928                 wl_client_post_no_memory(client);
 929                 return;
 930         }
 931
 932         surface->surface.resource.destroy = destroy_surface;
 933
 934         surface->surface.resource.object.id = id;
 935         surface->surface.resource.object.interface = &wl_surface_interface;
 936         surface->surface.resource.object.implementation =
 937                 (void (**)(void)) &surface_interface;
 938         surface->surface.client = client;
 939
 940         wl_client_add_resource(client, &surface->surface.resource);
 941 }
 942
 943 const static struct wl_compositor_interface compositor_interface = {
 944         compositor_create_surface,
 945 };
 946
 947 static void
 948 wlsc_surface_transform(struct wlsc_surface *surface,
 949                        int32_t x, int32_t y, int32_t *sx, int32_t *sy)
 950 {
 951         struct wlsc_vector v = { { x, y, 0, 1 } };
 952
 953         wlsc_matrix_transform(&surface->matrix_inv, &v);
 954         *sx = v.f[0] * surface->width;
 955         *sy = v.f[1] * surface->height;
 956 }
 957
 958 struct wlsc_surface *
 959 pick_surface(struct wl_input_device *device, int32_t *sx, int32_t *sy)
 960 {
 961         struct wlsc_compositor *ec =
 962                 (struct wlsc_compositor *) device->compositor;
 963         struct wlsc_surface *es;
 964
 965         wl_list_for_each(es, &ec->surface_list, link) {
 966                 wlsc_surface_transform(es, device->x, device->y, sx, sy);
 967                 if (0 <= *sx && *sx < es->width &&
 968                     0 <= *sy && *sy < es->height)
 969                         return es;
 970         }
 971
 972         return NULL;
 973 }
 974
 975
 976 static void
 977 motion_grab_motion(struct wl_grab *grab,
 978                    uint32_t time, int32_t x, int32_t y)
 979 {
 980         struct wlsc_input_device *device =
 981                 (struct wlsc_input_device *) grab->input_device;
 982         struct wlsc_surface *es =
 983                 (struct wlsc_surface *) device->input_device.pointer_focus;
 984         int32_t sx, sy;
 985
 986         wlsc_surface_transform(es, x, y, &sx, &sy);
 987         wl_client_post_event(es->surface.client,
 988                              &device->input_device.object,
 989                              WL_INPUT_DEVICE_MOTION,
 990                              time, x, y, sx, sy);
 991 }
 992
 993 static void
 994 motion_grab_button(struct wl_grab *grab,
 995                    uint32_t time, int32_t button, int32_t state)
 996 {
 997         wl_client_post_event(grab->input_device->pointer_focus->client,
 998                              &grab->input_device->object,
 999                              WL_INPUT_DEVICE_BUTTON,
1000                              time, button, state);
1001 }
1002
1003 static void
1004 motion_grab_end(struct wl_grab *grab, uint32_t time)
1005 {
1006 }
1007
1008 static const struct wl_grab_interface motion_grab_interface = {
1009         motion_grab_motion,
1010         motion_grab_button,
1011         motion_grab_end
1012 };
1013
1014 void
1015 notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
1016 {
1017         struct wlsc_surface *es;
1018         struct wlsc_compositor *ec =
1019                 (struct wlsc_compositor *) device->compositor;
1020         struct wlsc_output *output;
1021         const struct wl_grab_interface *interface;
1022         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1023         int32_t sx, sy;
1024         int x_valid = 0, y_valid = 0;
1025         int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN;
1026
1027         wl_list_for_each(output, &ec->output_list, link) {
1028                 if (output->x <= x && x <= output->x + output->width)
1029                         x_valid = 1;
1030
1031                 if (output->y <= y && y <= output->y + output->height)
1032                         y_valid = 1;
1033
1034                 /* FIXME: calculate this only on output addition/deletion */
1035                 if (output->x < min_x)
1036                         min_x = output->x;
1037                 if (output->y < min_y)
1038                         min_y = output->y;
1039
1040                 if (output->x + output->width > max_x)
1041                         max_x = output->x + output->width;
1042                 if (output->y + output->height > max_y)
1043                         max_y = output->y + output->height;
1044         }
1045
1046         if (!x_valid) {
1047                 if (x < min_x)
1048                         x = min_x;
1049                 else if (x >= max_x)
1050                         x = max_x;
1051         }
1052         if (!y_valid) {
1053                 if (y < min_y)
1054                         y = min_y;
1055                 else  if (y >= max_y)
1056                         y = max_y;
1057         }
1058
1059         device->x = x;
1060         device->y = y;
1061
1062         if (device->grab) {
1063                 interface = device->grab->interface;
1064                 interface->motion(device->grab, time, x, y);
1065         } else {
1066                 es = pick_surface(device, &sx, &sy);
1067                 wl_input_device_set_pointer_focus(device,
1068                                                   &es->surface,
1069                                                   time, x, y, sx, sy);
1070                 if (es)
1071                         wl_client_post_event(es->surface.client,
1072                                              &device->object,
1073                                              WL_INPUT_DEVICE_MOTION,
1074                                              time, x, y, sx, sy);
1075         }
1076
1077         wlsc_surface_damage(wd->sprite);
1078
1079         wd->sprite->x = device->x - wd->hotspot_x;
1080         wd->sprite->y = device->y - wd->hotspot_y;
1081         wlsc_surface_update_matrix(wd->sprite);
1082
1083         wlsc_surface_damage(wd->sprite);
1084 }
1085
1086 void
1087 wlsc_surface_activate(struct wlsc_surface *surface,
1088                       struct wlsc_input_device *device, uint32_t time)
1089 {
1090         wlsc_surface_raise(surface);
1091         if (device->selection)
1092                 wlsc_selection_set_focus(device->selection,
1093                                          &surface->surface, time);
1094
1095         wl_input_device_set_keyboard_focus(&device->input_device,
1096                                            &surface->surface,
1097                                            time);
1098 }
1099
1100 struct wlsc_binding {
1101         uint32_t key;
1102         uint32_t button;
1103         uint32_t modifier;
1104         wlsc_binding_handler_t handler;
1105         void *data;
1106         struct wl_list link;
1107 };
1108
1109 void
1110 notify_button(struct wl_input_device *device,
1111               uint32_t time, int32_t button, int32_t state)
1112 {
1113         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1114         struct wlsc_compositor *compositor =
1115                 (struct wlsc_compositor *) device->compositor;
1116         struct wlsc_binding *b;
1117         struct wlsc_surface *surface =
1118                 (struct wlsc_surface *) device->pointer_focus;
1119
1120         if (state && surface && device->grab == NULL) {
1121                 wlsc_surface_activate(surface, wd, time);
1122                 wl_input_device_start_grab(device,
1123                                            &device->motion_grab,
1124                                            button, time);
1125         }
1126
1127         wl_list_for_each(b, &compositor->binding_list, link) {
1128                 if (b->button == button &&
1129                     b->modifier == wd->modifier_state && state) {
1130                         b->handler(&wd->input_device,
1131                                    time, 0, button, state, b->data);
1132                         break;
1133                 }
1134         }
1135
1136         if (device->grab)
1137                 device->grab->interface->button(device->grab, time,
1138                                                 button, state);
1139
1140         if (!state && device->grab && device->grab_button == button)
1141                 wl_input_device_end_grab(device, time);
1142 }
1143
1144 static void
1145 terminate_binding(struct wl_input_device *device, uint32_t time,
1146                   uint32_t key, uint32_t button, uint32_t state, void *data)
1147 {
1148         struct wlsc_compositor *compositor = data;
1149
1150         wl_display_terminate(compositor->wl_display);
1151 }
1152
1153 struct wlsc_binding *
1154 wlsc_compositor_add_binding(struct wlsc_compositor *compositor,
1155                             uint32_t key, uint32_t button, uint32_t modifier,
1156                             wlsc_binding_handler_t handler, void *data)
1157 {
1158         struct wlsc_binding *binding;
1159
1160         binding = malloc(sizeof *binding);
1161         if (binding == NULL)
1162                 return NULL;
1163
1164         binding->key = key;
1165         binding->button = button;
1166         binding->modifier = modifier;
1167         binding->handler = handler;
1168         binding->data = data;
1169         wl_list_insert(compositor->binding_list.prev, &binding->link);
1170
1171         return binding;
1172 }
1173
1174 void
1175 wlsc_binding_destroy(struct wlsc_binding *binding)
1176 {
1177         wl_list_remove(&binding->link);
1178         free(binding);
1179 }
1180
1181 static void
1182 update_modifier_state(struct wlsc_input_device *device,
1183                       uint32_t key, uint32_t state)
1184 {
1185         uint32_t modifier;
1186
1187         switch (key) {
1188         case KEY_LEFTCTRL:
1189         case KEY_RIGHTCTRL:
1190                 modifier = MODIFIER_CTRL;
1191                 break;
1192
1193         case KEY_LEFTALT:
1194         case KEY_RIGHTALT:
1195                 modifier = MODIFIER_ALT;
1196                 break;
1197
1198         case KEY_LEFTMETA:
1199         case KEY_RIGHTMETA:
1200                 modifier = MODIFIER_SUPER;
1201                 break;
1202
1203         default:
1204                 modifier = 0;
1205                 break;
1206         }
1207
1208         if (state)
1209                 device->modifier_state |= modifier;
1210         else
1211                 device->modifier_state &= ~modifier;
1212 }
1213
1214 void
1215 notify_key(struct wl_input_device *device,
1216            uint32_t time, uint32_t key, uint32_t state)
1217 {
1218         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1219         struct wlsc_compositor *compositor =
1220                 (struct wlsc_compositor *) device->compositor;
1221         uint32_t *k, *end;
1222         struct wlsc_binding *b;
1223
1224         wl_list_for_each(b, &compositor->binding_list, link) {
1225                 if (b->key == key &&
1226                     b->modifier == wd->modifier_state && state) {
1227                         b->handler(&wd->input_device,
1228                                    time, key, 0, state, b->data);
1229                         break;
1230                 }
1231         }
1232
1233         update_modifier_state(wd, key, state);
1234         end = device->keys.data + device->keys.size;
1235         for (k = device->keys.data; k < end; k++) {
1236                 if (*k == key)
1237                         *k = *--end;
1238         }
1239         device->keys.size = (void *) end - device->keys.data;
1240         if (state) {
1241                 k = wl_array_add(&device->keys, sizeof *k);
1242                 *k = key;
1243         }
1244
1245         if (device->keyboard_focus != NULL)
1246                 wl_client_post_event(device->keyboard_focus->client,
1247                                      &device->object,
1248                                      WL_INPUT_DEVICE_KEY, time, key, state);
1249 }
1250
1251 void
1252 notify_pointer_focus(struct wl_input_device *device,
1253                      uint32_t time, struct wlsc_output *output,
1254                      int32_t x, int32_t y)
1255 {
1256         struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1257         struct wlsc_compositor *compositor =
1258                 (struct wlsc_compositor *) device->compositor;
1259         struct wlsc_surface *es;
1260         int32_t sx, sy;
1261
1262         if (output) {
1263                 device->x = x;
1264                 device->y = y;
1265                 es = pick_surface(device, &sx, &sy);
1266                 wl_input_device_set_pointer_focus(device,
1267                                                   &es->surface,
1268                                                   time, x, y, sx, sy);
1269
1270                 compositor->focus = 1;
1271
1272                 wd->sprite->x = device->x - wd->hotspot_x;
1273                 wd->sprite->y = device->y - wd->hotspot_y;
1274                 wlsc_surface_update_matrix(wd->sprite);
1275         } else {
1276                 wl_input_device_set_pointer_focus(device, NULL,
1277                                                   time, 0, 0, 0, 0);
1278                 compositor->focus = 0;
1279         }
1280
1281         wlsc_surface_damage(wd->sprite);
1282 }
1283
1284 void
1285 notify_keyboard_focus(struct wl_input_device *device,
1286                       uint32_t time, struct wlsc_output *output,
1287                       struct wl_array *keys)
1288 {
1289         struct wlsc_input_device *wd =
1290                 (struct wlsc_input_device *) device;
1291         struct wlsc_compositor *compositor =
1292                 (struct wlsc_compositor *) device->compositor;
1293         struct wlsc_surface *es;
1294         uint32_t *k, *end;
1295
1296         if (!wl_list_empty(&compositor->surface_list))
1297                 es = container_of(compositor->surface_list.next,
1298                                   struct wlsc_surface, link);
1299         else
1300                 es = NULL;
1301
1302         if (output) {
1303                 wl_array_copy(&wd->input_device.keys, keys);
1304                 wd->modifier_state = 0;
1305                 end = device->keys.data + device->keys.size;
1306                 for (k = device->keys.data; k < end; k++) {
1307                         update_modifier_state(wd, *k, 1);
1308                 }
1309
1310                 wl_input_device_set_keyboard_focus(&wd->input_device,
1311                                                    &es->surface, time);
1312         } else {
1313                 wd->modifier_state = 0;
1314                 wl_input_device_set_keyboard_focus(&wd->input_device,
1315                                                    NULL, time);
1316         }
1317 }
1318
1319
1320 static void
1321 input_device_attach(struct wl_client *client,
1322                     struct wl_input_device *device_base,
1323                     uint32_t time,
1324                     struct wl_buffer *buffer, int32_t x, int32_t y)
1325 {
1326         struct wlsc_input_device *device =
1327                 (struct wlsc_input_device *) device_base;
1328
1329         if (time < device->input_device.pointer_focus_time)
1330                 return;
1331         if (device->input_device.pointer_focus == NULL)
1332                 return;
1333         if (device->input_device.pointer_focus->client != client)
1334                 return;
1335
1336         if (buffer == NULL) {
1337                 wlsc_input_device_set_pointer_image(device,
1338                                                     WLSC_POINTER_LEFT_PTR);
1339                 return;
1340         }
1341
1342         wlsc_input_device_attach_buffer(device, buffer, x, y);
1343 }
1344
1345 const static struct wl_input_device_interface input_device_interface = {
1346         input_device_attach,
1347 };
1348
1349 void
1350 wlsc_input_device_init(struct wlsc_input_device *device,
1351                        struct wlsc_compositor *ec)
1352 {
1353         wl_input_device_init(&device->input_device, &ec->compositor);
1354
1355         device->input_device.object.interface = &wl_input_device_interface;
1356         device->input_device.object.implementation =
1357                 (void (**)(void)) &input_device_interface;
1358         wl_display_add_object(ec->wl_display, &device->input_device.object);
1359         wl_display_add_global(ec->wl_display, &device->input_device.object, NULL);
1360
1361         device->sprite = wlsc_surface_create(ec,
1362                                              device->input_device.x,
1363                                              device->input_device.y, 32, 32);
1364         device->hotspot_x = 16;
1365         device->hotspot_y = 16;
1366         device->modifier_state = 0;
1367
1368         device->input_device.motion_grab.interface = &motion_grab_interface;
1369
1370         wl_list_insert(ec->input_device_list.prev, &device->link);
1371
1372         wlsc_input_device_set_pointer_image(device, WLSC_POINTER_LEFT_PTR);
1373 }
1374
1375 static void
1376 wlsc_output_post_geometry(struct wl_client *client,
1377                           struct wl_object *global, uint32_t version)
1378 {
1379         struct wlsc_output *output =
1380                 container_of(global, struct wlsc_output, object);
1381
1382         wl_client_post_event(client, global,
1383                              WL_OUTPUT_GEOMETRY,
1384                              output->x, output->y,
1385                              output->width, output->height);
1386 }
1387
1388 static const char vertex_shader[] =
1389         "uniform mat4 proj;\n"
1390         "attribute vec2 position;\n"
1391         "attribute vec2 texcoord;\n"
1392         "varying vec2 v_texcoord;\n"
1393         "void main()\n"
1394         "{\n"
1395         "   gl_Position = proj * vec4(position, 0.0, 1.0);\n"
1396         "   v_texcoord = texcoord;\n"
1397         "}\n";
1398
1399 static const char fragment_shader[] =
1400         "precision mediump float;\n"
1401         "varying vec2 v_texcoord;\n"
1402         "uniform sampler2D tex;\n"
1403         "void main()\n"
1404         "{\n"
1405         "   gl_FragColor = texture2D(tex, v_texcoord)\n;"
1406         "}\n";
1407
1408 static int
1409 init_shaders(struct wlsc_compositor *ec)
1410 {
1411         GLuint v, f, program;
1412         const char *p;
1413         char msg[512];
1414         GLint status;
1415
1416         p = vertex_shader;
1417         v = glCreateShader(GL_VERTEX_SHADER);
1418         glShaderSource(v, 1, &p, NULL);
1419         glCompileShader(v);
1420         glGetShaderiv(v, GL_COMPILE_STATUS, &status);
1421         if (!status) {
1422                 glGetShaderInfoLog(v, sizeof msg, NULL, msg);
1423                 fprintf(stderr, "vertex shader info: %s\n", msg);
1424                 return -1;
1425         }
1426
1427         p = fragment_shader;
1428         f = glCreateShader(GL_FRAGMENT_SHADER);
1429         glShaderSource(f, 1, &p, NULL);
1430         glCompileShader(f);
1431         glGetShaderiv(f, GL_COMPILE_STATUS, &status);
1432         if (!status) {
1433                 glGetShaderInfoLog(f, sizeof msg, NULL, msg);
1434                 fprintf(stderr, "fragment shader info: %s\n", msg);
1435                 return -1;
1436         }
1437
1438         program = glCreateProgram();
1439         glAttachShader(program, v);
1440         glAttachShader(program, f);
1441         glBindAttribLocation(program, 0, "position");
1442         glBindAttribLocation(program, 1, "texcoord");
1443
1444         glLinkProgram(program);
1445         glGetProgramiv(program, GL_LINK_STATUS, &status);
1446         if (!status) {
1447                 glGetProgramInfoLog(program, sizeof msg, NULL, msg);
1448                 fprintf(stderr, "link info: %s\n", msg);
1449                 return -1;
1450         }
1451
1452         glUseProgram(program);
1453         ec->proj_uniform = glGetUniformLocation(program, "proj");
1454         ec->tex_uniform = glGetUniformLocation(program, "tex");
1455
1456         return 0;
1457 }
1458
1459 void
1460 wlsc_output_destroy(struct wlsc_output *output)
1461 {
1462         destroy_surface(&output->background->surface.resource, NULL);
1463 }
1464
1465 void
1466 wlsc_output_move(struct wlsc_output *output, int x, int y)
1467 {
1468         struct wlsc_compositor *c = output->compositor;
1469         int flip;
1470
1471         output->x = x;
1472         output->y = y;
1473
1474         if (output->background) {
1475                 output->background->x = x;
1476                 output->background->y = y;
1477                 wlsc_surface_update_matrix(output->background);
1478         }
1479
1480         pixman_region32_init(&output->previous_damage_region);
1481
1482         wlsc_matrix_init(&output->matrix);
1483         wlsc_matrix_translate(&output->matrix,
1484                               -output->x - output->width / 2.0,
1485                               -output->y - output->height / 2.0, 0);
1486
1487         flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
1488         wlsc_matrix_scale(&output->matrix,
1489                           2.0 / output->width,
1490                           flip * 2.0 / output->height, 1);
1491
1492         pixman_region32_union_rect(&c->damage_region,
1493                                    &c->damage_region,
1494                                    x, y, output->width, output->height);
1495 }
1496
1497 void
1498 wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c,
1499                  int x, int y, int width, int height, uint32_t flags)
1500 {
1501         output->compositor = c;
1502         output->x = x;
1503         output->y = y;
1504         output->width = width;
1505         output->height = height;
1506
1507         output->background =
1508                 background_create(output, option_background);
1509
1510         output->flags = flags;
1511         output->finished = 1;
1512         wlsc_output_move(output, x, y);
1513
1514         output->object.interface = &wl_output_interface;
1515         wl_display_add_object(c->wl_display, &output->object);
1516         wl_display_add_global(c->wl_display, &output->object,
1517                               wlsc_output_post_geometry);
1518 }
1519
1520 int
1521 wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display)
1522 {
1523         struct wl_event_loop *loop;
1524         const char *extensions;
1525
1526         ec->wl_display = display;
1527
1528         wl_compositor_init(&ec->compositor, &compositor_interface, display);
1529
1530         wlsc_shm_init(ec);
1531         eglBindWaylandDisplayWL(ec->display, ec->wl_display);
1532
1533         wl_list_init(&ec->surface_list);
1534         wl_list_init(&ec->input_device_list);
1535         wl_list_init(&ec->output_list);
1536         wl_list_init(&ec->binding_list);
1537
1538         wlsc_shell_init(ec);
1539         wlsc_switcher_init(ec);
1540
1541         wlsc_compositor_add_binding(ec, KEY_BACKSPACE, 0,
1542                                     MODIFIER_CTRL | MODIFIER_ALT,
1543                                     terminate_binding, ec);
1544
1545         create_pointer_images(ec);
1546
1547         screenshooter_create(ec);
1548
1549         extensions = (const char *) glGetString(GL_EXTENSIONS);
1550         if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
1551                 fprintf(stderr,
1552                         "GL_EXT_texture_format_BGRA8888 not available\n");
1553                 return -1;
1554         }
1555
1556         glActiveTexture(GL_TEXTURE0);
1557         if (init_shaders(ec) < 0)
1558                 return -1;
1559
1560         loop = wl_display_get_event_loop(ec->wl_display);
1561         ec->timer_source = wl_event_loop_add_timer(loop, repaint, ec);
1562         pixman_region32_init(&ec->damage_region);
1563         wlsc_compositor_schedule_repaint(ec);
1564
1565         return 0;
1566 }
1567
1568 static void on_term_signal(int signal_number, void *data)
1569 {
1570         struct wlsc_compositor *ec = data;
1571
1572         wl_display_terminate(ec->wl_display);
1573 }
1574
1575 int main(int argc, char *argv[])
1576 {
1577         struct wl_display *display;
1578         struct wlsc_compositor *ec;
1579         struct wl_event_loop *loop;
1580         GError *error = NULL;
1581         GOptionContext *context;
1582         int width, height;
1583
1584         g_type_init(); /* GdkPixbuf needs this, it seems. */
1585
1586         context = g_option_context_new(NULL);
1587         g_option_context_add_main_entries(context, option_entries, "Wayland");
1588         if (!g_option_context_parse(context, &argc, &argv, &error)) {
1589                 fprintf(stderr, "option parsing failed: %s\n", error->message);
1590                 exit(EXIT_FAILURE);
1591         }
1592         if (sscanf(option_geometry, "%dx%d", &width, &height) != 2) {
1593                 fprintf(stderr, "invalid geometry option: %s \n",
1594                         option_geometry);
1595                 exit(EXIT_FAILURE);
1596         }
1597
1598         display = wl_display_create();
1599
1600         ec = NULL;
1601
1602 #if BUILD_WAYLAND_COMPOSITOR
1603         if (getenv("WAYLAND_DISPLAY"))
1604                 ec = wayland_compositor_create(display, width, height);
1605 #endif
1606
1607 #if BUILD_X11_COMPOSITOR
1608         if (ec == NULL && getenv("DISPLAY"))
1609                 ec = x11_compositor_create(display, width, height);
1610 #endif
1611
1612 #if BUILD_OPENWFD_COMPOSITOR
1613         if (ec == NULL && getenv("OPENWFD"))
1614                 ec = wfd_compositor_create(display, option_connector);
1615 #endif
1616
1617 #if BUILD_DRM_COMPOSITOR
1618         if (ec == NULL)
1619                 ec = drm_compositor_create(display, option_connector);
1620 #endif
1621
1622         if (ec == NULL) {
1623                 fprintf(stderr, "failed to create compositor\n");
1624                 exit(EXIT_FAILURE);
1625         }
1626
1627         if (wl_display_add_socket(display, option_socket_name)) {
1628                 fprintf(stderr, "failed to add socket: %m\n");
1629                 exit(EXIT_FAILURE);
1630         }
1631
1632         loop = wl_display_get_event_loop(ec->wl_display);
1633         wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, ec);
1634         wl_event_loop_add_signal(loop, SIGINT, on_term_signal, ec);
1635
1636         wl_display_run(display);
1637
1638         eglUnbindWaylandDisplayWL(ec->display, display);
1639         wl_display_destroy(display);
1640
1641         ec->destroy(ec);
1642
1643         return 0;
1644 }