X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=utils%2Ferase.c;fp=utils%2Ferase.c;h=c2c8de7b9da1520d9deed5873a910697cd02843f;hb=df7adbee81405e2849728a24b498ad2117784b1f;hp=0000000000000000000000000000000000000000;hpb=41fae2ad67bc37e31c4d967bae81e4f3f50fa55a;p=xscreensaver diff --git a/utils/erase.c b/utils/erase.c new file mode 100644 index 00000000..c2c8de7b --- /dev/null +++ b/utils/erase.c @@ -0,0 +1,586 @@ +/* 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!) + */ + +#include "utils.h" +#include "yarandom.h" +#include "usleep.h" +#include "resources.h" + +#undef countof +#define countof(x) (sizeof(x)/sizeof(*(x))) + +typedef void (*Eraser) (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity); + + +static void +random_lines (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + Bool horiz_p = (random() & 1); + int max = (horiz_p ? height : width); + int *lines = (int *) calloc(max, sizeof(*lines)); + int i; + + for (i = 0; i < max; i++) + lines[i] = i; + + for (i = 0; i < max; i++) + { + int t, r; + t = lines[i]; + r = random() % max; + lines[i] = lines[r]; + lines[r] = t; + } + + for (i = 0; i < max; i++) + { + if (horiz_p) + XDrawLine (dpy, window, gc, 0, lines[i], width, lines[i]); + else + XDrawLine (dpy, window, gc, lines[i], 0, lines[i], height); + + XSync (dpy, False); + if (delay > 0 && ((i % granularity) == 0)) + usleep (delay * granularity); + } + free(lines); +} + + +static void +venetian (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + 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; + + granularity /= 6; + + j = 0; + for (i = 0; i < max*2; i++) + { + int line = ((i / 16) * 16) - ((i % 16) * 15); + if (line >= 0 && line < max) + 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]); + else + XDrawLine (dpy, window, gc, lines[i], 0, lines[i], height); + + XSync (dpy, False); + if (delay > 0 && ((i % granularity) == 0)) + usleep (delay * granularity); + } + free(lines); +} + + +static void +triple_wipe (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + Bool flip_x = random() & 1; + Bool flip_y = random() & 1; + int max = width + (height / 2); + int *lines = (int *)calloc(max, sizeof(int)); + int i; + + for(i = 0; i < width/2; i++) + lines[i] = i*2+height; + for(i = 0; i < height/2; i++) + lines[i+width/2] = i*2; + 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++) + { + 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; + + XDrawLine (dpy, window, gc, x, y, x2, y2); + XSync (dpy, False); + if (delay > 0 && ((i % granularity) == 0)) + usleep (delay*granularity); + } + free(lines); +} + + +static void +quad_wipe (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + Bool flip_x = random() & 1; + Bool flip_y = random() & 1; + int max = width + height; + int *lines = (int *)calloc(max, sizeof(int)); + int i; + + granularity /= 3; + + for (i = 0; i < max/4; i++) + { + lines[i*4] = i*2; + lines[i*4+1] = height-i*2-(height%2?0:1); + lines[i*4+2] = height+i*2; + 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; + + 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); + XSync (dpy, False); + if (delay > 0 && ((i % granularity) == 0)) + usleep (delay*granularity); + } + free(lines); +} + + + +static void +circle_wipe (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + int full = 360 * 64; + int inc = full / 64; + int start = random() % full; + 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) + { + XFillArc(dpy, window, gc, + (width/2)-rad, (height/2)-rad, rad*2, rad*2, + (i+start) % full, inc); + XFlush (dpy); + usleep (delay*granularity); + } +} + + +static void +three_circle_wipe (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + int i; + int full = 360 * 64; + int q = full / 6; + int q2 = q * 2; + int inc = full / 240; + int start = random() % q; + int rad = (width > height ? width : height); + + 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); + + 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); + + 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); + + XSync (dpy, False); + usleep (delay*granularity); + } +} + + +static void +squaretate (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + int steps = (((width > height ? width : width) * 2) / granularity); + int i; + Bool flip = random() & 1; + +#define DRAW() \ + if (flip) { \ + points[0].x = width-points[0].x; \ + points[1].x = width-points[1].x; \ + points[2].x = width-points[2].x; } \ + XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin) + + for (i = 0; i < steps; i++) + { + 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); + } +#undef DRAW +} + + +/* from Frederick Roeber */ +static void +fizzle (Display *dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + /* These dimensions must be prime numbers. They should be roughly the + square root of the width and height. */ +# define BX 31 +# define BY 31 +# define SIZE (BX*BY) + + int array[SIZE]; + int i, j; + XPoint *skews; + int nx, ny; + + /* Distribute the numbers [0,SIZE) randomly in the array */ + { + int indices[SIZE]; + + for( i = 0; i < SIZE; i++ ) { + array[i] = -1; + indices[i] = i; + } + + for( i = 0; i < SIZE; i++ ) { + j = random()%(SIZE-i); + array[indices[j]] = i; + indices[j] = indices[SIZE-i-1]; + } + } + + /* nx, ny are the number of cells across and down, rounded up */ + nx = width / BX + (0 == (width %BX) ? 0 : 1); + ny = height / BY + (0 == (height%BY) ? 0 : 1); + skews = (XPoint *)malloc(sizeof(XPoint) * (nx*ny)); + if( (XPoint *)0 != skews ) { + for( i = 0; i < nx; i++ ) { + for( j = 0; j < ny; j++ ) { + skews[j * nx + i].x = random()%BX; + skews[j * nx + i].y = random()%BY; + } + } + } + +# 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; + + { + 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; + XDrawPoint(dpy, window, gc, xx, yy); + } + } + } + + if( (BX-1) == (i%BX) ) { + XSync (dpy, False); + usleep (delay*granularity); + } + } + +# undef SKEWX +# undef SKEWY + + if( (XPoint *)0 != skews ) { + free(skews); + } + +# undef BX +# undef BY +# undef SIZE +} + + +/* from Rick Campbell */ +static void +spiral (Display *display, Window window, GC context, + int width, int height, int delay, int granularity) +{ +# 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) + + double angle; + int arc_limit; + int arc_max_limit; + int length_step; + XPoint points [3]; + + 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 += length_step; + points [0].x = width / 2; + points [0].y = height / 2; + points [1].x = points [0].x + length_step; + points [1].y = points [0].y; + points [2].x = points [1].x; + points [2].y = points [1].y; + + for (arc_limit = length_step; + arc_limit < arc_max_limit; + arc_limit += length_step) + { + int arc_length = length_step; + int length_base = arc_limit; + for (angle = 0.0; angle < SPIRAL_ERASE_PI_2; + angle += SPIRAL_ERASE_ANGLE_INCREMENT) + { + 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) */ + } + } +# undef SPIRAL_ERASE_DELAY +# undef SPIRAL_ERASE_ANGLE_INCREMENT +# undef SPIRAL_ERASE_ARC_COUNT +# undef SPIRAL_ERASE_LOOP_COUNT +# undef SPIRAL_ERASE_PI_2 +} + + +#undef MAX +#undef MIN +#define MAX(a,b) ((a)>(b)?(a):(b)) +#define MIN(a,b) ((a)<(b)?(a):(b)) + +/* from David Bagley */ +static void +random_squares(Display * dpy, Window window, GC gc, + int width, int height, int delay, int granularity) +{ + 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 */ + + for (i = 0; i < max; i++) + squares[i] = i; + + for (i = 0; i < max; i++) + { + int t, r; + t = squares[i]; + r = random() % max; + squares[i] = squares[r]; + squares[r] = t; + } + + for (i = 0; i < max; i++) + { + 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); + } + free(squares); +} + + +static Eraser erasers[] = { + random_lines, + venetian, + triple_wipe, + quad_wipe, + circle_wipe, + three_circle_wipe, + squaretate, + fizzle, + random_squares, + spiral, +}; + + +void +erase_window(Display *dpy, Window window, GC gc, + int width, int height, int mode, int delay) +{ + int granularity = 25; + + if (mode < 0 || mode >= countof(erasers)) + mode = random() % countof(erasers); + (*(erasers[mode])) (dpy, window, gc, width, height, delay, granularity); + XClearWindow (dpy, window); + XSync(dpy, False); +} + + +void +erase_full_window(Display *dpy, Window window) +{ + XWindowAttributes xgwa; + XGCValues gcv; + GC erase_gc; + XColor black; + int erase_speed, erase_mode; + char *s; + + s = get_string_resource("eraseSpeed", "Integer"); + if (s && *s) + erase_speed = get_integer_resource("eraseSpeed", "Integer"); + else + erase_speed = 400; + if (s) free(s); + + s = get_string_resource("eraseMode", "Integer"); + if (s && *s) + erase_mode = get_integer_resource("eraseMode", "Integer"); + else + erase_mode = -1; + if (s) free(s); + + 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); +} + + + +#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