/* piecewise, 21jan2003
 * Geoffrey Irving <irving@caltech.edu>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

#include <stdarg.h>
#include <math.h>
#include "screenhack.h"

#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
# include "xdbe.h"
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */

#define X_PI (180 * 64)

/******** splaying code */

typedef struct _tree {
  struct _tree *l, *r;   /* left and right children */
                         /* extra stuff would go here */
  } tree;

typedef int (*cut)(tree*);    /* cut x is <, =, or > 0 given a <, =, or > x for some a */

/* Top-down splay routine.  Reference:
 *   "Self-adjusting Binary Search Trees", Sleator and Tarjan,
 *   JACM Volume 32, No 3, July 1985, pp 652-686.
 * See page 668 for specific splay transformations */

tree *splay(cut c, tree *t) {
  int v, vv;
  tree *l, *r;
  tree **lr, **rl;
  tree *x, *y, *z;

  if (!t)
    return 0;

  /* initialization */
  x = t;
  l = r = 0;
  lr = &l;
  rl = &r;

  /* top-down splaying loop */
  for (;;) {
    v = c(x);
    if (v == 0)
      break;               /*** success ***/
    else if (v < 0) {
      y = x->l;
      if (!y)
        break;             /*** trivial ***/
      else {
        vv = c(y);
        if (vv == 0) {
          *rl = x;         /*** zig ***/
          rl = &x->l;
          x = y;
          break;
          }
        else if (vv < 0) {
          z = y->l;
          if (!z) {
            *rl = x;       /*** zig ***/
            rl = &x->l;
            x = y;
            break;
            }
          else {
            x->l = y->r;   /*** zig-zig ***/
            y->r = x;
            *rl = y;
            rl = &y->l;
            x = z;
            }
          }
        else { /* vv > 0 */
          z = y->r;
          if (!z) {
            *rl = x;       /*** zig ***/
            rl = &x->l;
            x = y;
            break;
            }
          else {           /*** zig-zag ***/
            *lr = y;
            lr = &y->r;
            *rl = x;
            rl = &x->l;
            x = z;
            }
          }
        }
      }
    else { /* v > 0 */
      y = x->r;
      if (!y)
        break;             /*** trivial ***/
      else {
        vv = c(y);
        if (vv == 0) {
          *lr = x;         /*** zig ***/
          lr = &x->r;
          x = y;
          break;
          }
        else if (vv > 0) {
          z = y->r;
          if (!z) {
            *lr = x;       /*** zig ***/
            lr = &x->r;
            x = y;
            break;
            }
          else {
            x->r = y->l;   /*** zig-zig ***/
            y->l = x;
            *lr = y;
            lr = &y->r;
            x = z;
            }
          }
        else { /* vv < 0 */
          z = y->l;
          if (!z) {
            *lr = x;       /*** zig ***/
            lr = &x->r;
            x = y;
            break;
            }
          else {           /*** zig-zag ***/
            *rl = y;
            rl = &y->l;
            *lr = x;
            lr = &x->r;
            x = z;
            }
          }
        }
      }
    }

  /* completion */
  *lr = x->l;
  x->l = l;
  *rl = x->r;
  x->r = r;
  return x;
  }

tree *splay_min(tree *t) {
  tree *r, **rl;
  tree *x, *y, *z;

  if (!t)
    return 0;

  x = t;
  r = 0;
  rl = &r;

  for (;;) {
    y = x->l;
    if (!y)
      break;           /*** trivial ***/
    else {
      z = y->l;
      if (!z) {
        *rl = x;       /*** zig ***/
        rl = &x->l;
        x = y;
        break;
        }
      else {
        x->l = y->r;   /*** zig-zig ***/
        y->r = x;
        *rl = y;
        rl = &y->l;
        x = z;
        }
      }
    }

  x->l = 0;
  *rl = x->r;
  x->r = r;
  return x;
  }

tree *splay_max(tree *t) {
  tree *l, **lr;
  tree *x, *y, *z;

  if (!t)
    return 0;

  x = t;
  l = 0;
  lr = &l;

  for (;;) {
    y = x->r;
    if (!y)
      break;           /*** trivial ***/
    else {
      z = y->r;
      if (!z) {
        *lr = x;       /*** zig ***/
        lr = &x->r;
        x = y;
        break;
        }
      else {
        x->r = y->l;   /*** zig-zig ***/
        y->l = x;
        *lr = y;
        lr = &y->r;
        x = z;
        }
      }
    }

  *lr = x->l;
  x->l = l;
  x->r = 0;
  return x;
  }

