diff --git a/xcompmgr.c b/xcompmgr.c index c3a76cbb..4569bb72 100644 --- a/xcompmgr.c +++ b/xcompmgr.c @@ -23,7 +23,7 @@ */ -/* Modified by Matthew Hawn. I don't know what to say here so follow what it +/* Modified by Matthew Hawn. I don't know what to say here so follow what it says above. Not that I can really do anything about it */ @@ -51,1370 +51,1266 @@ #define CAN_DO_USABLE 0 typedef enum { - WINTYPE_DESKTOP, - WINTYPE_DOCK, - WINTYPE_TOOLBAR, - WINTYPE_MENU, - WINTYPE_UTILITY, - WINTYPE_SPLASH, - WINTYPE_DIALOG, - WINTYPE_NORMAL, - WINTYPE_DROPDOWN_MENU, - WINTYPE_POPUP_MENU, - WINTYPE_TOOLTIP, - WINTYPE_NOTIFY, - WINTYPE_COMBO, - WINTYPE_DND, - NUM_WINTYPES + WINTYPE_DESKTOP, + WINTYPE_DOCK, + WINTYPE_TOOLBAR, + WINTYPE_MENU, + WINTYPE_UTILITY, + WINTYPE_SPLASH, + WINTYPE_DIALOG, + WINTYPE_NORMAL, + WINTYPE_DROPDOWN_MENU, + WINTYPE_POPUP_MENU, + WINTYPE_TOOLTIP, + WINTYPE_NOTIFY, + WINTYPE_COMBO, + WINTYPE_DND, + NUM_WINTYPES } wintype; typedef struct _ignore { - struct _ignore *next; - unsigned long sequence; + struct _ignore *next; + unsigned long sequence; } ignore; typedef struct _win { - struct _win *next; - Window id; + struct _win *next; + Window id; #if HAS_NAME_WINDOW_PIXMAP - Pixmap pixmap; + Pixmap pixmap; #endif - XWindowAttributes a; + XWindowAttributes a; #if CAN_DO_USABLE - Bool usable; /* mapped and all damaged at one point */ - XRectangle damage_bounds; /* bounds of damage */ + Bool usable; /* mapped and all damaged at one point */ + XRectangle damage_bounds; /* bounds of damage */ #endif - int mode; - int damaged; - Damage damage; - Picture picture; - Picture alphaPict; - Picture shadowPict; - XserverRegion borderSize; - XserverRegion extents; - Picture shadow; - int shadow_dx; - int shadow_dy; - int shadow_width; - int shadow_height; - unsigned int opacity; - wintype windowType; - unsigned long damage_sequence; /* sequence when damage was created */ - Bool destroyed; + int mode; + int damaged; + Damage damage; + Picture picture; + Picture alphaPict; + Picture shadowPict; + XserverRegion borderSize; + XserverRegion extents; + Picture shadow; + int shadow_dx; + int shadow_dy; + int shadow_width; + int shadow_height; + unsigned int opacity; + wintype windowType; + unsigned long damage_sequence; /* sequence when damage was created */ + Bool destroyed; - Bool need_configure; - XConfigureEvent queue_configure; + Bool need_configure; + XConfigureEvent queue_configure; - /* for drawing translucent windows */ - XserverRegion borderClip; - struct _win *prev_trans; + /* for drawing translucent windows */ + XserverRegion borderClip; + struct _win *prev_trans; } win; typedef struct _conv { - int size; - double *data; + int size; + double *data; } conv; typedef struct _fade { - struct _fade *next; - win *w; - double cur; - double finish; - double step; - void (*callback) (Display *dpy, win *w); - Display *dpy; + struct _fade *next; + win *w; + double cur; + double finish; + double step; + void (*callback) (Display *dpy, win *w); + Display *dpy; } fade; -win *list; -fade *fades; -Display *dpy; -int scr; -Window root; -Picture rootPicture; -Picture rootBuffer; -Picture blackPicture; -Picture transBlackPicture; -Picture rootTile; -XserverRegion allDamage; -Bool clipChanged; +win *list; +fade *fades; +Display *dpy; +int scr; +Window root; +Picture rootPicture; +Picture rootBuffer; +Picture blackPicture; +Picture transBlackPicture; +Picture rootTile; +XserverRegion allDamage; +Bool clipChanged; #if HAS_NAME_WINDOW_PIXMAP -Bool hasNamePixmap; +Bool hasNamePixmap; #endif -int root_height, root_width; -ignore *ignore_head, **ignore_tail = &ignore_head; -int xfixes_event, xfixes_error; -int damage_event, damage_error; -int composite_event, composite_error; -int render_event, render_error; -Bool synchronize; -int composite_opcode; +int root_height, root_width; +ignore *ignore_head, **ignore_tail = &ignore_head; +int xfixes_event, xfixes_error; +int damage_event, damage_error; +int composite_event, composite_error; +int render_event, render_error; +Bool synchronize; +int composite_opcode; /* find these once and be done with it */ -Atom opacityAtom; -Atom winTypeAtom; -Atom winType[NUM_WINTYPES]; -double winTypeOpacity[NUM_WINTYPES]; -Bool winTypeShadow[NUM_WINTYPES]; -Bool winTypeFade[NUM_WINTYPES]; +Atom opacityAtom; +Atom winTypeAtom; +Atom winType[NUM_WINTYPES]; +double winTypeOpacity[NUM_WINTYPES]; +Bool winTypeShadow[NUM_WINTYPES]; +Bool winTypeFade[NUM_WINTYPES]; /* opacity property name; sometime soon I'll write up an EWMH spec for it */ -#define OPACITY_PROP "_NET_WM_WINDOW_OPACITY" +#define OPACITY_PROP "_NET_WM_WINDOW_OPACITY" #define REGISTER_PROP "_NET_WM_CM_S" -#define TRANSLUCENT 0xe0000000 -#define OPAQUE 0xffffffff +#define TRANSLUCENT 0xe0000000 +#define OPAQUE 0xffffffff -conv *gaussianMap; +conv *gaussianMap; -#define WINDOW_SOLID 0 -#define WINDOW_TRANS 1 -#define WINDOW_ARGB 2 +#define WINDOW_SOLID 0 +#define WINDOW_TRANS 1 +#define WINDOW_ARGB 2 -#define TRANS_OPACITY 0.75 +#define TRANS_OPACITY 0.75 #define DEBUG_REPAINT 0 #define DEBUG_EVENTS 0 #define MONITOR_REPAINT 0 -#define SHADOWS 1 -#define SHARP_SHADOW 0 +#define SHADOWS 1 +#define SHARP_SHADOW 0 typedef enum _compMode { - CompSimple, /* looks like a regular X server */ - CompServerShadows, /* use window alpha for shadow; sharp, but precise */ - CompClientShadows, /* use window extents for shadow, blurred */ + CompSimple, /* looks like a regular X server */ + CompServerShadows, /* use window alpha for shadow; sharp, but precise */ + CompClientShadows, /* use window extents for shadow, blurred */ } CompMode; static void determine_mode(Display *dpy, win *w); - + static double get_opacity_percent(Display *dpy, win *w); static XserverRegion -win_extents (Display *dpy, win *w); +win_extents(Display *dpy, win *w); -CompMode compMode = CompSimple; +CompMode compMode = CompSimple; -int shadowRadius = 12; -int shadowOffsetX = -15; -int shadowOffsetY = -15; -double shadowOpacity = .75; +int shadowRadius = 12; +int shadowOffsetX = -15; +int shadowOffsetY = -15; +double shadowOpacity = .75; double fade_in_step = 0.028; double fade_out_step = 0.03; -int fade_delta = 10; -int fade_time = 0; -Bool fadeTrans = False; +int fade_delta = 10; +int fade_time = 0; +Bool fadeTrans = False; -Bool autoRedirect = False; +Bool autoRedirect = False; /* For shadow precomputation */ -int Gsize = -1; +int Gsize = -1; unsigned char *shadowCorner = NULL; unsigned char *shadowTop = NULL; int -get_time_in_milliseconds () -{ - struct timeval tv; +get_time_in_milliseconds() { + struct timeval tv; - gettimeofday (&tv, NULL); - return tv.tv_sec * 1000 + tv.tv_usec / 1000; + gettimeofday(&tv, NULL); + return tv.tv_sec * 1000 + tv.tv_usec / 1000; } fade * -find_fade (win *w) -{ - fade *f; - - for (f = fades; f; f = f->next) - { - if (f->w == w) - return f; +find_fade(win *w) { + fade *f; + + for(f = fades; f; f = f->next) { + if (f->w == w) + return f; + } + return 0; +} + +void +dequeue_fade(Display *dpy, fade *f) { + fade **prev; + + for (prev = &fades; *prev; prev = &(*prev)->next) + if (*prev == f) { + *prev = f->next; + if (f->callback) + (*f->callback) (dpy, f->w); + free(f); + break; } - return 0; } void -dequeue_fade (Display *dpy, fade *f) -{ - fade **prev; - - for (prev = &fades; *prev; prev = &(*prev)->next) - if (*prev == f) - { - *prev = f->next; - if (f->callback) - (*f->callback) (dpy, f->w); - free (f); - break; - } +cleanup_fade(Display *dpy, win *w) { + fade *f = find_fade (w); + if (f) + dequeue_fade(dpy, f); } void -cleanup_fade (Display *dpy, win *w) -{ - fade *f = find_fade (w); - if (f) - dequeue_fade (dpy, f); -} - -void -enqueue_fade (Display *dpy, fade *f) -{ - if (!fades) - fade_time = get_time_in_milliseconds () + fade_delta; - f->next = fades; - fades = f; +enqueue_fade(Display *dpy, fade *f) { + if (!fades) + fade_time = get_time_in_milliseconds() + fade_delta; + f->next = fades; + fades = f; } static void -set_fade (Display *dpy, win *w, double start, double finish, double step, - void (*callback) (Display *dpy, win *w), - Bool exec_callback, Bool override) -{ - fade *f; +set_fade(Display *dpy, win *w, double start, double finish, double step, + void(*callback) (Display *dpy, win *w), + Bool exec_callback, Bool override) { + fade *f; - f = find_fade (w); - if (!f) - { - f = malloc (sizeof (fade)); - f->next = 0; - f->w = w; - f->cur = start; - enqueue_fade (dpy, f); - } - else if(!override) - return; - else - { - if (exec_callback) - if (f->callback) - (*f->callback)(dpy, f->w); - } + f = find_fade(w); + if (!f) { + f = malloc(sizeof(fade)); + f->next = 0; + f->w = w; + f->cur = start; + enqueue_fade(dpy, f); + } else if (!override) + return; + else { + if (exec_callback) + if (f->callback) + (*f->callback)(dpy, f->w); + } - if (finish < 0) - finish = 0; - if (finish > 1) - finish = 1; - f->finish = finish; - if (f->cur < finish) - f->step = step; - else if (f->cur > finish) - f->step = -step; - f->callback = callback; - w->opacity = f->cur * OPAQUE; + if (finish < 0) + finish = 0; + if (finish > 1) + finish = 1; + f->finish = finish; + if (f->cur < finish) + f->step = step; + else if (f->cur > finish) + f->step = -step; + f->callback = callback; + w->opacity = f->cur * OPAQUE; #if 0 - printf ("set_fade start %g step %g\n", f->cur, f->step); + printf("set_fade start %g step %g\n", f->cur, f->step); #endif - determine_mode (dpy, w); - if (w->shadow) - { - XRenderFreePicture (dpy, w->shadow); - w->shadow = None; + determine_mode(dpy, w); + if (w->shadow) { + XRenderFreePicture(dpy, w->shadow); + w->shadow = None; - if (w->extents != None) - XFixesDestroyRegion (dpy, w->extents); + if (w->extents != None) + XFixesDestroyRegion(dpy, w->extents); - /* rebuild the shadow */ - w->extents = win_extents (dpy, w); - } + /* rebuild the shadow */ + w->extents = win_extents(dpy, w); + } - /* fading windows need to be drawn, mark them as damaged. - when a window maps, if it tries to fade in but it already at the right - opacity (map/unmap/map fast) then it will never get drawn without this - until it repaints */ - w->damaged = 1; + /* fading windows need to be drawn, mark them as damaged. + when a window maps, if it tries to fade in but it already at the right + opacity (map/unmap/map fast) then it will never get drawn without this + until it repaints */ + w->damaged = 1; } int -fade_timeout (void) -{ - int now; - int delta; - if (!fades) - return -1; - now = get_time_in_milliseconds(); - delta = fade_time - now; - if (delta < 0) - delta = 0; -/* printf ("timeout %d\n", delta); */ - return delta; +fade_timeout(void) { + int now; + int delta; + if (!fades) + return -1; + now = get_time_in_milliseconds(); + delta = fade_time - now; + if (delta < 0) + delta = 0; +/* printf("timeout %d\n", delta); */ + return delta; } void -run_fades (Display *dpy) -{ - int now = get_time_in_milliseconds(); - fade *next = fades; - int steps; - Bool need_dequeue; +run_fades(Display *dpy) { + int now = get_time_in_milliseconds(); + fade *next = fades; + int steps; + Bool need_dequeue; #if 0 - printf ("run fades\n"); + printf("run fades\n"); #endif - if (fade_time - now > 0) - return; - steps = 1 + (now - fade_time) / fade_delta; + if (fade_time - now > 0) + return; + steps = 1 + (now - fade_time) / fade_delta; - while (next) - { - fade *f = next; - win *w = f->w; - next = f->next; - f->cur += f->step * steps; - if (f->cur >= 1) - f->cur = 1; - else if (f->cur < 0) - f->cur = 0; + while (next) { + fade *f = next; + win *w = f->w; + next = f->next; + f->cur += f->step * steps; + if (f->cur >= 1) + f->cur = 1; + else if (f->cur < 0) + f->cur = 0; #if 0 - printf ("opacity now %g\n", f->cur); + printf("opacity now %g\n", f->cur); #endif - w->opacity = f->cur * OPAQUE; - need_dequeue = False; - if (f->step > 0) - { - if (f->cur >= f->finish) - { - w->opacity = f->finish*OPAQUE; - need_dequeue = True; - } - } - else - { - if (f->cur <= f->finish) - { - w->opacity = f->finish*OPAQUE; - need_dequeue = True; - } - } - determine_mode (dpy, w); - if (w->shadow) - { - XRenderFreePicture (dpy, w->shadow); - w->shadow = None; - - if (w->extents != None) - XFixesDestroyRegion (dpy, w->extents); - - /* rebuild the shadow */ - w->extents = win_extents(dpy, w); - } - /* Must do this last as it might destroy f->w in callbacks */ - if (need_dequeue) - dequeue_fade (dpy, f); + w->opacity = f->cur * OPAQUE; + need_dequeue = False; + if (f->step > 0) { + if (f->cur >= f->finish) { + w->opacity = f->finish*OPAQUE; + need_dequeue = True; + } + } else { + if (f->cur <= f->finish) { + w->opacity = f->finish*OPAQUE; + need_dequeue = True; + } } - fade_time = now + fade_delta; + determine_mode(dpy, w); + if (w->shadow) { + XRenderFreePicture(dpy, w->shadow); + w->shadow = None; + + if (w->extents != None) + XFixesDestroyRegion(dpy, w->extents); + + /* rebuild the shadow */ + w->extents = win_extents(dpy, w); + } + /* Must do this last as it might destroy f->w in callbacks */ + if (need_dequeue) + dequeue_fade(dpy, f); + } + fade_time = now + fade_delta; } static double -gaussian (double r, double x, double y) -{ - return ((1 / (sqrt (2 * M_PI * r))) * - exp ((- (x * x + y * y)) / (2 * r * r))); +gaussian(double r, double x, double y) { + return ((1 / (sqrt(2 * M_PI * r))) * + exp((- (x * x + y * y)) / (2 * r * r))); } static conv * -make_gaussian_map (Display *dpy, double r) -{ - conv *c; - int size = ((int) ceil ((r * 3)) + 1) & ~1; - int center = size / 2; - int x, y; - double t; - double g; - - c = malloc (sizeof (conv) + size * size * sizeof (double)); - c->size = size; - c->data = (double *) (c + 1); - t = 0.0; - for (y = 0; y < size; y++) - for (x = 0; x < size; x++) - { - g = gaussian (r, (double) (x - center), (double) (y - center)); - t += g; - c->data[y * size + x] = g; - } -/* printf ("gaussian total %f\n", t); */ - for (y = 0; y < size; y++) - for (x = 0; x < size; x++) - { - c->data[y*size + x] /= t; - } - return c; +make_gaussian_map(Display *dpy, double r) { + conv *c; + int size = ((int) ceil((r * 3)) + 1) & ~1; + int center = size / 2; + int x, y; + double t; + double g; + + c = malloc(sizeof(conv) + size * size * sizeof(double)); + c->size = size; + c->data = (double *) (c + 1); + t = 0.0; + for (y = 0; y < size; y++) + for (x = 0; x < size; x++) { + g = gaussian(r, (double) (x - center), (double) (y - center)); + t += g; + c->data[y * size + x] = g; + } +/* printf("gaussian total %f\n", t); */ + for (y = 0; y < size; y++) + for (x = 0; x < size; x++) { + c->data[y*size + x] /= t; + } + return c; } /* * A picture will help * - * -center 0 width width+center + * -center 0 width width+center * -center +-----+-------------------+-----+ - * | | | | - * | | | | - * 0 +-----+-------------------+-----+ - * | | | | - * | | | | - * | | | | + * | | | | + * | | | | + * 0 +-----+-------------------+-----+ + * | | | | + * | | | | + * | | | | * height +-----+-------------------+-----+ - * | | | | - * height+ | | | | + * | | | | + * height+ | | | | * center +-----+-------------------+-----+ */ - + static unsigned char -sum_gaussian (conv *map, double opacity, int x, int y, int width, int height) -{ - int fx, fy; - double *g_data; - double *g_line = map->data; - int g_size = map->size; - int center = g_size / 2; - int fx_start, fx_end; - int fy_start, fy_end; - double v; - - /* - * Compute set of filter values which are "in range", - * that's the set with: - * 0 <= x + (fx-center) && x + (fx-center) < width && - * 0 <= y + (fy-center) && y + (fy-center) < height - * - * 0 <= x + (fx - center) x + fx - center < width - * center - x <= fx fx < width + center - x - */ +sum_gaussian(conv *map, double opacity, int x, int y, int width, int height) { + int fx, fy; + double *g_data; + double *g_line = map->data; + int g_size = map->size; + int center = g_size / 2; + int fx_start, fx_end; + int fy_start, fy_end; + double v; - fx_start = center - x; - if (fx_start < 0) - fx_start = 0; - fx_end = width + center - x; - if (fx_end > g_size) - fx_end = g_size; + /* + * Compute set of filter values which are "in range", + * that's the set with: + * 0 <= x + (fx-center) && x + (fx-center) < width && + * 0 <= y + (fy-center) && y + (fy-center) < height + * + * 0 <= x + (fx - center) x + fx - center < width + * center - x <= fx fx < width + center - x + */ - fy_start = center - y; - if (fy_start < 0) - fy_start = 0; - fy_end = height + center - y; - if (fy_end > g_size) - fy_end = g_size; + fx_start = center - x; + if (fx_start < 0) + fx_start = 0; + fx_end = width + center - x; + if (fx_end > g_size) + fx_end = g_size; - g_line = g_line + fy_start * g_size + fx_start; - - v = 0; - for (fy = fy_start; fy < fy_end; fy++) - { - g_data = g_line; - g_line += g_size; - - for (fx = fx_start; fx < fx_end; fx++) - v += *g_data++; - } - if (v > 1) - v = 1; - - return ((unsigned char) (v * opacity * 255.0)); + fy_start = center - y; + if (fy_start < 0) + fy_start = 0; + fy_end = height + center - y; + if (fy_end > g_size) + fy_end = g_size; + + g_line = g_line + fy_start * g_size + fx_start; + + v = 0; + for (fy = fy_start; fy < fy_end; fy++) { + g_data = g_line; + g_line += g_size; + + for (fx = fx_start; fx < fx_end; fx++) + v += *g_data++; + } + if (v > 1) + v = 1; + + return ((unsigned char) (v * opacity * 255.0)); } /* precompute shadow corners and sides to save time for large windows */ static void -presum_gaussian (conv *map) -{ - int center = map->size/2; - int opacity, x, y; +presum_gaussian(conv *map) { + int center = map->size/2; + int opacity, x, y; - Gsize = map->size; + Gsize = map->size; - if (shadowCorner) - free ((void *)shadowCorner); - if (shadowTop) - free ((void *)shadowTop); + if (shadowCorner) + free((void *)shadowCorner); + if (shadowTop) + free((void *)shadowTop); - shadowCorner = (unsigned char *)(malloc ((Gsize + 1) * (Gsize + 1) * 26)); - shadowTop = (unsigned char *)(malloc ((Gsize + 1) * 26)); - - for (x = 0; x <= Gsize; x++) - { - shadowTop[25 * (Gsize + 1) + x] = sum_gaussian (map, 1, x - center, center, Gsize * 2, Gsize * 2); - for(opacity = 0; opacity < 25; opacity++) - shadowTop[opacity * (Gsize + 1) + x] = shadowTop[25 * (Gsize + 1) + x] * opacity / 25; - for(y = 0; y <= x; y++) - { - shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x] - = sum_gaussian (map, 1, x - center, y - center, Gsize * 2, Gsize * 2); - shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + x * (Gsize + 1) + y] - = shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x]; - for(opacity = 0; opacity < 25; opacity++) - shadowCorner[opacity * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x] - = shadowCorner[opacity * (Gsize + 1) * (Gsize + 1) + x * (Gsize + 1) + y] - = shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x] * opacity / 25; - } + shadowCorner = (unsigned char *)(malloc((Gsize + 1) * (Gsize + 1) * 26)); + shadowTop = (unsigned char *)(malloc((Gsize + 1) * 26)); + + for (x = 0; x <= Gsize; x++) { + shadowTop[25 * (Gsize + 1) + x] = sum_gaussian(map, 1, x - center, center, Gsize * 2, Gsize * 2); + for(opacity = 0; opacity < 25; opacity++) + shadowTop[opacity * (Gsize + 1) + x] = shadowTop[25 * (Gsize + 1) + x] * opacity / 25; + for(y = 0; y <= x; y++) { + shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x] + = sum_gaussian(map, 1, x - center, y - center, Gsize * 2, Gsize * 2); + shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + x * (Gsize + 1) + y] + = shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x]; + for(opacity = 0; opacity < 25; opacity++) + shadowCorner[opacity * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x] + = shadowCorner[opacity * (Gsize + 1) * (Gsize + 1) + x * (Gsize + 1) + y] + = shadowCorner[25 * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x] * opacity / 25; } + } } static XImage * -make_shadow (Display *dpy, double opacity, int width, int height) -{ - XImage *ximage; - unsigned char *data; - int gsize = gaussianMap->size; - int ylimit, xlimit; - int swidth = width + gsize; - int sheight = height + gsize; - int center = gsize / 2; - int x, y; - unsigned char d; - int x_diff; - int opacity_int = (int)(opacity * 25); - data = malloc (swidth * sheight * sizeof (unsigned char)); - if (!data) - return 0; - ximage = XCreateImage (dpy, - DefaultVisual(dpy, DefaultScreen(dpy)), - 8, - ZPixmap, - 0, - (char *) data, - swidth, sheight, 8, swidth * sizeof (unsigned char)); - if (!ximage) - { - free (data); - return 0; - } - /* - * Build the gaussian in sections - */ +make_shadow(Display *dpy, double opacity, int width, int height) { + XImage *ximage; + unsigned char *data; + int gsize = gaussianMap->size; + int ylimit, xlimit; + int swidth = width + gsize; + int sheight = height + gsize; + int center = gsize / 2; + int x, y; + unsigned char d; + int x_diff; + int opacity_int = (int)(opacity * 25); + data = malloc(swidth * sheight * sizeof(unsigned char)); + if (!data) + return 0; + ximage = XCreateImage(dpy, + DefaultVisual(dpy, DefaultScreen(dpy)), + 8, + ZPixmap, + 0, + (char *) data, + swidth, sheight, 8, swidth * sizeof(unsigned char)); + if (!ximage) { + free(data); + return 0; + } + /* + * Build the gaussian in sections + */ - /* - * center (fill the complete data array) - */ - if (Gsize > 0) - d = shadowTop[opacity_int * (Gsize + 1) + Gsize]; + /* + * center (fill the complete data array) + */ + if (Gsize > 0) + d = shadowTop[opacity_int * (Gsize + 1) + Gsize]; + else + d = sum_gaussian(gaussianMap, opacity, center, center, width, height); + memset(data, d, sheight * swidth); + + /* + * corners + */ + ylimit = gsize; + if (ylimit > sheight / 2) + ylimit = (sheight + 1) / 2; + xlimit = gsize; + if (xlimit > swidth / 2) + xlimit = (swidth + 1) / 2; + + for (y = 0; y < ylimit; y++) + for (x = 0; x < xlimit; x++) { + if (xlimit == Gsize && ylimit == Gsize) + d = shadowCorner[opacity_int * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x]; + else + d = sum_gaussian(gaussianMap, opacity, x - center, y - center, width, height); + data[y * swidth + x] = d; + data[(sheight - y - 1) * swidth + x] = d; + data[(sheight - y - 1) * swidth + (swidth - x - 1)] = d; + data[y * swidth + (swidth - x - 1)] = d; + } + + /* + * top/bottom + */ + x_diff = swidth - (gsize * 2); + if (x_diff > 0 && ylimit > 0) { + for (y = 0; y < ylimit; y++) { + if (ylimit == Gsize) + d = shadowTop[opacity_int * (Gsize + 1) + y]; + else + d = sum_gaussian(gaussianMap, opacity, center, y - center, width, height); + memset(&data[y * swidth + gsize], d, x_diff); + memset(&data[(sheight - y - 1) * swidth + gsize], d, x_diff); + } + } + + /* + * sides + */ + + for (x = 0; x < xlimit; x++) { + if (xlimit == Gsize) + d = shadowTop[opacity_int * (Gsize + 1) + x]; else - d = sum_gaussian (gaussianMap, opacity, center, center, width, height); - memset(data, d, sheight * swidth); - - /* - * corners - */ - ylimit = gsize; - if (ylimit > sheight / 2) - ylimit = (sheight + 1) / 2; - xlimit = gsize; - if (xlimit > swidth / 2) - xlimit = (swidth + 1) / 2; - - for (y = 0; y < ylimit; y++) - for (x = 0; x < xlimit; x++) - { - if (xlimit == Gsize && ylimit == Gsize) - d = shadowCorner[opacity_int * (Gsize + 1) * (Gsize + 1) + y * (Gsize + 1) + x]; - else - d = sum_gaussian (gaussianMap, opacity, x - center, y - center, width, height); - data[y * swidth + x] = d; - data[(sheight - y - 1) * swidth + x] = d; - data[(sheight - y - 1) * swidth + (swidth - x - 1)] = d; - data[y * swidth + (swidth - x - 1)] = d; - } - - /* - * top/bottom - */ - x_diff = swidth - (gsize * 2); - if (x_diff > 0 && ylimit > 0) - { - for (y = 0; y < ylimit; y++) - { - if (ylimit == Gsize) - d = shadowTop[opacity_int * (Gsize + 1) + y]; - else - d = sum_gaussian (gaussianMap, opacity, center, y - center, width, height); - memset (&data[y * swidth + gsize], d, x_diff); - memset (&data[(sheight - y - 1) * swidth + gsize], d, x_diff); - } + d = sum_gaussian(gaussianMap, opacity, x - center, center, width, height); + for (y = gsize; y < sheight - gsize; y++) { + data[y * swidth + x] = d; + data[y * swidth + (swidth - x - 1)] = d; } + } - /* - * sides - */ - - for (x = 0; x < xlimit; x++) - { - if (xlimit == Gsize) - d = shadowTop[opacity_int * (Gsize + 1) + x]; - else - d = sum_gaussian (gaussianMap, opacity, x - center, center, width, height); - for (y = gsize; y < sheight - gsize; y++) - { - data[y * swidth + x] = d; - data[y * swidth + (swidth - x - 1)] = d; - } - } - - return ximage; + return ximage; } static Picture -shadow_picture (Display *dpy, double opacity, Picture alpha_pict, int width, int height, int *wp, int *hp) -{ - XImage *shadowImage; - Pixmap shadowPixmap; - Picture shadowPicture; - GC gc; - - shadowImage = make_shadow (dpy, opacity, width, height); - if (!shadowImage) - return None; - shadowPixmap = XCreatePixmap (dpy, root, - shadowImage->width, - shadowImage->height, - 8); - if (!shadowPixmap) - { - XDestroyImage (shadowImage); - return None; - } +shadow_picture(Display *dpy, double opacity, Picture alpha_pict, int width, int height, int *wp, int *hp) { + XImage *shadowImage; + Pixmap shadowPixmap; + Picture shadowPicture; + GC gc; - shadowPicture = XRenderCreatePicture (dpy, shadowPixmap, - XRenderFindStandardFormat (dpy, PictStandardA8), - 0, 0); - if (!shadowPicture) - { - XDestroyImage (shadowImage); - XFreePixmap (dpy, shadowPixmap); - return None; - } + shadowImage = make_shadow(dpy, opacity, width, height); + if (!shadowImage) + return None; + shadowPixmap = XCreatePixmap(dpy, root, + shadowImage->width, + shadowImage->height, + 8); + if (!shadowPixmap) { + XDestroyImage(shadowImage); + return None; + } - gc = XCreateGC (dpy, shadowPixmap, 0, 0); - if (!gc) - { - XDestroyImage (shadowImage); - XFreePixmap (dpy, shadowPixmap); - XRenderFreePicture (dpy, shadowPicture); - return None; - } - - XPutImage (dpy, shadowPixmap, gc, shadowImage, 0, 0, 0, 0, - shadowImage->width, - shadowImage->height); - *wp = shadowImage->width; - *hp = shadowImage->height; - XFreeGC (dpy, gc); - XDestroyImage (shadowImage); - XFreePixmap (dpy, shadowPixmap); - return shadowPicture; + shadowPicture = XRenderCreatePicture(dpy, shadowPixmap, + XRenderFindStandardFormat(dpy, PictStandardA8), + 0, 0); + if (!shadowPicture) { + XDestroyImage(shadowImage); + XFreePixmap(dpy, shadowPixmap); + return None; + } + + gc = XCreateGC(dpy, shadowPixmap, 0, 0); + if (!gc) { + XDestroyImage(shadowImage); + XFreePixmap(dpy, shadowPixmap); + XRenderFreePicture(dpy, shadowPicture); + return None; + } + + XPutImage(dpy, shadowPixmap, gc, shadowImage, 0, 0, 0, 0, + shadowImage->width, + shadowImage->height); + *wp = shadowImage->width; + *hp = shadowImage->height; + XFreeGC(dpy, gc); + XDestroyImage(shadowImage); + XFreePixmap(dpy, shadowPixmap); + return shadowPicture; } Picture -solid_picture (Display *dpy, Bool argb, double a, double r, double g, double b) -{ - Pixmap pixmap; - Picture picture; - XRenderPictureAttributes pa; - XRenderColor c; +solid_picture(Display *dpy, Bool argb, double a, double r, double g, double b) { + Pixmap pixmap; + Picture picture; + XRenderPictureAttributes pa; + XRenderColor c; - pixmap = XCreatePixmap (dpy, root, 1, 1, argb ? 32 : 8); - if (!pixmap) - return None; + pixmap = XCreatePixmap(dpy, root, 1, 1, argb ? 32 : 8); + if (!pixmap) + return None; - pa.repeat = True; - picture = XRenderCreatePicture (dpy, pixmap, - XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8), - CPRepeat, - &pa); - if (!picture) - { - XFreePixmap (dpy, pixmap); - return None; - } + pa.repeat = True; + picture = XRenderCreatePicture(dpy, pixmap, + XRenderFindStandardFormat(dpy, argb ? PictStandardARGB32 : PictStandardA8), + CPRepeat, + &pa); + if (!picture) { + XFreePixmap(dpy, pixmap); + return None; + } - c.alpha = a * 0xffff; - c.red = r * 0xffff; - c.green = g * 0xffff; - c.blue = b * 0xffff; - XRenderFillRectangle (dpy, PictOpSrc, picture, &c, 0, 0, 1, 1); - XFreePixmap (dpy, pixmap); - return picture; + c.alpha = a * 0xffff; + c.red = r * 0xffff; + c.green = g * 0xffff; + c.blue = b * 0xffff; + XRenderFillRectangle(dpy, PictOpSrc, picture, &c, 0, 0, 1, 1); + XFreePixmap(dpy, pixmap); + return picture; } void -discard_ignore (Display *dpy, unsigned long sequence) -{ - while (ignore_head) - { - if ((long) (sequence - ignore_head->sequence) > 0) - { - ignore *next = ignore_head->next; - free (ignore_head); - ignore_head = next; - if (!ignore_head) - ignore_tail = &ignore_head; - } - else - break; - } +discard_ignore(Display *dpy, unsigned long sequence) { + while (ignore_head) { + if ((long) (sequence - ignore_head->sequence) > 0) { + ignore *next = ignore_head->next; + free(ignore_head); + ignore_head = next; + if (!ignore_head) + ignore_tail = &ignore_head; + } else + break; + } } void -set_ignore (Display *dpy, unsigned long sequence) -{ - ignore *i = malloc (sizeof (ignore)); - if (!i) - return; - i->sequence = sequence; - i->next = 0; - *ignore_tail = i; - ignore_tail = &i->next; +set_ignore(Display *dpy, unsigned long sequence) { + ignore *i = malloc(sizeof(ignore)); + if (!i) + return; + i->sequence = sequence; + i->next = 0; + *ignore_tail = i; + ignore_tail = &i->next; } int -should_ignore (Display *dpy, unsigned long sequence) -{ - discard_ignore (dpy, sequence); - return ignore_head && ignore_head->sequence == sequence; +should_ignore(Display *dpy, unsigned long sequence) { + discard_ignore(dpy, sequence); + return ignore_head && ignore_head->sequence == sequence; } static win * -find_win (Display *dpy, Window id) -{ - win *w; +find_win(Display *dpy, Window id) { + win *w; - for (w = list; w; w = w->next) - if (w->id == id && !w->destroyed) - return w; - return 0; + for (w = list; w; w = w->next) + if (w->id == id && !w->destroyed) + return w; + return 0; } static const char *backgroundProps[] = { - "_XROOTPMAP_ID", - "_XSETROOT_ID", - 0, + "_XROOTPMAP_ID", + "_XSETROOT_ID", + 0, }; - + static Picture -root_tile (Display *dpy) -{ - Picture picture; - Atom actual_type; - Pixmap pixmap; - int actual_format; - unsigned long nitems; - unsigned long bytes_after; - unsigned char *prop; - Bool fill; - XRenderPictureAttributes pa; - int p; +root_tile(Display *dpy) { + Picture picture; + Atom actual_type; + Pixmap pixmap; + int actual_format; + unsigned long nitems; + unsigned long bytes_after; + unsigned char *prop; + Bool fill; + XRenderPictureAttributes pa; + int p; - pixmap = None; - for (p = 0; backgroundProps[p]; p++) - { - if (XGetWindowProperty (dpy, root, XInternAtom (dpy, backgroundProps[p], False), - 0, 4, False, AnyPropertyType, - &actual_type, &actual_format, &nitems, &bytes_after, &prop) == Success && - actual_type == XInternAtom (dpy, "PIXMAP", False) && actual_format == 32 && nitems == 1) - { - memcpy (&pixmap, prop, 4); - XFree (prop); - fill = False; - break; - } + pixmap = None; + for (p = 0; backgroundProps[p]; p++) { + if (XGetWindowProperty(dpy, root, XInternAtom(dpy, backgroundProps[p], False), + 0, 4, False, AnyPropertyType, + &actual_type, &actual_format, &nitems, &bytes_after, &prop) == Success && + actual_type == XInternAtom(dpy, "PIXMAP", False) && actual_format == 32 && nitems == 1) { + memcpy(&pixmap, prop, 4); + XFree(prop); + fill = False; + break; } - if (!pixmap) - { - pixmap = XCreatePixmap (dpy, root, 1, 1, DefaultDepth (dpy, scr)); - fill = True; - } - pa.repeat = True; - picture = XRenderCreatePicture (dpy, pixmap, - XRenderFindVisualFormat (dpy, - DefaultVisual (dpy, scr)), - CPRepeat, &pa); - if (fill) - { - XRenderColor c; - - c.red = c.green = c.blue = 0x8080; - c.alpha = 0xffff; - XRenderFillRectangle (dpy, PictOpSrc, picture, &c, - 0, 0, 1, 1); - } - return picture; + } + if (!pixmap) { + pixmap = XCreatePixmap(dpy, root, 1, 1, DefaultDepth(dpy, scr)); + fill = True; + } + pa.repeat = True; + picture = XRenderCreatePicture(dpy, pixmap, + XRenderFindVisualFormat(dpy, + DefaultVisual(dpy, scr)), + CPRepeat, &pa); + if (fill) { + XRenderColor c; + + c.red = c.green = c.blue = 0x8080; + c.alpha = 0xffff; + XRenderFillRectangle(dpy, PictOpSrc, picture, &c, + 0, 0, 1, 1); + } + return picture; } static void -paint_root (Display *dpy) -{ - if (!rootTile) - rootTile = root_tile (dpy); - - XRenderComposite (dpy, PictOpSrc, - rootTile, None, rootBuffer, - 0, 0, 0, 0, 0, 0, root_width, root_height); +paint_root(Display *dpy) { + if (!rootTile) + rootTile = root_tile(dpy); + + XRenderComposite(dpy, PictOpSrc, + rootTile, None, rootBuffer, + 0, 0, 0, 0, 0, 0, root_width, root_height); } static XserverRegion -win_extents (Display *dpy, win *w) -{ - XRectangle r; - - r.x = w->a.x; - r.y = w->a.y; - r.width = w->a.width + w->a.border_width * 2; - r.height = w->a.height + w->a.border_width * 2; - if (winTypeShadow[w->windowType]) - { - if (compMode == CompServerShadows || w->mode != WINDOW_ARGB) - { - XRectangle sr; +win_extents(Display *dpy, win *w) { + XRectangle r; - if (compMode == CompServerShadows) - { - w->shadow_dx = shadowOffsetX; - w->shadow_dy = shadowOffsetY; - w->shadow_width = w->a.width; - w->shadow_height = w->a.height; - } - else - { - w->shadow_dx = shadowOffsetX; - w->shadow_dy = shadowOffsetY; - if (!w->shadow) - { - double opacity = shadowOpacity; - if (w->mode == WINDOW_TRANS) - opacity = opacity * ((double)w->opacity)/((double)OPAQUE); - w->shadow = shadow_picture (dpy, opacity, w->alphaPict, - w->a.width + w->a.border_width * 2, - w->a.height + w->a.border_width * 2, - &w->shadow_width, &w->shadow_height); - } - } - sr.x = w->a.x + w->shadow_dx; - sr.y = w->a.y + w->shadow_dy; - sr.width = w->shadow_width; - sr.height = w->shadow_height; - if (sr.x < r.x) - { - r.width = (r.x + r.width) - sr.x; - r.x = sr.x; - } - if (sr.y < r.y) - { - r.height = (r.y + r.height) - sr.y; - r.y = sr.y; - } - if (sr.x + sr.width > r.x + r.width) - r.width = sr.x + sr.width - r.x; - if (sr.y + sr.height > r.y + r.height) - r.height = sr.y + sr.height - r.y; - } - } - return XFixesCreateRegion (dpy, &r, 1); -} + r.x = w->a.x; + r.y = w->a.y; + r.width = w->a.width + w->a.border_width * 2; + r.height = w->a.height + w->a.border_width * 2; + if (winTypeShadow[w->windowType]) { + if (compMode == CompServerShadows || w->mode != WINDOW_ARGB) { + XRectangle sr; -static XserverRegion -border_size (Display *dpy, win *w) -{ - XserverRegion border; - /* - * if window doesn't exist anymore, this will generate an error - * as well as not generate a region. Perhaps a better XFixes - * architecture would be to have a request that copies instead - * of creates, that way you'd just end up with an empty region - * instead of an invalid XID. - */ - set_ignore (dpy, NextRequest (dpy)); - border = XFixesCreateRegionFromWindow (dpy, w->id, WindowRegionBounding); - /* translate this */ - set_ignore (dpy, NextRequest (dpy)); - XFixesTranslateRegion (dpy, border, - w->a.x + w->a.border_width, - w->a.y + w->a.border_width); - return border; -} - -static void -paint_all (Display *dpy, XserverRegion region) -{ - win *w; - win *t = 0; - - if (!region) - { - XRectangle r; - r.x = 0; - r.y = 0; - r.width = root_width; - r.height = root_height; - region = XFixesCreateRegion (dpy, &r, 1); - } -#if MONITOR_REPAINT - rootBuffer = rootPicture; -#else - if (!rootBuffer) - { - Pixmap rootPixmap = XCreatePixmap (dpy, root, root_width, root_height, - DefaultDepth (dpy, scr)); - rootBuffer = XRenderCreatePicture (dpy, rootPixmap, - XRenderFindVisualFormat (dpy, - DefaultVisual (dpy, scr)), - 0, 0); - XFreePixmap (dpy, rootPixmap); - } -#endif - XFixesSetPictureClipRegion (dpy, rootPicture, 0, 0, region); -#if MONITOR_REPAINT - XRenderComposite (dpy, PictOpSrc, blackPicture, None, rootPicture, - 0, 0, 0, 0, 0, 0, root_width, root_height); -#endif -#if DEBUG_REPAINT - printf ("paint:"); -#endif - for (w = list; w; w = w->next) - { -#if CAN_DO_USABLE - if (!w->usable) - continue; -#endif - /* never painted, ignore it */ - if (!w->damaged) - continue; - /* if invisible, ignore it */ - if (w->a.x + w->a.width < 1 || w->a.y + w->a.height < 1 - || w->a.x >= root_width || w->a.y >= root_height) - continue; - if (!w->picture) - { - XRenderPictureAttributes pa; - XRenderPictFormat *format; - Drawable draw = w->id; - -#if HAS_NAME_WINDOW_PIXMAP - if (hasNamePixmap && !w->pixmap) { - set_ignore (dpy, NextRequest (dpy)); - w->pixmap = XCompositeNameWindowPixmap (dpy, w->id); - } - if (w->pixmap) - draw = w->pixmap; -#endif - format = XRenderFindVisualFormat (dpy, w->a.visual); - pa.subwindow_mode = IncludeInferiors; - w->picture = XRenderCreatePicture (dpy, draw, - format, - CPSubwindowMode, - &pa); - } -#if DEBUG_REPAINT - printf (" 0x%x", w->id); -#endif - if (clipChanged) - { - if (w->borderSize) - { - set_ignore (dpy, NextRequest (dpy)); - XFixesDestroyRegion (dpy, w->borderSize); - w->borderSize = None; - } - if (w->extents) - { - XFixesDestroyRegion (dpy, w->extents); - w->extents = None; - } - if (w->borderClip) - { - XFixesDestroyRegion (dpy, w->borderClip); - w->borderClip = None; - } - } - if (!w->borderSize) - w->borderSize = border_size (dpy, w); - if (!w->extents) - w->extents = win_extents (dpy, w); - if (w->mode == WINDOW_SOLID) - { - int x, y, wid, hei; -#if HAS_NAME_WINDOW_PIXMAP - x = w->a.x; - y = w->a.y; - wid = w->a.width + w->a.border_width * 2; - hei = w->a.height + w->a.border_width * 2; -#else - x = w->a.x + w->a.border_width; - y = w->a.y + w->a.border_width; - wid = w->a.width; - hei = w->a.height; -#endif - XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, region); - set_ignore (dpy, NextRequest (dpy)); - XFixesSubtractRegion (dpy, region, region, w->borderSize); - set_ignore (dpy, NextRequest (dpy)); - XRenderComposite (dpy, PictOpSrc, w->picture, None, rootBuffer, - 0, 0, 0, 0, - x, y, wid, hei); - } - if (!w->borderClip) - { - w->borderClip = XFixesCreateRegion (dpy, 0, 0); - XFixesCopyRegion (dpy, w->borderClip, region); - } - w->prev_trans = t; - t = w; - } -#if DEBUG_REPAINT - printf ("\n"); - fflush (stdout); -#endif - XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, region); - paint_root (dpy); - for (w = t; w; w = w->prev_trans) - { - XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, w->borderClip); - if (winTypeShadow[w->windowType]) { - switch (compMode) { - case CompSimple: - break; - case CompServerShadows: - set_ignore (dpy, NextRequest (dpy)); - if (w->opacity != OPAQUE && !w->shadowPict) - w->shadowPict = solid_picture (dpy, True, - (double) w->opacity / OPAQUE * 0.3, - 0, 0, 0); - XRenderComposite (dpy, PictOpOver, - w->shadowPict ? w->shadowPict : transBlackPicture, - w->picture, rootBuffer, - 0, 0, 0, 0, - w->a.x + w->shadow_dx, - w->a.y + w->shadow_dy, - w->shadow_width, w->shadow_height); - break; - case CompClientShadows: - XRenderComposite (dpy, PictOpOver, blackPicture, w->shadow, rootBuffer, - 0, 0, 0, 0, - w->a.x + w->shadow_dx, - w->a.y + w->shadow_dy, - w->shadow_width, w->shadow_height); - break; - } + if (compMode == CompServerShadows) { + w->shadow_dx = shadowOffsetX; + w->shadow_dy = shadowOffsetY; + w->shadow_width = w->a.width; + w->shadow_height = w->a.height; + } else { + w->shadow_dx = shadowOffsetX; + w->shadow_dy = shadowOffsetY; + if (!w->shadow) { + double opacity = shadowOpacity; + if (w->mode == WINDOW_TRANS) + opacity = opacity * ((double)w->opacity)/((double)OPAQUE); + w->shadow = shadow_picture(dpy, opacity, w->alphaPict, + w->a.width + w->a.border_width * 2, + w->a.height + w->a.border_width * 2, + &w->shadow_width, &w->shadow_height); } - if (w->opacity != OPAQUE && !w->alphaPict) - w->alphaPict = solid_picture (dpy, False, - (double) w->opacity / OPAQUE, 0, 0, 0); - if (w->mode == WINDOW_TRANS) - { - int x, y, wid, hei; -#if HAS_NAME_WINDOW_PIXMAP - x = w->a.x; - y = w->a.y; - wid = w->a.width + w->a.border_width * 2; - hei = w->a.height + w->a.border_width * 2; -#else - x = w->a.x + w->a.border_width; - y = w->a.y + w->a.border_width; - wid = w->a.width; - hei = w->a.height; -#endif - set_ignore (dpy, NextRequest (dpy)); - XRenderComposite (dpy, PictOpOver, w->picture, w->alphaPict, rootBuffer, - 0, 0, 0, 0, - x, y, wid, hei); - } - else if (w->mode == WINDOW_ARGB) - { - int x, y, wid, hei; -#if HAS_NAME_WINDOW_PIXMAP - x = w->a.x; - y = w->a.y; - wid = w->a.width + w->a.border_width * 2; - hei = w->a.height + w->a.border_width * 2; -#else - x = w->a.x + w->a.border_width; - y = w->a.y + w->a.border_width; - wid = w->a.width; - hei = w->a.height; -#endif - set_ignore (dpy, NextRequest (dpy)); - XRenderComposite (dpy, PictOpOver, w->picture, w->alphaPict, rootBuffer, - 0, 0, 0, 0, - x, y, wid, hei); - } - XFixesDestroyRegion (dpy, w->borderClip); - w->borderClip = None; - } - XFixesDestroyRegion (dpy, region); - if (rootBuffer != rootPicture) - { - XFixesSetPictureClipRegion (dpy, rootBuffer, 0, 0, None); - XRenderComposite (dpy, PictOpSrc, rootBuffer, None, rootPicture, - 0, 0, 0, 0, 0, 0, root_width, root_height); + } + sr.x = w->a.x + w->shadow_dx; + sr.y = w->a.y + w->shadow_dy; + sr.width = w->shadow_width; + sr.height = w->shadow_height; + if (sr.x < r.x) { + r.width = (r.x + r.width) - sr.x; + r.x = sr.x; + } + if (sr.y < r.y) { + r.height = (r.y + r.height) - sr.y; + r.y = sr.y; + } + if (sr.x + sr.width > r.x + r.width) + r.width = sr.x + sr.width - r.x; + if (sr.y + sr.height > r.y + r.height) + r.height = sr.y + sr.height - r.y; } + } + return XFixesCreateRegion(dpy, &r, 1); +} + +static XserverRegion +border_size(Display *dpy, win *w) { + XserverRegion border; + /* + * if window doesn't exist anymore, this will generate an error + * as well as not generate a region. Perhaps a better XFixes + * architecture would be to have a request that copies instead + * of creates, that way you'd just end up with an empty region + * instead of an invalid XID. + */ + set_ignore(dpy, NextRequest(dpy)); + border = XFixesCreateRegionFromWindow(dpy, w->id, WindowRegionBounding); + /* translate this */ + set_ignore(dpy, NextRequest(dpy)); + XFixesTranslateRegion(dpy, border, + w->a.x + w->a.border_width, + w->a.y + w->a.border_width); + return border; } static void -add_damage (Display *dpy, XserverRegion damage) -{ - if (allDamage) - { - XFixesUnionRegion (dpy, allDamage, allDamage, damage); - XFixesDestroyRegion (dpy, damage); - } - else - allDamage = damage; -} - -static void -repair_win (Display *dpy, win *w) -{ - XserverRegion parts; +paint_all(Display *dpy, XserverRegion region) { + win *w; + win *t = 0; + if (!region) { + XRectangle r; + r.x = 0; + r.y = 0; + r.width = root_width; + r.height = root_height; + region = XFixesCreateRegion(dpy, &r, 1); + } +#if MONITOR_REPAINT + rootBuffer = rootPicture; +#else + if (!rootBuffer) { + Pixmap rootPixmap = XCreatePixmap(dpy, root, root_width, root_height, + DefaultDepth(dpy, scr)); + rootBuffer = XRenderCreatePicture(dpy, rootPixmap, + XRenderFindVisualFormat(dpy, + DefaultVisual(dpy, scr)), + 0, 0); + XFreePixmap(dpy, rootPixmap); + } +#endif + XFixesSetPictureClipRegion(dpy, rootPicture, 0, 0, region); +#if MONITOR_REPAINT + XRenderComposite(dpy, PictOpSrc, blackPicture, None, rootPicture, + 0, 0, 0, 0, 0, 0, root_width, root_height); +#endif +#if DEBUG_REPAINT + printf("paint:"); +#endif + for (w = list; w; w = w->next) { +#if CAN_DO_USABLE + if (!w->usable) + continue; +#endif + /* never painted, ignore it */ if (!w->damaged) - { - parts = win_extents (dpy, w); - set_ignore (dpy, NextRequest (dpy)); - XDamageSubtract (dpy, w->damage, None, None); + continue; + /* if invisible, ignore it */ + if (w->a.x + w->a.width < 1 || w->a.y + w->a.height < 1 + || w->a.x >= root_width || w->a.y >= root_height) + continue; + if (!w->picture) { + XRenderPictureAttributes pa; + XRenderPictFormat *format; + Drawable draw = w->id; + +#if HAS_NAME_WINDOW_PIXMAP + if (hasNamePixmap && !w->pixmap) { + set_ignore(dpy, NextRequest(dpy)); + w->pixmap = XCompositeNameWindowPixmap(dpy, w->id); + } + if (w->pixmap) + draw = w->pixmap; +#endif + format = XRenderFindVisualFormat(dpy, w->a.visual); + pa.subwindow_mode = IncludeInferiors; + w->picture = XRenderCreatePicture(dpy, draw, + format, + CPSubwindowMode, + &pa); } - else - { - XserverRegion o; - parts = XFixesCreateRegion (dpy, 0, 0); - set_ignore (dpy, NextRequest (dpy)); - XDamageSubtract (dpy, w->damage, None, parts); - XFixesTranslateRegion (dpy, parts, - w->a.x + w->a.border_width, - w->a.y + w->a.border_width); - if (compMode == CompServerShadows) - { - o = XFixesCreateRegion (dpy, 0, 0); - XFixesCopyRegion (dpy, o, parts); - XFixesTranslateRegion (dpy, o, w->shadow_dx, w->shadow_dy); - XFixesUnionRegion (dpy, parts, parts, o); - XFixesDestroyRegion (dpy, o); - } +#if DEBUG_REPAINT + printf(" 0x%x", w->id); +#endif + if (clipChanged) { + if (w->borderSize) { + set_ignore(dpy, NextRequest(dpy)); + XFixesDestroyRegion(dpy, w->borderSize); + w->borderSize = None; + } + if (w->extents) { + XFixesDestroyRegion(dpy, w->extents); + w->extents = None; + } + if (w->borderClip) { + XFixesDestroyRegion(dpy, w->borderClip); + w->borderClip = None; + } } - add_damage (dpy, parts); - w->damaged = 1; + if (!w->borderSize) + w->borderSize = border_size (dpy, w); + if (!w->extents) + w->extents = win_extents(dpy, w); + if (w->mode == WINDOW_SOLID) { + int x, y, wid, hei; +#if HAS_NAME_WINDOW_PIXMAP + x = w->a.x; + y = w->a.y; + wid = w->a.width + w->a.border_width * 2; + hei = w->a.height + w->a.border_width * 2; +#else + x = w->a.x + w->a.border_width; + y = w->a.y + w->a.border_width; + wid = w->a.width; + hei = w->a.height; +#endif + XFixesSetPictureClipRegion(dpy, rootBuffer, 0, 0, region); + set_ignore(dpy, NextRequest(dpy)); + XFixesSubtractRegion(dpy, region, region, w->borderSize); + set_ignore(dpy, NextRequest(dpy)); + XRenderComposite(dpy, PictOpSrc, w->picture, None, rootBuffer, + 0, 0, 0, 0, + x, y, wid, hei); + } + if (!w->borderClip) { + w->borderClip = XFixesCreateRegion(dpy, 0, 0); + XFixesCopyRegion(dpy, w->borderClip, region); + } + w->prev_trans = t; + t = w; + } +#if DEBUG_REPAINT + printf("\n"); + fflush(stdout); +#endif + XFixesSetPictureClipRegion(dpy, rootBuffer, 0, 0, region); + paint_root(dpy); + for (w = t; w; w = w->prev_trans) { + XFixesSetPictureClipRegion(dpy, rootBuffer, 0, 0, w->borderClip); + if (winTypeShadow[w->windowType]) { + switch (compMode) { + case CompSimple: + break; + case CompServerShadows: + set_ignore(dpy, NextRequest(dpy)); + if (w->opacity != OPAQUE && !w->shadowPict) + w->shadowPict = solid_picture(dpy, True, + (double) w->opacity / OPAQUE * 0.3, + 0, 0, 0); + XRenderComposite(dpy, PictOpOver, + w->shadowPict ? w->shadowPict : transBlackPicture, + w->picture, rootBuffer, + 0, 0, 0, 0, + w->a.x + w->shadow_dx, + w->a.y + w->shadow_dy, + w->shadow_width, w->shadow_height); + break; + case CompClientShadows: + XRenderComposite(dpy, PictOpOver, blackPicture, w->shadow, rootBuffer, + 0, 0, 0, 0, + w->a.x + w->shadow_dx, + w->a.y + w->shadow_dy, + w->shadow_width, w->shadow_height); + break; + } + } + if (w->opacity != OPAQUE && !w->alphaPict) + w->alphaPict = solid_picture(dpy, False, + (double) w->opacity / OPAQUE, 0, 0, 0); + if (w->mode == WINDOW_TRANS) { + int x, y, wid, hei; +#if HAS_NAME_WINDOW_PIXMAP + x = w->a.x; + y = w->a.y; + wid = w->a.width + w->a.border_width * 2; + hei = w->a.height + w->a.border_width * 2; +#else + x = w->a.x + w->a.border_width; + y = w->a.y + w->a.border_width; + wid = w->a.width; + hei = w->a.height; +#endif + set_ignore(dpy, NextRequest(dpy)); + XRenderComposite(dpy, PictOpOver, w->picture, w->alphaPict, rootBuffer, + 0, 0, 0, 0, + x, y, wid, hei); + } else if (w->mode == WINDOW_ARGB) { + int x, y, wid, hei; +#if HAS_NAME_WINDOW_PIXMAP + x = w->a.x; + y = w->a.y; + wid = w->a.width + w->a.border_width * 2; + hei = w->a.height + w->a.border_width * 2; +#else + x = w->a.x + w->a.border_width; + y = w->a.y + w->a.border_width; + wid = w->a.width; + hei = w->a.height; +#endif + set_ignore(dpy, NextRequest(dpy)); + XRenderComposite(dpy, PictOpOver, w->picture, w->alphaPict, rootBuffer, + 0, 0, 0, 0, + x, y, wid, hei); + } + XFixesDestroyRegion(dpy, w->borderClip); + w->borderClip = None; + } + XFixesDestroyRegion(dpy, region); + if (rootBuffer != rootPicture) { + XFixesSetPictureClipRegion(dpy, rootBuffer, 0, 0, None); + XRenderComposite(dpy, PictOpSrc, rootBuffer, None, rootPicture, + 0, 0, 0, 0, 0, 0, root_width, root_height); + } +} + +static void +add_damage(Display *dpy, XserverRegion damage) { + if (allDamage) { + XFixesUnionRegion(dpy, allDamage, allDamage, damage); + XFixesDestroyRegion(dpy, damage); + } else + allDamage = damage; +} + +static void +repair_win(Display *dpy, win *w) { + XserverRegion parts; + + if (!w->damaged) { + parts = win_extents(dpy, w); + set_ignore(dpy, NextRequest(dpy)); + XDamageSubtract(dpy, w->damage, None, None); + } else { + XserverRegion o; + parts = XFixesCreateRegion(dpy, 0, 0); + set_ignore(dpy, NextRequest(dpy)); + XDamageSubtract(dpy, w->damage, None, parts); + XFixesTranslateRegion(dpy, parts, + w->a.x + w->a.border_width, + w->a.y + w->a.border_width); + if (compMode == CompServerShadows) { + o = XFixesCreateRegion(dpy, 0, 0); + XFixesCopyRegion(dpy, o, parts); + XFixesTranslateRegion(dpy, o, w->shadow_dx, w->shadow_dy); + XFixesUnionRegion(dpy, parts, parts, o); + XFixesDestroyRegion(dpy, o); + } + } + add_damage(dpy, parts); + w->damaged = 1; } static const char* -wintype_name(wintype type) -{ - const char *t; - switch (type) { - case WINTYPE_DESKTOP: t = "desktop"; break; - case WINTYPE_DOCK: t = "dock"; break; - case WINTYPE_TOOLBAR: t = "toolbar"; break; - case WINTYPE_MENU: t = "menu"; break; - case WINTYPE_UTILITY: t = "utility"; break; - case WINTYPE_SPLASH: t = "slash"; break; - case WINTYPE_DIALOG: t = "dialog"; break; - case WINTYPE_NORMAL: t = "normal"; break; - case WINTYPE_DROPDOWN_MENU: t = "dropdown"; break; - case WINTYPE_POPUP_MENU: t = "popup"; break; - case WINTYPE_TOOLTIP: t = "tooltip"; break; - case WINTYPE_NOTIFY: t = "notification"; break; - case WINTYPE_COMBO: t = "combo"; break; - case WINTYPE_DND: t = "dnd"; break; - default: t = "unknown"; break; - } - return t; +wintype_name(wintype type) { + const char *t; + switch (type) { + case WINTYPE_DESKTOP: t = "desktop"; break; + case WINTYPE_DOCK: t = "dock"; break; + case WINTYPE_TOOLBAR: t = "toolbar"; break; + case WINTYPE_MENU: t = "menu"; break; + case WINTYPE_UTILITY: t = "utility"; break; + case WINTYPE_SPLASH: t = "slash"; break; + case WINTYPE_DIALOG: t = "dialog"; break; + case WINTYPE_NORMAL: t = "normal"; break; + case WINTYPE_DROPDOWN_MENU: t = "dropdown"; break; + case WINTYPE_POPUP_MENU: t = "popup"; break; + case WINTYPE_TOOLTIP: t = "tooltip"; break; + case WINTYPE_NOTIFY: t = "notification"; break; + case WINTYPE_COMBO: t = "combo"; break; + case WINTYPE_DND: t = "dnd"; break; + default: t = "unknown"; break; + } + return t; } static wintype -get_wintype_prop(Display * dpy, Window w) -{ - Atom actual; - wintype ret; - int format; - unsigned long n, left, off; - unsigned char *data; +get_wintype_prop(Display * dpy, Window w) { + Atom actual; + wintype ret; + int format; + unsigned long n, left, off; + unsigned char *data; - ret = (wintype)-1; - off = 0; + ret = (wintype)-1; + off = 0; - do { - set_ignore (dpy, NextRequest (dpy)); - int result = XGetWindowProperty (dpy, w, winTypeAtom, off, 1L, False, - XA_ATOM, &actual, &format, - &n, &left, &data); + do { + set_ignore(dpy, NextRequest(dpy)); + int result = XGetWindowProperty(dpy, w, winTypeAtom, off, 1L, False, + XA_ATOM, &actual, &format, + &n, &left, &data); - if (result != Success) - break; - if (data != None) - { - int i; + if (result != Success) + break; + if (data != None) { + int i; - for (i = 0; i < NUM_WINTYPES; ++i) { - Atom a; - memcpy (&a, data, sizeof (Atom)); - if (a == winType[i]) { - /* known type */ - ret = i; - break; - } - } - - XFree ( (void *) data); + for (i = 0; i < NUM_WINTYPES; ++i) { + Atom a; + memcpy(&a, data, sizeof(Atom)); + if (a == winType[i]) { + /* known type */ + ret = i; + break; } + } - ++off; - } while (left >= 4 && ret == (wintype)-1); + XFree( (void *) data); + } - return ret; + ++off; + } while (left >= 4 && ret == (wintype)-1); + + return ret; } static wintype -determine_wintype (Display *dpy, Window w, Window top) -{ - Window root_return, parent_return; - Window *children = NULL; - unsigned int nchildren, i; - wintype type; +determine_wintype(Display *dpy, Window w, Window top) { + Window root_return, parent_return; + Window *children = NULL; + unsigned int nchildren, i; + wintype type; - type = get_wintype_prop (dpy, w); - if (type != (wintype)-1) - return type; - - set_ignore (dpy, NextRequest (dpy)); - if (!XQueryTree (dpy, w, &root_return, &parent_return, &children, - &nchildren)) - { - /* XQueryTree failed. */ - if (children) - XFree ((void *)children); - return (wintype)-1; - } - - for (i = 0;i < nchildren;i++) - { - type = determine_wintype (dpy, children[i], top); - if (type != (wintype)-1) - return type; - } + type = get_wintype_prop(dpy, w); + if (type != (wintype)-1) + return type; + set_ignore(dpy, NextRequest(dpy)); + if (!XQueryTree(dpy, w, &root_return, &parent_return, &children, + &nchildren)) { + /* XQueryTree failed. */ if (children) - XFree ((void *)children); + XFree((void *)children); + return (wintype)-1; + } - if (w != top) - return (wintype)-1; - else - return WINTYPE_NORMAL; + for (i = 0;i < nchildren;i++) { + type = determine_wintype(dpy, children[i], top); + if (type != (wintype)-1) + return type; + } + + if (children) + XFree((void *)children); + + if (w != top) + return(wintype)-1; + else + return WINTYPE_NORMAL; } static unsigned int -get_opacity_prop (Display *dpy, win *w, unsigned int def); +get_opacity_prop(Display *dpy, win *w, unsigned int def); static void -configure_win (Display *dpy, XConfigureEvent *ce); +configure_win(Display *dpy, XConfigureEvent *ce); static void -map_win (Display *dpy, Window id, unsigned long sequence, Bool fade) -{ - win *w = find_win (dpy, id); +map_win(Display *dpy, Window id, unsigned long sequence, Bool fade) { + win *w = find_win(dpy, id); - if (!w) - return; + if (!w) + return; - w->a.map_state = IsViewable; + w->a.map_state = IsViewable; - w->windowType = determine_wintype (dpy, w->id, w->id); + w->windowType = determine_wintype(dpy, w->id, w->id); #if 0 - printf("window 0x%x type %s\n", w->id, wintype_name(w->windowType)); + printf("window 0x%x type %s\n", w->id, wintype_name(w->windowType)); #endif - /* select before reading the property so that no property changes are lost */ - XSelectInput (dpy, id, PropertyChangeMask); - w->opacity = get_opacity_prop (dpy, w, OPAQUE); + /* select before reading the property so that no property changes are lost */ + XSelectInput(dpy, id, PropertyChangeMask); + w->opacity = get_opacity_prop(dpy, w, OPAQUE); - determine_mode (dpy, w); + determine_mode(dpy, w); #if CAN_DO_USABLE - w->damage_bounds.x = w->damage_bounds.y = 0; - w->damage_bounds.width = w->damage_bounds.height = 0; + w->damage_bounds.x = w->damage_bounds.y = 0; + w->damage_bounds.width = w->damage_bounds.height = 0; #endif - w->damaged = 0; + w->damaged = 0; - if (fade && winTypeFade[w->windowType]) - set_fade (dpy, w, 0, get_opacity_percent (dpy, w), fade_in_step, 0, True, True); + if (fade && winTypeFade[w->windowType]) + set_fade(dpy, w, 0, get_opacity_percent(dpy, w), + fade_in_step, 0, True, True); - /* if any configure events happened while the window was unmapped, then - configure the window to its correct place */ - if (w->need_configure) - configure_win (dpy, &w->queue_configure); + /* if any configure events happened while the window was unmapped, then + configure the window to its correct place */ + if (w->need_configure) + configure_win(dpy, &w->queue_configure); } static void -finish_unmap_win (Display *dpy, win *w) -{ - w->damaged = 0; +finish_unmap_win(Display *dpy, win *w) { + w->damaged = 0; #if CAN_DO_USABLE - w->usable = False; + w->usable = False; #endif - if (w->extents != None) - { - add_damage (dpy, w->extents); /* destroys region */ - w->extents = None; - } - + if (w->extents != None) { + add_damage(dpy, w->extents); /* destroys region */ + w->extents = None; + } + #if HAS_NAME_WINDOW_PIXMAP - if (w->pixmap) - { - XFreePixmap (dpy, w->pixmap); - w->pixmap = None; - } + if (w->pixmap) { + XFreePixmap(dpy, w->pixmap); + w->pixmap = None; + } #endif - if (w->picture) - { - set_ignore (dpy, NextRequest (dpy)); - XRenderFreePicture (dpy, w->picture); - w->picture = None; - } + if (w->picture) { + set_ignore(dpy, NextRequest(dpy)); + XRenderFreePicture(dpy, w->picture); + w->picture = None; + } - if (w->borderSize) - { - set_ignore (dpy, NextRequest (dpy)); - XFixesDestroyRegion (dpy, w->borderSize); - w->borderSize = None; - } - if (w->shadow) - { - XRenderFreePicture (dpy, w->shadow); - w->shadow = None; - } - if (w->borderClip) - { - XFixesDestroyRegion (dpy, w->borderClip); - w->borderClip = None; - } + if (w->borderSize) { + set_ignore(dpy, NextRequest(dpy)); + XFixesDestroyRegion(dpy, w->borderSize); + w->borderSize = None; + } + if (w->shadow) { + XRenderFreePicture(dpy, w->shadow); + w->shadow = None; + } + if (w->borderClip) { + XFixesDestroyRegion(dpy, w->borderClip); + w->borderClip = None; + } - clipChanged = True; + clipChanged = True; } #if HAS_NAME_WINDOW_PIXMAP static void -unmap_callback (Display *dpy, win *w) -{ - finish_unmap_win (dpy, w); +unmap_callback(Display *dpy, win *w) { + finish_unmap_win(dpy, w); } #endif static void -unmap_win (Display *dpy, Window id, Bool fade) -{ - win *w = find_win (dpy, id); - if (!w) - return; - w->a.map_state = IsUnmapped; +unmap_win(Display *dpy, Window id, Bool fade) { + win *w = find_win(dpy, id); + if (!w) + return; + w->a.map_state = IsUnmapped; - /* don't care about properties anymore */ - set_ignore (dpy, NextRequest (dpy)); - XSelectInput(dpy, w->id, 0); + /* don't care about properties anymore */ + set_ignore(dpy, NextRequest(dpy)); + XSelectInput(dpy, w->id, 0); #if HAS_NAME_WINDOW_PIXMAP - if (w->pixmap && fade && winTypeFade[w->windowType]) - set_fade (dpy, w, w->opacity*1.0/OPAQUE, 0.0, fade_out_step, unmap_callback, False, True); - else + if (w->pixmap && fade && winTypeFade[w->windowType]) + set_fade(dpy, w, w->opacity*1.0/OPAQUE, 0.0, + fade_out_step, unmap_callback, False, True); + else #endif - finish_unmap_win (dpy, w); + finish_unmap_win(dpy, w); } /* Get the opacity prop from window @@ -1422,24 +1318,22 @@ unmap_win (Display *dpy, Window id, Bool fade) otherwise the value */ static unsigned int -get_opacity_prop(Display *dpy, win *w, unsigned int def) -{ - Atom actual; - int format; - unsigned long n, left; +get_opacity_prop(Display *dpy, win *w, unsigned int def) { + Atom actual; + int format; + unsigned long n, left; - unsigned char *data; - int result = XGetWindowProperty(dpy, w->id, opacityAtom, 0L, 1L, False, - XA_CARDINAL, &actual, &format, - &n, &left, &data); - if (result == Success && data != NULL) - { - unsigned int i; - memcpy (&i, data, sizeof (unsigned int)); - XFree( (void *) data); - return i; - } - return def; + unsigned char *data; + int result = XGetWindowProperty(dpy, w->id, opacityAtom, 0L, 1L, False, + XA_CARDINAL, &actual, &format, + &n, &left, &data); + if (result == Success && data != NULL) { + unsigned int i; + memcpy(&i, data, sizeof(unsigned int)); + XFree( (void *) data); + return i; + } + return def; } /* Get the opacity property from the window in a percent format @@ -1447,894 +1341,863 @@ get_opacity_prop(Display *dpy, win *w, unsigned int def) otherwise: the value */ static double -get_opacity_percent(Display *dpy, win *w) -{ - double def = winTypeOpacity[w->windowType]; - unsigned int opacity = get_opacity_prop (dpy, w, (unsigned int)(OPAQUE*def)); +get_opacity_percent(Display *dpy, win *w) { + double def = winTypeOpacity[w->windowType]; + unsigned int opacity = get_opacity_prop(dpy, w, (unsigned int)(OPAQUE*def)); - return opacity*1.0/OPAQUE; + return opacity*1.0/OPAQUE; } static void -determine_mode(Display *dpy, win *w) -{ - int mode; - XRenderPictFormat *format; +determine_mode(Display *dpy, win *w) { + int mode; + XRenderPictFormat *format; - /* if trans prop == -1 fall back on previous tests*/ + /* if trans prop == -1 fall back on previous tests*/ - if (w->alphaPict) - { - XRenderFreePicture (dpy, w->alphaPict); - w->alphaPict = None; - } - if (w->shadowPict) - { - XRenderFreePicture (dpy, w->shadowPict); - w->shadowPict = None; - } + if (w->alphaPict) { + XRenderFreePicture(dpy, w->alphaPict); + w->alphaPict = None; + } + if (w->shadowPict) { + XRenderFreePicture(dpy, w->shadowPict); + w->shadowPict = None; + } - if (w->a.class == InputOnly) - { - format = 0; - } - else - { - format = XRenderFindVisualFormat (dpy, w->a.visual); - } + if (w->a.class == InputOnly) { + format = 0; + } else { + format = XRenderFindVisualFormat(dpy, w->a.visual); + } - if (format && format->type == PictTypeDirect && format->direct.alphaMask) - { - mode = WINDOW_ARGB; - } - else if (w->opacity != OPAQUE) - { - mode = WINDOW_TRANS; - } - else - { - mode = WINDOW_SOLID; - } - w->mode = mode; - if (w->extents) - { - XserverRegion damage; - damage = XFixesCreateRegion (dpy, 0, 0); - XFixesCopyRegion (dpy, damage, w->extents); - add_damage (dpy, damage); - } + if (format && format->type == PictTypeDirect && format->direct.alphaMask) { + mode = WINDOW_ARGB; + } else if (w->opacity != OPAQUE) { + mode = WINDOW_TRANS; + } else { + mode = WINDOW_SOLID; + } + w->mode = mode; + if (w->extents) { + XserverRegion damage; + damage = XFixesCreateRegion(dpy, 0, 0); + XFixesCopyRegion(dpy, damage, w->extents); + add_damage(dpy, damage); + } } static void -add_win (Display *dpy, Window id, Window prev) -{ - win *new = malloc (sizeof (win)); - win **p; - - if (!new) - return; - if (prev) - { - for (p = &list; *p; p = &(*p)->next) - if ((*p)->id == prev && !(*p)->destroyed) - break; - } - else - p = &list; - new->id = id; - set_ignore (dpy, NextRequest (dpy)); - if (!XGetWindowAttributes (dpy, id, &new->a)) - { - free (new); - return; - } - new->damaged = 0; +add_win(Display *dpy, Window id, Window prev) { + win *new = malloc(sizeof(win)); + win **p; + + if (!new) + return; + if (prev) { + for (p = &list; *p; p = &(*p)->next) + if ((*p)->id == prev && !(*p)->destroyed) + break; + } else + p = &list; + new->id = id; + set_ignore(dpy, NextRequest(dpy)); + if (!XGetWindowAttributes(dpy, id, &new->a)) { + free(new); + return; + } + new->damaged = 0; #if CAN_DO_USABLE - new->usable = False; + new->usable = False; #endif #if HAS_NAME_WINDOW_PIXMAP - new->pixmap = None; + new->pixmap = None; #endif - new->picture = None; - if (new->a.class == InputOnly) - { - new->damage_sequence = 0; - new->damage = None; - } - else - { - new->damage_sequence = NextRequest (dpy); - set_ignore (dpy, NextRequest (dpy)); - new->damage = XDamageCreate (dpy, id, XDamageReportNonEmpty); - } - new->alphaPict = None; - new->shadowPict = None; - new->borderSize = None; - new->extents = None; - new->shadow = None; - new->shadow_dx = 0; - new->shadow_dy = 0; - new->shadow_width = 0; - new->shadow_height = 0; - new->opacity = OPAQUE; - new->destroyed = False; - new->need_configure = False; + new->picture = None; + if (new->a.class == InputOnly) { + new->damage_sequence = 0; + new->damage = None; + } else { + new->damage_sequence = NextRequest(dpy); + set_ignore(dpy, NextRequest(dpy)); + new->damage = XDamageCreate(dpy, id, XDamageReportNonEmpty); + } + new->alphaPict = None; + new->shadowPict = None; + new->borderSize = None; + new->extents = None; + new->shadow = None; + new->shadow_dx = 0; + new->shadow_dy = 0; + new->shadow_width = 0; + new->shadow_height = 0; + new->opacity = OPAQUE; + new->destroyed = False; + new->need_configure = False; - new->borderClip = None; - new->prev_trans = 0; + new->borderClip = None; + new->prev_trans = 0; - new->next = *p; - *p = new; - if (new->a.map_state == IsViewable) - map_win (dpy, id, new->damage_sequence - 1, True); + new->next = *p; + *p = new; + if (new->a.map_state == IsViewable) + map_win(dpy, id, new->damage_sequence - 1, True); } void -restack_win (Display *dpy, win *w, Window new_above) -{ - Window old_above; - - if (w->next) - old_above = w->next->id; - else - old_above = None; - if (old_above != new_above) - { - win **prev; +restack_win(Display *dpy, win *w, Window new_above) { + Window old_above; - /* unhook */ - for (prev = &list; *prev; prev = &(*prev)->next) - if ((*prev) == w) - break; - *prev = w->next; - - /* rehook */ - for (prev = &list; *prev; prev = &(*prev)->next) - { - if ((*prev)->id == new_above && !(*prev)->destroyed) - break; - } - w->next = *prev; - *prev = w; + if (w->next) + old_above = w->next->id; + else + old_above = None; + if (old_above != new_above) { + win **prev; + + /* unhook */ + for (prev = &list; *prev; prev = &(*prev)->next) + if ((*prev) == w) + break; + *prev = w->next; + + /* rehook */ + for (prev = &list; *prev; prev = &(*prev)->next) { + if ((*prev)->id == new_above && !(*prev)->destroyed) + break; } + w->next = *prev; + *prev = w; + } } static void -configure_win (Display *dpy, XConfigureEvent *ce) -{ - win *w = find_win (dpy, ce->window); - XserverRegion damage = None; - - if (!w) - { - if (ce->window == root) - { - if (rootBuffer) - { - XRenderFreePicture (dpy, rootBuffer); - rootBuffer = None; - } - root_width = ce->width; - root_height = ce->height; - } - return; - } +configure_win(Display *dpy, XConfigureEvent *ce) { + win *w = find_win(dpy, ce->window); + XserverRegion damage = None; - if (w->a.map_state == IsUnmapped) { - /* save the configure event for when the window maps */ - w->need_configure = True; - w->queue_configure = *ce; + if (!w) { + if (ce->window == root) { + if (rootBuffer) { + XRenderFreePicture(dpy, rootBuffer); + rootBuffer = None; + } + root_width = ce->width; + root_height = ce->height; } - else { - w->need_configure = False; + return; + } + + if (w->a.map_state == IsUnmapped) { + /* save the configure event for when the window maps */ + w->need_configure = True; + w->queue_configure = *ce; + } else { + w->need_configure = False; #if CAN_DO_USABLE - if (w->usable) -#endif - { - damage = XFixesCreateRegion (dpy, 0, 0); - if (w->extents != None) - XFixesCopyRegion (dpy, damage, w->extents); - } - - w->a.x = ce->x; - w->a.y = ce->y; - if (w->a.width != ce->width || w->a.height != ce->height) - { -#if HAS_NAME_WINDOW_PIXMAP - if (w->pixmap) - { - XFreePixmap (dpy, w->pixmap); - w->pixmap = None; - if (w->picture) - { - XRenderFreePicture (dpy, w->picture); - w->picture = None; - } - } -#endif - if (w->shadow) - { - XRenderFreePicture (dpy, w->shadow); - w->shadow = None; - } - } - w->a.width = ce->width; - w->a.height = ce->height; - w->a.border_width = ce->border_width; - if (w->a.map_state != IsUnmapped && damage) - { - XserverRegion extents = win_extents (dpy, w); - XFixesUnionRegion (dpy, damage, damage, extents); - XFixesDestroyRegion (dpy, extents); - add_damage (dpy, damage); - } - - clipChanged = True; - } - - w->a.override_redirect = ce->override_redirect; - restack_win (dpy, w, ce->above); -} - -static void -circulate_win (Display *dpy, XCirculateEvent *ce) -{ - win *w = find_win (dpy, ce->window); - Window new_above; - - if (!w) - return; - - if (ce->place == PlaceOnTop) - new_above = list->id; - else - new_above = None; - restack_win (dpy, w, new_above); - clipChanged = True; -} - -static void -finish_destroy_win (Display *dpy, Window id) -{ - win **prev, *w; - - for (prev = &list; (w = *prev); prev = &w->next) - if (w->id == id && w->destroyed) - { - finish_unmap_win (dpy, w); - *prev = w->next; - if (w->alphaPict) - { - XRenderFreePicture (dpy, w->alphaPict); - w->alphaPict = None; - } - if (w->shadowPict) - { - XRenderFreePicture (dpy, w->shadowPict); - w->shadowPict = None; - } - if (w->damage != None) - { - set_ignore (dpy, NextRequest (dpy)); - XDamageDestroy (dpy, w->damage); - w->damage = None; - } - - cleanup_fade (dpy, w); - free (w); - break; - } -} - -#if HAS_NAME_WINDOW_PIXMAP -static void -destroy_callback (Display *dpy, win *w) -{ - finish_destroy_win (dpy, w->id); -} -#endif - -static void -destroy_win (Display *dpy, Window id, Bool fade) -{ - win *w = find_win (dpy, id); - - if (w) w->destroyed = True; - -#if HAS_NAME_WINDOW_PIXMAP - if (w && w->pixmap && fade && winTypeFade[w->windowType]) - set_fade (dpy, w, w->opacity*1.0/OPAQUE, 0.0, fade_out_step, - destroy_callback, False, True); - else + if (w->usable) #endif { - finish_destroy_win (dpy, id); + damage = XFixesCreateRegion(dpy, 0, 0); + if (w->extents != None) + XFixesCopyRegion(dpy, damage, w->extents); } + + w->a.x = ce->x; + w->a.y = ce->y; + if (w->a.width != ce->width || w->a.height != ce->height) { +#if HAS_NAME_WINDOW_PIXMAP + if (w->pixmap) { + XFreePixmap(dpy, w->pixmap); + w->pixmap = None; + if (w->picture) { + XRenderFreePicture(dpy, w->picture); + w->picture = None; + } + } +#endif + if (w->shadow) { + XRenderFreePicture(dpy, w->shadow); + w->shadow = None; + } + } + w->a.width = ce->width; + w->a.height = ce->height; + w->a.border_width = ce->border_width; + if (w->a.map_state != IsUnmapped && damage) { + XserverRegion extents = win_extents(dpy, w); + XFixesUnionRegion(dpy, damage, damage, extents); + XFixesDestroyRegion(dpy, extents); + add_damage(dpy, damage); + } + + clipChanged = True; + } + + w->a.override_redirect = ce->override_redirect; + restack_win(dpy, w, ce->above); +} + +static void +circulate_win(Display *dpy, XCirculateEvent *ce) { + win *w = find_win(dpy, ce->window); + Window new_above; + + if (!w) + return; + + if (ce->place == PlaceOnTop) + new_above = list->id; + else + new_above = None; + restack_win(dpy, w, new_above); + clipChanged = True; +} + +static void +finish_destroy_win(Display *dpy, Window id) { + win **prev, *w; + + for (prev = &list; (w = *prev); prev = &w->next) + if (w->id == id && w->destroyed) { + finish_unmap_win(dpy, w); + *prev = w->next; + if (w->alphaPict) { + XRenderFreePicture(dpy, w->alphaPict); + w->alphaPict = None; + } + if (w->shadowPict) { + XRenderFreePicture(dpy, w->shadowPict); + w->shadowPict = None; + } + if (w->damage != None) { + set_ignore(dpy, NextRequest(dpy)); + XDamageDestroy(dpy, w->damage); + w->damage = None; + } + + cleanup_fade(dpy, w); + free(w); + break; + } +} + +#if HAS_NAME_WINDOW_PIXMAP +static void +destroy_callback(Display *dpy, win *w) { + finish_destroy_win(dpy, w->id); +} +#endif + +static void +destroy_win(Display *dpy, Window id, Bool fade) { + win *w = find_win(dpy, id); + + if (w) w->destroyed = True; + +#if HAS_NAME_WINDOW_PIXMAP + if (w && w->pixmap && fade && winTypeFade[w->windowType]) + set_fade(dpy, w, w->opacity*1.0/OPAQUE, 0.0, fade_out_step, + destroy_callback, False, True); + else +#endif + { + finish_destroy_win(dpy, id); + } } /* static void -dump_win (win *w) -{ - printf ("\t%08lx: %d x %d + %d + %d (%d)\n", w->id, - w->a.width, w->a.height, w->a.x, w->a.y, w->a.border_width); +dump_win(win *w) { + printf("\t%08lx: %d x %d + %d + %d(%d)\n", w->id, + w->a.width, w->a.height, w->a.x, w->a.y, w->a.border_width); } static void -dump_wins (void) -{ - win *w; +dump_wins(void) { + win *w; - printf ("windows:\n"); - for (w = list; w; w = w->next) - dump_win (w); + printf("windows:\n"); + for (w = list; w; w = w->next) + dump_win(w); } */ static void -damage_win (Display *dpy, XDamageNotifyEvent *de) -{ - win *w = find_win (dpy, de->drawable); +damage_win(Display *dpy, XDamageNotifyEvent *de) { + win *w = find_win(dpy, de->drawable); - if (!w) - return; + if (!w) + return; #if CAN_DO_USABLE - if (!w->usable) - { - if (w->damage_bounds.width == 0 || w->damage_bounds.height == 0) - { - w->damage_bounds = de->area; - } - else - { - if (de->area.x < w->damage_bounds.x) - { - w->damage_bounds.width += (w->damage_bounds.x - de->area.x); - w->damage_bounds.x = de->area.x; - } - if (de->area.y < w->damage_bounds.y) - { - w->damage_bounds.height += (w->damage_bounds.y - de->area.y); - w->damage_bounds.y = de->area.y; - } - if (de->area.x + de->area.width > w->damage_bounds.x + w->damage_bounds.width) - w->damage_bounds.width = de->area.x + de->area.width - w->damage_bounds.x; - if (de->area.y + de->area.height > w->damage_bounds.y + w->damage_bounds.height) - w->damage_bounds.height = de->area.y + de->area.height - w->damage_bounds.y; - } -#if 0 - printf ("unusable damage %d, %d: %d x %d bounds %d, %d: %d x %d\n", - de->area.x, - de->area.y, - de->area.width, - de->area.height, - w->damage_bounds.x, - w->damage_bounds.y, - w->damage_bounds.width, - w->damage_bounds.height); -#endif - if (w->damage_bounds.x <= 0 && - w->damage_bounds.y <= 0 && - w->a.width <= w->damage_bounds.x + w->damage_bounds.width && - w->a.height <= w->damage_bounds.y + w->damage_bounds.height) - { - clipChanged = True; - if (winTypeFade[w->windowType]) - set_fade (dpy, w, 0, get_opacity_percent (dpy, w), fade_in_step, 0, True, True); - w->usable = True; - } + if (!w->usable) { + if (w->damage_bounds.width == 0 || w->damage_bounds.height == 0) { + w->damage_bounds = de->area; + } else { + if (de->area.x < w->damage_bounds.x) { + w->damage_bounds.width += (w->damage_bounds.x - de->area.x); + w->damage_bounds.x = de->area.x; + } + if (de->area.y < w->damage_bounds.y) { + w->damage_bounds.height += (w->damage_bounds.y - de->area.y); + w->damage_bounds.y = de->area.y; + } + if (de->area.x + de->area.width > w->damage_bounds.x + w->damage_bounds.width) + w->damage_bounds.width = de->area.x + de->area.width - w->damage_bounds.x; + if (de->area.y + de->area.height > w->damage_bounds.y + w->damage_bounds.height) + w->damage_bounds.height = de->area.y + de->area.height - w->damage_bounds.y; } - if (w->usable) +#if 0 + printf("unusable damage %d, %d: %d x %d bounds %d, %d: %d x %d\n", + de->area.x, + de->area.y, + de->area.width, + de->area.height, + w->damage_bounds.x, + w->damage_bounds.y, + w->damage_bounds.width, + w->damage_bounds.height); #endif - repair_win (dpy, w); + if (w->damage_bounds.x <= 0 && + w->damage_bounds.y <= 0 && + w->a.width <= w->damage_bounds.x + w->damage_bounds.width && + w->a.height <= w->damage_bounds.y + w->damage_bounds.height) { + clipChanged = True; + if (winTypeFade[w->windowType]) + set_fade(dpy, w, 0, get_opacity_percent(dpy, w), + fade_in_step, 0, True, True); + w->usable = True; + } + } + if (w->usable) +#endif + repair_win(dpy, w); } static int -error (Display *dpy, XErrorEvent *ev) -{ - int o; - const char *name = 0; - - if (should_ignore (dpy, ev->serial)) - return 0; - - if (ev->request_code == composite_opcode && - ev->minor_code == X_CompositeRedirectSubwindows) - { - fprintf (stderr, "Another composite manager is already running\n"); - exit (1); - } - - o = ev->error_code - xfixes_error; - switch (o) { - case BadRegion: name = "BadRegion"; break; - default: break; - } - o = ev->error_code - damage_error; - switch (o) { - case BadDamage: name = "BadDamage"; break; - default: break; - } - o = ev->error_code - render_error; - switch (o) { - case BadPictFormat: name ="BadPictFormat"; break; - case BadPicture: name ="BadPicture"; break; - case BadPictOp: name ="BadPictOp"; break; - case BadGlyphSet: name ="BadGlyphSet"; break; - case BadGlyph: name ="BadGlyph"; break; - default: break; - } - - printf ("error %d request %d minor %d serial %lu\n", - ev->error_code, ev->request_code, ev->minor_code, ev->serial); +error(Display *dpy, XErrorEvent *ev) { + int o; + const char *name = 0; -/* abort (); this is just annoying to most people */ + if (should_ignore(dpy, ev->serial)) return 0; + + if (ev->request_code == composite_opcode && + ev->minor_code == X_CompositeRedirectSubwindows) { + fprintf(stderr, "Another composite manager is already running\n"); + exit(1); + } + + o = ev->error_code - xfixes_error; + switch (o) { + case BadRegion: name = "BadRegion"; break; + default: break; + } + o = ev->error_code - damage_error; + switch (o) { + case BadDamage: name = "BadDamage"; break; + default: break; + } + o = ev->error_code - render_error; + switch (o) { + case BadPictFormat: name ="BadPictFormat"; break; + case BadPicture: name ="BadPicture"; break; + case BadPictOp: name ="BadPictOp"; break; + case BadGlyphSet: name ="BadGlyphSet"; break; + case BadGlyph: name ="BadGlyph"; break; + default: break; + } + + printf("error %d request %d minor %d serial %lu\n", + ev->error_code, ev->request_code, ev->minor_code, ev->serial); + +/* abort(); this is just annoying to most people */ + return 0; } static void -expose_root (Display *dpy, Window root, XRectangle *rects, int nrects) -{ - XserverRegion region = XFixesCreateRegion (dpy, rects, nrects); - - add_damage (dpy, region); +expose_root(Display *dpy, Window root, XRectangle *rects, int nrects) { + XserverRegion region = XFixesCreateRegion(dpy, rects, nrects); + + add_damage(dpy, region); } #if DEBUG_EVENTS static int -ev_serial (XEvent *ev) -{ - if (ev->type & 0x7f != KeymapNotify) - return ev->xany.serial; - return NextRequest (ev->xany.display); +ev_serial(XEvent *ev) { + if (ev->type & 0x7f != KeymapNotify) + return ev->xany.serial; + return NextRequest(ev->xany.display); } static char * -ev_name (XEvent *ev) -{ - static char buf[128]; - switch (ev->type & 0x7f) { - case Expose: - return "Expose"; - case MapNotify: - return "Map"; - case UnmapNotify: - return "Unmap"; - case ReparentNotify: - return "Reparent"; - case CirculateNotify: - return "Circulate"; - default: - if (ev->type == damage_event + XDamageNotify) - return "Damage"; - sprintf (buf, "Event %d", ev->type); - return buf; - } +ev_name(XEvent *ev) { + static char buf[128]; + switch (ev->type & 0x7f) { + case Expose: + return "Expose"; + case MapNotify: + return "Map"; + case UnmapNotify: + return "Unmap"; + case ReparentNotify: + return "Reparent"; + case CirculateNotify: + return "Circulate"; + default: + if (ev->type == damage_event + XDamageNotify) + return "Damage"; + sprintf(buf, "Event %d", ev->type); + return buf; + } } static Window -ev_window (XEvent *ev) -{ - switch (ev->type) { - case Expose: - return ev->xexpose.window; - case MapNotify: - return ev->xmap.window; - case UnmapNotify: - return ev->xunmap.window; - case ReparentNotify: - return ev->xreparent.window; - case CirculateNotify: - return ev->xcirculate.window; - default: - if (ev->type == damage_event + XDamageNotify) - return ((XDamageNotifyEvent *) ev)->drawable; - return 0; - } +ev_window(XEvent *ev) { + switch (ev->type) { + case Expose: + return ev->xexpose.window; + case MapNotify: + return ev->xmap.window; + case UnmapNotify: + return ev->xunmap.window; + case ReparentNotify: + return ev->xreparent.window; + case CirculateNotify: + return ev->xcirculate.window; + default: + if (ev->type == damage_event + XDamageNotify) + return ((XDamageNotifyEvent *) ev)->drawable; + return 0; + } } #endif void -usage (char *program) -{ - fprintf (stderr, "%s v1.1.3\n", program); - fprintf (stderr, "usage: %s [options]\n", program); - fprintf (stderr, "Options\n"); - fprintf (stderr, " -d display\n Specifies which display should be managed.\n"); - fprintf (stderr, " -r radius\n Specifies the blur radius for client-side shadows. (default 12)\n"); - fprintf (stderr, " -o opacity\n Specifies the translucency for client-side shadows. (default .75)\n"); - fprintf (stderr, " -l left-offset\n Specifies the left offset for shadows. (default -15)\n"); - fprintf (stderr, " -t top-offset\n Specifies the top offset for shadows. (default -15)\n"); - fprintf (stderr, " -I fade-in-step\n Specifies the opacity change between steps while fading in. (default 0.028)\n"); - fprintf (stderr, " -O fade-out-step\n Specifies the opacity change between steps while fading out. (default 0.03)\n"); - fprintf (stderr, " -D fade-delta-time\n Specifies the time between steps in a fade in milliseconds. (default 10)\n"); - fprintf (stderr, " -m opacity\n Specifies the opacity for menus. (default 1.0)\n"); - fprintf (stderr, " -a\n Use automatic server-side compositing. Faster, but no special effects.\n"); - fprintf (stderr, " -c\n Draw client-side shadows with fuzzy edges.\n"); - fprintf (stderr, " -C\n Avoid drawing shadows on dock/panel windows.\n"); - fprintf (stderr, " -f\n Fade windows in/out when opening/closing.\n"); - fprintf (stderr, " -F\n Fade windows during opacity changes.\n"); - fprintf (stderr, " -n\n Normal client-side compositing with transparency support\n"); - fprintf (stderr, " -s\n Draw server-side shadows with sharp edges.\n"); - fprintf (stderr, " -S\n Enable synchronous operation (for debugging).\n"); - exit (1); +usage(char *program) { + fprintf(stderr, "%s v1.1.3\n", program); + fprintf(stderr, "usage: %s [options]\n", program); + + fprintf(stderr, "Options\n"); + fprintf(stderr, + " -d display\n Specifies which display should be managed.\n"); + fprintf(stderr, + " -r radius\n Specifies the blur radius for client-side shadows. (default 12)\n"); + fprintf(stderr, + " -o opacity\n Specifies the translucency for client-side shadows. (default .75)\n"); + fprintf(stderr, + " -l left-offset\n Specifies the left offset for shadows. (default -15)\n"); + fprintf(stderr, + " -t top-offset\n Specifies the top offset for shadows. (default -15)\n"); + fprintf(stderr, + " -I fade-in-step\n Specifies the opacity change between steps while fading in. (default 0.028)\n"); + fprintf(stderr, + " -O fade-out-step\n Specifies the opacity change between steps while fading out. (default 0.03)\n"); + fprintf(stderr, + " -D fade-delta-time\n Specifies the time between steps in a fade in milliseconds. (default 10)\n"); + fprintf(stderr, + " -m opacity\n Specifies the opacity for menus. (default 1.0)\n"); + fprintf(stderr, + " -a\n Use automatic server-side compositing. Faster, but no special effects.\n"); + fprintf(stderr, + " -c\n Draw client-side shadows with fuzzy edges.\n"); + fprintf(stderr, + " -C\n Avoid drawing shadows on dock/panel windows.\n"); + fprintf(stderr, + " -f\n Fade windows in/out when opening/closing.\n"); + fprintf(stderr, + " -F\n Fade windows during opacity changes.\n"); + fprintf(stderr, + " -n\n Normal client-side compositing with transparency support\n"); + fprintf(stderr, + " -s\n Draw server-side shadows with sharp edges.\n"); + fprintf(stderr, + " -S\n Enable synchronous operation (for debugging).\n"); + + exit(1); } static void -register_cm (int scr) -{ - Window w; - Atom a; - char *buf; - int len, s; +register_cm(int scr) { + Window w; + Atom a; + char *buf; + int len, s; - if (scr < 0) return; + if (scr < 0) return; - w = XCreateSimpleWindow (dpy, RootWindow (dpy, 0), 0, 0, 1, 1, 0, None, - None); + w = XCreateSimpleWindow(dpy, RootWindow(dpy, 0), 0, 0, 1, 1, 0, None, + None); - Xutf8SetWMProperties (dpy, w, "xcompmgr", "xcompmgr", NULL, 0, NULL, NULL, - NULL); + Xutf8SetWMProperties(dpy, w, "xcompmgr", "xcompmgr", NULL, 0, NULL, NULL, + NULL); - len = strlen(REGISTER_PROP) + 2; - s = scr; - while (s >= 10) { - ++len; - s /= 10; - } - buf = malloc(len); - snprintf(buf, len, REGISTER_PROP"%d", scr); + len = strlen(REGISTER_PROP) + 2; + s = scr; + while (s >= 10) { + ++len; + s /= 10; + } + buf = malloc(len); + snprintf(buf, len, REGISTER_PROP"%d", scr); - a = XInternAtom (dpy, buf, False); - free(buf); + a = XInternAtom(dpy, buf, False); + free(buf); - XSetSelectionOwner (dpy, a, w, 0); + XSetSelectionOwner(dpy, a, w, 0); } int -main (int argc, char **argv) -{ - XEvent ev; - Window root_return, parent_return; - Window *children; - unsigned int nchildren; - int i; - XRenderPictureAttributes pa; - XRectangle *expose_rects = 0; - int size_expose = 0; - int n_expose = 0; - struct pollfd ufd; - int p; - int composite_major, composite_minor; - char *display = 0; - int o; - Bool noDockShadow = False; +main(int argc, char **argv) { + XEvent ev; + Window root_return, parent_return; + Window *children; + unsigned int nchildren; + int i; + XRenderPictureAttributes pa; + XRectangle *expose_rects = 0; + int size_expose = 0; + int n_expose = 0; + struct pollfd ufd; + int p; + int composite_major, composite_minor; + char *display = 0; + int o; + Bool noDockShadow = False; - for (i = 0; i < NUM_WINTYPES; ++i) { - winTypeFade[i] = False; + for (i = 0; i < NUM_WINTYPES; ++i) { + winTypeFade[i] = False; + winTypeShadow[i] = False; + winTypeOpacity[i] = 1.0; + } + + /* don't bother to draw a shadow for the desktop */ + winTypeShadow[WINTYPE_DESKTOP] = False; + + while ((o = getopt(argc, argv, "D:I:O:d:r:o:m:l:t:scnfFCaS")) != -1) { + switch (o) { + case 'd': + display = optarg; + break; + case 'D': + fade_delta = atoi(optarg); + if (fade_delta < 1) + fade_delta = 10; + break; + case 'I': + fade_in_step = atof(optarg); + if (fade_in_step <= 0) + fade_in_step = 0.01; + break; + case 'O': + fade_out_step = atof(optarg); + if (fade_out_step <= 0) + fade_out_step = 0.01; + break; + case 's': + compMode = CompServerShadows; + for (i = 0; i < NUM_WINTYPES; ++i) + winTypeShadow[i] = True; + break; + case 'c': + compMode = CompClientShadows; + for (i = 0; i < NUM_WINTYPES; ++i) + winTypeShadow[i] = True; + break; + case 'C': + noDockShadow = True; + break; + case 'n': + compMode = CompSimple; + for (i = 0; i < NUM_WINTYPES; ++i) winTypeShadow[i] = False; - winTypeOpacity[i] = 1.0; + break; + case 'm': + winTypeOpacity[WINTYPE_DROPDOWN_MENU] = atof(optarg); + winTypeOpacity[WINTYPE_POPUP_MENU] = atof(optarg); + break; + case 'f': + for (i = 0; i < NUM_WINTYPES; ++i) + winTypeFade[i] = True; + break; + case 'F': + fadeTrans = True; + break; + case 'a': + autoRedirect = True; + break; + case 'S': + synchronize = True; + break; + case 'r': + shadowRadius = atoi(optarg); + break; + case 'o': + shadowOpacity = atof(optarg); + break; + case 'l': + shadowOffsetX = atoi(optarg); + break; + case 't': + shadowOffsetY = atoi(optarg); + break; + default: + usage(argv[0]); + break; } + } - /* don't bother to draw a shadow for the desktop */ - winTypeShadow[WINTYPE_DESKTOP] = False; + if (noDockShadow) + winTypeShadow[WINTYPE_DOCK] = False; - while ((o = getopt (argc, argv, "D:I:O:d:r:o:m:l:t:scnfFCaS")) != -1) - { - switch (o) { - case 'd': - display = optarg; - break; - case 'D': - fade_delta = atoi (optarg); - if (fade_delta < 1) - fade_delta = 10; - break; - case 'I': - fade_in_step = atof (optarg); - if (fade_in_step <= 0) - fade_in_step = 0.01; - break; - case 'O': - fade_out_step = atof (optarg); - if (fade_out_step <= 0) - fade_out_step = 0.01; - break; - case 's': - compMode = CompServerShadows; - for (i = 0; i < NUM_WINTYPES; ++i) - winTypeShadow[i] = True; - break; - case 'c': - compMode = CompClientShadows; - for (i = 0; i < NUM_WINTYPES; ++i) - winTypeShadow[i] = True; - break; - case 'C': - noDockShadow = True; - break; - case 'n': - compMode = CompSimple; - for (i = 0; i < NUM_WINTYPES; ++i) - winTypeShadow[i] = False; - break; - case 'm': - winTypeOpacity[WINTYPE_DROPDOWN_MENU] = atof (optarg); - winTypeOpacity[WINTYPE_POPUP_MENU] = atof (optarg); - break; - case 'f': - for (i = 0; i < NUM_WINTYPES; ++i) - winTypeFade[i] = True; - break; - case 'F': - fadeTrans = True; - break; - case 'a': - autoRedirect = True; - break; - case 'S': - synchronize = True; - break; - case 'r': - shadowRadius = atoi (optarg); - break; - case 'o': - shadowOpacity = atof (optarg); - break; - case 'l': - shadowOffsetX = atoi (optarg); - break; - case 't': - shadowOffsetY = atoi (optarg); - break; - default: - usage (argv[0]); - break; - } - } + dpy = XOpenDisplay(display); + if (!dpy) { + fprintf(stderr, "Can't open display\n"); + exit(1); + } - if (noDockShadow) - winTypeShadow[WINTYPE_DOCK] = False; - - dpy = XOpenDisplay (display); - if (!dpy) - { - fprintf (stderr, "Can't open display\n"); - exit (1); - } - XSetErrorHandler (error); - if (synchronize) - XSynchronize (dpy, 1); - scr = DefaultScreen (dpy); - root = RootWindow (dpy, scr); + XSetErrorHandler(error); + if (synchronize) + XSynchronize(dpy, 1); + + scr = DefaultScreen(dpy); + root = RootWindow(dpy, scr); + + if (!XRenderQueryExtension(dpy, &render_event, &render_error)) { + fprintf(stderr, "No render extension\n"); + exit(1); + } + + if (!XQueryExtension(dpy, COMPOSITE_NAME, &composite_opcode, + &composite_event, &composite_error)) { + fprintf(stderr, "No composite extension\n"); + exit(1); + } + + XCompositeQueryVersion(dpy, &composite_major, &composite_minor); - if (!XRenderQueryExtension (dpy, &render_event, &render_error)) - { - fprintf (stderr, "No render extension\n"); - exit (1); - } - if (!XQueryExtension (dpy, COMPOSITE_NAME, &composite_opcode, - &composite_event, &composite_error)) - { - fprintf (stderr, "No composite extension\n"); - exit (1); - } - XCompositeQueryVersion (dpy, &composite_major, &composite_minor); #if HAS_NAME_WINDOW_PIXMAP - if (composite_major > 0 || composite_minor >= 2) - hasNamePixmap = True; + if (composite_major > 0 || composite_minor >= 2) + hasNamePixmap = True; #endif - if (!XDamageQueryExtension (dpy, &damage_event, &damage_error)) - { - fprintf (stderr, "No damage extension\n"); - exit (1); - } - if (!XFixesQueryExtension (dpy, &xfixes_event, &xfixes_error)) - { - fprintf (stderr, "No XFixes extension\n"); - exit (1); - } + if (!XDamageQueryExtension(dpy, &damage_event, &damage_error)) { + fprintf(stderr, "No damage extension\n"); + exit(1); + } - register_cm(scr); + if (!XFixesQueryExtension(dpy, &xfixes_event, &xfixes_error)) { + fprintf(stderr, "No XFixes extension\n"); + exit(1); + } - /* get atoms */ - opacityAtom = XInternAtom (dpy, OPACITY_PROP, False); - winTypeAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE", False); - winType[WINTYPE_DESKTOP] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", False); - winType[WINTYPE_DOCK] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DOCK", False); - winType[WINTYPE_TOOLBAR] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLBAR", False); - winType[WINTYPE_MENU] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_MENU", False); - winType[WINTYPE_UTILITY] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_UTILITY", False); - winType[WINTYPE_SPLASH] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_SPLASH", False); - winType[WINTYPE_DIALOG] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False); - winType[WINTYPE_NORMAL] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NORMAL", False); - winType[WINTYPE_DROPDOWN_MENU] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False); - winType[WINTYPE_POPUP_MENU] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_POPUP_MENU", False); - winType[WINTYPE_TOOLTIP] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLTIP", False); - winType[WINTYPE_NOTIFY] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NOTIFICATION", False); - winType[WINTYPE_COMBO] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_COMBO", False); - winType[WINTYPE_DND] = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DND", False); + register_cm(scr); - pa.subwindow_mode = IncludeInferiors; + /* get atoms */ + opacityAtom = XInternAtom(dpy, + OPACITY_PROP, False); + winTypeAtom = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE", False); + winType[WINTYPE_DESKTOP] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_DESKTOP", False); + winType[WINTYPE_DOCK] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_DOCK", False); + winType[WINTYPE_TOOLBAR] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_TOOLBAR", False); + winType[WINTYPE_MENU] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_MENU", False); + winType[WINTYPE_UTILITY] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_UTILITY", False); + winType[WINTYPE_SPLASH] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_SPLASH", False); + winType[WINTYPE_DIALOG] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_DIALOG", False); + winType[WINTYPE_NORMAL] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_NORMAL", False); + winType[WINTYPE_DROPDOWN_MENU] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False); + winType[WINTYPE_POPUP_MENU] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_POPUP_MENU", False); + winType[WINTYPE_TOOLTIP] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_TOOLTIP", False); + winType[WINTYPE_NOTIFY] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_NOTIFICATION", False); + winType[WINTYPE_COMBO] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_COMBO", False); + winType[WINTYPE_DND] = XInternAtom(dpy, + "_NET_WM_WINDOW_TYPE_DND", False); - if (compMode == CompClientShadows) - { - gaussianMap = make_gaussian_map(dpy, shadowRadius); - presum_gaussian (gaussianMap); - } + pa.subwindow_mode = IncludeInferiors; - root_width = DisplayWidth (dpy, scr); - root_height = DisplayHeight (dpy, scr); + if (compMode == CompClientShadows) { + gaussianMap = make_gaussian_map(dpy, shadowRadius); + presum_gaussian(gaussianMap); + } - rootPicture = XRenderCreatePicture (dpy, root, - XRenderFindVisualFormat (dpy, - DefaultVisual (dpy, scr)), - CPSubwindowMode, - &pa); - blackPicture = solid_picture (dpy, True, 1, 0, 0, 0); - if (compMode == CompServerShadows) - transBlackPicture = solid_picture (dpy, True, 0.3, 0, 0, 0); - allDamage = None; - clipChanged = True; - XGrabServer (dpy); - if (autoRedirect) - XCompositeRedirectSubwindows (dpy, root, CompositeRedirectAutomatic); - else - { - XCompositeRedirectSubwindows (dpy, root, CompositeRedirectManual); - XSelectInput (dpy, root, - SubstructureNotifyMask| - ExposureMask| - StructureNotifyMask| - PropertyChangeMask); - XQueryTree (dpy, root, &root_return, &parent_return, &children, &nchildren); - for (i = 0; i < nchildren; i++) - add_win (dpy, children[i], i ? children[i-1] : None); - XFree (children); - } - XUngrabServer (dpy); - ufd.fd = ConnectionNumber (dpy); - ufd.events = POLLIN; - if (!autoRedirect) - paint_all (dpy, None); - for (;;) - { - /* dump_wins (); */ - do { - if (autoRedirect) - XFlush (dpy); - if (!QLength (dpy)) - { - if (poll (&ufd, 1, fade_timeout()) == 0) - { - run_fades (dpy); - break; - } - } + root_width = DisplayWidth(dpy, scr); + root_height = DisplayHeight(dpy, scr); + + rootPicture = XRenderCreatePicture(dpy, root, + XRenderFindVisualFormat(dpy, + DefaultVisual(dpy, scr)), + CPSubwindowMode, + &pa); + blackPicture = solid_picture(dpy, True, 1, 0, 0, 0); + + if (compMode == CompServerShadows) + transBlackPicture = solid_picture(dpy, True, 0.3, 0, 0, 0); + + allDamage = None; + clipChanged = True; + XGrabServer(dpy); + + if (autoRedirect) + XCompositeRedirectSubwindows(dpy, root, CompositeRedirectAutomatic); + else { + XCompositeRedirectSubwindows(dpy, root, CompositeRedirectManual); + XSelectInput(dpy, root, + SubstructureNotifyMask + | ExposureMask + | StructureNotifyMask + | PropertyChangeMask); + XQueryTree(dpy, root, &root_return, &parent_return, &children, &nchildren); + + for (i = 0; i < nchildren; i++) + add_win(dpy, children[i], i ? children[i-1] : None); + + XFree(children); + } + + XUngrabServer(dpy); + + ufd.fd = ConnectionNumber(dpy); + ufd.events = POLLIN; + if (!autoRedirect) + paint_all(dpy, None); + + for (;;) { + /* dump_wins(); */ + do { + if (autoRedirect) XFlush(dpy); + + if (!QLength(dpy)) { + if (poll(&ufd, 1, fade_timeout()) == 0) { + run_fades(dpy); + break; + } + } + + XNextEvent(dpy, &ev); + + if ((ev.type & 0x7f) != KeymapNotify) + discard_ignore(dpy, ev.xany.serial); - XNextEvent (dpy, &ev); - if ((ev.type & 0x7f) != KeymapNotify) - discard_ignore (dpy, ev.xany.serial); #if DEBUG_EVENTS - printf ("event %10.10s serial 0x%08x window 0x%08x\n", - ev_name(&ev), ev_serial (&ev), ev_window (&ev)); + printf("event %10.10s serial 0x%08x window 0x%08x\n", + ev_name(&ev), ev_serial(&ev), ev_window(&ev)); #endif - if (!autoRedirect) switch (ev.type) { - case CreateNotify: - add_win (dpy, ev.xcreatewindow.window, 0); - break; - case ConfigureNotify: - configure_win (dpy, &ev.xconfigure); - break; - case DestroyNotify: - destroy_win (dpy, ev.xdestroywindow.window, True); - break; - case MapNotify: - map_win (dpy, ev.xmap.window, ev.xmap.serial, True); - break; - case UnmapNotify: - unmap_win (dpy, ev.xunmap.window, True); - break; - case ReparentNotify: - if (ev.xreparent.parent == root) - add_win (dpy, ev.xreparent.window, 0); - else - destroy_win (dpy, ev.xreparent.window, True); - break; - case CirculateNotify: - circulate_win (dpy, &ev.xcirculate); - break; - case Expose: - if (ev.xexpose.window == root) - { - int more = ev.xexpose.count + 1; - if (n_expose == size_expose) - { - if (expose_rects) - { - expose_rects = realloc (expose_rects, - (size_expose + more) * - sizeof (XRectangle)); - size_expose += more; - } - else - { - expose_rects = malloc (more * sizeof (XRectangle)); - size_expose = more; - } - } - expose_rects[n_expose].x = ev.xexpose.x; - expose_rects[n_expose].y = ev.xexpose.y; - expose_rects[n_expose].width = ev.xexpose.width; - expose_rects[n_expose].height = ev.xexpose.height; - n_expose++; - if (ev.xexpose.count == 0) - { - expose_root (dpy, root, expose_rects, n_expose); - n_expose = 0; - } - } - break; - case PropertyNotify: - for (p = 0; backgroundProps[p]; p++) - { - if (ev.xproperty.atom == XInternAtom (dpy, backgroundProps[p], False)) - { - if (rootTile) - { - XClearArea (dpy, root, 0, 0, 0, 0, True); - XRenderFreePicture (dpy, rootTile); - rootTile = None; - break; - } - } - } - /* check if Trans property was changed */ - if (ev.xproperty.atom == opacityAtom) - { - /* reset mode and redraw window */ - win * w = find_win(dpy, ev.xproperty.window); - if (w) - { - if (fadeTrans) - set_fade (dpy, w, w->opacity*1.0/OPAQUE, get_opacity_percent (dpy, w), - fade_out_step, 0, True, False); - else - { - w->opacity = get_opacity_prop(dpy, w, OPAQUE); - determine_mode(dpy, w); - if (w->shadow) - { - XRenderFreePicture (dpy, w->shadow); - w->shadow = None; - if (w->extents != None) - XFixesDestroyRegion (dpy, w->extents); + if (!autoRedirect) switch (ev.type) { + case CreateNotify: + add_win(dpy, ev.xcreatewindow.window, 0); + break; + case ConfigureNotify: + configure_win(dpy, &ev.xconfigure); + break; + case DestroyNotify: + destroy_win(dpy, ev.xdestroywindow.window, True); + break; + case MapNotify: + map_win(dpy, ev.xmap.window, ev.xmap.serial, True); + break; + case UnmapNotify: + unmap_win(dpy, ev.xunmap.window, True); + break; + case ReparentNotify: + if (ev.xreparent.parent == root) + add_win(dpy, ev.xreparent.window, 0); + else + destroy_win(dpy, ev.xreparent.window, True); + break; + case CirculateNotify: + circulate_win(dpy, &ev.xcirculate); + break; + case Expose: + if (ev.xexpose.window == root) { + int more = ev.xexpose.count + 1; + if (n_expose == size_expose) { + if (expose_rects) { + expose_rects = realloc(expose_rects, + (size_expose + more) * + sizeof(XRectangle)); + size_expose += more; + } else { + expose_rects = malloc(more * sizeof(XRectangle)); + size_expose = more; + } + } + expose_rects[n_expose].x = ev.xexpose.x; + expose_rects[n_expose].y = ev.xexpose.y; + expose_rects[n_expose].width = ev.xexpose.width; + expose_rects[n_expose].height = ev.xexpose.height; + n_expose++; + if (ev.xexpose.count == 0) { + expose_root(dpy, root, expose_rects, n_expose); + n_expose = 0; + } + } + break; + case PropertyNotify: + for (p = 0; backgroundProps[p]; p++) { + if (ev.xproperty.atom == XInternAtom(dpy, backgroundProps[p], False)) { + if (rootTile) { + XClearArea(dpy, root, 0, 0, 0, 0, True); + XRenderFreePicture(dpy, rootTile); + rootTile = None; + break; + } + } + } + /* check if Trans property was changed */ + if (ev.xproperty.atom == opacityAtom) { + /* reset mode and redraw window */ + win * w = find_win(dpy, ev.xproperty.window); + if (w) { + if (fadeTrans) + set_fade(dpy, w, w->opacity*1.0/OPAQUE, get_opacity_percent(dpy, w), + fade_out_step, 0, True, False); + else { + w->opacity = get_opacity_prop(dpy, w, OPAQUE); + determine_mode(dpy, w); + if (w->shadow) { + XRenderFreePicture(dpy, w->shadow); + w->shadow = None; - /* rebuild the shadow */ - w->extents = win_extents (dpy, w); - } - } - } - } - break; - default: - if (ev.type == damage_event + XDamageNotify) - damage_win (dpy, (XDamageNotifyEvent *) &ev); - break; - } - } while (QLength (dpy)); - if (allDamage && !autoRedirect) - { - static int paint; - paint_all (dpy, allDamage); - paint++; - XSync (dpy, False); - allDamage = None; - clipChanged = False; - } + if (w->extents != None) + XFixesDestroyRegion(dpy, w->extents); + + /* rebuild the shadow */ + w->extents = win_extents(dpy, w); + } + } + } + } + break; + default: + if (ev.type == damage_event + XDamageNotify) + damage_win(dpy, (XDamageNotifyEvent *) &ev); + break; + } + } while (QLength(dpy)); + + if (allDamage && !autoRedirect) { + static int paint; + paint_all(dpy, allDamage); + paint++; + XSync(dpy, False); + allDamage = None; + clipChanged = False; } + } }