Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/x/volume18/xmandel/part03

Internet Message Format | 1992-07-13 | 50KB

Path: uunet!elroy.jpl.nasa.gov!swrinde!mips!msi!dcmartin
From: [e-mail] (Tony Field)
Newsgroups: comp.sources.x
Subject: v18i017: Xmandelbrot, Part03/03
Message-ID: <[e-mail]>
Date: 13 Jul 92 15:51:07 GMT
References: <[e-mail]>
Sender: [e-mail] (David C. Martin - Moderator)
Organization: Molecular Simulations, Inc.
Lines: 1759
Approved: [e-mail]
Originator: dcmartin@fascet

Submitted-by: [e-mail] (Tony Field)
Posting-number: Volume 18, Issue 17
Archive-name: xmandel/part03

#!/bin/sh
# this is part.03 (part 3 of a multipart archive)
# do not concatenate these parts, unpack them in order with /bin/sh
# file mandel.c continued
#
if test ! -r _shar_seq_.tmp; then
    echo 'Please unpack part 1 first!'
    exit 1
fi
(read Scheck
 if test "$Scheck" != 3; then
    echo Please unpack part "$Scheck" next!
    exit 1
 else
    exit 0
 fi
) < _shar_seq_.tmp || exit 1
if test ! -f _shar_wnt_.tmp; then
    echo 'x - still skipping mandel.c'