/******** circles and fringe */

struct _fringe;

typedef struct _circle {
  int r;                    /* radius */
  double x, y;              /* position */
  double dx, dy;            /* velocity */

  int visible;              /* default visibility */
  struct _fringe *lo, *hi;  /* lo and hi fringes */

  int ni;                   /* number of intersections */
  int *i;                   /* sorted intersection list */
  } circle;             

typedef struct _fringe {
  struct _fringe *l, *r;  /* left and right children for splay trees */

  circle *c;              /* associated circle */
  int side;               /* 0 for lo, 1 for hi */

  int mni;                /* size of intersection array */
  int ni;                 /* number of intersections */
  int *i;                 /* sorted intersection list */
  } fringe;

inline double fringe_x(fringe *f, double y) {
  double dy, d;
  dy = f->c->y - y;
  d = sqrt(f->c->r * f->c->r - dy * dy);
  return f->side ? f->c->x + d : f->c->x - d;
  }

inline void fringe_add_intersection(fringe *f, double x, double y) {
  f->ni++;
  if (f->mni < f->ni) {
    f->mni += 2;
    f->i = realloc(f->i, sizeof(int) * f->mni);
    }
  f->i[f->ni-1] = rint(atan2(y - f->c->y, x - f->c->x) * X_PI / M_PI);
  }

circle *init_circles(int n, int w, int h) {
  int i, r0, dr, speed;
  double v, a;
  double minradius, maxradius;
  fringe *s = malloc(sizeof(fringe) * n * 2);    /* never freed */
  circle *c = malloc(sizeof(circle) * n);

  speed = get_integer_resource("speed", "Speed");
  minradius = get_float_resource("minradius", "Float");
  maxradius = get_float_resource("maxradius", "Float");
  if (maxradius < minradius)
    maxradius = minradius;

  r0 = ceil(minradius * h); 
  dr = floor(maxradius * h) - r0 + 1;

  for (i=0;i<n;i++) {
    c[i].r = r0 + random() % dr;
    c[i].x = c[i].r + frand(w - 1 - 2 * c[i].r);
    c[i].y = c[i].r + frand(h - 1 - 2 * c[i].r);
    c[i].visible = random() & 1;

    c[i].ni = 0;
    c[i].i = 0;

    a = frand(2 * M_PI);
    v = (1 + frand(0.5)) * speed / 10.0;
    c[i].dx = v * cos(a);
    c[i].dy = v * sin(a);

    c[i].lo = s+i+i;
    c[i].hi = s+i+i+1;
    c[i].lo->c = c[i].hi->c = c+i;
    c[i].lo->side = 0;
    c[i].hi->side = 1;
    c[i].lo->mni = c[i].lo->ni = c[i].hi->mni = c[i].hi->ni = 0;
    c[i].lo->i = c[i].hi->i = 0;
    }

  return c;
  }

/* this is a hack, but I guess that's what I writing anyways */
void tweak_circle(circle *c) {
  c->x += frand(2) - 1;
  c->y += frand(1) + 0.1;
  }

void move_circle(circle *c, int w, int h) {
  c->x += c->dx;
  if (c->x < c->r) {
    c->x = c->r;
    c->dx = -c->dx;
    }
  else if (c->x >= w - c->r) {
    c->x = w - 1 - c->r;
    c->dx = -c->dx;
    }
  c->y += c->dy;
  if (c->y < c->r) {
    c->y = c->r;
    c->dy = -c->dy;
    }
  else if (c->y >= h - c->r) {
    c->y = h - 1 - c->r;
    c->dy = -c->dy;
    }
  }

/******** event queue */

#define START 0
#define CROSS 1
#define FINISH 2

typedef struct _event {
  struct _event *l, *r;    /* left and right children for splay tree */

  int kind;                /* type of event */
  double x, y;             /* position */
  fringe *lo, *hi;         /* fringes */
  } event;

static double event_cut_y;

int event_cut(event *e) {
  return event_cut_y == e->y ? 0 : event_cut_y < e->y ? -1 : 1;
  }

