source/main.c

   1 #define GL_GLEXT_PROTOTYPES
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <signal.h>
   6 #include <X11/Xlib.h>
   7 #include <X11/extensions/Xcomposite.h>
   8 #include <X11/extensions/Xdamage.h>
   9 #include <X11/extensions/shape.h>
  10 #include <GL/gl.h>
  11 #include <GL/glx.h>
  12
  13 typedef struct CompositedWindow
  14 {
  15         Window window;
  16         int x;
  17         int y;
  18         unsigned width;
  19         unsigned height;
  20         unsigned border;
  21         int map_state;
  22         Damage damage;
  23         Pixmap pixmap;
  24         GLXPixmap glx_pixmap;
  25         unsigned texture;
  26 } CompositedWindow;
  27
  28 typedef struct CompositedScreen
  29 {
  30         int number;
  31         Window root;
  32         unsigned width;
  33         unsigned height;
  34         Window overlay;
  35         Window render_window;
  36         GLXFBConfig fbconfig;
  37         GLXWindow glx_window;
  38         GLXContext glx_context;
  39         unsigned shaders[2];
  40         unsigned program;
  41         unsigned geometry_loc;
  42         unsigned vertex_buffer;
  43         unsigned vertex_array;
  44         CompositedWindow *windows;
  45         unsigned nwindows;
  46         unsigned windows_capacity;
  47         int dirty;
  48 } CompositedScreen;
  49
  50 typedef struct Compositor
  51 {
  52         Display *display;
  53         CompositedScreen *screens;
  54         unsigned nscreens;
  55         int damage_event;
  56         PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB;
  57         PFNGLXBINDTEXIMAGEEXTPROC glXBindTexImageEXT;
  58         PFNGLXRELEASETEXIMAGEEXTPROC glXReleaseTexImageEXT;
  59         int dirty;
  60 } Compositor;
  61
  62 static const char *vshader =
  63         "#version 150\n"
  64         "uniform vec4 geometry;\n"
  65         "in vec2 vertex;\n"
  66         "in vec2 texture_coord;\n"
  67         "out vec2 texcoord;\n"
  68         "void main()\n"
  69         "{\n"
  70         "  gl_Position = vec4((geometry.xy+vertex*geometry.zw)*2.0-1.0, 0.0, 1.0);\n"
  71         "  texcoord = texture_coord;\n"
  72         "}\n";
  73
  74 static const char *fshader =
  75         "#version 150\n"
  76         "uniform sampler2D image;\n"
  77         "in vec2 texcoord;\n"
  78         "out vec4 frag_color;\n"
  79         "void main()\n"
  80         "{\n"
  81         "       frag_color = texture(image, texcoord);\n"
  82         "}\n";
  83
  84 static const float vertices[] =
  85 {
  86         /* vertex    texcoord */
  87         0.0f, 1.0f,  0.0f, 0.0f,
  88         0.0f, 0.0f,  0.0f, 1.0f,
  89         1.0f, 1.0f,  1.0f, 0.0f,
  90         1.0f, 0.0f,  1.0f, 1.0f
  91 };
  92
  93 int terminate_requested = 0;
  94
  95 int x_error_handler(Display *display, XErrorEvent *event)
  96 {
  97         printf("Ignoring X error %d on resource %lx\n", event->error_code, event->resourceid);
  98         (void)display;
  99         return 0;
 100 }
 101
 102 int with_error(const char *message)
 103 {
 104         fprintf(stderr, "%s\n", message);
 105         return 0;
 106 }
 107
 108 int initialize_gl(Compositor *compositor, CompositedScreen *screen)
 109 {
 110         int attribs[9];
 111         unsigned i;
 112         GLXFBConfig *configs;
 113         int nconfigs;
 114         XVisualInfo *vi;
 115         XSetWindowAttributes win_attr;
 116
 117         i = 0;
 118         attribs[i++] = GLX_DRAWABLE_TYPE;
 119         attribs[i++] = GLX_WINDOW_BIT;
 120         attribs[i++] = GLX_RENDER_TYPE;
 121         attribs[i++] = GLX_RGBA_BIT;
 122         attribs[i++] = GLX_DOUBLEBUFFER;
 123         attribs[i++] = True;
 124         attribs[i++] = GLX_BIND_TO_TEXTURE_RGBA_EXT;
 125         attribs[i++] = True;
 126         attribs[i] = None;
 127
 128         configs = glXChooseFBConfig(compositor->display, screen->number, attribs, &nconfigs);
 129         if(!configs || !nconfigs)
 130                 return with_error("Could not find a suitable FBConfig");
 131         screen->fbconfig = configs[0];
 132         XFree(configs);
 133
 134         vi = glXGetVisualFromFBConfig(compositor->display, screen->fbconfig);
 135         win_attr.colormap = XCreateColormap(compositor->display, screen->root, vi->visual, AllocNone);
 136         screen->render_window = XCreateWindow(compositor->display, screen->overlay, 0, 0, screen->width, screen->height, 0, vi->depth, InputOutput, vi->visual, CWColormap, &win_attr);
 137         XMapWindow(compositor->display, screen->render_window);
 138
 139         screen->glx_window = glXCreateWindow(compositor->display, screen->fbconfig, screen->render_window, NULL);
 140
 141         i = 0;
 142         attribs[i++] = GLX_CONTEXT_FLAGS_ARB;
 143         attribs[i++] = GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
 144         attribs[i++] = GLX_CONTEXT_MAJOR_VERSION_ARB;
 145         attribs[i++] = 3;
 146         attribs[i++] = GLX_CONTEXT_MINOR_VERSION_ARB;
 147         attribs[i++] = 0;
 148         attribs[i] = None;
 149
 150         screen->glx_context = compositor->glXCreateContextAttribsARB(compositor->display, screen->fbconfig, NULL, True, attribs);
 151
 152         XFree(vi);
 153
 154         return 1;
 155 }
 156
 157 void use_gl(Compositor *compositor, CompositedScreen *screen)
 158 {
 159         glXMakeContextCurrent(compositor->display, screen->glx_window, screen->glx_window, screen->glx_context);
 160 }
 161
 162 unsigned compile_shader(GLenum type, const char *source)
 163 {
 164         unsigned shader;
 165         int status;
 166         char info_log[1024];
 167         GLsizei length;
 168
 169         shader = glCreateShader(type);
 170         glShaderSource(shader, 1, &source, NULL);
 171         glCompileShader(shader);
 172         glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
 173         glGetShaderInfoLog(shader, sizeof(info_log), &length, info_log);
 174         if(!status)
 175         {
 176                 fprintf(stderr, "Shader compilation failed:\n%s\n", info_log);
 177                 glDeleteShader(shader);
 178                 return 0;
 179         }
 180         else if(length)
 181                 printf("Shader info log:\n%s\n", info_log);
 182
 183         return shader;
 184 }
 185
 186 unsigned link_program(unsigned *shaders, unsigned nshaders)
 187 {
 188         unsigned program;
 189         unsigned i;
 190         int status;
 191         char info_log[1024];
 192         GLsizei length;
 193
 194         program = glCreateProgram();
 195         for(i=0; i<nshaders; ++i)
 196                 glAttachShader(program, shaders[i]);
 197         glBindAttribLocation(program, 0, "vertex");
 198         glBindAttribLocation(program, 1, "texture_coord");
 199         glBindFragDataLocation(program, 0, "frag_color");
 200         glLinkProgram(program);
 201
 202         glGetProgramiv(program, GL_LINK_STATUS, &status);
 203         glGetProgramInfoLog(program, sizeof(info_log), &length, info_log);
 204         if(!status)
 205         {
 206                 fprintf(stderr, "Program link failed:\n%s\n", info_log);
 207                 glDeleteProgram(program);
 208                 return 0;
 209         }
 210         else if(length)
 211                 printf("Program info log:\n%s\n", info_log);
 212
 213         return program;
 214 }
 215
 216 int create_gl_resources(Compositor *compositor, CompositedScreen *screen)
 217 {
 218         unsigned stride;
 219
 220         use_gl(compositor, screen);
 221
 222         screen->shaders[0] = compile_shader(GL_VERTEX_SHADER, vshader);
 223         screen->shaders[1] = compile_shader(GL_FRAGMENT_SHADER, fshader);
 224         if(!screen->shaders[0] || !screen->shaders[1])
 225                 return 0;
 226
 227         screen->program = link_program(screen->shaders, 2);
 228         if(!screen->program)
 229                 return 0;
 230
 231         screen->geometry_loc = glGetUniformLocation(screen->program, "geometry");
 232
 233         glGenBuffers(1, &screen->vertex_buffer);
 234         glBindBuffer(GL_ARRAY_BUFFER, screen->vertex_buffer);
 235         glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 236
 237         stride = 4*sizeof(float);
 238         glGenVertexArrays(1, &screen->vertex_array);
 239         glBindVertexArray(screen->vertex_array);
 240         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, stride, NULL);
 241         glEnableVertexAttribArray(0);
 242         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride, (void *)(2*sizeof(float)));
 243         glEnableVertexAttribArray(1);
 244         glBindVertexArray(0);
 245
 246         glBindBuffer(GL_ARRAY_BUFFER, 0);
 247
 248         return 1;
 249 }
 250
 251 CompositedWindow *find_window(CompositedScreen *screen, Window w)
 252 {
 253         unsigned i;
 254
 255         for(i=0; i<screen->nwindows; ++i)
 256                 if(screen->windows[i].window==w)
 257                         return &screen->windows[i];
 258
 259         return NULL;
 260 }
 261
 262 void create_window_pixmap(Compositor *compositor, CompositedScreen *screen, CompositedWindow *window)
 263 {
 264         int attribs[5];
 265         unsigned i;
 266
 267         if(window->pixmap)
 268         {
 269                 glXDestroyPixmap(compositor->display, window->glx_pixmap);
 270                 XFreePixmap(compositor->display, window->pixmap);
 271         }
 272
 273         i = 0;
 274         attribs[i++] = GLX_TEXTURE_TARGET_EXT;
 275         attribs[i++] = GLX_TEXTURE_2D_EXT;
 276         attribs[i++] = GLX_TEXTURE_FORMAT_EXT;
 277         attribs[i++] = GLX_TEXTURE_FORMAT_RGBA_EXT;
 278         attribs[i++] = None;
 279
 280         window->pixmap = XCompositeNameWindowPixmap(compositor->display, window->window);
 281         window->glx_pixmap = glXCreatePixmap(compositor->display, screen->fbconfig, window->pixmap, attribs);
 282 }
 283
 284 CompositedWindow *add_window(Compositor *compositor, CompositedScreen *screen, Window w)
 285 {
 286         CompositedWindow *window;
 287         XWindowAttributes win_attr;
 288
 289         if(w==screen->root || w==screen->overlay)
 290                 return NULL;
 291
 292         if(!XGetWindowAttributes(compositor->display, w, &win_attr))
 293         {
 294                 printf("XGetWindowAttributes failed; probably the window was already destroyed\n");
 295                 return NULL;
 296         }
 297         if(win_attr.class==InputOnly)
 298                 return NULL;
 299
 300         if(find_window(screen, w))
 301                 return NULL;
 302
 303         if(screen->nwindows==screen->windows_capacity)
 304         {
 305                 screen->windows = (CompositedWindow *)realloc(screen->windows, (screen->windows_capacity+1)*sizeof(CompositedWindow));
 306                 ++screen->windows_capacity;
 307         }
 308
 309         window = &screen->windows[screen->nwindows++];
 310
 311         window->window = w;
 312         window->x = win_attr.x;
 313         window->y = win_attr.y;
 314         window->width = win_attr.width;
 315         window->height = win_attr.height;
 316         window->border = win_attr.border_width;
 317         window->map_state = win_attr.map_state;
 318
 319         window->damage = XDamageCreate(compositor->display, window->window, XDamageReportNonEmpty);
 320         window->pixmap = None;
 321         window->glx_pixmap = None;
 322
 323         XCompositeRedirectWindow(compositor->display, window->window, CompositeRedirectManual);
 324         if(window->map_state==IsViewable)
 325                 create_window_pixmap(compositor, screen, window);
 326
 327         glGenTextures(1, &window->texture);
 328         glBindTexture(GL_TEXTURE_2D, window->texture);
 329         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 330         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 331         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 332
 333         return window;
 334 }
 335
 336 void remove_window(Compositor *compositor, CompositedScreen *screen, CompositedWindow *window, int destroyed)
 337 {
 338         unsigned i;
 339
 340         glDeleteTextures(1, &window->texture);
 341         if(!destroyed)
 342         {
 343                 XDamageDestroy(compositor->display, window->damage);
 344                 if(window->pixmap)
 345                 {
 346                         glXDestroyPixmap(compositor->display, window->glx_pixmap);
 347                         XFreePixmap(compositor->display, window->pixmap);
 348                 }
 349                 XCompositeUnredirectWindow(compositor->display, window->window, CompositeRedirectManual);
 350         }
 351
 352         --screen->nwindows;
 353         for(i=window-screen->windows; i<screen->nwindows; ++i)
 354                 screen->windows[i] = screen->windows[i+1];
 355 }
 356
 357 CompositedWindow *reorder_window(CompositedScreen *screen, CompositedWindow *window, Window above)
 358 {
 359         unsigned i, j;
 360         CompositedWindow hold;
 361
 362         i = window-screen->windows;
 363         if(above)
 364         {
 365                 for(j=0; j<screen->nwindows; ++j)
 366                         if(screen->windows[j].window==above)
 367                                 break;
 368
 369                 if(j>=screen->nwindows || i==j+1)
 370                         return window;
 371
 372                 if(j<i)
 373                         ++j;
 374         }
 375         else
 376                 j = 0;
 377
 378         hold = *window;
 379         if(i<j)
 380         {
 381                 for(; i<j; ++i)
 382                         screen->windows[i] = screen->windows[i+1];
 383         }
 384         else
 385         {
 386                 for(; i>j; --i)
 387                         screen->windows[i] = screen->windows[i-1];
 388         }
 389         screen->windows[j] = hold;
 390
 391         return &screen->windows[j];
 392 }
 393
 394 CompositedScreen *find_screen_by_root(Compositor *compositor, Window root)
 395 {
 396         unsigned i;
 397
 398         for(i=0; i<compositor->nscreens; ++i)
 399                 if(compositor->screens[i].root==root)
 400                         return &compositor->screens[i];
 401
 402         return NULL;
 403 }
 404
 405 CompositedScreen *find_screen_by_window(Compositor *compositor, Window w)
 406 {
 407         unsigned i, j;
 408
 409         for(i=0; i<compositor->nscreens; ++i)
 410                 for(j=0; j<compositor->screens[i].nwindows; ++j)
 411                         if(compositor->screens[i].windows[j].window==w)
 412                                 return &compositor->screens[i];
 413
 414         return NULL;
 415 }
 416
 417 int initialize_screen(Compositor *compositor, unsigned number)
 418 {
 419         CompositedScreen *screen;
 420         const char *extensions;
 421         Window dummy_root;
 422         int x, y;
 423         unsigned border;
 424         unsigned depth;
 425         Window dummy_parent;
 426         Window *children;
 427         unsigned nchildren;
 428         unsigned i;
 429
 430         screen = &compositor->screens[number];
 431         screen->number = number;
 432
 433         extensions = glXQueryExtensionsString(compositor->display, screen->number);
 434         if(!strstr(extensions, "GLX_ARB_create_context"))
 435                 return with_error("GLX_ARB_create_context is required");
 436         if(!strstr(extensions, "GLX_EXT_texture_from_pixmap"))
 437                 return with_error("GLX_EXT_texture_from_pixmap is required");
 438
 439         screen->root = RootWindow(compositor->display, screen->number);
 440         XSelectInput(compositor->display, screen->root, SubstructureNotifyMask);
 441         screen->overlay = XCompositeGetOverlayWindow(compositor->display, screen->root);
 442         XGetGeometry(compositor->display, screen->overlay, &dummy_root, &x, &y, &screen->width, &screen->height, &border, &depth);
 443         XShapeCombineRectangles(compositor->display, screen->overlay, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted);
 444
 445         if(!initialize_gl(compositor, screen))
 446                 return 0;
 447
 448         if(!create_gl_resources(compositor, screen))
 449                 return 0;
 450
 451         XQueryTree(compositor->display, screen->root, &dummy_root, &dummy_parent, &children, &nchildren);
 452
 453         screen->windows = (CompositedWindow *)malloc(nchildren*sizeof(CompositedWindow));
 454         screen->nwindows = 0;
 455         screen->windows_capacity = nchildren;
 456
 457         for(i=0; i<nchildren; ++i)
 458                 add_window(compositor, screen, children[i]);
 459
 460         XFree(children);
 461
 462         screen->dirty = 1;
 463
 464         return 1;
 465 }
 466
 467 int initialize_compositor(Compositor *compositor)
 468 {
 469         int event_base;
 470         int error_base;
 471         int major_ver;
 472         int minor_ver;
 473         unsigned i;
 474
 475         compositor->display = XOpenDisplay(NULL);
 476         if(!compositor->display)
 477                 return with_error("Could not open X display");
 478
 479         XSetErrorHandler(&x_error_handler);
 480
 481         if(!XCompositeQueryExtension(compositor->display, &event_base, &error_base))
 482                 return with_error("XComposite is required but was not found");
 483         else if(!XCompositeQueryVersion(compositor->display, &major_ver, &minor_ver))
 484                 return with_error("Cannot determine XComposite version");
 485         else if(major_ver==0 && minor_ver<3)
 486                 return with_error("XComposite 0.3 or later is required");
 487
 488         if(!glXQueryExtension(compositor->display, &event_base, &error_base))
 489                 return with_error("GLX is required but was not found");
 490         else if(!glXQueryVersion(compositor->display, &major_ver, &minor_ver))
 491                 return with_error("Cannot determine GLX version");
 492         else if(major_ver<1 || (major_ver==1 && minor_ver<4))
 493                 return with_error("GLX 1.4 or later is required");
 494
 495         if(!XDamageQueryExtension(compositor->display, &compositor->damage_event, &error_base))
 496                 return with_error("XDamage is required but was not found");
 497         else if(!XDamageQueryVersion(compositor->display, &major_ver, &minor_ver))
 498                 return with_error("Cannot determine XDamage version");
 499         else if(major_ver<1)
 500                 return with_error("XDamage 1.0 or later is required");
 501
 502         if(!XShapeQueryExtension(compositor->display, &event_base, &error_base))
 503                 return with_error("XShape is required but was not found");
 504         else if(!XShapeQueryVersion(compositor->display, &major_ver, &minor_ver))
 505                 return with_error("Cannot determine XShape version");
 506         else if(major_ver<1 || (major_ver==1 && minor_ver<1))
 507                 return with_error("XShape 1.1 or later is required");
 508
 509         compositor->glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddress((unsigned char *)"glXCreateContextAttribsARB");
 510         compositor->glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress((unsigned char *)"glXBindTexImageEXT");
 511         compositor->glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress((unsigned char *)"glXReleaseTexImageEXT");
 512
 513         compositor->nscreens = ScreenCount(compositor->display);
 514         compositor->screens = (CompositedScreen *)malloc(compositor->nscreens*sizeof(CompositedScreen));
 515         for(i=0; i<compositor->nscreens; ++i)
 516                 if(!initialize_screen(compositor, i))
 517                         return 0;
 518
 519         compositor->dirty = 1;
 520
 521         return 1;
 522 }
 523
 524 void shutdown_screen(Compositor *compositor, CompositedScreen *screen)
 525 {
 526         unsigned i;
 527
 528         use_gl(compositor, screen);
 529
 530         for(i=0; i<screen->nwindows; ++i)
 531         {
 532                 glDeleteTextures(1, &screen->windows[i].texture);
 533                 if(screen->windows[i].pixmap)
 534                 {
 535                         glXDestroyPixmap(compositor->display, screen->windows[i].glx_pixmap);
 536                         XFreePixmap(compositor->display, screen->windows[i].pixmap);
 537                         XDamageDestroy(compositor->display, screen->windows[i].damage);
 538                 }
 539         }
 540
 541         glXMakeContextCurrent(compositor->display, 0, 0, NULL);
 542         glXDestroyContext(compositor->display, screen->glx_context);
 543         glXDestroyWindow(compositor->display, screen->glx_window);
 544         XDestroyWindow(compositor->display, screen->render_window);
 545
 546         XCompositeReleaseOverlayWindow(compositor->display, screen->overlay);
 547
 548         free(screen->windows);
 549 }
 550
 551 void shutdown_compositor(Compositor *compositor)
 552 {
 553         unsigned i;
 554
 555         for(i=0; i<compositor->nscreens; ++i)
 556                 shutdown_screen(compositor, &compositor->screens[i]);
 557         free(compositor->screens);
 558
 559         XCloseDisplay(compositor->display);
 560 }
 561
 562 void mark_dirty(Compositor *compositor, CompositedScreen *screen)
 563 {
 564         compositor->dirty = 1;
 565         screen->dirty = 1;
 566 }
 567
 568 void process_create_window_event(Compositor *compositor, XCreateWindowEvent *event)
 569 {
 570         CompositedScreen *screen;
 571
 572         if((screen = find_screen_by_root(compositor, event->parent)))
 573                 add_window(compositor, screen, event->window);
 574 }
 575
 576 void process_destroy_window_event(Compositor *compositor, XDestroyWindowEvent *event)
 577 {
 578         CompositedScreen *screen;
 579         CompositedWindow *window;
 580
 581         if((screen = find_screen_by_root(compositor, event->event)))
 582                 if((window = find_window(screen, event->window)))
 583                         remove_window(compositor, screen, window, 1);
 584 }
 585
 586 void process_map_event(Compositor *compositor, XMapEvent *event)
 587 {
 588         CompositedScreen *screen;
 589         CompositedWindow *window;
 590
 591         screen = find_screen_by_root(compositor, event->event);
 592         if(!screen)
 593                 return;
 594
 595         window = find_window(screen, event->window);
 596         if(!window)
 597                 return;
 598
 599         window->map_state = IsViewable;
 600         create_window_pixmap(compositor, screen, window);
 601
 602         mark_dirty(compositor, screen);
 603 }
 604
 605 void process_unmap_event(Compositor *compositor, XUnmapEvent *event)
 606 {
 607         CompositedScreen *screen;
 608         CompositedWindow *window;
 609
 610         screen = find_screen_by_root(compositor, event->event);
 611         if(!screen)
 612                 return;
 613
 614         window = find_window(screen, event->window);
 615         if(window)
 616                 window->map_state = IsUnviewable;
 617
 618         mark_dirty(compositor, screen);
 619 }
 620
 621 void process_reparent_event(Compositor *compositor, XReparentEvent *event)
 622 {
 623         CompositedScreen *screen;
 624         CompositedWindow *window;
 625
 626         screen = find_screen_by_root(compositor, event->event);
 627         if(!screen)
 628                 return;
 629
 630         if(event->parent==screen->root)
 631                 window = add_window(compositor, screen, event->window);
 632         else
 633         {
 634                 window = find_window(screen, event->window);
 635                 if(!window)
 636                         return;
 637
 638                 remove_window(compositor, screen, window, 0);
 639         }
 640
 641         if(window && window->map_state==IsViewable)
 642                 mark_dirty(compositor, screen);
 643 }
 644
 645 void process_configure_event(Compositor *compositor, XConfigureEvent *event)
 646 {
 647         CompositedScreen *screen;
 648         CompositedWindow *window;
 649
 650         screen = find_screen_by_root(compositor, event->event);
 651         if(!screen)
 652                 return;
 653
 654         window = find_window(screen, event->window);
 655         if(!window)
 656                 return;
 657
 658         window->x = event->x;
 659         window->y = event->y;
 660         if((unsigned)event->width!=window->width || (unsigned)event->height!=window->height || (unsigned)event->border_width!=window->border)
 661         {
 662                 window->width = event->width;
 663                 window->height = event->height;
 664                 window->border = event->border_width;
 665                 create_window_pixmap(compositor, screen, window);
 666         }
 667         reorder_window(screen, window, event->above);
 668
 669         if(window->map_state==IsViewable)
 670                 mark_dirty(compositor, screen);
 671 }
 672
 673 void process_damage_event(Compositor *compositor, XDamageNotifyEvent *event)
 674 {
 675         CompositedScreen *screen;
 676         CompositedWindow *window;
 677
 678         screen = find_screen_by_window(compositor, event->drawable);
 679         if(!screen)
 680                 return;
 681
 682         window = find_window(screen, event->drawable);
 683         if(window->map_state==IsViewable)
 684                 mark_dirty(compositor, screen);
 685 }
 686
 687 int process_event(Compositor *compositor)
 688 {
 689         XEvent event;
 690         if(compositor->dirty)
 691         {
 692                 if(!XCheckMaskEvent(compositor->display, -1, &event))
 693                         return 0;
 694         }
 695         else
 696                 XNextEvent(compositor->display, &event);
 697
 698         switch(event.type)
 699         {
 700         case CreateNotify:
 701                 process_create_window_event(compositor, &event.xcreatewindow);
 702                 break;
 703         case DestroyNotify:
 704                 process_destroy_window_event(compositor, &event.xdestroywindow);
 705                 break;
 706         case MapNotify:
 707                 process_map_event(compositor, &event.xmap);
 708                 break;
 709         case UnmapNotify:
 710                 process_unmap_event(compositor, &event.xunmap);
 711                 break;
 712         case ReparentNotify:
 713                 process_reparent_event(compositor, &event.xreparent);
 714                 break;
 715         case ConfigureNotify:
 716                 process_configure_event(compositor, &event.xconfigure);
 717                 break;
 718         default:
 719                 if(event.type==compositor->damage_event+XDamageNotify)
 720                         process_damage_event(compositor, (XDamageNotifyEvent *)&event);
 721                 else
 722                         printf("Event %d\n", event.type);
 723         }
 724
 725         return 1;
 726 }
 727
 728 void refresh_screen(Compositor *compositor, CompositedScreen *screen)
 729 {
 730         unsigned i;
 731
 732         use_gl(compositor, screen);
 733
 734         glClearColor(0.5f, 0.5f, 0.5f, 0.0f);
 735         glClear(GL_COLOR_BUFFER_BIT);
 736
 737         glUseProgram(screen->program);
 738         glBindVertexArray(screen->vertex_array);
 739         for(i=0; i<screen->nwindows; ++i)
 740         {
 741                 CompositedWindow *window = &screen->windows[i];
 742                 if(window->map_state!=IsViewable)
 743                         continue;
 744
 745                 glBindTexture(GL_TEXTURE_2D, window->texture);
 746                 compositor->glXBindTexImageEXT(compositor->display, window->glx_pixmap, GLX_FRONT_LEFT_EXT, NULL);
 747                 glUniform4f(screen->geometry_loc,
 748                         (float)window->x/screen->width, (float)(screen->height-window->y-window->height)/screen->height,
 749                         (float)(window->width+2*window->border)/screen->width, (float)(window->height+2*window->border)/screen->height);
 750                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 751                 compositor->glXReleaseTexImageEXT(compositor->display, window->glx_pixmap, GLX_FRONT_LEFT_EXT);
 752                 XDamageSubtract(compositor->display, window->damage, None, None);
 753         }
 754
 755         glXSwapBuffers(compositor->display, screen->glx_window);
 756
 757         screen->dirty = 0;
 758 }
 759
 760 void refresh_all_screens(Compositor *compositor)
 761 {
 762         unsigned i;
 763
 764         for(i=0; i<compositor->nscreens; ++i)
 765         {
 766                 CompositedScreen *screen = &compositor->screens[i];
 767                 if(screen->dirty)
 768                         refresh_screen(compositor, screen);
 769         }
 770
 771         compositor->dirty = 0;
 772 }
 773
 774 void sighandler(int sig)
 775 {
 776         terminate_requested = 1;
 777         (void)sig;
 778 }
 779
 780 int main()
 781 {
 782         Compositor compositor;
 783
 784         signal(SIGINT, &sighandler);
 785         signal(SIGTERM, &sighandler);
 786
 787         if(!initialize_compositor(&compositor))
 788                 return 1;
 789
 790         while(!terminate_requested)
 791         {
 792                 if(!process_event(&compositor))
 793                         refresh_all_screens(&compositor);
 794         }
 795
 796         shutdown_compositor(&compositor);
 797
 798         return 0;
 799 }