1 /* Whirlygig -- an experiment in X programming
3 * Permission to use, copy, modify, distribute, and sell this software and its
4 * documentation for any purpose is hereby granted without fee, provided that
5 * the above copyright notice appear in all copies and that both that
6 * copyright notice and this permission notice appear in supporting
7 * documentation. No representations are made about the suitability of this
8 * software for any purpose. It is provided "as is" without express or
11 * When I was in trigonometry class as a kid, I remember being fascinated
12 * by the beauty of the shapes one receives when playing with sine waves
13 * Here is a little experiment to show that beauty is simple
18 #include "screenhack.h"
20 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
22 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
25 #define FULL_CYCLE 429496729
30 /* Bool writable; / * Is the screen writable */
31 double xspeed; /* A factor to modify the horizontal movement */
32 double yspeed; /* A factor to modify vertical movement */
35 int whirlies; /* How many whirlies per line do you want? */
36 int nlines; /* How many lines of whirlies do you want? */
37 int half_width; /* 1/2 the width of the screen */
49 spin_mode, funky_mode, circle_mode, linear_mode, test_mode, fun_mode, innie_mode, lissajous_mode
56 XGCValues gcv; /* The structure to hold the GC data */
57 XWindowAttributes xgwa; /* A structure to hold window data */
58 Pixmap b, ba; /* double-buffer to reduce flicker */
59 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
62 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
68 unsigned long int current_time; /* The global int telling the current time */
69 unsigned long int start_time;
71 char *xmode_str, *ymode_str; /* holds the current mode for x and y computation */
73 /* pos is the current position x,y -- last_x contains one cell of
74 every x coordinate for every position of every whirly in every
75 line up to 100 whirlies in 100 lines -- lasy_y and last_size hold
76 the same information for y and size respectively */
78 int pos[2], last_x[100][100], last_y[100][100], last_size[100][100];
82 double modifier; /* for innie */
84 XColor colors[NCOLORS];
89 static void draw_explain_string(struct state *, int, int, Display *, Window, GC);
90 static void spin(struct state *, unsigned long int, struct info *, int *, int);
91 static void funky(struct state *, unsigned long int, struct info *, int *, int);
92 static void circle(struct state *, unsigned long int, struct info *, int *, int);
93 static void fun(struct state *, unsigned long int, struct info *, int *, int);
94 static void linear(struct state *, unsigned long int, struct info *, int *, int);
95 static void lissajous(struct state *, unsigned long int, struct info *, int *, int);
96 static void test(struct state *, unsigned long int, struct info *, int *, int);
97 static void innie(struct state *, unsigned long int, struct info *, int *, int, double);
101 static const char spin_explanation[] =
102 "Spin mode is a simple sin/cos with every argument modified";
104 static const char funky_explanation[] =
105 "Funky mode is me goofing off.";
107 static const char circle_explanation[] =
108 "Circle mode graphs the x and y positions as you trace the edge of a circle over time.";
110 static const char linear_explanation[] =
111 "Linear mode draws a straight line";
113 static const char test_explanation[] =
114 "Test mode is a mode that I play around with ideas in.";
116 static const char fun_explanation[] =
117 "Fun mode is the coolest.";
119 static const char innie_explanation[] =
120 "Innie mode does something or other. Looks cool, though.";
122 static const char lissajous_explanation[] =
123 "Lissajous mode draws a slightly modified lissajous curve";
126 draw_explain_string(struct state *st, int mode, int offset, Display *dpy, Window window, GC fgc)
130 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
131 (char*) spin_explanation, strlen(spin_explanation));
134 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
135 (char*) funky_explanation, strlen(funky_explanation));
138 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
139 (char*) circle_explanation, strlen(circle_explanation));
142 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
143 (char*) linear_explanation, strlen(linear_explanation));
146 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
147 (char*) test_explanation, strlen(test_explanation));
150 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
151 (char*) fun_explanation, strlen(fun_explanation));
154 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
155 (char*) innie_explanation, strlen(innie_explanation));
158 XDrawString(st->dpy, st->window, st->fgc, 50, offset,
159 (char*) lissajous_explanation, strlen(linear_explanation));
164 funky(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
166 double new_time = ((the_time % 360 ) / 180.0) * M_PI;
168 double time_modifier = cos(new_time / 180.0);
169 double the_cos = cos((new_time * (double)st->info->xspeed) + (time_modifier * 80.0));
170 double dist_mod_x = cos(new_time) * (st->info->half_width - 50);
171 st->pos[index]= st->info->xamplitude * (the_cos * dist_mod_x) + st->info->half_width;
174 double new_time = ((the_time % 360 ) / 180.0) * M_PI;
175 double time_modifier = sin(new_time / 180.0);
176 double the_sin = sin((new_time * (double)st->info->yspeed) + (time_modifier * 80.0));
177 double dist_mod_y = sin(new_time) * (st->info->half_height - 50);
178 st->pos[index] = st->info->yamplitude * (the_sin * dist_mod_y) + st->info->half_height;
183 innie(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index, double modifier)
185 double frequency = 2000000.0 + (st->modifier * cos(((double)the_time / 100.0)));
186 double arg = (double)the_time / frequency;
187 double amplitude = 200.0 * cos(arg);
188 double fun = 150.0 * cos((double)the_time / 2000.0);
189 int vert_mod, horiz_mod;
191 horiz_mod = (int)(fun * cos((double)the_time / 100.0)) + st->info->half_width;
192 st->pos[index] = (amplitude * cos((double)the_time / 100.0 * st->info->xspeed)) + horiz_mod;
195 vert_mod = (int)(fun * sin((double)the_time / 100.0)) + st->info->half_height;
196 st->pos[index] = (amplitude * sin((double)the_time / 100.0 * st->info->yspeed)) + vert_mod;
201 lissajous(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
203 /* This is a pretty standard lissajous curve
206 The n and c modifiers are cyclic as well, however... */
208 double time = (double)the_time / 100.0;
209 double fun = 15.0 * cos((double)the_time / 800.0);
210 double weird = cos((time / 1100000.0) / 1000.0);
213 result = st->info->xamplitude * 200.0 * sin((weird * time) + fun) + st->info->half_width;
216 result = st->info->yamplitude * 200.0 * sin(time) + st->info->half_height;
218 st->pos[index] = result;
222 circle(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
226 result = st->info->xamplitude * (cos((double)the_time / 100.0 * st->info->xspeed) * (st->info->half_width / 2)) + st->info->half_width;
229 result = st->info->yamplitude * (sin((double)the_time / 100.0 * st->info->yspeed) * (st->info->half_height / 2)) + st->info->half_height;
231 st->pos[index] = result;
236 mod(unsigned long int the_time, struct info *info, int pos[], int index)
239 int max = st->info->half_width;
240 if ((the_time % (max * 2)) < max)
241 amplitude = max - ((the_time % (max * 2)) - max);
243 amplitude = the_time % (max * 2);
244 amplitude = amplitude - max;
249 spin(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
251 double funky = (((the_time % 360) * 1.0) / 180.0) * M_PI;
253 double the_cos = cos((double)the_time / (180.0 * st->info->xspeed));
254 double dist_mod_x = cos((double)funky) * (st->info->half_width - 50);
255 st->pos[index] = st->info->xamplitude * (the_cos * dist_mod_x) + st->info->half_width;
258 double the_sin = sin((double)the_time / (180.0 * st->info->yspeed));
259 double dist_mod_y = sin((double)funky) * (st->info->half_height - 50);
260 st->pos[index] = st->info->yamplitude * (the_sin * dist_mod_y) + st->info->half_height;
265 fun(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
268 int max = st->info->half_width;
269 if ((the_time % (max * 2)) < max)
270 amplitude = max - ((the_time % (max * 2)) - max);
272 amplitude = the_time % (max * 2);
273 amplitude = amplitude - max;
275 st->pos[index] = (amplitude * cos((double)the_time / 100.0 * st->info->xspeed)) + st->info->half_width;
278 st->pos[index] = (amplitude * sin((double)the_time / 100.0 * st->info->yspeed)) + st->info->half_height;
283 linear(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
285 if (index == 0) /* Calculate for the x axis */
286 st->pos[index] = ((the_time / 2) % (st->info->half_width * 2));
288 st->pos[index] = ((the_time / 2) % (st->info->half_height * 2));
292 test(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
295 st->pos[index] = st->info->xamplitude * (cos((double)the_time / 100.0 * st->info->xspeed) * (st->info->half_width / 2)) + st->info->half_width;
298 st->pos[index] = st->info->yamplitude * (sin((double)the_time / 100.0 * st->info->yspeed) * (st->info->half_height / 2)) + st->info->half_height;
302 static int preen(int current, int max) {
312 smoothen(struct state *st, int x, int lastx, int y, int lasty, int size, int last_color, XColor *colors, Display *dpy, Window window, GC bgc, int screen, struct info *info)
314 double xdistance = abs((double)x-(double)lastx);
315 double ydistance = abs((double)y-(double)lasty);
316 double distance = sqrt(((xdistance * xdistance) + (ydistance * ydistance)) );
317 double slope = (((double)y-(double)lasty) / ((double)x-(double)lastx));
318 printf("Starting smoothen with values: %f, %f, %f, %f\n", xdistance, ydistance, distance, slope);
319 if (distance > 2.0) {
320 int newx = (int)((xdistance / distance) * slope);
321 int newy = (int)((ydistance / distance) * slope);
322 if (! st->info->trail) {
323 XSetForeground(st->dpy, st->bgc, BlackPixel(st->dpy, st->screen));
324 XFillArc(st->dpy, st->window, st->bgc, lastx, lasty, size, size, START_ARC, END_ARC);
326 XSetForeground(st->dpy, st->bgc, st->colors[last_color].pixel);
327 XFillArc(st->dpy, st->window, st->bgc, newx, newy, size, size, START_ARC, END_ARC);
328 smoothen(st, newx, x, newy, y, size, last_color, st->colors, st->dpy, st->window, st->bgc, st->screen, st->info);
335 whirlygig_init (Display *dpy, Window window)
337 struct state *st = (struct state *) calloc (1, sizeof(*st));
341 st->ncolors = NCOLORS;
343 st->dbuf = get_boolean_resource (st->dpy, "doubleBuffer", "Boolean");
345 # ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
349 st->start_time = st->current_time;
350 st->info = (struct info *)malloc(sizeof(struct info));
352 st->screen = DefaultScreen(st->dpy);
353 XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
356 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
357 if (get_boolean_resource(st->dpy,"useDBE","Boolean"))
359 st->dbeclear_p = get_boolean_resource (st->dpy, "useDBEClear",
362 st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeBackground);
364 st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeUndefined);
367 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
371 st->ba = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height,st->xgwa.depth);
380 st->gcv.foreground = get_pixel_resource(st->dpy, st->xgwa.colormap, "foreground", "Foreground");
381 st->fgc = XCreateGC (st->dpy, st->b, GCForeground, &st->gcv);
382 st->gcv.foreground = get_pixel_resource(st->dpy, st->xgwa.colormap, "background", "Background");
383 st->bgc = XCreateGC (st->dpy, st->b, GCForeground, &st->gcv);
385 #ifdef HAVE_COCOA /* #### should turn off double-buffering instead */
386 jwxyz_XSetAntiAliasing (dpy, st->fgc, False);
387 jwxyz_XSetAntiAliasing (dpy, st->bgc, False);
391 Bool writable_p = False;
392 make_uniform_colormap (st->xgwa.screen, st->xgwa.visual,
393 st->xgwa.colormap, st->colors, &st->ncolors,
394 True, &writable_p, True);
397 if (st->ba) XFillRectangle (st->dpy, st->ba, st->bgc, 0, 0, st->xgwa.width, st->xgwa.height);
399 /* info is a structure holding all the random pieces of information I may want to
400 pass to my baby functions -- much of it I may never use, but it is nice to
401 have around just in case I want it to make a funky function funkier */
402 /* info->writable = get_boolean_resource (dpy, "cycle", "Boolean"); */
403 st->info->xspeed = get_float_resource(st->dpy, "xspeed" , "Float");
404 st->info->yspeed = get_float_resource(st->dpy, "yspeed" , "Float");
405 st->info->xamplitude = get_float_resource(st->dpy, "xamplitude", "Float");
406 st->info->yamplitude = get_float_resource(st->dpy, "yamplitude", "Float");
407 st->info->offset_period = get_float_resource(st->dpy, "offset_period", "Float");
408 st->info->whirlies = get_integer_resource(st->dpy, "whirlies", "Integer");
409 st->info->nlines = get_integer_resource(st->dpy, "nlines", "Integer");
410 st->info->half_width = st->xgwa.width / 2;
411 st->info->half_height = st->xgwa.height / 2;
412 st->info->speed = get_integer_resource(st->dpy, "speed" , "Integer");
413 st->info->trail = get_boolean_resource(st->dpy, "trail", "Integer");
414 st->info->color_modifier = get_integer_resource(st->dpy, "color_modifier", "Integer");
415 st->info->xoffset = get_float_resource(st->dpy, "xoffset", "Float");
416 st->info->yoffset = get_float_resource(st->dpy, "yoffset", "Float");
417 st->xmode_str = get_string_resource(st->dpy, "xmode", "Mode");
418 st->ymode_str = get_string_resource(st->dpy, "ymode", "Mode");
419 st->wrap = get_boolean_resource(st->dpy, "wrap", "Boolean");
420 st->modifier = 3000.0 + frand(1500.0);
421 if (! st->xmode_str) st->xmode = spin_mode;
422 else if (! strcmp (st->xmode_str, "spin")) st->xmode = spin_mode;
423 else if (! strcmp (st->xmode_str, "funky")) st->xmode = funky_mode;
424 else if (! strcmp (st->xmode_str, "circle")) st->xmode = circle_mode;
425 else if (! strcmp (st->xmode_str, "linear")) st->xmode = linear_mode;
426 else if (! strcmp (st->xmode_str, "test")) st->xmode = test_mode;
427 else if (! strcmp (st->xmode_str, "fun")) st->xmode = fun_mode;
428 else if (! strcmp (st->xmode_str, "innie")) st->xmode = innie_mode;
429 else if (! strcmp (st->xmode_str, "lissajous")) st->xmode = lissajous_mode;
431 st->xmode = random() % (int) lissajous_mode;
433 if (! st->ymode_str) st->ymode = spin_mode;
434 else if (! strcmp (st->ymode_str, "spin")) st->ymode = spin_mode;
435 else if (! strcmp (st->ymode_str, "funky")) st->ymode = funky_mode;
436 else if (! strcmp (st->ymode_str, "circle")) st->ymode = circle_mode;
437 else if (! strcmp (st->ymode_str, "linear")) st->ymode = linear_mode;
438 else if (! strcmp (st->ymode_str, "test")) st->ymode = test_mode;
439 else if (! strcmp (st->ymode_str, "fun")) st->ymode = fun_mode;
440 else if (! strcmp (st->ymode_str, "innie")) st->ymode = innie_mode;
441 else if (! strcmp (st->ymode_str, "lissajous")) st->ymode = lissajous_mode;
443 st->ymode = random() % (int) lissajous_mode;
446 if (get_integer_resource(st->dpy, "start_time", "Integer") == -1)
447 st->current_time = (unsigned long int)(random());
449 st->current_time = get_integer_resource(st->dpy, "start_time", "Integer");
450 if (st->info->whirlies == -1)
451 st->info->whirlies = 1 + (random() % 15);
452 if (st->info->nlines == -1)
453 st->info->nlines = 1 + (random() % 5);
454 if (st->info->color_modifier == -1)
455 st->info->color_modifier = 1 + (random() % 25);
456 if (get_boolean_resource(st->dpy, "explain", "Integer"))
458 st->current_color = 1 + (random() % NCOLORS);
464 whirlygig_draw (Display *dpy, Window window, void *closure)
466 struct state *st = (struct state *) closure;
467 int wcount; /* wcount is a counter incremented for every whirly take note of
468 internal_time before you mess with it */
469 int change_time = 4000;
471 if (st->explaining == 1) {
472 XClearWindow (st->dpy, st->window);
473 draw_explain_string(st, st->xmode, st->info->half_height-100,
474 st->dpy, st->window, st->fgc);
477 } else if (st->explaining == 2) {
478 XClearWindow (st->dpy, st->window);
482 if (! strcmp (st->xmode_str, "change") && ! strcmp (st->ymode_str, "change")) {
483 if ((st->current_time - st->start_time) > change_time) {
484 st->start_time = st->current_time;
485 st->xmode = 1 + (random() % 4);
486 st->ymode = 1 + (random() % 4);
489 else if (! strcmp (st->xmode_str, "change")) {
490 if ((st->current_time - st->start_time) > change_time) {
491 st->start_time = st->current_time;
492 st->xmode = 1 + (random() % 4);
495 else if (! strcmp (st->ymode_str, "change")) {
496 if ((st->current_time - st->start_time) > change_time) {
497 st->start_time = st->current_time;
498 st->ymode = 1 + (random() % 3);
499 printf("Changing ymode to %d\n", st->ymode);
502 if (++st->current_color >= NCOLORS)
503 st->current_color = 0;
504 for (wcount = 0; wcount < st->info->whirlies; wcount++) {
505 int lcount; /* lcount is a counter for every line -- take note of the offsets changing */
506 int internal_time = st->current_time;
507 int color_offset = (st->current_color + (st->info->color_modifier * wcount)) % NCOLORS;
508 if (st->current_time == 0)
511 /* I want the distance between whirlies to increase more each whirly */
512 internal_time = st->current_time + (10 * wcount) + (wcount * wcount);
514 /* All these functions expect an int time, the struct info,
515 a pointer to an array of positions, and the index that the
516 the function will fill of the array */
518 spin(st, internal_time, st->info, st->pos, 0);
521 funky(st, internal_time, st->info, st->pos, 0);
524 circle(st, internal_time, st->info, st->pos, 0);
527 linear(st, internal_time, st->info, st->pos, 0);
530 fun(st, internal_time, st->info, st->pos, 0);
533 test(st, internal_time, st->info, st->pos, 0);
536 innie(st, internal_time, st->info, st->pos, 0, st->modifier);
539 lissajous(st, internal_time, st->info, st->pos, 0);
542 spin(st, internal_time, st->info, st->pos, 0);
544 } /* End of the switch for the x position*/
547 spin(st, internal_time, st->info, st->pos, 1);
550 funky(st, internal_time, st->info, st->pos, 1);
553 circle(st, internal_time, st->info, st->pos, 1);
556 linear(st, internal_time, st->info, st->pos, 1);
559 fun(st, internal_time, st->info, st->pos, 1);
562 test(st, internal_time, st->info, st->pos, 1);
565 innie(st, internal_time, st->info, st->pos, 1, st->modifier);
568 lissajous(st, internal_time, st->info, st->pos, 1);
571 spin(st, internal_time, st->info, st->pos, 1);
573 } /* End of the switch for the y position*/
574 for (lcount = 0; lcount < st->info->nlines; lcount++) {
575 double arg = (double)((internal_time * st->info->offset_period) / 90.0);
576 double line_offset = 20.0 * (double)lcount * sin(arg);
578 size = (int)(15.0 + 5.0 * sin((double)internal_time / 180.0));
579 /* First delete the old circle... */
581 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
582 && ( !st->dbeclear_p || !st->backb)
583 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
585 XSetForeground(st->dpy, st->bgc, BlackPixel(st->dpy, st->screen));
586 XFillArc(st->dpy, st->b, st->bgc, st->last_x[wcount][lcount], st->last_y[wcount][lcount], st->last_size[wcount][lcount], st->last_size[wcount][lcount], START_ARC, END_ARC);
588 /* Now, lets draw in the new circle */
589 { /* Starting new scope for local x_pos and y_pos */
592 xpos = preen((int)(st->info->xoffset*line_offset)+st->pos[0], st->info->half_width * 2);
593 ypos = preen((int)(st->info->yoffset*line_offset)+st->pos[1], st->info->half_height * 2);
596 xpos = (int)(st->info->xoffset*line_offset)+st->pos[0];
597 ypos = (int)(st->info->yoffset*line_offset)+st->pos[1];
599 if (st->start_time == st->current_time) {
600 /* smoothen should move from one mode to another prettily... */
602 /* Note: smoothen has not been modified to take the double
603 buffering code into account, and needs to be hacked on
607 smoothen(xpos, last_x[wcount][lcount], ypos, last_y[wcount][lcount], size, color_offset, colors, dpy, window, bgc, screen, info);
610 st->last_x[wcount][lcount] = xpos;
611 st->last_y[wcount][lcount] = ypos;
612 st->last_size[wcount][lcount] = size;
613 XSetForeground(st->dpy, st->bgc, st->colors[color_offset].pixel);
614 XFillArc(st->dpy, st->b, st->bgc, xpos, ypos, size, size, START_ARC, END_ARC);
615 } /* End of my temporary scope for xpos and ypos */
616 } /* End of the for each line in nlines */
617 } /* End of the for each whirly in whirlies */
620 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
623 XdbeSwapInfo info[1];
624 info[0].swap_window = st->window;
625 info[0].swap_action = (st->dbeclear_p ? XdbeBackground : XdbeUndefined);
626 XdbeSwapBuffers (st->dpy, info, 1);
629 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
632 XCopyArea (st->dpy, st->b, st->window, st->bgc, 0, 0,
633 st->xgwa.width, st->xgwa.height, 0, 0);
636 if (st->current_time == FULL_CYCLE)
637 st->current_time = 1;
639 st->current_time = st->current_time + st->info->speed;
646 whirlygig_reshape (Display *dpy, Window window, void *closure,
647 unsigned int w, unsigned int h)
652 whirlygig_event (Display *dpy, Window window, void *closure, XEvent *event)
658 whirlygig_free (Display *dpy, Window window, void *closure)
663 static const char *whirlygig_defaults [] = {
664 ".background: black",
665 ".foreground: white",
677 "*color_modifier: -1",
684 "*doubleBuffer: True",
685 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
686 "*useDBEClear: True",
688 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
692 static XrmOptionDescRec whirlygig_options [] = {
693 { "-xspeed", ".xspeed", XrmoptionSepArg, 0 },
694 /* xspeed is a modifier of the argument to cos -- changing it thus
695 changes the frequency of cos */
696 { "-yspeed", ".yspeed", XrmoptionSepArg, 0 },
697 /* Similiarly, yspeed changes the frequency of sin */
698 { "-xamplitude", ".xamplitude", XrmoptionSepArg, 0 },
699 /* A factor by which to increase/decrease the amplitude of the sin */
700 { "-yamplitude", ".yamplitude", XrmoptionSepArg, 0 },
701 /* A factor by which to increase/decrease the amplitude of the cos */
702 { "-whirlies", ".whirlies",XrmoptionSepArg, 0 },
703 /* whirlies defines the number of circles to draw per line */
704 { "-nlines", ".nlines",XrmoptionSepArg, 0 },
705 /* nlines is the number of lines of whirlies to draw */
706 { "-xmode", ".xmode", XrmoptionSepArg, 0 },
707 /* There are a few different modes that I have written -- each mode
708 is in theory a different experiment with the possible modifiers to sin/cos */
709 { "-ymode", ".ymode", XrmoptionSepArg, 0 },
710 { "-speed", ".speed", XrmoptionSepArg, 0 },
711 /* This will modify how often it should draw, changing it will probably suck */
712 { "-trail", ".trail", XrmoptionNoArg, "True" },
713 /* Control whether or not you want the old circles to be erased */
714 { "-color_modifier", ".color_modifier", XrmoptionSepArg, 0 },
715 /* How many colors away from the current should the next whirly be? */
716 { "-start_time", ".start_time", XrmoptionSepArg, 0 },
717 /* Specify exactly at what time to start graphing... */
718 { "-xoffset", ".xoffset", XrmoptionSepArg, 0 },
719 /* Tell the whirlies to be offset by this factor of a sin */
720 { "-yoffset", ".yoffset", XrmoptionSepArg, 0 },
721 /* Tell the whirlies to be offset by this factor of a cos */
722 { "-offset_period", ".offset_period", XrmoptionSepArg, 0 },
723 /* Change the period of an offset cycle */
724 { "-explain", ".explain", XrmoptionNoArg, "True" },
725 /* Specify whether or not to print an explanation of the function used. */
726 { "-wrap", ".wrap", XrmoptionNoArg, "True" },
727 { "-no-wrap", ".wrap", XrmoptionNoArg, "False" },
728 /* Specify if you want whirlies which are out of the boundary of the screen to be
729 wrapped around to the other side */
730 { "-db", ".doubleBuffer", XrmoptionNoArg, "True" },
731 { "-no-db", ".doubleBuffer", XrmoptionNoArg, "False" },
735 XSCREENSAVER_MODULE ("Whirlygig", whirlygig)