6f547bea4f51ed2b46849d14e64455081a86364a
[xscreensaver] / hacks / ccurve.c
1 /* ccurve, Copyright (c) 1998, 1999
2  *  Rick Campbell <rick@campbellcentral.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
14 /* Draw self-similar linear fractals including the classic ``C Curve''
15  * 
16  * 16 Aug 1999  Rick Campbell <rick@campbellcentral.org>
17  *      Eliminated sub-windows-with-backing-store-double-buffering crap in
18  *      favor of drawing the new image in a pixmap and then splatting that on
19  *      the window.
20  *
21  * 19 Dec 1998  Rick Campbell <rick@campbellcentral.org>
22  *      Original version.
23  */
24
25 #include <assert.h>
26 #include <math.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <time.h>
30
31 #include "screenhack.h"
32 #include "colors.h"
33 #include "erase.h"
34
35 #define SQRT3 (1.73205080756887729353)
36 #define MAXIMUM_COLOR_COUNT (256)
37 #define EPSILON (1e-5)
38
39 typedef struct Position_struct
40 {
41     double x;
42     double y;
43 }
44 Position;
45
46 typedef struct Segment_struct
47 {
48     double angle;
49     double length;
50 }
51 Segment;
52
53 struct state {
54   Display *dpy;
55   Window window;
56
57   int                  color_count;
58   int                  color_index;
59   Colormap             color_map;
60   XColor               colors [MAXIMUM_COLOR_COUNT];
61   int                  line_count;
62   int                  maximum_lines;
63   double               plot_maximum_x;
64   double               plot_maximum_y;
65   double               plot_minimum_x;
66   double               plot_minimum_y;
67   int                  total_lines;
68
69   unsigned long int    background;
70   GC                   context;
71   Pixmap               pixmap;
72   int                  width;
73   int                  height;
74   float                delay;
75   float                delay2;
76
77   int    draw_index;
78
79   int draw_iterations;
80   double draw_maximum_x;
81   double draw_maximum_y;
82   double draw_minimum_x;
83   double draw_minimum_y;
84   int draw_segment_count;
85   Segment* draw_segments;
86   double draw_x1;
87   double draw_y1;
88   double draw_x2;
89   double draw_y2;
90 };
91
92
93
94
95 /* normalize alters the sequence to go from (0,0) to (1,0) */
96 static void
97 normalized_plot (int       segment_count,
98                  Segment*  segments,
99                  Position* points)
100 {
101     double   angle = 0.0;
102     double   cosine = 0.0;
103     int      index = 0;
104     double   length = 0.0;
105     double   sine = 0.0;
106     double   x = 0.0;
107     double   y = 0.0;
108
109     for (index = 0; index < segment_count; ++index)
110     {
111         Segment* segment = segments + index;
112         double length = segment->length;
113         double angle = segment->angle;
114
115         x += length * cos (angle);
116         y += length * sin (angle);
117         points [index].x = x;
118         points [index].y = y;
119     }
120     angle = -(atan2 (y, x));
121     cosine = cos (angle);
122     sine = sin (angle);
123     length = sqrt ((x * x) + (y * y));
124     /* rotate and scale */
125     for (index = 0; index < segment_count; ++index)
126     {
127         double temp_x = points [index].x;
128         double temp_y = points [index].y;
129         points [index].x = ((temp_x * cosine) + (temp_y * (-sine))) / length;
130         points [index].y = ((temp_x * sine) + (temp_y * cosine)) / length;
131     }
132 }
133
134 static void
135 copy_points (int       segment_count,
136              Position* source,
137              Position* target)
138 {
139     int      index = 0;
140
141     for (index = 0; index < segment_count; ++index)
142     {
143         target [index] = source [index];
144     }
145 }
146
147 static void
148 realign (double    x1,
149          double    y1,
150          double    x2,
151          double    y2,
152          int       segment_count,
153          Position* points)
154 {
155     double angle = 0.0;
156     double cosine = 0.0;
157     double delta_x = 0.0;
158     double delta_y = 0.0;
159     int    index = 0;
160     double length = 0.0;
161     double sine = 0.0;
162
163     delta_x = x2 - x1;
164     delta_y = y2 - y1;
165     angle = atan2 (delta_y, delta_x);
166     cosine = cos (angle);
167     sine = sin (angle);
168     length = sqrt ((delta_x * delta_x) + (delta_y * delta_y));
169     /* rotate, scale, then shift */
170     for (index = 0; index < segment_count; ++index)
171     {
172         double temp_x = points [index].x;
173         double temp_y = points [index].y;
174         points [index].x
175             = (length * ((temp_x * cosine) + (temp_y * (-sine)))) + x1;
176         points [index].y
177             = (length * ((temp_x * sine) + (temp_y * cosine))) + y1;
178     }
179 }
180
181 static Bool
182 self_similar_normalized (struct state *st,
183                          int       iterations,
184                          double    x1,
185                          double    y1,
186                          double    x2,
187                          double    y2,
188                          double    maximum_x,
189                          double    maximum_y,
190                          double    minimum_x,
191                          double    minimum_y,
192                          int       segment_count,
193                          Position* points)
194 {
195     if (iterations == 0)
196     {
197         double delta_x = maximum_x - minimum_x;
198         double delta_y = maximum_y - minimum_y;
199         st->color_index = (int)(((double)(st->line_count * st->color_count))
200                             / ((double)st->total_lines));
201         ++st->line_count;
202         XSetForeground (st->dpy, st->context, st->colors [st->color_index].pixel);
203         if (st->plot_maximum_x < x1) st->plot_maximum_x = x1;
204         if (st->plot_maximum_x < x2) st->plot_maximum_x = x2;
205         if (st->plot_maximum_y < y1) st->plot_maximum_y = y1;
206         if (st->plot_maximum_y < y2) st->plot_maximum_y = y2;
207         if (st->plot_minimum_x > x1) st->plot_minimum_x = x1;
208         if (st->plot_minimum_x > x2) st->plot_minimum_x = x2;
209         if (st->plot_minimum_y > y1) st->plot_minimum_y = y1;
210         if (st->plot_minimum_y > y2) st->plot_minimum_y = y2;
211         XDrawLine (st->dpy, st->pixmap, st->context,
212                    (int)(((x1 - minimum_x) / delta_x) * st->width),
213                    (int)(((maximum_y - y1) / delta_y) * st->height),
214                    (int)(((x2 - minimum_x) / delta_x) * st->width),
215                    (int)(((maximum_y - y2) / delta_y) * st->height));
216     }
217     else
218     {
219         int       index = 0;
220         double    next_x = 0.0;
221         double    next_y = 0.0;
222         Position* replacement = (Position*)NULL;
223         double    x = 0.0;
224         double    y = 0.0;
225
226         replacement = (Position*)(malloc (segment_count * sizeof (Segment)));
227         copy_points (segment_count, points, replacement);
228         assert (fabs ((replacement [segment_count - 1].x) - 1.0) < EPSILON);
229         assert (fabs (replacement [segment_count - 1].y) < EPSILON);
230         realign (x1, y1, x2, y2, segment_count, replacement);
231         /* jwz: I don't understand what these assertions are supposed to
232            be detecting, but let's just bail on the fractal instead of
233            crashing. */
234 /*      assert (fabs (x2 - (replacement [segment_count - 1].x)) < EPSILON);
235         assert (fabs (y2 - (replacement [segment_count - 1].y)) < EPSILON);*/
236         if (fabs (x2 - (replacement [segment_count - 1].x)) >= EPSILON ||
237             fabs (y2 - (replacement [segment_count - 1].y)) >= EPSILON) {
238           free (replacement);
239           return False;
240         }
241         x = x1;
242         y = y1;
243         for (index = 0; index < segment_count; ++index)
244         {
245             next_x = replacement [index].x;
246             next_y = replacement [index].y;
247             if (!self_similar_normalized (st, 
248                                      iterations - 1, x, y, next_x, next_y,
249                                      maximum_x, maximum_y,
250                                      minimum_x, minimum_y,
251                                      segment_count, points)) {
252               free(replacement);
253               return False;
254             }
255             x = next_x;
256             y = next_y;
257         }
258         free(replacement);
259     }
260     return True;
261 }
262
263 static void
264 self_similar (struct state *st,
265               Pixmap   pixmap,
266               GC       context,
267               int      width,
268               int      height,
269               int      iterations,
270               double   x1,
271               double   y1,
272               double   x2,
273               double   y2,
274               double   maximum_x,
275               double   maximum_y,
276               double   minimum_x,
277               double   minimum_y,
278               int      segment_count,
279               Segment* segments)
280 {
281     Position* points = (Position*)NULL;
282
283     points = (Position*)(malloc (segment_count * sizeof (Position)));
284     normalized_plot (segment_count, segments, points);
285     assert (fabs ((points [segment_count - 1].x) - 1.0) < EPSILON);
286     assert (fabs (points [segment_count - 1].y) < EPSILON);
287     self_similar_normalized (st, iterations,
288                              x1, y1, x2, y2,
289                              maximum_x, maximum_y,
290                              minimum_x, minimum_y,
291                              segment_count, points);
292     free((void*)points);
293 }
294
295 static
296 double
297 random_double (double base,
298                double limit,
299                double epsilon)
300 {
301     double       range = 0.0;
302     unsigned int steps = 0;
303
304     assert (base < limit);
305     assert (epsilon > 0.0);
306     range = limit - base;
307     steps = (unsigned int)(floor (range / epsilon));
308     return base + ((random () % steps) * epsilon);
309 }
310
311 static void
312 select_2_pattern (Segment* segments)
313 {
314     if ((random () % 2) == 0)
315     {
316         if ((random () % 2) == 0)
317         {
318             segments [0].angle  = -M_PI_4;
319             segments [0].length = M_SQRT2;
320             segments [1].angle  = M_PI_4;
321             segments [1].length = M_SQRT2;
322         }
323         else
324         {
325             segments [0].angle  = M_PI_4;
326             segments [0].length = M_SQRT2;
327             segments [1].angle  = -M_PI_4;
328             segments [1].length = M_SQRT2;
329         }
330     }
331     else
332     {
333         segments [0].angle
334             = random_double (M_PI / 6.0, M_PI / 3.0, M_PI / 180.0);
335         segments [0].length = random_double (0.25, 0.67, 0.001);
336         if ((random () % 2) == 0)
337         {
338             segments [1].angle = -(segments [0].angle);
339             segments [1].length = segments [0].length;
340         }
341         else
342         {
343             segments [1].angle = random_double ((-M_PI) / 3.0,
344                                                 (-M_PI) / 6.0,
345                                                 M_PI / 180.0);
346             segments [1].length = random_double (0.25, 0.67, 0.001);
347         }       
348     }
349 }
350
351 static void
352 select_3_pattern (Segment* segments)
353 {
354     switch (random () % 5)
355     {
356      case 0:
357         if ((random () % 2) == 0)
358         {
359             segments [0].angle  = M_PI_4;
360             segments [0].length = M_SQRT2 / 4.0;
361             segments [1].angle  = -M_PI_4;
362             segments [1].length = M_SQRT2 / 2.0;
363             segments [2].angle  = M_PI_4;
364             segments [2].length = M_SQRT2 / 4.0;
365         }
366         else
367         {
368             segments [0].angle  = -M_PI_4;
369             segments [0].length = M_SQRT2 / 4.0;
370             segments [1].angle  = M_PI_4;
371             segments [1].length = M_SQRT2 / 2.0;
372             segments [2].angle  = -M_PI_4;
373             segments [2].length = M_SQRT2 / 4.0;
374         }
375         break;
376      case 1:
377         if ((random () % 2) == 0)
378         {
379             segments [0].angle  = M_PI / 6.0;
380             segments [0].length = 1.0;
381             segments [1].angle  = -M_PI_2;
382             segments [1].length = 1.0;
383             segments [2].angle  = M_PI / 6.0;
384             segments [2].length = 1.0;
385         }
386         else
387         {
388             segments [0].angle  = -M_PI / 6.0;
389             segments [0].length = 1.0;
390             segments [1].angle  = M_PI_2;
391             segments [1].length = 1.0;
392             segments [2].angle  = -M_PI / 6.0;
393             segments [2].length = 1.0;
394         }
395         break;
396      case 2:
397      case 3:
398      case 4:
399         segments [0].angle
400             = random_double (M_PI / 6.0, M_PI / 3.0, M_PI / 180.0);
401         segments [0].length = random_double (0.25, 0.67, 0.001);
402         segments [1].angle
403             = random_double (-M_PI / 3.0, -M_PI / 6.0, M_PI / 180.0);
404         segments [1].length = random_double (0.25, 0.67, 0.001);
405         if ((random () % 3) == 0)
406         {
407             if ((random () % 2) == 0)
408             {
409                 segments [2].angle = segments [0].angle;
410             }
411             else
412             {
413                 segments [2].angle = -(segments [0].angle);
414             }
415             segments [2].length = segments [0].length;
416         }
417         else
418         {
419             segments [2].angle
420                 = random_double (-M_PI / 3.0, -M_PI / 6.0, M_PI / 180.0);
421             segments [2].length = random_double (0.25, 0.67, 0.001);
422         }
423         break;
424     }
425 }
426
427 static void
428 select_4_pattern (Segment* segments)
429 {
430     switch (random () % 9)
431     {
432      case 0:
433         if ((random () % 2) == 0)
434         {
435             double length = random_double (0.25, 0.50, 0.001);
436
437             segments [0].angle  = 0.0;
438             segments [0].length = 0.5;
439             segments [1].angle  = M_PI_2;
440             segments [1].length = length;
441             segments [2].angle  = -M_PI_2;
442             segments [2].length = length;
443             segments [3].angle  = 0.0;
444             segments [3].length = 0.5;
445         }
446         else
447         {
448             double length = random_double (0.25, 0.50, 0.001);
449
450             segments [0].angle  = 0.0;
451             segments [0].length = 0.5;
452             segments [1].angle  = -M_PI_2;
453             segments [1].length = length;
454             segments [2].angle  = M_PI_2;
455             segments [2].length = length;
456             segments [3].angle  = 0.0;
457             segments [3].length = 0.5;
458         }
459         break;
460      case 1:
461         if ((random () % 2) == 0)
462         {
463             segments [0].angle  = 0.0;
464             segments [0].length = 0.5;
465             segments [1].angle  = M_PI_2;
466             segments [1].length = 0.45;
467             segments [2].angle  = -M_PI_2;
468             segments [2].length = 0.45;
469             segments [3].angle  = 0.0;
470             segments [3].length = 0.5;
471         }
472         else
473         {
474             segments [0].angle  = 0.0;
475             segments [0].length = 0.5;
476             segments [1].angle  = -M_PI_2;
477             segments [1].length = 0.45;
478             segments [2].angle  = M_PI_2;
479             segments [2].length = 0.45;
480             segments [3].angle  = 0.0;
481             segments [3].length = 0.5;
482         }
483         break;
484      case 2:
485         if ((random () % 2) == 0)
486         {
487             segments [0].angle  = 0.0;
488             segments [0].length = 1.0;
489             segments [1].angle  = (5.0 * M_PI) / 12.0;
490             segments [1].length = 1.2;
491             segments [2].angle  = (-5.0 * M_PI) / 12.0;
492             segments [2].length = 1.2;
493             segments [3].angle  = 0.0;
494             segments [3].length = 1.0;
495         }
496         else
497         {
498             segments [0].angle  = 0.0;
499             segments [0].length = 1.0;
500             segments [1].angle  = (-5.0 * M_PI) / 12.0;
501             segments [1].length = 1.2;
502             segments [2].angle  = (5.0 * M_PI) / 12.0;
503             segments [2].length = 1.2;
504             segments [3].angle  = 0.0;
505             segments [3].length = 1.0;
506         }
507         break;
508      case 3:
509         if ((random () % 2) == 0)
510         {
511             double angle
512                 = random_double (M_PI / 4.0,
513                                  M_PI_2,
514                                  M_PI / 180.0);
515
516             segments [0].angle  = 0.0;
517             segments [0].length = 1.0;
518             segments [1].angle  = angle;
519             segments [1].length = 1.2;
520             segments [2].angle  = (-angle);
521             segments [2].length = 1.2;
522             segments [3].angle  = 0.0;
523             segments [3].length = 1.0;
524         }
525         else
526         {
527             double angle
528                 = random_double (M_PI / 4.0,
529                                  M_PI_2,
530                                  M_PI / 180.0);
531
532             segments [0].angle  = 0.0;
533             segments [0].length = 1.0;
534             segments [1].angle  = (-angle);
535             segments [1].length = 1.2;
536             segments [2].angle  = angle;
537             segments [2].length = 1.2;
538             segments [3].angle  = 0.0;
539             segments [3].length = 1.0;
540         }
541         break;
542      case 4:
543         if ((random () % 2) == 0)
544         {
545             double angle
546                 = random_double (M_PI / 4.0,
547                                  M_PI_2,
548                                  M_PI / 180.0);
549
550             segments [0].angle  = 0.0;
551             segments [0].length = 1.0;
552             segments [1].angle  = angle;
553             segments [1].length = 1.2;
554             segments [2].angle  = (-angle);
555             segments [2].length = 1.2;
556             segments [3].angle  = 0.0;
557             segments [3].length = 1.0;
558         }
559         else
560         {
561             double angle
562                 = random_double (M_PI / 4.0,
563                                  M_PI_2,
564                                  M_PI / 180.0);
565
566             segments [0].angle  = 0.0;
567             segments [0].length = 1.0;
568             segments [1].angle  = (-angle);
569             segments [1].length = 1.2;
570             segments [2].angle  = angle;
571             segments [2].length = 1.2;
572             segments [3].angle  = 0.0;
573             segments [3].length = 1.0;
574         }
575         break;
576      case 5:
577         if ((random () % 2) == 0)
578         {
579             double angle
580                 = random_double (M_PI / 4.0,
581                                  M_PI_2,
582                                  M_PI / 180.0);
583             double length = random_double (0.25, 0.50, 0.001);
584
585             segments [0].angle  = 0.0;
586             segments [0].length = 1.0;
587             segments [1].angle  = angle;
588             segments [1].length = length;
589             segments [2].angle  = (-angle);
590             segments [2].length = length;
591             segments [3].angle  = 0.0;
592             segments [3].length = 1.0;
593         }
594         else
595         {
596             double angle
597                 = random_double (M_PI / 4.0,
598                                  M_PI_2,
599                                  M_PI / 180.0);
600             double length = random_double (0.25, 0.50, 0.001);
601
602             segments [0].angle  = 0.0;
603             segments [0].length = 1.0;
604             segments [1].angle  = (-angle);
605             segments [1].length = length;
606             segments [2].angle  = angle;
607             segments [2].length = length;
608             segments [3].angle  = 0.0;
609             segments [3].length = 1.0;
610         }
611         break;
612      case 6:
613      case 7:
614      case 8:
615         segments [0].angle
616             = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
617         segments [0].length = random_double (0.25, 0.50, 0.001);
618         segments [1].angle
619             = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
620         segments [1].length = random_double (0.25, 0.50, 0.001);
621         if ((random () % 3) == 0)
622         {
623             segments [2].angle
624                 = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
625             segments [2].length = random_double (0.25, 0.50, 0.001);
626             segments [3].angle
627                 = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
628             segments [3].length = random_double (0.25, 0.50, 0.001);
629         }
630         else
631         {
632             if ((random () % 2) == 0)
633             {
634                 segments [2].angle = -(segments [1].angle);
635                 segments [2].length = segments [1].length;
636                 segments [3].angle = -(segments [0].angle);
637                 segments [3].length = segments [0].length;
638             }
639             else
640             {
641                 segments [2].angle = segments [1].angle;
642                 segments [2].length = segments [1].length;
643                 segments [3].angle = segments [0].angle;
644                 segments [3].length = segments [0].length;
645             }
646         }
647         break;
648     }
649 }
650
651 static void
652 select_pattern (int      segment_count,
653                 Segment* segments)
654 {
655     switch (segment_count)
656     {
657      case 2:
658         select_2_pattern (segments);
659         break;
660      case 3:
661         select_3_pattern (segments);
662         break;
663      case 4:
664         select_4_pattern (segments);
665         break;
666      default:
667         fprintf (stderr, "\nBad segment count, must be 2, 3, or 4.\n");
668         exit (1);
669     }
670 }
671
672 #define Y_START (0.5)
673
674 static void *
675 ccurve_init (Display *dpy, Window window)
676 {
677   struct state *st = (struct state *) calloc (1, sizeof(*st));
678     unsigned long int    black           = 0;
679     int                  depth           = 0;
680     XWindowAttributes    hack_attributes;
681     XGCValues            values;
682     unsigned long int    white           = 0;
683
684     st->dpy = dpy;
685     st->window = window;
686
687     st->delay = get_float_resource (st->dpy, "delay", "Integer");
688     st->delay2 = get_float_resource (st->dpy, "pause", "Integer");
689     st->maximum_lines = get_integer_resource (st->dpy, "limit", "Integer");
690     black = BlackPixel (st->dpy, DefaultScreen (st->dpy));
691     white = WhitePixel (st->dpy, DefaultScreen (st->dpy));
692     st->background = black;
693     XGetWindowAttributes (st->dpy, st->window, &hack_attributes);
694     st->width = hack_attributes.width;
695     st->height = hack_attributes.height;
696     depth = hack_attributes.depth;
697     st->color_map = hack_attributes.colormap;
698     st->pixmap = XCreatePixmap (st->dpy, st->window, st->width, st->height, depth);
699     values.foreground = white;
700     values.background = black;
701     st->context = XCreateGC (st->dpy, st->window, GCForeground | GCBackground,
702                          &values);
703     st->color_count = MAXIMUM_COLOR_COUNT;
704     make_color_loop (st->dpy, st->color_map,
705                      0,   1, 1,
706                      120, 1, 1,
707                      240, 1, 1,
708                      st->colors, &st->color_count, True, False);
709     if (st->color_count <= 0)
710     {
711         st->color_count = 1;
712         st->colors [0].red = st->colors [0].green = st->colors [0].blue = 0xFFFF;
713         XAllocColor (st->dpy, st->color_map, &st->colors [0]);
714     }
715
716     st->draw_maximum_x =  1.20;
717     st->draw_maximum_y =  0.525;
718     st->draw_minimum_x = -0.20;
719     st->draw_minimum_y = -0.525;
720     st->draw_x2 = 1.0;
721
722     return st;
723 }
724
725 static unsigned long
726 ccurve_draw (Display *dpy, Window window, void *closure)
727 {
728   struct state *st = (struct state *) closure;
729         static const int lengths [] = { 4, 4, 4, 4, 4, 3, 3, 3, 2 };
730
731         if (st->draw_index == 0)
732           {
733         st->draw_segment_count
734             = lengths [random () % (sizeof (lengths) / sizeof (int))];
735         st->draw_segments
736             = (Segment*)(malloc ((st->draw_segment_count) * sizeof (Segment)));
737         select_pattern (st->draw_segment_count, st->draw_segments);
738         st->draw_iterations = floor (log (st->maximum_lines)
739                                 / log (((double)(st->draw_segment_count))));
740         if ((random () % 3) != 0)
741         {
742             double factor = 0.45;
743             st->draw_x1 += random_double (-factor, factor, 0.001);
744             st->draw_y1 += random_double (-factor, factor, 0.001);
745             st->draw_x2 += random_double (-factor, factor, 0.001);
746             st->draw_y2 += random_double (-factor, factor, 0.001);
747         }
748 /*      background = (random () % 2) ? black : white; */
749
750         }
751
752         /* for (st->draw_index = 0; st->draw_index < st->draw_iterations; ++st->draw_index) */
753         {
754             double delta_x = 0.0;
755             double delta_y = 0.0;
756
757             XSetForeground (st->dpy, st->context, st->background);
758             XFillRectangle (st->dpy, st->pixmap, st->context, 0, 0, st->width, st->height);
759             st->line_count = 0;
760             st->total_lines = (int)(pow ((double)(st->draw_segment_count),
761                                      (double)st->draw_index));
762             st->plot_maximum_x = -1000.00;
763             st->plot_maximum_y = -1000.00;
764             st->plot_minimum_x =  1000.00;
765             st->plot_minimum_y =  1000.00;
766             self_similar (st, st->pixmap, st->context, st->width, st->height, st->draw_index,
767                           st->draw_x1, st->draw_y1, st->draw_x2, st->draw_y2,
768                           st->draw_maximum_x,
769                           st->draw_maximum_y,
770                           st->draw_minimum_x,
771                           st->draw_minimum_y,
772                           st->draw_segment_count, st->draw_segments);
773             delta_x = st->plot_maximum_x - st->plot_minimum_x;
774             delta_y = st->plot_maximum_y - st->plot_minimum_y;
775             st->draw_maximum_x = st->plot_maximum_x + (delta_x * 0.2);
776             st->draw_maximum_y = st->plot_maximum_y + (delta_y * 0.2);
777             st->draw_minimum_x = st->plot_minimum_x - (delta_x * 0.2);
778             st->draw_minimum_y = st->plot_minimum_y - (delta_y * 0.2);
779             delta_x = st->draw_maximum_x - st->draw_minimum_x;
780             delta_y = st->draw_maximum_y - st->draw_minimum_y;
781             if ((delta_y / delta_x) > (((double)st->height) / ((double)st->width)))
782             {
783                 double new_delta_x
784                     = (delta_y * ((double)st->width)) / ((double)st->height);
785                 st->draw_minimum_x -= (new_delta_x - delta_x) / 2.0;
786                 st->draw_maximum_x += (new_delta_x - delta_x) / 2.0;
787             }
788             else
789             {
790                 double new_delta_y
791                     = (delta_x * ((double)st->height)) / ((double)st->width);
792                 st->draw_minimum_y -= (new_delta_y - delta_y) / 2.0;
793                 st->draw_maximum_y += (new_delta_y - delta_y) / 2.0;
794             }
795             XCopyArea (st->dpy, st->pixmap, st->window, st->context, 0, 0, st->width, st->height,
796                        0, 0);
797         }
798         st->draw_index++;
799         /* #### mi->recursion_depth = st->draw_index; */
800
801         if (st->draw_index >= st->draw_iterations)
802           {
803             st->draw_index = 0;
804             free((void*)st->draw_segments);
805             st->draw_segments = 0;
806             return (int) (1000000 * st->delay);
807           }
808         else
809           return (int) (1000000 * st->delay2);
810 }
811
812 static void
813 ccurve_reshape (Display *dpy, Window window, void *closure, 
814                  unsigned int w, unsigned int h)
815 {
816   struct state *st = (struct state *) closure;
817   XWindowAttributes xgwa;
818   st->width = w;
819   st->height = h;
820   XGetWindowAttributes (st->dpy, st->window, &xgwa);
821   XFreePixmap (dpy, st->pixmap);
822   st->pixmap = XCreatePixmap (st->dpy, st->window, st->width, st->height,
823                               xgwa.depth);
824 }
825
826 static Bool
827 ccurve_event (Display *dpy, Window window, void *closure, XEvent *event)
828 {
829   return False;
830 }
831
832 static void
833 ccurve_free (Display *dpy, Window window, void *closure)
834 {
835 }
836
837
838 static const char *ccurve_defaults [] =
839 {
840     ".background:  black",
841     ".foreground:  white",
842     ".delay:      3",
843     ".pause:      0.4",
844     ".limit: 200000",
845     0
846 };
847
848 static XrmOptionDescRec ccurve_options [] =
849 {
850     { "-delay", ".delay", XrmoptionSepArg, 0 },
851     { "-pause", ".pause", XrmoptionSepArg, 0 },
852     { "-limit", ".limit", XrmoptionSepArg, 0 },
853     { 0, 0, 0, 0 }
854 };
855
856 XSCREENSAVER_MODULE ("CCurve", ccurve)