git.hungrycats.org Git - xscreensaver/blob - 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