void event_insert(event **eq, event *e) {
  if (!*eq) {
    e->l = e->r = 0;
    *eq = e;
    }

  event_cut_y = e->y;
  *eq = (event*)splay((cut)event_cut, (tree*)*eq);

  if (e->y == (*eq)->y) {
    if (!((e->lo == (*eq)->lo && e->hi == (*eq)->hi) || (e->lo == (*eq)->hi && e->hi == (*eq)->lo))) {
      e->l = (*eq)->l;
      e->r = 0;             /* doing this instead of dying might be dangerous */
      (*eq)->l = e;           
      }
    }
  else if (e->y < (*eq)->y) {
    e->l = (*eq)->l;
    e->r = *eq;
    (*eq)->l = 0;
    *eq = e;
    }
  else {
    e->l = *eq;
    e->r = (*eq)->r; 
    (*eq)->r = 0;
    *eq = e;
    }
  }

void circle_start_event(event **eq, circle *c) {
  event *s;
  s = malloc(sizeof(event));
  s->kind = START;
  s->x = c->x;
  s->y = c->y - c->r;
  s->lo = c->lo;
  s->hi = c->hi;
  event_insert(eq, s);
  }

void circle_finish_event(event **eq, circle *c) {
  event *f;
  f = malloc(sizeof(event));
  f->kind = FINISH;
  f->x = c->x;
  f->y = c->y + c->r;
  f->lo = c->lo;
  f->hi = c->hi;
  event_insert(eq, f);
  }

event *event_next(event **eq) {
  event *e;
  if (!*eq)
    return 0;
  else {
    e = (event*)splay_min((tree*)*eq);
    *eq = e->r; 
    return e;
    }
  }

void event_shred(event *e) {
  if (e) {
    event_shred(e->l);
    event_shred(e->r);
    free(e);
    }
  }

/******** fringe intersection */

inline int check_fringe_intersection(double ye, fringe *lo, fringe *hi, double x, double y) {
  return ye <= y && ((x < lo->c->x) ^ lo->side) && ((x < hi->c->x) ^ hi->side);
  }

void fringe_intersect(event **eq, double y, fringe *lo, fringe *hi) {
  event *e;
  double dx, dy, sd, rs, rd, d, sx, sy, rp, sqd;
  double x1, y1, x2, y2;

  if (lo->c == hi->c)
    return;

  dx = hi->c->x - lo->c->x; 
  dy = hi->c->y - lo->c->y; 
  sd = dx * dx + dy * dy; 

  if (sd == 0)
    return;

  rs = hi->c->r + lo->c->r; 
  rd = hi->c->r - lo->c->r; 
  d = (rd * rd - sd) * (sd - rs * rs);

  if (d <= 0)
    return;
 
  sd = 0.5 / sd;
  rp = rs * rd; 
  sqd = sqrt(d); 
  sx = (lo->c->x + hi->c->x) / 2;
  sy = (lo->c->y + hi->c->y) / 2;
  x1 = sx + sd * (dy * sqd - dx * rp); 
  y1 = sy - sd * (dx * sqd + dy * rp);
  x2 = sx - sd * (dy * sqd + dx * rp);
  y2 = sy + sd * (dx * sqd - dy * rp);

  #define CHECK(xi, yi) (y <= yi && ((xi < lo->c->x) ^ lo->side) && ((xi < hi->c->x) ^ hi->side))

  #define ADD_CROSS(xi, yi, ilo, ihi) {  \
    e = malloc(sizeof(event));           \
    e->kind = CROSS;                     \
    e->x = xi; e->y = yi;                \
    e->lo = ilo; e->hi = ihi;            \
    event_insert(eq, e);                 \
    }

  if (CHECK(x1, y1)) {
    if (CHECK(x2, y2)) {
      if (y1 < y2) {
        ADD_CROSS(x1, y1, lo, hi);
        ADD_CROSS(x2, y2, hi, lo);
        }
      else {
        ADD_CROSS(x1, y1, hi, lo);
        ADD_CROSS(x2, y2, lo, hi);
        }
      }
    else
      ADD_CROSS(x1, y1, lo, hi);
    }
  else if (CHECK(x2, y2))
    ADD_CROSS(x2, y2, lo, hi); 

  return;
  }

/******** fringe trees and event handling */

