http://ftp.x.org/contrib/applications/xscreensaver-3.07.tar.gz
[xscreensaver] / utils / erase.c
1 /* erase.c: Erase the screen in various more or less interesting ways.
2  * (c) 1997 by Johannes Keukelaar <johannes@nada.kth.se>
3  * Permission to use in any way granted. Provided "as is" without expressed
4  * or implied warranty. NO WARRANTY, NO EXPRESSION OF SUITABILITY FOR ANY
5  * PURPOSE. (I.e.: Use in any way, but at your own risk!)
6  */
7
8 #include "utils.h"
9 #include "yarandom.h"
10 #include "usleep.h"
11 #include "resources.h"
12
13 #undef countof
14 #define countof(x) (sizeof(x)/sizeof(*(x)))
15
16 typedef void (*Eraser) (Display *dpy, Window window, GC gc,
17                         int width, int height, int delay, int granularity);
18
19
20 static void
21 random_lines (Display *dpy, Window window, GC gc,
22               int width, int height, int delay, int granularity)
23 {
24   Bool horiz_p = (random() & 1);
25   int max = (horiz_p ? height : width);
26   int *lines = (int *) calloc(max, sizeof(*lines));
27   int i;
28
29   for (i = 0; i < max; i++)
30     lines[i] = i;
31
32   for (i = 0; i < max; i++)
33     {
34       int t, r;
35       t = lines[i];
36       r = random() % max;
37       lines[i] = lines[r];
38       lines[r] = t;
39     }
40
41   for (i = 0; i < max; i++)
42     { 
43       if (horiz_p)
44         XDrawLine (dpy, window, gc, 0, lines[i], width, lines[i]);
45       else
46         XDrawLine (dpy, window, gc, lines[i], 0, lines[i], height);
47
48       XSync (dpy, False);
49       if (delay > 0 && ((i % granularity) == 0))
50         usleep (delay * granularity);
51     }
52   free(lines);
53 }
54
55
56 static void
57 venetian (Display *dpy, Window window, GC gc,
58           int width, int height, int delay, int granularity)
59 {
60   Bool horiz_p = (random() & 1);
61   Bool flip_p = (random() & 1);
62   int max = (horiz_p ? height : width);
63   int *lines = (int *) calloc(max, sizeof(*lines));
64   int i, j;
65
66   granularity /= 6;
67
68   j = 0;
69   for (i = 0; i < max*2; i++)
70     {
71       int line = ((i / 16) * 16) - ((i % 16) * 15);
72       if (line >= 0 && line < max)
73         lines[j++] = (flip_p ? max - line : line);
74     }
75
76   for (i = 0; i < max; i++)
77     { 
78       if (horiz_p)
79         XDrawLine (dpy, window, gc, 0, lines[i], width, lines[i]);
80       else
81         XDrawLine (dpy, window, gc, lines[i], 0, lines[i], height);
82
83       XSync (dpy, False);
84       if (delay > 0 && ((i % granularity) == 0))
85         usleep (delay * granularity);
86     }
87   free(lines);
88 }
89
90
91 static void
92 triple_wipe (Display *dpy, Window window, GC gc,
93              int width, int height, int delay, int granularity)
94 {
95   Bool flip_x = random() & 1;
96   Bool flip_y = random() & 1;
97   int max = width + (height / 2);
98   int *lines = (int *)calloc(max, sizeof(int));
99   int i;
100
101   for(i = 0; i < width/2; i++)
102     lines[i] = i*2+height;
103   for(i = 0; i < height/2; i++)
104     lines[i+width/2] = i*2;
105   for(i = 0; i < width/2; i++)
106     lines[i+width/2+height/2] = width-i*2-(width%2?0:1)+height;
107
108   granularity /= 6;
109
110   for (i = 0; i < max; i++)
111     { 
112       int x, y, x2, y2;
113       if (lines[i] < height)
114         x = 0, y = lines[i], x2 = width, y2 = y;
115       else
116         x = lines[i]-height, y = 0, x2 = x, y2 = height;
117
118       if (flip_x)
119         x = width-x, x2 = width-x2;
120       if (flip_y)
121         y = height-y, y2 = height-y2;
122
123       XDrawLine (dpy, window, gc, x, y, x2, y2);
124       XSync (dpy, False);
125       if (delay > 0 && ((i % granularity) == 0))
126         usleep (delay*granularity);
127     }
128   free(lines);
129 }
130
131
132 static void
133 quad_wipe (Display *dpy, Window window, GC gc,
134            int width, int height, int delay, int granularity)
135 {
136   Bool flip_x = random() & 1;
137   Bool flip_y = random() & 1;
138   int max = width + height;
139   int *lines = (int *)calloc(max, sizeof(int));
140   int i;
141
142   granularity /= 3;
143
144   for (i = 0; i < max/4; i++)
145     {
146       lines[i*4]   = i*2;
147       lines[i*4+1] = height-i*2-(height%2?0:1);
148       lines[i*4+2] = height+i*2;
149       lines[i*4+3] = height+width-i*2-(width%2?0:1);
150     }
151
152   for (i = 0; i < max; i++)
153     { 
154       int x, y, x2, y2;
155       if (lines[i] < height)
156         x = 0, y = lines[i], x2 = width, y2 = y;
157       else
158         x = lines[i]-height, y = 0, x2 = x, y2 = height;
159
160       if (flip_x)
161         x = width-x, x2 = width-x2;
162       if (flip_y)
163         y = height-y, y2 = height-y2;
164
165       XDrawLine (dpy, window, gc, x, y, x2, y2);
166       XSync (dpy, False);
167       if (delay > 0 && ((i % granularity) == 0))
168         usleep (delay*granularity);
169     }
170   free(lines);
171 }
172
173
174
175 static void
176 circle_wipe (Display *dpy, Window window, GC gc,
177              int width, int height, int delay, int granularity)
178 {
179   int full = 360 * 64;
180   int inc = full / 64;
181   int start = random() % full;
182   int rad = (width > height ? width : height);
183   int i;
184   if (random() & 1)
185     inc = -inc;
186   for (i = (inc > 0 ? 0 : full);
187        (inc > 0 ? i < full : i > 0);
188        i += inc)
189     {
190       XFillArc(dpy, window, gc,
191                (width/2)-rad, (height/2)-rad, rad*2, rad*2,
192                (i+start) % full, inc);
193       XFlush (dpy);
194       usleep (delay*granularity);
195     }
196 }
197
198
199 static void
200 three_circle_wipe (Display *dpy, Window window, GC gc,
201                    int width, int height, int delay, int granularity)
202 {
203   int i;
204   int full = 360 * 64;
205   int q = full / 6;
206   int q2 = q * 2;
207   int inc = full / 240;
208   int start = random() % q;
209   int rad = (width > height ? width : height);
210
211   for (i = 0; i < q; i += inc)
212     {
213       XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,
214                (start+i) % full, inc);
215       XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,
216                (start-i) % full, -inc);
217
218       XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,
219                (start+q2+i) % full, inc);
220       XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,
221                (start+q2-i) % full, -inc);
222
223       XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,
224                (start+q2+q2+i) % full, inc);
225       XFillArc(dpy, window, gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,
226                (start+q2+q2-i) % full, -inc);
227
228       XSync (dpy, False);
229       usleep (delay*granularity);
230     }
231 }
232
233
234 static void
235 squaretate (Display *dpy, Window window, GC gc,
236             int width, int height, int delay, int granularity)
237 {
238   int steps = (((width > height ? width : width) * 2) / granularity);
239   int i;
240   Bool flip = random() & 1;
241
242 #define DRAW() \
243       if (flip) { \
244         points[0].x = width-points[0].x; \
245         points[1].x = width-points[1].x; \
246         points[2].x = width-points[2].x; } \
247       XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin)
248
249   for (i = 0; i < steps; i++)
250     {
251       XPoint points [3];
252       points[0].x = 0;
253       points[0].y = 0;
254       points[1].x = width;
255       points[1].y = 0;
256       points[2].x = 0;
257       points[2].y = points[0].y + ((i * height) / steps);
258       DRAW();
259
260       points[0].x = 0;
261       points[0].y = 0;
262       points[1].x = 0;
263       points[1].y = height;
264       points[2].x = ((i * width) / steps);
265       points[2].y = height;
266       DRAW();
267
268       points[0].x = width;
269       points[0].y = height;
270       points[1].x = 0;
271       points[1].y = height;
272       points[2].x = width;
273       points[2].y = height - ((i * height) / steps);
274       DRAW();
275
276       points[0].x = width;
277       points[0].y = height;
278       points[1].x = width;
279       points[1].y = 0;
280       points[2].x = width - ((i * width) / steps);
281       points[2].y = 0;
282       DRAW();
283
284       XSync (dpy, True);
285       if (delay > 0)
286         usleep (delay * granularity);
287    }
288 #undef DRAW
289 }
290
291
292 /* from Frederick Roeber <roeber@netscape.com> */
293 static void
294 fizzle (Display *dpy, Window window, GC gc,
295             int width, int height, int delay, int granularity)
296 {
297   /* These dimensions must be prime numbers.  They should be roughly the
298      square root of the width and height. */
299 # define BX 31
300 # define BY 31
301 # define SIZE (BX*BY)
302
303   int array[SIZE];
304   int i, j;
305   XPoint *skews;
306   int nx, ny;
307
308   /* Distribute the numbers [0,SIZE) randomly in the array */
309   {
310     int indices[SIZE];
311
312     for( i = 0; i < SIZE; i++ ) {
313       array[i] = -1;
314       indices[i] = i;
315     } 
316
317     for( i = 0; i < SIZE; i++ ) {
318       j = random()%(SIZE-i);
319       array[indices[j]] = i;
320       indices[j] = indices[SIZE-i-1];
321     }
322   }
323
324   /* nx, ny are the number of cells across and down, rounded up */
325   nx = width  / BX + (0 == (width %BX) ? 0 : 1);
326   ny = height / BY + (0 == (height%BY) ? 0 : 1);
327   skews = (XPoint *)malloc(sizeof(XPoint) * (nx*ny));
328   if( (XPoint *)0 != skews ) {
329     for( i = 0; i < nx; i++ ) {
330       for( j = 0; j < ny; j++ ) {
331         skews[j * nx + i].x = random()%BX;
332         skews[j * nx + i].y = random()%BY;
333       }
334     }
335   }
336
337 # define SKEWX(cx, cy) (((XPoint *)0 == skews)?0:skews[cy*nx + cx].x)
338 # define SKEWY(cx, cy) (((XPoint *)0 == skews)?0:skews[cy*nx + cx].y)
339
340   for( i = 0; i < SIZE; i++ ) {
341     int x = array[i] % BX;
342     int y = array[i] / BX;
343
344     {
345       int iy, cy;
346       for( iy = 0, cy = 0; iy < height; iy += BY, cy++ ) {
347         int ix, cx;
348         for( ix = 0, cx = 0; ix < width; ix += BX, cx++ ) {
349           int xx = ix + (SKEWX(cx, cy) + x*((cx%(BX-1))+1))%BX;
350           int yy = iy + (SKEWY(cx, cy) + y*((cy%(BY-1))+1))%BY;
351           XDrawPoint(dpy, window, gc, xx, yy);
352         }
353       }
354     }
355
356     if( (BX-1) == (i%BX) ) {
357       XSync (dpy, False);
358       usleep (delay*granularity);
359     }
360   }
361
362 # undef SKEWX
363 # undef SKEWY
364
365   if( (XPoint *)0 != skews ) {
366     free(skews);
367   }
368
369 # undef BX
370 # undef BY
371 # undef SIZE
372 }
373
374
375 #undef MAX
376 #undef MIN
377 #define MAX(a,b) ((a)>(b)?(a):(b))
378 #define MIN(a,b) ((a)<(b)?(a):(b))
379
380 /* from David Bagley <bagleyd@tux.org> */
381 static void
382 random_squares(Display * dpy, Window window, GC gc,
383                int width, int height, int delay, int granularity)
384 {
385   int randsize = MAX(1, MIN(width, height) / (16 + (random() % 32)));
386   int max = (height / randsize + 1) * (width / randsize + 1);
387   int *squares = (int *) calloc(max, sizeof (*squares));
388   int i;
389   int columns = width / randsize + 1;  /* Add an extra for roundoff */
390
391   for (i = 0; i < max; i++)
392     squares[i] = i;
393
394   for (i = 0; i < max; i++)
395     {
396       int t, r;
397       t = squares[i];
398       r = random() % max;
399       squares[i] = squares[r];
400       squares[r] = t;
401     }
402
403   for (i = 0; i < max; i++)
404     {
405       XFillRectangle(dpy, window, gc,
406                      (squares[i] % columns) * randsize,
407                      (squares[i] / columns) * randsize,
408                      randsize, randsize);
409
410       XSync(dpy, False);
411       if (delay > 0 && ((i % granularity) == 0))
412       usleep(delay * granularity);
413     }
414   free(squares);
415 }
416
417
418 static Eraser erasers[] = {
419   random_lines,
420   venetian,
421   triple_wipe,
422   quad_wipe,
423   circle_wipe,
424   three_circle_wipe,
425   squaretate,
426   fizzle,
427   random_squares,
428 };
429
430
431 void
432 erase_window(Display *dpy, Window window, GC gc,
433              int width, int height, int mode, int delay)
434 {
435   int granularity = 25;
436
437   if (mode < 0 || mode >= countof(erasers))
438     mode = random() % countof(erasers);
439   (*(erasers[mode])) (dpy, window, gc, width, height, delay, granularity);
440   XClearWindow (dpy, window);
441   XSync(dpy, False);
442 }
443
444
445 void
446 erase_full_window(Display *dpy, Window window)
447 {
448   XWindowAttributes xgwa;
449   XGCValues gcv;
450   GC erase_gc;
451   XColor black;
452   int erase_speed, erase_mode;
453   char *s;
454
455   s = get_string_resource("eraseSpeed", "Integer");
456   if (s && *s)
457     erase_speed = get_integer_resource("eraseSpeed", "Integer");
458   else
459     erase_speed = 400;
460   if (s) free(s);
461
462   s = get_string_resource("eraseMode", "Integer");
463   if (s && *s)
464     erase_mode = get_integer_resource("eraseMode", "Integer");
465   else
466     erase_mode = -1;
467   if (s) free(s);
468
469   XGetWindowAttributes (dpy, window, &xgwa);
470   black.flags = DoRed|DoGreen|DoBlue;
471   black.red = black.green = black.blue = 0;
472   XAllocColor(dpy, xgwa.colormap, &black);
473   gcv.foreground = black.pixel;
474   erase_gc = XCreateGC (dpy, window, GCForeground, &gcv);
475   erase_window (dpy, window, erase_gc, xgwa.width, xgwa.height,
476                 erase_mode, erase_speed);
477   XFreeColors(dpy, xgwa.colormap, &black.pixel, 1, 0);
478   XFreeGC(dpy, erase_gc);
479 }
480
481
482 \f
483 #if 0
484 #include "screenhack.h"
485
486 char *progclass = "Erase";
487 char *defaults [] = {
488   0
489 };
490
491 XrmOptionDescRec options [] = {{0}};
492 int options_size = 0;
493
494 void
495 screenhack (dpy, window)
496      Display *dpy;
497      Window window;
498 {
499   int delay = 500000;
500   XGCValues gcv;
501   GC gc;
502   XColor white;
503   XWindowAttributes xgwa;
504   XGetWindowAttributes (dpy, window, &xgwa);
505   white.flags = DoRed|DoGreen|DoBlue;
506   white.red = white.green = white.blue = 0xFFFF;
507   XAllocColor(dpy, xgwa.colormap, &white);
508   gcv.foreground = white.pixel;
509   gc = XCreateGC (dpy, window, GCForeground, &gcv);
510
511   while (1)
512     {
513       XFillRectangle(dpy, window, gc, 0, 0, 1280, 1024);
514       XSync (dpy, False);
515       usleep (delay);
516       erase_full_window(dpy, window);
517       XSync (dpy, False);
518       usleep (delay);
519
520     }
521 }
522
523 #endif