else
echo 'x - continuing file mandel.c'
sed 's/^X//' << 'SHAR_EOF' >> 'mandel.c' &&
X
void start_mandel()
{
X    if (manparm.window == 0)
X        return;
X    if (manparm.zoom)
X    {    /* reset to beginning by popping zps off stack if not already there */
X        while (zoomtmp = manparm.zoom->zp)
X        {    free(manparm.zoom);
X            manparm.zoom = zoomtmp;
X        }
X    }
X    else
X    {    manparm.zoom = (struct zoomd *) malloc(sizeof (struct zoomd));
X        manparm.zoom->zp = NULL;    /* NULL means last in stack - don't pop */
X    }
X    manparm.zoom->lx = START_LX; manparm.zoom->ux = START_UX;
X    manparm.zoom->ly = START_LY; manparm.zoom->uy = START_UY;
X
X    mandel ();
}
X
/************************************************************************
*    redo_mandel()        button: recalc        recalc current mandelbrot    *
************************************************************************/
X
void redo_mandel ()
{    if (manparm.window == 0)
X        return;
X    mandel ();
}
X
X
/************************************************************************
*    mandel()            do the mandelbrot calculations and send to video*
************************************************************************/
X
static void mandel ()
{
X    double wx, wy, oldwx;
X    double x, y;
X    double incrx, incry;
X    int ix, iy;
X    int        shift;
X    XEvent event;
X    XWindowAttributes draw_wattr;
X    GC draw_gc;
X    Visual *draw_v;
X    long    save_event_mask;
X
X    if (manparm.window == 0)
X        return;
X    manparm.lx = manparm.zoom->lx;
X    manparm.ly = manparm.zoom->ly;
X    manparm.ux = manparm.zoom->ux;
X    manparm.uy = manparm.zoom->uy;
X    update_coordinates (&manparm, 1);
X
X    XGetWindowAttributes (display, manparm.window, &draw_wattr);
X    draw_gc = screen->default_gc;
X    draw_v = screen->root_visual;
X    save_event_mask = draw_wattr.your_event_mask;
X    if (manparm.pixwidth != draw_wattr.width  ||  manparm.pixheight != draw_wattr.height)
X    {
X        /*    screen dimension changed.  rebuild image line information */
X
X        manparm.pixheight = draw_wattr.height;
X        manparm.pixwidth  = draw_wattr.width;
X        manparm.bytewidth = (manparm.pixwidth + dots_per_byte - 1) / dots_per_byte;
X        scanline = -1;
X
X        if (ximage)
X             XDestroyImage (ximage);        /* also deallocates image_data automagically */
X        if (manparm.pix)
X            free (manparm.pix);
X
X        image_data = malloc (manparm.bytewidth + 1);    /* Really! bug in ISC X11?? */
X        manparm.pix = (unsigned char *) malloc (manparm.bytewidth * manparm.pixheight);
X        if (image_data == NULL  ||  manparm.pix == NULL)
X        {    printf ("malloc failed\n");
X            return;
X        }
X        ximage = XCreateImage (display, draw_v, depth, ZPixmap, 0, image_data, manparm.pixwidth, 1, 8, 0);
X        ximage->byte_order = MSBFirst;
X        ximage->bitmap_bit_order = MSBFirst;
X    }
X
X    /*    incremental x/y values for pixel coordinates */
X
X    incrx = (manparm.zoom->ux - manparm.zoom->lx) / manparm.pixwidth;
X    incry = (manparm.zoom->uy - manparm.zoom->ly) / manparm.pixheight;
X    y = manparm.zoom->uy;
X
X    XClearWindow (display, manparm.window);
X    XSelectInput (display, manparm.window, ButtonPressMask | ButtonReleaseMask | ExposureMask);
X
X    for (iy = 0; iy < draw_wattr.height; iy++, y-= incry)
X    {    int i;
X        if (depth < 8)
X            for (i = 0; i < manparm.bytewidth; i++)
X                *(image_data + i) = 0;
X        x = manparm.zoom->lx;
X
X        /*    compute colour values for each pixel in a single scan line */
X
X        for (ix = 0; ix < manparm.pixwidth; ix++, x+= incrx)
X        {
X            /*    compute set value for current point */
X
X            wx = x; wy = y;
X            for (i = 0; i < ITERATION_DEPTH; i++)
X            {    oldwx = wx;
X                wx = wx * wx - wy * wy + x;
X                wy = 2 * oldwx * wy + y;
X                if (wx * wx + wy * wy > 4)
X                    goto useit;
X            }
X            if (depth == 8)
X            {    if (INFINITY_COLOR >= 0)
X                    i = INFINITY_COLOR - COLOR_BIAS;
X            }
X            else
X            {    if (INFINITY_COLOR >= 0)
X                    i = INFINITY_COLOR;
X            }
X
useit:        /*    assign colour to pixel    */
X
X            switch (depth)
X            {
X            case 8:
X                image_data[ix] = i + COLOR_BIAS;
X                break;
X
X            case 4:
X                if (ix % 2)
X                    image_data[ix >> 1] |= (i % 16);
X                else
X                    image_data[ix >> 1] |= ((i % 16) << 4);
X                break;
X
X            case 2:
X                switch (ix % 4)
X                {
X                case 0:        shift = 6;    break;
X                case 1:        shift = 4;    break;
X                case 2:        shift = 2;    break;
X                case 3:        shift = 0;    break;
X                }
X                image_data[ix >> 2] |= (i % 4) << shift;
X                break;
X
X            case 1:
X                if (i % 2)
X                    image_data[ix >> 3] |= 1 << (7 - ix%8);
X            }
X        }
X
X        /*    save scan line for exposure events or gif output */
X
X        memcpy (manparm.pix + iy * manparm.bytewidth, image_data, manparm.bytewidth);
X        scanline = iy;
X
X        /*    send image line to screen */
X
X        XPutImage (display, manparm.window, draw_gc, ximage, 0,0, 0, iy, manparm.pixwidth, 1);
X
X        /*    check for exposure or buttons after a few lines have been drawn.
X            This keeps server queries do a reasonable level while still
X            allowing exposures without too much delay.
X        */
X        if (iy % EXPOSURE_TEST == 0)
X        {    /*    XSync to ensure exposure or button is honoured "fast" */
X
X            XSync (display, False);
X
X            /*    first cleanup any pending exposures */
X
X            while (XCheckTypedEvent (display, Expose, &event) == True)
X                XtDispatchEvent (&event);
X
X            /*    then check for abort if a button is pressed */
X
X            while (XCheckWindowEvent (display, manparm.window, ButtonPressMask | ButtonReleaseMask, &event) == True)
X            {    if (event.type == ButtonRelease)
X                    goto escape;
X            }
X        }
X    }
escape:
X    XSelectInput (display, manparm.window, save_event_mask);
}
X
/************************************************************************
*    expose_mandel()            handle mandel exposure event                *
************************************************************************/
X
void expose_mandel (w, unused, event)
Widget w;
caddr_t unused;
XXExposeEvent *event;
{
X    if (manparm.window == 0)
X        return;
X    if (event  &&  manparm.pix  &&  scanline >= 0)
X        redraw_mandel (event);
}
X
/************************************************************************
*    redraw_mandel()            reshow mandelbrot from backup image.        *
************************************************************************/
X
void redraw_mandel (event)
XXExposeEvent *event;
{
X    int  iy;
X    XWindowAttributes draw_wattr;
X    GC draw_gc;
X    Visual *draw_v;
X    int    maxy;
X
X    if (manparm.window == 0)
X        return;
X    XGetWindowAttributes (display, manparm.window, &draw_wattr);
X    draw_gc = screen->default_gc;
X    draw_v = screen->root_visual;
X    if (event == NULL)
X    {
X        /*    refresh entire window */
X
X        maxy = MIN (scanline, manparm.pixheight-1);
X        for (iy = 0; iy <= maxy; iy++)
X        {    memcpy (image_data, manparm.pix + iy * manparm.bytewidth, manparm.bytewidth);
X            XPutImage (display, manparm.window, draw_gc, ximage, 0,0, 0, iy, manparm.pixwidth, 1);
X        }
X    }
X    else if (event->x < manparm.pixwidth)
X    {
X        /*    refresh only exposed area */
X
X        int    first_byte, last_byte, nbytes, first_dot, last_dot, ndots;
X
X        if (event->x < manparm.pixwidth)
X        {    first_byte = event->x / dots_per_byte;
X            first_dot  = first_byte * dots_per_byte;
X            last_dot   = MIN (manparm.pixwidth - 1, event->x + event->width - 1);
X            last_byte  = (last_dot + dots_per_byte - 1) / dots_per_byte;
X            nbytes     = last_byte - first_byte + 1;
X            ndots      = last_dot - first_dot + 1;
X            maxy       = MIN (event->y + event->height, manparm.pixheight);
X            for (iy = event->y; iy < maxy  &&  iy <= scanline; iy++)
X            {    memcpy (image_data, manparm.pix + iy * manparm.bytewidth + first_byte, nbytes);
X                XPutImage (display, manparm.window, draw_gc, ximage, 0,0, event->x, iy, ndots, 1);
X            }
X        }
X    }
X
X    XFlush(display);
}
X
/************************************************************************
*    do_zoom ()        button: zomm        zoom into mandelbrot            *
*                    The rubber band preserves preserves the current        *
*                    window aspect ration.                                *
************************************************************************/
X
void do_zoom (w, client_data, call_data)
Widget w;
caddr_t client_data;
caddr_t call_data;
{
X    XWindowAttributes draw_wattr;
X    GC draw_gc;
X    Window Root;
X    int S;
X    int    hh, ww, delta;
X    double scaley, xa, ya, xb, yb;
X    long    save_event_mask;
X    int        have_press;
X
X    Window    root, child;
X    int        pos_x, pos_y;
X    unsigned int keys_buttons;
X    int        root_x, root_y;
X
X    if (activeimage->window == 0)
X        return;
X    if (activeimage->zoom == NULL) return;
X
X    draw_gc = screen->default_gc;
X    S = DefaultScreen (display);
X    Root = RootWindow (display, S);
X
X    XSetForeground (display, draw_gc, 255);
X    XSetSubwindowMode (display, draw_gc, IncludeInferiors);
X    XSetFunction (display, draw_gc, GXxor);
X
X    XGetWindowAttributes (display, activeimage->window, &draw_wattr);
X
X    save_event_mask = draw_wattr.your_event_mask;
X    XSelectInput (display, activeimage->window, ButtonPressMask | ButtonReleaseMask
X            | PointerMotionHintMask | PointerMotionMask);
X
X    have_press = 0;        /* Motif translation override may cause a     */
X                        /* button release BEFORE a button press        */
X    while (1)
X    {    static int rubberband = 1;
X        XEvent report;
X
X        XNextEvent (display, &report);
X        if (report.xbutton.window != activeimage->window)
X            continue;
X        switch(report.type)
X        {
X            int winx0,winy0,winx1,winy1,width,height;
X            int x0, y0, x1, y1;
X            double tw, th;
X
X        case ButtonPress:
X            if (report.xbutton.button != Button1)
X                break;
X            x0 = winx0 = report.xbutton.x;
X            y0 = winy0 = report.xbutton.y;
X            rubberband = 0;
X            width = height = 0;
X            have_press = 1;
X            break;
X
X        case ButtonRelease:
X            if (have_press == 0)
X                break;
X            winx1 = report.xbutton.x;
X            winy1 = report.xbutton.y;
X            x0 = MIN (winx0, winx1);
X            x1 = MAX (winx0, winx1);
X            y0 = MIN (winy0, winy1);
X            y1 = MAX (winy0, winy1);
X            width  = x1 - x0;
X            height = y1 - y0;
X
X            /*    ensure rubber band preserves the proportions of the
X                current window.
X            */
X            ww = width;
X            hh = height;
X            delta = MAX (ww, hh);
X            scaley = (double) (draw_wattr.height) / (double) (draw_wattr.width);
X            x1 = x0 + delta;
X            y1 = y0 + delta * scaley;
X            height = y1 - y0;
X            width  = x1 - x0;
X
X            XDrawRectangle (display,activeimage->window, draw_gc, x0, y0, width, height);
X            rubberband = 1;
X            XSetFunction (display, draw_gc, GXcopy);
X            XFlush (display);
X            if (delta > 5  &&  report.xbutton.button == 1)
X            {    tw = activeimage->zoom->ux - activeimage->zoom->lx;
X                th = activeimage->zoom->uy - activeimage->zoom->ly;
X                zoomtmp = (struct zoomd *) malloc (sizeof (struct zoomd));
X                zoomtmp->zp = activeimage->zoom;        /* push onto stack */
X                zoomtmp->ux = activeimage->zoom->lx + ((double) x1 / (double) activeimage->pixwidth) * tw;
X                zoomtmp->lx = activeimage->zoom->lx + ((double) x0 / (double) activeimage->pixwidth) * tw;
X                zoomtmp->ly = activeimage->zoom->uy - ((double) y1 / (double) activeimage->pixheight) * th;
X                zoomtmp->uy = activeimage->zoom->uy - ((double) y0 / (double) activeimage->pixheight) * th;
X                activeimage->zoom = zoomtmp;            /* activeimage->zoom is current pointer */
X                XSelectInput (display, activeimage->window, save_event_mask);
X                if (activeimage == &manparm)
X                    mandel ();
X                else
X                    julia (0, 0);
X            }
X            else
X            {    /*    too small image or pressing button 2/3 quits zoom */
X
X                activeimage->lx = activeimage->zoom->lx;
X                activeimage->ly = activeimage->zoom->ly;
X                activeimage->ux = activeimage->zoom->ux;
X                activeimage->uy = activeimage->zoom->uy;
#ifndef MOTIF
X                printf ("\n");
#else
X                update_coordinates (activeimage, 0);
#endif
X                XSelectInput (display, activeimage->window, save_event_mask);
X            }
X            return;
X
X        case MotionNotify:
X            if (!XQueryPointer (display, report.xmotion.window,
X                    &root, &child, &root_x, &root_y,
X                    &pos_x, &pos_y, &keys_buttons))
X                break;
X            winx1 = pos_x;
X            winy1 = pos_y;
X            if (rubberband == 0)
X            {    XDrawRectangle (display,activeimage->window, draw_gc, x0, y0, width, height);
X                x0 = MIN(winx0, winx1);
X                x1 = MAX(winx0, winx1);
X                y0 = MIN(winy0, winy1);
X                y1 = MAX(winy0, winy1);
X                width  = x1 - x0;
X                height = y1 - y0;
X
X                /*    ensure rubber band preserves the proportions of the
X                    current window.
X                */
X                ww = width;
X                hh = height;
X                delta = MAX (ww, hh);
X                scaley = (double) (draw_wattr.height) / (double) (draw_wattr.width);
X                x1 = x0 + delta;
X                y1 = y0 + delta * scaley;
X                height = y1 - y0;
X                width  = x1 - x0;
X
X                XDrawRectangle (display,activeimage->window, draw_gc, x0, y0, width, height);
X
X                tw = activeimage->zoom->ux - activeimage->zoom->lx;
X                th = activeimage->zoom->uy - activeimage->zoom->ly;
X                xa = activeimage->zoom->lx + ((double) x0 / (double) activeimage->pixwidth) * tw;
X                ya = activeimage->zoom->uy - ((double) y0 / (double) activeimage->pixheight) * th;
X                xb = activeimage->zoom->lx + ((double) x1 / (double) activeimage->pixwidth) * tw;
X                yb = activeimage->zoom->uy - ((double) y1 / (double) activeimage->pixheight) * th;
X
X                activeimage->lx = MIN (xa, xb);
X                activeimage->ly = MIN (ya, yb);
X                activeimage->ux = MAX (xa, xb);
X                activeimage->uy = MAX (ya, yb);
X                update_coordinates (activeimage, 0);
X            }
X            else
X            {
X                tw = activeimage->zoom->ux - activeimage->zoom->lx;
X                th = activeimage->zoom->uy - activeimage->zoom->ly;
X                xa = activeimage->zoom->lx + ((double) winx1 / (double) activeimage->pixwidth) * tw;
X                ya = activeimage->zoom->uy - ((double) winy1 / (double) activeimage->pixheight) * th;
X
X                activeimage->pcolour = pixel_colour (activeimage, winx1, winy1);
X                activeimage->px = xa;
X                activeimage->py = ya;
X                update_point (activeimage);
X            }
X            fflush (stdout);
X            XFlush (display);
X            break;
X
X        default:
X            break;
X        }
X    }
}
X
/************************************************************************
*    do_unzoom()            button: unzoom        recalc previous zoom level.    *
************************************************************************/
X
void do_unzoom (w, client_data, call_data)
Widget w;
caddr_t client_data;
caddr_t call_data;
{
X    if (activeimage->window == 0)
X        return;
X    if (activeimage->zoom)
X    {    /* selecting mooz before mandel invalid */
X        if (zoomtmp = activeimage->zoom->zp)
X        {    /* last on stack */
X            free(activeimage->zoom);
X            activeimage->zoom = zoomtmp;
X        }
X        else
X            return;
X        if (activeimage == &manparm)
X            mandel ();
X        else
X            julia (0, 0);
X    }
}
X
/************************************************************************
*    pixel_colour()        return the colour of a pixel                    *
************************************************************************/
X
int pixel_colour (p, ix, iy)
struct imageparm *p;
int        ix, iy;
{    int        colour, shift;
X    unsigned char *imageline;
X
X    imageline = p->pix + iy * p->bytewidth;
X    switch (depth)
X    {
X    case 8:
X        colour = imageline[ix] & 0x0ff;
X        break;
X
X    case 4:
X        if (ix % 2)
X            shift = 0;
X        else
X            shift = 4;
X        colour = (imageline[ix >> 1] >> shift) & 0x0f;
X        break;
X
X    case 2:
X        switch (ix % 4)
X        {
X        case 0:        shift = 6;    break;
X        case 1:        shift = 4;    break;
X        case 2:        shift = 2;    break;
X        case 3:        shift = 0;    break;
X        }
X        colour  = (imageline[ix >> 2] >> shift) & 0x03;
X        break;
X
X    case 1:
X        colour = (imageline[ix >> 3]  >> (7 - ix % 8)) & 0x01;
X    }
X    return (colour);
}
SHAR_EOF
echo 'File mandel.c is complete' &&
chmod 0644 mandel.c ||
echo 'restore of mandel.c failed'
Wc_c="`wc -c < 'mandel.c'`"
test 15435 -eq "$Wc_c" ||
    echo 'mandel.c: original size 15435, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= mandel.h ==============
