X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=utils%2Ferase.c;h=feefd69d7d2db06355536ff9ced2fea7680e3d1c;hb=49f5b54f312fe4ac2e9bc47581a72451bd0e8439;hp=72f5a87a469b3d6129dadb55ed0ac47cd5b477ce;hpb=5b7bc6e70fb439cf4c4bf771ae9f94077fe4fe08;p=xscreensaver diff --git a/utils/erase.c b/utils/erase.c index 72f5a87a..feefd69d 100644 --- a/utils/erase.c +++ b/utils/erase.c @@ -1,213 +1,761 @@ /* erase.c: Erase the screen in various more or less interesting ways. - * (c) 1997 by Johannes Keukelaar - * Permission to use in any way granted. Provided "as is" without expressed - * or implied warranty. NO WARRANTY, NO EXPRESSION OF SUITABILITY FOR ANY - * PURPOSE. (I.e.: Use in any way, but at your own risk!) + * Copyright (c) 1997-2001, 2006 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + * + * Portions (c) 1997 by Johannes Keukelaar : + * Permission to use in any way granted. Provided "as is" without expressed + * or implied warranty. NO WARRANTY, NO EXPRESSION OF SUITABILITY FOR ANY + * PURPOSE. (I.e.: Use in any way, but at your own risk!) */ #include "utils.h" #include "yarandom.h" #include "usleep.h" #include "resources.h" +#include "erase.h" +#include /* for gettimeofday() */ -#define NUM_MODES 8 - -void -erase_window(Display *dpy, Window window, GC gc, - int width, int height, int mode, int delay) -{ - int *clear_lines; - int i, j, line, num_lines=0, granularity, max_num; - - max_num = 2*height; - if(2*width>max_num) - max_num = 2*width; - - clear_lines = (int *)calloc(max_num, sizeof(int)); - if(clear_lines) - { - if(mode<0 || mode>=NUM_MODES) - mode = random()%NUM_MODES; - granularity = 25; - switch(mode) - { - case 0: /* clear random horizontal lines */ - for(i = 0; i < height; i++) - clear_lines[i] = i; - for(i = 0; i < height; i++) - { - int t, r; - t = clear_lines[i]; - r = random()%height; - clear_lines[i] = clear_lines[r]; - clear_lines[r] = t; - } - num_lines = height; - break; - - case 1: /* clear random vertical lines */ - for(i = 0; i < width; i++) - clear_lines[i] = i+height; - for(i = 0; i < width; i++) - { - int t, r; - t = clear_lines[i]; - r = random()%width; - clear_lines[i] = clear_lines[r]; - clear_lines[r] = t; - } - num_lines = width; - break; - - case 2: /* 4 sequential wipes, - L-R, T-B, R-L, B-T. */ - for(i = 0; i < width/2; i++) - clear_lines[i] = i*2+height; - for(i = 0; i < height/2; i++) - clear_lines[i+width/2] = i*2; - for(i = 0; i < width/2; i++) - clear_lines[i+width/2+height/2] = width-i*2-(width%2?0:1)+height; - num_lines = width+height/2; - granularity = 4; - break; - - case 3: /* 4 parallel wipes, - L-R, T-B, R-L, B-T. */ - for(i = 0; i < max_num/4; i++) - { - clear_lines[i*4] = i*2; - clear_lines[i*4+1] = height-i*2-(height%2?0:1); - clear_lines[i*4+2] = height+i*2; - clear_lines[i*4+3] = height+width-i*2-(width%2?0:1); - } - num_lines = max_num; - granularity = 4; - break; - - case 4: /* flutter wipe L-R */ - j = 0; - for(i = 0; i < width*2; i++) - { - line = (i/16)*16-(i%16)*15; - if(line>=0 && line= 0; i--) - { - line = (i/16)*16-(i%16)*15; - if(line>=0 && line height ? width : height); - if (random() & 1) - inc = -inc; - for (i = (inc > 0 ? 0 : full); - (inc > 0 ? i < full : i > 0); - i += inc) { - XFillArc(dpy, window, gc, - (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (i+start) % full, inc); - XFlush (dpy); - usleep (delay*granularity); - } - num_lines = 0; - } - break; - - case 7: /* three-circle wipe */ - { - int full = 360 * 64; - int q = full / 3; - int inc = full / 180; - int start = random() % q; - int rad = (width > height ? width : height); - if (random() & 1) - inc = -inc; - for (i = (inc > 0 ? 0 : q); - (inc > 0 ? i < q : i > 0); - i += inc) { - XFillArc(dpy, window, gc, - (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (i+start) % full, inc); - XFillArc(dpy, window, gc, - (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (i+start+q) % full, inc); - XFillArc(dpy, window, gc, - (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (i+start+q+q) % full, inc); - XFlush (dpy); - usleep (delay*granularity); - } - num_lines = 0; - } - break; - - default: - abort(); - break; - } - - for (i = 0; i < num_lines; i++) - { - if(clear_lines[i] < height) - XDrawLine (dpy, window, gc, 0, clear_lines[i], width, - clear_lines[i]); - else - XDrawLine (dpy, window, gc, clear_lines[i]-height, 0, - clear_lines[i]-height, height); - XFlush (dpy); - if ((i % granularity) == 0) - { - usleep (delay*granularity); - } - } - - free(clear_lines); - } - - XClearWindow (dpy, window); - XSync(dpy, False); -} - - -void -erase_full_window(Display *dpy, Window window) +extern char *progname; + +#undef countof +#define countof(x) (sizeof(x)/sizeof(*(x))) + +typedef void (*Eraser) (eraser_state *); + +struct eraser_state { + Display *dpy; + Window window; + GC fg_gc, bg_gc; + int width, height; + Eraser fn; + + double start_time, stop_time; + double ratio, prev_ratio; + + /* data for random_lines, venetian, random_squares */ + Bool horiz_p; + Bool flip_p; + int nlines, *lines; + + /* data for triple_wipe, quad_wipe */ + Bool flip_x, flip_y; + + /* data for circle_wipe, three_circle_wipe */ + int start; + + /* data for random_squares */ + int cols; + +}; + + +static double +double_time (void) +{ + struct timeval now; +# ifdef GETTIMEOFDAY_TWO_ARGS + struct timezone tzp; + gettimeofday(&now, &tzp); +# else + gettimeofday(&now); +# endif + + return (now.tv_sec + ((double) now.tv_usec * 0.000001)); +} + + +static void +random_lines (eraser_state *st) +{ + int i; + + if (! st->lines) /* first time */ + { + st->horiz_p = (random() & 1); + st->nlines = (st->horiz_p ? st->height : st->width); + st->lines = (int *) calloc (st->nlines, sizeof(*st->lines)); + + for (i = 0; i < st->nlines; i++) /* every line */ + st->lines[i] = i; + + for (i = 0; i < st->nlines; i++) /* shuffle */ + { + int t, r; + t = st->lines[i]; + r = random() % st->nlines; + st->lines[i] = st->lines[r]; + st->lines[r] = t; + } + } + + for (i = st->nlines * st->prev_ratio; + i < st->nlines * st->ratio; + i++) + { + if (st->horiz_p) + XDrawLine (st->dpy, st->window, st->bg_gc, + 0, st->lines[i], st->width, st->lines[i]); + else + XDrawLine (st->dpy, st->window, st->bg_gc, + st->lines[i], 0, st->lines[i], st->height); + } + + if (st->ratio >= 1.0) + { + free (st->lines); + st->lines = 0; + } +} + + +static void +venetian (eraser_state *st) +{ + int i; + if (st->ratio == 0.0) + { + int j = 0; + st->horiz_p = (random() & 1); + st->flip_p = (random() & 1); + st->nlines = (st->horiz_p ? st->height : st->width); + st->lines = (int *) calloc (st->nlines, sizeof(*st->lines)); + + for (i = 0; i < st->nlines * 2; i++) + { + int line = ((i / 16) * 16) - ((i % 16) * 15); + if (line >= 0 && line < st->nlines) + st->lines[j++] = (st->flip_p ? st->nlines - line : line); + } + } + + + for (i = st->nlines * st->prev_ratio; + i < st->nlines * st->ratio; + i++) + { + if (st->horiz_p) + XDrawLine (st->dpy, st->window, st->bg_gc, + 0, st->lines[i], st->width, st->lines[i]); + else + XDrawLine (st->dpy, st->window, st->bg_gc, + st->lines[i], 0, st->lines[i], st->height); + } + + if (st->ratio >= 1.0) + { + free (st->lines); + st->lines = 0; + } +} + + +static void +triple_wipe (eraser_state *st) +{ + int i; + if (st->ratio == 0.0) + { + st->flip_x = random() & 1; + st->flip_y = random() & 1; + st->nlines = st->width + (st->height / 2); + st->lines = (int *) calloc (st->nlines, sizeof(*st->lines)); + + for (i = 0; i < st->width / 2; i++) + st->lines[i] = i * 2 + st->height; + for (i = 0; i < st->height / 2; i++) + st->lines[i + st->width / 2] = i*2; + for (i = 0; i < st->width / 2; i++) + st->lines[i + st->width / 2 + st->height / 2] = + st->width - i * 2 - (st->width % 2 ? 0 : 1) + st->height; + } + + for (i = st->nlines * st->prev_ratio; + i < st->nlines * st->ratio; + i++) + { + int x, y, x2, y2; + + if (st->lines[i] < st->height) + x = 0, y = st->lines[i], x2 = st->width, y2 = y; + else + x = st->lines[i]-st->height, y = 0, x2 = x, y2 = st->height; + + if (st->flip_x) + x = st->width - x, x2 = st->width - x2; + if (st->flip_y) + y = st->height - y, y2 = st->height - y2; + + XDrawLine (st->dpy, st->window, st->bg_gc, x, y, x2, y2); + } + + if (st->ratio >= 1.0) + { + free (st->lines); + st->lines = 0; + } +} + + +static void +quad_wipe (eraser_state *st) +{ + int i; + if (st->ratio == 0.0) + { + st->flip_x = random() & 1; + st->flip_y = random() & 1; + st->nlines = st->width + st->height; + st->lines = (int *) calloc (st->nlines, sizeof(*st->lines)); + + for (i = 0; i < st->nlines/4; i++) + { + st->lines[i*4] = i*2; + st->lines[i*4+1] = st->height - i*2 - (st->height % 2 ? 0 : 1); + st->lines[i*4+2] = st->height + i*2; + st->lines[i*4+3] = st->height + st->width - i*2 + - (st->width % 2 ? 0 : 1); + } + } + + for (i = st->nlines * st->prev_ratio; + i < st->nlines * st->ratio; + i++) + { + int x, y, x2, y2; + if (st->lines[i] < st->height) + x = 0, y = st->lines[i], x2 = st->width, y2 = y; + else + x = st->lines[i] - st->height, y = 0, x2 = x, y2 = st->height; + + if (st->flip_x) + x = st->width-x, x2 = st->width-x2; + if (st->flip_y) + y = st->height-y, y2 = st->height-y2; + + XDrawLine (st->dpy, st->window, st->bg_gc, x, y, x2, y2); + } + + if (st->ratio >= 1.0) + { + free (st->lines); + st->lines = 0; + } +} + + +static void +circle_wipe (eraser_state *st) +{ + int rad = (st->width > st->height ? st->width : st->height); + int max = 360 * 64; + int th, oth; + + if (st->ratio == 0.0) + { + st->flip_p = random() & 1; + st->start = random() % max; + } + + th = max * st->ratio; + oth = max * st->prev_ratio; + if (st->flip_p) + { + th = max - th; + oth = max - oth; + } + XFillArc (st->dpy, st->window, st->bg_gc, + (st->width / 2) - rad, + (st->height / 2) - rad, + rad*2, rad*2, + (st->start + oth) % max, + th-oth); +} + + +static void +three_circle_wipe (eraser_state *st) +{ + int rad = (st->width > st->height ? st->width : st->height); + int max = 360 * 64; + int th, oth; + int i; + + if (st->ratio == 0.0) + st->start = random() % max; + + th = max/6 * st->ratio; + oth = max/6 * st->prev_ratio; + + for (i = 0; i < 3; i++) + { + int off = i * max / 3; + XFillArc (st->dpy, st->window, st->bg_gc, + (st->width / 2) - rad, + (st->height / 2) - rad, + rad*2, rad*2, + (st->start + off + oth) % max, + th-oth); + XFillArc (st->dpy, st->window, st->bg_gc, + (st->width / 2) - rad, + (st->height / 2) - rad, + rad*2, rad*2, + (st->start + off - oth) % max, + oth-th); + } +} + + +static void +squaretate (eraser_state *st) { + int max = ((st->width > st->height ? st->width : st->height) * 2); + XPoint points [3]; + int i = max * st->ratio; + + if (st->ratio == 0.0) + st->flip_p = random() & 1; + +# define DRAW() \ + if (st->flip_p) { \ + points[0].x = st->width - points[0].x; \ + points[1].x = st->width - points[1].x; \ + points[2].x = st->width - points[2].x; \ + } \ + XFillPolygon (st->dpy, st->window, st->bg_gc, \ + points, 3, Convex, CoordModeOrigin) + + points[0].x = 0; + points[0].y = 0; + points[1].x = st->width; + points[1].y = 0; + points[2].x = 0; + points[2].y = points[0].y + ((i * st->height) / max); + DRAW(); + + points[0].x = 0; + points[0].y = 0; + points[1].x = 0; + points[1].y = st->height; + points[2].x = ((i * st->width) / max); + points[2].y = st->height; + DRAW(); + + points[0].x = st->width; + points[0].y = st->height; + points[1].x = 0; + points[1].y = st->height; + points[2].x = st->width; + points[2].y = st->height - ((i * st->height) / max); + DRAW(); + + points[0].x = st->width; + points[0].y = st->height; + points[1].x = st->width; + points[1].y = 0; + points[2].x = st->width - ((i * st->width) / max); + points[2].y = 0; + DRAW(); +# undef DRAW +} + + +static void +fizzle (eraser_state *st) +{ + XPoint *points; + int chunk = 20000; + int npoints = st->width * st->height * 4; + npoints *= (st->ratio - st->prev_ratio); + + points = (XPoint *) malloc (chunk * sizeof(*points)); + if (! points) return; + + while (npoints > 0) + { + int remain = (chunk > npoints ? npoints : chunk); + int i; + for (i = 0; i < remain; i++) + { + int r = random(); + points[i].x = r % st->width; + points[i].y = (r >> 16) % st->height; + } + XDrawPoints (st->dpy, st->window, st->bg_gc, + points, remain, CoordModeOrigin); + npoints -= remain; + } + free (points); +} + + +static void +spiral (eraser_state *st) +{ + int max_radius = (st->width > st->height ? st->width : st->height) * 0.7; + int loops = 10; + float max_th = M_PI * 2 * loops; + int i; + int steps = 360 * loops / 4; + float off; + + if (st->ratio == 0.0) + { + st->flip_p = random() & 1; + st->start = random() % 360; + } + + off = st->start * M_PI / 180; + + for (i = steps * st->prev_ratio; + i < steps * st->ratio; + i++) + { + float th1 = i * max_th / steps; + float th2 = (i+1) * max_th / steps; + int r1 = i * max_radius / steps; + int r2 = (i+1) * max_radius / steps; + XPoint points[3]; + + if (st->flip_p) + { + th1 = max_th - th1; + th2 = max_th - th2; + } + + points[0].x = st->width / 2; + points[0].y = st->height / 2; + points[1].x = points[0].x + r1 * cos (off + th1); + points[1].y = points[0].y + r1 * sin (off + th1); + points[2].x = points[0].x + r2 * cos (off + th2); + points[2].y = points[0].y + r2 * sin (off + th2); +/* XFillRectangle(st->dpy, st->window, st->fg_gc,0,0,st->width, st->height);*/ + XFillPolygon (st->dpy, st->window, st->bg_gc, + points, 3, Convex, CoordModeOrigin); + } +} + + +static void +random_squares (eraser_state *st) +{ + int i, size, rows; + + if (st->ratio == 0.0) + { + st->cols = 10 + random() % 30; + size = st->width / st->cols; + rows = (st->height / size) + 1; + st->nlines = st->cols * rows; + st->lines = (int *) calloc (st->nlines, sizeof(*st->lines)); + + for (i = 0; i < st->nlines; i++) /* every square */ + st->lines[i] = i; + + for (i = 0; i < st->nlines; i++) /* shuffle */ + { + int t, r; + t = st->lines[i]; + r = random() % st->nlines; + st->lines[i] = st->lines[r]; + st->lines[r] = t; + } + } + + size = st->width / st->cols; + rows = (st->height / size) + 1; + + for (i = st->nlines * st->prev_ratio; + i < st->nlines * st->ratio; + i++) + { + int x = st->lines[i] % st->cols; + int y = st->lines[i] / st->cols; + XFillRectangle (st->dpy, st->window, st->bg_gc, + st->width * x / st->cols, + st->height * y / rows, + size+1, size+1); + } + + if (st->ratio >= 1.0) + { + free (st->lines); + st->lines = 0; + } +} + + +/* I first saw something like this, albeit in reverse, in an early Tetris + implementation for the Mac. + -- Torbjörn Andersson + */ +static void +slide_lines (eraser_state *st) +{ + int max = st->width * 1.1; + int nlines = 40; + int h = st->height / nlines; + int y, step; + int tick = 0; + + if (h < 10) + h = 10; + + step = (max * st->ratio) - (max * st->prev_ratio); + if (step <= 0) + step = 1; + + for (y = 0; y < st->height; y += h) + { + if (tick & 1) + { + XCopyArea (st->dpy, st->window, st->window, st->fg_gc, + 0, y, st->width-step, h, step, y); + XFillRectangle (st->dpy, st->window, st->bg_gc, + 0, y, step, h); + } + else + { + XCopyArea (st->dpy, st->window, st->window, st->fg_gc, + step, y, st->width-step, h, 0, y); + XFillRectangle (st->dpy, st->window, st->bg_gc, + st->width-step, y, step, h); + } + + tick++; + } +} + + +/* from Frederick Roeber */ +static void +losira (eraser_state *st) +{ + double mode1 = 0.55; + double mode2 = mode1 + 0.30; + double mode3 = 1.0; + int radius = 10; + + if (st->ratio < mode1) /* squeeze from the sides */ + { + double ratio = st->ratio / mode1; + double prev_ratio = st->prev_ratio / mode1; + int max = st->width / 2; + int step = (max * ratio) - (max * prev_ratio); + + if (step <= 0) + step = 1; + + /* pull from left */ + XCopyArea (st->dpy, st->window, st->window, st->fg_gc, + 0, 0, max - step, st->height, step, 0); + XFillRectangle (st->dpy, st->window, st->bg_gc, + 0, 0, max * ratio, st->height); + + /* pull from right */ + XCopyArea (st->dpy, st->window, st->window, st->fg_gc, + max+step, 0, max - step, st->height, max, 0); + XFillRectangle (st->dpy, st->window, st->bg_gc, + max + max*(1-ratio), 0, max, st->height); + + /* expand white from center */ + XFillRectangle (st->dpy, st->window, st->fg_gc, + max - (radius * ratio), 0, + radius * ratio * 2, st->height); + } + else if (st->ratio < mode2) /* squeeze from the top/bottom */ + { + double ratio = (st->ratio - mode1) / (mode2 - mode1); + double prev_ratio = (st->prev_ratio - mode1) / (mode2 - mode1); + int max = st->height / 2; + int step = (max * ratio) - (max * prev_ratio); + + if (step <= 0) + step = 1; + + /* fill middle */ + XFillRectangle (st->dpy, st->window, st->fg_gc, + st->width/2 - radius, + max * ratio, + radius*2, st->height * (1 - ratio)); + + /* fill left and right */ + XFillRectangle (st->dpy, st->window, st->bg_gc, + 0, 0, st->width/2 - radius, st->height); + XFillRectangle (st->dpy, st->window, st->bg_gc, + st->width/2 + radius, 0, st->width/2, st->height); + + /* fill top and bottom */ + XFillRectangle (st->dpy, st->window, st->bg_gc, + 0, 0, st->width, max * ratio); + XFillRectangle (st->dpy, st->window, st->bg_gc, + 0, st->height - (max * ratio), + st->width, max); + + /* cap top */ + XFillArc (st->dpy, st->window, st->fg_gc, + st->width/2 - radius, + max * ratio - radius, + radius*2, radius*2, + 0, 180*64); + + /* cap bottom */ + XFillArc (st->dpy, st->window, st->fg_gc, + st->width/2 - radius, + st->height - (max * ratio + radius), + radius*2, radius*2, + 180*64, 180*64); + } + else /* starburst */ + { + double ratio = (st->ratio - mode2) / (mode3 - mode2); + double r2 = ratio * radius * 4; + XArc arc[9]; + int i; + int angle = 360*64/countof(arc); + + for (i = 0; i < countof(arc); i++) + { + double th; + arc[i].angle1 = angle * i; + arc[i].angle2 = angle; + arc[i].width = radius*2 * (1 + ratio); + arc[i].height = radius*2 * (1 + ratio); + arc[i].x = st->width / 2 - radius; + arc[i].y = st->height / 2 - radius; + + th = ((arc[i].angle1 + (arc[i].angle2 / 2)) / 64.0 / 180 * M_PI); + + arc[i].x += r2 * cos (th); + arc[i].y -= r2 * sin (th); + } + + XFillRectangle (st->dpy, st->window, st->bg_gc, + 0, 0, st->width, st->height); + XFillArcs (st->dpy, st->window, st->fg_gc, arc, countof(arc)); + } +} + + +static Eraser erasers[] = { + random_lines, + venetian, + triple_wipe, + quad_wipe, + circle_wipe, + three_circle_wipe, + squaretate, + fizzle, + spiral, + random_squares, + slide_lines, + losira, +}; + + +static eraser_state * +eraser_init (Display *dpy, Window window) +{ + eraser_state *st = (eraser_state *) calloc (1, sizeof(*st)); XWindowAttributes xgwa; XGCValues gcv; - GC erase_gc; - XColor black; - int erase_speed = get_integer_resource("eraseSpeed", "Integer"); - int erase_mode = get_integer_resource("eraseMode", "Integer"); + unsigned long fg, bg; + double duration; + int which; + char *s; + + st->dpy = dpy; + st->window = window; + XGetWindowAttributes (dpy, window, &xgwa); - black.flags = DoRed|DoGreen|DoBlue; - black.red = black.green = black.blue = 0; - XAllocColor(dpy, xgwa.colormap, &black); - gcv.foreground = black.pixel; - erase_gc = XCreateGC (dpy, window, GCForeground, &gcv); - erase_window (dpy, window, erase_gc, xgwa.width, xgwa.height, - erase_mode, erase_speed); - XFreeColors(dpy, xgwa.colormap, &black.pixel, 1, 0); - XFreeGC(dpy, erase_gc); + st->width = xgwa.width; + st->height = xgwa.height; + + bg = get_pixel_resource (dpy, xgwa.colormap, "background", "Background"); + fg = get_pixel_resource (dpy, xgwa.colormap, "foreground", "Foreground"); + + gcv.foreground = fg; + gcv.background = bg; + st->fg_gc = XCreateGC (dpy, window, GCForeground|GCBackground, &gcv); + gcv.foreground = bg; + gcv.background = fg; + st->bg_gc = XCreateGC (dpy, window, GCForeground|GCBackground, &gcv); + +# ifdef HAVE_COCOA + /* Pretty much all of these leave turds if AA is on. */ + jwxyz_XSetAntiAliasing (st->dpy, st->fg_gc, False); + jwxyz_XSetAntiAliasing (st->dpy, st->bg_gc, False); +# endif + + s = get_string_resource (dpy, "eraseMode", "Integer"); + if (!s || !*s) + which = -1; + else + which = get_integer_resource(dpy, "eraseMode", "Integer"); + + if (which < 0 || which >= countof(erasers)) + which = random() % countof(erasers); + st->fn = erasers[which]; + + duration = get_float_resource (dpy, "eraseSeconds", "Float"); + if (duration < 0.1 || duration > 10) + duration = 1; + + st->start_time = double_time(); + st->stop_time = st->start_time + duration; + + XSync (st->dpy, False); + + return st; +} + + +static Bool +eraser_draw (eraser_state *st, Bool first_p) +{ + double now = (first_p ? st->start_time : double_time()); + double duration = st->stop_time - st->start_time; + + st->prev_ratio = st->ratio; + st->ratio = (now - st->start_time) / duration; + + if (st->ratio > 1.0) + st->ratio = 1.0; + + st->fn (st); + XSync (st->dpy, False); + + return (st->ratio < 1.0); +} + +static void +eraser_free (eraser_state *st) +{ + XClearWindow (st->dpy, st->window); + XFreeGC (st->dpy, st->fg_gc); + XFreeGC (st->dpy, st->bg_gc); + free (st); +} + +eraser_state * +erase_window (Display *dpy, Window window, eraser_state *st) +{ + Bool first_p = False; + if (! st) + { + first_p = True; + st = eraser_init (dpy, window); + } + if (! eraser_draw (st, first_p)) + { + eraser_free (st); + st = 0; + } + return st; }