static void *
whirlygig_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
st->dpy = dpy;
st->window = window;
st->ncolors = NCOLORS;
st->dbuf = get_boolean_resource (st->dpy, "doubleBuffer", "Boolean");
# ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */
st->dbuf = False;
# endif
st->start_time = st->current_time;
st->info = (struct info *)malloc(sizeof(struct info));
st->screen = DefaultScreen(st->dpy);
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
if (st->dbuf)
{
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
if (get_boolean_resource(st->dpy,"useDBE","Boolean"))
{
st->dbeclear_p = get_boolean_resource (st->dpy, "useDBEClear",
"Boolean");
if (st->dbeclear_p)
st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeBackground);
else
st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeUndefined);
st->backb = st->b;
}
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
if (!st->b)
{
st->ba = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height,st->xgwa.depth);
st->b = st->ba;
}
}
else
{
st->b = st->window;
}
st->gcv.foreground = get_pixel_resource(st->dpy, st->xgwa.colormap, "foreground", "Foreground");
st->fgc = XCreateGC (st->dpy, st->b, GCForeground, &st->gcv);
st->gcv.foreground = get_pixel_resource(st->dpy, st->xgwa.colormap, "background", "Background");
st->bgc = XCreateGC (st->dpy, st->b, GCForeground, &st->gcv);
#ifdef HAVE_JWXYZ /* #### should turn off double-buffering instead */
jwxyz_XSetAntiAliasing (dpy, st->fgc, False);
jwxyz_XSetAntiAliasing (dpy, st->bgc, False);
#endif
{
Bool writable_p = False;
make_uniform_colormap (st->xgwa.screen, st->xgwa.visual,
st->xgwa.colormap, st->colors, &st->ncolors,
True, &writable_p, True);
}
if (st->ba) XFillRectangle (st->dpy, st->ba, st->bgc, 0, 0, st->xgwa.width, st->xgwa.height);
/* info is a structure holding all the random pieces of information I may want to
pass to my baby functions -- much of it I may never use, but it is nice to
have around just in case I want it to make a funky function funkier */
/* info->writable = get_boolean_resource (dpy, "cycle", "Boolean"); */
st->info->xspeed = get_float_resource(st->dpy, "xspeed" , "Float");
st->info->yspeed = get_float_resource(st->dpy, "yspeed" , "Float");
st->info->xamplitude = get_float_resource(st->dpy, "xamplitude", "Float");
st->info->yamplitude = get_float_resource(st->dpy, "yamplitude", "Float");
st->info->offset_period = get_float_resource(st->dpy, "offset_period", "Float");
st->info->whirlies = get_integer_resource(st->dpy, "whirlies", "Integer");
st->info->nlines = get_integer_resource(st->dpy, "nlines", "Integer");
st->info->half_width = st->xgwa.width / 2;
st->info->half_height = st->xgwa.height / 2;
st->info->speed = get_integer_resource(st->dpy, "speed" , "Integer");
st->info->trail = get_boolean_resource(st->dpy, "trail", "Integer");
st->info->color_modifier = get_integer_resource(st->dpy, "color_modifier", "Integer");
st->info->xoffset = get_float_resource(st->dpy, "xoffset", "Float");
st->info->yoffset = get_float_resource(st->dpy, "yoffset", "Float");
st->xmode_str = get_string_resource(st->dpy, "xmode", "Mode");
st->ymode_str = get_string_resource(st->dpy, "ymode", "Mode");
st->wrap = get_boolean_resource(st->dpy, "wrap", "Boolean");
st->modifier = 3000.0 + frand(1500.0);
if (! st->xmode_str) st->xmode = spin_mode;
else if (! strcmp (st->xmode_str, "spin")) st->xmode = spin_mode;
else if (! strcmp (st->xmode_str, "funky")) st->xmode = funky_mode;
else if (! strcmp (st->xmode_str, "circle")) st->xmode = circle_mode;
else if (! strcmp (st->xmode_str, "linear")) st->xmode = linear_mode;
else if (! strcmp (st->xmode_str, "test")) st->xmode = test_mode;
else if (! strcmp (st->xmode_str, "fun")) st->xmode = fun_mode;
else if (! strcmp (st->xmode_str, "innie")) st->xmode = innie_mode;
else if (! strcmp (st->xmode_str, "lissajous")) st->xmode = lissajous_mode;
else {
st->xmode = random() % (int) lissajous_mode;
}
if (! st->ymode_str) st->ymode = spin_mode;
else if (! strcmp (st->ymode_str, "spin")) st->ymode = spin_mode;
else if (! strcmp (st->ymode_str, "funky")) st->ymode = funky_mode;
else if (! strcmp (st->ymode_str, "circle")) st->ymode = circle_mode;
else if (! strcmp (st->ymode_str, "linear")) st->ymode = linear_mode;
else if (! strcmp (st->ymode_str, "test")) st->ymode = test_mode;
else if (! strcmp (st->ymode_str, "fun")) st->ymode = fun_mode;
else if (! strcmp (st->ymode_str, "innie")) st->ymode = innie_mode;
else if (! strcmp (st->ymode_str, "lissajous")) st->ymode = lissajous_mode;
else {
st->ymode = random() % (int) lissajous_mode;
}
if (get_integer_resource(st->dpy, "start_time", "Integer") == -1)
st->current_time = (unsigned long int)(random());
else
st->current_time = get_integer_resource(st->dpy, "start_time", "Integer");
if (st->info->whirlies == -1)
st->info->whirlies = 1 + (random() % 15);
if (st->info->nlines == -1)
st->info->nlines = 1 + (random() % 5);
if (st->info->color_modifier == -1)
st->info->color_modifier = 1 + (random() % 25);
if (get_boolean_resource(st->dpy, "explain", "Integer"))
st->explaining = 1;
st->current_color = 1 + (random() % NCOLORS);
return st;
}
static void *
deluxe_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
int i;
st->dpy = dpy;
st->window = window;
st->count = get_integer_resource (st->dpy, "count", "Integer");
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
st->ncolors = get_integer_resource (st->dpy, "ncolors", "Integer");
st->dbuf = get_boolean_resource (st->dpy, "doubleBuffer", "Boolean");
# ifdef HAVE_DOUBLE_BUFFER_EXTENSION
st->dbeclear_p = get_boolean_resource (st->dpy, "useDBEClear", "Boolean");
#endif
# ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */
st->dbuf = False;
# endif
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
st->transparent_p = get_boolean_resource(st->dpy, "transparent", "Transparent");
st->colors = (XColor *) calloc (sizeof(*st->colors), st->ncolors);
if (get_boolean_resource(st->dpy, "mono", "Boolean"))
{
MONO:
st->ncolors = 1;
st->colors[0].pixel = get_pixel_resource(st->dpy, st->xgwa.colormap,
"foreground", "Foreground");
}
#ifndef HAVE_JWXYZ
else if (st->transparent_p)
{
st->nplanes = get_integer_resource (st->dpy, "planes", "Planes");
if (st->nplanes <= 0)
st->nplanes = (random() % (st->xgwa.depth-2)) + 2;
allocate_alpha_colors (st->xgwa.screen, st->xgwa.visual, st->xgwa.colormap,
&st->nplanes, True, &st->plane_masks,
&st->base_pixel);
if (st->nplanes <= 1)
{
# if 0
fprintf (stderr,
"%s: couldn't allocate any color planes; turning transparency off.\n",
progname);
# endif
st->transparent_p = False;
goto COLOR;
}
}
#endif /* !HAVE_JWXYZ */
else
{
#ifndef HAVE_JWXYZ
COLOR:
#endif
make_random_colormap (st->xgwa.screen, st->xgwa.visual, st->xgwa.colormap,
st->colors, &st->ncolors, True, True, 0, True);
if (st->ncolors < 2)
goto MONO;
}
if (st->dbuf)
{
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
if (st->dbeclear_p)
st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeBackground);
else
st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeUndefined);
st->backb = st->b;
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
if (!st->b)
{
st->ba = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height,st->xgwa.depth);
st->bb = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height,st->xgwa.depth);
st->b = st->ba;
}
}
else
{
st->b = st->window;
}
st->throbbers = (struct throbber **) calloc (st->count, sizeof(struct throbber *));
for (i = 0; i < st->count; i++)
st->throbbers[i] = make_throbber (st, st->b, st->xgwa.width, st->xgwa.height,
st->colors[random() % st->ncolors].pixel);
gcv.foreground = get_pixel_resource (st->dpy, st->xgwa.colormap,
"background", "Background");
st->erase_gc = XCreateGC (st->dpy, st->b, GCForeground, &gcv);
if (st->ba) XFillRectangle (st->dpy, st->ba, st->erase_gc, 0, 0, st->xgwa.width, st->xgwa.height);
if (st->bb) XFillRectangle (st->dpy, st->bb, st->erase_gc, 0, 0, st->xgwa.width, st->xgwa.height);
return st;
}
static void *
popsquares_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
int x, y;
double s1, v1, s2, v2 = 0;
int h1, h2 = 0;
/* Not sure how to use DBEClear */
/* Bool dbeclear_p = get_boolean_resource(dpy, "useDBEClear", "Boolean"); */
XColor fg, bg;
XGCValues gcv;
st->dpy = dpy;
st->window = window;
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
st->subdivisionx = get_integer_resource(st->dpy, "subdivision", "Integer");
st->subdivisiony = st->subdivisionx;
st->border = get_integer_resource(st->dpy, "border", "Integer");
st->ncolors = get_integer_resource(st->dpy, "ncolors", "Integer");
st->twitch = get_boolean_resource(st->dpy, "twitch", "Boolean");
st->dbuf = get_boolean_resource(st->dpy, "doubleBuffer", "Boolean");
# ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */
st->dbuf = False;
# endif
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
fg.pixel = get_pixel_resource (st->dpy, st->xgwa.colormap, "foreground", "Foreground");
bg.pixel = get_pixel_resource (st->dpy, st->xgwa.colormap, "background", "Background");
XQueryColor (st->dpy, st->xgwa.colormap, &fg);
XQueryColor (st->dpy, st->xgwa.colormap, &bg);
st->sw = st->xgwa.width / st->subdivisionx;
st->sh = st->xgwa.height / st->subdivisiony;
st->gw = st->sw ? st->xgwa.width / st->sw : 0;
st->gh = st->sh ? st->xgwa.height / st->sh : 0;
st->nsquares = st->gw * st->gh;
if (st->nsquares < 1) st->nsquares = 1;
if (st->ncolors < 1) st->ncolors = 1;
gcv.foreground = fg.pixel;
gcv.background = bg.pixel;
st->gc = XCreateGC (st->dpy, st->window, GCForeground|GCBackground, &gcv);
st->colors = (XColor *) calloc (st->ncolors, sizeof(XColor));
st->squares = (square *) calloc (st->nsquares, sizeof(square));
rgb_to_hsv (fg.red, fg.green, fg.blue, &h1, &s1, &v1);
rgb_to_hsv (bg.red, bg.green, bg.blue, &h2, &s2, &v2);
make_color_ramp (st->xgwa.screen, st->xgwa.visual, st->xgwa.colormap,
h1, s1, v1,
h2, s2, v2,
st->colors, &st->ncolors, /* would this be considered a value-result argument? */
True, True, False);
if (st->ncolors < 2)
{
fprintf (stderr, "%s: insufficient colors!\n", progname);
exit (1);
}
for (y = 0; y < st->gh; y++)
for (x = 0; x < st->gw; x++)
{
square *s = (square *) &st->squares[st->gw * y + x];
s->w = st->sw;
s->h = st->sh;
s->x = x * st->sw;
s->y = y * st->sh;
}
randomize_square_colors(st->squares, st->nsquares, st->ncolors);
if (st->dbuf)
{
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
st->b = xdbe_get_backbuffer (st->dpy, st->window, XdbeUndefined);
st->backb = st->b;
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
if (!st->b)
{
st->ba = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height, st->xgwa.depth);
st->bb = XCreatePixmap (st->dpy, st->window, st->xgwa.width, st->xgwa.height, st->xgwa.depth);
st->b = st->ba;
}
}
else
{
st->b = st->window;
}
popsquares_reshape (dpy, window, st, st->xgwa.width, st->xgwa.height);
return st;
}
static Bool InitializeAll(struct state *st)
{
XGCValues xgcv;
XWindowAttributes xgwa;
/* XSetWindowAttributes xswa;*/
Colormap cmap;
XColor color;
int n,i;
double rspeed;
st->cosilines = True;
XGetWindowAttributes(st->dpy,st->win[0],&xgwa);
cmap=xgwa.colormap;
/* xswa.backing_store=Always;
XChangeWindowAttributes(st->dpy,st->win[0],CWBackingStore,&xswa);*/
xgcv.function=GXcopy;
xgcv.foreground=get_pixel_resource (st->dpy, cmap, "background", "Background");
st->fgc[32]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
n=0;
if (mono_p)
{
st->fgc[0]=st->fgc[32];
xgcv.foreground=get_pixel_resource (st->dpy, cmap, "foreground", "Foreground");
st->fgc[1]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
for (i=0;i<32;i+=2) st->fgc[i]=st->fgc[0];
for (i=1;i<32;i+=2) st->fgc[i]=st->fgc[1];
} else
for (i=0;i<32;i++)
{
color.red=colors[n++]<<8;
color.green=colors[n++]<<8;
color.blue=colors[n++]<<8;
color.flags=DoRed|DoGreen|DoBlue;
XAllocColor(st->dpy,cmap,&color);
xgcv.foreground=color.pixel;
st->fgc[i]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
}
st->cgc=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
XSetGraphicsExposures(st->dpy,st->cgc,False);
st->cosilines = get_boolean_resource(st->dpy, "random","Boolean");
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
if (get_boolean_resource (st->dpy, "useDBE", "Boolean"))
st->usedouble = True;
st->win[1] = xdbe_get_backbuffer (st->dpy, st->win[0], XdbeUndefined);
if (!st->win[1])
{
st->usedouble = False;
st->win[1] = st->win[0];
}
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
st->delay=get_integer_resource(st->dpy, "delay","Integer");
rspeed=get_float_resource(st->dpy, "speed","Float");
if (rspeed<0.0001 || rspeed>0.2)
{
fprintf(stderr,"Speed not in valid range! (0.0001 - 0.2), using 0.1 \n");
rspeed=0.1;
}
st->sizx=xgwa.width;
st->sizy=xgwa.height;
st->midx=st->sizx>>1;
st->midy=st->sizy>>1;
st->stateX=0;
st->stateY=0;
if (!make_rots(st,rspeed,rspeed))
{
fprintf(stderr,"Not enough memory for tables!\n");
return False;
}
return True;
}
static void *
compass_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
st->dpy = dpy;
st->window = window;
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
st->dbuf = get_boolean_resource (st->dpy, "doubleBuffer", "Boolean");
# ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */
st->dbuf = False;
# endif
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
st->size2 = MIN(st->xgwa.width, st->xgwa.height);
if (st->xgwa.width > st->xgwa.height * 5 || /* goofy aspect ratio */
st->xgwa.height > st->xgwa.width * 5)
st->size2 = MAX(st->xgwa.width, st->xgwa.height);
{
int max = 600;
if (st->xgwa.width > 2560) max *= 2; /* Retina displays */
if (st->size2 > max) st->size2 = max;
}
st->size = (st->size2 / 2) * 0.8;
st->x = st->xgwa.width/2;
st->y = st->xgwa.height/2;
if (st->dbuf)
{
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
st->b = st->backb = xdbe_get_backbuffer (st->dpy, st->window, XdbeUndefined);
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
if (!st->b)
{
st->x = st->size2/2;
st->y = st->size2/2;
st->ba = XCreatePixmap (st->dpy, st->window, st->size2, st->size2, st->xgwa.depth);
st->bb = XCreatePixmap (st->dpy, st->window, st->size2, st->size2, st->xgwa.depth);
st->b = st->ba;
}
}
else
{
st->b = st->window;
}
st->discs[0] = (struct disc *) calloc (1, sizeof (struct disc));
st->discs[1] = (struct disc *) calloc (1, sizeof (struct disc));
st->discs[2] = (struct disc *) calloc (1, sizeof (struct disc));
st->discs[3] = 0;
gcv.foreground = get_pixel_resource (st->dpy, st->xgwa.colormap,
"foreground", "Foreground");
gcv.line_width = MAX(2, (st->size/60));
gcv.join_style = JoinBevel;
st->discs[0]->draw = draw_ticks;
st->discs[0]->gc = XCreateGC (st->dpy, st->b, GCForeground|GCLineWidth|GCJoinStyle,
&gcv);
init_spin (st->discs[0]);
gcv.foreground = get_pixel_resource (st->dpy, st->xgwa.colormap,
"arrow2Foreground", "Foreground");
gcv.line_width = MAX(4, (st->size / 30));
st->discs[1]->draw = draw_thick_arrow;
st->discs[1]->gc = XCreateGC (st->dpy, st->b, GCForeground|GCLineWidth, &gcv);
init_spin (st->discs[1]);
gcv.foreground = get_pixel_resource (st->dpy, st->xgwa.colormap,
"arrow1Foreground", "Foreground");
gcv.line_width = MAX(4, (st->size / 30));
st->discs[2]->draw = draw_thin_arrow;
st->discs[2]->gc = XCreateGC (st->dpy, st->b, GCForeground|GCLineWidth, &gcv);
init_spin (st->discs[2]);
gcv.foreground = get_pixel_resource (st->dpy, st->xgwa.colormap,
"pointerForeground", "Foreground");
st->ptr_gc = XCreateGC (st->dpy, st->b, GCForeground|GCLineWidth, &gcv);
gcv.foreground = get_pixel_resource (st->dpy, st->xgwa.colormap,
"background", "Background");
st->erase_gc = XCreateGC (st->dpy, st->b, GCForeground, &gcv);
if (st->ba) XFillRectangle (st->dpy, st->ba, st->erase_gc, 0, 0, st->size2, st->size2);
if (st->bb) XFillRectangle (st->dpy, st->bb, st->erase_gc, 0, 0, st->size2, st->size2);
return st;
}
static void *
anemone_init (Display *disp, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XWindowAttributes wa;
st->dpy = disp;
st->turn = 0.;
st->width = get_integer_resource(st->dpy, "width", "Integer");
st->arms = get_integer_resource(st->dpy, "arms", "Integer");
st->finpoints = get_integer_resource(st->dpy, "finpoints", "Integer");
st->delay = get_integer_resource(st->dpy, "delay", "Integer");
st->withdraw = get_integer_resource(st->dpy, "withdraw", "Integer");
st->turndelta = get_float_resource(st->dpy, "turnspeed", "float") / 100000;
st->dbuf = TRUE;
# ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */
st->dbuf = False;
# endif
st->b = st->ba = st->bb = 0; /* double-buffer to reduce flicker */
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
st->b = st->backb = xdbe_get_backbuffer (st->dpy, window, XdbeUndefined);
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
XGetWindowAttributes(st->dpy, window, &wa);
st->scrWidth = wa.width;
st->scrHeight = wa.height;
st->cmap = wa.colormap;
st->ncolors = get_integer_resource (st->dpy, "colors", "Colors");
st->ncolors += 3;
st->colors = (XColor *) malloc(sizeof(*st->colors) * (st->ncolors+1));
make_smooth_colormap (wa.screen, wa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
st->gcDraw = XCreateGC(st->dpy, window, 0, &st->gcv);
st->gcv.foreground = get_pixel_resource(st->dpy, st->cmap,
"background", "Background");
st->gcClear = XCreateGC(st->dpy, window, GCForeground, &st->gcv);
if (st->dbuf) {
if (!st->b)
{
st->ba = XCreatePixmap (st->dpy, window, st->scrWidth, st->scrHeight, wa.depth);
st->bb = XCreatePixmap (st->dpy, window, st->scrWidth, st->scrHeight, wa.depth);
st->b = st->ba;
}
}
else
{
st->b = window;
}
if (st->ba) XFillRectangle (st->dpy, st->ba, st->gcClear, 0, 0, st->scrWidth, st->scrHeight);
if (st->bb) XFillRectangle (st->dpy, st->bb, st->gcClear, 0, 0, st->scrWidth, st->scrHeight);
XClearWindow(st->dpy, window);
XSetLineAttributes(st->dpy, st->gcDraw, st->width, LineSolid, CapRound, JoinBevel);
initAppendages(st);
return st;
}
static void *
fontglide_init (Display *dpy, Window window)
{
XGCValues gcv;
state *s = (state *) calloc (1, sizeof(*s));
s->dpy = dpy;
s->window = window;
s->frame_delay = get_integer_resource (dpy, "delay", "Integer");
XGetWindowAttributes (s->dpy, s->window, &s->xgwa);
s->font_override = get_string_resource (dpy, "font", "Font");
if (s->font_override && (!*s->font_override || *s->font_override == '('))
s->font_override = 0;
s->charset = get_string_resource (dpy, "fontCharset", "FontCharset");
s->border_width = get_integer_resource (dpy, "fontBorderWidth", "Integer");
if (s->border_width < 0 || s->border_width > 20)
s->border_width = 1;
s->speed = get_float_resource (dpy, "speed", "Float");
if (s->speed <= 0 || s->speed > 200)
s->speed = 1;
s->linger = get_float_resource (dpy, "linger", "Float");
if (s->linger <= 0 || s->linger > 200)
s->linger = 1;
s->trails_p = get_boolean_resource (dpy, "trails", "Trails");
s->debug_p = get_boolean_resource (dpy, "debug", "Debug");
s->debug_metrics_p = (get_boolean_resource (dpy, "debugMetrics", "Debug")
? 'y' : 0);
s->dbuf = get_boolean_resource (dpy, "doubleBuffer", "Boolean");
# ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
s->dbuf = False;
# endif
if (s->trails_p) s->dbuf = False; /* don't need it in this case */
{
char *ss = get_string_resource (dpy, "mode", "Mode");
if (!ss || !*ss || !strcasecmp (ss, "random"))
s->mode = ((random() % 2) ? SCROLL : PAGE);
else if (!strcasecmp (ss, "scroll"))
s->mode = SCROLL;
else if (!strcasecmp (ss, "page"))
s->mode = PAGE;
else
{
fprintf (stderr,
"%s: `mode' must be `scroll', `page', or `random', not `%s'\n",
progname, ss);
}
}
if (s->dbuf)
{
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
s->dbeclear_p = get_boolean_resource (dpy, "useDBEClear", "Boolean");
if (s->dbeclear_p)
s->b = xdbe_get_backbuffer (dpy, window, XdbeBackground);
else
s->b = xdbe_get_backbuffer (dpy, window, XdbeUndefined);
s->backb = s->b;
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
if (!s->b)
{
s->ba = XCreatePixmap (s->dpy, s->window,
s->xgwa.width, s->xgwa.height,
s->xgwa.depth);
s->b = s->ba;
}
}
else
{
s->b = s->window;
}
gcv.foreground = get_pixel_resource (s->dpy, s->xgwa.colormap,
"background", "Background");
s->bg_gc = XCreateGC (s->dpy, s->b, GCForeground, &gcv);
s->subproc_relaunch_delay = 2 * 1000;
if (! s->debug_metrics_p)
launch_text_generator (s);
s->nsentences = 5; /* #### */
s->sentences = (sentence **) calloc (s->nsentences, sizeof (sentence *));
s->spawn_p = True;
return s;
}
static void inter_init(Display* dpy, Window win, struct inter_context* c)
{
XWindowAttributes xgwa;
double H[3], S[3], V[3];
int i;
int mono;
int gray;
XGCValues val;
unsigned long valmask = 0;
Bool dbuf = get_boolean_resource (dpy, "doubleBuffer", "Boolean");
# ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */
dbuf = False;
# endif
memset (c, 0, sizeof(*c));
c->dpy = dpy;
c->win = win;
c->delay = get_integer_resource(dpy, "delay", "Integer");
XGetWindowAttributes(c->dpy, c->win, &xgwa);
c->w = xgwa.width;
c->h = xgwa.height;
c->cmap = xgwa.colormap;
#ifdef HAVE_XSHM_EXTENSION
c->use_shm = get_boolean_resource(dpy, "useSHM", "Boolean");
#endif /* HAVE_XSHM_EXTENSION */
if (dbuf)
{
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
c->back_buf = xdbe_get_backbuffer (c->dpy, c->win, XdbeUndefined);
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
#ifdef HAVE_DOUBLE_BUFFER_EXTENSION
if (!c->back_buf)
#endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
c->pix_buf = XCreatePixmap (dpy, win, xgwa.width, xgwa.height,
xgwa.depth);
}
val.function = GXcopy;
c->copy_gc = XCreateGC(c->dpy, TARGET(c), GCFunction, &val);
c->count = get_integer_resource(dpy, "count", "Integer");
if(c->count < 1)
c->count = 1;
c->grid_size = get_integer_resource(dpy, "gridsize", "Integer");
if(c->grid_size < 1)
c->grid_size = 1;
mono = get_boolean_resource(dpy, "mono", "Boolean");
if(!mono) {
c->colors = get_integer_resource(dpy, "ncolors", "Integer");
if(c->colors < 2)
c->colors = 2;
}
c->hue = get_integer_resource(dpy, "hue", "Float");
while (c->hue < 0 || c->hue >= 360)
c->hue = frand(360.0);
c->speed = get_integer_resource(dpy, "speed", "Integer");
c->shift = get_float_resource(dpy, "color-shift", "Float");
while(c->shift >= 360.0)
c->shift -= 360.0;
while(c->shift <= -360.0)
c->shift += 360.0;
c->radius = get_integer_resource(dpy, "radius", "Integer");;
if(c->radius < 1)
c->radius = 1;
#ifdef USE_XIMAGE
c->ximage = 0;
# ifdef HAVE_XSHM_EXTENSION
if (c->use_shm)
{
c->ximage = create_xshm_image(dpy, xgwa.visual, xgwa.depth,
ZPixmap, 0, &c->shm_info,
xgwa.width, c->grid_size);
if (!c->ximage)
c->use_shm = False;
}
# endif /* HAVE_XSHM_EXTENSION */
if (!c->ximage)
{
c->ximage =
XCreateImage (dpy, xgwa.visual,
xgwa.depth, ZPixmap, 0, 0, /* depth, fmt, offset, data */
xgwa.width, c->grid_size, /* width, height */
8, 0); /* pad, bpl */
c->ximage->data = (unsigned char *)
calloc(c->ximage->height, c->ximage->bytes_per_line);
}
#endif /* USE_XIMAGE */
if(!mono) {
c->pal = calloc(c->colors, sizeof(XColor));
gray = get_boolean_resource(dpy, "gray", "Boolean");
if(!gray) {
H[0] = c->hue;
H[1] = H[0] + c->shift < 360.0 ? H[0]+c->shift : H[0] + c->shift-360.0;
H[2] = H[1] + c->shift < 360.0 ? H[1]+c->shift : H[1] + c->shift-360.0;
S[0] = S[1] = S[2] = 1.0;
V[0] = V[1] = V[2] = 1.0;
} else {
H[0] = H[1] = H[2] = 0.0;
S[0] = S[1] = S[2] = 0.0;
V[0] = 1.0; V[1] = 0.5; V[2] = 0.0;
}
make_color_loop(c->dpy, c->cmap,
H[0], S[0], V[0],
H[1], S[1], V[1],
H[2], S[2], V[2],
c->pal, &(c->colors),
True, False);
if(c->colors < 2) { /* color allocation failure */
mono = 1;
free(c->pal);
}
}
if(mono) { /* DON'T else this with the previous if! */
c->colors = 2;
c->pal = calloc(2, sizeof(XColor));
c->pal[0].pixel = BlackPixel(c->dpy, DefaultScreen(c->dpy));
c->pal[1].pixel = WhitePixel(c->dpy, DefaultScreen(c->dpy));
}
valmask = GCForeground;
c->gcs = calloc(c->colors, sizeof(GC));
for(i = 0; i < c->colors; i++) {
val.foreground = c->pal[i].pixel;
c->gcs[i] = XCreateGC(c->dpy, TARGET(c), valmask, &val);
}
c->wave_height = calloc(c->radius, sizeof(int));
for(i = 0; i < c->radius; i++) {
float max =
((float)c->colors) *
((float)c->radius - (float)i) /
((float)c->radius);
c->wave_height[i] =
(int)
((max + max*cos((double)i/50.0)) / 2.0);
}
c->source = calloc(c->count, sizeof(struct inter_source));
for(i = 0; i < c->count; i++) {
c->source[i].x_theta = frand(2.0)*3.14159;
c->source[i].y_theta = frand(2.0)*3.14159;
}
}