#define PANIC ((fringe*)1)     /* by alignment, no fringe should every be 1 */

fringe *check_lo(event **eq, double y, fringe *f, fringe *hi) {
  if (f) {
    f = (fringe*)splay_max((tree*)f);
    fringe_intersect(eq, y, f, hi);
    }
  return f;
  }

fringe *check_hi(event **eq, double y, fringe *lo, fringe *f) {
  if (f) {
    f = (fringe*)splay_min((tree*)f);
    fringe_intersect(eq, y, lo, f);
    }
  return f;
  }

double fringe_start_cut_x;
double fringe_start_cut_y;

int fringe_start_cut(fringe *f) {
  double x = fringe_x(f, fringe_start_cut_y);
  return fringe_start_cut_x == x ? 0 : fringe_start_cut_x < x ? -1 : 1;
  }

fringe *fringe_start(event **eq, fringe *f, double x, double y, fringe *lo, fringe *hi) {
  double sx;

  if (!f) {
    circle_finish_event(eq, lo->c);
    lo->l = 0;
    lo->r = hi;
    hi->l = hi->r = 0;
    return lo;
    }

  fringe_start_cut_x = x;
  fringe_start_cut_y = y;
  f = (fringe*)splay((cut)fringe_start_cut, (tree*)f);

  sx = fringe_x(f, y);
  if (x == sx) {       /* time to cheat my way out of handling degeneracies */
    tweak_circle(lo->c);
    circle_start_event(eq, lo->c);
    return f;
    }
  else if (x < sx) {
    circle_finish_event(eq, lo->c);
    f->l = check_lo(eq, y, f->l, lo);    
    fringe_intersect(eq, y, hi, f);
    lo->l = f->l;
    lo->r = f;
    f->l = hi;
    hi->l = hi->r = 0;
    return lo;
    }
  else {
    circle_finish_event(eq, lo->c);
    fringe_intersect(eq, y, f, lo);
    f->r = check_hi(eq, y, hi, f->r);
    hi->r = f->r;
    hi->l = f;
    f->r = lo;
    lo->l = lo->r = 0;
    return hi;
    }
  }

double fringe_double_cut_x;
double fringe_double_cut_y;
fringe *fringe_double_cut_lo;
fringe *fringe_double_cut_hi;

int fringe_double_cut(fringe *f) {
  double x;
  if (f == fringe_double_cut_lo || f == fringe_double_cut_hi)
    return 0;
  x = fringe_x(f, fringe_double_cut_y);
  return fringe_double_cut_x == x ? 0 : fringe_double_cut_x < x ? -1 : 1;
  }

int fringe_double_splay(fringe *f, double x, double y, fringe *lo, fringe *hi) {
  fringe_double_cut_x = x;
  fringe_double_cut_y = y;
  fringe_double_cut_lo = lo;
  fringe_double_cut_hi = hi;
  f = (fringe*)splay((cut)fringe_double_cut, (tree*)f);

  if (f == lo)
    return (f->r = (fringe*)splay_min((tree*)f->r)) == hi;
  else if (f == hi)
    return (f->l = (fringe*)splay_max((tree*)f->l)) == lo;
  else
    return 0;
  }

fringe *fringe_cross(event **eq, fringe *f, double x, double y, fringe *lo, fringe *hi) {
  fringe *l, *r;
  if (!fringe_double_splay(f, x, y, lo, hi))
    return PANIC;
  l = check_lo(eq, y, lo->l, hi);
  r = check_hi(eq, y, lo, hi->r);
  lo->l = hi;
  lo->r = r;
  hi->l = l;
  hi->r = 0;
  return lo;
  }

fringe *fringe_finish(event **eq, fringe *f, double x, double y, fringe *lo, fringe *hi) {
  if (!fringe_double_splay(f, x, y, lo, hi))
    return PANIC;
  else if (!lo->l)
    return hi->r;
  else if (!hi->r)
    return lo->l;
  else {
    lo->l = (fringe*)splay_max((tree*)lo->l);
    hi->r = (fringe*)splay_min((tree*)hi->r);
    fringe_intersect(eq, y, lo->l, hi->r);
    lo->l->r = hi->r;
    hi->r->l = 0;
    return lo->l;
    }
  }

/******** plane sweep */

