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 /* from Rick Campbell <rick@campbellcentral.org> */
 376 static void
 377 spiral (Display *display, Window window, GC context,
 378         int width, int height, int delay, int granularity)
 379 {
 380 # define SPIRAL_ERASE_PI_2 (M_PI + M_PI)
 381 # define SPIRAL_ERASE_LOOP_COUNT (10)
 382 # define SPIRAL_ERASE_ARC_COUNT (360.0)
 383 # define SPIRAL_ERASE_ANGLE_INCREMENT (SPIRAL_ERASE_PI_2 /     \
 384 SPIRAL_ERASE_ARC_COUNT)
 385 # define SPIRAL_ERASE_DELAY (0)
 386
 387   double angle;
 388   int arc_limit;
 389   int arc_max_limit;
 390   int length_step;
 391   XPoint points [3];
 392
 393   angle = 0.0;
 394   arc_limit = 1;
 395   arc_max_limit = (int) (ceil (sqrt ((width * width) + (height * height)))
 396                          / 2.0);
 397   length_step = ((arc_max_limit + SPIRAL_ERASE_LOOP_COUNT - 1) /
 398                  SPIRAL_ERASE_LOOP_COUNT);
 399   arc_max_limit += length_step;
 400   points [0].x = width / 2;
 401   points [0].y = height / 2;
 402   points [1].x = points [0].x + length_step;
 403   points [1].y = points [0].y;
 404   points [2].x = points [1].x;
 405   points [2].y = points [1].y;
 406
 407   for (arc_limit = length_step;
 408        arc_limit < arc_max_limit;
 409        arc_limit += length_step)
 410     {
 411       int arc_length = length_step;
 412       int length_base = arc_limit;
 413       for (angle = 0.0; angle < SPIRAL_ERASE_PI_2;
 414            angle += SPIRAL_ERASE_ANGLE_INCREMENT)
 415         {
 416           arc_length = length_base + ((length_step * angle) /
 417                                       SPIRAL_ERASE_PI_2);
 418           points [1].x = points [2].x;
 419           points [1].y = points [2].y;
 420           points [2].x = points [0].x + (int)(cos (angle) * arc_length);
 421           points [2].y = points [0].y + (int)(sin (angle) * arc_length);
 422           XFillPolygon (display, window, context, points, 3, Convex,
 423                         CoordModeOrigin);
 424 # if (SPIRAL_ERASE_DELAY != 0)
 425           usleep (SPIRAL_ERASE_DELAY);
 426 # endif /* (SPIRAL_ERASE_DELAY != 0) */
 427         }
 428     }
 429 # undef SPIRAL_ERASE_DELAY
 430 # undef SPIRAL_ERASE_ANGLE_INCREMENT
 431 # undef SPIRAL_ERASE_ARC_COUNT
 432 # undef SPIRAL_ERASE_LOOP_COUNT
 433 # undef SPIRAL_ERASE_PI_2
 434 }
 435
 436
 437 #undef MAX
 438 #undef MIN
 439 #define MAX(a,b) ((a)>(b)?(a):(b))
 440 #define MIN(a,b) ((a)<(b)?(a):(b))
 441
 442 /* from David Bagley <bagleyd@tux.org> */
 443 static void
 444 random_squares(Display * dpy, Window window, GC gc,
 445                int width, int height, int delay, int granularity)
 446 {
 447   int randsize = MAX(1, MIN(width, height) / (16 + (random() % 32)));
 448   int max = (height / randsize + 1) * (width / randsize + 1);
 449   int *squares = (int *) calloc(max, sizeof (*squares));
 450   int i;
 451   int columns = width / randsize + 1;  /* Add an extra for roundoff */
 452
 453   for (i = 0; i < max; i++)
 454     squares[i] = i;
 455
 456   for (i = 0; i < max; i++)
 457     {
 458       int t, r;
 459       t = squares[i];
 460       r = random() % max;
 461       squares[i] = squares[r];
 462       squares[r] = t;
 463     }
 464
 465   for (i = 0; i < max; i++)
 466     {
 467       XFillRectangle(dpy, window, gc,
 468                      (squares[i] % columns) * randsize,
 469                      (squares[i] / columns) * randsize,
 470                      randsize, randsize);
 471
 472       XSync(dpy, False);
 473       if (delay > 0 && ((i % granularity) == 0))
 474       usleep(delay * granularity);
 475     }
 476   free(squares);
 477 }
 478
 479
 480 static Eraser erasers[] = {
 481   random_lines,
 482   venetian,
 483   triple_wipe,
 484   quad_wipe,
 485   circle_wipe,
 486   three_circle_wipe,
 487   squaretate,
 488   fizzle,
 489   random_squares,
 490   spiral,
 491 };
 492
 493
 494 void
 495 erase_window(Display *dpy, Window window, GC gc,
 496              int width, int height, int mode, int delay)
 497 {
 498   int granularity = 25;
 499
 500   if (mode < 0 || mode >= countof(erasers))
 501     mode = random() % countof(erasers);
 502   (*(erasers[mode])) (dpy, window, gc, width, height, delay, granularity);
 503   XClearWindow (dpy, window);
 504   XSync(dpy, False);
 505 }
 506
 507
 508 void
 509 erase_full_window(Display *dpy, Window window)
 510 {
 511   XWindowAttributes xgwa;
 512   XGCValues gcv;
 513   GC erase_gc;
 514   XColor black;
 515   int erase_speed, erase_mode;
 516   char *s;
 517
 518   s = get_string_resource("eraseSpeed", "Integer");
 519   if (s && *s)
 520     erase_speed = get_integer_resource("eraseSpeed", "Integer");
 521   else
 522     erase_speed = 400;
 523   if (s) free(s);
 524
 525   s = get_string_resource("eraseMode", "Integer");
 526   if (s && *s)
 527     erase_mode = get_integer_resource("eraseMode", "Integer");
 528   else
 529     erase_mode = -1;
 530   if (s) free(s);
 531
 532   XGetWindowAttributes (dpy, window, &xgwa);
 533   black.flags = DoRed|DoGreen|DoBlue;
 534   black.red = black.green = black.blue = 0;
 535   XAllocColor(dpy, xgwa.colormap, &black);
 536   gcv.foreground = black.pixel;
 537   erase_gc = XCreateGC (dpy, window, GCForeground, &gcv);
 538   erase_window (dpy, window, erase_gc, xgwa.width, xgwa.height,
 539                 erase_mode, erase_speed);
 540   XFreeColors(dpy, xgwa.colormap, &black.pixel, 1, 0);
 541   XFreeGC(dpy, erase_gc);
 542 }
 543
 544
 545 \f
 546 #if 0
 547 #include "screenhack.h"
 548
 549 char *progclass = "Erase";
 550 char *defaults [] = {
 551   0
 552 };
 553
 554 XrmOptionDescRec options [] = {{0}};
 555 int options_size = 0;
 556
 557 void
 558 screenhack (dpy, window)
 559      Display *dpy;
 560      Window window;
 561 {
 562   int delay = 500000;
 563   XGCValues gcv;
 564   GC gc;
 565   XColor white;
 566   XWindowAttributes xgwa;
 567   XGetWindowAttributes (dpy, window, &xgwa);
 568   white.flags = DoRed|DoGreen|DoBlue;
 569   white.red = white.green = white.blue = 0xFFFF;
 570   XAllocColor(dpy, xgwa.colormap, &white);
 571   gcv.foreground = white.pixel;
 572   gc = XCreateGC (dpy, window, GCForeground, &gcv);
 573
 574   while (1)
 575     {
 576       XFillRectangle(dpy, window, gc, 0, 0, 1280, 1024);
 577       XSync (dpy, False);
 578       usleep (delay);
 579       erase_full_window(dpy, window);
 580       XSync (dpy, False);
 581       usleep (delay);
 582
 583     }
 584 }
 585
 586 #endif