if test -f 'mandel.h' -a X"$1" != X"-c"; then
    echo 'x - skipping mandel.h (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting mandel.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'mandel.h' &&
/* ta=4 */
/*  xmandel.h  */
X
/* ---- some changes you may wish to make ------- */
X
/*  memcpy(dest,src,nbytes) is used in various routines.  If memcpy()
X    is not available, use the #define for bcopy().  If  bcopy() is not
X    available then enable "NEEDMEMCPY" to use a very inefficient
X    memory copy.
*/
X
#ifdef HAVEBCOPY
#define memcpy(a,b,c)    bcopy(b,a,c)    /* bsd type */
#endif
X
/* #define NEEDMEMCPY                /* for systems with neither */
X
X
/* set maximum depth of iteration for mandelbrot and julia sets. */
X
#define ITERATION_DEPTH        256
X
/* Check for exposure events after this many scan lines have been drawn
X   by the Mandelbrot or Julia generator.  If you have a very large
X   ITERATION_DEPTH (e.g. > 400) an EXPOSURE_TEST of 1 or 2 is reasonable  */
X
#define EXPOSURE_TEST        4
X
/* If a 256 colour display is used, Set a "color bias" to offset into
X   the colour table for colour value 0.  Iterations arc coloured
X   as "iteration_count + COLOR_BIAS".
*/
X
#define COLOR_BIAS        16
X
/* Set a color value for INFINITY.  A value >= 0 assigns the specified
X   colour number.  A value < 0 uses the "default" colour.
*/
X
#define INFINITY_COLOR        -1
X
/*  Initial starting coordinates for mandelbrot set */
X
#define START_LX -2.25
#define START_UX  1.0
#define START_LY -1.5
#define START_UY  1.5
X
X
/* ----- end configuration ------- */
X
#define MIN(a,b)((a) < (b) ? (a) : (b))
#define MAX(a,b)((a) < (b) ? (b) : (a))
#define ABS(a) ((a) < 0 ? (-a) : (a))
X
/*    for those places where I forgot to make the change... */
X
#define malloc(x)    XtMalloc(x)
#define calloc(x,y)    XtCalloc(x,y)
#define free(x)        XtFree(x)
X
typedef unsigned char    byte;
X
struct zoomd
{    struct zoomd *zp;        /*    previous zoom pointer        */
X    double lx, ux;            /*    bounds for zoom                */
X    double ly, uy;
};
X
#define SAVESIZE 25
X
struct imageparm
{    Window    window;            /* image in this window            */
X    double    lx, ly, ux, uy;    /* image corner coordinates.    */
X    double    px, py;            /* point location (for julia)    */
X    int        rotation;        /* current colour rotation        */
X    int        totrot;            /*    total rotation count        */
X    int        pcolour;        /*    pixel colour                */
X    long    pixheight;        /* image height in pixels        */
X    long    pixwidth;        /* impage width in pixels        */
X    long    bytewidth;        /* width of image line in bytes    */
X    unsigned char *pix;        /* copy of generated image         */
X    struct    zoomd *zoom;    /* zoom stack pointer            */
X    char     sux[SAVESIZE];    /* text ux, uy etc. to detect    */
X    char     suy[SAVESIZE];    /* if user changed values.        */
X    char    slx[SAVESIZE];
X    char    sly[SAVESIZE];
} ;
X
struct enter_buttons
{    char    *button;        /*    label text                    */
X    int        bx;                /*    lable x                        */
X    int        by;                /*    label y                        */
X    char    *field;            /*    data field name                */
X    int        fsize;            /*    data field size chars        */
} ;
X
X
struct button_list
{    char    *ident;                /*    widget name                */
X    void    (*bcall)();            /*    callback function        */
X    int        x;                    /*    x column location        */
X    int        y;                    /*    y row location            */
} ;
X
X
#ifdef __STDC__
/* main.c */
int main(int argc, char **argv);
void update_coordinates(struct imageparm *image, int lf);
void update_point(struct imageparm *image);
/* mandel.c */
void start_mandel(void);
void redo_mandel(void);
void expose_mandel(Widget w, caddr_t unused, XExposeEvent *event);
void redraw_mandel(XExposeEvent *event);
void do_zoom(Widget w, caddr_t client_data, caddr_t call_data);
void do_unzoom(Widget w, caddr_t client_data, caddr_t call_data);
int pixel_colour(struct imageparm *p, int ix, int iy);
/* julia.c */
void start_julia(int destroy_pixmap, int newimage);
void julia(int destroy_pixmap, int newimage);
void expose_julia(Widget w, caddr_t unused, XExposeEvent *event);
void redraw_julia(XExposeEvent *event);
/* writegif.c */
void ws1te_gif_image(char *fname, struct imageparm *imageinfo);
#else
/* main.c */
int main();
void update_coordinates();
void update_point();
/* mandel.c */
void start_mandel();
void redo_mandel();
void expose_mandel();
void redraw_mandel();
void do_zoom();
void do_unzoom();
int pixel_colour();
/* julia.c */
void start_julia();
void julia();
void expose_julia();
void redraw_julia();
/* writegif.c */
void write_gif_image();
#endif
SHAR_EOF
chmod 0644 mandel.h ||
echo 'restore of mandel.h failed'
Wc_c="`wc -c < 'mandel.h'`"
test 4079 -eq "$Wc_c" ||
    echo 'mandel.h: original size 4079, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= writegif.c ==============