void sweep(int n, circle *c) {
  int i;
  event *eq, *e;
  fringe *f;

  RESTART:
  #define CHECK_PANIC()                 \
    if (f == PANIC) {                   \
      free(e);                          \
      event_shred(eq);                  \
      for (i=0;i<n;i++) {               \
        tweak_circle(c+i);              \
        c[i].lo->ni = c[i].hi->ni = 0;  \
        }                               \
      goto RESTART;                     \
      }

  eq = 0;
  for (i=0;i<n;i++)
    circle_start_event(&eq, c+i); 
  f = 0;

  while ((e = event_next(&eq))) {
    switch (e->kind) {
      case START:
        f = fringe_start(&eq, f, e->x, e->y, e->lo, e->hi);
        break;
      case CROSS:
        f = fringe_cross(&eq, f, e->x, e->y, e->lo, e->hi);
        CHECK_PANIC();
        fringe_add_intersection(e->lo, e->x, e->y);
        fringe_add_intersection(e->hi, e->x, e->y);
        break;
      case FINISH:
        f = fringe_finish(&eq, f, e->x, e->y, e->lo, e->hi);
        CHECK_PANIC();
        break;
      }
    free(e);
    }
  }

/******** circle drawing */

void adjust_circle_visibility(circle *c) {
  int i, j, n, a;
  int *in;
  n = c->lo->ni + c->hi->ni;
  in = malloc(sizeof(int) * n);
  for (i=0;i<c->hi->ni;i++)
    in[i] = c->hi->i[i]; 
  for (i=c->lo->ni-1;i>=0;i--)
    in[n-i-1] = c->lo->i[i] > 0 ? c->lo->i[i] : c->lo->i[i] + 2 * X_PI;
  c->lo->ni = c->hi->ni = 0;

  i = j = 0;
  a = 0;
  while (i < n && j < c->ni)           /* whee */
    a = (in[i] < c->i[j] ? in[i++] : c->i[j++]) - a;
  while (i < n)
    a = in[i++] - a;
  while (j < c->ni)
    a = c->i[j++] - a;

  if (a > X_PI) 
    c->visible = !c->visible;
  free(c->i);  
  c->ni = n;
  c->i = in;
  }

#define ARC_BUFFER_SIZE 256
int arc_buffer_count = 0;
XArc arc_buffer[ARC_BUFFER_SIZE];

void flush_arc_buffer(Display *dpy, Drawable w, GC gc) {
  if (arc_buffer_count) {
    XDrawArcs(dpy, w, gc, arc_buffer, arc_buffer_count);
    arc_buffer_count = 0;
    }
  }

void draw_circle(Display *dpy, Drawable w, GC gc, circle *c) {
  int i, xi, yi, di;
  adjust_circle_visibility(c); 

  xi = rint(c->x - c->r);
  yi = rint(c->y - c->r);
  di = c->r << 1;

  #define ARC(p, a1, a2) {                                \
    if (((p) & 1) ^ c->visible) {                         \
      arc_buffer[arc_buffer_count].x      = xi;           \
      arc_buffer[arc_buffer_count].y      = yi;           \
      arc_buffer[arc_buffer_count].width  = di;           \
      arc_buffer[arc_buffer_count].height = di;           \
      arc_buffer[arc_buffer_count].angle1 = -(a1);        \
      arc_buffer[arc_buffer_count].angle2 = (a1) - (a2);  \
      arc_buffer_count++;                                 \
      if (arc_buffer_count == ARC_BUFFER_SIZE)            \
        flush_arc_buffer(dpy, w, gc);                     \
      }                                                   \
    }

  if (!c->ni)
    ARC(0, 0, 2 * X_PI)
  else
    ARC(0, c->i[c->ni-1], c->i[0] + 2 * X_PI)
  for (i=1;i<c->ni;i++)
    ARC(i, c->i[i-1], c->i[i])
  }

/******** toplevel */

char *progclass = "Piecewise";

char *defaults [] = {
  ".background:         black",
  ".foreground:         white",
  "*delay:              5000",
  "*speed:              15",
  "*ncolors:            256",
  ".colorspeed:         10",

  ".count:              32",
  ".minradius:          0.05",
  ".maxradius:          0.2",   

  "*doubleBuffer:       True",
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
  "*useDBE:             True",
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
  0
  };

