static void *
lcdscrub_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->spread = get_integer_resource (st->dpy, "spread", "Integer");
st->cycles = get_integer_resource (st->dpy, "cycles", "Integer");
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
gcv.foreground = BlackPixelOfScreen (st->xgwa.screen);
gcv.background = WhitePixelOfScreen (st->xgwa.screen);
st->bg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
gcv.foreground = WhitePixelOfScreen (st->xgwa.screen);
gcv.background = BlackPixelOfScreen (st->xgwa.screen);
st->fg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (st->dpy, st->fg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg, False);
#endif
return st;
}
static eraser_state *
eraser_init (Display *dpy, Window window)
{
eraser_state *st = (eraser_state *) calloc (1, sizeof(*st));
XWindowAttributes xgwa;
XGCValues gcv;
unsigned long fg, bg;
double duration;
int which;
char *s;
st->dpy = dpy;
st->window = window;
XGetWindowAttributes (dpy, window, &xgwa);
st->width = xgwa.width;
st->height = xgwa.height;
//bg = get_pixel_resource (dpy, xgwa.colormap, "background", "Background");
//fg = get_pixel_resource (dpy, xgwa.colormap, "foreground", "Foreground");
bg = load_color(dpy, xgwa.colormap, background);
fg = load_color(dpy, xgwa.colormap, foreground);
gcv.foreground = fg;
gcv.background = bg;
st->fg_gc = XCreateGC (dpy, window, GCForeground|GCBackground, &gcv);
gcv.foreground = bg;
gcv.background = fg;
st->bg_gc = XCreateGC (dpy, window, GCForeground|GCBackground, &gcv);
# ifdef HAVE_COCOA
/* Pretty much all of these leave turds if AA is on. */
jwxyz_XSetAntiAliasing (st->dpy, st->fg_gc, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg_gc, False);
# endif
//s = get_string_resource (dpy, "eraseMode", "Integer");
s = eraseMode;
if (!s || !*s)
which = -1;
else
//which = get_integer_resource(dpy, "eraseMode", "Integer");
which = atoi(eraseMode);
if (which < 0 || which >= countof(erasers))
which = random() % countof(erasers);
st->fn = erasers[which];
//duration = get_float_resource (dpy, "eraseSeconds", "Float");
duration = eraseSeconds;
if (duration < 0.1 || duration > 10)
duration = 1;
st->start_time = double_time();
st->stop_time = st->start_time + duration;
XSync (st->dpy, False);
return st;
}
static void *
lcdscrub_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->spread = get_integer_resource (st->dpy, "spread", "Integer");
//st->cycles = get_integer_resource (st->dpy, "cycles", "Integer");
st->delay = delay;
st->spread = spread;
st->cycles = cycles;
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
gcv.foreground = BlackPixelOfScreen (st->xgwa.screen);
gcv.background = WhitePixelOfScreen (st->xgwa.screen);
st->bg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
st->bg2 = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
gcv.foreground = WhitePixelOfScreen (st->xgwa.screen);
gcv.background = BlackPixelOfScreen (st->xgwa.screen);
st->fg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (st->dpy, st->fg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg2, False);
#endif
st->enabled_mask = 0;
#if 1
# define PREF(R,F) \
if (R) st->enabled_mask |= (1 << F)
#else
# define PREF(R,F) \
if (get_boolean_resource (st->dpy, R, "Mode")) st->enabled_mask |= (1 << F)
#endif
PREF("modeHW", HORIZ_W);
PREF("modeHB", HORIZ_B);
PREF("modeVW", VERT_W);
PREF("modeVB", VERT_B);
PREF("modeDW", DIAG_W);
PREF("modeDB", DIAG_B);
PREF("modeW", WHITE);
PREF("modeB", BLACK);
PREF("modeRGB", RGB);
# undef PREF
if (! st->enabled_mask)
{
fprintf (stderr, "%s: no modes enabled\n", progname);
exit (1);
}
pick_mode (st);
return st;
}
static void
init_planet(ModeInfo * mi, planetstruct * planet)
{
gravstruct *gp = &gravs[MI_SCREEN(mi)];
# ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
# endif
if (MI_NPIXELS(mi) > 2)
planet->colors = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
else
planet->colors = MI_WHITE_PIXEL(mi);
/* Initialize positions */
POS(X) = FLOATRAND(-XR, XR);
POS(Y) = FLOATRAND(-YR, YR);
POS(Z) = FLOATRAND(-ZR, ZR);
if (POS(Z) > -ALMOST) {
planet->xi = (int)
((double) gp->width * (HALF + POS(X) / (POS(Z) + DIST)));
planet->yi = (int)
((double) gp->height * (HALF + POS(Y) / (POS(Z) + DIST)));
} else
planet->xi = planet->yi = -1;
planet->ri = RADIUS;
/* Initialize velocities */
VEL(X) = FLOATRAND(-VR, VR);
VEL(Y) = FLOATRAND(-VR, VR);
VEL(Z) = FLOATRAND(-VR, VR);
}
ENTRYPOINT void
init_lissie (ModeInfo * mi)
{
lissstruct *lp;
unsigned char ball;
MI_INIT (mi, lisses, 0);
lp = &lisses[MI_SCREEN(mi)];
lp->width = MI_WIDTH(mi);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
#endif
lp->height = MI_HEIGHT(mi);
lp->nlissies = MI_COUNT(mi);
if (lp->nlissies < -MINLISSIES) {
if (lp->lissie) {
(void) free((void *) lp->lissie);
lp->lissie = (lissiestruct *) NULL;
}
lp->nlissies = NRAND(-lp->nlissies - MINLISSIES + 1) + MINLISSIES;
} else if (lp->nlissies < MINLISSIES)
lp->nlissies = MINLISSIES;
lp->loopcount = 0;
if (lp->lissie == NULL)
if ((lp->lissie = (lissiestruct *) calloc(lp->nlissies,
sizeof (lissiestruct))) == NULL)
return;
MI_CLEARWINDOW(mi);
lp->painted = False;
for (ball = 0; ball < (unsigned char) lp->nlissies; ball++)
initlissie(mi, &lp->lissie[ball]);
}
static void *
penetrate_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
int i;
/*char *fontname = "-*-new century schoolbook-*-r-*-*-*-380-*-*-*-*-*-*"; */
char *fontname = "-*-courier-*-r-*-*-*-380-*-*-*-*-*-*";
XGCValues gcv;
XWindowAttributes xgwa;
st->dpy = dpy;
st->window = window;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
st->cmap = xgwa.colormap;
st->lrate = 80;
st->nextBonus = kFirstBonus;
st->aim = 180;
st->smart = get_boolean_resource(st->dpy, "smart","Boolean");
st->bgrowth = get_integer_resource (st->dpy, "bgrowth", "Integer");
st->lrate = get_integer_resource (st->dpy, "lrate", "Integer");
if (st->bgrowth < 0) st->bgrowth = 2;
if (st->lrate < 0) st->lrate = 2;
st->startlrate = st->lrate;
if (!fontname || !*fontname)
fprintf (stderr, "%s: no font specified.\n", progname);
st->font = XLoadQueryFont(st->dpy, fontname);
if (!st->font)
fprintf (stderr, "%s: could not load font %s.\n", progname, fontname);
if (!(st->scoreFont = XLoadQueryFont(st->dpy, "-*-times-*-r-*-*-*-180-*-*-*-*-*-*")))
fprintf(stderr, "%s: Can't load Times font.", progname);
for (i = 0; i < kMaxMissiles; i++)
st->missile[i].alive = 0;
for (i = 0; i < kMaxLasers; i++)
st->laser[i].alive = 0;
for (i = 0; i < kMaxBooms; i++)
st->boom[i].alive = 0;
for (i = 0; i < kNumCities; i++) {
City *m = &st->city[i];
m->alive = 1;
m->color.red = m->color.green = m->color.blue = 0xFFFF;
m->color.blue = 0x1111; m->color.green = 0x8888;
m->color.flags = DoRed | DoGreen | DoBlue;
if (!XAllocColor (st->dpy, st->cmap, &m->color)) {
m->color.pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
m->color.red = m->color.green = m->color.blue = 0xFFFF;
}
}
gcv.foreground = st->default_fg_pixel =
get_pixel_resource(st->dpy, st->cmap, "foreground", "Foreground");
gcv.font = st->scoreFont->fid;
st->draw_gc = XCreateGC(st->dpy, st->window, GCForeground | GCFont, &gcv);
gcv.font = st->font->fid;
st->level_gc = XCreateGC(st->dpy, st->window, GCForeground | GCFont, &gcv);
XSetForeground (st->dpy, st->level_gc, st->city[0].color.pixel);
gcv.foreground = get_pixel_resource(st->dpy, st->cmap, "background", "Background");
st->erase_gc = XCreateGC(st->dpy, st->window, GCForeground, &gcv);
# ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (st->dpy, st->erase_gc, False);
jwxyz_XSetAntiAliasing (st->dpy, st->draw_gc, False);
# endif
/* make a gray color for score */
if (!mono_p) {
st->scoreColor.red = st->scoreColor.green = st->scoreColor.blue = 0xAAAA;
st->scoreColor.flags = DoRed | DoGreen | DoBlue;
if (!XAllocColor (st->dpy, st->cmap, &st->scoreColor)) {
st->scoreColor.pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
st->scoreColor.red = st->scoreColor.green = st->scoreColor.blue = 0xFFFF;
}
}
XClearWindow(st->dpy, st->window);
return st;
}
static int initGraphics(struct state *st)
{
XGCValues xgcv;
XWindowAttributes xgwa;
/* XSetWindowAttributes xswa;*/
Colormap cmap;
XColor color;
int n, i;
initCMap(st);
XGetWindowAttributes(st->dpy,st->win,&xgwa);
cmap=xgwa.colormap;
/* xswa.backing_store=Always;
XChangeWindowAttributes(st->dpy,st->win,CWBackingStore,&xswa);*/
xgcv.function=GXcopy;
st->delay = get_integer_resource(st->dpy, "delay","Integer");
xgcv.foreground=get_pixel_resource (st->dpy, cmap, "background", "Background");
st->fgc[0]=XCreateGC(st->dpy, st->win, GCForeground|GCFunction,&xgcv);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (st->dpy, st->fgc[0], False);
#endif
n=0;
if (mono_p) {
xgcv.foreground=get_pixel_resource (st->dpy, cmap, "foreground", "Foreground");
st->fgc[1]=XCreateGC(st->dpy,st->win,GCForeground|GCFunction,&xgcv);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (st->dpy, st->fgc[1], False);
#endif
for (i=0;i<st->numColors;i+=2) st->fgc[i]=st->fgc[0];
for (i=1;i<st->numColors;i+=2) st->fgc[i]=st->fgc[1];
} else {
for (i = 0; i < st->numColors; i++) {
color.red=st->colors[n++]<<8;
color.green=st->colors[n++]<<8;
color.blue=st->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, GCForeground | GCFunction,&xgcv);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (st->dpy, st->fgc[i], False);
#endif
}
}
st->cgc = XCreateGC(st->dpy,st->win,GCForeground|GCFunction,&xgcv);
XSetGraphicsExposures(st->dpy,st->cgc,False);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (st->dpy, st->cgc, False);
#endif
st->xsize = xgwa.width;
st->ysize = xgwa.height;
st->xc = st->xsize >> 1;
st->yc = st->ysize >> 1;
st->maxx = 1.0;
st->maxy = st->ysize/(float)st->xsize;
if (st->colorScheme < 0) st->colorScheme = random()%NUM_SCHEMES;
return True;
}
ENTRYPOINT void
init_laser(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
int i, c = 0;
lasersstruct *lp;
if (lasers == NULL) {
if ((lasers = (lasersstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (lasersstruct))) == NULL)
return;
}
lp = &lasers[MI_SCREEN(mi)];
lp->width = MI_WIDTH(mi);
lp->height = MI_HEIGHT(mi);
lp->time = 0;
lp->ln = MI_COUNT(mi);
if (lp->ln < -MINLASER) {
/* if lp->ln is random ... the size can change */
if (lp->laser != NULL) {
(void) free((void *) lp->laser);
lp->laser = (laserstruct *) NULL;
}
lp->ln = NRAND(-lp->ln - MINLASER + 1) + MINLASER;
} else if (lp->ln < MINLASER)
lp->ln = MINLASER;
if (lp->laser == NULL) {
if ((lp->laser = (laserstruct *) malloc(lp->ln *
sizeof (laserstruct))) == NULL) {
free_laser(display, lp);
return;
}
}
if (lp->stippledGC == None) {
XGCValues gcv;
gcv.foreground = MI_WHITE_PIXEL(mi);
gcv.background = MI_BLACK_PIXEL(mi);
lp->gcv_black.foreground = MI_BLACK_PIXEL(mi);
if ((lp->stippledGC = XCreateGC(display, MI_WINDOW(mi),
GCForeground | GCBackground, &gcv)) == None) {
free_laser(display, lp);
return;
}
# ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), lp->stippledGC, False);
# endif
}
MI_CLEARWINDOW(mi);
if (MINDIST < lp->width - MINDIST)
lp->cx = RANGE_RAND(MINDIST, lp->width - MINDIST);
else
lp->cx = RANGE_RAND(0, lp->width);
if (MINDIST < lp->height - MINDIST)
lp->cy = RANGE_RAND(MINDIST, lp->height - MINDIST);
else
lp->cy = RANGE_RAND(0, lp->height);
lp->lw = RANGE_RAND(MINWIDTH, MAXWIDTH);
lp->lr = RANGE_RAND(MINREDRAW, MAXREDRAW);
lp->sw = 0;
lp->so = 0;
if (MI_NPIXELS(mi) > 2)
c = NRAND(MI_NPIXELS(mi));
for (i = 0; i < lp->ln; i++) {
laserstruct *l = &lp->laser[i];
l->bn = (border) NRAND(4);
switch (l->bn) {
case TOP:
l->bx = NRAND(lp->width);
l->by = 0;
break;
case RIGHT:
l->bx = lp->width;
l->by = NRAND(lp->height);
break;
case BOTTOM:
l->bx = NRAND(lp->width);
l->by = lp->height;
break;
case LEFT:
l->bx = 0;
l->by = NRAND(lp->height);
}
l->dir = (int) (LRAND() & 1);
l->speed = ((RANGE_RAND(MINSPEED, MAXSPEED) * lp->width) / 1000) + 1;
if (MI_NPIXELS(mi) > 2) {
l->gcv.foreground = MI_PIXEL(mi, c);
c = (c + COLORSTEP) % MI_NPIXELS(mi);
} else
l->gcv.foreground = MI_WHITE_PIXEL(mi);
}
}
ENTRYPOINT void
init_rotor (ModeInfo * mi)
{
int x;
elem *pelem;
unsigned char wasiconified;
rotorstruct *rp;
if (rotors == NULL) {
if ((rotors = (rotorstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (rotorstruct))) == NULL)
return;
}
rp = &rotors[MI_SCREEN(mi)];
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
#endif
rp->prevcenterx = rp->centerx;
rp->prevcentery = rp->centery;
rp->centerx = MI_WIDTH(mi) / 2;
rp->centery = MI_HEIGHT(mi) / 2;
rp->redrawing = 0;
/*
* sometimes, you go into iconified view, only to see a really whizzy pattern
* that you would like to look more closely at. Normally, clicking in the
* icon reinitializes everything - but I don't, cuz I'm that kind of guy.
* HENCE, the wasiconified stuff you see here.
*/
wasiconified = rp->iconifiedscreen;
rp->iconifiedscreen = MI_IS_ICONIC(mi);
if (wasiconified && !rp->iconifiedscreen)
rp->firsttime = True;
else {
/* This is a fudge is needed since prevcenter may not be set when it comes
from the the random mode and return is pressed (and its not the first
mode that was running). This assumes that the size of the lock screen
window / size of the icon window = 12 */
if (!rp->prevcenterx)
rp->prevcenterx = rp->centerx * 12;
if (!rp->prevcentery)
rp->prevcentery = rp->centery * 12;
rp->num = MI_COUNT(mi);
if (rp->num < 0) {
rp->num = NRAND(-rp->num) + 1;
if (rp->elements != NULL) {
(void) free((void *) rp->elements);
rp->elements = (elem *) NULL;
}
}
if (rp->elements == NULL)
if ((rp->elements = (elem *) calloc(rp->num,
sizeof (elem))) == NULL) {
free_rotor(rp);
return;
}
rp->nsave = MI_CYCLES(mi);
if (rp->nsave <= 1)
rp->nsave = 2;
if (rp->save == NULL)
if ((rp->save = (XPoint *) malloc(rp->nsave *
sizeof (XPoint))) == NULL) {
free_rotor(rp);
return;
}
for (x = 0; x < rp->nsave; x++) {
rp->save[x].x = rp->centerx;
rp->save[x].y = rp->centery;
}
pelem = rp->elements;
for (x = rp->num; --x >= 0; pelem++) {
pelem->radius_drift_max = 1.0;
pelem->radius_drift_now = 1.0;
pelem->end_radius = 100.0;
pelem->ratio_drift_max = 1.0;
pelem->ratio_drift_now = 1.0;
pelem->end_ratio = 10.0;
}
if (MI_NPIXELS(mi) > 2)
rp->pix = NRAND(MI_NPIXELS(mi));
rp->rotor = 0;
rp->prev = 1;
rp->lastx = rp->centerx;
rp->lasty = rp->centery;
rp->angle = (float) NRAND((long) MAXANGLE) / 3.0;
rp->forward = rp->firsttime = True;
}
rp->linewidth = MI_SIZE(mi);
if (rp->linewidth == 0)
rp->linewidth = 1;
if (rp->linewidth < 0)
rp->linewidth = NRAND(-rp->linewidth) + 1;
MI_CLEARWINDOW(mi);
}
static void
capture_font_bits (p_state *state)
{
XFontStruct *font = state->font;
int safe_width, height;
unsigned char string[257];
int i;
Pixmap p;
# ifdef BUILTIN_FONT
Pixmap p2 = 0;
if (!font)
{
safe_width = state->char_width + 1;
height = state->char_height;
p2 = XCreatePixmapFromBitmapData (state->dpy, state->window,
(char *) font6x10_bits,
font6x10_width,
font6x10_height,
1, 0, 1);
}
else
# endif /* BUILTIN_FONT */
{
safe_width = font->max_bounds.rbearing - font->min_bounds.lbearing;
height = state->char_height;
}
p = XCreatePixmap (state->dpy, state->window,
(safe_width * 256), height, 1);
for (i = 0; i < 256; i++)
string[i] = (unsigned char) i;
string[256] = 0;
state->gcv.foreground = 0;
state->gcv.background = 0;
state->gc0 = XCreateGC (state->dpy, p,
(GCForeground | GCBackground),
&state->gcv);
state->gcv.foreground = 1;
state->gc1 = XCreateGC (state->dpy, p,
((font ? GCFont : 0) |
GCForeground | GCBackground |
GCCapStyle | GCLineWidth),
&state->gcv);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (state->dpy, state->gc0, False);
jwxyz_XSetAntiAliasing (state->dpy, state->gc1, False);
#endif
#ifdef FUZZY_BORDER
{
state->gcv.line_width = (int) (((long) state->scale) * 0.8);
if (state->gcv.line_width >= state->scale)
state->gcv.line_width = state->scale - 1;
if (state->gcv.line_width < 1)
state->gcv.line_width = 1;
state->gc2 = XCreateGC (state->dpy, p,
((font ? GCFont : 0) |
GCForeground | GCBackground |
GCCapStyle | GCLineWidth),
&state->gcv);
}
#endif /* FUZZY_BORDER */
XFillRectangle (state->dpy, p, state->gc0, 0, 0, (safe_width * 256), height);
# ifdef BUILTIN_FONT
if (p2)
{
XCopyPlane (state->dpy, p2, p, state->gc1,
0, 0, font6x10_width, font6x10_height,
0, 0, 1);
XFreePixmap (state->dpy, p2);
}
else
# endif /* BUILTIN_FONT */
{
for (i = 0; i < 256; i++)
{
if (string[i] < font->min_char_or_byte2 ||
string[i] > font->max_char_or_byte2)
continue;
XDrawString (state->dpy, p, state->gc1,
i * safe_width, font->ascent,
(char *) (string + i), 1);
}
}
/* Draw the cursor. */
XFillRectangle (state->dpy, p, state->gc1,
(CURSOR_INDEX * safe_width), 1,
(font
? (font->per_char
? font->per_char['n'-font->min_char_or_byte2].width
: font->max_bounds.width)
: state->char_width),
(font
? font->ascent - 1
: state->char_height));
state->font_bits = XGetImage (state->dpy, p, 0, 0,
(safe_width * 256), height, ~0L, XYPixmap);
XFreePixmap (state->dpy, p);
for (i = 0; i < 256; i++)
state->chars[i] = make_character (state, i);
state->chars[CURSOR_INDEX] = make_character (state, CURSOR_INDEX);
}
static struct starfish *
reset_starfish (struct state *st)
{
XGCValues gcv;
unsigned int flags = 0;
XWindowAttributes xgwa;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
st->cmap = xgwa.colormap;
if (st->done_once)
{
if (st->colors && st->ncolors)
free_colors (xgwa.screen, st->cmap, st->colors, st->ncolors);
if (st->colors)
free (st->colors);
st->colors = 0;
XFreeGC (st->dpy, st->gc);
st->gc = 0;
}
st->ncolors = get_integer_resource (st->dpy, "colors", "Colors");
if (st->ncolors < 2) st->ncolors = 2;
if (st->ncolors <= 2) mono_p = True;
if (mono_p)
st->colors = 0;
else
st->colors = (XColor *) malloc(sizeof(*st->colors) * (st->ncolors+1));
if (mono_p)
;
else if (random() % 3)
make_smooth_colormap (xgwa.screen, xgwa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
else
make_uniform_colormap (xgwa.screen, xgwa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
if (st->ncolors < 2) st->ncolors = 2;
if (st->ncolors <= 2) mono_p = True;
st->fg_index = 0;
if (!mono_p && !st->blob_p)
{
flags |= GCForeground;
gcv.foreground = st->colors[st->fg_index].pixel;
XSetWindowBackground (st->dpy, st->window, gcv.foreground);
}
if (!st->done_once)
{
XClearWindow (st->dpy, st->window);
st->done_once = 1;
}
flags |= GCFillRule;
gcv.fill_rule = EvenOddRule;
st->gc = XCreateGC (st->dpy, st->window, flags, &gcv);
#ifdef HAVE_JWXYZ
if (!st->blob_p)
jwxyz_XSetAntiAliasing (st->dpy, st->gc, False);
#endif
return make_window_starfish (st);
}
static void *
halo_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
XWindowAttributes xgwa;
char *mode_str = 0;
st->dpy = dpy;
st->window = window;
XGetWindowAttributes (st->dpy, st->window, &xgwa);
st->cmap = xgwa.colormap;
st->global_count = get_integer_resource (st->dpy, "count", "Integer");
if (st->global_count < 0) st->global_count = 0;
st->global_inc = get_integer_resource (st->dpy, "increment", "Integer");
if (st->global_inc < 0) st->global_inc = 0;
st->anim_p = get_boolean_resource (st->dpy, "animate", "Boolean");
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
st->delay2 = get_integer_resource (st->dpy, "delay2", "Integer") * 1000000;
mode_str = get_string_resource (st->dpy, "colorMode", "ColorMode");
if (! mode_str) cmode = random_mode;
else if (!strcmp (mode_str, "seuss")) cmode = seuss_mode;
else if (!strcmp (mode_str, "ramp")) cmode = ramp_mode;
else if (!strcmp (mode_str, "random")) cmode = random_mode;
else {
fprintf (stderr,
"%s: colorMode must be seuss, ramp, or random, not \"%s\"\n",
progname, mode_str);
exit (1);
}
if (mono_p) cmode = seuss_mode;
if (cmode == random_mode)
cmode = ((random()&3) == 1) ? ramp_mode : seuss_mode;
if (cmode == ramp_mode)
st->anim_p = False; /* This combo doesn't work right... */
st->ncolors = get_integer_resource (st->dpy, "colors", "Colors");
if (st->ncolors < 2) st->ncolors = 2;
if (st->ncolors <= 2) mono_p = True;
if (mono_p)
st->colors = 0;
else
st->colors = (XColor *) malloc(sizeof(*st->colors) * (st->ncolors+1));
if (mono_p)
;
else if (random() % (cmode == seuss_mode ? 2 : 10))
make_uniform_colormap (xgwa.screen, xgwa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
else
make_smooth_colormap (xgwa.screen, xgwa.visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
if (st->ncolors <= 2) mono_p = True;
if (mono_p) cmode = seuss_mode;
if (mono_p)
{
st->fg_pixel = get_pixel_resource (st->dpy, st->cmap, "foreground", "Foreground");
st->bg_pixel = get_pixel_resource (st->dpy, st->cmap, "background", "Background");
}
else
{
st->fg_index = 0;
st->bg_index = st->ncolors / 4;
if (st->fg_index == st->bg_index) st->bg_index++;
st->fg_pixel = st->colors[st->fg_index].pixel;
st->bg_pixel = st->colors[st->bg_index].pixel;
}
st->width = max (50, xgwa.width);
st->height = max (50, xgwa.height);
#ifdef DEBUG
st->width/=2; st->height/=2;
#endif
st->pixmap = XCreatePixmap (st->dpy, st->window, st->width, st->height, 1);
if (cmode == seuss_mode)
st->buffer = XCreatePixmap (st->dpy, st->window, st->width, st->height, 1);
else
st->buffer = 0;
gcv.foreground = 1;
gcv.background = 0;
st->draw_gc = XCreateGC (st->dpy, st->pixmap, GCForeground | GCBackground, &gcv);
gcv.foreground = 0;
st->erase_gc = XCreateGC (st->dpy, st->pixmap, GCForeground, &gcv);
gcv.foreground = st->fg_pixel;
gcv.background = st->bg_pixel;
st->copy_gc = XCreateGC (st->dpy, st->window, GCForeground | GCBackground, &gcv);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (dpy, st->draw_gc, False);
jwxyz_XSetAntiAliasing (dpy, st->erase_gc, False);
jwxyz_XSetAntiAliasing (dpy, st->copy_gc, False);
#endif
if (cmode == seuss_mode)
{
gcv.foreground = 1;
gcv.background = 0;
gcv.function = GXxor;
st->merge_gc = XCreateGC (st->dpy, st->pixmap,
GCForeground | GCBackground | GCFunction, &gcv);
}
else
{
gcv.foreground = st->fg_pixel;
gcv.background = st->bg_pixel;
gcv.function = GXcopy;
st->merge_gc = XCreateGC (st->dpy, st->window,
GCForeground | GCBackground | GCFunction, &gcv);
}
init_circles_1 (st);
XClearWindow (st->dpy, st->window);
if (st->buffer) XFillRectangle (st->dpy, st->buffer, st->erase_gc, 0, 0, st->width, st->height);
return st;
}
static unsigned long
fontglide_draw_metrics (state *s)
{
char txt[2];
char *fn = (s->font_override ? s->font_override : "fixed");
XFontStruct *font = XLoadQueryFont (s->dpy, fn);
XCharStruct c, overall;
int dir, ascent, descent;
int x, y;
GC gc;
unsigned long red = 0xFFFF0000; /* so shoot me */
unsigned long green = 0xFF00FF00;
unsigned long blue = 0xFF6666FF;
int i;
txt[0] = s->debug_metrics_p;
txt[1] = 0;
gc = XCreateGC (s->dpy, s->window, 0, 0);
XSetFont (s->dpy, gc, font->fid);
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (s->dpy, gc, False);
#endif
XTextExtents (font, txt, strlen(txt),
&dir, &ascent, &descent, &overall);
c = font->per_char[((unsigned char *) txt)[0] - font->min_char_or_byte2];
XClearWindow (s->dpy, s->window);
x = (s->xgwa.width - overall.width) / 2;
y = (s->xgwa.height - (2 * (ascent + descent))) / 2;
for (i = 0; i < 2; i++)
{
XCharStruct cc = (i == 0 ? c : overall);
int x1 = 20;
int x2 = s->xgwa.width - 40;
int x3 = s->xgwa.width;
XSetForeground (s->dpy, gc, red);
XDrawLine (s->dpy, s->window, gc, 0, y - ascent, x3, y - ascent);
XDrawLine (s->dpy, s->window, gc, 0, y + descent, x3, y + descent);
XSetForeground (s->dpy, gc, green);
/* ascent, baseline, descent */
XDrawLine (s->dpy, s->window, gc, x1, y - cc.ascent, x2, y - cc.ascent);
XDrawLine (s->dpy, s->window, gc, x1, y, x2, y);
XDrawLine (s->dpy, s->window, gc, x1, y + cc.descent, x2, y + cc.descent);
/* origin, width */
XSetForeground (s->dpy, gc, blue);
XDrawLine (s->dpy, s->window, gc,
x, y - ascent - 10,
x, y + descent + 10);
XDrawLine (s->dpy, s->window, gc,
x + cc.width, y - ascent - 10,
x + cc.width, y + descent + 10);
/* lbearing, rbearing */
XSetForeground (s->dpy, gc, green);
XDrawLine (s->dpy, s->window, gc,
x + cc.lbearing, y - ascent,
x + cc.lbearing, y + descent);
XDrawLine (s->dpy, s->window, gc,
x + cc.rbearing, y - ascent,
x + cc.rbearing, y + descent);
XSetForeground (s->dpy, gc, WhitePixelOfScreen (s->xgwa.screen));
XDrawString (s->dpy, s->window, gc, x, y, txt, strlen(txt));
y += (ascent + descent) * 2;
}
XFreeGC (s->dpy, gc);
XFreeFont (s->dpy, font);
return s->frame_delay;
}
static void *
critical_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
int model_w, model_h;
st->dpy = dpy;
st->window = window;
/* Find window attributes */
XGetWindowAttributes (st->dpy, st->window, &st->wattr);
st->batchcount = get_integer_resource (st->dpy, "batchcount", "Integer");
if (st->batchcount < 5)
st->batchcount = 5;
st->lines_per_color = 10;
/* For the moment the model size is just fixed -- making it vary
with the screen size just makes the hack boring on large
screens. */
model_w = 80;
st->settings.cell_size = st->wattr.width / model_w;
model_h = st->settings.cell_size ?
st->wattr.height / st->settings.cell_size : 1;
/* Construct the initial model state. */
st->settings.trail = clip(2, get_integer_resource (st->dpy, "trail", "Integer"), 1000);
st->history = calloc (st->settings.trail, sizeof (st->history[0]));
if (!st->history)
{
fprintf (stderr, "critical: "
"couldn't allocate trail history of %d cells\n",
st->settings.trail);
abort();
}
st->model = model_allocate (model_w, model_h);
if (!st->model)
{
fprintf (stderr, "critical: error preparing the model\n");
abort();
}
/* make a black gc for the background */
st->gcv.foreground = get_pixel_resource (st->dpy, st->wattr.colormap,
"background", "Background");
st->bgc = XCreateGC (st->dpy, st->window, GCForeground, &st->gcv);
st->fgc = XCreateGC (st->dpy, st->window, 0, &st->gcv);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (dpy, st->fgc, False);
jwxyz_XSetAntiAliasing (dpy, st->bgc, False);
#endif
st->delay_usecs = get_integer_resource (st->dpy, "delay", "Integer");
st->n_restart = get_integer_resource (st->dpy, "restart", "Integer");
setup_colormap (st, &st->d_colors, &st->d_n_colors);
model_initialize (st->model);
model_step (st->model, &st->history[0]);
st->d_pos = 1;
st->d_wrapped = 0;
st->i_restart = 0;
st->d_i_batch = st->batchcount;
return st;
}
ENTRYPOINT void
init_spiral(ModeInfo * mi)
{
spiralstruct *sp;
int i;
if (spirals == NULL) {
if ((spirals = (spiralstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (spiralstruct))) == NULL)
return;
}
sp = &spirals[MI_SCREEN(mi)];
#ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (MI_DISPLAY(mi), MI_GC(mi), False);
#endif
sp->width = MI_WIDTH(mi);
sp->height = MI_HEIGHT(mi);
MI_CLEARWINDOW(mi);
/* Init */
sp->nlength = MI_CYCLES(mi);
if (!sp->traildots)
if ((sp->traildots = (Traildots *) malloc(sp->nlength *
sizeof (Traildots))) == NULL) {
return;
}
/* initialize the allocated array */
for (i = 0; i < sp->nlength; i++) {
sp->traildots[i].hx = 0.0;
sp->traildots[i].hy = 0.0;
sp->traildots[i].ha = 0.0;
sp->traildots[i].hr = 0.0;
}
sp->redrawing = 0;
/* keep the window parameters proportional */
sp->top = 10000.0;
sp->bottom = 0;
sp->right = (float) (sp->width) / (float) (sp->height) * (10000.0);
sp->left = 0;
/* assign the initial values */
sp->cx = (float) (5000.0 - NRAND(2000)) / 10000.0 * sp->right;
sp->cy = (float) (5000.0 - NRAND(2000));
sp->radius = (float) (NRAND(200) + 200);
sp->angle = 0.0;
sp->dx = (float) (10 - NRAND(20)) * SPEED;
sp->dy = (float) (10 - NRAND(20)) * SPEED;
sp->dr = (float) ((NRAND(10) + 4) * (1 - (LRAND() & 1) * 2));
sp->da = (float) NRAND(360) / 7200.0 + 0.01;
if (MI_NPIXELS(mi) > 2)
sp->colors = (float) NRAND(MI_NPIXELS(mi));
sp->erase = 0;
sp->inc = 0;
sp->traildots[sp->inc].hx = sp->cx;
sp->traildots[sp->inc].hy = sp->cy;
sp->traildots[sp->inc].ha = sp->angle;
sp->traildots[sp->inc].hr = sp->radius;
sp->inc++;
sp->dots = MI_COUNT(mi);
if (sp->dots < -MINDOTS)
sp->dots = NRAND(sp->dots - MINDOTS + 1) + MINDOTS;
/* Absolute minimum */
if (sp->dots < MINDOTS)
sp->dots = MINDOTS;
}
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
init_g (GLOBAL *g)
{
XWindowAttributes xgwa;
XGCValues gcv;
char *color_mode_str;
g->symmetry = get_integer_resource(g->dpy, "symmetry", "Integer");
g->ntrails = get_integer_resource(g->dpy, "ntrails" , "Integer");
g->nsegments = get_integer_resource(g->dpy, "nsegments", "Integer");
g->narcs = get_integer_resource(g->dpy, "narcs", "Integer");
g->local_rotation = get_integer_resource(g->dpy, "local_rotation", "Integer");
g->global_rotation = get_integer_resource(g->dpy, "global_rotation", "Integer");
g->spring_constant = get_integer_resource(g->dpy, "spring_constant", "Integer");
g->delay = get_integer_resource(g->dpy, "delay", "Integer");
g->nobjects = g->nsegments + g->narcs;
color_mode_str = get_string_resource(g->dpy, "color_mode", "color_mode");
/* make into an enum... */
if(!color_mode_str) {
g->color_mode = 0;
} else if (!strcmp(color_mode_str, "greedy")) {
g->color_mode = 0;
} else if (!strcmp(color_mode_str, "nice")) {
g->color_mode = 1;
} else {
g->color_mode = 2;
}
XGetWindowAttributes (g->dpy, g->window, &xgwa);
g->xmax = xgwa.width;
g->ymax = xgwa.height;
g->xoff = g->xmax/2;
g->yoff = g->ymax/2;
g->costheta = cos(2*M_PI/g->symmetry);
g->sintheta = sin(2*M_PI/g->symmetry);
g->cmap = xgwa.colormap;
g->redmin = get_integer_resource(g->dpy, "redmin", "Integer");
g->redrange = get_integer_resource(g->dpy, "redrange", "Integer");
g->greenmin = get_integer_resource(g->dpy, "greenmin", "Integer");
g->greenrange = get_integer_resource(g->dpy, "greenrange", "Integer");
g->bluemin = get_integer_resource(g->dpy, "bluemin", "Integer");
g->bluerange = get_integer_resource(g->dpy, "bluerange", "Integer");
gcv.line_width = 1;
gcv.cap_style = CapRound;
gcv.foreground = g->default_fg_pixel = get_pixel_resource (g->dpy, g->cmap, "foreground", "Foreground");
g->draw_gc = XCreateGC (g->dpy, g->window, GCForeground|GCLineWidth|GCCapStyle, &gcv);
gcv.foreground = get_pixel_resource (g->dpy, g->cmap, "background", "Background");
g->erase_gc = XCreateGC (g->dpy, g->window, GCForeground|GCLineWidth|GCCapStyle,&gcv);
# ifdef HAVE_COCOA
jwxyz_XSetAntiAliasing (g->dpy, g->draw_gc, False);
jwxyz_XSetAntiAliasing (g->dpy, g->erase_gc, False);
# endif
}
