xcompmgr.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright © 2003 Keith Packard
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of Keith Packard not be used in
  11  * advertising or publicity pertaining to distribution of the software without
  12  * specific, written prior permission.  Keith Packard makes no
  13  * representations about the suitability of this software for any purpose.  It
  14  * is provided "as is" without express or implied warranty.
  15  *
  16  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  18  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  22  * PERFORMANCE OF THIS SOFTWARE.
  23  */
  24
  25
  26 /* Modified by Matthew Hawn. I don't know what to say here so follow what it
  27    says above. Not that I can really do anything about it
  28 */
  29
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <math.h>
  35 #include <sys/poll.h>
  36 #include <sys/time.h>
  37 #include <time.h>
  38 #include <unistd.h>
  39 #include <X11/Xlib.h>
  40 #include <X11/Xutil.h>
  41 #include <X11/Xatom.h>
  42 #include <X11/extensions/Xcomposite.h>
  43 #include <X11/extensions/Xdamage.h>
  44 #include <X11/extensions/Xrender.h>
  45
  46 #if COMPOSITE_MAJOR > 0 || COMPOSITE_MINOR >= 2
  47 #define HAS_NAME_WINDOW_PIXMAP 1
  48 #endif
  49
  50 #define CAN_DO_USABLE 0
  51
  52 typedef struct _ignore {
  53     struct _ignore      *next;
  54     unsigned long       sequence;
  55 } ignore;
  56
  57 typedef struct _win {
  58     struct _win         *next;
  59     Window              id;
  60 #if HAS_NAME_WINDOW_PIXMAP
  61     Pixmap              pixmap;
  62 #endif
  63     XWindowAttributes   a;
  64 #if CAN_DO_USABLE
  65     Bool                usable;             /* mapped and all damaged at one point */
  66     XRectangle          damage_bounds;      /* bounds of damage */
  67 #endif
  68     int                 mode;
  69     int                 damaged;
  70     Damage              damage;
  71     Picture             picture;
  72     Picture             alphaPict;
  73     Picture             shadowPict;
  74     XserverRegion       borderSize;
  75     XserverRegion       extents;
  76     Picture             shadow;
  77     int                 shadow_dx;
  78     int                 shadow_dy;
  79     int                 shadow_width;
  80     int                 shadow_height;
  81     unsigned int        opacity;
  82
  83     unsigned long       damage_sequence;    /* sequence when damage was created */
  84
  85     /* for drawing translucent windows */
  86     XserverRegion       borderClip;
  87     struct _win         *prev_trans;
  88 } win;
  89
  90 typedef struct _conv {
  91     int     size;
  92     double  *data;
  93 } conv;
  94
  95 typedef struct _fade {
  96     struct _fade        *next;
  97     win                 *w;
  98     double              cur;
  99     double              step;
 100     void                (*callback) (Display *dpy, win *w, Bool gone);
 101     Display             *dpy;
 102     Bool                gone;
 103 } fade;
 104
 105 win             *list;
 106 fade            *fades;
 107 Display         *dpy;
 108 int             scr;
 109 Window          root;
 110 Picture         rootPicture;
 111 Picture         rootBuffer;
 112 Picture         blackPicture;
 113 Picture         transBlackPicture;
 114 Picture         rootTile;
 115 XserverRegion   allDamage;
 116 Bool            clipChanged;
 117 #if HAS_NAME_WINDOW_PIXMAP
 118 Bool            hasNamePixmap;
 119 #endif
 120 int             root_height, root_width;
 121 ignore          *ignore_head, **ignore_tail = &ignore_head;
 122 int             xfixes_event, xfixes_error;
 123 int             damage_event, damage_error;
 124 int             composite_event, composite_error;
 125 int             render_event, render_error;
 126 Bool            synchronize;
 127 int             composite_opcode;
 128
 129 /* find these once and be done with it */
 130 Atom            opacityAtom;
 131
 132 /* opacity property name; sometime soon I'll write up an EWMH spec for it */
 133 #define OPACITY_PROP    "_NET_WM_WINDOW_OPACITY"
 134
 135 #define TRANSLUCENT     0xe0000000
 136 #define OPAQUE          0xffffffff
 137
 138 conv            *gaussianMap;
 139
 140 #define WINDOW_SOLID    0
 141 #define WINDOW_TRANS    1
 142 #define WINDOW_ARGB     2
 143
 144 #define TRANS_OPACITY   0.75
 145
 146 #define DEBUG_REPAINT 0
 147 #define DEBUG_EVENTS 0
 148 #define MONITOR_REPAINT 0
 149
 150 #define SHADOWS         1
 151 #define SHARP_SHADOW    0
 152
 153 typedef enum _compMode {
 154     CompSimple,         /* looks like a regular X server */
 155     CompServerShadows,  /* use window alpha for shadow; sharp, but precise */
 156     CompClientShadows,  /* use window extents for shadow, blurred */
 157 } CompMode;
 158
 159 static void
 160 determine_mode(Display *dpy, win *w);
 161
 162 CompMode    compMode = CompSimple;
 163
 164 int         shadowRadius = 12;
 165
 166 double  fade_step =     0.05;
 167 int     fade_delta =    10;
 168 int     fade_time =     0;
 169 Bool    fadeWindows;
 170
 171 Bool    autoRedirect = False;
 172
 173 int
 174 get_time_in_milliseconds ()
 175 {
 176     struct timeval  tv;
 177
 178     gettimeofday (&tv, NULL);
 179     return tv.tv_sec * 1000 + tv.tv_usec / 1000;
 180 }
 181
 182 fade *
 183 find_fade (win *w)
 184 {
 185     fade    *f;
 186
 187     for (f = fades; f; f = f->next)
 188     {
 189         if (f->w == w)
 190             return f;
 191     }
 192     return 0;
 193 }
 194
 195 void
 196 dequeue_fade (Display *dpy, fade *f)
 197 {
 198     fade    **prev;
 199
 200     for (prev = &fades; *prev; prev = &(*prev)->next)
 201         if (*prev == f)
 202         {
 203             *prev = f->next;
 204             if (f->callback)
 205                 (*f->callback) (dpy, f->w, f->gone);
 206             free (f);
 207             break;
 208         }
 209 }
 210
 211 void
 212 cleanup_fade (Display *dpy, win *w)
 213 {
 214     fade *f = find_fade (w);
 215     if (f)
 216         dequeue_fade (dpy, f);
 217 }
 218
 219 void
 220 enqueue_fade (Display *dpy, fade *f)
 221 {
 222     if (!fades)
 223         fade_time = get_time_in_milliseconds () + fade_delta;
 224     f->next = fades;
 225     fades = f;
 226 }
 227
 228 static void
 229 set_fade (Display *dpy, win *w, Bool in,
 230           void (*callback) (Display *dpy, win *w, Bool gone),
 231           Bool gone)
 232 {
 233     fade    *f;
 234
 235     f = find_fade (w);
 236     if (!f)
 237     {
 238         f = malloc (sizeof (fade));
 239         f->next = 0;
 240         f->w = w;
 241         if (in)
 242             f->cur = 0;
 243         else
 244             f->cur = 1;
 245         enqueue_fade (dpy, f);
 246     }
 247     if (in)
 248         f->step = fade_step;
 249     else
 250         f->step = -fade_step;
 251     f->callback = callback;
 252     f->gone = gone;
 253     w->opacity = f->cur * OPAQUE;
 254 #if 0
 255     printf ("set_fade start %g step %g\n", f->cur, f->step);
 256 #endif
 257     determine_mode (dpy, w);
 258 }
 259
 260 int
 261 fade_timeout (void)
 262 {
 263     int now;
 264     int delta;
 265     if (!fades)
 266         return -1;
 267     now = get_time_in_milliseconds();
 268     delta = fade_time - now;
 269     if (delta < 0)
 270         delta = 0;
 271 /*    printf ("timeout %d\n", delta); */
 272     return delta;
 273 }
 274
 275 void
 276 run_fades (Display *dpy)
 277 {
 278     int     now = get_time_in_milliseconds();
 279     fade    *f, *next;
 280     int     steps;
 281
 282 #if 0
 283     printf ("run fades\n");
 284 #endif
 285     if (fade_time - now > 0)
 286         return;
 287     steps = 1 + (now - fade_time) / fade_delta;
 288     for (next = fades; f = next; )
 289     {
 290         win *w = f->w;
 291         next = f->next;
 292         f->cur += f->step * steps;
 293         if (f->cur >= 1)
 294             f->cur = 1;
 295         else if (f->cur < 0)
 296             f->cur = 0;
 297 #if 0
 298         printf ("opacity now %g\n", f->cur);
 299 #endif
 300         w->opacity = f->cur * OPAQUE;
 301         if (f->step > 0)
 302         {
 303             if (f->cur >= 1)
 304                 dequeue_fade (dpy, f);
 305         }
 306         else
 307         {
 308             if (f->cur <= 0)
 309                 dequeue_fade (dpy, f);
 310         }
 311         determine_mode (dpy, w);
 312     }
 313     fade_time = now + fade_delta;
 314 }
 315
 316 #define SHADOW_OPACITY  0.75
 317 #define SHADOW_OFFSET_X (-shadowRadius * 5 / 4)
 318 #define SHADOW_OFFSET_Y (-shadowRadius * 5 / 4)
 319
 320 static double
 321 gaussian (double r, double x, double y)
 322 {
 323     return ((1 / (sqrt (2 * M_PI * r))) *
 324             exp ((- (x * x + y * y)) / (2 * r * r)));
 325 }
 326
 327
 328 static conv *
 329 make_gaussian_map (Display *dpy, double r)
 330 {
 331     conv            *c;
 332     int             size = ((int) ceil ((r * 3)) + 1) & ~1;
 333     int             center = size / 2;
 334     int             x, y;
 335     double          t;
 336     double          g;
 337
 338     c = malloc (sizeof (conv) + size * size * sizeof (double));
 339     c->size = size;
 340     c->data = (double *) (c + 1);
 341     t = 0.0;
 342     for (y = 0; y < size; y++)
 343         for (x = 0; x < size; x++)
 344         {
 345             g = gaussian (r, (double) (x - center), (double) (y - center));
 346             t += g;
 347             c->data[y * size + x] = g;
 348         }
 349 /*    printf ("gaussian total %f\n", t); */
 350     for (y = 0; y < size; y++)
 351         for (x = 0; x < size; x++)
 352         {
 353             c->data[y*size + x] /= t;
 354         }
 355     return c;
 356 }
 357
 358 /*
 359  * A picture will help
 360  *
 361  *      -center   0                width  width+center
 362  *  -center +-----+-------------------+-----+
 363  *          |     |                   |     |
 364  *          |     |                   |     |
 365  *        0 +-----+-------------------+-----+
 366  *          |     |                   |     |
 367  *          |     |                   |     |
 368  *          |     |                   |     |
 369  *   height +-----+-------------------+-----+
 370  *          |     |                   |     |
 371  * height+  |     |                   |     |
 372  *  center  +-----+-------------------+-----+
 373  */
 374
 375 static unsigned char
 376 sum_gaussian (conv *map, double opacity, int x, int y, int width, int height)
 377 {
 378     int     fx, fy;
 379     double  *g_data;
 380     double  *g_line = map->data;
 381     int     g_size = map->size;
 382     int     center = g_size / 2;
 383     int     fx_start, fx_end;
 384     int     fy_start, fy_end;
 385     double  v;
 386
 387     /*
 388      * Compute set of filter values which are "in range",
 389      * that's the set with:
 390      *  0 <= x + (fx-center) && x + (fx-center) < width &&
 391      *  0 <= y + (fy-center) && y + (fy-center) < height
 392      *
 393      *  0 <= x + (fx - center)  x + fx - center < width
 394      *  center - x <= fx        fx < width + center - x
 395      */
 396
 397     fx_start = center - x;
 398     if (fx_start < 0)
 399         fx_start = 0;
 400     fx_end = width + center - x;
 401     if (fx_end > g_size)
 402         fx_end = g_size;
 403
 404     fy_start = center - y;
 405     if (fy_start < 0)
 406         fy_start = 0;
 407     fy_end = height + center - y;
 408     if (fy_end > g_size)
 409         fy_end = g_size;
 410
 411     g_line = g_line + fy_start * g_size + fx_start;
 412
 413     v = 0;
 414     for (fy = fy_start; fy < fy_end; fy++)
 415     {
 416         g_data = g_line;
 417         g_line += g_size;
 418
 419         for (fx = fx_start; fx < fx_end; fx++)
 420             v += *g_data++;
 421     }
 422     if (v > 1)
 423         v = 1;
 424
 425     return ((unsigned char) (v * opacity * 255.0));
 426 }
 427
 428 static XImage *
 429 make_shadow (Display *dpy, double opacity, int width, int height)
 430 {
 431     XImage          *ximage;
 432     unsigned char   *data;
 433     int             gsize = gaussianMap->size;
 434     int             ylimit, xlimit;
 435     int             swidth = width + gsize;
 436     int             sheight = height + gsize;
 437     int             center = gsize / 2;
 438     int             x, y;
 439     unsigned char   d;
 440     int             x_diff;
 441
 442     data = malloc (swidth * sheight * sizeof (unsigned char));
 443     if (!data)
 444         return 0;
 445     ximage = XCreateImage (dpy,
 446                            DefaultVisual(dpy, DefaultScreen(dpy)),
 447                            8,
 448                            ZPixmap,
 449                            0,
 450                            (char *) data,
 451                            swidth, sheight, 8, swidth * sizeof (unsigned char));
 452     if (!ximage)
 453     {
 454         free (data);
 455         return 0;
 456     }
 457     /*
 458      * Build the gaussian in sections
 459      */
 460
 461     /*
 462      * center (fill the complete data array)
 463      */
 464
 465     d = sum_gaussian (gaussianMap, opacity, center, center, width, height);
 466     memset(data, d, sheight * swidth);
 467
 468     /*
 469      * corners
 470      */
 471     ylimit = gsize;
 472     if (ylimit > sheight / 2)
 473         ylimit = (sheight + 1) / 2;
 474     xlimit = gsize;
 475     if (xlimit > swidth / 2)
 476         xlimit = (swidth + 1) / 2;
 477
 478     for (y = 0; y < ylimit; y++)
 479         for (x = 0; x < xlimit; x++)
 480         {
 481             d = sum_gaussian (gaussianMap, opacity, x - center, y - center, width, height);
 482             data[y * swidth + x] = d;
 483             data[(sheight - y - 1) * swidth + x] = d;
 484             data[(sheight - y - 1) * swidth + (swidth - x - 1)] = d;
 485             data[y * swidth + (swidth - x - 1)] = d;
 486         }
 487
 488     /*
 489      * top/bottom
 490      */
 491     x_diff = swidth - (gsize * 2);
 492     if (x_diff > 0 && ylimit > 0)
 493     {
 494         for (y = 0; y < ylimit; y++)
 495         {
 496             d = sum_gaussian (gaussianMap, opacity, center, y - center, width, height);
 497             memset (&data[y * swidth + gsize], d, x_diff);
 498             memset (&data[(sheight - y - 1) * swidth + gsize], d, x_diff);
 499         }
 500     }
 501
 502     /*
 503      * sides
 504      */
 505
 506     for (x = 0; x < xlimit; x++)
 507     {
 508         d = sum_gaussian (gaussianMap, opacity, x - center, center, width, height);
 509         for (y = gsize; y < sheight - gsize; y++)
 510         {
 511             data[y * swidth + x] = d;
 512             data[y * swidth + (swidth - x - 1)] = d;
 513         }
 514     }
 515
 516     return ximage;
 517 }
 518
 519 static Picture
 520 shadow_picture (Display *dpy, double opacity, int width, int height, int *wp, int *hp)
 521 {
 522     XImage  *shadowImage;
 523     Pixmap  shadowPixmap;
 524     Picture shadowPicture;
 525     GC      gc;
 526
 527     shadowImage = make_shadow (dpy, opacity, width, height);
 528     if (!shadowImage)
 529         return None;
 530     shadowPixmap = XCreatePixmap (dpy, root,
 531                                   shadowImage->width,
 532                                   shadowImage->height,
 533                                   8);
 534     shadowPicture = XRenderCreatePicture (dpy, shadowPixmap,
 535                                           XRenderFindStandardFormat (dpy, PictStandardA8),
 536                                           0, 0);
 537     gc = XCreateGC (dpy, shadowPixmap, 0, 0);
 538
 539     XPutImage (dpy, shadowPixmap, gc, shadowImage, 0, 0, 0, 0,
 540                shadowImage->width,
 541                shadowImage->height);
 542     *wp = shadowImage->width;
 543     *hp = shadowImage->height;
 544     XFreeGC (dpy, gc);
 545     XDestroyImage (shadowImage);
 546     XFreePixmap (dpy, shadowPixmap);
 547     return shadowPicture;
 548 }
 549
 550 Picture
 551 solid_picture (Display *dpy, Bool argb, double a, double r, double g, double b)
 552 {
 553     Pixmap                      pixmap;
 554     Picture                     picture;
 555     XRenderPictureAttributes    pa;
 556     XRenderColor                c;
 557
 558     pixmap = XCreatePixmap (dpy, root, 1, 1, argb ? 32 : 8);
 559     pa.repeat = True;
 560     picture = XRenderCreatePicture (dpy, pixmap,
 561                                     XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8),
 562                                     CPRepeat,
 563                                     &pa);
 564     c.alpha = a * 0xffff;
 565     c.red = r * 0xffff;
 566     c.green = g * 0xffff;
 567     c.blue = b * 0xffff;
 568     XRenderFillRectangle (dpy, PictOpSrc, picture, &c, 0, 0, 1, 1);
 569     XFreePixmap (dpy, pixmap);
 570     return picture;
 571 }
 572
 573 void
 574 discard_ignore (Display *dpy, unsigned long sequence)
 575 {
 576     while (ignore_head)
 577     {
 578         if ((long) (sequence - ignore_head->sequence) > 0)
 579         {
 580             ignore  *next = ignore_head->next;
 581             free (ignore_head);
 582             ignore_head = next;
 583             if (!ignore_head)
 584                 ignore_tail = &ignore_head;
 585         }
 586         else
 587             break;
 588     }
 589 }
 590
 591 void
 592 set_ignore (Display *dpy, unsigned long sequence)
 593 {
 594     ignore  *i = malloc (sizeof (ignore));
 595     if (!i)
 596         return;
 597     i->sequence = sequence;
 598     i->next = 0;
 599     *ignore_tail = i;
 600     ignore_tail = &i->next;
 601 }
 602
 603 int
 604 should_ignore (Display *dpy, unsigned long sequence)
 605 {
 606     discard_ignore (dpy, sequence);
 607     return ignore_head && ignore_head->sequence == sequence;
 608 }
 609
 610 static win *
 611 find_win (Display *dpy, Window id)
 612 {
 613     win *w;
 614
 615     for (w = list; w; w = w->next)
 616         if (w->id == id)
 617             return w;
 618     return 0;
 619 }
 620
 621 static char *backgroundProps[] = {
 622     "_XROOTPMAP_ID",
 623     "_XSETROOT_ID",
 624     0,
 625 };
 626
 627 static Picture
 628 root_tile (Display *dpy)
 629 {
 630     Picture         picture;
 631     Atom            actual_type;
 632     Pixmap          pixmap;
 633     int             actual_format;
 634     unsigned long   nitems;
 635     unsigned long   bytes_after;
 636     unsigned char   *prop;
 637     Bool            fill;
 638     XRenderPictureAttributes    pa;
 639     int             p;
 640
 641     pixmap = None;
 642     for (p = 0; backgroundProps[p]; p++)
 643     {
 644         if (XGetWindowProperty (dpy, root, XInternAtom (dpy, backgroundProps[p], False),
 645                                 0, 4, False, AnyPropertyType,
 646                                 &actual_type, &actual_format, &nitems, &bytes_after, &prop) == Success &&
 647             actual_type == XInternAtom (dpy, "PIXMAP", False) && actual_format == 32 && nitems == 1)
 648         {
 649             memcpy (&pixmap, prop, 4);
 650             XFree (prop);
 651             fill = False;
 652             break;
 653         }
 654     }
 655     if (!pixmap)
 656     {
 657         pixmap = XCreatePixmap (dpy, root, 1, 1, DefaultDepth (dpy, scr));
 658         fill = True;
 659     }
 660     pa.repeat = True;
 661     picture = XRenderCreatePicture (dpy, pixmap,
 662                                     XRenderFindVisualFormat (dpy,
 663                                                              DefaultVisual (dpy, scr)),
 664                                     CPRepeat, &pa);
 665     if (fill)
 666     {
 667         XRenderColor    c;
 668
 669         c.red = c.green = c.blue = 0x8080;
 670         c.alpha = 0xffff;
 671         XRenderFillRectangle (dpy, PictOpSrc, picture, &c,
 672                               0, 0, 1, 1);
 673     }
 674     return picture;
 675 }
 676
 677 static void
 678 paint_root (Display *dpy)
 679 {
 680     if (!rootTile)
 681         rootTile = root_tile (dpy);
 682
 683     XRenderComposite (dpy, PictOpSrc,
 684                       rootTile, None, rootBuffer,
 685                       0, 0, 0, 0, 0, 0, root_width, root_height);
 686 }
 687
 688 static XserverRegion
 689 win_extents (Display *dpy, win *w)
 690 {
 691     XRectangle      r;
 692
 693     r.x = w->a.x;
 694     r.y = w->a.y;
 695     r.width = w->a.width + w->a.border_width * 2;
 696     r.height = w->a.height + w->a.border_width * 2;
 697     if (compMode != CompSimple)
 698     {
 699         if (compMode == CompServerShadows || w->mode != WINDOW_ARGB)
 700         {
 701             XRectangle  sr;
 702
 703             if (compMode == CompServerShadows)
 704             {
 705                 w->shadow_dx = 2;
 706                 w->shadow_dy = 7;
 707                 w->shadow_width = w->a.width;
 708                 w->shadow_height = w->a.height;
 709             }
 710             else
 711             {
 712                 w->shadow_dx = SHADOW_OFFSET_X;
 713                 w->shadow_dy = SHADOW_OFFSET_Y;
 714                 if (!w->shadow)
 715                 {
 716                     double      opacity = SHADOW_OPACITY;
 717                     if (w->mode == WINDOW_TRANS)
 718                         opacity = opacity * TRANS_OPACITY;
 719                     w->shadow = shadow_picture (dpy, opacity,
 720                                                 w->a.width + w->a.border_width * 2,
 721                                                 w->a.height + w->a.border_width * 2,
 722                                                 &w->shadow_width, &w->shadow_height);
 723                 }
 724             }
 725             sr.x = w->a.x + w->shadow_dx;
 726             sr.y = w->a.y + w->shadow_dy;
 727             sr.width = w->shadow_width;
 728             sr.height = w->shadow_height;
 729             if (sr.x < r.x)
 730             {
 731                 r.width = (r.x + r.width) - sr.x;
 732                 r.x = sr.x;
 733             }
 734             if (sr.y < r.y)
 735             {
 736                 r.height = (r.y + r.height) - sr.y;
 737                 r.y = sr.y;
 738             }
 739             if (sr.x + sr.width > r.x + r.width)
 740                 r.width = sr.x + sr.width - r.x;
 741             if (sr.y + sr.height > r.y + r.height)
 742                 r.height = sr.y + sr.height - r.y;
 743         }
 744     }
 745     return XFixesCreateRegion (dpy, &r, 1);
 746 }
 747
 748 static XserverRegion
 749 border_size (Display *dpy, win *w)
 750 {
 751     XserverRegion   border;
 752     /*
 753      * if window doesn't exist anymore,  this will generate an error
 754      * as well as not generate a region.  Perhaps a better XFixes
 755      * architecture would be to have a request that copies instead
 756      * of creates, that way you'd just end up with an empty region
 757      * instead of an invalid XID.
 758      */
 759     set_ignore (dpy, NextRequest (dpy));
 760     border = XFixesCreateRegionFromWindow (dpy, w->id, WindowRegionBounding);
 761     /* translate this */
 762     set_ignore (dpy, NextRequest (dpy));
 763     XFixesTranslateRegion (dpy, border,
 764                            w->a.x + w->a.border_width,
 765                            w->a.y + w->a.border_width);
 766     return border;
 767 }
 768
 769 static void
 770 paint_all (Display *dpy, XserverRegion region)
 771 {
 772     win *w;
 773     win *t = 0;
 774
 775     if (!region)
 776     {
 777         XRectangle  r;
 778         r.x = 0;
 779         r.y = 0;
 780         r.width = root_width;
 781         r.height = root_height;
 782         region = XFixesCreateRegion (dpy, &r, 1);
 783     }
 784 #if MONITOR_REPAINT
 785     rootBuffer = rootPicture;
 786 #else
 787     if (!rootBuffer)
 788     {
 789         Pixmap  rootPixmap = XCreatePixmap (dpy, root, root_width, root_height,
 790                                             DefaultDepth (dpy, scr));
 791         rootBuffer = XRenderCreatePicture (dpy, rootPixmap,
 792                                            XRenderFindVisualFormat (dpy,
 793                                                                     DefaultVisual (dpy, scr)),
 794                                            0, 0);
 795         XFreePixmap (dpy, rootPixmap);
 796     }
 797 #endif
 798     XFixesSetPictureClipRegion (dpy, rootPicture, 0, 0, region);
 799 #if MONITOR_REPAINT
 800     XRenderComposite (dpy, PictOpSrc, blackPicture, None, rootPicture,
 801                       0, 0, 0, 0, 0, 0, root_width, root_height);
 802 #endif
 803 #if DEBUG_REPAINT
 804     printf ("paint:");
 805 #endif
 806     for (w = list; w; w = w->next)
 807     {
 808 #if CAN_DO_USABLE
 809         if (!w->usable)
 810             continue;
 811 #endif
 812         /* never painted, ignore it */
 813         if (!w->damaged)
 814             continue;
 815         if (!w->picture)
 816         {
 817             XRenderPictureAttributes    pa;
 818             XRenderPictFormat           *format;
 819             Drawable                    draw = w->id;
 820
 821 #if HAS_NAME_WINDOW_PIXMAP
 822             if (hasNamePixmap && !w->pixmap)
 823                 w->pixmap = XCompositeNameWindowPixmap (dpy, w->id);
 824             if (w->pixmap)
 825                 draw = w->pixmap;
 826 #endif
 827             format = XRenderFindVisualFormat (dpy, w->a.visual);
 828             pa.subwindow_mode = IncludeInferiors;
 829             w->picture = XRenderCreatePicture (dpy, draw,
 830                                                format,
 831                                                CPSubwindowMode,
 832                                                &pa);
 833         }
 834 #if DEBUG_REPAINT
 835         printf (" 0x%x", w->id);
 836 #endif
 837         if (clipChanged)
 838         {
 839             if (w->borderSize)
 840             {
 841                 set_ignore (dpy, NextRequest (dpy));
 842                 XFixesDestroyRegion (dpy, w->borderSize);
 843                 w->borderSize = None;
 844             }
 845             if (w->extents)
 846             {
 847                 XFixesDestroyRegion (dpy, w->extents);
 848                 w->extents = None;
 849             }
 850             if (w->borderClip)
 851             {
 852                 XFixesDestroyRegion (dpy, w->borderClip);
 853                 w->borderClip = None;
 854             }
 855         }
 856         if (!w->borderSize)
 857             w->borderSize = border_size (dpy, w);
 858         if (!w->extents)
 859             w->extents = win_extents (dpy, w);
 860         if (w->mode == WINDOW_SOLID)
 861         {
 862             int x, y, wid, hei;
 863 #if HAS_NAME_WINDOW_PIXMAP
 864             x = w->a.x;
 865             y = w->a.y;
 866             wid = w->a.width + w->a.border_width * 2;
 867             hei = w->a.height + w->a.border_width * 2;
 868 #else
 869             x = w->a.x + w->a.border_width;
 870             y = w->a.y + w->a.border_width;
 871             wid = w->a.width;
 872             hei = w->a.height;
 873 #endif
 874             XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, region);
 875             set_ignore (dpy, NextRequest (dpy));
 876             XFixesSubtractRegion (dpy, region, region, w->borderSize);
 877             set_ignore (dpy, NextRequest (dpy));
 878             XRenderComposite (dpy, PictOpSrc, w->picture, None, rootBuffer,
 879                               0, 0, 0, 0,
 880                               x, y, wid, hei);
 881         }
 882         if (!w->borderClip)
 883         {
 884             w->borderClip = XFixesCreateRegion (dpy, 0, 0);
 885             XFixesCopyRegion (dpy, w->borderClip, region);
 886         }
 887         w->prev_trans = t;
 888         t = w;
 889     }
 890 #if DEBUG_REPAINT
 891     printf ("\n");
 892     fflush (stdout);
 893 #endif
 894     XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, region);
 895     paint_root (dpy);
 896     for (w = t; w; w = w->prev_trans)
 897     {
 898         XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, w->borderClip);
 899         switch (compMode) {
 900         case CompSimple:
 901             break;
 902         case CompServerShadows:
 903             set_ignore (dpy, NextRequest (dpy));
 904             if (w->opacity != OPAQUE && !w->shadowPict)
 905                 w->shadowPict = solid_picture (dpy, True,
 906                                                (double) w->opacity / OPAQUE * 0.3,
 907                                                0, 0, 0);
 908             XRenderComposite (dpy, PictOpOver,
 909                               w->shadowPict ? w->shadowPict : transBlackPicture,
 910                               w->picture, rootBuffer,
 911                               0, 0, 0, 0,
 912                               w->a.x + w->shadow_dx,
 913                               w->a.y + w->shadow_dy,
 914                               w->shadow_width, w->shadow_height);
 915             break;
 916         case CompClientShadows:
 917             if (w->shadow)
 918             {
 919                 XRenderComposite (dpy, PictOpOver, blackPicture, w->shadow, rootBuffer,
 920                                   0, 0, 0, 0,
 921                                   w->a.x + w->shadow_dx,
 922                                   w->a.y + w->shadow_dy,
 923                                   w->shadow_width, w->shadow_height);
 924             }
 925             break;
 926         }
 927         if (w->opacity != OPAQUE && !w->alphaPict)
 928             w->alphaPict = solid_picture (dpy, False,
 929                                           (double) w->opacity / OPAQUE, 0, 0, 0);
 930         if (w->mode == WINDOW_TRANS)
 931         {
 932             int x, y, wid, hei;
 933 #if HAS_NAME_WINDOW_PIXMAP
 934             x = w->a.x;
 935             y = w->a.y;
 936             wid = w->a.width + w->a.border_width * 2;
 937             hei = w->a.height + w->a.border_width * 2;
 938 #else
 939             x = w->a.x + w->a.border_width;
 940             y = w->a.y + w->a.border_width;
 941             wid = w->a.width;
 942             hei = w->a.height;
 943 #endif
 944             set_ignore (dpy, NextRequest (dpy));
 945             XRenderComposite (dpy, PictOpOver, w->picture, w->alphaPict, rootBuffer,
 946                               0, 0, 0, 0,
 947                               x, y, wid, hei);
 948         }
 949         else if (w->mode == WINDOW_ARGB)
 950         {
 951             int x, y, wid, hei;
 952 #if HAS_NAME_WINDOW_PIXMAP
 953             x = w->a.x;
 954             y = w->a.y;
 955             wid = w->a.width + w->a.border_width * 2;
 956             hei = w->a.height + w->a.border_width * 2;
 957 #else
 958             x = w->a.x + w->a.border_width;
 959             y = w->a.y + w->a.border_width;
 960             wid = w->a.width;
 961             hei = w->a.height;
 962 #endif
 963             set_ignore (dpy, NextRequest (dpy));
 964             XRenderComposite (dpy, PictOpOver, w->picture, w->alphaPict, rootBuffer,
 965                               0, 0, 0, 0,
 966                               x, y, wid, hei);
 967         }
 968         XFixesDestroyRegion (dpy, w->borderClip);
 969         w->borderClip = None;
 970     }
 971     XFixesDestroyRegion (dpy, region);
 972     if (rootBuffer != rootPicture)
 973     {
 974         XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, None);
 975         XRenderComposite (dpy, PictOpSrc, rootBuffer, None, rootPicture,
 976                           0, 0, 0, 0, 0, 0, root_width, root_height);
 977     }
 978 }
 979
 980 static void
 981 add_damage (Display *dpy, XserverRegion damage)
 982 {
 983     if (allDamage)
 984     {
 985         XFixesUnionRegion (dpy, allDamage, allDamage, damage);
 986         XFixesDestroyRegion (dpy, damage);
 987     }
 988     else
 989         allDamage = damage;
 990 }
 991
 992 static void
 993 repair_win (Display *dpy, win *w)
 994 {
 995     XserverRegion   parts;
 996
 997     if (!w->damaged)
 998     {
 999         parts = win_extents (dpy, w);
1000         set_ignore (dpy, NextRequest (dpy));
1001         XDamageSubtract (dpy, w->damage, None, None);
1002     }
1003     else
1004     {
1005         XserverRegion   o;
1006         parts = XFixesCreateRegion (dpy, 0, 0);
1007         set_ignore (dpy, NextRequest (dpy));
1008         XDamageSubtract (dpy, w->damage, None, parts);
1009         XFixesTranslateRegion (dpy, parts,
1010                                w->a.x + w->a.border_width,
1011                                w->a.y + w->a.border_width);
1012         if (compMode == CompServerShadows)
1013         {
1014             o = XFixesCreateRegion (dpy, 0, 0);
1015             XFixesCopyRegion (dpy, o, parts);
1016             XFixesTranslateRegion (dpy, o, w->shadow_dx, w->shadow_dy);
1017             XFixesUnionRegion (dpy, parts, parts, o);
1018             XFixesDestroyRegion (dpy, o);
1019         }
1020     }
1021     add_damage (dpy, parts);
1022     w->damaged = 1;
1023 }
1024
1025 static void
1026 map_win (Display *dpy, Window id, unsigned long sequence, Bool fade)
1027 {
1028     win         *w = find_win (dpy, id);
1029     Drawable    back;
1030
1031     if (!w)
1032         return;
1033     w->a.map_state = IsViewable;
1034
1035 #if CAN_DO_USABLE
1036     w->damage_bounds.x = w->damage_bounds.y = 0;
1037     w->damage_bounds.width = w->damage_bounds.height = 0;
1038 #endif
1039     w->damaged = 0;
1040 }
1041
1042 static void
1043 finish_unmap_win (Display *dpy, win *w)
1044 {
1045     w->damaged = 0;
1046 #if CAN_DO_USABLE
1047     w->usable = False;
1048 #endif
1049     if (w->extents != None)
1050     {
1051         add_damage (dpy, w->extents);    /* destroys region */
1052         w->extents = None;
1053     }
1054
1055 #if HAS_NAME_WINDOW_PIXMAP
1056     if (w->pixmap)
1057     {
1058         XFreePixmap (dpy, w->pixmap);
1059         w->pixmap = None;
1060     }
1061 #endif
1062
1063     if (w->picture)
1064     {
1065         set_ignore (dpy, NextRequest (dpy));
1066         XRenderFreePicture (dpy, w->picture);
1067         w->picture = None;
1068     }
1069
1070     /* don't care about properties anymore */
1071     set_ignore (dpy, NextRequest (dpy));
1072     XSelectInput(dpy, w->id, 0);
1073
1074     if (w->borderSize)
1075     {
1076         set_ignore (dpy, NextRequest (dpy));
1077         XFixesDestroyRegion (dpy, w->borderSize);
1078         w->borderSize = None;
1079     }
1080     if (w->shadow)
1081     {
1082         XRenderFreePicture (dpy, w->shadow);
1083         w->shadow = None;
1084     }
1085     if (w->borderClip)
1086     {
1087         XFixesDestroyRegion (dpy, w->borderClip);
1088         w->borderClip = None;
1089     }
1090
1091     clipChanged = True;
1092 }
1093
1094 #if HAS_NAME_WINDOW_PIXMAP
1095 static void
1096 unmap_callback (Display *dpy, win *w, Bool gone)
1097 {
1098     finish_unmap_win (dpy, w);
1099 }
1100 #endif
1101
1102 static void
1103 unmap_win (Display *dpy, Window id, Bool fade)
1104 {
1105     win *w = find_win (dpy, id);
1106     if (!w)
1107         return;
1108 #if HAS_NAME_WINDOW_PIXMAP
1109     if (w->pixmap && fade && fadeWindows)
1110         set_fade (dpy, w, False, unmap_callback, False);
1111     else
1112 #endif
1113         finish_unmap_win (dpy, w);
1114 }
1115
1116 /* Get the opacity prop from window
1117    not found: default
1118    otherwise the value
1119  */
1120 static unsigned int
1121 get_opacity_prop(Display *dpy, win *w, unsigned int def)
1122 {
1123     Atom actual;
1124     int format;
1125     unsigned long n, left;
1126
1127     char *data;
1128     XGetWindowProperty(dpy, w->id, opacityAtom, 0L, 1L, False,
1129                        XA_CARDINAL, &actual, &format,
1130                        &n, &left, (unsigned char **) &data);
1131     if (data != None)
1132     {
1133         unsigned int i;
1134         memcpy (&i, data, sizeof (unsigned int));
1135         XFree( (void *) data);
1136         return i;
1137     }
1138     return def;
1139 }
1140
1141 /* determine mode for window all in one place.
1142    Future might check for menu flag and other cool things
1143 */
1144
1145 static void
1146 determine_mode(Display *dpy, win *w)
1147 {
1148     int mode;
1149     XRenderPictFormat *format;
1150     unsigned int default_opacity;
1151
1152     /* if trans prop == -1 fall back on  previous tests*/
1153
1154     if (w->alphaPict)
1155     {
1156         XRenderFreePicture (dpy, w->alphaPict);
1157         w->alphaPict = None;
1158     }
1159     if (w->shadowPict)
1160     {
1161         XRenderFreePicture (dpy, w->shadowPict);
1162         w->shadowPict = None;
1163     }
1164
1165     if (w->a.class == InputOnly)
1166     {
1167         format = 0;
1168     }
1169     else
1170     {
1171         format = XRenderFindVisualFormat (dpy, w->a.visual);
1172     }
1173
1174     if (format && format->type == PictTypeDirect && format->direct.alphaMask)
1175     {
1176         mode = WINDOW_ARGB;
1177     }
1178     else if (w->opacity != OPAQUE)
1179     {
1180         mode = WINDOW_TRANS;
1181     }
1182     else
1183     {
1184         mode = WINDOW_SOLID;
1185     }
1186     w->mode = mode;
1187     if (w->extents)
1188     {
1189         XserverRegion damage;
1190         damage = XFixesCreateRegion (dpy, 0, 0);
1191         XFixesCopyRegion (dpy, damage, w->extents);
1192         add_damage (dpy, damage);
1193     }
1194 }
1195
1196 static void
1197 add_win (Display *dpy, Window id, Window prev)
1198 {
1199     win                         *new = malloc (sizeof (win));
1200     win                         **p;
1201
1202     if (!new)
1203         return;
1204     if (prev)
1205     {
1206         for (p = &list; *p; p = &(*p)->next)
1207             if ((*p)->id == prev)
1208                 break;
1209     }
1210     else
1211         p = &list;
1212     new->id = id;
1213     set_ignore (dpy, NextRequest (dpy));
1214     if (!XGetWindowAttributes (dpy, id, &new->a))
1215     {
1216         free (new);
1217         return;
1218     }
1219     new->damaged = 0;
1220 #if CAN_DO_USABLE
1221     new->usable = False;
1222 #endif
1223 #if HAS_NAME_WINDOW_PIXMAP
1224     new->pixmap = None;
1225 #endif
1226     new->picture = None;
1227     if (new->a.class == InputOnly)
1228     {
1229         new->damage_sequence = 0;
1230         new->damage = None;
1231     }
1232     else
1233     {
1234         new->damage_sequence = NextRequest (dpy);
1235         new->damage = XDamageCreate (dpy, id, XDamageReportNonEmpty);
1236     }
1237     new->alphaPict = None;
1238     new->shadowPict = None;
1239     new->borderSize = None;
1240     new->extents = None;
1241     new->shadow = None;
1242     new->shadow_dx = 0;
1243     new->shadow_dy = 0;
1244     new->shadow_width = 0;
1245     new->shadow_height = 0;
1246     new->opacity = OPAQUE;
1247
1248     new->borderClip = None;
1249     new->prev_trans = 0;
1250
1251     /* moved mode setting to one place */
1252     XSelectInput(dpy, id, PropertyChangeMask);
1253     new->opacity = get_opacity_prop(dpy, new, OPAQUE);
1254     determine_mode (dpy, new);
1255
1256     new->next = *p;
1257     *p = new;
1258     if (new->a.map_state == IsViewable)
1259         map_win (dpy, id, new->damage_sequence - 1, False);
1260 }
1261
1262 void
1263 restack_win (Display *dpy, win *w, Window new_above)
1264 {
1265     Window  old_above;
1266
1267     if (w->next)
1268         old_above = w->next->id;
1269     else
1270         old_above = None;
1271     if (old_above != new_above)
1272     {
1273         win **prev;
1274
1275         /* unhook */
1276         for (prev = &list; *prev; prev = &(*prev)->next)
1277             if ((*prev) == w)
1278                 break;
1279         *prev = w->next;
1280
1281         /* rehook */
1282         for (prev = &list; *prev; prev = &(*prev)->next)
1283         {
1284             if ((*prev)->id == new_above)
1285                 break;
1286         }
1287         w->next = *prev;
1288         *prev = w;
1289     }
1290 }
1291
1292 static void
1293 configure_win (Display *dpy, XConfigureEvent *ce)
1294 {
1295     win             *w = find_win (dpy, ce->window);
1296     Window          above;
1297     XserverRegion   damage = None;
1298
1299     if (!w)
1300     {
1301         if (ce->window == root)
1302         {
1303             if (rootBuffer)
1304             {
1305                 XRenderFreePicture (dpy, rootBuffer);
1306                 rootBuffer = None;
1307             }
1308             root_width = ce->width;
1309             root_height = ce->height;
1310         }
1311         return;
1312     }
1313 #if CAN_DO_USABLE
1314     if (w->usable)
1315 #endif
1316     {
1317         damage = XFixesCreateRegion (dpy, 0, 0);
1318         if (w->extents != None)
1319             XFixesCopyRegion (dpy, damage, w->extents);
1320     }
1321     w->a.x = ce->x;
1322     w->a.y = ce->y;
1323     if (w->a.width != ce->width || w->a.height != ce->height)
1324     {
1325 #if HAS_NAME_WINDOW_PIXMAP
1326         if (w->pixmap)
1327         {
1328             XFreePixmap (dpy, w->pixmap);
1329             w->pixmap = None;
1330             if (w->picture)
1331             {
1332                 XRenderFreePicture (dpy, w->picture);
1333                 w->picture = None;
1334             }
1335         }
1336 #endif
1337         if (w->shadow)
1338         {
1339             XRenderFreePicture (dpy, w->shadow);
1340             w->shadow = None;
1341         }
1342     }
1343     w->a.width = ce->width;
1344     w->a.height = ce->height;
1345     w->a.border_width = ce->border_width;
1346     w->a.override_redirect = ce->override_redirect;
1347     restack_win (dpy, w, ce->above);
1348     if (damage)
1349     {
1350         XserverRegion   extents = win_extents (dpy, w);
1351         XFixesUnionRegion (dpy, damage, damage, extents);
1352         XFixesDestroyRegion (dpy, extents);
1353         add_damage (dpy, damage);
1354     }
1355     clipChanged = True;
1356 }
1357
1358 static void
1359 circulate_win (Display *dpy, XCirculateEvent *ce)
1360 {
1361     win     *w = find_win (dpy, ce->window);
1362     Window  new_above;
1363
1364     if (ce->place == PlaceOnTop)
1365         new_above = list->id;
1366     else
1367         new_above = None;
1368     restack_win (dpy, w, new_above);
1369     clipChanged = True;
1370 }
1371
1372 static void
1373 finish_destroy_win (Display *dpy, Window id, Bool gone)
1374 {
1375     win **prev, *w;
1376
1377     for (prev = &list; (w = *prev); prev = &w->next)
1378         if (w->id == id)
1379         {
1380             if (!gone)
1381                 finish_unmap_win (dpy, w);
1382             *prev = w->next;
1383             if (w->picture)
1384             {
1385                 set_ignore (dpy, NextRequest (dpy));
1386                 XRenderFreePicture (dpy, w->picture);
1387             }
1388             if (w->alphaPict)
1389             {
1390                 XRenderFreePicture (dpy, w->alphaPict);
1391                 w->alphaPict = None;
1392             }
1393             if (w->shadowPict)
1394             {
1395                 XRenderFreePicture (dpy, w->shadowPict);
1396                 w->shadowPict = None;
1397             }
1398             if (w->damage != None)
1399             {
1400                 set_ignore (dpy, NextRequest (dpy));
1401                 XDamageDestroy (dpy, w->damage);
1402             }
1403             cleanup_fade (dpy, w);
1404             free (w);
1405             break;
1406         }
1407 }
1408
1409 #if HAS_NAME_WINDOW_PIXMAP
1410 static void
1411 destroy_callback (Display *dpy, win *w, Bool gone)
1412 {
1413     finish_destroy_win (dpy, w->id, gone);
1414 }
1415 #endif
1416
1417 static void
1418 destroy_win (Display *dpy, Window id, Bool gone, Bool fade)
1419 {
1420     win *w = find_win (dpy, id);
1421 #if HAS_NAME_WINDOW_PIXMAP
1422     if (w && w->pixmap && fade && fadeWindows)
1423         set_fade (dpy, w, False, destroy_callback, gone);
1424     else
1425 #endif
1426     {
1427         finish_destroy_win (dpy, id, gone);
1428     }
1429 }
1430
1431 /*
1432 static void
1433 dump_win (win *w)
1434 {
1435     printf ("\t%08lx: %d x %d + %d + %d (%d)\n", w->id,
1436             w->a.width, w->a.height, w->a.x, w->a.y, w->a.border_width);
1437 }
1438
1439
1440 static void
1441 dump_wins (void)
1442 {
1443     win *w;
1444
1445     printf ("windows:\n");
1446     for (w = list; w; w = w->next)
1447         dump_win (w);
1448 }
1449 */
1450
1451 static void
1452 damage_win (Display *dpy, XDamageNotifyEvent *de)
1453 {
1454     win *w = find_win (dpy, de->drawable);
1455
1456     if (!w)
1457         return;
1458 #if CAN_DO_USABLE
1459     if (!w->usable)
1460     {
1461         if (w->damage_bounds.width == 0 || w->damage_bounds.height == 0)
1462         {
1463             w->damage_bounds = de->area;
1464         }
1465         else
1466         {
1467             if (de->area.x < w->damage_bounds.x)
1468             {
1469                 w->damage_bounds.width += (w->damage_bounds.x - de->area.x);
1470                 w->damage_bounds.x = de->area.x;
1471             }
1472             if (de->area.y < w->damage_bounds.y)
1473             {
1474                 w->damage_bounds.height += (w->damage_bounds.y - de->area.y);
1475                 w->damage_bounds.y = de->area.y;
1476             }
1477             if (de->area.x + de->area.width > w->damage_bounds.x + w->damage_bounds.width)
1478                 w->damage_bounds.width = de->area.x + de->area.width - w->damage_bounds.x;
1479             if (de->area.y + de->area.height > w->damage_bounds.y + w->damage_bounds.height)
1480                 w->damage_bounds.height = de->area.y + de->area.height - w->damage_bounds.y;
1481         }
1482 #if 0
1483         printf ("unusable damage %d, %d: %d x %d bounds %d, %d: %d x %d\n",
1484                 de->area.x,
1485                 de->area.y,
1486                 de->area.width,
1487                 de->area.height,
1488                 w->damage_bounds.x,
1489                 w->damage_bounds.y,
1490                 w->damage_bounds.width,
1491                 w->damage_bounds.height);
1492 #endif
1493         if (w->damage_bounds.x <= 0 &&
1494             w->damage_bounds.y <= 0 &&
1495             w->a.width <= w->damage_bounds.x + w->damage_bounds.width &&
1496             w->a.height <= w->damage_bounds.y + w->damage_bounds.height)
1497         {
1498             clipChanged = True;
1499             if (fadeWindows)
1500                 set_fade (dpy, w, True, 0, False);
1501             w->usable = True;
1502         }
1503     }
1504     if (w->usable)
1505 #endif
1506         repair_win (dpy, w);
1507 }
1508
1509 static int
1510 error (Display *dpy, XErrorEvent *ev)
1511 {
1512     int     o;
1513     char    *name = 0;
1514
1515     if (should_ignore (dpy, ev->serial))
1516         return 0;
1517
1518     if (ev->request_code == composite_opcode &&
1519         ev->minor_code == X_CompositeRedirectSubwindows)
1520     {
1521         fprintf (stderr, "Another composite manager is already running\n");
1522         exit (1);
1523     }
1524
1525     o = ev->error_code - xfixes_error;
1526     switch (o) {
1527     case BadRegion: name = "BadRegion"; break;
1528     default: break;
1529     }
1530     o = ev->error_code - damage_error;
1531     switch (o) {
1532     case BadDamage: name = "BadDamage"; break;
1533     default: break;
1534     }
1535     o = ev->error_code - render_error;
1536     switch (o) {
1537     case BadPictFormat: name ="BadPictFormat"; break;
1538     case BadPicture: name ="BadPicture"; break;
1539     case BadPictOp: name ="BadPictOp"; break;
1540     case BadGlyphSet: name ="BadGlyphSet"; break;
1541     case BadGlyph: name ="BadGlyph"; break;
1542     default: break;
1543     }
1544
1545     printf ("error %d request %d minor %d serial %d\n",
1546             ev->error_code, ev->request_code, ev->minor_code, ev->serial);
1547
1548 /*    abort ();     this is just annoying to most people */
1549     return 0;
1550 }
1551
1552 static void
1553 expose_root (Display *dpy, Window root, XRectangle *rects, int nrects)
1554 {
1555     XserverRegion  region = XFixesCreateRegion (dpy, rects, nrects);
1556
1557     add_damage (dpy, region);
1558 }
1559
1560
1561 static int
1562 ev_serial (XEvent *ev)
1563 {
1564     if (ev->type & 0x7f != KeymapNotify)
1565         return ev->xany.serial;
1566     return NextRequest (ev->xany.display);
1567 }
1568
1569
1570 static char *
1571 ev_name (XEvent *ev)
1572 {
1573     static char buf[128];
1574     switch (ev->type & 0x7f) {
1575     case Expose:
1576         return "Expose";
1577     case MapNotify:
1578         return "Map";
1579     case UnmapNotify:
1580         return "Unmap";
1581     case ReparentNotify:
1582         return "Reparent";
1583     case CirculateNotify:
1584         return "Circulate";
1585     default:
1586         if (ev->type == damage_event + XDamageNotify)
1587             return "Damage";
1588         sprintf (buf, "Event %d", ev->type);
1589         return buf;
1590     }
1591 }
1592
1593 static Window
1594 ev_window (XEvent *ev)
1595 {
1596     switch (ev->type) {
1597     case Expose:
1598         return ev->xexpose.window;
1599     case MapNotify:
1600         return ev->xmap.window;
1601     case UnmapNotify:
1602         return ev->xunmap.window;
1603     case ReparentNotify:
1604         return ev->xreparent.window;
1605     case CirculateNotify:
1606         return ev->xcirculate.window;
1607     default:
1608         if (ev->type == damage_event + XDamageNotify)
1609             return ((XDamageNotifyEvent *) ev)->drawable;
1610         return 0;
1611     }
1612 }
1613
1614 void
1615 usage (char *program)
1616 {
1617     fprintf (stderr, "usage: %s [-d display] [-n] [-s] [-c] [-a]\n", program);
1618     exit (1);
1619 }
1620
1621 int
1622 main (int argc, char **argv)
1623 {
1624     XEvent          ev;
1625     Window          root_return, parent_return;
1626     Window          *children;
1627     Pixmap          transPixmap;
1628     Pixmap          blackPixmap;
1629     unsigned int    nchildren;
1630     int             i;
1631     XRenderPictureAttributes    pa;
1632     XRenderColor                c;
1633     XRectangle      *expose_rects = 0;
1634     int             size_expose = 0;
1635     int             n_expose = 0;
1636     struct pollfd   ufd;
1637     int             n;
1638     int             last_update;
1639     int             now;
1640     int             p;
1641     int             composite_major, composite_minor;
1642     char            *display = 0;
1643     int             o;
1644
1645     while ((o = getopt (argc, argv, "d:scnfaS")) != -1)
1646     {
1647         switch (o) {
1648         case 'd':
1649             display = optarg;
1650             break;
1651         case 's':
1652             compMode = CompServerShadows;
1653             break;
1654         case 'c':
1655             compMode = CompClientShadows;
1656             break;
1657         case 'n':
1658             compMode = CompSimple;
1659             break;
1660         case 'f':
1661             fadeWindows = True;
1662             break;
1663         case 'a':
1664             autoRedirect = True;
1665             break;
1666         case 'S':
1667             synchronize = True;
1668             break;
1669         default:
1670             usage (argv[0]);
1671             break;
1672         }
1673     }
1674
1675     dpy = XOpenDisplay (display);
1676     if (!dpy)
1677     {
1678         fprintf (stderr, "Can't open display\n");
1679         exit (1);
1680     }
1681     XSetErrorHandler (error);
1682     if (synchronize)
1683         XSynchronize (dpy, 1);
1684     scr = DefaultScreen (dpy);
1685     root = RootWindow (dpy, scr);
1686
1687     if (!XRenderQueryExtension (dpy, &render_event, &render_error))
1688     {
1689         fprintf (stderr, "No render extension\n");
1690         exit (1);
1691     }
1692     if (!XQueryExtension (dpy, COMPOSITE_NAME, &composite_opcode,
1693                           &composite_event, &composite_error))
1694     {
1695         fprintf (stderr, "No composite extension\n");
1696         exit (1);
1697     }
1698     XCompositeQueryVersion (dpy, &composite_major, &composite_minor);
1699 #if HAS_NAME_WINDOW_PIXMAP
1700     if (composite_major > 0 || composite_minor >= 2)
1701         hasNamePixmap = True;
1702 #endif
1703
1704     if (!XDamageQueryExtension (dpy, &damage_event, &damage_error))
1705     {
1706         fprintf (stderr, "No damage extension\n");
1707         exit (1);
1708     }
1709     if (!XFixesQueryExtension (dpy, &xfixes_event, &xfixes_error))
1710     {
1711         fprintf (stderr, "No XFixes extension\n");
1712         exit (1);
1713     }
1714     /* get atoms */
1715     opacityAtom = XInternAtom (dpy, OPACITY_PROP, False);
1716
1717     pa.subwindow_mode = IncludeInferiors;
1718
1719     if (compMode == CompClientShadows)
1720         gaussianMap = make_gaussian_map(dpy, shadowRadius);
1721
1722     root_width = DisplayWidth (dpy, scr);
1723     root_height = DisplayHeight (dpy, scr);
1724
1725     rootPicture = XRenderCreatePicture (dpy, root,
1726                                         XRenderFindVisualFormat (dpy,
1727                                                                  DefaultVisual (dpy, scr)),
1728                                         CPSubwindowMode,
1729                                         &pa);
1730     blackPicture = solid_picture (dpy, True, 1, 0, 0, 0);
1731     if (compMode == CompServerShadows)
1732         transBlackPicture = solid_picture (dpy, True, 0.3, 0, 0, 0);
1733     allDamage = None;
1734     clipChanged = True;
1735     XGrabServer (dpy);
1736     if (autoRedirect)
1737         XCompositeRedirectSubwindows (dpy, root, CompositeRedirectAutomatic);
1738     else
1739     {
1740         XCompositeRedirectSubwindows (dpy, root, CompositeRedirectManual);
1741         XSelectInput (dpy, root,
1742                       SubstructureNotifyMask|
1743                       ExposureMask|
1744                       StructureNotifyMask|
1745                       PropertyChangeMask);
1746         XQueryTree (dpy, root, &root_return, &parent_return, &children, &nchildren);
1747         for (i = 0; i < nchildren; i++)
1748             add_win (dpy, children[i], i ? children[i-1] : None);
1749         XFree (children);
1750     }
1751     XUngrabServer (dpy);
1752     ufd.fd = ConnectionNumber (dpy);
1753     ufd.events = POLLIN;
1754     if (!autoRedirect)
1755         paint_all (dpy, None);
1756     for (;;)
1757     {
1758         /*      dump_wins (); */
1759         do {
1760             if (autoRedirect)
1761                 XFlush (dpy);
1762             if (!QLength (dpy))
1763             {
1764                  if (poll (&ufd, 1, fade_timeout()) == 0)
1765                  {
1766                     run_fades (dpy);
1767                     break;
1768                  }
1769             }
1770
1771             XNextEvent (dpy, &ev);
1772             if (ev.type & 0x7f != KeymapNotify)
1773                 discard_ignore (dpy, ev.xany.serial);
1774 #if DEBUG_EVENTS
1775             printf ("event %10.10s serial 0x%08x window 0x%08x\n",
1776                     ev_name(&ev), ev_serial (&ev), ev_window (&ev));
1777 #endif
1778             if (!autoRedirect) switch (ev.type) {
1779             case CreateNotify:
1780                 add_win (dpy, ev.xcreatewindow.window, 0);
1781                 break;
1782             case ConfigureNotify:
1783                 configure_win (dpy, &ev.xconfigure);
1784                 break;
1785             case DestroyNotify:
1786                 destroy_win (dpy, ev.xdestroywindow.window, True, True);
1787                 break;
1788             case MapNotify:
1789                 map_win (dpy, ev.xmap.window, ev.xmap.serial, True);
1790                 break;
1791             case UnmapNotify:
1792                 unmap_win (dpy, ev.xunmap.window, True);
1793                 break;
1794             case ReparentNotify:
1795                 if (ev.xreparent.parent == root)
1796                     add_win (dpy, ev.xreparent.window, 0);
1797                 else
1798                     destroy_win (dpy, ev.xreparent.window, False, True);
1799                 break;
1800             case CirculateNotify:
1801                 circulate_win (dpy, &ev.xcirculate);
1802                 break;
1803             case Expose:
1804                 if (ev.xexpose.window == root)
1805                 {
1806                     int more = ev.xexpose.count + 1;
1807                     if (n_expose == size_expose)
1808                     {
1809                         if (expose_rects)
1810                         {
1811                             expose_rects = realloc (expose_rects,
1812                                                     (size_expose + more) *
1813                                                     sizeof (XRectangle));
1814                             size_expose += more;
1815                         }
1816                         else
1817                         {
1818                             expose_rects = malloc (more * sizeof (XRectangle));
1819                             size_expose = more;
1820                         }
1821                     }
1822                     expose_rects[n_expose].x = ev.xexpose.x;
1823                     expose_rects[n_expose].y = ev.xexpose.y;
1824                     expose_rects[n_expose].width = ev.xexpose.width;
1825                     expose_rects[n_expose].height = ev.xexpose.height;
1826                     n_expose++;
1827                     if (ev.xexpose.count == 0)
1828                     {
1829                         expose_root (dpy, root, expose_rects, n_expose);
1830                         n_expose = 0;
1831                     }
1832                 }
1833                 break;
1834             case PropertyNotify:
1835                 for (p = 0; backgroundProps[p]; p++)
1836                 {
1837                     if (ev.xproperty.atom == XInternAtom (dpy, backgroundProps[p], False))
1838                     {
1839                         if (rootTile)
1840                         {
1841                             XClearArea (dpy, root, 0, 0, 0, 0, True);
1842                             XRenderFreePicture (dpy, rootTile);
1843                             rootTile = None;
1844                             break;
1845                         }
1846                     }
1847                 }
1848                 /* check if Trans property was changed */
1849                 if (ev.xproperty.atom == opacityAtom)
1850                 {
1851                     /* reset mode and redraw window */
1852                     win * w = find_win(dpy, ev.xproperty.window);
1853                     if (w)
1854                     {
1855                         w->opacity = get_opacity_prop(dpy, w, OPAQUE);
1856                         determine_mode(dpy, w);
1857                     }
1858                 }
1859                 break;
1860             default:
1861                 if (ev.type == damage_event + XDamageNotify)
1862                     damage_win (dpy, (XDamageNotifyEvent *) &ev);
1863                 break;
1864             }
1865         } while (QLength (dpy));
1866         if (allDamage && !autoRedirect)
1867         {
1868             static int  paint;
1869             paint_all (dpy, allDamage);
1870             paint++;
1871             XSync (dpy, False);
1872             allDamage = None;
1873             clipChanged = False;
1874         }
1875     }
1876 }