http://ftp.x.org/contrib/applications/xscreensaver-3.20.tar.gz
[xscreensaver] / hacks / helix.c
1 /* xscreensaver, Copyright (c) 1992, 1995, 1996, 1997
2  *  Jamie Zawinski <jwz@jwz.org>
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation.  No representations are made about the suitability of this
9  * software for any purpose.  It is provided "as is" without express or 
10  * implied warranty.
11  */
12
13 /* Algorithm from a Mac program by Chris Tate, written in 1988 or so. */
14
15 /* 18-Sep-97: Johannes Keukelaar (johannes@nada.kth.se): Improved screen
16  *            eraser.
17  * 10-May-97: merged ellipse code by Dan Stromberg <strombrg@nis.acs.uci.edu>
18  *            as found in xlockmore 4.03a10.
19  * 1992:      jwz created.
20  */
21
22 #include <math.h>
23 #include "screenhack.h"
24 #include "erase.h"
25
26 static double sins [360];
27 static double coss [360];
28
29 static GC draw_gc;
30 static unsigned int default_fg_pixel;
31 static int sleep_time;
32
33 static void
34 init_helix (Display *dpy, Window window)
35 {
36   int i;
37   XGCValues gcv;
38   XWindowAttributes xgwa;
39   Colormap cmap;
40   XGetWindowAttributes (dpy, window, &xgwa);
41   cmap = xgwa.colormap;
42   gcv.foreground = default_fg_pixel =
43     get_pixel_resource ("foreground", "Foreground", dpy, cmap);
44   draw_gc = XCreateGC (dpy, window, GCForeground, &gcv);
45   gcv.foreground = get_pixel_resource ("background", "Background", dpy, cmap);
46
47   for (i = 0; i < 360; i++)
48     {
49       sins [i] = sin ((((double) i) / 180.0) * M_PI);
50       coss [i] = cos ((((double) i) / 180.0) * M_PI);
51     }
52 }
53
54 static int
55 gcd (int a, int b)
56 {
57   while (b > 0)
58     {
59       int tmp;
60       tmp = a % b;
61       a = b;
62       b = tmp;
63     }
64   return (a < 0 ? -a : a);
65 }
66
67 static void
68 helix (Display *dpy, Window window,
69        int radius1, int radius2, int d_angle,
70        int factor1, int factor2, int factor3, int factor4)
71 {
72   XWindowAttributes xgwa;
73   int width, height;
74   int xmid, ymid;
75   int x1, y1, x2, y2, angle, limit;
76   int i;
77
78   XClearWindow (dpy, window);
79   XGetWindowAttributes (dpy, window, &xgwa);
80   width = xgwa.width;
81   height = xgwa.height;
82
83   xmid = width / 2;
84   ymid = height / 2;
85   x1 = xmid;
86   y1 = ymid + radius2;
87   x2 = xmid;
88   y2 = ymid + radius1;
89   angle = 0;
90   limit = 1 + (360 / gcd (360, d_angle));
91   
92   for (i = 0; i < limit; i++)
93     {
94       int tmp;
95 #define pmod(x,y) (tmp=((x) % (y)), (tmp >= 0 ? tmp : (tmp + (y))))
96
97       x1 = xmid + (((double) radius1) * sins [pmod ((angle * factor1), 360)]);
98       y1 = ymid + (((double) radius2) * coss [pmod ((angle * factor2), 360)]);
99       XDrawLine (dpy, window, draw_gc, x1, y1, x2, y2);
100       x2 = xmid + (((double) radius2) * sins [pmod ((angle * factor3), 360)]);
101       y2 = ymid + (((double) radius1) * coss [pmod ((angle * factor4), 360)]);
102
103       XDrawLine (dpy, window, draw_gc, x1, y1, x2, y2);
104       angle += d_angle;
105       XFlush (dpy);
106     }
107 }
108
109 static void
110 trig (Display *dpy, Window window,
111       int d_angle, int factor1, int factor2,
112       int offset, int d_angle_offset, int dir, int density)
113 {
114   XWindowAttributes xgwa;
115   int width, height;
116   int xmid, ymid;
117   int x1, y1, x2, y2;
118   int tmp, angle;
119   Colormap cmap;
120
121   XClearWindow (dpy, window);
122   XGetWindowAttributes (dpy, window, &xgwa);
123   cmap = xgwa.colormap;
124   width = xgwa.width;
125   height = xgwa.height;
126
127   xmid = width / 2;
128   ymid = height / 2;
129
130   while (d_angle >= -360 && d_angle <= 360)
131     {
132       angle = d_angle + d_angle_offset;
133       x1 = (sins [pmod(angle * factor1, 360)] * xmid) + xmid;
134       y1 = (coss [pmod(angle * factor1, 360)] * ymid) + ymid;
135       x2 = (sins [pmod(angle * factor2 + offset, 360)] * xmid) + xmid;
136       y2 = (coss [pmod(angle * factor2 + offset, 360)] * ymid) + ymid;
137       XDrawLine(dpy, window, draw_gc, x1, y1, x2, y2);
138       tmp = (int) 360 / (2 * density * factor1 * factor2);
139       if (tmp == 0)     /* Do not want it getting stuck... */
140         tmp = 1;        /* Would not need if floating point */
141       d_angle += dir * tmp;
142     }
143 }
144
145 #define min(a,b) ((a)<(b)?(a):(b))
146
147 static void
148 random_helix (Display *dpy, Window window, XColor *color, Bool *got_color)
149 {
150   Colormap cmap;
151   int width, height;
152   int radius, radius1, radius2, d_angle, factor1, factor2, factor3, factor4;
153   double divisor;
154   XWindowAttributes xgwa;
155   XGetWindowAttributes (dpy, window, &xgwa);
156   width = xgwa.width;
157   height = xgwa.height;
158   cmap = xgwa.colormap;
159
160   radius = min (width, height) / 2;
161
162   d_angle = 0;
163   factor1 = 2;
164   factor2 = 2;
165   factor3 = 2;
166   factor4 = 2;
167
168   divisor = ((frand (3.0) + 1) * (((random() & 1) * 2) - 1));
169
170   if ((random () & 1) == 0)
171     {
172       radius1 = radius;
173       radius2 = radius / divisor;
174     }
175   else
176     {
177       radius2 = radius;
178       radius1 = radius / divisor;
179     }
180
181   while (gcd (360, d_angle) >= 2)
182     d_angle = random () % 360;
183
184 #define random_factor()                         \
185   (((random() % 7) ? ((random() & 1) + 1) : 3)  \
186    * (((random() & 1) * 2) - 1))
187
188   while (gcd (gcd (gcd (factor1, factor2), factor3), factor4) != 1)
189     {
190       factor1 = random_factor ();
191       factor2 = random_factor ();
192       factor3 = random_factor ();
193       factor4 = random_factor ();
194     }
195
196   if (mono_p)
197     XSetForeground (dpy, draw_gc, default_fg_pixel);
198   else
199     {
200       hsv_to_rgb (random () % 360, frand (1.0), frand (0.5) + 0.5,
201                   &color->red, &color->green, &color->blue);
202       if ((*got_color = XAllocColor (dpy, cmap, color)))
203         XSetForeground (dpy, draw_gc, color->pixel);
204       else
205         XSetForeground (dpy, draw_gc, default_fg_pixel);
206     }
207   helix (dpy, window, radius1, radius2, d_angle,
208          factor1, factor2, factor3, factor4);
209 }
210
211 static void
212 random_trig (Display *dpy, Window window, XColor *color, Bool *got_color)
213 {
214   Colormap cmap;
215   int width, height;
216   int radius, d_angle, factor1, factor2;
217   int offset, d_angle_offset, dir, density;
218
219   XWindowAttributes xgwa;
220   XGetWindowAttributes (dpy, window, &xgwa);
221   width = xgwa.width;
222   height = xgwa.height;
223   cmap = xgwa.colormap;
224
225   radius = min (width, height) / 2;
226
227   d_angle = 0;
228   factor1 = (random() % 8) + 1;
229   do {
230     factor2 = (random() % 8) + 1;
231   } while (factor1 == factor2);
232
233   dir = (random() & 1) ? 1 : -1;
234   d_angle_offset = random() % 360;
235   offset = ((random() % ((360 / 4) - 1)) + 1) / 4;
236   density = 1 << ((random() % 4) + 4);  /* Higher density, higher angles */
237
238   if (mono_p)
239     XSetForeground (dpy, draw_gc, default_fg_pixel);
240   else
241     {
242       hsv_to_rgb (random () % 360, frand (1.0), frand (0.5) + 0.5,
243                   &color->red, &color->green, &color->blue);
244       if ((*got_color = XAllocColor (dpy, cmap, color)))
245         XSetForeground (dpy, draw_gc, color->pixel);
246       else
247         XSetForeground (dpy, draw_gc, default_fg_pixel);
248     }
249   trig (dpy, window, d_angle, factor1, factor2,
250         offset, d_angle_offset, dir, density);
251 }
252
253 static void
254 random_helix_or_trig (Display *dpy, Window window)
255 {
256   Bool free_color = False;
257   XColor color;
258   int width, height;
259   XWindowAttributes xgwa;
260   Colormap cmap;
261   XGetWindowAttributes (dpy, window, &xgwa);
262   width = xgwa.width;
263   height = xgwa.height;
264   cmap = xgwa.colormap;
265
266   if (random() & 1)
267     random_helix(dpy, window, &color, &free_color);
268   else
269     random_trig(dpy, window, &color, &free_color);
270
271   XSync (dpy, False);
272   screenhack_handle_events (dpy);
273   sleep ( sleep_time );
274
275   screenhack_handle_events (dpy);
276   erase_full_window(dpy, window);
277
278   if (free_color) XFreeColors (dpy, cmap, &color.pixel, 1, 0);
279   XSync (dpy, False);
280   screenhack_handle_events (dpy);
281   sleep (1);
282 }
283
284 \f
285 char *progclass = "Helix";
286
287 char *defaults [] = {
288   ".background: black",
289   "*delay:      5",
290   0
291 };
292
293 XrmOptionDescRec options [] = {   
294   { "-delay",           ".delay",               XrmoptionSepArg, 0 },
295   { 0 },
296 };
297 int options_size = (sizeof (options) / sizeof (options[0]));
298
299 void
300 screenhack (Display *dpy, Window window)
301 {
302   sleep_time = get_integer_resource("delay", "Integer");
303   init_helix (dpy, window);
304   while (1)
305     random_helix_or_trig (dpy, window);
306 }