http://www.jwz.org/xscreensaver/xscreensaver-5.10.tar.gz
[xscreensaver] / hacks / bubbles.c
1 /* bubbles.c - frying pan / soft drink in a glass simulation */
2
3 /*$Id: bubbles.c,v 1.30 2008/07/31 19:27:48 jwz Exp $*/
4
5 /*
6  *  Copyright (C) 1995-1996 James Macnicol
7  *
8  * Permission to use, copy, modify, distribute, and sell this software and its
9  * documentation for any purpose is hereby granted without fee, provided that
10  * the above copyright notice appear in all copies and that both that
11  * copyright notice and this permission notice appear in supporting
12  * documentation.  No representations are made about the suitability of this
13  * software for any purpose.  It is provided "as is" without express or 
14  * implied warranty.
15  */
16
17 /*
18  * I got my original inspiration for this by looking at the bottom of a 
19  * frying pan while something was cooking and watching the little bubbles
20  * coming off the bottom of the pan as the oil was boiling joining together
21  * to form bigger bubbles and finally to *pop* and disappear.  I had some
22  * time on my hands so I wrote this little xscreensaver module to imitate
23  * it.  Now that it's done it reminds me more of the bubbles you get in
24  * a glass of fizzy soft drink.....
25  *
26  * The problem seemed to be that the position/size etc. of all the bubbles
27  * on the screen had to be remembered and searched through to find when
28  * bubbles hit each other and combined.  To do this more efficiently, the
29  * window/screen is divided up into a square mesh of side length mesh_length
30  * and separate lists of bubbles contained in each cell of the mesh are
31  * kept.  Only the cells in the immediate vicinity of the bubble in question
32  * are searched.  This should make things more efficient although the whole
33  * thing seems to use up too much CPU, but then I'm using an ancient PC so
34  * perhaps it's not surprising .
35  * (Six months after I wrote the above I now have a Pentium with PCI graphics 
36  * and things are _much_ nicer.)
37  *
38  * Author:           James Macnicol 
39  * Internet E-mail : j-macnicol@adfa.edu.au
40  */
41
42 #ifdef HAVE_CONFIG_H
43 # include "config.h"
44 #endif
45
46 #include <math.h>
47 #include <limits.h>
48
49 #ifndef VMS
50 # include <sys/wait.h>
51 #else /* VMS */
52 # if __DECC_VER >= 50200000
53 #  include <sys/wait.h>
54 # endif
55 #endif /* VMS */
56
57 #ifdef HAVE_UNISTD_H
58 # include <unistd.h>
59 #endif
60
61 #include "screenhack.h"
62 #include "yarandom.h"
63 #include "bubbles.h"
64 #include "xpm-pixmap.h"
65
66 #if defined(HAVE_GDK_PIXBUF) || defined(HAVE_XPM)
67 # define FANCY_BUBBLES
68 #endif
69
70 /* 
71  * Public variables 
72  */
73
74 static const char *bubbles_defaults [] = {
75   ".background:         black",
76   ".foreground:         white",
77   "*fpsSolid:           true",
78   "*simple:             false",
79   "*broken:             false",
80   "*delay:              10000",
81   "*quiet:              false", 
82   "*mode:               float",
83   "*trails:             false",
84   "*3D:                 false",
85   0
86 };
87
88 static XrmOptionDescRec bubbles_options [] = {
89   { "-simple",          ".simple",      XrmoptionNoArg, "true" },
90 #ifdef FANCY_BUBBLES
91   { "-broken",          ".broken",      XrmoptionNoArg, "true" },
92 #endif
93   { "-quiet",           ".quiet",       XrmoptionNoArg, "true" },
94   { "-3D",          ".3D",      XrmoptionNoArg, "true" },
95   { "-delay",           ".delay",       XrmoptionSepArg, 0 },
96   { "-mode",            ".mode",        XrmoptionSepArg, 0 },
97   { "-drop",            ".mode",        XrmoptionNoArg, "drop" },
98   { "-rise",            ".mode",        XrmoptionNoArg, "rise" },
99   { "-trails",          ".trails",      XrmoptionNoArg, "true" },
100   { 0, 0, 0, 0 }
101 };
102
103 /* 
104  * Private variables 
105  */
106
107 struct state {
108   Display *dpy;
109   Window window;
110
111   Bubble **mesh;
112   int mesh_length;
113   int mesh_width;
114   int mesh_height;
115   int mesh_cells;
116
117   int **adjacent_list;
118
119   int screen_width;
120   int screen_height;
121   int screen_depth;
122   unsigned int default_fg_pixel, default_bg_pixel;
123
124   int bubble_min_radius;        /* For simple mode only */
125   int bubble_max_radius;
126   long *bubble_areas;
127   int *bubble_droppages;
128   GC draw_gc, erase_gc;
129
130 #ifdef FANCY_BUBBLES
131   int num_bubble_pixmaps;
132   Bubble_Step **step_pixmaps;
133 #endif
134
135   Bool simple;
136   Bool broken;
137   Bool quiet;
138   Bool threed;
139   Bool drop;
140   Bool trails;
141   int drop_dir;
142   int delay;
143 };
144
145 static int drop_bubble( struct state *st, Bubble *bb );
146
147 /* 
148  * To prevent forward references, some stuff is up here 
149  */
150
151 static long
152 calc_bubble_area(struct state *st, int r)
153 /* Calculate the area of a bubble of radius r */
154 {
155 #ifdef DEBUG
156   printf("%d %g\n", r,
157          10.0 * PI * (double)r * (double)r * (double)r);
158 #endif /* DEBUG */
159   if (st->threed)
160     return (long)(10.0 * PI * (double)r * (double)r * (double)r);
161   else
162     return (long)(10.0 * PI * (double)r * (double)r);
163 }
164
165 static void *
166 xmalloc(size_t size)
167 /* Safe malloc */
168 {
169   void *ret;
170
171   if ((ret = malloc(size)) == NULL) {
172     fprintf(stderr, "%s: out of memory\n", progname);
173     exit(1);
174   }
175   return ret;
176 }
177
178 #ifdef DEBUG
179 static void 
180 die_bad_bubble(Bubble *bb)
181 /* This is for use with GDB */
182 {
183   fprintf(stderr, "Bad bubble detected at 0x%x!\n", (int)bb);
184   exit(1);
185 }
186 #endif
187
188 static int
189 null_bubble(Bubble *bb)
190 /* Returns true if the pointer passed is NULL.  If not then this checks to
191 see if the bubble is valid (i.e. the (x,y) position is valid and the magic
192 number is set correctly.  This only a sanity check for debugging and is
193 turned off if DEBUG isn't set. */
194 {
195   if (bb == (Bubble *)NULL)
196     return 1;
197 #ifdef DEBUG
198   if ((bb->cell_index < 0) || (bb->cell_index > st->mesh_cells)) {
199     fprintf(stderr, "cell_index = %d\n", bb->cell_index);
200     die_bad_bubble(bb);
201   }
202   if (bb->magic != BUBBLE_MAGIC)  {
203     fprintf(stderr, "Magic = %d\n", bb->magic);
204     die_bad_bubble(bb);
205   }
206   if (st->simple) {
207     if ((bb->x < 0) || (bb->x > st->screen_width) ||
208         (bb->y < 0) || (bb->y > st->screen_height) ||
209         (bb->radius < st->bubble_min_radius) || (bb->radius >
210                                              st->bubble_max_radius)) {
211       fprintf(stderr,
212               "radius = %d, x = %d, y = %d, magic = %d, cell index = %d\n",
213               bb->radius, bb->x, bb->y, bb->magic, bb->cell_index);
214       die_bad_bubble(bb);  
215     }
216 #ifdef FANCY_BUBBLES
217   } else {
218     if ((bb->x < 0) || (bb->x > st->screen_width) ||
219         (bb->y < 0) || (bb->y > st->screen_height) ||
220         (bb->radius < st->step_pixmaps[0]->radius) || 
221         (bb->radius > st->step_pixmaps[st->num_bubble_pixmaps-1]->radius)) {
222       fprintf(stderr,
223               "radius = %d, x = %d, y = %d, magic = %d, cell index = %d\n",
224               bb->radius, bb->x, bb->y, bb->magic, bb->cell_index);
225       die_bad_bubble(bb);  
226     }
227 #endif
228   }
229 #endif /* DEBUG */
230   return 0;
231 }
232
233 #ifdef DEBUG
234 static void 
235 print_bubble_list(Bubble *bb)
236 /* Print list of where all the bubbles are.  For debugging purposes only. */
237 {
238   if (! null_bubble(bb)) {
239     printf("  (%d, %d) %d\n", bb->x, bb->y, bb->radius);
240     print_bubble_list(bb->next);
241   }
242 }
243 #endif /* DEBUG */
244
245 static void 
246 add_bubble_to_list(Bubble **list, Bubble *bb)
247 /* Take a pointer to a list of bubbles and stick bb at the head of the
248  list. */
249 {
250   Bubble *head = *list;
251
252   if (null_bubble(head)) {
253     bb->prev = (Bubble *)NULL;
254     bb->next = (Bubble *)NULL;
255   } else {
256     bb->next = head;
257     bb->prev = (Bubble *)NULL;
258     head->prev = bb;
259   }
260   *list = bb;
261 }
262
263
264 /* 
265  * Mesh stuff 
266  */
267
268
269 static void 
270 init_mesh (struct state *st)
271 /* Setup the mesh of bubbles */
272 {
273   int i;
274
275   st->mesh = (Bubble **)xmalloc(st->mesh_cells * sizeof(Bubble *));
276   for (i = 0; i < st->mesh_cells; i++)
277     st->mesh[i] = (Bubble *)NULL;
278 }
279
280 static int
281 cell_to_mesh(struct state *st, int x, int y)
282 /* convert cell coordinates to mesh index */
283 {
284 #ifdef DEBUG
285   if ((x < 0) || (y < 0)) {
286     fprintf(stderr, "cell_to_mesh: x = %d, y = %d\n", x, y);
287     exit(1);
288   }
289 #endif
290   return ((st->mesh_width * y) + x);
291 }
292
293 static void 
294 mesh_to_cell(struct state *st, int mi, int *cx, int *cy)
295 /* convert mesh index into cell coordinates */
296 {
297   *cx = mi % st->mesh_width;
298   *cy = mi / st->mesh_width;
299 }
300
301 static int
302 pixel_to_mesh(struct state *st, int x, int y)
303 /* convert screen coordinates into mesh index */
304 {
305   return cell_to_mesh(st, (x / st->mesh_length), (y / st->mesh_length));
306 }
307
308 static int
309 verify_mesh_index(struct state *st, int x, int y)
310 /* check to see if (x,y) is in the mesh */
311 {
312   if ((x < 0) || (y < 0) || (x >= st->mesh_width) || (y >= st->mesh_height))
313     return (-1);
314   return (cell_to_mesh(st, x, y));
315 }
316
317 #ifdef DEBUG
318 static void 
319 print_adjacents(int *adj)
320 /* Print a list of the cells calculated above.  For debugging only. */
321 {
322   int i;
323
324   printf("(");
325   for (i = 0; i < 8; i++)
326     printf("%d ", adj[i]);
327   printf(")\n");
328 }
329 #endif /* DEBUG */
330
331 static void 
332 add_to_mesh(struct state *st, Bubble *bb)
333 /* Add the given bubble to the mesh by sticking it on the front of the
334 list.  bb is already allocated so no need to malloc() anything, just
335 adjust pointers. */
336 {
337 #ifdef DEBUG
338   if (null_bubble(bb)) {
339     fprintf(stderr, "Bad bubble passed to add_to_mesh()!\n");
340     exit(1);
341   }
342 #endif /* DEBUG */
343
344   add_bubble_to_list(&st->mesh[bb->cell_index], bb);
345 }
346
347 #ifdef DEBUG
348 static void 
349 print_mesh (struct state *st)
350 /* Print the contents of the mesh */
351 {
352   int i;
353
354   for (i = 0; i < st->mesh_cells; i++) {
355     if (! null_bubble(st->mesh[i])) {
356       printf("Mesh cell %d\n", i);
357       print_bubble_list(st->mesh[i]);
358     }
359   }
360 }
361
362 static void 
363 valid_mesh (struct state *st)
364 /* Check to see if the mesh is Okay.  For debugging only. */
365 {
366   int i;
367   Bubble *b;
368
369   for (i = 0; i < st->mesh_cells; i++) {
370     b = st->mesh[i];
371     while (! null_bubble(b))
372       b = b->next;
373   }
374 }
375
376 static int
377 total_bubbles (struct state *st)
378 /* Count how many bubbles there are in total.  For debugging only. */
379 {
380   int rv = 0;
381   int i;
382   Bubble *b;
383
384   for (i = 0; i < st->mesh_cells; i++) {
385     b = st->mesh[i];
386     while (! null_bubble(b)) {
387       rv++;
388       b = b->next;
389     } 
390   }
391
392   return rv;
393 }
394 #endif /* DEBUG */
395
396 static void 
397 calculate_adjacent_list (struct state *st)
398 /* Calculate the list of cells adjacent to a particular cell for use
399    later. */
400 {
401   int i; 
402   int ix, iy;
403
404   st->adjacent_list = (int **)xmalloc(st->mesh_cells * sizeof(int *));
405   for (i = 0; i < st->mesh_cells; i++) {
406     st->adjacent_list[i] = (int *)xmalloc(9 * sizeof(int));
407     mesh_to_cell(st, i, &ix, &iy);
408     st->adjacent_list[i][0] = verify_mesh_index(st, --ix, --iy);
409     st->adjacent_list[i][1] = verify_mesh_index(st, ++ix, iy);
410     st->adjacent_list[i][2] = verify_mesh_index(st, ++ix, iy);
411     st->adjacent_list[i][3] = verify_mesh_index(st, ix, ++iy);
412     st->adjacent_list[i][4] = verify_mesh_index(st, ix, ++iy);
413     st->adjacent_list[i][5] = verify_mesh_index(st, --ix, iy);
414     st->adjacent_list[i][6] = verify_mesh_index(st, --ix, iy);
415     st->adjacent_list[i][7] = verify_mesh_index(st, ix, --iy);
416     st->adjacent_list[i][8] = i;
417   }
418 }
419
420 static void
421 adjust_areas (struct state *st)
422 /* Adjust areas of bubbles so we don't get overflow in weighted_mean() */
423 {
424   double maxvalue;
425   long maxarea;
426   long factor;
427   int i;
428
429 #ifdef FANCY_BUBBLES
430   if (st->simple)
431     maxarea = st->bubble_areas[st->bubble_max_radius+1];
432   else
433     maxarea = st->step_pixmaps[st->num_bubble_pixmaps]->area;
434 #else /* !FANCY_BUBBLES */
435   maxarea = st->bubble_areas[st->bubble_max_radius+1];
436 #endif /* !FANCY_BUBBLES */
437   maxvalue = (double)st->screen_width * 2.0 * (double)maxarea;
438   factor = (long)ceil(maxvalue / (double)LONG_MAX);
439   if (factor > 1) {
440     /* Overflow will occur in weighted_mean().  We must divide areas
441        each by factor so it will never do so. */
442 #ifdef FANCY_BUBBLES
443     if (st->simple) {
444       for (i = st->bubble_min_radius; i <= st->bubble_max_radius+1; i++) {
445         st->bubble_areas[i] /= factor;
446         if (st->bubble_areas[i] == 0)
447           st->bubble_areas[i] = 1;
448       }
449     } else {
450       for (i = 0; i <= st->num_bubble_pixmaps; i++) {
451 #ifdef DEBUG
452         printf("area = %ld", st->step_pixmaps[i]->area);
453 #endif /* DEBUG */
454         st->step_pixmaps[i]->area /= factor;
455         if (st->step_pixmaps[i]->area == 0)
456           st->step_pixmaps[i]->area = 1;
457 #ifdef DEBUG
458         printf("-> %ld\n", st->step_pixmaps[i]->area);
459 #endif /* DEBUG */
460       }
461     }
462 #else /* !FANCY_BUBBLES */
463     for (i = st->bubble_min_radius; i <= st->bubble_max_radius+1; i++) {
464       st->bubble_areas[i] /= factor;
465       if (st->bubble_areas[i] == 0)
466         st->bubble_areas[i] = 1;
467     }
468 #endif /* !FANCY_BUBBLES */
469   }
470 #ifdef DEBUG
471   printf("maxarea = %ld\n", maxarea);
472   printf("maxvalue = %g\n", maxvalue);
473   printf("LONG_MAX = %ld\n", LONG_MAX);
474   printf("factor = %ld\n", factor);
475 #endif /* DEBUG */
476 }
477
478 /* 
479  * Bubbles stuff 
480  */
481
482 static Bubble *
483 new_bubble (struct state *st)
484 /* Add a new bubble at some random position on the screen of the smallest
485 size. */
486 {
487   Bubble *rv = (Bubble *)xmalloc(sizeof(Bubble));
488
489   /* Can't use null_bubble() here since magic number hasn't been set */
490   if (rv == (Bubble *)NULL) {
491     fprintf(stderr, "Ran out of memory!\n");
492     exit(1);
493   }
494
495   if (st->simple) {
496     rv->radius = st->bubble_min_radius;
497     rv->area = st->bubble_areas[st->bubble_min_radius];
498 #ifdef FANCY_BUBBLES
499   } else {
500     rv->step = 0;
501     rv->radius = st->step_pixmaps[0]->radius;
502     rv->area = st->step_pixmaps[0]->area;
503 #endif /* FANCY_BUBBLES */
504   }
505   rv->visible = 0;
506   rv->magic = BUBBLE_MAGIC;
507   rv->x = random() % st->screen_width;
508   rv->y = random() % st->screen_height;
509   rv->cell_index = pixel_to_mesh(st, rv->x, rv->y);
510
511   return rv;
512 }
513
514 static void 
515 show_bubble(struct state *st, Bubble *bb)
516 /* paint the bubble on the screen */
517 {
518   if (null_bubble(bb)) {
519     fprintf(stderr, "NULL bubble passed to show_bubble\n");
520     exit(1);
521   }
522
523   if (! bb->visible) {
524     bb->visible = 1;
525
526     if (st->simple) {
527       XDrawArc(st->dpy, st->window, st->draw_gc, (bb->x - bb->radius),
528                (bb->y - bb->radius), bb->radius*2, bb->radius*2, 0,
529                360*64);  
530     } else {
531 #ifdef FANCY_BUBBLES
532       XSetClipOrigin(st->dpy, st->step_pixmaps[bb->step]->draw_gc, 
533                      (bb->x - bb->radius),
534                      (bb->y - bb->radius));
535       
536       XCopyArea(st->dpy, st->step_pixmaps[bb->step]->ball, st->window, 
537                 st->step_pixmaps[bb->step]->draw_gc,
538                 0, 0, (bb->radius * 2), 
539                 (bb->radius * 2),  
540                 (bb->x - bb->radius),
541                 (bb->y - bb->radius));
542 #endif /* FANCY_BUBBLES */
543     }
544   }
545 }
546
547 static void 
548 hide_bubble(struct state *st, Bubble *bb)
549 /* erase the bubble */
550 {
551   if (null_bubble(bb)) {
552     fprintf(stderr, "NULL bubble passed to hide_bubble\n");
553     exit(1);
554   }
555
556   if (bb->visible) {
557     bb->visible = 0;
558
559     if (st->simple) {
560       XDrawArc(st->dpy, st->window, st->erase_gc, (bb->x - bb->radius),
561                (bb->y - bb->radius), bb->radius*2, bb->radius*2, 0,
562                360*64);
563     } else {
564 #ifdef FANCY_BUBBLES
565       if (! st->broken) {
566         XSetClipOrigin(st->dpy, st->step_pixmaps[bb->step]->erase_gc, 
567                        (bb->x - bb->radius), (bb->y - bb->radius));
568         
569         XFillRectangle(st->dpy, st->window, st->step_pixmaps[bb->step]->erase_gc,
570                        (bb->x - bb->radius),
571                        (bb->y - bb->radius),
572                        (bb->radius * 2),
573                        (bb->radius * 2));
574       }
575 #endif /* FANCY_BUBBLES */
576     }
577   }
578 }
579
580 static void 
581 delete_bubble_in_mesh(struct state *st, Bubble *bb, int keep_bubble)
582 /* Delete an individual bubble, adjusting list of bubbles around it.
583    If keep_bubble is true then the bubble isn't actually deleted.  We
584    use this to allow bubbles to change mesh cells without reallocating,
585    (it needs this when two bubbles collide and the centre position is
586    recalculated, and this may stray over a mesh boundary). */
587 {
588   if ((!null_bubble(bb->prev)) && (!null_bubble(bb->next))) {
589     bb->prev->next = bb->next;
590     bb->next->prev = bb->prev;
591   } else if ((!null_bubble(bb->prev)) &&
592              (null_bubble(bb->next))) {
593     bb->prev->next = (Bubble *)NULL;
594     bb->next = st->mesh[bb->cell_index];
595   } else if ((null_bubble(bb->prev)) &&
596              (!null_bubble(bb->next))) {
597     bb->next->prev = (Bubble *)NULL;
598     st->mesh[bb->cell_index] = bb->next;
599     bb->next = st->mesh[bb->cell_index];
600   } else {
601     /* Only item on list */
602     st->mesh[bb->cell_index] = (Bubble *)NULL;
603   }              
604   if (! keep_bubble)
605     free(bb);
606 }
607
608 static unsigned long 
609 ulongsqrint(int x)
610 /* Saves ugly inline code */
611 {
612   return ((unsigned long)x * (unsigned long)x);
613 }
614
615 static Bubble *
616 get_closest_bubble(struct state *st, Bubble *bb)
617 /* Find the closest bubble touching the this bubble, NULL if none are
618    touching. */
619 {
620   Bubble *rv = (Bubble *)NULL;
621   Bubble *tmp;
622   unsigned long separation2, touchdist2;
623   int dx, dy;
624   unsigned long closest2 = ULONG_MAX;
625   int i;
626
627 #ifdef DEBUG 
628   if (null_bubble(bb)) {
629     fprintf(stderr, "NULL pointer 0x%x passed to get_closest_bubble()!", 
630             (int)bb);
631     exit(1);
632   }
633 #endif /* DEBUG */
634
635   for (i = 0; i < 9; i++) {
636     /* There is a bug here where bb->cell_index is negaitve.. */
637 #ifdef DEBUG
638     if ((bb->cell_index < 0) || (bb->cell_index >= st->mesh_cells)) {
639       fprintf(stderr, "bb->cell_index = %d\n", bb->cell_index);
640       exit(1);
641     }
642 #endif /* DEBUG */
643 /*    printf("%d,", bb->cell_index); */
644     if (st->adjacent_list[bb->cell_index][i] != -1) {
645       tmp = st->mesh[st->adjacent_list[bb->cell_index][i]];
646       while (! null_bubble(tmp)) {
647         if (tmp != bb) {
648           dx = tmp->x - bb->x;
649           dy = tmp->y - bb->y;
650           separation2 = ulongsqrint(dx) + ulongsqrint(dy);
651           /* Add extra leeway so circles _never_ overlap */
652           touchdist2 = ulongsqrint(tmp->radius + bb->radius + 2);
653           if ((separation2 <= touchdist2) && (separation2 <
654                                               closest2)) {
655             rv = tmp;
656             closest2 = separation2;
657           }
658         }
659         tmp = tmp->next;
660       }
661     }
662   }
663
664   return rv;
665 }
666
667 #ifdef DEBUG
668 static void
669 ldr_barf (struct state *st)
670 {
671 }
672 #endif /* DEBUG */
673
674 static long
675 long_div_round(long num, long dem)
676 {
677   long divvie, moddo;
678
679 #ifdef DEBUG
680   if ((num < 0) || (dem < 0)) {
681     fprintf(stderr, "long_div_round: %ld, %ld\n", num, dem);
682     ldr_barf();
683     exit(1);
684   }
685 #endif /* DEBUG */
686
687   divvie = num / dem;
688   moddo = num % dem;
689   if (moddo > (dem / 2))
690     ++divvie;
691
692 #ifdef DEBUG
693   if ((divvie < 0) || (moddo < 0)) {
694     fprintf(stderr, "long_div_round: %ld, %ld\n", divvie, moddo);
695     ldr_barf();
696     exit(1);
697   }
698 #endif /* DEBUG */
699
700   return divvie;
701 }
702
703 static int
704 weighted_mean(int n1, int n2, long w1, long w2)
705 /* Mean of n1 and n2 respectively weighted by weights w1 and w2. */
706 {
707 #ifdef DEBUG
708   if ((w1 <= 0) || (w2 <= 0)) {
709     fprintf(stderr,
710             "Bad weights passed to weighted_mean() - (%d, %d, %ld, %ld)!\n",
711             n1, n2, w1, w2);
712     exit(1);
713   }
714 #endif /* DEBUG */
715   return ((int)long_div_round((long)n1 * w1 + (long)n2 * w2,
716                            w1 + w2));
717 }
718
719 static int
720 bubble_eat(struct state *st, Bubble *diner, Bubble *food)
721 /* The diner eats the food.  Returns true (1) if the diner still exists */
722
723   int i;
724   int newmi;
725
726 #ifdef DEBUG
727   if ((null_bubble(diner)) || (null_bubble(food))) {
728     fprintf(stderr, "Bad bubbles passed to bubble_eat()!\n");
729     exit(1);
730   }
731 #endif /* DEBUG */
732
733   /* We hide the diner even in the case that it doesn't grow so that
734      if the food overlaps its boundary it is replaced. This could
735      probably be solved by letting bubbles eat others which are close
736      but not quite touching.  It's probably worth it, too, since we
737      would then not have to redraw bubbles which don't change in
738      size. */
739
740   hide_bubble(st, diner);
741   hide_bubble(st, food);
742   diner->x = weighted_mean(diner->x, food->x, diner->area, food->area);
743   diner->y = weighted_mean(diner->y, food->y, diner->area, food->area);
744   newmi = pixel_to_mesh(st, diner->x, diner->y);
745   diner->area += food->area;
746   delete_bubble_in_mesh(st, food, DELETE_BUBBLE);
747
748   if (st->drop) {
749         if ((st->simple) && (diner->area > st->bubble_areas[st->bubble_max_radius])) {
750           diner->area = st->bubble_areas[st->bubble_max_radius];
751         }
752 #ifdef FANCY_BUBBLES
753         if ((! st->simple) && (diner->area > st->step_pixmaps[st->num_bubble_pixmaps]->area)) {
754           diner->area = st->step_pixmaps[st->num_bubble_pixmaps]->area;
755         }
756 #endif /* FANCY_BUBBLES */
757   }
758   else {
759         if ((st->simple) && (diner->area > st->bubble_areas[st->bubble_max_radius])) {
760           delete_bubble_in_mesh(st, diner, DELETE_BUBBLE);
761           return 0;
762         }
763 #ifdef FANCY_BUBBLES
764         if ((! st->simple) && (diner->area > 
765                                            st->step_pixmaps[st->num_bubble_pixmaps]->area)) {
766           delete_bubble_in_mesh(st, diner, DELETE_BUBBLE);
767           return 0;
768         }
769 #endif /* FANCY_BUBBLES */
770   }
771
772   if (st->simple) {
773     if (diner->area > st->bubble_areas[diner->radius + 1]) {
774       /* Move the bubble to a new radius */
775       i = diner->radius;
776       while ((i < st->bubble_max_radius - 1) && (diner->area > st->bubble_areas[i+1]))
777                 ++i;
778       diner->radius = i;
779     }
780     show_bubble(st, diner);
781 #ifdef FANCY_BUBBLES
782   } else {
783     if (diner->area > st->step_pixmaps[diner->step+1]->area) {
784       i = diner->step;
785       while ((i < st->num_bubble_pixmaps - 1) && (diner->area > st->step_pixmaps[i+1]->area))
786                 ++i;
787       diner->step = i;
788       diner->radius = st->step_pixmaps[diner->step]->radius;
789     }
790     show_bubble(st, diner);
791 #endif /* FANCY_BUBBLES */
792   }
793
794   /* Now adjust locations and cells if need be */
795   if (newmi != diner->cell_index) {
796     delete_bubble_in_mesh(st, diner, KEEP_BUBBLE);
797     diner->cell_index = newmi;
798     add_to_mesh(st, diner);
799   }
800
801   return 1;
802 }
803
804 static int
805 merge_bubbles(struct state *st, Bubble *b1, Bubble *b2)
806 /* These two bubbles merge into one.  If the first one wins out return
807 1 else return 2.  If there is no winner (it explodes) then return 0 */
808 {
809   int b1size, b2size;
810
811   b1size = b1->area;
812   b2size = b2->area;
813
814 #ifdef DEBUG
815   if ((null_bubble(b1) || null_bubble(b2))) {
816     fprintf(stderr, "NULL bubble passed to merge_bubbles()!\n");
817     exit(1);
818   }
819 #endif /* DEBUG */
820
821   if (b1 == b2) {
822     hide_bubble(st, b1);
823     delete_bubble_in_mesh(st, b1, DELETE_BUBBLE);
824     return 0;
825   }
826
827   if (b1size > b2size) {
828     switch (bubble_eat(st, b1, b2)) {
829     case 0:
830       return 0;
831       break;
832     case 1:
833       return 1;
834       break;
835     default:
836       break;
837     }
838   } else if (b1size < b2size) {
839     switch (bubble_eat(st, b2, b1)) {
840     case 0:
841       return 0;
842       break;
843     case 1:
844       return 2;
845       break;
846     default:
847       break;
848     }
849   } else {
850     if ((random() % 2) == 0) {
851       switch (bubble_eat(st, b1, b2)) {
852       case 0:
853         return 0;
854         break;
855       case 1:
856         return 1;
857         break;
858       default:
859         break;
860       }
861     } else {
862       switch (bubble_eat(st, b2, b1)) {
863       case 0:
864         return 0;
865         break;
866       case 1:
867         return 2;
868         break;
869       default:
870         break;
871       }
872     }
873   }
874   fprintf(stderr, "An error occurred in merge_bubbles()\n");
875   exit(1);
876 }
877
878 static void 
879 insert_new_bubble(struct state *st, Bubble *tmp)
880 /* Calculates which bubbles are eaten when a new bubble tmp is
881    inserted.  This is called recursively in case when a bubble grows
882    it eats others.  Careful to pick out disappearing bubbles. */
883 {
884   Bubble *nextbub;
885   Bubble *touch;
886
887 #ifdef DEBUG
888   if (null_bubble(tmp)) {
889     fprintf(stderr, "Bad bubble passed to insert_new_bubble()!\n");
890     exit(1);
891   }
892 #endif /* DEBUG */
893   
894   nextbub = tmp;
895   touch = get_closest_bubble(st, nextbub);
896   if (null_bubble(touch))
897         return;
898
899   while (1) {
900
901         /* Merge all touching bubbles */
902         while (! null_bubble(touch)) {
903           switch (merge_bubbles(st, nextbub, touch)) {
904           case 2:
905                 /* touch ate nextbub and survived */
906                 nextbub = touch;
907                 break;
908           case 1:
909                 /* nextbub ate touch and survived */
910                 break;
911           case 0:
912                 /* somebody ate someone else but they exploded */
913                 nextbub = (Bubble *)NULL;
914                 break;
915           default:
916                 /* something went wrong */
917                 fprintf(stderr, "Error occurred in insert_new_bubble()\n");
918                 exit(1);
919           }
920         
921           /* Check to see if any bubble survived. */
922           if (null_bubble(nextbub))
923                 break;
924
925           /* Check to see if there are any other bubbles still in the area
926                  and if we need to do this all over again for them. */
927           touch = get_closest_bubble(st, nextbub);
928         }
929         
930         if (null_bubble(nextbub))
931           break;
932
933         /* Shift bubble down.  Break if we run off the screen. */
934         if (st->drop) {
935           if (drop_bubble( st, nextbub ) == -1)
936                 break;
937         }
938
939         /* Check to see if there are any other bubbles still in the area
940            and if we need to do this all over again for them. */
941         touch = get_closest_bubble(st, nextbub);
942         if (null_bubble(touch)) {
943           /* We also continue every so often if we're dropping and the bubble is at max size */
944           if (st->drop) {
945                 if (st->simple) {
946                   if ((nextbub->area >= st->bubble_areas[st->bubble_max_radius - 1]) && (random() % 2 == 0))
947                         continue;
948                 }
949 #ifdef FANCY_BUBBLES
950                 else {
951                   if ((nextbub->step >= st->num_bubble_pixmaps - 1) && (random() % 2 == 0))
952                         continue;
953                 }
954 #endif /* FANCY_BUBBLES */
955       }
956           break;
957         }
958
959   }
960 }
961
962
963 static void
964 leave_trail(struct state *st,  Bubble *bb ) 
965 {
966   Bubble *tmp;
967
968   tmp = new_bubble(st);
969   tmp->x = bb->x;
970   tmp->y = bb->y - ((bb->radius + 10) * st->drop_dir);
971   tmp->cell_index = pixel_to_mesh(st, tmp->x, tmp->y);
972   add_to_mesh(st, tmp);
973   insert_new_bubble(st, tmp);
974   show_bubble( st, tmp );       
975 }
976
977
978 static int
979 drop_bubble( struct state *st, Bubble *bb )
980 {
981   int newmi;
982
983   hide_bubble( st, bb );
984
985   if (st->simple)
986         (bb->y) += (st->bubble_droppages[bb->radius] * st->drop_dir);
987 #ifdef FANCY_BUBBLES
988   else
989         (bb->y) += (st->step_pixmaps[bb->step]->droppage * st->drop_dir);
990 #endif /* FANCY_BUBBLES */
991   if ((bb->y < 0) || (bb->y > st->screen_height)) {
992         delete_bubble_in_mesh( st, bb, DELETE_BUBBLE );
993         return -1;
994   }
995
996   show_bubble( st, bb );
997
998   /* Now adjust locations and cells if need be */
999   newmi = pixel_to_mesh(st, bb->x, bb->y);
1000   if (newmi != bb->cell_index) {
1001     delete_bubble_in_mesh(st, bb, KEEP_BUBBLE);
1002     bb->cell_index = newmi;
1003     add_to_mesh(st, bb);
1004   }
1005
1006   if (st->trails) {
1007         if (st->simple) {
1008           if ((bb->area >= st->bubble_areas[st->bubble_max_radius - 1]) && (random() % 2 == 0)) 
1009                 leave_trail( st, bb );
1010         }
1011 #ifdef FANCY_BUBBLES
1012         else { 
1013           if ((bb->step >= st->num_bubble_pixmaps - 1) && (random() % 2 == 0))
1014                 leave_trail( st, bb );
1015         }
1016 #endif /* FANCY_BUBBLES */
1017   }
1018
1019   return 0;
1020 }
1021
1022
1023 #ifdef DEBUG
1024 static int
1025 get_length_of_bubble_list(Bubble *bb)
1026 {
1027   Bubble *tmp = bb;
1028   int rv = 0;
1029
1030   while (! null_bubble(tmp)) {
1031     rv++;
1032     tmp = tmp->next;
1033   }
1034
1035   return rv;
1036 }
1037 #endif /* DEBUG */
1038
1039 /*
1040  * Pixmap stuff used regardless of whether file I/O is available.  Must
1041  * still check for XPM, though!
1042  */
1043
1044 #ifdef FANCY_BUBBLES
1045
1046 /*
1047  * Pixmaps without file I/O (but do have XPM)
1048  */
1049
1050 static void 
1051 pixmap_sort(Bubble_Step **head, int numelems)
1052 /* Couldn't get qsort to work right with this so I wrote my own.  This puts
1053 the numelems length array with first element at head into order of radius.
1054 */
1055 {
1056   Bubble_Step tmp;
1057   Bubble_Step *least = 0;
1058   int minradius = INT_MAX;
1059   int i;
1060
1061   for (i = 0; i < numelems; i++) {
1062     if (head[i]->radius < minradius) {
1063       least = head[i];
1064       minradius = head[i]->radius;
1065     }
1066   }
1067   if (*head != least) {
1068     memcpy(&tmp, least, sizeof(Bubble_Step));
1069     memcpy(least, *head, sizeof(Bubble_Step));
1070     memcpy(*head, &tmp, sizeof(Bubble_Step));
1071   }
1072
1073   if (numelems > 2)
1074     pixmap_sort(&head[1], numelems-1);
1075 }
1076
1077 static int
1078 extrapolate(int i1, int i2)
1079 {
1080   return (i2 + (i2 - i1));
1081 }
1082
1083 static void 
1084 make_pixmap_array(struct state *st, Bubble_Step *list)
1085 /* From a linked list of bubbles construct the array step_pixmaps */
1086 {
1087   Bubble_Step *tmp = list;
1088   int ind;
1089 #ifdef DEBUG
1090   int prevrad = -1;
1091 #endif
1092   
1093   if (list == (Bubble_Step *)NULL) {
1094     fprintf(stderr, "NULL list passed to make_pixmap_array\n");
1095     exit(1);
1096   }
1097
1098   st->num_bubble_pixmaps = 1;
1099   while(tmp->next != (Bubble_Step *)NULL) {
1100     tmp = tmp->next;
1101     ++st->num_bubble_pixmaps;
1102   }
1103
1104   if (st->num_bubble_pixmaps < 2) {
1105     fprintf(stderr, "Must be at least two bubbles in file\n");
1106     exit(1);
1107   }
1108
1109   st->step_pixmaps = (Bubble_Step **)xmalloc((st->num_bubble_pixmaps + 1) * 
1110                                          sizeof(Bubble_Step *));
1111
1112   /* Copy them blindly into the array for sorting. */
1113   ind = 0;
1114   tmp = list;
1115   do {
1116     st->step_pixmaps[ind++] = tmp;
1117     tmp = tmp->next;
1118   } while(tmp != (Bubble_Step *)NULL);
1119
1120   /* We make another bubble beyond the ones with pixmaps so that the final
1121      bubble hangs around and doesn't pop immediately.  It's radius and area
1122      are found by extrapolating from the largest two bubbles with pixmaps. */
1123
1124   st->step_pixmaps[st->num_bubble_pixmaps] = 
1125     (Bubble_Step *)xmalloc(sizeof(Bubble_Step));
1126   st->step_pixmaps[st->num_bubble_pixmaps]->radius = INT_MAX;
1127
1128   pixmap_sort(st->step_pixmaps, (st->num_bubble_pixmaps + 1));
1129
1130 #ifdef DEBUG
1131   if (st->step_pixmaps[st->num_bubble_pixmaps]->radius != INT_MAX) {
1132     fprintf(stderr, "pixmap_sort() screwed up make_pixmap_array\n");
1133   }
1134 #endif /* DEBUG */
1135
1136   st->step_pixmaps[st->num_bubble_pixmaps]->radius = 
1137     extrapolate(st->step_pixmaps[st->num_bubble_pixmaps-2]->radius,
1138                 st->step_pixmaps[st->num_bubble_pixmaps-1]->radius);
1139   st->step_pixmaps[st->num_bubble_pixmaps]->area = 
1140     calc_bubble_area(st, st->step_pixmaps[st->num_bubble_pixmaps]->radius);
1141   
1142
1143 #ifdef DEBUG
1144   /* Now check for correct order */
1145   for (ind = 0; ind < st->num_bubble_pixmaps; ind++) {
1146     if (prevrad > 0) {
1147       if (st->step_pixmaps[ind]->radius < prevrad) {
1148         fprintf(stderr, "Pixmaps not in ascending order of radius\n");
1149         exit(1);
1150       }
1151     }
1152     prevrad = st->step_pixmaps[ind]->radius;
1153   }
1154 #endif /* DEBUG */
1155
1156   /* Now populate the droppage values */
1157   for (ind = 0; ind < st->num_bubble_pixmaps; ind++)
1158           st->step_pixmaps[ind]->droppage = MAX_DROPPAGE * ind / st->num_bubble_pixmaps;
1159 }
1160
1161 static void
1162 make_pixmap_from_default(struct state *st, char **pixmap_data, Bubble_Step *bl)
1163 /* Read pixmap data which has been compiled into the program and a pointer
1164  to which has been passed. 
1165
1166  This is virtually copied verbatim from make_pixmap_from_file() above and
1167 changes made to either should be propagated onwards! */
1168 {
1169   XGCValues gcv;
1170
1171 #ifdef DEBUG
1172   if (pixmap_data == (char **)0) {
1173     fprintf(stderr, "make_pixmap_from_default(): NULL passed\n");
1174     exit(1);
1175   }
1176 #endif
1177
1178   if (bl == (Bubble_Step *)NULL) {
1179     fprintf(stderr, "NULL pointer passed to make_pixmap()\n");
1180     exit(1);
1181   }
1182
1183 #ifdef FANCY_BUBBLES
1184   {
1185     int w, h;
1186     bl->ball = xpm_data_to_pixmap (st->dpy, st->window, (char **) pixmap_data,
1187                                    &w, &h, &bl->shape_mask);
1188     bl->radius = MAX(w, h) / 2;
1189     bl->area = calc_bubble_area(st, bl->radius);
1190   }
1191 #endif /* FANCY_BUBBLES */
1192
1193   gcv.foreground = st->default_fg_pixel;
1194   gcv.function = GXcopy;
1195   bl->draw_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
1196   XSetClipMask(st->dpy, bl->draw_gc, bl->shape_mask);
1197   
1198   gcv.foreground = st->default_bg_pixel;
1199   gcv.function = GXcopy;
1200   bl->erase_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
1201   XSetClipMask(st->dpy, bl->erase_gc, bl->shape_mask);
1202 }
1203
1204 static void 
1205 default_to_pixmaps (struct state *st)
1206 /* Make pixmaps out of default ball data stored in bubbles_default.c */
1207 {
1208   int i;
1209   Bubble_Step *pixmap_list = (Bubble_Step *)NULL;
1210   Bubble_Step *newpix, *tmppix;
1211   char **pixpt;
1212
1213   init_default_bubbles();
1214
1215   for (i = 0; i < num_default_bubbles; i++) {
1216     pixpt = default_bubbles[i];
1217     newpix = (Bubble_Step *)xmalloc(sizeof(Bubble_Step));
1218     make_pixmap_from_default(st, pixpt, newpix);
1219     /* Now add to list */
1220     if (pixmap_list == (Bubble_Step *)NULL) {
1221       pixmap_list = newpix;
1222     } else {
1223       tmppix = pixmap_list;
1224       while (tmppix->next != (Bubble_Step *)NULL)
1225         tmppix = tmppix->next;
1226       tmppix->next = newpix;
1227     }
1228     newpix->next = (Bubble_Step *)NULL;
1229   }
1230   
1231   /* Finally construct step_pixmaps[] */
1232   make_pixmap_array(st, pixmap_list);
1233 }
1234
1235 #endif /* FANCY_BUBBLES */
1236
1237
1238 /* 
1239  * Main stuff 
1240  */
1241
1242
1243 static void 
1244 get_resources(struct state *st)
1245 /* Get the appropriate X resources and warn about any inconsistencies. */
1246 {
1247   Bool rise;
1248   XWindowAttributes xgwa;
1249   Colormap cmap;
1250   char *s;
1251   XGetWindowAttributes (st->dpy, st->window, &xgwa);
1252   cmap = xgwa.colormap;
1253
1254   st->threed = get_boolean_resource(st->dpy, "3D", "Boolean");
1255   st->quiet = get_boolean_resource(st->dpy, "quiet", "Boolean");
1256   st->simple = get_boolean_resource(st->dpy, "simple", "Boolean");
1257   /* Forbid rendered bubbles on monochrome displays */
1258   if ((mono_p) && (! st->simple)) {
1259     if (! st->quiet)
1260       fprintf(stderr,
1261               "Rendered bubbles not supported on monochrome displays\n");
1262     st->simple = True;
1263   }
1264   st->delay = get_integer_resource(st->dpy, "delay", "Integer");
1265
1266   s = get_string_resource (st->dpy, "mode", "Mode");
1267   rise = False;
1268   if (!s || !*s || !strcasecmp (s, "float"))
1269     ;
1270   else if (!strcasecmp (s, "rise"))
1271     rise = True;
1272   else if (!strcasecmp (s, "drop"))
1273     st->drop = True;
1274   else
1275     fprintf (stderr, "%s: bogus mode: \"%s\"\n", progname, s);
1276
1277   st->trails = get_boolean_resource(st->dpy, "trails", "Boolean");
1278   st->drop_dir = (st->drop ? 1 : -1);
1279   if (st->drop || rise)
1280         st->drop = 1;
1281
1282   st->default_fg_pixel = get_pixel_resource (st->dpy,
1283                                          cmap, "foreground", "Foreground");
1284   st->default_bg_pixel = get_pixel_resource (st->dpy,
1285                                          cmap, "background", "Background");
1286
1287   if (st->simple) {
1288     /* This is easy */
1289     st->broken = get_boolean_resource(st->dpy, "broken", "Boolean");
1290     if (st->broken)
1291       if (! st->quiet)
1292         fprintf(stderr, "-broken not available in simple mode\n");
1293   } else {
1294 #ifndef FANCY_BUBBLES
1295     st->simple = 1;
1296 #else  /* FANCY_BUBBLES */
1297     st->broken = get_boolean_resource(st->dpy, "broken", "Boolean");
1298 #endif /* FANCY_BUBBLES */
1299   }
1300 }
1301
1302 static void *
1303 bubbles_init (Display *dpy, Window window)
1304 {
1305   struct state *st = (struct state *) calloc (1, sizeof(*st));
1306   XGCValues gcv;
1307   XWindowAttributes xgwa;
1308   int i;
1309
1310   st->dpy = dpy;
1311   st->window = window;
1312
1313   get_resources(st);
1314
1315   XGetWindowAttributes (st->dpy, st->window, &xgwa);
1316
1317 #ifdef DEBUG
1318   printf("sizof(int) on this platform is %d\n", sizeof(int));
1319   printf("sizof(long) on this platform is %d\n", sizeof(long));
1320 #endif /* DEBUG */
1321
1322   st->screen_width = xgwa.width;
1323   st->screen_height = xgwa.height;
1324   st->screen_depth = xgwa.depth;
1325
1326   if (st->simple) {
1327     /* These are pretty much plucked out of the air */
1328     st->bubble_min_radius = (int)(0.006*(double)(MIN(st->screen_width, 
1329                                                  st->screen_height)));
1330     st->bubble_max_radius = (int)(0.045*(double)(MIN(st->screen_width,
1331                                                  st->screen_height)));
1332     /* Some trivial values */
1333     if (st->bubble_min_radius < 1)
1334       st->bubble_min_radius = 1;
1335     if (st->bubble_max_radius <= st->bubble_min_radius)
1336       st->bubble_max_radius = st->bubble_min_radius + 1;
1337
1338     st->mesh_length = (2 * st->bubble_max_radius) + 3;
1339
1340     /* store area of each bubble of certain radius as number of 1/10s of
1341        a pixel area.  PI is defined in <math.h> */
1342     st->bubble_areas = (long *)xmalloc((st->bubble_max_radius + 2) * sizeof(int));
1343     for (i = 0; i < st->bubble_min_radius; i++)
1344       st->bubble_areas[i] = 0;
1345     for (i = st->bubble_min_radius; i <= (st->bubble_max_radius+1); i++)
1346       st->bubble_areas[i] = calc_bubble_area(st, i);
1347
1348         /* Now populate the droppage values */
1349     st->bubble_droppages = (int *)xmalloc((st->bubble_max_radius + 2) * sizeof(int));
1350     for (i = 0; i < st->bubble_min_radius; i++)
1351       st->bubble_droppages[i] = 0;
1352     for (i = st->bubble_min_radius; i <= (st->bubble_max_radius+1); i++)
1353       st->bubble_droppages[i] = MAX_DROPPAGE * (i - st->bubble_min_radius) / (st->bubble_max_radius - st->bubble_min_radius);
1354
1355     st->mesh_length = (2 * st->bubble_max_radius) + 3;
1356   } else {
1357 #ifndef FANCY_BUBBLES
1358     fprintf(stderr,
1359             "Bug: simple mode code not set but FANCY_BUBBLES not defined\n");
1360     exit(1);
1361 #else  /* FANCY_BUBBLES */
1362     /* Make sure all #ifdef sort of things have been taken care of in
1363        get_resources(). */
1364     default_to_pixmaps(st);
1365
1366     /* Set mesh length */
1367     st->mesh_length = (2 * st->step_pixmaps[st->num_bubble_pixmaps-1]->radius) + 3;
1368 #endif /* FANCY_BUBBLES */
1369
1370     /* Am I missing something in here??? */
1371   }
1372
1373   st->mesh_width = (st->screen_width / st->mesh_length) + 1;
1374   st->mesh_height = (st->screen_height / st->mesh_length) + 1;
1375   st->mesh_cells = st->mesh_width * st->mesh_height;
1376   init_mesh(st);
1377
1378   calculate_adjacent_list(st);
1379
1380   adjust_areas(st);
1381
1382   /* Graphics contexts for simple mode */
1383   if (st->simple) {
1384     gcv.foreground = st->default_fg_pixel;
1385     st->draw_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
1386     gcv.foreground = st->default_bg_pixel;
1387     st->erase_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
1388   }
1389
1390   XClearWindow (st->dpy, st->window);
1391
1392 # ifndef FANCY_BUBBLES
1393   st->simple = True;
1394 # endif
1395
1396   return st;
1397 }
1398
1399 static unsigned long
1400 bubbles_draw (Display *dpy, Window window, void *closure)
1401 {
1402   struct state *st = (struct state *) closure;
1403   int i;
1404   for (i = 0; i < 5; i++)
1405     {
1406       Bubble *tmp = new_bubble(st);
1407       add_to_mesh(st, tmp);
1408       insert_new_bubble(st, tmp);
1409     }
1410   return st->delay;
1411 }
1412
1413
1414 static void
1415 bubbles_reshape (Display *dpy, Window window, void *closure, 
1416                  unsigned int w, unsigned int h)
1417 {
1418 }
1419
1420 static Bool
1421 bubbles_event (Display *dpy, Window window, void *closure, XEvent *event)
1422 {
1423   return False;
1424 }
1425
1426 static void
1427 bubbles_free (Display *dpy, Window window, void *closure)
1428 {
1429   struct state *st = (struct state *) closure;
1430   free (st);
1431 }
1432
1433 XSCREENSAVER_MODULE ("Bubbles", bubbles)