if test -f 'writegif.c' -a X"$1" != X"-c"; then
    echo 'x - skipping writegif.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting writegif.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'writegif.c' &&
/* ta=4 */
#include <stdio.h>
#include <X11/Intrinsic.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Shell.h>
#include "mandel.h"
X
#define MAX_COLORS 3
X
unsigned char    rmap[256], gmap[256], bmap[256];
static struct imageparm    *image;
extern Display *display;
X
extern int depth;
typedef long int        count_int;
X
#ifdef __STDC__
static int getcolors(void);
static int writegif(FILE *fp, byte *pic, int w, int h, byte *rmap, byte *gmap, byte *bmap, int numcols, int colorstyle);
static void putword(int w, FILE *fp);
static void compress(int init_bits, FILE *outfile, byte *data, int len);
static void output(int code);
static void cl_block(void);
static void cl_hash(register count_int hsize);
static void char_init(void);
static void char_out(int c);
static void flush_char(void);
#else
static int getcolors();
static int writegif();
static void putword();
static void compress();
static void output();
static void cl_block();
static void cl_hash();
static void char_init();
static void char_out();
static void flush_char();
#endif
X
/************************************************************************
*    write_gif ()                                                        *
*    X11 image data recorded in *image->pix has pixel colors comressed     *
*    to     adjacent bits.  If there are less than 8 bits per pixel, unpack    *
*    the bytes - GIF format must have one pixel per output byte.            *
*    After compression, the wasted space is obviously removed.            *
************************************************************************/
X
void write_gif_image (fname, imageinfo)
char     *fname;
struct imageparm *imageinfo;
{    FILE    *fp;
X    int        i;
X    int        ncolors;
X    int        ix, iy, shift;
X    byte    *bytes, *these_bits, *input, *output;
X
X    image = imageinfo;
X    if (image->pix == NULL)
X        return;
X
X    for (i = 0;  i < 256;  i++)
X        rmap[i] = gmap[i] = bmap[i] = 0;
X
X    fp = fopen (fname, "w");
X    if (fp == NULL)
X    {    printf ("Cannot open gif output file\n");
X        exit (0);
X    }
X    ncolors = getcolors();
X    if (depth != 8)
X    {    bytes = (byte *) malloc (image->pixheight *  image->pixwidth);
X        for (iy = 0; iy < image->pixheight;  iy++)
X        {
X            output = bytes + iy * image->pixwidth;
X            input = image->pix  + iy * image->bytewidth;
X            switch (depth)
X            {
X            case 4:
X                for (ix = 0; ix < image->pixwidth; ix++)
X                {    if (ix % 2)
X                        shift = 0;
X                    else
X                        shift = 4;
X                    output[ix] = (input[ix >> 1] >> shift) & 0x0f;
X                }
X                break;
X
X            case 2:
X                for (ix = 0; ix < image->pixwidth; ix++)
X                {    switch (ix % 4)
X                    {
X                    case 0:        shift = 6;    break;
X                    case 1:        shift = 4;    break;
X                    case 2:        shift = 2;    break;
X                    case 3:        shift = 0;    break;
X                    }
X                    output[ix] = (input[ix >> 2] >> shift) & 0x03;
X                }
X                break;
X
X            case 1:
X                for (ix = 0; ix < image->pixwidth; ix++)
X                    output[ix] = (input[ix >> 3]  >> (7 - ix % 8)) & 0x01;
X            }
X        }
X        these_bits = bytes;
X    }
X    else
X    {    these_bits = image->pix;
X        bytes = NULL;
X    }
X    writegif (fp, these_bits, image->pixwidth, image->pixheight, rmap, gmap, bmap, ncolors, 0);
X    if (bytes)
X        free (bytes);
X    fclose (fp);
}
X
/************************************************************************
*    getcolors ()        get current colour map in rgb for gif output    *
************************************************************************/
X
static int getcolors ()
{
X    Colormap default_cmap;
X    int    ncolors, i;
X    XColor    my_colors[256];
X
X    ncolors = DisplayCells (display, DefaultScreen (display));
X    default_cmap = DefaultColormap (display, DefaultScreen (display));
X    for (i = 0;  i < DisplayCells (display, 0);  i++)
X    {    my_colors[i].pixel = i;
X        my_colors[i].flags = DoRed | DoGreen | DoBlue;
X    }
X
X    XQueryColors (display, default_cmap, my_colors, ncolors);
X
X    /*    scale the colours to a 0..255 range as expected by GIF
X        X11 always gives RGB values as a 16 bit number.
X    */
X    for (i = 0;  i < ncolors;  i++)
X    {    rmap[i] = (double) my_colors[i].red / 256.0;
X        gmap[i] = (double) my_colors[i].green / 256.0;
X        bmap[i] = (double) my_colors[i].blue / 256.0;
X    }
X    return (ncolors);
}
X
X
/*    Extracted for the XV.2.11 source distribution....
X *
X * xvgifwr.c  -  handles writing of GIF files.  based on flgife.c and
X *               flgifc.c from the FBM Library, by Michael Maudlin
X *
X * Contains:
X *   WriteGIF(fp, pic, w, h, rmap, gmap, bmap, numcols, colorstyle)
X *
X * Note: slightly brain-damaged, in that it'll only write non-interlaced
X *       GIF files (in the interests of speed, or something)
X *
X */
X
X
X
/*****************************************************************
X * Portions of this code Copyright (C) 1989 by Michael Mauldin.
X * Permission is granted to use this file in whole or in part provided
X * that you do not sell it for profit and that this copyright notice
X * and the names of all authors are retained unchanged.
X *
X * Authors:  Michael Mauldin ([e-mail])
X *           David Rowley ([e-mail])
X *
X * Based on: compress.c - File compression ala IEEE Computer, June 1984.
X *
X *    Spencer W. Thomas       (decvax!harpo!utah-cs!utah-gr!thomas)
X *    Jim McKie               (decvax!mcvax!jim)
X *    Steve Davies            (decvax!vax135!petsd!peora!srd)
X *    Ken Turkowski           (decvax!decwrl!turtlevax!ken)
X *    James A. Woods          (decvax!ihnp4!ames!jaw)
X *    Joe Orost               (decvax!vax135!petsd!joe)
X *****************************************************************/
X
/*
X * Copyright 1989, 1990 by the University of Pennsylvania
X *
X * Permission to use, copy, and distribute for non-commercial purposes,
X * is hereby granted without fee, providing that the above copyright
X * notice appear in all copies and that both the copyright notice and this
X * permission notice appear in supporting documentation.
X *
X * The software may be modified for your own purposes, but modified versions
X * may not be distributed.
X *
X * This software is provided "as is" without any express or implied warranty.
X */
X
X
/* MONO returns total intensity of r,g,b components */
X
#define MONO(rd,gn,bl) (((rd)*11 + (gn)*16 + (bl)*5) >> 5)  /*.33R+ .5G+ .17B*/
X
int DEBUG = 0;
X
static int  Width, Height;
static int  curx, cury;
static long CountDown;
static int  Interlace;
static byte bw[2] = {0, 0xff};
X
/*************************************************************/
static int writegif (fp, pic, w, h, rmap, gmap, bmap, numcols, colorstyle)
FILE *fp;
byte *pic;
int   w,h;
byte *rmap, *gmap, *bmap;
int   numcols, colorstyle;
{
X  int RWidth, RHeight;
X  int LeftOfs, TopOfs;
X  int Resolution, ColorMapSize, InitCodeSize, Background, BitsPerPixel;
X  int i,j;
X
X
X  /* if writing B/W stipple... */
X  if (colorstyle==2) {
X    rmap = gmap = bmap = bw;
X    numcols = 2;
X  }
X
X  Interlace = 0;
X  Background = 0;
X
X  /* figure out 'BitsPerPixel' */
X  for (i=1; i<8; i++)
X    if ( (1<<i) >= numcols) break;
X
X  BitsPerPixel = i;
X
X  ColorMapSize = 1 << BitsPerPixel;
X
X  RWidth  = Width  = w;
X  RHeight = Height = h;
X  LeftOfs = TopOfs = 0;
X
X  Resolution = BitsPerPixel;
X
X  CountDown = w * h;    /* # of pixels we'll be doing */
X
X  if (BitsPerPixel <= 1) InitCodeSize = 2;
X                    else InitCodeSize = BitsPerPixel;
X
X  curx = cury = 0;
X
X  if (!fp) {
X    fprintf(stderr,  "WriteGIF: file not open for writing\n" );
X    return (1);
X  }
X
X  if (DEBUG)
X    fprintf(stderr,"WrGIF: pic=%lx, w,h=%dx%d, numcols=%d, Bits%d,Cmap=%d\n",
X        pic, w,h,numcols,BitsPerPixel,ColorMapSize);
X
X  fwrite("GIF87a", 1, 6, fp);    /* the GIF magic number */
X
X  putword(RWidth, fp);           /* screen descriptor */
X  putword(RHeight, fp);
X
X  i = 0x80;                     /* Yes, there is a color map */
X  i |= (8-1)<<4;                 /* OR in the color resolution (hardwired 8) */
X  i |= (BitsPerPixel - 1);       /* OR in the # of bits per pixel */
X  fputc(i,fp);
X
X  fputc(Background, fp);         /* background color */
X
X  fputc(0, fp);                  /* future expansion byte */
X
X
X  if (colorstyle == 1) {         /* greyscale */
X    for (i=0; i<ColorMapSize; i++) {
X      j = MONO(rmap[i], gmap[i], bmap[i]);
X      fputc(j, fp);
X      fputc(j, fp);
X      fputc(j, fp);
X    }
X  }
X  else {
X    for (i=0; i<ColorMapSize; i++) {       /* write out Global colormap */
X      fputc(rmap[i], fp);
X      fputc(gmap[i], fp);
X      fputc(bmap[i], fp);
X    }
X  }
X
X  fputc( ',', fp );              /* image separator */
X
X  /* Write the Image header */
X  putword(LeftOfs, fp);
X  putword(TopOfs,  fp);
X  putword(Width,   fp);
X  putword(Height,  fp);
X  if (Interlace) fputc(0x40, fp);   /* Use Global Colormap, maybe Interlace */
X            else fputc(0x00, fp);
X
X  fputc(InitCodeSize, fp);
X  compress(InitCodeSize+1, fp, pic, w*h);
X
X  fputc(0,fp);                      /* Write out a Zero-length packet (EOF) */
X  fputc(';',fp);                    /* Write GIF file terminator */
X
X  return (0);
}
X
X
X
X
/******************************/
static void putword(w, fp)
int w;
FILE *fp;
{
X  /* writes a 16-bit integer in GIF order (LSB first) */
X  fputc(w & 0xff, fp);
X  fputc((w>>8)&0xff, fp);
}
X
X
X
X
/***********************************************************************/
X
X
static unsigned long cur_accum = 0;
static int           cur_bits = 0;
X
X
X
X
#define min(a,b)        ((a>b) ? b : a)
X
#define BITS    12
#define MSDOS    1
X
#define HSIZE  5003            /* 80% occupancy */
X
typedef unsigned char   char_type;
X
X
static int n_bits;                   /* number of bits/code */
static int maxbits = BITS;           /* user settable max # bits/code */
static int maxcode;                  /* maximum code, given n_bits */
static int maxmaxcode = 1 << BITS;   /* NEVER generate this */
X
#define MAXCODE(n_bits)     ( (1 << (n_bits)) - 1)
X
static  count_int      htab [HSIZE];
static  unsigned short codetab [HSIZE];
#define HashTabOf(i)   htab[i]
#define CodeTabOf(i)   codetab[i]
X
static int hsize = HSIZE;            /* for dynamic table sizing */
X
/*
X * To save much memory, we overlay the table used by compress() with those
X * used by decompress().  The tab_prefix table is the same size and type
X * as the codetab.  The tab_suffix table needs 2**BITS characters.  We
X * get this from the beginning of htab.  The output stack uses the rest
X * of htab, and contains characters.  There is plenty of room for any
X * possible stack (stack used to be 8000 characters).
X */
X
#define tab_prefixof(i) CodeTabOf(i)
#define tab_suffixof(i)        ((char_type *)(htab))[i]
#define de_stack               ((char_type *)&tab_suffixof(1<<BITS))
X
static int free_ent = 0;                  /* first unused entry */
X
/*
X * block compression parameters -- after all codes are used up,
X * and compression rate changes, start over.
X */
static int clear_flg = 0;
X
static long int in_count = 1;            /* length of input */
static long int out_count = 0;           /* # of codes output (for debugging) */
X
/*
X * compress stdin to stdout
X *
X * Algorithm:  use open addressing double hashing (no chaining) on the
X * prefix code / next character combination.  We do a variant of Knuth's
X * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
X * secondary probe.  Here, the modular division first probe is gives way
X * to a faster exclusive-or manipulation.  Also do block compression with
X * an adaptive reset, whereby the code table is cleared when the compression
X * ratio decreases, but after the table fills.  The variable-length output
X * codes are re-sized at this point, and a special CLEAR code is generated
X * for the decompressor.  Late addition:  construct the table according to
X * file size for noticeable speed improvement on small files.  Please direct
X * questions about this implementation to ames!jaw.
X */
X
static int g_init_bits;
static FILE *g_outfile;
X
static int ClearCode;
static int EOFCode;
X
X
/********************************************************/
static void compress(init_bits, outfile, data, len)
int   init_bits;
FILE *outfile;
byte *data;
int   len;
{
X  register long fcode;
X  register int i = 0;
X  register int c;
X  register int ent;
X  register int disp;
X  register int hsize_reg;
X  register int hshift;
X
X  /*
X   * Set up the globals:  g_init_bits - initial number of bits
X   *                      g_outfile   - pointer to output file
X   */
X  g_init_bits = init_bits;
X  g_outfile   = outfile;
X
X  /* initialize 'compress' globals */
X  maxbits = BITS;
X  maxmaxcode = 1<<BITS;
X  memset((char *) htab, 0, sizeof(htab));
X  memset((char *) codetab, 0, sizeof(codetab));
X  hsize = HSIZE;
X  free_ent = 0;
X  clear_flg = 0;
X  in_count = 1;
X  out_count = 0;
X  cur_accum = 0;
X  cur_bits = 0;
X
X
X  /*
X   * Set up the necessary values
X   */
X  out_count = 0;
X  clear_flg = 0;
X  in_count = 1;
X  maxcode = MAXCODE(n_bits = g_init_bits);
X
X  ClearCode = (1 << (init_bits - 1));
X  EOFCode = ClearCode + 1;
X  free_ent = ClearCode + 2;
X
X  char_init();
X  ent = *data++;  len--;
X
X  hshift = 0;
X  for ( fcode = (long) hsize;  fcode < 65536L; fcode *= 2L )
X    hshift++;
X  hshift = 8 - hshift;                /* set hash code range bound */
X
X  hsize_reg = hsize;
X  cl_hash( (count_int) hsize_reg);            /* clear hash table */
X
X  output(ClearCode);
X
X  while (len) {
X    c = *data++;  len--;
X    in_count++;
X
X    fcode = (long) ( ( (long) c << maxbits) + ent);
X    i = (((int) c << hshift) ^ ent);    /* xor hashing */
X
X    if ( HashTabOf (i) == fcode ) {
X      ent = CodeTabOf (i);
X      continue;
X    }
X
X    else if ( (long)HashTabOf (i) < 0 )      /* empty slot */
X      goto nomatch;
X
X    disp = hsize_reg - i;           /* secondary hash (after G. Knott) */
X    if ( i == 0 )
X      disp = 1;
X
probe:
X    if ( (i -= disp) < 0 )
X      i += hsize_reg;
X
X    if ( HashTabOf (i) == fcode ) {
X      ent = CodeTabOf (i);
X      continue;
X    }
X
X    if ( (long)HashTabOf (i) > 0 )
X      goto probe;
X
nomatch:
X    output(ent);
X    out_count++;
X    ent = c;
X
X    if ( free_ent < maxmaxcode ) {
X      CodeTabOf (i) = free_ent++; /* code -> hashtable */
X      HashTabOf (i) = fcode;
X    }
X    else
X      cl_block();
X  }
X
X  /* Put out the final code */
X  output(ent);
X  out_count++;
X  output(EOFCode);
}
X
X
/*****************************************************************
X * TAG( output )
X *
X * Output the given code.
X * Inputs:
X *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
X *              that n_bits =< (long)wordsize - 1.
X * Outputs:
X *      Outputs code to the file.
X * Assumptions:
X *      Chars are 8 bits long.
X * Algorithm:
X *      Maintain a BITS character long buffer (so that 8 codes will
X * fit in it exactly).  Use the VAX insv instruction to insert each
X * code in turn.  When the buffer fills up empty it and start over.
X */
X
static
unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
X                                  0x001F, 0x003F, 0x007F, 0x00FF,
X                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
X                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
X
static void output(code)
int code;
{
X  cur_accum &= masks[cur_bits];
X
X  if (cur_bits > 0)
X    cur_accum |= ((long)code << cur_bits);
X  else
X    cur_accum = code;
X
X  cur_bits += n_bits;
X
X  while( cur_bits >= 8 ) {
X    char_out( (unsigned int) (cur_accum & 0xff) );
X    cur_accum >>= 8;
X    cur_bits -= 8;
X  }
X
X  /*
X   * If the next entry is going to be too big for the code size,
X   * then increase it, if possible.
X   */
X
X  if (free_ent > maxcode || clear_flg) {
X
X    if( clear_flg ) {
X      maxcode = MAXCODE (n_bits = g_init_bits);
X      clear_flg = 0;
X    }
X    else {
X      n_bits++;
X      if ( n_bits == maxbits )
X    maxcode = maxmaxcode;
X      else
X    maxcode = MAXCODE(n_bits);
X    }
X  }
X
X  if( code == EOFCode ) {
X    /* At EOF, write the rest of the buffer */
X    while( cur_bits > 0 ) {
X      char_out( (unsigned int)(cur_accum & 0xff) );
X      cur_accum >>= 8;
X      cur_bits -= 8;
X    }
X
X    flush_char();
X
X    fflush( g_outfile );
X
X    if( ferror( g_outfile ) )
X    {    printf ("unable to write GIF file\n");
X        exit (1);
X    }
X  }
}
X
X
/********************************/
static void cl_block ()             /* table clear for block compress */
{
X  /* Clear out the hash table */
X
X  cl_hash ( (count_int) hsize );
X  free_ent = ClearCode + 2;
X  clear_flg = 1;
X
X  output(ClearCode);
}
X
X
/********************************/
static void cl_hash(hsize)          /* reset code table */
register count_int hsize;
{
X  register count_int *htab_p = htab+hsize;
X  register long i;
X  register long m1 = -1;
X
X  i = hsize - 16;
X  do {                            /* might use Sys V memset(3) here */
X    *(htab_p-16) = m1;
X    *(htab_p-15) = m1;
X    *(htab_p-14) = m1;
X    *(htab_p-13) = m1;
X    *(htab_p-12) = m1;
X    *(htab_p-11) = m1;
X    *(htab_p-10) = m1;
X    *(htab_p-9) = m1;
X    *(htab_p-8) = m1;
X    *(htab_p-7) = m1;
X    *(htab_p-6) = m1;
X    *(htab_p-5) = m1;
X    *(htab_p-4) = m1;
X    *(htab_p-3) = m1;
X    *(htab_p-2) = m1;
X    *(htab_p-1) = m1;
X    htab_p -= 16;
X  } while ((i -= 16) >= 0);
X
X  for ( i += 16; i > 0; i-- )
X    *--htab_p = m1;
}
X
X
/******************************************************************************
X *
X * GIF Specific routines
X *
X ******************************************************************************/
X
/*
X * Number of characters so far in this 'packet'
X */
static int a_count;
X
/*
X * Set up the 'byte output' routine
X */
static void char_init()
{
X    a_count = 0;
}
X
/*
X * Define the storage for the packet accumulator
X */
static char accum[ 256 ];
X
/*
X * Add a character to the end of the current packet, and if it is 254
X * characters, flush the packet to disk.
X */
static void char_out(c)
int c;
{
X  accum[ a_count++ ] = c;
X  if( a_count >= 254 )
X    flush_char();
}
X
/*
X * Flush the packet to disk, and reset the accumulator
X */
static void flush_char()
{
X  if( a_count > 0 ) {
X    fputc( a_count, g_outfile );
X    fwrite( accum, 1, a_count, g_outfile );
X    a_count = 0;
X  }
}
SHAR_EOF
chmod 0644 writegif.c ||
echo 'restore of writegif.c failed'
Wc_c="`wc -c < 'writegif.c'`"
test 17660 -eq "$Wc_c" ||
    echo 'writegif.c: original size 17660, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= xmandel.man ==============
