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
 293
 294 static Eraser erasers[] = {
 295   random_lines,
 296   venetian,
 297   triple_wipe,
 298   quad_wipe,
 299   circle_wipe,
 300   three_circle_wipe,
 301   squaretate,
 302 };
 303
 304
 305 void
 306 erase_window(Display *dpy, Window window, GC gc,
 307              int width, int height, int mode, int delay)
 308 {
 309   int granularity = 25;
 310
 311   if (mode < 0 || mode >= countof(erasers))
 312     mode = random() % countof(erasers);
 313   (*(erasers[mode])) (dpy, window, gc, width, height, delay, granularity);
 314   XClearWindow (dpy, window);
 315   XSync(dpy, False);
 316 }
 317
 318
 319 void
 320 erase_full_window(Display *dpy, Window window)
 321 {
 322   XWindowAttributes xgwa;
 323   XGCValues gcv;
 324   GC erase_gc;
 325   XColor black;
 326   int erase_speed, erase_mode;
 327   char *s;
 328
 329   s = get_string_resource("eraseSpeed", "Integer");
 330   if (s && *s)
 331     erase_speed = get_integer_resource("eraseSpeed", "Integer");
 332   else
 333     erase_speed = 400;
 334   if (s) free(s);
 335
 336   s = get_string_resource("eraseMode", "Integer");
 337   if (s && *s)
 338     erase_mode = get_integer_resource("eraseMode", "Integer");
 339   else
 340     erase_mode = -1;
 341   if (s) free(s);
 342
 343   XGetWindowAttributes (dpy, window, &xgwa);
 344   black.flags = DoRed|DoGreen|DoBlue;
 345   black.red = black.green = black.blue = 0;
 346   XAllocColor(dpy, xgwa.colormap, &black);
 347   gcv.foreground = black.pixel;
 348   erase_gc = XCreateGC (dpy, window, GCForeground, &gcv);
 349   erase_window (dpy, window, erase_gc, xgwa.width, xgwa.height,
 350                 erase_mode, erase_speed);
 351   XFreeColors(dpy, xgwa.colormap, &black.pixel, 1, 0);
 352   XFreeGC(dpy, erase_gc);
 353 }
 354
 355
 356 \f
 357 #if 0
 358 #include "screenhack.h"
 359
 360 char *progclass = "Erase";
 361 char *defaults [] = {
 362   0
 363 };
 364
 365 XrmOptionDescRec options [] = {0};
 366 int options_size = 0;
 367
 368 void
 369 screenhack (dpy, window)
 370      Display *dpy;
 371      Window window;
 372 {
 373   int delay = 500000;
 374   XGCValues gcv;
 375   GC gc;
 376   XColor white;
 377   XWindowAttributes xgwa;
 378   XGetWindowAttributes (dpy, window, &xgwa);
 379   white.flags = DoRed|DoGreen|DoBlue;
 380   white.red = white.green = white.blue = 0xFFFF;
 381   XAllocColor(dpy, xgwa.colormap, &white);
 382   gcv.foreground = white.pixel;
 383   gc = XCreateGC (dpy, window, GCForeground, &gcv);
 384
 385   while (1)
 386     {
 387       XFillRectangle(dpy, window, gc, 0, 0, 1280, 1024);
 388       XSync (dpy, False);
 389       usleep (delay);
 390       erase_full_window(dpy, window);
 391       XSync (dpy, False);
 392       usleep (delay);
 393
 394     }
 395 }
 396
 397 #endif