XrmOptionDescRec options [] = {
  { "-delay",           ".delay",       XrmoptionSepArg, 0 },
  { "-ncolors",         ".ncolors",     XrmoptionSepArg, 0 },
  { "-speed",           ".speed",       XrmoptionSepArg, 0 },
  { "-colorspeed",      ".colorspeed",  XrmoptionSepArg, 0 },

  { "-count",           ".count",       XrmoptionSepArg, 0 },
  { "-minradius",       ".minradius",   XrmoptionSepArg, 0 },
  { "-maxradius",       ".maxradius",   XrmoptionSepArg, 0 },

  { "-db",              ".doubleBuffer", XrmoptionNoArg,  "True" },
  { "-no-db",           ".doubleBuffer", XrmoptionNoArg,  "False" },
  { 0, 0, 0, 0 }
  };

void screenhack(Display *dpy, Window window) {
  int i;
  Bool dbuf;
  XColor *colors;
  XGCValues gcv;
  GC erase_gc, draw_gc;
  XWindowAttributes xgwa;
  Pixmap b = 0, ba = 0, bb = 0;    /* double-buffering pixmap */

#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
  XdbeBackBuffer backb = 0;
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */

  int count, delay, ncolors, colorspeed, color_index, flags, iterations;
  int color_iterations;
  circle *circles;

  count = get_integer_resource("count", "Integer");
  delay = get_integer_resource("delay", "Integer");
  ncolors = get_integer_resource("ncolors", "Integer");
  colorspeed = get_integer_resource("colorspeed", "Integer");
  dbuf = get_boolean_resource("doubleBuffer", "Boolean");

  color_iterations = colorspeed ? 100 / colorspeed : 100000;
  if (!color_iterations)
    color_iterations = 1;

  XGetWindowAttributes(dpy, window, &xgwa);
  colors = calloc(sizeof(XColor), ncolors);

  if (get_boolean_resource("mono", "Boolean")) {  
    MONO:
      ncolors = 1;
      colors[0].pixel = get_pixel_resource("foreground", "Foreground", dpy, xgwa.colormap);
    }
  else {
    make_color_loop(dpy, xgwa.colormap, 0, 1, 1, 120, 1, 1, 240, 1, 1, colors, &ncolors, True, False);
    if (ncolors < 2)
      goto MONO; 
    }

  if (dbuf) {
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
    b = backb = xdbe_get_backbuffer(dpy, window, XdbeUndefined);
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
    
    if (!b) {
      ba = XCreatePixmap(dpy, window, xgwa.width, xgwa.height,xgwa.depth);
      bb = XCreatePixmap(dpy, window, xgwa.width, xgwa.height,xgwa.depth);
      b = ba;
      }
    }
  else
    b = window;

  /* erasure gc */
  gcv.foreground = get_pixel_resource("background", "Background", dpy, xgwa.colormap);
  erase_gc = XCreateGC (dpy, b, GCForeground, &gcv);

  /* drawing gc */
  flags = GCForeground;
  color_index = random() % ncolors;
  gcv.foreground = colors[color_index].pixel;
  draw_gc = XCreateGC(dpy, b, flags, &gcv);

  /* initialize circles */
  circles = init_circles(count, xgwa.width, xgwa.height);
  
  iterations = 0;
  for (;;) {
    XFillRectangle (dpy, b, erase_gc, 0, 0, xgwa.width, xgwa.height);

    sweep(count, circles);
    for (i=0;i<count;i++) {
      draw_circle(dpy, b, draw_gc, circles+i);
      move_circle(circles+i, xgwa.width, xgwa.height);
      }
    flush_arc_buffer(dpy, b, draw_gc);

    if (++iterations % color_iterations == 0) {
      color_index = (color_index + 1) % ncolors;
      XSetForeground(dpy, draw_gc, colors[color_index].pixel);
      }

#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
    if (backb) {
      XdbeSwapInfo info[1];
      info[0].swap_window = window;
      info[0].swap_action = XdbeUndefined;
      XdbeSwapBuffers (dpy, info, 1);
      }
    else
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
    if (dbuf) {
      XCopyArea (dpy, b, window, erase_gc, 0, 0, xgwa.width, xgwa.height, 0, 0);
      b = (b == ba ? bb : ba);
      }

    XSync(dpy, False);
    screenhack_handle_events(dpy);
    if (delay)
      usleep(delay);
    }
  }