if test -f 'xmandel.man' -a X"$1" != X"-c"; then
    echo 'x - skipping xmandel.man (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting xmandel.man (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'xmandel.man' &&
.TH XMANDEL X " 25 April 1992" "X Version 11"
.UC 4
.SH NAME
xmandel \- X11 interface to the Mandelbrot and Julia sets
.SH SYNOPSIS
xmandel [-display display]
.SH DESCRIPTION
.PP
.IR Xmandel
is a user friendly interface for generating and colouring Mandelbrot and Julia sets.
It initially comes up with with eleven or so command buttons,
which are described below, for controlling the execution.
A Mandelbrot set is drawn in the window of the initial form
when the \fImandel\fP button is selected.
A separate window is created for drawing the Julia sets.
.SH THEORY
Let z0 be a number in the complex plane (x + yi).
Choose a complex constant C.
Calculate z1 = z0 ** 2 + C.
Repeat this recursively, so that z2 = z1 ** 2 + C,
z3 = z2 ** 2 + C and so on.
z[n] will either tend to infinity or zero, depending
on its initial value and the constant C.
Specifically if the absolute value of z[n],
expressed as |z| = sqrt(x**2 + y**2) is greater than 2,
then the recursive formula will diverge.
.PP
So, to calculate a Julia set, take each point near (0,0i),
and use the formula z = z**2 + C recursively.
The Julia set is the set of points for which
z = z**2 + C would iterate indefinitely for the constant C.
Pixels, which represent numbers in the complex plane,
are set to the number of iterations before |z| exceeds 2.
This then becomes an index into the hardware colormap.
Each color then represents the number of iterations before
divergence is detected.
.PP
To calculate a Mandelbrot set, again take each point near (0,0i),
use the same formula z = z**2 + C recursively.
This time let C be the initial value of the point itself (C = z0).
Rather than having the same C for every point in the complex plane
as in Julia set calculations,
C is different for each point in the plane.
Again let the pixel value be the number of iterations
before |z| exceeds 2.
.PP
On monochrome displays, the pixel value is set to 1
if the iteration count is 64, otherwise 0.
.PP
Mandelbrot sets and Julia sets are obviously closely
related as can be seen from the similarity of their
respective formulas.
If the constant C is chosen from the interior of the
Mandelbrot set, then the Julia set calculated from that
constant C will be connected, that is have no gaps or discontinuities.
If the constant C is chosen from outside the Mandelbrot set,
the Julia set will be disconnected, more like grains of dust (Fatou clouds).
If the constant C is chosen from the border of the Mandelbrot set,
then the Julia set will be more convoluted.
Given this relationship between points in the Mandelbrot set
and the Julia set generated,
XXmandel provides user selection of the constant C
by mouse selection in the Mandelbrot window.
.SH BUTTONS
To control execution of the calculations, various buttons
are provided.  The buttons are somewhat different between
the Athena Widget and Motif Widget implementations.
The buttons are:
.TP
.B mandel
Calculates a Mandelbrot set from (-2.25, -1.5) to (1.0, 1.5)
and display it in the window provided.
X
Pressing a mouse button with the cursor in
the drawing window terminates the calculations.
.TP
.B julia
Calculates a Julia set.
The user is required to select a point inside the Mandelbrot window using
the left mouse button as the constant C for the Julia set calculation.
It will open a new window if needed.
The Julia set is centered around (0,0),
going from (-1.5, -1.5) to (1.5, 1.5).
Julia set points can be selected from zoomed in Mandelbrot windows as well.
Beware of selecting points outside the Mandelbrot window.
X
Pressing a mouse button in the drawing window terminates the calculations.
.TP
.B Image
After the Mandelbrot or Julia set is generated, the
.I Image
button identifies which set is to be used for various manipluations
such as
.I zoom
or
.I +colour.
If this button is pressed, the active image toggles between "Mandel"
and "Julia" to identify the set that is to be manipulated.
X
The Motif implementation uses radio buttons for this toggle.
.TP
.B zoom
In order to zoom in on a given area in the Mandelbrot or Julia set,
a zoom button is provided.
The area to be zoomed in on is selected with the left mouse button.
Left button down begins the selection,
dragging with left button down draws a rubber banded box to show the zoom area,
and left button up begins the calculation.
You can zoom in on a zoomed in area until you reach
the limits of the precision of your hardware.
Selecting a zoom area that crosses a window border doesn't work.
X
To a certain degree, the zoom rubber banded box may be moved, enlarged
and otherwise resized by careful use of the mouse.
X
Zoom requests less than 5 pixels wide are ignored.  The zoom
request may be terminated by pressing button 2 or 3 while creating
the rubber band.
X
If the Motif version is used, the zoom coordinates may be specified
in the
.I ZOOM COORDINATES
dialogue boxes.  After the desired coodinates are enterd, pressing the
.I zoom
button activates the drawing.
.TP
.B unzoom
Return to previous zoom.
Note that you can zoom all the way out by selecting the \fImandel\fP button.
.TP
.B recalc
Recompute the set at the current coordinates.  This is useful
to redisplay the current image after the set's window has been
resized.
X
If the Motif version is used, the coordinates for recalculation may be
modified in the
.I ZOOM COORDINATES
dialogue boxes.
.TP
.B colour
The
.I colour
button selects colour rotation value to be applied when the
.I +colour
or
.I -colour
buttons are used.
X
The "colour step" value is added to each pixel colour before redisplay.
The effectively rotates the image through the available colour map.
By default, the rotation value is set to the number of bit planes: for
an 8 bit display, the rotation value is 8; for a 2 bit display, the rotation
value is 2; etc.
X
The selected set and rotation value is "remembered" for use with the
.I \+colour
and
.I \-colour
buttons.
X
The "rotate" dialogue box in the Motif edition is used to set
the colour rotation value.
.TP
.B \+colour
The default set
is rotated in a positive sense by adding the previously
specified colour rotation value to all pixels.
X
An interesting "colour zoom" effect can be achieved by first setting the
colour rotation value to 1 and rapidly pressing the
.I \+colour
or
.I \-colour
button.
.TP
.B \-colour
The default set
is rotated in a negative sense by subtracting the previously
specified colour rotation value.  In effect,
.I \-colour
undoes the effect of
.I \+colour.
.TP
.B gif
Either the Mandelbrot or Julia image may be captured to a GIF file.
The Mandelbrot image is saved in the specified file name if the
.I Mandelbrot
radio button is pressed, the Julia image is saved if the
.I Julia
radio button is pressed.
X
For the Motif implementation, the desired file name is entered
into the
.I Gif file
dialogue box.  Pressing the
.I Save
button saves the default image (set by the radio buttons)
as a gif file.
.TP
.B remove
Remove the Julia set window.  It will be recreated if another
Julia display is requested.
X
This button is not used in the Motif edition: the Julia set
may be removed by closing the Julia window.
.TP
.B quit
This causes \fIxmandel\fP to exit.
.SH MOTIF NOTES
The
.I default
set is selected by the radio buttons
.I mandel
or
.I julia.
The default set selection is used when the
.I recalc, \+colour,
.I \-colour,
or other buttons are pressed.  For example, if the
.I julia
radio button is selected, the
.I recalc
button will recompute the Julia set.  The Mandelbrot set is
unaffected.
X
The additional dialog boxes allow you to manually provide the
Mandelbrot zoom coordinates. Changes to the
.I POINT COORDINATES
are not allowed.
.SH BUGS
The system works only with 1, 2, 4, or 8 bit displays: 24 bit
display systems are not supported.
.PP
Exposure events are examined after the generation of every 4th
image scan line: there is some delay after and exposure event
before the image is actually refreshed.
.PP
XXmandel cannot manipluate the colour map.
.PP
Performance is slow on workstations,
especially workstations without floating point hardware.  Alternatively,
extensive use of
.I xmandel
may justify the purchase of a more powerful system.
.SH AUTHOR
John L. Freeman ([e-mail])
.nf
X
Changes for gif, Motif and SysV X11-R4:
X       Tony Field ([e-mail])
.fi
SHAR_EOF
chmod 0644 xmandel.man ||
echo 'restore of xmandel.man failed'
Wc_c="`wc -c < 'xmandel.man'`"
test 8293 -eq "$Wc_c" ||
    echo 'xmandel.man: original size 8293, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= xmandel.mot.ad ==============
if test -f 'xmandel.mot.ad' -a X"$1" != X"-c"; then
    echo 'x - skipping xmandel.mot.ad (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting xmandel.mot.ad (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'xmandel.mot.ad' &&
! Translate buttons so that they remain depressed duing the
! course of calculations or processing.
X
xmandel.name.mandel.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.julia.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.recalc.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.unzoom.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.+colour.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.-colour.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.Save.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
X
xmandel.name.zoom.Translations:  #override \
X        <Btn1Down>: Arm() \n \
X        <Btn1Up>:   ArmAndActivate()
SHAR_EOF
chmod 0644 xmandel.mot.ad ||
echo 'restore of xmandel.mot.ad failed'
Wc_c="`wc -c < 'xmandel.mot.ad'`"
test 929 -eq "$Wc_c" ||
    echo 'xmandel.mot.ad: original size 929, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
rm -f _shar_seq_.tmp
echo You have unpacked the last part
exit 0
--
--
Molecular Simulations, Inc.            mail: [e-mail]
796 N. Pastoria Avenue                uucp: uunet!dcmartin
Sunnyvale, California 94086            at&t: 408/522-9236