+++ /dev/null
-
-/*
-
- * Original Author Unknow.
-
- * 8/10/88 - Ported from X10 to X11R3 by:
-
- Jonathan Greenblatt (jonnyg@rover.umd.edu)
-
- * Cleaned up by Dave Lemke (lemke@sun.com)
-
- * Ported to monocrome by Jonathan Greenblatt (jonnyg@rover.umd.edu)
-
- * 05/02/1996 Added TrueColor support by TJ Phan (phan@aur.alcatel.com)
-
- TODO:
-
- Parameter parsing needs to be redone.
-
- * Throughout 1991 improved for animation and color and multiple
- fish types. Broke monocrome in the process.
- Eric Bina (ebina@ncsa.uiuc.edu)
-
- * 1992 added extra color remapping control options, as well as ways
- to let the fish swim on the root window, or an image of the users
- choice. Eric Bina (ebina@ncsa.uiuc.edu)
-
-*/
-
-#include <sys/types.h>
-#ifndef hpux
-#include <sys/time.h>
-#else
-#include <time.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#ifdef sgi
-#define _BSD_SIGNALS
-#endif
-#include <signal.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <Imlib2.h>
-
-#include "vroot.h"
-#include "xfishy.h"
-#include "bubbles.h"
-#include "medcut.h"
-
-/* constants are based on rand(3C) returning an integer between 0 and 32767 */
-
-#if defined(ultrix) || defined(sun) || defined(linux)
-#define RAND_I_1_16 134217728
-#define RAND_F_1_8 268435455.875
-#define RAND_I_1_4 536870911
-#define RAND_I_1_2 1073741823
-#define RAND_I_3_4 1610612735
-#define RAND_F_MAX 2147483647.0
-#elif defined(__FreeBSD__) || defined(__OpenBSD__)
-#define RAND_I_1_16 (RAND_MAX>>4)
-#define RAND_F_1_8 ((float)(RAND_MAX>>3))
-#define RAND_I_1_4 (RAND_MAX>>2)
-#define RAND_I_1_2 (RAND_MAX>>1)
-#define RAND_I_3_4 ((RAND_MAX>>2)*3)
-#define RAND_F_MAX ((float)RAND_MAX)
-#else
-#define RAND_I_1_16 2048
-#define RAND_F_1_8 4096.0
-#define RAND_I_1_4 8096
-#define RAND_I_1_2 16384
-#define RAND_I_3_4 24575
-#define RAND_F_MAX 32767.0
-#endif
-
-
-extern unsigned char *ReadBitmap();
-
-
-/* externals for pixmap and bimaps from xfishy.h */
-
-
-/* typedefs for bubble and fish structures, also caddr_t (not used in X.h) */
-typedef struct {
- int x, y, s, erased, i;
-} bubble;
-typedef struct {
- int x, y, d, frame, type, i;
-} fish;
-typedef unsigned char *caddrt;
-
-
-/* bubble increment and yes check tables */
-int binc[] = { 0, 64, 56, 48, 40, 32, 24, 16, 8 };
-char *yess[] = { "yes", "Yes", "YES", "on", "On", "ON" };
-
-
-char *pname, /* program name from argv[0] */
- sname[64], /* host:display specification */
- cname[64]; /* colorname specification */
-char picname[256]; /* name of the background picture file */
-int *Allocated; /* mark the used colors */
-int AllocCnt; /* count number of colors used */
-int mlimit = 0; /* num colors to median cut to. 0 = no limit */
-int climit = 0; /* limit on color use. 0 = no limit */
-int DoubleBuf = 0; /* Should we use double buffering */
-int Overlap = 0; /* Should fish swim over each other */
-int DoClipping = 0; /* Should clip masks be used. */
-int blimit = 32, /* bubble limit */
- flimit = 10, /* fish limit */
- pmode = 1, /* pop mode, (1 for lower, 0 for raise) */
- width, /* width of initial window in pixels */
- height, /* height of initial window in pixels */
- screen, /* Default screen of this display */
- Init_B, *cmap; /* Initialize bubbles with random y value */
-int Pwidth; /* width of background picture */
-int Pheight; /* height of background picture */
-int Pcnt; /* number of colors in background picture */
-unsigned char *Pdata; /* data from background picture */
-double rate = 0.2, /* update interval in seconds */
- smooth = 0.2; /* smoothness increment multiplier */
-bubble *binfo; /* bubble info structures, allocated
- * dynamically */
-fish *finfo; /* fish info structures, allocated dynamically */
-Display *Dpy;
-Window root_window;
-XImage *xfishA[NUM_FISH][3]; /* fish pixmaps (1 is left-fish, 2 is
- * right-fish) */
-XImage *xfishB[NUM_FISH][3]; /* fish pixmaps (1 is left-fish, 2 is
- * right-fish) */
-Pixmap pfishA[NUM_FISH][3];
-Pixmap pfishB[NUM_FISH][3];
-
-Pixmap mfishA[NUM_FISH][3]; /* masking pixmaps for fish to use as */
-Pixmap mfishB[NUM_FISH][3]; /* clipmasks */
-
-Pixmap PicMap; /* pixmap for background picture */
-
-Pixmap PixBuf; /* Pixmap buffer for double buffering */
-Pixmap ClipBuf; /* Clipmask buffer for double buffering */
-
-Pixmap xbubbles[9]; /* bubbles bitmaps (1 to 8, by size in pixels) */
-Window wid; /* aqaurium window */
-unsigned long white, black, bcolor;
-Colormap colormap;
-GC c0gc, cpgc; /* GCs to operateon the Clipmask buffer */
-GC pgc;
-GC gc, bgc;
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Output desired error message and exit.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-msgdie(message)
-char *message;
-{
- fprintf(stderr, "%s: %s\n", pname, message);
- exit(1);
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Set up program defaults, get X defaults, parse command line using getopts.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-parse(argc, argv)
-int argc;
-char **argv;
-{
- int c;
- const char *display = getenv("DISPLAY");
- extern int optind;
- extern char *optarg;
- extern double atof();
-
- pname = argv[0];
- if (display != NULL)
- strncpy(sname, display, sizeof(sname) - 1);
- strcpy(cname, "MediumAquamarine");
-
- while ((c = getopt(argc, argv, "dDob:C:c:p:m:f:i:r:s")) != EOF) {
- switch (c) {
- case 'd':
- DoClipping = 1;
- break;
- case 'D':
- DoubleBuf = 1;
- break;
- case 'o':
- Overlap = 1;
- break;
- case 'b':
- blimit = atoi(optarg);
- break;
- case 'C':
- climit = atoi(optarg);
- break;
- case 'm':
- mlimit = atoi(optarg);
- break;
- case 'c':
- strncpy(cname, optarg, sizeof(cname) - 1);
- break;
- case 'p':
- strncpy(picname, optarg, sizeof(picname) - 1);
- break;
- case 'f':
- flimit = atoi(optarg);
- break;
- case 'i':
- smooth = atof(optarg);
- break;
- case 'r':
- rate = atof(optarg);
- break;
- case 's':
- pmode = 0;
- break;
- case '?':
- fprintf(stderr, "usage: %s\n", pname);
- fprintf(stderr, "\t\t[-c color] background color\n");
- fprintf(stderr, "\t\t[-b limit] number of bubbles (default 32)\n");
- fprintf(stderr, "\t\t[-f limit] number of fish (default 10)\n");
- fprintf(stderr, "\t\t[-i mult] move interval (default 0.2)\n");
- fprintf(stderr, "\t\t[-r rate] move frequency (default 0.2)\n");
- fprintf(stderr, "\t\t[-m num] median cut to this many colors\n");
- fprintf(stderr, "\t\t[-C num] use only this many color cells\n");
- fprintf(stderr, "\t\t[-d] clip fish, swim on root window\n");
- fprintf(stderr, "\t\t[-p file] fish swim on picture in file\n");
- fprintf(stderr, "\t\t[host:display]\n");
- exit(1);
- }
- }
-
- if (optind < argc) {
- char *display;
-
- strncpy(sname, argv[optind], sizeof(sname) - 1);
- display = (char *) malloc(strlen(sname) + 9);
- snprintf(display, sizeof(display) - 1, "DISPLAY=%s", sname);
- putenv(display);
- }
-}
-
-
-void
-erasefish(f, x, y, d)
-fish *f;
-int x, y, d;
-{
- /*
- * for something as small as a bubble, it was never worth the
- * effort of using clipmasks to only turn of the bubble itself, so
- * we just clear the whole rectangle.
- */
- XClearArea(Dpy, wid, x, y, rwidth[f->type], rheight[f->type], False);
-#if 0
- XGCValues gcv;
-
- if (f->frame) {
- gcv.foreground = cmap[0];
- gcv.fill_style = FillTiled;
- gcv.fill_style = FillSolid;
- gcv.tile = pfishB[f->type][d];
- gcv.ts_x_origin = f->x;
- gcv.ts_y_origin = f->y;
- gcv.clip_mask = mfishB[f->type][d];
- gcv.clip_x_origin = x;
- gcv.clip_y_origin = y;
- XChangeGC(Dpy, gc, GCForeground | GCClipMask |
- GCTile | GCTileStipXOrigin | GCTileStipYOrigin |
- GCFillStyle | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyPlane(Dpy, mfishB[f->type][d], wid, gc, 0, 0,
- rwidth[f->type], rheight[f->type], x, y, (unsigned long) 1);
- } else {
- gcv.foreground = cmap[0];
- gcv.fill_style = FillTiled;
- gcv.fill_style = FillSolid;
- gcv.tile = pfishA[f->type][d];
- gcv.ts_x_origin = f->x;
- gcv.ts_y_origin = f->y;
- gcv.clip_mask = mfishA[f->type][d];
- gcv.clip_x_origin = x;
- gcv.clip_y_origin = y;
- XChangeGC(Dpy, gc, GCForeground | GCClipMask |
- GCTile | GCTileStipXOrigin | GCTileStipYOrigin |
- GCFillStyle | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyPlane(Dpy, mfishA[f->type][d], wid, gc, 0, 0,
- rwidth[f->type], rheight[f->type], x, y, (unsigned long) 1);
- }
-#endif
-}
-
-
-/*
- * Just places a fish. Normally this is all you need for animation, since
- * placeing the fish places an entire rectangle which erases most of the old
- * fish (the rest being cleaned up by the function that called putfish.
- * If DoClipping is set, this function is only called when placing a new
- * fish, otherwise newfish is called.
- */
-void
-putfish(f)
-fish *f;
-{
- XGCValues gcv;
-
- if (f->frame) {
- /*
- * If we have a pixmap of the fish use it, otherwise use
- * the XImage of the fish. In reality we will never use
- * the XImage since X dies if the pixmap create failed
- */
- if (pfishA[f->type][f->d]) {
- /*
- * Clipping overrides background picture because
- * the clipping prevents the drawing of any background
- * anyway.
- * DoClipping says just print a fish leaving the
- * background unchanged.
- * If there is a background picture, we use a buffer
- * to prevent flashing, we combine the background
- * picture and the fish, and then copy the
- * whole rectangle in.
- * Default is just copy in fish in with a background
- * color.
- */
- if (DoClipping) {
- gcv.clip_mask = mfishA[f->type][f->d];
- gcv.clip_x_origin = f->x;
- gcv.clip_y_origin = f->y;
- XChangeGC(Dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyArea(Dpy, pfishA[f->type][f->d], wid, gc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x, f->y);
- } else if (picname[0] != '\0') {
- gcv.fill_style = FillTiled;
- gcv.tile = PicMap;
- gcv.ts_x_origin = -(f->x);
- gcv.ts_y_origin = -(f->y);
- gcv.clip_mask = None;
- XChangeGC(Dpy, pgc, (GCFillStyle |
- GCTile | GCTileStipXOrigin |
- GCTileStipYOrigin | GCClipMask), &gcv);
- XFillRectangle(Dpy, PixBuf, pgc, 0, 0, rwidth[f->type], rheight[f->type]);
-
- gcv.clip_mask = mfishA[f->type][f->d];
- gcv.clip_x_origin = 0;
- gcv.clip_y_origin = 0;
- XChangeGC(Dpy, pgc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyArea(Dpy, pfishA[f->type][f->d], PixBuf, pgc,
- 0, 0, rwidth[f->type], rheight[f->type], 0, 0);
-
- XCopyArea(Dpy, PixBuf, wid, gc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x, f->y);
- } else {
- XCopyArea(Dpy, pfishA[f->type][f->d], wid, gc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x, f->y);
- }
- } else {
- XPutImage(Dpy, wid, gc, xfishA[f->type][f->d], 0, 0,
- f->x, f->y, rwidth[f->type], rheight[f->type]);
- }
- f->frame = 0;
- } else {
- /*
- * same as the above, only for the second frame of animation
- */
- if (pfishB[f->type][f->d]) {
- if (DoClipping) {
- gcv.clip_mask = mfishB[f->type][f->d];
- gcv.clip_x_origin = f->x;
- gcv.clip_y_origin = f->y;
- XChangeGC(Dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyArea(Dpy, pfishB[f->type][f->d], wid, gc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x, f->y);
- } else if (picname[0] != '\0') {
- gcv.fill_style = FillTiled;
- gcv.tile = PicMap;
- gcv.ts_x_origin = -(f->x);
- gcv.ts_y_origin = -(f->y);
- gcv.clip_mask = None;
- XChangeGC(Dpy, pgc, (GCFillStyle |
- GCTile | GCTileStipXOrigin |
- GCTileStipYOrigin | GCClipMask), &gcv);
- XFillRectangle(Dpy, PixBuf, pgc, 0, 0, rwidth[f->type], rheight[f->type]);
-
- gcv.clip_mask = mfishB[f->type][f->d];
- gcv.clip_x_origin = 0;
- gcv.clip_y_origin = 0;
- XChangeGC(Dpy, pgc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyArea(Dpy, pfishB[f->type][f->d], PixBuf, pgc,
- 0, 0, rwidth[f->type], rheight[f->type], 0, 0);
-
- XCopyArea(Dpy, PixBuf, wid, gc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x, f->y);
- } else {
- XCopyArea(Dpy, pfishB[f->type][f->d], wid, gc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x, f->y);
- }
- } else {
- XPutImage(Dpy, wid, gc, xfishB[f->type][f->d], 0, 0,
- f->x, f->y, rwidth[f->type], rheight[f->type]);
- }
- f->frame = 1;
- }
-}
-
-
-/*
- * This function can only be called if DoClipping is True. It is used to
- * move a clipmasked fish. First the area under the fish is cleared,
- * and then the new fish is masked in.
- * The parameters x, y, amd d are from the old fish that is being
- * erased before the new fish is drawn.
- */
-void
-movefish(f, x, y, d)
-fish *f;
-int x, y, d;
-{
- XGCValues gcv;
- int bx, by, bw, bh;
-
- /*
- * If we are going to double buffer, we need to find the bounding
- * rectangle of the overlap of the bounding rectangles of the old
- * and the new fish.
- */
- if (DoubleBuf) {
- if (x < f->x) {
- bx = x;
- bw = f->x - x + rwidth[f->type];
- } else {
- bx = f->x;
- bw = x - f->x + rwidth[f->type];
- }
- if (y < f->y) {
- by = y;
- bh = f->y - y + rheight[f->type];
- } else {
- by = f->y;
- bh = y - f->y + rheight[f->type];
- }
- }
-
- if (f->frame) {
- /*
- * If there is a pixmap use it.
- * This branchis always taken since right now, if the pixmap
- * allocation failed, the program dies.
- */
- if (pfishA[f->type][f->d]) {
- /*
- * A pointless if, you now only come here if
- * DoClipping is set, I've just been too lazy to
- * clean up my code.
- */
- if (DoClipping) {
- /*
- * Set up the masked gc for when we eventually
- * draw the fish. Origin is different for
- * whether we are drawing into the buffer
- * or into the window
- */
- gcv.clip_mask = mfishA[f->type][f->d];
- if (DoubleBuf) {
- gcv.clip_x_origin = f->x - bx;
- gcv.clip_y_origin = f->y - by;
- } else {
- gcv.clip_x_origin = f->x;
- gcv.clip_y_origin = f->y;
- }
- XChangeGC(Dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
-
- /*
- * If we have a background picture we want to
- * clear to that background, otherwise we just
- * do an XCleararea, and let the root restore
- * the background.
- */
- if (picname[0] != '\0') {
- gcv.fill_style = FillTiled;
- gcv.tile = PicMap;
- gcv.clip_mask = mfishB[f->type][d];
- if (DoubleBuf) {
- gcv.ts_x_origin = 0 - bx;
- gcv.ts_y_origin = 0 - by;
- gcv.clip_x_origin = x - bx;
- gcv.clip_y_origin = y - by;
- } else {
- gcv.ts_x_origin = 0;
- gcv.ts_y_origin = 0;
- gcv.clip_x_origin = x;
- gcv.clip_y_origin = y;
- }
- XChangeGC(Dpy, pgc, (GCFillStyle |
- GCTile | GCTileStipXOrigin |
- GCTileStipYOrigin | GCClipMask |
- GCClipXOrigin | GCClipYOrigin), &gcv);
-
- /*
- * if bouble buffering we clear the buffer
- * to the backgound picture, and then
- * shape the clip buffer to the shape of
- * the fish being erased.
- */
- if (DoubleBuf) {
- XFillRectangle(Dpy, PixBuf, pgc,
- x - bx, y - by, rwidth[f->type], rheight[f->type]);
- XFillRectangle(Dpy, ClipBuf, c0gc, 0, 0, 500, 500);
- XCopyArea(Dpy, mfishB[f->type][d],
- ClipBuf, cpgc, 0, 0,
- rwidth[f->type], rheight[f->type], x - bx, y - by);
- } else {
- XFillRectangle(Dpy, wid, pgc, x, y, rwidth[f->type], rheight[f->type]);
- }
- } else {
- XClearArea(Dpy, wid, x, y, rwidth[f->type], rheight[f->type], 0);
- }
- }
- /*
- * Now we just copy in the new fish with a clipmasked gc.
- * But if we doublebuffered, we copy the new fish into
- * the buffer, combine the new fishes clipmask in, and
- * then mask the whole lot from the buffer to the window.
- */
- if (DoubleBuf) {
- XCopyArea(Dpy, pfishA[f->type][f->d], PixBuf, gc, 0, 0,
- rwidth[f->type], rheight[f->type], f->x - bx, f->y - by);
- XCopyArea(Dpy, mfishA[f->type][f->d], ClipBuf, cpgc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x - bx, f->y - by);
- gcv.clip_mask = ClipBuf;
- gcv.clip_x_origin = bx;
- gcv.clip_y_origin = by;
- XChangeGC(Dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyArea(Dpy, PixBuf, wid, gc, 0, 0, bw, bh, bx, by);
- } else {
- XCopyArea(Dpy, pfishA[f->type][f->d], wid, gc, 0, 0,
- rwidth[f->type], rheight[f->type], f->x, f->y);
- }
- } else {
- if (DoClipping) {
- if (picname[0] != '\0') {
- gcv.fill_style = FillTiled;
- gcv.tile = PicMap;
- gcv.ts_x_origin = 0;
- gcv.ts_y_origin = 0;
- gcv.clip_mask = mfishB[f->type][d];
- gcv.clip_x_origin = x;
- gcv.clip_y_origin = y;
- XChangeGC(Dpy, pgc, (GCFillStyle |
- GCTile | GCTileStipXOrigin |
- GCTileStipYOrigin | GCClipMask |
- GCClipXOrigin | GCClipYOrigin), &gcv);
- XFillRectangle(Dpy, wid, pgc, x, y, rwidth[f->type], rheight[f->type]);
- } else {
- XClearArea(Dpy, wid, x, y, rwidth[f->type], rheight[f->type], 0);
- }
- }
- XPutImage(Dpy, wid, gc, xfishA[f->type][f->d], 0, 0,
- f->x, f->y, rwidth[f->type], rheight[f->type]);
- }
- f->frame = 0;
- } else {
- /*
- * Same as above, only for the second frame of animation.
- */
- if (pfishB[f->type][f->d]) {
- if (DoClipping) {
- gcv.clip_mask = mfishB[f->type][f->d];
- if (DoubleBuf) {
- gcv.clip_x_origin = f->x - bx;
- gcv.clip_y_origin = f->y - by;
- } else {
- gcv.clip_x_origin = f->x;
- gcv.clip_y_origin = f->y;
- }
- XChangeGC(Dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- if (picname[0] != '\0') {
- gcv.fill_style = FillTiled;
- gcv.tile = PicMap;
- gcv.clip_mask = mfishA[f->type][d];
- if (DoubleBuf) {
- gcv.ts_x_origin = 0 - bx;
- gcv.ts_y_origin = 0 - by;
- gcv.clip_x_origin = x - bx;
- gcv.clip_y_origin = y - by;
- } else {
- gcv.ts_x_origin = 0;
- gcv.ts_y_origin = 0;
- gcv.clip_x_origin = x;
- gcv.clip_y_origin = y;
- }
- XChangeGC(Dpy, pgc, (GCFillStyle |
- GCTile | GCTileStipXOrigin |
- GCTileStipYOrigin | GCClipMask |
- GCClipXOrigin | GCClipYOrigin), &gcv);
- if (DoubleBuf) {
- XFillRectangle(Dpy, PixBuf, pgc,
- x - bx, y - by, rwidth[f->type], rheight[f->type]);
- XFillRectangle(Dpy, ClipBuf, c0gc, 0, 0, 500, 500);
- XCopyArea(Dpy, mfishA[f->type][d],
- ClipBuf, cpgc, 0, 0,
- rwidth[f->type], rheight[f->type], x - bx, y - by);
- } else {
- XFillRectangle(Dpy, wid, pgc, x, y, rwidth[f->type], rheight[f->type]);
- }
- } else {
- XClearArea(Dpy, wid, x, y, rwidth[f->type], rheight[f->type], 0);
- }
- }
- if (DoubleBuf) {
- XCopyArea(Dpy, pfishB[f->type][f->d], PixBuf, gc, 0, 0,
- rwidth[f->type], rheight[f->type], f->x - bx, f->y - by);
- XCopyArea(Dpy, mfishB[f->type][f->d], ClipBuf, cpgc,
- 0, 0, rwidth[f->type], rheight[f->type], f->x - bx, f->y - by);
- gcv.clip_mask = ClipBuf;
- gcv.clip_x_origin = bx;
- gcv.clip_y_origin = by;
- XChangeGC(Dpy, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XCopyArea(Dpy, PixBuf, wid, gc, 0, 0, bw, bh, bx, by);
- } else {
- XCopyArea(Dpy, pfishB[f->type][f->d], wid, gc, 0, 0,
- rwidth[f->type], rheight[f->type], f->x, f->y);
- }
- } else {
- if (DoClipping) {
- if (picname[0] != '\0') {
- gcv.fill_style = FillTiled;
- gcv.tile = PicMap;
- gcv.ts_x_origin = 0;
- gcv.ts_y_origin = 0;
- gcv.clip_mask = mfishA[f->type][d];
- gcv.clip_x_origin = x;
- gcv.clip_y_origin = y;
- XChangeGC(Dpy, pgc, (GCFillStyle |
- GCTile | GCTileStipXOrigin |
- GCTileStipYOrigin | GCClipMask |
- GCClipXOrigin | GCClipYOrigin), &gcv);
- XFillRectangle(Dpy, wid, pgc, x, y, rwidth[f->type], rheight[f->type]);
- } else {
- XClearArea(Dpy, wid, x, y, rwidth[f->type], rheight[f->type], 0);
- }
- }
- XPutImage(Dpy, wid, gc, xfishB[f->type][f->d], 0, 0,
- f->x, f->y, rwidth[f->type], rheight[f->type]);
- }
- f->frame = 1;
- }
-}
-
-
-void
-erasebubble(b, s)
-bubble *b;
-int s;
-{
- XClearArea(Dpy, wid, b->x, b->y, s, s, 0);
-}
-
-
-void
-putbubble(b, s, c)
-bubble *b;
-int s;
-unsigned long c;
-{
- XGCValues gcv;
-
- gcv.foreground = c;
- gcv.clip_mask = xbubbles[s];
- gcv.clip_x_origin = b->x;
- gcv.clip_y_origin = b->y;
- XChangeGC(Dpy, bgc, GCForeground | GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
- XFillRectangle(Dpy, wid, bgc, b->x, b->y, s, s);
-}
-
-
-/*
- * Find the closest color by allocating it, or picking an already allocated
- * color
- */
-Visual(*visual_info) = NULL;
-int r_mask, g_mask, b_mask;
-int r_shift = 0, g_shift = 0, b_shift = 0;
-int r_bits = 0, g_bits = 0, b_bits = 0;
-void
-FindColor(Dpy, colormap, colr)
-Display *Dpy;
-Colormap colormap;
-XColor *colr;
-{
- int i, match;
- double rd, gd, bd, dist, mindist;
- int cindx;
- XColor def_colrs[256];
- int NumCells;
-
- if (visual_info == NULL && DefaultDepth(Dpy, DefaultScreen(Dpy)) > 8) {
- visual_info = DefaultVisual(Dpy, DefaultScreen(Dpy));
- r_mask = visual_info->red_mask;
- while (!(r_mask & 1)) {
- r_mask >>= 1;
- r_shift++;
- }
- while (r_mask & 1) {
- r_mask >>= 1;
- r_bits++;
- }
-
- g_mask = visual_info->green_mask;
- while (!(g_mask & 1)) {
- g_mask >>= 1;
- g_shift++;
- }
- while (g_mask & 1) {
- g_mask >>= 1;
- g_bits++;
- }
-
- b_mask = visual_info->blue_mask;
- while (!(b_mask & 1)) {
- b_mask >>= 1;
- b_shift++;
- }
- while (b_mask & 1) {
- b_mask >>= 1;
- b_bits++;
- }
- }
-
- if (DefaultDepth(Dpy, DefaultScreen(Dpy)) > 8) {
- colr->red >>= 16 - r_bits;
- colr->green >>= 16 - g_bits;
- colr->blue >>= 16 - b_bits;
-
- colr->pixel = ((colr->red << r_shift) & visual_info->red_mask) |
- ((colr->green << g_shift) & visual_info->green_mask) |
- ((colr->blue << b_shift) & visual_info->blue_mask);
- return;
- }
-
- if (AllocCnt < climit) {
- match = XAllocColor(Dpy, colormap, colr);
- } else {
- match = 0;
- }
- if (match == 0) {
- NumCells = DisplayCells(Dpy, DefaultScreen(Dpy));
- for (i = 0; i < NumCells; i++) {
- def_colrs[i].pixel = i;
- }
- XQueryColors(Dpy, colormap, def_colrs, NumCells);
- mindist = 65536.0 * 65536.0;
- cindx = colr->pixel;
- for (i = 0; i < NumCells; i++) {
- rd = (def_colrs[i].red - colr->red) / 256.0;
- gd = (def_colrs[i].green - colr->green) / 256.0;
- bd = (def_colrs[i].blue - colr->blue) / 256.0;
- dist = (rd * rd * rd * rd) + (gd * gd * gd * gd) + (bd * bd * bd * bd);
- if (dist < mindist) {
- mindist = dist;
- cindx = def_colrs[i].pixel;
- }
- }
- colr->pixel = cindx;
- colr->red = def_colrs[cindx].red;
- colr->green = def_colrs[cindx].green;
- colr->blue = def_colrs[cindx].blue;
- } else {
- if (Allocated[colr->pixel] == 0) {
- Allocated[colr->pixel] = 1;
- AllocCnt++;
- }
- }
-}
-
-
-int
-ColorUsage(data, width, height, colrs)
-unsigned char *data;
-int width, height;
-struct colr_data *colrs;
-{
- int mapping[256];
- int i, size;
- int cnt, indx;
- unsigned char *ptr;
- struct colr_data newcol[256];
-
- for (i = 0; i < 256; i++) {
- mapping[i] = -1;
- }
-
- size = width * height;
- cnt = 0;
- ptr = data;
- for (i = 0; i < size; i++) {
- indx = (int) *ptr;
- if (mapping[indx] == -1) {
- mapping[indx] = cnt;
- newcol[cnt].red = colrs[indx].red;
- newcol[cnt].green = colrs[indx].green;
- newcol[cnt].blue = colrs[indx].blue;
- cnt++;
- }
- ptr++;
- }
-
- ptr = data;
- for (i = 0; i < size; i++) {
- indx = (int) *ptr;
- *ptr = (unsigned char) mapping[indx];
- ptr++;
- }
-
- for (i = 0; i < cnt; i++) {
- colrs[i].red = newcol[i].red;
- colrs[i].green = newcol[i].green;
- colrs[i].blue = newcol[i].blue;
- }
- for (i = cnt; i < 256; i++) {
- colrs[i].red = 0;
- colrs[i].green = 0;
- colrs[i].blue = 0;
- }
-
- return (cnt);
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Initialize colormap for background color and required fish colors.
-The fish colors are coded in xfishy.h as a trio of tables.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-init_colormap()
-{
- int i, j, cnt;
- int NumCells;
- XColor hdef, edef;
- struct colr_data *cdp;
- struct colr_data colrs[256];
-
- colormap = XDefaultColormap(Dpy, screen);
-
- NumCells = DisplayCells(Dpy, DefaultScreen(Dpy));
- Allocated = (int *) malloc(NumCells * sizeof(int));
- for (i = 0; i < NumCells; i++) {
- Allocated[i] = 0;
- }
- AllocCnt = 0;
- if ((climit <= 0) || (climit > NumCells)) {
- climit = NumCells;
- }
-
- Pcnt = 0;
- if (picname[0] != '\0') {
- Imlib_Image image = imlib_load_image(picname);
- if (image == NULL) {
- fprintf(stderr, "Cannot load image %s\n", picname);
- picname[0] = 0;
- } else {
- imlib_context_set_image(image);
- imlib_context_set_display(Dpy);
- imlib_context_set_visual(DefaultVisual(Dpy, screen));
- Pwidth = imlib_image_get_width();
- Pheight = imlib_image_get_height();
- DATA32 *image_data = imlib_image_get_data_for_reading_only();
- Pdata = malloc(4 * Pwidth * Pheight);
- for (i = 0; i < Pwidth * Pheight; i++) {
- Pdata[4 * i] = image_data[i] & 0xFF;
- Pdata[4 * i + 1] = image_data[i] & 0xFF00;
- Pdata[4 * i + 2] = image_data[i] & 0xFF0000;
- Pdata[4 * i + 3] = image_data[i] & 0xFF000000;
- }
- Pcnt = ColorUsage(Pdata, Pwidth, Pheight, colrs);
- }
- }
-
- cnt = 0;
- cnt += Pcnt;
- for (i = 0; i < NUM_FISH; i++) {
- cnt += rcolors[i];
- }
- cmap = (int *) malloc((cnt + 1) * sizeof(int));
-
- XLookupColor(Dpy, colormap, cname, &hdef, &edef);
- hdef.flags = DoRed | DoGreen | DoBlue;
- FindColor(Dpy, colormap, &hdef);
- cmap[0] = hdef.pixel;
-
- if (mlimit > 0) {
- MedianInit();
- }
-
- if (mlimit > 0) {
- if (picname[0] != '\0') {
- MedianCount(Pdata, Pwidth, Pheight, colrs);
- }
- for (j = 0; j < NUM_FISH; j++) {
- int *rp, *gp, *bp;
-
- cdp = (struct colr_data *) malloc(rcolors[j] * sizeof(struct colr_data));
- rp = rreds[j];
- gp = rgreens[j];
- bp = rblues[j];
- for (i = 0; i < rcolors[j]; i++) {
- cdp[i].red = *rp++;
- cdp[i].green = *gp++;
- cdp[i].blue = *bp++;
- }
- MedianCount((unsigned char *) xfishRasterA[j],
- (int) rwidth[j], (int) rheight[j], cdp);
- free((char *) cdp);
- }
- MedianSplit(mlimit);
- }
-
- cnt = 1;
- if (picname[0] != '\0') {
- for (i = 0; i < Pcnt; i++) {
- int rv, gv, bv;
-
- rv = colrs[i].red;
- gv = colrs[i].green;
- bv = colrs[i].blue;
-
- if (mlimit > 0) {
- ConvertColor(&rv, &gv, &bv);
- }
-
- hdef.red = rv;
- hdef.green = gv;
- hdef.blue = bv;
- hdef.flags = DoRed | DoGreen | DoBlue;
- FindColor(Dpy, colormap, &hdef);
- cmap[cnt] = hdef.pixel;
- cnt++;
- }
- }
- for (j = 0; j < NUM_FISH; j++) {
- int *rp, *gp, *bp;
-
- rp = rreds[j];
- gp = rgreens[j];
- bp = rblues[j];
- for (i = 0; i < rcolors[j]; i++) {
- int rv, gv, bv;
-
- rv = *rp++;
- gv = *gp++;
- bv = *bp++;
-
- if (mlimit > 0) {
- ConvertColor(&rv, &gv, &bv);
- }
-
- hdef.red = rv;
- hdef.green = gv;
- hdef.blue = bv;
- hdef.flags = DoRed | DoGreen | DoBlue;
- FindColor(Dpy, colormap, &hdef);
- cmap[cnt] = hdef.pixel;
- if (i == rback[j]) {
- cmap[cnt] = cmap[0];
- }
- cnt++;
- }
- }
-
- bcolor = white;
-}
-
-
-/*
- * Make am image of appropriate depth for display from image data.
- */
-XImage *
-MakeImage(data, width, height)
-unsigned char *data;
-int width, height;
-{
- int linepad, shiftnum;
- int shiftstart, shiftstop, shiftinc;
- int bytesperline;
- int depth, temp;
- int w, h;
- XImage *newimage;
- unsigned char *bit_data, *bitp, *datap;
-
- depth = DefaultDepth(Dpy, DefaultScreen(Dpy));
- if ((depth != 1) && (depth != 2) && (depth != 4) && (depth != 8)) {
- fprintf(stderr, "Don't know how to format image for display of depth %d\n", depth);
- exit(1);
- }
-
- if (BitmapBitOrder(Dpy) == LSBFirst) {
- shiftstart = 0;
- shiftstop = 8;
- shiftinc = depth;
- } else {
- shiftstart = 8 - depth;
- shiftstop = -depth;
- shiftinc = -depth;
- }
- linepad = 8 - (width % 8);
- bit_data = (unsigned char *) malloc(((width + linepad) * height) + 1);
- bitp = bit_data;
- datap = data;
- *bitp = 0;
- shiftnum = shiftstart;
- for (h = 0; h < height; h++) {
- for (w = 0; w < width; w++) {
- temp = *datap++ << shiftnum;
- *bitp = *bitp | temp;
- shiftnum = shiftnum + shiftinc;
- if (shiftnum == shiftstop) {
- shiftnum = shiftstart;
- bitp++;
- *bitp = 0;
- }
- }
- for (w = 0; w < linepad; w++) {
- shiftnum = shiftnum + shiftinc;
- if (shiftnum == shiftstop) {
- shiftnum = shiftstart;
- bitp++;
- *bitp = 0;
- }
- }
- }
-
- bytesperline = (width * depth / 8 + linepad);
- newimage = XCreateImage(Dpy, DefaultVisual(Dpy, screen), depth,
- ZPixmap, 0, (char *) bit_data,
- (width + linepad), height, 8, bytesperline);
-
- return (newimage);
-}
-
-
-
-static unsigned char bits[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Calibrate the pixmaps and bimaps. The right-fish data is coded in xfishy.h,
-this is transformed to create the left-fish. The eight bubbles are coded
-in bubbles.h as a two dimensional array.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-init_pixmap()
-{
- register caddrt p, q, x1A, x1B, x2A, x2B;
- unsigned char *data;
- register int i, j, k;
- int cnt, wcnt;
-
- cnt = 1;
- cnt += Pcnt;
- for (k = 0; k < NUM_FISH; k++) {
-
- /*
- * The clipmasks must be created before we remap colors.
- * otherwise an opaque color might get remapped to a
- * transparent color.
- */
- if ((DoClipping) || (picname[0] != '\0')) {
- data = (unsigned char *) malloc((rwidth[k] + 7) / 8 * rheight[k]);
-
- p = (caddrt) xfishRasterA[k];
- q = data;
- wcnt = 0;
- for (i = 0; i < ((rwidth[k] + 7) / 8 * rheight[k]); i++) {
- unsigned char bt = 0x00;
- for (j = 0; j < 8; j++) {
- if (*p != rback[k]) {
- bt = bt | bits[j];
- }
- wcnt++;
- p++;
- if (wcnt == rwidth[k]) {
- wcnt = 0;
- break;
- }
- }
- *q++ = bt;
- }
- mfishA[k][2] = XCreateBitmapFromData(Dpy, wid,
- (char *) data, rwidth[k], rheight[k]);
-
- p = (caddrt) xfishRasterA[k];
- p = p + rwidth[k] - 1;
- q = data;
- wcnt = 0;
- for (i = 0; i < ((rwidth[k] + 7) / 8 * rheight[k]); i++) {
- unsigned char bt = 0x00;
- for (j = 0; j < 8; j++) {
- if (*p != rback[k]) {
- bt = bt | bits[j];
- }
- wcnt++;
- p--;
- if (wcnt == rwidth[k]) {
- wcnt = 0;
- p = p + (2 * rwidth[k]);
- break;
- }
- }
- *q++ = bt;
- }
- mfishA[k][1] = XCreateBitmapFromData(Dpy, wid,
- (char *) data, rwidth[k], rheight[k]);
-
- p = (caddrt) xfishRasterB[k];
- q = data;
- wcnt = 0;
- for (i = 0; i < ((rwidth[k] + 7) / 8 * rheight[k]); i++) {
- unsigned char bt = 0x00;
- for (j = 0; j < 8; j++) {
- if (*p != rback[k]) {
- bt = bt | bits[j];
- }
- wcnt++;
- p++;
- if (wcnt == rwidth[k]) {
- wcnt = 0;
- break;
- }
- }
- *q++ = bt;
- }
- mfishB[k][2] = XCreateBitmapFromData(Dpy, wid,
- (char *) data, rwidth[k], rheight[k]);
-
- p = (caddrt) xfishRasterB[k];
- p = p + rwidth[k] - 1;
- q = data;
- wcnt = 0;
- for (i = 0; i < ((rwidth[k] + 7) / 8 * rheight[k]); i++) {
- unsigned char bt = 0x00;
- for (j = 0; j < 8; j++) {
- if (*p != rback[k]) {
- bt = bt | bits[j];
- }
- wcnt++;
- p--;
- if (wcnt == rwidth[k]) {
- wcnt = 0;
- p = p + (2 * rwidth[k]);
- break;
- }
- }
- *q++ = bt;
- }
- mfishB[k][1] = XCreateBitmapFromData(Dpy, wid,
- (char *) data, rwidth[k], rheight[k]);
-
- free((char *) data);
- }
-
- if (DisplayPlanes(Dpy, screen) < 8) {
-
- j = rwidth[k] * rheight[k];
- x1A = (caddrt) malloc(rwidth[k] * rheight[k]);
- p = (caddrt) xfishRasterA[k];
-
-
- q = x1A;
- for (i = 0; i < j; i++) {
- *q = cmap[cnt + (int) (*p)];
- p++;
- q++;
- }
-
- x1B = (caddrt) malloc(rwidth[k] * rheight[k]);
- p = (caddrt) xfishRasterB[k];
- q = x1B;
- for (i = 0; i < j; i++) {
- *q = cmap[cnt + (int) (*p)];
- p++;
- q++;
- }
-
- x2A = (caddrt) malloc(rwidth[k] * rheight[k]);
- for (i = 0; i < rheight[k]; i++) {
- p = x1A + i * rwidth[k];
- q = x2A + (i + 1) * rwidth[k] - 1;
- for (j = 0; j < rwidth[k]; j++) {
- *q-- = *p++;
- }
- }
-
- x2B = (caddrt) malloc(rwidth[k] * rheight[k]);
- for (i = 0; i < rheight[k]; i++) {
- p = x1B + i * rwidth[k];
- q = x2B + (i + 1) * rwidth[k] - 1;
- for (j = 0; j < rwidth[k]; j++) {
- *q-- = *p++;
- }
- }
-
- xfishA[k][2] = MakeImage(x1A, rwidth[k], rheight[k]);
- xfishA[k][1] = MakeImage(x2A, rwidth[k], rheight[k]);
- xfishB[k][2] = MakeImage(x1B, rwidth[k], rheight[k]);
- xfishB[k][1] = MakeImage(x2B, rwidth[k], rheight[k]);
-
- free((char *) x1A);
- free((char *) x2A);
- free((char *) x1B);
- free((char *) x2B);
- } else {
- i = DisplayPlanes(Dpy, screen);
-
- xfishA[k][2] =
- XGetImage(Dpy, root_window, 0, 0, rwidth[k], rheight[k], 0, ZPixmap);
-
- p = (caddrt) xfishRasterA[k];
-
- for (j = 0; j < rheight[k]; j++) {
- for (i = 0; i < rwidth[k]; i++) {
- XPutPixel(xfishA[k][2], i, j, cmap[cnt + (int) (*p)]);
- p++;
- }
- }
-
- xfishB[k][2] =
- XGetImage(Dpy, root_window, 0, 0, rwidth[k], rheight[k], 0, ZPixmap);
-
- p = (caddrt) xfishRasterB[k];
-
- for (j = 0; j < rheight[k]; j++) {
- for (i = 0; i < rwidth[k]; i++) {
- XPutPixel(xfishB[k][2], i, j, cmap[cnt + (int) (*p)]);
- p++;
- }
- }
-
- xfishA[k][1] =
- XGetImage(Dpy, root_window, 0, 0, rwidth[k], rheight[k], 0, ZPixmap);
-
- for (j = 0; j < rheight[k]; j++) {
- for (i = 0; i < rwidth[k]; i++) {
- XPutPixel(xfishA[k][1], i, j,
- XGetPixel(xfishA[k][2], rwidth[k] - i - 1, j));
- }
- }
-
- xfishB[k][1] =
- XGetImage(Dpy, root_window, 0, 0, rwidth[k], rheight[k], 0, ZPixmap);
-
- for (j = 0; j < rheight[k]; j++) {
- for (i = 0; i < rwidth[k]; i++) {
- XPutPixel(xfishB[k][1], i, j,
- XGetPixel(xfishB[k][2], rwidth[k] - i - 1, j));
- }
- }
-
- }
-
-
- i = DisplayPlanes(Dpy, screen);
-
- pfishA[k][1] = XCreatePixmap(Dpy, wid, rwidth[k], rheight[k], i);
- pfishA[k][2] = XCreatePixmap(Dpy, wid, rwidth[k], rheight[k], i);
- pfishB[k][1] = XCreatePixmap(Dpy, wid, rwidth[k], rheight[k], i);
- pfishB[k][2] = XCreatePixmap(Dpy, wid, rwidth[k], rheight[k], i);
-
- if (pfishA[k][1]) {
- XPutImage(Dpy, pfishA[k][1], gc, xfishA[k][1], 0, 0, 0, 0, rwidth[k], rheight[k]);
- }
- if (pfishA[k][2]) {
- XPutImage(Dpy, pfishA[k][2], gc, xfishA[k][2], 0, 0, 0, 0, rwidth[k], rheight[k]);
- }
- if (pfishB[k][1]) {
- XPutImage(Dpy, pfishB[k][1], gc, xfishB[k][1], 0, 0, 0, 0, rwidth[k], rheight[k]);
- }
- if (pfishB[k][2]) {
- XPutImage(Dpy, pfishB[k][2], gc, xfishB[k][2], 0, 0, 0, 0, rwidth[k], rheight[k]);
- }
-
- cnt += rcolors[k];
- }
-
- for (i = 1; i <= 8; i++) {
- xbubbles[i] = XCreateBitmapFromData(Dpy, wid, (char *) xbBits[i], i, i);
- }
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Toggle secure mode on receipt of signal
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-#ifdef sgi
-int
-#else
-void
-#endif
-toggle_secure()
-{
- pmode = !pmode;
- if (pmode)
- XLowerWindow(Dpy, wid);
- else
- XRaiseWindow(Dpy, wid);
- XFlush(Dpy);
-#ifdef sgi
- return (1);
-#endif
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Initialize signal so that SIGUSR1 causes secure mode to toggle.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-init_signals()
-{
-#if defined(linux)
- signal(SIGUSR1, toggle_secure);
-#elif defined(MOTOROLA) || defined(SCO)
- sigset(SIGUSR1, toggle_secure);
-#else
- struct sigvec vec;
-
- vec.sv_handler = toggle_secure;
- vec.sv_mask = 0;
- vec.sv_onstack = 0;
-
-#ifndef hpux
- sigvec(SIGUSR1, &vec, &vec);
-#else
- sigvector(SIGUSR1, &vec, &vec);
-#endif
-#endif
-}
-
-
-void
-set_window_type_desktop(Display *dpy, Window wid)
-{
- Atom _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_DESKTOP;
-
- _NET_WM_WINDOW_TYPE = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False);
- _NET_WM_WINDOW_TYPE_DESKTOP = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", False);
-
- XChangeProperty(dpy, wid, _NET_WM_WINDOW_TYPE, XA_ATOM, 32,
- PropModeReplace, (unsigned char *) &_NET_WM_WINDOW_TYPE_DESKTOP, 1);
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Variety of initialization calls, including getting the window up and running.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-initialize()
-{
- XWindowAttributes winfo;
- XSetWindowAttributes attr;
- XGCValues vals;
- XSizeHints xsh;
- int i;
- char *p;
-
- root_window = VirtualRootWindowOfScreen(DefaultScreenOfDisplay(Dpy));
-
- XGetWindowAttributes(Dpy, root_window, &winfo);
- width = winfo.width;
- height = winfo.height;
-
- if ((p = XGetDefault(Dpy, pname, "BubbleLimit")) != NULL)
- blimit = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "ColorLimit")) != NULL)
- climit = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "MedianCutLimit")) != NULL)
- mlimit = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "DoClipping")) != NULL)
- DoClipping = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "DoubleBuffer")) != NULL)
- DoubleBuf = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "Overlap")) != NULL)
- Overlap = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "Color")) != NULL)
- strcpy(cname, p);
- if ((p = XGetDefault(Dpy, pname, "Picture")) != NULL)
- strcpy(picname, p);
- if ((p = XGetDefault(Dpy, pname, "FishLimit")) != NULL)
- flimit = atoi(p);
- if ((p = XGetDefault(Dpy, pname, "IncMult")) != NULL)
- smooth = atof(p);
- if ((p = XGetDefault(Dpy, pname, "Rate")) != NULL)
- rate = atof(p);
- if ((p = XGetDefault(Dpy, pname, "Secure")) != NULL)
- for (i = 0; i < 6; i++)
- if (strcmp(p, yess[i]) == 0)
- pmode = 0;
-
- /*
- * DoubleBuf is only useful if we are doing clipping on our
- * own background picture, otherwise turn it off.
- */
- if ((DoubleBuf) && ((!DoClipping) || (picname[0] == '\0'))) {
- DoubleBuf = 0;
- }
-
- init_colormap();
-
- if (picname[0] != '\0') {
- imlib_context_set_colormap(colormap);
- PicMap = XCreatePixmap(Dpy, root_window, Pwidth, Pheight, DisplayPlanes(Dpy, screen));
- imlib_context_set_drawable(PicMap);
- imlib_render_image_on_drawable(0, 0);
-
- }
-
- if ((DoubleBuf) || (picname[0] != '\0')) {
- i = DisplayPlanes(Dpy, screen);
- PixBuf = XCreatePixmap(Dpy, root_window, 500, 500, i);
- ClipBuf = XCreatePixmap(Dpy, root_window, 500, 500, 1);
- c0gc = XCreateGC(Dpy, ClipBuf, 0, NULL);
- XSetForeground(Dpy, c0gc, (unsigned long) 0);
- XSetFunction(Dpy, c0gc, GXcopy);
- cpgc = XCreateGC(Dpy, ClipBuf, 0, NULL);
- XSetFunction(Dpy, cpgc, GXor);
- }
-
- attr.override_redirect = True;
- attr.background_pixel = cmap[0];
-
- if (!DoClipping || picname[0] != '\0') {
- wid = XCreateWindow(Dpy, root_window,
- 1, 1, width - 2, height - 2, 0,
- CopyFromParent, CopyFromParent, CopyFromParent,
- CWBackPixel | CWOverrideRedirect, &attr);
-
- if (!wid)
- msgdie("XCreateWindow failed");
- set_window_type_desktop(Dpy, wid);
- } else {
- wid = root_window;
- XClearArea(Dpy, wid, 0, 0, 0, 0, False);
- }
-
- vals.foreground = vals.background = cmap[0];
- vals.graphics_exposures = False;
- gc = XCreateGC(Dpy, wid, GCForeground | GCBackground | GCGraphicsExposures, &vals);
- pgc = XCreateGC(Dpy, wid, GCForeground | GCBackground | GCGraphicsExposures, &vals);
- bgc = XCreateGC(Dpy, wid, GCForeground | GCBackground | GCGraphicsExposures, &vals);
-
- for (i = 0; i < NUM_FISH; i++) {
- pfishA[i][0] = 0;
- pfishA[i][1] = 0;
- pfishA[i][2] = 0;
- pfishB[i][0] = 0;
- pfishB[i][1] = 0;
- pfishB[i][2] = 0;
-
- mfishA[i][0] = 0;
- mfishA[i][1] = 0;
- mfishA[i][2] = 0;
- mfishB[i][0] = 0;
- mfishB[i][1] = 0;
- mfishB[i][2] = 0;
- }
-
- init_pixmap();
- init_signals();
-
- if (!DoClipping || picname[0] != '\0') {
- XStoreName(Dpy, wid, pname);
-
- xsh.flags = USSize | USPosition | PPosition | PSize;
- xsh.x = xsh.y = 0;
- xsh.width = width;
- xsh.height = height;
- XSetNormalHints(Dpy, wid, &xsh);
-
- if (picname[0] != '\0') {
- XSetWindowBackgroundPixmap(Dpy, wid, PicMap);
- }
-
- XMapWindow(Dpy, wid);
- }
-
- binfo = (bubble *) malloc(blimit * sizeof(bubble));
- finfo = (fish *) malloc(flimit * sizeof(fish));
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Create a new bubble. Placement along the x axis is random, as is the size of
-the bubble. Increment value is determined by speed.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-new_bubble(b0)
-bubble *b0;
-{
- register int s;
- register bubble *b = b0;
-
- b->x = width * (rand() / RAND_F_MAX);
- if (Init_B)
- b->y = (height / 16) * (rand() / RAND_I_1_16 + 1) - 1;
- else
- b->y = height - 1;
- b->s = s = 1.0 + rand() / RAND_F_1_8;
- if ((b->i = smooth * height / (float) binc[s]) == 0)
- b->i = 1;
- b->erased = 0;
- putbubble(b, s, bcolor);
-}
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Erase old bubbles, move and draw new bubbles. Random left-right factor
-can move bubble one size-unit in either direction.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-step_bubbles()
-{
- register int i, j, s;
- register bubble *b;
-
- for (i = 0; i < blimit; i++) {
- b = &binfo[i];
- s = b->s;
- /* clear */
- if ((b->y > 0) && (b->erased == 0)) {
- if ((DoClipping) || (picname[0] != '\0')) {
- erasebubble(b, s);
- } else {
- putbubble(b, s, cmap[0]);
- }
- }
- if ((b->y -= b->i) > 0) {
- j = rand();
- if (j < RAND_I_1_4) {
- b->x -= s;
- } else if (j > RAND_I_3_4) {
- b->x += s;
- }
- putbubble(b, s, bcolor);
- } else {
- if (rand() < RAND_I_1_4) {
- new_bubble(b);
- }
- }
- b->erased = 0;
- }
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Fish over bubble collision detection. The specified fish is checked against
-all bubbles for overlap. This way we don't try and erase bubbles that are
-already gone.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-collide_bubbles(f0, ofx, ofy)
-fish *f0;
-int ofx, ofy;
-{
- int i, delta;
- register fish *f = f0;
- register bubble *b;
-
- for (i = 0; i < blimit; i++) {
- b = &binfo[i];
- delta = b->x - ofx;
- if ((delta >= 0) && (delta <= (rwidth[f->type] - b->s))) {
- delta = b->y - ofy;
- if ((delta >= 0) && (delta <= (rheight[f->type] - b->s))) {
- b->erased = 1;
- continue;
- }
- }
- delta = b->x - f->x;
- if ((delta >= 0) && (delta <= (rwidth[f->type] - b->s))) {
- delta = b->y - f->y;
- if ((delta >= 0) && (delta <= (rheight[f->type] - b->s))) {
- b->erased = 1;
- continue;
- }
- }
- }
-}
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Fish collision detection. The specified fish is checked against all other
-fish for overlap. The xt parameter specifies a x axis multiplier for overlap.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-int
-collide_fish(f0, xt)
-fish *f0;
-int xt;
-{
- int i, j;
- register fish *f = f0;
-
- if (Overlap) {
- return (0);
- }
-
- for (i = 0; i < flimit; i++) {
- if (&finfo[i] != f) {
- j = finfo[i].y - f->y;
- if ((j > -rheight[finfo[i].type]) && (j < rheight[f->type])) {
- j = finfo[i].x - f->x;
- if ((j > -xt * rwidth[finfo[i].type]) && (j < xt * rwidth[f->type])) {
- return (1);
- }
- }
- }
- }
- return (0);
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Create a new fish. Placement along the y axis is random, as is the side
->from which the fish appears. Direction is determined from side. Increment
-is also random.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-new_fish(f0)
-fish *f0;
-{
- int i, collide;
- fish *f = f0;
-
- f->type = rand() % NUM_FISH;
- for (i = 0, collide = 1; (i < 16) && (collide); i++) {
- f->y = (height - rheight[f->type]) * (rand() / RAND_F_MAX);
- if ((f->i = smooth * width / (8.0 * (1.0 + rand() / RAND_F_1_8))) == 0) {
- f->i = 1;
- }
- if (rand() < RAND_I_1_2) {
- f->d = 1;
- f->x = width;
- } else {
- f->d = 2;
- f->x = -rwidth[f->type];
- }
- collide = collide_fish(f, 2);
- }
-
- if (!collide) {
- putfish(f);
- } else {
- f->d = 0;
- }
-
- f->frame = 0;
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Move all the fish. Clearing old fish is accomplished by masking only the
-exposed areas of the old fish. Random up-down factor can move fish 1/4 a
-fish height in either direction, if no collisions are caused.
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-move_fish()
-{
- register int i, j, x, y, ofx, ofy, ofd, done;
- register fish *f;
-
- for (i = 0; i < flimit; i++) {
- f = &finfo[i];
- if (f->d) {
- ofx = f->x;
- ofy = f->y;
- ofd = f->d;
-
- if (f->d == 1) {
- done = ((f->x -= f->i) < -rwidth[f->type]);
- x = f->x + rwidth[f->type];
- } else if (f->d == 2) {
- done = ((f->x += f->i) > width);
- x = f->x - f->i;
- }
-
- if (!collide_fish(f, 1)) {
- if (!done) {
- j = rand();
- if (j < RAND_I_1_4) {
- y = f->i / 4;
- } else if (j > RAND_I_3_4) {
- y = f->i / -4;
- } else {
- y = 0;
- }
-
- if (y) {
- f->y += y;
- if (collide_fish(f, 1)) {
- f->y -= y;
- y = 0;
- } else {
- if (y > 0) {
- j = f->y - y;
- } else {
- j = f->y + rheight[f->type];
- y *= -1;
- }
- }
- }
- if (DoClipping) {
- movefish(f, ofx, ofy, ofd);
- } else {
- putfish(f);
- XClearArea(Dpy, wid, x, ofy, f->i, rheight[f->type], 0);
- if (y) {
- XClearArea(Dpy, wid, ofx, j, rwidth[f->type], y, 0);
- }
- }
-
- } else {
- XClearArea(Dpy, wid, x, f->y, f->i, rheight[f->type], 0);
- new_fish(f);
- }
- } else {
- if ((f->d = 3 - f->d) == 1) {
- f->x = f->x - 2 * f->i;
- x = f->x + rwidth[f->type];
- } else {
- f->x = f->x + 2 * f->i;
- x = f->x - f->i;
- }
- if (DoClipping) {
- movefish(f, ofx, ofy, ofd);
- } else {
- putfish(f);
- XClearArea(Dpy, wid, x, f->y, f->i, rheight[f->type], 0);
- }
- }
- if ((!DoClipping) || (picname[0] == '\0')) {
- collide_bubbles(f, ofx, ofy);
- }
- } else {
- new_fish(f);
- }
- }
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-Higher-resolution sleep
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-void
-high_res_sleep(seconds)
-double seconds;
-{
- struct timeval timeout;
-
- timeout.tv_sec = seconds;
- timeout.tv_usec = (seconds - timeout.tv_sec) * 1000000.0;
- select(0, NULL, NULL, NULL, &timeout);
-}
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-int
-main(argc, argv)
-int argc;
-char **argv;
-{
- int i;
- XEvent ev;
-
- parse(argc, argv);
- if ((Dpy = XOpenDisplay(sname)) == 0)
- msgdie("XOpenDisplay failed");
- screen = DefaultScreen(Dpy);
-
- white = WhitePixel(Dpy, screen);
- black = BlackPixel(Dpy, screen);
- initialize();
-
- srand((unsigned) getpid());
-
- Init_B = 1;
- for (i = 0; i < blimit; i++)
- new_bubble(&binfo[i]);
- for (i = 0; i < flimit; i++) {
- finfo[i].x = 0;
- finfo[i].y = 0;
- finfo[i].type = 0;
- }
- for (i = 0; i < flimit; i++)
- new_fish(&finfo[i]);
- if (pmode)
- XLowerWindow(Dpy, wid);
- else
- XRaiseWindow(Dpy, wid);
- XFlush(Dpy);
-
- Init_B = 0;
-
- for (;;) {
- if (XPending(Dpy))
- XNextEvent(Dpy, &ev);
-
- high_res_sleep(rate);
-
- move_fish();
-
- step_bubbles();
-
- if (pmode)
- XLowerWindow(Dpy, wid);
- else
- XRaiseWindow(Dpy, wid);
- }
-
- return 0;
-}
projects / xfishtank.git / blobdiff