From http://www.jwz.org/xscreensaver/xscreensaver-5.35.tar.gz
[xscreensaver] / hacks / whirlygig.c
1 /*  Whirlygig -- an experiment in X programming
2  *
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 
9  * implied warranty.
10  *
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
14  */
15
16 #include <stdio.h>
17 #include <math.h>
18 #include "screenhack.h"
19
20 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
21 # include "xdbe.h"
22 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
23
24 #define NCOLORS 100
25 #define FULL_CYCLE 429496729
26 #define START_ARC 0
27 #define END_ARC 23040
28
29 struct info {
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 */
33     double xamplitude;
34     double yamplitude;
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 */
38     int half_height;
39     int speed;
40     int trail;
41     int color_modifier;
42     double xoffset;
43     double yoffset;
44     double offset_period;
45     Bool wrap;
46 };
47
48 enum object_mode {
49     spin_mode, funky_mode, circle_mode, linear_mode, test_mode, fun_mode, innie_mode, lissajous_mode
50 };
51
52 struct state {
53   Display *dpy;
54   Window window;
55
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
60     Bool dbeclear_p;
61     XdbeBackBuffer backb;
62 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
63
64     GC fgc, bgc;
65     int screen;
66     Bool dbuf;
67
68     unsigned long int current_time; /* The global int telling the current time */
69     unsigned long int start_time;
70     struct info  *info;
71     char *xmode_str, *ymode_str; /* holds the current mode for x and y computation */
72
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 */
77
78     int pos[2], last_x[100][100], last_y[100][100], last_size[100][100];
79     int current_color;
80     Bool wrap;
81     int xmode, ymode;
82     double modifier;    /* for innie */
83
84    XColor colors[NCOLORS];
85    int ncolors;
86    int explaining;
87 };
88
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);
98
99
100
101 static const char spin_explanation[] =
102 "Spin mode is a simple sin/cos with every argument modified";
103
104 static const char funky_explanation[] =
105 "Funky mode is me goofing off.";
106
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.";
109
110 static const char linear_explanation[] =
111 "Linear mode draws a straight line";
112
113 static const char test_explanation[] =
114 "Test mode is a mode that I play around with ideas in.";
115
116 static const char fun_explanation[] =
117 "Fun mode is the coolest.";
118
119 static const char innie_explanation[] =
120 "Innie mode does something or other. Looks cool, though.";
121
122 static const char lissajous_explanation[] =
123 "Lissajous mode draws a slightly modified lissajous curve";
124
125 static void
126 draw_explain_string(struct state *st, int mode, int offset, Display *dpy, Window window, GC fgc) 
127 {
128   switch(mode) {
129   case spin_mode:
130     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
131                 (char*) spin_explanation, strlen(spin_explanation));
132     break;
133   case funky_mode:
134     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
135                 (char*) funky_explanation, strlen(funky_explanation));
136     break;
137   case circle_mode:
138     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
139                 (char*) circle_explanation, strlen(circle_explanation));
140     break;
141   case linear_mode:
142     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
143                 (char*) linear_explanation, strlen(linear_explanation));
144     break;
145   case test_mode:
146     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
147                 (char*) test_explanation, strlen(test_explanation));
148     break;
149   case fun_mode:
150     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
151                 (char*) fun_explanation, strlen(fun_explanation));
152     break;
153   case innie_mode:
154     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
155                 (char*) innie_explanation, strlen(innie_explanation));
156     break;
157   case lissajous_mode:
158     XDrawString(st->dpy, st->window, st->fgc, 50, offset, 
159                 (char*) lissajous_explanation, strlen(linear_explanation));    
160   }
161 }
162
163 static void
164 funky(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
165 {
166     double new_time = ((the_time % 360 ) / 180.0) * M_PI;
167     if (index == 0) {
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;
172     }
173     else {
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;
179     }
180 }
181
182 static void
183 innie(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index, double modifier)
184 {
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;
190     if (index == 0) {
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;
193     }
194     else {
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;
197     }
198 }
199
200 static void
201 lissajous(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
202 {
203       /*  This is a pretty standard lissajous curve
204            x = a sin(nt + c) 
205            y = b sin(t) 
206            The n and c modifiers are cyclic as well, however... */
207   int result;
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);
211
212   if (index == 0) {
213       result = st->info->xamplitude * 200.0 * sin((weird * time) + fun) + st->info->half_width;
214   }
215   else {
216       result = st->info->yamplitude * 200.0 * sin(time) + st->info->half_height;
217   }
218   st->pos[index] = result;
219
220
221 static void
222 circle(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
223 {
224     int result;
225     if (index == 0) {
226         result = st->info->xamplitude * (cos((double)the_time / 100.0 * st->info->xspeed) * (st->info->half_width / 2)) + st->info->half_width;
227     }
228     else {
229         result = st->info->yamplitude * (sin((double)the_time / 100.0 * st->info->yspeed) * (st->info->half_height / 2)) + st->info->half_height;
230     }
231     st->pos[index] = result;
232 }
233
234 #if 0
235 static void
236 mod(unsigned long int the_time, struct info *info, int pos[], int index)
237 {
238     int amplitude;
239     int max = st->info->half_width;
240     if ((the_time % (max * 2)) < max)
241         amplitude = max - ((the_time % (max * 2)) - max);
242     else
243         amplitude = the_time % (max * 2);
244     amplitude = amplitude - max;
245 }
246 #endif
247
248 static void
249 spin(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
250 {
251     double funky = (((the_time % 360) * 1.0) / 180.0) * M_PI;
252     if (index ==0) {
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;
256     }
257     else {
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;
261     }
262 }
263
264 static void
265 fun(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
266 {
267     int amplitude;
268     int max = st->info->half_width;
269     if ((the_time % (max * 2)) < max)
270         amplitude = max - ((the_time % (max * 2)) - max);
271     else
272         amplitude = the_time % (max * 2);
273     amplitude = amplitude - max;
274     if (index ==0) {
275         st->pos[index] = (amplitude * cos((double)the_time / 100.0 * st->info->xspeed)) + st->info->half_width;
276     }
277     else {
278         st->pos[index] = (amplitude * sin((double)the_time / 100.0 * st->info->yspeed)) + st->info->half_height;
279     }
280 }
281
282 static void
283 linear(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
284 {
285     if (index == 0)   /* Calculate for the x axis */
286         st->pos[index] = ((the_time / 2) % (st->info->half_width * 2));
287     else
288         st->pos[index] = ((the_time / 2) % (st->info->half_height * 2));
289 }
290
291 static void
292 test(struct state *st, unsigned long int the_time, struct info *info, int pos[], int index)
293 {
294     if (index == 0) {
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;
296     }
297     else {
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;
299     }   
300 }
301
302 static int preen(int current, int max) {
303     if (current > max)
304         current=current-max;
305     if (current < 0)
306         current=current+max;
307     return(current);
308 }
309
310 #if 0
311 static void
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)
313 {
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);
325         }
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);
329     }
330 }
331 #endif
332
333
334 static void *
335 whirlygig_init (Display *dpy, Window window)
336 {
337   struct state *st = (struct state *) calloc (1, sizeof(*st));
338   st->dpy = dpy;
339   st->window = window;
340
341   st->ncolors = NCOLORS;
342
343     st->dbuf = get_boolean_resource (st->dpy, "doubleBuffer", "Boolean");
344
345 # ifdef HAVE_JWXYZ      /* Don't second-guess Quartz's double-buffering */
346     st->dbuf = False;
347 # endif
348
349     st->start_time = st->current_time;
350     st->info = (struct info *)malloc(sizeof(struct info));
351
352     st->screen = DefaultScreen(st->dpy);
353     XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
354     if (st->dbuf)
355       {
356 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
357         if (get_boolean_resource(st->dpy,"useDBE","Boolean"))
358           {
359             st->dbeclear_p = get_boolean_resource (st->dpy, "useDBEClear",
360                                                    "Boolean");
361             if (st->dbeclear_p)
362               st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeBackground);
363             else
364               st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeUndefined);
365             st->backb = st->b;
366           }
367 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
368
369         if (!st->b)
370           {
371             st->ba = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height,st->xgwa.depth);
372             st->b = st->ba;
373           }
374       }
375     else
376       {
377         st->b = st->window;
378       }
379
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);
384
385 #ifdef HAVE_JWXYZ  /* #### should turn off double-buffering instead */
386     jwxyz_XSetAntiAliasing (dpy, st->fgc, False);
387     jwxyz_XSetAntiAliasing (dpy, st->bgc, False);
388 #endif
389
390     {
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);
395     }
396
397     if (st->ba) XFillRectangle (st->dpy, st->ba, st->bgc, 0, 0, st->xgwa.width, st->xgwa.height);
398
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;
430     else {
431         st->xmode = random() % (int) lissajous_mode;
432     }
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;
442     else {
443         st->ymode = random() % (int) lissajous_mode;
444     }
445
446     if (get_integer_resource(st->dpy, "start_time", "Integer") == -1)
447         st->current_time = (unsigned long int)(random());
448     else
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"))
457       st->explaining = 1;
458     st->current_color = 1 + (random() % NCOLORS);
459
460   return st;
461 }
462
463 static unsigned long
464 whirlygig_draw (Display *dpy, Window window, void *closure)
465 {
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;
470
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);
475     st->explaining++;
476     return 3000000;
477   } else if (st->explaining == 2) {
478     XClearWindow (st->dpy, st->window);
479     st->explaining = 0;
480   }
481
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);
487     }
488   }
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);
493     }
494   }
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);
500     }
501   }
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 = 0;
507     int color_offset = (st->current_color + (st->info->color_modifier * wcount)) % NCOLORS;
508     if (st->current_time != 0)
509       /* I want the distance between whirlies to increase more each whirly */
510       internal_time = st->current_time + (10 * wcount) + (wcount * wcount); 
511     switch (st->xmode) {
512       /* All these functions expect an int time, the struct info,
513          a pointer to an array of positions, and the index that the 
514          the function will fill of the array */
515     case spin_mode:
516       spin(st, internal_time, st->info, st->pos, 0);
517       break;
518     case funky_mode:
519       funky(st, internal_time, st->info, st->pos, 0);
520       break;
521     case circle_mode:
522       circle(st, internal_time, st->info, st->pos, 0);
523       break;
524     case linear_mode:
525       linear(st, internal_time, st->info, st->pos, 0);
526       break;
527     case fun_mode:
528       fun(st, internal_time, st->info, st->pos, 0);
529       break;
530     case test_mode:
531       test(st, internal_time, st->info, st->pos, 0);
532       break;
533     case innie_mode:
534       innie(st, internal_time, st->info, st->pos, 0, st->modifier);
535       break;
536     case lissajous_mode:
537       lissajous(st, internal_time, st->info, st->pos, 0);
538       break;
539     default:
540       spin(st, internal_time, st->info, st->pos, 0);
541       break;
542     }   /* End of the switch for the x position*/
543     switch (st->ymode) {
544     case spin_mode:
545       spin(st, internal_time, st->info, st->pos, 1);
546       break;
547     case funky_mode:
548       funky(st, internal_time, st->info, st->pos, 1);
549       break;
550     case circle_mode:
551       circle(st, internal_time, st->info, st->pos, 1);
552       break;
553     case linear_mode:
554       linear(st, internal_time, st->info, st->pos, 1);
555       break;
556     case fun_mode:
557       fun(st, internal_time, st->info, st->pos, 1);
558       break;
559     case test_mode:
560       test(st, internal_time, st->info, st->pos, 1);
561       break;
562     case innie_mode:
563       innie(st, internal_time, st->info, st->pos, 1, st->modifier);
564       break;
565     case lissajous_mode:
566       lissajous(st, internal_time, st->info, st->pos, 1);
567       break;
568     default:
569       spin(st, internal_time, st->info, st->pos, 1);
570       break;
571     } /* End of the switch for the y position*/
572     for (lcount = 0; lcount < st->info->nlines; lcount++) {
573       double arg = (double)((internal_time * st->info->offset_period) / 90.0); 
574       double line_offset = 20.0 * (double)lcount * sin(arg); 
575       int size;
576       size = (int)(15.0 + 5.0 * sin((double)internal_time / 180.0));
577       /* First delete the old circle... */
578       if (!st->info->trail
579 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
580           && ( !st->dbeclear_p || !st->backb)
581 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
582           ) {
583         XSetForeground(st->dpy, st->bgc, BlackPixel(st->dpy, st->screen));
584         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);
585       }
586       /* Now, lets draw in the new circle */
587       {  /* Starting new scope for local x_pos and y_pos */
588         int xpos, ypos;
589         if (st->wrap) {
590           xpos = preen((int)(st->info->xoffset*line_offset)+st->pos[0], st->info->half_width * 2);
591           ypos = preen((int)(st->info->yoffset*line_offset)+st->pos[1], st->info->half_height * 2);
592         }
593         else {
594           xpos = (int)(st->info->xoffset*line_offset)+st->pos[0];
595           ypos = (int)(st->info->yoffset*line_offset)+st->pos[1]; 
596         }
597         if (st->start_time == st->current_time) {
598           /* smoothen should move from one mode to another prettily... */
599
600           /* Note: smoothen has not been modified to take the double
601              buffering code into account, and needs to be hacked on
602              before uncommenting.
603           */
604           /* 
605              smoothen(xpos, last_x[wcount][lcount], ypos, last_y[wcount][lcount], size, color_offset, colors, dpy, window, bgc, screen, info);
606           */
607         }
608         st->last_x[wcount][lcount] = xpos;
609         st->last_y[wcount][lcount] = ypos;
610         st->last_size[wcount][lcount] = size;
611         XSetForeground(st->dpy, st->bgc, st->colors[color_offset].pixel);
612         XFillArc(st->dpy, st->b, st->bgc, xpos, ypos, size, size, START_ARC, END_ARC);
613       } /* End of my temporary scope for xpos and ypos */
614     }  /* End of the for each line in nlines */
615   } /* End of the for each whirly in whirlies */
616
617
618 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
619   if (st->backb)
620     {
621       XdbeSwapInfo info[1];
622       info[0].swap_window = st->window;
623       info[0].swap_action = (st->dbeclear_p ? XdbeBackground : XdbeUndefined);
624       XdbeSwapBuffers (st->dpy, info, 1);
625     }
626   else
627 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
628     if (st->dbuf)
629       {
630         XCopyArea (st->dpy, st->b, st->window, st->bgc, 0, 0,
631                    st->xgwa.width, st->xgwa.height, 0, 0);
632       }
633
634   if (st->current_time == FULL_CYCLE)
635     st->current_time = 1;
636   else
637     st->current_time = st->current_time + st->info->speed;
638
639   return 10000;
640 }
641
642
643 static void
644 whirlygig_reshape (Display *dpy, Window window, void *closure, 
645                  unsigned int w, unsigned int h)
646 {
647 }
648
649 static Bool
650 whirlygig_event (Display *dpy, Window window, void *closure, XEvent *event)
651 {
652   return False;
653 }
654
655 static void
656 whirlygig_free (Display *dpy, Window window, void *closure)
657 {
658 }
659
660
661 static const char *whirlygig_defaults [] = {
662   ".background: black",
663   ".foreground: white",
664   "*fpsSolid:   true",
665   "*xspeed: 1.0",
666   "*yspeed: 1.0",
667   "*xamplitude: 1.0",
668   "*yamplitude: 1.0",
669   "*whirlies: -1",
670   "*nlines: -1",
671   "*xmode: change",
672   "*ymode: change",
673   "*speed: 1",
674   "*trail: false",
675   "*color_modifier: -1",
676   "*start_time: -1",
677   "*explain: False",
678   "*xoffset: 1.0",
679   "*yoffset: 1.0",
680   "*offset_period:    1",
681   "*wrap:               False",
682   "*doubleBuffer:       True",
683 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
684   "*useDBEClear:        True",
685   "*useDBE:             True",
686 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
687   0
688 };
689
690 static XrmOptionDescRec whirlygig_options [] = {
691   { "-xspeed",          ".xspeed", XrmoptionSepArg, 0 },
692       /* xspeed is a modifier of the argument to cos -- changing it thus
693          changes the frequency of cos */
694   { "-yspeed",          ".yspeed", XrmoptionSepArg, 0 },
695       /*  Similiarly, yspeed changes the frequency of sin */
696   { "-xamplitude",      ".xamplitude", XrmoptionSepArg, 0 },
697       /* A factor by which to increase/decrease the amplitude of the sin */
698   { "-yamplitude",      ".yamplitude", XrmoptionSepArg, 0 },
699       /* A factor by which to increase/decrease the amplitude of the cos */
700   { "-whirlies",         ".whirlies",XrmoptionSepArg, 0 },
701       /*  whirlies defines the number of circles to draw per line */
702   { "-nlines",         ".nlines",XrmoptionSepArg, 0 },
703       /* nlines is the number of lines of whirlies to draw */
704   { "-xmode",        ".xmode", XrmoptionSepArg, 0 },
705       /*  There are a few different modes that I have written -- each mode
706           is in theory a different experiment with the possible modifiers to sin/cos */
707   { "-ymode",       ".ymode", XrmoptionSepArg, 0 },
708   { "-speed",        ".speed", XrmoptionSepArg, 0 },
709       /*  This will modify how often it should draw, changing it will probably suck */
710   { "-trail",           ".trail", XrmoptionNoArg, "True" },
711       /* Control whether or not you want the old circles to be erased */
712   { "-color_modifier",          ".color_modifier", XrmoptionSepArg, 0 },
713       /*  How many colors away from the current should the next whirly be? */
714   { "-start_time",                ".start_time", XrmoptionSepArg, 0 },
715       /*  Specify exactly at what time to start graphing...  */
716   { "-xoffset",                    ".xoffset", XrmoptionSepArg, 0 },
717       /*  Tell the whirlies to be offset by this factor of a sin */
718   { "-yoffset",                    ".yoffset", XrmoptionSepArg, 0 },
719       /*  Tell the whirlies to be offset by this factor of a cos */
720   { "-offset_period",          ".offset_period", XrmoptionSepArg, 0 },
721       /*  Change the period of an offset cycle */
722   { "-explain",                    ".explain", XrmoptionNoArg, "True" },
723       /*  Specify whether or not to print an explanation of the function used. */
724   { "-wrap",                      ".wrap", XrmoptionNoArg, "True" },
725   { "-no-wrap",                   ".wrap", XrmoptionNoArg, "False" },
726       /* Specify if you want whirlies which are out of the boundary of the screen to be
727          wrapped around to the other side */
728   { "-db",              ".doubleBuffer", XrmoptionNoArg,  "True" },
729   { "-no-db",           ".doubleBuffer", XrmoptionNoArg,  "False" },
730   { 0, 0, 0, 0 }
731 };
732
733 XSCREENSAVER_MODULE ("Whirlygig", whirlygig)