f17c5cb68ef72b2c7e009d9ae3ff6728debb335c
[dana/xcompmgr.git] / 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 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <math.h>
29 #include <sys/poll.h>
30 #include <sys/time.h>
31 #include <time.h>
32 #include <X11/Xlib.h>
33 #include <X11/Xutil.h>
34 #include <X11/extensions/Xcomposite.h>
35 #include <X11/extensions/Xdamage.h>
36 #include <X11/extensions/Xrender.h>
37
38 typedef struct _win {
39     struct _win         *next;
40     Window              id;
41     XWindowAttributes   a;
42     int                 mode;
43     int                 damaged;
44     Damage              damage;
45     Picture             picture;
46     XserverRegion       borderSize;
47     XserverRegion       extents;
48     Picture             shadow;
49     int                 shadow_dx;
50     int                 shadow_dy;
51     int                 shadow_width;
52     int                 shadow_height;
53
54     unsigned long       damage_sequence;    /* sequence when damage was created */
55
56     /* for drawing translucent windows */
57     XserverRegion       borderClip;
58     struct _win         *prev_trans;
59 } win;
60
61 typedef struct _conv {
62     int     size;
63     double  *data;
64 } conv;
65
66 win             *list;
67 Display         *dpy;
68 int             scr;
69 Window          root;
70 Picture         rootPicture;
71 Picture         rootBuffer;
72 Picture         transPicture;
73 Picture         blackPicture;
74 Picture         rootTile;
75 XserverRegion   allDamage;
76 int             root_height, root_width;
77 conv            *gaussianMap;
78
79 #define WINDOW_SOLID    0
80 #define WINDOW_TRANS    1
81 #define WINDOW_ARGB     2
82
83 #define TRANS_OPACITY   0.75
84 #define SHADOW_RADIUS   15
85 #define SHADOW_OPACITY  0.75
86 #define SHADOW_OFFSET_X (-SHADOW_RADIUS)
87 #define SHADOW_OFFSET_Y (-SHADOW_RADIUS)
88
89 #define DEBUG 0
90 #define MONITOR_REPAINT 0
91
92 static double
93 gaussian (double r, double x, double y)
94 {
95     return ((1 / (sqrt (2 * M_PI * r))) *
96             exp ((- (x * x + y * y)) / (2 * r * r)));
97 }
98
99
100 static conv *
101 make_gaussian_map (Display *dpy, double r)
102 {
103     conv            *c;
104     int             size = ((int) ceil ((r * 3)) + 1) & ~1;
105     int             center = size / 2;
106     int             x, y;
107     double          t;
108     double          g;
109     
110     c = malloc (sizeof (conv) + size * size * sizeof (double));
111     c->size = size;
112     c->data = (double *) (c + 1);
113     for (y = 0; y < size; y++)
114         for (x = 0; x < size; x++)
115         {
116             g = gaussian (r, (double) (x - center), (double) (y - center));
117             t += g;
118             c->data[y * size + x] = g;
119         }
120 /*    printf ("gaussian total %f\n", t); */
121     for (y = 0; y < size; y++)
122         for (x = 0; x < size; x++)
123         {
124             c->data[y*size + x] /= t;
125         }
126     return c;
127 }
128
129 /*
130  * A picture will help
131  *
132  *      -center   0                width  width+center
133  *  -center +-----+-------------------+-----+
134  *          |     |                   |     |
135  *          |     |                   |     |
136  *        0 +-----+-------------------+-----+
137  *          |     |                   |     |
138  *          |     |                   |     |
139  *          |     |                   |     |
140  *   height +-----+-------------------+-----+
141  *          |     |                   |     |
142  * height+  |     |                   |     |
143  *  center  +-----+-------------------+-----+
144  */
145  
146 static unsigned char
147 sum_gaussian (conv *map, double opacity, int x, int y, int width, int height)
148 {
149     int     fx, fy;
150     double  *g_data;
151     double  *g_line = map->data;
152     int     g_size = map->size;
153     int     center = g_size / 2;
154     int     fx_start, fx_end;
155     int     fy_start, fy_end;
156     double  v;
157     
158     /*
159      * Compute set of filter values which are "in range",
160      * that's the set with:
161      *  0 <= x + (fx-center) && x + (fx-center) < width &&
162      *  0 <= y + (fy-center) && y + (fy-center) < height
163      *
164      *  0 <= x + (fx - center)  x + fx - center < width
165      *  center - x <= fx        fx < width + center - x
166      */
167
168     fx_start = center - x;
169     if (fx_start < 0)
170         fx_start = 0;
171     fx_end = width + center - x;
172     if (fx_end > g_size)
173         fx_end = g_size;
174
175     fy_start = center - y;
176     if (fy_start < 0)
177         fy_start = 0;
178     fy_end = height + center - y;
179     if (fy_end > g_size)
180         fy_end = g_size;
181
182     g_line = g_line + fy_start * g_size + fx_start;
183     
184     v = 0;
185     for (fy = fy_start; fy < fy_end; fy++)
186     {
187         g_data = g_line;
188         g_line += g_size;
189         
190         for (fx = fx_start; fx < fx_end; fx++)
191             v += *g_data++;
192     }
193     if (v > 1)
194         v = 1;
195     
196     return ((unsigned int) (v * opacity * 255.0));
197 }
198
199 static XImage *
200 make_shadow (Display *dpy, double opacity, int width, int height)
201 {
202     XImage          *ximage;
203     unsigned char   *data;
204     int             gsize = gaussianMap->size;
205     int             ylimit, xlimit;
206     int             swidth = width + gsize;
207     int             sheight = height + gsize;
208     int             center = gsize / 2;
209     int             x, y;
210     unsigned char   d;
211     
212     data = malloc (swidth * sheight * sizeof (unsigned char));
213     ximage = XCreateImage (dpy,
214                            DefaultVisual(dpy, DefaultScreen(dpy)),
215                            8,
216                            ZPixmap,
217                            0,
218                            (char *) data,
219                            swidth, sheight, 8, swidth * sizeof (unsigned char));
220     /*
221      * Build the gaussian in sections
222      */
223
224     /*
225      * corners
226      */
227     ylimit = gsize;
228     if (ylimit > sheight / 2)
229         ylimit = (sheight + 1) / 2;
230     xlimit = gsize;
231     if (xlimit > swidth / 2)
232         xlimit = (swidth + 1) / 2;
233
234     for (y = 0; y < ylimit; y++)
235         for (x = 0; x < xlimit; x++)
236         {
237             d = sum_gaussian (gaussianMap, opacity, x - center, y - center, width, height);
238             data[y * swidth + x] = d;
239             data[(sheight - y - 1) * swidth + x] = d;
240             data[(sheight - y - 1) * swidth + (swidth - x - 1)] = d;
241             data[y * swidth + (swidth - x - 1)] = d;
242         }
243
244     /*
245      * top/bottom
246      */
247     for (y = 0; y < ylimit; y++)
248     {
249         d = sum_gaussian (gaussianMap, opacity, center, y - center, width, height);
250         for (x = gsize; x < swidth - gsize; x++)
251         {
252             data[y * swidth + x] = d;
253             data[(sheight - y - 1) * swidth + x] = d;
254         }
255     }
256
257     /*
258      * sides
259      */
260     
261     for (x = 0; x < xlimit; x++)
262     {
263         d = sum_gaussian (gaussianMap, opacity, x - center, center, width, height);
264         for (y = gsize; y < sheight - gsize; y++)
265         {
266             data[y * swidth + x] = d;
267             data[y * swidth + (swidth - x - 1)] = d;
268         }
269     }
270
271     /*
272      * center
273      */
274
275     d = sum_gaussian (gaussianMap, opacity, center, center, width, height);
276     for (y = ylimit; y < sheight - ylimit; y++)
277         for (x = xlimit; x < swidth - xlimit; x++)
278             data[y * swidth + x] = d;
279
280     return ximage;
281 }
282
283 static Picture
284 shadow_picture (Display *dpy, double opacity, int width, int height, int *wp, int *hp)
285 {
286     XImage  *shadowImage = make_shadow (dpy, opacity, width, height);
287     Pixmap  shadowPixmap = XCreatePixmap (dpy, root, 
288                                           shadowImage->width,
289                                           shadowImage->height,
290                                           8);
291     Picture shadowPicture = XRenderCreatePicture (dpy, shadowPixmap,
292                                                   XRenderFindStandardFormat (dpy, PictStandardA8),
293                                                   0, 0);
294     GC      gc = XCreateGC (dpy, shadowPixmap, 0, 0);
295     
296     XPutImage (dpy, shadowPixmap, gc, shadowImage, 0, 0, 0, 0, 
297                shadowImage->width,
298                shadowImage->height);
299     *wp = shadowImage->width;
300     *hp = shadowImage->height;
301     XFreeGC (dpy, gc);
302     XDestroyImage (shadowImage);
303     XFreePixmap (dpy, shadowPixmap);
304     return shadowPicture;
305 }
306
307 static win *
308 find_win (Display *dpy, Window id)
309 {
310     win *w;
311
312     for (w = list; w; w = w->next)
313         if (w->id == id)
314             return w;
315     return 0;
316 }
317
318 static char *backgroundProps[] = {
319     "_XROOTPMAP_ID",
320     "_XSETROOT_ID",
321     0,
322 };
323     
324 static Picture
325 root_tile (Display *dpy)
326 {
327     Picture         picture;
328     Atom            actual_type;
329     Pixmap          pixmap;
330     int             actual_format;
331     unsigned long   nitems;
332     unsigned long   bytes_after;
333     unsigned char   *prop;
334     Bool            fill;
335     XRenderPictureAttributes    pa;
336     int             p;
337
338     for (p = 0; backgroundProps[p]; p++)
339     {
340         if (XGetWindowProperty (dpy, root, XInternAtom (dpy, backgroundProps[p], False),
341                                 0, 4, False, AnyPropertyType,
342                                 &actual_type, &actual_format, &nitems, &bytes_after, &prop) == Success &&
343             actual_type == XInternAtom (dpy, "PIXMAP", False) && actual_format == 32 && nitems == 1)
344         {
345             memcpy (&pixmap, prop, 4);
346             XFree (prop);
347             fill = False;
348             break;
349         }
350     }
351     if (!backgroundProps[p])
352     {
353         pixmap = XCreatePixmap (dpy, root, 1, 1, DefaultDepth (dpy, scr));
354         fill = True;
355     }
356     pa.repeat = True;
357     picture = XRenderCreatePicture (dpy, pixmap,
358                                     XRenderFindVisualFormat (dpy,
359                                                              DefaultVisual (dpy, scr)),
360                                     CPRepeat, &pa);
361     if (fill)
362     {
363         XRenderColor    c;
364         
365         c.red = c.green = c.blue = 0x8080;
366         c.alpha = 0xffff;
367         XRenderFillRectangle (dpy, PictOpSrc, picture, &c, 
368                               0, 0, 1, 1);
369     }
370     return picture;
371 }
372
373 static void
374 paint_root (Display *dpy)
375 {
376     if (!rootTile)
377         rootTile = root_tile (dpy);
378     
379     XRenderComposite (dpy, PictOpSrc,
380                       rootTile, None, rootBuffer,
381                       0, 0, 0, 0, 0, 0, root_width, root_height);
382 }
383
384 static XserverRegion
385 win_extents (Display *dpy, win *w)
386 {
387     XRectangle      r;
388     
389     r.x = w->a.x;
390     r.y = w->a.y;
391     r.width = w->a.width + w->a.border_width * 2;
392     r.height = w->a.height + w->a.border_width * 2;
393     if (w->mode != WINDOW_ARGB)
394     {
395         XRectangle  sr;
396         
397         if (!w->shadow)
398         {
399             double      opacity = SHADOW_OPACITY;
400             if (w->mode == WINDOW_TRANS)
401                 opacity = opacity * TRANS_OPACITY;
402             w->shadow = shadow_picture (dpy, opacity,
403                                         w->a.width + w->a.border_width * 2,
404                                         w->a.height + w->a.border_width * 2,
405                                         &w->shadow_width, &w->shadow_height);
406             w->shadow_dx = SHADOW_OFFSET_X;
407             w->shadow_dy = SHADOW_OFFSET_Y;
408         }
409         sr.x = w->a.x + w->shadow_dx;
410         sr.y = w->a.y + w->shadow_dy;
411         sr.width = w->shadow_width;
412         sr.height = w->shadow_height;
413         if (sr.x < r.x)
414         {
415             r.width = (r.x + r.width) - sr.x;
416             r.x = sr.x;
417         }
418         if (sr.y < r.y)
419         {
420             r.height = (r.y + r.height) - sr.y;
421             r.y = sr.y;
422         }
423         if (sr.width > r.width)
424             r.width = sr.width;
425         if (sr.height > r.height)
426             r.height = sr.height;
427     }
428     return XFixesCreateRegion (dpy, &r, 1);
429 }
430
431 static XserverRegion
432 border_size (Display *dpy, win *w)
433 {
434     XserverRegion   border;
435     border = XFixesCreateRegionFromWindow (dpy, w->id, WindowRegionBounding);
436     /* translate this */
437     XFixesTranslateRegion (dpy, border,
438                            w->a.x + w->a.border_width,
439                            w->a.y + w->a.border_width);
440     return border;
441 }
442
443 static void
444 paint_all (Display *dpy, XserverRegion region)
445 {
446     win *w;
447     win *t = 0;
448     
449     if (!region)
450     {
451         XRectangle  r;
452         r.x = 0;
453         r.y = 0;
454         r.width = root_width;
455         r.height = root_height;
456         region = XFixesCreateRegion (dpy, &r, 1);
457     }
458 #if MONITOR_REPAINT
459     rootBuffer = rootPicture;
460 #else
461     if (!rootBuffer)
462     {
463         Pixmap  rootPixmap = XCreatePixmap (dpy, root, root_width, root_height,
464                                             DefaultDepth (dpy, scr));
465         rootBuffer = XRenderCreatePicture (dpy, rootPixmap,
466                                            XRenderFindVisualFormat (dpy,
467                                                                     DefaultVisual (dpy, scr)),
468                                            0, 0);
469         XFreePixmap (dpy, rootPixmap);
470     }
471 #endif
472     XFixesSetPictureClipRegion (dpy, rootPicture, 0, 0, region);
473 #if MONITOR_REPAINT
474     XRenderComposite (dpy, PictOpSrc, blackPicture, None, rootPicture,
475                       0, 0, 0, 0, 0, 0, root_width, root_height);
476 #endif
477 #if DEBUG
478     printf ("paint:");
479 #endif
480     for (w = list; w; w = w->next)
481     {
482         if (w->a.map_state != IsViewable)
483             continue;
484         /* never painted, ignore it */
485         if (!w->damaged)
486             continue;
487         if (!w->picture)
488             continue;
489 #if DEBUG
490         printf (" 0x%x", w->id);
491 #endif
492         if (w->borderSize)
493             XFixesDestroyRegion (dpy, w->borderSize);
494         w->borderSize = border_size (dpy, w);
495         if (w->extents)
496             XFixesDestroyRegion (dpy, w->extents);
497         w->extents = win_extents (dpy, w);
498         if (w->mode == WINDOW_SOLID)
499         {
500             XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, region);
501             XFixesSubtractRegion (dpy, region, region, w->borderSize);
502             XRenderComposite (dpy, PictOpSrc, w->picture, None, rootBuffer,
503                               0, 0, 0, 0, 
504                               w->a.x + w->a.border_width,
505                               w->a.y + w->a.border_width,
506                               w->a.width,
507                               w->a.height);
508         }
509         w->borderClip = XFixesCreateRegion (dpy, 0, 0);
510         XFixesCopyRegion (dpy, w->borderClip, region);
511         w->prev_trans = t;
512         t = w;
513     }
514 #if DEBUG
515     printf ("\n");
516 #endif
517     XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, region);
518     paint_root (dpy);
519     for (w = t; w; w = w->prev_trans)
520     {
521         XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, w->borderClip);
522         if (w->shadow)
523         {
524             XRenderComposite (dpy, PictOpOver, blackPicture, w->shadow, rootBuffer,
525                               0, 0, 0, 0,
526                               w->a.x + w->shadow_dx,
527                               w->a.y + w->shadow_dy,
528                               w->shadow_width, w->shadow_height);
529         }
530         if (w->mode == WINDOW_TRANS)
531             XRenderComposite (dpy, PictOpOver, w->picture, transPicture, rootBuffer,
532                               0, 0, 0, 0, 
533                               w->a.x + w->a.border_width,
534                               w->a.y + w->a.border_width,
535                               w->a.width,
536                               w->a.height);
537         else if (w->mode == WINDOW_ARGB)
538             XRenderComposite (dpy, PictOpOver, w->picture, None, rootBuffer,
539                               0, 0, 0, 0, 
540                               w->a.x + w->a.border_width,
541                               w->a.y + w->a.border_width,
542                               w->a.width,
543                               w->a.height);
544         XFixesDestroyRegion (dpy, w->borderClip);
545         w->borderClip = None;
546     }
547     XFixesDestroyRegion (dpy, region);
548     if (rootBuffer != rootPicture)
549     {
550         XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, None);
551         XRenderComposite (dpy, PictOpSrc, rootBuffer, None, rootPicture,
552                           0, 0, 0, 0, 0, 0, root_width, root_height);
553     }
554 }
555
556 static void
557 add_damage (Display *dpy, XserverRegion damage)
558 {
559     if (allDamage)
560     {
561         XFixesUnionRegion (dpy, allDamage, allDamage, damage);
562         XFixesDestroyRegion (dpy, damage);
563     }
564     else
565         allDamage = damage;
566 }
567
568 static void
569 repair_win (Display *dpy, Window id)
570 {
571     win             *w = find_win (dpy, id);
572     XserverRegion   parts;
573
574     if (!w)
575         return;
576     if (!w->damaged)
577     {
578         parts = win_extents (dpy, w);
579         XDamageSubtract (dpy, w->damage, None, None);
580     }
581     else
582     {
583         parts = XFixesCreateRegion (dpy, 0, 0);
584         XDamageSubtract (dpy, w->damage, None, parts);
585         XFixesTranslateRegion (dpy, parts,
586                                w->a.x + w->a.border_width,
587                                w->a.y + w->a.border_width);
588     }
589     add_damage (dpy, parts);
590     w->damaged = 1;
591 }
592
593 static void
594 map_win (Display *dpy, Window id, unsigned long sequence)
595 {
596     win             *w = find_win (dpy, id);
597
598     if (!w)
599         return;
600     w->a.map_state = IsViewable;
601     w->damaged = 0;
602 }
603
604 static void
605 unmap_win (Display *dpy, Window id)
606 {
607     win *w = find_win (dpy, id);
608
609     if (!w)
610         return;
611     w->a.map_state = IsUnmapped;
612     w->damaged = 0;
613     if (w->extents != None)
614     {
615         add_damage (dpy, w->extents);    /* destroys region */
616         w->extents = None;
617     }
618 }
619
620 static void
621 add_win (Display *dpy, Window id, Window prev)
622 {
623     win                         *new = malloc (sizeof (win));
624     win                         **p;
625     XRenderPictureAttributes    pa;
626     XRenderPictFormat           *format;
627     
628     if (!new)
629         return;
630     if (prev)
631     {
632         for (p = &list; *p; p = &(*p)->next)
633             if ((*p)->id == prev)
634                 break;
635     }
636     else
637         p = &list;
638     new->id = id;
639     if (!XGetWindowAttributes (dpy, id, &new->a))
640     {
641         free (new);
642         return;
643     }
644     new->damage = None;
645     new->damaged = 0;
646     new->damage = None;
647     pa.subwindow_mode = IncludeInferiors;
648     if (new->a.class == InputOnly)
649     {
650         new->picture = 0;
651         format = 0;
652         new->damage_sequence = 0;
653     }
654     else
655     {
656         format = XRenderFindVisualFormat (dpy, new->a.visual);
657         new->picture = XRenderCreatePicture (dpy, id,
658                                              format,
659                                              CPSubwindowMode,
660                                              &pa);
661         new->damage_sequence = NextRequest (dpy);
662         new->damage = XDamageCreate (dpy, id, XDamageReportNonEmpty);
663     }
664                                          
665     new->shadow = None;
666     new->shadow_dx = 0;
667     new->shadow_dy = 0;
668     new->shadow_width = 0;
669     new->shadow_height = 0;
670     new->borderSize = None;
671     new->extents = None;
672     if (format && format->type == PictTypeDirect && format->direct.alphaMask)
673         new->mode = WINDOW_ARGB;
674     else if (new->a.override_redirect)
675         new->mode = WINDOW_TRANS;
676     else
677         new->mode = WINDOW_SOLID;
678     new->next = *p;
679     *p = new;
680     if (new->a.map_state == IsViewable)
681         map_win (dpy, id, new->damage_sequence - 1);
682 }
683
684 void
685 restack_win (Display *dpy, win *w, Window new_above)
686 {
687     Window  old_above;
688     
689     if (w->next)
690         old_above = w->next->id;
691     else
692         old_above = None;
693     if (old_above != new_above)
694     {
695         win **prev;
696
697         /* unhook */
698         for (prev = &list; *prev; prev = &(*prev)->next)
699             if ((*prev) == w)
700                 break;
701         *prev = w->next;
702         
703         /* rehook */
704         for (prev = &list; *prev; prev = &(*prev)->next)
705         {
706             if ((*prev)->id == new_above)
707                 break;
708         }
709         w->next = *prev;
710         *prev = w;
711     }
712 }
713
714 static void
715 configure_win (Display *dpy, XConfigureEvent *ce)
716 {
717     win             *w = find_win (dpy, ce->window);
718     Window          above;
719     XserverRegion   damage = None;
720     
721     if (!w)
722     {
723         if (ce->window == root)
724         {
725             if (rootBuffer)
726             {
727                 XRenderFreePicture (dpy, rootBuffer);
728                 rootBuffer = None;
729             }
730             root_width = ce->width;
731             root_height = ce->height;
732         }
733         return;
734     }
735     if (w->a.map_state == IsViewable)
736     {
737         damage = XFixesCreateRegion (dpy, 0, 0);
738         if (w->extents != None) 
739             XFixesCopyRegion (dpy, damage, w->extents);
740     }
741     w->a.x = ce->x;
742     w->a.y = ce->y;
743     if (w->a.width != ce->width || w->a.height != ce->height)
744         if (w->shadow)
745         {
746             XRenderFreePicture (dpy, w->shadow);
747             w->shadow = None;
748         }
749     w->a.width = ce->width;
750     w->a.height = ce->height;
751     w->a.border_width = ce->border_width;
752     w->a.override_redirect = ce->override_redirect;
753     restack_win (dpy, w, ce->above);
754     if (damage)
755     {
756         XserverRegion   extents = win_extents (dpy, w);
757         XFixesUnionRegion (dpy, damage, damage, extents);
758         XFixesDestroyRegion (dpy, extents);
759         add_damage (dpy, damage);
760     }
761 }
762
763 static void
764 circulate_win (Display *dpy, XCirculateEvent *ce)
765 {
766     win     *w = find_win (dpy, ce->window);
767     Window  new_above;
768
769     if (ce->place == PlaceOnTop)
770         new_above = list->id;
771     else
772         new_above = None;
773     restack_win (dpy, w, new_above);
774 }
775
776 static void
777 destroy_win (Display *dpy, Window id, Bool gone)
778 {
779     win **prev, *w;
780
781     for (prev = &list; (w = *prev); prev = &w->next)
782         if (w->id == id)
783         {
784             if (!gone)
785                 unmap_win (dpy, id);
786             *prev = w->next;
787             if (w->picture)
788                 XRenderFreePicture (dpy, w->picture);
789             if (w->damage != None)
790                 XDamageDestroy (dpy, w->damage);
791             free (w);
792             break;
793         }
794 }
795
796 /*
797 static void
798 dump_win (win *w)
799 {
800     printf ("\t%08lx: %d x %d + %d + %d (%d)\n", w->id,
801             w->a.width, w->a.height, w->a.x, w->a.y, w->a.border_width);
802 }
803
804
805 static void
806 dump_wins (void)
807 {
808     win *w;
809
810     printf ("windows:\n");
811     for (w = list; w; w = w->next)
812         dump_win (w);
813 }
814 */
815
816 static void
817 damage_win (Display *dpy, XDamageNotifyEvent *de)
818 {
819     repair_win (dpy, de->drawable);
820 }
821
822 static int
823 error (Display *dpy, XErrorEvent *ev)
824 {
825     printf ("error %d request %d minor %d\n",
826             ev->error_code, ev->request_code, ev->minor_code);
827
828     return 0;
829 }
830
831 static void
832 expose_root (Display *dpy, Window root, XRectangle *rects, int nrects)
833 {
834     XserverRegion  region = XFixesCreateRegion (dpy, rects, nrects);
835     
836     add_damage (dpy, region);
837 }
838
839 #define INTERVAL    0
840
841 #if INTERVAL
842 static int
843 time_in_millis (void)
844 {
845     struct timeval  tp;
846
847     gettimeofday (&tp, 0);
848     return(tp.tv_sec * 1000) + (tp.tv_usec / 1000);
849 }
850 #endif
851
852 #define INTERVAL    0
853
854 static int
855 ev_serial (XEvent *ev)
856 {
857     if (ev->type & 0x7f != KeymapNotify)
858         return ev->xany.serial;
859     return NextRequest (ev->xany.display);
860 }
861
862 int                 damage_event, damage_error;
863
864 static char *
865 ev_name (XEvent *ev)
866 {
867     static char buf[128];
868     switch (ev->type & 0x7f) {
869     case Expose:
870         return "Expose";
871     case MapNotify:
872         return "Map";
873     case UnmapNotify:
874         return "Unmap";
875     case ReparentNotify:
876         return "Reparent";
877     case CirculateNotify:
878         return "Circulate";
879     default:
880         if (ev->type == damage_event + XDamageNotify)
881             return "Damage";
882         sprintf (buf, "Event %d", ev->type);
883         return buf;
884     }
885 }
886
887 static Window
888 ev_window (XEvent *ev)
889 {
890     switch (ev->type) {
891     case Expose:
892         return ev->xexpose.window;
893     case MapNotify:
894         return ev->xmap.window;
895     case UnmapNotify:
896         return ev->xunmap.window;
897     case ReparentNotify:
898         return ev->xreparent.window;
899     case CirculateNotify:
900         return ev->xcirculate.window;
901     default:
902         if (ev->type == damage_event + XDamageNotify)
903             return ((XDamageNotifyEvent *) ev)->drawable;
904         return 0;
905     }
906 }
907
908 int
909 main (int argc, char **argv)
910 {
911     XEvent          ev;
912     int             event_base, error_base;
913     Window          root_return, parent_return;
914     Window          *children;
915     Pixmap          transPixmap;
916     Pixmap          blackPixmap;
917     unsigned int    nchildren;
918     int             i;
919     int             xfixes_event, xfixes_error;
920     XRenderPictureAttributes    pa;
921     XRenderColor                c;
922     XRectangle      *expose_rects = 0;
923     int             size_expose = 0;
924     int             n_expose = 0;
925     struct pollfd   ufd;
926     int             n;
927     int             last_update;
928     int             now;
929     int             p;
930 #if INTERVAL
931     int             timeout;
932 #endif
933
934     dpy = XOpenDisplay (0);
935     if (!dpy)
936     {
937         fprintf (stderr, "Can't open display\n");
938         exit (1);
939     }
940     XSetErrorHandler (error);
941     scr = DefaultScreen (dpy);
942     root = RootWindow (dpy, scr);
943     pa.subwindow_mode = IncludeInferiors;
944
945     gaussianMap = make_gaussian_map(dpy, SHADOW_RADIUS);
946
947     transPixmap = XCreatePixmap (dpy, root, 1, 1, 8);
948     pa.repeat = True;
949     transPicture = XRenderCreatePicture (dpy, transPixmap,
950                                          XRenderFindStandardFormat (dpy, PictStandardA8),
951                                          CPRepeat,
952                                          &pa);
953     c.red = c.green = c.blue = 0;
954     c.alpha = 0xc0c0;
955     XRenderFillRectangle (dpy, PictOpSrc, transPicture, &c, 0, 0, 1, 1);
956     
957     root_width = DisplayWidth (dpy, scr);
958     root_height = DisplayHeight (dpy, scr);
959     
960     rootPicture = XRenderCreatePicture (dpy, root, 
961                                         XRenderFindVisualFormat (dpy,
962                                                                  DefaultVisual (dpy, scr)),
963                                         CPSubwindowMode,
964                                         &pa);
965     blackPixmap = XCreatePixmap (dpy, root, 1, 1, 32);
966     pa.repeat = True;
967     blackPicture = XRenderCreatePicture (dpy, blackPixmap,
968                                          XRenderFindStandardFormat (dpy, PictStandardARGB32),
969                                          CPRepeat,
970                                          &pa);
971     c.red = c.green = c.blue = 0;
972     c.alpha = 0xffff;
973     XRenderFillRectangle (dpy, PictOpSrc, blackPicture, &c, 0, 0, 1, 1);
974     if (!XCompositeQueryExtension (dpy, &event_base, &error_base))
975     {
976         fprintf (stderr, "No composite extension\n");
977         exit (1);
978     }
979     if (!XDamageQueryExtension (dpy, &damage_event, &damage_error))
980     {
981         fprintf (stderr, "No damage extension\n");
982         exit (1);
983     }
984     if (!XFixesQueryExtension (dpy, &xfixes_event, &xfixes_error))
985     {
986         fprintf (stderr, "No XFixes extension\n");
987         exit (1);
988     }
989     allDamage = None;
990     XGrabServer (dpy);
991     XCompositeRedirectSubwindows (dpy, root, CompositeRedirectManual);
992     XSelectInput (dpy, root, 
993                   SubstructureNotifyMask|
994                   ExposureMask|
995                   StructureNotifyMask|
996                   PropertyChangeMask);
997     XQueryTree (dpy, root, &root_return, &parent_return, &children, &nchildren);
998     for (i = 0; i < nchildren; i++)
999         add_win (dpy, children[i], i ? children[i-1] : None);
1000     XFree (children);
1001     XUngrabServer (dpy);
1002     paint_all (dpy, None);
1003 #if INTERVAL
1004     last_update = time_in_millis ();
1005 #endif
1006     for (;;)
1007     {
1008 #if INTERVAL
1009         int busy_start = 0;
1010 #endif
1011 /*      dump_wins (); */
1012         do {
1013             XNextEvent (dpy, &ev);
1014 #if INTERVAL
1015             if (!busy_start)
1016                 busy_start = time_in_millis();
1017 #endif
1018 #if DEBUG
1019             printf ("event %10.10s serial 0x%08x window 0x%08x\n",
1020                     ev_name(&ev), ev_serial (&ev), ev_window (&ev));
1021 #endif
1022             switch (ev.type) {
1023             case CreateNotify:
1024                 add_win (dpy, ev.xcreatewindow.window, 0);
1025                 break;
1026             case ConfigureNotify:
1027                 configure_win (dpy, &ev.xconfigure);
1028                 break;
1029             case DestroyNotify:
1030                 destroy_win (dpy, ev.xdestroywindow.window, True);
1031                 break;
1032             case MapNotify:
1033                 map_win (dpy, ev.xmap.window, ev.xmap.serial);
1034                 break;
1035             case UnmapNotify:
1036                 unmap_win (dpy, ev.xunmap.window);
1037                 break;
1038             case ReparentNotify:
1039                 if (ev.xreparent.parent == root)
1040                     add_win (dpy, ev.xreparent.window, 0);
1041                 else
1042                     destroy_win (dpy, ev.xreparent.window, False);
1043                 break;
1044             case CirculateNotify:
1045                 circulate_win (dpy, &ev.xcirculate);
1046                 break;
1047             case Expose:
1048                 if (ev.xexpose.window == root)
1049                 {
1050                     int more = ev.xexpose.count + 1;
1051                     if (n_expose == size_expose)
1052                     {
1053                         if (expose_rects)
1054                         {
1055                             expose_rects = realloc (expose_rects, 
1056                                                     (size_expose + more) * 
1057                                                     sizeof (XRectangle));
1058                             size_expose += more;
1059                         }
1060                         else
1061                         {
1062                             expose_rects = malloc (more * sizeof (XRectangle));
1063                             size_expose = more;
1064                         }
1065                     }
1066                     expose_rects[n_expose].x = ev.xexpose.x;
1067                     expose_rects[n_expose].y = ev.xexpose.y;
1068                     expose_rects[n_expose].width = ev.xexpose.width;
1069                     expose_rects[n_expose].height = ev.xexpose.height;
1070                     n_expose++;
1071                     if (ev.xexpose.count == 0)
1072                     {
1073                         expose_root (dpy, root, expose_rects, n_expose);
1074                         n_expose = 0;
1075                     }
1076                 }
1077                 break;
1078             case PropertyNotify:
1079                 for (p = 0; backgroundProps[p]; p++)
1080                 {
1081                     if (ev.xproperty.atom == XInternAtom (dpy, backgroundProps[p], False))
1082                     {
1083                         if (rootTile)
1084                         {
1085                             XClearArea (dpy, root, 0, 0, 0, 0, True);
1086                             XRenderFreePicture (dpy, rootTile);
1087                             rootTile = None;
1088                             break;
1089                         }
1090                     }
1091                 }
1092                 break;
1093             default:
1094                 if (ev.type == damage_event + XDamageNotify)
1095                     damage_win (dpy, (XDamageNotifyEvent *) &ev);
1096                 break;
1097             }
1098         } while (QLength (dpy));
1099 #if INTERVAL
1100         now = time_in_millis ();
1101 /*      printf ("\t\tbusy %d\n", now - busy_start); */
1102         timeout = INTERVAL - (now - last_update);
1103         if (timeout > 0)
1104         {
1105             ufd.fd = ConnectionNumber (dpy);
1106             ufd.events = POLLIN;
1107             n = poll (&ufd, 1, timeout);
1108             if (n > 0 && (ufd.revents & POLLIN) && XEventsQueued (dpy, QueuedAfterReading))
1109                 continue;
1110         }
1111 #endif
1112         if (allDamage)
1113         {
1114 #if INTERVAL
1115             int old_update = last_update;
1116             last_update = time_in_millis();
1117 /*          printf ("delta %d\n", last_update - old_update); */
1118 #endif
1119             paint_all (dpy, allDamage);
1120             allDamage = None;
1121         }
1122     }
1123 }