static unsigned long
distort_draw (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
int k;
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
if (! st->img_loader) { /* just finished */
distort_finish_loading (st);
}
return st->delay;
}
if (!st->img_loader &&
st->start_time + st->duration < time ((time_t *) 0)) {
if (st->pm) XFreePixmap (st->dpy, st->pm);
st->pm = XCreatePixmap (st->dpy, st->window,
st->xgwa.width, st->xgwa.height, st->xgwa.depth);
st->img_loader = load_image_async_simple (0, st->xgwa.screen, st->window,
st->pm, 0, 0);
return st->delay;
}
for (k = 0; k < st->number; k++) {
st->effect(st,k);
st->draw(st,k);
}
return st->delay;
}
static unsigned long
twang_draw (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
if (! st->img_loader) { /* just finished */
grabImage_done (st);
}
return st->delay;
}
if (!st->img_loader &&
st->start_time + st->duration < time ((time_t *) 0)) {
XWindowAttributes xgwa;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
grabImage_start (st, &xgwa);
return st->delay;
}
modelEvents (st);
updateModel (st);
renderFrame (st);
return st->delay;
}
static void *
distort_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
long gcflags;
st->dpy = dpy;
st->window = window;
distort_reset (st);
st->black_pixel = BlackPixelOfScreen( st->xgwa.screen );
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
gcflags = GCFunction;
if (use_subwindow_mode_p(st->xgwa.screen, st->window)) /* see grabscreen.c */
gcflags |= GCSubwindowMode;
st->gc = XCreateGC (st->dpy, st->window, gcflags, &gcv);
/* On MacOS X11, XGetImage on a Window often gets an inexplicable BadMatch,
possibly due to the window manager having occluded something? It seems
nondeterministic. Loading the image into a pixmap instead fixes it. */
if (st->pm) XFreePixmap (st->dpy, st->pm);
st->pm = XCreatePixmap (st->dpy, st->window,
st->xgwa.width, st->xgwa.height, st->xgwa.depth);
st->img_loader = load_image_async_simple (0, st->xgwa.screen, st->window,
st->pm, 0, 0);
st->start_time = time ((time_t *) 0);
return st;
}
static unsigned long
blitspin_draw (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
int this_delay = st->delay;
int qwad;
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
if (!st->img_loader) { /* just finished */
st->first_time = 0;
st->loaded_p = True;
st->qwad = -1;
st->start_time = time ((time_t) 0);
blitspin_init_2 (st);
}
/* Rotate nothing if the very first image is not yet loaded */
if (! st->loaded_p)
return this_delay;
}
if (!st->img_loader &&
st->load_ext_p &&
st->start_time + st->duration < time ((time_t) 0)) {
/* Start a new image loading, but keep rotating the old image
until the new one arrives. */
st->img_loader = load_image_async_simple (0, st->xgwa.screen, st->window,
st->bitmap, 0, 0);
}
if (st->qwad == -1)
{
bitblt(st, st->mask, st->mask, clear,0,0, st->size, st->size, 0,0);
bitblt(st, st->mask, st->mask, set, 0,0, st->size>>1, st->size>>1, 0,0);
st->qwad = st->size>>1;
}
/* grab the source image */
static void
grabImage_start (struct state *st, XWindowAttributes *xwa)
{
/* On MacOS X11, XGetImage on a Window often gets an inexplicable BadMatch,
possibly due to the window manager having occluded something? It seems
nondeterministic. Loading the image into a pixmap instead fixes it. */
if (st->pm) XFreePixmap (st->dpy, st->pm);
st->pm = XCreatePixmap (st->dpy, st->window,
xwa->width, xwa->height, xwa->depth);
st->start_time = time ((time_t *) 0);
st->img_loader = load_image_async_simple (0, xwa->screen, st->window,
st->pm, 0, 0);
}
static unsigned long
boxfit_draw (Display *dpy, Window window, void *closure)
{
state *st = (state *) closure;
int delay;
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
if (! st->img_loader) /* just finished */
{
st->image = XGetImage (st->dpy,
(st->loading_pixmap ? st->loading_pixmap :
st->window),
0, 0,
st->xgwa.width, st->xgwa.height, ~0L,
ZPixmap);
if (st->loading_pixmap) XFreePixmap (st->dpy, st->loading_pixmap);
XSetWindowBackground (st->dpy, st->window, st->bg_color);
if (st->loading_pixmap)
XClearWindow (st->dpy, st->window);
else
st->countdown = 2000000;
st->loading_pixmap = 0;
}
return st->delay;
}
if (st->countdown > 0)
{
st->countdown -= st->delay;
if (st->countdown <= 0)
{
st->countdown = 0;
XClearWindow (st->dpy, st->window);
}
return st->delay;
}
if (st->growing_p) {
draw_boxes (st);
delay = grow_boxes (st);
} else {
delay = shrink_boxes (st);
draw_boxes (st);
}
return delay;
}
static void *
decayscreen_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
XWindowAttributes xgwa;
long gcflags;
unsigned long bg;
char *s;
st->dpy = dpy;
st->window = window;
s = get_string_resource(st->dpy, "mode", "Mode");
if (s && !strcmp(s, "shuffle")) st->mode = SHUFFLE;
else if (s && !strcmp(s, "up")) st->mode = UP;
else if (s && !strcmp(s, "left")) st->mode = LEFT;
else if (s && !strcmp(s, "right")) st->mode = RIGHT;
else if (s && !strcmp(s, "down")) st->mode = DOWN;
else if (s && !strcmp(s, "upleft")) st->mode = UPLEFT;
else if (s && !strcmp(s, "downleft")) st->mode = DOWNLEFT;
else if (s && !strcmp(s, "upright")) st->mode = UPRIGHT;
else if (s && !strcmp(s, "downright")) st->mode = DOWNRIGHT;
else if (s && !strcmp(s, "in")) st->mode = IN;
else if (s && !strcmp(s, "out")) st->mode = OUT;
else if (s && !strcmp(s, "melt")) st->mode = MELT;
else if (s && !strcmp(s, "stretch")) st->mode = STRETCH;
else if (s && !strcmp(s, "fuzz")) st->mode = FUZZ;
else {
if (s && *s && !!strcmp(s, "random"))
fprintf(stderr, "%s: unknown mode %s\n", progname, s);
st->mode = random() % (FUZZ+1);
}
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
if (st->delay < 0) st->delay = 0;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
bg = get_pixel_resource (st->dpy, xgwa.colormap, "background", "Background");
gcv.foreground = bg;
gcflags = GCForeground | GCFunction;
if (use_subwindow_mode_p(xgwa.screen, st->window)) /* see grabscreen.c */
gcflags |= GCSubwindowMode;
st->gc = XCreateGC (st->dpy, st->window, gcflags, &gcv);
st->sizex = xgwa.width;
st->sizey = xgwa.height;
if (st->mode == MELT || st->mode == STRETCH)
st->iterations = 1; /* slow down for smoother melting */
st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
st->window, 0, 0);
return st;
}
/*
* perform one iteration of decay
*/
static unsigned long
decayscreen_draw (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
int left, top, width, height, toleft, totop;
#define L 101
#define R 102
#define U 103
#define D 104
static const int no_bias[] = { L,L,L,L, R,R,R,R, U,U,U,U, D,D,D,D };
static const int up_bias[] = { L,L,L,L, R,R,R,R, U,U,U,U, U,U,D,D };
static const int down_bias[] = { L,L,L,L, R,R,R,R, U,U,D,D, D,D,D,D };
static const int left_bias[] = { L,L,L,L, L,L,R,R, U,U,U,U, D,D,D,D };
static const int right_bias[] = { L,L,R,R, R,R,R,R, U,U,U,U, D,D,D,D };
static const int upleft_bias[] = { L,L,L,L, L,R,R,R, U,U,U,U, U,D,D,D };
static const int downleft_bias[] = { L,L,L,L, L,R,R,R, U,U,U,D, D,D,D,D };
static const int upright_bias[] = { L,L,L,R, R,R,R,R, U,U,U,U, U,D,D,D };
static const int downright_bias[] = { L,L,L,R, R,R,R,R, U,U,U,D, D,D,D,D };
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader,
0, 0, 0, 0, 0);
if (! st->img_loader) { /* just finished */
if (st->mode == MELT || st->mode == STRETCH)
/* make sure screen eventually turns background color */
XDrawLine (st->dpy, st->window, st->gc, 0, 0, st->sizex, 0);
}
return st->delay;
}
switch (st->mode) {
case SHUFFLE: st->current_bias = no_bias; break;
case UP: st->current_bias = up_bias; break;
case LEFT: st->current_bias = left_bias; break;
case RIGHT: st->current_bias = right_bias; break;
case DOWN: st->current_bias = down_bias; break;
case UPLEFT: st->current_bias = upleft_bias; break;
case DOWNLEFT: st->current_bias = downleft_bias; break;
case UPRIGHT: st->current_bias = upright_bias; break;
case DOWNRIGHT: st->current_bias = downright_bias; break;
case IN: st->current_bias = no_bias; break;
case OUT: st->current_bias = no_bias; break;
case MELT: st->current_bias = no_bias; break;
case STRETCH: st->current_bias = no_bias; break;
case FUZZ: st->current_bias = no_bias; break;
default: abort();
}
#define nrnd(x) ((x) ? random() % (x) : x)
if (st->mode == MELT || st->mode == STRETCH) {
left = nrnd(st->sizex/2);
top = nrnd(st->sizey);
width = nrnd( st->sizex/2 ) + st->sizex/2 - left;
height = nrnd(st->sizey - top);
toleft = left;
totop = top+1;
} else if (st->mode == FUZZ) { /* By Vince Levey <*****@*****.**>;
inspired by the "melt" mode of the
"scrhack" IrisGL program by Paul Haeberli
circa 1991. */
left = nrnd(st->sizex - 1);
top = nrnd(st->sizey - 1);
st->fuzz_toggle = !st->fuzz_toggle;
if (st->fuzz_toggle)
{
totop = top;
height = 1;
toleft = nrnd(st->sizex - 1);
if (toleft > left)
{
width = toleft-left;
toleft = left;
left++;
}
else
{
width = left-toleft;
left = toleft;
toleft++;
}
}
else
{
toleft = left;
width = 1;
totop = nrnd(st->sizey - 1);
if (totop > top)
{
height = totop-top;
totop = top;
top++;
}
else
{
height = top-totop;
top = totop;
totop++;
}
}
} else {
left = nrnd(st->sizex - 1);
top = nrnd(st->sizey);
width = nrnd(st->sizex - left);
height = nrnd(st->sizey - top);
toleft = left;
totop = top;
if (st->mode == IN || st->mode == OUT) {
int x = left+(width/2);
int y = top+(height/2);
int cx = st->sizex/2;
int cy = st->sizey/2;
if (st->mode == IN) {
if (x > cx && y > cy) st->current_bias = upleft_bias;
else if (x < cx && y > cy) st->current_bias = upright_bias;
else if (x < cx && y < cy) st->current_bias = downright_bias;
else /* (x > cx && y < cy)*/ st->current_bias = downleft_bias;
} else {
if (x > cx && y > cy) st->current_bias = downright_bias;
else if (x < cx && y > cy) st->current_bias = downleft_bias;
else if (x < cx && y < cy) st->current_bias = upleft_bias;
else /* (x > cx && y < cy)*/ st->current_bias = upright_bias;
}
}
switch (st->current_bias[random() % (sizeof(no_bias)/sizeof(*no_bias))]) {
case L: toleft = left-1; break;
case R: toleft = left+1; break;
case U: totop = top-1; break;
case D: totop = top+1; break;
default: abort(); break;
}
}
if (st->mode == STRETCH) {
XCopyArea (st->dpy, st->window, st->window, st->gc, 0, st->sizey-top-2, st->sizex, top+1,
0, st->sizey-top-1);
} else {
XCopyArea (st->dpy, st->window, st->window, st->gc, left, top, width, height,
toleft, totop);
}
#undef nrnd
return st->delay;
}
static void *
zoom_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
XWindowAttributes xgwa;
Colormap cmap;
unsigned long bg;
long gcflags;
int nblocksx, nblocksy;
st->dpy = dpy;
st->window = window;
XGetWindowAttributes(st->dpy, st->window, &xgwa);
st->screen = xgwa.screen;
st->sizex = xgwa.width;
st->sizey = xgwa.height;
cmap = xgwa.colormap;
bg = get_pixel_resource(st->dpy, cmap, "background", "Background");
st->delay = get_integer_resource(st->dpy, "delay", "Integer");
if (st->delay < 1)
st->delay = 1;
st->duration = get_integer_resource (st->dpy, "duration", "Seconds");
if (st->duration < 1)
st->duration = 1;
st->pixwidth = get_integer_resource(st->dpy, "pixwidth", "Integer");
if (st->pixwidth < 1)
st->pixwidth = 1;
st->pixheight = get_integer_resource(st->dpy, "pixheight", "Integer");
if (st->pixheight < 1)
st->pixheight = 1;
st->pixspacex = get_integer_resource(st->dpy, "pixspacex", "Integer");
if (st->pixspacex < 0)
st->pixspacex = 0;
st->pixspacey = get_integer_resource(st->dpy, "pixspacey", "Integer");
if (st->pixspacey < 0)
st->pixspacey = 0;
st->lenses = get_boolean_resource(st->dpy, "lenses", "Boolean");
st->lensoffsetx = get_integer_resource(st->dpy, "lensoffsetx", "Integer");
st->lensoffsetx = MAX(0, MIN(st->pixwidth, st->lensoffsetx));
st->lensoffsety = get_integer_resource(st->dpy, "lensoffsety", "Integer");
st->lensoffsety = MAX(0, MIN(st->pixwidth, st->lensoffsety));
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
gcflags = GCForeground|GCFunction;
gcv.foreground = bg;
if (!st->lenses && use_subwindow_mode_p(xgwa.screen, st->window)) /* see grabscreen.c */
gcflags |= GCSubwindowMode;
st->window_gc = XCreateGC(st->dpy, st->window, gcflags, &gcv);
st->orig_map = NULL;
st->pm = XCreatePixmap(st->dpy, st->window, st->sizex, st->sizey, xgwa.depth);
XFillRectangle(st->dpy, st->window, st->window_gc, 0, 0, st->sizex, st->sizey);
XSetWindowBackground(st->dpy, st->window, bg);
st->start_time = time ((time_t) 0);
st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
st->pm, 0, 0);
/* We might have needed this to grab the image, but if we leave this set
to GCSubwindowMode, then we'll *draw* right over subwindows too. */
XSetSubwindowMode (st->dpy, st->window_gc, ClipByChildren);
nblocksx = (int)ceil((double)st->sizex / (double)(st->pixwidth + st->pixspacex));
nblocksy = (int)ceil((double)st->sizey / (double)(st->pixheight + st->pixspacey));
if (st->lenses)
st->s = MAX((nblocksx - 1) * st->lensoffsetx + st->pixwidth,
(nblocksy - 1) * st->lensoffsety + st->pixheight) * 2;
else
st->s = MAX(nblocksx, nblocksy) * 2;
st->sinusoid_offset = random();
return st;
}
static unsigned long
zoom_draw (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
unsigned x, y, i, j;
long now;
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
if (! st->img_loader) { /* just finished */
XClearWindow (st->dpy, st->window);
st->start_time = time ((time_t) 0);
if (!st->lenses) {
st->orig_map = XGetImage(st->dpy, st->pm, 0, 0, st->sizex, st->sizey, ~0L, ZPixmap);
/* XFreePixmap(st->dpy, st->pm);
st->pm = 0;*/
}
}
return st->delay;
}
if (!st->img_loader &&
st->start_time + st->duration < time ((time_t) 0)) {
st->img_loader = load_image_async_simple (0, st->screen, st->window,
st->pm, 0, 0);
return st->delay;
}
#define nrnd(x) (random() % (x))
now = currentTimeInMs(st);
now += st->sinusoid_offset; /* don't run multiple screens in lock-step */
/* find new x,y */
st->tlx = ((1. + sin(((double)now) / X_PERIOD * 2. * M_PI))/2.0)
* (st->sizex - st->s/2) /* -s/4 */ + MINX;
st->tly = ((1. + sin(((double)now) / Y_PERIOD * 2. * M_PI))/2.0)
* (st->sizey - st->s/2) /* -s/4 */ + MINY;
if (st->lenses) {
for (x = i = 0; x < st->sizex; x += (st->pixwidth + st->pixspacex), ++i)
for (y = j = 0; y < st->sizey; y += (st->pixheight + st->pixspacey), ++j) {
XCopyArea(st->dpy, st->pm /* src */, st->window /* dest */, st->window_gc,
st->tlx + i * st->lensoffsetx /* src_x */,
st->tly + j * st->lensoffsety /* src_y */,
st->pixwidth, st->pixheight,
x /* dest_x */, y /* dest_y */);
}
} else {
for (x = i = 0; x < st->sizex; x += (st->pixwidth + st->pixspacex), ++i)
for (y = j = 0; y < st->sizey; y += (st->pixheight + st->pixspacey), ++j) {
XSetForeground(st->dpy, st->window_gc, XGetPixel(st->orig_map, st->tlx+i, st->tly+j));
XFillRectangle(st->dpy, st->window, st->window_gc,
i * (st->pixwidth + st->pixspacex),
j * (st->pixheight + st->pixspacey), st->pixwidth, st->pixheight);
}
}
return st->delay;
}
static void *
spotlight_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
XWindowAttributes xgwa;
long gcflags;
Colormap cmap;
unsigned long fg, bg;
GC clip_gc;
Pixmap clip_pm;
st->dpy = dpy;
st->window = window;
st->first_p = True;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
st->sizex = xgwa.width;
st->sizey = xgwa.height;
cmap = xgwa.colormap;
fg = get_pixel_resource (st->dpy, cmap, "foreground", "Foreground");
bg = get_pixel_resource (st->dpy, cmap, "background", "Background");
/* read parameters, keep em sane */
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
if (st->delay < 1) st->delay = 1;
st->radius = get_integer_resource (st->dpy, "radius", "Integer");
if (st->radius < 0) st->radius = 125;
/* Don't let the spotlight be bigger than the window */
while (st->radius > xgwa.width * 0.45)
st->radius /= 2;
while (st->radius > xgwa.height * 0.45)
st->radius /= 2;
if (st->radius < 4)
st->radius = 4;
/* do the dance */
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
gcflags = GCForeground | GCFunction;
gcv.foreground = bg;
#ifdef NOPE
if (use_subwindow_mode_p(xgwa.screen, st->window)) /* see grabscreen.c */
gcflags |= GCSubwindowMode;
#endif
st->window_gc = XCreateGC(st->dpy, st->window, gcflags, &gcv);
/* grab screen to pixmap */
st->pm = XCreatePixmap(st->dpy, st->window, st->sizex, st->sizey, xgwa.depth);
XClearWindow(st->dpy, st->window);
/* create buffer to reduce flicker */
#ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
st->buffer = 0;
#else
st->buffer = XCreatePixmap(st->dpy, st->window, st->sizex, st->sizey, xgwa.depth);
#endif
st->buffer_gc = XCreateGC(st->dpy, (st->buffer ? st->buffer : window), gcflags, &gcv);
if (st->buffer)
XFillRectangle(st->dpy, st->buffer, st->buffer_gc, 0, 0, st->sizex, st->sizey);
/* blank out screen */
XFillRectangle(st->dpy, st->window, st->window_gc, 0, 0, st->sizex, st->sizey);
XSetWindowBackground (st->dpy, st->window, bg);
/* create clip mask (so it's a circle, not a square) */
clip_pm = XCreatePixmap(st->dpy, st->window, st->radius*4, st->radius*4, 1);
st->img_loader = load_image_async_simple (0, xgwa.screen, st->window, st->pm,
0, 0);
gcv.foreground = 0L;
clip_gc = XCreateGC(st->dpy, clip_pm, gcflags, &gcv);
XFillRectangle(st->dpy, clip_pm, clip_gc, 0, 0, st->radius*4, st->radius*4);
XSetForeground(st->dpy, clip_gc, 1L);
XFillArc(st->dpy, clip_pm, clip_gc, st->radius , st->radius,
st->radius*2, st->radius*2, 0, 360*64);
/* set buffer's clip mask to the one we just made */
XSetClipMask(st->dpy, st->buffer_gc, clip_pm);
/* free everything */
XFreeGC(st->dpy, clip_gc);
XFreePixmap(st->dpy, clip_pm);
/* avoid remants */
st->max_x_speed = st->max_y_speed = st->radius;
st->off = random();
#ifdef DEBUG
/* create GC with white fg */
gcv.foreground = fg;
st->white_gc = XCreateGC(st->dpy, st->window, gcflags, &gcv);
#endif
return st;
}
/*
* perform one iteration
*/
static void
onestep (struct state *st, Bool first_p)
{
long now;
if (st->img_loader) /* still loading */
{
st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
return;
}
#define nrnd(x) (random() % (x))
st->oldx = st->x;
st->oldy = st->y;
st->s = st->radius *4 ; /* s = width of buffer */
now = currentTimeInMs(st) + st->off;
/* find new x,y */
st->x = ((1 + sin(((double)now) / X_PERIOD * 2. * M_PI))/2.0)
* (st->sizex - st->s/2) -st->s/4 + MINX;
st->y = ((1 + sin(((double)now) / Y_PERIOD * 2. * M_PI))/2.0)
* (st->sizey - st->s/2) -st->s/4 + MINY;
if (!st->first_p)
{
/* limit change in x and y to buffer width */
if ( st->x < (st->oldx - st->max_x_speed) ) st->x = st->oldx - st->max_x_speed;
if ( st->x > (st->oldx + st->max_x_speed) ) st->x = st->oldx + st->max_x_speed;
if ( st->y < (st->oldy - st->max_y_speed) ) st->y = st->oldy - st->max_y_speed;
if ( st->y > (st->oldy + st->max_y_speed) ) st->y = st->oldy + st->max_y_speed;
}
if (! st->buffer)
{
XClearWindow (st->dpy, st->window);
XSetClipOrigin(st->dpy, st->buffer_gc, st->x,st->y);
XCopyArea(st->dpy, st->pm, st->window, st->buffer_gc, st->x, st->y, st->s, st->s, st->x, st->y);
}
else
{
/* clear buffer */
XFillRectangle(st->dpy, st->buffer, st->buffer_gc, st->x, st->y, st->s, st->s);
/* copy area of screen image (pm) to buffer
Clip to a circle */
XSetClipOrigin(st->dpy, st->buffer_gc, st->x,st->y);
XCopyArea(st->dpy, st->pm, st->buffer, st->buffer_gc, st->x, st->y, st->s, st->s, st->x, st->y);
/* copy buffer to screen (window) */
XCopyArea(st->dpy, st->buffer, st->window, st->window_gc, st->x , st->y, st->s, st->s, st->x, st->y);
}
#ifdef DEBUG
/* draw a box around the buffer */
XDrawRectangle(st->dpy, st->window, st->white_gc, st->x , st->y, st->s, st->s);
#endif
}
static void
reset_boxes (state *st)
{
st->nboxes = 0;
st->growing_p = True;
st->color_horiz_p = random() & 1;
if (st->done_once && st->colors)
free_colors (st->xgwa.screen, st->xgwa.colormap, st->colors, st->ncolors);
if (!st->done_once)
{
char *s = get_string_resource (st->dpy, "mode", "Mode");
if (!s || !*s || !strcasecmp (s, "random"))
st->mode = -1;
else if (!strcasecmp (s, "squares") || !strcasecmp (s, "square"))
st->mode = 0;
else if (!strcasecmp (s, "circles") || !strcasecmp (s, "circle"))
st->mode = 1;
else
{
fprintf (stderr,
"%s: mode must be random, squares, or circles, not '%s'\n",
progname, s);
exit (1);
}
}
if (st->mode == -1)
st->circles_p = random() & 1;
else
st->circles_p = (st->mode == 1);
st->done_once = True;
if (st->image || get_boolean_resource (st->dpy, "grab", "Boolean"))
{
if (st->image) XDestroyImage (st->image);
st->image = 0;
if (st->loading_pixmap) abort();
if (st->img_loader) abort();
if (!get_boolean_resource (st->dpy, "peek", "Boolean"))
st->loading_pixmap = XCreatePixmap (st->dpy, st->window,
st->xgwa.width, st->xgwa.height,
st->xgwa.depth);
XClearWindow (st->dpy, st->window);
st->img_loader = load_image_async_simple (0, st->xgwa.screen,
st->window,
(st->loading_pixmap
? st->loading_pixmap
: st->window),
0, 0);
}
else
{
st->ncolors = get_integer_resource (st->dpy, "colors", "Colors"); /* re-get */
if (st->ncolors < 1) st->ncolors = 1;
make_smooth_colormap (st->xgwa.screen, st->xgwa.visual, st->xgwa.colormap,
st->colors, &st->ncolors, True, 0, False);
if (st->ncolors < 1) abort();
XClearWindow (st->dpy, st->window);
}
}
