X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?p=xscreensaver;a=blobdiff_plain;f=utils%2Ferase.c;h=bd7a345d1d74cec162d9431286d73d17cf615778;hp=f3d6de8b49ebc8942972838a40b5fb846f8c7fe2;hb=3c58fb6311db49c46f1670922933b27c6ea0c065;hpb=585e1a6717d1dd9b90fbb53acaaae82106354d33 diff --git a/utils/erase.c b/utils/erase.c index f3d6de8b..bd7a345d 100644 --- a/utils/erase.c +++ b/utils/erase.c @@ -1,8 +1,18 @@ /* 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 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" @@ -10,21 +20,47 @@ #include "usleep.h" #include "resources.h" +extern char *progname; + #undef countof #define countof(x) (sizeof(x)/sizeof(*(x))) +#define LITTLE_NAP 5000 /* 1/200th sec */ + typedef void (*Eraser) (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity); + int width, int height, int total_msecs); + + +static unsigned long +millitime (void) +{ + struct timeval tt; +# ifdef GETTIMEOFDAY_TWO_ARGS + struct timezone tz; + gettimeofday (&tt, &tz); +# else + gettimeofday (&tt); +# endif + return (tt.tv_sec * 1000) + (tt.tv_usec / 1000); +} static void random_lines (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { + int granularity = 50; + Bool horiz_p = (random() & 1); int max = (horiz_p ? height : width); int *lines = (int *) calloc(max, sizeof(*lines)); + int oi = -1; int i; + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; for (i = 0; i < max; i++) lines[i] = i; @@ -38,32 +74,57 @@ random_lines (Display *dpy, Window window, GC gc, lines[r] = t; } - for (i = 0; i < max; i++) - { - if (horiz_p) - XDrawLine (dpy, window, gc, 0, lines[i], width, lines[i]); + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + + i /= granularity; + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } else - XDrawLine (dpy, window, gc, lines[i], 0, lines[i], height); + { + int j; + for (j = 0; j < granularity; j++) + { + int ii = i * granularity + j; + if (horiz_p) + XDrawLine (dpy, window, gc, 0, lines[ii], width, lines[ii]); + else + XDrawLine (dpy, window, gc, lines[ii], 0, lines[ii], height); + hits++; + } + XSync (dpy, False); + } - XSync (dpy, False); - if (delay > 0 && ((i % granularity) == 0)) - usleep (delay * granularity); + oi = i; + tick = millitime(); } + free(lines); } static void venetian (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { Bool horiz_p = (random() & 1); Bool flip_p = (random() & 1); int max = (horiz_p ? height : width); int *lines = (int *) calloc(max, sizeof(*lines)); int i, j; + int oi = -1; - granularity /= 6; + unsigned long start_tick = millitime(); + unsigned long end_tick = (start_tick + + (1.5 * total_msecs)); /* this one needs more */ + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; j = 0; for (i = 0; i < max*2; i++) @@ -73,16 +134,31 @@ venetian (Display *dpy, Window window, GC gc, lines[j++] = (flip_p ? max - line : line); } - for (i = 0; i < max; i++) - { - if (horiz_p) - XDrawLine (dpy, window, gc, 0, lines[i], width, lines[i]); + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } else - XDrawLine (dpy, window, gc, lines[i], 0, lines[i], height); + { + int k; + for (k = oi; k <= i; k++) + { + if (horiz_p) + XDrawLine(dpy,window, gc, 0, lines[k], width, lines[k]); + else + XDrawLine(dpy,window, gc, lines[k], 0, lines[k], height); + hits++; + } + XSync (dpy, False); + } - XSync (dpy, False); - if (delay > 0 && ((i % granularity) == 0)) - usleep (delay * granularity); + oi = i; + tick = millitime(); } free(lines); } @@ -90,13 +166,20 @@ venetian (Display *dpy, Window window, GC gc, static void triple_wipe (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { Bool flip_x = random() & 1; Bool flip_y = random() & 1; int max = width + (height / 2); int *lines = (int *)calloc(max, sizeof(int)); int i; + int oi = -1; + + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; for(i = 0; i < width/2; i++) lines[i] = i*2+height; @@ -105,25 +188,39 @@ triple_wipe (Display *dpy, Window window, GC gc, for(i = 0; i < width/2; i++) lines[i+width/2+height/2] = width-i*2-(width%2?0:1)+height; - granularity /= 6; - - for (i = 0; i < max; i++) - { + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); int x, y, x2, y2; - if (lines[i] < height) - x = 0, y = lines[i], x2 = width, y2 = y; - else - x = lines[i]-height, y = 0, x2 = x, y2 = height; - if (flip_x) - x = width-x, x2 = width-x2; - if (flip_y) - y = height-y, y2 = height-y2; + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int k; + for (k = oi; k <= i; k++) + { + if (lines[k] < height) + x = 0, y = lines[k], x2 = width, y2 = y; + else + x = lines[k]-height, y = 0, x2 = x, y2 = height; + + if (flip_x) + x = width-x, x2 = width-x2; + if (flip_y) + y = height-y, y2 = height-y2; + + XDrawLine (dpy, window, gc, x, y, x2, y2); + hits++; + } + XSync (dpy, False); + } - XDrawLine (dpy, window, gc, x, y, x2, y2); - XSync (dpy, False); - if (delay > 0 && ((i % granularity) == 0)) - usleep (delay*granularity); + oi = i; + tick = millitime(); } free(lines); } @@ -131,15 +228,20 @@ triple_wipe (Display *dpy, Window window, GC gc, static void quad_wipe (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { Bool flip_x = random() & 1; Bool flip_y = random() & 1; int max = width + height; int *lines = (int *)calloc(max, sizeof(int)); int i; + int oi = -1; - granularity /= 3; + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; for (i = 0; i < max/4; i++) { @@ -149,24 +251,41 @@ quad_wipe (Display *dpy, Window window, GC gc, lines[i*4+3] = height+width-i*2-(width%2?0:1); } - for (i = 0; i < max; i++) - { - int x, y, x2, y2; - if (lines[i] < height) - x = 0, y = lines[i], x2 = width, y2 = y; - else - x = lines[i]-height, y = 0, x2 = x, y2 = height; + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); - if (flip_x) - x = width-x, x2 = width-x2; - if (flip_y) - y = height-y, y2 = height-y2; + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int k; + for (k = oi; k <= i; k++) + { + int x, y, x2, y2; + if (lines[k] < height) + x = 0, y = lines[k], x2 = width, y2 = y; + else + x = lines[k]-height, y = 0, x2 = x, y2 = height; + + if (flip_x) + x = width-x, x2 = width-x2; + if (flip_y) + y = height-y, y2 = height-y2; + + XDrawLine (dpy, window, gc, x, y, x2, y2); + hits++; + } + XSync (dpy, False); + } - XDrawLine (dpy, window, gc, x, y, x2, y2); - XSync (dpy, False); - if (delay > 0 && ((i % granularity) == 0)) - usleep (delay*granularity); + oi = i; + tick = millitime(); } + free(lines); } @@ -174,71 +293,131 @@ quad_wipe (Display *dpy, Window window, GC gc, static void circle_wipe (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { - int full = 360 * 64; - int inc = full / 64; - int start = random() % full; + int max = 360 * 64; + int start = random() % max; int rad = (width > height ? width : height); - int i; - if (random() & 1) - inc = -inc; - for (i = (inc > 0 ? 0 : full); - (inc > 0 ? i < full : i > 0); - i += inc) + int flip_p = random() & 1; + int oth; + + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + + int hits = 0; + int nonhits = 0; + + oth = (flip_p ? max : 0); + while (tick < end_tick) { - XFillArc(dpy, window, gc, - (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (i+start) % full, inc); - XFlush (dpy); - usleep (delay*granularity); + int th = (max * (tick - start_tick)) / (end_tick - start_tick); + if (flip_p) + th = (360 * 64) - th; + + if (th == oth) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + (start+oth)%(360*64), + (th-oth)); + hits++; + XSync (dpy, False); + } + + oth = th; + tick = millitime(); } } static void three_circle_wipe (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { - int i; - int full = 360 * 64; - int q = full / 6; - int q2 = q * 2; - int inc = full / 240; - int start = random() % q; + int max = (360 * 64) / 6; + int start = random() % max; int rad = (width > height ? width : height); + int oth; - for (i = 0; i < q; i += inc) - { - XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (start+i) % full, inc); - XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (start-i) % full, -inc); + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + + int hits = 0; + int nonhits = 0; - XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (start+q2+i) % full, inc); - XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (start+q2-i) % full, -inc); + oth = 0; + while (tick < end_tick) + { + int th = (max * (tick - start_tick)) / (end_tick - start_tick); - XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (start+q2+q2+i) % full, inc); - XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2, - (start+q2+q2-i) % full, -inc); + if (th == oth) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int off = 0; + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + (start+off+oth)%(360*64), + (th-oth)); + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + ((start+off-oth))%(360*64), + -(th-oth)); + + off += max + max; + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + (start+off+oth)%(360*64), + (th-oth)); + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + ((start+off-oth))%(360*64), + -(th-oth)); + + off += max + max; + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + (start+off+oth)%(360*64), + (th-oth)); + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + ((start+off-oth))%(360*64), + -(th-oth)); + + hits++; + XSync (dpy, False); + } - XSync (dpy, False); - usleep (delay*granularity); + oth = th; + tick = millitime(); } } static void squaretate (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { - int steps = (((width > height ? width : width) * 2) / granularity); - int i; + int max = ((width > height ? width : width) * 2); + int oi = -1; Bool flip = random() & 1; + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; + #define DRAW() \ if (flip) { \ points[0].x = width-points[0].x; \ @@ -246,45 +425,56 @@ squaretate (Display *dpy, Window window, GC gc, points[2].x = width-points[2].x; } \ XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin) - for (i = 0; i < steps; i++) + while (tick < end_tick) { - XPoint points [3]; - points[0].x = 0; - points[0].y = 0; - points[1].x = width; - points[1].y = 0; - points[2].x = 0; - points[2].y = points[0].y + ((i * height) / steps); - DRAW(); - - points[0].x = 0; - points[0].y = 0; - points[1].x = 0; - points[1].y = height; - points[2].x = ((i * width) / steps); - points[2].y = height; - DRAW(); - - points[0].x = width; - points[0].y = height; - points[1].x = 0; - points[1].y = height; - points[2].x = width; - points[2].y = height - ((i * height) / steps); - DRAW(); - - points[0].x = width; - points[0].y = height; - points[1].x = width; - points[1].y = 0; - points[2].x = width - ((i * width) / steps); - points[2].y = 0; - DRAW(); - - XSync (dpy, True); - if (delay > 0) - usleep (delay * granularity); - } + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + XPoint points [3]; + points[0].x = 0; + points[0].y = 0; + points[1].x = width; + points[1].y = 0; + points[2].x = 0; + points[2].y = points[0].y + ((i * height) / max); + DRAW(); + + points[0].x = 0; + points[0].y = 0; + points[1].x = 0; + points[1].y = height; + points[2].x = ((i * width) / max); + points[2].y = height; + DRAW(); + + points[0].x = width; + points[0].y = height; + points[1].x = 0; + points[1].y = height; + points[2].x = width; + points[2].y = height - ((i * height) / max); + DRAW(); + + points[0].x = width; + points[0].y = height; + points[1].x = width; + points[1].y = 0; + points[2].x = width - ((i * width) / max); + points[2].y = 0; + DRAW(); + hits++; + XSync (dpy, True); + } + + oi = i; + tick = millitime(); + } #undef DRAW } @@ -292,19 +482,29 @@ squaretate (Display *dpy, Window window, GC gc, /* from Frederick Roeber */ static void fizzle (Display *dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { /* These dimensions must be prime numbers. They should be roughly the square root of the width and height. */ -# define BX 31 +# define BX 41 # define BY 31 # define SIZE (BX*BY) int array[SIZE]; int i, j; + int oi = -1; XPoint *skews; + XPoint points[250]; + int npoints = 0; int nx, ny; + unsigned long start_tick = millitime(); + unsigned long end_tick = (start_tick + + (2.5 * total_msecs)); /* this one needs more */ + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; + /* Distribute the numbers [0,SIZE) randomly in the array */ { int indices[SIZE]; @@ -337,66 +537,91 @@ fizzle (Display *dpy, Window window, GC gc, # define SKEWX(cx, cy) (((XPoint *)0 == skews)?0:skews[cy*nx + cx].x) # define SKEWY(cx, cy) (((XPoint *)0 == skews)?0:skews[cy*nx + cx].y) - for( i = 0; i < SIZE; i++ ) { - int x = array[i] % BX; - int y = array[i] / BX; - + while (tick < end_tick) { - int iy, cy; - for( iy = 0, cy = 0; iy < height; iy += BY, cy++ ) { - int ix, cx; - for( ix = 0, cx = 0; ix < width; ix += BX, cx++ ) { - int xx = ix + (SKEWX(cx, cy) + x*((cx%(BX-1))+1))%BX; - int yy = iy + (SKEWY(cx, cy) + y*((cy%(BY-1))+1))%BY; - if (xx < width && yy < height) - XDrawPoint(dpy, window, gc, xx, yy); + int i = (SIZE * (tick - start_tick)) / (end_tick - start_tick); + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; } - } + else + { + int j; + for (j = oi; j < i; j++) + { + int x = array[j] % BX; + int y = array[j] / BX; + int iy, cy; + for (iy = 0, cy = 0; iy < height; iy += BY, cy++) + { + int ix, cx; + for( ix = 0, cx = 0; ix < width; ix += BX, cx++ ) { + int xx = ix + (SKEWX(cx, cy) + x*((cx%(BX-1))+1))%BX; + int yy = iy + (SKEWY(cx, cy) + y*((cy%(BY-1))+1))%BY; + if (xx < width && yy < height) + { + points[npoints].x = xx; + points[npoints].y = yy; + if (++npoints == countof(points)) + { + XDrawPoints(dpy, window, gc, points, npoints, + CoordModeOrigin); + XSync (dpy, False); + npoints = 0; + } + } + } + } + } + hits++; + } + + oi = i; + tick = millitime(); } - if( (BX-1) == (i%BX) ) { + if (npoints > 100) + { + XDrawPoints(dpy, window, gc, points, npoints, CoordModeOrigin); XSync (dpy, False); - usleep (delay*granularity); + usleep (10000); } - } # undef SKEWX # undef SKEWY - - if( (XPoint *)0 != skews ) { - free(skews); - } - # undef BX # undef BY # undef SIZE + + if (skews) free(skews); } /* from Rick Campbell */ static void -spiral (Display *display, Window window, GC context, - int width, int height, int delay, int granularity) +spiral (Display *dpy, Window window, GC context, + int width, int height, int total_msecs) { -# define SPIRAL_ERASE_PI_2 (M_PI + M_PI) -# define SPIRAL_ERASE_LOOP_COUNT (10) -# define SPIRAL_ERASE_ARC_COUNT (360.0) -# define SPIRAL_ERASE_ANGLE_INCREMENT (SPIRAL_ERASE_PI_2 / \ -SPIRAL_ERASE_ARC_COUNT) -# define SPIRAL_ERASE_DELAY (0) + int granularity = 1; /* #### */ + double pi2 = (M_PI + M_PI); + int loop_count = 10; + int angle_step = 1000 / 8; /* disc granularity is 8 degrees */ + int max = pi2 * angle_step; double angle; int arc_limit; int arc_max_limit; int length_step; XPoint points [3]; + total_msecs *= 2.5; /* this one needs more */ + angle = 0.0; arc_limit = 1; - arc_max_limit = (int) (ceil (sqrt ((width * width) + (height * height))) - / 2.0); - length_step = ((arc_max_limit + SPIRAL_ERASE_LOOP_COUNT - 1) / - SPIRAL_ERASE_LOOP_COUNT); + arc_max_limit = (ceil (sqrt ((width * width) + (height * height))) / 2.0); + length_step = ((arc_max_limit + loop_count - 1) / loop_count); arc_max_limit += length_step; points [0].x = width / 2; points [0].y = height / 2; @@ -411,27 +636,65 @@ SPIRAL_ERASE_ARC_COUNT) { int arc_length = length_step; int length_base = arc_limit; - for (angle = 0.0; angle < SPIRAL_ERASE_PI_2; - angle += SPIRAL_ERASE_ANGLE_INCREMENT) + + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + (total_msecs / + (arc_max_limit / length_step)); + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; + int i = 0; + int oi = -1; + +#if 0 + int max2 = max / granularity; + while (i < max2) +#else + while (tick < end_tick) +#endif { - arc_length = length_base + ((length_step * angle) / - SPIRAL_ERASE_PI_2); - points [1].x = points [2].x; - points [1].y = points [2].y; - points [2].x = points [0].x + (int)(cos (angle) * arc_length); - points [2].y = points [0].y + (int)(sin (angle) * arc_length); - XFillPolygon (display, window, context, points, 3, Convex, - CoordModeOrigin); -# if (SPIRAL_ERASE_DELAY != 0) - usleep (SPIRAL_ERASE_DELAY); -# endif /* (SPIRAL_ERASE_DELAY != 0) */ + i = (max * (tick - start_tick)) / (end_tick - start_tick); + if (i > max) i = max; + + i /= granularity; + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int j, k; +#if 0 + for (k = oi; k <= i; k++) +#else + k = i; +#endif + { + for (j = 0; j < granularity; j++) + { + int ii = k * granularity + j; + angle = ii / (double) angle_step; + arc_length = length_base + ((length_step * angle) / pi2); + points [1].x = points [2].x; + points [1].y = points [2].y; + points [2].x = points [0].x + + (int)(cos(angle) * arc_length); + points [2].y = points [0].y + + (int)(sin(angle) * arc_length); + XFillPolygon (dpy, window, context, points, 3, Convex, + CoordModeOrigin); + hits++; + } + } + XSync (dpy, False); + } + + oi = i; + tick = millitime(); } } -# undef SPIRAL_ERASE_DELAY -# undef SPIRAL_ERASE_ANGLE_INCREMENT -# undef SPIRAL_ERASE_ARC_COUNT -# undef SPIRAL_ERASE_LOOP_COUNT -# undef SPIRAL_ERASE_PI_2 } @@ -443,14 +706,23 @@ SPIRAL_ERASE_ARC_COUNT) /* from David Bagley */ static void random_squares(Display * dpy, Window window, GC gc, - int width, int height, int delay, int granularity) + int width, int height, int total_msecs) { + int granularity = 20; + int randsize = MAX(1, MIN(width, height) / (16 + (random() % 32))); int max = (height / randsize + 1) * (width / randsize + 1); int *squares = (int *) calloc(max, sizeof (*squares)); int i; int columns = width / randsize + 1; /* Add an extra for roundoff */ + int oi = -1; + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; + for (i = 0; i < max; i++) squares[i] = i; @@ -463,16 +735,35 @@ random_squares(Display * dpy, Window window, GC gc, squares[r] = t; } - for (i = 0; i < max; i++) + while (tick < end_tick) { - XFillRectangle(dpy, window, gc, - (squares[i] % columns) * randsize, - (squares[i] / columns) * randsize, - randsize, randsize); - - XSync(dpy, False); - if (delay > 0 && ((i % granularity) == 0)) - usleep(delay * granularity); + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + + i /= granularity; + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int j; + for (j = 0; j < granularity; j++) + { + int ii = i * granularity + j; + + XFillRectangle(dpy, window, gc, + (squares[ii] % columns) * randsize, + (squares[ii] / columns) * randsize, + randsize, randsize); + hits++; + } + } + XSync (dpy, False); + + oi = i; + tick = millitime(); } free(squares); } @@ -481,51 +772,281 @@ random_squares(Display * dpy, Window window, GC gc, implementation for the Mac. -- Torbjörn Andersson */ +static void +slide_lines (Display *dpy, Window window, GC gc, + int width, int height, int total_msecs) +{ + int max = width; + int dy = MAX (10, height/40); + + int oi = 0; + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + total_msecs; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; + + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int y; + int tick = 0; + int from1 = oi; + int to1 = i; + int w = width-to1; + int from2 = width - oi - w; + int to2 = width - i - w; + + for (y = 0; y < height; y += dy) + { + if (++tick & 1) + { + XCopyArea (dpy, window, window, gc, from1, y, w, dy, to1, y); + XFillRectangle (dpy, window, gc, from1, y, to1-from1, dy); + } + else + { + XCopyArea (dpy, window, window, gc, from2, y, w, dy, to2, y); + XFillRectangle (dpy, window, gc, from2+w, y, to2-from2, dy); + } + } + + hits++; + XSync (dpy, False); + } + + oi = i; + tick = millitime(); + } +} + + +/* from Frederick Roeber */ static void -slide_lines (Display * dpy, Window window, GC gc, int width, int height, - int delay, int granularity) +losira (Display * dpy, Window window, GC gc, + int width, int height, int total_msecs) { - int slide_old_x, slide_new_x, clear_x; - int x, y, dx, dy; + XGCValues gcv; + XWindowAttributes wa; + XColor white; + GC white_gc; + XArc arc[2][8]; + double xx[8], yy[8], dx[8], dy[8]; + + int i; + int oi = 0; + + int max = width/2; + int max_off = MAX(1, max / 12); + + int msecs1 = (0.55 * total_msecs); + int msecs2 = (0.30 * total_msecs); + int msecs3 = (0.15 * total_msecs); + + unsigned long start_tick = millitime(); + unsigned long end_tick = start_tick + msecs1; + unsigned long tick = start_tick; + int hits = 0; + int nonhits = 0; + + XGetWindowAttributes(dpy, window, &wa); + white.flags = DoRed|DoGreen|DoBlue; + white.red = white.green = white.blue = 65535; + XAllocColor(dpy, wa.colormap, &white); + gcv.foreground = white.pixel; + white_gc = XCreateGC(dpy, window, GCForeground, &gcv); + + /* Squeeze in from the sides */ + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int off = (max_off * (tick - start_tick)) / (end_tick - start_tick); + + int from1 = oi; + int to1 = i; + int w = max - to1 - off/2 + 1; + int from2 = max+(to1-from1)+off/2; + int to2 = max+off/2; + + if (w < 0) + break; + + XCopyArea (dpy, window, window, gc, from1, 0, w, height, to1, 0); + XCopyArea (dpy, window, window, gc, from2, 0, w, height, to2, 0); + XFillRectangle (dpy, window, gc, from1, 0, (to1-from1), height); + XFillRectangle (dpy, window, gc, to2+w, 0, from2+w, height); + XFillRectangle (dpy, window, white_gc, max-off/2, 0, off, height); + hits++; + XSync(dpy, False); + } + + oi = i; + tick = millitime(); + } + + + XFillRectangle(dpy, window, white_gc, max-max_off/2, 0, max_off, height); + + /* Cap the top and bottom of the line */ + XFillRectangle(dpy, window, gc, max-max_off/2, 0, max_off, max_off/2); + XFillRectangle(dpy, window, gc, max-max_off/2, height-max_off/2, + max_off, max_off/2); + XFillArc(dpy, window, white_gc, max-max_off/2-1, 0, + max_off-1, max_off-1, 0, 180*64); + XFillArc(dpy, window, white_gc, max-max_off/2-1, height-max_off, + max_off-1, max_off-1, + 180*64, 360*64); + + XFillRectangle(dpy, window, gc, 0, 0, max-max_off/2, height); + XFillRectangle(dpy, window, gc, max+max_off/2-1, 0, max-max_off/2, height); + XSync(dpy, False); + + /* Collapse vertically */ + start_tick = millitime(); + end_tick = start_tick + msecs2; + tick = start_tick; + + max = height/2; + oi = 0; + while (tick < end_tick) + { + int i = (max * (tick - start_tick)) / (end_tick - start_tick); + int x = (width-max_off)/2; + int w = max_off; + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int off = (max_off * (tick - start_tick)) / (end_tick - start_tick); + + int from1 = oi; + int to1 = i; + int h = max - to1 - off/2; + int from2 = max+(to1-from1)+off/2; + int to2 = max+off/2; + + if (h < max_off/2) + break; + + XCopyArea (dpy, window, window, gc, x, from1, w, h, x, to1); + XCopyArea (dpy, window, window, gc, x, from2, w, h, x, to2); + XFillRectangle(dpy, window, gc, x, from1, w, (to1 - from1)); + XFillRectangle(dpy, window, gc, x, to2+h, w, (to2 - from2)); + hits++; + XSync(dpy, False); + } + + oi = i; + tick = millitime(); + } + + /* "This is Sci-Fi" */ + for( i = 0; i < 8; i++ ) { + arc[0][i].width = arc[0][i].height = max_off; + arc[1][i].width = arc[1][i].height = max_off; + arc[0][i].x = arc[1][i].x = width/2; + arc[0][i].y = arc[1][i].y = height/2; + xx[i] = (double)(width/2) - max_off/2; + yy[i] = (double)(height/2) - max_off/2; + } + + arc[0][0].angle1 = arc[1][0].angle1 = 0*64; arc[0][0].angle2 = arc[1][0].angle2 = 45*64; + arc[0][1].angle1 = arc[1][1].angle1 = 45*64; arc[0][1].angle2 = arc[1][1].angle2 = 45*64; + arc[0][2].angle1 = arc[1][2].angle1 = 90*64; arc[0][2].angle2 = arc[1][2].angle2 = 45*64; + arc[0][3].angle1 = arc[1][3].angle1 = 135*64; arc[0][3].angle2 = arc[1][3].angle2 = 45*64; + arc[0][4].angle1 = arc[1][4].angle1 = 180*64; arc[0][4].angle2 = arc[1][4].angle2 = 45*64; + arc[0][5].angle1 = arc[1][5].angle1 = 225*64; arc[0][5].angle2 = arc[1][5].angle2 = 45*64; + arc[0][6].angle1 = arc[1][6].angle1 = 270*64; arc[0][6].angle2 = arc[1][6].angle2 = 45*64; + arc[0][7].angle1 = arc[1][7].angle1 = 315*64; arc[0][7].angle2 = arc[1][7].angle2 = 45*64; + + for( i = 0; i < 8; i++ ) { + dx[i] = cos((i*45 + 22.5)/360 * 2*M_PI); + dy[i] = -sin((i*45 + 22.5)/360 * 2*M_PI); + } - /* This might need some tuning. The idea is to get sensible values no - matter what the size of the window. + gcv.line_width = 3; + XChangeGC(dpy, gc, GCLineWidth, &gcv); - Everything moves at constant speed. Should it accelerate instead? */ + XClearWindow (dpy, window); + XFillArc(dpy, window, white_gc, + width/2-max_off/2-1, height/2-max_off/2-1, + max_off-1, max_off-1, + 0, 360*64); + XDrawLine(dpy, window, gc, 0, height/2-1, width, height/2-1); + XDrawLine(dpy, window, gc, width/2-1, 0, width/2-1, height); + XDrawLine(dpy, window, gc, width/2-1-max_off, height/2-1-max_off, + width/2+max_off, height/2+max_off); + XDrawLine(dpy, window, gc, width/2+max_off, height/2-1-max_off, + width/2-1-max_off, height/2+max_off); - granularity *= 2; + XSync(dpy, False); - dy = MAX (1, height / granularity); - dx = MAX (1, width / 100); - for (x = 0; x < width; x += dx) + /* Fan out */ + start_tick = millitime(); + end_tick = start_tick + msecs3; + tick = start_tick; + oi = 0; + while (tick < end_tick) { - for (y = 0; y < height; y += dy) - { - if ((y / dy) & 1) - { - slide_old_x = x; - slide_new_x = x + dx; - clear_x = x; - } - else - { - slide_old_x = dx; - slide_new_x = 0; - clear_x = width - x - dx; - } - - XCopyArea (dpy, window, window, gc, slide_old_x, y, width - x - dx, - dy, slide_new_x, y); - XClearArea (dpy, window, clear_x, y, dx, dy, False); - } - - XSync(dpy, False); - usleep(delay * 3); + int i = (max_off * (tick - start_tick)) / (end_tick - start_tick); + + if (i == oi) + { + usleep (LITTLE_NAP); + nonhits++; + } + else + { + int j; + for (j = 0; j < 8; j++) + { + xx[j] += 2*dx[j]; + yy[j] += 2*dy[j]; + arc[(i+1)%2][j].x = xx[j]; + arc[(i+1)%2][j].y = yy[j]; + } + + XFillRectangle (dpy, window, gc, + (width-max_off*5)/2, (height-max_off*5)/2, + max_off*5, max_off*5); + XFillArcs(dpy, window, white_gc, arc[(i+1)%2], 8); + XSync(dpy, False); + hits++; + } + + oi = i; + tick = millitime(); } + + XSync (dpy, False); + + /*XFreeColors(dpy, wa.colormap, &white.pixel, 1, 0);*/ + XFreeGC(dpy, white_gc); } + + static Eraser erasers[] = { random_lines, venetian, @@ -535,23 +1056,32 @@ static Eraser erasers[] = { three_circle_wipe, squaretate, fizzle, - random_squares, spiral, + random_squares, slide_lines, + losira, }; -void -erase_window(Display *dpy, Window window, GC gc, - int width, int height, int mode, int delay) +static void +erase_window (Display *dpy, Window window, GC gc, + int width, int height, int mode, int total_msecs) { - int granularity = 25; + Bool verbose_p = False; + unsigned long start = millitime(); if (mode < 0 || mode >= countof(erasers)) mode = random() % countof(erasers); - (*(erasers[mode])) (dpy, window, gc, width, height, delay, granularity); + + (*(erasers[mode])) (dpy, window, gc, width, height, total_msecs); + + if (verbose_p) + fprintf(stderr, "%s: eraser %d time: %4.2f sec\n", + progname, mode, (millitime() - start) / 1000.0); + XClearWindow (dpy, window); XSync(dpy, False); + usleep (333333); /* 1/3 sec */ } @@ -562,14 +1092,18 @@ erase_full_window(Display *dpy, Window window) XGCValues gcv; GC erase_gc; XColor black; - int erase_speed, erase_mode; + int erase_msecs, erase_mode; char *s; - s = get_string_resource("eraseSpeed", "Integer"); + s = get_string_resource("eraseSeconds", "Integer"); if (s && *s) - erase_speed = get_integer_resource("eraseSpeed", "Integer"); + erase_msecs = 1000 * get_float_resource("eraseSeconds", "Float"); else - erase_speed = 400; + erase_msecs = 1000; + + if (erase_msecs < 10 || erase_msecs > 10000) + erase_msecs = 1000; + if (s) free(s); s = get_string_resource("eraseMode", "Integer"); @@ -586,51 +1120,7 @@ erase_full_window(Display *dpy, Window window) 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); + erase_mode, erase_msecs); XFreeColors(dpy, xgwa.colormap, &black.pixel, 1, 0); XFreeGC(dpy, erase_gc); } - - - -#if 0 -#include "screenhack.h" - -char *progclass = "Erase"; -char *defaults [] = { - 0 -}; - -XrmOptionDescRec options [] = {{0}}; -int options_size = 0; - -void -screenhack (dpy, window) - Display *dpy; - Window window; -{ - int delay = 500000; - XGCValues gcv; - GC gc; - XColor white; - XWindowAttributes xgwa; - XGetWindowAttributes (dpy, window, &xgwa); - white.flags = DoRed|DoGreen|DoBlue; - white.red = white.green = white.blue = 0xFFFF; - XAllocColor(dpy, xgwa.colormap, &white); - gcv.foreground = white.pixel; - gc = XCreateGC (dpy, window, GCForeground, &gcv); - - while (1) - { - XFillRectangle(dpy, window, gc, 0, 0, 1280, 1024); - XSync (dpy, False); - usleep (delay); - erase_full_window(dpy, window); - XSync (dpy, False); - usleep (delay); - - } -} - -#endif