Fractal Creations (Second Edition)/FRACTALS_2E.iso/xfract/xfsrc

Text File | 1993-10-28 | 2MB | 75,096 lines

#!/bin/sh
# This is a shell archive (shar 3.24)
# made 10/29/1993 06:19 UTC by [e-mail]
# Source directory /user6/shirriff/rsrch/fractint
#
# existing files WILL be overwritten
#
# This shar contains:
# length  mode       name
# ------ ---------- ------------------------------------------
#  10094 -rw-r--r-- 3d.c
#  84436 -rw-r--r-- calcfrac.c
#  67637 -rw-r--r-- cmdfiles.c
#  13232 -rw-r--r-- decoder.c
#  80381 -rw-r--r-- editpal.c
#  28368 -rw-r--r-- encoder.c
#   2503 -rw-r--r-- f16.c
#  30883 -rw-r--r-- fracsubr.c
#  48702 -rw-r--r-- fractalp.c
# 101275 -rw-r--r-- fractals.c
#  54603 -rw-r--r-- fractint.c
#   8871 -rw-r--r-- gifview.c
#  83237 -rw-r--r-- hc.c
#   2946 -rw-r--r-- hcmplx.c
#  36787 -rw-r--r-- help.c
#   3156 -rw-r--r-- intro.c
#  12009 -rw-r--r-- jb.c
#  35541 -rw-r--r-- jiim.c
#  77259 -rw-r--r-- line3d.c
#  14560 -rw-r--r-- loadfdos.c
#  22666 -rw-r--r-- loadfile.c
#   2268 -rw-r--r-- loadmap.c
#  66158 -rw-r--r-- lorenz.c
#  21423 -rw-r--r-- lsys.c
#  56787 -rw-r--r-- miscfrac.c
#  56485 -rw-r--r-- miscovl.c
#  27230 -rw-r--r-- miscres.c
#  11132 -rw-r--r-- mpmath_c.c
#  54067 -rw-r--r-- parser.c
#  35051 -rw-r--r-- parserfp.c
#  13679 -rw-r--r-- plot3d.c
#  44938 -rw-r--r-- printer.c
#  63669 -rw-r--r-- prompts1.c
#  49042 -rw-r--r-- prompts2.c
#  51622 -rw-r--r-- realdos.c
#  14636 -rw-r--r-- rotate.c
#   8468 -rw-r--r-- slideshw.c
#  19635 -rw-r--r-- targa.c
#   2048 -rw-r--r-- testpt.c
#   1504 -rw-r--r-- tgaview.c
#   7735 -rw-r--r-- tp3d.c
#  11727 -rw-r--r-- tplus.c
#  18354 -rw-r--r-- zoom.c
#  19765 -rw-r--r-- fractint.h
#   5675 -rw-r--r-- fractype.h
#   6871 -rw-r--r-- fmath.h
#   4549 -rw-r--r-- port.h
#  15703 -rw-r--r-- helpcom.h
#   7593 -rw-r--r-- helpdefs.h
#   7413 -rw-r--r-- mpmath.h
#   8664 -rw-r--r-- targa.h
#    618 -rw-r--r-- targa_lc.h
#   2388 -rw-r--r-- tplus.h
#  33264 -rw-r--r-- prototyp.h
#  17535 -rw-r--r-- fractsrc.doc
#   2610 -rw-r--r-- debugfla.doc
#  17114 -rw-r--r-- hc.doc
#    381 -rw-r--r-- calcmand.c
#   3910 -rw-r--r-- calmanfp.c
#   5594 -rw-r--r-- diskvidu.c
#   3671 -rw-r--r-- fpu087.c
#    589 -rw-r--r-- fracsuba.c
#  19394 -rw-r--r-- general.c
#   8947 -rw-r--r-- printera.c
#    295 -rw-r--r-- tplus_a.c
#  15972 -rw-r--r-- video.c
#   8340 -rw-r--r-- unix.c
#  46415 -rw-r--r-- unixscr.c
#   3507 -rw-r--r-- unix.h
#  10830 -rw-r--r-- Makefile
#   4195 -rw-r--r-- versions
#  76566 -rw-r--r-- help.src
# 116316 -rw-r--r-- help2.src
#  64400 -rw-r--r-- help3.src
#  79101 -rw-r--r-- help4.src
#  93177 -rw-r--r-- help5.src
#
if touch 2>&1 | fgrep '[-amc]' > /dev/null
 then TOUCH=touch
 else TOUCH=true
fi
# ============= 3d.c ==============
echo "x - extracting 3d.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > 3d.c &&
X/*
XA word about the 3D library. Even though this library supports
Xthree dimensions, the matrices are 4x4 for the following reason.
XWith normal 3 dimensional vectors, translation is an ADDITION,
Xand rotation is a MULTIPLICATION. A vector {x,y,z} is represented
Xas a 4-tuple {x,y,z,1}. It is then possible to define a 4x4
Xmatrix such that multiplying the vector by the matrix translates
Xthe vector. This allows combinations of translation and rotation
Xto be obtained in a single matrix by multiplying a translation
Xmatrix and a rotation matrix together. Note that in the code,
Xvectors have three components; since the fourth component is
Xalways 1, that value is not included in the vector variable to
Xsave space, but the routines make use of the fourth component
X(see vec_mult()). Similarly, the fourth column of EVERY matrix is
Xalways
X     0
X     0
X     0
X     1
Xbut currently the C version of a matrix includes this even though
Xit could be left out of the data structure and assumed in the
Xroutines. Vectors are ROW vectors, and are always multiplied with
Xmatrices FROM THE LEFT (e.g. vector*matrix). Also note the order
Xof indices of a matrix is matrix[row][column], and in usual C
Xfashion, numbering starts with 0.
X
XTRANSLATION MATRIX =  1     0      0    0
X              0     1      0    0
X              0     0      1    0
X              Tx    Ty      Tz    1
X
XSCALE MATRIX =          Sx    0      0    0
X              0     Sy      0    0
X              0     0      Sz    0
X              0     0      0    1
X
XRotation about x axis i degrees:
XROTX(i) =        1     0     0      0
X              0   cosi  sini    0
X              0  -sini  cosi    0
X              0     0      0    1
X
XRotation about y axis i degrees:
XROTY(i) =          cosi    0  -sini    0
X              0     1      0    0
X            sini    0   cosi    0
X              0     0      0    1
X
XRotation about z axis i degrees:
XROTZ(i) =          cosi  sini    0     0
X           -sini  cosi    0     0
X              0     0      1    0
X              0     0      0    1
X
X              --  Tim Wegner  April 22, 1989
X*/
X
X#include <stdio.h>
X#include <float.h>
X#include <string.h>
X#include "fractint.h"
X#include "prototyp.h"
Xextern int overflow;
Xextern int bad_value;
X
X/* initialize a matrix and set to identity matrix
X   (all 0's, 1's on diagonal) */
Xvoid identity(MATRIX m)
X{
X   int i,j;
X   for(i=0;i<CMAX;i++)
X   for(j=0;j<RMAX;j++)
X      if(i==j)
X     m[j][i] = 1.0;
X      else
X      m[j][i] = 0.0;
X}
X
X/* Multiply two matrices */
Xvoid mat_mul(MATRIX mat1, MATRIX mat2, MATRIX mat3)
X{
X     /* result stored in MATRIX new to avoid problems
X    in case parameter mat3 == mat2 or mat 1 */
X     MATRIX new;
X     int i,j;
X     for(i=0;i<4;i++)
X     for(j=0;j<4;j++)
X    new[j][i] =  mat1[j][0]*mat2[0][i]+
X             mat1[j][1]*mat2[1][i]+
X             mat1[j][2]*mat2[2][i]+
X             mat1[j][3]*mat2[3][i];
X     memcpy(mat3,new,sizeof(new));
X}
X
X/* multiply a matrix by a scalar */
Xvoid scale (double sx, double sy, double sz, MATRIX m)
X{
X   MATRIX scale;
X   identity(scale);
X   scale[0][0] = sx;
X   scale[1][1] = sy;
X   scale[2][2] = sz;
X   mat_mul(m,scale,m);
X}
X
X/* rotate about X axis    */
Xvoid xrot (double theta, MATRIX m)
X{
X   MATRIX rot;
X   double sintheta,costheta;
X   sintheta = sin(theta);
X   costheta = cos(theta);
X   identity(rot);
X   rot[1][1] = costheta;
X   rot[1][2] = -sintheta;
X   rot[2][1] = sintheta;
X   rot[2][2] = costheta;
X   mat_mul(m,rot,m);
X}
X
X/* rotate about Y axis    */
Xvoid yrot (double theta, MATRIX m)
X{
X   MATRIX rot;
X   double sintheta,costheta;
X   sintheta = sin(theta);
X   costheta = cos(theta);
X   identity(rot);
X   rot[0][0] = costheta;
X   rot[0][2] = sintheta;
X   rot[2][0] = -sintheta;
X   rot[2][2] = costheta;
X   mat_mul(m,rot,m);
X}
X
X/* rotate about Z axis    */
Xvoid zrot (double theta, MATRIX m)
X{
X   MATRIX rot;
X   double sintheta,costheta;
X   sintheta = sin(theta);
X   costheta = cos(theta);
X   identity(rot);
X   rot[0][0] = costheta;
X   rot[0][1] = -sintheta;
X   rot[1][0] = sintheta;
X   rot[1][1] = costheta;
X   mat_mul(m,rot,m);
X}
X
X/* translate  */
Xvoid trans (double tx, double ty, double tz, MATRIX m)
X{
X   MATRIX trans;
X   identity(trans);
X   trans[3][0] = tx;
X   trans[3][1] = ty;
X   trans[3][2] = tz;
X   mat_mul(m,trans,m);
X}
X
X/* cross product  - useful because cross is perpendicular to v and w */
Xint cross_product (VECTOR v, VECTOR w, VECTOR cross)
X{
X   VECTOR tmp;
X   tmp[0] =  v[1]*w[2] - w[1]*v[2];
X   tmp[1] =  w[0]*v[2] - v[0]*w[2];
X   tmp[2] =  v[0]*w[1] - w[0]*v[1];
X   cross[0] = tmp[0];
X   cross[1] = tmp[1];
X   cross[2] = tmp[2];
X   return(0);
X}
X
X/* cross product integer arguments (not fudged) */
X/*** pb, unused
Xint icross_product (IVECTOR v, IVECTOR w, IVECTOR cross)
X{
X   IVECTOR tmp;
X   tmp[0] =  v[1]*w[2] - w[1]*v[2];
X   tmp[1] =  w[0]*v[2] - v[0]*w[2];
X   tmp[2] =  v[0]*w[1] - w[0]*v[1];
X   cross[0] = tmp[0];
X   cross[1] = tmp[1];
X   cross[2] = tmp[2];
X   return(0);
X}
X***/
X
X/* normalize a vector to length 1 */
Xnormalize_vector(VECTOR v)
X{
X    double vlength;
X    vlength = dot_product(v,v);
X
X    /* bailout if zero vlength */
X    if(vlength < FLT_MIN || vlength > FLT_MAX)
X       return(-1);
X    vlength = sqrt(vlength);
X    if(vlength < FLT_MIN)
X       return(-1);
X
X    v[0] /= vlength;
X    v[1] /= vlength;
X    v[2] /= vlength;
X    return(0);
X}
X
X/* multiply source vector s by matrix m, result in target t */
X/* used to apply transformations to a vector */
Xint vmult(s,m,t)
XVECTOR s,t;
XMATRIX m;
X{
X   VECTOR tmp;
X   int i,j;
X   for(j=0;j<CMAX-1;j++)
X   {
X      tmp[j] = 0.0;
X      for(i=0;i<RMAX-1;i++)
X     tmp[j] += s[i]*m[i][j];
X      /* vector is really four dimensional with last component always 1 */
X      tmp[j] += m[3][j];
X   }
X   /* set target = tmp. Necessary to use tmp in case source = target */
X   memcpy(t,tmp,sizeof(tmp));
X   return(0);
X}
X
X/* multiply vector s by matrix m, result in s */
X/* use with a function pointer in line3d.c */
X/* must coordinate calling conventions with */
X/* mult_vec_iit in general.asm */
Xvoid mult_vec_c(s)
XVECTOR s;
X{
X   extern MATRIX m;
X   VECTOR tmp;
X   int i,j;
X   for(j=0;j<CMAX-1;j++)
X   {
X      tmp[j] = 0.0;
X      for(i=0;i<RMAX-1;i++)
X     tmp[j] += s[i]*m[i][j];
X      /* vector is really four dimensional with last component always 1 */
X      tmp[j] += m[3][j];
X   }
X   /* set target = tmp. Necessary to use tmp in case source = target */
X   memcpy(s,tmp,sizeof(tmp));
X}
X
X/* perspective projection of vector v with respect to viewpont vector view */
Xperspective(VECTOR v)
X{
X   extern VECTOR view;
X   double denom;
X   denom = view[2] - v[2];
X
X   if(denom >= 0.0)
X   {
X      v[0] = bad_value;   /* clipping will catch these values */
X      v[1] = bad_value;   /* so they won't plot values BEHIND viewer */
X      v[2] = bad_value;
X      return(-1);
X   }
X   v[0] = (v[0]*view[2] - view[0]*v[2])/denom;
X   v[1] = (v[1]*view[2] - view[1]*v[2])/denom;
X
X   /* calculation of z if needed later */
X   /* v[2] =  v[2]/denom;*/
X   return(0);
X}
X
X/* long version of vmult and perspective combined for speed */
Xlongvmultpersp(s, m, t0, t, lview, bitshift)
XLVECTOR s;     /* source vector */
XLMATRIX m;     /* transformation matrix */
XLVECTOR t0;     /* after transformation, before persp */
XLVECTOR t;     /* target vector */
XLVECTOR lview;     /* perspective viewer coordinates */
Xint bitshift;     /* fixed point conversion bitshift */
X{
X   LVECTOR tmp;
X   int i,j, k;
X   overflow = 0;
X   k = CMAX-1;            /* shorten the math if non-perspective and non-illum */
X   if (lview[2] == 0 && t0[0] == 0) k--;
X
X   for(j=0;j<k;j++)
X   {
X      tmp[j] = 0;
X      for(i=0;i<RMAX-1;i++)
X     tmp[j] += multiply(s[i],m[i][j],bitshift);
X      /* vector is really four dimensional with last component always 1 */
X      tmp[j] += m[3][j];
X   }
X   if(t0[0]) /* first component of  t0 used as flag */
X   {
X      /* faster than for loop, if less general */
X      t0[0] = tmp[0];
X      t0[1] = tmp[1];
X      t0[2] = tmp[2];
X   }
X   if (lview[2] != 0)        /* perspective 3D */
X   {
X
X      LVECTOR tmpview;
X      long denom;
X
X      denom = lview[2] - tmp[2];
X      if (denom >= 0)        /* bail out if point is "behind" us */
X      {
X       t[0] = bad_value;
X       t[0] = t[0]<<bitshift;
X       t[1] = t[0];
X       t[2] = t[0];
X       return(-1);
X      }
X
X      /* doing math in this order helps prevent overflow */
X      tmpview[0] = divide(lview[0],denom,bitshift);
X      tmpview[1] = divide(lview[1],denom,bitshift);
X      tmpview[2] = divide(lview[2],denom,bitshift);
X
X      tmp[0] = multiply(tmp[0], tmpview[2], bitshift) -
X           multiply(tmpview[0], tmp[2], bitshift);
X
X      tmp[1] = multiply(tmp[1], tmpview[2], bitshift) -
X           multiply(tmpview[1], tmp[2], bitshift);
X
X      /* z coordinate if needed       */
X      /* tmp[2] = divide(lview[2],denom);  */
X   }
X
X   /* set target = tmp. Necessary to use tmp in case source = target */
X   /* faster than for loop, if less general */
X   t[0] = tmp[0];
X   t[1] = tmp[1];
X   t[2] = tmp[2];
X   return(overflow);
X}
X
X/* Long version of perspective. Because of use of fixed point math, there
X   is danger of overflow and underflow */
Xlongpersp(LVECTOR lv, LVECTOR lview, int bitshift)
X{
X   LVECTOR tmpview;
X   long denom;
X   overflow = 0;
X   denom = lview[2] - lv[2];
X   if (denom >= 0)        /* bail out if point is "behind" us */
X   {
X    lv[0] = bad_value;
X    lv[0] = lv[0]<<bitshift;
X    lv[1] = lv[0];
X    lv[2] = lv[0];
X    return(-1);
X   }
X
X   /* doing math in this order helps prevent overflow */
X   tmpview[0] = divide(lview[0],denom,bitshift);
X   tmpview[1] = divide(lview[1],denom,bitshift);
X   tmpview[2] = divide(lview[2],denom,bitshift);
X
X   lv[0] = multiply(lv[0], tmpview[2], bitshift) -
X       multiply(tmpview[0], lv[2], bitshift);
X
X   lv[1] = multiply(lv[1], tmpview[2], bitshift) -
X       multiply(tmpview[1], lv[2], bitshift);
X
X   /* z coordinate if needed           */
X   /* lv[2] = divide(lview[2],denom);  */
X   return(overflow);
X}
X
Xint longvmult(LVECTOR s,LMATRIX m,LVECTOR t,int bitshift)
X{
X   LVECTOR tmp;
X   int i,j, k;
X   overflow = 0;
X   k = CMAX-1;
X
X   for(j=0;j<k;j++)
X   {
X      tmp[j] = 0;
X      for(i=0;i<RMAX-1;i++)
X     tmp[j] += multiply(s[i],m[i][j],bitshift);
X      /* vector is really four dimensional with last component always 1 */
X      tmp[j] += m[3][j];
X   }
X
X   /* set target = tmp. Necessary to use tmp in case source = target */
X   /* faster than for loop, if less general */
X   t[0] = tmp[0];
X   t[1] = tmp[1];
X   t[2] = tmp[2];
X   return(overflow);
X}
SHAR_EOF
$TOUCH -am 1028230093 3d.c &&
chmod 0644 3d.c ||
echo "restore of 3d.c failed"
set `wc -c 3d.c`;Wc_c=$1
if test "$Wc_c" != "10094"; then
    echo original size 10094, current size $Wc_c
fi
# ============= calcfrac.c ==============
echo "x - extracting calcfrac.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > calcfrac.c &&
X/*
XCALCFRAC.C contains the high level ("engine") code for calculating the
Xfractal images (well, SOMEBODY had to do it!).
XOriginal author Tim Wegner, but just about ALL the authors have contributed
XSOME code to this routine at one time or another, or contributed to one of
Xthe many massive restructurings.
XThis module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
XThe following modules work very closely with CALCFRAC.C:
X  FRACTALS.C    the fractal-specific code for escape-time fractals.
X  FRACSUBR.C    assorted subroutines belonging mainly to calcfrac.
X  CALCMAND.ASM    fast Mandelbrot/Julia integer implementation
XAdditional fractal-specific modules are also invoked from CALCFRAC:
X  LORENZ.C    engine level and fractal specific code for attractors.
X  JB.C        julibrot logic
X  PARSER.C    formula fractals
X  and more
X -------------------------------------------------------------------- */
X
X#include <stdio.h>
X#include <string.h>
X#include <stdlib.h>
X#include <float.h>
X#include <limits.h>
X#ifndef XFRACT
X#include <dos.h>
X#endif
X#include <limits.h>
X#include "fractint.h"
X#include "fractype.h"
X#include "mpmath.h"
X#include "targa_lc.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic void perform_worklist(void);
Xstatic int  OneOrTwoPass(void);
Xstatic int  _fastcall StandardCalc(int);
Xstatic int  _fastcall potential(double,int);
Xstatic void decomposition(void);
Xstatic int  bound_trace_main(void);
Xstatic void step_col_row(void);
Xstatic int  _fastcall boundary_trace(int,int);
Xstatic int  _fastcall calc_xy(int,int);
Xstatic int  _fastcall fillseg1(int,int,int,int);
Xstatic int  _fastcall fillseg(int,int,int,int);
Xstatic void _fastcall reverse_string(BYTE *,BYTE *,int);
Xstatic int  solidguess(void);
Xstatic int  _fastcall guessrow(int,int,int);
Xstatic void _fastcall plotblock(int,int,int,int);
Xstatic void _fastcall setsymmetry(int,int);
Xstatic int  _fastcall xsym_split(int,int);
Xstatic int  _fastcall ysym_split(int,int);
Xstatic void set_Plasma_palette(void);
Xstatic U16 _fastcall adjust(int xa,int ya,int x,int y,int xb,int yb);
Xstatic void _fastcall subDivide(int x1,int y1,int x2,int y2);
Xstatic int _fastcall new_subD (int x1,int y1,int x2,int y2, int recur);
Xstatic void verhulst(void);
Xstatic void Bif_Period_Init(void);
Xstatic int  _fastcall Bif_Periodic(int);
Xstatic void set_Cellular_palette(void);
X
X/**CJLT new function prototypes: */
Xstatic int tesseral(void);
Xstatic int _fastcall tesschkcol(int,int,int);
Xstatic int _fastcall tesschkrow(int,int,int);
Xstatic int _fastcall tesscol(int,int,int);
Xstatic int _fastcall tessrow(int,int,int);
X/* added for testing autologmap() */
Xstatic int autologmap(void);
X
Xextern _CMPLX initorbit;
Xextern char useinitorbit;
X_LCMPLX linitorbit;
Xextern int showdot;
Xextern unsigned int decoderline[];
Xextern int overflow;
Xlong lmagnitud, llimit, llimit2, lclosenuff, l16triglim;
X_CMPLX init,tmp,old,new,saved;
Xextern int biomorph,usr_biomorph;
Xextern _LCMPLX linit;
Xextern int basin;
Xextern int cpu;
Xextern char savename[80];   /* save files using this name */
Xextern int resave_flag;
Xextern int started_resaves;
Xextern int dotmode;
Xextern int save_release;    /* use this to maintain compatibility */
X
Xint color, oldcolor, row, col, passes;
Xint realcolor;
Xint iterations, invert;
Xdouble f_radius,f_xcenter, f_ycenter; /* for inversion */
Xextern double far *dx0, far *dy0;
Xextern double far *dx1, far *dy1;
X
Xextern int LogFlag;
Xextern BYTE far *LogTable;
Xextern int rangeslen;
Xextern int far *ranges;
X
Xvoid (_fastcall *plot)(int,int,int) = putcolor;
Xtypedef void (_fastcall *PLOT)(int,int,int);
X
Xextern double inversion[];        /* inversion radius, f_xcenter, f_ycenter */
Xextern int    xdots, ydots;        /* coordinates of dots on the screen  */
Xextern int    sxdots,sydots;
Xextern int    sxoffs,syoffs;
Xextern int    colors;         /* maximum colors available */
Xextern int    andcolor;        /* colors-1         */
Xextern int    inside;         /* "inside" color to use    */
Xextern int    fillcolor;         /* "fillcolor" color to use    */
Xextern int    outside;        /* "outside" color to use   */
Xextern int    finattract;
Xdouble        min_orbit;        /* orbit value closest to origin */
Xint        min_index;        /* iteration of min_orbit */
Xextern int    maxit;            /* try this many iterations */
Xextern int    fractype;        /* fractal type */
Xextern char    stdcalcmode;        /* '1', '2', 'g', 'b' */
Xextern int    debugflag;        /* for debugging purposes */
Xextern    int    diskvideo;        /* for disk-video klooges */
Xextern int    calc_status;        /* status of calculations */
Xextern long    calctime;        /* total calc time for image */
X
Xextern int rflag, rseed;
Xextern int decomp[];
Xextern int distest,distestwidth;
X
Xextern double    param[];        /* parameters */
Xextern int    potflag;        /* potential enabled? */
Xextern double    potparam[];        /* potential parameters */
Xextern int    pot16bit;        /* store 16bit continuous potential */
Xextern long    far *lx0, far *ly0; /* X, Y points */
Xextern long    far *lx1, far *ly1; /* X, Y points */
Xextern long    fudge;            /* fudge factor (2**n) */
Xextern int    bitshift;        /* bit shift for fudge */
Xextern long    delmin;         /* for periodicity checking */
X
Xextern double xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* corners */
Xextern long   xmin, xmax, ymin, ymax;           /* integer equivs */
Xextern long   delx,dely;               /* X, Y increments */
Xextern double delxx,delxx2,delyy,delyy2;
Xdouble deltaX, deltaY;
Xdouble magnitude, rqlim, rqlim2, rqlim_save;
Xextern _CMPLX parm,parm2;
Xint (*calctype)();
Xdouble closenuff;
Xint pixelpi; /* value of pi in pixels */
Xunsigned long lm;        /* magnitude limit (CALCMAND) */
Xextern long linitx,linity;    /* in calcmand */
Xextern unsigned long savedmask; /* in calcmand */
Xextern int TranspSymmetry;
X
X/* ORBIT variables */
Xint    show_orbit;            /* flag to turn on and off */
Xint    orbit_ptr;            /* pointer into save_orbit array */
Xint far *save_orbit;            /* array to save orbit values */
Xint    orbit_color=15;         /* XOR color */
X
Xint    ixstart, ixstop, iystart, iystop;    /* start, stop here */
Xint    symmetry;       /* symmetry flag */
Xint    reset_periodicity; /* nonzero if escape time pixel rtn to reset */
Xint    kbdcount, max_kbdcount;    /* avoids checking keyboard too often */
X
Xextern    int    integerfractal;     /* TRUE if fractal uses integer math */
X
Xchar far *resume_info = NULL;        /* pointer to resume info if allocated */
Xint resuming;                /* nonzero if resuming after interrupt */
Xint num_worklist;            /* resume worklist for standard engine */
Xstruct workliststuff worklist[MAXCALCWORK];
Xint xxstart,xxstop;            /* these are same as worklist, */
Xint yystart,yystop,yybegin;        /* declared as separate items  */
Xint workpass,worksym;            /* for the sake of calcmand    */
X
Xextern long timer_interval;        /* timer(...) total */
X
XVOIDFARPTR typespecific_workarea = NULL;
X
Xstatic double dem_delta, dem_width;    /* distance estimator variables */
Xstatic double dem_toobig;
X#define DEM_BAILOUT 535.5  /* (pb: not sure if this is special or arbitrary) */
X
X/* variables which must be visible for tab_display */
Xint got_status; /* -1 if not, 0 for 1or2pass, 1 for ssg, 2 for btm, 3 for 3d */
Xint curpass,totpasses;
Xint currow,curcol;
X
X/* static vars for solidguess & its subroutines */
Xstatic int maxblock,halfblock;
Xstatic int guessplot;            /* paint 1st pass row at a time?   */
Xstatic int right_guess,bottom_guess;
X#define maxyblk 7    /* maxxblk*maxyblk*2 <= 4096, the size of "prefix" */
X#define maxxblk 202  /* each maxnblk is oversize by 2 for a "border" */
X             /* maxxblk defn must match fracsubr.c */
X/* next has a skip bit for each maxblock unit;
X   1st pass sets bit  [1]... off only if block's contents guessed;
X   at end of 1st pass [0]... bits are set if any surrounding block not guessed;
X   bits are numbered [..][y/16+1][x+1]&(1<<(y&15)) */
Xextern unsigned int prefix[2][maxyblk][maxxblk]; /* common temp */
X/* size of next puts a limit of MAXPIXELS pixels across on solid guessing logic */
X#ifndef XFRACT
Xextern char dstack[4096];               /* common temp, two put_line calls */
Xextern char suffix[4096];             /* cellular, put_line/get_line calls */
Xextern unsigned int prefix[2][maxyblk][maxxblk]; /* common temp */
X#else
XBYTE dstack[4096];              /* common temp, two put_line calls */
Xunsigned int prefix[2][maxyblk][maxxblk]; /* common temp */
X#endif
X
Xint nxtscreenflag; /* for cellular next screen generation */
Xint    attractors;            /* number of finite attractors  */
X_CMPLX    attr[N_ATTR];        /* finite attractor vals (f.p)  */
X_LCMPLX lattr[N_ATTR];        /* finite attractor vals (int)  */
Xint    attrperiod[N_ATTR];        /* period of the finite attractor */
X
X/***** vars for new btm *****/
Xenum direction {North,East,South,West};
Xenum direction going_to;
Xint trail_row, trail_col;
X
X#ifndef sqr
X#define sqr(x) ((x)*(x))
X#endif
X
X#ifndef lsqr
X#define lsqr(x) (multiply((x),(x),bitshift))
X#endif
X
X/* -------------------------------------------------------------------- */
X/*        These variables are external for speed's sake only      */
X/* -------------------------------------------------------------------- */
Xextern _LCMPLX lold,lnew,lparm,lparm2;     /* added "lold" */
X
Xint periodicitycheck;
Xextern long ltempsqrx,ltempsqry;
Xextern double tempsqrx,tempsqry;
Xextern _LCMPLX ltmp;
Xextern int display3d;
X
X
Xvoid calcfrac_overlay() { }    /* for restore_active_ovly */
Xextern int first_err;   /* flag for math errors */
X
X/******* calcfract - the top level routine for generating an image *******/
X
Xint calcfract()
X{
X   ENTER_OVLY(OVLY_CALCFRAC);
X
X   first_err = 1;
X   attractors = 0;        /* default to no known finite attractors  */
X   display3d = 0;
X   basin = 0;
X
X   init_misc();  /* set up some variables in parser.c */
X
X   /* following delta values useful only for types with rotation disabled */
X   /* currently used only by bifurcation */
X   if (integerfractal)
X   {
X      distest = 0;
X      deltaX = (double)lx0[     1] / fudge - xxmin;
X      deltaY = yymax - (double)ly0[     1] / fudge;
X   }
X   else
X   {
X      deltaX = dx0[     1] - xxmin;
X      deltaY = yymax - dy0[     1];
X   }
X
X   parm.x   = param[0];
X   parm.y   = param[1];
X   parm2.x  = param[2];
X   parm2.y  = param[3];
X
X   if (LogFlag && colors < 16) {
X      static char far msg[]={"Need at least 16 colors to use logmap"};
X      stopmsg(0,msg);
X      LogFlag = 0;
X      }
X   if (LogFlag || rangeslen)
X      if (!(LogTable = farmemalloc((long)maxit + 1))) {
X      static char far msg[]={"Insufficient memory for logmap/ranges with this maxiter"};
X      stopmsg(0,msg);
X      }
X      else if (rangeslen) {
X     int i,k,l,m,numval,flip,altern;
X     i = k = l = 0;
X     while (i < rangeslen) {
X        m = flip = 0;
X        altern = 32767;
X        if ((numval = ranges[i++]) < 0) {
X           altern = ranges[i++];    /* sub-range iterations */
X           numval = ranges[i++];
X           }
X        if (numval > maxit || i >= rangeslen)
X           numval = maxit;
X        while (l <= numval)  {
X           LogTable[l++] = k + flip;
X           if (++m >= altern) {
X          flip ^= 1;        /* Alternate colors */
X          m = 0;
X          }
X           }
X        ++k;
X        if (altern != 32767) ++k;
X        }
X     }
X      else
X     SetupLogTable();
X
X   lm = 4L << bitshift;         /* CALCMAND magnitude limit */
X
X   /* ORBIT stuff */
X   save_orbit = (int far *)((double huge *)dx0 + 4*MAXPIXELS);
X   show_orbit = 0;
X   orbit_ptr = 0;
X   orbit_color = 15;
X   if(colors < 16)
X      orbit_color = 1;
X
X   if(inversion[0] != 0.0)
X   {
X      f_radius      = inversion[0];
X      f_xcenter   = inversion[1];
X      f_ycenter   = inversion[2];
X
X      if (inversion[0] == AUTOINVERT)  /*  auto calc radius 1/6 screen */
X     inversion[0] = f_radius = min(fabs(xxmax - xxmin),
X         fabs(yymax - yymin)) / 6.0;
X
X      if (invert < 2 || inversion[1] == AUTOINVERT)  /* xcenter not already set */
X      {
X     inversion[1] = f_xcenter = (xxmin + xxmax) / 2.0;
X     if (fabs(f_xcenter) < fabs(xxmax-xxmin) / 100)
X        inversion[1] = f_xcenter = 0.0;
X      }
X
X      if (invert < 3 || inversion[2] == AUTOINVERT)  /* ycenter not already set */
X      {
X     inversion[2] = f_ycenter = (yymin + yymax) / 2.0;
X     if (fabs(f_ycenter) < fabs(yymax-yymin) / 100)
X        inversion[2] = f_ycenter = 0.0;
X      }
X
X      invert = 3; /* so values will not be changed if we come back */
X   }
X
X   closenuff = delmin >> abs(periodicitycheck); /* for periodicity checking */
X   closenuff /= fudge;
X   rqlim_save = rqlim;
X   rqlim2 = sqrt(rqlim);
X   if (integerfractal)        /* for integer routines (lambda) */
X   {
X      lparm.x = parm.x * fudge;    /* real portion of Lambda */
X      lparm.y = parm.y * fudge;    /* imaginary portion of Lambda */
X      lparm2.x = parm2.x * fudge;  /* real portion of Lambda2 */
X      lparm2.y = parm2.y * fudge;  /* imaginary portion of Lambda2 */
X      llimit = rqlim * fudge;       /* stop if magnitude exceeds this */
X      if (llimit <= 0) llimit = 0x7fffffff; /* klooge for integer math */
X      llimit2 = rqlim2 * fudge;    /* stop if magnitude exceeds this */
X      lclosenuff = closenuff * fudge;    /* "close enough" value */
X      l16triglim = 8L<<16;       /* domain limit of fast trig functions */
X      linitorbit.x = initorbit.x * fudge;
X      linitorbit.y = initorbit.y * fudge;
X   }
X   resuming = (calc_status == 2);
X   if (!resuming) /* free resume_info memory if any is hanging around */
X   {
X      end_resume();
X      if (resave_flag) {
X     updatesavename(savename); /* do the pending increment */
X     resave_flag = started_resaves = 0;
X     }
X      calctime = 0;
X   }
X
X   if (curfractalspecific->calctype != StandardFractal
X       && curfractalspecific->calctype != calcmand
X       && curfractalspecific->calctype != calcmandfp
X       && curfractalspecific->calctype != lyapunov
X       && curfractalspecific->calctype != calcfroth)
X   {
X      calctype = curfractalspecific->calctype; /* per_image can override */
X      symmetry = curfractalspecific->symmetry; /*   calctype & symmetry  */
X      plot = putcolor; /* defaults when setsymmetry not called or does nothing */
X      iystart = ixstart = yystart = xxstart = yybegin = 0;
X      iystop = yystop = ydots -1;
X      ixstop = xxstop = xdots -1;
X      calc_status = 1; /* mark as in-progress */
X      distest = 0; /* only standard escape time engine supports distest */
X      /* per_image routine is run here */
X      if (curfractalspecific->per_image())
X      { /* not a stand-alone */
X     /* next two lines in case periodicity changed */
X     closenuff = delmin >> abs(periodicitycheck); /* for periodicity checking */
X     closenuff /= fudge;
X     lclosenuff = closenuff * fudge;    /* "close enough" value */
X     setsymmetry(symmetry,0);
X     timer(0,calctype); /* non-standard fractal engine */
X      }
X      if (check_key())
X      {
X     if (calc_status == 1) /* calctype didn't set this itself, */
X        calc_status = 3;   /* so mark it interrupted, non-resumable */
X      }
X      else
X     calc_status = 4; /* no key, so assume it completed */
X   }
X   else /* standard escape-time engine */
X      timer(0,(int (*)())perform_worklist);
X   calctime += timer_interval;
X
X   if(LogTable)
X   {
X      farmemfree(LogTable);
X      LogTable = NULL;
X   }
X   if(typespecific_workarea)
X   {
X      free_workarea();
X   }
X
X   EXIT_OVLY;
X   return((calc_status == 4) ? 0 : -1);
X}
X
X/**************** general escape-time engine routines *********************/
X
Xstatic void perform_worklist()
X{
X   int i;
X   long tmplong; /* this temp must be signed */
X
X   if (potflag && pot16bit)
X   {
X      int tmpcalcmode = stdcalcmode;
X
X      stdcalcmode = '1'; /* force 1 pass */
X      if (resuming == 0)
X     if (pot_startdisk() < 0)
X     {
X        pot16bit = 0;    /* startdisk failed or cancelled */
X        stdcalcmode = tmpcalcmode;    /* maybe we can carry on??? */
X     }
X   }
X   if (stdcalcmode == 'b' && (curfractalspecific->flags & NOTRACE))
X      stdcalcmode = '1';
X   if (stdcalcmode == 'g' && (curfractalspecific->flags & NOGUESS))
X      stdcalcmode = '1';
X
X   /* default setup a new worklist */
X   num_worklist = 1;
X   worklist[0].xxstart = 0;
X   worklist[0].yystart = worklist[0].yybegin = 0;
X   worklist[0].xxstop = xdots - 1;
X   worklist[0].yystop = ydots - 1;
X   worklist[0].pass = worklist[0].sym = 0;
X   if (resuming) /* restore worklist, if we can't the above will stay in place */
X   {
X      start_resume();
X      get_resume(sizeof(int),&num_worklist,sizeof(worklist),worklist,0);
X      end_resume();
X   }
X
X   if (distest) /* setup stuff for distance estimator */
X   {
X      double ftemp,ftemp2;
X      dem_delta = sqr(delxx) + sqr(delyy2);
X      if ((ftemp = sqr(delyy) + sqr(delxx2)) > dem_delta)
X     dem_delta = ftemp;
X      if (distestwidth == 0)
X     distestwidth = 71;
X      ftemp = distestwidth;
X      dem_delta *= sqr(ftemp)/10000; /* multiply by thickness desired */
X      dem_width = ( sqrt( sqr(xxmax-xxmin) + sqr(xx3rd-xxmin) ) * ydots/xdots
X      + sqrt( sqr(yymax-yymin) + sqr(yy3rd-yymin) ) ) / distest;
X      ftemp = (rqlim < DEM_BAILOUT) ? DEM_BAILOUT : rqlim;
X      ftemp += 3; /* bailout plus just a bit */
X      ftemp2 = log(ftemp);
X      dem_toobig = sqr(ftemp) * sqr(ftemp2) * 4 / dem_delta;
X   }
X
X   while (num_worklist > 0)
X   {
X      calctype = curfractalspecific->calctype; /* per_image can override */
X      symmetry = curfractalspecific->symmetry; /*   calctype & symmetry  */
X      plot = putcolor; /* defaults when setsymmetry not called or does nothing */
X
X      /* pull top entry off worklist */
X      ixstart = xxstart = worklist[0].xxstart;
X      ixstop  = xxstop    = worklist[0].xxstop;
X      iystart = yystart = worklist[0].yystart;
X      iystop  = yystop    = worklist[0].yystop;
X      yybegin  = worklist[0].yybegin;
X      workpass = worklist[0].pass;
X      worksym  = worklist[0].sym;
X      --num_worklist;
X      for (i=0; i<num_worklist; ++i)
X     worklist[i] = worklist[i+1];
X
X      calc_status = 1; /* mark as in-progress */
X
X      curfractalspecific->per_image();
X
X      /* some common initialization for escape-time pixel level routines */
X      closenuff = delmin >> abs(periodicitycheck); /* for periodicity checking */
X      closenuff /= fudge;
X      lclosenuff = closenuff * fudge;    /* "close enough" value */
X      kbdcount=max_kbdcount;
X      /* savedmask is for calcmand's periodicity checking */
X      savedmask = 0xC0000000; /* top 2 bits on */
X      tmplong = (delmin >> abs(periodicitycheck)) | 1;
X      while (tmplong > 0) /* while top bit not on */
X      {
X     tmplong <<= 1;
X     savedmask = (savedmask >> 1) | 0x80000000;
X      }
X
X      setsymmetry(symmetry,1);
X
X/* added for testing autologmap() */
X      if (!(resuming)&&(abs(LogFlag) ==2))
X       {  /* calculate round screen edges to work out best start for logmap */
X         LogFlag = ( autologmap() * (LogFlag / abs(LogFlag)));
X         SetupLogTable();
X       }
X
X      /* call the appropriate escape-time engine */
X      switch (stdcalcmode)
X      {
X      case 't':
X     tesseral();
X     break;
X      case 'b':
X     bound_trace_main();
X     break;
X      case 'g':
X     solidguess();
X     break;
X      default:
X     OneOrTwoPass();
X      }
X
X      if (check_key()) /* interrupted? */
X     break;
X   }
X
X   if (num_worklist > 0)
X   {  /* interrupted, resumable */
X      alloc_resume(sizeof(worklist)+10,1);
X      put_resume(sizeof(int),&num_worklist,sizeof(worklist),worklist,0);
X   }
X   else
X      calc_status = 4; /* completed */
X}
X
Xstatic int OneOrTwoPass()
X{
X   int i;
X   totpasses = 1;
X   if (stdcalcmode == '2') totpasses = 2;
X   if (stdcalcmode == '2' && workpass == 0) /* do 1st pass of two */
X   {
X      if (StandardCalc(1) == -1)
X      {
X     add_worklist(xxstart,xxstop,yystart,yystop,row,0,worksym);
X     return(-1);
X      }
X      if (num_worklist > 0) /* worklist not empty, defer 2nd pass */
X      {
X     add_worklist(xxstart,xxstop,yystart,yystop,yystart,1,worksym);
X     return(0);
X      }
X      workpass = 1;
X      yybegin = yystart;
X   }
X   /* second or only pass */
X   if (StandardCalc(2) == -1)
X   {
X      i = yystop;
X      if (iystop != yystop) /* must be due to symmetry */
X     i -= row - iystart;
X      add_worklist(xxstart,xxstop,row,i,row,workpass,worksym);
X      return(-1);
X   }
X   return(0);
X}
X
Xstatic int _fastcall StandardCalc(int passnum)
X{
X   got_status = 0;
X   curpass = passnum;
X   row = yybegin;
X   while (row <= iystop)
X   {
X      currow = row;
X      reset_periodicity = 1;
X      col = ixstart;
X      while (col <= ixstop)
X      {
X         if(showdot>0)
X            (*plot) (col, row, showdot&(colors-1));
X
X     /* on 2nd pass of two, skip even pts */
X     if (passnum == 1 || stdcalcmode == '1' || (row&1) != 0 || (col&1) != 0)
X     {
X        if ((*calctype)() == -1) /* StandardFractal(), calcmand() or calcmandfp() */
X           return(-1); /* interrupted */
X        reset_periodicity = 0;
X        if (passnum == 1) /* first pass, copy pixel and bump col */
X        {
X           if ((row&1) == 0 && row < iystop)
X           {
X          (*plot)(col,row+1,color);
X          if ((col&1) == 0 && col < ixstop)
X             (*plot)(col+1,row+1,color);
X           }
X           if ((col&1) == 0 && col < ixstop)
X          (*plot)(++col,row,color);
X        }
X     }
X     ++col;
X      }
X      if (passnum == 1 && (row&1) == 0)
X     ++row;
X      ++row;
X   }
X   return(0);
X}
X
Xint calcmand()        /* fast per pixel 1/2/b/g, called with row & col set */
X{
X   /* setup values from far array to avoid using es reg in calcmand.asm */
X   linitx = lx0[col] + lx1[row];
X   linity = ly0[row] + ly1[col];
X   if (calcmandasm() >= 0)
X   {
X      if (LogTable /* map color, but not if maxit & adjusted for inside,etc */
X      && (realcolor < maxit || (inside < 0 && color == maxit)))
X     color = LogTable[min(color, maxit)];
X      if (color >= colors) /* don't use color 0 unless from inside/outside */
X     if (colors < 16)
X        color &= andcolor;
X     else
X        color = ((color - 1) % andcolor) + 1;  /* skip color zero */
X      if(debugflag != 470)
X         if(color <= 0 && stdcalcmode == 'b' )   /* fix BTM bug */
X            color = 1;
X      (*plot) (col, row, color);
X   }
X   return (color);
X}
X
X/************************************************************************/
X/* added by Wes Loewer - sort of a floating point version of calcmand() */
X/* can also handle invert, any rqlim, potflag, zmag, epsilon cross,     */
X/* and all the current outside options    -Wes Loewer 11/03/91          */
X/************************************************************************/
Xint calcmandfp()
X{
X   if(invert)
X      invertz2(&init);
X   else
X   {
X      init.y = dy0[row]+dy1[col];
X      init.x = dx0[col]+dx1[row];
X   }
X   if (calcmandfpasm() >= 0)
X   {
X      if (potflag)
X     color = potential(magnitude, realcolor);
X      if (LogTable /* map color, but not if maxit & adjusted for inside,etc */
X          && (realcolor < maxit || (inside < 0 && color == maxit)))
X        color = LogTable[min(color, maxit)];
X     if (color >= colors) /* don't use color 0 unless from inside/outside */
X        if (colors < 16)
X           color &= andcolor;
X        else
X           color = ((color - 1) % andcolor) + 1;  /* skip color zero */
X         if(debugflag != 470)
X            if(color == 0 && stdcalcmode == 'b' )   /* fix BTM bug */
X               color = 1;
X      (*plot) (col, row, color);
X   }
X   return (color);
X}
X
X#define green 2
X#define yellow 6
Xint StandardFractal()    /* per pixel 1/2/b/g, called with row & col set */
X{
X   double tantable[16];
X   int hooper;
X   double close;
X   long lclose;
X   int cyclelen = -1;
X   int savedcolor;
X   int caught_a_cycle;
X   int savedand, savedincr;    /* for periodicity checking */
X   _LCMPLX lsaved;
X   int i, attracted;
X   _LCMPLX lat;
X   _CMPLX  at;
X   _CMPLX deriv;
X   int dem_color;
X   _CMPLX dem_new;
X   close = .01;
X   lclose = close*fudge;
X
X   if(inside == STARTRAIL)
X   {
X      int i;
X      for(i=0;i<16;i++)
X     tantable[i] = 0.0;
X   }
X   else if(inside == EPSCROSS)
X   {
X      close = .01;
X      lclose = close*fudge;
X   }
X   if (periodicitycheck == 0 || inside == ZMAG || inside == STARTRAIL)
X      oldcolor = 32767;     /* don't check periodicity at all */
X   else if (inside == PERIOD)    /* for display-periodicity */
X      oldcolor = maxit*4/5;    /* don't check until nearly done */
X   else if (reset_periodicity)
X      oldcolor = 250;        /* don't check periodicity 1st 250 iterations */
X
X   /* really fractal specific, but we'll leave it here */
X   if (!integerfractal)
X   {
X      if (useinitorbit == 1)
X     saved = initorbit;
X      else {
X     saved.x = 0;
X     saved.y = 0;
X      }
X      init.y = dy0[row] + dy1[col];
X      if (distest)
X      {
X     rqlim = rqlim_save;          /* start with regular bailout */
X     if (distest != 1 || colors == 2) /* not doing regular outside colors */
X        if (rqlim < DEM_BAILOUT)      /* so go straight for dem bailout */
X           rqlim = DEM_BAILOUT;
X     deriv.x = 1;
X     deriv.y = 0;
X     magnitude = 0;
X     dem_color = -1;
X      }
X   }
X   else
X   {
X      if (useinitorbit == 1)
X     lsaved = linitorbit;
X      else {
X     lsaved.x = 0;
X     lsaved.y = 0;
X      }
X      linit.y = ly0[row] + ly1[col];
X   }
X   orbit_ptr = 0;
X   color = 0;
X   if(fractype==JULIAFP || fractype==JULIA)
X      color = -1;
X   caught_a_cycle = 0;
X   if (inside == PERIOD) {
X       savedand = 16;        /* begin checking every 16th cycle */
X   } else {
X       savedand = 1;        /* begin checking every other cycle */
X   }
X   savedincr = 1;        /* start checking the very first time */
X
X   if (inside <= BOF60 && inside >= BOF61)
X   {
X      magnitude = lmagnitud = 0;
X      min_orbit = 100000.0;
X   }
X   overflow = 0;        /* reset integer math overflow flag */
X
X   curfractalspecific->per_pixel(); /* initialize the calculations */
X
X   attracted = FALSE;
X   while (++color < maxit)
X   {
X      if(showdot>0)
X         (*plot) (col, row, showdot&(colors-1));
X
X      /* calculation of one orbit goes here */
X      /* input in "old" -- output in "new" */
X
X      if (distest)
X      {
X     double ftemp;
X     /* Distance estimator for points near Mandelbrot set */
X     /* Original code by Phil Wilson, hacked around by PB */
X     /* Algorithms from Peitgen & Saupe, Science of Fractal Images, p.198 */
X     ftemp     = 2 * (old.x * deriv.x - old.y * deriv.y) + 1;
X     deriv.y = 2 * (old.y * deriv.x + old.x * deriv.y);
X     deriv.x = ftemp;
X     if (sqr(deriv.x)+sqr(deriv.y) > dem_toobig)
X        break;
X     /* if above exit taken, the later test vs dem_delta will place this
X            point on the boundary, because mag(old)<bailout just now */
X     if (curfractalspecific->orbitcalc())
X     {
X        if (dem_color < 0)          /* note "regular" color for later */
X        {
X           dem_color = color;
X           dem_new = new;
X        }
X        if (rqlim >= DEM_BAILOUT  /* exit if past real bailout */
X        || magnitude >= (rqlim = DEM_BAILOUT) /* reset to real bailout */
X        || magnitude == 0)     /* exit if type doesn't "floatbailout" */
X           break;
X        old = new;              /* carry on till past real bailout */
X     }
X      }
X      else /* the usual case */
X     if (curfractalspecific->orbitcalc() && inside != STARTRAIL)
X        break;
X      if (show_orbit)
X     if (!integerfractal)
X        plot_orbit(new.x, new.y, -1);
X     else
X        iplot_orbit(lnew.x, lnew.y, -1);
X      if(inside == STARTRAIL)
X      {
X     if(0 < color && color < 16)
X     {
X     if (integerfractal)
X     {
X           new.x = lnew.x;
X           new.x /= fudge;
X           new.y = lnew.y;
X           new.y /= fudge;
X        }
X        tantable[color-1] = new.y/(new.x+.000001);
X     }
X      }
X      else if(inside == EPSCROSS)
X      {
X     hooper = 0;
X     if(integerfractal)
X     {
X        if(labs(lnew.x) < lclose)
X        {
X           hooper = 1; /* close to y axis */
X           goto plot_inside;
X        }
X        else if(labs(lnew.y) < lclose)
X        {
X           hooper = 2; /* close to x axis */
X           goto plot_inside;
X        }
X     }
X     else
X     {
X        if(fabs(new.x) < close)
X        {
X           hooper = 1; /* close to y axis */
X           goto plot_inside;
X        }
X        else if(fabs(new.y) < close)
X        {
X           hooper = 2; /* close to x axis */
X           goto plot_inside;
X        }
X     }
X      }
X      else if (inside <= BOF60 && inside >= BOF61)
X      {
X     if (integerfractal)
X     {
X        if (lmagnitud == 0)
X           lmagnitud = lsqr(lnew.x) + lsqr(lnew.y);
X        magnitude = lmagnitud;
X        magnitude = magnitude / fudge;
X     }
X     else
X        if (magnitude == 0.0)
X           magnitude = sqr(new.x) + sqr(new.y);
X     if (magnitude < min_orbit)
X     {
X        min_orbit = magnitude;
X        min_index = color + 1;
X     }
X      }
X
X
X      if (attractors > 0)    /* finite attractor in the list   */
X      {             /* NOTE: Integer code is UNTESTED */
X     if (integerfractal)
X     {
X        for (i = 0; i < attractors; i++)
X        {
X        lat.x = lnew.x - lattr[i].x;
X        lat.x = lsqr(lat.x);
X        if (lat.x < l_at_rad)
X        {
X           lat.y = lnew.y - lattr[i].y;
X           lat.y = lsqr(lat.y);
X           if (lat.y < l_at_rad)
X           {
X              if ((lat.x + lat.y) < l_at_rad)
X              {
X             attracted = TRUE;
X             if (finattract<0) color = (color%attrperiod[i])+1;
X             break;
X              }
X           }
X        }
X        }
X     }
X     else
X     {
X        for (i = 0; i < attractors; i++)
X        {
X        at.x = new.x - attr[i].x;
X        at.x = sqr(at.x);
X        if (at.x < f_at_rad)
X        {
X           at.y = new.y - attr[i].y;
X           at.y = sqr(at.y);
X           if ( at.y < f_at_rad)
X           {
X              if ((at.x + at.y) < f_at_rad)
X              {
X             attracted = TRUE;
X             if (finattract<0) color = (color%attrperiod[i])+1;
X             break;
X              }
X           }
X        }
X        }
X     }
X     if (attracted)
X        break;        /* AHA! Eaten by an attractor */
X      }
X
X      if (color > oldcolor)    /* check periodicity */
X      {
X     if ((color & savedand) == 0)         /* time to save a new value */
X     {
X        savedcolor = color;
X        if (!integerfractal)
X           saved = new;  /* floating pt fractals */
X        else
X           lsaved = lnew;/* integer fractals */
X        if (--savedincr == 0)    /* time to lengthen the periodicity? */
X        {
X           savedand = (savedand << 1) + 1;         /* longer periodicity */
X           savedincr = 4;/* restart counter */
X        }
X     }
X     else             /* check against an old save */
X     {
X        if (!integerfractal)     /* floating-pt periodicity chk */
X        {
X           if (fabs(saved.x - new.x) < closenuff)
X          if (fabs(saved.y - new.y) < closenuff)
X          {
X             caught_a_cycle = 1;
X             cyclelen = color-savedcolor;
X             color = maxit - 1;
X          }
X        }
X        else         /* integer periodicity check */
X        {
X           if (labs(lsaved.x - lnew.x) < lclosenuff)
X          if (labs(lsaved.y - lnew.y) < lclosenuff)
X          {
X             caught_a_cycle = 1;
X             cyclelen = color-savedcolor;
X             color = maxit - 1;
X          }
X        }
X     }
X      }
X   }
X
X   if (show_orbit)
X      scrub_orbit();
X
X   realcolor = color;        /* save this before we start adjusting it */
X   if (color >= maxit)
X      oldcolor = 0;        /* check periodicity immediately next time */
X   else
X   {
X      oldcolor = color + 10;    /* check when past this + 10 next time */
X      if (color == 0)
X     color = 1;        /* needed to make same as calcmand */
X   }
X
X   if (potflag)
X   {
X      if (integerfractal)    /* adjust integer fractals */
X      {
X     new.x = ((double)lnew.x) / fudge;
X     new.y = ((double)lnew.y) / fudge;
X      }
X      magnitude = sqr(new.x) + sqr(new.y);
X      color = potential(magnitude, color);
X      if (LogTable)
X     color = LogTable[min(color, maxit)];
X      goto plot_pixel;        /* skip any other adjustments */
X   }
X
X   if (color >= maxit)        /* an "inside" point */
X      goto plot_inside;     /* distest, decomp, biomorph don't apply */
X
X
X   if (outside < -1)  /* these options by Richard Hughes modified by TW */
X   {
X      if (integerfractal)
X      {
X     new.x = ((double)lnew.x) / fudge;
X     new.y = ((double)lnew.y) / fudge;
X      }
X      /* Add 7 to overcome negative values on the MANDEL    */
X      if (outside == REAL)         /* "real" */
X     color += new.x + 7;
X      else if (outside == IMAG)         /* "imag" */
X     color += new.y + 7;
X      else if (outside == MULT  && new.y)  /* "mult" */
X      color *= (new.x/new.y);
X      else if (outside == SUM)         /* "sum" */
X      color += new.x + new.y;
X
X      /* eliminate negative colors & wrap arounds */
X      if (color < 0 || color > maxit)
X      color = 0;
X   }
X
X   if (distest)
X   {
X      double dist,temp;
X      dist = sqr(new.x) + sqr(new.y);
X      temp = log(dist);
X      dist = dist * sqr(temp) / ( sqr(deriv.x) + sqr(deriv.y) );
X      if (dist < dem_delta)    /* point is on the edge */
X      {
X     if (distest > 0)
X        goto plot_inside;    /* show it as an inside point */
X     color = 0 - distest;    /* show boundary as specified color */
X     goto plot_pixel;    /* no further adjustments apply */
X      }
X      if (colors == 2)
X      {
X     color = !inside;    /* the only useful distest 2 color use */
X     goto plot_pixel;    /* no further adjustments apply */
X      }
X      if (distest > 1)        /* pick color based on distance */
X      {
X     color = sqrt(dist / dem_width + 1);
X         color &= INT_MAX;     /* oops - color can be negative */
X     goto plot_pixel;    /* no further adjustments apply */
X      }
X      color = dem_color;    /* use pixel's "regular" color */
X      new = dem_new;
X   }
X
X   if (decomp[0] > 0)
X      decomposition();
X   else if (biomorph != -1)
X   {
X      if (integerfractal)
X      {
X     if (labs(lnew.x) < llimit2 || labs(lnew.y) < llimit2)
X        color = biomorph;
X      }
X      else
X     if (fabs(new.x) < rqlim2 || fabs(new.y) < rqlim2)
X        color = biomorph;
X   }
X
X   if (outside >= 0 && attracted == FALSE) /* merge escape-time stripes */
X      color = outside;
X   else if (LogTable)
X      color = LogTable[min(color, maxit)];
X   goto plot_pixel;
X
X   plot_inside: /* we're "inside" */
X   if (periodicitycheck < 0 && caught_a_cycle)
X      color = 7;           /* show periodicity */
X   else if (inside >= 0)
X      color = inside;           /* set to specified color, ignore logpal */
X   else
X   {
X      if(inside == STARTRAIL)
X      {
X     int i;
X     double diff;
X     color = 0;
X     for(i=1;i<16;i++)
X     {
X        diff = tantable[0] - tantable[i];
X        if(fabs(diff) < .05)
X        {
X           color = i;
X           break;
X        }
X     }
X      }
X      else if(inside== PERIOD) {
X      if (cyclelen>0) {
X          color = cyclelen;
X      } else {
X          color = maxit;
X      }
X      }
X      else if(inside == EPSCROSS)
X      {
X     if(hooper==1)
X        color = green;
X     else if(hooper==2)
X        color = yellow;
X     else
X        color = maxit;
X     if (show_orbit)
X        scrub_orbit();
X      }
X      else if (inside == BOF60)
X     color = sqrt(min_orbit) * 75;
X      else if (inside == BOF61)
X     color = min_index;
X      else if (inside == ZMAG)
X      {
X     if (integerfractal)
X     {
X        /*
X        new.x = ((double)lnew.x) / fudge;
X        new.y = ((double)lnew.y) / fudge;
X        */
X        color = (((double)lsqr(lnew.x))/fudge + ((double)lsqr(lnew.y))/fudge) * (maxit>>1) + 1;
X     }
X     else
X        color = (sqr(new.x) + sqr(new.y)) * (maxit>>1) + 1;
X      }
X      else /* inside == -1 */
X     color = maxit;
X      if (LogTable)
X     color = LogTable[min(color, maxit)];
X   }
X
X   plot_pixel:
X
X   if (color >= colors) /* don't use color 0 unless from inside/outside */
X      if (colors < 16)
X     color &= andcolor;
X      else
X     color = ((color - 1) % andcolor) + 1;    /* skip color zero */
X   if(debugflag != 470)
X      if(color <= 0 && stdcalcmode == 'b' )   /* fix BTM bug */
X         color = 1;
X   (*plot) (col, row, color);
X
X   if ((kbdcount -= realcolor) <= 0)
X   {
X      if (check_key())
X     return (-1);
X      kbdcount = max_kbdcount;
X   }
X
X   return (color);
X}
X#undef green
X#undef yellow
X
X
X
X/**************** standardfractal doodad subroutines *********************/
X
Xstatic void decomposition()
X{
X   static double far cos45       = 0.70710678118654750; /* cos 45    degrees */
X   static double far sin45       = 0.70710678118654750; /* sin 45    degrees */
X   static double far cos22_5   = 0.92387953251128670; /* cos 22.5    degrees */
X   static double far sin22_5   = 0.38268343236508980; /* sin 22.5    degrees */
X   static double far cos11_25  = 0.98078528040323040; /* cos 11.25    degrees */
X   static double far sin11_25  = 0.19509032201612820; /* sin 11.25    degrees */
X   static double far cos5_625  = 0.99518472667219690; /* cos 5.625    degrees */
X   static double far sin5_625  = 0.09801714032956060; /* sin 5.625    degrees */
X   static double far tan22_5   = 0.41421356237309500; /* tan 22.5    degrees */
X   static double far tan11_25  = 0.19891236737965800; /* tan 11.25    degrees */
X   static double far tan5_625  = 0.09849140335716425; /* tan 5.625    degrees */
X   static double far tan2_8125 = 0.04912684976946725; /* tan 2.8125 degrees */
X   static double far tan1_4063 = 0.02454862210892544; /* tan 1.4063 degrees */
X   static long far lcos45      ; /* cos 45      degrees */
X   static long far lsin45      ; /* sin 45      degrees */
X   static long far lcos22_5   ; /* cos 22.5   degrees */
X   static long far lsin22_5   ; /* sin 22.5   degrees */
X   static long far lcos11_25  ; /* cos 11.25  degrees */
X   static long far lsin11_25  ; /* sin 11.25  degrees */
X   static long far lcos5_625  ; /* cos 5.625  degrees */
X   static long far lsin5_625  ; /* sin 5.625  degrees */
X   static long far ltan22_5   ; /* tan 22.5   degrees */
X   static long far ltan11_25  ; /* tan 11.25  degrees */
X   static long far ltan5_625  ; /* tan 5.625  degrees */
X   static long far ltan2_8125 ; /* tan 2.8125 degrees */
X   static long far ltan1_4063 ; /* tan 1.4063 degrees */
X   static reset_fudge = -1;
X   int temp = 0;
X   int i;
X   _LCMPLX lalt;
X   _CMPLX alt;
X   color = 0;
X   if (integerfractal) /* the only case */
X   {
X      if (reset_fudge != fudge)
X      {
X     reset_fudge = fudge;
X     lcos45     = cos45     *fudge;
X     lsin45     = sin45     *fudge;
X     lcos22_5   = cos22_5     *fudge;
X     lsin22_5   = sin22_5     *fudge;
X     lcos11_25  = cos11_25     *fudge;
X     lsin11_25  = sin11_25     *fudge;
X     lcos5_625  = cos5_625     *fudge;
X     lsin5_625  = sin5_625     *fudge;
X     ltan22_5   = tan22_5     *fudge;
X     ltan11_25  = tan11_25     *fudge;
X     ltan5_625  = tan5_625     *fudge;
X     ltan2_8125 = tan2_8125  *fudge;
X     ltan1_4063 = tan1_4063  *fudge;
X      }
X      if (lnew.y < 0)
X      {
X     temp = 2;
X     lnew.y = -lnew.y;
X      }
X
X      if (lnew.x < 0)
X      {
X     ++temp;
X     lnew.x = -lnew.x;
X      }
X
X      if (decomp[0] >= 8)
X      {
X     temp <<= 1;
X     if (lnew.x < lnew.y)
X     {
X        ++temp;
X        lalt.x = lnew.x; /* just */
X        lnew.x = lnew.y; /* swap */
X        lnew.y = lalt.x; /* them */
X     }
X
X     if (decomp[0] >= 16)
X     {
X        temp <<= 1;
X        if (multiply(lnew.x,ltan22_5,bitshift) < lnew.y)
X        {
X           ++temp;
X           lalt = lnew;
X           lnew.x = multiply(lalt.x,lcos45,bitshift) +
X           multiply(lalt.y,lsin45,bitshift);
X           lnew.y = multiply(lalt.x,lsin45,bitshift) -
X           multiply(lalt.y,lcos45,bitshift);
X        }
X
X        if (decomp[0] >= 32)
X        {
X           temp <<= 1;
X           if (multiply(lnew.x,ltan11_25,bitshift) < lnew.y)
X           {
X          ++temp;
X          lalt = lnew;
X          lnew.x = multiply(lalt.x,lcos22_5,bitshift) +
X              multiply(lalt.y,lsin22_5,bitshift);
X          lnew.y = multiply(lalt.x,lsin22_5,bitshift) -
X              multiply(lalt.y,lcos22_5,bitshift);
X           }
X
X           if (decomp[0] >= 64)
X           {
X          temp <<= 1;
X          if (multiply(lnew.x,ltan5_625,bitshift) < lnew.y)
X          {
X             ++temp;
X             lalt = lnew;
X             lnew.x = multiply(lalt.x,lcos11_25,bitshift) +
X             multiply(lalt.y,lsin11_25,bitshift);
X             lnew.y = multiply(lalt.x,lsin11_25,bitshift) -
X             multiply(lalt.y,lcos11_25,bitshift);
X          }
X
X          if (decomp[0] >= 128)
X          {
X             temp <<= 1;
X             if (multiply(lnew.x,ltan2_8125,bitshift) < lnew.y)
X             {
X            ++temp;
X            lalt = lnew;
X            lnew.x = multiply(lalt.x,lcos5_625,bitshift) +
X                multiply(lalt.y,lsin5_625,bitshift);
X            lnew.y = multiply(lalt.x,lsin5_625,bitshift) -
X                multiply(lalt.y,lcos5_625,bitshift);
X             }
X
X             if (decomp[0] == 256)
X             {
X            temp <<= 1;
X            if (multiply(lnew.x,ltan1_4063,bitshift) < lnew.y)
X               if ((lnew.x*ltan1_4063 < lnew.y))
X                  ++temp;
X             }
X          }
X           }
X        }
X     }
X      }
X   }
X   else /* double case */
X   {
X      if (new.y < 0)
X      {
X     temp = 2;
X     new.y = -new.y;
X      }
X      if (new.x < 0)
X      {
X     ++temp;
X     new.x = -new.x;
X      }
X      if (decomp[0] >= 8)
X      {
X     temp <<= 1;
X     if (new.x < new.y)
X     {
X        ++temp;
X        alt.x = new.x; /* just */
X        new.x = new.y; /* swap */
X        new.y = alt.x; /* them */
X     }
X     if (decomp[0] >= 16)
X     {
X        temp <<= 1;
X        if (new.x*tan22_5 < new.y)
X        {
X           ++temp;
X           alt = new;
X           new.x = alt.x*cos45 + alt.y*sin45;
X           new.y = alt.x*sin45 - alt.y*cos45;
X        }
X
X        if (decomp[0] >= 32)
X        {
X           temp <<= 1;
X           if (new.x*tan11_25 < new.y)
X           {
X          ++temp;
X          alt = new;
X          new.x = alt.x*cos22_5 + alt.y*sin22_5;
X          new.y = alt.x*sin22_5 - alt.y*cos22_5;
X           }
X
X           if (decomp[0] >= 64)
X           {
X          temp <<= 1;
X          if (new.x*tan5_625 < new.y)
X          {
X             ++temp;
X             alt = new;
X             new.x = alt.x*cos11_25 + alt.y*sin11_25;
X             new.y = alt.x*sin11_25 - alt.y*cos11_25;
X          }
X
X          if (decomp[0] >= 128)
X          {
X             temp <<= 1;
X             if (new.x*tan2_8125 < new.y)
X             {
X            ++temp;
X            alt = new;
X            new.x = alt.x*cos5_625 + alt.y*sin5_625;
X            new.y = alt.x*sin5_625 - alt.y*cos5_625;
X             }
X
X             if (decomp[0] == 256)
X             {
X            temp <<= 1;
X            if ((new.x*tan1_4063 < new.y))
X               ++temp;
X             }
X          }
X           }
X        }
X     }
X      }
X   }
X   for (i = 1; temp > 0; ++i)
X   {
X      if (temp & 1)
X     color = (1 << i) - 1 - color;
X      temp >>= 1;
X   }
X   if (decomp[0] == 2)
X      color &= 1;
X   if (colors > decomp[0])
X      color++;
X}
X
X/******************************************************************/
X/* Continuous potential calculation for Mandelbrot and Julia      */
X/* Reference: Science of Fractal Images p. 190.           */
X/* Special thanks to Mark Peterson for his "MtMand" program that  */
X/* beautifully approximates plate 25 (same reference) and spurred */
X/* on the inclusion of similar capabilities in FRACTINT.      */
X/*                                  */
X/* The purpose of this function is to calculate a color value      */
X/* for a fractal that varies continuously with the screen pixels  */
X/* locations for better rendering in 3D.              */
X/*                                  */
X/* Here "magnitude" is the modulus of the orbit value at          */
X/* "iterations". The potparms[] are user-entered paramters        */
X/* controlling the level and slope of the continuous potential      */
X/* surface. Returns color.  - Tim Wegner 6/25/89          */
X/*                                  */
X/*               -- Change history --              */
X/*                                  */
X/* 09/12/89   - added floatflag support and fixed float underflow */
X/*                                  */
X/******************************************************************/
X
Xstatic int _fastcall potential(double mag, int iterations)
X{
X   float f_mag,f_tmp,pot;
X   double d_tmp;
X   int i_pot;
X   long l_pot;
X   extern char floatflag;
X
X   if(iterations < maxit)
X   {
X      pot = i_pot = iterations+2;
X      if(i_pot <= 0 || mag <= 1.0)
X     pot = 0.0;
X      else /* pot = log(mag) / pow(2.0, (double)pot); */
X      {
X     if(i_pot < 120 && !floatflag) /* empirically determined limit of fShift */
X     {
X        f_mag = mag;
X        fLog14(f_mag,f_tmp); /* this SHOULD be non-negative */
X        fShift(f_tmp,(char)-i_pot,pot);
X     }
X     else
X     {
X        d_tmp = log(mag)/(double)pow(2.0,(double)pot);
X        if(d_tmp > FLT_MIN) /* prevent float type underflow */
X           pot = d_tmp;
X        else
X           pot = 0.0;
X     }
X      }
X      /* following transformation strictly for aesthetic reasons */
X      /* meaning of parameters:
X        potparam[0] -- zero potential level - highest color -
X        potparam[1] -- slope multiplier -- higher is steeper
X        potparam[2] -- rqlim value if changeable (bailout for modulus) */
X
X      if(pot > 0.0)
X      {
X     if(floatflag)
X        pot = (float)sqrt((double)pot);
X     else
X     {
X        fSqrt14(pot,f_tmp);
X        pot = f_tmp;
X     }
X     pot = potparam[0] - pot*potparam[1] - 1.0;
X      }
X      else
X     pot = potparam[0] - 1.0;
X      if(pot < 1.0)
X     pot = 1.0; /* avoid color 0 */
X   }
X   else if(inside >= 0)
X      pot = inside;
X   else /* inside < 0 implies inside=maxit, so use 1st pot param instead */
X      pot = potparam[0];
X
X   i_pot = (l_pot = pot * 256) >> 8;
X   if(i_pot >= colors)
X   {
X      i_pot = colors - 1;
X      l_pot = 255;
X   }
X
X   if(pot16bit)
X   {
X      if (dotmode != 11) /* if putcolor won't be doing it for us */
X     writedisk(col+sxoffs,row+syoffs,i_pot);
X      writedisk(col+sxoffs,row+sydots+syoffs,(int)l_pot);
X   }
X
X   return(i_pot);
X}
X
X
X/******************* boundary trace method ***************************
XFractint's original btm was written by David Guenther.  There were a few
Xrare circumstances in which the original btm would not trace or fill
Xcorrectly, even on Mandelbrot Sets.  The code below was adapted from
X"Mandelbrot Sets by Wesley Loewer" (see calmanfp.asm) which was written
Xbefore I was introduced to Fractint.  It should be noted that without
XDavid Guenther's implimentation of a btm, I doubt that I would have been
Xable to impliment my own code into Fractint.  There are several things in
Xthe following code that are not original with me but came from David
XGuenther's code.  I've noted these places with the initials DG.
X
X                    Wesley Loewer 3/8/92
X*********************************************************************/
X#define bkcolor 0  /* I have some ideas for the future with this. -Wes */
X#define advance_match()     coming_from = ((going_to = (going_to - 1) & 0x03) - 1) & 0x03
X#define advance_no_match()  going_to = (going_to + 1) & 0x03
X
Xstatic
Xint  bound_trace_main()
X    {
X    enum direction coming_from;
X    unsigned int match_found, continue_loop;
X    int trail_color, fillcolor_used, last_fillcolor_used;
X    int max_putline_length;
X    int right, left, length;
X
X    if (inside == 0 || outside == 0)
X    {
X    static char far msg[]=
X        "Boundary tracing cannot be used with inside=0 or outside=0.";
X    stopmsg(0,msg);
X    return(-1);
X    }
X    if (colors < 16)
X    {
X    static char far msg[]=
X        "Boundary tracing cannot be used with < 16 colors.";
X    stopmsg(0,msg);
X    return(-1);
X    }
X
X    got_status = 2;
X    max_putline_length = 0; /* reset max_putline_length */
X    for (currow = iystart; currow <= iystop; currow++)
X    {
X    reset_periodicity = 1; /* reset for a new row */
X    color = bkcolor;
X    for (curcol = ixstart; curcol <= ixstop; curcol++)
X        {
X        if (getcolor(curcol, currow) != bkcolor)
X        continue;
X
X        trail_color = color;
X        row = currow;
X        col = curcol;
X        if ((*calctype)()== -1) /* color, row, col are global */
X        {
X        if (iystop != yystop)  /* DG */
X           iystop = yystop - (currow - yystart); /* allow for sym */
X        add_worklist(xxstart,xxstop,currow,iystop,currow,0,worksym);
X        return -1;
X        }
X        reset_periodicity = 0; /* normal periodicity checking */
X
X        /*
X        This next line may cause a few more pixels to be calculated,
X        but at the savings of quite a bit of overhead
X        */
X        if (color != trail_color)  /* DG */
X        continue;
X
X        /* sweep clockwise to trace outline */
X        trail_row = currow;
X        trail_col = curcol;
X        trail_color = color;
X        fillcolor_used = fillcolor > 0 ? fillcolor : trail_color;
X        coming_from = West;
X        going_to = East;
X        match_found = 0;
X        continue_loop = TRUE;
X        do
X        {
X        step_col_row();
X        if (row >= currow
X            && col >= ixstart
X            && col <= ixstop
X            && row <= iystop)
X            {
X            /* the order of operations in this next line is critical */
X            if ((color = getcolor(col, row)) == bkcolor && (*calctype)()== -1)
X                /* color, row, col are global for (*calctype)() */
X            {
X            if (iystop != yystop)  /* DG */
X               iystop = yystop - (currow - yystart); /* allow for sym */
X            add_worklist(xxstart,xxstop,currow,iystop,currow,0,worksym);
X            return -1;
X            }
X            else if (color == trail_color)
X            {
X            if (match_found < 4) /* to keep it from overflowing */
X                match_found++;
X            trail_row = row;
X            trail_col = col;
X            advance_match();
X            }
X            else
X            {
X            advance_no_match();
X            continue_loop = going_to != coming_from || match_found;
X            }
X            }
X        else
X            {
X            advance_no_match();
X            continue_loop = going_to != coming_from || match_found;
X            }
X        } while (continue_loop && (col != curcol || row != currow));
X
X        if (match_found <= 3)  /* DG */
X        { /* no hole */
X        color = bkcolor;
X        reset_periodicity = 1;
X        continue;
X        }
X
X/*
XFill in region by looping around again, filling lines to the left
Xwhenever going_to is South or West
X*/
X        trail_row = currow;
X        trail_col = curcol;
X        coming_from = West;
X        going_to = East;
X        do
X        {
X        match_found = FALSE;
X        do
X            {
X            step_col_row();
X            if (row >= currow
X                && col >= ixstart
X                && col <= ixstop
X                && row <= iystop
X                && getcolor(col,row) == trail_color)
X                  /* getcolor() must be last */
X            {
X            if (going_to == South
X                || (going_to == West && coming_from != East))
X                { /* fill a row, but only once */
X                right = col;
X                while (--right >= ixstart && (color = getcolor(right,row)) == trail_color)
X                ; /* do nothing */
X                if (color == bkcolor) /* check last color */
X                {
X                left = right;
X                while (getcolor(--left,row) == bkcolor)
X                      /* Should NOT be possible for left < ixstart */
X                    ; /* do nothing */
X                left++; /* one pixel too far */
X                if (right == left) /* only one hole */
X                    (*plot)(left,row,fillcolor_used);
X                else
X                    { /* fill the line to the left */
X                    length=right-left+1;
X                    if (fillcolor_used != last_fillcolor_used || length > max_putline_length)
X                    { /* only reset dstack if necessary */
X                    memset(dstack,fillcolor_used,length);
X                    last_fillcolor_used = fillcolor_used;
X                    max_putline_length = length;
X                    }
X                    put_line(row,left,right,dstack);
X                    /* here's where all the symmetry goes */
X                    if (plot == putcolor)
X                    kbdcount -= length >> 4; /* seems like a reasonable value */
X                    else if (plot == symplot2) /* X-axis symmetry */
X                    {
X                    put_line(yystop-(row-yystart),left,right,dstack);
X                    kbdcount -= length >> 3;
X                    }
X                    else if (plot == symplot2Y) /* Y-axis symmetry */
X                    {
X                    put_line(row,xxstop-(right-xxstart),xxstop-(left-xxstart),dstack);
X                    kbdcount -= length >> 3;
X                    }
X                    else if (plot == symplot2J)  /* Origin symmetry */
X                    {
X                    put_line(yystop-(row-yystart),xxstop-(right-xxstart),xxstop-(left-xxstart),dstack);
X                    kbdcount -= length >> 3;
X                    }
X                    else if (plot == symplot4) /* X-axis and Y-axis symmetry */
X                    {
X                    put_line(yystop-(row-yystart),left,right,dstack);
X                    put_line(row,xxstop-(right-xxstart),xxstop-(left-xxstart),dstack);
X                    put_line(yystop-(row-yystart),xxstop-(right-xxstart),xxstop-(left-xxstart),dstack);
X                    kbdcount -= length >> 2;
X                    }
X                    else    /* cheap and easy way out */
X                    {
X                    int c;
X                    for (c = left; c <= right; c++)  /* DG */
X                        (*plot)(c,row,fillcolor_used);
X                    kbdcount -= length >> 1;
X                    }
X                    }
X                } /* end of fill line */
X
X                if(--kbdcount<=0)
X                {
X                if(check_key())
X                    {
X                    if (iystop != yystop)
X                       iystop = yystop - (currow - yystart); /* allow for sym */
X                    add_worklist(xxstart,xxstop,currow,iystop,currow,0,worksym);
X                    return(-1);
X                    }
X                kbdcount=max_kbdcount;
X                }
X                }
X            trail_row = row;
X            trail_col = col;
X            advance_match();
X            match_found = TRUE;
X            }
X            else
X            advance_no_match();
X            } while (!match_found && going_to != coming_from);
X
X        if (!match_found)
X            { /* next one has to be a match */
X            step_col_row();
X            trail_row = row;
X            trail_col = col;
X            advance_match();
X            }
X        } while (trail_col != curcol || trail_row != currow);
X        reset_periodicity = 1; /* reset after a trace/fill */
X        color = bkcolor;
X        }
X    }
X    return 0;
X    }
X
X/*******************************************************************/
X/* take one step in the direction of going_to */
Xstatic void step_col_row()
X    {
X    switch (going_to)
X    {
X    case North:
X        col = trail_col;
X        row = trail_row - 1;
X        break;
X    case East:
X        col = trail_col + 1;
X        row = trail_row;
X        break;
X    case South:
X        col = trail_col;
X        row = trail_row + 1;
X        break;
X    case West:
X        col = trail_col - 1;
X        row = trail_row;
X        break;
X    }
X    }
X
X/******************* end of boundary trace method *******************/
X
X
X/************************ super solid guessing *****************************/
X
X/*
X   I, Timothy Wegner, invented this solidguessing idea and implemented it in
X   more or less the overall framework you see here.  I am adding this note
X   now in a possibly vain attempt to secure my place in history, because
X   Pieter Branderhorst has totally rewritten this routine, incorporating
X   a *MUCH* more sophisticated algorithm.  His revised code is not only
X   faster, but is also more accurate. Harrumph!
X*/
X
Xstatic int solidguess()
X{
X   int i,x,y,xlim,ylim,blocksize;
X   unsigned int *pfxp0,*pfxp1;
X   unsigned int u;
X
X   guessplot=(plot!=putcolor && plot!=symplot2 && plot!=symplot2J);
X   /* check if guessing at bottom & right edges is ok */
X   bottom_guess = (plot == symplot2 || (plot == putcolor && iystop+1 == ydots));
X   right_guess    = (plot == symplot2J
X       || ((plot == putcolor || plot == symplot2) && ixstop+1 == xdots));
X
X   i = maxblock = blocksize = ssg_blocksize();
X   totpasses = 1;
X   while ((i >>= 1) > 1) ++totpasses;
X
X   /* ensure window top and left are on required boundary, treat window
X     as larger than it really is if necessary (this is the reason symplot
X     routines must check for > xdots/ydots before plotting sym points) */
X   ixstart &= -1 - (maxblock-1);
X   iystart = yybegin;
X   iystart &= -1 - (maxblock-1);
X
X   got_status = 1;
X
X   if (workpass == 0) /* otherwise first pass already done */
X   {
X      /* first pass, calc every blocksize**2 pixel, quarter result & paint it */
X      curpass = 1;
X      if (iystart <= yystart) /* first time for this window, init it */
X      {
X     currow = 0;
X     memset(&prefix[1][0][0],0,maxxblk*maxyblk*2); /* noskip flags off */
X     reset_periodicity = 1;
X     row=iystart;
X     for(col=ixstart; col<=ixstop; col+=maxblock)
X     { /* calc top row */
X        if((*calctype)()== -1)
X        {
X           add_worklist(xxstart,xxstop,yystart,yystop,yybegin,0,worksym);
X           goto exit_solidguess;
X        }
X        reset_periodicity = 0;
X     }
X      }
X      else
X     memset(&prefix[1][0][0],-1,maxxblk*maxyblk*2); /* noskip flags on */
X      for(y=iystart; y<=iystop; y+=blocksize)
X      {
X     currow = y;
X     i = 0;
X     if(y+blocksize<=iystop)
X     { /* calc the row below */
X        row=y+blocksize;
X        reset_periodicity = 1;
X        for(col=ixstart; col<=ixstop; col+=maxblock)
X        {
X           if((i=(*calctype)()) == -1)
X          break;
X           reset_periodicity = 0;
X        }
X     }
X     reset_periodicity = 1;
X     if (i == -1 || guessrow(1,y,blocksize) != 0) /* interrupted? */
X     {
X        if (y < yystart)
X           y = yystart;
X        add_worklist(xxstart,xxstop,yystart,yystop,y,0,worksym);
X        goto exit_solidguess;
X     }
X      }
X
X      if (num_worklist) /* work list not empty, just do 1st pass */
X      {
X     add_worklist(xxstart,xxstop,yystart,yystop,yystart,1,worksym);
X     goto exit_solidguess;
X      }
X      ++workpass;
X      iystart = yystart & (-1 - (maxblock-1));
X
X      /* calculate skip flags for skippable blocks */
X      xlim=(ixstop+maxblock)/maxblock+1;
X      ylim=((iystop+maxblock)/maxblock+15)/16+1;
X      if(right_guess==0) /* no right edge guessing, zap border */
X     for(y=0;y<=ylim;++y)
X        prefix[1][y][xlim]= -1;
X      if(bottom_guess==0) /* no bottom edge guessing, zap border */
X      {
X     i=(iystop+maxblock)/maxblock+1;
X     y=i/16+1;
X     i=1<<(i&15);
X     for(x=0;x<=xlim;++x)
X        prefix[1][y][x]|=i;
X      }
X      /* set each bit in prefix[0] to OR of it & surrounding 8 in prefix[1] */
X      for(y=0;++y<ylim;)
X      {
X     pfxp0= &prefix[0][y][0];
X     pfxp1= &prefix[1][y][0];
X     for(x=0;++x<xlim;)
X     {
X        ++pfxp1;
X        u= *(pfxp1-1)|*pfxp1|*(pfxp1+1);
X        *(++pfxp0)=u|(u>>1)|(u<<1)
X           |((*(pfxp1-(maxxblk+1))|*(pfxp1-maxxblk)|*(pfxp1-(maxxblk-1)))>>15)
X          |((*(pfxp1+(maxxblk-1))|*(pfxp1+maxxblk)|*(pfxp1+(maxxblk+1)))<<15);
X     }
X      }
X   }
X   else /* first pass already done */
X      memset(&prefix[0][0][0],-1,maxxblk*maxyblk*2); /* noskip flags on */
X
X   /* remaining pass(es), halve blocksize & quarter each blocksize**2 */
X   i = workpass;
X   while (--i > 0) /* allow for already done passes */
X      blocksize = blocksize>>1;
X   reset_periodicity = 1;
X   while((blocksize=blocksize>>1)>=2)
X   {
X      curpass = workpass + 1;
X      for(y=iystart; y<=iystop; y+=blocksize)
X      {
X     currow = y;
X     if(guessrow(0,y,blocksize)!=0)
X     {
X        if (y < yystart)
X           y = yystart;
X        add_worklist(xxstart,xxstop,yystart,yystop,y,workpass,worksym);
X        goto exit_solidguess;
X     }
X      }
X      ++workpass;
X      if (num_worklist /* work list not empty, do one pass at a time */
X      && blocksize>2) /* if 2, we just did last pass */
X      {
X     add_worklist(xxstart,xxstop,yystart,yystop,yystart,workpass,worksym);
X     goto exit_solidguess;
X      }
X      iystart = yystart & (-1 - (maxblock-1));
X   }
X
X   exit_solidguess:
X   return(0);
X}
X
X#define calcadot(c,x,y) { col=x; row=y; if((c=(*calctype)())== -1) return -1; }
X
Xstatic int _fastcall guessrow(int firstpass,int y,int blocksize)
X{
X   int x,i,j,color;
X   int xplushalf,xplusblock;
X   int ylessblock,ylesshalf,yplushalf,yplusblock;
X   int       c21,c31,c41;     /* cxy is the color of pixel at (x,y) */
X   int c12,c22,c32,c42;     /* where c22 is the topleft corner of */
X   int c13,c23,c33;        /* the block being handled in current */
X   int       c24,    c44;     /* iteration                  */
X   int guessed23,guessed32,guessed33,guessed12,guessed13;
X   int prev11,fix21,fix31;
X   unsigned int *pfxptr,pfxmask;
X
X   halfblock=blocksize>>1;
X   i=y/maxblock;
X   pfxptr= &prefix[firstpass][(i>>4)+1][ixstart/maxblock];
X   pfxmask=1<<(i&15);
X   ylesshalf=y-halfblock;
X   ylessblock=y-blocksize; /* constants, for speed */
X   yplushalf=y+halfblock;
X   yplusblock=y+blocksize;
X   prev11= -1;
X   c24=c12=c13=c22=getcolor(ixstart,y);
X   c31=c21=getcolor(ixstart,(y>0)?ylesshalf:0);
X   if(yplusblock<=iystop)
X      c24=getcolor(ixstart,yplusblock);
X   else if(bottom_guess==0)
X      c24= -1;
X   guessed12=guessed13=0;
X
X   for(x=ixstart; x<=ixstop;)  /* increment at end, or when doing continue */
X   {
X      if((x&(maxblock-1))==0)  /* time for skip flag stuff */
X      {
X     ++pfxptr;
X     if(firstpass==0 && (*pfxptr&pfxmask)==0)  /* check for fast skip */
X     {
X        /* next useful in testing to make skips visible */
X        /*
X               if(halfblock==1)
X               {
X                  (*plot)(x+1,y,0); (*plot)(x,y+1,0); (*plot)(x+1,y+1,0);
X                  }
X             */
X        x+=maxblock;
X        prev11=c31=c21=c24=c12=c13=c22;
X        guessed12=guessed13=0;
X        continue;
X     }
X      }
X
X      if(firstpass)  /* 1st pass, paint topleft corner */
X     plotblock(0,x,y,c22);
X      /* setup variables */
X      xplusblock=(xplushalf=x+halfblock)+halfblock;
X      if(xplushalf>ixstop)
X      {
X     if(right_guess==0)
X        c31= -1;
X      }
X      else if(y>0)
X     c31=getcolor(xplushalf,ylesshalf);
X      if(xplusblock<=ixstop)
X      {
X     if(yplusblock<=iystop)
X        c44=getcolor(xplusblock,yplusblock);
X     c41=getcolor(xplusblock,(y>0)?ylesshalf:0);
X     c42=getcolor(xplusblock,y);
X      }
X      else if(right_guess==0)
X     c41=c42=c44= -1;
X      if(yplusblock>iystop)
X     c44=(bottom_guess)?c42:-1;
X
X      /* guess or calc the remaining 3 quarters of current block */
X      guessed23=guessed32=guessed33=1;
X      c23=c32=c33=c22;
X      if(yplushalf>iystop)
X      {
X     if(bottom_guess==0)
X        c23=c33= -1;
X     guessed23=guessed33= -1;
X      }
X      if(xplushalf>ixstop)
X      {
X     if(right_guess==0)
X        c32=c33= -1;
X     guessed32=guessed33= -1;
X      }
X      while(1) /* go around till none of 23,32,33 change anymore */
X      {
X     if(guessed33>0
X         && (c33!=c44 || c33!=c42 || c33!=c24 || c33!=c32 || c33!=c23))
X     {
X        calcadot(c33,xplushalf,yplushalf);
X        guessed33=0;
X     }
X     if(guessed32>0
X         && (c32!=c33 || c32!=c42 || c32!=c31 || c32!=c21
X         || c32!=c41 || c32!=c23))
X     {
X        calcadot(c32,xplushalf,y);
X        guessed32=0;
X        continue;
X     }
X     if(guessed23>0
X         && (c23!=c33 || c23!=c24 || c23!=c13 || c23!=c12 || c23!=c32))
X     {
X        calcadot(c23,x,yplushalf);
X        guessed23=0;
X        continue;
X     }
X     break;
X      }
X
X      if(firstpass) /* note whether any of block's contents were calculated */
X     if(guessed23==0 || guessed32==0 || guessed33==0)
X        *pfxptr|=pfxmask;
X
X      if(halfblock>1) /* not last pass, check if something to display */
X     if(firstpass)    /* display guessed corners, fill in block */
X     {
X        if(guessplot)
X        {
X           if(guessed23>0)
X          (*plot)(x,yplushalf,c23);
X           if(guessed32>0)
X          (*plot)(xplushalf,y,c32);
X           if(guessed33>0)
X          (*plot)(xplushalf,yplushalf,c33);
X        }
X        plotblock(1,x,yplushalf,c23);
X        plotblock(0,xplushalf,y,c32);
X        plotblock(1,xplushalf,yplushalf,c33);
X     }
X     else  /* repaint changed blocks */
X     {
X        if(c23!=c22)
X           plotblock(-1,x,yplushalf,c23);
X        if(c32!=c22)
X           plotblock(-1,xplushalf,y,c32);
X        if(c33!=c22)
X           plotblock(-1,xplushalf,yplushalf,c33);
X     }
X
X      /* check if some calcs in this block mean earlier guesses need fixing */
X      fix21=((c22!=c12 || c22!=c32)
X      && c21==c22 && c21==c31 && c21==prev11
X      && y>0
X      && (x==ixstart || c21==getcolor(x-halfblock,ylessblock))
X      && (xplushalf>ixstop || c21==getcolor(xplushalf,ylessblock))
X      && c21==getcolor(x,ylessblock));
X      fix31=(c22!=c32
X      && c31==c22 && c31==c42 && c31==c21 && c31==c41
X      && y>0 && xplushalf<=ixstop
X      && c31==getcolor(xplushalf,ylessblock)
X      && (xplusblock>ixstop || c31==getcolor(xplusblock,ylessblock))
X      && c31==getcolor(x,ylessblock));
X      prev11=c31; /* for next time around */
X      if(fix21)
X      {
X     calcadot(c21,x,ylesshalf);
X     if(halfblock>1 && c21!=c22)
X        plotblock(-1,x,ylesshalf,c21);
X      }
X      if(fix31)
X      {
X     calcadot(c31,xplushalf,ylesshalf);
X     if(halfblock>1 && c31!=c22)
X        plotblock(-1,xplushalf,ylesshalf,c31);
X      }
X      if(c23!=c22)
X      {
X     if(guessed12)
X     {
X        calcadot(c12,x-halfblock,y);
X        if(halfblock>1 && c12!=c22)
X           plotblock(-1,x-halfblock,y,c12);
X     }
X     if(guessed13)
X     {
X        calcadot(c13,x-halfblock,yplushalf);
X        if(halfblock>1 && c13!=c22)
X           plotblock(-1,x-halfblock,yplushalf,c13);
X     }
X      }
X      c22=c42;
X      c24=c44;
X      c13=c33;
X      c31=c21=c41;
X      c12=c32;
X      guessed12=guessed32;
X      guessed13=guessed33;
X      x+=blocksize;
X   } /* end x loop */
X
X   if(firstpass==0 || guessplot) return 0;
X
X   /* paint rows the fast way */
X   for(i=0;i<halfblock;++i)
X   {
X      if((j=y+i)<=iystop)
X     put_line(j,xxstart,ixstop,&dstack[xxstart]);
X      if((j=y+i+halfblock)<=iystop)
X     put_line(j,xxstart,ixstop,&dstack[xxstart+MAXPIXELS]);
X      if(keypressed()) return -1;
X   }
X   if(plot!=putcolor)  /* symmetry, just vertical & origin the fast way */
X   {
X      if(plot==symplot2J) /* origin sym, reverse lines */
X     for(i=(ixstop+xxstart+1)/2;--i>=xxstart;)
X     {
X        color=dstack[i];
X        dstack[i]=dstack[j=ixstop-(i-xxstart)];
X        dstack[j]=color;
X        j+=MAXPIXELS;
X        color=dstack[i+MAXPIXELS];
X        dstack[i+MAXPIXELS]=dstack[j];
X        dstack[j]=color;
X     }
X      for(i=0;i<halfblock;++i)
X      {
X     if((j=yystop-(y+i-yystart))>iystop && j<ydots)
X        put_line(j,xxstart,ixstop,&dstack[xxstart]);
X     if((j=yystop-(y+i+halfblock-yystart))>iystop && j<ydots)
X        put_line(j,xxstart,ixstop,&dstack[xxstart+MAXPIXELS]);
X     if(keypressed()) return -1;
X      }
X   }
X   return 0;
X}
X
Xstatic void _fastcall plotblock(int buildrow,int x,int y,int color)
X{
X   int i,xlim,ylim;
X   if((xlim=x+halfblock)>ixstop)
X      xlim=ixstop+1;
X   if(buildrow>=0 && guessplot==0) /* save it for later put_line */
X   {
X      if(buildrow==0)
X     for(i=x;i<xlim;++i)
X        dstack[i]=color;
X      else
X     for(i=x;i<xlim;++i)
X        dstack[i+MAXPIXELS]=color;
X      if (x>=xxstart) /* when x reduced for alignment, paint those dots too */
X     return; /* the usual case */
X   }
X   /* paint it */
X   if((ylim=y+halfblock)>iystop)
X   {
X      if(y>iystop)
X     return;
X      ylim=iystop+1;
X   }
X   for(i=x;++i<xlim;)
X      (*plot)(i,y,color); /* skip 1st dot on 1st row */
X   while(++y<ylim)
X      for(i=x;i<xlim;++i)
X     (*plot)(i,y,color);
X}
X
X
X/************************* symmetry plot setup ************************/
X
Xstatic int _fastcall xsym_split(int xaxis_row,int xaxis_between)
X{
X   int i;
X   if ((worksym&0x11) == 0x10) /* already decided not sym */
X      return(1);
X   if ((worksym&1) != 0) /* already decided on sym */
X      iystop = (yystart+yystop)/2;
X   else /* new window, decide */
X   {
X      worksym |= 0x10;
X      if (xaxis_row <= yystart || xaxis_row >= yystop)
X     return(1); /* axis not in window */
X      i = xaxis_row + (xaxis_row - yystart);
X      if (xaxis_between)
X     ++i;
X      if (i > yystop) /* split into 2 pieces, bottom has the symmetry */
X      {
X     if (num_worklist >= MAXCALCWORK-1) /* no room to split */
X        return(1);
X     iystop = xaxis_row - (yystop - xaxis_row);
X     if (!xaxis_between)
X        --iystop;
X     add_worklist(xxstart,xxstop,iystop+1,yystop,iystop+1,workpass,0);
X     yystop = iystop;
X     return(1); /* tell set_symmetry no sym for current window */
X      }
X      if (i < yystop) /* split into 2 pieces, top has the symmetry */
X      {
X     if (num_worklist >= MAXCALCWORK-1) /* no room to split */
X        return(1);
X     add_worklist(xxstart,xxstop,i+1,yystop,i+1,workpass,0);
X     yystop = i;
X      }
X      iystop = xaxis_row;
X      worksym |= 1;
X   }
X   symmetry = 0;
X   return(0); /* tell set_symmetry its a go */
X}
X
Xstatic int _fastcall ysym_split(int yaxis_col,int yaxis_between)
X{
X   int i;
X   if ((worksym&0x22) == 0x20) /* already decided not sym */
X      return(1);
X   if ((worksym&2) != 0) /* already decided on sym */
X      ixstop = (xxstart+xxstop)/2;
X   else /* new window, decide */
X   {
X      worksym |= 0x20;
X      if (yaxis_col <= xxstart || yaxis_col >= xxstop)
X     return(1); /* axis not in window */
X      i = yaxis_col + (yaxis_col - xxstart);
X      if (yaxis_between)
X     ++i;
X      if (i > xxstop) /* split into 2 pieces, right has the symmetry */
X      {
X     if (num_worklist >= MAXCALCWORK-1) /* no room to split */
X        return(1);
X     ixstop = yaxis_col - (xxstop - yaxis_col);
X     if (!yaxis_between)
X        --ixstop;
X     add_worklist(ixstop+1,xxstop,yystart,yystop,yystart,workpass,0);
X     xxstop = ixstop;
X     return(1); /* tell set_symmetry no sym for current window */
X      }
X      if (i < xxstop) /* split into 2 pieces, left has the symmetry */
X      {
X     if (num_worklist >= MAXCALCWORK-1) /* no room to split */
X        return(1);
X     add_worklist(i+1,xxstop,yystart,yystop,yystart,workpass,0);
X     xxstop = i;
X      }
X      ixstop = yaxis_col;
X      worksym |= 2;
X   }
X   symmetry = 0;
X   return(0); /* tell set_symmetry its a go */
X}
X
X#ifdef _MSC_VER
X#pragma optimize ("ea", off)
X#endif
X
Xstatic void _fastcall setsymmetry(int sym, int uselist) /* set up proper symmetrical plot functions */
X{
X   extern int forcesymmetry;
X   int i;
X   int parmszero;
X   int xaxis_row, yaxis_col;         /* pixel number for origin */
X   int xaxis_between, yaxis_between; /* if axis between 2 pixels, not on one */
X   double ftemp;
X   symmetry = 1;
X   TranspSymmetry = sym;         /* for tp3d.c, MCP 6-1-90 */
X   if(sym == NOPLOT && forcesymmetry == 999)
X   {
X      plot = noplot;
X      return;
X   }
X   /* NOTE: 16-bit potential disables symmetry */
X   /* also any decomp= option and any inversion not about the origin */
X   /* also any rotation other than 180deg and any off-axis stretch */
X   if ((potflag && pot16bit) || (invert && inversion[2] != 0.0)
X       || decomp[0] != 0
X       || xxmin!=xx3rd || yymin!=yy3rd)
X      return;
X   if(sym != XAXIS && sym != XAXIS_NOPARM && inversion[1] != 0.0 && forcesymmetry == 999)
X      return;
X   if(forcesymmetry < 999)
X      sym = forcesymmetry;
X   else if(forcesymmetry == 1000)
X      forcesymmetry = sym;  /* for backwards compatibility */
X   else if(outside==REAL || outside==IMAG || outside==MULT || outside==SUM)
X      return;
X   parmszero = (parm.x == 0.0 && parm.y == 0.0 && useinitorbit != 1);
X   switch (fractype)
X   { case LMANLAMFNFN:      /* These need only P1 checked. */
X     case FPMANLAMFNFN:     /* P2 is used for a switch value */
X     case LMANFNFN:         /* These have NOPARM set in fractalp.c, */
X     case FPMANFNFN:        /* but it only applies to P1. */
X     case FPMANDELZPOWER:   /* or P2 is an exponent */
X     case LMANDELZPOWER:
X     case FPMANZTOZPLUSZPWR:
X       break;
X     default:   /* Check P2 for the rest */
X       parmszero = (parmszero && parm2.x == 0.0 && parm2.y == 0.0);
X   }
X   xaxis_row = yaxis_col = -1;
X   if (fabs(yymin+yymax) < fabs(yymin)+fabs(yymax)) /* axis is on screen */
X   {
X      ftemp = (0.0-yymax) / (yymin-yymax) * (ydots-1) + 0.25;
X      xaxis_row = ftemp;
X      xaxis_between = (ftemp - xaxis_row >= 0.5);
X      if (uselist == 0 && (!xaxis_between || (xaxis_row+1)*2 != ydots))
X     xaxis_row = -1; /* can't split screen, so dead center or not at all */
X   }
X   if (fabs(xxmin+xxmax) < fabs(xxmin)+fabs(xxmax)) /* axis is on screen */
X   {
X      ftemp = (0.0-xxmin) / (xxmax-xxmin) * (xdots-1) + 0.25;
X      yaxis_col = ftemp;
X      yaxis_between = (ftemp - yaxis_col >= 0.5);
X      if (uselist == 0 && (!yaxis_between || (yaxis_col+1)*2 != xdots))
X     yaxis_col = -1; /* can't split screen, so dead center or not at all */
X   }
X   switch(sym)         /* symmetry switch */
X   {
X   case XAXIS_NOREAL:     /* X-axis Symmetry (no real param) */
X      if (parm.x != 0.0) break;
X      goto xsym;
X   case XAXIS_NOIMAG:     /* X-axis Symmetry (no imag param) */
X      if (parm.y != 0.0) break;
X      goto xsym;
X   case XAXIS_NOPARM:                 /* X-axis Symmetry  (no params)*/
X      if (!parmszero)
X     break;
X      xsym:
X   case XAXIS:                 /* X-axis Symmetry */
X      if (xsym_split(xaxis_row,xaxis_between) == 0)
X     if(basin)
X        plot = symplot2basin;
X     else
X        plot = symplot2;
X      break;
X   case YAXIS_NOPARM:                 /* Y-axis Symmetry (No Parms)*/
X      if (!parmszero)
X     break;
X   case YAXIS:                 /* Y-axis Symmetry */
X      if (ysym_split(yaxis_col,yaxis_between) == 0)
X     plot = symplot2Y;
X      break;
X   case XYAXIS_NOPARM:                 /* X-axis AND Y-axis Symmetry (no parms)*/
X      if(!parmszero)
X     break;
X   case XYAXIS:              /* X-axis AND Y-axis Symmetry */
X      xsym_split(xaxis_row,xaxis_between);
X      ysym_split(yaxis_col,yaxis_between);
X      switch (worksym & 3)
X      {
X      case 1: /* just xaxis symmetry */
X     if(basin)
X        plot = symplot2basin;
X     else
X        plot = symplot2 ;
X     break;
X      case 2: /* just yaxis symmetry */
X     if (basin) /* got no routine for this case */
X     {
X        ixstop = xxstop; /* fix what split should not have done */
X        symmetry = 1;
X     }
X     else
X        plot = symplot2Y;
X     break;
X      case 3: /* both axes */
X     if(basin)
X        plot = symplot4basin;
X     else
X        plot = symplot4 ;
X      }
X      break;
X   case ORIGIN_NOPARM:                 /* Origin Symmetry (no parms)*/
X      if (!parmszero)
X     break;
X   case ORIGIN:              /* Origin Symmetry */
X      originsym:
X      if ( xsym_split(xaxis_row,xaxis_between) == 0
X      && ysym_split(yaxis_col,yaxis_between) == 0)
X      {
X     plot = symplot2J;
X     ixstop = xxstop; /* didn't want this changed */
X      }
X      else
X      {
X     iystop = yystop; /* in case first split worked */
X     symmetry = 1;
X     worksym = 0x30; /* let it recombine with others like it */
X      }
X      break;
X   case PI_SYM_NOPARM:
X      if (!parmszero)
X     break;
X   case PI_SYM:              /* PI symmetry */
X      if(fabs(xxmax - xxmin) < PI/4)
X         break; /* no point in pi symmetry if values too close */
X      if(invert && forcesymmetry == 999)
X     goto originsym;
X      plot = symPIplot ;
X      symmetry = 0;
X      if ( xsym_split(xaxis_row,xaxis_between) == 0
X      && ysym_split(yaxis_col,yaxis_between) == 0)
X     if(parm.y == 0.0)
X        plot = symPIplot4J; /* both axes */
X     else
X        plot = symPIplot2J; /* origin */
X      else
X      {
X     iystop = yystop; /* in case first split worked */
X     worksym = 0x30;  /* don't mark pisym as ysym, just do it unmarked */
X      }
X      pixelpi = (PI/fabs(xxmax-xxmin))*xdots; /* PI in pixels */
X      if ( (ixstop = xxstart+pixelpi-1 ) > xxstop)
X     ixstop = xxstop;
X      if (plot == symPIplot4J && ixstop > (i = (xxstart+xxstop)/2))
X     ixstop = i;
X      break;
X   default:             /* no symmetry */
X      break;
X   }
X}
X
X#ifdef _MSC_VER
X#pragma optimize ("ea", on)
X#endif
X
X/**************** tesseral method by CJLT begins here*********************/
X/*  reworked by PB for speed and resumeability */
X
Xstruct tess { /* one of these per box to be done gets stacked */
X   int x1,x2,y1,y2;     /* left/right top/bottom x/y coords  */
X   int top,bot,lft,rgt;  /* edge colors, -1 mixed, -2 unknown */
X};
X
Xstatic int tesseral()
X{
X   register struct tess *tp;
X
X   guessplot = (plot != putcolor && plot != symplot2);
X   tp = (struct tess *)&dstack[0];
X   tp->x1 = ixstart;                  /* set up initial box */
X   tp->x2 = ixstop;
X   tp->y1 = iystart;
X   tp->y2 = iystop;
X
X   if (workpass == 0) { /* not resuming */
X      tp->top = tessrow(ixstart,ixstop,iystart);     /* Do top row */
X      tp->bot = tessrow(ixstart,ixstop,iystop);      /* Do bottom row */
X      tp->lft = tesscol(ixstart,iystart+1,iystop-1); /* Do left column */
X      tp->rgt = tesscol(ixstop,iystart+1,iystop-1);  /* Do right column */
X      if (check_key()) { /* interrupt before we got properly rolling */
X         add_worklist(xxstart,xxstop,yystart,yystop,yystart,0,worksym);
X         return(-1);
X      }
X   }
X
X   else { /* resuming, rebuild work stack */
X      int i,mid,curx,cury,xsize,ysize;
X      struct tess *tp2;
X      tp->top = tp->bot = tp->lft = tp->rgt = -2;
X      cury = yybegin & 0xfff;
X      ysize = 1;
X      i = (unsigned)yybegin >> 12;
X      while (--i >= 0) ysize <<= 1;
X      curx = workpass & 0xfff;
X      xsize = 1;
X      i = (unsigned)workpass >> 12;
X      while (--i >= 0) xsize <<= 1;
X      while (1) {
X         tp2 = tp;
X         if (tp->x2 - tp->x1 > tp->y2 - tp->y1) { /* next divide down middle */
X            if (tp->x1 == curx && (tp->x2 - tp->x1 - 2) < xsize)
X               break;
X            mid = (tp->x1 + tp->x2) >> 1;         /* Find mid point */
X            if (mid > curx) { /* stack right part */
X               memcpy(++tp,tp2,sizeof(*tp));
X               tp->x2 = mid;
X            }
X            tp2->x1 = mid;
X         }
X         else {                   /* next divide across */
X            if (tp->y1 == cury && (tp->y2 - tp->y1 - 2) < ysize) break;
X            mid = (tp->y1 + tp->y2) >> 1;         /* Find mid point */
X            if (mid > cury) { /* stack bottom part */
X               memcpy(++tp,tp2,sizeof(*tp));
X               tp->y2 = mid;
X            }
X            tp2->y1 = mid;
X         }
X      }
X   }
X
X   got_status = 4; /* for tab_display */
X
X   while (tp >= (struct tess *)&dstack[0]) { /* do next box */
X      curcol = tp->x1; /* for tab_display */
X      currow = tp->y1;
X
X      if (tp->top == -1 || tp->bot == -1 || tp->lft == -1 || tp->rgt == -1)
X         goto tess_split;
X      /* for any edge whose color is unknown, set it */
X      if (tp->top == -2)
X         tp->top = tesschkrow(tp->x1,tp->x2,tp->y1);
X      if (tp->top == -1)
X         goto tess_split;
X      if (tp->bot == -2)
X         tp->bot = tesschkrow(tp->x1,tp->x2,tp->y2);
X      if (tp->bot != tp->top)
X         goto tess_split;
X      if (tp->lft == -2)
X         tp->lft = tesschkcol(tp->x1,tp->y1,tp->y2);
X      if (tp->lft != tp->top)
X         goto tess_split;
X      if (tp->rgt == -2)
X         tp->rgt = tesschkcol(tp->x2,tp->y1,tp->y2);
X      if (tp->rgt != tp->top)
X         goto tess_split;
X
X      {
X      int mid,midcolor;
X      if (tp->x2 - tp->x1 > tp->y2 - tp->y1) { /* divide down the middle */
X         mid = (tp->x1 + tp->x2) >> 1;         /* Find mid point */
X         midcolor = tesscol(mid, tp->y1+1, tp->y2-1); /* Do mid column */
X         if (midcolor != tp->top) goto tess_split;
X         }
X      else {                   /* divide across the middle */
X         mid = (tp->y1 + tp->y2) >> 1;         /* Find mid point */
X         midcolor = tessrow(tp->x1+1, tp->x2-1, mid); /* Do mid row */
X         if (midcolor != tp->top) goto tess_split;
X         }
X      }
X
X      {  /* all 4 edges are the same color, fill in */
X         int i,j;
X         i = 0;
X         if(fillcolor != 0)
X         {
X         if(fillcolor > 0)
X            tp->top = fillcolor & (colors-1);
X         if (guessplot || (j = tp->x2 - tp->x1 - 1) < 2) { /* paint dots */
X            for (col = tp->x1 + 1; col < tp->x2; col++)
X               for (row = tp->y1 + 1; row < tp->y2; row++) {
X                  (*plot)(col,row,tp->top);
X                  if (++i > 500) {
X                     if (check_key()) goto tess_end;
X                     i = 0;
X                  }
X               }
X         }
X         else { /* use put_line for speed */
X            memset(&dstack[MAXPIXELS],tp->top,j);
X            for (row = tp->y1 + 1; row < tp->y2; row++) {
X               put_line(row,tp->x1+1,tp->x2-1,&dstack[MAXPIXELS]);
X               if (plot != putcolor) /* symmetry */
X                  if ((j = yystop-(row-yystart)) > iystop && j < ydots)
X                     put_line(j,tp->x1+1,tp->x2-1,&dstack[MAXPIXELS]);
X               if (++i > 25) {
X                  if (check_key()) goto tess_end;
X                  i = 0;
X               }
X            }
X         }
X         }
X         --tp;
X      }
X      continue;
X
X      tess_split:
X      {  /* box not surrounded by same color, sub-divide */
X         int mid,midcolor;
X         struct tess *tp2;
X         if (tp->x2 - tp->x1 > tp->y2 - tp->y1) { /* divide down the middle */
X            mid = (tp->x1 + tp->x2) >> 1;         /* Find mid point */
X            midcolor = tesscol(mid, tp->y1+1, tp->y2-1); /* Do mid column */
X            if (midcolor == -3) goto tess_end;
X            if (tp->x2 - mid > 1) {    /* right part >= 1 column */
X               if (tp->top == -1) tp->top = -2;
X               if (tp->bot == -1) tp->bot = -2;
X               tp2 = tp;
X               if (mid - tp->x1 > 1) { /* left part >= 1 col, stack right */
X                  memcpy(++tp,tp2,sizeof(*tp));
X                  tp->x2 = mid;
X                  tp->rgt = midcolor;
X               }
X               tp2->x1 = mid;
X               tp2->lft = midcolor;
X            }
X            else
X               --tp;
X         }
X         else {                   /* divide across the middle */
X            mid = (tp->y1 + tp->y2) >> 1;         /* Find mid point */
X            midcolor = tessrow(tp->x1+1, tp->x2-1, mid); /* Do mid row */
X            if (midcolor == -3) goto tess_end;
X            if (tp->y2 - mid > 1) {    /* bottom part >= 1 column */
X               if (tp->lft == -1) tp->lft = -2;
X               if (tp->rgt == -1) tp->rgt = -2;
X               tp2 = tp;
X               if (mid - tp->y1 > 1) { /* top also >= 1 col, stack bottom */
X                  memcpy(++tp,tp2,sizeof(*tp));
X                  tp->y2 = mid;
X                  tp->bot = midcolor;
X               }
X               tp2->y1 = mid;
X               tp2->top = midcolor;
X            }
X            else
X               --tp;
X         }
X      }
X
X   }
X
X   tess_end:
X   if (tp >= (struct tess *)&dstack[0]) { /* didn't complete */
X      int i,xsize,ysize;
X      xsize = ysize = 1;
X      i = 2;
X      while (tp->x2 - tp->x1 - 2 >= i) {
X         i <<= 1;
X         ++xsize;
X      }
X      i = 2;
X      while (tp->y2 - tp->y1 - 2 >= i) {
X         i <<= 1;
X         ++ysize;
X      }
X      add_worklist(xxstart,xxstop,yystart,yystop,
X          (ysize<<12)+tp->y1,(xsize<<12)+tp->x1,worksym);
X      return(-1);
X   }
X   return(0);
X
X} /* tesseral */
X
Xstatic int _fastcall tesschkcol(int x,int y1,int y2)
X{
X   int i;
X   i = getcolor(x,++y1);
X   while (--y2 > y1)
X      if (getcolor(x,y2) != i) return -1;
X   return i;
X}
X
Xstatic int _fastcall tesschkrow(int x1,int x2,int y)
X{
X   int i;
X   i = getcolor(x1,y);
X   while (x2 > x1) {
X      if (getcolor(x2,y) != i) return -1;
X      --x2;
X   }
X   return i;
X}
X
Xstatic int _fastcall tesscol(int x,int y1,int y2)
X{
X   int colcolor,i;
X   col = x;
X   row = y1;
X   reset_periodicity = 1;
X   colcolor = (*calctype)();
X   reset_periodicity = 0;
X   while (++row <= y2) { /* generate the column */
X      if ((i = (*calctype)()) < 0) return -3;
X      if (i != colcolor) colcolor = -1;
X   }
X   return colcolor;
X}
X
Xstatic int _fastcall tessrow(int x1,int x2,int y)
X{
X   int rowcolor,i;
X   row = y;
X   col = x1;
X   reset_periodicity = 1;
X   rowcolor = (*calctype)();
X   reset_periodicity = 0;
X   while (++col <= x2) { /* generate the row */
X      if ((i = (*calctype)()) < 0) return -3;
X      if (i != rowcolor) rowcolor = -1;
X   }
X   return rowcolor;
X}
X
X/* added for testing autologmap() */ /* CAE 9211 fixed missing comment */
X/* insert at end of CALCFRAC.C */
X
Xstatic int autologmap()   /*RB*/
X{  /* calculate round screen edges to avoid wasted colours in logmap */
X int mincolour,lag;
X mincolour=32767;
X row=iystart;
X reset_periodicity = 0;
X for (col=ixstart;col<ixstop;col++) /* top row */
X    {
X      color=(*calctype)();
X      if (realcolor < mincolour) mincolour=realcolor ;
X      if ( col >=32 ) (*plot)(col-32,row,0);
X    }                                    /* these lines tidy up for BTM etc */
X    for (lag=32;lag>0;lag--) (*plot)(col-lag,row,0);
X
X col=ixstop;
X for (row=iystart;row<iystop;row++) /* right  side */
X    {
X      color=(*calctype)();
X      if (realcolor < mincolour) mincolour=realcolor ;
X      if ( row >=32 ) (*plot)(col,row-32,0);
X    }
X    for (lag=32;lag>0;lag--) (*plot)(col,row-lag,0);
X
X col=ixstart;
X for (row=iystart;row<iystop;row++) /* left  side */
X    {
X      color=(*calctype)();
X      if (realcolor < mincolour) mincolour=realcolor ;
X      if ( row >=32 ) (*plot)(col,row-32,0);
X    }
X    for (lag=32;lag>0;lag--) (*plot)(col,row-lag,0);
X
X row=iystop ;
X for (col=ixstart;col<ixstop;col++) /* bottom row */
X    {
X      color=(*calctype)();
X      if (realcolor < mincolour) mincolour=realcolor ;
X      if ( col >=32 ) (*plot)(col-32,row,0);
X    }
X    for (lag=32;lag>0;lag--) (*plot)(col-lag,row,0);
X
X if (mincolour==2) resuming=1; /* insure autologmap not called again */
X
X return mincolour;
X}
X
X/* Symmetry plot for period PI */
Xvoid _fastcall symPIplot(x, y, color)
Xint x, y, color ;
X{
X   while(x <= xxstop)
X   {
X      putcolor(x, y, color) ;
X      x += pixelpi;
X   }
X}
X/* Symmetry plot for period PI plus Origin Symmetry */
Xvoid _fastcall symPIplot2J(x, y, color)
Xint x, y, color ;
X{
X   int i,j;
X   while(x <= xxstop)
X   {
X      putcolor(x, y, color) ;
X      if ((i=yystop-(y-yystart)) > iystop && i < ydots
X      && (j=xxstop-(x-xxstart)) < xdots)
X     putcolor(j, i, color) ;
X      x += pixelpi;
X   }
X}
X/* Symmetry plot for period PI plus Both Axis Symmetry */
Xvoid _fastcall symPIplot4J(x, y, color)
Xint x, y, color ;
X{
X   int i,j;
X   while(x <= (xxstart+xxstop)/2)
X   {
X      j = xxstop-(x-xxstart);
X      putcolor(       x , y , color) ;
X      if (j < xdots)
X     putcolor(j , y , color) ;
X      if ((i=yystop-(y-yystart)) > iystop && i < ydots)
X      {
X     putcolor(x , i , color) ;
X     if (j < xdots)
X        putcolor(j , i , color) ;
X      }
X      x += pixelpi;
X   }
X}
X
X/* Symmetry plot for X Axis Symmetry */
Xvoid _fastcall symplot2(x, y, color)
Xint x, y, color ;
X{
X   int i;
X   putcolor(x, y, color) ;
X   if ((i=yystop-(y-yystart)) > iystop && i < ydots)
X      putcolor(x, i, color) ;
X}
X
X/* Symmetry plot for Y Axis Symmetry */
Xvoid _fastcall symplot2Y(x, y, color)
Xint x, y, color ;
X{
X   int i;
X   putcolor(x, y, color) ;
X   if ((i=xxstop-(x-xxstart)) < xdots)
X      putcolor(i, y, color) ;
X}
X
X/* Symmetry plot for Origin Symmetry */
Xvoid _fastcall symplot2J(x, y, color)
Xint x, y, color ;
X{
X   int i,j;
X   putcolor(x, y, color) ;
X   if ((i=yystop-(y-yystart)) > iystop && i < ydots
X       && (j=xxstop-(x-xxstart)) < xdots)
X      putcolor(j, i, color) ;
X}
X
X/* Symmetry plot for Both Axis Symmetry */
Xvoid _fastcall symplot4(x, y, color)
Xint x, y, color ;
X{
X   int i,j;
X   j = xxstop-(x-xxstart);
X   putcolor(       x , y, color) ;
X   if (j < xdots)
X      putcolor(    j , y, color) ;
X   if ((i=yystop-(y-yystart)) > iystop && i < ydots)
X   {
X      putcolor(    x , i, color) ;
X      if (j < xdots)
X     putcolor(j , i, color) ;
X   }
X}
X
X/* Symmetry plot for X Axis Symmetry - Striped Newtbasin version */
Xvoid _fastcall symplot2basin(x, y, color)
Xint x, y, color ;
X{
X   int i,stripe;
X   extern int degree;
X   putcolor(x, y, color) ;
X   if(basin==2 && color > 8)
X      stripe=8;
X   else
X      stripe = 0;
X   if ((i=yystop-(y-yystart)) > iystop && i < ydots)
X   {
X      color -= stripe;              /* reconstruct unstriped color */
X      color = (degree+1-color)%degree+1;  /* symmetrical color */
X      color += stripe;              /* add stripe */
X      putcolor(x, i,color)  ;
X   }
X}
X
X/* Symmetry plot for Both Axis Symmetry  - Newtbasin version */
Xvoid _fastcall symplot4basin(x, y, color)
Xint x, y, color ;
X{
X   extern int degree;
X   int i,j,color1,stripe;
X   if(color == 0) /* assumed to be "inside" color */
X   {
X      symplot4(x, y, color);
X      return;
X   }
X   if(basin==2 && color > 8)
X      stripe = 8;
X   else
X      stripe = 0;
X   color -= stripe;          /* reconstruct unstriped color */
X   color1 = degree/2+degree+2 - color;
X   if(color < degree/2+2)
X      color1 = degree/2+2 - color;
X   else
X      color1 = degree/2+degree+2 - color;
X   j = xxstop-(x-xxstart);
X   putcolor(       x, y, color+stripe) ;
X   if (j < xdots)
X      putcolor(    j, y, color1+stripe) ;
X   if ((i=yystop-(y-yystart)) > iystop && i < ydots)
X   {
X      putcolor(    x, i, stripe + (degree+1 - color)%degree+1) ;
X      if (j < xdots)
X     putcolor(j, i, stripe + (degree+1 - color1)%degree+1) ;
X   }
X}
X
X/* Do nothing plot!!! */
Xvoid _fastcall noplot(int x,int y,int color)
X{
X}
SHAR_EOF
$TOUCH -am 1028230093 calcfrac.c &&
chmod 0644 calcfrac.c ||
echo "restore of calcfrac.c failed"
set `wc -c calcfrac.c`;Wc_c=$1
if test "$Wc_c" != "84436"; then
    echo original size 84436, current size $Wc_c
fi
# ============= cmdfiles.c ==============
echo "x - extracting cmdfiles.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > cmdfiles.c &&
X/*
X    Command-line / Command-File Parser Routines
X    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#include <float.h>
X#include <ctype.h>
X#include <time.h>
X#ifndef XFRACT
X#include <bios.h>
X#endif
X#include "fractint.h"
X#include "fractype.h"
X#ifdef __TURBOC__
X#include <dir.h>
X#endif
X#include "prototyp.h"
X
X#ifdef XFRACT
X#define DEFAULT_PRINTER 5    /* Assume a Postscript printer */
X#define PRT_RESOLUTION  100    /* Assume medium resolution    */
X#define INIT_GIF87      0    /* Turn on GIF 89a processing  */
X#else
X#define DEFAULT_PRINTER 2    /* Assume an IBM/Epson printer */
X#define PRT_RESOLUTION  60    /* Assume low resolution       */
X#define INIT_GIF87      0    /* Turn on GIF 89a processing  */
X#endif
X
Xstatic int  cmdfile(FILE *,int);
Xstatic int  next_command(char *,int,FILE *,char *,int *,int);
Xstatic int  next_line(FILE *,char *,int);
Xint  cmdarg(char *,int);
Xstatic void argerror(char *);
Xstatic void initvars_run(void);
Xstatic void initvars_restart(void);
Xstatic void initvars_fractal(void);
Xstatic void initvars_3d(void);
Xstatic void reset_ifs_defn(void);
Xstatic void parse_textcolors(char *value);
Xstatic int  parse_colors(char *value);
Xstatic int  parse_printer(char *value);
X
X/* variables defined by the command line/files processor */
Xint        showdot;    /* color to show crawling graphics cursor */
Xchar    temp1[256];        /* temporary strings        */
Xchar    readname[80];        /* name of fractal input file */
Xchar    gifmask[13] = {""};
Xchar    PrintName[80]={"fract001.prn"}; /* Name for print-to-file */
Xchar    savename[80]={"fract001"};      /* save files using this name */
Xchar    autoname[80]={"auto.key"};      /* record auto keystrokes here */
Xint    potflag=0;        /* continuous potential enabled? */
Xint    pot16bit;        /* store 16 bit continuous potential values */
Xint    gif87a_flag;        /* 1 if GIF87a format, 0 otherwise */
Xint     dither_flag;        /* 1 if want to dither GIFs */
Xint    askvideo;        /* flag for video prompting */
Xchar    floatflag;
Xint    biomorph;        /* flag for biomorph */
Xint    usr_biomorph;
Xint    forcesymmetry;        /* force symmetry */
Xint    showfile;        /* zero if file display pending */
Xint    rflag, rseed;        /* Random number seeding flag and value */
Xint    decomp[2];        /* Decomposition coloring */
Xint    distest;
Xint    distestwidth;
Xchar overwrite = 0;    /* 0 if file overwrite not allowed */
Xint    soundflag;        /* 0 if sound is off, 1 if on */
Xint    basehertz;        /* sound=x/y/x hertz value */
Xint    debugflag;        /* internal use only - you didn't see this */
Xint    timerflag;        /* you didn't see this, either */
Xint    cyclelimit;        /* color-rotator upper limit */
Xint    inside;         /* inside color: 1=blue     */
Xint    fillcolor;         /* fillcolor: -1=normal     */
Xint    outside;        /* outside color    */
Xint    finattract;        /* finite attractor logic */
Xint    display3d;        /* 3D display flag: 0 = OFF */
Xint    overlay3d;        /* 3D overlay flag: 0 = OFF */
Xint    init3d[20];        /* '3d=nn/nn/nn/...' values */
Xint    initbatch;        /* 1 if batch run (no kbd)  */
Xunsigned initsavetime;        /* autosave minutes        */
Xdouble    initorbit[2];        /* initial orbitvalue */
Xchar    useinitorbit;        /* flag for initorbit */
Xint    initmode;        /* initial video mode        */
Xint    initcyclelimit;     /* initial cycle limit        */
XBYTE usemag;        /* use center-mag corners   */
Xint    bailout;        /* user input bailout value */
Xdouble    inversion[3];        /* radius, xcenter, ycenter */
Xint    rotate_lo,rotate_hi;    /* cycling color range        */
Xint far *ranges;        /* iter->color ranges mapping */
Xint    rangeslen = 0;        /* size of ranges array     */
Xchar far *mapdacbox = NULL;    /* map= (default colors)    */
Xint    colorstate;        /* 0, dacbox matches default (bios or map=) */
X                /* 1, dacbox matches no known defined map   */
X                /* 2, dacbox matches the colorfile map        */
Xint    colorpreloaded;     /* if dacbox preloaded for next mode select */
Xint     save_release;        /* release creating PAR file*/
X
Xextern int calc_status;
Xextern int Targa_Overlay;
Xint Targa_Out = 0;
Xchar    colorfile[80];        /* from last <l> <s> or colors=@filename    */
Xint functionpreloaded; /* if function loaded for new bifs, JCO 7/5/92 */
Xfloat    screenaspect = DEFAULTASPECT;    /* aspect ratio of the screen */
X
X/* TARGA+ variables */
Xint    TPlusFlag;        /* Use the TARGA+ if found  */
Xint    MaxColorRes;        /* Default Color Resolution if available */
Xint    PixelZoom;        /* TPlus Zoom Level */
Xint    NonInterlaced;        /* Non-Interlaced video flag */
X
X/* 3D Transparency Variables, MCP 5-30-91 */
Xdouble xcoord, ycoord, zcoord, tcoord;
Xdouble zzmin, zzmax;        /* initial depth corner values */
Xdouble ttmin, ttmax;        /* initial time coordinates */
Xint Transparent3D, SolidCore, MultiDrawing;
Xint tpdepth, tptime;
Xunsigned CoreRed, CoreGreen, CoreBlue, NumFrames;
X
X/* AntiAliasing variables, MCP 6-6-91 */
Xint AntiAliasing, Shadowing;
X
X/* Julibrot variables TIW 1/24/93 */
Xextern double mxmaxfp, mxminfp, mymaxfp, myminfp, originfp;
Xextern double depthfp, heightfp, widthfp, distfp, eyesfp;
Xextern int zdots;
X
Xextern int lastorbittype, neworbittype;
Xextern char *juli3Doptions[];
Xextern int juli3Dmode;
Xextern struct moreparams far moreparams[];
X
X/* inverse julia methods. MVS 3/15/93 */
Xextern int major_method;
Xextern int minor_method;
X
Xint    orbitsave = 0;        /* for IFS and LORENZ to output acrospin file */
Xint orbit_delay;                /* clock ticks delating orbit release */
Xextern    int invert;
Xextern int fractype;        /* fractal type         */
Xextern double param[];         /* initial parameters        */
Xextern double xxmin,xxmax;    /* initial corner values    */
Xextern double yymin,yymax;    /* initial corner values    */
Xextern double xx3rd,yy3rd;    /* initial corner values    */
Xextern char usr_stdcalcmode;    /* '1', '2', 'g', 'b'       */
Xextern int maxit;        /* max iterations        */
Xextern int usr_periodicitycheck; /* periodicity checking  1=on,0=off */
Xextern char usr_floatflag;    /* flag for float calcs */
Xextern int usr_distest;     /* nonzero if distance estimator option */
Xextern char color_lakes;    /* finite attractor flag */
Xextern int haze;
Xextern int RANDOMIZE;
Xextern int Ambient;
Xextern char light_name[];
Xextern int BRIEF;
Xextern int RAY;
Xextern int release;
X
Xextern BYTE back_color[];
Xextern BYTE dacbox[256][3];
Xextern struct videoinfo far videotable[];
Xextern int fpu;
Xextern int iit;
X
Xextern double potparam[];    /* potential parameters  */
Xextern int Printer_Resolution, LPTNumber,
X       Printer_Type, Printer_Titleblock,
X       Printer_ColorXlat, Printer_SetScreen,
X       Printer_SFrequency, Printer_SAngle, Printer_SStyle,
X       Printer_RFrequency, Printer_RAngle, Printer_RStyle,
X       Printer_GFrequency, Printer_GAngle, Printer_GStyle,
X       Printer_BFrequency, Printer_BAngle, Printer_BStyle,
X       Printer_Compress,
X       EPSFileType, ColorPS,
X       Print_To_File,Printer_CRLF;        /* for printer functions */
X
Xint    transparent[2];     /* transparency min/max values */
Xint    LogFlag;        /* Logarithmic palette flag: 0 = no */
X
XBYTE exitmode = 3;    /* video mode on exit */
X
Xextern int video_type;
Xextern int svga_type;           /* for forcing a specific SVGA adapter */
Xextern int mode7text;
Xextern int textsafe;
Xextern int vesa_detect;
Xchar    ai_8514;    /* Flag for using 8514a afi JCO 4/11/92 */
X
Xint        bios_palette;        /* set to 1 to force BIOS palette updates */
Xint        escape_exit;         /* set to 1 to avoid the "are you sure?" screen */
X
Xextern int   viewwindow;
Xextern float viewreduction;
Xextern int   viewcrop;
Xextern float finalaspectratio;
Xextern int   viewxdots,viewydots;
X
Xextern char MAP_name[];
Xextern int mapset;
X
Xextern int eyeseparation; /* Occular Separation */
Xextern int glassestype;
Xextern int xadjust; /* Convergence */
Xextern int yadjust;
Xextern int xtrans, ytrans; /* X,Y shift with no perspective */
Xextern int red_crop_left, red_crop_right;
Xextern int blue_crop_left, blue_crop_right;
Xextern int red_bright, blue_bright;
Xextern char showbox; /* flag to show box and vector in preview */
Xextern char preview;        /* 3D preview mode flag */
Xextern int previewfactor; /* Coarsness */
X
Xint first_init=1;        /* first time into cmdfiles? */
Xstatic int init_rseed;
Xstatic char initcorners,initparams;
Xstruct fractalspecificstuff far *curfractalspecific;
X
Xchar FormFileName[80];        /* file to find (type=)formulas in */
Xchar FormName[ITEMNAMELEN+1];    /* Name of the Formula (if not null) */
Xchar LFileName[80];        /* file to find (type=)L-System's in */
Xchar LName[ITEMNAMELEN+1];    /* Name of L-System */
Xchar CommandFile[80];        /* file to find command sets in */
Xchar CommandName[ITEMNAMELEN+1];/* Name of Command set */
Xchar far CommandComment1[57];    /* comments for command set */
Xchar far CommandComment2[57];
Xchar far CommandComment3[57];
Xchar far CommandComment4[57];
Xchar IFSFileName[80];        /* file to find (type=)IFS in */
Xchar IFSName[ITEMNAMELEN+1];    /* Name of the IFS def'n (if not null) */
Xfloat far *ifs_defn = NULL;    /* ifs parameters */
Xint  ifs_changed;        /* nonzero if parameters have been edited */
Xint  ifs_type;            /* 0=2d, 1=3d */
Xint  slides = 0;        /* 1 autokey=play, 2 autokey=record */
X
XBYTE txtcolor[]={
X      BLUE*16+L_WHITE,      /* C_TITLE           title background */
X      BLUE*16+L_GREEN,      /* C_TITLE_DEV       development vsn foreground */
X      GREEN*16+YELLOW,      /* C_HELP_HDG        help page title line */
X      WHITE*16+BLACK,      /* C_HELP_BODY       help page body */
X      GREEN*16+GRAY,      /* C_HELP_INSTR      help page instr at bottom */
X      WHITE*16+BLUE,      /* C_HELP_LINK       help page links */
X      CYAN*16+BLUE,      /* C_HELP_CURLINK    help page current link */
X      WHITE*16+GRAY,      /* C_PROMPT_BKGRD    prompt/choice background */
X      WHITE*16+BLACK,      /* C_PROMPT_TEXT     prompt/choice extra info */
X      BLUE*16+WHITE,      /* C_PROMPT_LO       prompt/choice text */
X      BLUE*16+L_WHITE,      /* C_PROMPT_MED      prompt/choice hdg2/... */
X      BLUE*16+YELLOW,      /* C_PROMPT_HI       prompt/choice hdg/cur/... */
X      GREEN*16+L_WHITE,   /* C_PROMPT_INPUT    fullscreen_prompt input */
X      CYAN*16+L_WHITE,      /* C_PROMPT_CHOOSE   fullscreen_prompt choice */
X      MAGENTA*16+L_WHITE, /* C_CHOICE_CURRENT  fullscreen_choice input */
X      BLACK*16+WHITE,      /* C_CHOICE_SP_INSTR speed key bar & instr */
X      BLACK*16+L_MAGENTA, /* C_CHOICE_SP_KEYIN speed key value */
X      WHITE*16+BLUE,      /* C_GENERAL_HI      tab, thinking, IFS */
X      WHITE*16+BLACK,      /* C_GENERAL_MED */
X      WHITE*16+GRAY,      /* C_GENERAL_LO */
X      BLACK*16+L_WHITE,   /* C_GENERAL_INPUT */
X      WHITE*16+BLACK,      /* C_DVID_BKGRD      disk video */
X      BLACK*16+YELLOW,      /* C_DVID_HI */
X      BLACK*16+L_WHITE,   /* C_DVID_LO */
X      RED*16+L_WHITE,      /* C_STOP_ERR        stop message, error */
X      GREEN*16+BLACK,      /* C_STOP_INFO       stop message, info */
X      BLUE*16+WHITE,      /* C_TITLE_LOW       bottom lines of title screen */
X      GREEN*16+BLACK,      /* C_AUTHDIV1        title screen dividers */
X      GREEN*16+GRAY,      /* C_AUTHDIV2        title screen dividers */
X      BLACK*16+L_WHITE,   /* C_PRIMARY           primary authors */
X      BLACK*16+WHITE      /* C_CONTRIB           contributing authors */
X      };
X
Xextern int active_system;
X/* start of string literals cleanup */
Xchar s_iter[]    = "iter";
Xchar s_real[]    = "real";
Xchar s_mult[]     = "mult";
Xchar s_sum[]     = "summ";
Xchar s_imag[]    = "imag";
Xchar s_zmag[]    = "zmag";
Xchar s_bof60[]   = "bof60";
Xchar s_bof61[]   = "bof61";
Xchar s_maxiter[] =  "maxiter";
Xchar s_epscross[] =  "epsiloncross";
Xchar s_startrail[] =  "startrail";
Xchar s_normal[] =  "normal";
Xchar s_period[] = "period";
X
X
Xvoid cmdfiles_overlay() { }    /* for restore_active_ovly */
X
X/*
X    cmdfiles(argc,argv) process the command-line arguments
X        it also processes the 'sstools.ini' file and any
X        indirect files ('fractint @myfile')
X*/
X
Xint cmdfiles(int argc,char **argv)
X{
X   int       i;
X   char    curarg[141];
X   char    tempstring[101];
X   char    *sptr;
X   FILE    *initfile;
X
X   ENTER_OVLY(OVLY_CMDFILES);
X
X   if (first_init) initvars_run();    /* once per run initialization */
X   initvars_restart();            /* <ins> key initialization */
X   initvars_fractal();            /* image initialization */
X
X   findpath("sstools.ini", tempstring); /* look for SSTOOLS.INI */
X   if (tempstring[0] != 0)        /* found it! */
X      if ((initfile = fopen(tempstring,"r")) != NULL)
X     cmdfile(initfile,1);        /* process it */
X
X   for (i = 1; i < argc; i++) {     /* cycle through args */
X#ifdef XFRACT
X      /* Let the xfract code take a look at the argument */
X      if (unixarg(argc,argv,&i)) continue;
X#endif
X      strcpy(curarg,argv[i]);
X      if (curarg[0] == ';')             /* start of comments? */
X     break;
X      if (curarg[0] != '@') {           /* simple command? */
X     if (strchr(curarg,'=') == NULL) { /* not xxx=yyy, so check for gif */
X        strcpy(tempstring,curarg);
X        if (strchr(curarg,'.') == NULL)
X           strcat(tempstring,".gif");
X        if ((initfile = fopen(tempstring,"rb"))) {
X           fread(tempstring,6,1,initfile);
X           if ( tempstring[0] == 'G'
X         && tempstring[1] == 'I'
X         && tempstring[2] == 'F'
X         && tempstring[3] >= '8' && tempstring[3] <= '9'
X         && tempstring[4] >= '0' && tempstring[4] <= '9') {
X          strcpy(readname,curarg);
X          curarg[0] = showfile = 0;
X          }
X           fclose(initfile);
X           }
X        }
X     if (curarg[0])
X        cmdarg(curarg,0);        /* process simple command */
X     }
X      else if ((sptr = strchr(curarg,'/'))) { /* @filename/setname? */
X     *sptr = 0;
X     strcpy(CommandFile,&curarg[1]);
X     strcpy(CommandName,sptr+1);
X     find_file_item(CommandFile,CommandName,&initfile);
X     cmdfile(initfile,3);
X     }
X      else {                /* @filename */
X     if ((initfile = fopen(&curarg[1],"r")) == NULL)
X        argerror(curarg);
X     cmdfile(initfile,0);
X     }
X      }
X
X   if (first_init == 0) {
X      initmode = -1; /* don't set video when <ins> key used */
X      showfile = 1;  /* nor startup image file            */
X      }
X
X   if(debugflag != 110)
X       first_init = 0;
X   EXIT_OVLY;
X   return(0);
X}
X
X
Xint load_commands(FILE *infile)
X{
X   /* when called, file is open in binary mode, positioned at the */
X   /* '(' or '{' following the desired parameter set's name       */
X   int ret;
X   ENTER_OVLY(OVLY_CMDFILES);
X   initcorners = initparams = 0; /* reset flags for type= */
X   ret = cmdfile(infile,2);
X   EXIT_OVLY;
X   return ret;
X}
X
X
Xstatic void initvars_run()        /* once per run init */
X{
X   init_rseed = (int)time(NULL);
X}
X
Xstatic void initvars_restart()        /* <ins> key init */
X{
X   save_release = release;              /* this release number */
X   gif87a_flag = INIT_GIF87;            /* turn on GIF89a processing */
X   dither_flag = 0;            /* no dithering */
X   askvideo = 1;            /* turn on video-prompt flag */
X   overwrite = 0;            /* don't overwrite           */
X   soundflag = -1;            /* sound is on             */
X   basehertz = 440;            /* basic hertz rate         */
X   initbatch = 0;            /* not in batch mode         */
X   initsavetime = 0;            /* no auto-save          */
X   initmode = -1;            /* no initial video mode     */
X   viewwindow = 0;            /* no view window         */
X   viewreduction = 4.2;
X   viewcrop = 1;
X   ai_8514 = 0;                         /* no need for the 8514 API  */
X   finalaspectratio = screenaspect;
X   viewxdots = viewydots = 0;
X   orbit_delay = 0;                     /* full speed orbits */
X   debugflag = 0;            /* debugging flag(s) are off */
X   timerflag = 0;            /* timer flags are off         */
X   strcpy(FormFileName,"fractint.frm"); /* default formula file      */
X   FormName[0] = 0;
X   strcpy(LFileName,"fractint.l");
X   LName[0] = 0;
X   strcpy(CommandFile,"fractint.par");
X   CommandName[0] = CommandComment1[0] = CommandComment2[0] = 0;
X   CommandComment3[0] = CommandComment4[0] = 0;
X   strcpy(IFSFileName,"fractint.ifs");
X   IFSName[0] = 0;
X   reset_ifs_defn();
X   rflag = 0;                /* not a fixed srand() seed */
X   rseed = init_rseed;
X   strcpy(readname,DOTSLASH);           /* initially current directory */
X   showfile = 1;
X   /* next should perhaps be fractal re-init, not just <ins> ? */
X   initcyclelimit=55;            /* spin-DAC default speed limit */
X   mapset = 0;                /* no map= name active */
X   if (mapdacbox) {
X      farmemfree(mapdacbox);
X      mapdacbox = NULL;
X      }
X   TPlusFlag = 1;
X   MaxColorRes = 8;
X   PixelZoom = 0;
X   NonInterlaced = 0;
X
X   Transparent3D = 0;
X   SolidCore = 1;
X   CoreRed   = 128;
X   CoreGreen = 128;
X   CoreBlue  = 128;
X   zzmin = -1.5;
X   zzmax = 1.5;
X   ttmin = 0.0;
X   ttmax = 0.0;
X   NumFrames = 1;
X   tpdepth = tptime = 0;
X
X   AntiAliasing = 0;
X   Shadowing = 0;
X
X   Printer_Type = DEFAULT_PRINTER;      /* assume an IBM/EPSON    */
X   Printer_Resolution = PRT_RESOLUTION; /* assume low resolution  */
X   Printer_Titleblock = 0;        /* assume no title block  */
X   Printer_ColorXlat = 0;        /* assume positive image  */
X   Printer_SetScreen = 0;               /* assume default screen  */
X   Printer_SFrequency = 45;             /* New screen frequency K */
X   Printer_SAngle = 45;                 /* New screen angle     K */
X   Printer_SStyle = 1;                  /* New screen style     K */
X   Printer_RFrequency = 45;             /* New screen frequency R */
X   Printer_RAngle = 75;                 /* New screen angle     R */
X   Printer_RStyle = 1;                  /* New screen style     R */
X   Printer_GFrequency = 45;             /* New screen frequency G */
X   Printer_GAngle = 15;                 /* New screen angle     G */
X   Printer_GStyle = 1;                  /* New screen style     G */
X   Printer_BFrequency = 45;             /* New screen frequency B */
X   Printer_BAngle = 0;                  /* New screen angle     B */
X   Printer_BStyle = 1;                  /* New screen style     B */
X#ifndef XFRACT
X   Print_To_File = 0;                   /* No print-to-file       */
X   Printer_CRLF = 0;                    /* Assume CR+LF           */
X#else
X   Print_To_File = 1;                   /* Print-to-file          */
X   Printer_CRLF = 2;                    /* Assume LF              */
X   Printer_Compress = 0;                /* Assume NO PostScript compression */
X#endif
X   EPSFileType = 0;            /* Assume no save to .EPS */
X   LPTNumber = 1;            /* assume LPT1 */
X   ColorPS = 0;                         /* Assume NO Color PostScr*/
X   major_method = minor_method = 0;    /* default inverse julia methods */
X}
X
Xstatic void initvars_fractal()        /* init vars affecting calculation */
X{
X   int i;
X   bios_palette = 0;                    /* don't force use of a BIOS palette */
X   escape_exit = 0;                     /* don't disable the "are you sure?" screen */
X   usr_periodicitycheck = 1;        /* turn on periodicity      */
X   inside = 1;                /* inside color = blue      */
X   fillcolor = -1;            /* no special fill color */
X   usr_biomorph = -1;            /* turn off biomorph flag */
X   outside = -1;            /* outside color = -1 (not used) */
X   maxit = 150;             /* initial maxiter      */
X   usr_stdcalcmode = 'g';               /* initial solid-guessing */
X#ifndef XFRACT
X   usr_floatflag = 0;            /* turn off the float flag */
X#else
X   usr_floatflag = 1;            /* turn on the float flag */
X#endif
X   finattract = 0;            /* disable finite attractor logic */
X   fractype = 0;            /* initial type Set flag  */
X   curfractalspecific = &fractalspecific[0];
X   initcorners = initparams = 0;
X   bailout = 0;             /* no user-entered bailout */
X   useinitorbit = 0;
X   for (i = 0; i < MAXPARAMS; i++) param[i] = 0.0;     /* initial parameter values */
X   for (i = 0; i < 3; i++) potparam[i]    = 0.0; /* initial potential values */
X   for (i = 0; i < 3; i++) inversion[i] = 0.0;    /* initial invert values */
X   initorbit[0] = initorbit[1] = 0.0;    /* initial orbit values */
X   invert = 0;
X   decomp[0] = decomp[1] = 0;
X   usr_distest = 0;
X   distestwidth = 71;
X   forcesymmetry = 999;         /* symmetry not forced */
X   xx3rd = xxmin = -2.5; xxmax = 1.5;    /* initial corner values  */
X   yy3rd = yymin = -1.5; yymax = 1.5;    /* initial corner values  */
X   pot16bit = potflag = 0;
X   LogFlag = 0;             /* no logarithmic palette */
X   set_trig_array(0,"sin");             /* trigfn defaults */
X   set_trig_array(1,"sqr");
X   set_trig_array(2,"sinh");
X   set_trig_array(3,"cosh");
X   if (rangeslen) {
X      farmemfree((char far *)ranges);
X      rangeslen = 0;
X      }
X   usemag = 0;                /* use corners, not center-mag */
X
X   colorstate = colorpreloaded = 0;
X   rotate_lo = 1; rotate_hi = 255;    /* color cycling default range */
X
X   display3d = 0;            /* 3D display is off        */
X   overlay3d = 0;            /* 3D overlay is off        */
X
X   functionpreloaded = 0; /* for old bifs  JCO 7/5/92 */
X   mxminfp = -.83;
X   myminfp = -.25;
X   mxmaxfp = -.83;
X   mymaxfp =  .25;
X   originfp = 8;
X   heightfp = 7;
X   widthfp = 10;
X   distfp = 24;
X   eyesfp = 2.5;
X   depthfp = 8;
X   lastorbittype = -1;
X   neworbittype = JULIA;
X   zdots = 128;
X   initvars_3d();
X}
X
Xstatic void initvars_3d()        /* init vars affecting 3d */
X{
X   RAY     = 0;
X   BRIEF   = 0;
X   SPHERE = FALSE;
X   preview = 0;
X   showbox = 0;
X   xadjust = 0;
X   yadjust = 0;
X   eyeseparation = 0;
X   glassestype = 0;
X   previewfactor = 20;
X   red_crop_left   = 4;
X   red_crop_right  = 0;
X   blue_crop_left  = 0;
X   blue_crop_right = 4;
X   red_bright      = 80;
X   blue_bright     = 100;
X   transparent[0] = transparent[1] = 0; /* no min/max transparency */
X   set_3d_defaults();
X}
X
Xstatic void reset_ifs_defn()
X{
X   if (ifs_defn) {
X      farmemfree((char far *)ifs_defn);
X      ifs_defn = NULL;
X      }
X}
X
X
Xstatic int cmdfile(FILE *handle,int mode)
X   /* mode = 0 command line @filename          */
X   /*         1 sstools.ini              */
X   /*         2 <@> command after startup      */
X   /*         3 command line @filename/setname */
X{
X   /* note that cmdfile could be open as text OR as binary */
X   /* binary is used in @ command processing for reasonable speed note/point */
X   int i;
X   int lineoffset = 0;
X   int changeflag = 0; /* &1 fractal stuff chgd, &2 3d stuff chgd */
X   char linebuf[513],cmdbuf[1001];
X   if (mode == 2 || mode == 3) {
X      while ((i = getc(handle)) != '{' && i != EOF) { }
X      CommandComment1[0] = CommandComment2[0] = 0;
X      CommandComment3[0] = CommandComment4[0] = 0;
X      }
X   linebuf[0] = 0;
X   while (next_command(cmdbuf,1000,handle,linebuf,&lineoffset,mode) > 0) {
X      if ((mode == 2 || mode == 3) && strcmp(cmdbuf,"}") == 0) break;
X      if ((i = cmdarg(cmdbuf,mode)) < 0) break;
X      changeflag |= i;
X      }
X   fclose(handle);
X#ifdef XFRACT
X   initmode = 0;        /* Skip credits if @file is used. */
X#endif
X   return changeflag;
X}
X
Xstatic int next_command(char *cmdbuf,int maxlen,
X              FILE *handle,char *linebuf,int *lineoffset,int mode)
X{
X   int cmdlen = 0;
X   char *lineptr;
X   lineptr = linebuf + *lineoffset;
X   while(1) {
X      while (*lineptr <= ' ' || *lineptr == ';') {
X     if (cmdlen) {            /* space or ; marks end of command */
X        cmdbuf[cmdlen] = 0;
X        *lineoffset = lineptr - linebuf;
X        return cmdlen;
X        }
X     while (*lineptr && *lineptr <= ' ')
X        ++lineptr;            /* skip spaces and tabs */
X     if (*lineptr == ';' || *lineptr == 0) {
X        if (*lineptr == ';'
X          && (mode == 2 || mode == 3)
X          && (CommandComment1[0] == 0 || CommandComment2[0] == 0 ||
X              CommandComment3[0] == 0 || CommandComment4[0] == 0)) {
X           /* save comment */
X           while (*(++lineptr)
X         && (*lineptr == ' ' || *lineptr == '\t')) { }
X           if (*lineptr) {
X          if (strlen(lineptr) > 56)
X             *(lineptr+56) = 0;
X          if (CommandComment1[0] == 0)
X             far_strcpy(CommandComment1,lineptr);
X          else if (CommandComment2[0] == 0)
X             far_strcpy(CommandComment2,lineptr);
X          else if (CommandComment3[0] == 0)
X             far_strcpy(CommandComment3,lineptr);
X          else
X             far_strcpy(CommandComment4,lineptr);
X          }
X           }
X        if (next_line(handle,linebuf,mode) != 0)
X           return(-1); /* eof */
X        lineptr = linebuf; /* start new line */
X        }
X     }
X      if (*lineptr == '\\'              /* continuation onto next line? */
X    && *(lineptr+1) == 0) {
X     if (next_line(handle,linebuf,mode) != 0) {
X        argerror(cmdbuf);        /* missing continuation */
X        return(-1);
X        }
X     lineptr = linebuf;
X     while (*lineptr && *lineptr <= ' ')
X        ++lineptr;            /* skip white space @ start next line */
X     continue;            /* loop to check end of line again */
X     }
X      cmdbuf[cmdlen] = *(lineptr++);    /* copy character to command buffer */
X      if (++cmdlen >= maxlen) {     /* command too long? */
X     argerror(cmdbuf);
X     return(-1);
X     }
X      }
X}
X
Xstatic int next_line(FILE *handle,char *linebuf,int mode)
X{
X   int toolssection;
X   char tmpbuf[10];
X   toolssection = 0;
X   while (file_gets(linebuf,512,handle) >= 0) {
X      if (mode == 1 && linebuf[0] == '[') {     /* check for [fractint] */
X     strncpy(tmpbuf,&linebuf[1],9);
X     tmpbuf[9] = 0;
X     strlwr(tmpbuf);
X     toolssection = strncmp(tmpbuf,"fractint]",9);
X     continue;                /* skip tools section heading */
X     }
X      if (toolssection == 0) return(0);
X      }
X   return(-1);
X}
X
X/*
X  cmdarg(string,mode) processes a single command-line/command-file argument
X    return:
X      -1 error, >= 0 ok
X      if ok, return value:
X    | 1 means fractal parm has been set
X    | 2 means 3d parm has been set
X    | 4 means 3d=yes specified
X    | 8 means reset specified
X*/
X
Xint cmdarg(char *curarg,int mode) /* process a single argument */
X{
X   char    variable[21];        /* variable name goes here   */
X   char    *value;            /* pointer to variable value */
X   int       valuelen;            /* length of value         */
X   int       numval;            /* numeric value of arg      */
X#define NONNUMERIC -32767
X   char    charval;            /* first character of arg    */
X   int       yesnoval;            /* 0 if 'n', 1 if 'y', -1 if not */
X   double  ftemp;
X   int       i, j, k, l;
X   char    *argptr,*argptr2;
X   int       totparms;            /* # of / delimited parms    */
X   int       intparms;            /* # of / delimited ints     */
X   int       floatparms;            /* # of / delimited floats   */
X   int       intval[64];            /* pre-parsed integer parms  */
X   double  floatval[16];        /* pre-parsed floating parms */
X   char    tmpc;
X   int       lastarg;
X
X   argptr = curarg;
X   while (*argptr) {            /* convert to lower case */
X      if (*argptr >= 'A' && *argptr <= 'Z')
X     *argptr += 'a' - 'A';
X      if (*argptr == '=' && strncmp(curarg,"colors=",7) == 0)
X     break;             /* don't convert colors=value */
X      ++argptr;
X      }
X
X   if ((value = strchr(&curarg[1],'='))) {
X      if ((j = (value++) - curarg) > 1 && curarg[j-1] == ':')
X     --j;                /* treat := same as =      */
X      }
X   else
X      value = curarg + (j = strlen(curarg));
X   if (j > 20) goto badarg;        /* keyword too long */
X   strncpy(variable,curarg,j);        /* get the variable name  */
X   variable[j] = 0;            /* truncate variable name */
X   valuelen = strlen(value);        /* note value's length    */
X   charval = value[0];            /* first letter of value  */
X   yesnoval = -1;            /* note yes|no value      */
X   if (charval == 'n') yesnoval = 0;
X   if (charval == 'y') yesnoval = 1;
X
X   argptr = value;
X   numval = totparms = intparms = floatparms = 0;
X   while (*argptr) {            /* count and pre-parse parms */
X      long ll;
X      lastarg = 0;
X      if ((argptr2 = strchr(argptr,'/')) == NULL) {     /* find next '/' */
X     argptr2 = argptr + strlen(argptr);
X     *argptr2 = '/';
X     lastarg = 1;
X     }
X      if (totparms == 0) numval = NONNUMERIC;
X      i = -1;
X      charval = *argptr;            /* first letter of value  */
X      if (charval == 'n') yesnoval = 0;    /* allows only ONE y/n param */
X      if (charval == 'y') yesnoval = 1;
X      if (sscanf(argptr,"%c%c",&j,&tmpc) > 0    /* NULL entry */
X      && (j == '/' || j == '=') && tmpc == '/') {
X     j = 0;
X     ++floatparms; ++intparms;
X     if (totparms < 16) floatval[totparms] = j;
X     if (totparms < 64) intval[totparms] = j;
X     if (totparms == 0) numval = j;
X     }
X      else if (sscanf(argptr,"%ld%c",&ll,&tmpc) > 0       /* got an integer */
X    && tmpc == '/') {        /* needs a long int, ll, here for lyapunov */
X     ++floatparms; ++intparms;
X     if (totparms < 16) floatval[totparms] = ll;
X     if (totparms < 64) intval[totparms] = (int)ll;
X     if (totparms == 0) numval = (int)ll;
X     }
X#ifndef XFRACT
X      else if (sscanf(argptr,"%lg%c",&ftemp,&tmpc) > 0  /* got a float */
X#else
X      else if (sscanf(argptr,"%lf%c",&ftemp,&tmpc) > 0  /* got a float */
X#endif
X         && tmpc == '/') {
X     ++floatparms;
X     if (totparms < 16) floatval[totparms] = ftemp;
X     }
X      ++totparms;
X      argptr = argptr2;                 /* on to the next */
X      if (lastarg)
X     *argptr = 0;
X      else
X     ++argptr;
X      }
X
X   if (mode != 2 || debugflag==110) {
X      /* these commands are allowed only at startup */
X
X      if (strcmp(variable,"batch") == 0 ) {     /* batch=?      */
X     if (yesnoval < 0) goto badarg;
X#ifdef XFRACT
X         initmode = yesnoval?0:-1; /* skip credits for batch mode */
X#endif
X     initbatch = yesnoval;
X     return 3;
X     }
X
X#ifndef XFRACT
X      if (strcmp(variable,"adapter") == 0 ) {   /* adapter==?     */
X         int i, j;
X         extern char supervga_list;    /* from the list in VIDEO.ASM */
X         char adapter_name[8];      /* entry lenth from VIDEO.ASM */
X         char *adapter_ptr;
X
X         adapter_ptr = &supervga_list;
X
X         for(i = 0 ; ; i++) {        /* find the SuperVGA entry */
X             memcpy(adapter_name , adapter_ptr, 8);
X             adapter_name[6] = ' ';
X             for (j = 0; j < 8; j++)
X                 if(adapter_name[j] == ' ')
X                     adapter_name[j] = 0;
X             if (adapter_name[0] == 0) break;  /* end-of-the-list */
X             if (strncmp(value,adapter_name,strlen(adapter_name)) == 0) {
X                svga_type = i+1;
X                adapter_ptr[6] = 1;
X                break;
X                }
X             adapter_ptr += 8;
X             }
X         if (svga_type != 0) return 3;
X
X     video_type = 5;            /* assume video=vga */
X     if (strcmp(value,"egamono") == 0) {
X        video_type = 3;
X        mode7text = 1;
X        }
X     else if (strcmp(value,"hgc") == 0) {   /* video = hgc */
X        video_type = 1;
X        mode7text = 1;
X        }
X     else if (strcmp(value,"ega") == 0)     /* video = ega */
X        video_type = 3;
X     else if (strcmp(value,"cga") == 0)     /* video = cga */
X        video_type = 2;
X     else if (strcmp(value,"mcga") == 0)    /* video = mcga */
X        video_type = 4;
X     else if (strcmp(value,"vga") == 0)     /* video = vga */
X        video_type = 5;
X     else
X        goto badarg;
X     return 3;
X     }
X
X      if (strcmp(variable,"afi") == 0) {
X       if (strncmp(value,"8514"  ,4) == 0
X           || charval == 'y') ai_8514 = 1; /* set afi flag JCO 4/11/92 */
X       return 3;
X    }
X
X      if (strcmp(variable,"textsafe") == 0 ) {  /* textsafe==? */
X     if (first_init) {
X        if (charval == 'n') /* no */
X           textsafe = 2;
X        else if (charval == 'y') /* yes */
X           textsafe = 1;
X        else if (charval == 'b') /* bios */
X           textsafe = 3;
X        else if (charval == 's') /* save */
X           textsafe = 4;
X        else
X           goto badarg;
X        }
X     return 3;
X     }
X
X      if (strcmp(variable, "vesadetect") == 0) {
X     if (yesnoval < 0) goto badarg;
X     vesa_detect = yesnoval;
X     return 3;
X     }
X
X      if (strcmp(variable, "biospalette") == 0) {
X         if (yesnoval < 0) goto badarg;
X         bios_palette = yesnoval;
X         return 3;
X         }
X
X      if (strcmp(variable,"fpu") == 0) {
X     if (strcmp(value,"iit") == 0) {
X        fpu = 387;
X        iit = 1;
X        return 0;
X        }
X     if (strcmp(value,"noiit") == 0) {
X        iit = -2;
X        return 0;
X        }
X     if (strcmp(value,"387") == 0) {
X        fpu = 387;
X        iit = -2;
X        return 0;
X        }
X     goto badarg;
X     }
X#endif
X
X      if (strcmp(variable, "exitnoask") == 0) {
X         if (yesnoval < 0) goto badarg;
X         escape_exit = yesnoval;
X         return 3;
X         }
X
X      if (strcmp(variable,"makedoc") == 0) {
X     print_document(*value ? value : "fractint.doc", makedoc_msg_func, 0);
X#ifndef WINFRACT
X     goodbye();
X#endif
X     }
X
X      } /* end of commands allowed only at startup */
X
X   if (strcmp(variable,"reset") == 0) {
X      initvars_fractal();
X
X      /* PAR release unknown unless specified */
X      if (numval>=0) save_release = numval;
X      else goto badarg;
X      return 9;
X      }
X
X   if (strcmp(variable,"filename") == 0) {      /* filename=?     */
X      if (charval == '.') {
X     if (valuelen > 4) goto badarg;
X     gifmask[0] = '*';
X     gifmask[1] = 0;
X     strcat(gifmask,value);
X     return 0;
X     }
X      if (valuelen > 79) goto badarg;
X      if (mode == 2 && display3d == 0) /* can't do this in @ command */
X     goto badarg;
X      strcpy(readname,value);
X      showfile = 0;
X      return 3;
X      }
X
X   if (strcmp(variable,"video") == 0) {         /* video=? */
X      if (active_system == 0) {
X     if ((k = check_vidmode_keyname(value)) == 0) goto badarg;
X     initmode = -1;
X     for (i = 0; i < MAXVIDEOTABLE; ++i) {
X        if (videotable[i].keynum == k) {
X           initmode = i;
X           break;
X           }
X        }
X     if (initmode == -1) goto badarg;
X     }
X      return 3;
X      }
X
X   if (strcmp(variable,"map") == 0 ) {         /* map=, set default colors */
X      if (valuelen > 79 || SetColorPaletteName(value) != 0) goto badarg;
X      mapset = 1;
X      strcpy(MAP_name,value);
X      return 0;
X      }
X
X   if (strcmp(variable,"colors") == 0) {       /* colors=, set current colors */
X      if (parse_colors(value) < 0) goto badarg;
X      return 0;
X      }
X
X   if (strcmp(variable, "tplus") == 0) {       /* Use the TARGA+ if found? */
X      if (yesnoval < 0) goto badarg;
X      TPlusFlag = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable, "noninterlaced") == 0) {
X      if (yesnoval < 0) goto badarg;
X      NonInterlaced = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable, "maxcolorres") == 0) { /* Change default color resolution */
X      if (numval == 1 || numval == 4 || numval == 8 ||
X            numval == 16 || numval == 24) {
X     MaxColorRes = numval;
X     return 0;
X     }
X      goto badarg;
X      }
X
X   if (strcmp(variable, "pixelzoom") == 0) {
X      if (numval < 5)
X     PixelZoom = numval;
X      return 0;
X      }
X
X   /* keep this for backward compatibility */
X   if (strcmp(variable,"warn") == 0 ) {         /* warn=? */
X      if (yesnoval < 0) goto badarg;
X      overwrite = yesnoval ^ 1;
X      return 0;
X      }
X   if (strcmp(variable,"overwrite") == 0 ) {    /* overwrite=? */
X      if (yesnoval < 0) goto badarg;
X      overwrite = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable,"gif87a") == 0 ) {       /* gif87a=? */
X      if (yesnoval < 0) goto badarg;
X      gif87a_flag = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable,"dither") == 0 ) {       /* dither=? */
X      if (yesnoval < 0) goto badarg;
X      dither_flag = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable,"savetime") == 0) {      /* savetime=? */
X      initsavetime = numval;
X      return 0;
X      }
X
X   if (strcmp(variable,"autokey") == 0) {       /* autokey=? */
X      if (strcmp(value,"record")==0)
X     slides=2;
X      else if (strcmp(value,"play")==0)
X     slides=1;
X      else
X     goto badarg;
X      return 0;
X      }
X
X   if(strcmp(variable, "solidcore") == 0) {
X      SolidCore = yesnoval;
X      return(0);
X      }
X/* (nuked until antialiasing become an option)
X   if(strcmp(variable, "antialias") == 0) {
X      if(numval < 0 || numval > 8)
X     goto badarg;
X      AntiAliasing = numval;
X      return(0);
X      }
X*/
X   if(strcmp(variable, "transparent3d") == 0) {
X      Transparent3D = yesnoval;
X      return(0);
X      }
X
X   if(strcmp(variable, "corecolor") == 0) {
X      if(floatparms != totparms || totparms != 3)
X     goto badarg;
X      CoreRed    = (int)floatval[0];
X      CoreGreen = (int)floatval[1];
X      CoreBlue    = (int)floatval[2];
X      return(0);
X      }
X
X   if(strcmp(variable, "mdcorners") == 0) {
X      if(floatparms != totparms || totparms < 2 || totparms > 4)
X     goto badarg;
X      zzmin = floatval[0];
X      zzmax = floatval[1];
X      if(totparms >= 3)
X     ttmin = floatval[2];
X      if(totparms == 4)
X     ttmax = floatval[3];
X      return(0);
X      }
X
X   if(strcmp(variable, "numframes") == 0) {
X      NumFrames = numval;
X      return(0);
X      }
X
X   if (strcmp(variable,"autokeyname") == 0) {   /* autokeyname=? */
X      strcpy(autoname,value);
X      return 0;
X      }
X
X   if (strcmp(variable,"type") == 0 ) {         /* type=? */
X      if (value[valuelen-1] == '*')
X     value[--valuelen] = 0;
X      /* kludge because type ifs3d has an asterisk in front */
X      if(strcmp(value,"ifs3d")==0)
X         value[3]=0;
X      for (k = 0; fractalspecific[k].name != NULL; k++)
X     if (strcmp(value,fractalspecific[k].name) == 0)
X        break;
X      if (fractalspecific[k].name == NULL) goto badarg;
X      curfractalspecific = &fractalspecific[fractype = k];
X      if (initcorners == 0) {
X     xx3rd = xxmin = curfractalspecific->xmin;
X     xxmax           = curfractalspecific->xmax;
X     yy3rd = yymin = curfractalspecific->ymin;
X     yymax           = curfractalspecific->ymax;
X     }
X      if (initparams == 0) {
X     for (k = 0; k < 4; ++k) {
X        param[k] = curfractalspecific->paramvalue[k];
X        if(fractype != CELLULAR) /* don't round cellular */
X           roundfloatd(¶m[k]);
X      }
X         if(curfractalspecific->flags&MORE) {
X            int extra;
X            if((extra=find_extra_param(fractype)) > -1)
X            for(i=0;i<MAXPARAMS-4;i++) {
X               param[i+4] = moreparams[extra].paramvalue[i];
X           }
X         }
X      }
X      return 1;
X      }
X   if (strcmp(variable,"inside") == 0 ) {       /* inside=? */
X      if(strcmp(value,s_zmag)==0)
X     inside = -59;
X      else if(strcmp(value,s_bof60)==0)
X     inside = -60;
X      else if(strcmp(value,s_bof61)==0)
X     inside = -61;
X      else if(strncmp(value,s_epscross,3)==0)
X     inside = -100;
X      else if(strncmp(value,s_startrail,4)==0)
X     inside = -101;
X      else if(strncmp(value,s_period,3)==0)
X     inside = -102;
X      else if(strcmp(value,s_maxiter)==0)
X     inside = -1;
X      else if(numval == NONNUMERIC)
X     goto badarg;
X      else
X     inside = numval;
X      return 1;
X      }
X   if (strcmp(variable,"fillcolor") == 0 ) {       /* fillcolor */
X      if(strcmp(value,s_normal)==0)
X     fillcolor = -1;
X      else if(numval == NONNUMERIC)
X     goto badarg;
X      else
X     fillcolor = numval;
X      return 1;
X      }
X
X   if (strcmp(variable,"finattract") == 0 ) {   /* finattract=? */
X      if (yesnoval < 0) goto badarg;
X      finattract = yesnoval;
X      return 1;
X      }
X
X   if (strcmp(variable,"function") == 0) {      /* function=?,? */
X      k = 0;
X      while (*value && k < 4) {
X     if(set_trig_array(k++,value)) goto badarg;
X     if ((value = strchr(value,'/')) == NULL) break;
X     ++value;
X     }
X       functionpreloaded = 1; /* for old bifs  JCO 7/5/92 */
X      return 1;
X      }
X
X   if (strcmp(variable,"outside") == 0 ) {      /* outside=? */
X      if(strcmp(value,s_iter)==0)
X     outside = -1;
X      else if(strcmp(value,s_real)==0)
X     outside = -2;
X      else if(strcmp(value,s_imag)==0)
X     outside = -3;
X      else if(strcmp(value,s_mult)==0)
X     outside = -4;
X      else if(strcmp(value,s_sum)==0)
X     outside = -5;
X
X      else if(numval == NONNUMERIC)
X     goto badarg;
X      else if(numval < -5 || numval > 255) goto badarg;
X      else outside = numval;
X      return 1;
X      }
X
X   if (strcmp(variable,s_maxiter) == 0) {       /* maxiter=? */
X      if (numval < 2) goto badarg;
X      maxit = numval;
X      return 1;
X      }
X
X   if (strcmp(variable,"iterincr") == 0)        /* iterincr=? */
X      return 0;
X
X   if (strcmp(variable,"passes") == 0) {        /* passes=? */
X      if ( charval != '1' && charval != '2'
X    && charval != 'g' && charval != 'b'
X    && charval != 't')
X     goto badarg;
X      usr_stdcalcmode = charval;
X      return 1;
X      }
X
X   if (strcmp(variable,"cyclelimit") == 0 ) {   /* cyclelimit=? */
X      if (numval <= 1 || numval > 256) goto badarg;
X      initcyclelimit = numval;
X      return 0;
X      }
X
X   if (strcmp(variable,"makemig") == 0) {
X       int xmult, ymult;
X       if (totparms < 2) goto badarg;
X       xmult = intval[0];
X       ymult = intval[1];
X       make_mig(xmult, ymult);
X#ifndef WINFRACT
X       exit(0);
X#endif
X       }
X
X   if (strcmp(variable,"cyclerange") == 0) {
X      if (totparms < 2) intval[1] = 255;
X      if (totparms < 1) intval[0] = 1;
X      if (totparms != intparms
X    || intval[0] < 0 || intval[1] > 255 || intval[0] > intval[1])
X     goto badarg;
X      rotate_lo = intval[0];
X      rotate_hi = intval[1];
X      return 0;
X      }
X
X   if (strcmp(variable,"ranges") == 0) {
X      int i,j,entries,prev;
X      int tmpranges[128];
X      if (totparms != intparms) goto badarg;
X      entries = prev = i = 0;
X      while (i < totparms) {
X     if ((j = intval[i++]) < 0) { /* striping */
X        if ((j = 0-j) < 1 || j >= 16384 || i >= totparms) goto badarg;
X        tmpranges[entries++] = -1; /* {-1,width,limit} for striping */
X        tmpranges[entries++] = j;
X        j = intval[i++];
X        }
X     if (j < prev) goto badarg;
X     tmpranges[entries++] = prev = j;
X     }
X      if (prev == 0) goto badarg;
X      if ((ranges = (int far *)farmemalloc(2L*entries)) == NULL) {
X     static char far msg[] = {"Insufficient memory for ranges="};
X     stopmsg(0,msg);
X     return(-1);
X     }
X      rangeslen = entries;
X      for (i = 0; i < rangeslen; ++i)
X     ranges[i] = tmpranges[i];
X      return 1;
X      }
X
X   if (strcmp(variable,"savename") == 0) {      /* savename=? */
X      if (valuelen > 79) goto badarg;
X      if (first_init || mode == 2)
X     strcpy(savename,value);
X      return 0;
X      }
X
X   if (strcmp(variable,"exitmode") == 0) {      /* exitmode=? */
X      sscanf(value,"%x",&numval);
X      exitmode = numval;
X      return 0;
X      }
X
X   if (strcmp(variable,"textcolors") == 0) {
X      parse_textcolors(value);
X      return 0;
X      }
X
X   if (strcmp(variable,"potential") == 0) {     /* potential=? */
X      k = 0;
X      while (k < 3 && *value) {
X         if(k==1)
X        potparam[k] = atof(value);
X     else
X        potparam[k] = atoi(value);
X     k++;
X       if ((value = strchr(value,'/')) == NULL) k = 99;
X     ++value;
X     }
X      pot16bit = 0;
X      if (k < 99) {
X     if (strcmp(value,"16bit")) goto badarg;
X     pot16bit = 1;
X     }
X      return 1;
X      }
X
X   if (strcmp(variable,"params") == 0) {        /* params=?,? */
X      if (totparms != floatparms || totparms > MAXPARAMS)
X     goto badarg;
X      for (k = 0; k < MAXPARAMS; ++k)
X     param[k] = (k < totparms) ? floatval[k] : 0.0;
X      initparams = 1;
X      return 1;
X      }
X
X   if (strcmp(variable, "miim") == 0) {        /* miim=?[/?[/?[/?]]] */
X      k = 0;
X      do {
X     if (isdigit(*value) ||
X         *value == '.' || *value == '-' || *value == '+') {
X        if (k >= 4)
X           goto badarg;
X        param[k++] = atof(value);
X     }
X     else if (strncmp(value, "breadth", 7) == 0)
X        major_method = 0;
X     else if (strncmp(value, "depth",   5) == 0)
X        major_method = 1;
X     else if (strncmp(value, "walk",    4) == 0)
X        major_method = 2;
X     else if (strncmp(value, "run",     3) == 0)
X        major_method = 3;
X     else if (strncmp(value, "left",    4) == 0)
X        minor_method = 0;
X     else if (strncmp(value, "right",   5) == 0)
X        minor_method = 1;
X     else goto badarg;
X     value = strchr(value, '/');
X      } while (value++);
X      return 1;
X   }
X
X   if (strcmp(variable,"initorbit") == 0) {     /* initorbit=?,? */
X      if(strcmp(value,"pixel")==0)
X     useinitorbit = 2;
X      else {
X     if (totparms != 2 || floatparms != 2) goto badarg;
X     initorbit[0] = floatval[0];
X     initorbit[1] = floatval[1];
X     useinitorbit = 1;
X     }
X      return 1;
X      }
X
X   if (strcmp(variable,"orbitname") == 0 ) {         /* orbitname=? */
X      if(check_orbit_name(value))
X         goto badarg;
X      return 1;
X      }
X   if (strcmp(variable,"3dmode") == 0 ) {         /* orbitname=? */
X      int i,j;
X      j = -1;
X      for(i=0;i<4;i++)
X         if(strcmp(value,juli3Doptions[i])==0)
X            j = i;
X      if(j < 0)
X         goto badarg;
X      else
X         juli3Dmode = j;
X      return 1;
X      }
X
X   if (strcmp(variable,"julibrot3d") == 0) {       /* julibrot3d=?,?,?,? */
X      if (floatparms != totparms)
X     goto badarg;
X      if(totparms > 0)
X         zdots = floatval[0];
X      if (totparms > 1)
X         originfp = floatval[1];
X      if (totparms > 2)
X         depthfp = floatval[2];
X      if (totparms > 3)
X         heightfp = floatval[3];
X      if (totparms > 4)
X         widthfp = floatval[4];
X      if (totparms > 5)
X         distfp = floatval[5];
X      return 1;
X      }
X
X   if (strcmp(variable,"julibroteyes") == 0) {       /* julibroteyes=?,?,?,? */
X      if (floatparms != totparms || totparms != 1)
X     goto badarg;
X      eyesfp =  floatval[0];
X      return 1;
X      }
X
X   if (strcmp(variable,"julibrotfromto") == 0) {       /* julibrotfromto=?,?,?,? */
X      if (floatparms != totparms || totparms != 4)
X     goto badarg;
X      mxmaxfp = floatval[0];
X      mxminfp = floatval[1];
X      mymaxfp = floatval[2];
X      myminfp = floatval[3];
X      return 1;
X      }
X
X   if (strcmp(variable,"corners") == 0) {       /* corners=?,?,?,? */
X      if (fractype == CELLULAR)
X          return 1; /* skip setting the corners */
X      if (floatparms != totparms || (totparms != 4 && totparms != 6))
X     goto badarg;
X      usemag = 0;
X      initcorners = 1;
X      xx3rd = xxmin = floatval[0];
X      xxmax =          floatval[1];
X      yy3rd = yymin = floatval[2];
X      yymax =          floatval[3];
X      if (totparms == 6) {
X     xx3rd =      floatval[4];
X     yy3rd =      floatval[5];
X     }
X      return 1;
X      }
X
X   if (strcmp(variable,"viewwindows") == 0) {  /* viewwindows=?,?,?,?,? */
X      if (totparms > 5 || floatparms-intparms > 2 || intparms > 4)
X     goto badarg;
X      viewwindow = 1;
X      viewreduction = 4.2;  /* reset default values */
X      finalaspectratio = screenaspect;
X      viewcrop = 1; /* yes */
X      viewxdots = viewydots = 0;
X
X      if((totparms > 0) && (floatval[0] > 0.001))
X        viewreduction = floatval[0];
X      if((totparms > 1) && (floatval[1] > 0.001))
X        finalaspectratio = floatval[1];
X      if((totparms > 2) && (yesnoval == 0))
X        viewcrop = yesnoval;
X      if((totparms > 3) && (intval[3] > 0))
X        viewxdots = intval[3];
X      if((totparms == 5) && (intval[4] > 0))
X        viewydots = intval[4];
X      return 1;
X      }
X
X   if (strcmp(variable,"center-mag") == 0) {    /* center-mag=?,?,? */
X      double Xctr, Yctr,Magnification,Ratio,Height, Width,Radius;
X      if (totparms != floatparms
X    || (totparms != 0 && totparms != 3)
X    || (totparms == 3 && floatval[2] <= 0.0))
X     goto badarg;
X      usemag = 1;
X      if (totparms == 0) return 0;
X      initcorners = 1;
X      Xctr = floatval[0];
X      Yctr = floatval[1];
X      Magnification = floatval[2];
X      Radius = 1.0 / Magnification;
X      Ratio = .75;    /* inverse aspect ratio of screen  */
X      /* calculate bounds */
X      Height = 2.0 * Radius;
X      Width = Height / Ratio;
X      yymax = Yctr + Radius;
X      yy3rd = yymin = Yctr - Radius;
X      xxmax = Xctr + Width / 2.0;
X      xx3rd = xxmin = Xctr - Width / 2.0;
X      return 1;
X      }
X
X   if (strcmp(variable,"invert") == 0) {        /* invert=?,?,? */
X      if (totparms != floatparms || (totparms != 1 && totparms != 3))
X     goto badarg;
X      invert = ((inversion[0] = floatval[0]) != 0.0) ? totparms : 0;
X      if (totparms == 3) {
X     inversion[1] = floatval[1];
X     inversion[2] = floatval[2];
X     }
X      return 1;
X      }
X
X   if (strcmp(variable,"askvideo") == 0 ) {     /* askvideo=?   */
X      if (yesnoval < 0) goto badarg;
X      askvideo = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable,"ramvideo") == 0 )       /* ramvideo=?   */
X      return 0; /* just ignore and return, for old time's sake */
X
X   if (strcmp(variable,"float") == 0 ) {        /* float=? */
X      if (yesnoval < 0) goto badarg;
X      usr_floatflag = yesnoval;
X      return 3;
X      }
X
X   if (strcmp(variable,"biomorph") == 0 ) {     /* biomorph=? */
X      usr_biomorph = numval;
X      return 1;
X      }
X
X   if (strcmp(variable,"orbitsave") == 0 ) {     /* orbitsave=? */
X      if (yesnoval < 0) goto badarg;
X      orbitsave = yesnoval;
X      return 1;
X      }
X
X   if (strcmp(variable,"bailout") == 0 ) {      /* bailout=? */
X      if (numval < 4 || numval > 32000) goto badarg;
X      bailout = numval;
X      return 1;
X      }
X
X   if (strcmp(variable,"symmetry") == 0 ) {     /* symmetry=? */
X      if     (strcmp(value,"xaxis" )==0) forcesymmetry = XAXIS;
X      else if(strcmp(value,"yaxis" )==0) forcesymmetry = YAXIS;
X      else if(strcmp(value,"xyaxis")==0) forcesymmetry = XYAXIS;
X      else if(strcmp(value,"origin")==0) forcesymmetry = ORIGIN;
X      else if(strcmp(value,"pi"    )==0) forcesymmetry = PI_SYM;
X      else if(strcmp(value,"none"  )==0) forcesymmetry = NOSYM;
X      else goto badarg;
X      return 1;
X      }
X
X   if (strcmp(variable,"printer") == 0 ) {      /* printer=? */
X      if (parse_printer(value) < 0) goto badarg;
X      return 0;
X      }
X
X   if (strcmp(variable,"printfile") == 0) {     /* print-to-file? SWT */
X      if (valuelen > 79) goto badarg;
X      Print_To_File = 1;
X      strcpy(PrintName,value);
X      return 0;
X      }
X   if(strcmp(variable, "rleps") == 0) {
X      Printer_Compress = yesnoval;
X      return(0);
X      }
X   if(strcmp(variable, "colorps") == 0) {
X      ColorPS = yesnoval;
X      return(0);
X      }
X
X   if (strcmp(variable,"epsf") == 0) {          /* EPS type? SWT */
X      Print_To_File = 1;
X      EPSFileType = numval;
X      Printer_Type = 5;
X      if (strcmp(PrintName,"fract001.prn")==0)
X     strcpy(PrintName,"fract001.eps");
X      return 0;
X      }
X
X   if (strcmp(variable,"title") == 0) {         /* Printer title block? SWT */
X      if (yesnoval < 0) goto badarg;
X      Printer_Titleblock = yesnoval;
X      return 0;
X      }
X
X   if (strcmp(variable,"translate") == 0) {     /* Translate color? SWT */
X      Printer_ColorXlat=0;
X      if (charval == 'y')
X     Printer_ColorXlat=1;
X      else if (numval > 1 || numval < -1)
X     Printer_ColorXlat=numval;
X      return 0;
X      }
X
X   if (strcmp(variable,"plotstyle") == 0) {     /* plot style? SWT */
X      Printer_SStyle = numval;
X      return 0;
X      }
X
X   if (strcmp(variable,"halftone") == 0) {      /* New halftoning? SWT */
X      if (totparms != intparms) goto badarg;
X      Printer_SetScreen=1;
X      if ((totparms >  0) && ( intval[ 0] >= 0))
X                      Printer_SFrequency = intval[ 0];
X      if ((totparms >  1) && ( intval[ 1] >= 0))
X                      Printer_SAngle     = intval[ 1];
X      if ((totparms >  2) && ( intval[ 2] >= 0))
X                      Printer_SStyle     = intval[ 2];
X      if ((totparms >  3) && ( intval[ 3] >= 0))
X                      Printer_RFrequency = intval[ 3];
X      if ((totparms >  4) && ( intval[ 4] >= 0))
X                      Printer_RAngle     = intval[ 4];
X      if ((totparms >  5) && ( intval[ 5] >= 0))
X                      Printer_RStyle     = intval[ 5];
X      if ((totparms >  6) && ( intval[ 6] >= 0))
X                      Printer_GFrequency = intval[ 6];
X      if ((totparms >  7) && ( intval[ 7] >= 0))
X                      Printer_GAngle     = intval[ 7];
X      if ((totparms >  8) && ( intval[ 8] >= 0))
X                      Printer_GStyle     = intval[ 8];
X      if ((totparms >  9) && ( intval[ 9] >= 0))
X                      Printer_BFrequency = intval[ 9];
X      if ((totparms > 10) && ( intval[10] >= 0))
X                      Printer_BAngle     = intval[10];
X      if ((totparms > 11) && ( intval[11] >= 0))
X                      Printer_BStyle     = intval[11];
X      return 0;
X      }
X
X   if (strcmp(variable,"linefeed") == 0) {      /* Use LF for printer */
X      if      (strcmp(value,"cr")   == 0) Printer_CRLF = 1;
X      else if (strcmp(value,"lf")   == 0) Printer_CRLF = 2;
X      else if (strcmp(value,"crlf") == 0) Printer_CRLF = 0;
X      else goto badarg;
X      return 0;
X      }
X
X   if (strcmp(variable,"comport") == 0 ) {      /* Set the COM parameters */
X      if ((value=strchr(value,'/')) == NULL) goto badarg;
X      switch (atoi(++value)) {
X     case 110:  l = 0;   break;
X     case 150:  l = 32;  break;
X     case 300:  l = 64;  break;
X     case 600:  l = 96;  break;
X     case 1200: l = 128; break;
X     case 2400: l = 160; break;
X     case 4800: l = 192; break;
X     case 9600:
X     default:   l = 224; break;
X     }
X      if ((value=strchr(value,'/')) == NULL) goto badarg;
X      for (k=0; k < strlen(value); k++) {
X     switch (value[k]) {
X        case '7':  l |= 2;  break;
X        case '8':  l |= 3;  break;
X        case 'o':  l |= 8;  break;
X        case 'e':  l |= 24; break;
X        case '2':  l |= 4;  break;
X        }
X     }
X#ifndef XFRACT
X#ifndef WINFRACT
X      _bios_serialcom(0,numval-1,l);
X#endif
X#endif
X      return 0;
X      }
X
X   if (strcmp(variable,"sound") == 0 ) {        /* sound=? */
X      soundflag = 0;
X      if (strncmp(value,"ye",2) == 0) {
X     soundflag = -1;
X     return(0);
X     }
X      if (charval == 'x')
X     soundflag = 1;
X      if (charval == 'y')
X     soundflag = 2;
X      if (charval == 'z')
X     soundflag = 3;
X      return 0;
X      }
X
X   if (strcmp(variable,"hertz") == 0) {         /* Hertz=? */
X      if (numval < 200 || numval > 10000) goto badarg;
X      basehertz = numval;
X      return 0;
X      }
X
X   if (strcmp(variable,"periodicity") == 0 ) {  /* periodicity=? */
X      usr_periodicitycheck=1;
X      if ((charval == 'n') || (numval == 0))
X     usr_periodicitycheck=0;
X      else if (charval == 'y')
X     usr_periodicitycheck=1;
X      else if (charval == 's')   /* 's' for 'show' */
X     usr_periodicitycheck= -1;
X      else if(numval == NONNUMERIC)
X     goto badarg;
X      else if(numval != 0)
X     usr_periodicitycheck=numval;
X      return 1;
X      }
X
X   if (strcmp(variable,"logmap") == 0 ) {       /* logmap=? */
X      if (charval == 'y')
X     LogFlag = 1;                /* palette is logarithmic */
X      else if (charval == 'n')
X     LogFlag = 0;
X      else if (charval == 'o')
X     LogFlag = -1;                /* old log palette */
X      else
X     LogFlag = numval;
X      return 1;
X      }
X
X   if (strcmp(variable,"debugflag") == 0
X     || strcmp(variable,"debug") == 0) {        /* internal use only */
X      debugflag = numval;
X      timerflag = debugflag & 1;        /* separate timer flag */
X      debugflag -= timerflag;
X      return 0;
X      }
X
X   if (strcmp(variable, "rseed") == 0) {
X      rseed = numval;
X      rflag = 1;
X      return 1;
X      }
X
X   if (strcmp(variable, "orbitdelay") == 0) {
X      orbit_delay = numval;
X      return 0;
X      }
X
X   if (strcmp(variable, "showdot") == 0) {
X      showdot=numval;
X      if(showdot<0)
X         showdot=0;
X      return 0;
X      }
X
X   if (strcmp(variable, "decomp") == 0) {
X      if (totparms != intparms || totparms < 1) goto badarg;
X      decomp[0] = intval[0];
X      decomp[1] = 0;
X      if (totparms > 1) /* backward compatibility */
X     bailout = decomp[1] = intval[1];
X      return 1;
X      }
X
X   if (strcmp(variable, "distest") == 0) {
X      if (totparms != intparms || totparms < 1) goto badarg;
X      usr_distest = intval[0];
X      distestwidth = 71;
X      if (totparms > 1)
X     distestwidth = intval[1];
X      return 1;
X      }
X
X   if (strcmp(variable,"formulafile") == 0) {   /* formulafile=? */
X      if (valuelen > 79) goto badarg;
X      strcpy(FormFileName,value);
X      return 1;
X      }
X
X   if (strcmp(variable,"formulaname") == 0) {   /* formulaname=? */
X      if (valuelen > ITEMNAMELEN) goto badarg;
X      strcpy(FormName,value);
X      return 1;
X      }
X
X   if (strcmp(variable,"lfile") == 0) {
X      if (valuelen > 79) goto badarg;
X      strcpy(LFileName,value);
X      return 1;
X      }
X
X   if (strcmp(variable,"lname") == 0) {
X      if (valuelen > ITEMNAMELEN) goto badarg;
X      strcpy(LName,value);
X      return 1;
X      }
X
X   if (strcmp(variable,"ifsfile") == 0) {
X      if (valuelen > 79) goto badarg;
X      strcpy(IFSFileName,value);
X      reset_ifs_defn();
X      return 1;
X      }
X
X   if (strcmp(variable,"ifs") == 0
X     || strcmp(variable,"ifs3d") == 0) {        /* ifs3d for old time's sake */
X      if (valuelen > ITEMNAMELEN) goto badarg;
X      strcpy(IFSName,value);
X      reset_ifs_defn();
X      return 1;
X      }
X
X   if (strcmp(variable,"parmfile") == 0) {
X      if (valuelen > 79) goto badarg;
X      strcpy(CommandFile,value);
X      return 0;
X      }
X
X   if (strcmp(variable,"stereo") == 0) {        /* stereo=? */
X      if ((numval<0) || (numval>3)) goto badarg;
X      glassestype = numval;
X      return 3;
X      }
X
X   if (strcmp(variable,"rotation") == 0) {      /* rotation=?/?/? */
X      if (totparms != 3 || intparms != 3) goto badarg;
X      XROT = intval[0];
X      YROT = intval[1];
X      ZROT = intval[2];
X      return 3;
X      }
X
X   if (strcmp(variable,"perspective") == 0) {   /* perspective=? */
X      if (numval == NONNUMERIC) goto badarg;
X      ZVIEWER = numval;
X      return 3;
X      }
X
X   if (strcmp(variable,"xyshift") == 0) {       /* xyshift=?/?  */
X      if (totparms != 2 || intparms != 2) goto badarg;
X      XSHIFT = intval[0];
X      YSHIFT = intval[1];
X      return 3;
X      }
X
X   if (strcmp(variable,"interocular") == 0) {   /* interocular=? */
X      eyeseparation = numval;
X      return 3;
X      }
X
X   if (strcmp(variable,"converge") == 0) {      /* converg=? */
X      xadjust = numval;
X      return 3;
X      }
X
X   if (strcmp(variable,"crop") == 0) {          /* crop=? */
X      if (totparms != 4 || intparms != 4
X    || intval[0] < 0 || intval[0] > 100
X    || intval[1] < 0 || intval[1] > 100
X    || intval[2] < 0 || intval[2] > 100
X    || intval[3] < 0 || intval[3] > 100)
X      goto badarg;
X      red_crop_left   = intval[0];
X      red_crop_right  = intval[1];
X      blue_crop_left  = intval[2];
X      blue_crop_right = intval[3];
X      return 3;
X      }
X
X   if (strcmp(variable,"bright") == 0) {        /* bright=? */
X      if (totparms != 2 || intparms != 2) goto badarg;
X      red_bright  = intval[0];
X      blue_bright = intval[1];
X      return 3;
X      }
X
X   if (strcmp(variable,"xyadjust") == 0) {      /* trans=? */
X      if (totparms != 2 || intparms != 2) goto badarg;
X      xtrans = intval[0];
X      ytrans = intval[1];
X      return 3;
X      }
X
X   if (strcmp(variable,"3d") == 0) {            /* 3d=?/?/..    */
X      if(strcmp(value,"overlay")==0) {
X         yesnoval=1;
X         if(calc_status > -1) /* if no image, treat same as 3D=yes */
X            overlay3d=1;
X      }
X      else if (yesnoval < 0) goto badarg;
X      display3d = yesnoval;
X      initvars_3d();
X      return (display3d) ? 6 : 2;
X      }
X
X   if (strcmp(variable,"sphere") == 0 ) {       /* sphere=? */
X      if (yesnoval < 0) goto badarg;
X      SPHERE = yesnoval;
X      return 2;
X      }
X
X   if (strcmp(variable,"scalexyz") == 0) {      /* scalexyz=?/?/? */
X      if (totparms < 2 || intparms != totparms) goto badarg;
X      XSCALE = intval[0];
X      YSCALE = intval[1];
X      if (totparms > 2) ROUGH = intval[2];
X      return 2;
X      }
X
X   /* "rough" is really scale z, but we add it here for convenience */
X   if (strcmp(variable,"roughness") == 0) {     /* roughness=?  */
X      ROUGH = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"waterline") == 0) {     /* waterline=?  */
X      if (numval<0) goto badarg;
X      WATERLINE = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"filltype") == 0) {      /* filltype=?   */
X      if (numval < -1 || numval > 6) goto badarg;
X      FILLTYPE = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"lightsource") == 0) {   /* lightsource=?/?/? */
X      if (totparms != 3 || intparms != 3) goto badarg;
X      XLIGHT = intval[0];
X      YLIGHT = intval[1];
X      ZLIGHT = intval[2];
X      return 2;
X      }
X
X   if (strcmp(variable,"smoothing") == 0) {     /* smoothing=?  */
X      if (numval<0) goto badarg;
X      LIGHTAVG = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"latitude") == 0) {      /* latitude=?/? */
X      if (totparms != 2 || intparms != 2) goto badarg;
X      THETA1 = intval[0];
X      THETA2 = intval[1];
X      return 2;
X      }
X
X   if (strcmp(variable,"longitude") == 0) {     /* longitude=?/? */
X      if (totparms != 2 || intparms != 2) goto badarg;
X      PHI1 = intval[0];
X      PHI2 = intval[1];
X      return 2;
X      }
X
X   if (strcmp(variable,"radius") == 0) {        /* radius=? */
X      if (numval < 0) goto badarg;
X      RADIUS = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"transparent") == 0) {   /* transparent? */
X      if (totparms != intparms || totparms < 1) goto badarg;
X      transparent[1] = transparent[0] = intval[0];
X      if (totparms > 1) transparent[1] = intval[1];
X      return 2;
X      }
X
X   if (strcmp(variable,"preview") == 0) {       /* preview? */
X      if (yesnoval < 0) goto badarg;
X      preview = yesnoval;
X      return 2;
X      }
X
X   if (strcmp(variable,"showbox") == 0) {       /* showbox? */
X      if (yesnoval < 0) goto badarg;
X      showbox = yesnoval;
X      return 2;
X      }
X
X   if (strcmp(variable,"coarse") == 0) {        /* coarse=? */
X      if (numval < 3 || numval > 2000) goto badarg;
X      previewfactor = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"randomize") == 0) {     /* RANDOMIZE=? */
X      if (numval<0 || numval>7) goto badarg;
X      RANDOMIZE = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"ambient") == 0) {       /* ambient=? */
X      if (numval<0||numval>100) goto badarg;
X      Ambient = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"haze") == 0) {          /* haze=? */
X      if (numval<0||numval>100) goto badarg;
X      haze = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"fullcolor") == 0) {     /* fullcolor=? */
X      if (yesnoval < 0) goto badarg;
X      Targa_Out = yesnoval;
X      return 2;
X      }
X   if (strcmp(variable,"targa_out") == 0) {     /* Targa Out? */
X      if (yesnoval < 0) goto badarg;
X      Targa_Out = yesnoval;
X      return 2;
X      }
X
X   if (strcmp(variable,"targa_overlay") == 0) {         /* Targa Overlay? */
X      if (yesnoval < 0) goto badarg;
X      Targa_Overlay = yesnoval;
X      return 2;
X      }
X
X   if (strcmp(variable,"background") == 0) {     /* background=?/? */
X      if (totparms != 3 || intparms != 3) goto badarg;
X                for (i=0;i<3;i++)
X                        if (intval[i] & 0xff)
X                                goto badarg;
X      back_color[0] = intval[0];
X      back_color[1] = intval[1];
X      back_color[2] = intval[2];
X      return 2;
X      }
X
X   if (strcmp(variable,"lightname") == 0) {     /* lightname=?   */
X      if (valuelen > 79) goto badarg;
X      if (first_init || mode == 2)
X     strcpy(light_name,value);
X      return 0;
X      }
X
X   if (strcmp(variable,"ray") == 0) {           /* RAY=? */
X      if (numval < 0 || numval > 6) goto badarg;
X      RAY = numval;
X      return 2;
X      }
X
X   if (strcmp(variable,"brief") == 0) {         /* BRIEF? */
X      if (yesnoval < 0) goto badarg;
X      BRIEF = yesnoval;
X      return 2;
X      }
X
X   if (strcmp(variable,"release") == 0) {       /* release */
X      if (numval < 0) goto badarg;
X
X      save_release = numval;
X      return 2;
X      }
X
X
Xbadarg:
X   argerror(curarg);
X   return(-1);
X
X}
X
X/* Some routines broken out of above so compiler doesn't run out of heap: */
X
Xstatic void parse_textcolors(char *value)
X{
X   int i,j,k,hexval;
X   if (strcmp(value,"mono") == 0) {
X      for (k = 0; k < sizeof(txtcolor); ++k)
X     txtcolor[k] = BLACK*16+WHITE;
X   /* C_HELP_CURLINK = C_PROMPT_INPUT = C_CHOICE_CURRENT = C_GENERAL_INPUT
X             = C_AUTHDIV1 = C_AUTHDIV2 = WHITE*16+BLACK; */
X      txtcolor[6] = txtcolor[12] = txtcolor[13] = txtcolor[14] = txtcolor[20]
X          = txtcolor[27] = txtcolor[28] = WHITE*16+BLACK;
X      /* C_TITLE = C_HELP_HDG = C_HELP_LINK = C_PROMPT_HI = C_CHOICE_SP_KEYIN
X         = C_GENERAL_HI = C_DVID_HI = C_STOP_ERR
X         = C_STOP_INFO = BLACK*16+L_WHITE; */
X      txtcolor[0] = txtcolor[2] = txtcolor[5] = txtcolor[11] = txtcolor[16]
X          = txtcolor[17] = txtcolor[22] = txtcolor[24]
X          = txtcolor[25] = BLACK*16+L_WHITE;
X      }
X   else {
X      k = 0;
X      while ( k < sizeof(txtcolor)) {
X     if (*value == 0) break;
X     if (*value != '/') {
X        sscanf(value,"%x",&hexval);
X        i = (hexval / 16) & 7;
X        j = hexval & 15;
X        if (i == j || (i == 0 && j == 8)) /* force contrast */
X           j = 15;
X        txtcolor[k] = i * 16 + j;
X        if ((value = strchr(value,'/')) == NULL) break;
X        }
X     ++value;
X     ++k;
X     }
X      }
X}
X
Xstatic int parse_colors(char *value)
X{
X   int i,j,k;
X   if (*value == '@') {
X      if (strlen(value) > 80 || ValidateLuts(&value[1]) != 0) goto badcolor;
X      if (display3d) {
X        mapset = 1;
X        strcpy(MAP_name,&value[1]);
X        }
X      else {
X        strcpy(colorfile,&value[1]);
X        colorstate = 2;
X        }
X      }
X   else {
X      int smooth;
X      i = smooth = 0;
X      while (*value) {
X     if (i >= 256) goto badcolor;
X     if (*value == '<') {
X        if (i == 0 || smooth
X          || (smooth = atoi(value+1)) < 2
X          || (value = strchr(value,'>')) == NULL)
X           goto badcolor;
X        i += smooth;
X        ++value;
X        }
X     else {
X        for (j = 0; j < 3; ++j) {
X           if ((k = *(value++)) < '0')  goto badcolor;
X           else if (k <= '9')       k -= '0';
X           else if (k < 'A')            goto badcolor;
X           else if (k <= 'Z')       k -= ('A'-10);
X           else if (k < '_' || k > 'z') goto badcolor;
X           else            k -= ('_'-36);
X           dacbox[i][j] = k;
X           if (smooth) {
X          int start,spread,cnum;
X          start = i - (spread = smooth + 1);
X          cnum = 0;
X          if ((k - (int)dacbox[start][j]) == 0) {
X             while (++cnum < spread)
X            dacbox[start+cnum][j] = k;
X             }
X          else {
X             while (++cnum < spread)
X            dacbox[start+cnum][j] =
X               ( cnum         *dacbox[i][j]
X               + (i-(start+cnum))*dacbox[start][j]
X               + spread/2 )
X               / spread;
X             }
X          }
X           }
X        smooth = 0;
X        ++i;
X        }
X     }
X      if (smooth) goto badcolor;
X      while (i < 256)  { /* zap unset entries */
X     dacbox[i][0] = dacbox[i][1] = dacbox[i][2] = 40;
X     ++i;
X     }
X      colorstate = 1;
X      }
X   colorpreloaded = 1;
X   return(0);
Xbadcolor:
X   return(-1);
X}
X
Xstatic int parse_printer(char *value)
X{
X   int k;
X   if (value[0]=='h' && value[1]=='p')
X      Printer_Type=1;                 /* HP LaserJet           */
X   if (value[0]=='i' && value[1]=='b')
X      Printer_Type=2;                 /* IBM Graphics           */
X   if (value[0]=='e' && value[1]=='p')
X      Printer_Type=2;                 /* Epson (model?)           */
X   if (value[0]=='c' && value[1]=='o')
X      Printer_Type=3;                 /* Star (Epson-Comp?) color */
X   if (value[0]=='p') {
X      if (value[1]=='a')
X     Printer_Type=4;             /* HP Paintjet (color)    */
X      if ((value[1]=='o' || value[1]=='s')) {
X     Printer_Type=5;             /* PostScript  SWT */
X     if (value[2]=='h' || value[2]=='l')
X        Printer_Type=6;
X     }
X      if (value[1]=='l')
X     Printer_Type=7;             /* HP Plotter (semi-color) */
X      }
X   if (Printer_Type == 1)             /* assume low resolution */
X      Printer_Resolution = 75;
X   else
X      Printer_Resolution = 60;
X   if (EPSFileType > 0)              /* EPS save - force type 5 */
X      Printer_Type = 5;
X   if ((Printer_Type == 5) || (Printer_Type == 6))
X      Printer_Resolution = 150;          /* PostScript def. res. */
X   if ((value=strchr(value,'/'))) {
X      if ((k=atoi(++value)) >= 0) Printer_Resolution=k;
X      if ((value=strchr(value,'/'))) {
X     if ((k=atoi(++value))> 0) LPTNumber = k;
X     if (k < 0) {
X        Print_To_File = 1;
X        LPTNumber = 1;
X        }
X     }
X      }
X   return(0);
X}
X
X
X
Xstatic void argerror(char *badarg)    /* oops. couldn't decode this */
X{
X   static char far argerrmsg1[]={"\
XOops. I couldn't understand the argument:\n  "};
X   static char far argerrmsg2[]={"\n\n\
X(see the Startup Help screens or documentation for a complete\n\
X argument list with descriptions)"};
X   char msg[300];
X   if (strlen(badarg) > 70) badarg[70] = 0;
X   if (active_system == 0 /* DOS */
X     && first_init)      /* & this is 1st call to cmdfiles */
X#ifndef XFRACT
X      sprintf(msg,"%Fs%s%Fs",argerrmsg1,badarg,argerrmsg2);
X   else
X      sprintf(msg,"%Fs%s",argerrmsg1,badarg);
X#else
X      sprintf(msg,"%s%s%s",argerrmsg1,badarg,argerrmsg2);
X   else
X      sprintf(msg,"%s%s",argerrmsg1,badarg);
X#endif
X   stopmsg(0,msg);
X}
X
Xvoid set_3d_defaults()
X{
X   ENTER_OVLY(OVLY_CMDFILES);
X   ROUGH     = 30;
X   WATERLINE = 0;
X   ZVIEWER   = 0;
X   XSHIFT    = 0;
X   YSHIFT    = 0;
X   xtrans    = 0;
X   ytrans    = 0;
X   LIGHTAVG  = 0;
X   Ambient   = 20;
X   RANDOMIZE = 0;
X   haze      = 0;
X   back_color[0] = 51; back_color[1] = 153; back_color[2] = 200;
X   if(SPHERE) {
X      PHI1    =  180;
X      PHI2    =  0;
X      THETA1    =  -90;
X      THETA2    =  90;
X      RADIUS    =  100;
X      FILLTYPE    = 2;
X      XLIGHT    = 1;
X      YLIGHT    = 1;
X      ZLIGHT    = 1;
X      }
X   else {
X      XROT    = 60;
X      YROT    = 30;
X      ZROT    = 0;
X      XSCALE    = 90;
X      YSCALE    = 90;
X      FILLTYPE    = 0;
X      if (active_system != 0)
X     FILLTYPE = 2;
X      XLIGHT    = 1;
X      YLIGHT    = -1;
X      ZLIGHT    = 1;
X      }
X    EXIT_OVLY;
X}
SHAR_EOF
$TOUCH -am 1028230093 cmdfiles.c &&
chmod 0644 cmdfiles.c ||
echo "restore of cmdfiles.c failed"
set `wc -c cmdfiles.c`;Wc_c=$1
if test "$Wc_c" != "67637"; then
    echo original size 67637, current size $Wc_c
fi
# ============= decoder.c ==============
echo "x - extracting decoder.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > decoder.c &&
X/* DECODE.C - An LZW decoder for GIF
X * Copyright (C) 1987, by Steven A. Bennett
X *
X * Permission is given by the author to freely redistribute and include
X * this code in any program as long as this credit is given where due.
X *
X * In accordance with the above, I want to credit Steve Wilhite who wrote
X * the code which this is heavily inspired by...
X *
X * GIF and 'Graphics Interchange Format' are trademarks (tm) of
X * Compuserve, Incorporated, an H&R Block Company.
X *
X * Release Notes: This file contains a decoder routine for GIF images
X * which is similar, structurally, to the original routine by Steve Wilhite.
X * It is, however, somewhat noticably faster in most cases.
X *
X == This routine was modified for use in FRACTINT in two ways.
X ==
X == 1) The original #includes were folded into the routine strictly to hold
X ==    down the number of files we were dealing with.
X ==
X == 2) The 'stack', 'suffix', 'prefix', and 'decoderline' arrays were changed from
X ==    static and 'malloc()'ed to external only so that the assembler
X ==    program could use the same array space for several independent
X ==    chunks of code.    Also, 'stack' was renamed to 'dstack' for TASM
X ==    compatibility.
X ==
X == 3) The 'out_line()' external function has been changed to reference
X ==    '*outln()' for flexibility (in particular, 3D transformations)
X ==
X == 4) A call to 'keypressed()' has been added after the 'outln()' calls
X ==    to check for the presenc of a key-press as a bail-out signal
X ==
X == (Bert Tyler and Timothy Wegner)
X */
X
X/* Rev ??/??/?? - Initial Release
X * Rev 01/02/91 - Revised by Mike Gelvin
X *                    altered logic to allow newcode to input a line at a time
X *                    altered logic to allow decoder to place characters
X *                        directly into the output buffer if they fit
X*/
X
X/***** C Library Includes ***********************************************/
X#include <stdio.h>
X
X/***** Application Includes *********************************************/
X#include "prototyp.h"
X
X/***** Application Function Prototypes **********************************/
Xstatic short get_next_code(void);
X
X/* extern short out_line(pixels, linelen)
X *     UBYTE pixels[];
X *     short linelen;
X *
X *   - This function takes a full line of pixels (one byte per pixel) and
X * displays them (or does whatever your program wants with them...).  It
X * should return zero, or negative if an error or some other event occurs
X * which would require aborting the decode process...  Note that the length
X * passed will almost always be equal to the line length passed to the
X * decoder function, with the sole exception occurring when an ending code
X * occurs in an odd place in the GIF file...  In any case, linelen will be
X * equal to the number of pixels passed...
X */
Xint (*outln)(BYTE *,int) = out_line;
X
X/***** Local Static Variables *******************************************/
X/* Various error codes used by decoder
X * and my own routines...   It's okay
X * for you to define whatever you want,
X * as long as it's negative...  It will be
X * returned intact up the various subroutine
X * levels...
X */
X#define OUT_OF_MEMORY -10
X#define BAD_CODE_SIZE -20
X#define READ_ERROR -1
X#define WRITE_ERROR -2
X#define OPEN_ERROR -3
X#define CREATE_ERROR -4
X
X#define MAX_CODES   4095
X
X#define NOPE 0
X#define YUP -1
X
Xstatic short curr_size;            /* The current code size */
X
X#ifndef XFRACT
Xstatic short far sizeofstring[MAX_CODES+1];
X#else
Xstatic short sizeofstring[MAX_CODES+1];    /* size of string list */
X#endif
X
X/* The following static variables are used
X * for seperating out codes
X */
Xstatic short navail_bytes;        /* # bytes left in block */
Xstatic short nbits_left;        /* # bits left in current byte */
Xstatic BYTE byte_buff[257];    /* Current block, reuse shared mem */
Xstatic BYTE *pbytes;        /* Pointer to next byte in block */
Xstatic unsigned short ret_code;
X
Xstatic short code_mask[13] = {
X     0,
X     0x0001, 0x0003,
X     0x0007, 0x000F,
X     0x001F, 0x003F,
X     0x007F, 0x00FF,
X     0x01FF, 0x03FF,
X     0x07FF, 0x0FFF
X     };
X
X/***** External Variables ***********************************************/
X/* extern short bad_code_count;
X *
X * This value is the only other global required by the using program, and
X * is incremented each time an out of range code is read by the decoder.
X * When this value is non-zero after a decode, your GIF file is probably
X * corrupt in some way...
X */
Xextern short bad_code_count;
X
X/* whups, here are more globals, added by PB: */
Xextern short skipxdots; /* 0 to get every dot, 1 for every 2nd, 2 every 3rd, ... */
Xextern short skipydots; /* ditto for rows */
X
X/*
XI removed the LOCAL identifiers in the arrays below and replaced them
Xwith 'extern's so as to declare (and re-use) the space elsewhere.
XThe arrays are actually declared in the assembler source.
X                        Bert Tyler
X*/
Xextern BYTE dstack[MAX_CODES + 1];            /* Stack for storing pixels */
Xextern BYTE suffix[MAX_CODES + 1];            /* Suffix table */
Xextern unsigned short prefix[MAX_CODES + 1];        /* Prefix linked list */
Xextern BYTE decoderline[2];                /* decoded line goes here */
X
X
X/* The reason we have these separated like this instead of using
X * a structure like the original Wilhite code did, is because this
X * stuff generally produces significantly faster code when compiled...
X * This code is full of similar speedups...  (For a good book on writing
X * C for speed or for space optimization, see Efficient C by Tom Plum,
X * published by Plum-Hall Associates...)
X */
X
X
X/***** Program **********************************************************/
X/* short decoder(linewidth)
X *    short linewidth;            * Pixels per line of image *
X *
X * - This function decodes an LZW image, according to the method used
X * in the GIF spec.  Every *linewidth* "characters" (ie. pixels) decoded
X * will generate a call to out_line(), which is a user specific function
X * to display a line of pixels.  The function gets its codes from
X * get_next_code() which is responsible for reading blocks of data and
X * seperating them into the proper size codes.    Finally, get_byte() is
X * the global routine to read the next byte from the GIF file.
X *
X * It is generally a good idea to have linewidth correspond to the actual
X * width of a line (as specified in the Image header) to make your own
X * code a bit simpler, but it isn't absolutely necessary.
X *
X * Returns: 0 if successful, else negative.  (See ERRS.H)
X *
X */
Xshort decoder( short linewidth)
X{
X    BYTE *sp;
X    short code;
X    short old_code;
X    short ret;
X    short c;
X    short size;
X    short i;
X    short j;
X    short fastloop;
X    short bufcnt;                    /* how many empty spaces left in buffer */
X    short xskip;
X    short slot;                        /* Last read code */
X    short newcodes;                    /* First available code */
X    BYTE *bufptr;
X    short yskip;
X    short top_slot;                    /* Highest code for current size */
X    short clear;                    /* Value for a clear code */
X    short ending;                    /* Value for a ending code */
X    BYTE out_value;
X
X
X    /* Initialize for decoding a new image...
X    */
X
X    if ((size = get_byte()) < 0)
X        return(size);
X    if (size < 2 || 9 < size)
X        return(BAD_CODE_SIZE);
X
X    curr_size = size + 1;
X    top_slot = 1 << curr_size;
X    clear = 1 << size;
X    ending = clear + 1;
X    slot = newcodes = ending + 1;
X    navail_bytes = nbits_left = sizeofstring[slot] = xskip = yskip
X        = old_code = 0;
X    out_value = 0;
Xfor (i = 0; i < slot; i++)
X{    sizeofstring[i] = 0;
X}
X
X    /* Initialize in case they forgot to put in a clear code.
X     * (This shouldn't happen, but we'll try and decode it anyway...)
X    */
X
X    /* Set up the stack pointer and decode buffer pointer
X    */
X    sp = dstack;
X    bufptr = decoderline;
X    bufcnt = linewidth;
X
X    /* This is the main loop.  For each code we get we pass through the
X     * linked list of prefix codes, pushing the corresponding "character" for
X     * each code onto the stack.  When the list reaches a single "character"
X     * we push that on the stack too, and then start unstacking each
X     * character for output in the correct order.  Special handling is
X     * included for the clear code, and the whole thing ends when we get
X     * an ending code.
X    */
X    while ((c = get_next_code()) != ending)
X    {
X
X        /* If we had a file error, return without completing the decode
X        */
X        if (c < 0)
X            return(0);
X
X        /* If the code is a clear code, reinitialize all necessary items.
X        */
X        if (c == clear)
X        {
X            curr_size = size + 1;
X            slot = newcodes;
X            sizeofstring[slot] = 0;
X            top_slot = 1 << curr_size;
X
X            /* Continue reading codes until we get a non-clear code
X             * (Another unlikely, but possible case...)
X            */
X            while ((c = get_next_code()) == clear)
X            ;
X
X            /* If we get an ending code immediately after a clear code
X             * (Yet another unlikely case), then break out of the loop.
X            */
X            if (c == ending)
X                break;
X
X            /* Finally, if the code is beyond the range of already set codes,
X             * (This one had better NOT happen...    I have no idea what will
X             * result from this, but I doubt it will look good...) then set it
X             * to color zero.
X            */
X            if (c >= slot)
X                c = 0;
X
X            old_code = out_value = c;
X
X            /* And let us not forget to put the char into the buffer... */
X            *sp++ = c;
X        }
X        else
X        {
X
X            /* In this case, it's not a clear code or an ending code, so
X             * it must be a code code...  So we can now decode the code into
X             * a stack of character codes. (Clear as mud, right?)
X            */
X            code = c;
X
X            /* Here we go again with one of those off chances...  If, on the
X             * off chance, the code we got is beyond the range of those already
X             * set up (Another thing which had better NOT happen...) we trick
X             * the decoder into thinking it actually got the next slot avail.
X            */
X
X            if (code >= slot)
X            {
X                if (code > slot)
X                {
X                    ++bad_code_count;
X                    c = slot;
X                }
X                code = old_code;
X                *sp++ = out_value;
X            }
X
X            /* Here we scan back along the linked list of prefixes.  If they can
X             * fit into the output buffer then transfer them direct.  ELSE push
X             * them into the stack until we are down to enough characters that
X             * they do fit.  Output the line then fall through to unstack the ones
X             * that would not fit.
X            */
X            fastloop = NOPE;
X            while (code >= newcodes)
X            {    j = i = sizeofstring[code];
X                if (i > 0 && bufcnt - i > 0 && skipxdots == 0)
X                {
X                    fastloop = YUP;
X
X                    do
X                    {    *(bufptr + j) = suffix[code];
X                        code = prefix[code];
X                    } while(--j > 0);
X                    *bufptr = (BYTE)code;
X                    bufptr += ++i;
X                    bufcnt -= i;
X                    if (bufcnt == 0) /* finished an input row? */
X                    {    if (--yskip < 0)
X                        {
X                            if ((ret = (*outln)(decoderline, bufptr - decoderline)) < 0)
X                                return(ret);
X                            yskip = skipydots;
X                        }
X                        if (keypressed())
X                            return(-1);
X                        bufptr = decoderline;
X                        bufcnt = linewidth;
X                        xskip = 0;
X                    }
X                }
X                else
X                {
X                    *sp++ = suffix[code];
X                    code = prefix[code];
X                }
X            }
X
X            /* Push the last character on the stack, and set up the new
X             * prefix and suffix, and if the required slot number is greater
X             * than that allowed by the current bit size, increase the bit
X             * size.  (NOTE - If we are all full, we *don't* save the new
X             * suffix and prefix...  I'm not certain if this is correct...
X             * it might be more proper to overwrite the last code...
X            */
X            if (fastloop == NOPE)
X                *sp++ = (BYTE)code;
X
X            if (slot < top_slot)
X            {
X                sizeofstring[slot] = sizeofstring[old_code]+1;
X                suffix[slot] = out_value = (BYTE)code;
X                prefix[slot++] = old_code;
X                old_code = c;
X            }
X            if (slot >= top_slot)
X                if (curr_size < 12)
X                {
X                    top_slot <<= 1;
X                    ++curr_size;
X                }
X        }
X        while (sp > dstack)
X        {
X            --sp;
X            if (--xskip < 0)
X            {
X                xskip = skipxdots;
X                *bufptr++ = *sp;
X            }
X            if (--bufcnt == 0) /* finished an input row? */
X            {    if (--yskip < 0)
X                {
X                    if ((ret = (*outln)(decoderline, bufptr - decoderline)) < 0)
X                        return(ret);
X                    yskip = skipydots;
X                }
X                if (keypressed())
X                    return(-1);
X                bufptr = decoderline;
X                bufcnt = linewidth;
X                xskip = 0;
X            }
X        }
X
X    }
X    /* PB note that if last line is incomplete, we're not going to try
X     * to emit it;  original code did, but did so via out_line and therefore
X     * couldn't have worked well in all cases...
X    */
X    return(0);
X}
X
X
X
X
X/***** Program **********************************************************/
X/* get_next_code()
X * - gets the next code from the GIF file.  Returns the code, or else
X * a negative number in case of file errors...
X */
Xstatic short get_next_code()
X{
X    static BYTE b1;                /* Current byte */
X    static unsigned short ret_code;
X
X    if (nbits_left == 0)
X    {
X        if (navail_bytes <= 0)
X        {
X
X            /* Out of bytes in current block, so read next block
X            */
X            pbytes = byte_buff;
X            if ((navail_bytes = get_byte()) < 0)
X                return(navail_bytes);
X            else
X                if (navail_bytes)
X                    get_bytes(byte_buff,navail_bytes);
X        }
X        b1 = *pbytes++;
X        nbits_left = 8;
X        --navail_bytes;
X    }
X
X    ret_code = b1 >> (8 - nbits_left);
X    while (curr_size > nbits_left)
X    {
X        if (navail_bytes <= 0)
X        {
X
X            /* Out of bytes in current block, so read next block
X            */
X            pbytes = byte_buff;
X            if ((navail_bytes = get_byte()) < 0)
X                return(navail_bytes);
X            else
X                if (navail_bytes)
X                    get_bytes(byte_buff,navail_bytes);
X        }
X        b1 = *pbytes++;
X        ret_code |= b1 << nbits_left;
X        nbits_left += 8;
X        --navail_bytes;
X    }
X    nbits_left -= curr_size;
X    return(ret_code & code_mask[curr_size]);
X}
SHAR_EOF
$TOUCH -am 1028230093 decoder.c &&
chmod 0644 decoder.c ||
echo "restore of decoder.c failed"
set `wc -c decoder.c`;Wc_c=$1
if test "$Wc_c" != "13232"; then
    echo original size 13232, current size $Wc_c
fi
# ============= editpal.c ==============
echo "x - extracting editpal.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > editpal.c &&
X/*
X * editpal.c
X *
X * Edits VGA 256-color palettes.
X *
X * This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X *
X *
X * Key to initials:
X *
X *    EAN - Ethan Nagel [70022,2552]
X *
X *    JJB - Juan J. Buhler [[e-mail]]
X *
X *    TIW - Tim Wegner
X *
X * Revision History:
X *
X *   10-22-90 EAN     Initial release.
X *
X *   10-23-90 EAN     "Discovered" get_line/put_line functions, integrated
X *                them in (instead of only getcolor/putcolor). Much
X *                faster!
X *              Redesigned color editors (now at top of palette) and
X *                re-assigned some keys.
X *              Added (A)uto option.
X *              Fixed memory allocation problem.  Now uses shared
X *                FRACTINT data area (strlocn).  Uses 6 bytes DS.
X *
X *   10-27-90 EAN     Added save to memory option - will save screen image to
X *                memory, if enough mem avail.  (disk otherwise).
X *              Added s(T)ripe mode - works like (S)hade except only
X *                changes every n'th entry.
X *              Added temporary palette save/restore.  (Can work like
X *                an undo feature.)  Thanks to Pieter Branderhorst for
X *                idea.
X *
X *   10-28-90 EAN     The (H)ide function now makes the palette invisible,
X *                while allowing any other operations (except '\\' -
X *                move/resize) to continue.
X *
X *   10-29-90 PB (in EAN's absence, <grin>)
X *              Change 'c' to 'd' and 's' to '=' for below.
X *              Add 'l' to load palette from .map, 's' to store .map.
X *              Add 'c' to invoke color cycling.
X *              Change cursor to use whatever colors it can from
X *              the palette (not fixed 0 and 255).
X *              Restore colors 0 and 255 to real values whenever
X *              palette is not on display.
X *              Rotate 255 colors instead of 254.
X *              Reduce cursor blink rate.
X *
X *   11-15-90 EAN     Minor "bug" fixes.  Continuous rotation now at a fixed
X *                rate - once every timer tick (18.2 sec);  Blanks out
X *                color samples when rotating; Editors no longer rotate
X *                with the colors in color rotation mode;  Eliminated
X *                (Z)oom mode; other minor fixes.
X *
X *   01-05-91 PB      Add 'w' function to convert to greyscale.
X *
X *   01-16-91 PB      Change rotate function to use new cyclerange stuff.
X *
X *   01-29-91 EAN     Made all colors editable.  The two reserved colors are
X *             X'ed out.  They can be edited but the color is not
X *             visible.  (There is an X over the sample instead.)
X *              Changed default reserved colors to 254 & 255.
X *              Added 'v' command to set the reserved colors to those
X *             under the editors.
X *              Added 'o' command to set the rotate range to between
X *                the two editors.
X *              Modified 'w' function:
X *                uses internal function to do conversion (not BIOS)
X *                will convert only current color if in 'x' mode or
X *              range between editors in 'y' mode or entire palette
X *              if in "normal" mode.
X *
X *   02-08-91 EAN     Improved 16 color support.  In 16 color mode, colors
X *                16-255 have a dot over them and are editable but not
X *                visible (like the two reserved colors).
X *
X *   09-08-91 SWT     Added 'n' command to make a negative color palette:
X *                      will convert only current color if in 'x' mode or
X *                      range between editors in 'y' mode or entire palette
X *                      if in "normal" mode.
X *
X *   03-03-92 JJB     Added '!', '@' and '#' commands to swap RG, GB and
X *                      RB columns (sorry, I didn't find better keys)
X *
X *  10-03-92 TIW      Minor changes for Jiim support, primarily changing
X *                    variables from static to global.
X *
X *   2-11-93 EAN      Added full Undo ('U' key) and Redo ('E' key)
X *                      capability.  Works pretty much as you'd expect
X *                      it to.
X *
X *    3-6-93 EAN      Modified "freestyle" mode, written by RB, to integrate
X *                      into palette editor more completely and work with
X *                      undo logic.
X *                    Added status area under the "fractint" message to
X *                      display current state of editor.  A = Auto mode,
X *                      X, Y = exclusion modes, F = freesyle mode, T = stripe
X *                      mode is waiting for #.
X *
X */
X
X
X
X#ifdef DEBUG_UNDO
X#include "mdisp.h"   /* EAN 930211 *** Debug Only *** */
X#endif
X
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X#ifndef XFRACT
X#include <stdarg.h>
X#include <dos.h>     /* for FP_SEG & FP_OFF */
X#else
X#include <varargs.h>
X#endif
X#include <math.h>
X
X#ifdef __TURBOC__
X#   include <mem.h>   /* to get mem...() declarations */
X#endif
X
X#include "fractint.h" /* for overlay stuff */
X#include "prototyp.h"
X
X
X/*
X * misc. #defines
X */
X
X#define FONT_DEPTH        8      /* font size */
X
X#define CSIZE_MIN        8      /* csize cannot be smaller than this */
X
X#define CURSOR_SIZE        5      /* length of one side of the x-hair cursor */
X
X#ifndef XFRACT
X#define CURSOR_BLINK_RATE   3      /* timer ticks between cursor blinks */
X#else
X#define CURSOR_BLINK_RATE   300      /* timer ticks between cursor blinks */
X#endif
X
X#define FAR_RESERVE     8192L      /* amount of far mem we will leave avail. */
X
X#define MAX_WIDTH     1024      /* palette editor cannot be wider than this */
X
Xchar scrnfile[] = "FRACTINT.$$1";  /* file where screen portion is */
X                   /* stored */
Xchar undofile[] = "FRACTINT.$$2";  /* file where undo list is stored */
X#define TITLE   "FRACTINT"
X
X#define TITLE_LEN (8)
X
X
X#define newx(size)     mem_alloc(size)
X#define new(class)     (class *)(mem_alloc(sizeof(class)))
X#define delete(block)
X
X#ifdef XFRACT
Xint editpal_cursor = 0;
X#endif
X
X
X/*
X * Stuff from fractint
X */
X
Xextern BYTE dacbox[256][3];     /* DAC spindac() will use         */
Xextern int         sxdots;         /* width of physical screen         */
Xextern int         sydots;         /* depth of physical screen         */
Xextern int         sxoffs;         /* start of logical screen         */
Xextern int         syoffs;         /* start of logical screen         */
Xextern int         lookatmouse;     /* mouse mode for getakey(), etc    */
Xextern int         strlocn[];      /* 10K buffer to store classes in   */
Xextern int         colors;         /* # colors avail.             */
Xextern int         color_bright;     /* brightest color in palette         */
Xextern int         color_dark;     /* darkest color in palette         */
Xextern int         color_medium;     /* nearest to medbright gray color  */
Xextern int         rotate_lo, rotate_hi;
Xextern int         debugflag;
Xint using_jiim = 0;
X
X/*
X * basic data types
X */
X
X
Xtypedef struct
X   {
X   BYTE red,
X         green,
X         blue;
X   } PALENTRY;
X
X
X
X/*
X * static data
X */
X
X
Xstatic BYTE far *font8x8 = NULL;
XBYTE     *line_buff;   /* must be alloced!!! */
Xstatic BYTE      fg_color,
X              bg_color;
Xstatic BOOLEAN          reserve_colors;
Xstatic BOOLEAN          inverse;
X
Xstatic float    gamma_val = 1.0;
X
X
X/*
X * Interface to FRACTINT's graphics stuff
X */
X
X
Xstatic void setpal(int pal, int r, int g, int b)
X   {
X   dacbox[pal][0] = r;
X   dacbox[pal][1] = g;
X   dacbox[pal][2] = b;
X   spindac(0,1);
X   }
X
X
Xstatic void setpalrange(int first, int how_many, PALENTRY *pal)
X   {
X   memmove(dacbox+first, pal, how_many*3);
X   spindac(0,1);
X   }
X
X
Xstatic void getpalrange(int first, int how_many, PALENTRY *pal)
X   {
X   memmove(pal, dacbox+first, how_many*3);
X   }
X
X
Xstatic void rotatepal(PALENTRY *pal, int dir, int lo, int hi)
X   {             /* rotate in either direction */
X   PALENTRY hold;
X   int        size;
X
X   size  = 1 + (hi-lo);
X
X   if ( dir > 0 )
X      {
X      while ( dir-- > 0 )
X         {
X         memmove(&hold, &pal[hi],  3);
X         memmove(&pal[lo+1], &pal[lo], 3*(size-1));
X         memmove(&pal[lo], &hold, 3);
X         }
X      }
X
X   else if ( dir < 0 )
X      {
X      while ( dir++ < 0 )
X         {
X         memmove(&hold, &pal[lo], 3);
X         memmove(&pal[lo], &pal[lo+1], 3*(size-1));
X         memmove(&pal[hi], &hold,  3);
X         }
X      }
X   }
X
X
Xstatic void clip_put_line(int row, int start, int stop, BYTE *pixels)
X   {
X   if ( row < 0 || row >= sydots || start > sxdots || stop < 0 )
X      return ;
X
X   if ( start < 0 )
X      {
X      pixels += -start;
X      start = 0;
X      }
X
X   if ( stop >= sxdots )
X      stop = sxdots - 1;
X
X   if ( start > stop )
X      return ;
X
X   put_line(row, start, stop, pixels);
X   }
X
X
Xstatic void clip_get_line(int row, int start, int stop, BYTE *pixels)
X   {
X   if ( row < 0 || row >= sydots || start > sxdots || stop < 0 )
X      return ;
X
X   if ( start < 0 )
X      {
X      pixels += -start;
X      start = 0;
X      }
X
X   if ( stop >= sxdots )
X      stop = sxdots - 1;
X
X   if ( start > stop )
X      return ;
X
X   get_line(row, start, stop, pixels);
X   }
X
X
Xvoid clip_putcolor(int x, int y, int color)
X   {
X   if ( x < 0 || y < 0 || x >= sxdots || y >= sydots )
X      return ;
X
X   putcolor(x, y, color);
X   }
X
X
Xint clip_getcolor(int x, int y)
X   {
X   if ( x < 0 || y < 0 || x >= sxdots || y >= sydots )
X      return (0);
X
X   return ( getcolor(x, y) );
X   }
X
X
Xvoid hline(int x, int y, int width, int color)
X   {
X   memset(line_buff, color, width);
X   clip_put_line(y, x, x+width-1, line_buff);
X   }
X
X
Xvoid vline(int x, int y, int depth, int color)
X   {
X   while (depth-- > 0)
X      clip_putcolor(x, y++, color);
X   }
X
X
Xvoid getrow(int x, int y, int width, char *buff)
X   {
X   clip_get_line(y, x, x+width-1, (BYTE *)buff);
X   }
X
X
Xvoid putrow(int x, int y, int width, char *buff)
X   {
X   clip_put_line(y, x, x+width-1, (BYTE *)buff);
X   }
X
X
Xstatic void vgetrow(int x, int y, int depth, char *buff)
X   {
X   while (depth-- > 0)
X      *buff++ = clip_getcolor(x, y++);
X   }
X
X
Xstatic void vputrow(int x, int y, int depth, char *buff)
X   {
X   while (depth-- > 0)
X      clip_putcolor(x, y++, (BYTE)(*buff++));
X   }
X
X
Xstatic void fillrect(int x, int y, int width, int depth, int color)
X   {
X   while (depth-- > 0)
X      hline(x, y++, width, color);
X   }
X
X
Xstatic void rect(int x, int y, int width, int depth, int color)
X   {
X   hline(x, y, width, color);
X   hline(x, y+depth-1, width, color);
X
X   vline(x, y, depth, color);
X   vline(x+width-1, y, depth, color);
X   }
X
X
Xvoid displayc(int x, int y, int fg, int bg, int ch)
X   {
X   int              xc, yc;
X   BYTE      t;
X   BYTE far *ptr;
X
X   if( font8x8 == NULL)
X      if ( (font8x8 = findfont(0)) == NULL )
X         return ;
X
X   ptr = ((BYTE far *)font8x8) + ch*FONT_DEPTH;
X
X   for (yc=0; yc<FONT_DEPTH; yc++, y++, ++ptr)
X      {
X      for (xc=0, t= *ptr; xc<8; xc++, t<<=1)
X     line_buff[xc] = (t&0x80) ? (unsigned)fg : (unsigned)bg;
X      putrow(x, y, 8, (char *)line_buff);
X      }
X   }
X
X
X#ifndef XFRACT
Xstatic void displayf(int x, int y, int fg, int bg, char *format, ...)
X#else
Xstatic void displayf(va_alist)
Xva_dcl
X#endif
X   {
X   char buff[81];
X   int  ctr;
X
X   va_list arg_list;
X
X#ifndef XFRACT
X   va_start(arg_list, format);
X#else
X   int x,y,fg,bg;
X   char *format;
X
X   va_start(arg_list);
X   x = va_arg(arg_list,int);
X   y = va_arg(arg_list,int);
X   fg = va_arg(arg_list,int);
X   bg = va_arg(arg_list,int);
X   format = va_arg(arg_list,char *);
X#endif
X   vsprintf(buff, format, arg_list);
X   va_end(arg_list);
X
X   for(ctr=0; buff[ctr]!='\0'; ctr++, x+=8)
X      displayc(x, y, fg, bg, buff[ctr]);
X   }
X
X
X/*
X * create smooth shades between two colors
X */
X
X
Xstatic void mkpalrange(PALENTRY *p1, PALENTRY *p2, PALENTRY pal[], int num, int skip)
X   {
X   int      curr;
X   double rm = (double)((int) p2->red   - (int) p1->red  ) / num,
X      gm = (double)((int) p2->green - (int) p1->green) / num,
X      bm = (double)((int) p2->blue  - (int) p1->blue ) / num;
X
X   for (curr=0; curr<num; curr+=skip)
X      {
X      if (gamma_val == 1)
X          {
X      pal[curr].red   = (p1->red   == p2->red  ) ? p1->red   :
X          (int) p1->red   + (int) ( rm * curr );
X      pal[curr].green = (p1->green == p2->green) ? p1->green :
X          (int) p1->green + (int) ( gm * curr );
X      pal[curr].blue  = (p1->blue  == p2->blue ) ? p1->blue  :
X          (int) p1->blue  + (int) ( bm * curr );
X      }
X      else
X      {
X      pal[curr].red   = (p1->red   == p2->red  ) ? p1->red   :
X          (int) p1->red   + pow(curr/(double)(num-1),gamma_val)*num*rm;
X      pal[curr].green = (p1->green == p2->green) ? p1->green :
X          (int) p1->green + pow(curr/(double)(num-1),gamma_val)*num*gm;
X      pal[curr].blue  = (p1->blue  == p2->blue ) ? p1->blue  :
X          (int) p1->blue  + pow(curr/(double)(num-1),gamma_val)*num*bm;
X      }
X      }
X   }
X
X
X
X/*  Swap RG GB & RB columns */
X
Xstatic void rotcolrg(PALENTRY pal[], int num)
X   {
X   int      curr;
X   int    dummy;
X
X    for (curr=0; curr<=num; curr++)
X      {
X      dummy = pal[curr].red;
X      pal[curr].red = pal[curr].green;
X      pal[curr].green = dummy;
X      }
X   }
X
X
Xstatic void rotcolgb(PALENTRY pal[], int num)
X   {
X   int      curr;
X   int    dummy;
X
X    for (curr=0; curr<=num; curr++)
X      {
X      dummy = pal[curr].green;
X      pal[curr].green = pal[curr].blue;
X      pal[curr].blue = dummy;
X      }
X   }
X
Xstatic void rotcolbr(PALENTRY pal[], int num)
X   {
X   int      curr;
X   int    dummy;
X
X    for (curr=0; curr<=num; curr++)
X      {
X      dummy = pal[curr].red;
X      pal[curr].red = pal[curr].blue;
X      pal[curr].blue = dummy;
X      }
X   }
X
X
X/*
X * convert a range of colors to grey scale
X */
X
X
Xstatic void palrangetogrey(PALENTRY pal[], int first, int how_many)
X   {
X   PALENTRY      *curr;
X   BYTE  val;
X
X
X   for (curr = &pal[first]; how_many>0; how_many--, curr++)
X      {
X      val = (BYTE) ( ((int)curr->red*30 + (int)curr->green*59 + (int)curr->blue*11) / 100 );
X      curr->red = curr->green = curr->blue = (BYTE)val;
X      }
X   }
X
X/*
X * convert a range of colors to their inverse
X */
X
X
Xstatic void palrangetonegative(PALENTRY pal[], int first, int how_many)
X   {
X   PALENTRY      *curr;
X
X   for (curr = &pal[first]; how_many>0; how_many--, curr++)
X      {
X      curr->red   = 63 - curr->red;
X      curr->green = 63 - curr->green;
X      curr->blue  = 63 - curr->blue;
X      }
X   }
X
X
X/*
X * draw and horizontal/vertical dotted lines
X */
X
X
Xstatic void hdline(int x, int y, int width)
X   {
X   int ctr;
X   BYTE *ptr;
X
X   for (ctr=0, ptr=line_buff; ctr<width; ctr++, ptr++)
X      *ptr = (ctr&2) ? bg_color : fg_color;
X
X   putrow(x, y, width, (char *)line_buff);
X   }
X
X
Xstatic void vdline(int x, int y, int depth)
X   {
X   int ctr;
X
X   for (ctr=0; ctr<depth; ctr++, y++)
X      clip_putcolor(x, y, (ctr&2) ? bg_color : fg_color);
X   }
X
X
Xstatic void drect(int x, int y, int width, int depth)
X   {
X   hdline(x, y, width);
X   hdline(x, y+depth-1, width);
X
X   vdline(x, y, depth);
X   vdline(x+width-1, y, depth);
X   }
X
X
X/*
X * A very simple memory "allocator".
X *
X * Each call to mem_alloc() returns size bytes from the array mem_block.
X *
X * Be sure to call mem_init() before using mem_alloc()!
X *
X */
X
Xstatic char     *mem_block;
Xstatic unsigned  mem_avail;
X
X
Xvoid mem_init(VOIDPTR block, unsigned size)
X   {
X   mem_block = (char *)block;
X   mem_avail = size;
X   }
X
X
XVOIDPTR mem_alloc(unsigned size)
X   {
X   VOIDPTR block;
X
X#ifndef XFRACT
X   if (size & 1)
X      ++size;   /* allocate even sizes */
X#else
X   size = (size+3)&~3; /* allocate word-aligned memory */
X#endif
X
X   if (mem_avail < size)   /* don't let this happen! */
X      {
X      static char far msg[] = "editpal.c: Out of memory!\n";
X
X      stopmsg(0, msg);
X      exit(1);
X      }
X
X   block = mem_block;
X   mem_avail -= size;
X   mem_block += size;
X
X   return(block);
X   }
X
X
X
X/*
X * misc. routines
X *
X */
X
X
Xstatic BOOLEAN is_reserved(int color)
X   {
X   return ( (reserve_colors && (color==fg_color || color==bg_color) ) ? TRUE : FALSE );
X   }
X
X
X
Xstatic BOOLEAN is_in_box(int x, int y, int bx, int by, int bw, int bd)
X   {
X   return ( (x >= bx) && (y >= by) && (x < bx+bw) && (y < by+bd) );
X   }
X
X
X
Xstatic void draw_diamond(int x, int y, int color)
X   {
X   putcolor (x+2, y+0,      color);
X   hline    (x+1, y+1, 3, color);
X   hline    (x+0, y+2, 5, color);
X   hline    (x+1, y+3, 3, color);
X   putcolor (x+2, y+4,      color);
X   }
X
X
X
X/*
X * Class:     Cursor
X *
X * Purpose:   Draw the blinking cross-hair cursor.
X *
X * Note:      Only one Cursor can exist (referenced through the_cursor).
X *          IMPORTANT: Call Cursor_Construct before you use any other
X *          Cursor_ function!  Call Cursor_Destroy before exiting to
X *          deallocate memory.
X */
X
Xstruct _Cursor
X   {
X
X   int       x, y;
X   int       hidden;     /* >0 if mouse hidden */
X   long    last_blink;
X   BOOLEAN blink;
X   char    t[CURSOR_SIZE],      /* save line segments here */
X       b[CURSOR_SIZE],
X       l[CURSOR_SIZE],
X       r[CURSOR_SIZE];
X   } ;
X
X#define Cursor struct _Cursor
X
X/* private: */
X
X   static  void    Cursor__Draw      (void);
X   static  void    Cursor__Save      (void);
X   static  void    Cursor__Restore   (void);
X
X/* public: */
X#ifdef NOT_USED
X   static  BOOLEAN Cursor_IsHidden  (void);
X#endif
X
X
X
Xstatic Cursor *the_cursor = NULL;
X
X
XBOOLEAN Cursor_Construct(void)
X   {
X   if (the_cursor != NULL)
X      return(FALSE);
X
X   the_cursor = new(Cursor);
X
X   the_cursor->x      = sxdots/2;
X   the_cursor->y      = sydots/2;
X   the_cursor->hidden      = 1;
X   the_cursor->blink      = FALSE;
X   the_cursor->last_blink = 0;
X
X   return (TRUE);
X   }
X
X
Xvoid Cursor_Destroy(void)
X   {
X   if (the_cursor != NULL)
X      delete(the_cursor);
X
X   the_cursor = NULL;
X   }
X
X
X
Xstatic void Cursor__Draw(void)
X   {
X   int color;
X
X   find_special_colors();
X   color = (the_cursor->blink) ? color_medium : color_dark;
X
X   vline(the_cursor->x, the_cursor->y-CURSOR_SIZE-1, CURSOR_SIZE, color);
X   vline(the_cursor->x, the_cursor->y+2,         CURSOR_SIZE, color);
X
X   hline(the_cursor->x-CURSOR_SIZE-1, the_cursor->y, CURSOR_SIZE, color);
X   hline(the_cursor->x+2,          the_cursor->y, CURSOR_SIZE, color);
X   }
X
X
Xstatic void Cursor__Save(void)
X   {
X   vgetrow(the_cursor->x, the_cursor->y-CURSOR_SIZE-1, CURSOR_SIZE, the_cursor->t);
X   vgetrow(the_cursor->x, the_cursor->y+2,           CURSOR_SIZE, the_cursor->b);
X
X   getrow(the_cursor->x-CURSOR_SIZE-1, the_cursor->y,  CURSOR_SIZE, the_cursor->l);
X   getrow(the_cursor->x+2,           the_cursor->y,  CURSOR_SIZE, the_cursor->r);
X   }
X
X
Xstatic void Cursor__Restore(void)
X   {
X   vputrow(the_cursor->x, the_cursor->y-CURSOR_SIZE-1, CURSOR_SIZE, the_cursor->t);
X   vputrow(the_cursor->x, the_cursor->y+2,           CURSOR_SIZE, the_cursor->b);
X
X   putrow(the_cursor->x-CURSOR_SIZE-1, the_cursor->y,  CURSOR_SIZE, the_cursor->l);
X   putrow(the_cursor->x+2,           the_cursor->y,  CURSOR_SIZE, the_cursor->r);
X   }
X
X
X
Xvoid Cursor_SetPos(int x, int y)
X   {
X   if (!the_cursor->hidden)
X      Cursor__Restore();
X
X   the_cursor->x = x;
X   the_cursor->y = y;
X
X   if (!the_cursor->hidden)
X      {
X      Cursor__Save();
X      Cursor__Draw();
X      }
X   }
X
X#ifdef NOT_USED
X
Xstatic int Cursor_IsHidden(void)
X   {
X   return ( the_cursor->hidden );
X   }
X
X
X#endif
X
X
Xvoid Cursor_Move(int xoff, int yoff)
X   {
X   if ( !the_cursor->hidden )
X      Cursor__Restore();
X
X   the_cursor->x += xoff;
X   the_cursor->y += yoff;
X
X   if (the_cursor->x < 0)       the_cursor->x = 0;
X   if (the_cursor->y < 0)       the_cursor->y = 0;
X   if (the_cursor->x >= sxdots) the_cursor->x = sxdots-1;
X   if (the_cursor->y >= sydots) the_cursor->y = sydots-1;
X
X   if ( !the_cursor->hidden )
X      {
X      Cursor__Save();
X      Cursor__Draw();
X      }
X   }
X
X
Xint Cursor_GetX(void)   { return(the_cursor->x); }
X
Xint Cursor_GetY(void)   { return(the_cursor->y); }
X
X
Xvoid Cursor_Hide(void)
X   {
X   if ( the_cursor->hidden++ == 0 )
X      Cursor__Restore();
X   }
X
X
Xvoid Cursor_Show(void)
X   {
X   if ( --the_cursor->hidden == 0)
X      {
X      Cursor__Save();
X      Cursor__Draw();
X      }
X   }
X
X#ifdef XFRACT
Xvoid Cursor_StartMouseTracking()
X{
X    editpal_cursor = 1;
X}
X
Xvoid Cursor_EndMouseTracking()
X{
X    editpal_cursor = 0;
X}
X#endif
X
X/* See if the cursor should blink yet, and blink it if so */
Xvoid Cursor_CheckBlink(void)
X{
X   long tick;
X   tick = readticker();
X
X   if ( (tick - the_cursor->last_blink) > CURSOR_BLINK_RATE )
X      {
X      the_cursor->blink = (the_cursor->blink) ? FALSE : TRUE;
X      the_cursor->last_blink = tick;
X      if ( !the_cursor->hidden )
X     Cursor__Draw();
X      }
X   else if ( tick < the_cursor->last_blink )
X      the_cursor->last_blink = tick;
X}
X
Xint Cursor_WaitKey(void)   /* blink cursor while waiting for a key */
X   {
X
X#ifndef XFRACT
X   while ( !keypressed() ) {
X       Cursor_CheckBlink();
X   }
X#else
X   while ( !waitkeypressed(1) ) {
X       Cursor_CheckBlink();
X   }
X#endif
X
X   return( keypressed() );
X   }
X
X
X
X/*
X * Class:     MoveBox
X *
X * Purpose:   Handles the rectangular move/resize box.
X */
X
Xstruct _MoveBox
X   {
X   int        x, y;
X   int        base_width,
X        base_depth;
X   int        csize;
X   BOOLEAN  moved;
X   BOOLEAN  should_hide;
X   char    *t, *b,
X       *l, *r;
X   } ;
X
X#define MoveBox struct _MoveBox
X
X/* private: */
X
X   static void       MoveBox__Draw     (MoveBox *this);
X   static void       MoveBox__Erase    (MoveBox *this);
X   static void       MoveBox__Move     (MoveBox *this, int key);
X
X/* public: */
X
X   static MoveBox *MoveBox_Construct  (int x, int y, int csize, int base_width,
X                      int base_depth);
X   static void       MoveBox_Destroy    (MoveBox *this);
X   static BOOLEAN  MoveBox_Process    (MoveBox *this); /* returns FALSE if ESCAPED */
X   static BOOLEAN  MoveBox_Moved      (MoveBox *this);
X   static BOOLEAN  MoveBox_ShouldHide (MoveBox *this);
X   static int       MoveBox_X          (MoveBox *this);
X   static int       MoveBox_Y          (MoveBox *this);
X   static int       MoveBox_CSize      (MoveBox *this);
X
X   static void       MoveBox_SetPos     (MoveBox *this, int x, int y);
X   static void       MoveBox_SetCSize   (MoveBox *this, int csize);
X
X
X
Xstatic MoveBox *MoveBox_Construct(int x, int y, int csize, int base_width, int base_depth)
X   {
X   MoveBox *this = new(MoveBox);
X
X   this->x         = x;
X   this->y         = y;
X   this->csize         = csize;
X   this->base_width  = base_width;
X   this->base_depth  = base_depth;
X   this->moved         = FALSE;
X   this->should_hide = FALSE;
X   this->t         = newx(sxdots);
X   this->b         = newx(sxdots);
X   this->l         = newx(sydots);
X   this->r         = newx(sydots);
X
X   return(this);
X   }
X
X
Xstatic void MoveBox_Destroy(MoveBox *this)
X   {
X   delete(this->t);
X   delete(this->b);
X   delete(this->l);
X   delete(this->r);
X   delete(this);
X   }
X
X
Xstatic BOOLEAN MoveBox_Moved(MoveBox *this) { return(this->moved); }
X
Xstatic BOOLEAN MoveBox_ShouldHide(MoveBox *this) { return(this->should_hide); }
X
Xstatic int MoveBox_X(MoveBox *this)     { return(this->x); }
X
Xstatic int MoveBox_Y(MoveBox *this)     { return(this->y); }
X
Xstatic int MoveBox_CSize(MoveBox *this)  { return(this->csize); }
X
X
Xstatic void MoveBox_SetPos(MoveBox *this, int x, int y)
X   {
X   this->x = x;
X   this->y = y;
X   }
X
X
Xstatic void MoveBox_SetCSize(MoveBox *this, int csize)
X   {
X   this->csize = csize;
X   }
X
X
Xstatic void MoveBox__Draw(MoveBox *this)  /* private */
X   {
X   int width = this->base_width + this->csize*16+1,
X       depth = this->base_depth + this->csize*16+1;
X   int x     = this->x,
X       y     = this->y;
X
X
X   getrow (x, y,     width, this->t);
X   getrow (x, y+depth-1, width, this->b);
X
X   vgetrow(x,          y, depth, this->l);
X   vgetrow(x+width-1, y, depth, this->r);
X
X   hdline(x, y,         width);
X   hdline(x, y+depth-1, width);
X
X   vdline(x,         y, depth);
X   vdline(x+width-1, y, depth);
X   }
X
X
Xstatic void MoveBox__Erase(MoveBox *this)   /* private */
X   {
X   int width = this->base_width + this->csize*16+1,
X       depth = this->base_depth + this->csize*16+1;
X
X   vputrow(this->x,        this->y, depth, this->l);
X   vputrow(this->x+width-1, this->y, depth, this->r);
X
X   putrow(this->x, this->y,        width, this->t);
X   putrow(this->x, this->y+depth-1, width, this->b);
X   }
X
X
X#define BOX_INC     1
X#define CSIZE_INC   2
X
Xstatic void MoveBox__Move(MoveBox *this, int key)
X   {
X   BOOLEAN done  = FALSE;
X   BOOLEAN first = TRUE;
X   int       xoff  = 0,
X       yoff  = 0;
X
X   while ( !done )
X      {
X      switch(key)
X     {
X     case RIGHT_ARROW_2:     xoff += BOX_INC*4;   break;
X     case RIGHT_ARROW:     xoff += BOX_INC;     break;
X     case LEFT_ARROW_2:     xoff -= BOX_INC*4;   break;
X     case LEFT_ARROW:     xoff -= BOX_INC;     break;
X     case DOWN_ARROW_2:     yoff += BOX_INC*4;   break;
X     case DOWN_ARROW:     yoff += BOX_INC;     break;
X     case UP_ARROW_2:     yoff -= BOX_INC*4;   break;
X     case UP_ARROW:      yoff -= BOX_INC;     break;
X
X     default:
X        done = TRUE;
X     }
X
X      if (!done)
X     {
X     if (!first)
X        getakey();         /* delete key from buffer */
X     else
X        first = FALSE;
X     key = keypressed();   /* peek at the next one... */
X     }
X      }
X
X   xoff += this->x;
X   yoff += this->y;   /* (xoff,yoff) = new position */
X
X   if (xoff < 0) xoff = 0;
X   if (yoff < 0) yoff = 0;
X
X   if (xoff+this->base_width+this->csize*16+1 > sxdots)
X       xoff = sxdots - (this->base_width+this->csize*16+1);
X
X   if (yoff+this->base_depth+this->csize*16+1 > sydots)
X      yoff = sydots - (this->base_depth+this->csize*16+1);
X
X   if ( xoff!=this->x || yoff!=this->y )
X      {
X      MoveBox__Erase(this);
X      this->y = yoff;
X      this->x = xoff;
X      MoveBox__Draw(this);
X      }
X   }
X
X
Xstatic BOOLEAN MoveBox_Process(MoveBox *this)
X   {
X   int       key;
X   int       orig_x     = this->x,
X       orig_y     = this->y,
X       orig_csize = this->csize;
X
X   MoveBox__Draw(this);
X
X#ifdef XFRACT
X   Cursor_StartMouseTracking();
X#endif
X   while (1)
X      {
X      Cursor_WaitKey();
X      key = getakey();
X
X      if (key==ENTER || key==ENTER_2 || key==ESC || key=='H' || key=='h')
X     {
X     if (this->x != orig_x || this->y != orig_y || this->csize != orig_csize)
X        this->moved = TRUE;
X     else
X       this->moved = FALSE;
X     break;
X     }
X
X      switch(key)
X     {
X     case UP_ARROW:
X     case DOWN_ARROW:
X     case LEFT_ARROW:
X     case RIGHT_ARROW:
X     case UP_ARROW_2:
X     case DOWN_ARROW_2:
X     case LEFT_ARROW_2:
X     case RIGHT_ARROW_2:
X        MoveBox__Move(this, key);
X        break;
X
X     case PAGE_UP:     /* shrink */
X        if (this->csize > CSIZE_MIN)
X           {
X           int t = this->csize - CSIZE_INC;
X           int change;
X
X           if (t < CSIZE_MIN)
X          t = CSIZE_MIN;
X
X           MoveBox__Erase(this);
X
X           change = this->csize - t;
X           this->csize = t;
X           this->x += (change*16) / 2;
X           this->y += (change*16) / 2;
X           MoveBox__Draw(this);
X           }
X        break;
X
X     case PAGE_DOWN:   /* grow */
X        {
X        int max_width = min(sxdots, MAX_WIDTH);
X
X        if (this->base_depth+(this->csize+CSIZE_INC)*16+1 < sydots  &&
X            this->base_width+(this->csize+CSIZE_INC)*16+1 < max_width )
X           {
X           MoveBox__Erase(this);
X           this->x -= (CSIZE_INC*16) / 2;
X           this->y -= (CSIZE_INC*16) / 2;
X           this->csize += CSIZE_INC;
X           if (this->y+this->base_depth+this->csize*16+1 > sydots)
X          this->y = sydots - (this->base_depth+this->csize*16+1);
X           if (this->x+this->base_width+this->csize*16+1 > max_width)
X          this->x = max_width - (this->base_width+this->csize*16+1);
X           if (this->y < 0)
X          this->y = 0;
X           if (this->x < 0)
X          this->x = 0;
X           MoveBox__Draw(this);
X           }
X        }
X        break;
X     }
X      }
X
X#ifdef XFRACT
X   Cursor_EndMouseTracking();
X#endif
X
X   MoveBox__Erase(this);
X
X   this->should_hide = (key == 'H' || key == 'h') ? TRUE : FALSE;
X
X   return( (key==ESC) ? FALSE : TRUE );
X   }
X
X
X
X/*
X * Class:     CEditor
X *
X * Purpose:   Edits a single color component (R, G or B)
X *
X * Note:      Calls the "other_key" function to process keys it doesn't use.
X *          The "change" function is called whenever the value is changed
X *          by the CEditor.
X */
X
Xstruct _CEditor
X   {
X   int         x, y;
X   char      letter;
X   int         val;
X   BOOLEAN   done;
X   BOOLEAN   hidden;
X#ifndef XFRACT
X   void    (*other_key)(int key, struct _CEditor *ce, VOIDPTR info);
X   void    (*change)(struct _CEditor *ce, VOIDPTR info);
X#else
X   void    (*other_key)();
X   void    (*change)();
X#endif
X   void     *info;
X
X   } ;
X
X#define CEditor struct _CEditor
X
X/* public: */
X
X#ifndef XFRACT
X   static CEditor *CEditor_Construct( int x, int y, char letter,
X                      void (*other_key)(int,CEditor*,void*),
X                                      void (*change)(CEditor*,void*), VOIDPTR info);
X   static void CEditor_Destroy     (CEditor *this);
X   static void CEditor_Draw     (CEditor *this);
X   static void CEditor_SetPos     (CEditor *this, int x, int y);
X   static void CEditor_SetVal     (CEditor *this, int val);
X   static int  CEditor_GetVal     (CEditor *this);
X   static void CEditor_SetDone     (CEditor *this, BOOLEAN done);
X   static void CEditor_SetHidden (CEditor *this, BOOLEAN hidden);
X   static int  CEditor_Edit     (CEditor *this);
X#else
X   static CEditor *CEditor_Construct( int , int , char ,
X                                    void (*other_key)(),
X                                    void (*change)(), VOIDPTR );
X   static void CEditor_Destroy         (CEditor *);
X   static void CEditor_Draw    (CEditor *);
X   static void CEditor_SetPos  (CEditor *, int , int );
X   static void CEditor_SetVal  (CEditor *, int );
X   static int  CEditor_GetVal  (CEditor *);
X   static void CEditor_SetDone         (CEditor *, BOOLEAN );
X   static void CEditor_SetHidden (CEditor *, BOOLEAN );
X   static int  CEditor_Edit    (CEditor *);
X#endif
X
X#define CEditor_WIDTH (8*3+4)
X#define CEditor_DEPTH (8+4)
X
X
X
X#ifndef XFRACT
Xstatic CEditor *CEditor_Construct( int x, int y, char letter,
X                   void (*other_key)(int,CEditor*,VOIDPTR),
X                   void (*change)(CEditor*, VOIDPTR), VOIDPTR info)
X#else
Xstatic CEditor *CEditor_Construct( int x, int y, char letter,
X                                   void (*other_key)(),
X                                   void (*change)(), VOIDPTR info)
X#endif
X   {
X   CEditor *this = new(CEditor);
X
X   this->x       = x;
X   this->y       = y;
X   this->letter    = letter;
X   this->val       = 0;
X   this->other_key = other_key;
X   this->hidden    = FALSE;
X   this->change    = change;
X   this->info       = info;
X
X   return(this);
X   }
X
X
Xstatic void CEditor_Destroy(CEditor *this)
X   {
X   delete(this);
X   }
X
X
Xstatic void CEditor_Draw(CEditor *this)
X   {
X   if (this->hidden)
X      return;
X
X   Cursor_Hide();
X   displayf(this->x+2, this->y+2, fg_color, bg_color, "%c%02d", this->letter, this->val);
X   Cursor_Show();
X   }
X
X
Xstatic void CEditor_SetPos(CEditor *this, int x, int y)
X   {
X   this->x = x;
X   this->y = y;
X   }
X
X
Xstatic void CEditor_SetVal(CEditor *this, int val)
X   {
X   this->val = val;
X   }
X
X
Xstatic int CEditor_GetVal(CEditor *this)
X   {
X   return(this->val);
X   }
X
X
Xstatic void CEditor_SetDone(CEditor *this, BOOLEAN done)
X   {
X   this->done = done;
X   }
X
X
Xstatic void CEditor_SetHidden(CEditor *this, BOOLEAN hidden)
X   {
X   this->hidden = hidden;
X   }
X
X
Xstatic int CEditor_Edit(CEditor *this)
X   {
X   int key;
X   int diff;
X
X   this->done = FALSE;
X
X   if (!this->hidden)
X      {
X      Cursor_Hide();
X      rect(this->x, this->y, CEditor_WIDTH, CEditor_DEPTH, fg_color);
X      Cursor_Show();
X      }
X
X#ifdef XFRACT
X   Cursor_StartMouseTracking();
X#endif
X   while ( !this->done )
X      {
X      Cursor_WaitKey();
X      key = getakey();
X
X      switch( key )
X     {
X     case PAGE_UP:
X        if (this->val < 63)
X           {
X           this->val += 5;
X           if (this->val > 63)
X          this->val = 63;
X           CEditor_Draw(this);
X           this->change(this, this->info);
X           }
X        break;
X
X     case '+':
X        diff = 1;
X        while ( keypressed() == key )
X           {
X           getakey();
X           ++diff;
X           }
X        if (this->val < 63)
X           {
X           this->val += diff;
X           if (this->val > 63)
X          this->val = 63;
X           CEditor_Draw(this);
X           this->change(this, this->info);
X           }
X        break;
X
X     case PAGE_DOWN:
X        if (this->val > 0)
X           {
X           this->val -= 5;
X           if (this->val < 0)
X          this->val = 0;
X           CEditor_Draw(this);
X           this->change(this, this->info);
X           } break;
X
X     case '-':
X        diff = 1;
X        while ( keypressed() == key )
X           {
X           getakey();
X           ++diff;
X           }
X        if (this->val > 0)
X           {
X           this->val -= diff;
X           if (this->val < 0)
X          this->val = 0;
X           CEditor_Draw(this);
X           this->change(this, this->info);
X           }
X        break;
X
X     case '0':
X     case '1':
X     case '2':
X     case '3':
X     case '4':
X     case '5':
X     case '6':
X     case '7':
X     case '8':
X     case '9':
X        this->val = (key - '0') * 10;
X        if (this->val > 63)
X           this->val = 63;
X        CEditor_Draw(this);
X        this->change(this, this->info);
X        break;
X
X     default:
X        this->other_key(key, this, this->info);
X        break;
X     } /* switch */
X      } /* while */
X#ifdef XFRACT
X   Cursor_EndMouseTracking();
X#endif
X
X   if (!this->hidden)
X      {
X      Cursor_Hide();
X      rect(this->x, this->y, CEditor_WIDTH, CEditor_DEPTH, bg_color);
X      Cursor_Show();
X      }
X
X   return(key);
X   }
X
X
X
X/*
X * Class:     RGBEditor
X *
X * Purpose:   Edits a complete color using three CEditors for R, G and B
X */
X
Xstruct _RGBEditor
X   {
X   int         x, y;          /* position */
X   int         curr;          /* 0=r, 1=g, 2=b */
X   int         pal;          /* palette number */
X   BOOLEAN   done;
X   BOOLEAN   hidden;
X   CEditor  *color[3];          /* color editors 0=r, 1=g, 2=b */
X#ifndef XFRACT
X   void    (*other_key)(int key, struct _RGBEditor *e, VOIDPTR info);
X   void    (*change)(struct _RGBEditor *e, VOIDPTR info);
X#else
X   void    (*other_key)();
X   void    (*change)();
X#endif
X   void     *info;
X   } ;
X
X#define RGBEditor struct _RGBEditor
X
X/* private: */
X
X   static void      RGBEditor__other_key (int key, CEditor *ceditor, VOIDPTR info);
X   static void      RGBEditor__change    (CEditor *ceditor, VOIDPTR info);
X
X/* public: */
X
X#ifndef XFRACT
X   static RGBEditor *RGBEditor_Construct(int x, int y,
X             void (*other_key)(int,RGBEditor*,void*),
X             void (*change)(RGBEditor*,void*), VOIDPTR info);
X#else
X   static RGBEditor *RGBEditor_Construct(int x, int y,
X                     void (*other_key)(),
X                     void (*change)(), VOIDPTR info);
X#endif
X
X   static void       RGBEditor_Destroy  (RGBEditor *this);
X   static void       RGBEditor_SetPos   (RGBEditor *this, int x, int y);
X   static void       RGBEditor_SetDone  (RGBEditor *this, BOOLEAN done);
X   static void       RGBEditor_SetHidden(RGBEditor *this, BOOLEAN hidden);
X   static void       RGBEditor_BlankSampleBox(RGBEditor *this);
X   static void       RGBEditor_Update   (RGBEditor *this);
X   static void       RGBEditor_Draw     (RGBEditor *this);
X   static int       RGBEditor_Edit     (RGBEditor *this);
X   static void       RGBEditor_SetRGB   (RGBEditor *this, int pal, PALENTRY *rgb);
X   static PALENTRY RGBEditor_GetRGB   (RGBEditor *this);
X
X#define RGBEditor_WIDTH 62
X#define RGBEditor_DEPTH (1+1+CEditor_DEPTH*3-2+2)
X
X#define RGBEditor_BWIDTH ( RGBEditor_WIDTH - (2+CEditor_WIDTH+1 + 2) )
X#define RGBEditor_BDEPTH ( RGBEditor_DEPTH - 4 )
X
X
X
X#ifndef XFRACT
Xstatic RGBEditor *RGBEditor_Construct(int x, int y, void (*other_key)(int,RGBEditor*,void*),
X                      void (*change)(RGBEditor*,void*), VOIDPTR info)
X#else
Xstatic RGBEditor *RGBEditor_Construct(int x, int y, void (*other_key)(),
X                                      void (*change)(), VOIDPTR info)
X#endif
X   {
X   RGBEditor      *this     = new(RGBEditor);
X   static char far letter[] = "RGB";
X   int           ctr;
X
X   for (ctr=0; ctr<3; ctr++)
X      this->color[ctr] = CEditor_Construct(0, 0, letter[ctr], RGBEditor__other_key,
X                       RGBEditor__change, this);
X
X   RGBEditor_SetPos(this, x, y);
X   this->curr       = 0;
X   this->pal       = 1;
X   this->hidden    = FALSE;
X   this->other_key = other_key;
X   this->change    = change;
X   this->info       = info;
X
X   return(this);
X   }
X
X
Xstatic void RGBEditor_Destroy(RGBEditor *this)
X   {
X   CEditor_Destroy(this->color[0]);
X   CEditor_Destroy(this->color[1]);
X   CEditor_Destroy(this->color[2]);
X   delete(this);
X   }
X
X
Xstatic void RGBEditor_SetDone(RGBEditor *this, BOOLEAN done)
X   {
X   this->done = done;
X   }
X
X
Xstatic void RGBEditor_SetHidden(RGBEditor *this, BOOLEAN hidden)
X   {
X   this->hidden = hidden;
X   CEditor_SetHidden(this->color[0], hidden);
X   CEditor_SetHidden(this->color[1], hidden);
X   CEditor_SetHidden(this->color[2], hidden);
X   }
X
X
Xstatic void RGBEditor__other_key(int key, CEditor *ceditor, VOIDPTR info) /* private */
X   {
X   RGBEditor *this = (RGBEditor *)info;
X
X   switch( key )
X      {
X      case 'R':
X      case 'r':
X     if (this->curr != 0)
X        {
X        this->curr = 0;
X        CEditor_SetDone(ceditor, TRUE);
X        }
X     break;
X
X      case 'G':
X      case 'g':
X     if (this->curr != 1)
X        {
X        this->curr = 1;
X        CEditor_SetDone(ceditor, TRUE);
X        }
X     break;
X
X      case 'B':
X      case 'b':
X     if (this->curr != 2)
X        {
X        this->curr = 2;
X        CEditor_SetDone(ceditor, TRUE);
X        }
X     break;
X
X      case DELETE:   /* move to next CEditor */
X     if ( ++this->curr > 2)
X        this->curr = 0;
X     CEditor_SetDone(ceditor, TRUE);
X     break;
X
X      case INSERT:   /* move to prev CEditor */
X     if ( --this->curr < 0)
X        this->curr = 2;
X     CEditor_SetDone(ceditor, TRUE);
X     break;
X
X      default:
X     this->other_key(key, this, this->info);
X     if (this->done)
X        CEditor_SetDone(ceditor, TRUE);
X     break;
X      }
X   }
X
X
X
X#ifdef __TURBOC__
X#   pragma argsused   /* kills "arg not used" warning */
X#endif
X
Xstatic void RGBEditor__change(CEditor *ceditor, VOIDPTR info) /* private */
X   {
X   RGBEditor *this = (RGBEditor *)info;
X
X   if ( this->pal < colors && !is_reserved(this->pal) )
X      setpal(this->pal, CEditor_GetVal(this->color[0]),
X      CEditor_GetVal(this->color[1]), CEditor_GetVal(this->color[2]));
X
X   this->change(this, this->info);
X   }
X
X
Xstatic void RGBEditor_SetPos(RGBEditor *this, int x, int y)
X   {
X   this->x = x;
X   this->y = y;
X
X   CEditor_SetPos(this->color[0], x+2, y+2);
X   CEditor_SetPos(this->color[1], x+2, y+2+CEditor_DEPTH-1);
X   CEditor_SetPos(this->color[2], x+2, y+2+CEditor_DEPTH-1+CEditor_DEPTH-1);
X   }
X
X
Xstatic void RGBEditor_BlankSampleBox(RGBEditor *this)
X   {
X   if (this->hidden)
X      return ;
X
X   Cursor_Hide();
X   fillrect(this->x+2+CEditor_WIDTH+1+1, this->y+2+1, RGBEditor_BWIDTH-2, RGBEditor_BDEPTH-2, bg_color);
X   Cursor_Show();
X   }
X
X
Xstatic void RGBEditor_Update(RGBEditor *this)
X   {
X   int x1 = this->x+2+CEditor_WIDTH+1+1,
X       y1 = this->y+2+1;
X
X   if (this->hidden)
X      return ;
X
X   Cursor_Hide();
X
X   if ( this->pal >= colors )
X      {
X      fillrect(x1, y1, RGBEditor_BWIDTH-2, RGBEditor_BDEPTH-2, bg_color);
X      draw_diamond(x1+(RGBEditor_BWIDTH-5)/2, y1+(RGBEditor_BDEPTH-5)/2, fg_color);
X      }
X
X   else if ( is_reserved(this->pal) )
X      {
X      int x2 = x1+RGBEditor_BWIDTH-3,
X      y2 = y1+RGBEditor_BDEPTH-3;
X
X      fillrect(x1, y1, RGBEditor_BWIDTH-2, RGBEditor_BDEPTH-2, bg_color);
X      draw_line(x1, y1, x2, y2, fg_color);
X      draw_line(x1, y2, x2, y1, fg_color);
X      }
X   else
X      fillrect(x1, y1, RGBEditor_BWIDTH-2, RGBEditor_BDEPTH-2, this->pal);
X
X   CEditor_Draw(this->color[0]);
X   CEditor_Draw(this->color[1]);
X   CEditor_Draw(this->color[2]);
X   Cursor_Show();
X   }
X
X
Xstatic void RGBEditor_Draw(RGBEditor *this)
X   {
X   if (this->hidden)
X      return ;
X
X   Cursor_Hide();
X   drect(this->x, this->y, RGBEditor_WIDTH, RGBEditor_DEPTH);
X   fillrect(this->x+1, this->y+1, RGBEditor_WIDTH-2, RGBEditor_DEPTH-2, bg_color);
X   rect(this->x+1+CEditor_WIDTH+2, this->y+2, RGBEditor_BWIDTH, RGBEditor_BDEPTH, fg_color);
X   RGBEditor_Update(this);
X   Cursor_Show();
X   }
X
X
Xstatic int RGBEditor_Edit(RGBEditor *this)
X   {
X   int key;
X
X   this->done = FALSE;
X
X   if (!this->hidden)
X      {
X      Cursor_Hide();
X      rect(this->x, this->y, RGBEditor_WIDTH, RGBEditor_DEPTH, fg_color);
X      Cursor_Show();
X      }
X
X   while ( !this->done )
X      key = CEditor_Edit( this->color[this->curr] );
X
X   if (!this->hidden)
X      {
X      Cursor_Hide();
X      drect(this->x, this->y, RGBEditor_WIDTH, RGBEditor_DEPTH);
X      Cursor_Show();
X      }
X
X   return (key);
X   }
X
X
Xstatic void RGBEditor_SetRGB(RGBEditor *this, int pal, PALENTRY *rgb)
X   {
X   this->pal = pal;
X   CEditor_SetVal(this->color[0], rgb->red);
X   CEditor_SetVal(this->color[1], rgb->green);
X   CEditor_SetVal(this->color[2], rgb->blue);
X   }
X
X
Xstatic PALENTRY RGBEditor_GetRGB(RGBEditor *this)
X   {
X   PALENTRY pal;
X
X   pal.red   = CEditor_GetVal(this->color[0]);
X   pal.green = CEditor_GetVal(this->color[1]);
X   pal.blue  = CEditor_GetVal(this->color[2]);
X
X   return(pal);
X   }
X
X
X
X/*
X * Class:     PalTable
X *
X * Purpose:   This is where it all comes together.  Creates the two RGBEditors
X *          and the palette. Moves the cursor, hides/restores the screen,
X *          handles (S)hading, (C)opying, e(X)clude mode, the "Y" exclusion
X *          mode, (Z)oom option, (H)ide palette, rotation, etc.
X *
X */
X
Xenum stored_at_values
X   {
X   NOWHERE,
X   DISK,
X   MEMORY
X   } ;
X
X/*
X
XModes:
X   Auto:          "A", " "
X   Exclusion:     "X", "Y", " "
X   Freestyle:     "F", " "
X   S(t)ripe mode: "T", " "
X
X*/
X
X
X
Xstruct  _PalTable
X   {
X   int         x, y;
X   int         csize;
X   int         active;   /* which RGBEditor is active (0,1) */
X   int         curr[2];
X   RGBEditor    *rgb[2];
X   MoveBox      *movebox;
X   BOOLEAN     done;
X   BOOLEAN     exclude;
X   BOOLEAN     auto_select;
X   PALENTRY     pal[256];
X   FILE         *undo_file;
X   BOOLEAN       curr_changed;
X   int           num_redo;
X   int         hidden;
X   int         stored_at;
X   FILE         *file;
X   char far     *memory;
X
X   PALENTRY far *save_pal[8];
X
X   PALENTRY      fs_color;
X   int           top,bottom; /* top and bottom colours of freestyle band */
X   int           bandwidth; /*size of freestyle colour band */
X   BOOLEAN       freestyle;
X   } ;
X
X#define PalTable struct _PalTable
X
X/* private: */
X
X   static void    PalTable__DrawStatus  (PalTable *this, BOOLEAN stripe_mode);
X   static void      PalTable__HlPal       (PalTable *this, int pnum, int color);
X   static void      PalTable__Draw        (PalTable *this);
X   static BOOLEAN PalTable__SetCurr     (PalTable *this, int which, int curr);
X   static BOOLEAN PalTable__MemoryAlloc (PalTable *this, long size);
X   static void      PalTable__SaveRect    (PalTable *this);
X   static void      PalTable__RestoreRect (PalTable *this);
X   static void      PalTable__SetPos      (PalTable *this, int x, int y);
X   static void      PalTable__SetCSize    (PalTable *this, int csize);
X   static int      PalTable__GetCursorColor(PalTable *this);
X   static void      PalTable__DoCurs      (PalTable *this, int key);
X   static void      PalTable__Rotate      (PalTable *this, int dir, int lo, int hi);
X   static void      PalTable__UpdateDAC   (PalTable *this);
X   static void    PalTable__other_key   (int key, RGBEditor *rgb, VOIDPTR info);
X   static void    PalTable__SaveUndoData(PalTable *this, int first, int last);
X   static void    PalTable__SaveUndoRotate(PalTable *this, int dir, int first, int last);
X   static void    PalTable__UndoProcess (PalTable *this, int delta);
X   static void    PalTable__Undo        (PalTable *this);
X   static void    PalTable__Redo        (PalTable *this);
X   static void    PalTable__change      (RGBEditor *rgb, VOIDPTR info);
X
X/* public: */
X
X   static PalTable *PalTable_Construct (void);
X   static void        PalTable_Destroy   (PalTable *this);
X   static void        PalTable_Process   (PalTable *this);
X   static void        PalTable_SetHidden (PalTable *this, BOOLEAN hidden);
X   static void        PalTable_Hide      (PalTable *this, RGBEditor *rgb, BOOLEAN hidden);
X
X
X#define PalTable_PALX (1)
X#define PalTable_PALY (2+RGBEditor_DEPTH+2)
X
X#define UNDO_DATA        (1)
X#define UNDO_DATA_SINGLE (2)
X#define UNDO_ROTATE      (3)
X
X
X
X/*  - Freestyle code - */
X
X
Xvoid PalTable__CalcTopBottom(PalTable *this)
X   {
X   if (this->curr[this->active] < this->bandwidth )
X      this->bottom = 0;
X   else
X      this->bottom = (this->curr[this->active]) - this->bandwidth;
X
X   if (this->curr[this->active] > (255-this->bandwidth) )
X      this->top = 255;
X   else
X      this->top = (this->curr[this->active]) + this->bandwidth;
X   }
X
X
Xvoid PalTable__PutBand(PalTable *this, PALENTRY *pal)
X   {
X   int r,b,a;
X
X  /* clip top and bottom values to stop them running off the end of the DAC */
X
X   PalTable__CalcTopBottom(this);
X
X  /* put bands either side of current colour */
X
X   a = this->curr[this->active];
X   b = this->bottom;
X   r = this->top;
X
X   pal[a] = this->fs_color;
X
X   if (r != a && a != b)
X      {
X      mkpalrange(&pal[a], &pal[r], &pal[a], r-a, 1);
X      mkpalrange(&pal[b], &pal[a], &pal[b], a-b, 1);
X      }
X
X   }
X
X
X/* - Undo.Redo code - */
X
X
Xstatic void PalTable__SaveUndoData(PalTable *this, int first, int last)
X   {
X   int num;
X
X   if ( this->undo_file == NULL )
X      return ;
X
X   num = (last - first) + 1;
X
X#ifdef DEBUG_UNDO
X   mprintf("%6ld Writing Undo DATA from %d to %d (%d)", ftell(this->undo_file), first, last, num);
X#endif
X
X   fseek(this->undo_file, 0, SEEK_CUR);
X   if ( num == 1 )
X      {
X      putc(UNDO_DATA_SINGLE, this->undo_file);
X      putc(first, this->undo_file);
X      fwrite(this->pal+first, 3, 1, this->undo_file);
X      putw( 1 + 1 + 3 + sizeof(int), this->undo_file);
X      }
X   else
X      {
X      putc(UNDO_DATA, this->undo_file);
X      putc(first, this->undo_file);
X      putc(last,  this->undo_file);
X      fwrite(this->pal+first, 3, num, this->undo_file);
X      putw(1 + 2 + (num*3) + sizeof(int), this->undo_file);
X      }
X
X   this->num_redo = 0;
X   }
X
X
Xstatic void PalTable__SaveUndoRotate(PalTable *this, int dir, int first, int last)
X   {
X   if ( this->undo_file == NULL )
X      return ;
X
X#ifdef DEBUG_UNDO
X   mprintf("%6ld Writing Undo ROTATE of %d from %d to %d", ftell(this->undo_file), dir, first, last);
X#endif
X
X   fseek(this->undo_file, 0, SEEK_CUR);
X   putc(UNDO_ROTATE, this->undo_file);
X   putc(first, this->undo_file);
X   putc(last,  this->undo_file);
X   putw(dir, this->undo_file);
X   putw(1 + 2 + sizeof(int), this->undo_file);
X
X   this->num_redo = 0;
X   }
X
X
Xstatic void PalTable__UndoProcess(PalTable *this, int delta)   /* undo/redo common code */
X   {              /* delta = -1 for undo, +1 for redo */
X   int cmd = getc(this->undo_file);
X
X   switch( cmd )
X      {
X      case UNDO_DATA:
X      case UNDO_DATA_SINGLE:
X         {
X         int      first, last, num;
X         PALENTRY temp[256];
X
X         if ( cmd == UNDO_DATA )
X            {
X            first = (unsigned char)getc(this->undo_file);
X            last  = (unsigned char)getc(this->undo_file);
X            }
X         else  /* UNDO_DATA_SINGLE */
X            first = last = (unsigned char)getc(this->undo_file);
X
X         num = (last - first) + 1;
X
X#ifdef DEBUG_UNDO
X         mprintf("          Reading DATA from %d to %d", first, last);
X#endif
X
X         fread(temp, 3, num, this->undo_file);
X
X         fseek(this->undo_file, -(num*3), SEEK_CUR);  /* go to start of undo/redo data */
X         fwrite(this->pal+first, 3, num, this->undo_file);  /* write redo/undo data */
X
X         memmove(this->pal+first, temp, num*3);
X
X         PalTable__UpdateDAC(this);
X
X         RGBEditor_SetRGB(this->rgb[0], this->curr[0], &(this->pal[this->curr[0]]));
X         RGBEditor_SetRGB(this->rgb[1], this->curr[1], &(this->pal[this->curr[1]]));
X         RGBEditor_Update(this->rgb[0]);
X         RGBEditor_Update(this->rgb[1]);
X         break;
X         }
X
X      case UNDO_ROTATE:
X         {
X         int first = (unsigned char)getc(this->undo_file);
X         int last  = (unsigned char)getc(this->undo_file);
X         int dir   = getw(this->undo_file);
X
X#ifdef DEBUG_UNDO
X         mprintf("          Reading ROTATE of %d from %d to %d", dir, first, last);
X#endif
X         PalTable__Rotate(this, delta*dir, first, last);
X         break;
X         }
X
X      default:
X#ifdef DEBUG_UNDO
X         mprintf("          Unknown command: %d", cmd);
X#endif
X         break;
X      }
X
X   fseek(this->undo_file, 0, SEEK_CUR);  /* to put us in read mode */
X   getw(this->undo_file);  /* read size */
X   }
X
X
Xstatic void PalTable__Undo(PalTable *this)
X   {
X   int  size;
X   long pos;
X
X   if ( ftell(this->undo_file) <= 0  )   /* at beginning of file? */
X      {                                  /*   nothing to undo -- exit */
X      return ;
X      }
X
X   fseek(this->undo_file, -(int)sizeof(int), SEEK_CUR);  /* go back to get size */
X
X   size = getw(this->undo_file);
X   fseek(this->undo_file, -size, SEEK_CUR);   /* go to start of undo */
X
X#ifdef DEBUG_UNDO
X   mprintf("%6ld Undo:", ftell(this->undo_file));
X#endif
X
X   pos = ftell(this->undo_file);
X
X   PalTable__UndoProcess(this, -1);
X
X   fseek(this->undo_file, pos, SEEK_SET);   /* go to start of this block */
X
X   ++this->num_redo;
X   }
X
X
Xstatic void PalTable__Redo(PalTable *this)
X   {
X   if ( this->num_redo <= 0 )
X      return ;
X
X#ifdef DEBUG_UNDO
X   mprintf("%6ld Redo:", ftell(this->undo_file));
X#endif
X
X   fseek(this->undo_file, 0, SEEK_CUR);  /* to make sure we are in "read" mode */
X   PalTable__UndoProcess(this, 1);
X
X   --this->num_redo;
X   }
X
X
X/* - everything else - */
X
X
X#define STATUS_LEN (4)
X
Xstatic void PalTable__DrawStatus(PalTable *this, BOOLEAN stripe_mode)
X   {
X   int width = 1+(this->csize*16)+1+1;
X
X   if ( !this->hidden && ( width - (RGBEditor_WIDTH*2+4) >= STATUS_LEN*8 ) )
X      {
X      int x = this->x + 2 + RGBEditor_WIDTH,
X          y = this->y + PalTable_PALY - 10;
X
X      Cursor_Hide();
X
X      displayc(x+(0*8), y, fg_color, bg_color, (this->auto_select) ? 'A' : 254);
X      displayc(x+(1*8), y, fg_color, bg_color, (this->exclude==1)  ? 'X' :
X                                               (this->exclude==2)  ? 'Y' : 254);
X      displayc(x+(2*8), y, fg_color, bg_color, (this->freestyle)   ? 'F' : 254);
X      displayc(x+(3*8), y, fg_color, bg_color, (stripe_mode)       ? 'T' : 254);
X
X      Cursor_Show();
X      }
X   }
X
X
Xstatic void PalTable__HlPal(PalTable *this, int pnum, int color)
X   {
X   int x    = this->x + PalTable_PALX + (pnum%16)*this->csize,
X       y    = this->y + PalTable_PALY + (pnum/16)*this->csize,
X       size = this->csize;
X
X   if (this->hidden)
X      return ;
X
X   Cursor_Hide();
X
X   if (color < 0)
X      drect(x, y, size+1, size+1);
X   else
X      rect(x, y, size+1, size+1, color);
X
X   Cursor_Show();
X   }
X
X
Xstatic void PalTable__Draw(PalTable *this)
X   {
X   int pal;
X   int xoff, yoff;
X   int width;
X
X   if (this->hidden)
X      return ;
X
X   Cursor_Hide();
X
X   width = 1+(this->csize*16)+1+1;
X
X   rect(this->x, this->y, width, 2+RGBEditor_DEPTH+2+(this->csize*16)+1+1, fg_color);
X
X   fillrect(this->x+1, this->y+1, width-2, 2+RGBEditor_DEPTH+2+(this->csize*16)+1+1-2, bg_color);
X
X   hline(this->x, this->y+PalTable_PALY-1, width, fg_color);
X
X   if ( width - (RGBEditor_WIDTH*2+4) >= TITLE_LEN*8 )
X      {
X      int center = (width - TITLE_LEN*8) / 2;
X
X      displayf(this->x+center, this->y+2+RGBEditor_DEPTH/2-4, fg_color, bg_color, TITLE);
X      }
X
X   RGBEditor_Draw(this->rgb[0]);
X   RGBEditor_Draw(this->rgb[1]);
X
X   for (pal=0; pal<256; pal++)
X      {
X      xoff = PalTable_PALX + (pal%16) * this->csize;
X      yoff = PalTable_PALY + (pal/16) * this->csize;
X
X      if ( pal >= colors )
X     {
X     fillrect(this->x + xoff + 1, this->y + yoff + 1, this->csize-1, this->csize-1, bg_color);
X     draw_diamond(this->x + xoff + this->csize/2 - 1, this->y + yoff + this->csize/2 - 1, fg_color);
X     }
X
X      else if ( is_reserved(pal) )
X     {
X     int x1 = this->x + xoff + 1,
X         y1 = this->y + yoff + 1,
X         x2 = x1 + this->csize - 2,
X         y2 = y1 + this->csize - 2;
X     fillrect(this->x + xoff + 1, this->y + yoff + 1, this->csize-1, this->csize-1, bg_color);
X     draw_line(x1, y1, x2, y2, fg_color);
X     draw_line(x1, y2, x2, y1, fg_color);
X     }
X      else
X     fillrect(this->x + xoff + 1, this->y + yoff + 1, this->csize-1, this->csize-1, pal);
X
X      }
X
X   if (this->active == 0)
X      {
X      PalTable__HlPal(this, this->curr[1], -1);
X      PalTable__HlPal(this, this->curr[0], fg_color);
X      }
X   else
X      {
X      PalTable__HlPal(this, this->curr[0], -1);
X      PalTable__HlPal(this, this->curr[1], fg_color);
X      }
X
X   PalTable__DrawStatus(this, FALSE);
X
X   Cursor_Show();
X   }
X
X
X
Xstatic BOOLEAN PalTable__SetCurr(PalTable *this, int which, int curr)
X   {
X   BOOLEAN redraw = (which < 0) ? TRUE : FALSE;
X
X   if ( redraw )
X      {
X      which = this->active;
X      curr = this->curr[which];
X      }
X   else
X      if ( curr == this->curr[which] || curr < 0 )
X     return (FALSE);
X
X   Cursor_Hide();
X
X   PalTable__HlPal(this, this->curr[0], bg_color);
X   PalTable__HlPal(this, this->curr[1], bg_color);
X   PalTable__HlPal(this, this->top,     bg_color);
X   PalTable__HlPal(this, this->bottom,  bg_color);
X
X   if ( this->freestyle )
X      {
X      this->curr[which] = curr;
X
X      PalTable__CalcTopBottom(this);
X
X      PalTable__HlPal(this, this->top,    -1);
X      PalTable__HlPal(this, this->bottom, -1);
X      PalTable__HlPal(this, this->curr[this->active], fg_color);
X
X      RGBEditor_SetRGB(this->rgb[which], this->curr[which], &this->fs_color);
X      RGBEditor_Update(this->rgb[which]);
X
X      PalTable__UpdateDAC(this);
X
X      Cursor_Show();
X
X      return (TRUE);
X      }
X
X   this->curr[which] = curr;
X
X   if (this->curr[0] != this->curr[1])
X      PalTable__HlPal(this, this->curr[this->active==0?1:0], -1);
X   PalTable__HlPal(this, this->curr[this->active], fg_color);
X
X   RGBEditor_SetRGB(this->rgb[which], this->curr[which], &(this->pal[this->curr[which]]));
X
X   if (redraw)
X      {
X      int other = (which==0) ? 1 : 0;
X      RGBEditor_SetRGB(this->rgb[other], this->curr[other], &(this->pal[this->curr[other]]));
X      RGBEditor_Update(this->rgb[0]);
X      RGBEditor_Update(this->rgb[1]);
X      }
X   else
X      RGBEditor_Update(this->rgb[which]);
X
X   if (this->exclude)
X      PalTable__UpdateDAC(this);
X
X   Cursor_Show();
X
X   this->curr_changed = FALSE;
X
X   return(TRUE);
X   }
X
X
Xstatic BOOLEAN PalTable__MemoryAlloc(PalTable *this, long size)
X   {
X   char far *temp;
X
X   if (debugflag = 420)
X      {
X      this->stored_at = NOWHERE;
X      return (FALSE);   /* can't do it */
X      }
X   temp = farmemalloc(FAR_RESERVE);   /* minimum free space */
X
X   if (temp == NULL)
X      {
X      this->stored_at = NOWHERE;
X      return (FALSE);   /* can't do it */
X      }
X
X   this->memory = farmemalloc( size );
X
X   farmemfree(temp);
X
X   if ( this->memory == NULL )
X      {
X      this->stored_at = NOWHERE;
X      return (FALSE);
X      }
X   else
X      {
X      this->stored_at = MEMORY;
X      return (TRUE);
X      }
X   }
X
X
Xstatic void PalTable__SaveRect(PalTable *this)
X   {
X   char buff[MAX_WIDTH];
X   int  width = PalTable_PALX + this->csize*16 + 1 + 1,
X        depth = PalTable_PALY + this->csize*16 + 1 + 1;
X   int  yoff;
X
X
X   /* first, do any de-allocationg */
X
X   switch( this->stored_at )
X      {
X      case NOWHERE:
X     break;
X
X      case DISK:
X     break;
X
X      case MEMORY:
X     if (this->memory != NULL)
X        farmemfree(this->memory);
X     this->memory = NULL;
X     break;
X      } ;
X
X   /* allocate space and store the rect */
X
X   if ( PalTable__MemoryAlloc(this, (long)width*depth) )
X      {
X      char far  *ptr = this->memory;
X      char far  *bufptr = buff; /* MSC needs this indirection to get it right */
X
X      Cursor_Hide();
X      for (yoff=0; yoff<depth; yoff++)
X     {
X     getrow(this->x, this->y+yoff, width, buff);
X     hline (this->x, this->y+yoff, width, bg_color);
X     movedata(FP_SEG(bufptr), FP_OFF(bufptr), FP_SEG(ptr), FP_OFF(ptr), width);
X     ptr = (char far *)normalize(ptr+width);
X     }
X      Cursor_Show();
X      }
X
X   else /* to disk */
X      {
X      this->stored_at = DISK;
X
X      if ( this->file == NULL )
X     {
X     this->file = fopen(scrnfile, "w+b");
X     if (this->file == NULL)
X        {
X        this->stored_at = NOWHERE;
X        buzzer(3);
X        return ;
X        }
X     }
X
X      rewind(this->file);
X      Cursor_Hide();
X      for (yoff=0; yoff<depth; yoff++)
X     {
X     getrow(this->x, this->y+yoff, width, buff);
X     hline (this->x, this->y+yoff, width, bg_color);
X     if ( fwrite(buff, width, 1, this->file) != 1 )
X        {
X        buzzer(3);
X        break;
X        }
X     }
X      Cursor_Show();
X      }
X
X   }
X
X
Xstatic void PalTable__RestoreRect(PalTable *this)
X   {
X   char buff[MAX_WIDTH];
X   int  width = PalTable_PALX + this->csize*16 + 1 + 1,
X        depth = PalTable_PALY + this->csize*16 + 1 + 1;
X   int  yoff;
X
X   if (this->hidden)
X      return;
X
X   switch ( this->stored_at )
X      {
X      case DISK:
X     rewind(this->file);
X     Cursor_Hide();
X     for (yoff=0; yoff<depth; yoff++)
X        {
X        if ( fread(buff, width, 1, this->file) != 1 )
X           {
X           buzzer(3);
X           break;
X           }
X        putrow(this->x, this->y+yoff, width, buff);
X        }
X     Cursor_Show();
X     break;
X
X      case MEMORY:
X     {
X     char far  *ptr = this->memory;
X     char far  *bufptr = buff; /* MSC needs this indirection to get it right */
X
X     Cursor_Hide();
X     for (yoff=0; yoff<depth; yoff++)
X        {
X        movedata(FP_SEG(ptr), FP_OFF(ptr), FP_SEG(bufptr), FP_OFF(bufptr), width);
X        putrow(this->x, this->y+yoff, width, buff);
X        ptr = (char far *)normalize(ptr+width);
X        }
X     Cursor_Show();
X     break;
X     }
X
X      case NOWHERE:
X     break;
X      } /* switch */
X   }
X
X
Xstatic void PalTable__SetPos(PalTable *this, int x, int y)
X   {
X   int width = PalTable_PALX + this->csize*16 + 1 + 1;
X
X   this->x = x;
X   this->y = y;
X
X   RGBEditor_SetPos(this->rgb[0], x+2, y+2);
X   RGBEditor_SetPos(this->rgb[1], x+width-2-RGBEditor_WIDTH, y+2);
X   }
X
X
Xstatic void PalTable__SetCSize(PalTable *this, int csize)
X   {
X   this->csize = csize;
X   PalTable__SetPos(this, this->x, this->y);
X   }
X
X
Xstatic int PalTable__GetCursorColor(PalTable *this)
X   {
X   int x     = Cursor_GetX(),
X       y     = Cursor_GetY(),
X       size;
X   int color = getcolor(x, y);
X
X   if ( is_reserved(color) )
X      {
X      if ( is_in_box(x, y, this->x, this->y, 1+(this->csize*16)+1+1, 2+RGBEditor_DEPTH+2+(this->csize*16)+1+1) )
X     {  /* is the cursor over the editor? */
X     x -= this->x + PalTable_PALX;
X     y -= this->y + PalTable_PALY;
X     size = this->csize;
X
X     if (x < 0 || y < 0 || x > size*16 || y > size*16)
X        return (-1);
X
X     if ( x == size*16 )
X        --x;
X     if ( y == size*16 )
X        --y;
X
X     return ( (y/size)*16 + x/size );
X     }
X      else
X     return (color);
X      }
X
X   return (color);
X   }
X
X
X
X#define CURS_INC 1
X
Xstatic void PalTable__DoCurs(PalTable *this, int key)
X   {
X   BOOLEAN done  = FALSE;
X   BOOLEAN first = TRUE;
X   int       xoff  = 0,
X       yoff  = 0;
X
X   while ( !done )
X      {
X      switch(key)
X     {
X     case RIGHT_ARROW_2:     xoff += CURS_INC*4;   break;
X     case RIGHT_ARROW:     xoff += CURS_INC;     break;
X     case LEFT_ARROW_2:     xoff -= CURS_INC*4;   break;
X     case LEFT_ARROW:     xoff -= CURS_INC;     break;
X     case DOWN_ARROW_2:     yoff += CURS_INC*4;   break;
X     case DOWN_ARROW:     yoff += CURS_INC;     break;
X     case UP_ARROW_2:     yoff -= CURS_INC*4;   break;
X     case UP_ARROW:      yoff -= CURS_INC;     break;
X
X     default:
X        done = TRUE;
X     }
X
X      if (!done)
X     {
X     if (!first)
X        getakey();         /* delete key from buffer */
X     else
X        first = FALSE;
X     key = keypressed();   /* peek at the next one... */
X     }
X      }
X
X   Cursor_Move(xoff, yoff);
X
X   if (this->auto_select)
X      PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X   }
X
X
X#ifdef __TURBOC__
X#   pragma argsused
X#endif
X
Xstatic void PalTable__change(RGBEditor *rgb, VOIDPTR info)
X   {
X   PalTable *this = (PalTable *)info;
X   int       pnum = this->curr[this->active];
X
X   if ( this->freestyle )
X      {
X      this->fs_color = RGBEditor_GetRGB(rgb);
X      PalTable__UpdateDAC(this);
X      return ;
X      }
X
X   if ( !this->curr_changed )
X      {
X      PalTable__SaveUndoData(this, pnum, pnum);
X      this->curr_changed = TRUE;
X      }
X
X   this->pal[pnum] = RGBEditor_GetRGB(rgb);
X
X   if (this->curr[0] == this->curr[1])
X      {
X      int      other = this->active==0 ? 1 : 0;
X      PALENTRY color;
X
X      color = RGBEditor_GetRGB(this->rgb[this->active]);
X      RGBEditor_SetRGB(this->rgb[other], this->curr[other], &color);
X
X      Cursor_Hide();
X      RGBEditor_Update(this->rgb[other]);
X      Cursor_Show();
X      }
X
X   }
X
X
Xstatic void PalTable__UpdateDAC(PalTable *this)
X   {
X   if ( this->exclude )
X      {
X      memset(dacbox, 0, 256*3);
X      if (this->exclude == 1)
X     {
X     int a = this->curr[this->active];
X     memmove(dacbox[a], &this->pal[a], 3);
X     }
X      else
X     {
X     int a = this->curr[0],
X         b = this->curr[1];
X
X     if (a>b)
X        {
X        int t=a;
X        a=b;
X        b=t;
X        }
X
X     memmove(dacbox[a], &this->pal[a], 3*(1+(b-a)));
X     }
X      }
X   else
X      {
X      memmove(dacbox[0], this->pal, 3*colors);
X
X      if ( this->freestyle )
X         PalTable__PutBand(this, (PALENTRY *)dacbox);   /* apply band to dacbox */
X      }
X
X   if ( !this->hidden )
X      {
X      if (inverse)
X     {
X     memset(dacbox[fg_color], 0, 3);     /* dacbox[fg] = (0,0,0) */
X     memset(dacbox[bg_color], 48, 3);     /* dacbox[bg] = (48,48,48) */
X     }
X      else
X     {
X     memset(dacbox[bg_color], 0, 3);     /* dacbox[bg] = (0,0,0) */
X     memset(dacbox[fg_color], 48, 3);     /* dacbox[fg] = (48,48,48) */
X     }
X      }
X
X   spindac(0,1);
X   }
X
X
Xstatic void PalTable__Rotate(PalTable *this, int dir, int lo, int hi)
X   {
X
X   rotatepal(this->pal, dir, lo, hi);
X
X   Cursor_Hide();
X
X   /* update the DAC.  */
X
X   PalTable__UpdateDAC(this);
X
X   /* update the editors. */
X
X   RGBEditor_SetRGB(this->rgb[0], this->curr[0], &(this->pal[this->curr[0]]));
X   RGBEditor_SetRGB(this->rgb[1], this->curr[1], &(this->pal[this->curr[1]]));
X   RGBEditor_Update(this->rgb[0]);
X   RGBEditor_Update(this->rgb[1]);
X
X   Cursor_Show();
X   }
X
X
Xstatic void PalTable__other_key(int key, RGBEditor *rgb, VOIDPTR info)
X   {
X   PalTable *this = (PalTable *)info;
X
X   switch(key)
X      {
X      case '\\':    /* move/resize */
X     {
X     if (this->hidden)
X        break;         /* cannot move a hidden pal */
X     Cursor_Hide();
X     PalTable__RestoreRect(this);
X     MoveBox_SetPos(this->movebox, this->x, this->y);
X     MoveBox_SetCSize(this->movebox, this->csize);
X     if ( MoveBox_Process(this->movebox) )
X        {
X        if ( MoveBox_ShouldHide(this->movebox) )
X           PalTable_SetHidden(this, TRUE);
X        else if ( MoveBox_Moved(this->movebox) )
X           {
X           PalTable__SetPos(this, MoveBox_X(this->movebox), MoveBox_Y(this->movebox));
X           PalTable__SetCSize(this, MoveBox_CSize(this->movebox));
X           PalTable__SaveRect(this);
X           }
X        }
X     PalTable__Draw(this);
X     Cursor_Show();
X
X     RGBEditor_SetDone(this->rgb[this->active], TRUE);
X
X     if (this->auto_select)
X        PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X     break;
X     }
X
X      case 'Y':    /* exclude range */
X      case 'y':
X     if ( this->exclude==2 )
X        this->exclude = 0;
X     else
X        this->exclude = 2;
X     PalTable__UpdateDAC(this);
X         PalTable__DrawStatus(this, FALSE);
X     break;
X
X      case 'X':
X      case 'x':     /* exclude current entry */
X     if ( this->exclude==1 )
X        this->exclude = 0;
X     else
X        this->exclude = 1;
X     PalTable__UpdateDAC(this);
X         PalTable__DrawStatus(this, FALSE);
X     break;
X
X      case RIGHT_ARROW:
X      case LEFT_ARROW:
X      case UP_ARROW:
X      case DOWN_ARROW:
X      case RIGHT_ARROW_2:
X      case LEFT_ARROW_2:
X      case UP_ARROW_2:
X      case DOWN_ARROW_2:
X     PalTable__DoCurs(this, key);
X     break;
X
X      case ESC:
X     this->done = TRUE;
X     RGBEditor_SetDone(rgb, TRUE);
X     break;
X
X      case ' ':     /* select the other palette register */
X     this->active = (this->active==0) ? 1 : 0;
X     if (this->auto_select)
X        PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X      else
X        PalTable__SetCurr(this, -1, 0);
X
X     if (this->exclude || this->freestyle)
X        PalTable__UpdateDAC(this);
X
X     RGBEditor_SetDone(rgb, TRUE);
X     break;
X
X      case ENTER:    /* set register to color under cursor.  useful when not */
X      case ENTER_2:  /* in auto_select mode */
X
X         if ( this->freestyle )
X            {
X            PalTable__SaveUndoData(this, this->bottom, this->top);
X            PalTable__PutBand(this, this->pal);
X            }
X
X     PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X
X     if (this->exclude || this->freestyle )
X        PalTable__UpdateDAC(this);
X
X     RGBEditor_SetDone(rgb, TRUE);
X     break;
X
X      case 'D':    /* copy (Duplicate?) color in inactive to color in active */
X      case 'd':
X     {
X     int   a = this->active,
X          b = (a==0) ? 1 : 0;
X     PALENTRY t;
X
X     t = RGBEditor_GetRGB(this->rgb[b]);
X     Cursor_Hide();
X
X     RGBEditor_SetRGB(this->rgb[a], this->curr[a], &t);
X     RGBEditor_Update(this->rgb[a]);
X     PalTable__change(this->rgb[a], this);
X     PalTable__UpdateDAC(this);
X
X     Cursor_Show();
X     break;
X     }
X
X      case '=':    /* create a shade range between the two entries */
X     {
X     int a = this->curr[0],
X         b = this->curr[1];
X
X     if (a > b)
X        {
X        int t = a;
X        a = b;
X        b = t;
X        }
X
X         PalTable__SaveUndoData(this, a, b);
X
X     if (a != b)
X        {
X        mkpalrange(&this->pal[a], &this->pal[b], &this->pal[a], b-a, 1);
X        PalTable__UpdateDAC(this);
X        }
X
X     break;
X     }
X
X      case '!':    /* swap r<->g */
X     {
X     int a = this->curr[0],
X         b = this->curr[1];
X
X     if (a > b)
X        {
X        int t = a;
X        a = b;
X        b = t;
X        }
X
X         PalTable__SaveUndoData(this, a, b);
X
X     if (a != b)
X        {
X        rotcolrg(&this->pal[a], b-a);
X        PalTable__UpdateDAC(this);
X        }
X
X
X     break;
X     }
X
X      case '@':    /* swap g<->b */
X     {
X     int a = this->curr[0],
X         b = this->curr[1];
X
X     if (a > b)
X        {
X        int t = a;
X        a = b;
X        b = t;
X        }
X
X         PalTable__SaveUndoData(this, a, b);
X
X     if (a != b)
X        {
X        rotcolgb(&this->pal[a], b-a);
X        PalTable__UpdateDAC(this);
X        }
X
X     break;
X     }
X
X      case '#':    /* swap r<->b */
X     {
X     int a = this->curr[0],
X         b = this->curr[1];
X
X     if (a > b)
X        {
X        int t = a;
X        a = b;
X        b = t;
X        }
X
X         PalTable__SaveUndoData(this, a, b);
X
X     if (a != b)
X        {
X        rotcolbr(&this->pal[a], b-a);
X        PalTable__UpdateDAC(this);
X        }
X
X     break;
X     }
X
X
X      case 'T':
X      case 't':   /* s(T)ripe mode */
X     {
X     int key;
X
X     Cursor_Hide();
X         PalTable__DrawStatus(this, TRUE);
X     key = getakeynohelp();
X         PalTable__DrawStatus(this, FALSE);
X     Cursor_Show();
X
X     if (key >= '1' && key <= '9')
X        {
X        int a = this->curr[0],
X        b = this->curr[1];
X
X        if (a > b)
X           {
X           int t = a;
X           a = b;
X           b = t;
X           }
X
X            PalTable__SaveUndoData(this, a, b);
X
X        if (a != b)
X           {
X           mkpalrange(&this->pal[a], &this->pal[b], &this->pal[a], b-a, key-'0');
X           PalTable__UpdateDAC(this);
X           }
X        }
X
X     break;
X     }
X
X      case 'M':   /* set gamma */
X      case 'm':
X      {
X          int i;
X          char buf[20];
X          sprintf(buf,"%.3f",1./gamma_val);
X          stackscreen();
X          i = field_prompt(0,"Enter gamma value",NULL,buf,20,NULL);
X          unstackscreen();
X          if (i != -1) {
X          sscanf(buf,"%f",&gamma_val);
X          if (gamma_val==0) {
X              gamma_val = 0.0000000001;
X          }
X          gamma_val = 1./gamma_val;
X          }
X      }
X      break;
X      case 'A':   /* toggle auto-select mode */
X      case 'a':
X     this->auto_select = (this->auto_select) ? FALSE : TRUE;
X     if (this->auto_select)
X        {
X        PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X        if (this->exclude)
X           PalTable__UpdateDAC(this);
X        }
X         PalTable__DrawStatus(this, FALSE);
X     break;
X
X      case 'H':
X      case 'h': /* toggle hide/display of palette editor */
X     Cursor_Hide();
X     PalTable_Hide(this, rgb, (BOOLEAN)((this->hidden) ? FALSE : TRUE));
X     Cursor_Show();
X     break;
X
X      case '.':   /* rotate once */
X      case ',':
X     {
X         int dir = (key=='.') ? 1 : -1;
X
X         PalTable__SaveUndoRotate(this, dir, rotate_lo, rotate_hi);
X     PalTable__Rotate(this, dir, rotate_lo, rotate_hi);
X     break;
X     }
X
X      case '>':   /* continuous rotation (until a key is pressed) */
X      case '<':
X     {
X         int  dir;
X     long tick;
X         int  diff = 0;
X
X     Cursor_Hide();
X
X     if ( !this->hidden )
X        {
X        RGBEditor_BlankSampleBox(this->rgb[0]);
X        RGBEditor_BlankSampleBox(this->rgb[1]);
X        RGBEditor_SetHidden(this->rgb[0], TRUE);
X        RGBEditor_SetHidden(this->rgb[1], TRUE);
X        }
X
X         do
X            {
X            dir = (key=='>') ? 1 : -1;
X
X           while ( !keypressed() )
X           {
X           tick = readticker();
X           PalTable__Rotate(this, dir, rotate_lo, rotate_hi);
X               diff += dir;
X           while (readticker() == tick) ;   /* wait until a tick passes */
X           }
X
X          key = getakey();
X            }
X         while (key=='<' || key=='>');
X
X     if ( !this->hidden )
X        {
X        RGBEditor_SetHidden(this->rgb[0], FALSE);
X        RGBEditor_SetHidden(this->rgb[1], FALSE);
X        RGBEditor_Update(this->rgb[0]);
X        RGBEditor_Update(this->rgb[1]);
X        }
X
X         if ( diff != 0 )
X            PalTable__SaveUndoRotate(this, diff, rotate_lo, rotate_hi);
X
X     Cursor_Show();
X     break;
X     }
X
X      case 'I':     /* invert the fg & bg colors */
X      case 'i':
X    inverse = !inverse;
X    PalTable__UpdateDAC(this);
X    break;
X
X      case 'V':
X      case 'v':     /* set the reserved colors to the editor colors */
X     if ( this->curr[0] >= colors || this->curr[1] >= colors ||
X          this->curr[0] == this->curr[1] )
X        {
X        buzzer(2);
X        break;
X        }
X
X     fg_color = this->curr[0];
X     bg_color = this->curr[1];
X
X     if ( !this->hidden )
X        {
X        Cursor_Hide();
X        PalTable__UpdateDAC(this);
X        PalTable__Draw(this);
X        Cursor_Show();
X        }
X
X     RGBEditor_SetDone(this->rgb[this->active], TRUE);
X     break;
X
X      case 'O':    /* set rotate_lo and rotate_hi to editors */
X      case 'o':
X     if (this->curr[0] > this->curr[1])
X        {
X        rotate_lo = this->curr[1];
X        rotate_hi = this->curr[0];
X        }
X     else
X        {
X        rotate_lo = this->curr[0];
X        rotate_hi = this->curr[1];
X        }
X     break;
X
X      case F2:      /* restore a palette */
X      case F3:
X      case F4:
X      case F5:
X      case F6:
X      case F7:
X      case F8:
X      case F9:
X     {
X     int which = key - F2;
X
X     if ( this->save_pal[which] != NULL )
X        {
X        struct SREGS seg;
X
X        Cursor_Hide();
X
X            PalTable__SaveUndoData(this, 0, 255);
X
X        segread(&seg);
X        movedata(FP_SEG(this->save_pal[which]), FP_OFF(this->save_pal[which]),
X             seg.ds, (USEGTYPE)(this->pal), 256*3);
X
X        PalTable__UpdateDAC(this);
X
X        PalTable__SetCurr(this, -1, 0);
X        Cursor_Show();
X        RGBEditor_SetDone(this->rgb[this->active], TRUE);
X        }
X     else
X        buzzer(3);     /* error buzz */
X     break;
X     }
X
X      case SF2:   /* save a palette */
X      case SF3:
X      case SF4:
X      case SF5:
X      case SF6:
X      case SF7:
X      case SF8:
X      case SF9:
X     {
X     int which = key - SF2;
X
X     if ( this->save_pal[which] != NULL )
X        {
X        struct SREGS seg;
X
X        segread(&seg);
X        movedata(seg.ds, (USEGTYPE)(this->pal), FP_SEG(this->save_pal[which]),
X            FP_OFF(this->save_pal[which]), 256*3);
X        }
X     else
X        buzzer(3); /* oops! short on memory! */
X     break;
X     }
X
X      case 'L':     /* load a .map palette */
X      case 'l':
X     {
X         PalTable__SaveUndoData(this, 0, 255);
X
X     load_palette();
X#ifndef XFRACT
X     getpalrange(0, colors, this->pal);
X#else
X     getpalrange(0, 256, this->pal);
X#endif
X     PalTable__UpdateDAC(this);
X     RGBEditor_SetRGB(this->rgb[0], this->curr[0], &(this->pal[this->curr[0]]));
X     RGBEditor_Update(this->rgb[0]);
X     RGBEditor_SetRGB(this->rgb[1], this->curr[1], &(this->pal[this->curr[1]]));
X     RGBEditor_Update(this->rgb[1]);
X     break;
X     }
X
X      case 'S':     /* save a .map palette */
X      case 's':
X     {
X#ifndef XFRACT
X     setpalrange(0, colors, this->pal);
X#else
X     setpalrange(0, 256, this->pal);
X#endif
X     save_palette();
X     PalTable__UpdateDAC(this);
X     break;
X     }
X
X      case 'C':     /* color cycling sub-mode */
X      case 'c':
X     {
X     BOOLEAN oldhidden = this->hidden;
X
X         PalTable__SaveUndoData(this, 0, 255);
X
X     Cursor_Hide();
X     if ( !oldhidden )
X        PalTable_Hide(this, rgb, TRUE);
X     setpalrange(0, colors, this->pal);
X     rotate(0);
X     getpalrange(0, colors, this->pal);
X     PalTable__UpdateDAC(this);
X     if ( !oldhidden )
X        {
X        RGBEditor_SetRGB(this->rgb[0], this->curr[0], &(this->pal[this->curr[0]]));
X        RGBEditor_SetRGB(this->rgb[1], this->curr[1], &(this->pal[this->curr[1]]));
X        PalTable_Hide(this, rgb, FALSE);
X        }
X     Cursor_Show();
X     break;
X     }
X
X      case 'F':
X      case 'f':    /* toggle freestyle palette edit mode */
X         this->freestyle= (this->freestyle) ? FALSE :TRUE;
X
X         PalTable__SetCurr(this, -1, 0);
X
X         if ( !this->freestyle )   /* if turning off... */
X            PalTable__UpdateDAC(this);
X
X         PalTable__DrawStatus(this, FALSE);
X         break;
X
X      case CTL_DEL:  /* rt plus down */
X         if (this->bandwidth >0 )
X            this->bandwidth  --;
X         else
X            this->bandwidth=0;
X         PalTable__SetCurr(this, -1, 0);
X         break;
X
X      case CTL_INSERT: /* rt plus up */
X         if (this->bandwidth <255 )
X           this->bandwidth ++;
X         else
X            this->bandwidth = 255;
X         PalTable__SetCurr(this, -1, 0);
X         break;
X
X      case 'W':   /* convert to greyscale */
X      case 'w':
X     {
X     switch ( this->exclude )
X        {
X        case 0:   /* normal mode.  convert all colors to grey scale */
X               PalTable__SaveUndoData(this, 0, 255);
X           palrangetogrey(this->pal, 0, 256);
X           break;
X
X        case 1:   /* 'x' mode. convert current color to grey scale.  */
X               PalTable__SaveUndoData(this, this->curr[this->active], this->curr[this->active]);
X           palrangetogrey(this->pal, this->curr[this->active], 1);
X           break;
X
X        case 2:  /* 'y' mode.  convert range between editors to grey. */
X           {
X           int a = this->curr[0],
X           b = this->curr[1];
X
X           if (a > b)
X          {
X          int t = a;
X          a = b;
X          b = t;
X          }
X
X               PalTable__SaveUndoData(this, a, b);
X           palrangetogrey(this->pal, a, 1+(b-a));
X           break;
X           }
X        }
X
X     PalTable__UpdateDAC(this);
X     RGBEditor_SetRGB(this->rgb[0], this->curr[0], &(this->pal[this->curr[0]]));
X     RGBEditor_Update(this->rgb[0]);
X     RGBEditor_SetRGB(this->rgb[1], this->curr[1], &(this->pal[this->curr[1]]));
X     RGBEditor_Update(this->rgb[1]);
X     break;
X     }
X
X      case 'N':   /* convert to negative color */
X      case 'n':
X     {
X     switch ( this->exclude )
X        {
X        case 0:     /* normal mode.  convert all colors to grey scale */
X               PalTable__SaveUndoData(this, 0, 255);
X           palrangetonegative(this->pal, 0, 256);
X           break;
X
X        case 1:     /* 'x' mode. convert current color to grey scale.  */
X               PalTable__SaveUndoData(this, this->curr[this->active], this->curr[this->active]);
X           palrangetonegative(this->pal, this->curr[this->active], 1);
X           break;
X
X        case 2:  /* 'y' mode.  convert range between editors to grey. */
X           {
X           int a = this->curr[0],
X           b = this->curr[1];
X
X           if (a > b)
X          {
X          int t = a;
X          a = b;
X          b = t;
X          }
X
X               PalTable__SaveUndoData(this, a, b);
X           palrangetonegative(this->pal, a, 1+(b-a));
X           break;
X           }
X        }
X
X     PalTable__UpdateDAC(this);
X     RGBEditor_SetRGB(this->rgb[0], this->curr[0], &(this->pal[this->curr[0]]));
X     RGBEditor_Update(this->rgb[0]);
X     RGBEditor_SetRGB(this->rgb[1], this->curr[1], &(this->pal[this->curr[1]]));
X     RGBEditor_Update(this->rgb[1]);
X     break;
X     }
X
X      case 'U':     /* Undo */
X      case 'u':
X         PalTable__Undo(this);
X         break;
X
X      case 'e':    /* Redo */
X      case 'E':
X         PalTable__Redo(this);
X         break;
X
X      } /* switch */
X   }
X
X
Xstatic void PalTable__MkDefaultPalettes(PalTable *this)  /* creates default Fkey palettes */
X   {
X   PALENTRY     black,
X            white;
X   PALENTRY     temp[256];
X   int            ctr;
X   struct SREGS seg;
X
X   black.red = black.green = black.blue = 0;
X   white.red = white.green = white.blue = 63;
X   mkpalrange(&black, &white, temp, 256, 1); /* boring! */
X
X   segread(&seg);
X
X   for (ctr=0; ctr<8; ctr++)   /* copy temp into all fkey saves */
X      movedata(seg.ss, (USEGTYPE)(temp), FP_SEG(this->save_pal[ctr]),
X           FP_OFF(this->save_pal[ctr]), 256*3);
X   }
X
X
X
Xstatic PalTable *PalTable_Construct(void)
X   {
X   PalTable     *this = new(PalTable);
X   int         csize;
X   int         ctr;
X   PALENTRY far *mem_block;
X   void far     *temp;
X
X   temp = farmemalloc(FAR_RESERVE);
X
X   if ( temp != NULL )
X      {
X      mem_block = (PALENTRY far *)farmemalloc(256L*3 * 8);
X
X      if ( mem_block == NULL )
X     {
X     for (ctr=0; ctr<8; ctr++)
X        this->save_pal[ctr] = NULL;
X     }
X      else
X     {
X     for (ctr=0; ctr<8; ctr++)
X        this->save_pal[ctr] = mem_block + (256*ctr);
X
X     PalTable__MkDefaultPalettes(this);
X     }
X      farmemfree(temp);
X      }
X
X   this->rgb[0] = RGBEditor_Construct(0, 0, PalTable__other_key,
X          PalTable__change, this);
X   this->rgb[1] = RGBEditor_Construct(0, 0, PalTable__other_key,
X          PalTable__change, this);
X
X   this->movebox = MoveBox_Construct(0,0,0, PalTable_PALX+1, PalTable_PALY+1);
X
X   this->active      = 0;
X   this->curr[0]     = 1;
X   this->curr[1]     = 1;
X   this->auto_select = TRUE;
X   this->exclude     = FALSE;
X   this->hidden      = FALSE;
X   this->stored_at   = NOWHERE;
X   this->file         = NULL;
X   this->memory      = NULL;
X
X   this->fs_color.red   = 42;
X   this->fs_color.green = 42;
X   this->fs_color.blue  = 42;
X   this->freestyle      = FALSE;
X   this->bandwidth      = 15;
X   this->top            = 255;
X   this->bottom         = 0 ;
X
X   this->undo_file    = fopen(undofile, "w+b");
X   this->curr_changed = FALSE;
X   this->num_redo     = 0;
X
X   RGBEditor_SetRGB(this->rgb[0], this->curr[0], &this->pal[this->curr[0]]);
X   RGBEditor_SetRGB(this->rgb[1], this->curr[1], &this->pal[this->curr[0]]);
X
X   PalTable__SetPos(this, 0, 0);
X
X   csize = ( (sydots-(PalTable_PALY+1+1)) / 2 ) / 16;
X   if (csize<CSIZE_MIN)
X      csize = CSIZE_MIN;
X   PalTable__SetCSize(this, csize);
X
X   return(this);
X   }
X
X
Xstatic void PalTable_SetHidden(PalTable *this, BOOLEAN hidden)
X   {
X   this->hidden = hidden;
X   RGBEditor_SetHidden(this->rgb[0], hidden);
X   RGBEditor_SetHidden(this->rgb[1], hidden);
X   PalTable__UpdateDAC(this);
X   }
X
X
X
Xstatic void PalTable_Hide(PalTable *this, RGBEditor *rgb, BOOLEAN hidden)
X   {
X   if (hidden)
X      {
X      PalTable__RestoreRect(this);
X      PalTable_SetHidden(this, TRUE);
X      reserve_colors = FALSE;
X      if (this->auto_select)
X     PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X      }
X   else
X      {
X      PalTable_SetHidden(this, FALSE);
X      reserve_colors = TRUE;
X      if (this->stored_at == NOWHERE)  /* do we need to save screen? */
X     PalTable__SaveRect(this);
X      PalTable__Draw(this);
X      if (this->auto_select)
X     PalTable__SetCurr(this, this->active, PalTable__GetCursorColor(this));
X      RGBEditor_SetDone(rgb, TRUE);
X      }
X   }
X
X
Xstatic void PalTable_Destroy(PalTable *this)
X   {
X
X   if (this->file != NULL)
X      {
X      fclose(this->file);
X      remove(scrnfile);
X      }
X
X   if (this->undo_file != NULL)
X      {
X      fclose(this->undo_file);
X      remove(undofile);
X      }
X
X   if (this->memory != NULL)
X      farmemfree(this->memory);
X
X   if (this->save_pal[0] != NULL)
X      farmemfree((BYTE far *)this->save_pal[0]);
X
X   RGBEditor_Destroy(this->rgb[0]);
X   RGBEditor_Destroy(this->rgb[1]);
X   MoveBox_Destroy(this->movebox);
X   delete(this);
X   }
X
X
Xstatic void PalTable_Process(PalTable *this)
X   {
X   int ctr;
X
X   getpalrange(0, colors, this->pal);
X
X   /* Make sure all palette entries are 0-63 */
X
X   for(ctr=0; ctr<768; ctr++)
X      ((char *)this->pal)[ctr] &= 63;
X
X   PalTable__UpdateDAC(this);
X
X   RGBEditor_SetRGB(this->rgb[0], this->curr[0], &this->pal[this->curr[0]]);
X   RGBEditor_SetRGB(this->rgb[1], this->curr[1], &this->pal[this->curr[0]]);
X
X   if (!this->hidden)
X      {
X      MoveBox_SetPos(this->movebox, this->x, this->y);
X      MoveBox_SetCSize(this->movebox, this->csize);
X      if ( !MoveBox_Process(this->movebox) )
X     {
X     setpalrange(0, colors, this->pal);
X     return ;
X     }
X
X      PalTable__SetPos(this, MoveBox_X(this->movebox), MoveBox_Y(this->movebox));
X      PalTable__SetCSize(this, MoveBox_CSize(this->movebox));
X
X      if ( MoveBox_ShouldHide(this->movebox) )
X     {
X     PalTable_SetHidden(this, TRUE);
X     reserve_colors = FALSE;   /* <EAN> */
X     }
X      else
X     {
X     reserve_colors = TRUE;    /* <EAN> */
X     PalTable__SaveRect(this);
X     PalTable__Draw(this);
X     }
X      }
X
X   PalTable__SetCurr(this, this->active,      PalTable__GetCursorColor(this));
X   PalTable__SetCurr(this, (this->active==1)?0:1, PalTable__GetCursorColor(this));
X   Cursor_Show();
X
X   this->done = FALSE;
X
X   while ( !this->done )
X      RGBEditor_Edit(this->rgb[this->active]);
X
X   Cursor_Hide();
X   PalTable__RestoreRect(this);
X   setpalrange(0, colors, this->pal);
X   }
X
X
X/*
X * interface to FRACTINT
X */
X
X
X
Xvoid EditPalette(void)         /* called by fractint */
X   {
X   int         oldlookatmouse = lookatmouse;
X   int         oldsxoffs        = sxoffs;
X   int         oldsyoffs        = syoffs;
X   PalTable *pt;
X
X   ENTER_OVLY(OVLY_ROTATE);
X
X   mem_init(strlocn, 10*1024);
X
X   if ( (font8x8 = findfont(0)) == NULL )
X      return ;
X
X   plot = putcolor;
X
X   line_buff = newx(max(sxdots,sydots));
X
X   lookatmouse = 3;
X   sxoffs = syoffs = 0;
X
X   reserve_colors = TRUE;
X   inverse = FALSE;
X   fg_color = 255%colors;
X   bg_color = fg_color-1;
X
X   Cursor_Construct();
X   pt = PalTable_Construct();
X   PalTable_Process(pt);
X   PalTable_Destroy(pt);
X   Cursor_Destroy();
X
X   lookatmouse = oldlookatmouse;
X   sxoffs = oldsxoffs;
X   syoffs = oldsyoffs;
X   delete(line_buff);
X   EXIT_OVLY;
X   }
X
SHAR_EOF
$TOUCH -am 1028230093 editpal.c &&
chmod 0644 editpal.c ||
echo "restore of editpal.c failed"
set `wc -c editpal.c`;Wc_c=$1
if test "$Wc_c" != "80381"; then
    echo original size 80381, current size $Wc_c
fi
# ============= encoder.c ==============
echo "x - extracting encoder.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > encoder.c &&
X/*
X    encoder.c - GIF Encoder and associated routines
X    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#ifndef XFRACT
X#include <io.h>
X#endif
X#include "fractint.h"
X#include "fractype.h"
X#include "prototyp.h"
X
X/* MCP 10-27-91 */
X#ifdef WINFRACT
X   extern int OperCancelled;
X   void OpenStatusBox(void);
X   void UpdateStatusBox(unsigned long Partial, unsigned long Total);
X   void CloseStatusBox(void);
X#endif
X
Xextern char s_cantopen[];
Xextern char s_cantwrite[];
Xextern char s_cantcreate[];
Xextern char s_cantunderstand[];
Xextern char s_cantfind[];
Xextern char maxfn;
Xstatic void _fastcall setup_save_info(struct fractal_info *);
Xstatic int inittable(void);
Xstatic int _fastcall shftwrite(BYTE *color,int numcolors);
Xstatic int _fastcall raster(unsigned int);
Xstatic int  _fastcall extend_blk_len(int datalen);
Xstatic int _fastcall put_extend_blk(int block_id,int block_len,char far *block_data);
Xstatic int  _fastcall store_item_name(char *);
X
Xextern int initbatch;
Xextern char far *resume_info;        /* pointer to resume info if allocated */
Xextern int  resume_len;         /* length of resume info */
Xextern char LName[];
Xextern char FormName[];         /* formula name */
Xextern char IFSName[];
Xextern int  active_system;        /* 0=dos, 1=windows */
Xextern int  far *ranges;
Xextern int  rangeslen;
X
Xextern    int    sxdots,sydots;        /* # of dots on the physical screen    */
Xextern    int    sxoffs,syoffs;        /* physical top left of logical screen */
Xextern    int    xdots, ydots;        /* # of dots on the logical screen     */
Xextern    int    viewwindow;        /* 0 for full screen, 1 for window */
Xextern    float    finalaspectratio;    /* for view shape and rotation */
Xextern    int    viewxdots,viewydots;    /* explicit view sizing */
Xextern    int    colors;         /* maximum colors available */
Xextern    int    dotmode;        /* so we can detect disk-video */
Xextern    char overwrite;         /* overwrite on/off */
Xextern    int    resave_flag;        /* resaving after a timed save */
Xextern    int    started_resaves;
Xextern    int    timedsave;        /* if doing an auto save */
Xextern    int    disk16bit;        /* 16 bit continuous potential */
X
Xextern BYTE dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
Xextern    int    gotrealdac;        /* DAC valid? */
Xextern int    daclearn, daccount;    /* used by the color-cyclers */
Xextern SEGTYPE    extraseg;        /* used by Save-to-GIF routines */
Xextern int    debugflag;
X
Xextern int    gif87a_flag;        /* if 1, supress GIF extension blocks */
X
Xextern int    calc_status;
Xextern long   calctime;
Xextern char   stdcalcmode;
Xextern int    fractype;
Xextern double xxmin,xxmax;
Xextern double yymin,yymax;
Xextern double xx3rd,yy3rd;
Xextern double param[];
Xextern int    major_method;        /* inverse julia parms */
Xextern int    minor_method;
Xextern int    maxit;            /* try this many iterations */
Xextern int    fillcolor;        /* fill color: -1 = normal  */
Xextern int    inside;            /* inside color: 1=blue     */
Xextern int    outside;            /* outside color, if set    */
Xextern int    finattract;        /* finite attractor option  */
Xextern int    forcesymmetry;
Xextern int    LogFlag;            /* non-zero if logarithmic palettes */
Xextern int    rflag, rseed;
Xextern int    periodicitycheck;
Xextern char   useinitorbit;
Xextern _CMPLX initorbit;
Xextern int    pot16bit;
Xextern float  finalaspectratio;
Xextern double potparam[3];        /* three potential parameters*/
Xextern double inversion[];
Xextern int    decomp[];
Xextern int    distest;            /* non-zero if distance estimator   */
Xextern int    distestwidth;
Xextern int    init3d[20];        /* '3d=nn/nn/nn/...' values */
Xextern char   floatflag;        /* floating-point fractals? */
Xextern int    usr_biomorph;
Xextern int    bailout;            /* user input bailout value */
Xextern int    previewfactor;
Xextern int    xtrans;
Xextern int    ytrans;
Xextern int    red_crop_left;
Xextern int    red_crop_right;
Xextern int    blue_crop_left;
Xextern int    blue_crop_right;
Xextern int    red_bright;
Xextern int    blue_bright;
Xextern int    xadjust;
Xextern int    eyeseparation;
Xextern int    glassestype;
Xextern int    save_system;
Xextern int    save_release;
Xextern int    display3d;        /* 3D display flag: 0 = OFF */
Xextern int    Ambient;
Xextern int    RANDOMIZE;
Xextern int    haze;
Xextern int    transparent[2];
Xextern int    rotate_lo,rotate_hi;
Xextern char   busy;
Xextern float  screenaspect;
Xextern     double mxmaxfp;
Xextern     double mxminfp;
Xextern     double mymaxfp;
Xextern     double myminfp;
Xextern     int zdots;
Xextern     float originfp;
Xextern     float depthfp;
Xextern     float heightfp;
Xextern     float widthfp;
Xextern     float distfp;
Xextern     float eyesfp;
Xextern     int neworbittype;
Xextern     short juli3Dmode;
X
X#ifdef XFRACT
Xextern int decode_fractal_info();
X#endif
X
X/*
X            Save-To-Disk Routines (GIF)
X
XGIF and 'Graphics Interchange Format' are trademarks (tm) of Compuserve
XIncorporated, an H&R Block Company.
X
X
XThe following routines perform the GIF encoding when the 's' key is pressed.
XThe routines refer to several variables that are declared elsewhere
X[colors, xdots, ydots, and 'dacbox'], and rely on external routines to
Xactually read and write screen pixels [getcolor(x,y) and putcolor(x,y,color)].
X(Writing pixels is just stuffed in here as a sort of visual status report,
Xand has nothing to do with any GIF function.)    They also rely on the
Xexistence of an externally-defined 64K dataspace and they use the routines
X'toextra()' and 'cmpextra()' to deal with that dataspace (in the same manner
Xas 'memcpy()' and 'memcmp()' would).   Otherwise, they perform a generic
XGIF-encoder function.
X
XNote that these routines use small string- and hash-tables, and "flush"
Xthe GIF entries whenever the hash-table gets two-thirds full or the string
Xtable gets full.   They also use the GIF encoding technique of limiting the
Xencoded string length to a specific size, "adding" a string to the hash table
Xat that point even if a matching string exists ("adding" is in quotes, because
Xif a matching string exists we can increment the code counter but safely throw
Xthe duplicate string away, saving both string space and a hash table entry).
X
X   This results in relatively good speed and small data space, but at the
Xexpense of compression efficiency (filesize).    These trade-offs could be
Xadjusted by modifying the #DEFINEd variables below.
X
XNote that the 'strlocn' and 'teststring' routines are declared
Xto be external just so that they can be defined (and the space re-used)
Xelsewhere.  The actual declarations are in the assembler code.
X
X*/
X
X#define MAXTEST   100        /* maximum single string length */
X#define MAXSTRING 64000     /* total space reserved for strings */
X                /* maximum number of strings available */
X#define MAXENTRY  5003        /* (a prime number is best for hashing) */
X
X#ifndef XFRACT
Xextern unsigned int strlocn[MAXENTRY];
Xextern BYTE teststring[MAXTEST];
Xextern BYTE block[266];   /* GIF-encoded blocks go here */
X#else
Xunsigned int strlocn[10240];
XBYTE teststring[MAXTEST];
XBYTE block[266];   /* GIF-encoded blocks go here */
X#endif
X
Xstatic int numsaves = 0;    /* For adjusting 'save-to-disk' filenames */
X
Xstatic FILE *out;
Xstatic int last_colorbar;
Xstatic int save16bit;
Xstatic int outcolor1s, outcolor2s;
X
Xstatic int lentest, lastentry, numentries, numrealentries;
Xstatic unsigned int nextentry;
Xstatic int clearcode, endcode;
Xstatic unsigned int hashcode;
X
Xstatic BYTE blockcount;
Xstatic int startbits, codebits, bytecount, bitcount;
X
Xstatic char paletteBW[] = {            /* B&W palette */
X      0,  0,  0, 63, 63, 63,
X    };
Xstatic char paletteCGA[] = {            /* 4-color (CGA) palette  */
X      0,  0,  0, 21, 63, 63, 63, 21, 63, 63, 63, 63,
X    };
Xstatic char paletteEGA[] = {            /* 16-color (EGA/CGA) pal */
X      0,  0,  0,  0,  0, 42,  0, 42,  0,  0, 42, 42,
X     42,  0,  0, 42,  0, 42, 42, 21,  0, 42, 42, 42,
X     21, 21, 21, 21, 21, 63, 21, 63, 21, 21, 63, 63,
X     63, 21, 21, 63, 21, 63, 63, 63, 21, 63, 63, 63,
X    };
X
Xvoid encoder_overlay() { }    /* for restore_active_ovly */
X
Xint savetodisk(filename)    /* save-to-disk routine */
X   char *filename;
X   {
X   char tmpmsg[41]; /* before openfile in case of overrun */
X   char openfile[80], openfiletype[10];
X   char tmpfile[80];
X   int newfile;
X   int i, j, outcolor1, outcolor2, interrupted;
X
X   ENTER_OVLY(OVLY_ENCODER);
X
Xrestart:
X
X   save16bit = disk16bit;
X   if (gif87a_flag) /* not storing non-standard fractal info */
X      save16bit = 0;
X
X   strcpy(openfile,filename);        /* decode and open the filename */
X   strcpy(openfiletype,DEFAULTFRACTALTYPE);/* determine the file extension */
X   if (save16bit)
X      strcpy(openfiletype,".pot");
X   for (i = 0; i < strlen(openfile); i++)
X      if (openfile[i] == '.') {
X         strcpy(openfiletype,&openfile[i]);
X         openfile[i] = 0;
X         }
X   if (resave_flag != 1)
X      updatesavename(filename); /* for next time */
X
X   strcat(openfile,openfiletype);
X
X   strcpy(tmpfile,openfile);
X   if (access(openfile,0) != 0) /* file doesn't exist */
X      newfile = 1;
X   else { /* file already exists */
X      if (overwrite == 0) {
X         if (resave_flag == 0)
X            goto restart;
X         if (started_resaves == 0) { /* first save of a savetime set */
X            updatesavename(filename);
X            goto restart;
X            }
X         }
X      if (access(openfile,2) != 0) {
X         sprintf(tmpmsg,s_cantwrite,openfile);
X         stopmsg(0,tmpmsg);
X         EXIT_OVLY;
X         return -1;
X         }
X      newfile = 0;
X      i = strlen(tmpfile);
X      while (--i >= 0 && tmpfile[i] != SLASHC)
X         tmpfile[i] = 0;
X      strcat(tmpfile,"fractint.tmp");
X      }
X
X   started_resaves = (resave_flag == 1) ? 1 : 0;
X   if (resave_flag == 2) /* final save of savetime set? */
X      resave_flag = 0;
X
X   if ((out=fopen(tmpfile,"wb")) == NULL) {
X      sprintf(tmpmsg,s_cantcreate,tmpfile);
X      stopmsg(0,tmpmsg);
X      EXIT_OVLY;
X      return -1;
X      }
X
X   if (dotmode == 11) {            /* disk-video */
X      char buf[60];
X      sprintf(buf,"Saving %s",openfile);
X      dvid_status(1,buf);
X      }
X#ifdef XFRACT
X      else {
X      putstring(3,0,0,"Saving to:");
X      putstring(4,0,0,openfile);
X      putstring(5,0,0,"               ");
X      }
X#endif
X
X   busy = 1;
X
X   if (debugflag != 200)
X      interrupted = encoder();
X   else
X      interrupted = timer(2,NULL);    /* invoke encoder() via timer */
X
X   busy = 0;
X
X   fclose(out);
X
X   if (interrupted) {
X      char buf[200];
X      sprintf(buf,"Save of %s interrupted.\nCancel to ",openfile);
X      if (newfile)
X         strcat(buf,"delete the file,\ncontinue to keep the partial image.");
X      else
X         strcat(buf,"retain the original file,\ncontinue to replace original with new partial image.");
X      interrupted = 1;
X      if (stopmsg(2,buf) < 0) {
X         interrupted = -1;
X         unlink(tmpfile);
X         }
X      }
X
X   if (newfile == 0 && interrupted >= 0) { /* replace the real file */
X      unlink(openfile);        /* success assumed since we checked */
X      rename(tmpfile,openfile);    /* earlier with access            */
X      }
X
X   if (dotmode != 11) {            /* supress this on disk-video */
X      if (active_system == 0) {        /* no bars in Windows version */
X         outcolor1 = outcolor1s;
X         outcolor2 = outcolor2s;
X         for (j = 0; j <= last_colorbar; j++) {
X            if ((j & 4) == 0) {
X               if (++outcolor1 >= colors) outcolor1 = 0;
X               if (++outcolor2 >= colors) outcolor2 = 0;
X               }
X            for (i = 0; 250*i < xdots; i++) { /* clear vert status bars */
X               putcolor(i,j,getcolor(i,j)^outcolor1);
X               putcolor(xdots-1-i,j,getcolor(xdots-1-i,j)^outcolor2);
X               }
X            }
X         }
X#ifdef XFRACT
X         putstring(5,0,0,"Saving done\n");
X#endif
X      }
X   else                    /* disk-video */
X      dvid_status(1,"");
X
X   if (interrupted) {
X      texttempmsg(" *interrupted* save ");
X      if (initbatch == 2 || initbatch == 5) initbatch = 3; /* if batch mode, set error level */
X      EXIT_OVLY;
X      return -1;
X      }
X   if (timedsave == 0) {
X      buzzer(0);
X      if (initbatch == 0) {
X         sprintf(tmpmsg," File saved as %s ",openfile);
X         texttempmsg(tmpmsg);
X         }
X      }
X   EXIT_OVLY;
X   return 0;
X   }
X
X
Xint encoder()
X{
Xint i, ydot, xdot, color, outcolor1, outcolor2;
Xint width;
Xint rownum, rowlimit;
Xunsigned int hashentry;
XBYTE bitsperpixel, x;
Xint entrynum;
Xstruct fractal_info save_info;
X
Xif(initbatch)            /* flush any impending keystrokes */
X   while(keypressed())
X      getakey();
X
Xsetup_save_info(&save_info);
X
X#ifndef XFRACT
Xbitsperpixel = 0;            /* calculate bits / pixel */
Xfor (i = colors; i >= 2; i /= 2 )
X    bitsperpixel++;
X
Xstartbits = bitsperpixel+1;        /* start coding with this many bits */
Xif (colors == 2)
X    startbits++;            /* B&W Klooge */
X#else
X    if (colors==2) {
X        bitsperpixel = 1;
X        startbits = 3;
X    } else {
X        bitsperpixel = 8;
X        startbits = 9;
X    }
X#endif
X
Xclearcode = 1 << (startbits - 1);    /* set clear and end codes */
Xendcode = clearcode+1;
X
Xoutcolor1 = 0;                /* use these colors to show progress */
Xoutcolor2 = 1;                /* (this has nothing to do with GIF) */
Xif (colors > 2) {
X    outcolor1 = 2;
X    outcolor2 = 3;
X    }
Xif (((++numsaves) & 1) == 0) {            /* reverse the colors on alt saves */
X    i = outcolor1;
X    outcolor1 = outcolor2;
X    outcolor2 = i;
X    }
Xoutcolor1s = outcolor1;
Xoutcolor2s = outcolor2;
X
Xif (gif87a_flag == 1) {
X    if (fwrite("GIF87a",6,1,out) != 1) goto oops;  /* old GIF Signature */
X} else {
X    if (fwrite("GIF89a",6,1,out) != 1) goto oops;  /* new GIF Signature */
X}
X
Xwidth = xdots;
Xrowlimit = ydots;
Xif (save16bit) {
X    /* pot16bit info is stored as:
X       file:    double width rows, right side of row is low 8 bits
X       diskvid: ydots rows of colors followed by ydots rows of low 8 bits
X       decoder: returns (row of color info then row of low 8 bits) * ydots
X       */
X    rowlimit <<= 1;
X    width <<= 1;
X    }
Xif (write2(&width,2,1,out) != 1) goto oops;  /* screen descriptor */
Xif (write2(&ydots,2,1,out) != 1) goto oops;
Xx = 128 + ((6-1)<<4) + (bitsperpixel-1); /* color resolution == 6 bits worth */
Xif (write1(&x,1,1,out) != 1) goto oops;
Xif (fputc(0,out) != 0) goto oops;    /* background color */
Xi = 0;
X/** PB, changed to always store pixel aspect ratio, some utilities
X    have been reported to like it **/
X/**
Xif ( finalaspectratio < screenaspect-0.01
X  || finalaspectratio > screenaspect+0.01) {
X **/
Xif (viewwindow                    /* less than full screen?  */
X  && (viewxdots == 0 || viewydots == 0))    /* and we picked the dots? */
X   i = ((double)sydots / (double)sxdots) * 64.0/screenaspect - 14.5;
Xelse /* must risk loss of precision if numbers low */
X   i = (((double)ydots / (double)xdots) / finalaspectratio) * 64 - 14.5;
Xif (i < 1)   i = 1;
Xif (i > 255) i = 255;
Xif (gif87a_flag) i = 0;    /* for some decoders which can't handle aspect */
Xif (fputc(i,out) != i) goto oops;    /* pixel aspect ratio */
X
X#ifndef XFRACT
Xif (colors == 256) {            /* write out the 256-color palette */
X    if (gotrealdac) {         /* got a DAC - must be a VGA */
X        if (!shftwrite((BYTE *)dacbox,colors)) goto oops;
X#else
Xif (colors > 2) {
X        if (gotrealdac) {               /* got a DAC - must be a VGA */
X                if (!shftwrite((BYTE *)dacbox,256)) goto oops;
X#endif
X     } else {            /* uh oh - better fake it */
X        for (i = 0; i < 256; i += 16)
X            if (!shftwrite((BYTE *)paletteEGA,16)) goto oops;
X        }
X    }
Xif (colors == 2) {            /* write out the B&W palette */
X    if (!shftwrite((BYTE *)paletteBW,colors)) goto oops;
X    }
X#ifndef XFRACT
Xif (colors == 4) {            /* write out the CGA palette */
X    if (!shftwrite(paletteCGA,colors))goto oops;
X    }
Xif (colors == 16) {            /* Either EGA or VGA */
X    if (gotrealdac) {
X        if (!shftwrite((BYTE *)dacbox,colors))goto oops;
X        }
X     else    {            /* no DAC - must be an EGA */
X        if (!shftwrite(paletteEGA,colors))goto oops;
X        }
X    }
X#endif
X
Xif (fwrite(",",1,1,out) != 1) goto oops;  /* Image Descriptor */
Xi = 0;
Xif (write2(&i,2,1,out) != 1) goto oops;
Xif (write2(&i,2,1,out) != 1) goto oops;
Xif (write2(&width,2,1,out) != 1) goto oops;
Xif (write2(&ydots,2,1,out) != 1) goto oops;
Xif (write1(&i,1,1,out) != 1) goto oops;
X
Xbitsperpixel = startbits - 1;        /* raster data starts here */
Xif (write1(&bitsperpixel,1,1,out) != 1) goto oops;
X
Xcodebits = startbits;            /* start encoding */
X
Xif (!raster(9999)) goto oops;        /* initialize the raster routine */
X
Xif (!inittable()) goto oops;        /* initialize the LZW tables */
X
Xfor ( rownum = 0; rownum < ydots; rownum++
X#ifdef WINFRACT
X      , UpdateStatusBox(rownum, ydots)
X#endif
X) {  /* scan through the dots */
X    for (ydot = rownum; ydot < rowlimit; ydot += ydots) {
X    for (xdot = 0; xdot < xdots; xdot++) {
X        if (save16bit == 0 || ydot < ydots)
X            color = getcolor(xdot,ydot);
X        else
X            color = readdisk(xdot+sxoffs,ydot+syoffs);
X        teststring[0] = ++lentest;
X        teststring[lentest] = color;
X        if (lentest == 1) {        /* root entry? */
X            lastentry = color;
X            continue;
X            }
X        if (lentest == 2)        /* init   the hash code */
X            hashcode = 301 * (teststring[1]+1);
X        hashcode *= (color + lentest);    /* update the hash code */
X        hashentry = ++hashcode % MAXENTRY;
X        for( i = 0; i < MAXENTRY; i++) {
X            if (++hashentry >= MAXENTRY) hashentry = 0;
X            if (cmpextra(strlocn[hashentry]+sizeof(int),
X                (char *)teststring,lentest+1) == 0)
X                    break;
X            if (strlocn[hashentry] == 0) i = MAXENTRY;
X            }
X        /* found an entry and string length isn't too bad */
X        if (strlocn[hashentry] != 0 && lentest < MAXTEST-1-sizeof(int)) {
X            fromextra(strlocn[hashentry],(char *)&entrynum,sizeof(int));
X            lastentry = entrynum;
X            continue;
X            }
X        if (!raster(lastentry)) goto oops;    /* write entry */
X        numentries++;        /* act like you added one, anyway */
X        if (strlocn[hashentry] == 0) {    /* add new string, if any */
X            entrynum = numentries+endcode;
X            strlocn[hashentry] = nextentry;
X            toextra(nextentry, (char *)&entrynum,sizeof(int));
X            toextra(nextentry+sizeof(int),
X                (char *)teststring,lentest+1);
X            nextentry += lentest+1+sizeof(int);
X            numrealentries++;
X            }
X        teststring[0] = 1;        /* reset current entry */
X        teststring[1] = color;
X        lentest = 1;
X        lastentry = color;
X
X        if ((numentries+endcode) == (1<<codebits))
X            codebits++;         /* use longer encoding */
X
X        if ( numentries + endcode > 4093 ||    /* out of room? */
X            numrealentries > (MAXENTRY*2)/3 ||
X            nextentry > MAXSTRING-MAXTEST-1-2*sizeof(int)) {
X            if (!raster(lastentry)) goto oops;    /* flush & restart */
X            if (!inittable()) goto oops;
X            }
X        }
X    if (dotmode != 11            /* supress this on disk-video */
X        && active_system == 0        /* and in Windows version     */
X        && ydot == rownum) {
X        if ((ydot & 4) == 0) {
X            if (++outcolor1 >= colors) outcolor1 = 0;
X            if (++outcolor2 >= colors) outcolor2 = 0;
X            }
X        for (i = 0; 250*i < xdots; i++) {    /* display vert status bars */
X                            /*   (this is NOT GIF-related)    */
X            /* PB Changed following code to xor color, so that
X               image can be restored at end and resumed
X               putcolor(      i,ydot,outcolor1);
X               putcolor(xdots-1-i,ydot,outcolor2);
X            */
X            putcolor(i,ydot,getcolor(i,ydot)^outcolor1);
X            putcolor(xdots-1-i,ydot,getcolor(xdots-1-i,ydot)^outcolor2);
X            }
X        last_colorbar = ydot;
X        }
X#ifdef WINFRACT
X        keypressed();
X        if (OperCancelled)
X#else
X        if (keypressed())                     /* keyboard hit - bail out */
X#endif
X        ydot = rownum = 9999;
X    }
X    }
X
Xif (!raster(lastentry)) goto oops;    /* tidy up - dump the last code */
X
Xif (!raster(endcode)) goto oops;    /* finish the map */
X
Xif (fputc(0,out) != 0) goto oops;    /* raster data ends here */
X
Xif (gif87a_flag == 0) { /* store non-standard fractal info */
X    /* loadfile.c has notes about extension block structure */
X    if (ydot >= 9999)
X        save_info.calc_status = 0; /* partial save is not resumable */
X    save_info.tot_extend_len = 0;
X    if (resume_info != NULL && save_info.calc_status == 2) {
X        /* resume info block, 002 */
X        save_info.tot_extend_len += extend_blk_len(resume_len);
X        if (!put_extend_blk(2,resume_len,resume_info))goto oops;
X        }
X    if (save_info.fractal_type == FORMULA || save_info.fractal_type == FFORMULA)
X        save_info.tot_extend_len += store_item_name(FormName);
X    if (save_info.fractal_type == LSYSTEM)
X        save_info.tot_extend_len += store_item_name(LName);
X    if (save_info.fractal_type == IFS || save_info.fractal_type == IFS3D)
X        save_info.tot_extend_len += store_item_name(IFSName);
X    if (display3d <= 0 && rangeslen) {
X        /* ranges block, 004 */
X        save_info.tot_extend_len += extend_blk_len(rangeslen*2);
X#ifdef XFRACT
X        fix_ranges(ranges,rangeslen,0);
X        put_extend_blk(4,rangeslen*2,(char far *)ranges);
X        fix_ranges(ranges,rangeslen,0);
X#else
X        if (!put_extend_blk(4,rangeslen*2,(char far *)ranges))
X            goto oops;
X#endif
X        }
X
X    /* main and last block, 001 */
X    save_info.tot_extend_len += extend_blk_len(FRACTAL_INFO_SIZE);
X#ifdef XFRACT
X        decode_fractal_info(&save_info,0);
X#endif
X    if (!put_extend_blk(1,FRACTAL_INFO_SIZE,(char far *)&save_info)) {
X        goto oops;
X    }
X    }
X
Xif (fwrite(";",1,1,out) != 1) goto oops;          /* GIF Terminator */
X
Xreturn ((ydot < 9999) ? 0 : 1);
X
Xoops:
X    {
X    fflush(out);
X    stopmsg(0,"Error Writing to disk (Disk full?)");
X    return 1;
X    }
X}
X
Xstatic int _fastcall shftwrite(BYTE *color,int numcolors)
X/* shift IBM colors to GIF */
X{
XBYTE thiscolor;
Xint i,j;
Xfor (i = 0; i < numcolors; i++)
X    for (j = 0; j < 3; j++) {
X        thiscolor = color[3*i+j];
X        thiscolor = thiscolor << 2;
X        thiscolor += (thiscolor >> 6);
X        if (fputc(thiscolor,out) != thiscolor) return(0);
X        }
Xreturn(1);
X}
X
Xstatic int inittable()         /* routine to init tables */
X{
Xint i;
X
Xif (!raster(clearcode)) return(0);    /* signal that table is initialized */
X
Xnumentries = 0;             /* initialize the table */
Xnumrealentries = 0;
Xnextentry = 1;
Xlentest = 0;
Xcodebits = startbits;
X
Xtoextra(0,"\0",1);                      /* clear the hash entries */
Xfor (i = 0; i < MAXENTRY; i++)
X    strlocn[i] = 0;
X
Xreturn(1);
X}
X
Xstatic int _fastcall raster(code)    /* routine to block and output codes */
Xunsigned int code;
X{
Xunsigned int icode, i, j;
X
Xif (code == 9999) {            /* special start-up signal */
X    bytecount = 0;
X    bitcount = 0;
X    for (i = 0; i < 266; i++)
X        block[i] = 0;
X    return(1);
X    }
X
Xicode = code << bitcount;        /* update the bit string */
Xblock[bytecount  ] |= (icode & 255);
Xblock[bytecount+1] |= ((icode>>8) & 255);
Xicode = (code>>8) << bitcount;
Xblock[bytecount+2] |= ((icode>>8) & 255);
Xbitcount += codebits;
Xwhile (bitcount >= 8) {         /* locate next starting point */
X    bitcount -= 8;
X    bytecount++;
X    }
X
Xif (bytecount > 250 || code == endcode) {    /* time to write a block */
X    if (code == endcode)
X        while (bitcount > 0) {        /* if EOF, find the real end */
X            bitcount -= 8;
X            bytecount++;
X            }
X    i = bytecount;
X    blockcount = i;
X        if (write1(&blockcount,1,1,out) != 1) return(0); /* write the block */
X    if (fwrite(block,i,1,out) != 1) return(0);
X    bytecount = 0;                /* now re-start the block */
X    for (j = 0; j < 5; j++)         /* (may have leftover bits) */
X        block[j] = block[j+i];
X    for (j = 5; j < 266; j++)
X        block[j] = 0;
X    }
Xreturn(1);
X}
X
X
Xstatic int _fastcall extend_blk_len(int datalen)
X{
X   return(datalen + (datalen+254)/255 + 15);
X   /*       data   +    1.per.block   + 14 for id + 1 for null at end  */
X}
X
Xstatic int _fastcall put_extend_blk(int block_id,int block_len,char far *block_data)
X{
X   int i,j;
X   char header[15];
X   strcpy(header,"!\377\013fractint");
X   sprintf(&header[11],"%03u",block_id);
X   if (fwrite(header,14,1,out) != 1) return(0);
X   i = (block_len + 254) / 255;
X   while (--i >= 0) {
X      block_len -= (j = min(block_len,255));
X      if (fputc(j,out) != j) return(0);
X      while (--j >= 0)
X     fputc(*(block_data++),out);
X      }
X   if (fputc(0,out) != 0) return(0);
X   return(1);
X}
X
Xstatic int _fastcall store_item_name(char *nameptr)
X{
X   char tmpname[40];
X   strcpy(tmpname,nameptr);
X   /* formula/lsys/ifs info block, 003 */
X   put_extend_blk(3,40,tmpname);
X   return(extend_blk_len(40));
X}
X
Xstatic void _fastcall setup_save_info(struct fractal_info *save_info)
X{
X   int i;
X
X   if(fractype != FORMULA && fractype != FFORMULA)
X      maxfn = 0;
X   /* set save parameters in save structure */
X   strcpy(save_info->info_id, INFO_ID);
X   save_info->version          = 9; /* file version, independant of system */
X   save_info->iterations      = maxit;
X   save_info->fractal_type    = fractype;
X   save_info->xmin          = xxmin;
X   save_info->xmax          = xxmax;
X   save_info->ymin          = yymin;
X   save_info->ymax          = yymax;
X   save_info->creal          = param[0];
X   save_info->cimag          = param[1];
X   save_info->videomodeax     = videoentry.videomodeax;
X   save_info->videomodebx     = videoentry.videomodebx;
X   save_info->videomodecx     = videoentry.videomodecx;
X   save_info->videomodedx     = videoentry.videomodedx;
X   save_info->dotmode          = videoentry.dotmode % 100;
X   save_info->xdots          = videoentry.xdots;
X   save_info->ydots          = videoentry.ydots;
X   save_info->colors          = videoentry.colors;
X   save_info->parm3          = 0; /* pre version==7 fields */
X   save_info->parm4          = 0;
X   save_info->dparm3          = param[2];
X   save_info->dparm4          = param[3];
X   save_info->dparm5          = param[4];
X   save_info->dparm6          = param[5];
X   save_info->dparm7          = param[6];
X   save_info->dparm8          = param[7];
X   save_info->dparm9          = param[8];
X   save_info->dparm10         = param[9];
X   save_info->fillcolor          = fillcolor;
X   save_info->potential[0]    = potparam[0];
X   save_info->potential[1]    = potparam[1];
X   save_info->potential[2]    = potparam[2];
X   save_info->rflag          = rflag;
X   save_info->rseed          = rseed;
X   save_info->inside          = inside;
X   save_info->logmap          = LogFlag;
X   save_info->invert[0]       = inversion[0];
X   save_info->invert[1]       = inversion[1];
X   save_info->invert[2]       = inversion[2];
X   save_info->decomp[0]       = decomp[0];
X   save_info->biomorph          = usr_biomorph;
X   save_info->symmetry          = forcesymmetry;
X   for (i = 0; i < 16; i++)
X      save_info->init3d[i] = init3d[i];
X   save_info->previewfactor   = previewfactor;
X   save_info->xtrans          = xtrans;
X   save_info->ytrans          = ytrans;
X   save_info->red_crop_left   = red_crop_left;
X   save_info->red_crop_right  = red_crop_right;
X   save_info->blue_crop_left  = blue_crop_left;
X   save_info->blue_crop_right = blue_crop_right;
X   save_info->red_bright      = red_bright;
X   save_info->blue_bright     = blue_bright;
X   save_info->xadjust          = xadjust;
X   save_info->eyeseparation   = eyeseparation;
X   save_info->glassestype     = glassestype;
X   save_info->outside          = outside;
X   save_info->x3rd          = xx3rd;
X   save_info->y3rd          = yy3rd;
X   save_info->calc_status     = calc_status;
X   save_info->stdcalcmode     = stdcalcmode;
X   save_info->distest          = distest;
X   save_info->floatflag       = floatflag;
X   save_info->bailout          = bailout;
X   save_info->calctime          = calctime;
X   save_info->trigndx[0]      = trigndx[0];
X   save_info->trigndx[1]      = trigndx[1];
X   save_info->trigndx[2]      = trigndx[2];
X   save_info->trigndx[3]      = trigndx[3];
X   save_info->finattract      = finattract;
X   save_info->initorbit[0]    = initorbit.x;
X   save_info->initorbit[1]    = initorbit.y;
X   save_info->useinitorbit    = useinitorbit;
X   save_info->periodicity     = periodicitycheck;
X   save_info->pot16bit          = disk16bit;
X   save_info->faspectratio    = finalaspectratio;
X   save_info->system          = save_system;
X   save_info->release          = save_release;
X   save_info->flag3d          = display3d;
X   save_info->ambient          = Ambient;
X   save_info->randomize       = RANDOMIZE;
X   save_info->haze          = haze;
X   save_info->transparent[0]  = transparent[0];
X   save_info->transparent[1]  = transparent[1];
X   save_info->rotate_lo       = rotate_lo;
X   save_info->rotate_hi       = rotate_hi;
X   save_info->distestwidth    = distestwidth;
X   save_info->mxmaxfp         = mxmaxfp;
X   save_info->mxminfp         = mxminfp;
X   save_info->mymaxfp         = mymaxfp;
X   save_info->myminfp         = myminfp;
X   save_info->zdots           = zdots;
X   save_info->originfp        = originfp;
X   save_info->depthfp         = depthfp;
X   save_info->heightfp        = heightfp;
X   save_info->widthfp         = widthfp;
X   save_info->distfp          = distfp;
X   save_info->eyesfp          = eyesfp;
X   save_info->orbittype       = neworbittype;
X   save_info->juli3Dmode      = juli3Dmode;
X   save_info->maxfn           = maxfn;
X   save_info->inversejulia    = (major_method << 8) + minor_method; /* MVS */
X   for (i = 0; i < sizeof(save_info->future)/sizeof(short); i++)
X      save_info->future[i] = 0;
X}
SHAR_EOF
$TOUCH -am 1028230093 encoder.c &&
chmod 0644 encoder.c ||
echo "restore of encoder.c failed"
set `wc -c encoder.c`;Wc_c=$1
if test "$Wc_c" != "28368"; then
    echo original size 28368, current size $Wc_c
fi
# ============= f16.c ==============
echo "x - extracting f16.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > f16.c &&
X/**************************************
X**
X** F16.C : Code to read 16-bit fractal data sets.  Uses
X** strictly Targa16 type 10 files (run-length encoded 16-bit RGB).
X*/
X
X/* Lee Daniel Crocker       CompuServe: 73407,2030   <== Preferred
X** 1380 Jewett Ave.          BIX: lcrocker
X** Pittsburg, CA  94565        Usenet: ...!ames!pacbell!sactoh0!siva!lee
X**
X** This code is hereby placed in the public domain.  You are free to
X** use, modify, usurp, laugh at, destroy, or otherwise abuse it in any
X** way you see fit.
X**
X** "If you steal from one author it's plagiarism; if you steal from
X** many it's research."  --Wilson Mizner
X*/
X
X/* 16 bit .tga files were generated for continuous potential "potfile"s
X   from version 9.? thru version 14.  Replaced by double row gif type
X   file (.pot) in version 15.  Delete this code after a few more revs.
X   The part which wrote 16 bit .tga files has already been deleted.
X*/
X
X#include <stdio.h>
X#include <string.h>
X#include <ctype.h>
X#include "targa_lc.h"
X#include "prototyp.h"
X
X#ifndef XFRACT
Xextern char rlebuf[258];    /* RLE-state variables */
X#else
Xchar rlebuf[258];    /* RLE-state variables */
X#endif
Xstatic int state, count, bufp;
X
X/**************************************
X**
X** Open previously saved Targa16 type 10 file filling in hs, vs, and
X** csize with values in the header.  If *csize is not zero, the block
X** pointed to by cp is filled with the comment block.  The caller
X** _must_ allocate 256 bytes for this purpose before calling.
X*/
X
XFILE *t16_open(char *fname, int *hs, int *vs, int *csize, U8 *cp)
X{
X    char filename[64];
X    U8 header[HEADERSIZE];
X    FILE *fp;
X
X    strcpy(filename, fname);
X    if (strchr(filename, '.') == NULL) strcat(filename, ".TGA");
X    if ((fp = fopen(filename, READMODE)) == NULL) return NULL;
X
X    fread(header, HEADERSIZE, 1, fp);
X    if ((header[O_FILETYPE] != T_RLERGB) || (header[O_ESIZE] != 16)) {
X    fclose(fp);
X    return NULL;
X    }
X    GET16(header[O_HSIZE], *hs);
X    GET16(header[O_VSIZE], *vs);
X    if (*csize = header[O_COMMENTLEN]) fread(cp, *csize, 1, fp);
X
X    state = count = bufp = 0;
X    return fp;
X}
X
Xint t16_getline(FILE *fp, int hs, U16 *data)
X{
X    int i;
X
X    for (i=0; i<hs; ++i) {
X    if (state == 0) {
X        bufp = 0;
X        if ((count = getc(fp)) > 127) {
X        state = 1;
X        count -= 127;
X        fread(rlebuf, 2, 1, fp);
X        } else {
X        state = 2;
X        ++count;
X        fread(rlebuf, 2, count, fp);
X        }
X    }
X    GET16(rlebuf[bufp], data[i]);
X    if (--count == 0) state = 0;
X    if (state == 2) bufp += 2;
X    }
X    return 0;
X}
X
SHAR_EOF
$TOUCH -am 1028230093 f16.c &&
chmod 0644 f16.c ||
echo "restore of f16.c failed"
set `wc -c f16.c`;Wc_c=$1
if test "$Wc_c" != "2503"; then
    echo original size 2503, current size $Wc_c
fi
# ============= fracsubr.c ==============
echo "x - extracting fracsubr.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fracsubr.c &&
X/*
XFRACSUBR.C contains subroutines which belong primarily to CALCFRAC.C and
XFRACTALS.C, i.e. which are non-fractal-specific fractal engine subroutines.
X*/
X
X#include <stdio.h>
X#ifndef XFRACT
X#include <stdarg.h>
X#else
X#include <varargs.h>
X#endif
X#include <float.h>
X#include <sys/types.h>
X#include <sys/timeb.h>
X#include <stdlib.h>
X#include "fractint.h"
X#include "fractype.h"
X#include "mpmath.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic long   _fastcall fudgetolong(double d);
Xstatic double _fastcall fudgetodouble(long l);
Xstatic void   _fastcall adjust_to_limits(double);
Xstatic void   _fastcall smallest_add(double *);
Xstatic int    _fastcall ratio_bad(double,double);
Xstatic void   _fastcall plotdorbit(double,double,int);
Xstatic int    _fastcall combine_worklist(void);
X
X
Xextern int    calc_status;        /* status of calculations */
Xextern char far *resume_info;        /* pointer to resume info if allocated */
X       int    resume_len;        /* length of resume info */
Xstatic int    resume_offset;        /* offset in resume info gets */
Xextern double plotmx1,plotmx2,plotmy1,plotmy2; /* real->screen conversion */
Xextern int    orbit_ptr;        /* pointer into save_orbit array */
Xextern int orbit_delay;         /* orbit delay value */
Xextern int far *save_orbit;        /* array to save orbit values */
Xextern int    orbit_color;        /* XOR color */
Xextern int    num_worklist;        /* resume worklist for standard engine */
Xextern int    fractype;         /* fractal type */
Xextern char   stdcalcmode;        /* '1', '2', 'g', 'b'       */
Xextern char   floatflag;        /* floating-point fractals? */
Xextern int    integerfractal;        /* TRUE if fractal uses integer math */
Xextern struct workliststuff worklist[MAXCALCWORK];
Xextern int    sxdots,sydots;        /* # of dots on the physical screen    */
Xextern int    sxoffs,syoffs;        /* physical top left of logical screen */
Xextern int    xdots, ydots;        /* # of dots on the logical screen     */
Xextern int    colors;            /* maximum colors available */
Xextern long   fudge;            /* fudge factor (2**n) */
Xextern int    bitshift;         /* bit shift for fudge */
Xextern int    inside;            /* inside color: 1=blue     */
Xextern int    outside;            /* outside color    */
Xextern double xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* corners */
Xextern long   xmin, xmax, ymin, ymax, x3rd, y3rd;  /* integer equivs */
Xextern int    maxit;            /* try this many iterations */
Xextern int    attractors;        /* number of finite attractors    */
Xextern _CMPLX  attr[];        /* finite attractor vals (f.p)    */
Xextern _LCMPLX lattr[];     /* finite attractor vals (int)    */
Xextern int    attrperiod[];         /* finite attractor period    */
Xextern _CMPLX  old,new;
Xextern _LCMPLX lold,lnew;
Xextern double tempsqrx,tempsqry;
Xextern long   ltempsqrx,ltempsqry;
Xextern int    xxstart,xxstop;        /* these are same as worklist, */
Xextern int    yystart,yystop,yybegin;    /* declared as separate items  */
Xextern int    periodicitycheck;
Xextern int    basin;
Xextern int    finattract;
Xextern int    pixelpi;            /* value of pi in pixels */
Xextern double closenuff;
Xextern long   lclosenuff;
Xextern int    ixstart, ixstop, iystart, iystop;
Xextern int    color;
Xextern int    decomp[];
Xextern double potparam[3];        /* three potential parameters*/
Xextern int    distest;            /* non-zero if distance estimator */
Xextern double param[];          /* parameters */
Xextern int    invert;            /* non-zero if inversion active */
Xextern int    biomorph,usr_biomorph;
Xextern int    debugflag; /* internal use only - you didn't see this */
Xextern long   creal, cimag;        /* for calcmand */
Xextern long   delx, dely;        /* screen pixel increments  */
Xextern long   delx2, dely2;        /* screen pixel increments  */
Xextern double delxx, delyy;        /* screen pixel increments  */
Xextern double delxx2, delyy2;        /* screen pixel increments  */
Xextern long   delmin;            /* for calcfrac/calcmand    */
Xextern double ddelmin;            /* same as a double        */
Xextern int    potflag;            /* continuous potential flag */
Xextern int    bailout;
Xextern double rqlim;
Xextern double  dxsize, dysize;        /* xdots-1, ydots-1        */
Xextern int soundflag;
Xextern int basehertz;
X
Xextern long   far *lx0, far *ly0;    /* x, y grid            */
Xextern long   far *lx1, far *ly1;    /* adjustment for rotate    */
X/* note that lx1 & ly1 values can overflow into sign bit; since     */
X/* they're used only to add to lx0/ly0, 2s comp straightens it out  */
Xextern double far *dx0, far *dy0;    /* floating pt equivs */
Xextern double far *dx1, far *dy1;
X
Xextern char   usr_floatflag;
Xextern char   usr_stdcalcmode;
Xextern int    usr_periodicitycheck;
Xextern int    usr_distest;
Xextern double zwidth;
X
Xextern int neworbittype;
X
X#define FUDGEFACTOR    29    /* fudge all values up by 2**this */
X#define FUDGEFACTOR2    24    /* (or maybe this)          */
X
X
Xvoid calcfracinit() /* initialize a *pile* of stuff for fractal calculation */
X{
X   int i;
X   double ftemp;
X
X   floatflag = usr_floatflag;
X   if (calc_status == 2) /* on resume, ensure floatflag correct */
X      if (curfractalspecific->isinteger)
X     floatflag = 0;
X      else
X     floatflag = 1;
X   /* if floating pt only, set floatflag for TAB screen */
X   if (!curfractalspecific->isinteger && curfractalspecific->tofloat == NOFRACTAL)
X      floatflag = 1;
X
Xinit_restart:
X
X   /* the following variables may be forced to a different setting due to
X      calc routine constraints;  usr_xxx is what the user last said is wanted,
X      xxx is what we actually do in the current situation */
X   stdcalcmode        = usr_stdcalcmode;
X   periodicitycheck = usr_periodicitycheck;
X   distest        = usr_distest;
X   biomorph        = usr_biomorph;
X
X   potflag = 0;
X   if (potparam[0] != 0.0
X     && colors >= 64
X     && (curfractalspecific->calctype == StandardFractal
X     || curfractalspecific->calctype == calcmand
X     || curfractalspecific->calctype == calcmandfp)) {
X      potflag = 1;
X      distest = 0;    /* can't do distest too */
X      }
X
X   if (distest)
X      floatflag = 1;  /* force floating point for dist est */
X
X   if (floatflag) { /* ensure type matches floatflag */
X      if (curfractalspecific->isinteger != 0
X    && curfractalspecific->tofloat != NOFRACTAL)
X     fractype = curfractalspecific->tofloat;
X      }
X   else {
X      if (curfractalspecific->isinteger == 0
X    && curfractalspecific->tofloat != NOFRACTAL)
X     fractype = curfractalspecific->tofloat;
X      }
X   /* match Julibrot with integer mode of orbit */
X   if(fractype == JULIBROTFP && fractalspecific[neworbittype].isinteger)
X   {
X      int i;
X      if((i=fractalspecific[neworbittype].tofloat) != NOFRACTAL)
X         neworbittype = i;
X      else
X         fractype = JULIBROT;
X   }
X   else if(fractype == JULIBROT && fractalspecific[neworbittype].isinteger==0)
X   {
X      int i;
X      if((i=fractalspecific[neworbittype].tofloat) != NOFRACTAL)
X         neworbittype = i;
X      else
X         fractype = JULIBROTFP;
X   }
X
X   curfractalspecific = &fractalspecific[fractype];
X
X   integerfractal = curfractalspecific->isinteger;
X
X/*   if (fractype == JULIBROT)
X      rqlim = 4;
X   else */ if (potflag && potparam[2] != 0.0)
X      rqlim = potparam[2];
X/* else if (decomp[0] > 0 && decomp[1] > 0)
X      rqlim = (double)decomp[1]; */
X   else if (bailout) /* user input bailout */
X      rqlim = bailout;
X   else if (biomorph != -1) /* biomorph benefits from larger bailout */
X      rqlim = 100;
X   else
X      rqlim = curfractalspecific->orbit_bailout;
X   if (integerfractal) /* the bailout limit mustn't be too high here */
X      if (rqlim > 127.0) rqlim = 127.0;
X
X   if ((curfractalspecific->flags&NOROTATE) != 0) {
X      /* ensure min<max and unrotated rectangle */
X      if (xxmin > xxmax) { ftemp = xxmax; xxmax = xxmin; xxmin = ftemp; }
X      if (yymin > yymax) { ftemp = yymax; yymax = yymin; yymin = ftemp; }
X      xx3rd = xxmin; yy3rd = yymin;
X      }
X
X   /* set up bitshift for integer math */
X   bitshift = FUDGEFACTOR2; /* by default, the smaller shift */
X   if (integerfractal > 1)  /* use specific override from table */
X      bitshift = integerfractal;
X   if (integerfractal == 0) /* float? */
X      if ((i = curfractalspecific->tofloat) != NOFRACTAL) /* -> int? */
X     if (fractalspecific[i].isinteger > 1) /* specific shift? */
X        bitshift = fractalspecific[i].isinteger;
X
X/* We want this code if we're using the assembler calcmand */
X   if (fractype == MANDEL || fractype == JULIA) { /* adust shift bits if.. */
X      if (potflag == 0                  /* not using potential */
X    && (param[0] > -2.0 && param[0] < 2.0)  /* parameters not too large */
X    && (param[1] > -2.0 && param[1] < 2.0)
X    && !invert                  /* and not inverting */
X    && biomorph == -1              /* and not biomorphing */
X    && rqlim <= 4.0               /* and bailout not too high */
X    && (outside > -2 || outside < -5)      /* and no funny outside stuff */
X    && debugflag != 1234)              /* and not debugging */
X     bitshift = FUDGEFACTOR;          /* use the larger bitshift */
X      }
X
X   fudge = 1L << bitshift;
X
X   l_at_rad = fudge/32768L;
X   f_at_rad = 1.0/32768L;
X
X   /* now setup arrays of real coordinates corresponding to each pixel */
X
X   adjust_to_limits(1.0); /* make sure all corners in valid range */
X
X   delxx  = (xxmax - xx3rd) / dxsize; /* calculate stepsizes */
X   delyy  = (yymax - yy3rd) / dysize;
X   delxx2 = (xx3rd - xxmin) / dysize;
X   delyy2 = (yy3rd - yymin) / dxsize;
X
X  if(fractype != CELLULAR) { /* fudgetolong fails w >10 digits in double */
X   creal = fudgetolong(param[0]); /* integer equivs for it all */
X   cimag = fudgetolong(param[1]);
X   xmin  = fudgetolong(xxmin);
X   xmax  = fudgetolong(xxmax);
X   x3rd  = fudgetolong(xx3rd);
X   ymin  = fudgetolong(yymin);
X   ymax  = fudgetolong(yymax);
X   y3rd  = fudgetolong(yy3rd);
X   delx  = fudgetolong(delxx);
X   dely  = fudgetolong(delyy);
X   delx2 = fudgetolong(delxx2);
X   dely2 = fudgetolong(delyy2);
X  }
X
X   if (fractype != PLASMA) { /* skip this if plasma to avoid 3d problems */
X      if (integerfractal && !invert) {
X     if (    (delx  == 0 && delxx  != 0.0)
X         || (delx2 == 0 && delxx2 != 0.0)
X         || (dely  == 0 && delyy  != 0.0)
X         || (dely2 == 0 && delyy2 != 0.0) )
X        goto expand_retry;
X     lx0[0] = xmin;         /* fill up the x, y grids */
X     ly0[0] = ymax;
X     lx1[0] = ly1[0] = 0;
X     for (i = 1; i < xdots; i++ ) {
X        lx0[i] = lx0[i-1] + delx;
X        ly1[i] = ly1[i-1] - dely2;
X        }
X     for (i = 1; i < ydots; i++ ) {
X        ly0[i] = ly0[i-1] - dely;
X        lx1[i] = lx1[i-1] + delx2;
X        }
X     /* past max res?  check corners within 10% of expected */
X     if (    ratio_bad((double)lx0[xdots-1]-xmin,(double)xmax-x3rd)
X         || ratio_bad((double)ly0[ydots-1]-ymax,(double)y3rd-ymax)
X         || ratio_bad((double)lx1[(ydots>>1)-1],((double)x3rd-xmin)/2)
X         || ratio_bad((double)ly1[(xdots>>1)-1],((double)ymin-y3rd)/2) ) {
Xexpand_retry:
X        if (integerfractal        /* integer fractal type? */
X          && curfractalspecific->tofloat != NOFRACTAL)
X           floatflag = 1;        /* switch to floating pt */
X        else
X           adjust_to_limits(2.0);    /* double the size */
X        if (calc_status == 2)    /* due to restore of an old file? */
X           calc_status = 0;     /*   whatever, it isn't resumable */
X        goto init_restart;
X        }
X     /* re-set corners to match reality */
X     xmax = lx0[xdots-1] + lx1[ydots-1];
X     ymin = ly0[ydots-1] + ly1[xdots-1];
X     x3rd = xmin + lx1[ydots-1];
X     y3rd = ly0[ydots-1];
X     xxmin = fudgetodouble(xmin);
X     xxmax = fudgetodouble(xmax);
X     xx3rd = fudgetodouble(x3rd);
X     yymin = fudgetodouble(ymin);
X     yymax = fudgetodouble(ymax);
X     yy3rd = fudgetodouble(y3rd);
X     }
X      else {
X     /* set up dx0 and dy0 analogs of lx0 and ly0 */
X     /* put fractal parameters in doubles */
X     dx0[0] = xxmin;        /* fill up the x, y grids */
X     dy0[0] = yymax;
X     dx1[0] = dy1[0] = 0;
X     for (i = 1; i < xdots; i++ ) {
X        dx0[i] = dx0[i-1] + delxx;
X        dy1[i] = dy1[i-1] - delyy2;
X        }
X     for (i = 1; i < ydots; i++ ) {
X        dy0[i] = dy0[i-1] - delyy;
X        dx1[i] = dx1[i-1] + delxx2;
X        }
X     if (    ratio_bad(dx0[xdots-1]-xxmin,xxmax-xx3rd)
X         || ratio_bad(dy0[ydots-1]-yymax,yy3rd-yymax)
X         || ratio_bad(dx1[ydots-1],xx3rd-xxmin)
X         || ratio_bad(dy1[xdots-1],yymin-yy3rd))
X        goto expand_retry;
X     /* re-set corners to match reality */
X     xxmax = dx0[xdots-1] + dx1[ydots-1];
X     yymin = dy0[ydots-1] + dy1[xdots-1];
X     xx3rd = xxmin + dx1[ydots-1];
X     yy3rd = dy0[ydots-1];
X     }
X      }
X
X   /* for periodicity close-enough, and for unity: */
X   /*      min(max(delx,delx2),max(dely,dely2)       */
X   ddelmin = fabs(delxx);
X   if (fabs(delxx2) > ddelmin)
X      ddelmin = fabs(delxx2);
X   if (fabs(delyy) > fabs(delyy2)) {
X      if (fabs(delyy) < ddelmin)
X     ddelmin = fabs(delyy);
X      }
X   else
X      if (fabs(delyy2) < ddelmin)
X     ddelmin = fabs(delyy2);
X   delmin = fudgetolong(ddelmin);
X
X   /* calculate factors which plot real values to screen co-ords */
X   /* calcfrac.c plot_orbit routines have comments about this     */
X   ftemp = (0.0-delyy2) * delxx2 * dxsize * dysize
X       - (xxmax-xx3rd) * (yy3rd-yymax);
X   plotmx1 = delxx2 * dxsize * dysize / ftemp;
X   plotmx2 = (yy3rd-yymax) * dxsize / ftemp;
X   plotmy1 = (0.0-delyy2) * dxsize * dysize / ftemp;
X   plotmy2 = (xxmax-xx3rd) * dysize / ftemp;
X
X}
X
Xstatic long _fastcall fudgetolong(double d)
X{
X   if ((d *= fudge) > 0) d += 0.5;
X   else          d -= 0.5;
X   return (long)d;
X}
X
Xstatic double _fastcall fudgetodouble(long l)
X{
X   char buf[30];
X   double d;
X   sprintf(buf,"%.9g",(double)l / fudge);
X#ifndef XFRACT
X   sscanf(buf,"%lg",&d);
X#else
X   sscanf(buf,"%lf",&d);
X#endif
X   return d;
X}
X
X
Xvoid adjust_corner()
X{
X   /* make edges very near vert/horiz exact, to ditch rounding errs and */
X   /* to avoid problems when delta per axis makes too large a ratio    */
X   double ftemp,ftemp2;
X   if( (ftemp=fabs(xx3rd-xxmin)) < (ftemp2=fabs(xxmax-xx3rd)) ) {
X      if (ftemp*10000 < ftemp2 && yy3rd != yymax)
X     xx3rd = xxmin;
X      }
X   else if (ftemp2*10000 < ftemp && yy3rd != yymin)
X      xx3rd = xxmax;
X   if( (ftemp=fabs(yy3rd-yymin)) < (ftemp2=fabs(yymax-yy3rd)) ) {
X      if (ftemp*10000 < ftemp2 && xx3rd != xxmax)
X     yy3rd = yymin;
X      }
X   else if (ftemp2*10000 < ftemp && xx3rd != xxmin)
X      yy3rd = yymax;
X}
X
Xstatic void _fastcall adjust_to_limits(double expand)
X{  double cornerx[4],cornery[4];
X   double lowx,highx,lowy,highy,limit,ftemp;
X   double centerx,centery,adjx,adjy;
X   int i;
X   limit = 32767.99;
X   if (bitshift >= 24) limit = 31.99;
X   if (bitshift >= 29) limit = 3.99;
X   centerx = (xxmin+xxmax)/2;
X   centery = (yymin+yymax)/2;
X   if (xxmin == centerx) { /* ohoh, infinitely thin, fix it */
X      smallest_add(&xxmax);
X      xxmin -= xxmax-centerx;
X      }
X   if (yymin == centery) {
X      smallest_add(&yymax);
X      yymin -= yymax-centery;
X      }
X   if (xx3rd == centerx)
X      smallest_add(&xx3rd);
X   if (yy3rd == centery)
X      smallest_add(&yy3rd);
X   /* setup array for easier manipulation */
X   cornerx[0] = xxmin; cornerx[1] = xxmax;
X   cornerx[2] = xx3rd; cornerx[3] = xxmin+(xxmax-xx3rd);
X   cornery[0] = yymax; cornery[1] = yymin;
X   cornery[2] = yy3rd; cornery[3] = yymin+(yymax-yy3rd);
X   /* if caller wants image size adjusted, do that first */
X   if (expand != 1.0)
X      for (i=0; i<4; ++i) {
X     cornerx[i] = centerx + (cornerx[i]-centerx)*expand;
X     cornery[i] = centery + (cornery[i]-centery)*expand;
X      }
X   /* get min/max x/y values */
X   lowx = highx = cornerx[0];
X   lowy = highy = cornery[0];
X   for (i=1; i<4; ++i) {
X      if (cornerx[i] < lowx)  lowx  = cornerx[i];
X      if (cornerx[i] > highx) highx = cornerx[i];
X      if (cornery[i] < lowy)  lowy  = cornery[i];
X      if (cornery[i] > highy) highy = cornery[i];
X      }
X   /* if image is too large, downsize it maintaining center */
X   ftemp = highx-lowx;
X   if (highy-lowy > ftemp) ftemp = highy-lowy;
X   if ((ftemp = limit*2/ftemp) < 1.0)
X      for (i=0; i<4; ++i) {
X     cornerx[i] = centerx + (cornerx[i]-centerx)*ftemp;
X     cornery[i] = centery + (cornery[i]-centery)*ftemp;
X     }
X   /* if any corner has x or y past limit, move the image */
X   adjx = adjy = 0;
X   for (i=0; i<4; ++i) {
X      if (cornerx[i] > limit     && (ftemp = cornerx[i] - limit) > adjx)
X     adjx = ftemp;
X      if (cornerx[i] < 0.0-limit && (ftemp = cornerx[i] + limit) < adjx)
X     adjx = ftemp;
X      if (cornery[i] > limit     && (ftemp = cornery[i] - limit) > adjy)
X     adjy = ftemp;
X      if (cornery[i] < 0.0-limit && (ftemp = cornery[i] + limit) < adjy)
X     adjy = ftemp;
X      }
X   if (calc_status == 2 && (adjx != 0 || adjy != 0) && (zwidth == 1.0))
X      calc_status = 0;
X   xxmin = cornerx[0] - adjx;
X   xxmax = cornerx[1] - adjx;
X   xx3rd = cornerx[2] - adjx;
X   yymax = cornery[0] - adjy;
X   yymin = cornery[1] - adjy;
X   yy3rd = cornery[2] - adjy;
X   adjust_corner(); /* make 3rd corner exact if very near other co-ords */
X}
X
Xstatic void _fastcall smallest_add(double *num)
X{
X   *num += *num * 5.0e-16;
X}
X
Xstatic int _fastcall ratio_bad(double actual, double desired)
X{  double ftemp;
X   if (desired != 0)
X      if ((ftemp = actual / desired) < 0.95 || ftemp > 1.05)
X     return(1);
X   return(0);
X}
X
X
X/* Save/resume stuff:
X
X   Engines which aren't resumable can simply ignore all this.
X
X   Before calling the (per_image,calctype) routines (engine), calcfract sets:
X      "resuming" to 0 if new image, nonzero if resuming a partially done image
X      "calc_status" to 1
X   If an engine is interrupted and wants to be able to resume it must:
X      store whatever status info it needs to be able to resume later
X      set calc_status to 2 and return
X   If subsequently called with resuming!=0, the engine must restore status
X   info and continue from where it left off.
X
X   Since the info required for resume can get rather large for some types,
X   it is not stored directly in save_info.  Instead, memory is dynamically
X   allocated as required, and stored in .fra files as a separate block.
X   To save info for later resume, an engine routine can use:
X      alloc_resume(maxsize,version)
X     Maxsize must be >= max bytes subsequently saved + 2; over-allocation
X     is harmless except for possibility of insufficient mem available;
X     undersize is not checked and probably causes serious misbehaviour.
X     Version is an arbitrary number so that subsequent revisions of the
X     engine can be made backward compatible.
X     Alloc_resume sets calc_status to 2 (resumable) if it succeeds; to 3
X     if it cannot allocate memory (and issues warning to user).
X      put_resume({bytes,&argument,} ... 0)
X     Can be called as often as required to store the info.
X     Arguments must not be far addresses.
X     Is not protected against calls which use more space than allocated.
X   To reload info when resuming, use:
X      start_resume()
X     initializes and returns version number
X      get_resume({bytes,&argument,} ... 0)
X     inverse of store_resume
X      end_resume()
X     optional, frees the memory area sooner than would happen otherwise
X
X   Example, save info:
X      alloc_resume(sizeof(parmarray)+100,2);
X      put_resume(sizeof(int),&row, sizeof(int),&col,
X         sizeof(parmarray),parmarray, 0);
X    restore info:
X      vsn = start_resume();
X      get_resume(sizeof(int),&row, sizeof(int),&col, 0);
X      if (vsn >= 2)
X     get_resume(sizeof(parmarray),parmarray,0);
X      end_resume();
X
X   Engines which allocate a large far memory chunk of their own might
X   directly set resume_info, resume_len, calc_status to avoid doubling
X   transient memory needs by using these routines.
X
X   StandardFractal, calcmand, solidguess, and bound_trace_main are a related
X   set of engines for escape-time fractals.  They use a common worklist
X   structure for save/resume.  Fractals using these must specify calcmand
X   or StandardFractal as the engine in fractalspecificinfo.
X   Other engines don't get btm nor ssg, don't get off-axis symmetry nor
X   panning (the worklist stuff), and are on their own for save/resume.
X
X   */
X
X#ifndef XFRACT
Xint put_resume(int len, ...)
X#else
Xint put_resume(va_alist)
Xva_dcl
X#endif
X{
X   va_list arg_marker;    /* variable arg list */
X   char *source_ptr;
X#ifdef XFRACT
X   int len;
X#endif
X
X   if (resume_info == NULL)
X      return(-1);
X#ifndef XFRACT
X   va_start(arg_marker,len);
X#else
X   va_start(arg_marker);
X   len = va_arg(arg_marker,int);
X#endif
X   while (len)
X   {
X      source_ptr = va_arg(arg_marker,char *);
X      far_memcpy(resume_info+resume_len,source_ptr,len);
X      resume_len += len;
X      len = va_arg(arg_marker,int);
X   }
X   return(0);
X}
X
Xint alloc_resume(int alloclen, int version)
X{
X   if (resume_info != NULL) /* free the prior area if there is one */
X      farmemfree(resume_info);
X   if ((resume_info = farmemalloc((long)alloclen))== NULL)
X   {
X      static char msg[] = {"\
XWarning - insufficient free memory to save status.\n\
XYou will not be able to resume calculating this image."};
X      stopmsg(0,msg);
X      calc_status = 3;
X      return(-1);
X   }
X   resume_len = 0;
X   put_resume(sizeof(int),&version,0);
X   calc_status = 2;
X   return(0);
X}
X
X#ifndef XFRACT
Xint get_resume(int len, ...)
X#else
Xint get_resume(va_alist)
Xva_dcl
X#endif
X{
X   va_list arg_marker;    /* variable arg list */
X   char *dest_ptr;
X#ifdef XFRACT
X   int len;
X#endif
X
X   if (resume_info == NULL)
X      return(-1);
X#ifndef XFRACT
X   va_start(arg_marker,len);
X#else
X   va_start(arg_marker);
X   len = va_arg(arg_marker,int);
X#endif
X   while (len)
X   {
X      dest_ptr = va_arg(arg_marker,char *);
X      far_memcpy(dest_ptr,resume_info+resume_offset,len);
X      resume_offset += len;
X      len = va_arg(arg_marker,int);
X   }
X   return(0);
X}
X
Xint start_resume()
X{
X   int version;
X   if (resume_info == NULL)
X      return(-1);
X   resume_offset = 0;
X   get_resume(sizeof(int),&version,0);
X   return(version);
X}
X
Xvoid end_resume()
X{
X   if (resume_info != NULL) /* free the prior area if there is one */
X   {
X      farmemfree(resume_info);
X      resume_info = NULL;
X   }
X}
X
X
X/* Showing orbit requires converting real co-ords to screen co-ords.
X   Define:
X       Xs == xxmax-xx3rd           Ys == yy3rd-yymax
X       W  == xdots-1               D  == ydots-1
X   We know that:
X       realx == lx0[col] + lx1[row]
X       realy == ly0[row] + ly1[col]
X       lx0[col] == (col/width) * Xs + xxmin
X       lx1[row] == row * delxx
X       ly0[row] == (row/D) * Ys + yymax
X       ly1[col] == col * (0-delyy)
X  so:
X       realx == (col/W) * Xs + xxmin + row * delxx
X       realy == (row/D) * Ys + yymax + col * (0-delyy)
X  and therefore:
X       row == (realx-xxmin - (col/W)*Xs) / Xv     (1)
X       col == (realy-yymax - (row/D)*Ys) / Yv     (2)
X  substitute (2) into (1) and solve for row:
X       row == ((realx-xxmin)*(0-delyy2)*W*D - (realy-yymax)*Xs*D)
X              / ((0-delyy2)*W*delxx2*D-Ys*Xs)
X  */
X
X/* sleep N * a tenth of a millisecond */
X
Xvoid sleepms(long ms)
X{
X    extern int tabmode;
X    static long scalems=0L;
X    int savehelpmode,savetabmode;
X    struct timeb t1,t2;
X#define SLEEPINIT 250 /* milliseconds for calibration */
X    savetabmode  = tabmode;
X    savehelpmode = helpmode;
X    tabmode  = 0;
X    helpmode = -1;
X    if(scalems==0L) /* calibrate */
X    {
X    /* selects a value of scalems that makes the units
X       10000 per sec independent of CPU speed */
X    char msg[80];
X    long millisecs;
X    int i,elapsed;
X
X    scalems = 1L;
X    if(keypressed()) /* check at start, hope to get start of timeslice */
X       goto sleepexit;
X    /* calibrate, assume slow computer first */
X    do
X    {
X       scalems *= 2;
X       ftime(&t2);
X       do { /* wait for the start of a new tick */
X          ftime(&t1);
X        }
X        while (t2.time == t1.time && t2.millitm == t1.millitm);
X       sleepms(10L * SLEEPINIT); /* about 1/4 sec */
X       ftime(&t2);
X       if(keypressed()) {
X          scalems = 0L;
X          goto sleepexit;
X       }
X     }
X     while ((elapsed = (int)(t2.time-t1.time)*1000 + t2.millitm-t1.millitm)
X        < SLEEPINIT);
X    /* once more to see if faster (eg multi-tasking) */
X    do { /* wait for the start of a new tick */
X       ftime(&t1);
X       }
X     while (t2.time == t1.time && t2.millitm == t1.millitm);
X    sleepms(10L * SLEEPINIT);
X    ftime(&t2);
X    if ((i = (int)(t2.time-t1.time)*1000 + t2.millitm-t1.millitm) < elapsed)
X       elapsed = (i == 0) ? 1 : i;
X    scalems = (float)SLEEPINIT/(float)(elapsed) * scalems;
X    if (debugflag == 700) {
X       sprintf(msg,"scale factor=%ld",scalems);
X       stopmsg(0,msg);
X    }
X    }
X    if(ms > 10L * SLEEPINIT) { /* using ftime is probably more accurate */
X    ms /= 10;
X    ftime(&t1);
X    while(1) {
X       if(keypressed()) break;
X       ftime(&t2);
X       if ((t2.time-t1.time)*1000 + t2.millitm-t1.millitm >= ms) break;
X    }
X    }
X    else
X    if(!keypressed()) {
X       ms *= scalems;
X       while(ms-- >= 0);
X    }
Xsleepexit:
X    tabmode  = savetabmode;
X    helpmode = savehelpmode;
X}
X
X
Xstatic void _fastcall plotdorbit(double dx, double dy, int color)
X{
X   int i, j, c;
X   int save_sxoffs,save_syoffs;
X   if (orbit_ptr >= 1500) return;
X   i = dy * plotmx1 - dx * plotmx2; i += sxoffs;
X   if (i < 0 || i >= sxdots) return;
X   j = dx * plotmy1 - dy * plotmy2; j += syoffs;
X   if (j < 0 || j >= sydots) return;
X   save_sxoffs = sxoffs;
X   save_syoffs = syoffs;
X   sxoffs = syoffs = 0;
X   /* save orbit value */
X   if(color == -1)
X   {
X      *(save_orbit + orbit_ptr++) = i;
X      *(save_orbit + orbit_ptr++) = j;
X      *(save_orbit + orbit_ptr++) = c = getcolor(i,j);
X      putcolor(i,j,c^orbit_color);
X   }
X   else
X      putcolor(i,j,color);
X   sxoffs = save_sxoffs;
X   syoffs = save_syoffs;
X   if(orbit_delay > 0)
X      sleepms(orbit_delay);
X   if(soundflag==1)
X       snd((int)(i*1000/xdots+basehertz));
X   else if(soundflag > 1)
X       snd((int)(j*1000/ydots+basehertz));
X   /* placing sleepms here delays each dot */
X}
X
Xvoid iplot_orbit(ix, iy, color)
Xlong ix, iy;
Xint color;
X{
X   plotdorbit((double)ix/fudge-xxmin,(double)iy/fudge-yymax,color);
X}
X
Xvoid plot_orbit(real,imag,color)
Xdouble real,imag;
Xint color;
X{
X   plotdorbit(real-xxmin,imag-yymax,color);
X}
X
Xvoid scrub_orbit()
X{
X   static long oldtime = 0;
X   int i,j,c;
X   int save_sxoffs,save_syoffs;
X   save_sxoffs = sxoffs;
X   save_syoffs = syoffs;
X   sxoffs = syoffs = 0;
X   while(orbit_ptr > 0)
X   {
X      c = *(save_orbit + --orbit_ptr);
X      j = *(save_orbit + --orbit_ptr);
X      i = *(save_orbit + --orbit_ptr);
X      putcolor(i,j,c);
X   }
X   sxoffs = save_sxoffs;
X   syoffs = save_syoffs;
X   nosnd();
X}
X
X
Xint add_worklist(int xfrom, int xto, int yfrom, int yto, int ybegin,
Xint pass, int sym)
X{
X   if (num_worklist >= MAXCALCWORK)
X      return(-1);
X   worklist[num_worklist].xxstart = xfrom;
X   worklist[num_worklist].xxstop  = xto;
X   worklist[num_worklist].yystart = yfrom;
X   worklist[num_worklist].yystop  = yto;
X   worklist[num_worklist].yybegin = ybegin;
X   worklist[num_worklist].pass      = pass;
X   worklist[num_worklist].sym      = sym;
X   ++num_worklist;
X   tidy_worklist();
X   return(0);
X}
X
Xstatic int _fastcall combine_worklist() /* look for 2 entries which can freely merge */
X{
X   int i,j;
X   for (i=0; i<num_worklist; ++i)
X      if (worklist[i].yystart == worklist[i].yybegin)
X     for (j=i+1; j<num_worklist; ++j)
X        if (worklist[j].sym == worklist[i].sym
X        && worklist[j].yystart == worklist[j].yybegin
X        && worklist[i].pass == worklist[j].pass)
X        {
X           if ( worklist[i].xxstart == worklist[j].xxstart
X           && worklist[i].xxstop  == worklist[j].xxstop)
X           {
X          if (worklist[i].yystop+1 == worklist[j].yystart)
X          {
X             worklist[i].yystop = worklist[j].yystop;
X             return(j);
X          }
X          if (worklist[j].yystop+1 == worklist[i].yystart)
X          {
X             worklist[i].yystart = worklist[j].yystart;
X             worklist[i].yybegin = worklist[j].yybegin;
X             return(j);
X          }
X           }
X           if ( worklist[i].yystart == worklist[j].yystart
X           && worklist[i].yystop  == worklist[j].yystop)
X           {
X          if (worklist[i].xxstop+1 == worklist[j].xxstart)
X          {
X             worklist[i].xxstop = worklist[j].xxstop;
X             return(j);
X          }
X          if (worklist[j].xxstop+1 == worklist[i].xxstart)
X          {
X             worklist[i].xxstart = worklist[j].xxstart;
X             return(j);
X          }
X           }
X        }
X   return(0); /* nothing combined */
X}
X
Xvoid tidy_worklist() /* combine mergeable entries, resort */
X{
X   int i,j;
X   struct workliststuff tempwork;
X   while (i=combine_worklist())
X   { /* merged two, delete the gone one */
X      while (++i < num_worklist)
X     worklist[i-1] = worklist[i];
X      --num_worklist;
X   }
X   for (i=0; i<num_worklist; ++i)
X      for (j=i+1; j<num_worklist; ++j)
X     if (worklist[j].pass < worklist[i].pass
X         || (worklist[j].pass == worklist[i].pass
X         && (worklist[j].yystart < worklist[i].yystart
X         || (   worklist[j].yystart == worklist[i].yystart
X         && worklist[j].xxstart <  worklist[i].xxstart))))
X     { /* dumb sort, swap 2 entries to correct order */
X        tempwork = worklist[i];
X        worklist[i] = worklist[j];
X        worklist[j] = tempwork;
X     }
X}
X
X
Xvoid get_julia_attractor (double real, double imag)
X{
X   _LCMPLX lresult;
X   _CMPLX result;
X   int savper,savmaxit;
X   int i;
X
X   if (attractors == 0 && finattract == 0) /* not magnet & not requested */
X      return;
X
X   if (attractors >= N_ATTR)     /* space for more attractors ?  */
X      return;               /* Bad luck - no room left !    */
X
X   savper = periodicitycheck;
X   savmaxit = maxit;
X   periodicitycheck = 0;
X   old.x = real;            /* prepare for f.p orbit calc */
X   old.y = imag;
X   tempsqrx = sqr(old.x);
X   tempsqry = sqr(old.y);
X
X   lold.x = real;        /* prepare for int orbit calc */
X   lold.y = imag;
X   ltempsqrx = tempsqrx;
X   ltempsqry = tempsqry;
X
X   lold.x = lold.x << bitshift;
X   lold.y = lold.y << bitshift;
X   ltempsqrx = ltempsqrx << bitshift;
X   ltempsqry = ltempsqry << bitshift;
X
X   if (maxit < 500)        /* we're going to try at least this hard */
X      maxit = 500;
X   color = 0;
X   while (++color < maxit)
X      if(curfractalspecific->orbitcalc())
X     break;
X   if (color >= maxit)        /* if orbit stays in the lake */
X   {
X      if (integerfractal)   /* remember where it went to */
X     lresult = lnew;
X      else
X     result =  new;
X     for (i=0;i<10;i++) {
X      if(!curfractalspecific->orbitcalc()) /* if it stays in the lake */
X      {                /* and doen't move far, probably */
X     if (integerfractal)   /*   found a finite attractor    */
X     {
X        if(labs(lresult.x-lnew.x) < lclosenuff
X        && labs(lresult.y-lnew.y) < lclosenuff)
X        {
X           lattr[attractors] = lnew;
X           attrperiod[attractors] = i+1;
X           attractors++;   /* another attractor - coloured lakes ! */
X           break;
X        }
X     }
X     else
X     {
X        if(fabs(result.x-new.x) < closenuff
X        && fabs(result.y-new.y) < closenuff)
X        {
X           attr[attractors] = new;
X           attrperiod[attractors] = i+1;
X           attractors++;   /* another attractor - coloured lakes ! */
X           break;
X        }
X     }
X      } else {
X      break;
X      }
X     }
X   }
X   if(attractors==0)
X      periodicitycheck = savper;
X   maxit = savmaxit;
X}
X
X
X#define maxyblk 7    /* must match calcfrac.c */
X#define maxxblk 202  /* must match calcfrac.c */
Xint ssg_blocksize() /* used by solidguessing and by zoom panning */
X{
X   int blocksize,i;
X   /* blocksize 4 if <300 rows, 8 if 300-599, 16 if 600-1199, 32 if >=1200 */
X   blocksize=4;
X   i=300;
X   while(i<=ydots)
X   {
X      blocksize+=blocksize;
X      i+=i;
X   }
X   /* increase blocksize if prefix array not big enough */
X   while(blocksize*(maxxblk-2)<xdots || blocksize*(maxyblk-2)*16<ydots)
X      blocksize+=blocksize;
X   return(blocksize);
X}
X
SHAR_EOF
$TOUCH -am 1028230093 fracsubr.c &&
chmod 0644 fracsubr.c ||
echo "restore of fracsubr.c failed"
set `wc -c fracsubr.c`;Wc_c=$1
if test "$Wc_c" != "30883"; then
    echo original size 30883, current size $Wc_c
fi
# ============= fractalp.c ==============
echo "x - extracting fractalp.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fractalp.c &&
X/*
X    This module consists only of the fractalspecific structure
X    and a *slew* of defines needed to get it to compile
X*/
X
X/* includes needed for fractalspecific */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include "fractint.h"
X#include "mpmath.h"
X#include "helpdefs.h"
X#include "fractype.h"
X#include "prototyp.h"
X
X/* functions defined elswhere needed for fractalspecific */
X/* moved to prototyp.h */
X
X/* parameter descriptions */
X/* Note: parameters preceded by + are integer parameters */
X
X/* for Mandelbrots */
Xstatic char realz0[] = "Real Perturbation of Z(0)";
Xstatic char imagz0[] = "Imaginary Perturbation of Z(0)";
X
X/* for Julias */
Xstatic char realparm[] = "Real Part of Parameter";
Xstatic char imagparm[] = "Imaginary Part of Parameter";
X
X/* for Newtons */
Xstatic char newtdegree[] = "+Polynomial Degree (>= 2)";
X
X/* for MarksMandel/Julia */
Xstatic char exponent[]   = "Real part of Exponent";
Xstatic char imexponent[] = "Imag part of Exponent";
X
X/* for Complex Newton */
Xstatic char realroot[]     = "Real part of Root";
Xstatic char imagroot[]     = "Imag part of Root";
Xstatic char realdegree[] = "Real part of Degree";
Xstatic char imagdegree[] = "Imag part of Degree";
X
X/* for Lorenz */
Xstatic char timestep[]       = "Time Step";
X
X/* for formula */
Xstatic char p1real[] = "Real portion of p1";
Xstatic char p2real[] = "Real portion of p2";
Xstatic char p1imag[] = "Imaginary portion of p1";
Xstatic char p2imag[] = "Imaginary portion of p2";
X
X/* trig functions */
Xstatic char recoeftrg1[] = "Real Coefficient First Function";
Xstatic char imcoeftrg1[] = "Imag Coefficient First Function";
Xstatic char recoeftrg2[] = "Real Coefficient Second Function";
Xstatic char imcoeftrg2[] = "Imag Coefficient Second Function";
X
X/* MCP 7-7-91
Xstatic char recoefsqr[] = "Real Coefficient Square Term";
Xstatic char imcoefsqr[] = "Imag Coefficient Square Term";
X*/
X
Xstatic char recoef2nd[] = "Real Coefficient Second Term";
Xstatic char imcoef2nd[] = "Imag Coefficient Second Term";
X
X/* KAM Torus */
Xstatic char kamangle[] = "Angle (radians)";
Xstatic char kamstep[] =  "Step size";
Xstatic char kamstop[] =  "Stop value";
Xstatic char pointsperorbit[] = "+Points per orbit";
X
X/* Newtbasin */
Xstatic char stripes[] = "Enter non-zero value for stripes";
X
X/* Gingerbreadman */
Xstatic char initx[] = "Initial x";
Xstatic char inity[] = "Initial y";
X
X/* popcorn */
Xstatic char step[] = "Step size";
X
X/* bifurcations */
Xstatic char filt[] = "+Filter Cycles";
Xstatic char seed[] = "Seed Population";
X
X/* frothy basins */
Xstatic char frothattractor[] = "+3 or 6 attractor system";
Xstatic char frothshade[] =  "+Enter non-zero value for alternate color shading";
X
X/* symmetrical icon fractals */
Xstatic char lambda[] = "Lambda";
Xstatic char alpha[]  = "Alpha";
Xstatic char beta[]   = "Beta";
Xstatic char gamma2[]  = "Gamma";
Xstatic char omega[]  = "Omega";
Xstatic char symdegree[] = "+Degree of symmetry";
X
Xstatic char shiftval[] = "Function Shift Value";
X
X/* ifs */
Xstatic char color_method[] = "+Coloring method (0,1)";
X
X/* orbit fractals */
Xstatic char A[] = "a";
Xstatic char B[] = "b";
Xstatic char D[] = "d";
X
X/* 4D fractals */
Xstatic char C[] = "c";
Xstatic char C1[] = "c1";
Xstatic char CI[] = "ci";
Xstatic char CJ[] = "cj";
Xstatic char CK[] = "ck";
Xstatic char ZJ[] = "zj";
Xstatic char ZK[] = "zk";
X
X/* empty string */
Xstatic char ES[] = "";
X
X/* bailout defines */
X#define FTRIGBAILOUT 2500.0
X#define LTRIGBAILOUT   64.0
X#define FROTHBAILOUT    6.0
X#define STDBAILOUT    4.0
X#define NOBAILOUT    0.0
X
Xstruct moreparams far moreparams[] =
X{
X    ICON,  omega,symdegree,ES,ES,ES,ES,0,3,0,0,0,0,
X    ICON3D,omega,symdegree,ES,ES,ES,ES,0,3,0,0,0,0,
X    HYPERCMPLXJFP,ZJ,ZK,   ES,ES,ES,ES,0,0,0,0,0,0,
X    QUATJULFP    ,ZJ,ZK,   ES,ES,ES,ES,0,0,0,0,0,0,
X    -1,      NULL,NULL,NULL,NULL,NULL,NULL,0,0,0,0,0,0
X};
X
X
Xstruct fractalspecificstuff far fractalspecific[] =
X{
X   /*
X     fractal name, parameter text strings, parameter values,
X     helptext, helpformula, flags,
X     xmin  xmax  ymin  ymax int tojulia   tomandel tofloat  symmetry
X   |------|-----|-----|-----|--|--------|---------|--------|---------|
X     orbit fnct     per_pixel fnct  per_image fnct  calctype fcnt    bailout
X   |---------------|---------------|---------------|----------------|-------|
X   */
X
X   "mandel", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MANDEL, HF_MANDEL, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 1, JULIA, NOFRACTAL, MANDELFP, XAXIS_NOPARM,
X   JuliaFractal, mandel_per_pixel,MandelSetup, StandardFractal, STDBAILOUT,
X
X   "julia", realparm, imagparm,ES,ES,0.3,0.6,0,0,
X   HT_JULIA, HF_JULIA, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, MANDEL, JULIAFP,  ORIGIN,
X   JuliaFractal, julia_per_pixel, JuliaSetup, StandardFractal, STDBAILOUT,
X
X   "*newtbasin", newtdegree,stripes, ES,ES,3,0,0,0,
X   HT_NEWTBAS, HF_NEWTBAS, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, MPNEWTBASIN,   NOSYM,
X   NewtonFractal2, otherjuliafp_per_pixel,  NewtonSetup, StandardFractal,NOBAILOUT,
X
X   "lambda",      realparm, imagparm,ES,ES,0.85,0.6,0,0,
X   HT_LAMBDA, HF_LAMBDA, WINFRAC+OKJB,
X   -1.5,  2.5, -1.5,  1.5, 1, NOFRACTAL, MANDELLAMBDA, LAMBDAFP,  NOSYM,
X   LambdaFractal,   julia_per_pixel, JulialongSetup,  StandardFractal,STDBAILOUT,
X
X   "*mandel",    realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MANDEL, HF_MANDEL, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 0, JULIAFP,   NOFRACTAL, MANDEL,  XAXIS_NOPARM,
X   JuliafpFractal,mandelfp_per_pixel, MandelfpSetup, StandardFractal, STDBAILOUT,
X
X   "*newton", newtdegree, ES, ES,ES,3,0,0,0,
X   HT_NEWT, HF_NEWT, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, MPNEWTON,    XAXIS,
X   NewtonFractal2, otherjuliafp_per_pixel,  NewtonSetup, StandardFractal,NOBAILOUT,
X
X   "*julia",     realparm, imagparm,ES,ES,0.3,0.6,0,0,
X   HT_JULIA, HF_JULIA, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, MANDELFP, JULIA,  ORIGIN,
X   JuliafpFractal, juliafp_per_pixel,  JuliafpSetup, StandardFractal,STDBAILOUT,
X
X   "plasma",      "Graininess Factor (.1 to 50, default is 2)",
X                  "+Algorithm (0 = original, 1 = new)",
X                  "+Random Seed Value (0 = Random, 1 = Reuse Last)",
X                  "+Save as Pot File? (0 = No,     1 = Yes)",
X                  2,0,0,0,
X   HT_PLASMA, HF_PLASMA, NOZOOM+NOGUESS+NOTRACE+NORESUME+WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   NULL,       NULL,   StandaloneSetup,     plasma,      NOBAILOUT,
X
X   "*mandelfn",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MANDFN, HF_MANDFN, TRIG1+WINFRAC,
X   -8.0,  8.0, -6.0,  6.0, 0, LAMBDATRIGFP,NOFRACTAL, MANDELTRIG, XYAXIS_NOPARM,
X   LambdaTrigfpFractal,othermandelfp_per_pixel,MandelTrigSetup,StandardFractal,LTRIGBAILOUT,
X
X   "*manowar",    realz0, imagz0,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_MANOWAR, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 0, MANOWARJFP, NOFRACTAL, MANOWAR,  XAXIS_NOPARM,
X   ManOWarfpFractal,mandelfp_per_pixel, MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "manowar",    realz0, imagz0,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_MANOWAR, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 1, MANOWARJ, NOFRACTAL, MANOWARFP, XAXIS_NOPARM,
X   ManOWarFractal,mandel_per_pixel, MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "test","(testpt Param #1)","(testpt param #2)","(testpt param #3)","(testpt param #4)",0,0,0,0,
X   HT_TEST, HF_TEST, 0,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   NULL,      NULL,         StandaloneSetup, test,    STDBAILOUT,
X
X   "sierpinski",  ES,ES,ES,ES,0,0,0,0,
X   HT_SIER, HF_SIER, WINFRAC,
X   -0.9,  1.7, -0.9,  1.7, 1, NOFRACTAL, NOFRACTAL, SIERPINSKIFP,   NOSYM,
X   SierpinskiFractal,long_julia_per_pixel, SierpinskiSetup,StandardFractal,127.0,
X
X   "barnsleym1",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_BARNS, HF_BARNSM1, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, BARNSLEYJ1,NOFRACTAL, BARNSLEYM1FP,  XYAXIS_NOPARM,
X   Barnsley1Fractal,long_mandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "barnsleyj1",  realparm, imagparm,ES,ES,0.6,1.1,0,0,
X   HT_BARNS, HF_BARNSJ1, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, BARNSLEYM1, BARNSLEYJ1FP,  ORIGIN,
X   Barnsley1Fractal,long_julia_per_pixel,JulialongSetup,StandardFractal,STDBAILOUT,
X
X   "barnsleym2",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_BARNS, HF_BARNSM2, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, BARNSLEYJ2,NOFRACTAL, BARNSLEYM2FP,  YAXIS_NOPARM,
X   Barnsley2Fractal,long_mandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "barnsleyj2",  realparm, imagparm,ES,ES,0.6,1.1,0,0,
X   HT_BARNS, HF_BARNSJ2, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, BARNSLEYM2, BARNSLEYJ2FP,  ORIGIN,
X   Barnsley2Fractal,long_julia_per_pixel,JulialongSetup,StandardFractal,STDBAILOUT,
X
X   "sqr(fn)", ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_SQRFN, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, NOFRACTAL, SQRTRIGFP,XAXIS,
X   SqrTrigFractal,   long_julia_per_pixel, SqrTrigSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "*sqr(fn)", ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_SQRFN, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, NOFRACTAL, SQRTRIG,XAXIS,
X   SqrTrigfpFractal,   otherjuliafp_per_pixel, SqrTrigSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "fn+fn", recoeftrg1, imcoeftrg1,recoeftrg2, imcoeftrg2,1,0,1,0,
X   HT_SCOTSKIN, HF_FNPLUSFN, TRIG2+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, NOFRACTAL, TRIGPLUSTRIGFP,XAXIS,
X   TrigPlusTrigFractal,   long_julia_per_pixel, TrigPlusTriglongSetup,    StandardFractal,LTRIGBAILOUT,
X
X   "mandellambda",realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MLAMBDA, HF_MLAMBDA, WINFRAC,
X   -3.0,  5.0, -3.0,  3.0, 1, LAMBDA,     NOFRACTAL, MANDELLAMBDAFP,  XAXIS_NOPARM,
X   LambdaFractal,mandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "marksmandel", realz0, imagz0, exponent,ES,0,0,1,0,
X   HT_MARKS, HF_MARKSMAND, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, MARKSJULIA, NOFRACTAL, MARKSMANDELFP,  NOSYM,
X   MarksLambdaFractal,marksmandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "marksjulia", realparm, imagparm, exponent,ES,0.1,0.9,0,0,
X   HT_MARKS, HF_MARKSJULIA, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, MARKSMANDEL, MARKSJULIAFP,   ORIGIN,
X   MarksLambdaFractal,julia_per_pixel,MarksJuliaSetup,StandardFractal,STDBAILOUT,
X
X   "unity", ES,ES,ES,ES,0,0,0,0,
X   HT_UNITY, HF_UNITY, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, NOFRACTAL, UNITYFP,   XYAXIS,
X   UnityFractal, long_julia_per_pixel,UnitySetup,StandardFractal,NOBAILOUT,
X
X   "mandel4", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MANDJUL4, HF_MANDEL4, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, JULIA4,      NOFRACTAL, MANDEL4FP,  XAXIS_NOPARM,
X   Mandel4Fractal,  mandel_per_pixel, MandellongSetup, StandardFractal,  STDBAILOUT,
X
X   "julia4", realparm, imagparm,ES,ES,0.6,0.55,0,0,
X   HT_MANDJUL4, HF_JULIA4, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, MANDEL4, JULIA4FP, ORIGIN,
X   Mandel4Fractal,   julia_per_pixel, JulialongSetup,StandardFractal,     STDBAILOUT,
X
X   "ifs",color_method,ES,ES,ES,0,0,0,0,
X   HT_IFS, -1, NOGUESS+NOTRACE+NORESUME+WINFRAC,
X   -8.0,  8.0, -1.0, 11.0, 16, NOFRACTAL, NOFRACTAL, NOFRACTAL,  NOSYM,
X   NULL,      NULL,      StandaloneSetup, ifs,    NOBAILOUT,
X
X   "*ifs3d",color_method,ES,ES,ES,0,0,0,0,
X   HT_IFS, -1, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -11.0,  11.0, -11.0, 11.0, 16, NOFRACTAL, NOFRACTAL, NOFRACTAL,   NOSYM,
X   NULL,      NULL,      StandaloneSetup, ifs,    NOBAILOUT,
X
X   "barnsleym3",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_BARNS, HF_BARNSM3, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, BARNSLEYJ3,NOFRACTAL, BARNSLEYM3FP,  XAXIS_NOPARM,
X   Barnsley3Fractal,long_mandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "barnsleyj3",  realparm, imagparm,ES,ES,0.1,0.36,0,0,
X   HT_BARNS, HF_BARNSJ3, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, BARNSLEYM3, BARNSLEYJ3FP,  NOSYM,
X   Barnsley3Fractal,long_julia_per_pixel,JulialongSetup,StandardFractal,STDBAILOUT,
X
X   "fn(z*z)", ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_FNZTIMESZ, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, NOFRACTAL, TRIGSQRFP,XYAXIS,
X   TrigZsqrdFractal,   julia_per_pixel, JulialongSetup,  StandardFractal,STDBAILOUT,
X
X   "*fn(z*z)", ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_FNZTIMESZ, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, NOFRACTAL, TRIGSQR,XYAXIS,
X   TrigZsqrdfpFractal,     juliafp_per_pixel, JuliafpSetup,  StandardFractal,STDBAILOUT,
X
X   "*bifurcation",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFURCATION, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   1.9,  3.0, 0,  1.34, 0, NOFRACTAL, NOFRACTAL, LBIFURCATION, NOSYM,
X   BifurcVerhulstTrig, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "*fn+fn",recoeftrg1,imcoeftrg1,recoeftrg2,imcoeftrg2,1,0,1,0,
X   HT_SCOTSKIN, HF_FNPLUSFN, TRIG2+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, NOFRACTAL, TRIGPLUSTRIG,XAXIS,
X   TrigPlusTrigfpFractal, otherjuliafp_per_pixel, TrigPlusTrigfpSetup,    StandardFractal,LTRIGBAILOUT,
X
X   "fn*fn", ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_FNTIMESFN, TRIG2+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, NOFRACTAL, TRIGXTRIGFP,XAXIS,
X   TrigXTrigFractal, long_julia_per_pixel, FnXFnSetup,    StandardFractal,LTRIGBAILOUT,
X
X   "*fn*fn", ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_FNTIMESFN, TRIG2+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, NOFRACTAL, TRIGXTRIG,XAXIS,
X   TrigXTrigfpFractal, otherjuliafp_per_pixel, FnXFnSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "sqr(1/fn)",ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_SQROVFN, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, NOFRACTAL, SQR1OVERTRIGFP,NOSYM,
X   Sqr1overTrigFractal, long_julia_per_pixel, SqrTrigSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "*sqr(1/fn)",ES,ES,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_SQROVFN, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, NOFRACTAL, SQR1OVERTRIG,NOSYM,
X   Sqr1overTrigfpFractal, otherjuliafp_per_pixel, SqrTrigSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "fn*z+z",recoeftrg1, imcoeftrg1, recoef2nd,imcoef2nd,1,0,1,0,
X   HT_SCOTSKIN, HF_FNXZPLUSZ, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 1, NOFRACTAL, NOFRACTAL, ZXTRIGPLUSZFP,XAXIS,
X   ZXTrigPlusZFractal,julia_per_pixel,ZXTrigPlusZSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "*fn*z+z",recoeftrg1, imcoeftrg2, recoef2nd,imcoef2nd,1,0,1,0,
X   HT_SCOTSKIN, HF_FNXZPLUSZ, TRIG1+WINFRAC,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, NOFRACTAL, ZXTRIGPLUSZ,XAXIS,
X   ZXTrigPlusZfpFractal,   juliafp_per_pixel, ZXTrigPlusZSetup,  StandardFractal,LTRIGBAILOUT,
X
X   "*kamtorus",kamangle,kamstep,kamstop,pointsperorbit,1.3,.05,1.5,150,
X   HT_KAM, HF_KAM, NOGUESS+NOTRACE+WINFRAC,
X   -1.0,  1.0, -.75, .75, 0, NOFRACTAL, NOFRACTAL, KAM,   NOSYM,
X   kamtorusfloatorbit, NULL, orbit3dfloatsetup, orbit2dfloat, NOBAILOUT,
X
X   "kamtorus",kamangle,kamstep,kamstop,pointsperorbit,1.3,.05,1.5,150,
X   HT_KAM, HF_KAM, NOGUESS+NOTRACE+WINFRAC,
X   -1.0,  1.0, -.75, .75,16, NOFRACTAL, NOFRACTAL, KAMFP, NOSYM,
X   kamtoruslongorbit,  NULL, orbit3dlongsetup, orbit2dlong,   NOBAILOUT,
X
X   "*kamtorus3d",kamangle,kamstep,kamstop,pointsperorbit,1.3,.05,1.5,150,
X   HT_KAM, HF_KAM, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -3.0,  3.0, -1, 3.5, 0, NOFRACTAL, NOFRACTAL, KAM3D,   NOSYM,
X   kamtorusfloatorbit, NULL, orbit3dfloatsetup, orbit3dfloat, NOBAILOUT,
X
X   "kamtorus3d",kamangle,kamstep,kamstop,pointsperorbit,1.3,.05,1.5,150,
X   HT_KAM, HF_KAM, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -3.0,  3.0, -1, 3.5,16, NOFRACTAL, NOFRACTAL, KAM3DFP, NOSYM,
X   kamtoruslongorbit,  NULL, orbit3dlongsetup, orbit3dlong,   NOBAILOUT,
X
X   "lambdafn",     realparm, imagparm,ES,ES,1.0,0.4,0,0,
X   HT_LAMBDAFN, HF_LAMBDAFN, TRIG1+WINFRAC+OKJB,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, MANDELTRIG, LAMBDATRIGFP,PI_SYM,
X   LambdaTrigFractal,long_julia_per_pixel, LambdaTrigSetup,    StandardFractal,LTRIGBAILOUT,
X
X   "manfn+zsqrd",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_PICKMJ, HF_MANDFNPLUSZSQRD, TRIG1+WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 16, LJULTRIGPLUSZSQRD,  NOFRACTAL, FPMANTRIGPLUSZSQRD, XAXIS_NOPARM,
X   TrigPlusZsquaredFractal,mandel_per_pixel,MandellongSetup,StandardFractal, STDBAILOUT,
X
X   "julfn+zsqrd",  realparm, imagparm,ES,ES,-0.5,0.5,0,0,
X   HT_PICKMJ, HF_JULFNPLUSZSQRD, TRIG1+WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 16, NOFRACTAL, LMANTRIGPLUSZSQRD, FPJULTRIGPLUSZSQRD,    NOSYM,
X   TrigPlusZsquaredFractal,julia_per_pixel, JuliafnPlusZsqrdSetup,StandardFractal, STDBAILOUT,
X
X   "*manfn+zsqrd", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_PICKMJ, HF_MANDFNPLUSZSQRD, TRIG1+WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 0, FPJULTRIGPLUSZSQRD,   NOFRACTAL, LMANTRIGPLUSZSQRD, XAXIS_NOPARM,
X   TrigPlusZsquaredfpFractal,mandelfp_per_pixel, MandelfpSetup,StandardFractal, STDBAILOUT,
X
X   "*julfn+zsqrd", realparm, imagparm,ES,ES,-0.5,0.5,0,0,
X   HT_PICKMJ, HF_JULFNPLUSZSQRD, TRIG1+WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, FPMANTRIGPLUSZSQRD, LJULTRIGPLUSZSQRD, NOSYM,
X   TrigPlusZsquaredfpFractal, juliafp_per_pixel,  JuliafnPlusZsqrdSetup,StandardFractal, STDBAILOUT,
X
X   "*lambdafn",  realparm, imagparm,ES,ES,1.0,0.4,0,0,
X   HT_LAMBDAFN, HF_LAMBDAFN, TRIG1+WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, MANDELTRIGFP, LAMBDATRIG, PI_SYM,
X   LambdaTrigfpFractal,otherjuliafp_per_pixel,LambdaTrigSetup,StandardFractal,LTRIGBAILOUT,
X
X   "mandelfn",realz0, imagz0,ES,ES, 0,0,0,0,
X   HT_MANDFN, HF_MANDFN, TRIG1+WINFRAC,
X   -8.0,  8.0, -6.0,  6.0, 16, LAMBDATRIG, NOFRACTAL, MANDELTRIGFP, XYAXIS_NOPARM,
X   LambdaTrigFractal,long_mandel_per_pixel,MandelTrigSetup,StandardFractal,LTRIGBAILOUT,
X
X   "manzpower", realz0, imagz0, exponent,imexponent,0,0,2,0,
X   HT_PICKMJ, HF_MANZPOWER, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 1, LJULIAZPOWER, NOFRACTAL, FPMANDELZPOWER,    XAXIS_NOIMAG,
X   longZpowerFractal,long_mandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "julzpower", realparm, imagparm, exponent,imexponent,0.3,0.6,2,0,
X   HT_PICKMJ, HF_JULZPOWER, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 1, NOFRACTAL, LMANDELZPOWER, FPJULIAZPOWER,     ORIGIN,
X   longZpowerFractal,long_julia_per_pixel,JulialongSetup,StandardFractal,STDBAILOUT,
X
X   "*manzpower", realz0, imagz0, exponent,imexponent,0,0,2,0,
X   HT_PICKMJ, HF_MANZPOWER, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 0, FPJULIAZPOWER,   NOFRACTAL, LMANDELZPOWER,  XAXIS_NOIMAG,
X   floatZpowerFractal,othermandelfp_per_pixel, MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*julzpower", realparm, imagparm, exponent,imexponent,0.3,0.6,2,0,
X   HT_PICKMJ, HF_JULZPOWER, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, FPMANDELZPOWER, LJULIAZPOWER,    ORIGIN,
X   floatZpowerFractal, otherjuliafp_per_pixel,    JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "manzzpwr", realz0, imagz0, exponent,ES,0,0,2,0,
X   HT_PICKMJ, HF_MANZZPWR, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 0, FPJULZTOZPLUSZPWR,   NOFRACTAL, NOFRACTAL,  XAXIS_NOPARM,
X   floatZtozPluszpwrFractal,othermandelfp_per_pixel, MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "julzzpwr", realparm, imagparm, exponent,ES,-0.3,0.3,2,0,
X   HT_PICKMJ, HF_JULZZPWR, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, FPMANZTOZPLUSZPWR, NOFRACTAL,    NOSYM,
X   floatZtozPluszpwrFractal, otherjuliafp_per_pixel,  JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "manfn+exp",realz0, imagz0,ES,ES,0,0,0,0,
X   HT_PICKMJ, HF_MANDFNPLUSEXP, TRIG1+WINFRAC,
X   -8.0,  8.0, -6.0,  6.0, 16, LJULTRIGPLUSEXP,    NOFRACTAL,  FPMANTRIGPLUSEXP, XAXIS_NOPARM,
X   LongTrigPlusExponentFractal,long_mandel_per_pixel,MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "julfn+exp", realparm, imagparm,ES,ES,0,0,0,0,
X   HT_PICKMJ, HF_JULFNPLUSEXP, TRIG1+WINFRAC+OKJB,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, LMANTRIGPLUSEXP,FPJULTRIGPLUSEXP, NOSYM,
X   LongTrigPlusExponentFractal,   long_julia_per_pixel, JulialongSetup,  StandardFractal,STDBAILOUT,
X
X   "*manfn+exp", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_PICKMJ, HF_MANDFNPLUSEXP, TRIG1+WINFRAC,
X   -8.0,  8.0, -6.0,  6.0, 0, FPJULTRIGPLUSEXP, NOFRACTAL, LMANTRIGPLUSEXP,   XAXIS_NOPARM,
X   FloatTrigPlusExponentFractal,othermandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*julfn+exp", realparm, imagparm,ES,ES,0,0,0,0,
X   HT_PICKMJ, HF_JULFNPLUSEXP, TRIG1+WINFRAC+OKJB,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, FPMANTRIGPLUSEXP, LJULTRIGPLUSEXP,   NOSYM,
X   FloatTrigPlusExponentFractal,otherjuliafp_per_pixel,JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "*popcorn", step, ES, ES,ES,0.05,0,0,0,
X   HT_POPCORN, HF_POPCORN, NOGUESS+NOTRACE+WINFRAC,
X   -3.0,  3.0, -2.2,  2.2, 0, NOFRACTAL, NOFRACTAL, LPOPCORN,  NOPLOT,
X   PopcornFractal, otherjuliafp_per_pixel,  JuliafpSetup,  popcorn,STDBAILOUT,
X
X   "popcorn", step, ES, ES,ES,0.05,0,0,0,
X   HT_POPCORN, HF_POPCORN, NOGUESS+NOTRACE+WINFRAC,
X   -3.0,  3.0, -2.2,  2.2, 16, NOFRACTAL, NOFRACTAL, FPPOPCORN,  NOPLOT,
X   LPopcornFractal,   long_julia_per_pixel, JulialongSetup,popcorn,STDBAILOUT,
X
X   "*lorenz",timestep,A,B, C,.02,5,15,1,
X   HT_LORENZ, HF_LORENZ, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -15,  15, 0, 30, 0, NOFRACTAL, NOFRACTAL, LLORENZ,   NOSYM,
X   lorenz3dfloatorbit, NULL,         orbit3dfloatsetup, orbit2dfloat,     NOBAILOUT,
X
X   "lorenz",timestep,A,B, C,.02,5,15,1,
X   HT_LORENZ, HF_LORENZ, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -15,  15, 0, 30, 16, NOFRACTAL, NOFRACTAL, FPLORENZ,   NOSYM,
X   lorenz3dlongorbit, NULL,        orbit3dlongsetup, orbit2dlong,    NOBAILOUT,
X
X   "lorenz3d",timestep,A,B, C,.02,5,15,1,
X   HT_LORENZ, HF_LORENZ, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -30.0,   30.0, 16, NOFRACTAL, NOFRACTAL, FPLORENZ3D,   NOSYM,
X   lorenz3dlongorbit, NULL,        orbit3dlongsetup, orbit3dlong,    NOBAILOUT,
X
X   "newton", newtdegree,ES, ES,ES,3,0,0,0,
X   HT_NEWT, HF_NEWT, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NEWTON,   XAXIS,
X   MPCNewtonFractal, MPCjulia_per_pixel,  NewtonSetup, StandardFractal,NOBAILOUT,
X
X   "newtbasin", newtdegree,stripes, ES,ES,3,0,0,0,
X   HT_NEWTBAS, HF_NEWTBAS, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NEWTBASIN,     NOSYM,
X   MPCNewtonFractal, MPCjulia_per_pixel,  NewtonSetup, StandardFractal,NOBAILOUT,
X
X   "complexnewton", realdegree,imagdegree,realroot,imagroot,3,0,1,0,
X   HT_NEWTCMPLX, HF_COMPLEXNEWT, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   ComplexNewton, otherjuliafp_per_pixel,  ComplexNewtonSetup, StandardFractal,NOBAILOUT,
X
X   "complexbasin", realdegree,imagdegree,realroot,imagroot,3,0,1,0,
X   HT_NEWTCMPLX, HF_COMPLEXNEWT, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   ComplexBasin, otherjuliafp_per_pixel,  ComplexNewtonSetup,  StandardFractal, NOBAILOUT,
X
X   "cmplxmarksmand", realz0, imagz0, realdegree, imagdegree,0,0,1,0,
X   HT_MARKS, HF_CMPLXMARKSMAND, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, COMPLEXMARKSJUL, NOFRACTAL, NOFRACTAL,   NOSYM,
X   MarksCplxMand, MarksCplxMandperp, MandelfpSetup, StandardFractal, STDBAILOUT,
X
X   "cmplxmarksjul", realparm, imagparm, realdegree, imagdegree,0.3,0.6,1,0,
X   HT_MARKS, HF_CMPLXMARKSJUL, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, COMPLEXMARKSMAND, NOFRACTAL,    NOSYM,
X   MarksCplxMand, juliafp_per_pixel, JuliafpSetup, StandardFractal, STDBAILOUT,
X
X   "formula", p1real, p1imag, p2real, p2imag, 0,0,0,0,
X   HT_FORMULA, -2, WINFRAC,
X   -2.0, 2.0, -1.5, 1.5, 1, NOFRACTAL, NOFRACTAL, FFORMULA, SETUP_SYM,
X   Formula, form_per_pixel, intFormulaSetup, StandardFractal, 0,
X
X   "*formula", p1real, p1imag, p2real, p2imag, 0,0,0,0,
X   HT_FORMULA, -2, WINFRAC,
X   -2.0, 2.0, -1.5, 1.5, 0, NOFRACTAL, NOFRACTAL, FORMULA, SETUP_SYM,
X   Formula, form_per_pixel, fpFormulaSetup, StandardFractal, 0,
X
X   "*sierpinski",  ES,ES,ES,ES,0,0,0,0,
X   HT_SIER, HF_SIER, WINFRAC,
X   -0.9,  1.7, -0.9,  1.7, 0, NOFRACTAL, NOFRACTAL, SIERPINSKI,   NOSYM,
X   SierpinskiFPFractal, otherjuliafp_per_pixel, SierpinskiFPSetup,StandardFractal,127.0,
X
X   "*lambda", realparm, imagparm,ES,ES,0.85,0.6,0,0,
X   HT_LAMBDA, HF_LAMBDA, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, MANDELLAMBDAFP, LAMBDA,  NOSYM,
X   LambdaFPFractal,   juliafp_per_pixel, JuliafpSetup,    StandardFractal,STDBAILOUT,
X
X   "*barnsleym1", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_BARNS, HF_BARNSM1, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, BARNSLEYJ1FP,NOFRACTAL, BARNSLEYM1,  XYAXIS_NOPARM,
X   Barnsley1FPFractal, othermandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*barnsleyj1", realparm, imagparm,ES,ES,0.6,1.1,0,0,
X   HT_BARNS, HF_BARNSJ1, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, BARNSLEYM1FP, BARNSLEYJ1,  ORIGIN,
X   Barnsley1FPFractal, otherjuliafp_per_pixel,JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "*barnsleym2", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_BARNS, HF_BARNSM2, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, BARNSLEYJ2FP,NOFRACTAL, BARNSLEYM2,  YAXIS_NOPARM,
X   Barnsley2FPFractal,othermandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*barnsleyj2", realparm, imagparm,ES,ES,0.6,1.1,0,0,
X   HT_BARNS, HF_BARNSJ2, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, BARNSLEYM2FP, BARNSLEYJ2,  ORIGIN,
X   Barnsley2FPFractal,otherjuliafp_per_pixel,JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "*barnsleym3", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_BARNS, HF_BARNSM3, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, BARNSLEYJ3FP, NOFRACTAL, BARNSLEYM3,  XAXIS_NOPARM,
X   Barnsley3FPFractal,othermandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*barnsleyj3", realparm, imagparm,ES,ES,0.6,1.1,0,0,
X   HT_BARNS, HF_BARNSJ3, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, BARNSLEYM3FP, BARNSLEYJ3,  XAXIS,
X   Barnsley3FPFractal,otherjuliafp_per_pixel,JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "*mandellambda",realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MLAMBDA, HF_MLAMBDA, WINFRAC,
X   -3.0,  5.0, -3.0,  3.0, 0, LAMBDAFP, NOFRACTAL, MANDELLAMBDA,  XAXIS_NOPARM,
X   LambdaFPFractal,mandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "julibrot", ES,ES,ES,ES,0,0,0,0,
X   HT_JULIBROT, -1, NOGUESS+NOTRACE+NOROTATE+NORESUME+WINFRAC,
X   -2.0, 2.0, -1.5, 1.5, 1, NOFRACTAL, NOFRACTAL, JULIBROTFP, NOSYM,
X   JuliaFractal, jb_per_pixel, JulibrotSetup, Std4dFractal, STDBAILOUT,
X
X   "*lorenz3d",timestep,A,B,C,.02,5,15,1,
X   HT_LORENZ, HF_LORENZ, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -30.0,   30.0, 0, NOFRACTAL, NOFRACTAL, LLORENZ3D,   NOSYM,
X   lorenz3dfloatorbit, NULL,         orbit3dfloatsetup, orbit3dfloat,     NOBAILOUT,
X
X   "rossler3d",timestep,A,B,C,.04,.2,.2,5.7,
X   HT_ROSS, HF_ROSS, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -20.0,   40.0, 16, NOFRACTAL, NOFRACTAL, FPROSSLER,    NOSYM,
X   rosslerlongorbit, NULL,       orbit3dlongsetup, orbit3dlong,    NOBAILOUT,
X
X   "*rossler3d",timestep,A,B,C,.04,.2,.2,5.7,
X   HT_ROSS, HF_ROSS, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -20.0,   40.0, 0, NOFRACTAL, NOFRACTAL, LROSSLER,   NOSYM,
X   rosslerfloatorbit, NULL,        orbit3dfloatsetup, orbit3dfloat,    NOBAILOUT,
X
X   "henon",A,B,ES,ES,1.4,.3,0,0,
X   HT_HENON, HF_HENON, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -1.4,  1.4,    -.5,   .5, 16, NOFRACTAL, NOFRACTAL, FPHENON,    NOSYM,
X   henonlongorbit, NULL,     orbit3dlongsetup, orbit2dlong,    NOBAILOUT,
X
X   "*henon",A,B,ES,ES,1.4,.3,0,0,
X   HT_HENON, HF_HENON, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -1.4,  1.4,    -.5,   .5, 0, NOFRACTAL, NOFRACTAL, LHENON,   NOSYM,
X   henonfloatorbit, NULL,      orbit3dfloatsetup, orbit2dfloat,    NOBAILOUT,
X
X   "pickover",A,B,C,D,2.24,.43,-.65,-2.43,
X   HT_PICK, HF_PICKOVER, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -2.8,  2.8,    -2.0, 2.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   pickoverfloatorbit, NULL,         orbit3dfloatsetup, orbit3dfloat,     NOBAILOUT,
X
X   "gingerbreadman",initx,inity,ES,ES,-.1,0,0,0,
X   HT_GINGER, HF_GINGER, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -4.5,  8.5,    -4.5, 8.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   gingerbreadfloatorbit, NULL, orbit3dfloatsetup, orbit2dfloat,    NOBAILOUT,
X
X   "diffusion", "+Border size","+Type (0=Central,1=Falling,2=Square Cavity)",ES, ES,10,0,0,0,
X   HT_DIFFUS, HF_DIFFUS, NOZOOM+NOGUESS+NOTRACE+WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,     NOSYM,
X   NULL,   NULL,     StandaloneSetup, diffusion,    NOBAILOUT,
X
X   "*unity", ES,ES,ES,ES,0,0,0,0,
X   HT_UNITY, HF_UNITY, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, UNITY,   XYAXIS,
X   UnityfpFractal, otherjuliafp_per_pixel,StandardSetup,StandardFractal,NOBAILOUT,
X
X   "*spider", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_SPIDER, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, SPIDER,  XAXIS_NOPARM,
X   SpiderfpFractal,mandelfp_per_pixel, MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "spider",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_SPIDER, WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 1, NOFRACTAL, NOFRACTAL, SPIDERFP,  XAXIS_NOPARM,
X   SpiderFractal,mandel_per_pixel, MandellongSetup,StandardFractal,STDBAILOUT,
X
X   "tetrate", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_TETRATE, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,    XAXIS,
X   TetratefpFractal,othermandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "magnet1m", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MAGNET, HF_MAGM1, WINFRAC,
X   -4.0, 4.0, -3.0, 3.0, 0, MAGNET1J,NOFRACTAL,NOFRACTAL, XAXIS_NOPARM,
X   Magnet1Fractal,mandelfp_per_pixel,MandelfpSetup,StandardFractal,100.0,
X
X   "magnet1j", realparm, imagparm,ES,ES,0,0,0,0,
X   HT_MAGNET, HF_MAGJ1, WINFRAC,
X   -8.0,  8.0, -6.0,  6.0, 0, NOFRACTAL,MAGNET1M,NOFRACTAL, XAXIS_NOIMAG,
X   Magnet1Fractal,juliafp_per_pixel,JuliafpSetup,StandardFractal,100.0,
X
X   "magnet2m", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MAGNET, HF_MAGM2, WINFRAC,
X   -1.5,3.7, -1.95,1.95,   0, MAGNET2J,NOFRACTAL,NOFRACTAL, XAXIS_NOPARM,
X   Magnet2Fractal,mandelfp_per_pixel,MandelfpSetup,StandardFractal,100.0,
X
X   "magnet2j", realparm, imagparm,ES,ES,0,0,0,0,
X   HT_MAGNET, HF_MAGJ2, WINFRAC,
X   -8.0,  8.0, -6.0,  6.0, 0, NOFRACTAL,MAGNET2M,NOFRACTAL, XAXIS_NOIMAG,
X   Magnet2Fractal,juliafp_per_pixel,JuliafpSetup,StandardFractal,100.0,
X
X   "bifurcation",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFURCATION, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   1.9,  3.0, 0,  1.34, 1, NOFRACTAL, NOFRACTAL, BIFURCATION, NOSYM,
X   LongBifurcVerhulstTrig, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "biflambda",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFLAMBDA, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   -2.0, 4.0, -1.0, 2.0, 1, NOFRACTAL, NOFRACTAL, BIFLAMBDA,   NOSYM,
X   LongBifurcLambdaTrig, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "*biflambda",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFLAMBDA, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   -2.0, 4.0, -1.0, 2.0, 0, NOFRACTAL, NOFRACTAL, LBIFLAMBDA,  NOSYM,
X   BifurcLambdaTrig, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "*bif+sinpi",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFPLUSSINPI, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   0.275,1.45, 0.0, 2.0, 0, NOFRACTAL, NOFRACTAL, LBIFADSINPI,     NOSYM,
X   BifurcAddTrigPi, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "*bif=sinpi",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFEQSINPI, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   -2.5, 2.5, -3.5, 3.5, 0, NOFRACTAL, NOFRACTAL, LBIFEQSINPI,     NOSYM,
X   BifurcSetTrigPi, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "*popcornjul", step, ES, ES,ES,0.05,0,0,0,
X   HT_POPCORN, HF_POPCJUL, WINFRAC,
X   -3.0,  3.0, -2.2,  2.2, 0, NOFRACTAL, NOFRACTAL, LPOPCORNJUL,  ORIGIN,
X   PopcornFractal, otherjuliafp_per_pixel,  JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "popcornjul", step, ES, ES,ES,0.05,0,0,0,
X   HT_POPCORN, HF_POPCJUL, WINFRAC,
X   -3.0,  3.0, -2.2,  2.2, 16, NOFRACTAL, NOFRACTAL, FPPOPCORNJUL,  ORIGIN,
X   LPopcornFractal,   long_julia_per_pixel, JulialongSetup,  StandardFractal,STDBAILOUT,
X
X   "lsystem", "+Order",ES,ES,ES,2,0,0,0,
X   HT_LSYS, -3, NOZOOM+NORESUME+NOGUESS+NOTRACE+WINFRAC,
X   -1, 1, -1, 1, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   NULL, NULL, StandaloneSetup, Lsystem, NOBAILOUT,
X
X   "*manowarj", realparm, imagparm,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_MANOWARJ, WINFRAC+OKJB,
X   -2.5,  1.5, -1.5, 1.5, 0, NOFRACTAL, MANOWARFP, MANOWARJ,   NOSYM,
X   ManOWarfpFractal,juliafp_per_pixel, JuliafpSetup,StandardFractal,STDBAILOUT,
X
X   "manowarj",  realparm, imagparm,ES,ES,0,0,0,0,
X   HT_SCOTSKIN, HF_MANOWARJ, WINFRAC+OKJB,
X   -2.5,  1.5, -1.5, 1.5, 1, NOFRACTAL, MANOWAR,   MANOWARJFP, NOSYM,
X   ManOWarFractal,julia_per_pixel, JulialongSetup,StandardFractal,STDBAILOUT,
X
X   "*fn(z)+fn(pix)", realz0,imagz0,recoeftrg2,imcoeftrg2,0,0,1,0,
X   HT_SCOTSKIN, HF_FNPLUSFNPIX, TRIG2,
X   -2.5,  1.5, -1.5, 1.5, 0, NOFRACTAL, NOFRACTAL, FNPLUSFNPIXLONG, NOSYM,
X   Richard8fpFractal,otherrichard8fp_per_pixel, MandelfpSetup,StandardFractal,LTRIGBAILOUT,
X
X   "fn(z)+fn(pix)",  realz0,imagz0,recoeftrg2,imcoeftrg2,0,0,1,0,
X   HT_SCOTSKIN, HF_FNPLUSFNPIX, TRIG2,
X   -2.5,  1.5, -1.5, 1.5, 1, NOFRACTAL, NOFRACTAL, FNPLUSFNPIXFP, NOSYM,
X   Richard8Fractal,long_richard8_per_pixel, MandellongSetup,StandardFractal,LTRIGBAILOUT,
X
X   "*marksmandelpwr", realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MARKS, HF_MARKSMANDPWR, TRIG1+WINFRAC,
X   -2.5,  1.5, -1.5, 1.5, 0, NOFRACTAL, NOFRACTAL, MARKSMANDELPWR, XAXIS_NOPARM,
X   MarksMandelPwrfpFractal,marks_mandelpwrfp_per_pixel, MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "marksmandelpwr",  realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MARKS, HF_MARKSMANDPWR, TRIG1+WINFRAC,
X   -2.5,  1.5, -1.5,  1.5, 1, NOFRACTAL,     NOFRACTAL, MARKSMANDELPWRFP,  XAXIS_NOPARM,
X   MarksMandelPwrFractal,marks_mandelpwr_per_pixel, MandelSetup,StandardFractal,STDBAILOUT,
X
X   "*tim's_error",    realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MARKS, HF_TIMSERR, WINFRAC+TRIG1,
X   -2.5,  3.0, -2.0,  2.0, 0, NOFRACTAL,     NOFRACTAL, TIMSERROR,    XAXIS_NOPARM,
X   TimsErrorfpFractal,marks_mandelpwrfp_per_pixel, MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "tim's_error",    realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MARKS, HF_TIMSERR, WINFRAC+TRIG1,
X   -2.5,  3.0, -2.0,  2.0, 1, NOFRACTAL,     NOFRACTAL, TIMSERRORFP,  XAXIS_NOPARM,
X   TimsErrorFractal,marks_mandelpwr_per_pixel, MandelSetup,StandardFractal,STDBAILOUT,
X
X   "bif=sinpi",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFEQSINPI, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   -2.5, 2.5, -3.5, 3.5, 1, NOFRACTAL, NOFRACTAL, BIFEQSINPI,     NOSYM,
X   LongBifurcSetTrigPi, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "bif+sinpi",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFPLUSSINPI, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   0.275,1.45, 0.0, 2.0, 1, NOFRACTAL, NOFRACTAL, BIFADSINPI,     NOSYM,
X   LongBifurcAddTrigPi, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "*bifstewart",filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFSTEWART, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   0.7,2.0, -1.1,1.1, 0, NOFRACTAL, NOFRACTAL, LBIFSTEWART, NOSYM,
X   BifurcStewartTrig, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "bifstewart", filt,seed,ES,ES,1000.0,0.66,0,0,
X   HT_BIF, HF_BIFSTEWART, TRIG1+NOGUESS+NOTRACE+NOROTATE+WINFRAC,
X   0.7,2.0, -1.1,1.1, 1, NOFRACTAL, NOFRACTAL, BIFSTEWART, NOSYM,
X   LongBifurcStewartTrig, NULL, StandaloneSetup, Bifurcation, NOBAILOUT,
X
X   "hopalong",A,B,C,ES,.4,1,0,0,
X   HT_MARTIN, HF_HOPALONG, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -2.0, 3.0, -1.625, 2.625, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,    NOSYM,
X   hopalong2dfloatorbit, NULL,         orbit3dfloatsetup, orbit2dfloat,     NOBAILOUT,
X
X   "circle", "magnification",ES,ES,ES,200000,0,0,0,
X   HT_CIRCLE, HF_CIRCLE, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,  XYAXIS,
X   CirclefpFractal, juliafp_per_pixel,  JuliafpSetup,StandardFractal,NOBAILOUT,
X
X   "martin",A,ES,ES,ES,3.14,0,0,0,
X   HT_MARTIN, HF_MARTIN, NOGUESS+NOTRACE+INFCALC+WINFRAC,
X   -32,  32, -32, 32, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,    NOSYM,
X   martin2dfloatorbit, NULL,         orbit3dfloatsetup, orbit2dfloat,     NOBAILOUT,
X
X  "lyapunov", "+Order (integer)", "Population Seed", "+Filter Cycles", ES, 0, 0.5, 0, 0,
X   HT_LYAPUNOV, HT_LYAPUNOV, WINFRAC,
X   -8.0, 8.0, -6.0, 6.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   BifurcLambda, NULL, lya_setup, lyapunov, NOBAILOUT,
X
X   "lorenz3d1",timestep,A,B,C,.02,5,15,1,
X   HT_LORENZ, HF_LORENZ3D1, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -30.0,   30.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   lorenz3d1floatorbit, NULL, orbit3dfloatsetup, orbit3dfloat, NOBAILOUT,
X
X   "lorenz3d3",timestep,A,B,C,.02,10,28,2.66,
X   HT_LORENZ, HF_LORENZ3D3, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -30.0,   30.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   lorenz3d3floatorbit, NULL, orbit3dfloatsetup, orbit3dfloat, NOBAILOUT,
X
X   "lorenz3d4",timestep,A,B,C,.02,10,28,2.66,
X   HT_LORENZ, HF_LORENZ3D4, NOGUESS+NOTRACE+NORESUME+WINFRAC+PARMS3D,
X   -30.0,  30.0,  -30.0,   30.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   lorenz3d4floatorbit, NULL, orbit3dfloatsetup, orbit3dfloat, NOBAILOUT,
X
X   "lambda(fn||fn)", realparm, imagparm, shiftval, ES,1,0.1,1,0,
X   HT_FNORFN, HF_LAMBDAFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, LMANLAMFNFN, FPLAMBDAFNFN, ORIGIN,
X   LambdaTrigOrTrigFractal, long_julia_per_pixel, LambdaTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "*lambda(fn||fn)", realparm, imagparm, shiftval,ES,1,0.1,1,0,
X   HT_FNORFN, HF_LAMBDAFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, FPMANLAMFNFN, LLAMBDAFNFN,ORIGIN,
X   LambdaTrigOrTrigfpFractal, otherjuliafp_per_pixel, LambdaTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "julia(fn||fn)", realparm, imagparm, shiftval, ES,0,0,8,0,
X   HT_FNORFN, HF_JULIAFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 16, NOFRACTAL, LMANFNFN, FPJULFNFN,XAXIS,
X   JuliaTrigOrTrigFractal, long_julia_per_pixel, JuliaTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "*julia(fn||fn)", realparm, imagparm, shiftval,ES,0,0,8,0,
X   HT_FNORFN, HF_JULIAFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 0, NOFRACTAL, FPMANFNFN, LJULFNFN,XAXIS,
X   JuliaTrigOrTrigfpFractal, otherjuliafp_per_pixel, JuliaTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "manlam(fn||fn)", realz0, imagz0, shiftval,ES,0,0,10,0,
X   HT_FNORFN, HF_MANLAMFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 16, LLAMBDAFNFN, NOFRACTAL, FPMANLAMFNFN,XAXIS_NOPARM,
X   LambdaTrigOrTrigFractal, long_mandel_per_pixel, ManlamTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "*manlam(fn||fn)", realz0, imagz0, shiftval,ES,0,0,10,0,
X   HT_FNORFN, HF_MANLAMFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 0, FPLAMBDAFNFN, NOFRACTAL, LMANLAMFNFN,XAXIS_NOPARM,
X   LambdaTrigOrTrigfpFractal, othermandelfp_per_pixel, ManlamTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "mandel(fn||fn)", realz0, imagz0, shiftval,ES,0,0,0.5,0,
X   HT_FNORFN, HF_MANDELFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 16, LJULFNFN, NOFRACTAL, FPMANFNFN,XAXIS_NOPARM,
X   JuliaTrigOrTrigFractal, long_mandel_per_pixel, MandelTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "*mandel(fn||fn)", realz0, imagz0, shiftval,ES,0,0,0.5,0,
X   HT_FNORFN, HF_MANDELFNFN, TRIG2,
X   -4.0,  4.0, -3.0,  3.0, 0, FPJULFNFN, NOFRACTAL, LMANFNFN,XAXIS_NOPARM,
X   JuliaTrigOrTrigfpFractal, othermandelfp_per_pixel, MandelTrigOrTrigSetup, StandardFractal,LTRIGBAILOUT,
X
X   "bifmay",filt,seed,"Beta >= 2",ES,300.0,0.9,5,0,
X   HT_BIF, HF_BIFMAY, NOGUESS+NOTRACE+NOROTATE,
X   -3.5, -0.9, -0.5, 3.2, 16, NOFRACTAL, NOFRACTAL, BIFMAY,     NOSYM,
X   LongBifurcMay, NULL, BifurcMaySetup, Bifurcation, NOBAILOUT,
X
X   "*bifmay",filt,seed,"Beta >= 2",ES,300.0,0.9,5,0,
X   HT_BIF, HF_BIFMAY, NOGUESS+NOTRACE+NOROTATE,
X   -3.5, -0.9, -0.5, 3.2, 0, NOFRACTAL, NOFRACTAL, LBIFMAY,     NOSYM,
X   BifurcMay, NULL, BifurcMaySetup, Bifurcation, NOBAILOUT,
X
X  "halley", "+Order (integer > 1)", "Relaxation coefficient", "Epsilon", ES, 6, 1.0, 0.0001, 0,
X   HT_HALLEY, HF_HALLEY, 0,
X   -2.0, 2.0, -1.3, 1.3, 0, NOFRACTAL, NOFRACTAL, HALLEY, XYAXIS,
X   MPCHalleyFractal, MPCHalley_per_pixel, HalleySetup, StandardFractal, NOBAILOUT,
X
X  "*halley", "+Order (integer > 1)", "Relaxation coefficient", "Epsilon", ES, 6, 1.0, 0.0001, 0,
X   HT_HALLEY, HF_HALLEY, 0,
X   -2.0, 2.0, -1.3, 1.3, 0, NOFRACTAL, NOFRACTAL, MPHALLEY, XYAXIS,
X   HalleyFractal, Halley_per_pixel, HalleySetup, StandardFractal, NOBAILOUT,
X
X   "dynamic","+# of intervals (<0 = connect)","time step (<0 = Euler",A,B,
X   50,.1,1,3,
X   HT_DYNAM, HF_DYNAM, NOGUESS+NOTRACE+NORESUME+WINFRAC+TRIG1,
X   -20.0,  20.0,  -20.0,   20.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   dynamfloat, NULL, dynam2dfloatsetup, dynam2dfloat, NOBAILOUT,
X
X   "quat", "notused", "notused",CJ,CK,0,0,0,0,
X   HT_QUAT, HF_QUAT, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, QUATJULFP, NOFRACTAL, NOFRACTAL,  XAXIS,
X   QuaternionFPFractal, quaternionfp_per_pixel,MandelfpSetup,StandardFractal,
X   LTRIGBAILOUT,
X
X   "quatjul", C1, CI, CJ,CK,-.745,0,.113,.05,
X   HT_QUAT, HF_QUATJ, WINFRAC+OKJB+MORE,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, QUATFP, NOFRACTAL,  ORIGIN,
X   QuaternionFPFractal, quaternionjulfp_per_pixel,JuliafpSetup,StandardFractal,
X   LTRIGBAILOUT,
X
X   "cellular", "Initial String | 0 = Random | -1 = Reuse Last Random",
X   "Rule = # of digits (see below) | 0 = Random",
X   "Type (see below)",
X   "Starting Row Number",
X   11.0, 3311100320.0, 41.0, 0,
X   HT_CELLULAR, HF_CELLULAR, NOGUESS+NOTRACE+NOZOOM,
X   -1.0,  1.0, -1.0,  1.0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,  NOSYM,
X   NULL,       NULL,   CellularSetup,     cellular,      NOBAILOUT,
X
X   "*julibrot", ES,ES,ES,ES,0, 0, 0, 0,
X   HT_JULIBROT, -1, NOGUESS+NOTRACE+NOROTATE+NORESUME+WINFRAC,
X   -2.0, 2.0, -1.5, 1.5, 0, NOFRACTAL, NOFRACTAL, JULIBROT, NOSYM,
X   JuliafpFractal, jbfp_per_pixel, JulibrotSetup, Std4dfpFractal, STDBAILOUT,
X
X#ifdef RANDOM_RUN
X   "julia_inverse", realparm, imagparm,
X   "Max Hits per Pixel", "Random Run Interval", -0.11, 0.6557, 4, 1024,
X   HT_INVERSE, HF_INVERSE, NOGUESS+NOTRACE+INFCALC+WINFRAC+NORESUME,
X   -2.0,  2.0, -1.5, 1.5, 24, NOFRACTAL, MANDEL, INVERSEJULIAFP,  NOSYM,
X   Linverse_julia_orbit, NULL, orbit3dlongsetup, inverse_julia_per_image, NOBAILOUT,
X
X   "*julia_inverse", realparm, imagparm,
X   "Max Hits per Pixel", "Random Run Interval", -0.11, 0.6557, 4, 1024,
X   HT_INVERSE, HF_INVERSE, NOGUESS+NOTRACE+INFCALC+WINFRAC+NORESUME,
X   -2.0,  2.0, -1.5, 1.5,  0, NOFRACTAL, MANDEL, INVERSEJULIA,  NOSYM,
X   Minverse_julia_orbit, NULL, orbit3dfloatsetup, inverse_julia_per_image, NOBAILOUT,
X#else
X   "julia_inverse", realparm, imagparm,
X   "Max Hits per Pixel", ES, -0.11, 0.6557, 4, 1024,
X   HT_INVERSE, HF_INVERSE, NOGUESS+NOTRACE+INFCALC+WINFRAC+NORESUME,
X   -2.0,  2.0, -1.5, 1.5, 24, NOFRACTAL, MANDEL, INVERSEJULIAFP,  NOSYM,
X   Linverse_julia_orbit, NULL, orbit3dlongsetup, inverse_julia_per_image, NOBAILOUT,
X
X   "*julia_inverse", realparm, imagparm,
X   "Max Hits per Pixel", ES, -0.11, 0.6557, 4, 1024,
X   HT_INVERSE, HF_INVERSE, NOGUESS+NOTRACE+INFCALC+WINFRAC+NORESUME,
X   -2.0,  2.0, -1.5, 1.5,  0, NOFRACTAL, MANDEL, INVERSEJULIA,  NOSYM,
X   Minverse_julia_orbit, NULL, orbit3dfloatsetup, inverse_julia_per_image, NOBAILOUT,
X
X#endif
X
X   "mandelcloud","+# of intervals (<0 = connect)",ES,ES,ES,
X   50,0,0,0,
X   HT_MANDELCLOUD, HF_MANDELCLOUD, NOGUESS+NOTRACE+NORESUME+WINFRAC,
X   -2.5,  1.5,  -1.5,   1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   mandelcloudfloat, NULL, dynam2dfloatsetup, dynam2dfloat, NOBAILOUT,
X
X   "phoenix",p1real,p2real,"Degree of Z = 0 | >= 2 | <= -3",ES,0.56667,-0.5,0,0,
X   HT_PHOENIX, HF_PHOENIX, 0,
X   -2.0, 2.0, -1.5, 1.5, 1, NOFRACTAL, MANDPHOENIX, PHOENIXFP, XAXIS,
X   LongPhoenixFractal, long_phoenix_per_pixel, PhoenixSetup, StandardFractal, STDBAILOUT,
X
X   "*phoenix",p1real,p2real,"Degree of Z = 0 | >= 2 | <= -3",ES,0.56667,-0.5,0,0,
X   HT_PHOENIX, HF_PHOENIX, 0,
X   -2.0, 2.0, -1.5, 1.5, 0, NOFRACTAL, MANDPHOENIXFP, PHOENIX, XAXIS,
X   PhoenixFractal, phoenix_per_pixel, PhoenixSetup, StandardFractal, STDBAILOUT,
X
X   "mandphoenix",realz0,imagz0,"Degree of Z = 0 | >= 2 | <= -3",ES,0.0,0.0,0,0,
X   HT_PHOENIX, HF_MANDPHOENIX, 0,
X   -2.5, 1.5, -1.5, 1.5, 1, PHOENIX, NOFRACTAL, MANDPHOENIXFP, NOSYM,
X   LongPhoenixFractal, long_mandphoenix_per_pixel, MandPhoenixSetup, StandardFractal, STDBAILOUT,
X
X   "*mandphoenix",realz0,imagz0,"Degree of Z = 0 | >= 2 | <= -3",ES,0.0,0.0,0,0,
X   HT_PHOENIX, HF_MANDPHOENIX, 0,
X   -2.5, 1.5, -1.5, 1.5, 0, PHOENIXFP, NOFRACTAL, MANDPHOENIX, NOSYM,
X   PhoenixFractal, mandphoenix_per_pixel, MandPhoenixSetup, StandardFractal, STDBAILOUT,
X
X   "hypercomplex", "notused", "notused",CJ,CK,0,0,0,0,
X   HT_HYPERC, HF_HYPERC, WINFRAC+OKJB+TRIG1,
X   -2.0,  2.0, -1.5,  1.5, 0, HYPERCMPLXJFP, NOFRACTAL, NOFRACTAL,  XAXIS,
X   HyperComplexFPFractal, quaternionfp_per_pixel,MandelfpSetup,StandardFractal,
X   LTRIGBAILOUT,
X
X   "hypercomplexj", C1, CI, CJ,CK,-.745,0,.113,.05,
X   HT_HYPERC, HF_HYPERCJ, WINFRAC+OKJB+TRIG1+MORE,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, HYPERCMPLXFP, NOFRACTAL,  ORIGIN,
X   HyperComplexFPFractal, quaternionjulfp_per_pixel,JuliafpSetup,StandardFractal,
X   LTRIGBAILOUT,
X
X  "frothybasin", frothattractor, frothshade, ES, ES, 3, 0, 0, 0,
X   HT_FROTH, HF_FROTH, NOTRACE+WINFRAC,
X   -3, 3, -2.5, 2, 28, NOFRACTAL, NOFRACTAL, FROTHFP, NOSYM,
X   NULL, NULL, froth_setup, calcfroth, FROTHBAILOUT,
X
X  "*frothybasin", frothattractor, frothshade, ES, ES, 3, 0, 0, 0,
X   HT_FROTH, HF_FROTH, NOTRACE+WINFRAC,
X   -3, 3, -2.5, 2, 0, NOFRACTAL, NOFRACTAL, FROTH, NOSYM,
X   NULL, NULL, froth_setup, calcfroth, FROTHBAILOUT,
X
X   "*mandel4",realz0, imagz0,ES,ES,0,0,0,0,
X   HT_MANDJUL4, HF_MANDEL4, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, JULIA4FP, NOFRACTAL, MANDEL4,  XAXIS_NOPARM,
X   Mandel4fpFractal,mandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*julia4", realparm, imagparm,ES,ES,0.6,0.55,0,0,
X   HT_MANDJUL4, HF_JULIA4, WINFRAC+OKJB,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, MANDEL4FP, JULIA4, ORIGIN,
X   Mandel4fpFractal, juliafp_per_pixel, JuliafpSetup,StandardFractal,     STDBAILOUT,
X
X   "*marksmandel", realz0, imagz0, exponent,ES,0,0,1,0,
X   HT_MARKS, HF_MARKSMAND, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, MARKSJULIAFP, NOFRACTAL, MARKSMANDEL,  NOSYM,
X   MarksLambdafpFractal,marksmandelfp_per_pixel,MandelfpSetup,StandardFractal,STDBAILOUT,
X
X   "*marksjulia", realparm, imagparm, exponent,ES,0.1,0.9,0,0,
X   HT_MARKS, HF_MARKSJULIA, WINFRAC,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, MARKSMANDELFP, MARKSJULIA,   ORIGIN,
X   MarksLambdafpFractal,juliafp_per_pixel,MarksJuliafpSetup,StandardFractal,STDBAILOUT,
X
X   /* dmf */
X   "icons", lambda, alpha,beta,gamma2, -2.34, 2.0, 0.2, 0.1,
X   HT_ICON, HF_ICON, NOGUESS+NOTRACE+WINFRAC+INFCALC+MORE,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL,  NOFRACTAL, NOSYM,
X   iconfloatorbit, NULL, orbit3dfloatsetup,  orbit2dfloat, NOBAILOUT,
X
X   /* dmf */
X   "icons3d", lambda, alpha,beta,gamma2, -2.34, 2.0, 0.2, 0.1,
X   HT_ICON, HF_ICON, NOGUESS+NOTRACE+WINFRAC+INFCALC+PARMS3D+MORE,
X   -2.0,  2.0, -1.5,  1.5, 0, NOFRACTAL, NOFRACTAL,  NOFRACTAL, NOSYM,
X   iconfloatorbit, NULL, orbit3dfloatsetup,  orbit3dfloat, NOBAILOUT,
X
X/*  the following demonstration drunkard's walk fractal requires
X    only the demowalk() routine in FRACTALS.C to be functional
X    (the definition of the positional value DEMOWALK in FRACTYPE.H
X    is not really required, but is good practice).
X*/
X/*
X   "demowalk", "Average Stepsize (% of image)",
X               "Color (0 means rotate colors)",ES,ES,5,0.0,0,0,
X   -1, -1, NORESUME+WINFRAC,
X   -2.5,  1.5,  -1.5,   1.5, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL, NOSYM,
X   NULL,  NULL,  StandaloneSetup,  demowalk,  NOBAILOUT,
X*/
X
X/*  the following demonstration Mandelbrot/Julia fractals require
X    only the definition of the four positional values DEMOMANDEL,
X    DEMOJULIA, DEMOMANDELFP, and DEMOJULIAFP in FRACTYPE.H to be
X    functional - and we only need *them* for the integer/floatingpoint
X    and Mandelbrot/Julia toggle items in their structure items.
X*/
X/*
X   "demomandel", realz0, imagz0,ES,ES,0,0,0,0,
X   -1, -1, WINFRAC,
X   -2.5, 1.5, -1.5, 1.5, 1, DEMOJULIA,  NOFRACTAL, DEMOMANDELFP, XAXIS_NOPARM,
X   JuliaFractal, mandel_per_pixel, MandellongSetup, StandardFractal, STDBAILOUT,
X
X   "demojulia", realparm, imagparm,ES,ES,0.3,0.6,0,0,
X   -1, -1, WINFRAC,
X   -2.0, 2.0, -1.5, 1.5, 1, NOFRACTAL, DEMOMANDEL, DEMOJULIAFP, ORIGIN,
X   JuliaFractal, julia_per_pixel, JulialongSetup, StandardFractal, STDBAILOUT,
X
X   "*demomandel", realz0, imagz0,ES,ES,0,0,0,0,
X   -1, -1, WINFRAC,
X   -2.5, 1.5, -1.5, 1.5, 0, DEMOJULIAFP,  NOFRACTAL, DEMOJULIA, XAXIS_NOPARM,
X   JuliafpFractal, mandelfp_per_pixel, MandelfpSetup, StandardFractal, STDBAILOUT,
X
X   "*demojulia", realparm, imagparm,ES,ES,0.3,0.6,0,0,
X   -1, -1, WINFRAC,
X   -2.0, 2.0, -1.5, 1.5, 0, NOFRACTAL, DEMOMANDELFP, DEMOMANDEL, ORIGIN,
X   JuliafpFractal, juliafp_per_pixel, JuliafpSetup, StandardFractal, STDBAILOUT,
X*/
X
X
X   NULL, NULL, NULL, NULL, NULL,0,0,0,0,    /* marks the END of the list */
X   -1, -1, 0,
X   0,  0, 0,  0, 0, NOFRACTAL, NOFRACTAL, NOFRACTAL,   NOSYM,
X   NULL, NULL, NULL, NULL,0
X
X};
X
Xint num_fractal_types = (sizeof(fractalspecific)/
X    sizeof(struct fractalspecificstuff)) -1;
X
SHAR_EOF
$TOUCH -am 1028230093 fractalp.c &&
chmod 0644 fractalp.c ||
echo "restore of fractalp.c failed"
set `wc -c fractalp.c`;Wc_c=$1
if test "$Wc_c" != "48702"; then
    echo original size 48702, current size $Wc_c
fi
# ============= fractals.c ==============
echo "x - extracting fractals.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fractals.c &&
X/*
XFRACTALS.C, FRACTALP.C and CALCFRAC.C actually calculate the fractal
Ximages (well, SOMEBODY had to do it!).  The modules are set up so that
Xall logic that is independent of any fractal-specific code is in
XCALCFRAC.C, the code that IS fractal-specific is in FRACTALS.C, and the
Xstruscture that ties (we hope!) everything together is in FRACTALP.C.
XOriginal author Tim Wegner, but just about ALL the authors have
Xcontributed SOME code to this routine at one time or another, or
Xcontributed to one of the many massive restructurings.
X
XThe Fractal-specific routines are divided into three categories:
X
X1. Routines that are called once-per-orbit to calculate the orbit
X   value. These have names like "XxxxFractal", and their function
X   pointers are stored in fractalspecific[fractype].orbitcalc. EVERY
X   new fractal type needs one of these. Return 0 to continue iterations,
X   1 if we're done. Results for integer fractals are left in 'lnew.x' and
X   'lnew.y', for floating point fractals in 'new.x' and 'new.y'.
X
X2. Routines that are called once per pixel to set various variables
X   prior to the orbit calculation. These have names like xxx_per_pixel
X   and are fairly generic - chances are one is right for your new type.
X   They are stored in fractalspecific[fractype].per_pixel.
X
X3. Routines that are called once per screen to set various variables.
X   These have names like XxxxSetup, and are stored in
X   fractalspecific[fractype].per_image.
X
X4. The main fractal routine. Usually this will be StandardFractal(),
X   but if you have written a stand-alone fractal routine independent
X   of the StandardFractal mechanisms, your routine name goes here,
X   stored in fractalspecific[fractype].calctype.per_image.
X
XAdding a new fractal type should be simply a matter of adding an item
Xto the 'fractalspecific' structure, writing (or re-using one of the existing)
Xan appropriate setup, per_image, per_pixel, and orbit routines.
X
X--------------------------------------------------------------------   */
X
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <float.h>
X#include <limits.h>
X#include <string.h>
X#ifdef __TURBOC__
X#include <alloc.h>
X#elif !defined(__386BSD__)
X#include <malloc.h>
X#endif
X#include "fractint.h"
X#include "mpmath.h"
X#include "helpdefs.h"
X#include "fractype.h"
X#include "prototyp.h"
X
X#define NEWTONDEGREELIMIT  100
X
Xextern int using_jiim;
Xextern _CMPLX  initorbit;
Xextern _LCMPLX linitorbit;
Xextern char useinitorbit;
Xextern double fgLimit;
Xextern int distest;
X
X#define CMPLXsqr_old(out)    \
X   (out).y = (old.x+old.x) * old.y;\
X   (out).x = tempsqrx - tempsqry
X
X#define CMPLXpwr(arg1,arg2,out)   (out)= ComplexPower((arg1), (arg2))
X#define CMPLXmult1(arg1,arg2,out)    Arg2->d = (arg1); Arg1->d = (arg2);\
X     dStkMul(); Arg1++; Arg2++; (out) = Arg2->d
X
X#define CMPLXmult(arg1,arg2,out)  \
X    {\
X       _CMPLX TmP;\
X       TmP.x = (arg1).x*(arg2).x - (arg1).y*(arg2).y;\
X       TmP.y = (arg1).x*(arg2).y + (arg1).y*(arg2).x;\
X       (out) = TmP;\
X     }
X#if 0
X#define CMPLXmult(arg1,arg2,out)  {CMPLXmult2(arg1,arg2,&out);}
X#endif
X
Xvoid CMPLXmult2(_CMPLX arg1,_CMPLX arg2, _CMPLX *out)
X{
X    _CMPLX TmP;
X    TmP.x = (arg1).x*(arg2).x - (arg1).y*(arg2).y;
X    TmP.y = (arg1).x*(arg2).y + (arg1).y*(arg2).x;
X    *out = TmP;
X}
X
X#define CMPLXadd(arg1,arg2,out)    \
X    (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
X#define CMPLXsub(arg1,arg2,out)    \
X    (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
X#define CMPLXtimesreal(arg,real,out)   \
X    (out).x = (arg).x*(real);\
X    (out).y = (arg).y*(real)
X
X#define CMPLXrecip(arg,out)    \
X   { double denom; denom = sqr((arg).x) + sqr((arg).y);\
X     if(denom==0.0) {(out).x = 1.0e10;(out).y = 1.0e10;}else\
X    { (out).x =  (arg).x/denom;\
X     (out).y = -(arg).y/denom;}}
X
Xextern int xshift, yshift;
Xextern int biomorph;
Xextern int forcesymmetry;
Xextern int symmetry;
X_LCMPLX lcoefficient,lold,lnew,lparm, linit,ltmp,ltmp2,lparm2;
Xlong ltempsqrx,ltempsqry;
Xextern int decomp[];
Xextern double param[];
Xextern int potflag;                   /* potential enabled? */
Xextern double f_radius,f_xcenter,f_ycenter;    /* inversion radius, center */
Xextern double xxmin,xxmax,yymin,yymax;           /* corners */
Xextern int overflow;
Xextern int integerfractal;    /* TRUE if fractal uses integer math */
X
Xint maxcolor;
Xint root, degree,basin;
Xdouble floatmin,floatmax;
Xdouble roverd, d1overd, threshold;
X_CMPLX tmp2;
Xextern _CMPLX init,tmp,old,new,saved,jbcfp;
X_CMPLX coefficient;
X_CMPLX    staticroots[16]; /* roots array for degree 16 or less */
X_CMPLX    *roots = staticroots;
Xstruct MPC    *MPCroots;
Xextern int color, row, col;
Xextern int invert;
Xextern double far *dx0, far *dy0;
Xextern double far *dx1, far *dy1;
Xlong FgHalf;
X
X_CMPLX one;
X_CMPLX pwr;
X_CMPLX Coefficient;
X
Xextern int    colors;             /* maximum colors available */
Xextern int    inside;             /* "inside" color to use    */
Xextern int    outside;            /* "outside" color to use   */
Xextern int    finattract;
Xextern int    fractype;            /* fractal type */
Xextern int    debugflag;            /* for debugging purposes */
X
Xextern double    param[];        /* parameters */
Xextern long    far *lx0, far *ly0;        /* X, Y points */
Xextern long    far *lx1, far *ly1;        /* X, Y points */
Xextern long    delx,dely;            /* X, Y increments */
Xextern long    delmin;             /* min(max(dx),max(dy) */
Xextern double    ddelmin;            /* min(max(dx),max(dy) */
Xextern long    fudge;                /* fudge factor (2**n) */
Xextern int    bitshift;            /* bit shift for fudge */
Xint    bitshiftless1;            /* bit shift less 1 */
X
X#ifndef sqr
X#define sqr(x) ((x)*(x))
X#endif
X
X#ifndef lsqr
X#define lsqr(x) (multiply((x),(x),bitshift))
X#endif
X
X#define modulus(z)     (sqr((z).x)+sqr((z).y))
X#define conjugate(pz)    ((pz)->y = 0.0 - (pz)->y)
X#define distance(z1,z2)  (sqr((z1).x-(z2).x)+sqr((z1).y-(z2).y))
X#define pMPsqr(z) (*pMPmul((z),(z)))
X#define MPdistance(z1,z2)  (*pMPadd(pMPsqr(*pMPsub((z1).x,(z2).x)),pMPsqr(*pMPsub((z1).y,(z2).y))))
X
Xdouble twopi = PI*2.0;
Xint c_exp;
X
X
X/* These are local but I don't want to pass them as parameters */
X_CMPLX lambda;
Xextern double magnitude, rqlim, rqlim2;
X_CMPLX parm,parm2;
X_CMPLX *floatparm;
X_LCMPLX *longparm; /* used here and in jb.c */
Xextern int (*calctype)();
Xextern unsigned long lm;        /* magnitude limit (CALCMAND) */
X
X/* -------------------------------------------------------------------- */
X/*        These variables are external for speed's sake only      */
X/* -------------------------------------------------------------------- */
X
Xdouble sinx,cosx,sinhx,coshx;
Xdouble siny,cosy,sinhy,coshy;
Xdouble tmpexp;
Xdouble tempsqrx,tempsqry,tempsqrz,tempsqrt;
X
Xdouble foldxinitx,foldyinity,foldxinity,foldyinitx;
Xlong oldxinitx,oldyinity,oldxinity,oldyinitx;
Xlong longtmp;
Xextern long lmagnitud, llimit, llimit2, l16triglim;
Xextern periodicitycheck;
Xextern char floatflag;
X
X/* These are for quaternions */
Xdouble qc,qci,qcj,qck;
X
X/* temporary variables for trig use */
Xlong lcosx, lcoshx, lsinx, lsinhx;
Xlong lcosy, lcoshy, lsiny, lsinhy;
X
X/*
X**  details of finite attractors (required for Magnet Fractals)
X**  (can also be used in "coloring in" the lakes of Julia types)
X*/
Xextern          int      attractors; /* number of finite attractors   */
Xextern _CMPLX  attr[];       /* finite attractor values (f.p) */
Xextern _LCMPLX lattr[];      /* finite attractor values (int) */
Xextern int    attrperiod[]; /* finite attractor period */
X
X/*
X**  pre-calculated values for fractal types Magnet2M & Magnet2J
X*/
X_CMPLX    T_Cm1;          /* 3 * (floatparm - 1)            */
X_CMPLX    T_Cm2;          /* 3 * (floatparm - 2)            */
X_CMPLX    T_Cm1Cm2;     /* (floatparm - 1) * (floatparm - 2) */
X
Xvoid FloatPreCalcMagnet2() /* precalculation for Magnet2 (M & J) for speed */
X  {
X    T_Cm1.x = floatparm->x - 1.0;   T_Cm1.y = floatparm->y;
X    T_Cm2.x = floatparm->x - 2.0;   T_Cm2.y = floatparm->y;
X    T_Cm1Cm2.x = (T_Cm1.x * T_Cm2.x) - (T_Cm1.y * T_Cm2.y);
X    T_Cm1Cm2.y = (T_Cm1.x * T_Cm2.y) + (T_Cm1.y * T_Cm2.x);
X    T_Cm1.x += T_Cm1.x + T_Cm1.x;   T_Cm1.y += T_Cm1.y + T_Cm1.y;
X    T_Cm2.x += T_Cm2.x + T_Cm2.x;   T_Cm2.y += T_Cm2.y + T_Cm2.y;
X  }
X
X
X/* -------------------------------------------------------------------- */
X/*        Bailout Routines Macros                                                 */
X/* -------------------------------------------------------------------- */
X
Xstatic int near floatbailout()
X{
X   if ( ( magnitude = ( tempsqrx=sqr(new.x) )
X            + ( tempsqry=sqr(new.y) ) ) >= rqlim ) return(1);
X   old = new;
X   return(0);
X}
X
X/* longbailout() is equivalent to next */
X#define LONGBAILOUT()    \
X   ltempsqrx = lsqr(lnew.x); ltempsqry = lsqr(lnew.y);\
X   lmagnitud = ltempsqrx + ltempsqry;\
X   if (lmagnitud >= llimit || lmagnitud < 0 || labs(lnew.x) > llimit2\
X     || labs(lnew.y) > llimit2 || overflow) \
X           { overflow=0;return(1);}\
X   lold = lnew;
X
X#define FLOATTRIGBAILOUT()  \
X   if (fabs(old.y) >= rqlim2) return(1);
X
X#define LONGTRIGBAILOUT()  \
X   if(labs(lold.y) >= llimit2 || overflow) { overflow=0;return(1);}
X
X#define LONGXYTRIGBAILOUT()  \
X   if(labs(lold.x) >= llimit2 || labs(lold.y) >= llimit2 || overflow)\
X    { overflow=0;return(1);}
X
X#define FLOATXYTRIGBAILOUT()  \
X   if (fabs(old.x) >= rqlim2 || fabs(old.y) >= rqlim2) return(1);
X
X#define FLOATHTRIGBAILOUT()  \
X   if (fabs(old.x) >= rqlim2) return(1);
X
X#define LONGHTRIGBAILOUT()  \
X   if(labs(lold.x) >= llimit2 || overflow) { overflow=0;return(1);}
X
X#define TRIG16CHECK(X)    \
X      if(labs((X)) > l16triglim || overflow) { overflow=0;return(1);}
X
X#define FLOATEXPBAILOUT()  \
X   if (fabs(old.y) >= 1.0e8) return(1);\
X   if (fabs(old.x) >= 6.4e2) return(1);
X
X#define LONGEXPBAILOUT()  \
X   if (labs(lold.y) >= (1000L<<bitshift)) return(1);\
X   if (labs(lold.x) >=      (8L<<bitshift)) return(1);
X
X#if 0
X/* this define uses usual trig instead of fast trig */
X#define FPUsincos(px,psinx,pcosx) \
X   *(psinx) = sin(*(px));\
X   *(pcosx) = cos(*(px));
X
X#define FPUsinhcosh(px,psinhx,pcoshx) \
X   *(psinhx) = sinh(*(px));\
X   *(pcoshx) = cosh(*(px));
X#endif
X
X#define LTRIGARG(X)    \
X   if(labs((X)) > l16triglim)\
X   {\
X      double tmp;\
X      tmp = (X);\
X      tmp /= fudge;\
X      tmp = fmod(tmp,twopi);\
X      tmp *= fudge;\
X      (X) = tmp;\
X   }\
X
Xstatic int near Halleybailout()
X{
X   if ( fabs(modulus(new)-modulus(old)) < parm2.x)
X      return(1);
X   old = new;
X   return(0);
X}
X
X#ifndef XFRACT
X#define MPCmod(m) (*pMPadd(*pMPmul((m).x, (m).x), *pMPmul((m).y, (m).y)))
Xstruct MPC mpcold, mpcnew, mpctmp, mpctmp1;
Xstruct MP mptmpparm2x;
X
Xstatic int near MPCHalleybailout()
X{
Xstatic struct MP mptmpbailout;
X   mptmpbailout = *MPabs(*pMPsub(MPCmod(mpcnew), MPCmod(mpcold)));
X   if (pMPcmp(mptmpbailout, mptmpparm2x) < 0)
X      return(1);
X   mpcold = mpcnew;
X   return(0);
X}
X#endif
X
X/* -------------------------------------------------------------------- */
X/*        Fractal (once per iteration) routines            */
X/* -------------------------------------------------------------------- */
Xstatic double xt, yt, t2;
X
X/* Raise complex number (base) to the (exp) power, storing the result
X** in complex (result).
X*/
Xvoid cpower(_CMPLX *base, int exp, _CMPLX *result)
X{
X    if (exp<0) {
X    cpower(base,-exp,result);
X    CMPLXrecip(*result,*result);
X    return;
X    }
X
X    xt = base->x;   yt = base->y;
X
X    if (exp & 1)
X    {
X       result->x = xt;
X       result->y = yt;
X    }
X    else
X    {
X       result->x = 1.0;
X       result->y = 0.0;
X    }
X
X    exp >>= 1;
X    while (exp)
X    {
X    t2 = xt * xt - yt * yt;
X    yt = 2 * xt * yt;
X    xt = t2;
X
X    if (exp & 1)
X    {
X        t2 = xt * result->x - yt * result->y;
X        result->y = result->y * xt + yt * result->x;
X        result->x = t2;
X    }
X    exp >>= 1;
X    }
X}
X/* long version */
Xstatic long lxt, lyt, lt2;
X
Xlcpower(_LCMPLX *base, int exp, _LCMPLX *result, int bitshift)
X{
X    static long maxarg;
X    maxarg = 64L<<bitshift;
X
X    overflow = 0;
X    lxt = base->x;   lyt = base->y;
X
X    if (exp & 1)
X    {
X       result->x = lxt;
X       result->y = lyt;
X    }
X    else
X    {
X       result->x = 1L<<bitshift;
X       result->y = 0L;
X    }
X
X    exp >>= 1;
X    while (exp)
X    {
X    /*
X    if(labs(lxt) >= maxarg || labs(lyt) >= maxarg)
X       return(-1);
X    */
X    lt2 = multiply(lxt, lxt, bitshift) - multiply(lyt,lyt,bitshift);
X    lyt = multiply(lxt,lyt,bitshiftless1);
X    if(overflow)
X       return(overflow);
X    lxt = lt2;
X
X    if (exp & 1)
X    {
X        lt2 = multiply(lxt,result->x, bitshift) - multiply(lyt,result->y,bitshift);
X        result->y = multiply(result->y,lxt,bitshift) + multiply(lyt,result->x,bitshift);
X        result->x = lt2;
X    }
X    exp >>= 1;
X    }
X    if(result->x == 0 && result->y == 0)
X       overflow = 1;
X    return(overflow);
X}
X#if 0
Xz_to_the_z(_CMPLX *z, _CMPLX *out)
X{
X    static _CMPLX tmp1,tmp2;
X    /* raises complex z to the z power */
X    int errno_xxx;
X    errno_xxx = 0;
X
X    if(fabs(z->x) < DBL_EPSILON) return(-1);
X
X    /* log(x + iy) = 1/2(log(x*x + y*y) + i(arc_tan(y/x)) */
X    tmp1.x = .5*log(sqr(z->x)+sqr(z->y));
X
X    /* the fabs in next line added to prevent discontinuity in image */
X    tmp1.y = atan(fabs(z->y/z->x));
X
X    /* log(z)*z */
X    tmp2.x = tmp1.x * z->x - tmp1.y * z->y;
X    tmp2.y = tmp1.x * z->y + tmp1.y * z->x;
X
X    /* z*z = e**(log(z)*z) */
X    /* e**(x + iy) =  e**x * (cos(y) + isin(y)) */
X
X    tmpexp = exp(tmp2.x);
X
X    FPUsincos(&tmp2.y,&siny,&cosy);
X    out->x = tmpexp*cosy;
X    out->y = tmpexp*siny;
X    return(errno_xxx);
X}
X#endif
X
Xint complex_div(_CMPLX arg1,_CMPLX arg2,_CMPLX *pz);
Xint complex_mult(_CMPLX arg1,_CMPLX arg2,_CMPLX *pz);
X
X#ifdef XFRACT /* fractint uses the NewtonFractal2 code in newton.asm */
X
X/* Distance of complex z from unit circle */
X#define DIST1(z) (((z).x-1.0)*((z).x-1.0)+((z).y)*((z).y))
X#define LDIST1(z) (lsqr((((z).x)-fudge)) + lsqr(((z).y)))
X
X
Xint NewtonFractal2()
X{
X    static char start=1;
X    if(start)
X    {
X       start = 0;
X    }
X    cpower(&old, degree-1, &tmp);
X    complex_mult(tmp, old, &new);
X
X    if (DIST1(new) < threshold)
X    {
X       if(fractype==NEWTBASIN || fractype==MPNEWTBASIN)
X       {
X      int tmpcolor;
X      int i;
X      tmpcolor = -1;
X      /* this code determines which degree-th root of root the
X         Newton formula converges to. The roots of a 1 are
X         distributed on a circle of radius 1 about the origin. */
X      for(i=0;i<degree;i++)
X         /* color in alternating shades with iteration according to
X        which root of 1 it converged to */
X          if(distance(roots[i],old) < threshold)
X          {
X          if (basin==2) {
X                  tmpcolor = 1+(i&7)+((color&1)<<3);
X          } else {
X              tmpcolor = 1+i;
X          }
X          break;
X          }
X       if(tmpcolor == -1)
X          color = maxcolor;
X       else
X          color = tmpcolor;
X       }
X       return(1);
X    }
X    new.x = d1overd * new.x + roverd;
X    new.y *= d1overd;
X
X    /* Watch for divide underflow */
X    if ((t2 = tmp.x * tmp.x + tmp.y * tmp.y) < FLT_MIN)
X      return(1);
X    else
X    {
X    t2 = 1.0 / t2;
X    old.x = t2 * (new.x * tmp.x + new.y * tmp.y);
X    old.y = t2 * (new.y * tmp.x - new.x * tmp.y);
X    }
X    return(0);
X}
X
X
X
X#endif /* newton code only used by xfractint */
X
Xcomplex_mult(arg1,arg2,pz)
X_CMPLX arg1,arg2,*pz;
X{
X   pz->x = arg1.x*arg2.x - arg1.y*arg2.y;
X   pz->y = arg1.x*arg2.y+arg1.y*arg2.x;
X   return(0);
X}
X
X
Xcomplex_div(numerator,denominator,pout)
X_CMPLX numerator,denominator,*pout;
X{
X   double mod;
X   if((mod = modulus(denominator)) < FLT_MIN)
X      return(1);
X   conjugate(&denominator);
X   complex_mult(numerator,denominator,pout);
X   pout->x = pout->x/mod;
X   pout->y = pout->y/mod;
X   return(0);
X}
X
X#ifndef XFRACT
Xstruct MP mproverd, mpd1overd, mpthreshold,sqrmpthreshold;
Xstruct MP mpt2;
Xstruct MP mpone;
Xextern struct MPC MPCone;
Xextern int MPOverflow;
X#endif
X
Xint MPCNewtonFractal()
X{
X#ifndef XFRACT
X    MPOverflow = 0;
X    mpctmp   = MPCpow(mpcold,degree-1);
X
X    mpcnew.x = *pMPsub(*pMPmul(mpctmp.x,mpcold.x),*pMPmul(mpctmp.y,mpcold.y));
X    mpcnew.y = *pMPadd(*pMPmul(mpctmp.x,mpcold.y),*pMPmul(mpctmp.y,mpcold.x));
X    mpctmp1.x = *pMPsub(mpcnew.x, MPCone.x);
X    mpctmp1.y = *pMPsub(mpcnew.y, MPCone.y);
X    if(pMPcmp(MPCmod(mpctmp1),mpthreshold)< 0)
X    {
X      if(fractype==MPNEWTBASIN)
X      {
X     int tmpcolor;
X     int i;
X     tmpcolor = -1;
X     for(i=0;i<degree;i++)
X         if(pMPcmp(MPdistance(MPCroots[i],mpcold),mpthreshold) < 0)
X         {
X        if(basin==2)
X           tmpcolor = 1+(i&7) + ((color&1)<<3);
X        else
X           tmpcolor = 1+i;
X            break;
X         }
X      if(tmpcolor == -1)
X         color = maxcolor;
X      else
X         color = tmpcolor;
X      }
X       return(1);
X    }
X
X    mpcnew.x = *pMPadd(*pMPmul(mpd1overd,mpcnew.x),mproverd);
X    mpcnew.y = *pMPmul(mpcnew.y,mpd1overd);
X    mpt2 = MPCmod(mpctmp);
X    mpt2 = *pMPdiv(mpone,mpt2);
X    mpcold.x = *pMPmul(mpt2,(*pMPadd(*pMPmul(mpcnew.x,mpctmp.x),*pMPmul(mpcnew.y,mpctmp.y))));
X    mpcold.y = *pMPmul(mpt2,(*pMPsub(*pMPmul(mpcnew.y,mpctmp.x),*pMPmul(mpcnew.x,mpctmp.y))));
X    new.x = *pMP2d(mpcold.x);
X    new.y = *pMP2d(mpcold.y);
X    return(MPOverflow);
X#endif
X}
X
X
XBarnsley1Fractal()
X{
X#ifndef XFRACT
X   /* Barnsley's Mandelbrot type M1 from "Fractals
X   Everywhere" by Michael Barnsley, p. 322 */
X
X   /* calculate intermediate products */
X   oldxinitx   = multiply(lold.x, longparm->x, bitshift);
X   oldyinity   = multiply(lold.y, longparm->y, bitshift);
X   oldxinity   = multiply(lold.x, longparm->y, bitshift);
X   oldyinitx   = multiply(lold.y, longparm->x, bitshift);
X   /* orbit calculation */
X   if(lold.x >= 0)
X   {
X      lnew.x = (oldxinitx - longparm->x - oldyinity);
X      lnew.y = (oldyinitx - longparm->y + oldxinity);
X   }
X   else
X   {
X      lnew.x = (oldxinitx + longparm->x - oldyinity);
X      lnew.y = (oldyinitx + longparm->y + oldxinity);
X   }
X   return(longbailout());
X#endif
X}
X
XBarnsley1FPFractal()
X{
X   /* Barnsley's Mandelbrot type M1 from "Fractals
X   Everywhere" by Michael Barnsley, p. 322 */
X   /* note that fast >= 287 equiv in fracsuba.asm must be kept in step */
X
X   /* calculate intermediate products */
X   foldxinitx = old.x * floatparm->x;
X   foldyinity = old.y * floatparm->y;
X   foldxinity = old.x * floatparm->y;
X   foldyinitx = old.y * floatparm->x;
X   /* orbit calculation */
X   if(old.x >= 0)
X   {
X      new.x = (foldxinitx - floatparm->x - foldyinity);
X      new.y = (foldyinitx - floatparm->y + foldxinity);
X   }
X   else
X   {
X      new.x = (foldxinitx + floatparm->x - foldyinity);
X      new.y = (foldyinitx + floatparm->y + foldxinity);
X   }
X   return(floatbailout());
X}
X
XBarnsley2Fractal()
X{
X#ifndef XFRACT
X   /* An unnamed Mandelbrot/Julia function from "Fractals
X   Everywhere" by Michael Barnsley, p. 331, example 4.2 */
X   /* note that fast >= 287 equiv in fracsuba.asm must be kept in step */
X
X   /* calculate intermediate products */
X   oldxinitx   = multiply(lold.x, longparm->x, bitshift);
X   oldyinity   = multiply(lold.y, longparm->y, bitshift);
X   oldxinity   = multiply(lold.x, longparm->y, bitshift);
X   oldyinitx   = multiply(lold.y, longparm->x, bitshift);
X
X   /* orbit calculation */
X   if(oldxinity + oldyinitx >= 0)
X   {
X      lnew.x = oldxinitx - longparm->x - oldyinity;
X      lnew.y = oldyinitx - longparm->y + oldxinity;
X   }
X   else
X   {
X      lnew.x = oldxinitx + longparm->x - oldyinity;
X      lnew.y = oldyinitx + longparm->y + oldxinity;
X   }
X   return(longbailout());
X#endif
X}
X
XBarnsley2FPFractal()
X{
X   /* An unnamed Mandelbrot/Julia function from "Fractals
X   Everywhere" by Michael Barnsley, p. 331, example 4.2 */
X
X   /* calculate intermediate products */
X   foldxinitx = old.x * floatparm->x;
X   foldyinity = old.y * floatparm->y;
X   foldxinity = old.x * floatparm->y;
X   foldyinitx = old.y * floatparm->x;
X
X   /* orbit calculation */
X   if(foldxinity + foldyinitx >= 0)
X   {
X      new.x = foldxinitx - floatparm->x - foldyinity;
X      new.y = foldyinitx - floatparm->y + foldxinity;
X   }
X   else
X   {
X      new.x = foldxinitx + floatparm->x - foldyinity;
X      new.y = foldyinitx + floatparm->y + foldxinity;
X   }
X   return(floatbailout());
X}
X
XJuliaFractal()
X{
X#ifndef XFRACT
X   /* used for C prototype of fast integer math routines for classic
X      Mandelbrot and Julia */
X   lnew.x  = ltempsqrx - ltempsqry + longparm->x;
X   lnew.y = multiply(lold.x, lold.y, bitshiftless1) + longparm->y;
X   return(longbailout());
X#elif !defined(__386BSD__)
X   fprintf(stderr,"JuliaFractal called\n");
X   exit(-1);
X#endif
X}
X
XJuliafpFractal()
X{
X   /* floating point version of classical Mandelbrot/Julia */
X   /* note that fast >= 287 equiv in fracsuba.asm must be kept in step */
X   new.x = tempsqrx - tempsqry + floatparm->x;
X   new.y = 2.0 * old.x * old.y + floatparm->y;
X   return(floatbailout());
X}
X
Xstatic double f(double x, double y)
X{
X   return(x - x*y);
X}
X
Xstatic double g(double x, double y)
X{
X   return(-y + x*y);
X}
X
XLambdaFPFractal()
X{
X   /* variation of classical Mandelbrot/Julia */
X   /* note that fast >= 287 equiv in fracsuba.asm must be kept in step */
X
X   tempsqrx = old.x - tempsqrx + tempsqry;
X   tempsqry = -(old.y * old.x);
X   tempsqry += tempsqry + old.y;
X
X   new.x = floatparm->x * tempsqrx - floatparm->y * tempsqry;
X   new.y = floatparm->x * tempsqry + floatparm->y * tempsqrx;
X   return(floatbailout());
X}
X
XLambdaFractal()
X{
X#ifndef XFRACT
X   /* variation of classical Mandelbrot/Julia */
X
X   /* in complex math) temp = Z * (1-Z) */
X   ltempsqrx = lold.x - ltempsqrx + ltempsqry;
X   ltempsqry = lold.y
X         - multiply(lold.y, lold.x, bitshiftless1);
X   /* (in complex math) Z = Lambda * Z */
X   lnew.x = multiply(longparm->x, ltempsqrx, bitshift)
X    - multiply(longparm->y, ltempsqry, bitshift);
X   lnew.y = multiply(longparm->x, ltempsqry, bitshift)
X    + multiply(longparm->y, ltempsqrx, bitshift);
X   return(longbailout());
X#endif
X}
X
XSierpinskiFractal()
X{
X#ifndef XFRACT
X   /* following code translated from basic - see "Fractals
X   Everywhere" by Michael Barnsley, p. 251, Program 7.1.1 */
X   lnew.x = (lold.x << 1);        /* new.x = 2 * old.x  */
X   lnew.y = (lold.y << 1);        /* new.y = 2 * old.y  */
X   if(lold.y > ltmp.y)    /* if old.y > .5 */
X      lnew.y = lnew.y - ltmp.x; /* new.y = 2 * old.y - 1 */
X   else if(lold.x > ltmp.y)    /* if old.x > .5 */
X      lnew.x = lnew.x - ltmp.x; /* new.x = 2 * old.x - 1 */
X   /* end barnsley code */
X   return(longbailout());
X#endif
X}
X
XSierpinskiFPFractal()
X{
X   /* following code translated from basic - see "Fractals
X   Everywhere" by Michael Barnsley, p. 251, Program 7.1.1 */
X
X   new.x = old.x + old.x;
X   new.y = old.y + old.y;
X   if(old.y > .5)
X      new.y = new.y - 1;
X   else if (old.x > .5)
X      new.x = new.x - 1;
X
X   /* end barnsley code */
X   return(floatbailout());
X}
X
XLambdaexponentFractal()
X{
X   /* found this in  "Science of Fractal Images" */
X   FLOATEXPBAILOUT();
X   FPUsincos  (&old.y,&siny,&cosy);
X
X   if (old.x >= rqlim && cosy >= 0.0) return(1);
X   tmpexp = exp(old.x);
X   tmp.x = tmpexp*cosy;
X   tmp.y = tmpexp*siny;
X
X   /*multiply by lamda */
X   new.x = floatparm->x*tmp.x - floatparm->y*tmp.y;
X   new.y = floatparm->y*tmp.x + floatparm->x*tmp.y;
X   old = new;
X   return(0);
X}
X
XLongLambdaexponentFractal()
X{
X#ifndef XFRACT
X   /* found this in  "Science of Fractal Images" */
X   LONGEXPBAILOUT();
X
X   SinCos086  (lold.y, &lsiny,    &lcosy);
X
X   if (lold.x >= llimit && lcosy >= 0L) return(1);
X   longtmp = Exp086(lold.x);
X
X   ltmp.x = multiply(longtmp,       lcosy,   bitshift);
X   ltmp.y = multiply(longtmp,       lsiny,   bitshift);
X
X   lnew.x  = multiply(longparm->x, ltmp.x, bitshift)
X       - multiply(longparm->y, ltmp.y, bitshift);
X   lnew.y  = multiply(longparm->x, ltmp.y, bitshift)
X       + multiply(longparm->y, ltmp.x, bitshift);
X   lold = lnew;
X   return(0);
X#endif
X}
X
XFloatTrigPlusExponentFractal()
X{
X   /* another Scientific American biomorph type */
X   /* z(n+1) = e**z(n) + trig(z(n)) + C */
X
X   if (fabs(old.x) >= 6.4e2) return(1); /* DOMAIN errors */
X   tmpexp = exp(old.x);
X   FPUsincos  (&old.y,&siny,&cosy);
X   CMPLXtrig0(old,new);
X
X   /*new =   trig(old) + e**old + C  */
X   new.x += tmpexp*cosy + floatparm->x;
X   new.y += tmpexp*siny + floatparm->y;
X   return(floatbailout());
X}
X
X
XLongTrigPlusExponentFractal()
X{
X#ifndef XFRACT
X   /* calculate exp(z) */
X
X   /* domain check for fast transcendental functions */
X   TRIG16CHECK(lold.x);
X   TRIG16CHECK(lold.y);
X
X   longtmp = Exp086(lold.x);
X   SinCos086  (lold.y, &lsiny,    &lcosy);
X   LCMPLXtrig0(lold,lnew);
X   lnew.x += multiply(longtmp,      lcosy,   bitshift) + longparm->x;
X   lnew.y += multiply(longtmp,      lsiny,   bitshift) + longparm->y;
X   return(longbailout());
X#endif
X}
X
XMarksLambdaFractal()
X{
X   /* Mark Peterson's variation of "lambda" function */
X
X   /* Z1 = (C^(exp-1) * Z**2) + C */
X   ltmp.x = ltempsqrx - ltempsqry;
X   ltmp.y = multiply(lold.x ,lold.y ,bitshiftless1);
X
X   lnew.x = multiply(lcoefficient.x, ltmp.x, bitshift)
X    - multiply(lcoefficient.y, ltmp.y, bitshift) + longparm->x;
X   lnew.y = multiply(lcoefficient.x, ltmp.y, bitshift)
X    + multiply(lcoefficient.y, ltmp.x, bitshift) + longparm->y;
X
X   return(longbailout());
X}
X
XMarksLambdafpFractal()
X{
X   /* Mark Peterson's variation of "lambda" function */
X
X   /* Z1 = (C^(exp-1) * Z**2) + C */
X   tmp.x = tempsqrx - tempsqry;
X   tmp.y = old.x * old.y *2;
X
X   new.x = coefficient.x * tmp.x - coefficient.y * tmp.y + floatparm->x;
X   new.y = coefficient.x * tmp.y + coefficient.y * tmp.x + floatparm->y;
X
X   return(floatbailout());
X}
X
X
Xlong XXOne, FgOne, FgTwo;
X
XUnityFractal()
X{
X#ifndef XFRACT
X   /* brought to you by Mark Peterson - you won't find this in any fractal
X      books unless they saw it here first - Mark invented it! */
X   XXOne = multiply(lold.x, lold.x, bitshift) + multiply(lold.y, lold.y, bitshift);
X   if((XXOne > FgTwo) || (labs(XXOne - FgOne) < delmin))
X      return(1);
X   lold.y = multiply(FgTwo - XXOne, lold.x, bitshift);
X   lold.x = multiply(FgTwo - XXOne, lold.y, bitshift);
X   lnew=lold;  /* TW added this line */
X   return(0);
X#endif
X}
X
X#define XXOne new.x
X
XUnityfpFractal()
X{
X   /* brought to you by Mark Peterson - you won't find this in any fractal
X      books unless they saw it here first - Mark invented it! */
X
X   XXOne = sqr(old.x) + sqr(old.y);
X   if((XXOne > 2.0) || (fabs(XXOne - 1.0) < ddelmin))
X      return(1);
X   old.y = (2.0 - XXOne)* old.x;
X   old.x = (2.0 - XXOne)* old.y;
X   new=old;  /* TW added this line */
X   return(0);
X}
X
X#undef XXOne
X
XMandel4Fractal()
X{
X   /* By writing this code, Bert has left behind the excuse "don't
X      know what a fractal is, just know how to make'em go fast".
X      Bert is hereby declared a bonafide fractal expert! Supposedly
X      this routine calculates the Mandelbrot/Julia set based on the
X      polynomial z**4 + lambda, but I wouldn't know -- can't follow
X      all that integer math speedup stuff - Tim */
X
X   /* first, compute (x + iy)**2 */
X   lnew.x  = ltempsqrx - ltempsqry;
X   lnew.y = multiply(lold.x, lold.y, bitshiftless1);
X   if (longbailout()) return(1);
X
X   /* then, compute ((x + iy)**2)**2 + lambda */
X   lnew.x  = ltempsqrx - ltempsqry + longparm->x;
X   lnew.y = multiply(lold.x, lold.y, bitshiftless1) + longparm->y;
X   return(longbailout());
X}
X
XMandel4fpFractal()
X{
X   /* first, compute (x + iy)**2 */
X   new.x  = tempsqrx - tempsqry;
X   new.y = old.x*old.y*2;
X   if (floatbailout()) return(1);
X
X   /* then, compute ((x + iy)**2)**2 + lambda */
X   new.x  = tempsqrx - tempsqry + floatparm->x;
X   new.y =  old.x*old.y*2 + floatparm->y;
X   return(floatbailout());
X}
X
XfloatZtozPluszpwrFractal()
X{
X   cpower(&old,(int)param[2],&new);
X   old = ComplexPower(old,old);
X   new.x = new.x + old.x +floatparm->x;
X   new.y = new.y + old.y +floatparm->y;
X   return(floatbailout());
X}
X
XlongZpowerFractal()
X{
X#ifndef XFRACT
X   if(lcpower(&lold,c_exp,&lnew,bitshift))
X      lnew.x = lnew.y = 8L<<bitshift;
X   lnew.x += longparm->x;
X   lnew.y += longparm->y;
X   return(longbailout());
X#endif
X}
X
XlongCmplxZpowerFractal()
X{
X#ifndef XFRACT
X   _CMPLX x, y;
X
X   x.x = (double)lold.x / fudge;
X   x.y = (double)lold.y / fudge;
X   y.x = (double)lparm2.x / fudge;
X   y.y = (double)lparm2.y / fudge;
X   x = ComplexPower(x, y);
X   if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
X      lnew.x = (long)(x.x * fudge);
X      lnew.y = (long)(x.y * fudge);
X   }
X   else
X      overflow = 1;
X   lnew.x += longparm->x;
X   lnew.y += longparm->y;
X   return(longbailout());
X#endif
X}
X
XfloatZpowerFractal()
X{
X   cpower(&old,c_exp,&new);
X   new.x += floatparm->x;
X   new.y += floatparm->y;
X   return(floatbailout());
X}
X
XfloatCmplxZpowerFractal()
X{
X   new = ComplexPower(old, parm2);
X   new.x += floatparm->x;
X   new.y += floatparm->y;
X   return(floatbailout());
X}
X
XBarnsley3Fractal()
X{
X   /* An unnamed Mandelbrot/Julia function from "Fractals
X   Everywhere" by Michael Barnsley, p. 292, example 4.1 */
X
X   /* calculate intermediate products */
X   oldxinitx   = multiply(lold.x, lold.x, bitshift);
X   oldyinity   = multiply(lold.y, lold.y, bitshift);
X   oldxinity   = multiply(lold.x, lold.y, bitshift);
X
X   /* orbit calculation */
X   if(lold.x > 0)
X   {
X      lnew.x = oldxinitx   - oldyinity - fudge;
X      lnew.y = oldxinity << 1;
X   }
X   else
X   {
X      lnew.x = oldxinitx - oldyinity - fudge
X       + multiply(longparm->x,lold.x,bitshift);
X      lnew.y = oldxinity <<1;
X
X      /* This term added by Tim Wegner to make dependent on the
X     imaginary part of the parameter. (Otherwise Mandelbrot
X     is uninteresting. */
X      lnew.y += multiply(longparm->y,lold.x,bitshift);
X   }
X   return(longbailout());
X}
X
XBarnsley3FPFractal()
X{
X   /* An unnamed Mandelbrot/Julia function from "Fractals
X   Everywhere" by Michael Barnsley, p. 292, example 4.1 */
X
X
X   /* calculate intermediate products */
X   foldxinitx  = old.x * old.x;
X   foldyinity  = old.y * old.y;
X   foldxinity  = old.x * old.y;
X
X   /* orbit calculation */
X   if(old.x > 0)
X   {
X      new.x = foldxinitx - foldyinity - 1.0;
X      new.y = foldxinity * 2;
X   }
X   else
X   {
X      new.x = foldxinitx - foldyinity -1.0 + floatparm->x * old.x;
X      new.y = foldxinity * 2;
X
X      /* This term added by Tim Wegner to make dependent on the
X     imaginary part of the parameter. (Otherwise Mandelbrot
X     is uninteresting. */
X      new.y += floatparm->y * old.x;
X   }
X   return(floatbailout());
X}
X
XTrigPlusZsquaredFractal()
X{
X#ifndef XFRACT
X   /* From Scientific American, July 1989 */
X   /* A Biomorph              */
X   /* z(n+1) = trig(z(n))+z(n)**2+C      */
X   LCMPLXtrig0(lold,lnew);
X   lnew.x += ltempsqrx - ltempsqry + longparm->x;
X   lnew.y += multiply(lold.x, lold.y, bitshiftless1) + longparm->y;
X   return(longbailout());
X#endif
X}
X
XTrigPlusZsquaredfpFractal()
X{
X   /* From Scientific American, July 1989 */
X   /* A Biomorph              */
X   /* z(n+1) = trig(z(n))+z(n)**2+C      */
X
X   CMPLXtrig0(old,new);
X   new.x += tempsqrx - tempsqry + floatparm->x;
X   new.y += 2.0 * old.x * old.y + floatparm->y;
X   return(floatbailout());
X}
X
XRichard8fpFractal()
X{
X   /*  Richard8 {c = z = pixel: z=sin(z)+sin(pixel),|z|<=50} */
X   CMPLXtrig0(old,new);
X/*   CMPLXtrig1(*floatparm,tmp); */
X   new.x += tmp.x;
X   new.y += tmp.y;
X   return(floatbailout());
X}
X
XRichard8Fractal()
X{
X#ifndef XFRACT
X   /*  Richard8 {c = z = pixel: z=sin(z)+sin(pixel),|z|<=50} */
X   LCMPLXtrig0(lold,lnew);
X/*   LCMPLXtrig1(*longparm,ltmp); */
X   lnew.x += ltmp.x;
X   lnew.y += ltmp.y;
X   return(longbailout());
X#endif
X}
X
XPopcornFractal()
X{
X   extern int row;
X   tmp = old;
X   tmp.x *= 3.0;
X   tmp.y *= 3.0;
X   FPUsincos(&tmp.x,&sinx,&cosx);
X   FPUsincos(&tmp.y,&siny,&cosy);
X   tmp.x = sinx/cosx + old.x;
X   tmp.y = siny/cosy + old.y;
X   FPUsincos(&tmp.x,&sinx,&cosx);
X   FPUsincos(&tmp.y,&siny,&cosy);
X   new.x = old.x - parm.x*siny;
X   new.y = old.y - parm.x*sinx;
X   /*
X   new.x = old.x - parm.x*sin(old.y+tan(3*old.y));
X   new.y = old.y - parm.x*sin(old.x+tan(3*old.x));
X   */
X   if(plot == noplot)
X   {
X      plot_orbit(new.x,new.y,1+row%colors);
X      old = new;
X   }
X   else
X   /* FLOATBAILOUT(); */
X   /* PB The above line was weird, not what it seems to be!  But, bracketing
X     it or always doing it (either of which seem more likely to be what
X     was intended) changes the image for the worse, so I'm not touching it.
X     Same applies to int form in next routine. */
X   /* PB later: recoded inline, still leaving it weird */
X      tempsqrx = sqr(new.x);
X   tempsqry = sqr(new.y);
X   if((magnitude = tempsqrx + tempsqry) >= rqlim) return(1);
X   old = new;
X   return(0);
X}
X
XLPopcornFractal()
X{
X#ifndef XFRACT
X   extern int row;
X   ltmp = lold;
X   ltmp.x *= 3L;
X   ltmp.y *= 3L;
X   LTRIGARG(ltmp.x);
X   LTRIGARG(ltmp.y);
X   SinCos086(ltmp.x,&lsinx,&lcosx);
X   SinCos086(ltmp.y,&lsiny,&lcosy);
X   ltmp.x = divide(lsinx,lcosx,bitshift) + lold.x;
X   ltmp.y = divide(lsiny,lcosy,bitshift) + lold.y;
X   LTRIGARG(ltmp.x);
X   LTRIGARG(ltmp.y);
X   SinCos086(ltmp.x,&lsinx,&lcosx);
X   SinCos086(ltmp.y,&lsiny,&lcosy);
X   lnew.x = lold.x - multiply(lparm.x,lsiny,bitshift);
X   lnew.y = lold.y - multiply(lparm.x,lsinx,bitshift);
X   if(plot == noplot)
X   {
X      iplot_orbit(lnew.x,lnew.y,1+row%colors);
X      lold = lnew;
X   }
X   else
X      LONGBAILOUT();
X   /* PB above still the old way, is weird, see notes in FP popcorn case */
X   return(0);
X#endif
X}
X
Xint MarksCplxMand(void)
X{
X   tmp.x = tempsqrx - tempsqry;
X   tmp.y = 2*old.x*old.y;
X   FPUcplxmul(&tmp, &Coefficient, &new);
X   new.x += floatparm->x;
X   new.y += floatparm->y;
X   return(floatbailout());
X}
X
Xint SpiderfpFractal(void)
X{
X   /* Spider(XAXIS) { c=z=pixel: z=z*z+c; c=c/2+z, |z|<=4 } */
X   new.x = tempsqrx - tempsqry + tmp.x;
X   new.y = 2 * old.x * old.y + tmp.y;
X   tmp.x = tmp.x/2 + new.x;
X   tmp.y = tmp.y/2 + new.y;
X   return(floatbailout());
X}
X
XSpiderFractal(void)
X{
X#ifndef XFRACT
X   /* Spider(XAXIS) { c=z=pixel: z=z*z+c; c=c/2+z, |z|<=4 } */
X   lnew.x  = ltempsqrx - ltempsqry + ltmp.x;
X   lnew.y = multiply(lold.x, lold.y, bitshiftless1) + ltmp.y;
X   ltmp.x = (ltmp.x >> 1) + lnew.x;
X   ltmp.y = (ltmp.y >> 1) + lnew.y;
X   return(longbailout());
X#endif
X}
X
XTetratefpFractal()
X{
X   /* Tetrate(XAXIS) { c=z=pixel: z=c^z, |z|<=(P1+3) } */
X   new = ComplexPower(*floatparm,old);
X   return(floatbailout());
X}
X
XZXTrigPlusZFractal()
X{
X#ifndef XFRACT
X   /* z = (p1*z*trig(z))+p2*z */
X   LCMPLXtrig0(lold,ltmp);        /* ltmp  = trig(old)         */
X   LCMPLXmult(lparm,ltmp,ltmp);      /* ltmp  = p1*trig(old)          */
X   LCMPLXmult(lold,ltmp,ltmp2);      /* ltmp2 = p1*old*trig(old)      */
X   LCMPLXmult(lparm2,lold,ltmp);     /* ltmp  = p2*old              */
X   LCMPLXadd(ltmp2,ltmp,lnew);         /* lnew  = p1*trig(old) + p2*old */
X   return(longbailout());
X#endif
X}
X
XScottZXTrigPlusZFractal()
X{
X#ifndef XFRACT
X   /* z = (z*trig(z))+z */
X   LCMPLXtrig0(lold,ltmp);        /* ltmp  = trig(old)       */
X   LCMPLXmult(lold,ltmp,lnew);         /* lnew  = old*trig(old)    */
X   LCMPLXadd(lnew,lold,lnew);         /* lnew  = trig(old) + old */
X   return(longbailout());
X#endif
X}
X
XSkinnerZXTrigSubZFractal()
X{
X#ifndef XFRACT
X   /* z = (z*trig(z))-z */
X   LCMPLXtrig0(lold,ltmp);        /* ltmp  = trig(old)       */
X   LCMPLXmult(lold,ltmp,lnew);         /* lnew  = old*trig(old)    */
X   LCMPLXsub(lnew,lold,lnew);         /* lnew  = trig(old) - old */
X   return(longbailout());
X#endif
X}
X
XZXTrigPlusZfpFractal()
X{
X   /* z = (p1*z*trig(z))+p2*z */
X   CMPLXtrig0(old,tmp);      /* tmp  = trig(old)         */
X   CMPLXmult(parm,tmp,tmp);     /* tmp  = p1*trig(old)      */
X   CMPLXmult(old,tmp,tmp2);     /* tmp2 = p1*old*trig(old)     */
X   CMPLXmult(parm2,old,tmp);     /* tmp  = p2*old         */
X   CMPLXadd(tmp2,tmp,new);     /* new  = p1*trig(old) + p2*old */
X   return(floatbailout());
X}
X
XScottZXTrigPlusZfpFractal()
X{
X   /* z = (z*trig(z))+z */
X   CMPLXtrig0(old,tmp);     /* tmp    = trig(old)      */
X   CMPLXmult(old,tmp,new);     /* new  = old*trig(old)   */
X   CMPLXadd(new,old,new);     /* new  = trig(old) + old */
X   return(floatbailout());
X}
X
XSkinnerZXTrigSubZfpFractal()
X{
X   /* z = (z*trig(z))-z */
X   CMPLXtrig0(old,tmp);     /* tmp    = trig(old)      */
X   CMPLXmult(old,tmp,new);     /* new  = old*trig(old)   */
X   CMPLXsub(new,old,new);     /* new  = trig(old) - old */
X   return(floatbailout());
X}
X
XSqr1overTrigFractal()
X{
X#ifndef XFRACT
X   /* z = sqr(1/trig(z)) */
X   LCMPLXtrig0(lold,lold);
X   LCMPLXrecip(lold,lold);
X   LCMPLXsqr(lold,lnew);
X   return(longbailout());
X#endif
X}
X
XSqr1overTrigfpFractal()
X{
X   /* z = sqr(1/trig(z)) */
X   CMPLXtrig0(old,old);
X   CMPLXrecip(old,old);
X   CMPLXsqr(old,new);
X   return(floatbailout());
X}
X
XTrigPlusTrigFractal()
X{
X#ifndef XFRACT
X   /* z = trig(0,z)*p1+trig1(z)*p2 */
X   LCMPLXtrig0(lold,ltmp);
X   LCMPLXmult(lparm,ltmp,ltmp);
X   LCMPLXtrig1(lold,ltmp2);
X   LCMPLXmult(lparm2,ltmp2,lold);
X   LCMPLXadd(ltmp,lold,lnew);
X   return(longbailout());
X#endif
X}
X
XTrigPlusTrigfpFractal()
X{
X   /* z = trig0(z)*p1+trig1(z)*p2 */
X   CMPLXtrig0(old,tmp);
X   CMPLXmult(parm,tmp,tmp);
X   CMPLXtrig1(old,old);
X   CMPLXmult(parm2,old,old);
X   CMPLXadd(tmp,old,new);
X   return(floatbailout());
X}
X
X/* The following four fractals are based on the idea of parallel
X   or alternate calculations.  The shift is made when the mod
X   reaches a given value.  JCO  5/6/92 */
X
XLambdaTrigOrTrigFractal()
X{
X#ifndef XFRACT
X   /* z = trig0(z)*p1 if mod(old) < p2.x and
X          trig1(z)*p1 if mod(old) >= p2.x */
X   if ((LCMPLXmod(lold)) < lparm2.x){
X     LCMPLXtrig0(lold,ltmp);
X     LCMPLXmult(*longparm,ltmp,lnew);}
X   else{
X     LCMPLXtrig1(lold,ltmp);
X     LCMPLXmult(*longparm,ltmp,lnew);}
X   return(longbailout());
X#endif
X}
X
XLambdaTrigOrTrigfpFractal()
X{
X   /* z = trig0(z)*p1 if mod(old) < p2.x and
X          trig1(z)*p1 if mod(old) >= p2.x */
X   if (CMPLXmod(old) < parm2.x){
X     CMPLXtrig0(old,old);
X     FPUcplxmul(floatparm,&old,&new);}
X   else{
X     CMPLXtrig1(old,old);
X     FPUcplxmul(floatparm,&old,&new);}
X   return(floatbailout());
X}
X
XJuliaTrigOrTrigFractal()
X{
X#ifndef XFRACT
X   /* z = trig0(z)+p1 if mod(old) < p2.x and
X          trig1(z)+p1 if mod(old) >= p2.x */
X   if (LCMPLXmod(lold) < lparm2.x){
X     LCMPLXtrig0(lold,ltmp);
X     LCMPLXadd(*longparm,ltmp,lnew);}
X   else{
X     LCMPLXtrig1(lold,ltmp);
X     LCMPLXadd(*longparm,ltmp,lnew);}
X   return(longbailout());
X#endif
X}
X
XJuliaTrigOrTrigfpFractal()
X{
X   /* z = trig0(z)+p1 if mod(old) < p2.x and
X          trig1(z)+p1 if mod(old) >= p2.x */
X   if (CMPLXmod(old) < parm2.x){
X     CMPLXtrig0(old,old);
X     CMPLXadd(*floatparm,old,new);}
X   else{
X     CMPLXtrig1(old,old);
X     CMPLXadd(*floatparm,old,new);}
X   return(floatbailout());
X}
X
Xstatic int AplusOne, Ap1deg;
Xstatic struct MP mpAplusOne, mpAp1deg, mptmpparmy;
X
Xint MPCHalleyFractal()
X{
X#ifndef XFRACT
X   /*  X(X^a - 1) = 0, Halley Map */
X   /*  a = parm.x,  relaxation coeff. = parm.y,  epsilon = parm2.x  */
X
Xint ihal;
Xstruct MPC mpcXtoAlessOne, mpcXtoA;
Xstruct MPC mpcXtoAplusOne; /* a-1, a, a+1 */
Xstruct MPC mpcFX, mpcF1prime, mpcF2prime, mpcHalnumer1;
Xstruct MPC mpcHalnumer2, mpcHaldenom, mpctmp;
X
X   MPOverflow = 0;
X   mpcXtoAlessOne.x = mpcold.x;
X   mpcXtoAlessOne.y = mpcold.y;
X   for(ihal=2; ihal<degree; ihal++) {
X     mpctmp.x = *pMPsub(*pMPmul(mpcXtoAlessOne.x,mpcold.x),*pMPmul(mpcXtoAlessOne.y,mpcold.y));
X     mpctmp.y = *pMPadd(*pMPmul(mpcXtoAlessOne.x,mpcold.y),*pMPmul(mpcXtoAlessOne.y,mpcold.x));
X     mpcXtoAlessOne.x = mpctmp.x;
X     mpcXtoAlessOne.y = mpctmp.y;
X   }
X   mpcXtoA.x = *pMPsub(*pMPmul(mpcXtoAlessOne.x,mpcold.x),*pMPmul(mpcXtoAlessOne.y,mpcold.y));
X   mpcXtoA.y = *pMPadd(*pMPmul(mpcXtoAlessOne.x,mpcold.y),*pMPmul(mpcXtoAlessOne.y,mpcold.x));
X   mpcXtoAplusOne.x = *pMPsub(*pMPmul(mpcXtoA.x,mpcold.x),*pMPmul(mpcXtoA.y,mpcold.y));
X   mpcXtoAplusOne.y = *pMPadd(*pMPmul(mpcXtoA.x,mpcold.y),*pMPmul(mpcXtoA.y,mpcold.x));
X
X   mpcFX.x = *pMPsub(mpcXtoAplusOne.x, mpcold.x);
X   mpcFX.y = *pMPsub(mpcXtoAplusOne.y, mpcold.y); /* FX = X^(a+1) - X  = F */
X
X   mpcF2prime.x = *pMPmul(mpAp1deg, mpcXtoAlessOne.x); /* mpAp1deg in setup */
X   mpcF2prime.y = *pMPmul(mpAp1deg, mpcXtoAlessOne.y);        /* F" */
X
X   mpcF1prime.x = *pMPsub(*pMPmul(mpAplusOne, mpcXtoA.x), mpone);
X   mpcF1prime.y = *pMPmul(mpAplusOne, mpcXtoA.y);                   /*  F'  */
X
X   mpctmp.x = *pMPsub(*pMPmul(mpcF2prime.x,mpcFX.x),*pMPmul(mpcF2prime.y,mpcFX.y));
X   mpctmp.y = *pMPadd(*pMPmul(mpcF2prime.x,mpcFX.y),*pMPmul(mpcF2prime.y,mpcFX.x));
X   /*  F * F"  */
X
X   mpcHaldenom.x = *pMPadd(mpcF1prime.x, mpcF1prime.x);
X   mpcHaldenom.y = *pMPadd(mpcF1prime.y, mpcF1prime.y);      /*  2 * F'  */
X
X   mpcHalnumer1 = MPCdiv(mpctmp, mpcHaldenom);        /*  F"F/2F'  */
X   mpctmp.x = *pMPsub(mpcF1prime.x, mpcHalnumer1.x);
X   mpctmp.y = *pMPsub(mpcF1prime.y, mpcHalnumer1.y); /*  F' - F"F/2F'  */
X   mpcHalnumer2 = MPCdiv(mpcFX, mpctmp);
X
X   mpctmp.x = *pMPmul(mptmpparmy,mpcHalnumer2.x); /* mptmpparmy is */
X   mpctmp.y = *pMPmul(mptmpparmy,mpcHalnumer2.y); /* relaxation coef. */
X   mpcnew.x = *pMPsub(mpcold.x, mpctmp.x);
X   mpcnew.y = *pMPsub(mpcold.y, mpctmp.y);
X
X   new.x = *pMP2d(mpcnew.x);
X   new.y = *pMP2d(mpcnew.y);
X
X   return(MPCHalleybailout()||MPOverflow);
X#endif
X}
X
XHalleyFractal()
X{
X   /*  X(X^a - 1) = 0, Halley Map */
X   /*  a = parm.x = degree, relaxation coeff. = parm.y, epsilon = parm2.x  */
X
Xint ihal;
X_CMPLX XtoAlessOne, XtoA, XtoAplusOne; /* a-1, a, a+1 */
X_CMPLX FX, F1prime, F2prime, Halnumer1, Halnumer2, Haldenom;
X
X   XtoAlessOne = old;
X   for(ihal=2; ihal<degree; ihal++) {
X     FPUcplxmul(&old, &XtoAlessOne, &XtoAlessOne);
X   }
X   FPUcplxmul(&old, &XtoAlessOne, &XtoA);
X   FPUcplxmul(&old, &XtoA, &XtoAplusOne);
X
X   CMPLXsub(XtoAplusOne, old, FX);        /* FX = X^(a+1) - X  = F */
X   F2prime.x = Ap1deg * XtoAlessOne.x; /* Ap1deg in setup */
X   F2prime.y = Ap1deg * XtoAlessOne.y;        /* F" */
X
X   F1prime.x = AplusOne * XtoA.x - 1.0;
X   F1prime.y = AplusOne * XtoA.y;                             /*  F'  */
X
X   FPUcplxmul(&F2prime, &FX, &Halnumer1);                  /*  F * F"  */
X   Haldenom.x = F1prime.x + F1prime.x;
X   Haldenom.y = F1prime.y + F1prime.y;                     /*  2 * F'  */
X
X   FPUcplxdiv(&Halnumer1, &Haldenom, &Halnumer1);         /*  F"F/2F'  */
X   CMPLXsub(F1prime, Halnumer1, Halnumer2);          /*  F' - F"F/2F'  */
X   FPUcplxdiv(&FX, &Halnumer2, &Halnumer2);
X   new.x = old.x - (parm.y * Halnumer2.x); /* parm.y is relaxation coef. */
X   new.y = old.y - (parm.y * Halnumer2.y);
X
X   return(Halleybailout());
X}
X
XLongPhoenixFractal()
X{
X#ifndef XFRACT
X/* z(n+1) = z(n)^2 + p + qy(n),  y(n+1) = z(n) */
X   ltmp.x = multiply(lold.x, lold.y, bitshift);
X   lnew.x = ltempsqrx-ltempsqry+longparm->x+multiply(longparm->y,ltmp2.x,bitshift);
X   lnew.y = (ltmp.x + ltmp.x) + multiply(longparm->y,ltmp2.y,bitshift);
X   ltmp2 = lold; /* set ltmp2 to Y value */
X   return(longbailout());
X#endif
X}
X
XPhoenixFractal()
X{
X/* z(n+1) = z(n)^2 + p + qy(n),  y(n+1) = z(n) */
X   tmp.x = old.x * old.y;
X   new.x = tempsqrx - tempsqry + floatparm->x + (floatparm->y * tmp2.x);
X   new.y = (tmp.x + tmp.x) + (floatparm->y * tmp2.y);
X   tmp2 = old; /* set tmp2 to Y value */
X   return(floatbailout());
X}
X
XLongPhoenixPlusFractal()
X{
X#ifndef XFRACT
X/* z(n+1) = z(n)^(degree-1) * (z(n) + p) + qy(n),  y(n+1) = z(n) */
Xint i;
X_LCMPLX loldplus, lnewminus;
X   loldplus = lold;
X   ltmp = lold;
X   for(i=1; i<degree; i++) { /* degree >= 2, degree=degree-1 in setup */
X      LCMPLXmult(lold,ltmp,ltmp); /* = old^(degree-1) */
X   }
X   loldplus.x += longparm->x;
X   LCMPLXmult(ltmp, loldplus, lnewminus);
X   lnew.x = lnewminus.x + multiply(longparm->y,ltmp2.x,bitshift);
X   lnew.y = lnewminus.y + multiply(longparm->y,ltmp2.y,bitshift);
X   ltmp2 = lold; /* set ltmp2 to Y value */
X   return(longbailout());
X#endif
X}
X
XPhoenixPlusFractal()
X{
X/* z(n+1) = z(n)^(degree-1) * (z(n) + p) + qy(n),  y(n+1) = z(n) */
Xint i;
X_CMPLX oldplus, newminus;
X   oldplus = old;
X   tmp = old;
X   for(i=1; i<degree; i++) { /* degree >= 2, degree=degree-1 in setup */
X     FPUcplxmul(&old, &tmp, &tmp); /* = old^(degree-1) */
X   }
X   oldplus.x += floatparm->x;
X   FPUcplxmul(&tmp, &oldplus, &newminus);
X   new.x = newminus.x + (floatparm->y * tmp2.x);
X   new.y = newminus.y + (floatparm->y * tmp2.y);
X   tmp2 = old; /* set tmp2 to Y value */
X   return(floatbailout());
X}
X
XLongPhoenixMinusFractal()
X{
X#ifndef XFRACT
X/* z(n+1) = z(n)^(degree-2) * (z(n)^2 + p) + qy(n),  y(n+1) = z(n) */
Xint i;
X_LCMPLX loldsqr, lnewminus;
X   LCMPLXmult(lold,lold,loldsqr);
X   ltmp = lold;
X   for(i=1; i<degree; i++) { /* degree >= 3, degree=degree-2 in setup */
X      LCMPLXmult(lold,ltmp,ltmp); /* = old^(degree-2) */
X   }
X   loldsqr.x += longparm->x;
X   LCMPLXmult(ltmp, loldsqr, lnewminus);
X   lnew.x = lnewminus.x + multiply(longparm->y,ltmp2.x,bitshift);
X   lnew.y = lnewminus.y + multiply(longparm->y,ltmp2.y,bitshift);
X   ltmp2 = lold; /* set ltmp2 to Y value */
X   return(longbailout());
X#endif
X}
X
XPhoenixMinusFractal()
X{
X/* z(n+1) = z(n)^(degree-2) * (z(n)^2 + p) + qy(n),  y(n+1) = z(n) */
Xint i;
X_CMPLX oldsqr, newminus;
X   FPUcplxmul(&old, &old, &oldsqr);
X   tmp = old;
X   for(i=1; i<degree; i++) { /* degree >= 3, degree=degree-2 in setup */
X     FPUcplxmul(&old, &tmp, &tmp); /* = old^(degree-2) */
X   }
X   oldsqr.x += floatparm->x;
X   FPUcplxmul(&tmp, &oldsqr, &newminus);
X   new.x = newminus.x + (floatparm->y * tmp2.x);
X   new.y = newminus.y + (floatparm->y * tmp2.y);
X   tmp2 = old; /* set tmp2 to Y value */
X   return(floatbailout());
X}
X
XScottTrigPlusTrigFractal()
X{
X#ifndef XFRACT
X   /* z = trig0(z)+trig1(z) */
X   LCMPLXtrig0(lold,ltmp);
X   LCMPLXtrig1(lold,lold);
X   LCMPLXadd(ltmp,lold,lnew);
X   return(longbailout());
X#endif
X}
X
XScottTrigPlusTrigfpFractal()
X{
X   /* z = trig0(z)+trig1(z) */
X   CMPLXtrig0(old,tmp);
X   CMPLXtrig1(old,tmp2);
X   CMPLXadd(tmp,tmp2,new);
X   return(floatbailout());
X}
X
XSkinnerTrigSubTrigFractal()
X{
X#ifndef XFRACT
X   /* z = trig(0,z)-trig1(z) */
X   LCMPLXtrig0(lold,ltmp);
X   LCMPLXtrig1(lold,ltmp2);
X   LCMPLXsub(ltmp,ltmp2,lnew);
X   return(longbailout());
X#endif
X}
X
XSkinnerTrigSubTrigfpFractal()
X{
X   /* z = trig0(z)-trig1(z) */
X   CMPLXtrig0(old,tmp);
X   CMPLXtrig1(old,tmp2);
X   CMPLXsub(tmp,tmp2,new);
X   return(floatbailout());
X}
X
X
XTrigXTrigfpFractal()
X{
X   /* z = trig0(z)*trig1(z) */
X   CMPLXtrig0(old,tmp);
X   CMPLXtrig1(old,old);
X   CMPLXmult(tmp,old,new);
X   return(floatbailout());
X}
X
XTrigXTrigFractal()
X{
X#ifndef XFRACT
X   _LCMPLX ltmp2;
X   /* z = trig0(z)*trig1(z) */
X   LCMPLXtrig0(lold,ltmp);
X   LCMPLXtrig1(lold,ltmp2);
X   LCMPLXmult(ltmp,ltmp2,lnew);
X   if(overflow)
X      TryFloatFractal(TrigXTrigfpFractal);
X   return(longbailout());
X#endif
X}
X
X /* call float version of fractal if integer math overflow */
XTryFloatFractal(int (*fpFractal)())
X{
X   overflow=0;
X   /* lold had better not be changed! */
X   old.x = lold.x; old.x /= fudge;
X   old.y = lold.y; old.y /= fudge;
X   tempsqrx = sqr(old.x);
X   tempsqry = sqr(old.y);
X   fpFractal();
X   lnew.x = new.x/fudge;
X   lnew.y = new.y/fudge;
X   return(0);
X}
X
X/********************************************************************/
X/*  Next six orbit functions are one type - extra functions are     */
X/*    special cases written for speed.                    */
X/********************************************************************/
X
XTrigPlusSqrFractal() /* generalization of Scott and Skinner types */
X{
X#ifndef XFRACT
X   /* { z=pixel: z=(p1,p2)*trig(z)+(p3,p4)*sqr(z), |z|<BAILOUT } */
X   LCMPLXtrig0(lold,ltmp);     /* ltmp = trig(lold)               */
X   LCMPLXmult(lparm,ltmp,lnew); /* lnew = lparm*trig(lold)            */
X   LCMPLXsqr_old(ltmp);     /* ltmp = sqr(lold)                */
X   LCMPLXmult(lparm2,ltmp,ltmp);/* ltmp = lparm2*sqr(lold)            */
X   LCMPLXadd(lnew,ltmp,lnew);    /* lnew = lparm*trig(lold)+lparm2*sqr(lold) */
X   return(longbailout());
X#endif
X}
X
XTrigPlusSqrfpFractal() /* generalization of Scott and Skinner types */
X{
X   /* { z=pixel: z=(p1,p2)*trig(z)+(p3,p4)*sqr(z), |z|<BAILOUT } */
X   CMPLXtrig0(old,tmp);     /* tmp = trig(old)               */
X   CMPLXmult(parm,tmp,new); /* new = parm*trig(old)           */
X   CMPLXsqr_old(tmp);         /* tmp = sqr(old)                */
X   CMPLXmult(parm2,tmp,tmp2); /* tmp = parm2*sqr(old)             */
X   CMPLXadd(new,tmp2,new);    /* new = parm*trig(old)+parm2*sqr(old) */
X   return(floatbailout());
X}
X
XScottTrigPlusSqrFractal()
X{
X#ifndef XFRACT
X   /*  { z=pixel: z=trig(z)+sqr(z), |z|<BAILOUT } */
X   LCMPLXtrig0(lold,lnew);    /* lnew = trig(lold)         */
X   LCMPLXsqr_old(ltmp);        /* lold = sqr(lold)          */
X   LCMPLXadd(ltmp,lnew,lnew);  /* lnew = trig(lold)+sqr(lold) */
X   return(longbailout());
X#endif
X}
X
XScottTrigPlusSqrfpFractal() /* float version */
X{
X   /* { z=pixel: z=sin(z)+sqr(z), |z|<BAILOUT } */
X   CMPLXtrig0(old,new);       /* new = trig(old)      */
X   CMPLXsqr_old(tmp);           /* tmp = sqr(old)       */
X   CMPLXadd(new,tmp,new);      /* new = trig(old)+sqr(old) */
X   return(floatbailout());
X}
X
XSkinnerTrigSubSqrFractal()
X{
X#ifndef XFRACT
X   /* { z=pixel: z=sin(z)-sqr(z), |z|<BAILOUT }           */
X   LCMPLXtrig0(lold,lnew);    /* lnew = trig(lold)         */
X   LCMPLXsqr_old(ltmp);        /* lold = sqr(lold)          */
X   LCMPLXsub(lnew,ltmp,lnew);  /* lnew = trig(lold)-sqr(lold) */
X   return(longbailout());
X#endif
X}
X
XSkinnerTrigSubSqrfpFractal()
X{
X   /* { z=pixel: z=sin(z)-sqr(z), |z|<BAILOUT } */
X   CMPLXtrig0(old,new);       /* new = trig(old) */
X   CMPLXsqr_old(tmp);           /* old = sqr(old)  */
X   CMPLXsub(new,tmp,new);      /* new = trig(old)-sqr(old) */
X   return(floatbailout());
X}
X
XTrigZsqrdfpFractal()
X{
X   /* { z=pixel: z=trig(z*z), |z|<TEST } */
X   CMPLXsqr_old(tmp);
X   CMPLXtrig0(tmp,new);
X   return(floatbailout());
X}
X
XTrigZsqrdFractal() /* this doesn't work very well */
X{
X#ifndef XFRACT
X   /* { z=pixel: z=trig(z*z), |z|<TEST } */
X   LCMPLXsqr_old(ltmp);
X   LCMPLXtrig0(ltmp,lnew);
X   if(overflow)
X      TryFloatFractal(TrigZsqrdfpFractal);
X   return(longbailout());
X#endif
X}
X
XSqrTrigFractal()
X{
X#ifndef XFRACT
X   /* { z=pixel: z=sqr(trig(z)), |z|<TEST} */
X   LCMPLXtrig0(lold,ltmp);
X   LCMPLXsqr(ltmp,lnew);
X   return(longbailout());
X#endif
X}
X
XSqrTrigfpFractal()
X{
X   /* SZSB(XYAXIS) { z=pixel, TEST=(p1+3): z=sin(z)*sin(z), |z|<TEST} */
X   CMPLXtrig0(old,tmp);
X   CMPLXsqr(tmp,new);
X   return(floatbailout());
X}
X
X
XMagnet1Fractal()    /*      Z = ((Z**2 + C - 1)/(2Z + C - 2))**2      */
X  {              /*  In "Beauty of Fractals", code by Kev Allen. */
X    _CMPLX top, bot, tmp;
X    double div;
X
X    top.x = tempsqrx - tempsqry + floatparm->x - 1; /* top = Z**2+C-1 */
X    top.y = old.x * old.y;
X    top.y = top.y + top.y + floatparm->y;
X
X    bot.x = old.x + old.x + floatparm->x - 2;        /* bot = 2*Z+C-2  */
X    bot.y = old.y + old.y + floatparm->y;
X
X    div = bot.x*bot.x + bot.y*bot.y;            /* tmp = top/bot  */
X    if (div < FLT_MIN) return(1);
X    tmp.x = (top.x*bot.x + top.y*bot.y)/div;
X    tmp.y = (top.y*bot.x - top.x*bot.y)/div;
X
X    new.x = (tmp.x + tmp.y) * (tmp.x - tmp.y);        /* Z = tmp**2     */
X    new.y = tmp.x * tmp.y;
X    new.y += new.y;
X
X    return(floatbailout());
X  }
X
XMagnet2Fractal()  /* Z = ((Z**3 + 3(C-1)Z + (C-1)(C-2)    ) /     */
X            /*         (3Z**2 + 3(C-2)Z + (C-1)(C-2)+1) )**2  */
X  {            /*     In "Beauty of Fractals", code by Kev Allen.  */
X    _CMPLX top, bot, tmp;
X    double div;
X
X    top.x = old.x * (tempsqrx-tempsqry-tempsqry-tempsqry + T_Cm1.x)
X      - old.y * T_Cm1.y + T_Cm1Cm2.x;
X    top.y = old.y * (tempsqrx+tempsqrx+tempsqrx-tempsqry + T_Cm1.x)
X      + old.x * T_Cm1.y + T_Cm1Cm2.y;
X
X    bot.x = tempsqrx - tempsqry;
X    bot.x = bot.x + bot.x + bot.x
X      + old.x * T_Cm2.x - old.y * T_Cm2.y
X      + T_Cm1Cm2.x + 1.0;
X    bot.y = old.x * old.y;
X    bot.y += bot.y;
X    bot.y = bot.y + bot.y + bot.y
X      + old.x * T_Cm2.y + old.y * T_Cm2.x
X      + T_Cm1Cm2.y;
X
X    div = bot.x*bot.x + bot.y*bot.y;            /* tmp = top/bot  */
X    if (div < FLT_MIN) return(1);
X    tmp.x = (top.x*bot.x + top.y*bot.y)/div;
X    tmp.y = (top.y*bot.x - top.x*bot.y)/div;
X
X    new.x = (tmp.x + tmp.y) * (tmp.x - tmp.y);        /* Z = tmp**2     */
X    new.y = tmp.x * tmp.y;
X    new.y += new.y;
X
X    return(floatbailout());
X  }
X
XLambdaTrigFractal()
X{
X#ifndef XFRACT
X   LONGXYTRIGBAILOUT();
X   LCMPLXtrig0(lold,ltmp);         /* ltmp = trig(lold)        */
X   LCMPLXmult(*longparm,ltmp,lnew);   /* lnew = longparm*trig(lold)  */
X   lold = lnew;
X   return(0);
X#endif
X}
X
XLambdaTrigfpFractal()
X{
X   FLOATXYTRIGBAILOUT();
X   CMPLXtrig0(old,tmp);          /* tmp = trig(old)       */
X   CMPLXmult(*floatparm,tmp,new);   /* new = longparm*trig(old)  */
X   old = new;
X   return(0);
X}
X
X/* bailouts are different for different trig functions */
XLambdaTrigFractal1()
X{
X#ifndef XFRACT
X   LONGTRIGBAILOUT(); /* sin,cos */
X   LCMPLXtrig0(lold,ltmp);         /* ltmp = trig(lold)        */
X   LCMPLXmult(*longparm,ltmp,lnew);   /* lnew = longparm*trig(lold)  */
X   lold = lnew;
X   return(0);
X#endif
X}
X
XLambdaTrigfpFractal1()
X{
X   FLOATTRIGBAILOUT(); /* sin,cos */
X   CMPLXtrig0(old,tmp);          /* tmp = trig(old)       */
X   CMPLXmult(*floatparm,tmp,new);   /* new = longparm*trig(old)  */
X   old = new;
X   return(0);
X}
X
XLambdaTrigFractal2()
X{
X#ifndef XFRACT
X   LONGHTRIGBAILOUT(); /* sinh,cosh */
X   LCMPLXtrig0(lold,ltmp);         /* ltmp = trig(lold)        */
X   LCMPLXmult(*longparm,ltmp,lnew);   /* lnew = longparm*trig(lold)  */
X   lold = lnew;
X   return(0);
X#endif
X}
X
XLambdaTrigfpFractal2()
X{
X#ifndef XFRACT
X   FLOATHTRIGBAILOUT(); /* sinh,cosh */
X   CMPLXtrig0(old,tmp);          /* tmp = trig(old)       */
X   CMPLXmult(*floatparm,tmp,new);   /* new = longparm*trig(old)  */
X   old = new;
X   return(0);
X#endif
X}
X
XManOWarFractal()
X{
X#ifndef XFRACT
X   /* From Art Matrix via Lee Skinner */
X   lnew.x  = ltempsqrx - ltempsqry + ltmp.x + longparm->x;
X   lnew.y = multiply(lold.x, lold.y, bitshiftless1) + ltmp.y + longparm->y;
X   ltmp = lold;
X   return(longbailout());
X#endif
X}
X
XManOWarfpFractal()
X{
X   /* From Art Matrix via Lee Skinner */
X   /* note that fast >= 287 equiv in fracsuba.asm must be kept in step */
X   new.x = tempsqrx - tempsqry + tmp.x + floatparm->x;
X   new.y = 2.0 * old.x * old.y + tmp.y + floatparm->y;
X   tmp = old;
X   return(floatbailout());
X}
X
X/*
X   MarksMandelPwr (XAXIS) {
X      z = pixel, c = z ^ (z - 1):
X     z = c * sqr(z) + pixel,
X      |z| <= 4
X   }
X*/
X
XMarksMandelPwrfpFractal()
X{
X   CMPLXtrig0(old,new);
X   CMPLXmult(tmp,new,new);
X   new.x += floatparm->x;
X   new.y += floatparm->y;
X   return(floatbailout());
X}
X
XMarksMandelPwrFractal()
X{
X#ifndef XFRACT
X   LCMPLXtrig0(lold,lnew);
X   LCMPLXmult(ltmp,lnew,lnew);
X   lnew.x += longparm->x;
X   lnew.y += longparm->y;
X   return(longbailout());
X#endif
X}
X
X/* I was coding Marksmandelpower and failed to use some temporary
X   variables. The result was nice, and since my name is not on any fractal,
X   I thought I would immortalize myself with this error!
X        Tim Wegner */
X
X
XTimsErrorfpFractal()
X{
X   CMPLXtrig0(old,new);
X   new.x = new.x * tmp.x - new.y * tmp.y;
X   new.y = new.x * tmp.y - new.y * tmp.x;
X   new.x += floatparm->x;
X   new.y += floatparm->y;
X   return(floatbailout());
X}
XTimsErrorFractal()
X{
X#ifndef XFRACT
X   LCMPLXtrig0(lold,lnew);
X   lnew.x = multiply(lnew.x,ltmp.x,bitshift)-multiply(lnew.y,ltmp.y,bitshift);
X   lnew.y = multiply(lnew.x,ltmp.y,bitshift)-multiply(lnew.y,ltmp.x,bitshift);
X   lnew.x += longparm->x;
X   lnew.y += longparm->y;
X   return(longbailout());
X#endif
X}
X
XCirclefpFractal()
X{
X   extern int colors;
X   extern int color;
X   int i;
X   i = param[0]*(tempsqrx+tempsqry);
X   color = i&(colors-1);
X   return(1);
X}
X/*
XCirclelongFractal()
X{
X   extern int colors;
X   extern int color;
X   long i;
X   i = multiply(lparm.x,(ltempsqrx+ltempsqry),bitshift);
X   i = i >> bitshift;
X   color = i&(colors-1);
X   return(1);
X}
X*/
X
X/* -------------------------------------------------------------------- */
X/*        Initialization (once per pixel) routines                        */
X/* -------------------------------------------------------------------- */
X
X#ifdef XFRACT
X/* this code translated to asm - lives in newton.asm */
X/* transform points with reciprocal function */
Xvoid invertz2(_CMPLX *z)
X{
X   z->x = dx0[col]+dx1[row];
X   z->y = dy0[row]+dy1[col];
X   z->x -= f_xcenter; z->y -= f_ycenter;  /* Normalize values to center of circle */
X
X   tempsqrx = sqr(z->x) + sqr(z->y);  /* Get old radius */
X   if(fabs(tempsqrx) > FLT_MIN)
X      tempsqrx = f_radius / tempsqrx;
X   else
X      tempsqrx = FLT_MAX;   /* a big number, but not TOO big */
X   z->x *= tempsqrx;      z->y *= tempsqrx;     /* Perform inversion */
X   z->x += f_xcenter; z->y += f_ycenter; /* Renormalize */
X}
X#endif
X
Xint long_julia_per_pixel()
X{
X#ifndef XFRACT
X   /* integer julia types */
X   /* lambda */
X   /* barnsleyj1 */
X   /* barnsleyj2 */
X   /* sierpinski */
X   if(invert)
X   {
X      /* invert */
X      invertz2(&old);
X
X      /* watch out for overflow */
X      if(sqr(old.x)+sqr(old.y) >= 127)
X      {
X     old.x = 8;  /* value to bail out in one iteration */
X     old.y = 8;
X      }
X
X      /* convert to fudged longs */
X      lold.x = old.x*fudge;
X      lold.y = old.y*fudge;
X   }
X   else
X   {
X      lold.x = lx0[col]+lx1[row];
X      lold.y = ly0[row]+ly1[col];
X   }
X   return(0);
X#else
X   printf("Called long_julia_per_pixel\n");
X   exit(0);
X#endif
X}
X
Xint long_richard8_per_pixel()
X{
X#ifndef XFRACT
X    long_mandel_per_pixel();
X    LCMPLXtrig1(*longparm,ltmp);
X    LCMPLXmult(ltmp,lparm2,ltmp);
X    return(1);
X#endif
X}
X
Xint long_mandel_per_pixel()
X{
X#ifndef XFRACT
X   /* integer mandel types */
X   /* barnsleym1 */
X   /* barnsleym2 */
X   linit.x = lx0[col]+lx1[row];
X
X   if(invert)
X   {
X      /* invert */
X      invertz2(&init);
X
X      /* watch out for overflow */
X      if(sqr(init.x)+sqr(init.y) >= 127)
X      {
X     init.x = 8;  /* value to bail out in one iteration */
X     init.y = 8;
X      }
X
X      /* convert to fudged longs */
X      linit.x = init.x*fudge;
X      linit.y = init.y*fudge;
X   }
X
X   if(useinitorbit == 1)
X      lold = linitorbit;
X   else
X      lold = linit;
X
X   lold.x += lparm.x;     /* initial pertubation of parameters set */
X   lold.y += lparm.y;
X   return(1); /* 1st iteration has been done */
X#else
X   printf("Called long_mandel_per_pixel\n");
X   exit(0);
X#endif
X}
X
Xint julia_per_pixel()
X{
X   /* julia */
X
X   if(invert)
X   {
X      /* invert */
X      invertz2(&old);
X
X      /* watch out for overflow */
X      if(bitshift <= 24)
X     if (sqr(old.x)+sqr(old.y) >= 127)
X     {
X        old.x = 8;    /* value to bail out in one iteration */
X        old.y = 8;
X     }
X      if(bitshift >  24)
X     if (sqr(old.x)+sqr(old.y) >= 4.0)
X     {
X        old.x = 2;    /* value to bail out in one iteration */
X        old.y = 2;
X     }
X
X      /* convert to fudged longs */
X      lold.x = old.x*fudge;
X      lold.y = old.y*fudge;
X   }
X   else
X   {
X      lold.x = lx0[col]+lx1[row];
X      lold.y = ly0[row]+ly1[col];
X   }
X
X   ltempsqrx = multiply(lold.x, lold.x, bitshift);
X   ltempsqry = multiply(lold.y, lold.y, bitshift);
X   ltmp = lold;
X   return(0);
X}
X
Xmarks_mandelpwr_per_pixel()
X{
X#ifndef XFRACT
X   mandel_per_pixel();
X   ltmp = lold;
X   ltmp.x -= fudge;
X   LCMPLXpwr(lold,ltmp,ltmp);
X   return(1);
X#endif
X}
X
Xint mandel_per_pixel()
X{
X   /* mandel */
X
X   if(invert)
X   {
X      invertz2(&init);
X
X      /* watch out for overflow */
X      if(bitshift <= 24)
X     if (sqr(init.x)+sqr(init.y) >= 127)
X     {
X        init.x = 8;  /* value to bail out in one iteration */
X        init.y = 8;
X     }
X      if(bitshift >  24)
X     if (sqr(init.x)+sqr(init.y) >= 4)
X     {
X        init.x = 2;  /* value to bail out in one iteration */
X        init.y = 2;
X     }
X
X      /* convert to fudged longs */
X      linit.x = init.x*fudge;
X      linit.y = init.y*fudge;
X   }
X   else
X      linit.x = lx0[col]+lx1[row];
X   switch (fractype)
X     {
X    case MANDELLAMBDA:        /* Critical Value 0.5 + 0.0i  */
X        lold.x = FgHalf;
X        lold.y = 0;
X        break;
X    default:
X        lold = linit;
X        break;
X      }
X
X   /* alter init value */
X   if(useinitorbit == 1)
X      lold = linitorbit;
X   else if(useinitorbit == 2)
X      lold = linit;
X
X   if(inside == -60 || inside == -61)
X   {
X      /* kludge to match "Beauty of Fractals" picture since we start
X     Mandelbrot iteration with init rather than 0 */
X      lold.x = lparm.x; /* initial pertubation of parameters set */
X      lold.y = lparm.y;
X      color = -1;
X   }
X   else
X   {
X      lold.x += lparm.x; /* initial pertubation of parameters set */
X      lold.y += lparm.y;
X   }
X   ltmp = linit; /* for spider */
X   ltempsqrx = multiply(lold.x, lold.x, bitshift);
X   ltempsqry = multiply(lold.y, lold.y, bitshift);
X   return(1); /* 1st iteration has been done */
X}
X
X
Xint marksmandel_per_pixel()
X{
X   /* marksmandel */
X
X   if(invert)
X   {
X      invertz2(&init);
X
X      /* watch out for overflow */
X      if(sqr(init.x)+sqr(init.y) >= 127)
X      {
X     init.x = 8;  /* value to bail out in one iteration */
X     init.y = 8;
X      }
X
X      /* convert to fudged longs */
X      linit.x = init.x*fudge;
X      linit.y = init.y*fudge;
X   }
X   else
X      linit.x = lx0[col]+lx1[row];
X
X   if(useinitorbit == 1)
X      lold = linitorbit;
X   else
X      lold = linit;
X
X   lold.x += lparm.x;     /* initial pertubation of parameters set */
X   lold.y += lparm.y;
X
X   if(c_exp > 3)
X      lcpower(&lold,c_exp-1,&lcoefficient,bitshift);
X   else if(c_exp == 3) {
X      lcoefficient.x = multiply(lold.x, lold.x, bitshift)
X     - multiply(lold.y, lold.y, bitshift);
X      lcoefficient.y = multiply(lold.x, lold.y, bitshiftless1);
X   }
X   else if(c_exp == 2)
X      lcoefficient = lold;
X   else if(c_exp < 2) {
X      lcoefficient.x = 1L << bitshift;
X      lcoefficient.y = 0L;
X   }
X
X   ltempsqrx = multiply(lold.x, lold.x, bitshift);
X   ltempsqry = multiply(lold.y, lold.y, bitshift);
X   return(1); /* 1st iteration has been done */
X}
X
Xint marksmandelfp_per_pixel()
X{
X   /* marksmandel */
X
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X
X   if(useinitorbit == 1)
X      old = initorbit;
X   else
X      old = init;
X
X   old.x += parm.x;     /* initial pertubation of parameters set */
X   old.y += parm.y;
X
X   tempsqrx = sqr(old.x);
X   tempsqry = sqr(old.y);
X
X   if(c_exp > 3)
X      cpower(&old,c_exp-1,&coefficient);
X   else if(c_exp == 3) {
X      coefficient.x = tempsqrx - tempsqry;
X      coefficient.y = old.x * old.y * 2;
X   }
X   else if(c_exp == 2)
X      coefficient = old;
X   else if(c_exp < 2) {
X      coefficient.x = 1.0;
X      coefficient.y = 0.0;
X   }
X
X   return(1); /* 1st iteration has been done */
X}
X
Xmarks_mandelpwrfp_per_pixel()
X{
X   mandelfp_per_pixel();
X   tmp = old;
X   tmp.x -= 1;
X   CMPLXpwr(old,tmp,tmp);
X   return(1);
X}
X
Xint mandelfp_per_pixel()
X{
X   /* floating point mandelbrot */
X   /* mandelfp */
X
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X    switch (fractype)
X      {
X    case MAGNET2M:
X        FloatPreCalcMagnet2();
X    case MAGNET1M:         /* Crit Val Zero both, but neither   */
X        old.x = old.y = 0.0; /* is of the form f(Z,C) = Z*g(Z)+C  */
X        break;
X    case MANDELLAMBDAFP:        /* Critical Value 0.5 + 0.0i  */
X        old.x = 0.5;
X        old.y = 0.0;
X        break;
X    default:
X        old = init;
X        break;
X      }
X
X   /* alter init value */
X   if(useinitorbit == 1)
X      old = initorbit;
X   else if(useinitorbit == 2)
X      old = init;
X
X   if(inside == -60 || inside == -61)
X   {
X      /* kludge to match "Beauty of Fractals" picture since we start
X     Mandelbrot iteration with init rather than 0 */
X      old.x = parm.x; /* initial pertubation of parameters set */
X      old.y = parm.y;
X      color = -1;
X   }
X   else
X   {
X     old.x += parm.x;
X     old.y += parm.y;
X   }
X   tmp = init; /* for spider */
X   tempsqrx = sqr(old.x);  /* precalculated value for regular Mandelbrot */
X   tempsqry = sqr(old.y);
X   return(1); /* 1st iteration has been done */
X}
X
Xint juliafp_per_pixel()
X{
X   /* floating point julia */
X   /* juliafp */
X   if(invert)
X      invertz2(&old);
X   else
X   {
X     old.x = dx0[col]+dx1[row];
X     old.y = dy0[row]+dy1[col];
X   }
X   tempsqrx = sqr(old.x);  /* precalculated value for regular Julia */
X   tempsqry = sqr(old.y);
X   tmp = old;
X   return(0);
X}
X
Xint MPCjulia_per_pixel()
X{
X#ifndef XFRACT
X   /* floating point julia */
X   /* juliafp */
X   if(invert)
X      invertz2(&old);
X   else
X   {
X     old.x = dx0[col]+dx1[row];
X     old.y = dy0[row]+dy1[col];
X   }
X   mpcold.x = *pd2MP(old.x);
X   mpcold.y = *pd2MP(old.y);
X   return(0);
X#endif
X}
X
Xotherrichard8fp_per_pixel()
X{
X    othermandelfp_per_pixel();
X    CMPLXtrig1(*floatparm,tmp);
X    CMPLXmult(tmp,parm2,tmp);
X    return(1);
X}
X
Xint othermandelfp_per_pixel()
X{
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X
X   if(useinitorbit == 1)
X      old = initorbit;
X   else
X      old = init;
X
X   old.x += parm.x;     /* initial pertubation of parameters set */
X   old.y += parm.y;
X
X   return(1); /* 1st iteration has been done */
X}
X
Xint MPCHalley_per_pixel()
X{
X#ifndef XFRACT
X   /* MPC halley */
X   if(invert)
X      invertz2(&init);
X   else
X     init.x = dx0[col]+dx1[row];
X
X   mpcold.x = *pd2MP(init.x);
X   mpcold.y = *pd2MP(init.y);
X
X   return(0);
X#endif
X}
X
Xint Halley_per_pixel()
X{
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X
X   old = init;
X
X   return(0); /* 1st iteration is not done */
X}
X
Xint otherjuliafp_per_pixel()
X{
X   if(invert)
X      invertz2(&old);
X   else
X   {
X      old.x = dx0[col]+dx1[row];
X      old.y = dy0[row]+dy1[col];
X   }
X   return(0);
X}
X
X#if 0
X#define Q0 .113
X#define Q1 .01
X#else
X#define Q0 0
X#define Q1 0
X#endif
X
Xint quaternionjulfp_per_pixel()
X{
X   old.x = dx0[col]+dx1[row];
X   old.y = dy0[row]+dy1[col];
X   floatparm->x = param[4];
X   floatparm->y = param[5];
X   qc  = param[0];
X   qci = param[1];
X   qcj = param[2];
X   qck = param[3];
X   return(0);
X}
X
Xint quaternionfp_per_pixel()
X{
X   old.x = 0;
X   old.y = 0;
X   floatparm->x = 0;
X   floatparm->y = 0;
X   qc  = dx0[col]+dx1[row];
X   qci = dy0[row]+dy1[col];
X   qcj = param[2];
X   qck = param[3];
X   return(0);
X}
X
Xint trigmandelfp_per_pixel()
X{
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X
X   if(useinitorbit == 1)
X      old = initorbit;
X   else
X      old = init;
X
X   old.x += parm.x;     /* initial pertubation of parameters set */
X   old.y += parm.y;
X   CMPLXtrig0(old,old);
X   return(1); /* 1st iteration has been done */
X}
X
Xint trigjuliafp_per_pixel()
X{
X   /* for tetrated types */
X   if(invert)
X      invertz2(&old);
X   else
X   {
X      old.x = dx0[col]+dx1[row];
X      old.y = dy0[row]+dy1[col];
X   }
X   CMPLXtrig0(old,old);
X   return(0);
X}
X
Xint trigXtrigmandelfp_per_pixel()
X{
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X
X   if(useinitorbit == 1)
X      old = initorbit;
X   else
X      old = init;
X
X   old.x += parm.x;     /* initial pertubation of parameters set */
X   old.y += parm.y;
X   CMPLXtrig0(old,tmp);
X   CMPLXtrig1(old,tmp2);
X   CMPLXmult(tmp,tmp2,old);
X   return(1); /* 1st iteration has been done */
X}
X
Xint trigXtrigjuliafp_per_pixel()
X{
X   if(invert)
X      invertz2(&old);
X   else
X   {
X      old.x = dx0[col]+dx1[row];
X      old.y = dy0[row]+dy1[col];
X   }
X   CMPLXtrig0(old,tmp);
X   CMPLXtrig1(old,tmp2);
X   CMPLXmult(tmp,tmp2,old);
X   return(0);
X}
X
Xint MarksCplxMandperp(void)
X{
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X   old.x = init.x + parm.x; /* initial pertubation of parameters set */
X   old.y = init.y + parm.y;
X   tempsqrx = sqr(old.x);  /* precalculated value */
X   tempsqry = sqr(old.y);
X   Coefficient = ComplexPower(init, pwr);
X   return(1);
X}
X
Xint long_phoenix_per_pixel()
X{
X#ifndef XFRACT
X   if(invert)
X   {
X      /* invert */
X      invertz2(&old);
X
X      /* watch out for overflow */
X      if(sqr(old.x)+sqr(old.y) >= 127)
X      {
X     old.x = 8;  /* value to bail out in one iteration */
X     old.y = 8;
X      }
X
X      /* convert to fudged longs */
X      lold.x = old.x*fudge;
X      lold.y = old.y*fudge;
X   }
X   else
X   {
X      lold.x = lx0[col]+lx1[row];
X      lold.y = ly0[row]+ly1[col];
X   }
X   ltempsqrx = multiply(lold.x, lold.x, bitshift);
X   ltempsqry = multiply(lold.y, lold.y, bitshift);
X   ltmp2.x = 0; /* use ltmp2 as the complex Y value */
X   ltmp2.y = 0;
X   return(0);
X#else
X   printf("Called long_phoenix_per_pixel\n");
X   exit(0);
X#endif
X}
X
Xint phoenix_per_pixel()
X{
X   if(invert)
X      invertz2(&old);
X   else
X   {
X      old.x = dx0[col]+dx1[row];
X      old.y = dy0[row]+dy1[col];
X   }
X   tempsqrx = sqr(old.x);  /* precalculated value */
X   tempsqry = sqr(old.y);
X   tmp2.x = 0; /* use tmp2 as the complex Y value */
X   tmp2.y = 0;
X   return(0);
X}
Xint long_mandphoenix_per_pixel()
X{
X#ifndef XFRACT
X   linit.x = lx0[col]+lx1[row];
X
X   if(invert)
X   {
X      /* invert */
X      invertz2(&init);
X
X      /* watch out for overflow */
X      if(sqr(init.x)+sqr(init.y) >= 127)
X      {
X     init.x = 8;  /* value to bail out in one iteration */
X     init.y = 8;
X      }
X
X      /* convert to fudged longs */
X      linit.x = init.x*fudge;
X      linit.y = init.y*fudge;
X   }
X
X   if(useinitorbit == 1)
X      lold = linitorbit;
X   else
X      lold = linit;
X
X   lold.x += lparm.x;     /* initial pertubation of parameters set */
X   lold.y += lparm.y;
X   ltempsqrx = multiply(lold.x, lold.x, bitshift);
X   ltempsqry = multiply(lold.y, lold.y, bitshift);
X   ltmp2.x = 0;
X   ltmp2.y = 0;
X   return(1); /* 1st iteration has been done */
X#else
X   printf("Called long_mandphoenix_per_pixel\n");
X   exit(0);
X#endif
X}
Xint mandphoenix_per_pixel()
X{
X   if(invert)
X      invertz2(&init);
X   else
X      init.x = dx0[col]+dx1[row];
X
X   if(useinitorbit == 1)
X      old = initorbit;
X   else
X      old = init;
X
X   old.x += parm.x;     /* initial pertubation of parameters set */
X   old.y += parm.y;
X   tempsqrx = sqr(old.x);  /* precalculated value */
X   tempsqry = sqr(old.y);
X   tmp2.x = 0;
X   tmp2.y = 0;
X   return(1); /* 1st iteration has been done */
X}
X
XQuaternionFPFractal()
X{
X   double a0,a1,a2,a3,n0,n1,n2,n3;
X   a0 = old.x;
X   a1 = old.y;
X   a2 = floatparm->x;
X   a3 = floatparm->y;
X
X   n0 = a0*a0-a1*a1-a2*a2-a3*a3 + qc;
X   n1 = 2*a0*a1 + qci;
X   n2 = 2*a0*a2 + qcj;
X   n3 = 2*a0*a3 + qck;
X   /* Check bailout */
X   magnitude = a0*a0+a1*a1+a2*a2+a3*a3;
X   if (magnitude>rqlim) {
X       return 1;
X   }
X   old.x = n0;
X   old.y = n1;
X   floatparm->x = n2;
X   floatparm->y = n3;
X   return(0);
X}
X
XHyperComplex1FPFractal()
X{
X   double n0,n1,n2,n3;
X
X   n0 = sqr(old.x)-sqr(old.y)-sqr(floatparm->x)+sqr(floatparm->y) + qc;
X   n1 = 2*old.x*old.y - 2*floatparm->x*floatparm->y + qci;
X   n2 = 2*old.x*floatparm->x - 2*old.y*floatparm->y + qcj;
X   n3 = 2*old.x*floatparm->y + 2*old.y*floatparm->x + qck;
X
X   old.x = n0;
X   old.y = n1;
X   floatparm->x = n2;
X   floatparm->y = n3;
X
X   /* Check bailout */
X   magnitude = sqr(old.x)+sqr(old.y)+sqr(floatparm->x)+sqr(floatparm->y);
X   if (magnitude>rqlim) {
X       return 1;
X   }
X   return(0);
X}
X
XHyperComplexFPFractal()
X{
X   double n0,n1,n2,n3;
X   _HCMPLX hold, hnew;
X   hold.x = old.x;
X   hold.y = old.y;
X   hold.z = floatparm->x;
X   hold.t = floatparm->y;
X
X/*   HComplexSqr(&hold,&hnew); */
X   HComplexTrig0(&hold,&hnew);
X
X   hnew.x += qc;
X   hnew.y += qci;
X   hnew.z += qcj;
X   hnew.t += qck;
X
X   old.x = hnew.x;
X   old.y = hnew.y;
X   floatparm->x = hnew.z;
X   floatparm->y = hnew.t;
X
X   /* Check bailout */
X   magnitude = sqr(old.x)+sqr(old.y)+sqr(floatparm->x)+sqr(floatparm->y);
X   if (magnitude>rqlim) {
X       return 1;
X   }
X   return(0);
X}
X
X/* -------------------------------------------------------------------- */
X/*        Setup (once per fractal image) routines         */
X/* -------------------------------------------------------------------- */
X
XMandelSetup()        /* Mandelbrot Routine */
X{
X   if (debugflag != 90 && ! invert && decomp[0] == 0 && rqlim <= 4.0
X       && bitshift == 29 && potflag == 0
X       && biomorph == -1 && inside > -59 && outside >= -1
X       && useinitorbit != 1 && using_jiim == 0)
X      calctype = calcmand; /* the normal case - use CALCMAND */
X   else
X   {
X      /* special case: use the main processing loop */
X      calctype = StandardFractal;
X      longparm = &linit;
X   }
X   return(1);
X}
X
XJuliaSetup()        /* Julia Routine */
X{
X   if (debugflag != 90 && ! invert && decomp[0] == 0 && rqlim <= 4.0
X       && bitshift == 29 && potflag == 0
X       && biomorph == -1 && inside > -59 && outside >= -1
X       && !finattract && using_jiim == 0)
X      calctype = calcmand; /* the normal case - use CALCMAND */
X   else
X   {
X      /* special case: use the main processing loop */
X      calctype = StandardFractal;
X      longparm = &lparm;
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X   }
X   return(1);
X}
X
XNewtonSetup()        /* Newton/NewtBasin Routines */
X{
X   int i;
X   extern int basin;
X   extern int fpu;
X   if (debugflag != 1010)
X   {
X      if(fpu != 0)
X      {
X     if(fractype == MPNEWTON)
X        fractype = NEWTON;
X     else if(fractype == MPNEWTBASIN)
X        fractype = NEWTBASIN;
X      }
X      else
X      {
X     if(fractype == NEWTON)
X           fractype = MPNEWTON;
X     else if(fractype == NEWTBASIN)
X           fractype = MPNEWTBASIN;
X      }
X      curfractalspecific = &fractalspecific[fractype];
X   }
X
X   /* set up table of roots of 1 along unit circle */
X   degree = (int)parm.x;
X   if(degree < 2)
X      degree = 3;   /* defaults to 3, but 2 is possible */
X   root = 1;
X
X   /* precalculated values */
X   roverd    = (double)root / (double)degree;
X   d1overd    = (double)(degree - 1) / (double)degree;
X   maxcolor    = 0;
X   threshold    = .3*PI/degree; /* less than half distance between roots */
X#ifndef XFRACT
X   if (fractype == MPNEWTON || fractype == MPNEWTBASIN) {
X      mproverd       = *pd2MP(roverd);
X      mpd1overd    = *pd2MP(d1overd);
X      mpthreshold  = *pd2MP(threshold);
X      mpone       = *pd2MP(1.0);
X   }
X#endif
X
X   floatmin = FLT_MIN;
X   floatmax = FLT_MAX;
X
X   basin = 0;
X   if(roots != staticroots) {
X      free(roots);
X      roots = staticroots;
X   }
X
X   if (fractype==NEWTBASIN)
X   {
X      if(parm.y)
X     basin = 2; /*stripes */
X      else
X     basin = 1;
X      if(degree > 16)
X      {
X     if((roots=(_CMPLX *)malloc(degree*sizeof(_CMPLX)))==NULL)
X     {
X        roots = staticroots;
X        degree = 16;
X     }
X      }
X      else
X     roots = staticroots;
X
X      /* list of roots to discover where we converged for newtbasin */
X      for(i=0;i<degree;i++)
X      {
X     roots[i].x = cos(i*twopi/(double)degree);
X     roots[i].y = sin(i*twopi/(double)degree);
X      }
X   }
X#ifndef XFRACT
X   else if (fractype==MPNEWTBASIN)
X   {
X     if(parm.y)
X     basin = 2; /*stripes */
X      else
X     basin = 1;
X
X      if(degree > 16)
X      {
X     if((MPCroots=(struct MPC *)malloc(degree*sizeof(struct MPC)))==NULL)
X     {
X        MPCroots = (struct MPC *)staticroots;
X        degree = 16;
X     }
X      }
X      else
X     MPCroots = (struct MPC *)staticroots;
X
X      /* list of roots to discover where we converged for newtbasin */
X      for(i=0;i<degree;i++)
X      {
X     MPCroots[i].x = *pd2MP(cos(i*twopi/(double)degree));
X     MPCroots[i].y = *pd2MP(sin(i*twopi/(double)degree));
X      }
X   }
X#endif
X
X   param[0] = (double)degree; /* JCO 7/1/92 */
X   if (degree%4 == 0)
X      symmetry = XYAXIS;
X   else
X      symmetry = XAXIS;
X
X   calctype=StandardFractal;
X#ifndef XFRACT
X   if (fractype == MPNEWTON || fractype == MPNEWTBASIN)
X      setMPfunctions();
X#endif
X   return(1);
X}
X
X
XStandaloneSetup()
X{
X   timer(0,curfractalspecific->calctype);
X   return(0);        /* effectively disable solid-guessing */
X}
X
XUnitySetup()
X{
X   periodicitycheck = 0;
X   FgOne = (1L << bitshift);
X   FgTwo = FgOne + FgOne;
X   return(1);
X}
X
XMandelfpSetup()
X{
X   c_exp = param[2];
X   pwr.x = param[2] - 1.0;
X   pwr.y = param[3];
X   floatparm = &init;
X   switch (fractype)
X   {
X   case MARKSMANDELFP:
X      if(c_exp < 1)
X         c_exp = 1;
X      if(!(c_exp & 1))
X         symmetry = XYAXIS_NOPARM;    /* odd exponents */
X      if(c_exp & 1)
X         symmetry = XAXIS_NOPARM;
X      break;
X   case MANDELFP:
X    /*
X       floating point code could probably be altered to handle many of
X       the situations that otherwise are using StandardFractal().
X       calcmandfp() can currently handle invert, any rqlim, potflag
X       zmag, epsilon cross, and all the current outside options
X                             Wes Loewer 11/03/91
X    */
X    if (debugflag != 90
X        && !distest
X        && decomp[0] == 0
X        && biomorph == -1
X        && (inside >= -1 || inside == -59 || inside == -100)
X        /* uncomment this next line if more outside options are added */
X        /* && outside >= -5 */
X        && useinitorbit != 1
X        && using_jiim == 0)
X    {
X       calctype = calcmandfp; /* the normal case - use calcmandfp */
X       calcmandfpasmstart();
X    }
X    else
X    {
X       /* special case: use the main processing loop */
X       calctype = StandardFractal;
X    }
X    break;
X   case FPMANDELZPOWER:
X      if((double)c_exp == param[2] && c_exp & 1) /* odd exponents */
X         symmetry = XYAXIS_NOPARM;
X      if(param[3] != 0)
X         symmetry = NOSYM;
X      if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
X          fractalspecific[fractype].orbitcalc = floatZpowerFractal;
X      else
X          fractalspecific[fractype].orbitcalc = floatCmplxZpowerFractal;
X      break;
X   case MAGNET1M:
X   case MAGNET2M:
X      attr[0].x = 1.0;        /* 1.0 + 0.0i always attracts */
X      attr[0].y = 0.0;        /* - both MAGNET1 and MAGNET2 */
X      attrperiod[0] = 1;
X      attractors = 1;
X      break;
X   case SPIDERFP:
X      if(periodicitycheck==1) /* if not user set */
X     periodicitycheck=4;
X      break;
X   case MANDELEXP:
X      symmetry = XAXIS_NOPARM;
X      break;
X/* Added to account for symmetry in manfn+exp and manfn+zsqrd */
X/*     JCO 2/29/92 */
X   case FPMANTRIGPLUSEXP:
X   case FPMANTRIGPLUSZSQRD:
X     if(parm.y == 0.0)
X        symmetry = XAXIS;
X     else
X        symmetry = NOSYM;
X     if ((trigndx[0] == LOG) || (trigndx[0] == 14)) /* LOG or FLIP */
X        symmetry = NOSYM;
X      break;
X   case QUATFP:
X   case HYPERCMPLXFP:
X      floatparm = &tmp;
X      attractors = 0;
X      periodicitycheck = 0;
X      break;
X   default:
X      break;
X   }
X   return(1);
X}
X
XJuliafpSetup()
X{
X   c_exp = param[2];
X   floatparm = &parm;
X   if(fractype==COMPLEXMARKSJUL)
X   {
X      pwr.x = param[2] - 1.0;
X      pwr.y = param[3];
X      Coefficient = ComplexPower(*floatparm, pwr);
X   }
X   switch (fractype)
X   {
X   case JULIAFP:
X    /*
X       floating point code could probably be altered to handle many of
X       the situations that otherwise are using StandardFractal().
X       calcmandfp() can currently handle invert, any rqlim, potflag
X       zmag, epsilon cross, and all the current outside options
X                             Wes Loewer 11/03/91
X    */
X    if (debugflag != 90
X        && !distest
X        && decomp[0] == 0
X        && biomorph == -1
X        && (inside >= -1 || inside == -59 || inside == -100)
X        /* uncomment this next line if more outside options are added */
X        /* && outside >= -5 */
X        && useinitorbit != 1
X        && !finattract
X        && using_jiim == 0)
X    {
X       calctype = calcmandfp; /* the normal case - use calcmandfp */
X       calcmandfpasmstart();
X    }
X    else
X    {
X       /* special case: use the main processing loop */
X       calctype = StandardFractal;
X       get_julia_attractor (0.0, 0.0);   /* another attractor? */
X    }
X    break;
X   case FPJULIAZPOWER:
X      if((c_exp & 1) || param[3] != 0.0 || (double)c_exp != param[2] )
X         symmetry = NOSYM;
X      if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
X          fractalspecific[fractype].orbitcalc = floatZpowerFractal;
X      else
X          fractalspecific[fractype].orbitcalc = floatCmplxZpowerFractal;
X      get_julia_attractor (param[0], param[1]);    /* another attractor? */
X      break;
X   case MAGNET2J:
X      FloatPreCalcMagnet2();
X   case MAGNET1J:
X      attr[0].x = 1.0;        /* 1.0 + 0.0i always attracts */
X      attr[0].y = 0.0;        /* - both MAGNET1 and MAGNET2 */
X      attrperiod[0] = 1;
X      attractors = 1;
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      break;
X   case LAMBDAFP:
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      get_julia_attractor (0.5, 0.0);    /* another attractor? */
X      break;
X   case LAMBDAEXP:
X      if(parm.y == 0.0)
X     symmetry=XAXIS;
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      break;
X/* Added to account for symmetry in julfn+exp and julfn+zsqrd */
X/*     JCO 2/29/92 */
X   case FPJULTRIGPLUSEXP:
X   case FPJULTRIGPLUSZSQRD:
X     if(parm.y == 0.0)
X        symmetry = XAXIS;
X     else
X        symmetry = NOSYM;
X     if ((trigndx[0] == LOG) || (trigndx[0] == 14)) /* LOG or FLIP */
X        symmetry = NOSYM;
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      break;
X   case HYPERCMPLXJFP:
X      if(trigndx[0] != SQR)
X         symmetry=NOSYM;
X   case QUATJULFP:
X      attractors = 0;    /* attractors broken since code checks r,i not j,k */
X      periodicitycheck = 0;
X      if(param[4] != 0.0 || param[5] != 0)
X         symmetry = NOSYM;
X      break;
X   default:
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      break;
X   }
X   return(1);
X}
X
XMandellongSetup()
X{
X   FgHalf = fudge >> 1;
X   c_exp = param[2];
X   if(fractype==MARKSMANDEL && c_exp < 1)
X      c_exp = 1;
X   if(fractype==LMANDELZPOWER && c_exp < 1)
X      c_exp = 1;
X   if((fractype==MARKSMANDEL   && !(c_exp & 1)) ||
X       (fractype==LMANDELZPOWER && c_exp & 1))
X      symmetry = XYAXIS_NOPARM;    /* odd exponents */
X   if((fractype==MARKSMANDEL && (c_exp & 1)) || fractype==LMANDELEXP)
X      symmetry = XAXIS_NOPARM;
X   if(fractype==SPIDER && periodicitycheck==1)
X      periodicitycheck=4;
X   longparm = &linit;
X   if(fractype==LMANDELZPOWER)
X   {
X      if(param[3] == 0.0 && debugflag != 6000  && (double)c_exp == param[2])
X          fractalspecific[fractype].orbitcalc = longZpowerFractal;
X      else
X          fractalspecific[fractype].orbitcalc = longCmplxZpowerFractal;
X      if(param[3] != 0 || (double)c_exp != param[2] )
X         symmetry = NOSYM;
X    }
X/* Added to account for symmetry in manfn+exp and manfn+zsqrd */
X/*     JCO 2/29/92 */
X   if((fractype==LMANTRIGPLUSEXP)||(fractype==LMANTRIGPLUSZSQRD))
X   {
X     if(parm.y == 0.0)
X        symmetry = XAXIS;
X     else
X        symmetry = NOSYM;
X     if ((trigndx[0] == LOG) || (trigndx[0] == 14)) /* LOG or FLIP */
X        symmetry = NOSYM;
X   }
X   return(1);
X}
X
XJulialongSetup()
X{
X   c_exp = param[2];
X   longparm = &lparm;
X   switch (fractype)
X   {
X   case LJULIAZPOWER:
X      if((c_exp & 1) || param[3] != 0.0 || (double)c_exp != param[2])
X         symmetry = NOSYM;
X      else if(c_exp < 1)
X         c_exp = 1;
X      if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
X          fractalspecific[fractype].orbitcalc = longZpowerFractal;
X      else
X          fractalspecific[fractype].orbitcalc = longCmplxZpowerFractal;
X      break;
X   case LAMBDA:
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      get_julia_attractor (0.5, 0.0);    /* another attractor? */
X      break;
X   case LLAMBDAEXP:
X      if(lparm.y == 0)
X     symmetry = XAXIS;
X      break;
X/* Added to account for symmetry in julfn+exp and julfn+zsqrd */
X/*     JCO 2/29/92 */
X   case LJULTRIGPLUSEXP:
X   case LJULTRIGPLUSZSQRD:
X     if(parm.y == 0.0)
X        symmetry = XAXIS;
X     else
X        symmetry = NOSYM;
X     if ((trigndx[0] == LOG) || (trigndx[0] == 14)) /* LOG or FLIP */
X        symmetry = NOSYM;
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      break;
X   default:
X      get_julia_attractor (0.0, 0.0);    /* another attractor? */
X      break;
X   }
X   return(1);
X}
X
XTrigPlusSqrlongSetup()
X{
X   curfractalspecific->per_pixel =  julia_per_pixel;
X   curfractalspecific->orbitcalc =  TrigPlusSqrFractal;
X   if(lparm.x == fudge && lparm.y == 0L && lparm2.y == 0L && debugflag != 90)
X   {
X      if(lparm2.x == fudge)       /* Scott variant */
X     curfractalspecific->orbitcalc =  ScottTrigPlusSqrFractal;
X      else if(lparm2.x == -fudge)  /* Skinner variant */
X     curfractalspecific->orbitcalc =  SkinnerTrigSubSqrFractal;
X   }
X   return(JulialongSetup());
X}
X
XTrigPlusSqrfpSetup()
X{
X   curfractalspecific->per_pixel =  juliafp_per_pixel;
X   curfractalspecific->orbitcalc =  TrigPlusSqrfpFractal;
X   if(parm.x == 1.0 && parm.y == 0.0 && parm2.y == 0.0 && debugflag != 90)
X   {
X      if(parm2.x == 1.0)    /* Scott variant */
X     curfractalspecific->orbitcalc =  ScottTrigPlusSqrfpFractal;
X      else if(parm2.x == -1.0)    /* Skinner variant */
X     curfractalspecific->orbitcalc =  SkinnerTrigSubSqrfpFractal;
X   }
X   return(JuliafpSetup());
X}
X
XTrigPlusTriglongSetup()
X{
X   FnPlusFnSym();
X   if(trigndx[1] == SQR)
X      return(TrigPlusSqrlongSetup());
X   curfractalspecific->per_pixel =  long_julia_per_pixel;
X   curfractalspecific->orbitcalc =  TrigPlusTrigFractal;
X   if(lparm.x == fudge && lparm.y == 0L && lparm2.y == 0L && debugflag != 90)
X   {
X      if(lparm2.x == fudge)       /* Scott variant */
X     curfractalspecific->orbitcalc =  ScottTrigPlusTrigFractal;
X      else if(lparm2.x == -fudge)  /* Skinner variant */
X     curfractalspecific->orbitcalc =  SkinnerTrigSubTrigFractal;
X   }
X   return(JulialongSetup());
X}
X
XTrigPlusTrigfpSetup()
X{
X   FnPlusFnSym();
X   if(trigndx[1] == SQR)
X      return(TrigPlusSqrfpSetup());
X   curfractalspecific->per_pixel =  otherjuliafp_per_pixel;
X   curfractalspecific->orbitcalc =  TrigPlusTrigfpFractal;
X   if(parm.x == 1.0 && parm.y == 0.0 && parm2.y == 0.0 && debugflag != 90)
X   {
X      if(parm2.x == 1.0)    /* Scott variant */
X     curfractalspecific->orbitcalc =  ScottTrigPlusTrigfpFractal;
X      else if(parm2.x == -1.0)    /* Skinner variant */
X     curfractalspecific->orbitcalc =  SkinnerTrigSubTrigfpFractal;
X   }
X   return(JuliafpSetup());
X}
X
XFnPlusFnSym() /* set symmetry matrix for fn+fn type */
X{
X   static char far fnplusfn[7][7] =
X   {/* fn2 ->sin     cos    sinh    cosh   exp    log    sqr  */
X   /* fn1 */
X   /* sin */ {PI_SYM,XAXIS, XYAXIS, XAXIS, XAXIS, XAXIS, XAXIS},
X   /* cos */ {XAXIS, PI_SYM,XAXIS,  XYAXIS,XAXIS, XAXIS, XAXIS},
X   /* sinh*/ {XYAXIS,XAXIS, XYAXIS, XAXIS, XAXIS, XAXIS, XAXIS},
X   /* cosh*/ {XAXIS, XYAXIS,XAXIS,  XYAXIS,XAXIS, XAXIS, XAXIS},
X   /* exp */ {XAXIS, XYAXIS,XAXIS,  XAXIS, XYAXIS,XAXIS, XAXIS},
X   /* log */ {XAXIS, XAXIS, XAXIS,  XAXIS, XAXIS, XAXIS, XAXIS},
X   /* sqr */ {XAXIS, XAXIS, XAXIS,  XAXIS, XAXIS, XAXIS, XYAXIS}
X   };
X   if(parm.y == 0.0 && parm2.y == 0.0)
X    { if(trigndx[0] < 7 && trigndx[1] < 7)  /* bounds of array JCO 5/6/92*/
X        symmetry = fnplusfn[trigndx[0]][trigndx[1]];  /* JCO 5/6/92 */
X    }                 /* defaults to XAXIS symmetry JCO 5/6/92 */
X   else
X      symmetry = NOSYM;
X   return(0);
X}
X
XLambdaTrigOrTrigSetup()
X{
X/* default symmetry is ORIGIN  JCO 2/29/92 (changed from PI_SYM) */
X   longparm = &lparm; /* added to consolidate code 10/1/92 JCO */
X   floatparm = &parm;
X   if ((trigndx[0] == EXP) || (trigndx[1] == EXP))
X      symmetry = NOSYM; /* JCO 1/9/93 */
X   if ((trigndx[0] == LOG) || (trigndx[1] == LOG))
X      symmetry = XAXIS;
X   get_julia_attractor (0.0, 0.0);    /* an attractor? */
X   return(1);
X}
X
XJuliaTrigOrTrigSetup()
X{
X/* default symmetry is XAXIS */
X   longparm = &lparm; /* added to consolidate code 10/1/92 JCO */
X   floatparm = &parm;
X   if(parm.y != 0.0)
X     symmetry = NOSYM;
X   get_julia_attractor (0.0, 0.0);    /* an attractor? */
X   return(1);
X}
X
XManlamTrigOrTrigSetup()
X{ /* psuedo */
X/* default symmetry is XAXIS */
X   longparm = &linit; /* added to consolidate code 10/1/92 JCO */
X   floatparm = &init;
X   if (trigndx[0] == SQR)
X      symmetry = NOSYM;
X   if ((trigndx[0] == LOG) || (trigndx[1] == LOG))
X      symmetry = NOSYM;
X   return(1);
X}
X
XMandelTrigOrTrigSetup()
X{
X/* default symmetry is XAXIS_NOPARM */
X   longparm = &linit; /* added to consolidate code 10/1/92 JCO */
X   floatparm = &init;
X   if ((trigndx[0] == 14) || (trigndx[1] == 14)) /* FLIP  JCO 5/28/92 */
X      symmetry = NOSYM;
X   return(1);
X}
X
X
XZXTrigPlusZSetup()
X{
X/*   static char far ZXTrigPlusZSym1[] = */
X   /* fn1 ->  sin   cos    sinh  cosh exp   log   sqr */
X/*         {XAXIS,XYAXIS,XAXIS,XYAXIS,XAXIS,NOSYM,XYAXIS}; */
X/*   static char far ZXTrigPlusZSym2[] = */
X   /* fn1 ->  sin   cos    sinh  cosh exp   log   sqr */
X/*         {NOSYM,ORIGIN,NOSYM,ORIGIN,NOSYM,NOSYM,ORIGIN}; */
X
X   if(param[1] == 0.0 && param[3] == 0.0)
X/*      symmetry = ZXTrigPlusZSym1[trigndx[0]]; */
X   switch(trigndx[0])
X   {
X      case COS:   /* changed to two case statments and made any added */
X      case COSH:  /* functions default to XAXIS symmetry. JCO 5/25/92 */
X      case SQR:
X      case 9:   /* 'real' cos */
X         symmetry = XYAXIS;
X         break;
X      case 14:   /* FLIP  JCO 2/29/92 */
X         symmetry = YAXIS;
X         break;
X      case LOG:
X         symmetry = NOSYM;
X         break;
X      default:
X         symmetry = XAXIS;
X         break;
X      }
X   else
X/*      symmetry = ZXTrigPlusZSym2[trigndx[0]]; */
X   switch(trigndx[0])
X   {
X      case COS:
X      case COSH:
X      case SQR:
X      case 9:   /* 'real' cos */
X         symmetry = ORIGIN;
X         break;
X      case 14:   /* FLIP  JCO 2/29/92 */
X         symmetry = NOSYM;
X         break;
X      default:
X         symmetry = XAXIS;
X         break;
X      }
X   if(curfractalspecific->isinteger)
X   {
X      curfractalspecific->orbitcalc =  ZXTrigPlusZFractal;
X      if(lparm.x == fudge && lparm.y == 0L && lparm2.y == 0L && debugflag != 90)
X      {
X     if(lparm2.x == fudge)       /* Scott variant */
X         curfractalspecific->orbitcalc =  ScottZXTrigPlusZFractal;
X     else if(lparm2.x == -fudge)  /* Skinner variant */
X         curfractalspecific->orbitcalc =  SkinnerZXTrigSubZFractal;
X      }
X      return(JulialongSetup());
X   }
X   else
X   {
X      curfractalspecific->orbitcalc =  ZXTrigPlusZfpFractal;
X      if(parm.x == 1.0 && parm.y == 0.0 && parm2.y == 0.0 && debugflag != 90)
X      {
X     if(parm2.x == 1.0)    /* Scott variant */
X         curfractalspecific->orbitcalc =  ScottZXTrigPlusZfpFractal;
X     else if(parm2.x == -1.0)    /* Skinner variant */
X         curfractalspecific->orbitcalc =  SkinnerZXTrigSubZfpFractal;
X      }
X   }
X   return(JuliafpSetup());
X}
X
XLambdaTrigSetup()
X{
X   int isinteger;
X   if((isinteger = curfractalspecific->isinteger))
X      curfractalspecific->orbitcalc =  LambdaTrigFractal;
X   else
X      curfractalspecific->orbitcalc =  LambdaTrigfpFractal;
X   switch(trigndx[0])
X   {
X   case SIN:
X   case COS:
X   case 9:   /* 'real' cos, added this and default for additional functions */
X      symmetry = PI_SYM;
X      if(isinteger)
X     curfractalspecific->orbitcalc =  LambdaTrigFractal1;
X      else
X     curfractalspecific->orbitcalc =  LambdaTrigfpFractal1;
X      break;
X   case SINH:
X   case COSH:
X      symmetry = ORIGIN;
X      if(isinteger)
X     curfractalspecific->orbitcalc =  LambdaTrigFractal2;
X      else
X     curfractalspecific->orbitcalc =  LambdaTrigfpFractal2;
X      break;
X   case SQR:
X      symmetry = ORIGIN;
X      break;
X   case EXP:
X      if(isinteger)
X     curfractalspecific->orbitcalc =  LongLambdaexponentFractal;
X      else
X     curfractalspecific->orbitcalc =  LambdaexponentFractal;
X      symmetry = NOSYM; /* JCO 1/9/93 */
X      break;
X   case LOG:
X      symmetry = NOSYM;
X      break;
X   default:   /* default for additional functions */
X      symmetry = ORIGIN;  /* JCO 5/8/92 */
X      break;
X   }
X   get_julia_attractor (0.0, 0.0);    /* an attractor? */
X   if(isinteger)
X      return(JulialongSetup());
X   else
X      return(JuliafpSetup());
X}
X
XJuliafnPlusZsqrdSetup()
X{
X/*   static char far fnpluszsqrd[] = */
X   /* fn1 ->  sin   cos    sinh  cosh    sqr    exp   log  */
X   /* sin    {NOSYM,ORIGIN,NOSYM,ORIGIN,ORIGIN,NOSYM,NOSYM}; */
X
X/*   symmetry = fnpluszsqrd[trigndx[0]];   JCO  5/8/92 */
X   switch(trigndx[0]) /* fix sqr symmetry & add additional functions */
X   {
X   case COS: /* cosxx */
X   case COSH:
X   case SQR:
X   case 9:   /* 'real' cos */
X   case 10:  /* tan */
X   case 11:  /* tanh */
X   symmetry = ORIGIN;
X    /* default is for NOSYM symmetry */
X   }
X   if(curfractalspecific->isinteger)
X      return(JulialongSetup());
X   else
X      return(JuliafpSetup());
X}
X
XSqrTrigSetup()
X{
X/*   static char far SqrTrigSym[] = */
X   /* fn1 ->  sin    cos    sinh   cosh   sqr     exp   log  */
X/*         {PI_SYM,PI_SYM,XYAXIS,XYAXIS,XYAXIS,XAXIS,XAXIS}; */
X/*   symmetry = SqrTrigSym[trigndx[0]];      JCO  5/9/92 */
X   switch(trigndx[0]) /* fix sqr symmetry & add additional functions */
X   {
X   case SIN:
X   case COS: /* cosxx */
X   case 9:   /* 'real' cos */
X   symmetry = PI_SYM;
X    /* default is for XAXIS symmetry */
X   }
X   if(curfractalspecific->isinteger)
X      return(JulialongSetup());
X   else
X      return(JuliafpSetup());
X}
X
XFnXFnSetup()
X{
X   static char far fnxfn[7][7] =
X   {/* fn2 ->sin     cos    sinh    cosh  exp    log    sqr */
X   /* fn1 */
X   /* sin */ {PI_SYM,YAXIS, XYAXIS,XYAXIS,XAXIS, NOSYM, XYAXIS},
X   /* cos */ {YAXIS, PI_SYM,XYAXIS,XYAXIS,XAXIS, NOSYM, XYAXIS},
X   /* sinh*/ {XYAXIS,XYAXIS,XYAXIS,XYAXIS,XAXIS, NOSYM, XYAXIS},
X   /* cosh*/ {XYAXIS,XYAXIS,XYAXIS,XYAXIS,XAXIS, NOSYM, XYAXIS},
X   /* exp */ {XAXIS, XAXIS, XAXIS, XAXIS, XAXIS, NOSYM, XYAXIS},
X   /* log */ {NOSYM, NOSYM, NOSYM, NOSYM, NOSYM, XAXIS, NOSYM},
X   /* sqr */ {XYAXIS,XYAXIS,XYAXIS,XYAXIS,XYAXIS,NOSYM, XYAXIS},
X   };
X   /*
X   if(trigndx[0]==EXP || trigndx[0]==LOG || trigndx[1]==EXP || trigndx[1]==LOG)
X      symmetry = XAXIS;
X   else if((trigndx[0]==SIN && trigndx[1]==SIN)||(trigndx[0]==COS && trigndx[1]==COS))
X      symmetry = PI_SYM;
X   else if((trigndx[0]==SIN && trigndx[1]==COS)||(trigndx[0]==COS && trigndx[1]==SIN))
X      symmetry = YAXIS;
X   else
X      symmetry = XYAXIS;
X   */
X   if(trigndx[0] < 7 && trigndx[1] < 7)  /* bounds of array JCO 5/22/92*/
X        symmetry = fnxfn[trigndx[0]][trigndx[1]];  /* JCO 5/22/92 */
X                    /* defaults to XAXIS symmetry JCO 5/22/92 */
X   else {  /* added to complete the symmetry JCO 5/22/92 */
X      if (trigndx[0]==LOG || trigndx[1] ==LOG) symmetry = NOSYM;
X      if (trigndx[0]==9 || trigndx[1] ==9) { /* 'real' cos */
X         if (trigndx[0]==SIN || trigndx[1] ==SIN) symmetry = PI_SYM;
X         if (trigndx[0]==COS || trigndx[1] ==COS) symmetry = PI_SYM;
X      }
X      if (trigndx[0]==9 && trigndx[1] ==9) symmetry = PI_SYM;
X   }
X   if(curfractalspecific->isinteger)
X      return(JulialongSetup());
X   else
X      return(JuliafpSetup());
X}
X
XMandelTrigSetup()
X{
X   int isinteger;
X   if((isinteger = curfractalspecific->isinteger))
X      curfractalspecific->orbitcalc =  LambdaTrigFractal;
X   else
X      curfractalspecific->orbitcalc =  LambdaTrigfpFractal;
X   symmetry = XYAXIS_NOPARM;
X   switch(trigndx[0])
X   {
X   case SIN:
X   case COS:
X      if(isinteger)
X     curfractalspecific->orbitcalc =  LambdaTrigFractal1;
X      else
X     curfractalspecific->orbitcalc =  LambdaTrigfpFractal1;
X      break;
X   case SINH:
X   case COSH:
X      if(isinteger)
X     curfractalspecific->orbitcalc =  LambdaTrigFractal2;
X      else
X     curfractalspecific->orbitcalc =  LambdaTrigfpFractal2;
X      break;
X   case EXP:
X      symmetry = XAXIS_NOPARM;
X      if(isinteger)
X     curfractalspecific->orbitcalc =  LongLambdaexponentFractal;
X      else
X     curfractalspecific->orbitcalc =  LambdaexponentFractal;
X      break;
X   case LOG:
X      symmetry = XAXIS_NOPARM;
X      break;
X   default:   /* added for additional functions, JCO 5/25/92 */
X      symmetry = XYAXIS_NOPARM;
X      break;
X   }
X   if(isinteger)
X      return(MandellongSetup());
X   else
X      return(MandelfpSetup());
X}
X
XMarksJuliaSetup()
X{
X   c_exp = param[2];
X   longparm = &lparm;
X   lold = *longparm;
X   if(c_exp > 2)
X      lcpower(&lold,c_exp,&lcoefficient,bitshift);
X   else if(c_exp == 2)
X   {
X      lcoefficient.x = multiply(lold.x,lold.x,bitshift) - multiply(lold.y,lold.y,bitshift);
X      lcoefficient.y = multiply(lold.x,lold.y,bitshiftless1);
X   }
X   else if(c_exp < 2)
X      lcoefficient = lold;
X   get_julia_attractor (0.0, 0.0);    /* an attractor? */
X   return(1);
X}
X
XMarksJuliafpSetup()
X{
X   c_exp = param[2];
X   floatparm = &parm;
X   old = *floatparm;
X   if(c_exp > 2)
X      cpower(&old,c_exp,&coefficient);
X   else if(c_exp == 2)
X   {
X      coefficient.x = sqr(old.x) - sqr(old.y);
X      coefficient.y = old.x * old.y * 2;
X   }
X   else if(c_exp < 2)
X      coefficient = old;
X   get_julia_attractor (0.0, 0.0);    /* an attractor? */
X   return(1);
X}
X
XSierpinskiSetup()
X{
X   /* sierpinski */
X   periodicitycheck = 0;        /* disable periodicity checks */
X   ltmp.x = 1;
X   ltmp.x = ltmp.x << bitshift; /* ltmp.x = 1 */
X   ltmp.y = ltmp.x >> 1;            /* ltmp.y = .5 */
X   return(1);
X}
X
XSierpinskiFPSetup()
X{
X   /* sierpinski */
X   periodicitycheck = 0;        /* disable periodicity checks */
X   tmp.x = 1;
X   tmp.y = 0.5;
X   return(1);
X}
X
Xextern char usr_floatflag;
X
XHalleySetup()
X{
X   /* Halley */
X   periodicitycheck=0;
X
X   if(usr_floatflag)
X     fractype = HALLEY; /* float on */
X   else
X     fractype = MPHALLEY;
X
X   curfractalspecific = &fractalspecific[fractype];
X
X   degree = (int)parm.x;
X   if(degree < 2)
X      degree = 2;
X   param[0] = (double)degree;
X
X/*  precalculated values */
X   AplusOne = degree + 1; /* a+1 */
X   Ap1deg = AplusOne * degree;
X
X#ifndef XFRACT
X   if(fractype == MPHALLEY) {
X      setMPfunctions();
X      mpAplusOne = *pd2MP((double)AplusOne);
X      mpAp1deg = *pd2MP((double)Ap1deg);
X      mptmpparmy = *pd2MP(parm.y);
X      mptmpparm2x = *pd2MP(parm2.x);
X      mpone       = *pd2MP(1.0);
X   }
X#endif
X
X   if(degree % 2)
X     symmetry = XAXIS;   /* odd */
X   else
X     symmetry = XYAXIS; /* even */
X   return(1);
X}
X
XPhoenixSetup()
X{
X   longparm = &lparm; /* added to consolidate code 10/1/92 JCO */
X   floatparm = &parm;
X   degree = (int)parm2.x;
X   if(degree < 2 && degree > -3) degree = 0;
X   param[2] = (double)degree;
X   if(degree == 0){
X     if(usr_floatflag)
X       curfractalspecific->orbitcalc =  PhoenixFractal;
X     else
X       curfractalspecific->orbitcalc =  LongPhoenixFractal;
X   }
X   if(degree >= 2){
X     degree = degree - 1;
X     if(usr_floatflag)
X       curfractalspecific->orbitcalc =  PhoenixPlusFractal;
X     else
X       curfractalspecific->orbitcalc =  LongPhoenixPlusFractal;
X   }
X   if(degree <= -3){
X     degree = abs(degree) - 2;
X     if(degree % 2)
X       symmetry = XYAXIS; /* odd */
X     else
X       symmetry = XAXIS; /* even */
X     if(usr_floatflag)
X       curfractalspecific->orbitcalc =  PhoenixMinusFractal;
X     else
X       curfractalspecific->orbitcalc =  LongPhoenixMinusFractal;
X   }
X
X   return(1);
X}
X
XMandPhoenixSetup()
X{
X   longparm = &linit; /* added to consolidate code 10/1/92 JCO */
X   floatparm = &init;
X   degree = (int)parm2.x;
X   if(degree < 2 && degree > -3) degree = 0;
X   param[2] = (double)degree;
X   if(degree == 0){
X     if(usr_floatflag)
X       curfractalspecific->orbitcalc =  PhoenixFractal;
X     else
X       curfractalspecific->orbitcalc =  LongPhoenixFractal;
X   }
X   if(degree >= 2){
X     degree = degree - 1;
X     if(usr_floatflag)
X       curfractalspecific->orbitcalc =  PhoenixPlusFractal;
X     else
X       curfractalspecific->orbitcalc =  LongPhoenixPlusFractal;
X   }
X   if(degree <= -3){
X     degree = abs(degree) - 2;
X     if(usr_floatflag)
X       curfractalspecific->orbitcalc =  PhoenixMinusFractal;
X     else
X       curfractalspecific->orbitcalc =  LongPhoenixMinusFractal;
X   }
X
X   return(1);
X}
X
XStandardSetup()
X{
X   if(fractype==UNITYFP)
X      periodicitycheck=0;
X   return(1);
X}
X
Xdemowalk()
X{
X    extern double param[];        /* optional user parameters */
X    extern int maxit;            /* maximum iterations (steps) */
X    extern int rflag, rseed;        /* random number seed */
X    extern int xdots, ydots;        /* image coordinates */
X    extern int colors;                  /* maximum colors available */
X    extern double far *dx0, far *dy0;    /* arrays of pixel coordinates */
X    extern double far *dx1, far *dy1;    /* (... for skewed zoom-boxes) */
X
X    float stepsize;            /* average stepsize */
X    int xwalk, ywalk;            /* current position */
X    int xstep, ystep;            /* current step */
X    int steps;                /* number of steps */
X    int color;                /* color to draw this step */
X    float temp, tempadjust;        /* temporary variables */
X
Xif (param[0] != 999) {            /* if 999, do a Mandelbrot instead */
X
X    srand(rseed);            /* seed the random number generator */
X    if (!rflag) ++rseed;
X    tempadjust = RAND_MAX >> 2;        /* adjustment factor */
X
X    xwalk = xdots / 2;            /* start in the center of the image */
X    ywalk = ydots / 2;
X
X    stepsize = min(xdots, ydots)     /* calculate average stepsize */
X               * (param[0]/100.0);    /* as a percentage of the image */
X
X    color = max(0, min(colors, param[1]));  /* set the initial color */
X
X    for (steps = 0; steps < maxit; steps++) { /* take maxit steps */
X        if (keypressed())        /* abort if told to do so */
X            return(0);
X        temp = rand();            /* calculate the next xstep */
X        xstep = ((temp/tempadjust) - 2.0) * stepsize;
X        xstep = min(xwalk + xstep, xdots - 1);
X        xstep = max(0, xstep);
X        temp = rand();            /* calculate the next ystep */
X        ystep = ((temp/tempadjust) - 2.0) * stepsize;
X        ystep = min(ywalk + ystep, ydots - 1);
X        ystep = max(0, ystep);
X        if (param[1] == 0.0)        /* rotate the colors? */
X            if (++color >= colors)    /* rotate the colors, avoiding */
X                color = 1;        /* the background color 0 */
X        /* the draw_line function is borrowed from the 3D routines */
X        draw_line(xwalk, ywalk,xstep,ystep,color);
X        /* or, we could be on a pogo stick and just displaying
X           where we landed...
X        putcolor(xstep, ystep, color);
X        */
X
X        xwalk = xstep;            /* remember where we were */
X        ywalk = ystep;
X        }
X    return(1);                          /* we're done */
X
X} else {                /* a simple Mandelbrot routine */
X
X    /* the following routine determines the X and Y values of
X       each pixel coordinate and calculates a simple mandelbrot
X       fractal with them - slowly, but surely */
X    int ix, iy;
X    for (iy = 0; iy < ydots; iy++) {
X        for (ix = 0; ix < xdots; ix++) {
X            int iter;
X            double x, y, newx, newy, tempxx, tempxy, tempyy;
X            /* first, obtain the X and Y coordinate values of this pixel */
X            x = dx0[ix]+dx1[iy];
X            y = dy0[iy]+dy1[ix];
X            /* now initialize the temporary values */
X            tempxx = tempyy = tempxy = 0.0;
X            if (keypressed())        /* abort if told to do so */
X                return(0);
X            /* the inner iteration loop */
X            for (iter = 1; iter < maxit; iter++) {
X                /* calculate the X and Y values of Z(iter) */
X                newx = tempxx - tempyy + x;
X                newy = tempxy + tempxy + y;
X                /* calculate the temporary values */
X                tempxx = newx * newx;
X                tempyy = newy * newy;
X                tempxy = newx * newy;
X                /* are we done yet? */
X                if (tempxx + tempyy > 4.0) break;
X                }
X            /* color in the pixel */
X            putcolor(ix, iy, iter & (colors - 1));
X            }
X        }
X    return(1);                          /* we're done */
X    }
X
X}
SHAR_EOF
$TOUCH -am 1028230093 fractals.c &&
chmod 0644 fractals.c ||
echo "restore of fractals.c failed"
set `wc -c fractals.c`;Wc_c=$1
if test "$Wc_c" != "101275"; then
    echo original size 101275, current size $Wc_c
fi
# ============= fractint.c ==============
echo "x - extracting fractint.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fractint.c &&
X/*
X    FRACTINT - The Ultimate Fractal Generator
X            Main Routine
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#include <time.h>
X#ifndef XFRACT
X#include <dos.h>
X#include <stdarg.h>
X#else
X#include <varargs.h>
X#endif
X#include <ctype.h>
X#include "prototyp.h"
X/* routines in this module    */
X
Xstatic void cmp_line_cleanup();
Xstatic void move_zoombox(int);
Xstatic int call_line3d(BYTE *pixels, int linelen);
Xvoid clear_zoombox();
Xstatic void note_zoom();
Xstatic void restore_zoom();
Xstatic void setup287code();
X
X#ifndef XFRACT
Xextern    int timer(int timertype,int(*subrtn)(),...);
X#else
Xextern  int timer();
X#endif
X
X#define PUTTHEMHERE 1        /* stuff common external arrays here */
X
X#include "fractint.h"
X#include "mpmath.h"
X#include "fractype.h"
X#include "helpdefs.h"
X
Xlong timer_start,timer_interval;    /* timer(...) start & total */
Xextern int  timerflag;
X
Xint    adapter;        /* Video Adapter chosen from list in ...h */
X
Xextern double xcjul, ycjul;
Xextern int soundflag;
Xextern int julibrot;
X
Xextern char gifmask[];
Xextern int TPlusErr;
X
Xextern int save_release, bailout;
Xextern int Transparent3D, far NewTPFractal, tpdepth;
Xextern int AntiAliasing, Shadowing;
Xextern int pot16bit;        /* save 16 bit values for continuous potential */
Xextern int disk16bit;        /* disk video up & running with 16 bit values */
Xextern int video_type;        /* coded value indicating video adapter type */
Xextern int usr_biomorph;
Xextern int escape_exit;
Xextern int forcesymmetry;
Xextern float  screenaspect;
Xextern    char    readname[];    /* name of fractal input file */
Xextern    int    showfile;    /* zero if display of file is pending */
X#define MAXHISTORY    10    /* save this many historical rcds */
Xstruct historystruct {        /* history structure */
X    int fractype;        /* fractal type */
X    double param[MAXPARAMS];/* parameters   */
X    double xxmin;        /* top left    */
X    double yymax;        /* top left    */
X    double xxmax;        /* bottom right */
X    double yymin;        /* bottom right */
X    double xx3rd;        /* bottom left    */
X    double yy3rd;        /* bottom left    */
X    } far *history;
X
Xchar *fract_dir1="", *fract_dir2="";
X
X#ifdef __TURBOC__
X
X/* yes, I *know* it's supposed to be compatible with Microsoft C,
X   but some of the routines need to know if the "C" code
X   has been compiled with Turbo-C.  This flag is a 1 if FRACTINT.C
X   (and presumably the other routines as well) has been compiled
X   with Turbo-C. */
Xint compiled_by_turboc = 1;
X
X/* set size to be used for overlays, a bit bigger than largest (help) */
Xunsigned _ovrbuffer = 54 * 64; /* that's 54k for overlays, counted in paragraphs */
X
X#else
X
Xint compiled_by_turboc = 0;
X
X#endif
X
Xextern char savename[];     /* save files using this name */
Xextern char preview;        /* 3D preview mode flag */
Xextern char temp1[];        /* temporary strings        */
Xextern int  debugflag;        /* internal use only - you didn't see this */
X/*
X   the following variables are out here only so
X   that the calcfract() and assembler routines can get at them easily
X*/
X    int    active_system = 0;    /* 0 for DOS, WINFRAC for Windows */
X    int    dotmode;        /* video access method        */
X    int    textsafe2;        /* textsafe override from videotable */
X    int    oktoprint;        /* 0 if printf() won't work */
X    int    sxdots,sydots;        /* # of dots on the physical screen    */
X    int    sxoffs,syoffs;        /* physical top left of logical screen */
X    int    xdots, ydots;        /* # of dots on the logical screen     */
X    double    dxsize, dysize;     /* xdots-1, ydots-1        */
X    int    colors;         /* maximum colors available */
X    int    maxit;            /* try this many iterations */
X    int    boxcount;        /* 0 if no zoom-box yet     */
X    int    zrotate;        /* zoombox rotation        */
X    double    zbx,zby;        /* topleft of zoombox        */
X    double    zwidth,zdepth,zskew;    /* zoombox size & shape     */
X
X    int    fractype;        /* if == 0, use Mandelbrot  */
X    char    stdcalcmode;        /* '1', '2', 'g', 'b'       */
X    long    creal, cimag;        /* real, imag'ry parts of C */
X    long    delx, dely;        /* screen pixel increments  */
X    long    delx2, dely2;        /* screen pixel increments  */
X    double    delxx, delyy;        /* screen pixel increments  */
X    double    delxx2, delyy2;     /* screen pixel increments  */
X    long    delmin;         /* for calcfrac/calcmand    */
X    double    ddelmin;        /* same as a double        */
X    double    param[MAXPARAMS];    /* parameters               */
X    double    potparam[3];        /* three potential parameters*/
X    long    fudge;            /* 2**fudgefactor        */
X    long    l_at_rad;        /* finite attractor radius  */
X    double    f_at_rad;        /* finite attractor radius  */
X    int    bitshift;        /* fudgefactor            */
X
X    int    badconfig = 0;        /* 'fractint.cfg' ok?       */
X    int    diskisactive;        /* disk-video drivers flag  */
X    int    diskvideo;        /* disk-video access flag   */
X    int hasinverse = 0;
X    /* note that integer grid is set when integerfractal && !invert;    */
X    /* otherwise the floating point grid is set; never both at once     */
X    long    far *lx0, far *ly0;    /* x, y grid            */
X    long    far *lx1, far *ly1;    /* adjustment for rotate    */
X    /* note that lx1 & ly1 values can overflow into sign bit; since     */
X    /* they're used only to add to lx0/ly0, 2s comp straightens it out  */
X    double far *dx0, far *dy0;    /* floating pt equivs */
X    double far *dx1, far *dy1;
X    int    integerfractal;     /* TRUE if fractal uses integer math */
X
X    /* usr_xxx is what the user wants, vs what we may be forced to do */
X    char    usr_stdcalcmode;
X    int    usr_periodicitycheck;
X    int    usr_distest;
X    char    usr_floatflag;
X
X    int    viewwindow;        /* 0 for full screen, 1 for window */
X    float    viewreduction;        /* window auto-sizing */
X    int    viewcrop;        /* nonzero to crop default coords */
X    float    finalaspectratio;    /* for view shape and rotation */
X    int    viewxdots,viewydots;    /* explicit view sizing */
Xextern    int    inside;         /* inside color: 1=blue     */
Xextern    int    outside;        /* outside color, if set    */
Xextern    int    cyclelimit;        /* color-rotator upper limit */
Xextern    int    display3d;        /* 3D display flag: 0 = OFF */
Xextern    int    overlay3d;        /* 3D overlay flag: 0 = OFF */
Xextern    int    boxcolor;        /* zoom box color */
Xextern    int    color_bright;        /* set by find_special_colors */
X
X#ifndef XFRACT
Xextern BYTE dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
Xextern BYTE olddacbox[256][3]; /* backup copy of the Video-DAC */
X#else
XBYTE dacbox[256][3];   /* Video-DAC (filled in by SETVIDEO) */
XBYTE olddacbox[256][3]; /* backup copy of the Video-DAC */
X#endif
Xextern struct videoinfo far videotable[];
Xextern BYTE far *mapdacbox;    /* default dacbox when map= specified */
Xextern int    daclearn, daccount;    /* used by the color-cyclers */
Xextern SEGTYPE    extraseg;        /* used by Save-to-DISK routines */
Xextern int    cpu;            /* cpu type            */
Xextern int    fpu;            /* fpu type            */
Xextern int    iit;            /* iit fpu?            */
Xextern int    lookatmouse;        /* used to select mouse mode    */
Xextern int    (*outln)(BYTE *, int);    /* called in decoder */
X       void    (*outln_cleanup)();
Xextern int    filetype;        /* GIF or other */
X
X/* variables defined by the command line/files processor */
Xextern    double    inversion[];
Xextern    int    invert;     /* non-zero if inversion active */
Xextern    int    initbatch;    /* 1 if batch run (no kbd)  */
X                 /* 2 batch, no save */
X                 /* 3 user interrupt, errorlevel 2 */
X                 /* 4 program error errorlevel 1, save */
X                 /* 5 program error errorlevel 1, don't save */
X                /* -1 complete first, then set to 1 */
X
Xextern    int    initmode;        /* initial video mode        */
Xextern    int    goodmode;        /* video.asm sets nonzero if mode ok */
Xextern    int    initcyclelimit;     /* initial cycle limit        */
Xextern    int    LogFlag;        /* non-zero if logarithmic palettes */
Xextern    int    reallyega;        /* == 0 if it's really an EGA */
X
Xextern char showbox;        /* flag to show box and vector in preview */
Xextern unsigned initsavetime;    /* timed save interval */
X
Xint    comparegif=0;            /* compare two gif files flag */
Xint    timedsave=0;            /* when doing a timed save */
Xextern long saveticks, savebase;    /* timed save vars for general.asm */
Xextern int  finishrow;            /* for general.asm timed save */
Xint    resave_flag=0;            /* tells encoder not to incr filename */
Xint    started_resaves=0;        /* but incr on first resave */
Xint    save_system;            /* from and for save files */
Xint    tabmode = 1;            /* tab display enabled */
Xextern    int got_status;
Xextern    int loaded3d;
Xextern    int colorstate,colorpreloaded;    /* comments in cmdfiles */
Xextern int functionpreloaded; /* set in cmdfiles for old bifs JCO 7/5/92 */
X
Xextern int  show_orbit;
X
X#ifdef XFRACT
Xextern int XZoomWaiting;
X#endif
X
X/* for historical reasons (before rotation):         */
X/*    top    left  corner of screen is (xxmin,yymax) */
X/*    bottom left  corner of screen is (xx3rd,yy3rd) */
X/*    bottom right corner of screen is (xxmax,yymin) */
Xdouble    xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* selected screen corners  */
Xlong    xmin, xmax, ymin, ymax, x3rd, y3rd;  /* integer equivs         */
Xdouble    sxmin,sxmax,symin,symax,sx3rd,sy3rd; /* displayed screen corners */
Xdouble    plotmx1,plotmx2,plotmy1,plotmy2;     /* real->screen multipliers */
X
Xint calc_status; /* -1 no fractal            */
X         /*  0 parms changed, recalc reqd   */
X         /*  1 actively calculating        */
X         /*  2 interrupted, resumable        */
X         /*  3 interrupted, not resumable   */
X         /*  4 completed            */
Xlong calctime;
X
Xint max_colors;                /* maximum palette size */
Xextern int max_kbdcount;        /* governs keyboard-check speed */
X
Xint       zoomoff;            /* = 0 when zoom is disabled    */
Xextern int nxtscreenflag; /* for cellular next screen generation */
X
Xstatic int far fromtext_flag = 0;    /* = 1 if we're in graphics mode */
Xint       savedac;            /* save-the-Video DAC flag    */
X
Xvoid main(int argc, char **argv)
X{
X   double  jxxmin, jxxmax, jyymin, jyymax; /* "Julia mode" entry point */
X   double  jxx3rd, jyy3rd;
X   int       frommandel;            /* if julia entered from mandel */
X   int       axmode, bxmode, cxmode, dxmode; /* video mode (BIOS ##)    */
X   int       historyptr;            /* pointer into history tbl    */
X   int       historyflag;         /* are we backing off in history? */
X   int       kbdchar;            /* keyboard key-hit value    */
X   int       kbdmore;            /* continuation variable    */
X   int       i, k;            /* temporary loop counters    */
X   double  ftemp;            /* fp temp            */
X   char stacked=0;            /* flag to indicate screen stacked */
X
X   initasmvars();            /* initialize ASM stuff */
X
X   if (extraseg == 0        /* oops.  not enough memory */
X     || (history = (struct historystruct far * ) farmemalloc((unsigned long)
X              (MAXHISTORY * sizeof(*history)))) == NULL
X     || (ly0 = (long far *) farmemalloc(4096L)) == NULL) {
X      buzzer(2);
X      printf(" I'm sorry, but you don't have enough free memory \n");
X      printf(" to run this program.\n\n");
X      exit(1);
X      }
X   farmemfree((BYTE far *)ly0); /* was just to check for min space */
X
X   dx0 = MK_FP(extraseg,0);
X   dy1 = (dx1 = (dy0 = dx0 + MAXPIXELS) + MAXPIXELS) + MAXPIXELS;
X   lx0 = (long far *) dx0;
X   ly1 = (lx1 = (ly0 = lx0 + MAXPIXELS) + MAXPIXELS) + MAXPIXELS;
X
X   historyptr = 0;            /* initialize history ptr */
X   historyflag = 0;
X   history[historyptr].fractype = -1;
X
X   load_videotable(1); /* load fractint.cfg, no message yet if bad */
X#ifdef XFRACT
X   UnixInit();
X#endif
X   init_help();
X
Xrestart:                /* insert key re-starts here */
X
X   cmdfiles(argc,argv);         /* process the command-line */
X   if(debugflag==450 && strcmp(savename,"fract001") != 0)
X   {
X      char name[80];
X      strcpy(name,savename);
X      strcat(name,".gif");
X      if(access(name,0)==0)
X         exit(0);
X   }
X#ifdef XFRACT
X   initUnixWindow();
X#endif
X
X   memcpy(olddacbox,dacbox,256*3);    /* save in case colors= present */
X
X   if (debugflag == 8088)         cpu =    86; /* for testing purposes */
X   if (debugflag == 2870 && fpu >= 287 ) fpu = 287; /* for testing purposes */
X   if (debugflag ==  870 && fpu >=  87 ) fpu =    87; /* for testing purposes */
X   if (debugflag ==   70)         fpu =     0; /* for testing purposes */
X   if (getenv("NO87")) fpu = 0;
X   fract_dir1 = getenv("FRACTDIR");
X   if (fract_dir1==NULL) {
X       fract_dir1 = ".";
X   }
X#ifdef SRCDIR
X   fract_dir2 = SRCDIR;
X#else
X   fract_dir2 = ".";
X#endif
X   if (fpu == 0)       iit = 0;
X   if (fpu >= 287 && debugflag != 72)    /* Fast 287 math */
X      setup287code();
X
X   /* IIT math coprocessor chip logic */
X   if(iit == 0 && fpu)
X      if(IITCoPro())
X         iit = 3;  /* detect iit chip */
X   if(iit < 0) iit = 0;  /* user wants chip turned off */
X   if(iit>0)
X   {
X      if(F4x4Check())
X         iit = 2;    /* semaphore TSR is installed */
X      else if(iit == 3)
X         iit = 0;    /* we detetct chip but no tsr - don't use */
X      /* else user forced iit == 1 */
X   }
X
X   adapter_detect();            /* check what video is really present */
X   if (debugflag >= 9002 && debugflag <= 9100) /* for testing purposes */
X      if (video_type > (debugflag-9000)/2)     /* adjust the video value */
X     video_type = (debugflag-9000)/2;
X
X   diskisactive = 0;            /* disk-video is inactive */
X   diskvideo = 0;            /* disk driver is not in use */
X   setvideotext();            /* switch to text mode */
X   calc_status = -1;            /* no active fractal image */
X   savedac = 0;             /* don't save the VGA DAC */
X
X   if (debugflag == 10000)        /* check for free memory */
X      showfreemem();
X
X#ifndef XFRACT
X   if (badconfig < 0)            /* fractint.cfg bad, no msg yet */
X      bad_fractint_cfg_msg();
X#endif
X
X   max_colors = 256;                    /* the Windows version is lower */
X   max_kbdcount=(cpu==386) ? 80 : 30;   /* check the keyboard this often */
X
X   if (showfile && initmode < 0) {
X      intro();                /* display the credits screen */
X      if (keypressed() == ESC) {
X     getakey();
X     goodbye();
X     }
X      }
X
X   if (colorpreloaded)
X      memcpy(dacbox,olddacbox,256*3);    /* restore in case colors= present */
X   if (!functionpreloaded)
X      set_if_old_bif();
X   stacked = 0;
Xrestorestart:
X
X   lookatmouse = 0;            /* ignore mouse */
X
X   while (showfile <= 0) {        /* image is to be loaded */
X      char *hdg;
X      tabmode = 0;
X      if (overlay3d) {
X     hdg = "Select File for 3D Overlay";
X     helpmode = HELP3DOVLY;
X     }
X      else if (display3d) {
X     hdg = "Select File for 3D Transform";
X     helpmode = HELP3D;
X     }
X      else {
X     hdg = "Select File to Restore";
X     helpmode = HELPSAVEREST;
X     }
X      if (showfile < 0 && getafilename(hdg,gifmask,readname) < 0) {
X     showfile = 1;             /* cancelled */
X     initmode = -1;
X     break;
X     }
X      showfile = 0;
X      helpmode = -1;
X      tabmode = 1;
X      if(stacked)
X      {
X         discardscreen();
X         setvideotext();
X         stacked = 0;
X      }
X      if (read_overlay() == 0)         /* read hdr, get video mode */
X     break;              /* got it, exit */
X      showfile = -1;             /* retry */
X      }
X
X   helpmode = HELPMENU;         /* now use this help mode */
X   tabmode = 1;
X   lookatmouse = 0;            /* ignore mouse */
X
X   if ((overlay3d || stacked) && initmode < 0) {    /* overlay command failed */
X      unstackscreen();            /* restore the graphics screen */
X      stacked = 0;
X      overlay3d = 0;            /* forget overlays */
X      display3d = 0;            /* forget 3D */
X      if (calc_status > 0 && calc_status !=2)
X     calc_status = 0;
X      goto resumeloop;            /* ooh, this is ugly */
X      }
X
X   savedac = 0;             /* don't save the VGA DAC */
Ximagestart:                /* calc/display a new image */
X   if(stacked)
X   {
X      discardscreen();
X      stacked = 0;
X   }
X#ifdef XFRACT
X   usr_floatflag = 1;
X#endif
X   got_status = -1;            /* for tab_display */
X
X   if (showfile)
X      if (calc_status > 0)        /* goto imagestart implies re-calc */
X     calc_status = 0;
X
X   if (initbatch == 0)
X      lookatmouse = -PAGE_UP;        /* just mouse left button, == pgup */
X
X   cyclelimit = initcyclelimit;     /* default cycle limit     */
X
X   frommandel = 0;
X
X   adapter = initmode;            /* set the video adapter up */
X   initmode = -1;            /* (once)            */
X
X   while (adapter < 0) {        /* cycle through instructions */
X      if (initbatch) {                /* batch, nothing to do */
X         initbatch = 4;            /* exit with error condition set */
X         goodbye();
X      }
X      kbdchar = main_menu(0);
X      if (kbdchar == INSERT) goto restart;    /* restart pgm on Insert Key */
X      if (kbdchar == DELETE)            /* select video mode list */
X     kbdchar = select_video_mode(-1);
X      if ((adapter = check_vidmode_key(0,kbdchar)) >= 0)
X     break;                 /* got a video mode now */
X#ifndef XFRACT
X      if ('A' <= kbdchar && kbdchar <= 'Z')
X     kbdchar = tolower(kbdchar);
X#endif
X      if (kbdchar == 'd') {                     /* shell to DOS */
X     setclear();
X     printf("\n\nShelling to DOS - type 'exit' to return\n\n");
X     shell_to_dos();
X     goto imagestart;
X     }
X#ifndef XFRACT
X      if (kbdchar == '@') {                     /* execute commands */
X#else
X      if (kbdchar == F2 || kbdchar == '@') {     /* We mapped @ to F2 */
X#endif
X     if ((get_commands() & 4) == 0)
X        goto imagestart;
X     kbdchar = '3';                         /* 3d=y so fall thru '3' code */
X     }
X#ifndef XFRACT
X      if (kbdchar == 'r' || kbdchar == '3' || kbdchar == '#') {
X#else
X      if (kbdchar == 'r' || kbdchar == '3' || kbdchar == F3) {
X#endif
X     display3d = 0;
X     if (kbdchar == '3' || kbdchar == '#' || kbdchar == F3)
X        display3d = 1;
X     setvideotext(); /* switch to text mode */
X     showfile = -1;
X     goto restorestart;
X     }
X      if (kbdchar == 't') {                     /* set fractal type */
X         julibrot = 0;
X     get_fracttype();
X     goto imagestart;
X     }
X      if (kbdchar == 'x') {                     /* generic toggle switch */
X     get_toggles();
X     goto imagestart;
X     }
X      if (kbdchar == 'y') {                     /* generic toggle switch */
X     get_toggles2();
X     goto imagestart;
X     }
X      if (kbdchar == 'z') {                     /* type specific parms */
X     get_fract_params(1);
X     goto imagestart;
X     }
X      if (kbdchar == 'v') {                     /* view parameters */
X     get_view_params();
X     goto imagestart;
X     }
X      if (kbdchar == 'f') {                     /* floating pt toggle */
X     if (usr_floatflag == 0)
X        usr_floatflag = 1;
X     else
X        usr_floatflag = 0;
X     goto imagestart;
X     }
X      if (kbdchar == 'i') {                     /* set 3d fractal parms */
X     get_fract3d_params(); /* get the parameters */
X     goto imagestart;
X     }
X      if (kbdchar == 'g') {
X     get_cmd_string(); /* get command string */
X     goto imagestart;
X         }
X      /* buzzer(2); */                /* unrecognized key */
X      }
X
X   zoomoff = 1;         /* zooming is enabled */
X   helpmode = HELPMAIN;     /* now use this help mode */
X
X   while (1) {            /* eternal loop */
X
X      if (calc_status != 2 || showfile == 0) {
X#ifdef XFRACT
X         if (resizeWindow()) {
X         calc_status = -1;
X     }
X#endif
X     far_memcpy((char far *)&videoentry,(char far *)&videotable[adapter],
X            sizeof(videoentry));
X     axmode  = videoentry.videomodeax; /* video mode (BIOS call)   */
X     bxmode  = videoentry.videomodebx; /* video mode (BIOS call)   */
X     cxmode  = videoentry.videomodecx; /* video mode (BIOS call)   */
X     dxmode  = videoentry.videomodedx; /* video mode (BIOS call)   */
X     dotmode = videoentry.dotmode;       /* assembler dot read/write */
X     xdots     = videoentry.xdots;       /* # dots across the screen */
X     ydots     = videoentry.ydots;       /* # dots down the screen   */
X     colors  = videoentry.colors;       /* # colors available */
X     textsafe2 = dotmode / 100;
X     dotmode  %= 100;
X     sxdots  = xdots;
X     sydots  = ydots;
X     sxoffs = syoffs = 0;
X
X     diskvideo = 0;         /* set diskvideo flag */
X     if (dotmode == 11)        /* default assumption is disk */
X        diskvideo = 2;
X
X     memcpy(olddacbox,dacbox,256*3); /* save the DAC */
X     diskisactive = 1;        /* flag for disk-video routines */
X
X     if (overlay3d) {
X        unstackscreen();        /* restore old graphics image */
X        overlay3d = 0;
X        }
X
X     else {
X        setvideomode(axmode,bxmode,cxmode,dxmode); /* switch video modes */
X        if (goodmode == 0) {
X           static char far msg[] = {"That video mode is not available with your adapter."};
X           static char far TPlusStr[] = "This video mode requires 'noninterlaced=yes'";
X
X           if(TPlusErr) {
X          stopmsg(0, TPlusStr);
X          TPlusErr = 0;
X          }
X           else
X          stopmsg(0,msg);
X           initmode = -1;
X           setvideotext(); /* switch to text mode */
X           goto restorestart;
X           }
X
X        if(Transparent3D && curfractalspecific->orbitcalc == Formula) {
X           char far *ErrMsg;
X           if((ErrMsg = TrueColorAutoDetect()) != ((char far*)0)) {
X          stopmsg(0, ErrMsg);
X          Transparent3D = 0;
X          }
X           else {
X          tpdepth = 0;
X          NewTPFractal = 1;
X          }
X           }
X        else if(AntiAliasing) {
X           if(dotmode != 11) {
X          static char far DiskVidError[] =
X            "Anti-aliasing resolution too high, try a lower value or lower\n\
Xscreen resolution.";
X          /* Ensure the absolute resolution is < MAXPIXELS */
X          if(AntiAliasing >= 8 ||
X             ((long)xdots << AntiAliasing) > MAXPIXELS)
X             goto AntiAliasError;
X          if(!colors)
X             TrueColorAutoDetect();
X          if(SetupShadowVideo() != 0) {
XAntiAliasError:
X             stopmsg(0, DiskVidError);
X             initmode = -1;
X             setvideotext(); /* switch to text mode */
X             goto restorestart;
X             }
X          }
X           }
X        }
X
X     diskisactive = 0;        /* flag for disk-video routines */
X     if (savedac || colorpreloaded) {
X        memcpy(dacbox,olddacbox,256*3); /* restore the DAC */
X        spindac(0,1);
X        colorpreloaded = 0;
X        }
X     else { /* reset DAC to defaults, which setvideomode has done for us */
X        if (mapdacbox) { /* but there's a map=, so load that */
X           far_memcpy((char far *)dacbox,mapdacbox,768);
X           spindac(0,1);
X           }
X        else if ((dotmode == 11 && colors == 256) || !colors) {
X           /* disk video, setvideomode via bios didn't get it right, so: */
X#ifndef XFRACT
X           ValidateLuts("default"); /* read the default palette file */
X#endif
X           }
X        colorstate = 0;
X        }
X     if (viewwindow) {
X        ftemp = finalaspectratio
X            * (double)sydots / (double)sxdots / screenaspect;
X        if ((xdots = viewxdots)) { /* xdots specified */
X           if ((ydots = viewydots) == 0) /* calc ydots? */
X          ydots = (double)xdots * ftemp + 0.5;
X           }
X        else
X           if (finalaspectratio <= screenaspect) {
X          xdots = (double)sxdots / viewreduction + 0.5;
X          ydots = (double)xdots * ftemp + 0.5;
X          }
X           else {
X          ydots = (double)sydots / viewreduction + 0.5;
X          xdots = (double)ydots / ftemp + 0.5;
X          }
X        if (xdots > sxdots || ydots > sydots) {
X           static char far msg[] = {"View window too large; using full screen."};
X           stopmsg(0,msg);
X           xdots = sxdots;
X           ydots = sydots;
X           }
X        else if (xdots <= sxdots/20 || ydots <= sydots/20) { /* so ssg works */
X           static char far msg[] = {"View window too small; using full screen."};
X           stopmsg(0,msg);
X           xdots = sxdots;
X           ydots = sydots;
X           }
X        sxoffs = (sxdots - xdots) / 2;
X        syoffs = (sydots - ydots) / 3;
X        }
X     dxsize = xdots - 1;        /* convert just once now */
X     dysize = ydots - 1;
X     }
X      if(savedac == 0)
X        savedac = 2;            /* assume we save next time (except jb) */
X      else
X      savedac = 1;            /* assume we save next time */
X      if (initbatch == 0)
X     lookatmouse = -PAGE_UP;    /* mouse left button == pgup */
X
X      if(showfile == 0) {        /* loading an image */
X     outln_cleanup = NULL;        /* outln routine can set this */
X     if (display3d)         /* set up 3D decoding */
X        outln = call_line3d;
X     else if(filetype >= 1)     /* old .tga format input file */
X        outln = outlin16;
X     else if(comparegif)        /* debug 50 */
X        outln = cmp_line;
X     else if(pot16bit) {        /* .pot format input file */
X        if (pot_startdisk() < 0)
X        {                /* pot file failed?  */
X           extern int potflag;
X
X           showfile = 1;
X           potflag  = 0;
X           pot16bit = 0;
X           initmode = -1;
X           calc_status = 2;        /* "resume" without 16-bit */
X           setvideotext();
X           get_fracttype();
X           goto imagestart;
X        }
X        outln = pot_line;
X     }
X     else                /* regular gif/fra input file */
X            if(soundflag > 0)
X               outln = sound_line;      /* sound decoding */
X            else
X               outln = out_line;        /* regular decoding */
X     if(filetype == 0)
X     {
X        if(iit == 2 && usr_floatflag != 0)
X           if(F4x4Lock()==0)
X              iit = -1;  /* semaphore not free - no iit */
X        if(debugflag==2224)
X         {
X            char buf[80];
X            sprintf(buf,"iit=%d floatflag=%d",iit,usr_floatflag);
X            stopmsg(4,(char far *)buf);
X         }
X
X        i = funny_glasses_call(gifview);
X        if(iit == 2)
X           F4x4Free();      /* unlock semaphore */
X        else if(iit == -1)
X           iit = 2;         /* semaphore operating */
X     }
X     else
X        i = funny_glasses_call(tgaview);
X     if(outln_cleanup)        /* cleanup routine defined? */
X        (*outln_cleanup)();
X     if(i == 0)
X        buzzer(0);
X     else {
X        calc_status = -1;
X        if (keypressed()) {
X           buzzer(1);
X           while (keypressed()) getakey();
X           texttempmsg("*** load incomplete ***");
X           }
X        }
X     }
X
X      zoomoff = 1;            /* zooming is enabled */
X      if (dotmode == 11 || (curfractalspecific->flags&NOZOOM) != 0)
X     zoomoff = 0;            /* for these cases disable zooming */
X
X      calcfracinit();
X#ifdef XFRACT
X      schedulealarm(1);
X#endif
X
X      sxmin = xxmin; /* save 3 corners for zoom.c ref points */
X      sxmax = xxmax;
X      sx3rd = xx3rd;
X      symin = yymin;
X      symax = yymax;
X      sy3rd = yy3rd;
X
X      if (history[0].fractype == -1)    /* initialize the history file */
X     for (i = 0; i < MAXHISTORY; i++) {
X        int j;
X        history[i].xxmax = xxmax;
X        history[i].xxmin = xxmin;
X        history[i].yymax = yymax;
X        history[i].yymin = yymin;
X        history[i].xx3rd = xx3rd;
X        history[i].yy3rd = yy3rd;
X        for(j=0;j<MAXPARAMS;j++)
X           history[i].param[j] = param[j];
X        history[i].fractype = fractype;
X        }
X
X      if ( history[historyptr].xxmax != xxmax  || /* save any (new) zoom data */
X       history[historyptr].xxmin != xxmin  ||
X       history[historyptr].yymax != yymax  ||
X       history[historyptr].yymin != yymin  ||
X       history[historyptr].xx3rd != xx3rd  ||
X       history[historyptr].yy3rd != yy3rd  ||
X       history[historyptr].param[0] != param[0] ||
X       history[historyptr].param[1] != param[1] ||
X       history[historyptr].param[2] != param[2] ||
X       history[historyptr].param[3] != param[3] ||
X       history[historyptr].param[4] != param[4] ||
X       history[historyptr].param[5] != param[5] ||
X       history[historyptr].param[6] != param[6] ||
X       history[historyptr].param[7] != param[7] ||
X       history[historyptr].param[8] != param[8] ||
X       history[historyptr].param[9] != param[9] ||
X       history[historyptr].fractype != fractype) {
X           int j;
X     if (historyflag == 0) /* if we're not backing off for <\> */
X        if (++historyptr == MAXHISTORY) historyptr = 0;
X     history[historyptr].xxmax = xxmax;
X     history[historyptr].xxmin = xxmin;
X     history[historyptr].yymax = yymax;
X     history[historyptr].yymin = yymin;
X     history[historyptr].xx3rd = xx3rd;
X     history[historyptr].yy3rd = yy3rd;
X         for(j=0;j<MAXPARAMS;j++)
X            history[historyptr].param[j] = param[j];
X     history[historyptr].fractype = fractype;
X     }
X      historyflag = 0;
X
X      if (display3d || showfile) {    /* paranoia: these vars don't get set */
X     save_system  = active_system;    /*   unless really doing some work,   */
X     }                /*   so simple <r> + <s> keeps number */
X
X      if(showfile == 0) {        /* image has been loaded */
X     showfile = 1;
X     if (initbatch == 1 && calc_status == 2)
X        initbatch = -1; /* flag to finish calc before save */
X     if (loaded3d)        /* 'r' of image created with '3' */
X        display3d = 1;  /* so set flag for 'b' command */
X     }
X      else {                /* draw an image */
X     diskisactive = 1;        /* flag for disk-video routines */
X     if (initsavetime != 0        /* autosave and resumable? */
X       && (curfractalspecific->flags&NORESUME) == 0) {
X        savebase = readticker(); /* calc's start time */
X        saveticks = (long)initsavetime * 1092; /* bios ticks/minute */
X        if ((saveticks & 65535L) == 0)
X           ++saveticks; /* make low word nonzero */
X        finishrow = -1;
X        }
X
X     if(Transparent3D && curfractalspecific->orbitcalc == Formula)
X        i = Transp3DFnct();
X     else {
X        i = calcfract();    /* draw the fractal using "C" */
X        if(AntiAliasing && i == 0)
X           AntiAliasPass();
X        }
X     if (i == 0)
X        buzzer(0); /* finished!! */
X
X     saveticks = 0;         /* turn off autosave timer */
X     if (dotmode == 11 && i == 0) /* disk-video */
X        dvid_status(0,"Image has been completed");
X     diskisactive = 0;        /* flag for disk-video routines */
X     }
X
X#ifndef XFRACT
X      boxcount = 0;            /* no zoom box yet  */
X      zwidth = 0;
X#else
X      if (!XZoomWaiting) {
X      boxcount = 0;            /* no zoom box yet  */
X      zwidth = 0;
X      }
X#endif
X
X      if (fractype == PLASMA && cpu > 88) {
X     cyclelimit = 256;        /* plasma clouds need quick spins */
X     daccount = 256;
X     daclearn = 1;
X     }
X
Xresumeloop:                /* return here on failed overlays */
X
X      kbdmore = 1;
X      while (kbdmore == 1) {        /* loop through command keys */
X
X     if (timedsave != 0) {
X        if (timedsave == 1) {    /* woke up for timed save */
X           getakey();     /* eat the dummy char */
X           kbdchar = 's'; /* do the save */
X           resave_flag = 1;
X           timedsave = 2;
X           }
X        else {            /* save done, resume */
X           timedsave = 0;
X           resave_flag = 2;
X           kbdchar = ENTER;
X           }
X        }
X     else if (initbatch == 0) {    /* not batch mode */
X        lookatmouse = (zwidth == 0) ? -PAGE_UP : 3;
X        if (calc_status == 2 && zwidth == 0 && !keypressed()) {
X           kbdchar = ENTER;        /* no visible reason to stop, continue */
X        } else {            /* wait for a real keystroke */
X#ifndef XFRACT
X               while (!keypressed()) { }  /* enables help */
X#else
X               waitkeypressed(0);
X#endif
X           kbdchar = getakey();
X           if (kbdchar == ESC || kbdchar == 'm' || kbdchar == 'M') {
X                  if (kbdchar == ESC && escape_exit != 0)
X                      /* don't ask, just get out */
X                      goodbye();
X          stackscreen();
X#ifndef XFRACT
X          kbdchar = main_menu(1);
X#else
X                  if (XZoomWaiting) {
X              kbdchar = ENTER;
X          } else {
X              kbdchar = main_menu(1);
X              if (XZoomWaiting) {
X              kbdchar = ENTER;
X              }
X          }
X#endif
X          if (kbdchar == '\\'
X            || check_vidmode_key(0,kbdchar) >= 0)
X             discardscreen();
X          else if (kbdchar == 'x' || kbdchar == 'y' ||
X                   kbdchar == 'z' || kbdchar == 'g' )
X             fromtext_flag = 1;
X          else
X             unstackscreen();
X          }
X           }
X        }
X     else {             /* batch mode, fake next keystroke */
X        if (initbatch == -1) {    /* finish calc */
X           kbdchar = ENTER;
X           initbatch = 1;
X           }
X        else if (initbatch == 1 || initbatch == 4 ) {    /* save-to-disk */
X/*
X           while(keypressed())
X         getakey();
X*/
X           if (debugflag == 50)
X          kbdchar = 'r';
X           else
X          kbdchar = 's';
X           if(initbatch == 1) initbatch = 2;
X           if(initbatch == 4) initbatch = 5;
X           }
X        else {
X           if(calc_status != 4) initbatch = 3; /* bailout with error */
X           goodbye();        /* done, exit */
X           }
X        }
X
X#ifndef XFRACT
X         if ('A' <= kbdchar && kbdchar <= 'Z')
X            kbdchar = tolower(kbdchar);
X#endif
X     switch (kbdchar) {
X        int x,y,v;
X        case 't':                   /* new fractal type             */
X           julibrot = 0;
X           clear_zoombox();
X           stackscreen();
X           if ((i = get_fracttype()) >= 0) {
X          discardscreen();
X          savedac = 0;
X          if (i == 0) {
X             initmode = adapter;
X             frommandel = 0;
X             }
X          else
X             if (initmode < 0)    /* it is supposed to be... */
X            setvideotext(); /* reset to text mode       */
X          goto imagestart;
X          }
X           unstackscreen();
X           break;
X        case 24:                    /* Ctl-X, Ctl-Y, CTL-Z do flipping */
X        case 25:
X        case 26:
X           flip_image(kbdchar);
X           break;
X        case 'x':                   /* invoke options screen        */
X        case 'y':
X        case 'z':                   /* type specific parms */
X        case 'g':
X           if (fromtext_flag == 1)
X               fromtext_flag = 0;
X           else
X               stackscreen();
X           if (kbdchar == 'x')
X          i = get_toggles();
X           else if (kbdchar == 'y')
X          i = get_toggles2();
X           else if (kbdchar =='z')
X          i = get_fract_params(1);
X               else
X                  i = get_cmd_string();
X           if (i > 0) {        /* time to redraw? */
X          discardscreen();
X          kbdmore = calc_status = 0;
X          }
X           else
X          unstackscreen();
X           break;
X#ifndef XFRACT
X        case '@':                   /* execute commands */
X#else
X        case F2:                   /* execute commands */
X#endif
X           stackscreen();
X           i = get_commands();
X           if (initmode != -1) {    /* video= was specified */
X          adapter = initmode;
X          initmode = -1;
X          i |= 1;
X          savedac = 0;
X          }
X           else if (colorpreloaded) { /* colors= was specified */
X          spindac(0,1);
X          colorpreloaded = 0;
X          }
X           else if ((i & 8))    /* reset was specified */
X          savedac = 0;
X           if ((i & 4)) {        /* 3d = was specified */
X          kbdchar = '3';
X          unstackscreen();
X          goto do_3d_transform; /* pretend '3' was keyed */
X          }
X           if ((i & 1)) {        /* fractal parameter changed */
X          discardscreen();
X          if(!functionpreloaded)
X            set_if_old_bif(); /* old bifs need function set, JCO 7/5/92 */
X          if(fractype==MANDELTRIG && usr_floatflag==1
X             && save_release < 1800 && bailout == 0)
X            bailout = 2500;
X          if(fractype==LAMBDATRIG && usr_floatflag==1
X             && save_release < 1800 && bailout == 0)
X            bailout = 2500;
X          kbdmore = calc_status = 0;
X          }
X           else
X          unstackscreen();
X           break;
X        case 'v':                   /* invoke options screen        */
X           i = get_view_params();    /* get the parameters */
X           if (i > 0)        /* time to redraw? */
X          kbdmore = calc_status = 0;
X           break;
X        case 'f':                   /* floating pt toggle           */
X           if (usr_floatflag == 0)
X          usr_floatflag = 1;
X           else
X          usr_floatflag = 0;
X           initmode = adapter;
X           goto imagestart;
X        case 'i':                   /* 3d fractal parms */
X           if (get_fract3d_params() >= 0) /* get the parameters */
X          calc_status = kbdmore = 0;  /* time to redraw */
X           break;
X        case 'a':                  /* starfield parms               */
X           clear_zoombox();
X           if (get_starfield_params() >= 0) {
X              if (starfield() >= 0)
X             calc_status = 0;
X          continue;
X          }
X           break;
X        case 15:   /* ctrl-o */
X        case 'o':
X            /* must use standard fractal and have a float variant */
X            if(fractalspecific[fractype].calctype == StandardFractal &&
X               (fractalspecific[fractype].isinteger == 0 ||
X                fractalspecific[fractype].tofloat != NOFRACTAL))
X            {
X               clear_zoombox();
X               Jiim(ORBIT);
X            }
X            break;
X        case SPACE:               /* spacebar, toggle mand/julia    */
X        if (fractype == CELLULAR) {
X            if(nxtscreenflag)
X              nxtscreenflag = 0; /* toggle flag to stop generation */
X            else
X              nxtscreenflag = 1; /* toggle flag to generate next screen */
X            calc_status = 2;
X            kbdmore = 0;
X        }
X        else {
X           if (curfractalspecific->tojulia != NOFRACTAL
X         && param[0] == 0.0 && param[1] == 0.0) {
X          /* switch to corresponding Julia set */
X         if(1)
X         {
X             int key;
X              if(fractype==MANDEL || fractype==MANDELFP)
X                 hasinverse=1;
X              else
X                 hasinverse=0;
X             clear_zoombox();
X             Jiim(JIIM);
X             key = getakey(); /* flush keyboard buffer */
X             if(key != SPACE)
X             {
X                ungetakey(key);
X                break;
X             }
X          }
X          fractype = curfractalspecific->tojulia;
X          curfractalspecific = &fractalspecific[fractype];
X          if(xcjul == BIG || ycjul == BIG)
X          {
X                param[0] = (xxmax + xxmin) / 2;
X             param[1] = (yymax + yymin) / 2;
X          }
X          else
X          {
X                param[0] = xcjul;
X             param[1] = ycjul;
X             xcjul = ycjul = BIG;
X          }
X          jxxmin = sxmin; jxxmax = sxmax;
X          jyymax = symax; jyymin = symin;
X          jxx3rd = sx3rd; jyy3rd = sy3rd;
X          frommandel = 1 ;
X          xxmin = curfractalspecific->xmin;
X          xxmax = curfractalspecific->xmax;
X          yymin = curfractalspecific->ymin;
X          yymax = curfractalspecific->ymax;
X          xx3rd = xxmin;
X          yy3rd = yymin;
X          if (usr_distest == 0 && usr_biomorph != -1 && bitshift != 29) {
X             xxmin *= 3.0;
X             xxmax *= 3.0;
X             yymin *= 3.0;
X             yymax *= 3.0;
X             xx3rd *= 3.0;
X             yy3rd *= 3.0;
X             }
X          zoomoff = 1;
X          calc_status = 0;
X          kbdmore = 0;
X          }
X           else if (curfractalspecific->tomandel != NOFRACTAL) {
X          /* switch to corresponding Mandel set */
X          fractype = curfractalspecific->tomandel;
X          curfractalspecific = &fractalspecific[fractype];
X          if (frommandel) {
X             xxmin = jxxmin;  xxmax = jxxmax;
X             yymin = jyymin;  yymax = jyymax;
X             xx3rd = jxx3rd;  yy3rd = jyy3rd;
X             }
X          else {
X             double ccreal,ccimag;
X             ccreal = (curfractalspecific->xmax - curfractalspecific->xmin) / 2;
X             ccimag = (curfractalspecific->ymax - curfractalspecific->ymin) / 2;
X             xxmin = xx3rd = param[0] - ccreal;
X             xxmax = param[0] + ccreal;
X             yymin = yy3rd = param[1] - ccimag;
X             yymax = param[1] + ccimag;
X             }
X          param[0] = 0;
X          param[1] = 0;
X          zoomoff = 1;
X          calc_status = 0;
X          kbdmore = 0;
X          }
X           else
X          buzzer(2); /* can't switch */
X           } /* end of else for if == cellular */
X           break;
X        case 'j':                 /* inverse julia toggle */
X           /* if the inverse types proliferate, something more elegant will
X              be needed */
X           if(fractype==JULIA || fractype==JULIAFP || fractype==INVERSEJULIA)
X           {
X              static int oldtype = -1;
X              if(fractype==JULIA || fractype==JULIAFP)
X              {
X                 oldtype=fractype;
X                 fractype=INVERSEJULIA;
X              }
X              else if(fractype==INVERSEJULIA)
X              {
X                 if(oldtype != -1)
X                    fractype=oldtype;
X                 else
X                    fractype=JULIA;
X              }
X             curfractalspecific = &fractalspecific[fractype];
X             zoomoff = 1;
X             calc_status = 0;
X             kbdmore = 0;
X          }
X#if 0
X          else if(fractype==MANDEL || fractype==MANDELFP)
X          {
X            clear_zoombox();
X            Jiim(JIIM);
X            }
X#endif
X          else
X          buzzer(2);
X           break;
X        case '\\':                 /* return to prev image    */
X           if (--historyptr < 0)
X          historyptr = MAXHISTORY-1;
X           xxmax  = history[historyptr].xxmax;
X           xxmin  = history[historyptr].xxmin;
X           yymax  = history[historyptr].yymax;
X           yymin  = history[historyptr].yymin;
X           xx3rd  = history[historyptr].xx3rd;
X           yy3rd  = history[historyptr].yy3rd;
X           {
X              int j;
X              for(j=0;j<MAXPARAMS;j++)
X                    param[j] = history[historyptr].param[j];
X               }
X           fractype = history[historyptr].fractype;
X           curfractalspecific = &fractalspecific[fractype];
X           zoomoff = 1;
X           initmode = adapter;
X           if (curfractalspecific->isinteger != 0 &&
X           curfractalspecific->tofloat != NOFRACTAL)
X          usr_floatflag = 0;
X           if (curfractalspecific->isinteger == 0 &&
X           curfractalspecific->tofloat != NOFRACTAL)
X          usr_floatflag = 1;
X           historyflag = 1; /* avoid re-store parms due to rounding errs */
X           goto imagestart;
X        case 'd':                   /* shell to MS-DOS              */
X           stackscreen();
X#ifndef XFRACT
X           if (axmode == 0 || axmode > 7) {
Xstatic char far dosmsg[]={"\
XNote:  Your graphics image is still squirreled away in your video\n\
Xadapter's memory.  Switching video modes will clobber part of that\n\
Ximage.  Sorry - it's the best we could do."};
X          putstring(0,0,7,dosmsg);
X          movecursor(6,0);
X          }
X#endif
X           shell_to_dos();
X           unstackscreen();
X/*           calc_status = 0; */
X           break;
X        case 'c':                   /* switch to color cycling      */
X        case '+':                   /* rotate palette               */
X        case '-':                   /* rotate palette               */
X           clear_zoombox();
X           memcpy(olddacbox,dacbox,256*3);
X           rotate((kbdchar == 'c') ? 0 : ((kbdchar == '+') ? 1 : -1));
X           if (memcmp(olddacbox,dacbox,256*3))
X          colorstate = 1;
X           continue;
X        case 'e':                   /* switch to color editing      */
X           clear_zoombox();
X           if (dacbox[0][0] != 255 && !reallyega && colors >= 16
X         && dotmode != 11) {
X          int oldhelpmode;
X          oldhelpmode = helpmode;
X          memcpy(olddacbox,dacbox,256*3);
X          helpmode = HELPXHAIR;
X          EditPalette();
X          helpmode = oldhelpmode;
X          if (memcmp(olddacbox,dacbox,256*3))
X             colorstate = 1;
X          }
X           continue;
X        case 's':                   /* save-to-disk                 */
X           diskisactive = 1;    /* flag for disk-video routines */
X           note_zoom();
X           savetodisk(savename);
X           restore_zoom();
X           diskisactive = 0;    /* flag for disk-video routines */
X           continue;
X        case '#':                   /* 3D overlay                   */
X#ifdef XFRACT
X        case F3:                   /* 3D overlay                   */
X#endif
X           clear_zoombox();
X           overlay3d = 1;
X        case '3':                   /* restore-from (3d)            */
Xdo_3d_transform:
X           if(overlay3d)
X              display3d = 2;    /* for <b> command         */
X           else
X           display3d = 1;
X        case 'r':                   /* restore-from                 */
X           comparegif = 0;
X           frommandel = 0;
X           if(kbdchar == 'r')  {
X          if(debugflag == 50) {
X             comparegif = overlay3d = 1;
X             if (initbatch == 2) {
X            stackscreen(); /* save graphics image */
X            strcpy(readname,savename);
X            showfile = 0;
X            goto restorestart;
X            }
X             }
X          else
X             comparegif = overlay3d = 0;
X          display3d = 0;
X          }
X           stackscreen(); /* save graphics image */
X        if (overlay3d)
X              stacked = 0;
X            else
X              stacked = 1;
X           if (resave_flag) {
X          updatesavename(savename); /* do the pending increment */
X          resave_flag = started_resaves = 0;
X          }
X           showfile = -1;
X           goto restorestart;
X        case 'b':                   /* make batch file              */
X           make_batch_file();
X           break;
X        case 'p':                   /* print current image          */
X           note_zoom();
X           Print_Screen();
X           restore_zoom();
X           if (!keypressed())
X          buzzer(0);
X           else {
X          buzzer(1);
X          getakey();
X          }
X           continue;
X            case ENTER:                 /* Enter                        */
X            case ENTER_2:               /* Numeric-Keypad Enter         */
X#ifdef XFRACT
X               XZoomWaiting = 0;
X#endif
X           if (zwidth != 0.0) {    /* do a zoom */
X          init_pan_or_recalc(0);
X          kbdmore = 0;
X          }
X           if (calc_status != 4)    /* don't restart if image complete */
X          kbdmore = 0;
X           break;
X            case CTL_ENTER:             /* control-Enter                */
X            case CTL_ENTER_2:           /* Control-Keypad Enter         */
X           init_pan_or_recalc(1);
X           kbdmore = 0;
X           zoomout(); /* calc corners for zooming out */
X           break;
X            case INSERT:                /* insert                       */
X           setvideotext(); /* force text mode */
X           goto restart;
X            case LEFT_ARROW:            /* cursor left                  */
X            case RIGHT_ARROW:           /* cursor right                 */
X            case UP_ARROW:              /* cursor up                    */
X            case DOWN_ARROW:            /* cursor down                  */
X            case LEFT_ARROW_2:          /* Ctrl-cursor left             */
X            case RIGHT_ARROW_2:         /* Ctrl-cursor right            */
X            case UP_ARROW_2:            /* Ctrl-cursor up               */
X            case DOWN_ARROW_2:          /* Ctrl-cursor down             */
X           move_zoombox(kbdchar);
X           break;
X            case CTL_HOME:              /* Ctrl-home                    */
X           if (boxcount && (curfractalspecific->flags&NOROTATE) == 0) {
X                  i = key_count(CTL_HOME);
X          if ((zskew -= 0.02*i) < -0.48)
X             zskew = -0.48;
X          }
X           break;
X            case CTL_END:               /* Ctrl-end                     */
X               if (boxcount && (curfractalspecific->flags&NOROTATE) == 0) {
X                  i = key_count(CTL_END);
X          if ((zskew += 0.02*i) > 0.48)
X             zskew = 0.48;
X          }
X           break;
X            case CTL_PAGE_UP:           /* Ctrl-pgup                    */
X               if (boxcount)
X                  chgboxi(0,-2*key_count(CTL_PAGE_UP));
X               break;
X            case CTL_PAGE_DOWN:         /* Ctrl-pgdn                    */
X               if (boxcount)
X                  chgboxi(0,2*key_count(CTL_PAGE_DOWN));
X               break;
X            case PAGE_UP:               /* page up                      */
X           if (zoomoff == 1)
X          if (zwidth == 0) { /* start zoombox */
X             zwidth = zdepth = 1;
X             zrotate = zskew = 0;
X             zbx = zby = 0;
X             find_special_colors();
X             boxcolor = color_bright;
X             }
X          else
X                     resizebox(0-key_count(PAGE_UP));
X               break;
X            case PAGE_DOWN:             /* page down                    */
X           if (boxcount) {
X          if (zwidth >= .999 && zdepth >= 0.999) /* end zoombox */
X             zwidth = 0;
X          else
X                     resizebox(key_count(PAGE_DOWN));
X                  }
X               break;
X            case CTL_MINUS:             /* Ctrl-kpad-                  */
X               if (boxcount && (curfractalspecific->flags&NOROTATE) == 0)
X                  zrotate += key_count(CTL_MINUS);
X               break;
X            case CTL_PLUS:              /* Ctrl-kpad+               */
X               if (boxcount && (curfractalspecific->flags&NOROTATE) == 0)
X                  zrotate -= key_count(CTL_PLUS);
X               break;
X            case CTL_INSERT:            /* Ctrl-ins                 */
X               boxcolor += key_count(CTL_INSERT);
X               break;
X            case CTL_DEL:               /* Ctrl-del                 */
X               boxcolor -= key_count(CTL_DEL);
X           break;
X        case DELETE:        /* select video mode from list */
X           stackscreen();
X           kbdchar = select_video_mode(adapter);
X           if (check_vidmode_key(0,kbdchar) >= 0) /* picked a new mode? */
X          discardscreen();
X           else
X          unstackscreen();
X           /* fall through */
X        default:            /* other (maybe a valid Fn key) */
X           if ((k = check_vidmode_key(0,kbdchar)) >= 0) {
X          adapter = k;
X/*          if (videotable[adapter].dotmode != 11       Took out so that */
X/*            || videotable[adapter].colors != colors)  DAC is not reset */
X/*             savedac = 0;                    when changing video modes */
X          calc_status = 0;
X          kbdmore = 0;
X          continue;
X          }
X           break;
X
X        } /* end of the big switch */
X
X     if (zoomoff == 1 && kbdmore == 1) /* draw/clear a zoom box? */
X        drawbox(1);
X#ifdef XFRACT
X     if (resizeWindow()) {
X         calc_status = -1;
X     }
X#endif
X     }
X      }
X
X}
X
X/* read keystrokes while = specified key, return 1+count;    */
X/* used to catch up when moving zoombox is slower than keyboard */
Xint key_count(int keynum)
X{  int ctr;
X   ctr = 1;
X   while (keypressed() == keynum) {
X      getakey();
X      ++ctr;
X      }
X   return ctr;
X}
X
X/* do all pending movement at once for smooth mouse diagonal moves */
Xstatic void move_zoombox(int keynum)
X{  int vertical, horizontal, getmore;
X   if (boxcount == 0)
X      return;
X   vertical = horizontal = 0;
X   getmore = 1;
X   while (getmore) {
X      switch (keynum) {
X         case LEFT_ARROW:               /* cursor left */
X            --horizontal;
X            break;
X         case RIGHT_ARROW:              /* cursor right */
X            ++horizontal;
X            break;
X         case UP_ARROW:                 /* cursor up */
X            --vertical;
X            break;
X         case DOWN_ARROW:               /* cursor down */
X            ++vertical;
X            break;
X         case LEFT_ARROW_2:             /* Ctrl-cursor left */
X            horizontal -= 5;
X            break;
X         case RIGHT_ARROW_2:             /* Ctrl-cursor right */
X            horizontal += 5;
X            break;
X         case UP_ARROW_2:               /* Ctrl-cursor up */
X            vertical -= 5;
X            break;
X         case DOWN_ARROW_2:             /* Ctrl-cursor down */
X        vertical += 5;
X        break;
X     default:
X        getmore = 0;
X     }
X      if (getmore) {
X     if (getmore == 2)        /* eat last key used */
X        getakey();
X     getmore = 2;
X     keynum = keypressed();     /* next pending key */
X     }
X      }
X   if (horizontal!=0)
X      moveboxf((double)horizontal/dxsize,0.0);
X   if (vertical!=0)
X      moveboxf(0.0,(double)vertical/dysize);
X}
X
X/* displays differences between current image file and new image */
Xstatic FILE *cmp_fp;
Xstatic errcount;
Xint cmp_line(BYTE *pixels, int linelen)
X{
X   extern int rowcount;
X   int row,col;
X   int oldcolor;
X   if((row = rowcount++) == 0) {
X      errcount = 0;
X      cmp_fp = fopen("cmperr",(initbatch)?"a":"w");
X      outln_cleanup = cmp_line_cleanup;
X      }
X   if(pot16bit) { /* 16 bit info, ignore odd numbered rows */
X      if((row & 1) != 0) return(0);
X      row >>= 1;
X      }
X   for(col=0;col<linelen;col++) {
X      oldcolor=getcolor(col,row);
X      if(oldcolor==pixels[col])
X     putcolor(col,row,0);
X      else {
X     if(oldcolor==0)
X        putcolor(col,row,1);
X     ++errcount;
X     if(initbatch == 0)
X        fprintf(cmp_fp,"#%5d col %3d row %3d old %3d new %3d\n",
X           errcount,col,row,oldcolor,pixels[col]);
X     }
X      }
X   return(0);
X}
X
Xstatic void cmp_line_cleanup()
X{
X   char *timestring;
X   time_t ltime;
X   if(initbatch) {
X      time(<ime);
X      timestring = ctime(<ime);
X      timestring[24] = 0; /*clobber newline in time string */
X      fprintf(cmp_fp,"%s compare to %s has %5d errs\n",
X             timestring,readname,errcount);
X      }
X   fclose(cmp_fp);
X}
X
Xint pot_line(BYTE *pixels, int linelen)
X{
X   extern int rowcount;
X   int row,col,saverowcount;
X   if (rowcount == 0)
X      if (pot_startdisk() < 0)
X     return -1;
X   saverowcount = rowcount;
X   row = (rowcount >>= 1);
X   if ((saverowcount & 1) != 0) /* odd line */
X      row += ydots;
X   else             /* even line */
X      if (dotmode != 11) /* display the line too */
X     out_line(pixels,linelen);
X   for (col = 0; col < xdots; ++col)
X      writedisk(col+sxoffs,row+syoffs,*(pixels+col));
X   rowcount = saverowcount + 1;
X   return(0);
X}
X
Xstatic int call_line3d(BYTE *pixels, int linelen)
X{
X   /* this routine exists because line3d might be in an overlay */
X   return(line3d(pixels,linelen));
X}
X
X
Xvoid clear_zoombox()
X{
X   zwidth = 0;
X   drawbox(0);
X   reset_zoom_corners();
X}
X
Xvoid reset_zoom_corners()
X{
X   xxmin = sxmin;
X   xxmax = sxmax;
X   xx3rd = sx3rd;
X   yymax = symax;
X   yymin = symin;
X   yy3rd = sy3rd;
X}
X
Xstatic char far *savezoom;
Xextern int boxcount;
Xextern char boxx[],boxy[];
Xextern char boxvalues[];
X
Xstatic void note_zoom()
X{
X   if (boxcount) { /* save zoombox stuff in far mem before encode (mem reused) */
X      if ((savezoom = farmemalloc((long)(5*boxcount))) == NULL)
X     clear_zoombox(); /* not enuf mem so clear the box */
X      else {
X     reset_zoom_corners(); /* reset these to overall image, not box */
X     far_memcpy(savezoom,boxx,boxcount*2);
X     far_memcpy(savezoom+boxcount*2,boxy,boxcount*2);
X     far_memcpy(savezoom+boxcount*4,boxvalues,boxcount);
X     }
X      }
X}
X
Xstatic void restore_zoom()
X{
X   if (boxcount) { /* restore zoombox arrays */
X      far_memcpy(boxx,savezoom,boxcount*2);
X      far_memcpy(boxy,savezoom+boxcount*2,boxcount*2);
X      far_memcpy(boxvalues,savezoom+boxcount*4,boxcount);
X      farmemfree(savezoom);
X      drawbox(1); /* get the xxmin etc variables recalc'd by redisplaying */
X      }
X}
X
X
X/*
X   Function setup287code is called by main() when a 287
X   or better fpu is detected.
X*/
X#define ORBPTR(x) fractalspecific[x].orbitcalc
Xstatic void setup287code()
X{
X   ORBPTR(MANDELFP)      = ORBPTR(JULIAFP)     = FJuliafpFractal;
X   ORBPTR(BARNSLEYM1FP)   = ORBPTR(BARNSLEYJ1FP) = FBarnsley1FPFractal;
X   ORBPTR(BARNSLEYM2FP)   = ORBPTR(BARNSLEYJ2FP) = FBarnsley2FPFractal;
X   ORBPTR(MANOWARFP)      = ORBPTR(MANOWARJFP)     = FManOWarfpFractal;
X   ORBPTR(MANDELLAMBDAFP) = ORBPTR(LAMBDAFP)     = FLambdaFPFractal;
X}
X
Xint sound_line(pixels, linelen)
XBYTE *pixels;
Xint linelen;
X{
X   extern int rowcount;
X   extern int basehertz;
X   extern int xdots;
X   extern int colors;
X   extern int orbit_delay;
X   int i;
X   for(i=0;i<linelen;i++)
X   {
X      putcolor(i,rowcount,pixels[i]);
X      if(orbit_delay > 0)
X         sleepms(orbit_delay);
X      snd((int)(pixels[i]*3000/colors+basehertz));
X      if(keypressed())
X      {
X        nosnd();
X        return(-1);
X      }
X   }
X   nosnd();
X   rowcount++;
X   return(0);
X}
X
Xint check_key()
X{
X   int key;
X   if((key = keypressed()) != 0) {
X      if(key != 'o' && key != 'O') {
X     fflush(stdout);
X     return(-1);
X      }
X      getakey();
X      if (dotmode != 11)
X     show_orbit = 1 - show_orbit;
X   }
X   return(0);
X}
X
X/* timer function:
X     timer(0,(*fractal)())        fractal engine
X     timer(1,NULL,int width)        decoder
X     timer(2)                encoder
X  */
X#ifndef XFRACT
Xint timer(int timertype,int(*subrtn)(),...)
X#else
Xint timer(va_alist)
Xva_dcl
X#endif
X{
X   va_list arg_marker;    /* variable arg list */
X   char *timestring;
X   time_t ltime;
X   FILE *fp;
X   int out;
X   int i;
X   int do_bench;
X
X#ifndef XFRACT
X   va_start(arg_marker,subrtn);
X#else
X   int timertype;
X   int (*subrtn)();
X   va_start(arg_marker);
X   timertype = va_arg(arg_marker, int);
X   subrtn = ( int (*)()) va_arg(arg_marker, int *);
X#endif
X
X   do_bench = timerflag; /* record time? */
X   if (timertype == 2)     /* encoder, record time only if debug=200 */
X      do_bench = (debugflag == 200);
X   if(do_bench)
X      fp=fopen("bench","a");
X   timer_start = clock_ticks();
X   switch(timertype) {
X      case 0:
X     out = (*subrtn)();
X     break;
X      case 1:
X     i = va_arg(arg_marker,int);
X     out = decoder(i);         /* not indirect, safer with overlays */
X     break;
X      case 2:
X     out = encoder();         /* not indirect, safer with overlays */
X     break;
X      }
X   /* next assumes CLK_TCK is 10^n, n>=2 */
X   timer_interval = (clock_ticks() - timer_start) / (CLK_TCK/100);
X
X   if(do_bench) {
X      time(<ime);
X      timestring = ctime(<ime);
X      timestring[24] = 0; /*clobber newline in time string */
X      switch(timertype) {
X     case 1:
X        fprintf(fp,"decode ");
X        break;
X     case 2:
X        fprintf(fp,"encode ");
X        break;
X     }
X      fprintf(fp,"%s type=%s resolution = %dx%d maxiter=%d",
X      timestring,
X      curfractalspecific->name,
X      xdots,
X      ydots,
X      maxit);
X      fprintf(fp," time= %ld.%02ld secs\n",timer_interval/100,timer_interval%100);
X      if(fp != NULL)
X     fclose(fp);
X      }
X   return(out);
X}
SHAR_EOF
$TOUCH -am 1028230093 fractint.c &&
chmod 0644 fractint.c ||
echo "restore of fractint.c failed"
set `wc -c fractint.c`;Wc_c=$1
if test "$Wc_c" != "54603"; then
    echo original size 54603, current size $Wc_c
fi
# ============= gifview.c ==============
echo "x - extracting gifview.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > gifview.c &&
X/*
X *
X * This GIF decoder is designed for use with the FRACTINT program.
X * This decoder code lacks full generality in the following respects:
X * supports non-interlaced GIF files only, and calmly ignores any
X * local color maps and non-Fractint-specific extension blocks.
X *
X * GIF and 'Graphics Interchange Format' are trademarks (tm) of
X * Compuserve, Incorporated, an H&R Block Company.
X *
X *                                            Tim Wegner
X */
X
X#include <stdio.h>
X#include <string.h>
X#ifndef XFRACT
X#include <dos.h>
X#endif
X#include "fractint.h"
X#include "prototyp.h"
X
Xstatic void close_file(void);
X
X#define MAXCOLORS    256
X
Xextern int rowcount;        /* row counter for screen */
Xextern char readname[];     /* file name          */
Xstatic FILE *fpin = NULL;    /* FILE pointer       */
Xunsigned int height;
Xextern    char busy;
Xunsigned numcolors;
X
Xextern char MAP_name[];
Xextern int mapset;
Xextern int colorstate;        /* comments in cmdfiles */
X
Xextern int colors;
Xextern int glassestype;
Xextern int display3d;
Xextern int dotmode;        /* so we can detect disk-video */
Xextern int calc_status;
Xextern long calctime;
Xextern long timer_interval;
Xextern int pot16bit;        /* 16 bit values for continuous potential */
Xextern int dither_flag;
X
Xextern int (*outln)();
Xstatic int out_line_dither(BYTE *, int);
Xstatic int out_line_migs(BYTE *, int);
X
Xint bad_code_count = 0;     /* needed by decoder module */
X
Xextern short skipxdots; /* 0 to get every dot, 1 for every 2nd, 2 every 3rd, ... */
Xextern short skipydots; /* ditto for rows */
Xunsigned int far gifview_image_top;    /* (for migs) */
Xunsigned int far gifview_image_left;    /* (for migs) */
Xunsigned int far gifview_image_twidth;    /* (for migs) */
X
Xint get_byte()
X{
X   return (getc(fpin)); /* EOF is -1, as desired */
X}
X
Xint get_bytes(BYTE *where,int how_many)
X{
X   return (fread((char *)where,1,how_many,fpin)); /* EOF is -1, as desired */
X}
X
Xextern BYTE dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
X#ifndef XFRACT
Xextern BYTE decoderline[MAXPIXELS+1]; /* write-line routines use this */
X#else
XBYTE decoderline[MAXPIXELS+1]; /* write-line routines use this */
X#endif
X
Xstatic int ditherlen = -1;
Xstatic char far *ditherbuf = NULL;
X
X/* Main entry decoder */
X
Xvoid decoder_overlay() { }    /* for restore_active_ovly */
X
Xint gifview1()
X{
X   BYTE buffer[16];
X   unsigned top, left, width, finished;
X   char temp1[81];
X
X   int status;
X   int i, j, k, planes;
X
X   ENTER_OVLY(OVLY_DECODER);
X
X   status = 0;
X
X   /* initialize the row count for write-lines */
X   rowcount = 0;
X
X   /* zero out the full write-line */
X   for (width = 0; width < MAXPIXELS+1; width++) decoderline[width] = 0;
X
X   /* Open the file */
X   strcpy(temp1,readname);
X   if (strchr(temp1,'.') == NULL) {
X      strcat(temp1,DEFAULTFRACTALTYPE);
X      if ((fpin = fopen(temp1,"rb")) != NULL) {
X     fclose(fpin);
X     }
X      else {
X     strcpy(temp1,readname);
X     strcat(temp1,ALTERNATEFRACTALTYPE);
X     }
X      }
X   if ((fpin = fopen(temp1, "rb")) == NULL) {
X      EXIT_OVLY;
X      return (-1);
X      }
X
X   /* Get the screen description */
X   for (i = 0; i < 13; i++)
X   {
X      int tmp;
X
X      buffer[i] = tmp = get_byte();
X      if (tmp < 0)
X      {
X     close_file();
X         EXIT_OVLY;
X     return(-1);
X      }
X   }
X
X   if(strncmp(buffer,"GIF87a",3) ||             /* use updated GIF specs */
X      buffer[3] < '0' || buffer[3] > '9' ||
X      buffer[4] < '0' || buffer[4] > '9' ||
X      buffer[5] < 'A' || buffer[5] > 'z' )
X   {
X      close_file();
X      EXIT_OVLY;
X      return(-1);
X   }
X
X   width  = buffer[6] | (buffer[7] << 8);
X   height = buffer[8] | (buffer[9] << 8);
X   planes = (buffer[10] & 0x0F) + 1;
X   gifview_image_twidth = width;
X
X   if((buffer[10] & 0x80)==0)     /* color map (better be!) */
X   {
X      close_file();
X      EXIT_OVLY;
X      return(-1);
X   }
X   numcolors = 1 << planes;
X
X   if (dither_flag && numcolors>2 && colors==2 && outln==out_line) {
X     outln = out_line_dither;
X   }
X
X
X   for (i = 0; i < numcolors; i++)
X   {
X      for (j = 0; j < 3; j++) {
X     if ((k = get_byte()) < 0)
X     {
X        close_file();
X            EXIT_OVLY;
X        return(-1);
X     }
X     if(!display3d || (glassestype != 1 && glassestype != 2))
X        dacbox[i][j] = k >> 2;
X      }
X   }
X   colorstate = 1; /* colors aren't default and not a known .map file */
X
X   /* don't read if glasses */
X   if (display3d && mapset && glassestype!=1 && glassestype != 2)
X   {
X       ValidateLuts(MAP_name);    /* read the palette file */
X       spindac(0,1); /* load it, but don't spin */
X   }
X   if (dacbox[0][0] != 255)
X      spindac(0,1);      /* update the DAC */
X
X   if (dotmode == 11) /* disk-video */
X       dvid_status(1,"...restoring...");
X
X   /* Now display one or more GIF objects */
X   finished = 0;
X   while (!finished)
X   {
X      switch (get_byte())
X      {
X      case ';':
X     /* End of the GIF dataset */
X
X     finished = 1;
X     status = 0;
X     break;
X
X      case '!':                               /* GIF Extension Block */
X     get_byte();             /* read (and ignore) the ID */
X     while ((i = get_byte()) > 0)     /* get the data length */
X        for (j = 0; j < i; j++)
X           get_byte();     /* flush the data */
X     break;
X      case ',':
X     /*
X      * Start of an image object. Read the image description.
X      */
X
X     for (i = 0; i < 9; i++)
X     {
X            int tmp;
X
X            buffer[i] = tmp = get_byte();
X        if (tmp < 0)
X        {
X           status = -1;
X           break;
X        }
X     }
X     if(status < 0)
X     {
X        finished = 1;
X        break;
X     }
X
X     left    = buffer[0] | (buffer[1] << 8);
X     top    = buffer[2] | (buffer[3] << 8);
X     width    = buffer[4] | (buffer[5] << 8);
X     if (pot16bit) width >>= 1;
X     height = buffer[6] | (buffer[7] << 8);
X
X         /* adjustments for handling MIGs */
X         gifview_image_top  = top;
X         if (skipxdots > 0)
X             gifview_image_top /= (skipydots+1);
X         gifview_image_left = left;
X         if (skipydots > 0)
X             gifview_image_left /= (skipxdots+1);
X         if (outln==out_line &&
X             (width != gifview_image_twidth || top != 0)) {
X              /* we're using normal decoding and we have a MIG */
X         outln = out_line_migs;
X             }
X
X         /* Skip local color palette */
X         if((buffer[8] & 0x80)==0x80) {      /* local map? */
X             int numcolors;    /* make this local */
X             planes = (buffer[8] & 0x0F) + 1;
X             numcolors = 1 << planes;
X             /* skip local map */
X             for (i = 0; i < numcolors; i++) {
X                for (j = 0; j < 3; j++) {
X                   if ((k = get_byte()) < 0) {
X                      close_file();
X                      return(-1);
X                      }
X                   }
X                }
X             }
X
X         /* initialize the row count for write-lines */
X         rowcount = 0;
X
X         /* zero out the full write-line */
X         {
X         int i;
X         for (i = 0; i < MAXPIXELS+1; i++) decoderline[i] = 0;
X         }
X
X     if (calc_status == 1) /* should never be so, but make sure */
X        calc_status = 0;
X     busy = 1;    /* for slideshow CALCWAIT */
X     status = timer(1,NULL,width); /* call decoder(width) via timer */
X     busy = 0;    /* for slideshow CALCWAIT */
X     if (calc_status == 1) /* e.g., set by line3d */
X     {
X        calctime = timer_interval; /* note how long it took */
X        if (keypressed() != 0) {
X           calc_status = 3; /* interrupted, not resumable */
X               finished = 1;
X           }
X        else
X           calc_status = 4; /* complete */
X     }
X         /* Hey! the decoder doesn't read the last (0-length) block!! */
X         if (get_byte() != 0) {
X             status = -1;
X             finished = 1;
X             }
X     break;
X      default:
X     status = -1;
X     finished = 1;
X     break;
X      }
X   }
X   close_file();
X   if (dotmode == 11) { /* disk-video */
X      dvid_status(0,"Restore completed");
X      dvid_status(1,"");
X      }
X
X    if (ditherbuf != NULL) { /* we're done, free dither memory */
X        farmemfree(ditherbuf);
X        ditherbuf = NULL;
X    }
X
X   EXIT_OVLY;
X   return(status);
X}
X
Xstatic void close_file()
X{
X   fclose(fpin);
X   fpin = NULL;
X}
X
X/* routine for MIGS that generates partial output lines */
X
Xstatic out_line_migs(BYTE *pixels, int linelen)
X{
Xint row, startcol, stopcol;
X
Xrow = gifview_image_top + rowcount;
Xstartcol = gifview_image_left;
Xstopcol = startcol+linelen-1;
Xput_line(row, startcol, stopcol, pixels);
Xrowcount++;
X
X}
X
X
Xstatic int out_line_dither(pixels, linelen)
XBYTE *pixels;
Xint linelen;
X{
X    int i,nexterr,brt,err;
X    if(ditherbuf == NULL)
X        ditherbuf = (char far *)farmemalloc(linelen+1);
X    far_memset( ditherbuf, 0, linelen+1);
X
X    nexterr = (rand15()&0x1f)-16;
X    for (i=0;i<linelen;i++) {
X    brt = (dacbox[pixels[i]][0]*5+dacbox[pixels[i]][1]*9 +
X        dacbox[pixels[i]][2]*2)>>4; /* brightness from 0 to 63 */
X    brt += nexterr;
X    if (brt>32) {
X        pixels[i] = 1;
X        err = brt-63;
X    } else {
X        pixels[i] = 0;
X        err = brt;
X    }
X    nexterr = ditherbuf[i+1]+err/3;
X    ditherbuf[i] = err/3;
X    ditherbuf[i+1] = err/3;
X    }
X    return out_line(pixels, linelen);
X}
SHAR_EOF
$TOUCH -am 1028230093 gifview.c &&
chmod 0644 gifview.c ||
echo "restore of gifview.c failed"
set `wc -c gifview.c`;Wc_c=$1
if test "$Wc_c" != "8871"; then
    echo original size 8871, current size $Wc_c
fi
# ============= hc.c ==============
echo "x - extracting hc.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > hc.c &&
X
X/*
X * hc.c
X *
X * Stand-alone FRACTINT help compiler.  Compile in the COMPACT memory model.
X *
X * See HC.DOC for source file syntax.
X *
X *
X * Revision History:
X *
X *   02-26-91 EAN     Initial version.
X *
X *   03-21-91 EAN     Modified for automatic paragraph formatting.
X *              Added several new commands:
X *             Format[+/-]  Enable/disable paragraph formatting
X *             Doc[+/-]     Enable/disable output to document.
X *             Online[+/-]  Enable/disable output to online help.
X *             Label=       Defines a label. Replaces ~(...)
X *             FF          Forces a form-feed.  Replaces ~~
X *             FormatExclude=val Exclude lines past val from
X *                      formatting.  If before any topic sets
X *                      global default, otherwise set local.
X *             FormatExclude= Set to global default.
X *             FormatExclude=n Disable exclusion. (global or local)
X *             FormatExclude[+/-] Enable/disable format exclusion.
X *             Center[+/-]  Enable/disable centering of text.
X *             \ before nl  Forces the end of a paragraph
X *              Support for commands embedded in text with new
X *              ~(...) format.
X *              Support for multiple commands on a line separated by
X *              commas.
X *              Support for implict links; explicit links must now
X *              start with an equal sign.
X *   04-03-91 EAN     Added "include" command (works like #include)
X *   04-10-91 EAN     Added support for "data" topics.
X *              Added Comment/EndComment commands for multi-line
X *             comments.
X *              Added CompressSpaces[+/-] command.
X *              Added DocContents command for document printing.
X *              Added BinInc command which includes a binary file
X *             in a data topic.
X *              Fixed tables to flow down instead of across the page.
X *             Makes no allowances for page breaks within tables.
X *
X */
X
X
X#define HC_C
X
X#define INCLUDE_COMMON  /* tell helpcom.h to include common code */
X
X
X#include <stdio.h>
X#ifndef XFRACT
X#include <io.h>
X#include <stdarg.h>
X#else
X#include <varargs.h>
X#define strupr strlwr
X#endif
X#include <fcntl.h>
X#include <stdlib.h>
X#include <string.h>
X#include <ctype.h>
X
X#ifdef __TURBOC__
X#   include <dir.h>
X#   define FNSPLIT fnsplit
X#else
X#   define MAXFILE _MAX_FNAME
X#   define MAXEXT  _MAX_EXT
X#   define FNSPLIT _splitpath
X#endif
X
X
X#include <assert.h>
X#include "helpcom.h"
X
X
X/*
X * When defined, SHOW_ERROR_LINE will cause the line number in HC.C where
X * errors/warnings/messages are generated to be displayed at the start of
X * the line.
X *
X * Used when debugging HC.  Also useful for finding the line (in HC.C) that
X * generated a error or warning.
X */
X
X#ifndef XFRACT
X#define SHOW_ERROR_LINE
X#endif
X
X
X#define DEFAULT_SRC_FNAME "help.src"
X#define DEFAULT_HLP_FNAME "fractint.hlp"
X#define DEFAULT_EXE_FNAME "fractint.exe"
X#define DEFAULT_DOC_FNAME "fractint.doc"
X
X#define TEMP_FNAME      "HC.$$$"
X#define SWAP_FNAME      "HCSWAP.$$$"
X
X#define MAX_ERRORS      (25)     /* stop after this many errors */
X#define MAX_WARNINGS      (25)     /* stop after this many warnings */
X                 /* 0 = never stop */
X
X#define INDEX_LABEL      "HELP_INDEX"
X#define DOCCONTENTS_TITLE "DocContent"
X
X
X
X#define BUFFER_SIZE   (24*1024)
X
X
Xtypedef struct
X   {
X   int        type;         /* 0 = name is topic title, 1 = name is label, */
X                 /*   2 = "special topic"; name is NULL and */
X                 /*   topic_num/topic_off is valid */
X   int        topic_num;         /* topic number to link to */
X   unsigned topic_off;         /* offset into topic to link to */
X   int        doc_page;         /* document page # to link to */
X   char    *name;         /* name of label or title of topic to link to */
X   char    *srcfile;         /* .SRC file link appears in */
X   int        srcline;         /* .SRC file line # link appears in */
X   } LINK;
X
X
Xtypedef struct
X   {
X   unsigned offset;     /* offset from start of topic text */
X   unsigned length;     /* length of page (in chars) */
X   int        margin;     /* if > 0 then page starts in_para and text */
X                /* should be indented by this much */
X   } PAGE;
X
X
X/* values for TOPIC.flags */
X
X#define TF_IN_DOC  (1)         /* 1 if topic is part of the printed document */
X#define TF_DATA    (2)         /* 1 if it is a "data" topic */
X
X
Xtypedef struct
X   {
X   unsigned  flags;         /* see #defines for TF_??? */
X   int         doc_page;         /* page number in document where topic starts */
X   unsigned  title_len;      /* length of title */
X   char     *title;         /* title for this topic */
X   int         num_page;         /* number of pages */
X   PAGE     *page;         /* list of pages */
X   unsigned  text_len;         /* lenth of topic text */
X   long      text;         /* topic text (all pages) */
X   long      offset;         /* offset to topic from start of file */
X   } TOPIC;
X
X
Xtypedef struct
X   {
X   char    *name;         /* its name */
X   int        topic_num;         /* topic number */
X   unsigned topic_off;         /* offset of label in the topic's text */
X   int        doc_page;
X   } LABEL;
X
X
X/* values for CONTENT.flags */
X
X#define CF_NEW_PAGE  (1)     /* true if section starts on a new page */
X
X
X#define MAX_CONTENT_TOPIC (10)
X
X
Xtypedef struct
X   {
X   unsigned  flags;
X   char     *id;
X   char     *name;
X   int         doc_page;
X   unsigned  page_num_pos;
X   int         num_topic;
X   char      is_label[MAX_CONTENT_TOPIC];
X   char     *topic_name[MAX_CONTENT_TOPIC];
X   int         topic_num[MAX_CONTENT_TOPIC];
X   char     *srcfile;
X   int         srcline;
X   } CONTENT;
X
X
Xstruct help_sig_info
X   {
X   unsigned long sig;
X   int         version;
X   unsigned long base;
X   } ;
X
X
Xint     num_topic      = 0;      /* topics */
XTOPIC   *topic;
X
Xint     num_label      = 0;      /* labels */
XLABEL   *label;
X
Xint     num_plabel      = 0;      /* private labels */
XLABEL   *plabel;
X
Xint     num_link      = 0;      /* all links */
XLINK    *a_link          = 0;
X
Xint     num_contents      = 0;      /* the table-of-contents */
XCONTENT *contents;
X
Xint     quiet_mode      = 0;      /* true if "/Q" option used */
X
Xint     max_pages      = 0;      /* max. pages in any topic */
Xint     max_links      = 0;      /* max. links on any page */
Xint     num_doc_pages      = 0;      /* total number of pages in document */
X
XFILE    *srcfile;          /* .SRC file */
Xint     srcline      = 0;      /* .SRC line number (used for errors) */
Xint     srccol       = 0;      /* .SRC column. */
X
Xint     version      = -1;   /* help file version */
X
Xint     errors       = 0,      /* number of errors reported */
X     warnings      = 0;      /* number of warnings reported */
X
Xchar     src_fname[81]      = "";   /* command-line .SRC filename */
Xchar     hdr_fname[81]      = "";   /* .H filename */
Xchar     hlp_fname[81]      = "";   /* .HLP filename */
Xchar    *src_cfname      = NULL; /* current .SRC filename */
X
Xint     format_exclude   = 0;      /* disable formatting at this col, 0 to */
X                  /*    never disable formatting */
XFILE    *swapfile;
Xlong     swappos;
X
Xchar    *buffer;          /* alloc'ed as BUFFER_SIZE bytes */
Xchar    *curr;              /* current position in the buffer */
Xchar     cmd[128];          /* holds the current command */
Xint     compress_spaces;
Xint     xonline;
Xint     xdoc;
X
X#define  MAX_INCLUDE_STACK (5)      /* allow 5 nested includes */
X
Xstruct
X   {
X   char *fname;
X   FILE *file;
X   int     line;
X   int     col;
X   } include_stack[MAX_INCLUDE_STACK];
Xint include_stack_top = -1;
X
X
X#define CHK_BUFFER(off) { if ((unsigned)(curr+(off)) - (unsigned)buffer >= (BUFFER_SIZE-1024)) fatal(0,"Buffer overflowed -- Help topic too large."); }
X
X#ifdef __WATCOMC__
X#define putw( x1, x2 )  fprintf( x2, "%c%c", x1&0xFF, x1>>8 );
X#endif
X
X#ifdef XFRACT
X#define putw( x1, x2 )  fwrite( &(x1), 1, sizeof(int), x2);
X#endif
X
X/*
X * error/warning/message reporting functions.
X */
X
X
Xvoid report_errors(void)
X   {
X   printf("\n");
X   printf("Compiler Status:\n");
X   printf("%8d Error%c\n",     errors,   (errors==1)     ? ' ' : 's');
X   printf("%8d Warning%c\n",     warnings, (warnings==1) ? ' ' : 's');
X   }
X
X
Xvoid print_msg(char *type, int lnum, char *format, va_list arg)
X   {
X   if (type != NULL)
X      {
X      printf("   %s", type);
X      if (lnum>0)
X     printf(" %s %d", src_cfname, lnum);
X      printf(": ");
X      }
X   vprintf(format, arg);
X   printf("\n");
X   }
X
X
X#ifndef XFRACT
Xvoid fatal(int diff, char *format, ...)
X#else
Xvoid fatal(va_alist)
X    va_dcl
X#endif
X   {
X   va_list arg;
X
X#ifndef XFRACT
X   va_start(arg, format);
X#else
X   int diff;
X   char *format;
X   va_start(arg);
X   diff = va_arg(arg,int);
X   format = va_arg(arg,char *);
X#endif
X
X   print_msg("Fatal", srcline-diff, format, arg);
X   va_end(arg);
X
X   if ( errors || warnings )
X      report_errors();
X
X   exit( errors + 1 );
X   }
X
X
X#ifndef XFRACT
Xvoid error(int diff, char *format, ...)
X#else
Xvoid error(va_alist)
X    va_dcl
X#endif
X   {
X   va_list arg;
X
X#ifndef XFRACT
X   va_start(arg, format);
X#else
X   int diff;
X   char *format;
X   va_start(arg);
X   diff = va_arg(arg,int);
X   format = va_arg(arg,char *);
X#endif
X   print_msg("Error", srcline-diff, format, arg);
X   va_end(arg);
X
X   if (++errors >= MAX_ERRORS && MAX_ERRORS > 0)
X      fatal(0,"Too many errors!");
X   }
X
X
X#ifndef XFRACT
Xvoid warn(int diff, char *format, ...)
X#else
Xvoid warn(va_alist)
X   va_dcl
X#endif
X   {
X   va_list arg;
X#ifndef XFRACT
X   va_start(arg, format);
X#else
X   int diff;
X   char *format;
X   va_start(arg);
X   diff = va_arg(arg, int);
X   format = va_arg(arg, char *);
X#endif
X   print_msg("Warning", srcline-diff, format, arg);
X   va_end(arg);
X
X   if (++warnings >= MAX_WARNINGS && MAX_WARNINGS > 0)
X      fatal(0,"Too many warnings!");
X   }
X
X
X#ifndef XFRACT
Xvoid notice(char *format, ...)
X#else
Xvoid notice(va_alist)
X    va_dcl
X#endif
X   {
X   va_list arg;
X#ifndef XFRACT
X   va_start(arg, format);
X#else
X   char *format;
X
X   va_start(arg);
X   format = va_arg(arg,char *);
X#endif
X   print_msg("Note", srcline, format, arg);
X   va_end(arg);
X   }
X
X
X#ifndef XFRACT
Xvoid msg(char *format, ...)
X#else
Xvoid msg(va_alist)
Xva_dcl
X#endif
X   {
X   va_list arg;
X#ifdef XFRACT
X   char *format;
X#endif
X
X   if (quiet_mode)
X      return;
X#ifndef XFRACT
X   va_start(arg, format);
X#else
X   va_start(arg);
X   format = va_arg(arg,char *);
X#endif
X   print_msg(NULL, 0, format, arg);
X   va_end(arg);
X   }
X
X
X#ifdef SHOW_ERROR_LINE
X#   define fatal  (printf("[%04d] ", __LINE__), fatal)
X#   define error  (printf("[%04d] ", __LINE__), error)
X#   define warn   (printf("[%04d] ", __LINE__), warn)
X#   define notice (printf("[%04d] ", __LINE__), notice)
X#   define msg      (printf((quiet_mode)?"":"[%04d] ", __LINE__), msg)
X#endif
X
X
X/*
X * store-topic-text-to-disk stuff.
X */
X
X
Xvoid alloc_topic_text(TOPIC *t, unsigned size)
X   {
X   t->text_len = size;
X   t->text = swappos;
X   swappos += size;
X   fseek(swapfile, t->text, SEEK_SET);
X   fwrite(buffer, 1, t->text_len, swapfile);
X   }
X
X
Xchar *get_topic_text(TOPIC *t)
X   {
X   fseek(swapfile, t->text, SEEK_SET);
X   fread(buffer, 1, t->text_len, swapfile);
X   return (buffer);
X   }
X
X
Xvoid release_topic_text(TOPIC *t, int save)
X   {
X   if ( save )
X      {
X      fseek(swapfile, t->text, SEEK_SET);
X      fwrite(buffer, 1, t->text_len, swapfile);
X      }
X   }
X
X
X/*
X * memory-allocation functions.
X */
X
X
X#define new(item)    (item *)newx(sizeof(item))
X#define delete(item) free(item)
X
X
XVOIDPTR newx(unsigned size)
X   {
X   VOIDPTR ptr;
X
X   ptr = malloc(size);
X
X   if (ptr == NULL)
X      fatal(0,"Out of memory!");
X
X   return (ptr);
X   }
X
X
XVOIDPTR renewx(VOIDPTR ptr, unsigned size)
X   {
X   ptr = realloc(ptr, size);
X
X   if (ptr == NULL)
X      fatal(0,"Out of memory!");
X
X   return (ptr);
X   }
X
X
Xchar *dupstr(char *s, unsigned len)
X   {
X   char *ptr;
X
X   if (len == 0)
X      len = strlen(s) + 1;
X
X   ptr = newx(len);
X
X   memcpy(ptr, s, len);
X
X   return (ptr);
X   }
X
X
X#define LINK_ALLOC_SIZE (16)
X
X
Xint add_link(LINK *l)
X   {
X   if (num_link == 0)
X      a_link = newx( sizeof(LINK)*LINK_ALLOC_SIZE );
X
X   else if (num_link%LINK_ALLOC_SIZE == 0)
X      a_link = renewx(a_link, sizeof(LINK) * (num_link+LINK_ALLOC_SIZE) );
X
X   a_link[num_link] = *l;
X
X   return( num_link++ );
X   }
X
X
X#define PAGE_ALLOC_SIZE (4)
X
X
Xint add_page(TOPIC *t, PAGE *p)
X   {
X   if (t->num_page == 0)
X      t->page = newx( sizeof(PAGE)*PAGE_ALLOC_SIZE );
X
X   else if (t->num_page%PAGE_ALLOC_SIZE == 0)
X      t->page = renewx(t->page, sizeof(PAGE) * (t->num_page+PAGE_ALLOC_SIZE) );
X
X   t->page[t->num_page] = *p;
X
X   return ( t->num_page++ );
X   }
X
X
X#define TOPIC_ALLOC_SIZE (16)
X
X
Xint add_topic(TOPIC *t)
X   {
X   if (num_topic == 0)
X      topic = newx( sizeof(TOPIC)*TOPIC_ALLOC_SIZE );
X
X   else if (num_topic%TOPIC_ALLOC_SIZE == 0)
X      topic = renewx(topic, sizeof(TOPIC) * (num_topic+TOPIC_ALLOC_SIZE) );
X
X   topic[num_topic] = *t;
X
X   return ( num_topic++ );
X   }
X
X
X#define LABEL_ALLOC_SIZE (16)
X
X
Xint add_label(LABEL *l)
X   {
X   if (l->name[0] == '@')    /* if it's a private label... */
X      {
X      if (num_plabel == 0)
X     plabel = newx( sizeof(LABEL)*LABEL_ALLOC_SIZE );
X
X      else if (num_plabel%LABEL_ALLOC_SIZE == 0)
X     plabel = renewx(plabel, sizeof(LABEL) * (num_plabel+LABEL_ALLOC_SIZE) );
X
X      plabel[num_plabel] = *l;
X
X      return ( num_plabel++ );
X      }
X   else
X      {
X      if (num_label == 0)
X     label = newx( sizeof(LABEL)*LABEL_ALLOC_SIZE );
X
X      else if (num_label%LABEL_ALLOC_SIZE == 0)
X     label = renewx(label, sizeof(LABEL) * (num_label+LABEL_ALLOC_SIZE) );
X
X      label[num_label] = *l;
X
X      return ( num_label++ );
X      }
X   }
X
X
X#define CONTENTS_ALLOC_SIZE (16)
X
X
Xint add_content(CONTENT *c)
X   {
X   if (num_contents == 0)
X      contents = newx( sizeof(CONTENT)*CONTENTS_ALLOC_SIZE );
X
X   else if (num_contents%CONTENTS_ALLOC_SIZE == 0)
X      contents = renewx(contents, sizeof(CONTENT) * (num_contents+CONTENTS_ALLOC_SIZE) );
X
X   contents[num_contents] = *c;
X
X   return ( num_contents++ );
X   }
X
X
X/*
X * read_char() stuff
X */
X
X
X#define READ_CHAR_BUFF_SIZE (32)
X
X
Xint  read_char_buff[READ_CHAR_BUFF_SIZE];
Xint  read_char_buff_pos = -1;
Xint  read_char_sp       = 0;
X
X
Xvoid unread_char(int ch)
X   /*
X    * Will not handle new-lines or tabs correctly!
X    */
X   {
X   if (read_char_buff_pos+1 >= READ_CHAR_BUFF_SIZE)
X      fatal(0,"Compiler Error -- Read char buffer overflow!");
X
X   read_char_buff[++read_char_buff_pos] = ch;
X
X   --srccol;
X   }
X
X
Xvoid unread_string(char *s)
X   {
X   int p = strlen(s);
X
X   while (p-- > 0)
X      unread_char(s[p]);
X   }
X
X
Xint eos(void)     /* end-of-source ? */
X   {
X   return ( !((read_char_sp==0) && (read_char_buff_pos==0) && feof(srcfile)) );
X   }
X
X
Xint _read_char(void)
X   {
X   int ch;
X
X   if (srcline <= 0)
X      {
X      srcline = 1;
X      srccol = 0;
X      }
X
X   if (read_char_buff_pos >= 0)
X      {
X      ++srccol;
X      return ( read_char_buff[read_char_buff_pos--] );
X      }
X
X   if (read_char_sp > 0)
X      {
X      --read_char_sp;
X      return (' ');
X      }
X
X   if ( feof(srcfile) )
X      return (-1);
X
X   while (1)
X      {
X      ch = getc(srcfile);
X
X      switch (ch)
X     {
X     case '\t':    /* expand a tab */
X        {
X        int diff = ( ( (srccol/8) + 1 ) * 8 ) - srccol;
X
X        srccol += diff;
X        read_char_sp += diff;
X        break;
X        }
X
X     case ' ':
X        ++srccol;
X        ++read_char_sp;
X        break;
X
X     case '\n':
X        read_char_sp = 0;   /* delete spaces before a \n */
X        srccol = 0;
X        ++srcline;
X        return ('\n');
X
X     case -1:            /* EOF */
X        if (read_char_sp > 0)
X           {
X           --read_char_sp;
X           return (' ');
X           }
X        return (-1);
X
X     default:
X        if (read_char_sp > 0)
X           {
X           ungetc(ch, srcfile);
X           --read_char_sp;
X           return (' ');
X           }
X
X        ++srccol;
X        return (ch);
X
X     } /* switch */
X      }
X   }
X
X
Xint read_char(void)
X   {
X   int ch;
X
X   ch = _read_char();
X
X   while (ch == ';' && srccol==1)    /* skip over comments */
X      {
X      ch = _read_char();
X
X      while (ch!='\n' && ch!=-1 )
X     ch = _read_char();
X
X      ch = _read_char();
X      }
X
X   if (ch == '\\')   /* process an escape code */
X      {
X      ch = _read_char();
X
X      if (ch >= '0' && ch <= '9')
X     {
X     char buff[4];
X     int  ctr;
X
X     for (ctr=0; ; ctr++)
X        {
X        if ( ch<'0' || ch>'9' || ch==-1 || ctr>=3 )
X           {
X           unread_char(ch);
X           break;
X           }
X        buff[ctr] = ch;
X        ch = _read_char();
X        }
X     buff[ctr] = '\0';
X     ch = atoi(buff);
X     }
X
X#ifdef XFRACT
X   /* Convert graphics arrows into keyboard chars */
X       if (ch>=24 && ch<=27) {
X       ch = "KJHL"[ch-24];
X       }
X#endif
X      ch |= 0x100;
X      }
X
X   if ( (ch & 0xFF) == 0 )
X      {
X      error(0,"Null character (\'\\0\') not allowed!");
X      ch = 0x1FF; /* since we've had an error the file will not be written; */
X          /*   the value we return doesn't really matter */
X      }
X
X   return(ch);
X   }
X
X
X/*
X * misc. search functions.
X */
X
X
XLABEL *find_label(char *name)
X   {
X   int      l;
X   LABEL *lp;
X
X   if (*name == '@')
X      {
X      for (l=0, lp=plabel; l<num_plabel; l++, lp++)
X     if ( strcmp(name, lp->name) == 0 )
X        return (lp);
X      }
X   else
X      {
X      for (l=0, lp=label; l<num_label; l++, lp++)
X     if ( strcmp(name, lp->name) == 0 )
X        return (lp);
X      }
X
X   return (NULL);
X   }
X
X
Xint find_topic_title(char *title)
X   {
X   int t;
X   int len;
X
X   while (*title == ' ')
X      ++title;
X
X   len = strlen(title) - 1;
X   while ( title[len] == ' ' && len > 0 )
X      --len;
X
X   ++len;
X
X   if ( len > 2 && title[0] == '\"' && title[len-1] == '\"' )
X      {
X      ++title;
X      len -= 2;
X      }
X
X   for (t=0; t<num_topic; t++)
X      if ( strlen(topic[t].title) == len &&
X       strnicmp(title, topic[t].title, len) == 0 )
X     return (t);
X
X   return (-1);   /* not found */
X   }
X
X
X/*
X * .SRC file parser stuff
X */
X
X
Xint validate_label_name(char *name)
X   {
X   if ( !isalpha(*name) && *name!='@' && *name!='_' )
X      return (0);  /* invalid */
X
X   while (*(++name) != '\0')
X      if ( !isalpha(*name) && !isdigit(*name) && *name!='_' )
X     return(0);  /* invalid */
X
X   return (1);  /* valid */
X   }
X
X
Xchar *read_until(char *buff, int len, char *stop_chars)
X   {
X   int ch;
X
X   while ( --len > 0 )
X      {
X      ch = read_char();
X
X      if ( ch == -1 )
X     {
X     *buff++ = '\0';
X     break;
X     }
X
X      if ( (ch&0xFF) <= MAX_CMD )
X     *buff++ = CMD_LITERAL;
X
X      *buff++ = ch;
X
X      if ( (ch&0x100)==0 && strchr(stop_chars, ch) != NULL )
X     break;
X      }
X
X   return ( buff-1 );
X   }
X
X
Xvoid skip_over(char *skip)
X   {
X   int ch;
X
X   while (1)
X      {
X      ch = read_char();
X
X      if ( ch == -1 )
X     break;
X
X      else if ( (ch&0x100) == 0 && strchr(skip, ch) == NULL )
X     {
X     unread_char(ch);
X     break;
X     }
X      }
X   }
X
X
Xchar *pchar(int ch)
X   {
X   static char buff[16];
X
X   if ( ch >= 0x20 && ch <= 0x7E )
X      sprintf(buff, "\'%c\'", ch);
X   else
X      sprintf(buff, "\'\\x%02X\'", ch&0xFF);
X
X   return (buff);
X   }
X
X
Xvoid put_spaces(int how_many)
X   {
X   if (how_many > 2 && compress_spaces)
X      {
X      if (how_many > 255)
X     {
X     error(0,"Too many spaces (over 255).");
X     how_many = 255;
X     }
X
X      *curr++ = CMD_SPACE;
X      *curr++ = (BYTE)how_many;
X      }
X   else
X      {
X      while (how_many-- > 0)
X     *curr++ = ' ';
X      }
X   }
X
X
Xint get_next_item(void)   /* used by parse_contents() */
X   {
X   int     last;
X   char *ptr;
X
X   skip_over(" \t\n");
X   ptr = read_until(cmd, 128, ",}");
X   last = (*ptr == '}');
X   --ptr;
X   while ( ptr >= cmd && strchr(" \t\n",*ptr) )   /* strip trailing spaces */
X      --ptr;
X   *(++ptr) = '\0';
X
X   return (last);
X   }
X
X
Xvoid process_contents(void)
X   {
X   CONTENT c;
X   char   *ptr;
X   int       indent;
X   int       ch;
X   TOPIC   t;
X
X   t.flags     = 0;
X   t.title_len = strlen(DOCCONTENTS_TITLE)+1;
X   t.title     = dupstr(DOCCONTENTS_TITLE, t.title_len);
X   t.doc_page  = -1;
X   t.num_page  = 0;
X
X   curr = buffer;
X
X   c.flags = 0;
X   c.id = dupstr("",1);
X   c.name = dupstr("",1);
X   c.doc_page = -1;
X   c.page_num_pos = 0;
X   c.num_topic = 1;
X   c.is_label[0] = 0;
X   c.topic_name[0] = dupstr(DOCCONTENTS_TITLE,0);
X   c.srcline = -1;
X   add_content(&c);
X
X   while (1)
X      {
X      ch = read_char();
X
X      if (ch == '{')   /* process a CONTENT entry */
X     {
X     int last;
X
X     c.flags = 0;
X     c.num_topic = 0;
X     c.doc_page = -1;
X     c.srcfile = src_cfname;
X     c.srcline = srcline;
X
X     if ( get_next_item() )
X        {
X        error(0,"Unexpected end of DocContent entry.");
X        continue;
X        }
X     c.id = dupstr(cmd,0);
X
X     if ( get_next_item() )
X        {
X        error(0,"Unexpected end of DocContent entry.");
X        continue;
X        }
X     indent = atoi(cmd);
X
X     last = get_next_item();
X
X     if ( cmd[0] == '\"' )
X        {
X        ptr = cmd+1;
X        if (ptr[strlen(ptr)-1] == '\"')
X           ptr[strlen(ptr)-1] = '\0';
X        else
X           warn(0,"Missing ending quote.");
X
X        c.is_label[c.num_topic] = 0;
X        c.topic_name[c.num_topic] = dupstr(ptr,0);
X        ++c.num_topic;
X        c.name = dupstr(ptr,0);
X        }
X     else
X        c.name = dupstr(cmd,0);
X
X     /* now, make the entry in the buffer */
X
X     sprintf(curr, "%-5s %*.0s%s", c.id, indent*2, "", c.name);
X     ptr = curr + strlen(curr);
X     while ( (ptr-curr) < PAGE_WIDTH-10 )
X        *ptr++ = '.';
X     c.page_num_pos = (unsigned) ( (ptr-3) - buffer );
X     curr = ptr;
X
X     while (!last)
X        {
X        last = get_next_item();
X
X        if ( stricmp(cmd, "FF") == 0 )
X           {
X           if ( c.flags & CF_NEW_PAGE )
X          warn(0,"FF already present in this entry.");
X           c.flags |= CF_NEW_PAGE;
X           continue;
X           }
X
X        if (cmd[0] == '\"')
X           {
X           ptr = cmd+1;
X           if (ptr[strlen(ptr)-1] == '\"')
X          ptr[strlen(ptr)-1] = '\0';
X           else
X          warn(0,"Missing ending quote.");
X
X           c.is_label[c.num_topic] = 0;
X           c.topic_name[c.num_topic] = dupstr(ptr,0);
X           }
X        else
X           {
X           c.is_label[c.num_topic] = 1;
X           c.topic_name[c.num_topic] = dupstr(cmd,0);
X           }
X
X        if ( ++c.num_topic >= MAX_CONTENT_TOPIC )
X           {
X           error(0,"Too many topics in DocContent entry.");
X           break;
X           }
X        }
X
X     add_content(&c);
X     }
X
X      else if (ch == '~')   /* end at any command */
X     {
X     unread_char(ch);
X     break;
X     }
X
X      else
X     *curr++ = ch;
X
X      CHK_BUFFER(0);
X      }
X
X   alloc_topic_text(&t, (unsigned) (curr - buffer) );
X   add_topic(&t);
X   }
X
X
Xint parse_link(void)   /* returns length of link or 0 on error */
X   {
X   char *ptr;
X   char *end;
X   int     bad = 0;
X   int     len;
X   LINK  l;
X   int     lnum;
X   int     err_off;
X
X   l.srcfile  = src_cfname;
X   l.srcline  = srcline;
X   l.doc_page = -1;
X
X   end = read_until(cmd, 128, "}\n");   /* get the entire hot-link */
X
X   if (*end == '\0')
X      {
X      error(0,"Unexpected EOF in hot-link.");
X      return (0);
X      }
X
X   if (*end == '\n')
X      {
X      err_off = 1;
X      warn(1,"Hot-link has no closing curly-brace (\'}\').");
X      }
X   else
X      err_off = 0;
X
X   *end = '\0';
X
X   if (cmd[0] == '=')   /* it's an "explicit" link to a label or "special" */
X      {
X      ptr = strchr(cmd, ' ');
X
X      if (ptr == NULL)
X     ptr = end;
X      else
X     *ptr++ = '\0';
X
X      len = (int) (end - ptr);
X
X      if ( cmd[1] == '-' )
X     {
X     l.type      = 2;       /* type 2 = "special" */
X     l.topic_num = atoi(cmd+1);
X     l.topic_off = 0;
X     l.name      = NULL;
X     }
X      else
X     {
X     l.type = 1;           /* type 1 = to a label */
X     if (strlen(cmd) > 32)
X        warn(err_off, "Label is long.");
X     if (cmd[1] == '\0')
X        {
X        error(err_off, "Explicit hot-link has no Label.");
X        bad = 1;
X        }
X     else
X        l.name = dupstr(cmd+1,0);
X     }
X      if (len == 0)
X     warn(err_off, "Explicit hot-link has no title.");
X      }
X   else
X      {
X      ptr = cmd;
X      l.type = 0;   /* type 0 = topic title */
X      len = (int) (end - ptr);
X      if (len == 0)
X     {
X     error(err_off, "Implicit hot-link has no title.");
X     bad = 1;
X     }
X      l.name = dupstr(ptr,len+1);
X      l.name[len] = '\0';
X      }
X
X   if ( !bad )
X      {
X      CHK_BUFFER(1+3*sizeof(int)+len+1)
X      lnum = add_link(&l);
X      *curr++ = CMD_LINK;
X      setint(curr,lnum);
X      curr += 3*sizeof(int);
X      memcpy(curr, ptr, len);
X      curr += len;
X      *curr++ = CMD_LINK;
X      return (len);
X      }
X   else
X      return (0);
X   }
X
X
X#define MAX_TABLE_SIZE (100)
X
X
Xint create_table(void)
X   {
X   char  *ptr;
X   int      width;
X   int      cols;
X   int      start_off;
X   int      first_link;
X   int      rows;
X   int      r, c;
X   int      ch;
X   int      done;
X   int      len;
X   int      lnum;
X   int      count;
X   char  *title[MAX_TABLE_SIZE];
X   char  *table_start;
X
X   ptr = strchr(cmd, '=');
X
X   if (ptr == NULL)
X      return (0);   /* should never happen! */
X
X   ptr++;
X
X   len = sscanf(ptr, " %d %d %d", &width, &cols, &start_off);
X
X   if (len < 3)
X      {
X      error(1,"Too few arguments to Table.");
X      return (0);
X      }
X
X   if (width<=0 || width > 78 || cols<=0 || start_off<0 || start_off > 78)
X      {
X      error(1,"Argument out of range.");
X      return (0);
X      }
X
X   done = 0;
X
X   first_link = num_link;
X   table_start = curr;
X   count = 0;
X
X   /* first, read all the links in the table */
X
X   do
X      {
X
X      do
X     ch = read_char();
X      while ( ch=='\n' || ch == ' ' );
X
X      if (done)
X     break;
X
X      switch (ch)
X     {
X     case -1:
X        error(0,"Unexpected EOF in a Table.");
X        return(0);
X
X     case '{':
X        if (count >= MAX_TABLE_SIZE)
X           fatal(0,"Table is too large.");
X        len = parse_link();
X        curr = table_start;   /* reset to the start... */
X            title[count] = dupstr(curr+3*sizeof(int)+1, len+1);
X        if (len >= width)
X           {
X           warn(1,"Link is too long; truncating.");
X           len = width-1;
X           }
X        title[count][len] = '\0';
X        ++count;
X        break;
X
X     case '~':
X        {
X        int imbedded;
X
X        ch = read_char();
X
X        if (ch=='(')
X           imbedded = 1;
X        else
X           {
X           imbedded = 0;
X           unread_char(ch);
X           }
X
X        ptr = read_until(cmd, 128, ")\n,");
X
X        ch = *ptr;
X        *ptr = '\0';
X
X        if  ( stricmp(cmd, "EndTable") == 0 )
X           done = 1;
X        else
X           {
X           error(1,"Unexpected command in table \"%s\"", cmd);
X           warn(1,"Command will be ignored.");
X           }
X
X        if (ch == ',')
X           {
X           if (imbedded)
X          unread_char('(');
X           unread_char('~');
X           }
X        }
X        break;
X
X     default:
X        error(0,"Unexpected character %s.", pchar(ch));
X        break;
X     }
X      }
X   while (!done);
X
X   /* now, put all the links into the buffer... */
X
X   rows = 1 + ( count / cols );
X
X   for (r=0; r<rows; r++)
X      {
X      put_spaces(start_off);
X      for (c=0; c<cols; c++)
X     {
X     lnum = c*rows + r;
X
X     if ( first_link+lnum >= num_link )
X        break;
X
X     len = strlen(title[lnum]);
X     *curr++ = CMD_LINK;
X         setint(curr,first_link+lnum);
X         curr += 3*sizeof(int);
X     memcpy(curr, title[lnum], len);
X     curr += len;
X     *curr++ = CMD_LINK;
X
X     delete(title[lnum]);
X
X     if ( c < cols-1 )
X        put_spaces( width-len );
X     }
X      *curr++ = '\n';
X      }
X
X   return (1);
X   }
X
X
Xvoid process_comment(void)
X   {
X   int ch;
X
X   while ( 1 )
X      {
X      ch = read_char();
X
X      if (ch == '~')
X     {
X     int   imbedded;
X     char *ptr;
X
X     ch = read_char();
X
X     if (ch=='(')
X        imbedded = 1;
X     else
X        {
X        imbedded = 0;
X        unread_char(ch);
X        }
X
X     ptr = read_until(cmd, 128, ")\n,");
X
X     ch = *ptr;
X     *ptr = '\0';
X
X     if  ( stricmp(cmd, "EndComment") == 0 )
X        {
X        if (ch == ',')
X           {
X           if (imbedded)
X          unread_char('(');
X           unread_char('~');
X           }
X        break;
X        }
X     }
X
X      else if ( ch == -1 )
X     {
X     error(0,"Unexpected EOF in Comment");
X     break;
X     }
X      }
X   }
X
X
Xvoid process_bininc(void)
X   {
X   int  handle;
X   long len;
X
X   if ( (handle=open(cmd+7, O_RDONLY|O_BINARY)) == -1 )
X      {
X      error(0,"Unable to open \"%s\"", cmd+7);
X      return ;
X      }
X
X   len = filelength(handle);
X
X   if ( len >= BUFFER_SIZE )
X      {
X      error(0,"File \"%s\" is too large to BinInc (%dK).", cmd+7, (int)(len>>10));
X      close(handle);
X      return ;
X      }
X
X   /*
X    * Since we know len is less than BUFFER_SIZE (and therefore less then
X    * 64K) we can treat it as an unsigned.
X    */
X
X   CHK_BUFFER((unsigned)len);
X
X   read(handle, curr, (unsigned)len);
X
X   curr += (unsigned)len;
X
X   close(handle);
X   }
X
X
Xvoid start_topic(TOPIC *t, char *title, int title_len)
X   {
X   t->flags = 0;
X   t->title_len = title_len;
X   t->title = dupstr(title, title_len+1);
X   t->title[title_len] = '\0';
X   t->doc_page = -1;
X   t->num_page = 0;
X   curr = buffer;
X   }
X
X
Xvoid end_topic(TOPIC *t)
X   {
X   alloc_topic_text(t, (unsigned) (curr - buffer) );
X   add_topic(t);
X   }
X
X
Xint end_of_sentence(char *ptr)  /* true if ptr is at the end of a sentence */
X   {
X   if ( *ptr == ')')
X      --ptr;
X
X   if ( *ptr == '\"')
X      --ptr;
X
X   return ( *ptr=='.' || *ptr=='?' || *ptr=='!' );
X   }
X
X
Xvoid add_blank_for_split(void)     /* add space at curr for merging two lines */
X   {
X   if ( !is_hyphen(curr-1) )   /* no spaces if it's a hyphen */
X      {
X      if ( end_of_sentence(curr-1) )
X     *curr++ = ' ';  /* two spaces at end of a sentence */
X      *curr++ = ' ';
X      }
X   }
X
X
Xvoid put_a_char(int ch, TOPIC *t)
X   {
X   if (ch == '{' && !(t->flags & TF_DATA) )   /* is it a hot-link? */
X      parse_link();
X   else
X      {
X      if ( (ch&0xFF) <= MAX_CMD)
X     *curr++ = CMD_LITERAL;
X      *curr++ = ch;
X      }
X   }
X
X
Xenum STATES   /* states for FSM's */
X   {
X   S_Start,            /* initial state, between paragraphs       */
X   S_StartFirstLine,        /* spaces at start of first line           */
X   S_FirstLine,         /* text on the first line               */
X   S_FirstLineSpaces,        /* spaces on the first line            */
X   S_StartSecondLine,        /* spaces at start of second line           */
X   S_Line,            /* text on lines after the first           */
X   S_LineSpaces,        /* spaces on lines after the first           */
X   S_StartLine,         /* spaces at start of lines after second       */
X   S_FormatDisabled,        /* format automatically disabled for this line */
X   S_FormatDisabledSpaces,  /* spaces in line which format is disabled       */
X   S_Spaces
X   } ;
X
X
Xvoid check_command_length(int eoff, int len)
X   {
X   if (strlen(cmd) != len)
X      error(eoff, "Invalid text after a command \"%s\"", cmd+len);
X   }
X
X
Xvoid read_src(char *fname)
X   {
X   int      ch;
X   char  *ptr;
X   TOPIC  t;
X   LABEL  lbl;
X   char  *margin_pos = NULL;
X   int      in_topic   = 0,
X      formatting = 1,
X      state      = S_Start,
X      num_spaces = 0,
X      margin     = 0,
X      in_para    = 0,
X      centering  = 0,
X      lformat_exclude = format_exclude,
X      again;
X
X   xonline = xdoc = 0;
X
X   src_cfname = fname;
X
X   if ( (srcfile = fopen(fname, "rt")) == NULL )
X      fatal(0,"Unable to open \"%s\"", fname);
X
X   msg("Compiling: %s", fname);
X
X   in_topic = 0;
X
X   curr = buffer;
X
X   while ( 1 )
X      {
X
X      ch = read_char();
X
X      if ( ch == -1 )   /* EOF? */
X     {
X     if ( include_stack_top >= 0)
X        {
X        fclose(srcfile);
X        src_cfname = include_stack[include_stack_top].fname;
X        srcfile = include_stack[include_stack_top].file;
X        srcline = include_stack[include_stack_top].line;
X        srccol  = include_stack[include_stack_top].col;
X        --include_stack_top;
X        continue;
X        }
X     else
X        {
X        if (in_topic)  /* if we're in a topic, finish it */
X           end_topic(&t);
X        if (num_topic == 0)
X           warn(0,".SRC file has no topics.");
X        break;
X        }
X     }
X
X      if (ch == '~')   /* is is a command? */
X     {
X     int imbedded;
X     int eoff;
X     int done;
X
X     ch = read_char();
X     if (ch == '(')
X        {
X        imbedded = 1;
X        eoff = 0;
X        }
X     else
X        {
X        imbedded = 0;
X        eoff=0;
X        unread_char(ch);
X        }
X
X     done = 0;
X
X     while ( !done )
X        {
X        do
X           ch = read_char();
X        while (ch == ' ');
X        unread_char(ch);
X
X        if (imbedded)
X           ptr = read_until(cmd, 128, ")\n,");
X        else
X           ptr = read_until(cmd, 128, "\n,");
X
X        done = 1;
X
X        if ( *ptr == '\0' )
X           {
X           error(0,"Unexpected EOF in command.");
X           break;
X           }
X
X        if (*ptr == '\n')
X           ++eoff;
X
X        if ( imbedded && *ptr == '\n' )
X           error(eoff,"Imbedded command has no closing parend (\')\')");
X
X        done = (*ptr != ',');   /* we done if it's not a comma */
X
X        if ( *ptr != '\n' && *ptr != ')' && *ptr != ',' )
X           {
X           error(0,"Command line too long.");
X           break;
X           }
X
X        *ptr = '\0';
X
X
X        /* commands allowed anytime... */
X
X        if ( strnicmp(cmd, "Topic=", 6) == 0 )
X           {
X           if (in_topic)  /* if we're in a topic, finish it */
X          end_topic(&t);
X           else
X          in_topic = 1;
X
X           if (cmd[6] == '\0')
X          warn(eoff,"Topic has no title.");
X
X           else if (strlen(cmd+6) > 70)
X          error(eoff,"Topic title is too long.");
X
X           else if (strlen(cmd+6) > 60)
X          warn(eoff,"Topic title is long.");
X
X           if ( find_topic_title(cmd+6) != -1 )
X          error(eoff,"Topic title already exists.");
X
X           start_topic(&t, cmd+6, (unsigned)(ptr-(cmd+6)));
X           formatting = 1;
X           centering = 0;
X           state = S_Start;
X           in_para = 0;
X           num_spaces = 0;
X           xonline = xdoc = 0;
X           lformat_exclude = format_exclude;
X           compress_spaces = 1;
X           continue;
X           }
X
X        else if ( strnicmp(cmd, "Data=", 5) == 0 )
X           {
X           if (in_topic)  /* if we're in a topic, finish it */
X          end_topic(&t);
X           else
X          in_topic = 1;
X
X           if (cmd[5] == '\0')
X          warn(eoff,"Data topic has no label.");
X
X           if ( !validate_label_name(cmd+5) )
X          {
X          error(eoff,"Label \"%s\" contains illegal characters.", cmd+5);
X          continue;
X          }
X
X           if ( find_label(cmd+5) != NULL )
X          {
X          error(eoff,"Label \"%s\" already exists", cmd+5);
X          continue;
X          }
X
X           if ( cmd[5] == '@' )
X          warn(eoff, "Data topic has a local label.");
X
X           start_topic(&t, "", 0);
X           t.flags |= TF_DATA;
X
X           if (strlen(cmd+5) > 32)
X          warn(eoff,"Label name is long.");
X
X           lbl.name      = dupstr(cmd+5, 0);
X           lbl.topic_num = num_topic;
X           lbl.topic_off = 0;
X           lbl.doc_page  = -1;
X           add_label(&lbl);
X
X           formatting = 0;
X           centering = 0;
X           state = S_Start;
X           in_para = 0;
X           num_spaces = 0;
X           xonline = xdoc = 0;
X           lformat_exclude = format_exclude;
X           compress_spaces = 0;
X           continue;
X           }
X
X        else if ( strnicmp(cmd, "DocContents", 11) == 0 )
X           {
X           check_command_length(eoff, 11);
X           if (in_topic)  /* if we're in a topic, finish it */
X          end_topic(&t);
X           if (!done)
X          {
X          if (imbedded)
X             unread_char('(');
X          unread_char('~');
X          done = 1;
X          }
X           compress_spaces = 1;
X           process_contents();
X           in_topic = 0;
X           continue;
X           }
X
X        else if ( stricmp(cmd, "Comment") == 0 )
X           {
X           process_comment();
X           continue;
X           }
X
X        else if ( strnicmp(cmd, "FormatExclude", 13) == 0 )
X           {
X           if (cmd[13] == '-')
X          {
X          check_command_length(eoff, 14);
X          if ( in_topic )
X             {
X             if (lformat_exclude > 0)
X                lformat_exclude = -lformat_exclude;
X             else
X                warn(eoff,"\"FormatExclude-\" is already in effect.");
X             }
X          else
X             {
X             if (format_exclude > 0)
X                format_exclude = -format_exclude;
X             else
X                warn(eoff,"\"FormatExclude-\" is already in effect.");
X             }
X          }
X           else if (cmd[13] == '+')
X          {
X          check_command_length(eoff,14);
X          if ( in_topic )
X             {
X             if (lformat_exclude < 0)
X                lformat_exclude = -lformat_exclude;
X             else
X                warn(eoff,"\"FormatExclude+\" is already in effect.");
X             }
X          else
X             {
X             if (format_exclude < 0)
X                format_exclude = -format_exclude;
X             else
X                warn(eoff,"\"FormatExclude+\" is already in effect.");
X             }
X          }
X           else if (cmd[13] == '=')
X          {
X          if (cmd[14] == 'n' || cmd[14] == 'N')
X             {
X             check_command_length(eoff,15);
X             if (in_topic)
X                lformat_exclude = 0;
X             else
X               format_exclude = 0;
X             }
X          else if (cmd[14] == '\0')
X             lformat_exclude = format_exclude;
X          else
X             {
X             int n = ( ( (in_topic) ? lformat_exclude : format_exclude) < 0 ) ? -1 : 1;
X
X             lformat_exclude = atoi(cmd+14);
X
X             if ( lformat_exclude <= 0 )
X                {
X                error(eoff,"Invalid argument to FormatExclude=");
X                lformat_exclude = 0;
X                }
X
X             lformat_exclude *= n;
X
X             if ( !in_topic )
X                format_exclude = lformat_exclude;
X             }
X          }
X           else
X          error(eoff,"Invalid format for FormatExclude");
X
X           continue;
X           }
X
X        else if ( strnicmp(cmd, "Include ", 8) == 0 )
X           {
X           if (include_stack_top >= MAX_INCLUDE_STACK-1)
X          error(eoff, "Too many nested Includes.");
X           else
X          {
X          ++include_stack_top;
X          include_stack[include_stack_top].fname = src_cfname;
X          include_stack[include_stack_top].file = srcfile;
X          include_stack[include_stack_top].line = srcline;
X          include_stack[include_stack_top].col  = srccol;
X          strupr(cmd+8);
X          if ( (srcfile = fopen(cmd+8, "rt")) == NULL )
X             {
X             error(eoff, "Unable to open \"%s\"", cmd+8);
X             srcfile = include_stack[include_stack_top--].file;
X             }
X          src_cfname = dupstr(cmd+8,0);  /* never deallocate! */
X          srcline = 1;
X          srccol = 0;
X          }
X
X           continue;
X           }
X
X
X        /* commands allowed only before all topics... */
X
X        if ( !in_topic )
X           {
X           if ( strnicmp(cmd, "HdrFile=", 8) == 0 )
X          {
X          if (hdr_fname[0] != '\0')
X             warn(eoff,"Header Filename has already been defined.");
X          strcpy(hdr_fname, cmd+8);
X          strupr(hdr_fname);
X          }
X
X           else if ( strnicmp(cmd, "HlpFile=", 8) == 0 )
X          {
X          if (hlp_fname[0] != '\0')
X             warn(eoff,"Help Filename has already been defined.");
X          strcpy(hlp_fname, cmd+8);
X          strupr(hlp_fname);
X          }
X
X           else if ( strnicmp(cmd, "Version=", 8) == 0 )
X          {
X          if (version != -1)   /* an unlikely value */
X             warn(eoff,"Help version has already been defined");
X          version = atoi(cmd+8);
X          }
X
X           else
X          error(eoff,"Bad or unexpected command \"%s\"", cmd);
X
X           continue;
X           }
X
X
X        /* commands allowed only in a topic... */
X
X        else
X           {
X           if (strnicmp(cmd, "FF", 2) == 0 )
X          {
X          check_command_length(eoff,2);
X          if ( in_para )
X             *curr++ = '\n';  /* finish off current paragraph */
X          *curr++ = CMD_FF;
X          state = S_Start;
X          in_para = 0;
X          num_spaces = 0;
X          }
X
X           else if (strnicmp(cmd, "DocFF", 5) == 0 )
X          {
X          check_command_length(eoff,5);
X          if ( in_para )
X             *curr++ = '\n';  /* finish off current paragraph */
X          if (!xonline)
X             *curr++ = CMD_XONLINE;
X          *curr++ = CMD_FF;
X          if (!xonline)
X             *curr++ = CMD_XONLINE;
X          state = S_Start;
X          in_para = 0;
X          num_spaces = 0;
X          }
X
X           else if (strnicmp(cmd, "OnlineFF", 8) == 0 )
X          {
X          check_command_length(eoff,8);
X          if ( in_para )
X             *curr++ = '\n';  /* finish off current paragraph */
X          if (!xdoc)
X             *curr++ = CMD_XDOC;
X          *curr++ = CMD_FF;
X          if (!xdoc)
X             *curr++ = CMD_XDOC;
X          state = S_Start;
X          in_para = 0;
X          num_spaces = 0;
X          }
X
X           else if ( strnicmp(cmd, "Label=", 6) == 0 )
X          {
X          if (strlen(cmd+6) <= 0)
X             error(eoff,"Label has no name.");
X
X          else if ( !validate_label_name(cmd+6) )
X             error(eoff,"Label \"%s\" contains illegal characters.", cmd+6);
X
X          else if ( find_label(cmd+6) != NULL )
X             error(eoff,"Label \"%s\" already exists", cmd+6);
X
X          else
X             {
X             if (strlen(cmd+6) > 32)
X                warn(eoff,"Label name is long.");
X
X            if ( (t.flags & TF_DATA) && cmd[6] == '@' )
X               warn(eoff, "Data topic has a local label.");
X
X             lbl.name       = dupstr(cmd+6, 0);
X             lbl.topic_num = num_topic;
X             lbl.topic_off = (unsigned)(curr - buffer);
X             lbl.doc_page  = -1;
X             add_label(&lbl);
X             }
X          }
X
X           else if ( strnicmp(cmd, "Table=", 6) == 0 )
X          {
X          if ( in_para )
X             {
X             *curr++ = '\n';  /* finish off current paragraph */
X             in_para = 0;
X             num_spaces = 0;
X             state = S_Start;
X             }
X
X          if (!done)
X             {
X             if (imbedded)
X                unread_char('(');
X             unread_char('~');
X             done = 1;
X             }
X
X          create_table();
X          }
X
X           else if ( strnicmp(cmd, "FormatExclude", 12) == 0 )
X          {
X          if (cmd[13] == '-')
X             {
X             check_command_length(eoff,14);
X             if (lformat_exclude > 0)
X                lformat_exclude = -lformat_exclude;
X             else
X                warn(0,"\"FormatExclude-\" is already in effect.");
X             }
X          else if (cmd[13] == '+')
X             {
X             check_command_length(eoff,14);
X             if (lformat_exclude < 0)
X                lformat_exclude = -lformat_exclude;
X             else
X                warn(0,"\"FormatExclude+\" is already in effect.");
X             }
X          else
X             error(eoff,"Unexpected or invalid argument to FormatExclude.");
X          }
X
X           else if ( strnicmp(cmd, "Format", 6) == 0 )
X          {
X          if (cmd[6] == '+')
X             {
X             check_command_length(eoff,7);
X             if ( !formatting )
X                {
X                formatting = 1;
X                in_para = 0;
X                num_spaces = 0;
X                state = S_Start;
X                }
X             else
X                warn(eoff,"\"Format+\" is already in effect.");
X             }
X          else if (cmd[6] == '-')
X             {
X             check_command_length(eoff,7);
X             if ( formatting )
X                {
X                if ( in_para )
X               *curr++ = '\n';  /* finish off current paragraph */
X                state = S_Start;
X                in_para = 0;
X                formatting = 0;
X                num_spaces = 0;
X                state = S_Start;
X                }
X             else
X                warn(eoff,"\"Format-\" is already in effect.");
X             }
X          else
X             error(eoff,"Invalid argument to Format.");
X          }
X
X           else if ( strnicmp(cmd, "Online", 6) == 0 )
X          {
X          if (cmd[6] == '+')
X             {
X             check_command_length(eoff,7);
X
X             if ( xonline )
X                {
X                *curr++ = CMD_XONLINE;
X                xonline = 0;
X                }
X             else
X                warn(eoff,"\"Online+\" already in effect.");
X             }
X          else if (cmd[6] == '-')
X             {
X             check_command_length(eoff,7);
X             if ( !xonline )
X                {
X                *curr++ = CMD_XONLINE;
X                xonline = 1;
X                }
X             else
X                warn(eoff,"\"Online-\" already in effect.");
X             }
X          else
X             error(eoff,"Invalid argument to Online.");
X          }
X
X           else if ( strnicmp(cmd, "Doc", 3) == 0 )
X          {
X          if (cmd[3] == '+')
X             {
X             check_command_length(eoff,4);
X             if ( xdoc )
X                {
X                *curr++ = CMD_XDOC;
X                xdoc = 0;
X                }
X             else
X                warn(eoff,"\"Doc+\" already in effect.");
X             }
X          else if (cmd[3] == '-')
X             {
X             check_command_length(eoff,4);
X             if ( !xdoc )
X                {
X                *curr++ = CMD_XDOC;
X                xdoc = 1;
X                }
X             else
X                warn(eoff,"\"Doc-\" already in effect.");
X             }
X          else
X             error(eoff,"Invalid argument to Doc.");
X          }
X
X           else if ( strnicmp(cmd, "Center", 6) == 0 )
X          {
X          if (cmd[6] == '+')
X             {
X             check_command_length(eoff,7);
X             if ( !centering )
X                {
X                centering = 1;
X                if ( in_para )
X               {
X               *curr++ = '\n';
X               in_para = 0;
X               }
X                state = S_Start;  /* for centering FSM */
X                }
X             else
X                warn(eoff,"\"Center+\" already in effect.");
X             }
X          else if (cmd[6] == '-')
X             {
X             check_command_length(eoff,7);
X             if ( centering )
X                {
X                centering = 0;
X                state = S_Start;  /* for centering FSM */
X                }
X             else
X                warn(eoff,"\"Center-\" already in effect.");
X             }
X          else
X             error(eoff,"Invalid argument to Center.");
X          }
X
X           else if ( strnicmp(cmd, "CompressSpaces", 14) == 0 )
X          {
X          check_command_length(eoff,15);
X
X          if ( cmd[14] == '+' )
X             {
X             if ( compress_spaces )
X                warn(eoff,"\"CompressSpaces+\" is already in effect.");
X             else
X                compress_spaces = 1;
X             }
X          else if ( cmd[14] == '-' )
X             {
X             if ( !compress_spaces )
X                warn(eoff,"\"CompressSpaces-\" is already in effect.");
X             else
X                compress_spaces = 0;
X             }
X          else
X             error(eoff,"Invalid argument to CompressSpaces.");
X          }
X
X           else if ( strnicmp("BinInc ", cmd, 7) == 0 )
X          {
X          if ( !(t.flags & TF_DATA) )
X             error(eoff,"BinInc allowed only in Data topics.");
X          else
X             process_bininc();
X          }
X
X           else
X          error(eoff,"Bad or unexpected command \"%s\".", cmd);
X           } /* else */
X
X        } /* while (!done) */
X
X     continue;
X     }
X
X      if ( !in_topic )
X     {
X     cmd[0] = ch;
X     ptr = read_until(cmd+1, 127, "\n~");
X     if (*ptr == '~')
X        unread_char('~');
X     *ptr = '\0';
X     error(0,"Text outside of any topic \"%s\".", cmd);
X     continue;
X     }
X
X      if ( centering )
X     {
X     do
X        {
X        again = 0;     /* default */
X
X        switch (state)
X           {
X           case S_Start:
X          if (ch == ' ')
X             ; /* do nothing */
X          else if ( (ch&0xFF) == '\n' )
X             *curr++ = ch;  /* no need to center blank lines. */
X          else
X             {
X             *curr++ = CMD_CENTER;
X             state = S_Line;
X             again = 1;
X             }
X          break;
X
X           case S_Line:
X          put_a_char(ch, &t);
X          if ( (ch&0xFF) == '\n')
X             state = S_Start;
X          break;
X           } /* switch */
X        }
X     while (again);
X     }
X
X      else if ( formatting )
X     {
X     int again;
X
X     do
X        {
X        again = 0;     /* default */
X
X        switch (state)
X           {
X           case S_Start:
X          if ( (ch&0xFF) == '\n' )
X             *curr++ = ch;
X          else
X             {
X             state = S_StartFirstLine;
X             num_spaces = 0;
X             again = 1;
X             }
X          break;
X
X           case S_StartFirstLine:
X          if ( ch == ' ')
X             ++num_spaces;
X
X          else
X             {
X             if (lformat_exclude > 0 && num_spaces >= lformat_exclude )
X                {
X                put_spaces(num_spaces);
X                num_spaces = 0;
X                state = S_FormatDisabled;
X                again = 1;
X                }
X             else
X                {
X                *curr++ = CMD_PARA;
X                *curr++ = (char)num_spaces;
X                *curr++ = (char)num_spaces;
X                margin_pos = curr - 1;
X                state = S_FirstLine;
X                again = 1;
X                in_para = 1;
X                }
X             }
X          break;
X
X           case S_FirstLine:
X          if (ch == '\n')
X             {
X             state = S_StartSecondLine;
X             num_spaces = 0;
X             }
X          else if (ch == ('\n'|0x100) )   /* force end of para ? */
X             {
X             *curr++ = '\n';
X             in_para = 0;
X             state = S_Start;
X             }
X          else if ( ch == ' ' )
X             {
X             state = S_FirstLineSpaces;
X             num_spaces = 1;
X             }
X          else
X             put_a_char(ch, &t);
X          break;
X
X           case S_FirstLineSpaces:
X          if (ch == ' ')
X             ++num_spaces;
X          else
X             {
X             put_spaces(num_spaces);
X             state = S_FirstLine;
X             again = 1;
X             }
X          break;
X
X           case S_StartSecondLine:
X          if ( ch == ' ')
X             ++num_spaces;
X          else if ((ch&0xFF) == '\n') /* a blank line means end of a para */
X             {
X             *curr++ = '\n';   /* end the para */
X             *curr++ = '\n';   /* for the blank line */
X             in_para = 0;
X             state = S_Start;
X             }
X          else
X             {
X             if (lformat_exclude > 0 && num_spaces >= lformat_exclude )
X                {
X                *curr++ = '\n';
X                in_para = 0;
X                put_spaces(num_spaces);
X                num_spaces = 0;
X                state = S_FormatDisabled;
X                again = 1;
X                }
X             else
X                {
X                add_blank_for_split();
X                margin = num_spaces;
X                *margin_pos = (char)num_spaces;
X                state = S_Line;
X                again = 1;
X                }
X             }
X          break;
X
X           case S_Line:   /* all lines after the first */
X          if (ch == '\n')
X             {
X             state = S_StartLine;
X             num_spaces = 0;
X             }
X          else if (ch == ('\n' | 0x100) )   /* force end of para ? */
X             {
X             *curr++ = '\n';
X             in_para = 0;
X             state = S_Start;
X             }
X          else if ( ch == ' ' )
X             {
X             state = S_LineSpaces;
X             num_spaces = 1;
X             }
X          else
X             put_a_char(ch, &t);
X          break;
X
X           case S_LineSpaces:
X          if (ch == ' ')
X             ++num_spaces;
X          else
X             {
X             put_spaces(num_spaces);
X             state = S_Line;
X             again = 1;
X             }
X          break;
X
X           case S_StartLine:   /* for all lines after the second */
X          if ( ch == ' ')
X             ++num_spaces;
X          else if ((ch&0xFF) == '\n') /* a blank line means end of a para */
X             {
X             *curr++ = '\n';   /* end the para */
X             *curr++ = '\n';   /* for the blank line */
X             in_para = 0;
X             state = S_Start;
X             }
X          else
X             {
X             if ( num_spaces != margin )
X                {
X                *curr++ = '\n';
X                in_para = 0;
X                state = S_StartFirstLine;  /* with current num_spaces */
X                again = 1;
X                }
X             else
X                {
X                add_blank_for_split();
X                state = S_Line;
X                again = 1;
X                }
X             }
X          break;
X
X           case S_FormatDisabled:
X          if ( ch == ' ' )
X             {
X             state = S_FormatDisabledSpaces;
X             num_spaces = 1;
X             }
X          else
X             {
X             if ( (ch&0xFF) == '\n' )
X                state = S_Start;
X             put_a_char(ch, &t);
X             }
X          break;
X
X           case S_FormatDisabledSpaces:
X          if ( ch == ' ' )
X             ++num_spaces;
X          else
X             {
X             put_spaces(num_spaces);
X             num_spaces = 0;    /* is this needed? */
X             state = S_FormatDisabled;
X             again = 1;
X             }
X          break;
X
X           } /* switch (state) */
X        }
X     while (again);
X     }
X
X      else
X     {
X     do
X        {
X        again = 0;     /* default */
X
X        switch (state)
X           {
X           case S_Start:
X          if ( ch == ' ' )
X             {
X             state = S_Spaces;
X             num_spaces = 1;
X             }
X          else
X             put_a_char(ch, &t);
X          break;
X
X           case S_Spaces:
X          if (ch == ' ')
X             ++num_spaces;
X          else
X             {
X             put_spaces(num_spaces);
X             num_spaces = 0;     /* is this needed? */
X             state = S_Start;
X             again = 1;
X             }
X          break;
X           } /* switch */
X        }
X     while (again);
X     }
X
X      CHK_BUFFER(0)
X      } /* while ( 1 ) */
X
X   fclose(srcfile);
X
X   srcline = -1;
X   }
X
X
X/*
X * stuff to resolve hot-link references.
X */
X
X
Xvoid make_hot_links(void)
X   /*
X    * calculate topic_num/topic_off for each link.
X    */
X   {
X   LINK    *l;
X   LABEL   *lbl;
X   int        lctr;
X   int        t;
X   CONTENT *c;
X   int        ctr;
X
X   msg("Making hot-links.");
X
X   /*
X    * Calculate topic_num for all entries in DocContents.  Also set
X    * "TF_IN_DOC" flag for all topics included in the document.
X    */
X
X   for (lctr=0, c=contents; lctr<num_contents; lctr++, c++)
X      {
X      for (ctr=0; ctr<c->num_topic; ctr++)
X     {
X     if ( c->is_label[ctr] )
X        {
X        lbl = find_label(c->topic_name[ctr]);
X        if (lbl == NULL)
X           {
X           src_cfname = c->srcfile;
X           srcline = c->srcline;
X           error(0,"Cannot find DocContent label \"%s\".", c->topic_name[ctr]);
X           srcline = -1;
X           }
X        else
X           {
X           if ( topic[lbl->topic_num].flags & TF_DATA )
X          {
X          src_cfname = c->srcfile;
X          srcline = c->srcline;
X          error(0,"Label \"%s\" is a data-only topic.", c->topic_name[ctr]);
X          srcline = -1;
X          }
X           else
X          {
X          c->topic_num[ctr] = lbl->topic_num;
X          if ( topic[lbl->topic_num].flags & TF_IN_DOC )
X             warn(0,"Topic \"%s\" appears in document more than once.",
X              topic[lbl->topic_num].title);
X          else
X             topic[lbl->topic_num].flags |= TF_IN_DOC;
X          }
X           }
X
X        }
X     else
X        {
X        t = find_topic_title(c->topic_name[ctr]);
X
X        if (t == -1)
X           {
X           src_cfname = c->srcfile;
X           srcline = c->srcline;
X           error(0,"Cannot find DocContent topic \"%s\".", c->topic_name[ctr]);
X           srcline = -1;  /* back to reality */
X           }
X        else
X           {
X           c->topic_num[ctr] = t;
X           if ( topic[t].flags & TF_IN_DOC )
X          warn(0,"Topic \"%s\" appears in document more than once.",
X               topic[t].title);
X           else
X          topic[t].flags |= TF_IN_DOC;
X           }
X        }
X     }
X      }
X
X   /*
X    * Find topic_num and topic_off for all hot-links.  Also flag all hot-
X    * links which will (probably) appear in the document.
X    */
X
X   for (lctr=0, l=a_link; lctr<num_link; l++, lctr++)
X      {
X      switch ( l->type )
X     {
X     case 0:      /* name is the title of the topic */
X        t = find_topic_title(l->name);
X        if (t == -1)
X           {
X           src_cfname = l->srcfile;
X           srcline = l->srcline; /* pretend we are still in the source... */
X           error(0,"Cannot find implicit hot-link \"%s\".", l->name);
X           srcline = -1;  /* back to reality */
X           }
X        else
X           {
X           l->topic_num = t;
X           l->topic_off = 0;
X           l->doc_page = (topic[t].flags & TF_IN_DOC) ? 0 : -1;
X           }
X        break;
X
X     case 1:  /* name is the name of a label */
X        lbl = find_label(l->name);
X        if (lbl == NULL)
X           {
X           src_cfname = l->srcfile;
X           srcline = l->srcline; /* pretend again */
X           error(0,"Cannot find explicit hot-link \"%s\".", l->name);
X           srcline = -1;
X           }
X        else
X           {
X           if ( topic[lbl->topic_num].flags & TF_DATA )
X          {
X          src_cfname = l->srcfile;
X          srcline = l->srcline;
X          error(0,"Label \"%s\" is a data-only topic.", l->name);
X          srcline = -1;
X          }
X           else
X          {
X          l->topic_num = lbl->topic_num;
X          l->topic_off = lbl->topic_off;
X          l->doc_page  = (topic[lbl->topic_num].flags & TF_IN_DOC) ? 0 : -1;
X          }
X           }
X        break;
X
X     case 2:   /* it's a "special" link; topic_off already has the value */
X        break;
X     }
X      }
X
X   }
X
X
X/*
X * online help pagination stuff
X */
X
X
Xvoid add_page_break(TOPIC *t, int margin, char *text, char *start, char *curr, int num_links)
X   {
X   PAGE p;
X
X   p.offset = (unsigned) (start - text);
X   p.length = (unsigned) (curr - start);
X   p.margin = margin;
X   add_page(t, &p);
X
X   if (max_links < num_links)
X      max_links = num_links;
X   }
X
X
Xvoid paginate_online(void)    /* paginate the text for on-line help */
X   {               /* also calculates max_pages and max_links */
X   int         lnum;
X   char     *start;
X   char     *curr;
X   char     *text;
X   TOPIC    *t;
X   int         tctr;
X   unsigned  len;
X   int         skip_blanks;
X   int         num_links;
X   int         col;
X   int         tok;
X   int         size,
X         width;
X   int         start_margin;
X
X   msg("Paginating online help.");
X
X   for (t=topic, tctr=0; tctr<num_topic; t++, tctr++)
X      {
X      if ( t->flags & TF_DATA )
X     continue;    /* don't paginate data topics */
X
X      text = get_topic_text(t);
X      curr = text;
X      len  = t->text_len;
X
X      start = curr;
X      skip_blanks = 0;
X      lnum = 0;
X      num_links = 0;
X      col = 0;
X      start_margin = -1;
X
X      while (len > 0)
X     {
X     tok = find_token_length(ONLINE, curr, len, &size, &width);
X
X     switch ( tok )
X        {
X        case TOK_PARA:
X           {
X           int indent,
X           margin;
X
X           ++curr;
X
X           indent = *curr++;
X           margin = *curr++;
X
X           len -= 3;
X
X           col = indent;
X
X           while (1)
X          {
X          tok = find_token_length(ONLINE, curr, len, &size, &width);
X
X          if (tok == TOK_DONE || tok == TOK_NL || tok == TOK_FF )
X             break;
X
X          if ( tok == TOK_PARA )
X             {
X             col = 0;   /* fake a nl */
X             ++lnum;
X             break;
X             }
X
X          if (tok == TOK_XONLINE || tok == TOK_XDOC )
X             {
X             curr += size;
X             len -= size;
X             continue;
X             }
X
X          /* now tok is TOK_SPACE or TOK_LINK or TOK_WORD */
X
X          if (col+width > SCREEN_WIDTH)
X             {            /* go to next line... */
X             if ( ++lnum >= SCREEN_DEPTH )
X                {        /* go to next page... */
X                add_page_break(t, start_margin, text, start, curr, num_links);
X                start = curr + ( (tok == TOK_SPACE) ? size : 0 );
X                start_margin = margin;
X                lnum = 0;
X                num_links = 0;
X                }
X             if ( tok == TOK_SPACE )
X                width = 0;   /* skip spaces at start of a line */
X
X             col = margin;
X             }
X
X          col += width;
X          curr += size;
X          len -= size;
X          }
X
X           skip_blanks = 0;
X           width = size = 0;
X           break;
X           }
X
X        case TOK_NL:
X           if (skip_blanks && col == 0)
X          {
X          start += size;
X          break;
X          }
X           ++lnum;
X           if ( lnum >= SCREEN_DEPTH || (col == 0 && lnum==SCREEN_DEPTH-1) )
X          {
X          add_page_break(t, start_margin, text, start, curr, num_links);
X          start = curr + size;
X          start_margin = -1;
X          lnum = 0;
X          num_links = 0;
X          skip_blanks = 1;
X          }
X           col = 0;
X           break;
X
X        case TOK_FF:
X           col = 0;
X           if (skip_blanks)
X          {
X          start += size;
X          break;
X          }
X           add_page_break(t, start_margin, text, start, curr, num_links);
X           start_margin = -1;
X           start = curr + size;
X           lnum = 0;
X           num_links = 0;
X           break;
X
X        case TOK_DONE:
X        case TOK_XONLINE:   /* skip */
X        case TOK_XDOC:      /* ignore */
X        case TOK_CENTER:    /* ignore */
X           break;
X
X        case TOK_LINK:
X           ++num_links;
X
X           /* fall-through */
X
X        default:    /* TOK_SPACE, TOK_LINK, TOK_WORD */
X           skip_blanks = 0;
X           break;
X
X        } /* switch */
X
X     curr += size;
X     len  -= size;
X     col  += width;
X     } /* while */
X
X      if (!skip_blanks)
X     add_page_break(t, start_margin, text, start, curr, num_links);
X
X      if (max_pages < t->num_page)
X     max_pages = t->num_page;
X
X      release_topic_text(t, 0);
X      } /* for */
X   }
X
X
X/*
X * paginate document stuff
X */
X
X
X#define CNUM           0
X#define TNUM           1
X#define LINK_DEST_WARN 2
X
X
Xtypedef struct
X   {
X   int        cnum,  /* must match above #defines so pd_get_info() will work */
X        tnum,
X        link_dest_warn;
X
X   char far *start;
X   CONTENT  *c;
X   LABEL    *lbl;
X
X   } PAGINATE_DOC_INFO;
X
X
XLABEL *find_next_label_by_topic(int t)
X   {
X   LABEL *temp, *g, *p;
X   int      ctr;
X
X   g = p = NULL;
X
X   for (temp=label, ctr=0; ctr<num_label; ctr++, temp++)
X      if ( temp->topic_num == t && temp->doc_page == -1 )
X     {
X     g = temp;
X     break;
X     }
X      else if (temp->topic_num > t)
X     break;
X
X   for (temp=plabel, ctr=0; ctr<num_plabel; ctr++, temp++)
X      if ( temp->topic_num == t && temp->doc_page == -1 )
X     {
X     p = temp;
X     break;
X     }
X      else if (temp->topic_num > t)
X     break;
X
X   if ( p == NULL )
X      return (g);
X
X   else if ( g == NULL )
X      return (p);
X
X   else
X      return ( (g->topic_off < p->topic_off) ? g : p );
X   }
X
X
Xvoid set_hot_link_doc_page(void)
X   /*
X    * Find doc_page for all hot-links.
X    */
X   {
X   LINK  *l;
X   LABEL *lbl;
X   int      lctr;
X   int      t;
X
X   for (lctr=0, l=a_link; lctr<num_link; l++, lctr++)
X      {
X      switch ( l->type )
X     {
X     case 0:      /* name is the title of the topic */
X        t = find_topic_title(l->name);
X        if (t == -1)
X           {
X           src_cfname = l->srcfile;
X           srcline = l->srcline; /* pretend we are still in the source... */
X           error(0,"Cannot find implicit hot-link \"%s\".", l->name);
X           srcline = -1;  /* back to reality */
X           }
X        else
X           l->doc_page = topic[t].doc_page;
X        break;
X
X     case 1:  /* name is the name of a label */
X        lbl = find_label(l->name);
X        if (lbl == NULL)
X           {
X           src_cfname = l->srcfile;
X           srcline = l->srcline; /* pretend again */
X           error(0,"Cannot find explicit hot-link \"%s\".", l->name);
X           srcline = -1;
X           }
X        else
X           l->doc_page = lbl->doc_page;
X        break;
X
X     case 2:   /* special topics don't appear in the document */
X        break;
X     }
X      }
X   }
X
X
Xvoid set_content_doc_page(void)
X   /*
X    * insert page #'s in the DocContents
X    */
X   {
X   CONTENT *c;
X   TOPIC   *t;
X   char    *base;
X   int        tnum;
X   int        ctr;
X   char     buf[4];
X   int        len;
X
X   tnum = find_topic_title(DOCCONTENTS_TITLE);
X   assert(tnum>=0);
X   t = &topic[tnum];
X
X   base = get_topic_text(t);
X
X   for (ctr=1, c=contents+1; ctr<num_contents; ctr++, c++)
X      {
X      assert(c->doc_page>=1);
X      sprintf(buf, "%d", c->doc_page);
X      len = strlen(buf);
X      assert(len<=3);
X      memcpy(base+c->page_num_pos+(3-len), buf, len);
X      }
X
X   release_topic_text(t, 1);
X   }
X
X
Xint pd_get_info(int cmd, PD_INFO *pd, int *info)
X   {         /* this funtion also used by print_document() */
X   CONTENT *c;
X
X   switch (cmd)
X      {
X      case PD_GET_CONTENT:
X     if ( ++info[CNUM] >= num_contents )
X        return (0);
X     c = &contents[info[CNUM]];
X     info[TNUM] = -1;
X     pd->id       = c->id;
X     pd->title    = c->name;
X     pd->new_page = (c->flags & CF_NEW_PAGE) ? 1 : 0;
X     return (1);
X
X      case PD_GET_TOPIC:
X     c = &contents[info[CNUM]];
X     if ( ++info[TNUM] >= c->num_topic )
X        return (0);
X     pd->curr = get_topic_text( &topic[c->topic_num[info[TNUM]]] );
X     pd->len = topic[c->topic_num[info[TNUM]]].text_len;
X     return (1);
X
X      case PD_GET_LINK_PAGE:
X         if ( a_link[getint(pd->s)].doc_page == -1 )
X        {
X        if ( info[LINK_DEST_WARN] )
X           {
X               src_cfname = a_link[getint(pd->s)].srcfile;
X               srcline    = a_link[getint(pd->s)].srcline;
X           warn(0,"Hot-link destination is not in the document.");
X           srcline = -1;
X           }
X        return (0);
X        }
X         pd->i = a_link[getint(pd->s)].doc_page;
X     return (1);
X
X      case PD_RELEASE_TOPIC:
X     c = &contents[info[CNUM]];
X     release_topic_text(&topic[c->topic_num[info[TNUM]]], 0);
X     return (1);
X
X      default:
X     return (0);
X      }
X   }
X
X
Xint paginate_doc_output(int cmd, PD_INFO *pd, PAGINATE_DOC_INFO *info)
X   {
X   switch (cmd)
X      {
X      case PD_FOOTING:
X      case PD_PRINT:
X      case PD_PRINTN:
X      case PD_PRINT_SEC:
X     return (1);
X
X      case PD_HEADING:
X     ++num_doc_pages;
X     return (1);
X
X      case PD_START_SECTION:
X     info->c = &contents[info->cnum];
X     return (1);
X
X      case PD_START_TOPIC:
X     info->start = pd->curr;
X     info->lbl = find_next_label_by_topic(info->c->topic_num[info->tnum]);
X     return (1);
X
X      case PD_SET_SECTION_PAGE:
X     info->c->doc_page = pd->pnum;
X     return (1);
X
X      case PD_SET_TOPIC_PAGE:
X     topic[info->c->topic_num[info->tnum]].doc_page = pd->pnum;
X     return (1);
X
X      case PD_PERIODIC:
X     while ( info->lbl != NULL && (unsigned)(pd->curr - info->start) >= info->lbl->topic_off)
X        {
X        info->lbl->doc_page = pd->pnum;
X        info->lbl = find_next_label_by_topic(info->c->topic_num[info->tnum]);
X        }
X     return (1);
X
X      default:
X     return (0);
X      }
X   }
X
X
Xvoid paginate_document(void)
X   {
X   PAGINATE_DOC_INFO info;
X
X   if (num_contents == 0)
X      return ;
X
X   msg("Paginating document.");
X
X   info.cnum = info.tnum = -1;
X   info.link_dest_warn = 1;
X
X   process_document((PD_FUNC)pd_get_info, (PD_FUNC)paginate_doc_output, &info);
X
X   set_hot_link_doc_page();
X   set_content_doc_page();
X   }
X
X
X/*
X * label sorting stuff
X */
X
X
Xint fcmp_LABEL(VOIDCONSTPTR a, VOIDCONSTPTR b)
X   {
X   char *an = ((LABEL *)a)->name,
X        *bn = ((LABEL *)b)->name;
X   int     diff;
X
X   /* compare the names, making sure that the index goes first */
X
X   if ( (diff=strcmp(an,bn)) == 0 )
X      return (0);
X
X   if ( strcmp(an, INDEX_LABEL) == 0 )
X      return (-1);
X
X   if ( strcmp(bn, INDEX_LABEL) == 0 )
X      return (1);
X
X   return ( diff );
X   }
X
X
Xvoid sort_labels(void)
X   {
X   qsort(label,  num_label,  sizeof(LABEL), fcmp_LABEL);
X   qsort(plabel, num_plabel, sizeof(LABEL), fcmp_LABEL);
X   }
X
X
X/*
X * file write stuff.
X */
X
X
Xint compare_files(FILE *f1, FILE *f2) /* returns TRUE if different */
X   {
X   if ( filelength(fileno(f1)) != filelength(fileno(f2)) )
X      return (1);   /* different if sizes are not the same */
X
X   while ( !feof(f1) && !feof(f2) )
X      if ( getc(f1) != getc(f2) )
X     return (1);
X
X   return ( ( feof(f1) && feof(f2) ) ? 0 : 1);
X   }
X
X
Xvoid _write_hdr(char *fname, FILE *file)
X   {
X   int ctr;
X   char nfile[MAXFILE],
X        next[MAXEXT];
X
X   FNSPLIT(fname, NULL, NULL, nfile, next);
X   fprintf(file, "\n/*\n * %s%s\n", nfile, next);
X   FNSPLIT(src_fname, NULL, NULL, nfile, next);
X   fprintf(file, " *\n * Contains #defines for help.\n *\n");
X   fprintf(file, " * Generated by HC from: %s%s\n *\n */\n\n\n", nfile, next);
X
X   fprintf(file, "/* current help file version */\n");
X   fprintf(file, "\n");
X   fprintf(file, "#define %-32s %3d\n", "HELP_VERSION", version);
X   fprintf(file, "\n\n");
X
X   fprintf(file, "/* labels */\n\n");
X
X   for (ctr=0; ctr<num_label; ctr++)
X      if (label[ctr].name[0] != '@')  /* if it's not a local label... */
X     {
X     fprintf(file, "#define %-32s %3d", label[ctr].name, ctr);
X     if ( strcmp(label[ctr].name, INDEX_LABEL) == 0 )
X        fprintf(file, "        /* index */");
X     fprintf(file, "\n");
X     }
X
X   fprintf(file, "\n\n");
X   }
X
X
Xvoid write_hdr(char *fname)
X   {
X   FILE *temp,
X        *hdr;
X
X   hdr = fopen(fname, "rt");
X
X   if (hdr == NULL)
X      {         /* if no prev. hdr file generate a new one */
X      hdr = fopen(fname, "wt");
X      if (hdr == NULL)
X     fatal(0,"Cannot create \"%s\".", fname);
X      msg("Writing: %s", fname);
X      _write_hdr(fname, hdr);
X      fclose(hdr);
X      notice("FRACTINT must be re-compiled.");
X      return ;
X      }
X
X   msg("Comparing: %s", fname);
X
X   temp = fopen(TEMP_FNAME, "wt");
X
X   if (temp == NULL)
X      fatal(0,"Cannot create temporary file: \"%s\".", TEMP_FNAME);
X
X   _write_hdr(fname, temp);
X
X   fclose(temp);
X   temp = fopen(TEMP_FNAME, "rt");
X
X   if (temp == NULL)
X      fatal(0,"Cannot open temporary file: \"%s\".", TEMP_FNAME);
X
X   if ( compare_files(temp, hdr) )   /* if they are different... */
X      {
X      msg("Updating: %s", fname);
X      fclose(temp);
X      fclose(hdr);
X      unlink(fname);           /* delete the old hdr file */
X      rename(TEMP_FNAME, fname);   /* rename the temp to the hdr file */
X      notice("FRACTINT must be re-compiled.");
X      }
X   else
X      {   /* if they are the same leave the original alone. */
X      fclose(temp);
X      fclose(hdr);
X      unlink(TEMP_FNAME);      /* delete the temp */
X      }
X   }
X
X
Xvoid calc_offsets(void)    /* calc file offset to each topic */
X   {
X   int        t;
X   TOPIC   *tp;
X   long     offset;
X   CONTENT *cp;
X   int        c;
X
X   /* NOTE: offsets do NOT include 6 bytes for signature & version! */
X
X   offset = sizeof(int) +           /* max_pages */
X            sizeof(int) +           /* max_links */
X            sizeof(int) +           /* num_topic */
X            sizeof(int) +           /* num_label */
X            sizeof(int) +           /* num_contents */
X            sizeof(int) +           /* num_doc_pages */
X            num_topic*sizeof(long) +/* offsets to each topic */
X            num_label*2*sizeof(int);/* topic_num/topic_off for all public labels */
X
X   for (c=0, cp=contents; c<num_contents; c++, cp++)
X      offset += sizeof(int) +       /* flags */
X            1 +            /* id length */
X            strlen(cp->id) +    /* id text */
X            1 +            /* name length */
X            strlen(cp->name) +  /* name text */
X            1 +            /* number of topics */
X                cp->num_topic*sizeof(int);    /* topic numbers */
X
X   for (t=0, tp=topic; t<num_topic; t++, tp++)
X      {
X      tp->offset = offset;
X      offset += (long)sizeof(int) + /* topic flags */
X                sizeof(int) +       /* number of pages */
X                tp->num_page*3*sizeof(int) +   /* page offset, length & starting margin */
X            1 +            /* length of title */
X            tp->title_len +     /* title */
X                sizeof(int) +       /* length of text */
X            tp->text_len;        /* text */
X      }
X
X   }
X
X
Xvoid insert_real_link_info(char *curr, unsigned len)
X   /*
X    * Replaces link indexes in the help text with topic_num, topic_off and
X    * doc_page info.
X    */
X   {
X   int         size;
X   int         tok;
X   LINK     *l;
X
X   while (len > 0)
X      {
X      tok = find_token_length(0, curr, len, &size, NULL);
X
X      if ( tok == TOK_LINK )
X     {
X         l = &a_link[ getint(curr+1) ];
X         setint(curr+1,l->topic_num);
X         setint(curr+1+sizeof(int),l->topic_off);
X         setint(curr+1+2*sizeof(int),l->doc_page);
X     }
X
X      len -= size;
X      curr += size;
X      }
X   }
X
X
Xvoid _write_help(FILE *file)
X   {
X   int             t, p, l, c;
X   char             *text;
X   TOPIC            *tp;
X   CONTENT            *cp;
X   struct help_sig_info  hs;
X
X   /* write the signature and version */
X
X   hs.sig = HELP_SIG; /* Edit line 17 of helpcom.h if this is a syntax error */
X   hs.version = version;
X
X   fwrite(&hs, sizeof(long)+sizeof(int), 1, file);
X
X   /* write max_pages & max_links */
X
X   putw(max_pages, file);
X   putw(max_links, file);
X
X   /* write num_topic, num_label and num_contents */
X
X   putw(num_topic, file);
X   putw(num_label, file);
X   putw(num_contents, file);
X
X   /* write num_doc_page */
X
X   putw(num_doc_pages, file);
X
X   /* write the offsets to each topic */
X
X   for (t=0; t<num_topic; t++)
X      fwrite(&topic[t].offset, sizeof(long), 1, file);
X
X   /* write all public labels */
X
X   for (l=0; l<num_label; l++)
X      {
X      putw(label[l].topic_num, file);
X      putw(label[l].topic_off, file);
X      }
X
X   /* write contents */
X
X   for (c=0, cp=contents; c<num_contents; c++, cp++)
X      {
X      putw(cp->flags, file);
X
X      t = strlen(cp->id);
X      putc((BYTE)t, file);
X      fwrite(cp->id, 1, t, file);
X
X      t = strlen(cp->name);
X      putc((BYTE)t, file);
X      fwrite(cp->name, 1, t, file);
X
X      putc((BYTE)cp->num_topic, file);
X      fwrite(cp->topic_num, sizeof(int), cp->num_topic, file);
X      }
X
X   /* write topics */
X
X   for (t=0, tp=topic; t<num_topic; t++, tp++)
X      {
X      /* write the topics flags */
X
X      putw(tp->flags, file);
X
X      /* write offset, length and starting margin for each page */
X
X      putw(tp->num_page, file);
X      for (p=0; p<tp->num_page; p++)
X     {
X     putw(tp->page[p].offset, file);
X     putw(tp->page[p].length, file);
X     putw(tp->page[p].margin, file);
X     }
X
X      /* write the help title */
X
X      putc((BYTE)tp->title_len, file);
X      fwrite(tp->title, 1, tp->title_len, file);
X
X      /* insert hot-link info & write the help text */
X
X      text = get_topic_text(tp);
X
X      if ( !(tp->flags & TF_DATA) )   /* don't process data topics... */
X     insert_real_link_info(text, tp->text_len);
X
X      putw(tp->text_len, file);
X      fwrite(text, 1, tp->text_len, file);
X
X      release_topic_text(tp, 0);  /* don't save the text even though        */
X                  /* insert_real_link_info() modified it    */
X                  /* because we don't access the info after */
X                  /* this.                    */
X
X      }
X   }
X
X
Xvoid write_help(char *fname)
X   {
X   FILE *hlp;
X
X   hlp = fopen(fname, "wb");
X
X   if (hlp == NULL)
X      fatal(0,"Cannot create .HLP file: \"%s\".", fname);
X
X   msg("Writing: %s", fname);
X
X   _write_help(hlp);
X
X   fclose(hlp);
X   }
X
X
X/*
X * print document stuff.
X */
X
X
Xtypedef struct
X   {
X
X   /*
X    * Note: Don't move these first three or pd_get_info will work not
X    *        correctly.
X    */
X
X   int        cnum;
X   int        tnum;
X   int        link_dest_warn;   /* = 0 */
X
X   FILE    *file;
X   int        margin;
X   int        start_of_line;
X   int        spaces;
X   } PRINT_DOC_INFO;
X
X
Xvoid printerc(PRINT_DOC_INFO *info, int c, int n)
X   {
X   while ( n-- > 0 )
X      {
X      if (c==' ')
X     ++info->spaces;
X
X      else if (c=='\n' || c=='\f')
X     {
X     info->start_of_line = 1;
X     info->spaces = 0;   /* strip spaces before a new-line */
X     putc(c, info->file);
X     }
X
X      else
X     {
X     if (info->start_of_line)
X        {
X        info->spaces += info->margin;
X        info->start_of_line = 0;
X        }
X
X     while (info->spaces > 0)
X        {
X        fputc(' ', info->file);
X        --info->spaces;
X        }
X
X     fputc(c, info->file);
X     }
X      }
X   }
X
X
Xvoid printers(PRINT_DOC_INFO *info, char far *s, int n)
X   {
X   if (n > 0)
X      {
X      while ( n-- > 0 )
X     printerc(info, *s++, 1);
X      }
X   else
X      {
X      while ( *s != '\0' )
X     printerc(info, *s++, 1);
X      }
X   }
X
X
Xint print_doc_output(int cmd, PD_INFO *pd, PRINT_DOC_INFO *info)
X   {
X   switch (cmd)
X      {
X      case PD_HEADING:
X     {
X     char buff[20];
X
X     info->margin = 0;
X     printers(info, "\n                     Fractint Version xx.xx                     Page ", 0);
X     sprintf(buff, "%d\n\n", pd->pnum);
X     printers(info, buff, 0);
X     info->margin = PAGE_INDENT;
X     return (1);
X     }
X
X      case PD_FOOTING:
X     info->margin = 0;
X     printerc(info, '\f', 1);
X     info->margin = PAGE_INDENT;
X     return (1);
X
X      case PD_PRINT:
X     printers(info, pd->s, pd->i);
X     return (1);
X
X      case PD_PRINTN:
X     printerc(info, *pd->s, pd->i);
X     return (1);
X
X      case PD_PRINT_SEC:
X     info->margin = TITLE_INDENT;
X     if (pd->id[0] != '\0')
X        {
X        printers(info, pd->id, 0);
X        printerc(info, ' ', 1);
X        }
X     printers(info, pd->title, 0);
X     printerc(info, '\n', 1);
X     info->margin = PAGE_INDENT;
X     return (1);
X
X      case PD_START_SECTION:
X      case PD_START_TOPIC:
X      case PD_SET_SECTION_PAGE:
X      case PD_SET_TOPIC_PAGE:
X      case PD_PERIODIC:
X     return (1);
X
X      default:
X     return (0);
X      }
X   }
X
X
Xvoid print_document(char *fname)
X   {
X   PRINT_DOC_INFO info;
X
X   if (num_contents == 0)
X      fatal(0,".SRC has no DocContents.");
X
X   msg("Printing to: %s", fname);
X
X   info.cnum = info.tnum = -1;
X   info.link_dest_warn = 0;
X
X   if ( (info.file = fopen(fname, "wt")) == NULL )
X      fatal(0,"Couldn't create \"%s\"", fname);
X
X   info.margin = PAGE_INDENT;
X   info.start_of_line = 1;
X   info.spaces = 0;
X
X   process_document((PD_FUNC)pd_get_info, (PD_FUNC)print_doc_output, &info);
X
X   fclose(info.file);
X   }
X
X
X/*
X * compiler status and memory usage report stuff.
X */
X
X
Xvoid report_memory(void)
X   {
X   long string = 0,   /* bytes in strings */
X        text   = 0,   /* bytes in topic text (stored on disk) */
X        data   = 0,   /* bytes in active data structure */
X        dead   = 0;   /* bytes in unused data structure */
X   int  ctr, ctr2;
X
X   for (ctr=0; ctr<num_topic; ctr++)
X      {
X      data   += sizeof(TOPIC);
X      string += topic[ctr].title_len;
X      text   += topic[ctr].text_len;
X      data   += topic[ctr].num_page * sizeof(PAGE);
X
X      dead   += (PAGE_ALLOC_SIZE-(topic[ctr].num_page%PAGE_ALLOC_SIZE)) * sizeof(PAGE);
X      }
X
X   for (ctr=0; ctr<num_link; ctr++)
X      {
X      data += sizeof(LINK);
X      string += strlen(a_link[ctr].name);
X      }
X
X   if (num_link > 0)
X      dead += (LINK_ALLOC_SIZE-(num_link%LINK_ALLOC_SIZE)) * sizeof(LINK);
X
X   for (ctr=0; ctr<num_label; ctr++)
X      {
X      data   += sizeof(LABEL);
X      string += strlen(label[ctr].name) + 1;
X      }
X
X   if (num_label > 0)
X      dead += (LABEL_ALLOC_SIZE-(num_label%LABEL_ALLOC_SIZE)) * sizeof(LABEL);
X
X   for (ctr=0; ctr<num_plabel; ctr++)
X      {
X      data   += sizeof(LABEL);
X      string += strlen(plabel[ctr].name) + 1;
X      }
X
X   if (num_plabel > 0)
X      dead += (LABEL_ALLOC_SIZE-(num_plabel%LABEL_ALLOC_SIZE)) * sizeof(LABEL);
X
X   for (ctr=0; ctr<num_contents; ctr++)
X      {
X      int t;
X
X      t = ( MAX_CONTENT_TOPIC - contents[ctr].num_topic ) *
X      ( sizeof(contents[0].is_label[0])   +
X        sizeof(contents[0].topic_name[0]) +
X        sizeof(contents[0].topic_num[0])     );
X      data += sizeof(CONTENT) - t;
X      dead += t;
X      string += strlen(contents[ctr].id) + 1;
X      string += strlen(contents[ctr].name) + 1;
X      for (ctr2=0; ctr2<contents[ctr].num_topic; ctr2++)
X     string += strlen(contents[ctr].topic_name[ctr2]) + 1;
X      }
X
X   dead += (CONTENTS_ALLOC_SIZE-(num_contents%CONTENTS_ALLOC_SIZE)) * sizeof(CONTENT);
X
X   printf("\n");
X   printf("Memory Usage:\n");
X   printf("%8ld Bytes in buffers.\n", (long)BUFFER_SIZE);
X   printf("%8ld Bytes in strings.\n", string);
X   printf("%8ld Bytes in data.\n", data);
X   printf("%8ld Bytes in dead space.\n", dead);
X   printf("--------\n");
X   printf("%8ld Bytes total.\n", (long)BUFFER_SIZE+string+data+dead);
X   printf("\n");
X   printf("Disk Usage:\n");
X   printf("%8ld Bytes in topic text.\n", text);
X   }
X
X
Xvoid report_stats(void)
X   {
X   int  pages = 0;
X   int        t;
X
X   for (t=0; t<num_topic; t++)
X      pages += topic[t].num_page;
X
X   printf("\n");
X   printf("Statistics:\n");
X   printf("%8d Topics\n", num_topic);
X   printf("%8d Links\n", num_link);
X   printf("%8d Labels\n", num_label);
X   printf("%8d Private labels\n", num_plabel);
X   printf("%8d Table of contents (DocContent) entries\n", num_contents);
X   printf("%8d Online help pages\n", pages);
X   printf("%8d Document pages\n", num_doc_pages);
X   }
X
X
X/*
X * add/delete help from .EXE functions.
X */
X
X
Xvoid add_hlp_to_exe(char *hlp_fname, char *exe_fname)
X   {
X   int                exe,   /* handles */
X                hlp;
X   long             len,
X                count;
X   int                size;
X   struct help_sig_info hs;
X
X   if ( (exe=open(exe_fname, O_RDWR|O_BINARY)) == -1 )
X      fatal(0,"Unable to open \"%s\"", exe_fname);
X
X   if ( (hlp=open(hlp_fname, O_RDONLY|O_BINARY)) == -1 )
X      fatal(0,"Unable to open \"%s\"", hlp_fname);
X
X   msg("Appending %s to %s", hlp_fname, exe_fname);
X
X   /* first, check and see if any help is currently installed */
X
X   lseek(exe, filelength(exe) - sizeof(struct help_sig_info), SEEK_SET);
X
X   read(exe, (char *)&hs, 10);
X
X   if ( hs.sig == HELP_SIG )
X      warn(0,"Overwriting previous help. (Version=%d)", hs.version);
X   else
X      hs.base = filelength(exe);
X
X   /* now, let's see if their help file is for real (and get the version) */
X
X   read(hlp, (char *)&hs, sizeof(long)+sizeof(int));
X
X   if (hs.sig != HELP_SIG )
X      fatal(0,"Help signature not found in %s", hlp_fname);
X
X   msg("Help file %s Version=%d", hlp_fname, hs.version);
X
X   /* append the help stuff, overwriting old help (if any) */
X
X   lseek(exe, hs.base, SEEK_SET);
X
X   len = filelength(hlp) - sizeof(long) - sizeof(int); /* adjust for the file signature & version */
X
X   for (count=0; count<len; )
X      {
X      size = (int) min((long)BUFFER_SIZE, len-count);
X      read(hlp, buffer, size);
X      write(exe, buffer, size);
X      count += size;
X      }
X
X   /* add on the signature, version and offset */
X
X   write(exe, (char *)&hs, 10);
X
X   chsize(exe, lseek(exe,0L,SEEK_CUR));/* truncate if old help was longer */
X
X   close(exe);
X   close(hlp);
X   }
X
X
Xvoid delete_hlp_from_exe(char *exe_fname)
X   {
X   int     exe;   /* file handle */
X   struct help_sig_info hs;
X
X   if ( (exe=open(exe_fname, O_RDWR|O_BINARY)) == -1 )
X      fatal(0,"Unable to open \"%s\"", exe_fname);
X
X   msg("Deleting help from %s", exe_fname);
X
X   /* see if any help is currently installed */
X
X#ifndef XFRACT
X   lseek(exe, filelength(exe) - 10, SEEK_SET);
X   read(exe, (char *)&hs, 10);
X#else
X   lseek(exe, filelength(exe) - 12, SEEK_SET);
X   read(exe, (char *)&hs, 12);
X#endif
X
X   if ( hs.sig == HELP_SIG )
X      {
X      chsize(exe, hs.base);   /* truncate at the start of the help */
X      close(exe);
X      }
X   else
X      {
X      close(exe);
X      fatal(0,"No help found in %s", exe_fname);
X      }
X   }
X
X
X/*
X * command-line parser, etc.
X */
X
X
X#define MODE_COMPILE 1
X#define MODE_PRINT   2
X#define MODE_APPEND  3
X#define MODE_DELETE  4
X
X
Xint main(int argc, char *argv[])
X   {
X   int      show_stats = 0,
X      show_mem   = 0;
X   int      mode         = 0;
X
X   char **arg;
X   char   fname1[81],
X      fname2[81];
X   char   swappath[81];
X
X   fname1[0] = fname2[0] = swappath[0] = 0;
X
X   printf("HC - FRACTINT Help Compiler.\n\n");
X
X   buffer = malloc(BUFFER_SIZE);
X
X   if (buffer == NULL)
X      fatal(0,"Not enough memory to allocate buffer.");
X
X   for (arg= &argv[1]; argc>1; argc--, arg++)
X      {
X      switch ( (*arg)[0] )
X     {
X     case '/':
X     case '-':
X        switch ( (*arg)[1] )
X           {
X           case 'c':
X          if (mode == 0)
X             mode = MODE_COMPILE;
X          else
X             fatal(0,"Cannot have /c with /a, /d or /p");
X          break;
X
X           case 'a':
X          if (mode == 0)
X             mode = MODE_APPEND;
X          else
X             fatal(0,"Cannot have /a with /c, /d or /p");
X          break;
X
X           case 'd':
X          if (mode == 0)
X             mode = MODE_DELETE;
X          else
X             fatal(0,"Cannot have /d with /c, /a or /p");
X          break;
X
X           case 'p':
X          if (mode == 0)
X             mode = MODE_PRINT;
X          else
X             fatal(0,"Cannot have /p with /c, /a or /d");
X          break;
X
X           case 'm':
X          if (mode == MODE_COMPILE)
X             show_mem = 1;
X          else
X             fatal(0,"/m switch allowed only when compiling (/c)");
X          break;
X
X           case 's':
X          if (mode == MODE_COMPILE)
X             show_stats = 1;
X          else
X             fatal(0,"/s switch allowed only when compiling (/c)");
X          break;
X
X           case 'r':
X          if (mode == MODE_COMPILE || mode == MODE_PRINT)
X             strcpy(swappath, (*arg)+2);
X          else
X             fatal(0,"/r switch allowed when compiling (/c) or printing (/p)");
X          break;
X
X           case 'q':
X          quiet_mode = 1;
X          break;
X
X           default:
X          fatal(0,"Bad command-line switch /%c", (*arg)[1]);
X          break;
X           }
X        break;
X
X     default:   /* assume it is a fname */
X        if (fname1[0] == '\0')
X           strcpy(fname1, *arg);
X        else if (fname2[0] == '\0')
X           strcpy(fname2, *arg);
X        else
X           fatal(0,"Unexpected command-line argument \"%s\"", *arg);
X        break;
X     } /* switch */
X      } /* for */
X
X   strupr(fname1);
X   strupr(fname2);
X   strupr(swappath);
X
X   switch (mode)
X      {
X      case 0:
X         printf( "To compile a .SRC file:\n");
X         printf( "      HC /c [/s] [/m] [/r[path]] [src_file]\n");
X         printf( "         /s       = report statistics.\n");
X         printf( "         /m       = report memory usage.\n");
X         printf( "         /r[path] = set swap file path.\n");
X         printf( "         src_file = .SRC file.  Default is \"%s\"\n", DEFAULT_SRC_FNAME);
X         printf( "To print a .SRC file:\n");
X         printf( "      HC /p [/r[path]] [src_file] [out_file]\n");
X         printf( "         /r[path] = set swap file path.\n");
X         printf( "         src_file = .SRC file.  Default is \"%s\"\n", DEFAULT_SRC_FNAME);
X         printf( "         out_file = Filename to print to. Default is \"%s\"\n",
X         DEFAULT_DOC_FNAME);
X         printf( "To append a .HLP file to an .EXE file:\n");
X         printf( "      HC /a [hlp_file] [exe_file]\n");
X         printf( "         hlp_file = .HLP file.  Default is \"%s\"\n", DEFAULT_HLP_FNAME);
X         printf( "         exe_file = .EXE file.  Default is \"%s\"\n", DEFAULT_EXE_FNAME);
X         printf( "To delete help info from an .EXE file:\n");
X         printf( "      HC /d [exe_file]\n");
X         printf( "         exe_file = .EXE file.  Default is \"%s\"\n", DEFAULT_EXE_FNAME);
X         printf( "\n");
X         printf( "Use \"/q\" for quiet mode. (No status messages.)\n");
X     break;
X
X      case MODE_COMPILE:
X     if (fname2[0] != '\0')
X        fatal(0,"Unexpected command-line argument \"%s\"", fname2);
X
X     strcpy(src_fname, (fname1[0]=='\0') ? DEFAULT_SRC_FNAME : fname1);
X
X     strcat(swappath, SWAP_FNAME);
X
X     if ( (swapfile=fopen(swappath, "w+b")) == NULL )
X        fatal(0,"Cannot create swap file \"%s\"", swappath);
X     swappos = 0;
X
X     read_src(src_fname);
X
X     if (hdr_fname[0] == '\0')
X        error(0,"No .H file defined.  (Use \"~HdrFile=\")");
X     if (hlp_fname[0] == '\0')
X        error(0,"No .HLP file defined.  (Use \"~HlpFile=\")");
X     if (version == -1)
X        warn(0,"No help version has been defined.  (Use \"~Version=\")");
X
X     /* order of these is very important... */
X
X     make_hot_links();  /* do even if errors since it may report */
X                /* more... */
X
X     if ( !errors )     paginate_online();
X     if ( !errors )     paginate_document();
X     if ( !errors )     calc_offsets();
X     if ( !errors )     sort_labels();
X     if ( !errors )     write_hdr(hdr_fname);
X     if ( !errors )     write_help(hlp_fname);
X
X     if ( show_stats )
X        report_stats();
X
X     if ( show_mem )
X        report_memory();
X
X     if ( errors || warnings )
X        report_errors();
X
X     fclose(swapfile);
X     remove(swappath);
X
X     break;
X
X      case MODE_PRINT:
X     strcpy(src_fname, (fname1[0]=='\0') ? DEFAULT_SRC_FNAME : fname1);
X
X     strcat(swappath, SWAP_FNAME);
X
X     if ( (swapfile=fopen(swappath, "w+b")) == NULL )
X        fatal(0,"Cannot create swap file \"%s\"", swappath);
X     swappos = 0;
X
X     read_src(src_fname);
X
X     make_hot_links();
X
X     if ( !errors )     paginate_document();
X     if ( !errors )     print_document( (fname2[0]=='\0') ? DEFAULT_DOC_FNAME : fname2 );
X
X     if ( errors || warnings )
X        report_errors();
X
X     fclose(swapfile);
X     remove(swappath);
X
X     break;
X
X      case MODE_APPEND:
X     add_hlp_to_exe( (fname1[0]=='\0') ? DEFAULT_HLP_FNAME : fname1,
X             (fname2[0]=='\0') ? DEFAULT_EXE_FNAME : fname2);
X     break;
X
X      case MODE_DELETE:
X     if (fname2[0] != '\0')
X        fatal(0,"Unexpected argument \"%s\"", fname2);
X     delete_hlp_from_exe((fname1[0]=='\0') ? DEFAULT_EXE_FNAME : fname1);
X     break;
X      }
X
X   free(buffer);
X
X   return ( errors );   /* return the number of errors */
X   }
X
X
SHAR_EOF
$TOUCH -am 1028230093 hc.c &&
chmod 0644 hc.c ||
echo "restore of hc.c failed"
set `wc -c hc.c`;Wc_c=$1
if test "$Wc_c" != "83237"; then
    echo original size 83237, current size $Wc_c
fi
# ============= hcmplx.c ==============
echo "x - extracting hcmplx.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > hcmplx.c &&
X/* some hyper complex functions */
X#include "fractint.h"
X#include "mpmath.h"
X
Xvoid HComplexMult(_HCMPLX *arg1, _HCMPLX *arg2, _HCMPLX *out)
X{
X    /* it is possible to reoganize this code and reduce the multiplies
X        from 16 to 10, but on my 486 it is SLOWER !!! so I left it
X        like this - Tim Wegner */
X    out->x = arg1->x * arg2->x - arg1->y * arg2->y
X           - arg1->z * arg2->z + arg1->t * arg2->t;
X    out->y = arg1->y * arg2->x + arg1->x * arg2->y
X           - arg1->t * arg2->z - arg1->z * arg2->t;
X    out->z = arg1->z * arg2->x - arg1->t * arg2->y
X           + arg1->x * arg2->z - arg1->y * arg2->t;
X    out->t = arg1->t * arg2->x + arg1->z * arg2->y
X           + arg1->y * arg2->z + arg1->x * arg2->t;
X}
X
Xvoid HComplexSqr(_HCMPLX *arg, _HCMPLX *out)
X{
X    out->x = arg->x * arg->x - arg->y * arg->y
X           - arg->z * arg->z + arg->t * arg->t;
X    out->y = 2 * arg->x * arg->y - 2 * arg->z * arg->t;
X    out->z = 2 * arg->z * arg->x - 2 * arg->t * arg->y;
X    out->t = 2 * arg->t * arg->x + 2 * arg->z * arg->y;
X}
X
Xint HComplexInv(_HCMPLX *arg, _HCMPLX *out)
X{
X   double det, mod, xt_minus_yz;
X
X   det = (sqr(arg->x - arg->t) + sqr(arg->y + arg->z))*
X           (sqr(arg->x + arg->t) + sqr(arg->y - arg->z));
X
X   if(det == 0.0)
X      return(-1);
X   mod = sqr(arg->x) + sqr(arg->y) + sqr(arg->z) + sqr(arg->t);
X   xt_minus_yz = arg->x * arg->t - arg->y * arg->z;
X
X   out->x = ( arg->x * mod - 2 * arg->t * xt_minus_yz)/det;
X   out->y = (-arg->y * mod - 2 * arg->z * xt_minus_yz)/det;
X   out->z = (-arg->z * mod - 2 * arg->y * xt_minus_yz)/det;
X   out->t = ( arg->t * mod - 2 * arg->x * xt_minus_yz)/det;
X   return(0);
X}
X
Xvoid HComplexAdd(_HCMPLX *arg1, _HCMPLX *arg2, _HCMPLX *out)
X{
X    out->x = arg1->x + arg2->x;
X    out->y = arg1->y + arg2->y;
X    out->z = arg1->z + arg2->z;
X    out->t = arg1->t + arg2->t;
X}
X
Xvoid HComplexSub(_HCMPLX *arg1, _HCMPLX *arg2, _HCMPLX *out)
X{
X    out->x = arg1->x - arg2->x;
X    out->y = arg1->y - arg2->y;
X    out->z = arg1->z - arg2->z;
X    out->t = arg1->t - arg2->t;
X}
X
Xvoid HComplexMinus(_HCMPLX *arg1, _HCMPLX *out)
X{
X    out->x = -arg1->x;
X    out->y = -arg1->y;
X    out->z = -arg1->z;
X    out->t = -arg1->t;
X}
X
X/* extends the unary function f to *h1 */
Xvoid HComplexTrig0(_HCMPLX *h, _HCMPLX *out)
X{
X    /* This is the whole beauty of Hypercomplex numbers - *ANY* unary
X       complex valued function of a complex variable can easily
X       be generalized to hypercomplex numbers */
X
X    _CMPLX a,b, resulta,resultb;
X    double t,s;
X
X    /* convert to duplex form */
X    a.x = h->x - h->t;
X    a.y = h->y + h->z;
X    b.x = h->x + h->t;
X    b.y = h->y - h->z;
X
X    /* apply function to each part */
X    CMPLXtrig0(a,resulta);
X    CMPLXtrig0(b,resultb);
X
X    /* convert back */
X    out->x =  (resulta.x + resultb.x)/2;
X    out->y =  (resulta.y + resultb.y)/2;
X    out->z =  (resulta.y - resultb.y)/2;
X    out->t =  (resultb.x - resulta.x)/2;
X}
SHAR_EOF
$TOUCH -am 1028230093 hcmplx.c &&
chmod 0644 hcmplx.c ||
echo "restore of hcmplx.c failed"
set `wc -c hcmplx.c`;Wc_c=$1
if test "$Wc_c" != "2946"; then
    echo original size 2946, current size $Wc_c
fi
# ============= help.c ==============
echo "x - extracting help.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > help.c &&
X/*
X * help.c
X *
X * This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X *
X *
X * Revision history:
X *
X *   2-26-90  EAN     Initial version.
X *
X *
X */
X
X
X#ifndef TEST /* kills all those assert macros in production version */
X#define NDEBUG
X#endif
X
X#define INCLUDE_COMMON    /* include common code in helpcom.h */
X
X
X#include <stdio.h>
X#include <stdlib.h>
X#ifndef XFRACT
X#include <io.h>
X#include <dos.h>
X#endif
X#include <fcntl.h>
X#include <string.h>
X#include <time.h>
X#include <assert.h>
X#include <sys/types.h>
X#include <sys/stat.h>
X#ifdef XFRACT
X#include <unistd.h>
X#endif
X#include "fractint.h"
X#include "helpcom.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X
X#define MAX_HIST       16         /* number of pages we'll remember */
X
X#define ALT_F1         1104
X#define BACK_TAB     1015
X#define BACKSPACE        8
X
X#define ACTION_CALL        0         /* values returned by help_topic() */
X#define ACTION_PREV        1
X#define ACTION_PREV2        2         /* special - go back two topics */
X#define ACTION_INDEX        3
X#define ACTION_QUIT        4
X
X#define F_HIST            (1<<0)   /* flags for help_topic() */
X#define F_INDEX         (1<<1)
X
X#define MAX_PAGE_SIZE        (80*25)  /* no page of text may be larger */
X
X#define TEXT_START_ROW        2         /* start print the help text here */
X
X
Xtypedef struct
X   {
X   BYTE r, c;
X   int         width;
X   unsigned     offset;
X   int         topic_num;
X   unsigned     topic_off;
X   } LINK;
X
X
Xtypedef struct
X   {
X   int        topic_num;
X   unsigned topic_off;
X   } LABEL;
X
X
Xtypedef struct
X   {
X   unsigned     offset;
X   unsigned     len;
X   int         margin;
X   } PAGE;
X
X
Xtypedef struct
X   {
X   int        topic_num;
X   unsigned topic_off;
X   int        link;
X   } HIST;
X
X
Xstruct help_sig_info
X   {
X   unsigned long sig;
X   int         version;
X   unsigned long base;       /* only if added to fractint.exe */
X   } ;
X
X
Xvoid print_document(char *outfname, int (*msg_func)(int,int), int save_extraseg );
Xstatic int print_doc_msg_func(int pnum, int num_pages);
X
X
X
Xvoid help_overlay(void) { }
X
X
X
X/* stuff from fractint */
X
Xextern int  lookatmouse;
Xextern long timer_start;
Xextern int  helpmode;
Xextern int  text_type;     /* 0=real color text, 1=640x200x2, 2=??mono?? */
Xextern int  textcbase;
Xextern int  textrbase;
Xextern SEGTYPE  extraseg;
Xextern int  release;
X
Xint  putstringcenter (int row, int col, int width, int attr, char far *msg);
Xvoid helptitle         (void);
Xvoid stackscreen     (void);
Xvoid unstackscreen   (void);
Xvoid findpath         (char *filename, char *path);
X
X
Xstatic int          help_file = -1; /* help file handle */
Xstatic long          base_off;       /* offset to help info in help file */
Xstatic int          max_links;      /* max # of links in any page */
Xstatic int          max_pages;      /* max # of pages in any topic */
Xstatic int          num_label;      /* number of labels */
Xstatic int          num_topic;      /* number of topics */
Xstatic int          curr_hist = 0;  /* current pos in history */
X
X/* these items alloc'ed in init_help... */
X
Xstatic long     far *topic_offset;       /* 4*num_topic */
Xstatic LABEL     far *label;           /* 4*num_label */
Xstatic HIST     far *hist;           /* 6*MAX_HIST (96 bytes) */
X
X/* these items alloc'ed only while help is active... */
X
Xstatic char      far *buffer;         /* MAX_PAGE_SIZE (2048 bytes) */
Xstatic LINK      far *link_table;     /* 10*max_links */
Xstatic PAGE      far *page_table;     /* 4*max_pages  */
X
X
Xstatic void help_seek(long pos)
X   {
X   lseek(help_file, base_off+pos, SEEK_SET);
X   }
X
X
Xstatic void displayc(int row, int col, int color, int ch)
X   {
X#ifndef XFRACT
X   static char *s = "?";
X#else
X   static char s[] = "?";
X#endif
X
X   if (text_type == 1)     /* if 640x200x2 mode */
X      {
X      /*
X       * This is REALLY ugly, but it works.  Non-current links (ones that
X       * would be bold if 640x200 supported it) are in upper-case and the
X       * current item is inversed.
X       *
X       */
X
X      if (color & INVERSE)
X     color = (signed int)INVERSE;
X      else if (color & BRIGHT)
X     {
X     color = 0;   /* normal */
X     if (ch>='a' && ch<='z')
X        ch += 'A' - 'a';
X     }
X      else
X     color = 0;   /* normal */
X      }
X
X   s[0] = ch;
X   putstring(row, col, color, s);
X   }
X
X
Xstatic void display_text(int row, int col, int color, char far *text, unsigned len)
X   {
X   while (len-- > 0)
X      {
X      if (*text == CMD_LITERAL)
X     {
X     ++text;
X     --len;
X     }
X      displayc(row, col++, color, *text++);
X      }
X   }
X
X
Xstatic void display_parse_text(char far *text, unsigned len, int start_margin, int *num_link, LINK far *link)
X   {
X   char far  *curr;
X   int          row, col;
X   int          tok;
X   int          size,
X          width;
X
X   textcbase = SCREEN_INDENT;
X   textrbase = TEXT_START_ROW;
X
X   curr = text;
X   row = 0;
X   col = 0;
X
X   size = width = 0;
X
X   if (start_margin >= 0)
X      tok = TOK_PARA;
X   else
X      tok = -1;
X
X   while ( 1 )
X      {
X      switch ( tok )
X     {
X     case TOK_PARA:
X        {
X        int indent,
X        margin;
X
X        if (size > 0)
X           {
X           ++curr;
X           indent = *curr++;
X           margin = *curr++;
X           len  -= 3;
X           }
X        else
X           {
X           indent = start_margin;
X           margin = start_margin;
X           }
X
X        col = indent;
X
X        while (1)
X           {
X           tok = find_token_length(ONLINE, curr, len, &size, &width);
X
X           if (tok == TOK_DONE || tok == TOK_NL || tok == TOK_FF )
X          break;
X
X           if (tok == TOK_PARA)
X          {
X          col = 0;   /* fake a new-line */
X          row++;
X          break;
X          }
X
X           if (tok == TOK_XONLINE || tok == TOK_XDOC)
X          {
X          curr += size;
X          len  -= size;
X          continue;
X          }
X
X           /* now tok is TOK_SPACE or TOK_LINK or TOK_WORD */
X
X           if (col+width > SCREEN_WIDTH)
X          {         /* go to next line... */
X          col = margin;
X          ++row;
X
X          if ( tok == TOK_SPACE )
X             width = 0;   /* skip spaces at start of a line */
X          }
X
X           if (tok == TOK_LINK)
X          {
X          display_text(row, col, C_HELP_LINK, curr+1+3*sizeof(int), width);
X          if (num_link != NULL)
X             {
X             link[*num_link].r           = row;
X             link[*num_link].c           = col;
X                     link[*num_link].topic_num = getint(curr+1);
X                     link[*num_link].topic_off = getint(curr+1+sizeof(int));
X                     link[*num_link].offset    = (unsigned) ((curr+1+3*sizeof(int)) - text);
X             link[*num_link].width     = width;
X             ++(*num_link);
X             }
X          }
X           else if (tok == TOK_WORD )
X          display_text(row, col, C_HELP_BODY, curr, width);
X
X           col += width;
X           curr += size;
X           len -= size;
X           }
X
X        width = size = 0;
X        break;
X        }
X
X     case TOK_CENTER:
X        col = find_line_width(ONLINE, curr, len);
X        col = (SCREEN_WIDTH-col)/2;
X        if (col < 0)
X           col = 0;
X        break;
X
X     case TOK_NL:
X        col = 0;
X        ++row;
X        break;
X
X     case TOK_LINK:
X            display_text(row, col, C_HELP_LINK, curr+1+3*sizeof(int), width);
X        if (num_link != NULL)
X           {
X           link[*num_link].r     = row;
X           link[*num_link].c     = col;
X               link[*num_link].topic_num = getint(curr+1);
X               link[*num_link].topic_off = getint(curr+1+sizeof(int));
X               link[*num_link].offset    = (unsigned) ((curr+1+3*sizeof(int)) - text);
X           link[*num_link].width     = width;
X           ++(*num_link);
X           }
X        break;
X
X     case TOK_XONLINE:  /* skip */
X     case TOK_FF:        /* ignore */
X     case TOK_XDOC:     /* ignore */
X     case TOK_DONE:
X     case TOK_SPACE:
X        break;
X
X     case TOK_WORD:
X        display_text(row, col, C_HELP_BODY, curr, width);
X        break;
X     } /* switch */
X
X      curr += size;
X      len  -= size;
X      col  += width;
X
X      if (len == 0)
X     break;
X
X      tok = find_token_length(ONLINE, curr, len, &size, &width);
X      } /* while */
X
X   textcbase = 0;
X   textrbase = 0;
X   }
X
X
Xstatic void color_link(LINK far *link, int color)
X   {
X   textcbase = SCREEN_INDENT;
X   textrbase = TEXT_START_ROW;
X
X   if (text_type == 1)     /* if 640x200x2 mode */
X      display_text(link->r, link->c, color, buffer+link->offset, link->width);
X   else
X      setattr(link->r, link->c, color, link->width);
X
X   textcbase = 0;
X   textrbase = 0;
X   }
X
X
X
X/* #define PUT_KEY(name, descrip) putstring(-1,-1,C_HELP_INSTR_KEYS,name), putstring(-1,-1,C_HELP_INSTR," "descrip"  ") */
X#ifndef XFRACT
X#define PUT_KEY(name, descrip) putstring(-1,-1,C_HELP_INSTR,name); putstring(-1,-1,C_HELP_INSTR,":"descrip"  ")
X#else
X#define PUT_KEY(name, descrip) putstring(-1,-1,C_HELP_INSTR,name);\
Xputstring(-1,-1,C_HELP_INSTR,":");\
Xputstring(-1,-1,C_HELP_INSTR,descrip);\
Xputstring(-1,-1,C_HELP_INSTR,"  ")
X#endif
X
X
Xstatic void helpinstr(void)
X   {
X   int ctr;
X
X   for (ctr=0; ctr<80; ctr++)
X     putstring(24, ctr, C_HELP_INSTR, " ");
X
X   movecursor(24, 1);
X   PUT_KEY("F1",               "Index");
X#ifndef XFRACT
X   PUT_KEY("\030\031\033\032", "Select");
X#else
X   PUT_KEY("K J H L", "Select");
X#endif
X   PUT_KEY("Enter",            "Go to");
X   PUT_KEY("Backspace",        "Last topic");
X   PUT_KEY("Escape",           "Exit help");
X   }
X
X
Xstatic void printinstr(void)
X   {
X   int ctr;
X
X   for (ctr=0; ctr<80; ctr++)
X     putstring(24, ctr, C_HELP_INSTR, " ");
X
X   movecursor(24, 1);
X   PUT_KEY("Escape", "Abort");
X   }
X
X
X#undef PUT_KEY
X
X
Xstatic void display_page(char far *title, char far *text, unsigned text_len, int page, int num_pages, int start_margin, int *num_link, LINK far *link)
X   {
X   char temp[9];
X
X   helptitle();
X   helpinstr();
X   setattr(2, 0, C_HELP_BODY, 80*22);
X   putstringcenter(1, 0, 80, C_HELP_HDG, title);
X   sprintf(temp, "%2d of %d", page+1, num_pages);
X#ifndef XFRACT
X   putstring(1, 79-(6 + ((num_pages>=10)?2:1)), C_HELP_INSTR, temp);
X#else
X   /* Some systems (Ultrix) mess up if you write to column 80 */
X   putstring(1, 78-(6 + ((num_pages>=10)?2:1)), C_HELP_INSTR, temp);
X#endif
X
X   if (text != NULL)
X      display_parse_text(text, text_len, start_margin, num_link, link);
X
X   movecursor(25, 80);     /* hide cursor */
X   }
X
X
X
X/*
X * int overlap(int a, int a2, int b, int b2);
X *
X * If a, a2, b, and b2 are points on a line, this function returns the
X * distance of intersection between a-->a2 and b-->b2.    If there is no
X * intersection between the lines this function will return a negative number
X * representing the distance between the two lines.
X *
X * There are six possible cases of intersection between the lines:
X *
X *            a              a2
X *            |              |
X *     b     b2    |              |       b     b2
X *     |---(1)---|    |              |       |---(2)---|
X *            |              |
X *        b    |     b2      b       |      b2
X *        |------(3)----|       |------(4)-----|
X *            |              |
X *         b    |              |   b2
X *         |------+--------(5)----------+---|
X *            |              |
X *            |     b       b2      |
X *            |     |--(6)--|       |
X *            |              |
X *            |              |
X *
X */
X
X
Xstatic int overlap(int a, int a2, int b, int b2)
X   {
X   if ( b < a )
X      {
X      if ( b2 >= a2 )
X     return ( a2 - a );           /* case (5) */
X
X      return ( b2 - a );           /* case (1), case (3) */
X      }
X
X   if ( b2 <= a2 )
X      return ( b2 - b );           /* case (6) */
X
X   return ( a2 - b );               /* case (2), case (4) */
X   }
X
X
Xstatic int dist(int a, int b)
X   {
X   int t = a - b;
X
X   return (abs(t));
X   }
X
X
X#ifdef __TURBOC__
X#   pragma warn -def /* turn off "Possible use before definition" warning */
X#endif
X
X
X
X
Xstatic int find_link_updown(LINK far *link, int num_link, int curr_link, int up)
X   {
X   int         ctr,
X         curr_c2,
X         best_overlap,
X         temp_overlap;
X   LINK far *curr,
X    far *temp,
X    far *best;
X   int         temp_dist;
X
X   curr    = &link[curr_link];
X   best    = NULL;
X   curr_c2 = curr->c + curr->width - 1;
X
X   for (ctr=0, temp=link; ctr<num_link; ctr++, temp++)
X      {
X      if ( ctr != curr_link &&
X       ( (up && temp->r < curr->r) || (!up && temp->r > curr->r) ) )
X     {
X     temp_overlap = overlap(curr->c, curr_c2, temp->c, temp->c+temp->width-1);
X     /* if >= 3 lines between, prioritize on vertical distance: */
X     if ((temp_dist = dist(temp->r, curr->r)) >= 4)
X        temp_overlap -= temp_dist * 100;
X
X     if (best != NULL)
X        {
X        if ( best_overlap >= 0 && temp_overlap >= 0 )
X           {     /* if they're both under curr set to closest in y dir */
X           if ( dist(best->r, curr->r) > temp_dist )
X          best = NULL;
X           }
X        else
X           {
X           if ( best_overlap < temp_overlap )
X          best = NULL;
X           }
X        }
X
X     if (best == NULL)
X        {
X        best = temp;
X        best_overlap = temp_overlap;
X        }
X     }
X      }
X
X   return ( (best==NULL) ? -1 : (int)(best-link) );
X   }
X
X
Xstatic int find_link_leftright(LINK far *link, int num_link, int curr_link, int left)
X   {
X   int         ctr,
X         curr_c2,
X         best_c2,
X         temp_c2,
X         best_dist,
X         temp_dist;
X   LINK far *curr,
X    far *temp,
X    far *best;
X
X   curr    = &link[curr_link];
X   best    = NULL;
X   curr_c2 = curr->c + curr->width - 1;
X
X   for (ctr=0, temp=link; ctr<num_link; ctr++, temp++)
X      {
X      temp_c2 = temp->c + temp->width - 1;
X
X      if ( ctr != curr_link &&
X       ( (left && temp_c2 < curr->c) || (!left && temp->c > curr_c2) ) )
X     {
X     temp_dist = dist(curr->r, temp->r);
X
X     if (best != NULL)
X        {
X        if ( best_dist == 0 && temp_dist == 0 )  /* if both on curr's line... */
X           {
X           if ( (  left && dist(curr->c, best_c2) > dist(curr->c, temp_c2) ) ||
X            ( !left && dist(curr_c2, best->c) > dist(curr_c2, temp->c) ) )
X          best = NULL;
X           }
X        else
X           {
X           if ( best_dist >= temp_dist )   /* if temp is closer... */
X          best = NULL;
X           }
X        } /* if (best...) */
X
X     if (best == NULL)
X        {
X        best      = temp;
X        best_dist = temp_dist;
X        best_c2   = temp_c2;
X        }
X     }
X      } /* for */
X
X   return ( (best==NULL) ? -1 : (int)(best-link) );
X   }
X
X
X#ifdef __TURBOC__
X#   pragma warn .def   /* back to default */
X#   pragma warn -par   /* now turn off "Parameter not used" warning */
X#endif
X
X
Xstatic int find_link_key(LINK far *link, int num_link, int curr_link, int key)
X   {
X   switch (key)
X      {
X      case TAB:      return ( (curr_link>=num_link-1) ? -1 : curr_link+1 );
X      case BACK_TAB: return ( (curr_link<=0)          ? -1 : curr_link-1 );
X      default:         assert(0);  return (-1);
X      }
X   }
X
X
X#ifdef __TURBOC__
X#   pragma warn .par /* back to default */
X#endif
X
X
Xstatic int do_move_link(LINK far *link, int num_link, int *curr, int (*f)(LINK far *,int,int,int), int val)
X   {
X   int t;
X
X   if (num_link > 1)
X      {
X      if ( f == NULL )
X     t = val;
X      else
X     t = (*f)(link, num_link, *curr, val);
X
X      if ( t >= 0 && t != *curr )
X     {
X     color_link(&link[*curr], C_HELP_LINK);
X     *curr = t;
X     color_link(&link[*curr], C_HELP_CURLINK);
X     return (1);
X     }
X      }
X
X   return (0);
X   }
X
X
Xstatic int help_topic(HIST *curr, HIST *next, int flags)
X   {
X   int         len;
X   int         key;
X   int         num_pages;
X   int         num_link;
X   int         page;
X   int         curr_link;
X   char      title[81];
X   long      where;
X   int         draw_page;
X   int         action;
X   BYTE ch;
X
X   where     = topic_offset[curr->topic_num]+sizeof(int); /* to skip flags */
X   curr_link = curr->link;
X
X   help_seek(where);
X
X   read(help_file, (char *)&num_pages, sizeof(int));
X   assert(num_pages>0 && num_pages<=max_pages);
X
X   farread(help_file, (char far *)page_table, 3*sizeof(int)*num_pages);
X
X   read(help_file, &ch, 1);
X   len = ch;
X   assert(len<81);
X   read(help_file, (char *)title, len);
X   title[len] = '\0';
X
X   where += sizeof(int) + num_pages*3*sizeof(int) + 1 + len + sizeof(int);
X
X   for(page=0; page<num_pages; page++)
X      if (curr->topic_off >= page_table[page].offset &&
X      curr->topic_off <  page_table[page].offset+page_table[page].len )
X     break;
X
X   assert(page < num_pages);
X
X   action = -1;
X   draw_page = 2;
X
X   do
X      {
X      if (draw_page)
X     {
X     help_seek(where+page_table[page].offset);
X     farread(help_file, buffer, page_table[page].len);
X
X     num_link = 0;
X     display_page(title, buffer, page_table[page].len, page, num_pages,
X              page_table[page].margin, &num_link, link_table);
X
X     if (draw_page==2)
X        {
X        assert(num_link<=0 || (curr_link>=0 && curr_link<num_link));
X        }
X     else if (draw_page==3)
X        curr_link = num_link - 1;
X     else
X        curr_link = 0;
X
X     if (num_link > 0)
X        color_link(&link_table[curr_link], C_HELP_CURLINK);
X
X     draw_page = 0;
X     }
X
X      key = getakey();
X
X      switch(key)
X     {
X     case PAGE_DOWN:
X        if (page<num_pages-1)
X           {
X           page++;
X           draw_page = 1;
X           }
X        break;
X
X     case PAGE_UP:
X        if (page>0)
X           {
X           page--;
X           draw_page = 1;
X           }
X        break;
X
X     case HOME:
X        if ( page != 0 )
X           {
X           page = 0;
X           draw_page = 1;
X           }
X        else
X           do_move_link(link_table, num_link, &curr_link, NULL, 0);
X        break;
X
X     case END:
X        if ( page != num_pages-1 )
X           {
X           page = num_pages-1;
X           draw_page = 3;
X           }
X        else
X           do_move_link(link_table, num_link, &curr_link, NULL, num_link-1);
X        break;
X
X     case TAB:
X        if ( !do_move_link(link_table, num_link, &curr_link, find_link_key, key) &&
X         page<num_pages-1 )
X           {
X           ++page;
X           draw_page = 1;
X           }
X        break;
X
X     case BACK_TAB:
X        if ( !do_move_link(link_table, num_link, &curr_link, find_link_key, key) &&
X         page>0 )
X           {
X           --page;
X           draw_page = 3;
X           }
X        break;
X
X     case DOWN_ARROW:
X        if ( !do_move_link(link_table, num_link, &curr_link, find_link_updown, 0) &&
X         page<num_pages-1 )
X           {
X           ++page;
X           draw_page = 1;
X           }
X        break;
X
X     case UP_ARROW:
X        if ( !do_move_link(link_table, num_link, &curr_link, find_link_updown, 1) &&
X         page>0 )
X           {
X           --page;
X           draw_page = 3;
X           }
X        break;
X
X     case LEFT_ARROW:
X        do_move_link(link_table, num_link, &curr_link, find_link_leftright, 1);
X        break;
X
X     case RIGHT_ARROW:
X        do_move_link(link_table, num_link, &curr_link, find_link_leftright, 0);
X        break;
X
X     case ESC:       /* exit help */
X        action = ACTION_QUIT;
X        break;
X
X     case BACKSPACE:   /* prev topic */
X     case ALT_F1:
X        if (flags & F_HIST)
X           action = ACTION_PREV;
X        break;
X
X     case F1:    /* help index */
X        if (!(flags & F_INDEX))
X           action = ACTION_INDEX;
X        break;
X
X     case ENTER:
X     case ENTER_2:
X        if (num_link > 0)
X           {
X           next->topic_num = link_table[curr_link].topic_num;
X           next->topic_off = link_table[curr_link].topic_off;
X           action = ACTION_CALL;
X           }
X        break;
X     } /* switch */
X      }
X   while ( action == -1 );
X
X   curr->topic_off = page_table[page].offset;
X   curr->link       = curr_link;
X
X   return (action);
X   }
X
X
Xint help(int action)
X   {
X   static char far unknowntopic_msg[] = "Unknown Help Topic";
X   HIST      curr;
X   int         oldlookatmouse;
X   int         oldhelpmode;
X   int         flags;
X   HIST      next;
X
X   ENTER_OVLY(OVLY_HELP);
X
X   if (helpmode == -1)     /* is help disabled? */
X      {
X      EXIT_OVLY;
X      return (0);
X      }
X
X   if (help_file == -1)
X      {
X      buzzer(2);
X      EXIT_OVLY;
X      return (0);
X      }
X
X   buffer = farmemalloc((long)MAX_PAGE_SIZE + sizeof(LINK)*max_links +
X            sizeof(PAGE)*max_pages);
X
X   if (buffer == NULL)
X      {
X      buzzer(2);
X      EXIT_OVLY;
X      return (0);
X      }
X
X   link_table = (LINK far *)(&buffer[MAX_PAGE_SIZE]);
X   page_table = (PAGE far *)(&link_table[max_links]);
X
X   oldlookatmouse = lookatmouse;
X   lookatmouse = 0;
X   timer_start -= clock_ticks();
X   stackscreen();
X
X   if (helpmode >= 0)
X      {
X      next.topic_num = label[helpmode].topic_num;
X      next.topic_off = label[helpmode].topic_off;
X      }
X   else
X      {
X      next.topic_num = helpmode;
X      next.topic_off = 0;
X      }
X
X   oldhelpmode = helpmode;
X
X   if (curr_hist <= 0)
X      action = ACTION_CALL;  /* make sure it isn't ACTION_PREV! */
X
X   do
X      {
X      switch(action)
X     {
X     case ACTION_PREV2:
X        if (curr_hist > 0)
X           curr = hist[--curr_hist];
X
X        /* fall-through */
X
X     case ACTION_PREV:
X        if (curr_hist > 0)
X           curr = hist[--curr_hist];
X        break;
X
X     case ACTION_QUIT:
X        break;
X
X     case ACTION_INDEX:
X        next.topic_num = label[HELP_INDEX].topic_num;
X        next.topic_off = label[HELP_INDEX].topic_off;
X
X        /* fall-through */
X
X     case ACTION_CALL:
X        curr = next;
X        curr.link = 0;
X        break;
X     } /* switch */
X
X      flags = 0;
X      if (curr.topic_num == label[HELP_INDEX].topic_num)
X     flags |= F_INDEX;
X      if (curr_hist > 0)
X     flags |= F_HIST;
X
X      if ( curr.topic_num >= 0 )
X     action = help_topic(&curr, &next, flags);
X      else
X     {
X     if ( curr.topic_num == -100 )
X        {
X        print_document("FRACTINT.DOC", print_doc_msg_func, 1);
X        action = ACTION_PREV2;
X        }
X
X     else if ( curr.topic_num == -101 )
X        action = ACTION_PREV2;
X
X     else
X        {
X        display_page(unknowntopic_msg, NULL, 0, 0, 1, 0, NULL, NULL);
X        action = -1;
X        while (action == -1)
X           {
X           switch (getakey())
X          {
X          case ESC:     action = ACTION_QUIT;    break;
X          case ALT_F1:     action = ACTION_PREV;    break;
X          case F1:     action = ACTION_INDEX; break;
X          } /* switch */
X           } /* while */
X        }
X     } /* else */
X
X      if ( action != ACTION_PREV && action != ACTION_PREV2 )
X     {
X     if (curr_hist >= MAX_HIST)
X        {
X        int ctr;
X
X        for (ctr=0; ctr<MAX_HIST-1; ctr++)
X           hist[ctr] = hist[ctr+1];
X
X        curr_hist = MAX_HIST-1;
X        }
X     hist[curr_hist++] = curr;
X     }
X      }
X   while (action != ACTION_QUIT);
X
X   farmemfree((BYTE far *)buffer);
X
X   unstackscreen();
X   lookatmouse = oldlookatmouse;
X   helpmode = oldhelpmode;
X   timer_start += clock_ticks();
X
X   EXIT_OVLY;
X   return(0);
X   }
X
X
X
Xstatic int dos_version(void)
X   {
X#ifndef XFRACT
X   union REGS r;
X
X   r.x.ax = 0x3000;
X   intdos(&r, &r);
X
X   return (r.h.al*100 + r.h.ah);
X#else
X   return 0;
X#endif
X   }
X
X
Xstatic int exe_path(char *filename, char *path)
X   {
X#ifndef XFRACT
X   char *ptr;
X
X   if (dos_version() >= 300)  /* DOS version 3.00+ ? */
X      {
X#ifdef __TURBOC__
X      strcpy(path, _argv[0]);
X#else  /* assume MSC */
X      extern char **__argv;
X      strcpy(path, __argv[0]);     /* note: __argv may be undocumented in MSC */
X#endif
X
X      ptr = strrchr(path, SLASHC);
X      if (ptr == NULL)
X     ptr = path;
X      else
X     ++ptr;
X      strcpy(ptr, filename);
X      return (1);
X      }
X
X   return (0);
X#else
X   strcpy(path,SRCDIR);
X   strcat(path,"/");
X   strcat(path,filename);
X   return 1;
X#endif
X   }
X
X
Xstatic int find_file(char *filename, char *path)
X   {
X   int handle;
X
X   if ( exe_path(filename, path) )
X      if ( (handle=open(path, O_RDONLY)) != -1)
X     {
X     close(handle);
X     return (1);
X     }
X
X   findpath(filename,path);
X   return ( (path[0]) ? 1 : 0);
X   }
X
X
Xstatic int _read_help_topic(int topic, int off, int len, VOIDFARPTR buf)
X   {
X   static int  curr_topic = -1;
X   static long curr_base;
X   static int  curr_len;
X   int           read_len;
X
X   if ( topic != curr_topic )
X      {
X      int t;
X      char ch;
X
X      curr_topic = topic;
X
X      curr_base = topic_offset[topic];
X
X      curr_base += sizeof(int);            /* skip flags */
X
X      help_seek(curr_base);
X      read(help_file, (char *)&t, sizeof(int));    /* read num_pages */
X      curr_base += sizeof(int) + t*3*sizeof(int); /* skip page info */
X
X      if (t>0)
X     help_seek(curr_base);
X      read(help_file, &ch, 1);            /* read title_len */
X      t = ch;
X      curr_base += 1 + t;            /* skip title */
X
X      if (t>0)
X     help_seek(curr_base);
X      read(help_file, (char *)&curr_len, sizeof(int)); /* read topic len */
X      curr_base += sizeof(int);
X      }
X
X   read_len = (off+len > curr_len) ? curr_len - off : len;
X
X   if (read_len > 0)
X      {
X      help_seek(curr_base + off);
X      farread(help_file, (char far *)buf, read_len);
X      }
X
X   return ( curr_len - (off+len) );
X   }
X
X
Xint read_help_topic(int label_num, int off, int len, VOIDFARPTR buf)
X   /*
X    * reads text from a help topic.  Returns number of bytes from (off+len)
X    * to end of topic.    On "EOF" returns a negative number representing
X    * number of bytes not read.
X    */
X   {
X   int ret;
X
X   ENTER_OVLY(OVLY_HELP);
X
X   ret = _read_help_topic(label[label_num].topic_num,
X              label[label_num].topic_off + off, len, buf);
X
X   EXIT_OVLY;
X
X   return ( ret );
X   }
X
X
X#define PRINT_BUFFER_SIZE  (32767)     /* max. size of help topic in doc. */
X#define TEMP_FILE_NAME       "HELP.$$$"    /* temp file for storing extraseg  */
X                     /*    while printing document        */
X#define MAX_NUM_TOPIC_SEC  (10)      /* max. number of topics under any */
X                     /*    single section (CONTENT)     */
X
X
Xtypedef struct PRINT_DOC_INFO
X   {
X   int         cnum;        /* current CONTENT num */
X   int         tnum;        /* current topic num */
X
X   long      content_pos;   /* current CONTENT item offset in file */
X   int         num_page;        /* total number of pages in document */
X
X   int         num_contents,  /* total number of CONTENT entries */
X         num_topic;     /* number of topics in current CONTENT */
X
X   int         topic_num[MAX_NUM_TOPIC_SEC]; /* topic_num[] for current CONTENT entry */
X
X   char far *buffer;        /* text buffer */
X
X   char      id[81];        /* buffer to store id in */
X   char      title[81];     /* buffer to store title in */
X
X#ifndef XFRACT
X   int     (*msg_func)(int pnum, int num_page);
X#else
X   int     (*msg_func)();
X   int pnum;
X#endif
X
X   FILE     *file;        /* file to sent output to */
X   int         margin;        /* indent text by this much */
X   int         start_of_line; /* are we at the beginning of a line? */
X   int         spaces;        /* number of spaces in a row */
X   } PRINT_DOC_INFO;
X
X
Xvoid print_document(char *outfname, int (*msg_func)(int,int), int save_extraseg );
X
X
Xstatic void printerc(PRINT_DOC_INFO *info, int c, int n)
X   {
X   while ( n-- > 0 )
X      {
X      if (c==' ')
X     ++info->spaces;
X
X      else if (c=='\n' || c=='\f')
X     {
X     info->start_of_line = 1;
X     info->spaces = 0;   /* strip spaces before a new-line */
X     putc(c, info->file);
X     }
X
X      else
X     {
X     if (info->start_of_line)
X        {
X        info->spaces += info->margin;
X        info->start_of_line = 0;
X        }
X
X     while (info->spaces > 0)
X        {
X        fputc(' ', info->file);
X        --info->spaces;
X        }
X
X     fputc(c, info->file);
X     }
X      }
X   }
X
X
Xstatic void printers(PRINT_DOC_INFO *info, char far *s, int n)
X   {
X   if (n > 0)
X      {
X      while ( n-- > 0 )
X     printerc(info, *s++, 1);
X      }
X   else
X      {
X      while ( *s != '\0' )
X     printerc(info, *s++, 1);
X      }
X   }
X
X
Xstatic int print_doc_get_info(int cmd, PD_INFO *pd, PRINT_DOC_INFO *info)
X   {
X   int t;
X   BYTE ch;
X
X   switch (cmd)
X      {
X      case PD_GET_CONTENT:
X     if ( ++info->cnum >= info->num_contents )
X        return (0);
X
X     help_seek( info->content_pos );
X
X         read(help_file, (char *)&t, sizeof(int));      /* read flags */
X         info->content_pos += sizeof(int);
X     pd->new_page = (t & 1) ? 1 : 0;
X
X         read(help_file, &ch, 1);       /* read id len */
X         t = ch;
X     assert(t<80);
X     read(help_file, (char *)info->id, t);    /* read the id */
X     info->content_pos += 1 + t;
X     info->id[t] = '\0';
X
X         read(help_file, (char *)&ch, 1);       /* read title len */
X         t = ch;
X     assert(t<80);
X     read(help_file, (char *)info->title, t); /* read the title */
X     info->content_pos += 1 + t;
X     info->title[t] = '\0';
X
X         read(help_file, (char *)&ch, 1);       /* read num_topic */
X         t = ch;
X     assert(t<MAX_NUM_TOPIC_SEC);
X         read(help_file, (char *)info->topic_num, t*sizeof(int));  /* read topic_num[] */
X     info->num_topic = t;
X         info->content_pos += 1 + t*sizeof(int);
X
X     info->tnum = -1;
X
X     pd->id = info->id;
X     pd->title = info->title;
X     return (1);
X
X      case PD_GET_TOPIC:
X     if ( ++info->tnum >= info->num_topic )
X        return (0);
X
X     t = _read_help_topic(info->topic_num[info->tnum], 0, PRINT_BUFFER_SIZE, info->buffer);
X
X     assert(t <= 0);
X
X     pd->curr = info->buffer;
X     pd->len  = PRINT_BUFFER_SIZE + t;   /* same as ...SIZE - abs(t) */
X     return (1);
X
X      case PD_GET_LINK_PAGE:
X         pd->i = getint(pd->s+sizeof(long));
X     return ( (pd->i == -1) ? 0 : 1 );
X
X      case PD_RELEASE_TOPIC:
X     return (1);
X
X      default:
X     return (0);
X      }
X   }
X
X
Xstatic int print_doc_output(int cmd, PD_INFO *pd, PRINT_DOC_INFO *info)
X   {
X   switch (cmd)
X      {
X      case PD_HEADING:
X     {
X     char line[81];
X     char buff[40];
X     int  width = PAGE_WIDTH + PAGE_INDENT;
X     int  keep_going;
X
X     if ( info->msg_func != NULL )
X        keep_going = (*info->msg_func)(pd->pnum, info->num_page);
X     else
X        keep_going = 1;
X
X     info->margin = 0;
X
X     memset(line, ' ', 81);
X     sprintf(buff, "Fractint Version %d.%01d%c",release/100, (release%100)/10,
X                ( (release%10) ? '0'+(release%10) : ' ') );
X     memmove(line + ( (width-strlen(buff)) / 2)-4, buff, strlen(buff));
X
X     sprintf(buff, "Page %d", pd->pnum);
X     memmove(line + (width - strlen(buff)), buff, strlen(buff));
X
X     printerc(info, '\n', 1);
X     printers(info, line, width);
X     printerc(info, '\n', 2);
X
X     info->margin = PAGE_INDENT;
X
X     return ( keep_going );
X     }
X
X      case PD_FOOTING:
X     info->margin = 0;
X     printerc(info, '\f', 1);
X     info->margin = PAGE_INDENT;
X     return (1);
X
X      case PD_PRINT:
X     printers(info, pd->s, pd->i);
X     return (1);
X
X      case PD_PRINTN:
X     printerc(info, *pd->s, pd->i);
X     return (1);
X
X      case PD_PRINT_SEC:
X     info->margin = TITLE_INDENT;
X     if (pd->id[0] != '\0')
X        {
X        printers(info, pd->id, 0);
X        printerc(info, ' ', 1);
X        }
X     printers(info, pd->title, 0);
X     printerc(info, '\n', 1);
X     info->margin = PAGE_INDENT;
X     return (1);
X
X      case PD_START_SECTION:
X      case PD_START_TOPIC:
X      case PD_SET_SECTION_PAGE:
X      case PD_SET_TOPIC_PAGE:
X      case PD_PERIODIC:
X     return (1);
X
X      default:
X     return (0);
X      }
X   }
X
X
Xstatic int print_doc_msg_func(int pnum, int num_pages)
X   {
X   char temp[10];
X   int    key;
X
X   if ( pnum == -1 )    /* successful completion */
X      {
X      buzzer(0);
X      putstringcenter(7, 0, 80, C_HELP_LINK, "Done -- Press any key");
X      getakey();
X      return (0);
X      }
X
X   if ( pnum == -2 )   /* aborted */
X      {
X      buzzer(1);
X      putstringcenter(7, 0, 80, C_HELP_LINK, "Aborted -- Press any key");
X      getakey();
X      return (0);
X      }
X
X   if (pnum == 0)   /* initialization */
X      {
X      helptitle();
X      printinstr();
X      setattr(2, 0, C_HELP_BODY, 80*22);
X      putstringcenter(1, 0, 80, C_HELP_HDG, "Generating FRACTINT.DOC");
X
X      putstring(7, 30, C_HELP_BODY, "Completed:");
X
X      movecursor(25,80);   /* hide cursor */
X      }
X
X
X   sprintf(temp, "%d%%", (int)( (100.0 / num_pages) * pnum ) );
X   putstring(7, 41, C_HELP_LINK, temp);
X
X   while ( keypressed() )
X      {
X      key = getakey();
X      if ( key == ESC )
X     return (0);    /* user abort */
X      }
X
X   return (1);     /* AOK -- continue */
X   }
X
Xint makedoc_msg_func(int pnum, int num_pages)
X   {
X   if (pnum >= 0)
X      {
X      printf("\rcompleted %d%%", (int)( (100.0 / num_pages) * pnum ) );
X      return (1);
X      }
X   if ( pnum == -2 )
X      printf("\n*** aborted");
X   printf("\n");
X   return (0);
X   }
X
X
X
Xvoid print_document(char *outfname, int (*msg_func)(int,int), int save_extraseg )
X   {
X   static char far err_no_temp[]  = "Unable to create temporary file.\n";
X   static char far err_no_out[]   = "Unable to create output file.\n";
X   static char far err_badwrite[] = "Error writing temporary file.\n";
X   static char far err_badread[]  = "Error reading temporary file.\nSystem may be corrupt!\nSave your image and re-start FRACTINT!\n";
X
X   PRINT_DOC_INFO info;
X   int          success;
X   int          temp_file = -1;
X   char      far *msg = NULL;
X
X   ENTER_OVLY(OVLY_HELP);
X
X   info.buffer = MK_FP(extraseg, 0);
X
X/*   help_seek((long)sizeof(int)+sizeof(long));        Strange -- should be 8 -- CWM */
X   help_seek(8L);                /* indeed it should - Bert */
X   read(help_file, (char *)&info.num_contents, sizeof(int));
X   read(help_file, (char *)&info.num_page, sizeof(int));
X
X   info.cnum = info.tnum = -1;
X   info.content_pos = sizeof(long)+4*sizeof(int) + num_topic*sizeof(long) + num_label*2*sizeof(int);
X   info.msg_func = msg_func;
X
X   if ( msg_func != NULL )
X      msg_func(0, info.num_page);   /* initialize */
X
X   if ( save_extraseg )
X      {
X      if ( (temp_file=open(TEMP_FILE_NAME, O_RDWR|O_CREAT|O_TRUNC|O_BINARY, S_IREAD|S_IWRITE)) == -1 )
X     {
X     msg = err_no_temp;
X     goto ErrorAbort;
X     }
X
X      if ( farwrite(temp_file, info.buffer, PRINT_BUFFER_SIZE) != PRINT_BUFFER_SIZE )
X     {
X     msg = err_badwrite;
X     goto ErrorAbort;
X     }
X      }
X
X   if ( (info.file = fopen(outfname, "wt")) == NULL )
X      {
X      msg = err_no_out;
X      goto ErrorAbort;
X      }
X
X   info.margin = PAGE_INDENT;
X   info.start_of_line = 1;
X   info.spaces = 0;
X
X   success = process_document((PD_FUNC)print_doc_get_info,
X                  (PD_FUNC)print_doc_output,   &info);
X   fclose(info.file);
X
X   if ( save_extraseg )
X      {
X      if ( lseek(temp_file, 0L, SEEK_SET) != 0L )
X     {
X     msg = err_badread;
X     goto ErrorAbort;
X     }
X
X      if ( farread(temp_file, info.buffer, PRINT_BUFFER_SIZE) != PRINT_BUFFER_SIZE )
X     {
X     msg = err_badread;
X     goto ErrorAbort;
X     }
X      }
X
XErrorAbort:
X   if (temp_file != -1)
X      {
X      close(temp_file);
X      remove(TEMP_FILE_NAME);
X      temp_file = -1;
X      }
X
X   if ( msg != NULL )
X      {
X      helptitle();
X      stopmsg(1, msg);
X      }
X
X   else if ( msg_func != NULL )
X      msg_func((success) ? -1 : -2, info.num_page );
X
X   EXIT_OVLY;
X   }
X
X
Xint init_help(void)
X   {
X   struct help_sig_info hs;
X   char         path[81];
X
X   ENTER_OVLY(OVLY_HELP);
X
X   help_file = -1;
X
X#ifndef XFRACT
X   if (help_file == -1)        /* now look for help files in FRACTINT.EXE */
X      {
X      static char far err_no_open[]    = "Help system was unable to open FRACTINT.EXE!\n";
X      static char far err_no_exe[]     = "Help system couldn't find FRACTINT.EXE!\n";
X      static char far err_wrong_ver[]  = "Wrong help version in FRACTINT.EXE!\n";
X/*
X      static char far err_not_in_exe[] = "Help not found in FRACTINT.EXE!\n";
X*/
X
X      if ( find_file("FRACTINT.EXE", path) )
X     {
X     if ( (help_file = open(path, O_RDONLY|O_BINARY)) != -1 )
X        {
X        long help_offset;
X
X        for (help_offset = -((long)sizeof(hs)); help_offset >= -128L; help_offset--)
X               {
X           lseek(help_file, help_offset, SEEK_END);
X           read(help_file, (char *)&hs, sizeof(hs));
X           if (hs.sig == HELP_SIG)  break;
X           }
X
X        if ( hs.sig != HELP_SIG )
X           {
X           close(help_file);
X           help_file = -1;
X           /* (leave out the error message)
X           stopmsg(1, err_not_in_exe);
X           */
X           }
X
X        else
X           {
X           if ( hs.version != HELP_VERSION )
X              {
X              close(help_file);
X              help_file = -1;
X              stopmsg(1, err_wrong_ver);
X              }
X             else
X              base_off = hs.base;
X
X               }
X        }
X     else
X        stopmsg(1, err_no_open);
X     }
X      else
X     stopmsg(1, err_no_exe);
X
X      }
X#endif
X
Xif (help_file == -1)        /* look for FRACTINT.HLP */
X   {
X   if ( find_file("fractint.hlp", path) )
X      {
X      if ( (help_file = open(path, O_RDONLY|O_BINARY)) != -1 )
X     {
X         read(help_file, (char *)&hs, sizeof(long)+sizeof(int));
X
X     if ( hs.sig != HELP_SIG )
X        {
X        static char far msg[] = {"Invalid help signature in FRACTINT.HLP!\n"};
X        close(help_file);
X        stopmsg(1, msg);
X        }
X
X     else if ( hs.version != HELP_VERSION )
X        {
X        static char far msg[] = {"Wrong help version in FRACTINT.HLP!\n"};
X        close(help_file);
X        stopmsg(1, msg);
X        }
X
X     else
X        base_off = sizeof(long)+sizeof(int);
X     }
X      }
X   }
X
X   if (help_file == -1)        /* Can't find the help files anywhere! */
X      {
X      static char far msg[] =
X#ifndef XFRACT
X     {"Help Files aren't in FRACTINT.EXE, and couldn't find FRACTINT.HLP!\n"};
X#else
X     {"Couldn't find fractint.hlp; set FRACTDIR to proper directory with setenv.\n"};
X#endif
X      stopmsg(1, msg);
X      }
X
X   help_seek(0L);
X
X   read(help_file, (char *)&max_pages, sizeof(int));
X   read(help_file, (char *)&max_links, sizeof(int));
X   read(help_file, (char *)&num_topic, sizeof(int));
X   read(help_file, (char *)&num_label, sizeof(int));
X   help_seek((long)6*sizeof(int));  /* skip num_contents and num_doc_pages */
X
X   assert(max_pages > 0);
X   assert(max_links >= 0);
X   assert(num_topic > 0);
X   assert(num_label > 0);
X
X   /* allocate one big chunk for all three arrays */
X
X   topic_offset = (long far *)farmemalloc(sizeof(long)*num_topic + 2L*sizeof(int)*num_label + sizeof(HIST)*MAX_HIST);
X
X   if (topic_offset == NULL)
X      {
X      static char far err_no_mem[] = "Not enough memory for help system!\n";
X      close(help_file);
X      help_file = -1;
X      stopmsg(1, err_no_mem);
X
X      EXIT_OVLY;      /* JIC stopmsg continues for some reason? */
X      return (-2);
X      }
X
X   /* split off the other arrays */
X
X   label = (LABEL far *)(&topic_offset[num_topic]);
X   hist  = (HIST far *)(&label[num_label]);
X
X   /* read in the tables... */
X
X   farread(help_file, topic_offset, num_topic*sizeof(long));
X   farread(help_file, label, num_label*2*sizeof(int));
X
X   /* finished! */
X
X   EXIT_OVLY;
X   return (0);    /* success */
X   }
X
X
Xvoid end_help(void)
X   {
X   ENTER_OVLY(OVLY_HELP);
X   if (help_file != -1)
X      {
X      close(help_file);
X      farmemfree((BYTE far *)topic_offset);
X      help_file = -1;
X      }
X   EXIT_OVLY;
X   }
X
X
SHAR_EOF
$TOUCH -am 1028230093 help.c &&
chmod 0644 help.c ||
echo "restore of help.c failed"
set `wc -c help.c`;Wc_c=$1
if test "$Wc_c" != "36787"; then
    echo original size 36787, current size $Wc_c
fi
# ============= intro.c ==============
echo "x - extracting intro.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > intro.c &&
X
X/*
X * intro.c
X *
X * FRACTINT intro screen (authors & credits)
X *
X *
X */
X
X#include <stdio.h>
X#include <time.h>
X#ifndef XFRACT
X#include <dos.h>
X#endif
X
X#include "fractint.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* stuff from fractint */
X
Xextern int  lookatmouse;
Xextern long timer_start;
Xextern int  helpmode;
Xextern SEGTYPE  extraseg;
X
X
X#ifdef XFRACT
Xextern int slowdisplay;
X#endif
X
X
Xvoid intro_overlay(void) { }
X
X
Xvoid intro(void)
X   {
X   int         toprow, botrow, i, j, delaymax;
X   char      oldchar;
X   int         authors[100];        /* this should be enough for awhile */
X   char far *credits;
X   char far *screen_text;
X   int         oldlookatmouse;
X   int         oldhelpmode;
X
X   ENTER_OVLY(OVLY_INTRO);
X
X   timer_start -= clock_ticks();        /* "time out" during help */
X   oldlookatmouse = lookatmouse;
X   oldhelpmode = helpmode;
X   lookatmouse = 0;            /* de-activate full mouse checking */
X
X   screen_text = MK_FP(extraseg, 0);
X
X   i = 32767 + read_help_topic(INTRO_AUTHORS, 0, 32767, screen_text);
X   screen_text[i++] = '\0';
X   credits = screen_text + i;
X   i = 32767 + read_help_topic(INTRO_CREDITS, 0, 32767, credits);
X   credits[i++] = '\0';
X
X   j = 0;
X   authors[j] = 0;        /* find the start of each credit-line */
X   for (i = 0; credits[i] != 0; i++)
X      if (credits[i] == 10)
X     authors[++j] = i+1;
X   authors[j+1] = i;
X
X   helptitle();
X   toprow = 8;
X#ifndef XFRACT
X   botrow = 21;
X#else
X   botrow = 20;
X   putstringcenter(21,0,80,C_TITLE,
X   "Unix/X port of fractint by Ken Shirriff [[e-mail]]");
X#endif
X   putstringcenter(1,0,80,C_TITLE, "Press ENTER for main menu, F1 for help.");
X   putstring(2,0,C_CONTRIB,screen_text);
X   setattr(2,0,C_AUTHDIV1,80);
X   setattr(7,0,C_AUTHDIV1,80);
X   setattr(22,0,C_AUTHDIV2,80);
X   setattr(3,0,C_PRIMARY,320);
X   setattr(23,0,C_TITLE_LOW,160);
X   for (i = 3; i < 7; ++i)
X      setattr(i,20,C_CONTRIB,60);
X   setattr(toprow,0,C_CONTRIB,14*80);
X   i = botrow - toprow;
X   srand(clock_ticks());
X   j = rand15()%(j-(botrow-toprow)); /* first to use */
X   i = j+botrow-toprow; /* last to use */
X   oldchar = credits[authors[i+1]];
X   credits[authors[i+1]] = 0;
X   putstring(toprow,0,C_CONTRIB,credits+authors[j]);
X   credits[authors[i+1]] = oldchar;
X   delaymax = 10;
X   movecursor(25,80); /* turn it off */
X   helpmode = HELPMENU;
X   while (! keypressed())
X      {
X#ifdef XFRACT
X      if (slowdisplay) delaymax *= 15;
X#endif
X      for (j = 0; j < delaymax && !(keypressed()); j++)
X     delay(100);
X      if (keypressed() == 32)
X     {    /* spacebar pauses */
X     getakey();
X#ifndef XFRACT
X         while (!keypressed()) ;
X#else
X         waitkeypressed(0);
X#endif
X     if (keypressed() == 32)
X        getakey();
X     }
X      delaymax = 15;
X      scrollup(toprow, botrow);
X      i++;
X      if (credits[authors[i]] == 0)
X     i = 0;
X      oldchar = credits[authors[i+1]];
X      credits[authors[i+1]] = 0;
X      putstring(botrow,0,C_CONTRIB,&credits[authors[i]]);
X      setattr(botrow,0,C_CONTRIB,80);
X      credits[authors[i+1]] = oldchar;
X      movecursor(25,80); /* turn it off */
X      }
X
X   lookatmouse = oldlookatmouse;        /* restore the mouse-checking */
X   helpmode = oldhelpmode;
X   EXIT_OVLY;
X   return ;
X   }
SHAR_EOF
$TOUCH -am 1028230093 intro.c &&
chmod 0644 intro.c ||
echo "restore of intro.c failed"
set `wc -c intro.c`;Wc_c=$1
if test "$Wc_c" != "3156"; then
    echo original size 3156, current size $Wc_c
fi
# ============= jb.c ==============
echo "x - extracting jb.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > jb.c &&
X#include <stdio.h>
X#include <stdlib.h>
X#include "fractint.h"
X#include "mpmath.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X#include "fractype.h"
X
Xextern int savedac;
Xextern int c_exp;
Xextern int debugflag;
Xextern int maxit;
Xextern int num_fractal_types;
Xextern struct fractalspecificstuff far fractalspecific[];
Xextern int row, col, xdots, ydots, bitshift, fractype;
Xextern int ixstart, ixstop, iystart, iystop, colors, helpmode;
Xextern double param[], xxmin, xxmax, yymin, yymax;
Xextern long delx, dely, ltempsqrx, ltempsqry, far * lx0, far * ly0;
Xextern double tempsqrx, tempsqry, qc, qci, qcj, qck;
Xextern _LCMPLX lold, lnew, *longparm;
Xextern _CMPLX old, new, *floatparm;
Xextern llimit2;
X
X/* these need to be accessed elsewhere for saving data */
Xdouble mxminfp = -.83;
Xdouble myminfp = -.25;
Xdouble mxmaxfp = -.83;
Xdouble mymaxfp =  .25;
X
Xstatic long mxmin, mymin;
Xstatic long x_per_inch, y_per_inch, inch_per_xdot, inch_per_ydot;
Xstatic double x_per_inchfp, y_per_inchfp, inch_per_xdotfp, inch_per_ydotfp;
Xstatic int bbase;
Xstatic long xpixel, ypixel;
Xstatic double xpixelfp, ypixelfp;
Xstatic long initz, djx, djy, dmx, dmy;
Xstatic double initzfp, djxfp, djyfp, dmxfp, dmyfp;
Xstatic long jx, jy, mx, my, xoffset, yoffset;
Xstatic double jxfp, jyfp, mxfp, myfp, xoffsetfp, yoffsetfp;
X
Xstruct Perspective
X{
X   long x, y, zx, zy;
X};
X
Xstruct Perspectivefp
X{
X   double x, y, zx, zy;
X};
X
Xstruct Perspective LeftEye, RightEye, *Per;
Xstruct Perspectivefp LeftEyefp, RightEyefp, *Perfp;
X
X_LCMPLX jbc;
X_CMPLX jbcfp;
X
Xextern char Glasses1Map[];
Xextern char GreyFile[];
X
Xstatic double fg, fg16;
Xint zdots = 128;
X
Xdouble originfp = 8, heightfp = 7, widthfp = 10, distfp = 24, eyesfp = 2.5, depthfp = 8, brratiofp = 1;
Xstatic long width, dist, eyes, depth, brratio;
X
Xint juli3Dmode = 0;
X
Xint lastorbittype = -1;
Xint neworbittype = JULIA;
X
Xint
XJulibrotSetup(void)
X{
X   long origin, height;
X   int numparams;
X   struct fractalspecificstuff far *oldcurfractalspecific;
X   int oldfractype;
X   int i;
X   int r;
X   int oldhelpmode;
X   char *mapname;
X
X#ifndef XFRACT
X   if (colors < 255)
X   {
X      static char far msg[] =
X      {"Sorry, but Julibrots require a 256-color video mode"};
X      stopmsg(0, msg);
X      return (0);
X   }
X#endif
X
X   stackscreen();
X   oldhelpmode = helpmode;
X   helpmode = HT_JULIBROT;
X   xoffsetfp = (xxmax + xxmin) / 2;     /* Calculate average */
X   yoffsetfp = (yymax + yymin) / 2;     /* Calculate average */
X   dmxfp = (mxmaxfp - mxminfp) / zdots;
X   dmyfp = (mymaxfp - myminfp) / zdots;
X   floatparm = &jbcfp;
X
X
X   x_per_inchfp = (xxmin - xxmax) / widthfp;
X   y_per_inchfp = (yymax - yymin) / heightfp;
X   inch_per_xdotfp = widthfp / xdots;
X   inch_per_ydotfp = heightfp / ydots;
X
X   initzfp = originfp - (depthfp / 2);
X   if(juli3Dmode == 0)
X      RightEyefp.x = 0.0;
X   else
X      RightEyefp.x = eyesfp / 2;
X   LeftEyefp.x = -RightEyefp.x;
X   LeftEyefp.y = RightEyefp.y = 0;
X   LeftEyefp.zx = RightEyefp.zx = distfp;
X   LeftEyefp.zy = RightEyefp.zy = distfp;
X   bbase = 128;
X   oldcurfractalspecific = curfractalspecific;
X   oldfractype = fractype;
X   fractype = neworbittype;
X   curfractalspecific = &fractalspecific[fractype];
X   lastorbittype = neworbittype;
X   curfractalspecific = oldcurfractalspecific;
X   fractype = oldfractype;
X#ifndef XFRACT
X   if (fractalspecific[fractype].isinteger > 0)
X   {
X      long jxmin, jxmax, jymin, jymax, mxmax, mymax;
X      if (fractalspecific[neworbittype].isinteger == 0)
X      {
X         char msg[80];
X         sprintf(msg, "Julibrot orbit type isinteger mismatch");
X         stopmsg(0, msg);
X      }
X      if (fractalspecific[neworbittype].isinteger > 1)
X         bitshift = fractalspecific[neworbittype].isinteger;
X      fg = (double) (1L << bitshift);
X      fg16 = (double) (1L << 16);
X      jxmin = (long) (xxmin * fg);
X      jxmax = (long) (xxmax * fg);
X      xoffset = (jxmax + jxmin) / 2;    /* Calculate average */
X      jymin = (long) (yymin * fg);
X      jymax = (long) (yymax * fg);
X      yoffset = (jymax + jymin) / 2;    /* Calculate average */
X      mxmin = (long) (mxminfp * fg);
X      mxmax = (long) (mxmaxfp * fg);
X      mymin = (long) (myminfp * fg);
X      mymax = (long) (mymaxfp * fg);
X      origin = (long) (originfp * fg16);
X      depth = (long) (depthfp * fg16);
X      height = (long) (heightfp * fg16);
X      width = (long) (widthfp * fg16);
X      dist = (long) (distfp * fg16);
X      eyes = (long) (eyesfp * fg16);
X      brratio = (long) (brratiofp * fg16);
X      dmx = (mxmax - mxmin) / zdots;
X      dmy = (mymax - mymin) / zdots;
X      longparm = &jbc;
X
X      x_per_inch = (long) ((xxmin - xxmax) / widthfp * fg);
X      y_per_inch = (long) ((yymax - yymin) / heightfp * fg);
X      inch_per_xdot = (long) ((widthfp / xdots) * fg16);
X      inch_per_ydot = (long) ((heightfp / ydots) * fg16);
X      initz = origin - (depth / 2);
X      if(juli3Dmode == 0)
X         RightEye.x = 0l;
X      else
X         RightEye.x = eyes / 2;
X      LeftEye.x = -RightEye.x;
X      LeftEye.y = RightEye.y = 0l;
X      LeftEye.zx = RightEye.zx = dist;
X      LeftEye.zy = RightEye.zy = dist;
X      bbase = (int) (128.0 * brratiofp);
X   }
X#endif
X
X   helpmode = oldhelpmode;
X   unstackscreen();
X   if (juli3Dmode == 3)
X   {
X      savedac = 0;
X      mapname = Glasses1Map;
X   }
X   else
X      mapname = GreyFile;
X   if(savedac != 1)
X   {
X   if (ValidateLuts(mapname) != 0)
X      return (0);
X   spindac(0, 1);               /* load it, but don't spin */
X      if(savedac == 2)
X        savedac = 1;
X   }
X   return (r >= 0);
X}
X
X
Xint
Xjb_per_pixel(void)
X{
X   jx = multiply(Per->x - xpixel, initz, 16);
X   jx = divide(jx, dist, 16) - xpixel;
X   jx = multiply(jx << (bitshift - 16), x_per_inch, bitshift);
X   jx += xoffset;
X   djx = divide(depth, dist, 16);
X   djx = multiply(djx, Per->x - xpixel, 16) << (bitshift - 16);
X   djx = multiply(djx, x_per_inch, bitshift) / zdots;
X
X   jy = multiply(Per->y - ypixel, initz, 16);
X   jy = divide(jy, dist, 16) - ypixel;
X   jy = multiply(jy << (bitshift - 16), y_per_inch, bitshift);
X   jy += yoffset;
X   djy = divide(depth, dist, 16);
X   djy = multiply(djy, Per->y - ypixel, 16) << (bitshift - 16);
X   djy = multiply(djy, y_per_inch, bitshift) / zdots;
X
X   return (1);
X}
X
Xint
Xjbfp_per_pixel(void)
X{
X   jxfp = ((Perfp->x - xpixelfp) * initzfp / distfp - xpixelfp) * x_per_inchfp;
X   jxfp += xoffsetfp;
X   djxfp = (depthfp / distfp) * (Perfp->x - xpixelfp) * x_per_inchfp / zdots;
X
X   jyfp = ((Perfp->y - ypixelfp) * initzfp / distfp - ypixelfp) * y_per_inchfp;
X   jyfp += yoffsetfp;
X   djyfp = depthfp / distfp * (Perfp->y - ypixelfp) * y_per_inchfp / zdots;
X
X   return (1);
X}
X
Xstatic int n, zpixel, plotted, color;
X
Xint
Xzline(long x, long y)
X{
X   xpixel = x;
X   ypixel = y;
X   mx = mxmin;
X   my = mymin;
X   switch(juli3Dmode)
X   {
X   case 0:
X   case 1:
X      Per = &LeftEye;
X      break;
X   case 2:
X      Per = &RightEye;
X      break;
X   case 3:
X      if ((row + col) & 1)
X         Per = &LeftEye;
X      else
X         Per = &RightEye;
X      break;
X   }
X   jb_per_pixel();
X   for (zpixel = 0; zpixel < zdots; zpixel++)
X   {
X      lold.x = jx;
X      lold.y = jy;
X      jbc.x = mx;
X      jbc.y = my;
X      if (check_key())
X         return (-1);
X      ltempsqrx = multiply(lold.x, lold.x, bitshift);
X      ltempsqry = multiply(lold.y, lold.y, bitshift);
X      for (n = 0; n < maxit; n++)
X         if (fractalspecific[neworbittype].orbitcalc())
X            break;
X      if (n == maxit)
X      {
X         if (juli3Dmode==3)
X         {
X            color = (int) (128l * zpixel / zdots);
X            if ((row + col) & 1)
X            {
X
X               (*plot) (col, row, 127 - color);
X            }
X            else
X            {
X               color = (int) (multiply((long) color << 16, brratio, 16) >> 16);
X               if (color < 1)
X                  color = 1;
X               if (color > 127)
X                  color = 127;
X               (*plot) (col, row, 127 + bbase - color);
X            }
X         }
X         else
X         {
X            color = (int) (254l * zpixel / zdots);
X            (*plot) (col, row, color + 1);
X         }
X         plotted = 1;
X         break;
X      }
X      mx += dmx;
X      my += dmy;
X      jx += djx;
X      jy += djy;
X   }
X   return (0);
X}
X
Xint
Xzlinefp(double x, double y)
X{
X   static int keychk = 0;
X   xpixelfp = x;
X   ypixelfp = y;
X   mxfp = mxminfp;
X   myfp = myminfp;
X   switch(juli3Dmode)
X   {
X   case 0:
X   case 1:
X      Perfp = &LeftEyefp;
X      break;
X   case 2:
X      Perfp = &RightEyefp;
X      break;
X   case 3:
X      if ((row + col) & 1)
X         Perfp = &LeftEyefp;
X      else
X         Perfp = &RightEyefp;
X      break;
X   }
X   jbfp_per_pixel();
X   for (zpixel = 0; zpixel < zdots; zpixel++)
X   {
X      old.x = jxfp;
X      old.y = jyfp;
X      jbcfp.x = mxfp;
X      jbcfp.y = myfp;
X      qc = param[0];
X      qci = param[1];
X      qcj = param[2];
X      qck = param[3];
X#ifdef XFRACT
X      if (keychk++ > 500)
X      {
X         keychk = 0;
X         if (check_key())
X            return (-1);
X      }
X#else
X      if (check_key())
X         return (-1);
X#endif
X      tempsqrx = sqr(old.x);
X      tempsqry = sqr(old.y);
X
X      for (n = 0; n < maxit; n++)
X         if (fractalspecific[neworbittype].orbitcalc())
X            break;
X      if (n == maxit)
X      {
X         if (juli3Dmode == 3)
X         {
X            color = (int) (128l * zpixel / zdots);
X            if ((row + col) & 1)
X               (*plot) (col, row, 127 - color);
X            else
X            {
X               color = color * brratiofp;
X               if (color < 1)
X                  color = 1;
X               if (color > 127)
X                  color = 127;
X               (*plot) (col, row, 127 + bbase - color);
X            }
X         }
X         else
X         {
X            color = (int) (254l * zpixel / zdots);
X            (*plot) (col, row, color + 1);
X         }
X         plotted = 1;
X         break;
X      }
X      mxfp += dmxfp;
X      myfp += dmyfp;
X      jxfp += djxfp;
X      jyfp += djyfp;
X   }
X   return (0);
X}
X
Xint
XStd4dFractal(void)
X{
X   long x, y;
X   int xdot, ydot;
X   c_exp = param[2];
X   if(neworbittype == LJULIAZPOWER)
X   {
X      if(c_exp < 1)
X         c_exp = 1;
X      if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
X          fractalspecific[neworbittype].orbitcalc = longZpowerFractal;
X      else
X          fractalspecific[neworbittype].orbitcalc = longCmplxZpowerFractal;
X   }
X
X   for (y = 0, ydot = (ydots >> 1) - 1; ydot >= 0; ydot--, y -= inch_per_ydot)
X   {
X      plotted = 0;
X      x = -(width >> 1);
X      for (xdot = 0; xdot < xdots; xdot++, x += inch_per_xdot)
X      {
X         col = xdot;
X         row = ydot;
X         if (zline(x, y) < 0)
X            return (-1);
X         col = xdots - col - 1;
X         row = ydots - row - 1;
X         if (zline(-x, -y) < 0)
X            return (-1);
X      }
X      if (plotted == 0)
X      {
X         if (y == 0)
X           plotted = -1;  /* no points first pass; don't give up */
X         else
X           break;
X      }
X   }
X   return (0);
X}
Xint
XStd4dfpFractal(void)
X{
X   double x, y;
X   int xdot, ydot;
X   c_exp = param[2];
X
X   if(neworbittype == FPJULIAZPOWER)
X   {
X      if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
X          fractalspecific[neworbittype].orbitcalc = floatZpowerFractal;
X      else
X          fractalspecific[neworbittype].orbitcalc = floatCmplxZpowerFractal;
X      get_julia_attractor (param[0], param[1]);    /* another attractor? */
X   }
X
X   for (y = 0, ydot = (ydots >> 1) - 1; ydot >= 0; ydot--, y -= inch_per_ydotfp)
X   {
X      plotted = 0;
X      x = -widthfp / 2;
X      for (xdot = 0; xdot < xdots; xdot++, x += inch_per_xdotfp)
X      {
X         col = xdot;
X         row = ydot;
X         if (zlinefp(x, y) < 0)
X            return (-1);
X         col = xdots - col - 1;
X         row = ydots - row - 1;
X         if (zlinefp(-x, -y) < 0)
X            return (-1);
X      }
X      if (plotted == 0)
X      {
X         if (y == 0)
X           plotted = -1;  /* no points first pass; don't give up */
X         else
X           break;
X      }
X   }
X   return (0);
X}
SHAR_EOF
$TOUCH -am 1028230093 jb.c &&
chmod 0644 jb.c ||
echo "restore of jb.c failed"
set `wc -c jb.c`;Wc_c=$1
if test "$Wc_c" != "12009"; then
    echo original size 12009, current size $Wc_c
fi
# ============= jiim.c ==============
echo "x - extracting jiim.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > jiim.c &&
X/*
X * JIIM.C
X *
X * Generates Inverse Julia in real time, lets move a cursor which determines
X * the J-set.
X *
X *  The J-set is generated in a fixed-size window, a third of the screen.
X *
X * This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X *
X *
X * The routines used to set/move the cursor and to save/restore the
X * window were "borrowed" from editpal.c (TW - now we *use* the editpal code)
X *     (if you don't know how to write good code, look for someone who does)
X *
X *    JJB  [[e-mail]]
X *    TIW  Tim Wegner
X *    MS   Michael Snyder
X *    KS   Ken Shirriff
X * Revision History:
X *
X *        7-28-92       JJB  Initial release out of editpal.c
X *        7-29-92       JJB  Added SaveRect() & RestoreRect() - now the
X *                           screen is restored after leaving.
X *        7-30-92       JJB  Now, if the cursor goes into the window, the
X *                           window is moved to the other side of the screen.
X *                           Worked from the first time!
X *        10-09-92      TIW  A major rewrite that merged cut routines duplicated
X *                           in EDITPAL.C and added orbits feature.
X *        11-02-92      KS   Made cursor blink
X *        11-18-92      MS   Altered Inverse Julia to use MIIM method.
X *      11-25-92    MS   Modified MIIM support routines to better be
X *                 shared with stand-alone inverse julia in
X *                 LORENZ.C, and to use DISKVID for swap space.
X *        05-05-93      TIW  Boy this change file really got out of date.
X *                 Added orbits capability, various commands, some
X *                  of Dan Farmer's ideas like circles and lines
X *                 connecting orbits points.
X */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X
X#ifndef XFRACT
X#include <stdarg.h>
X#include <dos.h>     /* for FP_SEG & FP_OFF */
X#else
X#include <varargs.h>
X#endif
X
X#include <math.h>
X
X#ifdef __TURBOC__
X#   include <mem.h>   /* to get mem...() declarations */
X#endif
X
X#include "helpdefs.h"
X#include "fractint.h" /* for overlay stuff */
X#include "fractype.h"
X#include "prototyp.h"
X
X#define FAR_RESERVE     8192L     /* amount of far mem we will leave avail. */
X#define MAXRECT         1024      /* largest width of SaveRect/RestoreRect */
X
X#define newx(size)     mem_alloc(size)
X#define delete(block)
X
Xenum stored_at_values
X   {
X   NOWHERE,
X   DISK,
X   MEMORY
X   } ;
X
X/* borrowed from LORENZ.C */
Xstruct affine
X{
X   /* weird order so a,b,e and c,d,f are vectors */
X   double a;
X   double b;
X   double e;
X   double c;
X   double d;
X   double f;
X};
X
Xextern int  setup_convert_to_screen(struct affine *);
X
Xint show_numbers =0;              /* toggle for display of coords */
Xint stored_at;
Xchar far *memory = NULL;            /* pointer to saved rectangle */
XFILE *file;
Xint windows = 0;               /* windows management system */
X
Xextern char scrnfile[];   /* file where screen portion is */
X                  /* stored */
Xextern BYTE      *line_buff;   /* must be alloced!!! */
Xextern int           sxdots;             /* width of physical screen         */
Xextern int           sydots;             /* depth of physical screen         */
Xextern int           sxoffs;             /* start of logical screen          */
Xextern int           syoffs;             /* start of logical screen          */
Xextern int           strlocn[];          /* 10K buffer to store classes in   */
Xextern int           colors;             /* # colors avail.                  */
Xextern int       using_jiim;
Xextern int       viewwindow;     /* 0 for full screen, 1 for window */
Xextern float     viewreduction;  /* window auto-sizing */
Xextern int       viewcrop;               /* nonzero to crop default coords */
Xextern float     finalaspectratio;              /* for view shape and rotation */
Xextern int       viewxdots,viewydots;   /* explicit view sizing */
Xextern double    dxsize, dysize;
Xextern int       xdots;                  /* width of logical screen          */
Xextern int       ydots;                  /* depth of logical screen          */
Xextern double    xxmax,xxmin;    /* limits of the "window"       */
Xextern double    yymax,yymin;    /* on the z-plane               */
Xextern int           color_bright;       /* brightest color in palette       */
Xextern int           color_dark;         /* darkest color in palette         */
Xextern int           color_medium;       /* nearest to medbright gray color  */
Xextern int           lookatmouse;        /* mouse mode for getakey(), etc    */
Xextern int           maxit;                  /* try this many iterations */
Xextern int           fractype;       /* fractal type */
Xextern _CMPLX     old,new,init;
Xextern double tempsqrx,tempsqry;
Xstatic int xc, yc;                       /* corners of the window */
Xstatic int xd, yd;                       /* dots in the window    */
Xextern void displayc(int x, int y, int fg, int bg, int ch);
Xextern float screenaspect;
Xdouble xcjul = BIG;
Xdouble ycjul = BIG;
Xextern int hasinverse;
X
Xvoid displays(int x, int y, int fg, int bg, char *str, int len)
X{
X   int i;
X   for(i=0;i<len; i++)
X      displayc(x+i*8, y, fg, bg, str[i]);
X}
X
X/* circle routines from Dr. Dobbs June 1990 */
Xint xbase, ybase;
Xunsigned xAspect, yAspect;
X
Xvoid SetAspect(double aspect)
X{
X   xAspect = 0;
X   yAspect = 0;
X   aspect = fabs(aspect);
X   if (aspect != 1.0)
X      if (aspect > 1.0)
X     yAspect = 65536.0 / aspect;
X      else
X     xAspect = 65536.0 * aspect;
X}
X
Xvoid _fastcall c_putcolor(int x, int y, int color)
X   {
X   /* avoid writing outside window */
X   if ( x < xc || y < yc || x >= xc + xd || y >= yc + yd )
X      return ;
X   if(y >= sydots - show_numbers) /* avoid overwriting coords */
X      return;
X   if(windows == 2) /* avoid overwriting fractal */
X      if (0 <= x && x < xdots && 0 <= y && y < ydots)
X     return;
X   putcolor(x, y, color);
X   }
X
X
Xint  c_getcolor(int x, int y)
X   {
X   /* avoid reading outside window */
X   if ( x < xc || y < yc || x >= xc + xd || y >= yc + yd )
X      return 1000;
X   if(y >= sydots - show_numbers) /* avoid overreading coords */
X      return 1000;
X   if(windows == 2) /* avoid overreading fractal */
X      if (0 <= x && x < xdots && 0 <= y && y < ydots)
X     return 1000;
X   return getcolor(x, y);
X   }
X
Xvoid circleplot(int x, int y, int color)
X{
X   if (xAspect == 0)
X      if (yAspect == 0)
X     c_putcolor(x+xbase, y+ybase,color);
X      else
X     c_putcolor(x+xbase, (short)(ybase + (((long) y * (long) yAspect) >> 16)),color);
X   else
X      c_putcolor((int)(xbase + (((long) x * (long) xAspect) >> 16)), y+ybase, color);
X}
X
Xvoid plot8(int x, int y, int color)
X{
X   circleplot(x,y,color);
X   circleplot(-x,y,color);
X   circleplot(x,-y,color);
X   circleplot(-x,-y,color);
X   circleplot(y,x,color);
X   circleplot(-y,x,color);
X   circleplot(y,-x,color);
X   circleplot(-y,-x,color);
X}
X
Xvoid circle(int radius, int color)
X{
X   int x,y,sum;
X
X   x = 0;
X   y = radius << 1;
X   sum = 0;
X
X   while (x <= y)
X   {
X      if ( !(x & 1) )   /* plot if x is even */
X     plot8( x >> 1, (y+1) >> 1, color);
X      sum += (x << 1) + 1;
X      x++;
X      if (sum > 0)
X      {
X     sum -= (y << 1) - 1;
X     y--;
X      }
X   }
X}
X
X
X/*
X * MIIM section:
X *
X * Global variables and service functions used for computing
X * MIIM Julias will be grouped here (and shared by code in LORENZ.C)
X *
X */
X
X
X long   ListFront, ListBack, ListSize;  /* head, tail, size of MIIM Queue */
X long   lsize, lmax;            /* how many in queue (now, ever) */
X int    maxhits = 1;
X int    OKtoMIIM;
X int    SecretExperimentalMode;
X float  luckyx = 0, luckyy = 0;
X extern int debugflag;
X extern int           bitshift;         /* bit shift for fudge */
X extern long          fudge;            /* fudge factor (2**n) */
X
X
Xlong lsqrt(long f)
X{
X    int N;
X    unsigned long y0, z;
X    static long a=0, b=0, c=0;                  /* constant factors */
X
X    if (f == 0)
X    return f;
X    if (f <  0)
X    return 0;
X
X    if (a==0)                                   /* one-time compute consts */
X    {
X    a = fudge * .41731;
X    b = fudge * .59016;
X    c = fudge * .7071067811;
X    }
X
X    N  = 0;
X    while (f & 0xff000000L)                     /* shift arg f into the */
X    {                                           /* range: 0.5 <= f < 1  */
X    N++;
X    f /= 2;
X    }
X    while (!(f & 0xff800000L))
X    {
X    N--;
X    f *= 2;
X    }
X
X    y0 = a + multiply(b, f,  bitshift);         /* Newton's approximation */
X
X    z  = y0 + divide (f, y0, bitshift);
X    y0 = (z>>2) + divide(f, z,  bitshift);
X
X    if (N % 2)
X    {
X    N++;
X    y0 = multiply(c,y0, bitshift);
X    }
X    N /= 2;
X    if (N >= 0)
X    return y0 <<  N;                        /* correct for shift above */
X    else
X    return y0 >> -N;
X}
X
X#define SinCosFudge 0x10000L
X
X
XLCMPLX
XComplexSqrtLong(long x, long y)
X{
X   double    mag, theta;
X   long      maglong, thetalong;
X   LCMPLX    result;
X
X#if 1
X   mag       = sqrt(sqrt(((double) multiply(x,x,bitshift))/fudge +
X             ((double) multiply(y,y,bitshift))/ fudge));
X   maglong   = mag * fudge;
X#else
X   maglong   = lsqrt(lsqrt(multiply(x,x,bitshift)+multiply(y,y,bitshift)));
X#endif
X   theta     = atan2((double) y/fudge, (double) x/fudge)/2;
X   thetalong = theta * SinCosFudge;
X   SinCos086(thetalong, &result.y, &result.x);
X   result.x  = multiply(result.x << (bitshift - 16), maglong, bitshift);
X   result.y  = multiply(result.y << (bitshift - 16), maglong, bitshift);
X   return result;
X}
X
X_CMPLX
XComplexSqrtFloat(double x, double y)
X{
X   double mag   = sqrt(sqrt(x*x + y*y));
X   double theta = atan2(y, x) / 2;
X   _CMPLX  result;
X
X   FPUsincos(&theta, &result.y, &result.x);
X   result.x *= mag;
X   result.y *= mag;
X   return result;
X}
X
X
Xextern char dstack[];
X
Xstatic void fillrect(int x, int y, int width, int depth, int color)
X{
X   /* fast version of fillrect */
X   if(hasinverse == 0)
X      return;
X   memset(dstack, color % colors, width);
X   while (depth-- > 0)
X   {
X      if(keypressed()) /* we could do this less often when in fast modes */
X         return;
X      putrow(x, y++, width, dstack);
X   }
X}
X
X/*
X * Queue/Stack Section:
X *
X * Defines a buffer that can be used as a FIFO queue or LIFO stack.
X */
X
Xint
XQueueEmpty()        /* True if NO points remain in queue */
X{
X   return (ListFront == ListBack);
X}
X
Xint
XQueueFull()        /* True if room for NO more points in queue */
X{
X   return (((ListFront + 1) % ListSize) == ListBack);
X}
X
Xint
XQueueFullAlmost()    /* True if room for ONE more point in queue */
X{
X   return (((ListFront + 2) % ListSize) == ListBack);
X}
X
Xvoid
XClearQueue()
X{
X   ListFront = ListBack = lsize = lmax = 0;
X}
X
X
X/*
X * Queue functions for MIIM julia:
X * move to JIIM.C when done
X */
X
Xextern long  ListSize, ListFront, ListBack, lsize, lmax;
Xextern float luckyx, luckyy;
X
Xint Init_Queue(unsigned long request)
X{
X   extern int _fastcall common_startdisk(long, long, int);
X   extern unsigned int xmmlongest();
X   extern unsigned int xmmreallocate(unsigned int, unsigned int);
X   extern int dotmode;
X   unsigned int        largest;
X
X
X   if (dotmode == 11)
X   {
X      static char far *nono = "Don't try this in disk video mode, kids...\n";
X      stopmsg(0, nono);
X      ListSize = 0;
X      return 0;
X   }
X
X#if 0
X   if (xmmquery() && debugflag != 420)    /* use LARGEST extended mem */
X      if ((largest = xmmlongest()) > request / 128)
X     request   = (unsigned long) largest * 128L;
X#endif
X
X   for (ListSize = request; ListSize > 1024; ListSize -= 512)
X      switch (common_startdisk(ListSize * 8, 1, 256))
X      {
X     case 0:                        /* success */
X        ListFront = ListBack = 0;
X        lsize = lmax = 0;
X        return 1;
X     case -1:
X        continue;            /* try smaller queue size */
X     case -2:
X        ListSize = 0;               /* cancelled by user      */
X        return 0;
X      }
X
X   /* failed to get memory for MIIM Queue */
X   ListSize = 0;
X   return 0;
X}
X
Xvoid
XFree_Queue()
X{
X   enddisk();
X   ListFront = ListBack = ListSize = lsize = lmax = 0;
X}
X
Xextern int ToMemDisk  (long, int, void far *);
Xextern int FromMemDisk(long, int, void far *);
X
Xint
XPushLong(long x, long y)
X{
X   if (((ListFront + 1) % ListSize) != ListBack)
X   {
X      if (ToMemDisk(8*ListFront, sizeof(x), &x) &&
X      ToMemDisk(8*ListFront +sizeof(x), sizeof(y), &y))
X      {
X     ListFront = (ListFront + 1) % ListSize;
X     if (++lsize > lmax)
X     {
X        lmax   = lsize;
X        luckyx = x;
X        luckyy = y;
X     }
X     return 1;
X      }
X   }
X   return 0;            /* fail */
X}
X
Xint
XPushFloat(float x, float y)
X{
X   if (((ListFront + 1) % ListSize) != ListBack)
X   {
X      if (ToMemDisk(8*ListFront, sizeof(x), &x) &&
X      ToMemDisk(8*ListFront +sizeof(x), sizeof(y), &y))
X      {
X     ListFront = (ListFront + 1) % ListSize;
X     if (++lsize > lmax)
X     {
X        lmax   = lsize;
X        luckyx = x;
X        luckyy = y;
X     }
X     return 1;
X      }
X   }
X   return 0;            /* fail */
X}
X
X_CMPLX
XPopFloat()
X{
X   _CMPLX pop;
X   float  popx, popy;
X
X   if (!QueueEmpty())
X   {
X      ListFront--;
X      if (ListFront < 0)
X      ListFront = ListSize - 1;
X      if (FromMemDisk(8*ListFront, sizeof(popx), &popx) &&
X      FromMemDisk(8*ListFront +sizeof(popx), sizeof(popy), &popy))
X      {
X     pop.x = popx;
X     pop.y = popy;
X     --lsize;
X      }
X      return pop;
X   }
X   pop.x = 0;
X   pop.y = 0;
X   return pop;
X}
X
XLCMPLX
XPopLong()
X{
X   LCMPLX pop;
X
X   if (!QueueEmpty())
X   {
X      ListFront--;
X      if (ListFront < 0)
X      ListFront = ListSize - 1;
X      if (FromMemDisk(8*ListFront, sizeof(pop.x), &pop.x) &&
X      FromMemDisk(8*ListFront +sizeof(pop.x), sizeof(pop.y), &pop.y))
X     --lsize;
X      return pop;
X   }
X   pop.x = 0;
X   pop.y = 0;
X   return pop;
X}
X
Xint
XEnQueueFloat(float x, float y)
X{
X   return PushFloat(x, y);
X}
X
Xint
XEnQueueLong(long x, long y)
X{
X   return PushLong(x, y);
X}
X
X_CMPLX
XDeQueueFloat()
X{
X   _CMPLX out;
X   float outx, outy;
X
X   if (ListBack != ListFront)
X   {
X      if (FromMemDisk(8*ListBack, sizeof(outx), &outx) &&
X      FromMemDisk(8*ListBack +sizeof(outx), sizeof(outy), &outy))
X      {
X     ListBack = (ListBack + 1) % ListSize;
X     out.x = outx;
X     out.y = outy;
X     lsize--;
X      }
X      return out;
X   }
X   out.x = 0;
X   out.y = 0;
X   return out;
X}
X
XLCMPLX
XDeQueueLong()
X{
X   LCMPLX out;
X   out.x = 0;
X   out.y = 0;
X
X   if (ListBack != ListFront)
X   {
X      if (FromMemDisk(8*ListBack, sizeof(out.x), &out.x) &&
X      FromMemDisk(8*ListBack +sizeof(out.x), sizeof(out.y), &out.y))
X      {
X     ListBack = (ListBack + 1) % ListSize;
X     lsize--;
X      }
X      return out;
X   }
X   out.x = 0;
X   out.y = 0;
X   return out;
X}
X
X
X
X/*
X * End MIIM section;
X */
X
X
X
Xstatic BOOLEAN MemoryAlloc(long size)
X{
X   char far *temp;
X
X   if (debugflag == 420)
X      return(FALSE);
X   temp = (char far *)farmemalloc(FAR_RESERVE);   /* minimum free space */
X
X   if (temp == NULL)
X   {
X      stored_at = NOWHERE;
X      return (FALSE);   /* can't do it */
X   }
X
X   memory = (char far *)farmemalloc( size );
X   farmemfree(temp);
X
X   if ( memory == NULL )
X   {
X      stored_at = NOWHERE;
X      return (FALSE);
X   }
X   else
X   {
X      stored_at = MEMORY;
X      return (TRUE);
X   }
X}
X
X
Xstatic void SaveRect(int x, int y, int width, int depth)
X{
X   char buff[MAXRECT];
X   int  yoff;
X   if(hasinverse == 0)
X      return;
X   /* first, do any de-allocationg */
X
X   switch( stored_at )
X   {
X   case NOWHERE:
X      break;
X
X   case DISK:
X      break;
X
X   case MEMORY:
X      if (memory != NULL)
X      {
X     farmemfree(memory);
X      }
X      memory = NULL;
X      break;
X   }
X
X   /* allocate space and store the rect */
X
X   memset(dstack, color_dark, width);
X   if ( MemoryAlloc( (long)width*(long)depth) )
X   {
X      char far  *ptr = memory;
X      char far  *bufptr = buff; /* MSC needs this indirection to get it right */
X
X      Cursor_Hide();
X      for (yoff=0; yoff<depth; yoff++)
X      {
X     getrow(x, y+yoff, width, buff);
X     putrow(x, y+yoff, width, dstack);
X     movedata(FP_SEG(bufptr), FP_OFF(bufptr), FP_SEG(ptr), FP_OFF(ptr), width);
X     ptr = (char far *)normalize(ptr+width);
X      }
X      Cursor_Show();
X   }
X
X   else /* to disk */
X   {
X      stored_at = DISK;
X
X      if ( file == NULL )
X      {
X     file = fopen(scrnfile, "w+b");
X     if (file == NULL)
X     {
X        stored_at = NOWHERE;
X        buzzer(3);
X        return ;
X     }
X      }
X
X      rewind(file);
X      Cursor_Hide();
X      for (yoff=0; yoff<depth; yoff++)
X      {
X     getrow(x, y+yoff, width, buff);
X     putrow(x, y+yoff, width, dstack);
X     if ( fwrite(buff, width, 1, file) != 1 )
X     {
X        buzzer(3);
X        break;
X     }
X      }
X      Cursor_Show();
X   }
X}
X
X
Xstatic void RestoreRect(x, y, width, depth)
X{
X   char buff[MAXRECT];
X   int  yoff;
X   if(hasinverse == 0)
X      return;
X
X   switch ( stored_at )
X   {
X   case DISK:
X      rewind(file);
X      Cursor_Hide();
X      for (yoff=0; yoff<depth; yoff++)
X      {
X     if ( fread(buff, width, 1, file) != 1 )
X     {
X        buzzer(3);
X        break;
X     }
X     putrow(x, y+yoff, width, buff);
X      }
X      Cursor_Show();
X      break;
X
X   case MEMORY:
X      {
X     char far  *ptr = memory;
X     char far  *bufptr = buff; /* MSC needs this indirection to get it right */
X
X     Cursor_Hide();
X     for (yoff=0; yoff<depth; yoff++)
X     {
X        movedata(FP_SEG(ptr), FP_OFF(ptr), FP_SEG(bufptr), FP_OFF(bufptr), width);
X        putrow(x, y+yoff, width, buff);
X        ptr = (char far *)normalize(ptr+width);
X     }
X     Cursor_Show();
X     break;
X      }
X
X   case NOWHERE:
X      break;
X   } /* switch */
X}
X
X/*
X * interface to FRACTINT
X */
Xint jfractype;
X
Xextern int row, col;
Xextern double far *dx0, far *dy0;
Xextern double far *dx1, far *dy1;
Xextern int integerfractal;
Xextern long far *lx0, far *ly0;
Xextern long far *lx1, far *ly1;
Xextern int bitshift;
Xextern int helpmode;
X
X/* the following macros and function call the setup, per_pixel, and orbit
X   routines and calculate an orbit at row 0 column 0. Have to save and
X   restore the first elements of dx0 ... dy1 as well as row and col */
X
X#define PER_IMAGE fractalspecific[o_fractype].per_image
X#define PER_PIXEL fractalspecific[o_fractype].per_pixel
X#define ORBITCALC   fractalspecific[o_fractype].orbitcalc
X
Xint do_fractal_routines(double cr, double ci, int (*func)())
X{
X   int ret;
X   int old_row, old_col;
X   double old_dx0, old_dx1, old_dy0, old_dy1;
X   old_dx0 = *dx0; old_dx1 = *dx1;
X   old_dy0 = *dy0; old_dy1 = *dy1;
X   old_row = row;  old_col = col;
X   row = col = 0;
X   *dx0 = cr; *dy0 = ci; *dx1 = *dy1 = 0.0;
X   ret = func();
X   *dx0 = old_dx0; *dx1 = old_dx1;
X   *dy0 = old_dy0; *dy1 = old_dy1;
X   row = old_row;  col = old_col;
X   return(ret);
X}
X
X
Xvoid Jiim(int which)         /* called by fractint */
X{
X   struct affine cvt;
X   int exact = 0;
X   int oldhelpmode;
X   int count = 0;            /* coloring julia */
X   static int mode = 0;      /* point, circle, ... */
X   int       oldlookatmouse = lookatmouse;
X   double cr, ci, r;
X   int xfactor, yfactor;             /* aspect ratio          */
X
X   int xoff, yoff;                   /* center of the window  */
X   int x, y;
X   int still, kbdchar;
X   int xcrsr,ycrsr;     /* coords of the cursor / offsets to move it  */
X   int iter;
X   int color;
X   float zoom;
X   int oldsxoffs, oldsyoffs;
X   int savehasinverse;
X   int (*oldcalctype)();
X   extern int (*calctype)();
X   int o_fractype;
X   int old_x, old_y;
X   double aspect;
X   static int randir = 0;
X   static int rancnt = 0;
X   static _CMPLX SaveC = {-3000.0, -3000.0};
X   int actively_computing = 1;
X   int first_time = 1;
X
X   ENTER_OVLY(OVLY_ROTATE);
X   /* must use standard fractal and have a float variant */
X   if(fractalspecific[fractype].calctype != StandardFractal ||
X     (fractalspecific[fractype].isinteger &&
X     fractalspecific[fractype].tofloat == NOFRACTAL))
X   {
X       EXIT_OVLY;
X       return;
X   }
X   oldhelpmode = helpmode;
X   if(which == JIIM)
X      helpmode = HELP_JIIM;
X   else
X   {
X      helpmode = HELP_ORBITS;
X      hasinverse = 1;
X   }
X   if(fractalspecific[fractype].isinteger)
X      o_fractype = fractalspecific[fractype].tofloat;
X   else
X      o_fractype = fractype;
X   oldsxoffs = sxoffs;
X   oldsyoffs = syoffs;
X   oldcalctype = calctype;
X   show_numbers = 0;
X   using_jiim = 1;
X   mem_init(strlocn, 10*1024);
X   line_buff = newx(max(sxdots,sydots));
X   aspect = ((double)xdots*3)/((double)ydots*4);  /* assumes 4:3 */
X     actively_computing = 1;
X   SetAspect(aspect);
X   lookatmouse = 3;
X   Cursor_Construct();
X
X/*
X * MIIM code:
X * Grab far memory for Queue/Stack before SaveRect gets it.
X */
X   OKtoMIIM  = 0;
X   if (which == JIIM && debugflag != 300)
X      OKtoMIIM = Init_Queue((long)8*1024); /* Queue Set-up Successful? */
X
X   maxhits = 1;
X   if (which == ORBIT)
X      plot = c_putcolor;             /* for line with clipping */
X
X/*
X * end MIIM code.
X */
X
X
X   if(sxoffs != 0 || syoffs != 0) /* we're in view windows */
X   {
X      savehasinverse = hasinverse;
X      hasinverse = 1;
X      SaveRect(0,0,xdots,ydots);
X      sxoffs = 0;
X      syoffs = 0;
X      RestoreRect(0,0,xdots,ydots);
X      hasinverse = savehasinverse;
X   }
X
X   if(which == ORBIT)
X      do_fractal_routines(cr, ci,PER_IMAGE);
X   else
X      color = color_bright;
X
X   oldhelpmode = helpmode;
X   if(which == JIIM)
X      helpmode = HELP_JIIM;
X   else
X      helpmode = HELP_ORBITS;
X
X   if(xdots == sxdots || ydots == sydots ||
X       sxdots-xdots < sxdots/3 ||
X       sydots-ydots < sydots/3 ||
X       xdots >= MAXRECT )
X   {
X      /* this mode puts orbit/julia in an overlapping window 1/3 the size of
X     the physical screen */
X      windows = 0; /* full screen or large view window */
X      xd = sxdots / 3;
X      yd = sydots / 3;
X      xc = xd * 2;
X      yc = yd * 2;
X      xoff = xd * 5 / 2;
X      yoff = yd * 5 / 2;
X   }
X   else if(xdots > sxdots/3 && ydots > sydots/3)
X   {
X      /* Julia/orbit and fractal don't overlap */
X      windows = 1;
X      xd = sxdots-xdots;
X      yd = sydots-ydots;
X      xc = xdots;
X      yc = ydots;
X      xoff = xc + xd/2;
X      yoff = yc + yd/2;
X
X   }
X   else
X   {
X      /* Julia/orbit takes whole screen */
X      windows = 2;
X      xd = sxdots;
X      yd = sydots;
X      xc = 0;
X      yc = 0;
X      xoff = xd/2;
X      yoff = yd/2;
X   }
X
X   xfactor = xd/5.33;
X   yfactor = -yd/4;
X
X   if(windows == 0)
X      SaveRect(xc,yc,xd,yd);
X   else if(windows == 2)  /* leave the fractal */
X   {
X      fillrect(xdots, yc, xd-xdots, yd, color_dark);
X      fillrect(xc   , ydots, xdots, yd-ydots, color_dark);
X   }
X   else  /* blank whole window */
X      fillrect(xc, yc, xd, yd, color_dark);
X
X   setup_convert_to_screen(&cvt);
X
X   /* reuse last location if inside window */
X   xcrsr = cvt.a*SaveC.x + cvt.b*SaveC.y + cvt.e + .5;
X   ycrsr = cvt.c*SaveC.x + cvt.d*SaveC.y + cvt.f + .5;
X   if(xcrsr < 0 || xcrsr >= xdots ||
X      ycrsr < 0 || ycrsr >= ydots)
X   {
X      cr = (xxmax + xxmin) / 2.0;
X      ci = (yymax + yymin) / 2.0;
X   }
X   else
X   {
X      cr = SaveC.x;
X      ci = SaveC.y;
X   }
X
X   old_x = old_y = -1;
X
X   xcrsr = cvt.a*cr + cvt.b*ci + cvt.e + .5;
X   ycrsr = cvt.c*cr + cvt.d*ci + cvt.f + .5;
X
X   Cursor_SetPos(xcrsr, ycrsr);
X   Cursor_Show();
X   color = color_bright;
X
X   iter = 1;
X   still = 1;
X   zoom = 1;
X
X#ifdef XFRACT
X   Cursor_StartMouseTracking();
X#endif
X
X   while (still)
X   {
X      int dxcrsr, dycrsr;
X      if (actively_computing) {
X      Cursor_CheckBlink();
X      } else {
X      Cursor_WaitKey();
X      }
X      if(keypressed() || first_time) /* prevent burning up UNIX CPU */
X      {
X     first_time = 0;
X     while(keypressed())
X     {
X        Cursor_WaitKey();
X        kbdchar = getakey();
X
X        dxcrsr = dycrsr = 0;
X        xcjul = BIG;
X        ycjul = BIG;
X        switch (kbdchar)
X        {
X            case 1143:    /* ctrl - keypad 5 */
X        case 1076:    /* keypad 5        */
X           break;     /* do nothing */
X        case CTL_PAGE_UP:
X           dxcrsr = 4;
X           dycrsr = -4;
X           break;
X        case CTL_PAGE_DOWN:
X           dxcrsr = 4;
X           dycrsr = 4;
X           break;
X        case CTL_HOME:
X           dxcrsr = -4;
X           dycrsr = -4;
X           break;
X        case CTL_END:
X           dxcrsr = -4;
X           dycrsr = 4;
X           break;
X        case PAGE_UP:
X           dxcrsr = 1;
X           dycrsr = -1;
X           break;
X        case PAGE_DOWN:
X           dxcrsr = 1;
X           dycrsr = 1;
X           break;
X        case HOME:
X           dxcrsr = -1;
X           dycrsr = -1;
X           break;
X        case END:
X           dxcrsr = -1;
X           dycrsr = 1;
X           break;
X        case UP_ARROW:
X           dycrsr = -1;
X           break;
X        case DOWN_ARROW:
X           dycrsr = 1;
X           break;
X        case LEFT_ARROW:
X           dxcrsr = -1;
X           break;
X        case RIGHT_ARROW:
X           dxcrsr = 1;
X           break;
X        case UP_ARROW_2:
X           dycrsr = -4;
X           break;
X        case DOWN_ARROW_2:
X           dycrsr = 4;
X           break;
X        case LEFT_ARROW_2:
X           dxcrsr = -4;
X           break;
X        case RIGHT_ARROW_2:
X           dxcrsr = 4;
X           break;
X        case 'z':
X        case 'Z':
X           zoom = 1.0;
X           break;
X        case '<':
X        case ',':
X           zoom /= 1.15;
X           break;
X        case '>':
X        case '.':
X           zoom *= 1.15;
X           break;
X        case SPACE:
X           xcjul = cr;
X           ycjul = ci;
X           goto finish;
X           break;
X        case 'c':   /* circle toggle */
X        case 'C':   /* circle toggle */
X           mode = mode ^ 1;
X           break;
X        case 'l':
X        case 'L':
X           mode = mode ^ 2;
X           break;
X        case 'n':
X        case 'N':
X           show_numbers = 8 - show_numbers;
X           if(windows == 0 && show_numbers == 0)
X           {
X          Cursor_Hide();
X          cleartempmsg();
X          Cursor_Show();
X           }
X           break;
X        case 'p':
X        case 'P':
X           get_a_number(&cr,&ci);
X               exact = 1;
X               xcrsr = cvt.a*cr + cvt.b*ci + cvt.e + .5;
X               ycrsr = cvt.c*cr + cvt.d*ci + cvt.f + .5;
X               dxcrsr = dycrsr = 0;
X           break;
X        case 'h':   /* hide fractal toggle */
X        case 'H':   /* hide fractal toggle */
X           if(windows == 2)
X          windows = 3;
X           else if(windows == 3 && xd == sxdots)
X           {
X          RestoreRect(0, 0, xdots, ydots);
X          windows = 2;
X           }
X           break;
X#ifdef XFRACT
X        case ENTER:
X        break;
X#endif
X        case '0':
X        case '1':
X        case '2':
X/*        case '3': */  /* don't use '3', it's already meaningful */
X        case '4':
X        case '5':
X        case '6':
X        case '7':
X        case '8':
X        case '9':
X           if (which == JIIM)
X           {
X          SecretExperimentalMode = kbdchar - '0';
X          break;
X           }
X        default:
X           still = 0;
X        }  /* switch */
X        if(kbdchar == 's' || kbdchar == 'S')
X           goto finish;
X            if(dxcrsr > 0 || dycrsr > 0)
X               exact = 0;
X            xcrsr += dxcrsr;
X            ycrsr += dycrsr;
X#ifdef XFRACT
X        if (kbdchar == ENTER) {
X        /* We want to use the position of the cursor */
X        exact=0;
X        xcrsr = Cursor_GetX();
X        ycrsr = Cursor_GetY();
X        }
X#endif
X
X        /* keep cursor in logical screen */
X       if(xcrsr >= xdots)
X          xcrsr = xdots -1, exact = 0;
X       if(ycrsr >= ydots)
X          ycrsr = ydots -1, exact = 0;
X       if(xcrsr < 0)
X          xcrsr = 0, exact = 0;
X       if(ycrsr < 0)
X          ycrsr = 0, exact = 0;
X
X            Cursor_SetPos(xcrsr,ycrsr);
X     }  /* end while (keypressed) */
X
X         if(exact == 0)
X         {
X        if(integerfractal)
X        {
X           cr = lx0[xcrsr]+lx1[ycrsr];  /* supports rotated zoom boxes! */
X           ci = ly0[ycrsr]+ly1[xcrsr];
X           cr /= (1L<<bitshift);
X           ci /= (1L<<bitshift);
X        }
X        else
X        {
X           cr = dx0[xcrsr]+dx1[ycrsr];
X           ci = dy0[ycrsr]+dy1[xcrsr];
X        }
X     }
X     actively_computing = 1;
X     if(show_numbers) /* write coordinates on screen */
X     {
X        char str[80];
X        sprintf(str,"x=%16.14f y=%16.14f   ",cr,ci);
X        str[40] = 0;
X        if(windows == 0)
X        {
X           Cursor_Hide();
X           actively_computing = 1;
X           showtempmsg(str);
X           Cursor_Show();
X        }
X        else
X           displays(5, sydots-show_numbers, WHITE, BLACK, str,strlen(str));
X     }
X     iter = 1;
X     old.x = old.y = 0;
X     SaveC.x = init.x =  cr;
X     SaveC.y = init.y =  ci;
X     old_x = old_y = -1;
X/*
X * MIIM code:
X * compute fixed points and use them as starting points of JIIM
X */
X     if (which == JIIM && OKtoMIIM)
X     {
X        _CMPLX f1, f2, Sqrt;    /* Fixed points of Julia */
X
X        Sqrt = ComplexSqrtFloat(1 - 4 * cr, -4 * ci);
X        f1.x = (1 + Sqrt.x) / 2;
X        f2.x = (1 - Sqrt.x) / 2;
X        f1.y =  Sqrt.y / 2;
X        f2.y = -Sqrt.y / 2;
X
X        ClearQueue();
X        maxhits = 1;
X        EnQueueFloat(f1.x, f1.y);
X        EnQueueFloat(f2.x, f2.y);
X     }
X/*
X * End MIIM code.
X */
X     if(which == ORBIT)
X           do_fractal_routines(cr, ci,PER_PIXEL);
X     /* move window if bumped */
X     if(windows==0 && xcrsr>xc && xcrsr < xc+xd && ycrsr>yc && ycrsr < yc+yd)
X     {
X        RestoreRect(xc,yc,xd,yd);
X        if (xc == xd*2)
X           xc = 2;
X        else
X           xc = xd*2;
X        xoff = xc + xd /  2;
X        SaveRect(xc,yc,xd,yd);
X     }
X     if(windows == 2)
X     {
X        fillrect(xdots, yc, xd-xdots, yd-show_numbers, color_dark);
X        fillrect(xc   , ydots, xdots, yd-ydots-show_numbers, color_dark);
X     }
X     else
X        fillrect(xc, yc, xd, yd, color_dark);
X
X      } /* end if (keypressed) */
X
X      if(which == JIIM)
X      {
X         if(hasinverse == 0)
X            continue;
X/*
X * MIIM code:
X * If we have MIIM queue allocated, then use MIIM method.
X */
X     if (OKtoMIIM)
X     {
X        if (QueueEmpty())
X        {
X           if (maxhits < colors - 1 && maxhits < 5 &&
X          (luckyx != 0.0 || luckyy != 0.0))
X           {
X          int i;
X
X          lsize  = lmax   = 0;
X          old.x  = new.x  = luckyx;
X          old.y  = new.y  = luckyy;
X          luckyx = luckyy = 0.0;
X          for (i=0; i<199; i++)
X          {
X             old = ComplexSqrtFloat(old.x - cr, old.y - ci);
X             new = ComplexSqrtFloat(new.x - cr, new.y - ci);
X             EnQueueFloat( new.x,  new.y);
X             EnQueueFloat(-old.x, -old.y);
X          }
X          maxhits++;
X           }
X           else
X          continue;        /* loop while (still) */
X        }
X
X        old = DeQueueFloat();
X
X#if 0 /* try a different new method */
X        if (lsize < (lmax / 8) && maxhits < 5)    /* NEW METHOD */
X           if (maxhits < colors - 1)
X           maxhits++;
X#endif
X        x = old.x * xfactor * zoom + xoff;
X        y = old.y * yfactor * zoom + yoff;
X        color = c_getcolor(x, y);
X        if (color < maxhits)
X        {
X           c_putcolor(x, y, color + 1);
X           new = ComplexSqrtFloat(old.x - cr, old.y - ci);
X           EnQueueFloat( new.x,  new.y);
X           EnQueueFloat(-new.x, -new.y);
X        }
X     }
X     else
X     {
X/*
X * end Msnyder code, commence if not MIIM code.
X */
X     old.x -= cr;
X     old.y -= ci;
X     r = old.x*old.x + old.y*old.y;
X     if(r > 10.0)
X     {
X         old.x = old.y = 0.0; /* avoids math error */
X         iter = 1;
X     }
X     iter++;
X     color = ((count++)>>5)&(colors-1); /* chg color every 32 pts */
X     if(color==0)
X      color = 1;
X
X     r = sqrt(old.x*old.x + old.y*old.y);
X     new.x = sqrt(fabs((r + old.x)/2));
X     if (old.y < 0)
X        new.x = -new.x;
X
X     new.y = sqrt(fabs((r - old.x)/2));
X
X
X     switch (SecretExperimentalMode) {
X        case 0:            /* unmodified random walk */
X        default:
X        if (rand() % 2)
X        {
X           new.x = -new.x;
X           new.y = -new.y;
X        }
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        break;
X        case 1:              /* always go one direction */
X        if (SaveC.y < 0)
X        {
X           new.x = -new.x;
X           new.y = -new.y;
X        }
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        break;
X        case 2:            /* go one dir, draw the other */
X        if (SaveC.y < 0)
X        {
X           new.x = -new.x;
X           new.y = -new.y;
X        }
X        x = -new.x * xfactor * zoom + xoff;
X        y = -new.y * yfactor * zoom + yoff;
X        break;
X        case 4:            /* go negative if max color */
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        if (c_getcolor(x, y) == colors - 1)
X        {
X           new.x = -new.x;
X           new.y = -new.y;
X           x = new.x * xfactor * zoom + xoff;
X           y = new.y * yfactor * zoom + yoff;
X        }
X        break;
X        case 5:            /* go positive if max color */
X        new.x = -new.x;
X        new.y = -new.y;
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        if (c_getcolor(x, y) == colors - 1)
X        {
X           x = new.x * xfactor * zoom + xoff;
X           y = new.y * yfactor * zoom + yoff;
X        }
X        break;
X        case 7:
X        if (SaveC.y < 0)
X        {
X           new.x = -new.x;
X           new.y = -new.y;
X        }
X        x = -new.x * xfactor * zoom + xoff;
X        y = -new.y * yfactor * zoom + yoff;
X        if(iter > 10)
X        {
X           if(mode == 0)            /* pixels  */
X              c_putcolor(x, y, color);
X           else if (mode & 1)            /* circles */
X           {
X              xbase = x;
X              ybase = y;
X              circle((int)(zoom*(xd >> 1)/iter),color);
X           }
X           if ((mode & 2) && x > 0 && y > 0 && old_x > 0 && old_y > 0)
X           {
X              draw_line(x, y, old_x, old_y, color);
X           }
X           old_x = x;
X           old_y = y;
X        }
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        break;
X        case 8:            /* go in long zig zags */
X        if (rancnt >= 300)
X            rancnt = -300;
X        if (rancnt < 0)
X        {
X            new.x = -new.x;
X            new.y = -new.y;
X        }
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        break;
X        case 9:            /* "random run" */
X        switch (randir) {
X            case 0:             /* go random direction for a while */
X            if (rand() % 2)
X            {
X                new.x = -new.x;
X                new.y = -new.y;
X            }
X            if (++rancnt > 1024)
X            {
X                rancnt = 0;
X                if (rand() % 2)
X                randir =  1;
X                else
X                randir = -1;
X            }
X            break;
X            case 1:             /* now go negative dir for a while */
X            new.x = -new.x;
X            new.y = -new.y;
X            /* fall through */
X            case -1:            /* now go positive dir for a while */
X            if (++rancnt > 512)
X                randir = rancnt = 0;
X            break;
X        }
X        x = new.x * xfactor * zoom + xoff;
X        y = new.y * yfactor * zoom + yoff;
X        break;
X     } /* end switch SecretMode (sorry about the indentation) */
X     } /* end if not MIIM */
X      }
X      else /* orbits */
X      {
X     if(iter < maxit)
X     {
X        color = iter&(colors-1);
X        x = (old.x - init.x) * xfactor * 3 * zoom + xoff;
X        y = (old.y - init.y) * yfactor * 3 * zoom + yoff;
X        if(do_fractal_routines(cr, ci,ORBITCALC))
X           iter = maxit;
X        else
X           iter++;
X     }
X     else
X     {
X        x = y = -1;
X        actively_computing = 0;
X     }
X      }
X      if(which == ORBIT || iter > 10)
X      {
X     if(mode == 0)            /* pixels  */
X        c_putcolor(x, y, color);
X     else if (mode & 1)            /* circles */
X     {
X        xbase = x;
X        ybase = y;
X        circle((int)(zoom*(xd >> 1)/iter),color);
X     }
X     if ((mode & 2) && x > 0 && y > 0 && old_x > 0 && old_y > 0)
X     {
X        draw_line(x, y, old_x, old_y, color);
X     }
X     old_x = x;
X     old_y = y;
X      }
X      old = new;
X   } /* end while(still) */
Xfinish:
X
X/*
X * Msnyder code:
X * free MIIM queue
X */
X
X   Free_Queue();
X/*
X * end Msnyder code.
X */
X
X   if(kbdchar != 's'&& kbdchar != 'S')
X   {
X      Cursor_Hide();
X      if(windows == 0)
X     RestoreRect(xc,yc,xd,yd);
X      else if(windows >= 2 )
X      {
X     if(windows == 2)
X     {
X        fillrect(xdots, yc, xd-xdots, yd, color_dark);
X        fillrect(xc   , ydots, xdots, yd-ydots, color_dark);
X     }
X     else
X        fillrect(xc, yc, xd, yd, color_dark);
X         if(windows == 3 && xd == sxdots) /* unhide */
X         {
X            RestoreRect(0, 0, xdots, ydots);
X            windows = 2;
X         }
X     Cursor_Hide();
X     savehasinverse = hasinverse;
X     hasinverse = 1;
X     SaveRect(0,0,xdots,ydots);
X     sxoffs = oldsxoffs;
X     syoffs = oldsyoffs;
X     RestoreRect(0,0,xdots,ydots);
X     hasinverse = savehasinverse;
X      }
X   }
X   Cursor_Destroy();
X#ifdef XFRACT
X   Cursor_EndMouseTracking();
X#endif
X   delete(line_buff);
X   if (memory)            /* done with memory, free it */
X   {
X      farmemfree(memory);
X      memory = NULL;
X   }
X
X   lookatmouse = oldlookatmouse;
X   using_jiim = 0;
X   calctype = oldcalctype;
X
X   helpmode = oldhelpmode;
X   if(kbdchar == 's' || kbdchar == 'S')
X   {
X      viewwindow = viewxdots = viewydots = 0;
X      viewreduction = 4.2;
X      viewcrop = 1;
X      finalaspectratio = screenaspect;
X      xdots = sxdots;
X      ydots = sydots;
X      dxsize = xdots - 1;
X      dysize = ydots - 1;
X      sxoffs = 0;
X      syoffs = 0;
X      freetempmsg();
X   }
X   else
X      cleartempmsg();
X   if (file != NULL)
X      {
X      fclose(file);
X      file = NULL;
X      remove(scrnfile);
X      }
X   show_numbers = 0;
X   ungetakey(kbdchar);
X   EXIT_OVLY;
X}
X
SHAR_EOF
$TOUCH -am 1028230093 jiim.c &&
chmod 0644 jiim.c ||
echo "restore of jiim.c failed"
set `wc -c jiim.c`;Wc_c=$1
if test "$Wc_c" != "35541"; then
    echo original size 35541, current size $Wc_c
fi
# ============= line3d.c ==============
echo "x - extracting line3d.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > line3d.c &&
X/******************************************************************************/
X/* This file contains a 3D replacement for the out_line function called            */
X/* by the decoder. The purpose is to apply various 3D transformations            */
X/* before displaying points. Called once per line of the input file.                */
X/*                                                                                                        */
X/* This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.            */
X/*                                                                                                        */
X/* Original Author Tim Wegner, with extensive help from Marc Reinig.                */
X/*****************************************************************************/
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <limits.h>
X#ifndef XFRACT
X#include <dos.h>
X#endif
X#include "fractint.h"
X#include "prototyp.h"
X
Xstruct point
X{
X    int x;
X    int y;
X    int color;
X};
X
X/* routines in this module    */
X
Xstatic void _fastcall vdraw_line(double *,double *,int);
Xstatic void (_fastcall *fillplot)(int,int,int);
Xstatic void (_fastcall *normalplot)(int,int,int);
Xstatic void _fastcall putminmax(int x,int y,int color);
Xstatic void _fastcall clipcolor(int x,int y,int color);
Xstatic void _fastcall T_clipcolor(int x,int y,int color);
Xstatic void _fastcall interpcolor(int x,int y,int color);
Xstatic void corners(),draw_light_box();
Xstatic void _fastcall putatriangle(struct point pt1,struct point pt2,
X                    struct point pt3,int color);
Xstatic int _fastcall offscreen(struct point pt);
Xstatic int  H_R(),R_H();
Xstatic int  startdisk1(char *File_Name2, FILE *Source, int overlay);
Xstatic int  set_pixel_buff();
Xstatic void line3d_cleanup();
Xextern int glassestype, whichimage;
Xvoid (_fastcall *standardplot)(int,int,int);
X
Xstatic    int line_length1;
Xstatic    int T_header_24 = 18; /* Size of current Targa-24 header */
Xextern    BYTE dacbox[256][3];
XMATRIX m;                /* transformation matrix */
Xvoid (*mult_vec)(VECTOR) = mult_vec_c;
Xextern int iit;                 /* iit flag */
Xstatic    FILE *File_Ptr1 = NULL;
Xint Ambient;
Xstatic unsigned int IAmbient;
Xint RANDOMIZE;
Xstatic int rand_factor;
Xint haze;
Xstatic int HAZE_MULT;
Xint Real_V = 0; /* mrr Actual value of V for fillytpe>4 monochrome images */
X
Xchar light_name[80] = "fract001";
Xint Targa_Overlay, error;
Xextern int Targa_Out;
Xchar targa_temp[14] = "fractemp.tga";
Xstatic void File_Error (char *File_Name1, int ERROR);
Xstatic BYTE T24=24;
Xstatic BYTE T32=32;
Xstatic BYTE upr_lwr[4];
Xstatic int T_Safe; /* Original Targa Image successfully copied to targa_temp */
Xint P = 250; /* Perspective dist used when viewing light vector */
Xstatic void draw_rect (VECTOR V0, VECTOR V1, VECTOR V2, VECTOR V3, int color,
X                            int rect);
Xstatic VECTOR light_direction;
X
XBYTE back_color[3];
Xstatic BYTE Real_Color; /* Actual color of cur pixel */
Xextern int dotmode; /* video access method, 11 if really disk video */
Xextern int calc_status;
Xextern long calctime;
Xextern int got_status,currow;
X
X
Xstatic int RO, CO, CO_MAX; /*  For use in Acrospin support */
Xstatic char far acro_s1[] =
X    {"Set Layer 1\nSet Color 2\nEndpointList X Y Z Name\n"};
Xstatic char far acro_s2[] = {"LineList From To\n"};
Xstatic char far s3[] = {"{ Created by FRACTINT Ver. "};
Xstatic char far s3a[] = {" }\n\n"};
X#ifndef XFRACT
Xstatic char banner[] ="%Fs%#4.2f%Fs";
X#else
Xstatic char banner[] ="%s%#4.2f%s";
X#endif
Xchar ray_name[80] = "fract001";
X
Xchar preview = 0;
Xchar showbox = 0;
Xstatic int localpreviewfactor;
Xint previewfactor = 20;
Xint xadjust = 0;
Xint yadjust = 0;
Xint xxadjust;
Xint yyadjust;
Xint xshift;
Xint yshift;
Xextern int overflow;
Xextern int filetype;
Xextern char usr_floatflag;
Xextern int xdots, ydots, colors, sxoffs, syoffs;
Xextern int debugflag;
Xextern SEGTYPE extraseg;
Xextern unsigned height;
Xextern int rowcount;        /* in general.asm */
Xextern int init3d[];        /* 3D arguments (FRACTINT.C) */
Xextern long far *lx0;
Xextern int transparent[2];    /* transparency min/max */
Xextern int pot16bit;
Xextern int filecolors;
Xextern void (*outln_cleanup)();
X
Xstatic int zcoord = 256;
Xstatic double aspect;            /* aspect ratio */
Xstatic int evenoddrow;
X
Xstatic float far *sinthetaarray;    /* all sine        thetas go here  */
Xstatic float far *costhetaarray;    /* all cosine thetas go here */
X
Xstatic double rXrscale;         /* precalculation factor */
X
Xstatic int persp;    /* flag for indicating perspective transformations */
Xint bad_value = -10000; /* set bad values to this */
Xint bad_check = -3000;    /* check values against this to determine if good */
X
X/* this array remembers the previous line */
Xstruct point far *lastrow;
X
Xstatic struct point p1,p2,p3;
X
Xstruct f_point
X{
X    float x;
X    float y;
X    float color;
X}
Xfar *f_lastrow;
X
X
Xint RAY = 0; /* Flag to generate Ray trace compatible files in 3d */
Xint BRIEF = 0; /* 1 = short ray trace files */
Xextern int release; /* Current release level of Fractint */
Xstatic int _fastcall RAY_Header(void);
Xstatic void _fastcall triangle_bounds(float pt_t[3][3]);
Xstatic int _fastcall out_triangle(struct f_point pt1, struct f_point pt2,
X            struct f_point pt3, int c1, int c2, int c3);
Xstatic float min_xyz[3], max_xyz[3]; /* For Raytrace output */
Xstatic int _fastcall start_object(void);
Xstatic int _fastcall end_object(int triout);
Xextern unsigned numcolors; /* number of colors in original GIF */
Xstatic long num_tris; /* number of triangles output to ray trace file */
X
X/* array of min and max x values used in triangle fill */
Xstruct minmax
X{
X    int minx;
X    int maxx;
X}
Xfar *minmax_x;
X
XVECTOR view;    /* position of observer for perspective */
XVECTOR cross;
XVECTOR tmpcross;
X
Xstruct point oldlast =
X{
X    0, 0, 0
X};    /* old pixels */
X
Xvoid line3d_overlay() {
X}    /* for restore_active_ovly */
X
Xint line3d(BYTE *pixels, unsigned linelen)
X{
X    int tout; /*  triangle has been sent to ray trace file */
X    int RND;
X    float f_water; /* transformed WATERLINE for ray trace files */
X
X    /* these values come from FRACTINT.C */
X
X    /* These variables must preserve their values across calls */
X    static float    deltaphi;  /* increment of latitude, longitude */
X    static double rscale;            /* surface roughness factor */
X    static long xcenter,ycenter;            /* circle center */
X    double r0;
X    int xcenter0,ycenter0; /* Unfudged versions */
X
X    static double sclx,scly,sclz;        /* scale factors */
X    static double R;                /* radius values */
X    static double Rfactor;            /* for intermediate calculation */
X    MATRIX lightm;                /* m w/no trans, keeps obj. on screen */
X    static LMATRIX lm;                /* "" */
X    static LVECTOR lview;            /* for perspective views */
X    static double zcutoff;            /* perspective backside cutoff value */
X    static float twocosdeltaphi;
X    static float cosphi,sinphi;            /* precalculated sin/cos of longitude */
X    static float oldcosphi1,oldsinphi1;
X    static float oldcosphi2,oldsinphi2;
X    double r;                    /* sphere radius */
X    double xval,yval,zval;            /* rotation values */
X    float costheta,sintheta;            /* precalculated sin/cos of latitude */
X    float twocosdeltatheta;
X
X    int next; /* used by preview and grid */
X    int col;                    /* current column (original GIF) */
X    struct point cur;                /* current pixels */
X    struct point old;                /* old pixels */
X
X    static struct point bad;            /* out of range value */
X
X    struct f_point f_cur;
X    struct f_point f_old;
X    static struct f_point f_bad;            /* out of range value */
X
X    static BYTE far *fraction;/* float version of pixels array */
X
X    VECTOR v;                    /* double vector */
X    VECTOR v1,v2;
X    VECTOR crossavg;
X    char crossnotinit;                /* flag for crossavg init indication */
X
X    double v_length;
X    VECTOR origin, direct, tmp;
X    LVECTOR lv;                    /* long equivalent of v */
X    LVECTOR lv0;                 /* long equivalent of v */
X
X    /* corners of transformed xdotx by ydots x colors box */
X    double xmin, ymin, zmin, xmax, ymax, zmax;
X    int i,j;
X    int lastdot;
X
X    long fudge;
X
X    ENTER_OVLY(OVLY_LINE3D);
X
X    fudge = 1L<<16;
X
X
X    if(transparent[0] || transparent[1])
X        plot = normalplot = T_clipcolor;    /*  Use transparent plot function */
X    else            /* Use the usual FRACTINT plot function with clipping */
X        plot = normalplot = clipcolor;
X
X    currow = rowcount; /* use separate variable to allow for pot16bit files */
X    if (pot16bit)
X        currow >>= 1;
X
X    /************************************************************************/
X    /* This IF clause is executed ONCE per image. All precalculations are    */
X    /* done here, with out any special concern about speed. DANGER -            */
X    /* communication with the rest of the program is generally via static    */
X    /* or global variables.                                                                    */
X    /************************************************************************/
X    if(rowcount++ == 0)
X    {
X        long check_extra;
X        float theta,theta1,theta2;    /* current,start,stop latitude */
X        float phi1,phi2;            /* current start,stop longitude */
X        float    deltatheta;        /* increment of latitude */
X        outln_cleanup = line3d_cleanup;
X
X        calctime = evenoddrow = 0;
X        /* mark as in-progress, and enable <tab> timer display */
X        calc_status = 1;
X
X        IAmbient = (unsigned int) (255 * (float)(100 - Ambient) / 100.0);
X        if (IAmbient < 1)        IAmbient = 1;
X
X        tout = 0;
X        num_tris = 0;
X
X        /* Open file for RAY trace output and write header */
X        if (RAY)
X        {
X            RAY_Header();
X            xxadjust = yyadjust = 0; /* Disable shifting in ray tracing */
X            xshift = yshift = 0;
X        }
X
X        CO_MAX=CO=RO=0;
X
X        upr_lwr[0] = xdots & 0xff;
X        upr_lwr[1] = xdots >> 8;
X        upr_lwr[2] = ydots &  0xff;
X        upr_lwr[3] = ydots >> 8;
X        line_length1 = 3 * xdots;        /*  line length @ 3 bytes per pixel  */
X        error = 0;
X
X        if (whichimage < 2)
X            T_Safe = 0; /* Not safe yet to mess with the source image */
X
X        if (Targa_Out && !((glassestype==1 || glassestype==2) && whichimage==2))
X        {
X            if (Targa_Overlay)
X            {
X                /* Make sure target file is a supportable Targa File */
X                if(targa_validate (light_name))
X                    return(-1);
X            }
X            else
X            {
X                check_writefile(light_name,".tga");
X                if (startdisk1(light_name, NULL, 0))    /* Open new file */
X                    return(-1);
X            }
X        }
X
X        rand_factor = 14 - RANDOMIZE;
X
X        zcoord = filecolors;
X
X        crossavg[0] = 0;
X        crossavg[1] = 0;
X        crossavg[2] = 0;
X
X        /*********************************************************************/
X        /*  Memory allocation - assumptions - a 64K segment starting at        */
X        /*  extraseg has been grabbed. It may have other purposes elsewhere, */
X        /*  but it is assumed that it is totally free for use here. Our        */
X        /*  strategy is to assign all the far pointers needed here to various*/
X        /*  spots in the extra segment, depending on the pixel dimensions of */
X        /*  the video mode, and check whether we have run out. There is        */
X        /*  basically one case where the extra segment is not big enough        */
X        /*  -- SPHERE mode with a fill type that uses putatriangle() (array    */
X        /*  minmax_x) at the largest legal resolution of MAXPIXELSxMAXPIXELS or            */
X        /*  thereabouts. In that case we use farmemalloc to grab    memory        */
X        /*  for minmax_x. This memory is never freed.                                */
X        /*********************************************************************/
X
X        /* lastrow stores the previous row of the original GIF image for
X            the purpose of filling in gaps with triangle procedure */
X        lastrow = MK_FP(extraseg,0);
X
X        check_extra = sizeof(*lastrow)*xdots;
X        if(SPHERE)
X        {
X            sinthetaarray = (float far *)(lastrow+xdots);
X            check_extra += sizeof(*sinthetaarray)*xdots;
X
X            costhetaarray = (float far *)(sinthetaarray+xdots);
X            check_extra += sizeof(*costhetaarray)*xdots;
X
X            f_lastrow = (struct f_point far *)(costhetaarray+xdots);
X        }
X        else
X            f_lastrow = (struct f_point far *)(lastrow+xdots);
X        check_extra += sizeof(*f_lastrow)*(xdots);
X
X        if(pot16bit)
X        {
X            fraction = (BYTE far *)(f_lastrow+xdots);
X            check_extra += sizeof(*fraction)*xdots;
X        }
X        minmax_x = (struct minmax *)NULL;
X
X        /* these fill types call putatriangle which uses minmax_x */
X        if( FILLTYPE == 2 || FILLTYPE == 3 || FILLTYPE == 5 || FILLTYPE == 6)
X        {
X            /* end of arrays if we use extra segement */
X            check_extra += sizeof(struct minmax)*ydots;
X            if(check_extra > (1L<<16)) /* run out of extra segment? */
X            {
X                static struct minmax far *got_mem = NULL;
X                /* not using extra segment so decrement check_extra */
X                check_extra -= sizeof(struct minmax)*ydots;
X                if(got_mem == NULL)
X                    got_mem = (struct minmax far *)(farmemalloc(MAXPIXELS *
X                sizeof(struct minmax)));
X
X                if(got_mem)
X                    minmax_x = got_mem;
X                else
X                {
X                    EXIT_OVLY;
X                    return(-1);
X                }
X            }
X            else /* ok to use extra segment */
X            {
X                if(pot16bit)
X                    minmax_x = (struct minmax far *)(fraction+xdots);
X                else
X                    minmax_x = (struct minmax far *)(f_lastrow+xdots);
X
X            }
X        }
X
X        if(debugflag == 2222 || check_extra > (1L<<16))
X        {
X            char tmpmsg[70];
X            static char far extramsg[] = {" of extra segment"};
X#ifndef XFRACT
X            sprintf(tmpmsg,"used %ld%Fs", check_extra, extramsg);
X#else
X            sprintf(tmpmsg,"used %ld%s", check_extra, extramsg);
X#endif
X            stopmsg(4,tmpmsg);
X        }
X
X        /* get scale factors */
X        sclx =    XSCALE/100.0;
X        scly =    YSCALE/100.0;
X        if (ROUGH)
X            sclz = -ROUGH/100.0;
X        else
X            rscale = sclz = -0.0001; /* if rough=0 make it very flat but plot something */
X
X        /* aspect ratio calculation - assume screen is 4 x 3 */
X        aspect = (double)xdots*.75/(double)ydots;
X
X        if(SPHERE==FALSE)  /* skip this slow stuff in sphere case */
X        {
X        /*********************************************************************/
X        /* What is done here is to create a single matrix, m, which has        */
X        /* scale, rotation, and shift all combined. This allows us to use        */
X        /* a single matrix to transform any point. Additionally, we create      */
X        /* two perspective vectors.                                                        */
X        /*                                                                                            */
X        /* Start with a unit matrix. Add scale and rotation. Then calculate     */
X        /* the perspective vectors. Finally add enough translation to center    */
X        /* the final image plus whatever shift the user has set.                    */
X        /*********************************************************************/
X
X            /* start with identity */
X            identity (m);
X            identity (lightm);
X
X            /* translate so origin is in center of box, so that when we rotate */
X            /* it, we do so through the center */
X            trans ( (double)xdots/(-2.0),(double)ydots/(-2.0),
X                    (double)zcoord/(-2.0),m);
X            trans ( (double)xdots/(-2.0),(double)ydots/(-2.0),
X                    (double)zcoord/(-2.0),lightm);
X
X            /* apply scale factors */
X            scale(sclx,scly,sclz,m);
X            scale(sclx,scly,sclz,lightm);
X
X            /* rotation values - converting from degrees to radians */
X            xval = XROT / 57.29577;
X            yval = YROT / 57.29577;
X            zval = ZROT / 57.29577;
X
X            if (RAY)    {xval = yval = zval = 0;}
X
X            xrot (xval,m);
X            xrot (xval,lightm);
X            yrot (yval,m);
X            yrot (yval,lightm);
X            zrot (zval,m);
X            zrot (zval,lightm);
X
X            /* Find values of translation that make all x,y,z negative */
X            /* m current matrix */
X            /* 0 means don't show box */
X            /* returns minimum and maximum values of x,y,z in fractal */
X            corners(m,0,&xmin,&ymin,&zmin,&xmax,&ymax,&zmax);
X        }
X
X        /* perspective 3D vector - lview[2] == 0 means no perspective */
X
X        /* set perspective flag */
X        persp = 0;
X        if (ZVIEWER != 0)
X        {
X            persp = 1;
X            if(ZVIEWER < 80) /* force float */
X                usr_floatflag |= 2; /* turn on second bit */
X        }
X
X        /* set up view vector, and put viewer in center of screen */
X        lview[0] = xdots >> 1;
X        lview[1] = ydots >> 1;
X
X        /* z value of user's eye - should be more negative than extreme
X                                negative part of image */
X        if(SPHERE) /* sphere case */
X            lview[2] = -(long)((double)ydots*(double)ZVIEWER/100.0);
X        else    /* non-sphere case */
X            lview[2] = (long)((zmin-zmax)*(double)ZVIEWER/100.0);
X
X        view[0] = lview[0];
X        view[1] = lview[1];
X        view[2] = lview[2];
X        lview[0] = lview[0] << 16;
X        lview[1] = lview[1] << 16;
X        lview[2] = lview[2] << 16;
X
X        if(SPHERE==FALSE) /* sphere skips this */
X        {
X            /* translate back exactly amount we translated earlier plus enough
X                to center image so maximum values are non-positive */
X            trans(((double)xdots-xmax-xmin)/2,((double)ydots-ymax-ymin) / 2,
X                -zmax,m);
X
X            /* Keep the box centered and on screen regardless of shifts */
X            trans(((double)xdots-xmax-xmin)/2,((double)ydots-ymax-ymin)/2,
X                -zmax,lightm);
X
X            trans((double)(xshift),(double)(-yshift),0.0,m);
X
X            /* matrix m now contains ALL those transforms composed together !!
X                convert m to long integers shifted 16 bits */
X            for (i = 0; i < 4; i++)
X                for (j = 0; j < 4; j++)
X                    lm[i][j] = m[i][j] * 65536.0;
X
X        }
X        else /* sphere stuff goes here */
X        {
X            /* Sphere is on side - north pole on right. Top is -90 degrees
X                latitude; bottom 90 degrees */
X
X            /* Map X to this LATITUDE range */
X            theta1 = THETA1*PI/180.0;
X            theta2 = THETA2*PI/180.0;
X
X            /* Map Y to this LONGITUDE range */
X            phi1    = PHI1*PI/180.0;
X            phi2    = PHI2*PI/180.0;
X
X            theta = theta1;
X
X        /*********************************************************************/
X        /* Thanks to Hugh Bray for the following idea: when calculating        */
X        /* a table of evenly spaced sines or cosines, only a few initial        */
X        /* values need be calculated, and the remaining values can be            */
X        /* gotten from a derivative of the sine/cosine angle sum formula        */
X        /* at the cost of one multiplication and one addition per value!        */
X        /*                                                                                            */
X        /* This idea is applied once here to get a complete table for            */
X        /* latitude, and near the bottom of this routine to incrementally        */
X        /* calculate longitude.                                                                */
X        /*                                                                                            */
X        /* Precalculate 2*cos(deltaangle), sin(start) and sin(start+delta).    */
X        /* Then apply recursively:                                                            */
X        /*    sin(angle+2*delta) = sin(angle+delta) * 2cosdelta - sin(angle)        */
X        /*                                                                                            */
X        /* Similarly for cosine. Neat!                                                     */
X        /*********************************************************************/
X
X            deltatheta = (float)(theta2 - theta1)/(float)linelen;
X
X            /* initial sin,cos theta */
X            sinthetaarray[0] = sin((double)theta);
X            costhetaarray[0] = cos((double)theta);
X            sinthetaarray[1] = sin((double)(theta + deltatheta));
X            costhetaarray[1] = cos((double)(theta + deltatheta));
X
X            /* sin,cos delta theta */
X            twocosdeltatheta = 2.0*cos((double)deltatheta);
X
X            /* build table of other sin,cos with trig identity */
X            for(i=2;i<linelen;i++)
X            {
X                sinthetaarray[i] = sinthetaarray[i-1]*twocosdeltatheta-
X                    sinthetaarray[i-2];
X                costhetaarray[i] = costhetaarray[i-1]*twocosdeltatheta-
X                    costhetaarray[i-2];
X            }
X
X            /* now phi - these calculated as we go - get started here */
X            deltaphi    = (float)(phi2    - phi1  )/(float)height;
X
X            /* initial sin,cos phi */
X
X            sinphi = oldsinphi1 = sin((double)phi1);
X            cosphi = oldcosphi1 = cos((double)phi1);
X            oldsinphi2 = sin((double)(phi1+deltaphi));
X            oldcosphi2 = cos((double)(phi1+deltaphi));
X
X            /* sin,cos delta phi */
X            twocosdeltaphi = 2*cos((double)deltaphi);
X
X            xcenter0 = xcenter = xdots/2 + xshift;
X            ycenter0 = ycenter = ydots/2 - yshift;
X
X            /* affects how rough planet terrain is */
X            if (ROUGH)
X                rscale = .3*ROUGH/100.0;
X
X            /* radius of planet */
X            R = (double)(ydots)/2;
X
X            /* precalculate factor */
X            rXrscale = R*rscale;
X
X            sclz = sclx = scly = RADIUS/100.0; /* Need x,y,z for RAY */
X
X            /* adjust x scale factor for aspect */
X            sclx *= aspect;
X
X            /* precalculation factor used in sphere calc */
X            Rfactor = rscale*R/(double)zcoord;
X
X            if(persp) /* precalculate fudge factor */
X            {
X                double radius;
X                double zview;
X                double angle;
X
X                xcenter  = xcenter << 16;
X                ycenter  = ycenter << 16;
X
X                Rfactor *= 65536.0;
X                R            *= 65536.0;
X
X                /* calculate z cutoff factor
X                    attempt to prevent out-of-view surfaces from being written */
X                zview = -(long)((double)ydots*(double)ZVIEWER/100.0);
X                radius = (double)(ydots)/2;
X                angle = atan(-radius/(zview+radius));
X                zcutoff = -radius - sin(angle)*radius;
X                zcutoff *= 1.1; /* for safety */
X                zcutoff *= 65536;
X            }
X        }
X
X        /* set fill plot function */
X        if(FILLTYPE != 3)
X            fillplot = interpcolor;
X        else
X        {
X            fillplot = clipcolor;
X
X            if(transparent[0] || transparent[1])
X                /*    If transparent colors are set */
X                fillplot = T_clipcolor;  /*  Use the transparent plot function  */
X        }
X
X        /* Both Sphere and Normal 3D */
X        direct[0] = light_direction[0] = XLIGHT;
X        direct[1] = light_direction[1] = -YLIGHT;
X        direct[2] = light_direction[2] = ZLIGHT;
X
X        /* Needed because sclz = -ROUGH/100 and light_direction is transformed
X            in FILLTYPE 6 but not in 5. */
X        if (FILLTYPE == 5)
X            direct[2] = light_direction[2] = -ZLIGHT;
X
X        if(FILLTYPE==6) /* transform light direction */
X        {
X            /* Think of light direction  as a vector with tail at (0,0,0) and
X                head at (light_direction). We apply the transformation to
X                BOTH head and tail and take the difference */
X
X            v[0] = 0.0;
X            v[1] = 0.0;
X            v[2] = 0.0;
X            vmult(v,m,v);
X            vmult(light_direction,m,light_direction);
X
X            for (i=0;i<3;i++)        light_direction[i] -= v[i];
X        }
X        normalize_vector(light_direction);
X
X        if(preview && showbox)
X        {
X            normalize_vector(direct);
X
X            /* move light vector to be more clear with grey scale maps */
X            origin[0] = (3 * xdots) / 16;
X            origin[1] = (3 * ydots) / 4;
X            if (FILLTYPE == 6)
X                origin[1] = (11 * ydots) / 16;
X
X            origin[2] = 0.0;
X
X            v_length = min (xdots, ydots) / 2;
X            if (persp && ZVIEWER <= P)
X                v_length *= (long)(P + 600) /((long)(ZVIEWER+600) * 2);
X
X            /* Set direct[] to point from origin[] in direction of
X                untransformed light_direction (direct[]). */
X            for (i=0;i<3;i++)
X                direct[i] = origin[i] + direct[i] * v_length;
X
X            /* center light box */
X            for (i=0;i<2;i++)
X            {
X                tmp[i] = (direct[i] - origin[i]) / 2;
X                origin[i] -= tmp[i];
X                direct[i] -= tmp[i];
X            }
X
X            /* Draw light source vector and box containing it, draw_light_box
X                will transform them if necessary. */
X            draw_light_box (origin,direct,lightm);
X            /* draw box around original field of view to help visualize effect
X                of rotations 1 means show box - xmin etc. do nothing here */
X            if (!SPHERE)
X                corners(m,1,&xmin,&ymin,&zmin,&xmax,&ymax,&zmax);
X        }
X
X        /* bad has values caught by clipping */
X        f_bad.x            = bad.x            = bad_value;
X        f_bad.y            = bad.y            = bad_value;
X        f_bad.color = bad.color = bad_value;
X        for(i=0;i<linelen;i++)
X        {
X            lastrow[i]    = bad;
X            f_lastrow[i] = f_bad;
X        }
X        got_status = 3;
X        if(iit>0)
X        {
X            load_mat(m); /* load matrix into iit registers */
X            mult_vec = mult_vec_iit;
X        }
X        else
X            mult_vec = mult_vec_c;
X    } /* end of once-per-image intializations */
X
X    crossnotinit = 1;
X    col = 0;
X
X    CO = 0;
X
X    /* make sure these pixel coordinates are out of range */
X    old        = bad;
X    f_old = f_bad;
X
X    /* copies pixels buffer to float type fraction buffer for fill purposes */
X    if(pot16bit)
X        if (set_pixel_buff(pixels,fraction,linelen))
X        {
X            EXIT_OVLY;
X            return(0);
X        }
X
X  /*************************************************************************/
X  /* This section of code allows the operation of a preview mode when the    */
X  /* preview flag is set. Enabled, it allows the drawing of only the first */
X  /* line of the source image, then every 10th line, until and including    */
X  /* the last line. For the undrawn lines, only necessary calculations are */
X  /* made. As a bonus, in non-sphere mode a box is drawn to help visualize */
X  /* the effects of 3D transformations. Thanks to Marc Reinig for this idea*/
X  /* and code -- BTW, Marc did NOT put the goto in, but WE did, to avoid    */
X  /* copying code here, and to avoid a HUGE "if-then" construct. Besides,    */
X  /* we have ALREADY sinned, so why not sin some more?                            */
X  /*************************************************************************/
X
X
X    lastdot = min(xdots-1, linelen-1);
X    if (FILLTYPE >= 5)
X        if (haze && Targa_Out)
X        {
X            HAZE_MULT = haze * (
X                (float)((long)(ydots - 1 - currow) *
X                (long)(ydots - 1 - currow)) /
X                (float)((long)(ydots - 1) * (long)(ydots - 1)));
X            HAZE_MULT = 100 - HAZE_MULT;
X        }
X
X    if (previewfactor >= ydots || previewfactor > lastdot)
X        previewfactor = min ( ydots - 1, lastdot);
X
X    localpreviewfactor = ydots/previewfactor;
X
X    tout = 0;
X    /* Insure last line is drawn in preview and filltypes <0  */
X    if ((RAY || preview || FILLTYPE < 0) && (currow != ydots-1) &&
X        (currow % localpreviewfactor) && /* Draw mod preview lines */
X        !(!RAY && (FILLTYPE > 4) && (currow == 1)))
X            /* Get init geometry in lightsource modes */
X            goto reallythebottom; /* skip over most of the line3d calcs */
X    if (dotmode == 11)
X    {
X        char s[40];
X        sprintf(s,"mapping to 3d, reading line %d", currow);
X        dvid_status(1,s);
X    }
X
X    if(!col && RAY && currow != 0)        start_object();
X
X    if(FILLTYPE==0 && !SPHERE && !pot16bit && !RAY && debugflag != 2224 )
X        /* This while loop contains just a limited non-sphere case for speed */
X        /* Other while loop still has the old logic. Use debugflag to compare*/
X        while(col < linelen)
X        {
X            Real_Color = cur.color = pixels[col];
X            if (cur.color > 0 && cur.color < WATERLINE)
X                Real_Color = cur.color = WATERLINE;  /* "lake" */
X            if(!usr_floatflag)
X            {
X                lv0[0] = 0; /* don't save vector before perspective */
X
X                /* use 32-bit multiply math to snap this out */
X                lv[0] = col;
X                lv[0] = lv[0] << 16;
X                lv[1] = currow;
X                lv[1] = lv[1] << 16;
X                lv[2] = cur.color;
X                lv[2] = lv[2] << 16;
X
X                if(longvmultpersp(lv,lm,lv0,lv,lview,16) == -1)
X                {
X                    cur    = bad;
X                    goto loopbottom;
X                }
X                cur.x = ((lv[0]/* +32768L */) >> 16) + xxadjust;
X                cur.y = ((lv[1]/* +32768L */) >> 16) + yyadjust;
X            }
X            /* do in float if integer math overflowed */
X            if(usr_floatflag || overflow)
X            {
X                /* slow float version for comparison */
X                v[0] = col;
X                v[1] = currow;
X                v[2] = cur.color;
X                mult_vec(v); /* matrix*vector routine */
X                if(persp)
X                    perspective(v);
X                cur.x = v[0] + xxadjust /* + .5 */;
X                cur.y = v[1] + yyadjust /* + .5 */;
X            }
X            (*plot)(cur.x,cur.y,cur.color);
X            col++;
X        }  /*  End of while statement for plotting line  */
X    else
X
X        /* PROCESS ROW LOOP BEGINS HERE */
X        while(col < linelen)
X        {
X            if ((RAY || preview || FILLTYPE < 0) &&
X                (col != lastdot) &&        /* if this is not the last col */
X                /* if not the 1st or mod factor col*/
X                (col % (int)(aspect * localpreviewfactor)) &&
X                (!(!RAY && FILLTYPE > 4 && col == 1)))
X                    goto loopbottom;
X
X            f_cur.color = Real_Color = cur.color = pixels[col];
X
X            if (RAY || preview || FILLTYPE < 0)
X            {
X                next = col + aspect * localpreviewfactor;
X                if (next == col)        next = col + 1;
X            }
X            else
X                next = col + 1;
X            if (next >= lastdot)
X                next = lastdot;
X
X            if (cur.color > 0 && cur.color < WATERLINE)
X                f_cur.color = Real_Color = cur.color = WATERLINE;        /* "lake" */
X            else if(pot16bit)
X                f_cur.color += ((float)fraction[col])/(float)(1<<8);
X
X            if(SPHERE) /* sphere case */
X            {
X                sintheta = sinthetaarray[col];
X                costheta = costhetaarray[col];
X
X                if(sinphi < 0 && !(RAY || FILLTYPE < 0))
X                {
X                    cur    = bad;
X                    f_cur = f_bad;
X                    goto loopbottom;    /* another goto ! */
X                }
X            /******************************************************************/
X            /* KEEP THIS FOR DOCS - original formula --                                */
X            /* if(rscale < 0.0)                                                                 */
X            /*            r = 1.0+((double)cur.color/(double)zcoord)*rscale;            */
X            /* else                                                                                */
X            /*            r = 1.0-rscale+((double)cur.color/(double)zcoord)*rscale;*/
X            /* R = (double)ydots/2;                                                            */
X            /* r = r*R;                                                                         */
X            /* cur.x = xdots/2 + sclx*r*sintheta*aspect + xup ;                    */
X            /* cur.y = ydots/2 + scly*r*costheta*cosphi - yup ;                    */
X            /******************************************************************/
X
X                if(rscale < 0.0)
X                    r = R + Rfactor*(double)f_cur.color*costheta;
X                else if(rscale > 0.0)
X                    r = R -rXrscale + Rfactor*(double)f_cur.color*costheta;
X                else
X                    r = R;
X                if(persp || RAY) /* Allow Ray trace to go through so display is ok */
X                {    /* mrr how do lv[] and cur and f_cur all relate */
X                    /* NOTE: fudge was pre-calculated above in r and R */
X                    /* (almost) guarantee negative */
X                    lv[2] = -R - r*costheta*sinphi;    /* z */
X                    if((lv[2] > zcutoff) && !FILLTYPE < 0)
X                    {
X                        cur = bad;
X                        f_cur = f_bad;
X                        goto loopbottom;    /* another goto ! */
X                    }
X                    lv[0] = xcenter + sintheta*sclx*r;    /* x */
X                    lv[1] = ycenter + costheta*cosphi*scly*r;        /* y */
X
X                    if((FILLTYPE >= 5) || RAY)
X                    {  /* calculate illumination normal before persp */
X
X                        r0        = r/65536;
X                        f_cur.x        = xcenter0 + sintheta*sclx*r0;
X                        f_cur.y        = ycenter0 + costheta*cosphi*scly*r0;
X                        f_cur.color = -r0*costheta*sinphi;
X                    }
X                    if(!(usr_floatflag || RAY))
X                    {
X                        if(longpersp(lv,lview,16) == -1)
X                        {
X                            cur = bad;
X                            f_cur = f_bad;
X                            goto loopbottom;    /* another goto ! */
X                        }
X                        cur.x = ((lv[0]+32768L) >> 16) + xxadjust;
X                        cur.y = ((lv[1]+32768L) >> 16) + yyadjust;
X                    }
X                    if(usr_floatflag || overflow || RAY)
X                    {
X                        v[0] = lv[0];
X                        v[1] = lv[1];
X                        v[2] = lv[2];
X                        v[0] /= fudge;
X                        v[1] /= fudge;
X                        v[2] /= fudge;
X                        perspective(v);
X                        cur.x = v[0]+.5 + xxadjust;
X                        cur.y = v[1]+.5 + yyadjust;
X                    }
X                }
X                else if (!(persp && RAY)) /* mrr Not sure how this and 3rd if
X                                                    above relate */
X                {    /* mrr Why the xx- and yyadjust here and not above? */
X                    cur.x = f_cur.x = xcenter + sintheta*sclx*r + xxadjust;
X                    cur.y = f_cur.y = ycenter + costheta*cosphi*scly*r + yyadjust;
X                    if(FILLTYPE >= 5 || RAY) /* mrr why do we do this for filltype>5? */
X                        f_cur.color = -r * costheta * sinphi * sclz;
X                    v[0]=v[1]=v[2]=0;    /* MRR Why do we do this? */
X                }
X            }
X            else /* non-sphere 3D */
X            {
X                if(!usr_floatflag && !RAY)
X                {
X                    if(FILLTYPE >= 5) /* flag to save vector before perspective */
X                        lv0[0] = 1;        /* in longvmultpersp calculation */
X                    else
X                        lv0[0] = 0;
X
X                    /* use 32-bit multiply math to snap this out */
X                    lv[0] = col;
X                    lv[0] = lv[0] << 16;
X                    lv[1] = currow;
X                    lv[1] = lv[1] << 16;
X                    if(filetype || pot16bit) /* don't truncate fractional part */
X                        lv[2] = f_cur.color*65536.0;
X                    else    /* there IS no fractaional part here! */
X                    {
X                        lv[2] = f_cur.color;
X                        lv[2] = lv[2] << 16;
X                    }
X
X                    if(longvmultpersp(lv,lm,lv0,lv,lview,16) == -1)
X                    {
X                        cur    = bad;
X                        f_cur = f_bad;
X                        goto loopbottom;
X                    }
X
X                    cur.x = ((lv[0]+32768L) >> 16) + xxadjust;
X                    cur.y = ((lv[1]+32768L) >> 16) + yyadjust;
X                    if(FILLTYPE >= 5 && !overflow)
X                    {
X                        f_cur.x        = lv0[0];
X                        f_cur.x            /= 65536.0;
X                        f_cur.y        = lv0[1];
X                        f_cur.y            /= 65536.0;
X                        f_cur.color  = lv0[2];
X                        f_cur.color /= 65536.0;
X                    }
X                }
X
X                if(usr_floatflag || overflow || RAY)
X                /* do in float if integer math overflowed or doing Ray trace */
X                {
X                    /* slow float version for comparison */
X                    v[0] = col;
X                    v[1] = currow;
X                    v[2] = f_cur.color; /* Actually the z value */
X
X                    mult_vec(v); /* matrix*vector routine */
X
X                    if (FILLTYPE > 4 || RAY)
X                    {
X                        f_cur.x    = v[0];
X                        f_cur.y    = v[1];
X                        f_cur.color = v[2];
X
X                        if(RAY == 6)
X                        {
X                            f_cur.x = f_cur.x * (2.0 / xdots) - 1;
X                            f_cur.y = f_cur.y * (2.0 / ydots) - 1;
X                            f_cur.color = -f_cur.color * (2.0 / numcolors) - 1;
X                        }
X                    }
X
X                    if(persp && !RAY)
X                        perspective(v);
X                    cur.x = v[0] + xxadjust + .5;
X                    cur.y = v[1] + yyadjust + .5;
X
X                    v[0] = 0;
X                    v[1] = 0;
X                    v[2] = WATERLINE;
X                    mult_vec(v);
X                    f_water = v[2];
X                }
X            }
X
X            if (RANDOMIZE)
X                if (cur.color > WATERLINE)
X                {
X                    RND = rand15() >> 8;    /* 7-bit number */
X                    RND = RND * RND >> rand_factor;    /* n-bit number */
X
X                    if (rand() & 1)
X                        RND = -RND; /* Make +/- n-bit number */
X
X                    if ((int)(cur.color) + RND >= colors)
X                        cur.color = colors-2;
X                    else if ((int)(cur.color) + RND <= WATERLINE)
X                        cur.color = WATERLINE + 1;
X                    else
X                        cur.color = cur.color + RND;
X                    Real_Color = cur.color;
X                }
X
X            if (RAY)
X            {
X                if (col && currow &&
X                    old.x > bad_check &&
X                    old.x < (xdots - bad_check) &&
X                    lastrow[col].x > bad_check &&
X                    lastrow[col].y > bad_check &&
X                    lastrow[col].x < (xdots - bad_check) &&
X                    lastrow[col].y < (ydots - bad_check))
X                {
X                    /* Get rid of all the triangles in the plane
X                        at the base of the object */
X
X                    if (f_cur.color == f_water &&
X                        f_lastrow[col].color == f_water &&
X                        f_lastrow[next].color == f_water)
X                            goto loopbottom;
X
X                    if (RAY != 6) /* Output the vertex info */
X                        out_triangle(f_cur, f_old, f_lastrow[col],
X                            cur.color, old.color, lastrow[col].color);
X
X                    tout = 1;
X
X                    draw_line (old.x, old.y, cur.x, cur.y, old.color);
X                    draw_line (old.x, old.y, lastrow[col].x,
X                        lastrow[col].y, old.color);
X                    draw_line (lastrow[col].x, lastrow[col].y,
X                        cur.x, cur.y, cur.color);
X                    num_tris++;
X                }
X
X                if (col < lastdot && currow &&
X                    lastrow[col].x > bad_check &&
X                    lastrow[col].y > bad_check &&
X                    lastrow[col].x < (xdots - bad_check) &&
X                    lastrow[col].y < (ydots - bad_check) &&
X                    lastrow[next].x > bad_check &&
X                    lastrow[next].y > bad_check &&
X                    lastrow[next].x < (xdots - bad_check) &&
X                    lastrow[next].y < (ydots - bad_check))
X                {
X                    /* Get rid of all the triangles in the plane
X                    at the base of the object */
X
X                    if (f_cur.color == f_water &&
X                        f_lastrow[col].color == f_water &&
X                        f_lastrow[next].color == f_water)
X                            goto loopbottom;
X
X                    if (RAY != 6) /* Output the vertex info */
X                        out_triangle(f_cur, f_lastrow[col], f_lastrow[next],
X                            cur.color, lastrow[col].color, lastrow[next].color);
X
X                    tout = 1;
X
X                    draw_line (lastrow[col].x, lastrow[col].y, cur.x, cur.y,
X                        cur.color);
X                    draw_line (lastrow[next].x, lastrow[next].y, cur.x, cur.y,
X                        cur.color);
X                    draw_line (lastrow[next].x, lastrow[next].y, lastrow[col].x,
X                        lastrow[col].y, lastrow[col].color);
X                    num_tris++;
X                }
X
X                if (RAY == 6)  /* Output vertex info for Acrospin */
X                {
X                    fprintf (File_Ptr1, "% #4.4f % #4.4f % #4.4f R%dC%d\n",
X                        f_cur.x, f_cur.y, f_cur.color, RO, CO);
X                    if (CO > CO_MAX)
X                        CO_MAX = CO;
X                    CO++;
X                }
X                goto loopbottom;
X
X            }
X
X            switch(FILLTYPE)
X            {
X                case -1:
X                    if (col &&
X                    old.x > bad_check &&
X                    old.x < (xdots - bad_check))
X                        draw_line (old.x, old.y, cur.x, cur.y, cur.color);
X                    if (currow &&
X                    lastrow[col].x > bad_check &&
X                    lastrow[col].y > bad_check &&
X                    lastrow[col].x < (xdots - bad_check) &&
X                    lastrow[col].y < (ydots - bad_check))
X                        draw_line (lastrow[col].x,lastrow[col].y,cur.x,
X                            cur.y,cur.color);
X                    break;
X
X                case 0:
X                    (*plot)(cur.x,cur.y,cur.color);
X                    break;
X
X                case 1:            /* connect-a-dot */
X                    if ((old.x < xdots) && (col) &&
X                        old.x > bad_check &&
X                        old.y > bad_check) /* Don't draw from old to cur on col 0 */
X                            draw_line(old.x,old.y,cur.x,cur.y,cur.color);
X                    break;
X
X                case 2: /* with interpolation */
X                case 3: /* no interpolation */
X                    /***************************************************************/
X                    /*  "triangle fill" - consider four points: current point,        */
X                    /*  previous point same row, point opposite current point in    */
X                    /*  previous row, point after current point in previous row.    */
X                    /*  The object is to fill all points inside the two triangles.    */
X                    /*                                                                                    */
X                    /*    lastrow[col].x/y___ lastrow[next]                                    */
X                    /*              /    1         /                                                        */
X                    /*            /        1       /                                                        */
X                    /*            /        1     /                                                         */
X                    /*  oldrow/col _____ trow/col                                                */
X                    /***************************************************************/
X
X                    if(currow && !col)
X                        putatriangle(lastrow[next],lastrow[col],cur,cur.color);
X                    if(currow && col)        /* skip first row and first column */
X                    {
X                        if(col == 1)
X                            putatriangle(lastrow[col],oldlast,old,old.color);
X
X                        if(col < lastdot)
X                            putatriangle(lastrow[next],lastrow[col], cur, cur.color);
X                        putatriangle(old, lastrow[col], cur, cur.color);
X                    }
X                    break;
X
X                case 4: /* "solid fill" */
X                    if (SPHERE)
X                    {
X                        if (persp)
X                        {
X                            old.x = xcenter>>16;
X                            old.y = ycenter>>16;
X                        }
X                        else
X                        {
X                            old.x = xcenter;
X                            old.y = ycenter;
X                        }
X                    }
X                    else
X                    {
X                        lv[0] = col;
X                        lv[1] = currow;
X                        lv[2] = 0;
X
X                        /* apply fudge bit shift for integer math */
X                        lv[0] = lv[0] << 16;
X                        lv[1] = lv[1] << 16;
X                        /* Since 0, unnecessary lv[2] = lv[2] << 16;*/
X
X                        if(longvmultpersp(lv,lm,lv0,lv,lview,16))
X                        {
X                            cur    = bad;
X                            f_cur = f_bad;
X                            goto loopbottom;    /* another goto ! */
X                        }
X
X                        /*    Round and fudge back to original  */
X                        old.x = (lv[0]+32768L) >> 16;
X                        old.y = (lv[1]+32768L) >> 16;
X                    }
X                    if (old.x < 0)
X                        old.x = 0;
X                    if (old.x >= xdots)
X                        old.x = xdots-1;
X                    if (old.y < 0)
X                        old.y = 0;
X                    if (old.y >= ydots)
X                        old.y = ydots-1;
X                    draw_line(old.x,old.y,cur.x,cur.y,cur.color);
X                    break;
X
X                case 5:
X                case 6:
X                    /* light-source modulated fill */
X                    if(currow && col)        /* skip first row and first column */
X                    {
X                        if(f_cur.color < bad_check || f_old.color < bad_check ||
X                            f_lastrow[col].color < bad_check)
X                                break;
X
X                        v1[0] = f_cur.x        - f_old.x;
X                        v1[1] = f_cur.y        - f_old.y;
X                        v1[2] = f_cur.color - f_old.color;
X
X                        v2[0] = f_lastrow[col].x            - f_cur.x;
X                        v2[1] = f_lastrow[col].y            - f_cur.y;
X                        v2[2] = f_lastrow[col].color - f_cur.color;
X
X                        cross_product (v1, v2, cross);
X
X                        /* normalize cross - and check if non-zero */
X                        if(normalize_vector(cross))
X                        {
X                            if(debugflag)
X                            {
X                                static char far msg[] = {"debug, cur.color=bad"};
X                                stopmsg(0,msg);
X                            }
X                            cur.color = f_cur.color = bad.color;
X                        }
X                        else
X                        {
X                            /* line-wise averaging scheme */
X                            if(LIGHTAVG>0)
X                            {
X                                if(crossnotinit)
X                                {
X                                    /* initialize array of old normal vectors */
X                                    crossavg[0] = cross[0];
X                                    crossavg[1] = cross[1];
X                                    crossavg[2] = cross[2];
X                                    crossnotinit = 0;
X                                }
X                                tmpcross[0] = (crossavg[0]*LIGHTAVG+cross[0]) /
X                                   (LIGHTAVG+1);
X                                tmpcross[1] = (crossavg[1]*LIGHTAVG+cross[1]) /
X                                   (LIGHTAVG+1);
X                                tmpcross[2] = (crossavg[2]*LIGHTAVG+cross[2]) /
X                                   (LIGHTAVG+1);
X
X                                cross[0] = tmpcross[0];
X                                cross[1] = tmpcross[1];
X                                cross[2] = tmpcross[2];
X
X                                if(normalize_vector(cross))
X                                {
X                                    /* this shouldn't happen */
X                                    if(debugflag)
X                                    {
X                                        static char far msg[] =
X                                        {"debug, normal vector err2"};
X                                        stopmsg(0,msg);
X                                        /* use next instead if you ever need details:
X                                        static char far tmp[] = {"debug, vector err"};
X                                        char msg[200];
X#ifndef XFRACT
X                                        sprintf(msg,"%Fs\n%f %f %f\n%f %f %f\n%f %f %f",
X#else
X                                        sprintf(msg,"%s\n%f %f %f\n%f %f %f\n%f %f %f",
X#endif
X                                        tmp, f_cur.x, f_cur.y, f_cur.color,
X                                        f_lastrow[col].x, f_lastrow[col].y,
X                                        f_lastrow[col].color, f_lastrow[col-1].x,
X                                        f_lastrow[col-1].y,f_lastrow[col-1].color);
X                                        stopmsg(0,msg);
X                                        */
X                                    }
X                                    cur.color = f_cur.color = colors;
X                                }
X                            }
X                            crossavg[0] = tmpcross[0];
X                            crossavg[1] = tmpcross[1];
X                            crossavg[2] = tmpcross[2];
X
X                            /* dot product of unit vectors is cos of angle between */
X                            /* we will use this value to shade surface */
X
X                            cur.color = 1 + (colors-2) *
X                                (1.0-dot_product(cross,light_direction));
X                        }
X                        /* if colors out of range, set them to min or max color
X                            index but avoid background index. This makes colors
X                            "opaque" so SOMETHING plots. These conditions shouldn't
X                            happen but just in case                    */
X                        if(cur.color < 1)            /* prevent transparent colors */
X                            cur.color = 1;        /* avoid background */
X                        if(cur.color > colors-1)
X                            cur.color = colors-1;
X
X                    /* why "col < 2"? So we have sufficient geometry for the fill */
X                    /* algorithm, which needs previous point in same row to have  */
X                    /* already been calculated (variable old)        */
X                    /* fix ragged left margin in preview */
X                        if (col == 1 && currow > 1)
X                            putatriangle(lastrow[next],lastrow[col],cur,cur.color);
X
X                        if(col < 2 || currow < 2) /* don't have valid colors yet */
X                            break;
X
X                        if(col < lastdot)
X                            putatriangle(lastrow[next],lastrow[col],cur,cur.color);
X                        putatriangle(old,lastrow[col],cur,cur.color);
X
X                        plot=standardplot;
X                    }
X                    break;
X            }  /*    End of CASE statement for fill type  */
X
Xloopbottom:
X
X            if (RAY || (FILLTYPE != 0 && FILLTYPE != 4))
X            {
X                /* for triangle and grid fill purposes */
X                oldlast = lastrow[col];
X                old = lastrow[col] = cur;
X
X                /* for illumination model purposes */
X                f_old    = f_lastrow[col] = f_cur;
X                if (currow && RAY && col >= lastdot)
X                /* if we're at the end of a row, close the object */
X                {
X                    end_object(tout);
X                    tout=0;
X                    if (ferror (File_Ptr1))
X                    {
X                        fclose (File_Ptr1);
X                        remove (light_name);
X                        File_Error(ray_name, 2);
X                        EXIT_OVLY;
X                        return(-1);
X                    }
X                }
X            }
X
X            col++;
X
X        }  /*  End of while statement for plotting line  */
X
X    RO++;
X
Xreallythebottom:
X
X    /* stuff that HAS to be done, even in preview mode, goes here */
X    if(SPHERE)
X    {
X        /* incremental sin/cos phi calc */
X        if(currow == 0)
X        {
X            sinphi = oldsinphi2;
X            cosphi = oldcosphi2;
X        }
X        else
X        {
X            sinphi = twocosdeltaphi*oldsinphi2 - oldsinphi1;
X            cosphi = twocosdeltaphi*oldcosphi2 - oldcosphi1;
X            oldsinphi1 = oldsinphi2;
X            oldsinphi2 = sinphi;
X            oldcosphi1 = oldcosphi2;
X            oldcosphi2 = cosphi;
X        }
X    }
X    EXIT_OVLY;
X    return(0); /* decoder needs to know all is well !!! */
X}
X
X
X/* vector version of line draw */
Xstatic void _fastcall vdraw_line(v1,v2,color)
Xdouble *v1,*v2;
Xint color;
X{
X    int x1,y1,x2,y2;
X    x1 = (int)v1[0];
X    y1 = (int)v1[1];
X    x2 = (int)v2[0];
X    y2 = (int)v2[1];
X    draw_line(x1,y1,x2,y2,color);
X}
X
X
X
Xstatic void corners(m,show,pxmin,pymin,pzmin,pxmax,pymax,pzmax)
X
XMATRIX m;
Xint show; /* turns on box-showing feature */
Xdouble *pxmin,*pymin,*pzmin,*pxmax,*pymax,*pzmax;
X
X{
X    int i,j;
X    VECTOR S[2][4]; /* Holds the top an bottom points, S[0][]=bottom */
X
X    /*
X    define corners of box fractal is in in x,y,z plane
X    "b" stands for "bottom" - these points are the corners of the screen
X    in the x-y plane. The "t"'s stand for Top - they are the top of
X    the cube where 255 color points hit.
X    */
X
X    *pxmin = *pymin = *pzmin = (int)INT_MAX;
X    *pxmax = *pymax = *pzmax = (int)INT_MIN;
X
X    for (j = 0; j < 4; ++j)
X        for (i=0;i<3;i++)
X            S[0][j][i]=S[1][j][i]=0;
X
X    S[0][1][0] = S[0][2][0] = S[1][1][0] = S[1][2][0] = xdots-1;
X    S[0][2][1] = S[0][3][1] = S[1][2][1] = S[1][3][1] = ydots-1;
X    S[1][0][2] = S[1][1][2] = S[1][2][2] = S[1][3][2] = zcoord-1;
X
X    for (i = 0; i < 4; ++i)
X    {
X        /* transform points */
X        vmult(S[0][i],m,S[0][i]);
X        vmult(S[1][i],m,S[1][i]);
X
X        /* update minimums and maximums */
X        if (S[0][i][0] <= *pxmin) *pxmin = S[0][i][0];
X        if (S[0][i][0] >= *pxmax) *pxmax = S[0][i][0];
X        if (S[1][i][0] <= *pxmin) *pxmin = S[1][i][0];
X        if (S[1][i][0] >= *pxmax) *pxmax = S[1][i][0];
X        if (S[0][i][1] <= *pymin) *pymin = S[0][i][1];
X        if (S[0][i][1] >= *pymax) *pymax = S[0][i][1];
X        if (S[1][i][1] <= *pymin) *pymin = S[1][i][1];
X        if (S[1][i][1] >= *pymax) *pymax = S[1][i][1];
X        if (S[0][i][2] <= *pzmin) *pzmin = S[0][i][2];
X        if (S[0][i][2] >= *pzmax) *pzmax = S[0][i][2];
X        if (S[1][i][2] <= *pzmin) *pzmin = S[1][i][2];
X        if (S[1][i][2] >= *pzmax) *pzmax = S[1][i][2];
X    }
X
X    if(show)
X    {
X        if(persp)
X        {
X            for (i=0;i<4;i++)
X            {
X                perspective(S[0][i]);
X                perspective(S[1][i]);
X            }
X        }
X
X        /* Keep the box surrounding the fractal */
X        for (j=0;j<2;j++)
X            for (i = 0; i < 4; ++i)
X            {
X                S[j][i][0] += xxadjust;
X                S[j][i][1] += yyadjust;
X            }
X
X        draw_rect(S[0][0],S[0][1],S[0][2],S[0][3],2,1);/* Bottom */
X
X        draw_rect(S[0][0],S[1][0],S[0][1],S[1][1], 5, 0); /* Sides */
X        draw_rect(S[0][2],S[1][2],S[0][3],S[1][3], 6, 0);
X
X        draw_rect(S[1][0],S[1][1],S[1][2],S[1][3],8,1); /* Top */
X    }
X}
X
X
X
X/* This function draws a vector from origin[] to direct[] and a box
X    around it. The vector and box are transformed or not depending on
X    FILLTYPE.
X
X*/
X
Xstatic void draw_light_box (origin, direct, light_m)
Xdouble *origin, *direct;
XMATRIX light_m;
X
X
X{
X    VECTOR S[2][4];
X    int i,j;
X    double temp;
X
X    S[1][0][0] = S[0][0][0] = origin[0];
X    S[1][0][1] = S[0][0][1] = origin[1];
X
X    S[1][0][2] = direct[2];
X
X    for (i=0;i<2;i++)
X    {
X        S[i][1][0] = S[i][0][0];
X        S[i][1][1] = direct[1];
X        S[i][1][2] = S[i][0][2];
X        S[i][2][0] = direct[0];
X        S[i][2][1] = S[i][1][1];
X        S[i][2][2] = S[i][0][2];
X        S[i][3][0] = S[i][2][0];
X        S[i][3][1] = S[i][0][1];
X        S[i][3][2] = S[i][0][2];
X    }
X
X    /* transform the corners if necessary */
X    if (FILLTYPE == 6)
X        for (i=0;i<4;i++)
X        {
X            vmult (S[0][i],light_m,S[0][i]);
X            vmult (S[1][i],light_m,S[1][i]);
X        }
X
X    /* always use perspective to aid viewing */
X    temp = view[2]; /* save perspective distance for a later restore */
X    view[2] = - P * 300.0 / 100.0;
X
X    for (i=0;i<4;i++)
X    {
X        perspective(S[0][i]);
X        perspective(S[1][i]);
X    }
X    view[2] = temp; /* Restore perspective distance*/
X
X    /* Adjust for aspect */
X    for (i=0;i<4;i++)
X    {
X        S[0][i][0] = S[0][i][0] * aspect;
X        S[1][i][0] = S[1][i][0] * aspect;
X    }
X
X    /* draw box connecting transformed points. NOTE order and COLORS */
X    draw_rect(S[0][0],S[0][1],S[0][2],S[0][3],2,1);
X
X    vdraw_line (S[0][0],S[1][2],8);
X
X    /* sides */
X    draw_rect(S[0][0],S[1][0],S[0][1],S[1][1], 4, 0);
X    draw_rect(S[0][2],S[1][2],S[0][3],S[1][3], 5, 0);
X
X    draw_rect(S[1][0],S[1][1],S[1][2],S[1][3],3,1);
X
X    /* Draw the "arrow head" */
X    for (i= -3;i<4;i++)
X        for (j= -3;j<4;j++)
X            if (abs(i) + abs(j) < 6)
X                plot((int)(S[1][2][0]+i),(int)(S[1][2][1]+j),10);
X}
X
X
X
Xstatic void draw_rect (V0, V1, V2, V3, color, rect)
X
XVECTOR V0, V1, V2, V3;
Xint color, rect;
X
X{
XVECTOR V[4];
Xint i;
X
X    for (i=0;i<2;i++)
X    { /* Since V[2] is not used by vdraw_line don't bother setting it */
X        V[0][i] = V0[i];
X        V[1][i] = V1[i];
X        V[2][i] = V2[i];
X        V[3][i] = V3[i];
X    }
X    if (rect) /* Draw a rectangle */
X    {
X        for (i=0;i<4;i++)
X            if (fabs(V[i][0]-V[(i+1)%4][0]) < -2*bad_check &&
X                fabs(V[i][1]-V[(i+1)%4][1]) < -2*bad_check)
X                    vdraw_line (V[i],V[(i+1)%4],color);
X    }
X    else /* Draw 2 lines instead */
X    {
X        for(i=0;i<3;i+=2)
X            if (fabs(V[i][0]-V[i+1][0]) < -2*bad_check &&
X                fabs(V[i][1]-V[i+1][1]) < -2*bad_check)
X                    vdraw_line (V[i],V[i+1],color);
X    }
X    return;
X}
X
X
X
X/* replacement for plot - builds a table of min and max x's instead of plot */
X/* called by draw_line as part of triangle fill routine */
Xstatic void _fastcall putminmax(int x,int y,int color)
X{
X    if(y >= 0 && y < ydots)
X    {
X        if(x < minmax_x[y].minx) minmax_x[y].minx = x;
X        if(x > minmax_x[y].maxx) minmax_x[y].maxx = x;
X    }
X}
X
X/*
X    This routine fills in a triangle. Extreme left and right values for
X    each row are calculated by calling the line function for the sides.
X    Then rows are filled in with horizontal lines
X*/
X#define MAXOFFSCREEN  2 /* allow two of three points to be off screen */
X
Xstatic void _fastcall putatriangle(struct point pt1,struct point pt2,
X                    struct point pt3,int color)
X{
X    extern struct point p1,p2,p3;
X    int miny,maxy;
X    int x,y,xlim;
X
X    /* Too many points off the screen? */
X    if(offscreen(pt1) + offscreen(pt2) + offscreen(pt3) > MAXOFFSCREEN)
X        return;
X
X    p1 = pt1; /* needed by interpcolor */
X    p2 = pt2;
X    p3 = pt3;
X
X    /* fast way if single point or single line */
X    if (p1.y == p2.y && p1.x == p2.x)
X    {
X        plot = fillplot;
X        if (p1.y == p3.y && p1.x == p3.x)
X            (*plot)(p1.x, p1.y, color);
X        else
X            draw_line(p1.x,p1.y,p3.x,p3.y,color);
X        plot = normalplot;
X        return;
X    }
X    else if ( (p3.y == p1.y && p3.x == p1.x) || (p3.y == p2.y && p3.x == p2.x) )
X    {
X        plot = fillplot;
X        draw_line(p1.x,p1.y,p2.x,p2.y,color);
X        plot = normalplot;
X        return;
X    }
X
X    /* find min max y */
X    miny = maxy = p1.y;
X    if(p2.y < miny) miny = p2.y;
X    else         maxy = p2.y;
X    if(p3.y < miny) miny = p3.y;
X    else if(p3.y > maxy) maxy = p3.y;
X
X    /* only worried about values on screen */
X    if(miny < 0)        miny = 0;
X    if(maxy >= ydots) maxy = ydots-1;
X
X    for(y=miny;y<=maxy;y++)
X    {
X        minmax_x[y].minx = (int)INT_MAX;
X        minmax_x[y].maxx = (int)INT_MIN;
X    }
X
X    /* set plot to "fake" plot function */
X    plot = putminmax;
X
X    /* build table of extreme x's of triangle */
X    draw_line(p1.x,p1.y,p2.x,p2.y,0);
X    draw_line(p2.x,p2.y,p3.x,p3.y,0);
X    draw_line(p3.x,p3.y,p1.x,p1.y,0);
X
X    for(y=miny;y<=maxy;y++)
X    {
X        xlim = minmax_x[y].maxx;
X        for(x=minmax_x[y].minx;x<=xlim;x++)
X        (*fillplot)(x,y,color);
X    }
X    plot = normalplot;
X}
X
X
Xstatic int _fastcall offscreen(struct point pt)
X{
X    if(pt.x >= 0)
X        if(pt.x < xdots)
X            if(pt.y >= 0)
X                if(pt.y < ydots)
X                    return(0); /* point is ok */
X    if (abs(pt.x) > 0-bad_check || abs(pt.y) > 0-bad_check)
X        return(99); /* point is bad */
X    return(1); /* point is off the screen */
X}
X
Xstatic void _fastcall clipcolor(int x,int y,int color)
X{
X    if(0 <= x    && x < xdots    &&
X        0 <= y    && y < ydots    &&
X        0 <= color && color < filecolors)
X    {
X        standardplot(x,y,color);
X
X        if (Targa_Out)
X            if (!(glassestype==1 || glassestype==2)) /* standardplot modifies color in these types */
X                targa_color(x, y, color);
X    }
X}
X
X/*********************************************************************/
X/* This function is the same as clipcolor but checks for color being */
X/* in transparent range. Intended to be called only if transparency  */
X/* has been enabled.                                                 */
X/*********************************************************************/
X
Xstatic void _fastcall T_clipcolor(int x,int y,int color)
X{
X    if (0 <= x        && x < xdots            && /*  is the point on screen?  */
X        0 <= y    && y < ydots            && /*  Yes?  */
X        0 <= color && color < colors    && /*  Colors in valid range?  */
X        /*  Lets make sure its not a transparent color  */
X        (transparent[0] > color || color > transparent[1]))
X    {
X        standardplot(x,y,color); /* I guess we can plot then  */
X
X        if (Targa_Out)
X            if (!(glassestype==1 || glassestype==2)) /* standardplot modifies color in these types */
X                targa_color(x, y, color);
X    }
X}
X
X/************************************************************************/
X/* A substitute for plotcolor that interpolates the colors according    */
X/* to the x and y values of three points (p1,p2,p3) which are static in    */
X/* this routine                                                            */
X/*                                                                        */
X/*    In Light source modes, color is light value, not actual color        */
X/*    Real_Color always contains the actual color                            */
X/************************************************************************/
X
Xstatic void _fastcall interpcolor(int x,int y,int color)
X{
X    int D,d1,d2,d3;
X
X  /* this distance formula is not the usual one - but it has the virtue
X        that it uses ONLY additions (almost) and it DOES go to zero as the
X        points get close.
X        */
X
X    d1 = abs(p1.x-x)+abs(p1.y-y);
X    d2 = abs(p2.x-x)+abs(p2.y-y);
X    d3 = abs(p3.x-x)+abs(p3.y-y);
X
X    D = (d1 + d2 + d3) << 1;
X    if(D)
X    {  /* calculate a weighted average of colors -
X        long casts prevent integer overflow. This can evaluate to zero */
X        color = ((long)(d2+d3)*(long)p1.color +
X            (long)(d1+d3)*(long)p2.color +
X            (long)(d1+d2)*(long)p3.color) / D;
X    }
X
X    if(0 <= x        && x < xdots    &&
X        0 <= y        && y < ydots    &&
X        0 <= color && color < colors &&
X        (transparent[1] == 0 || Real_Color > transparent[1] ||
X        transparent[0] > Real_Color))
X    {
X        if (Targa_Out)
X            if (!(glassestype==1 || glassestype==2)) /* standardplot modifies color in these types */
X                D = targa_color(x, y, color);
X
X        if (FILLTYPE >= 5)
X            if (Real_V && Targa_Out)
X                color = D;
X            else
X                        {
X                            color =  (1 + (unsigned)color * IAmbient)/256;
X                            if (color == 0)
X                                color = 1;
X                        }
X        standardplot(x,y,color);
X    }
X}
X
X
X
X/*
X    In non light source modes, both color and Real_Color contain the
X    actual pixel color. In light source modes, color contains the
X    light value, and Real_Color contains the origninal color
X
X    This routine takes a pixel modifies it for lightshading if appropriate
X    and plots it in a Targa file. Used in plot3d.c
X*/
X
Xint _fastcall targa_color(int x,int y,int color)
X{
X    unsigned long H, S, V;
X    BYTE RGB[3];
X
X    if (FILLTYPE == 2 || glassestype==1 || glassestype==2)
X        Real_Color = color; /* So Targa gets interpolated color */
X
X    RGB[0]  =  dacbox [Real_Color] [0] << 2; /* Move color space to */
X    RGB[1]  =  dacbox [Real_Color] [1] << 2; /* 256 color primaries */
X    RGB[2]  =  dacbox [Real_Color] [2] << 2; /* from 64 colors */
X
X    /* Now lets convert it to HSV */
X    R_H(RGB[0], RGB[1], RGB[2], &H, &S, &V);
X
X    /* Modify original S and V components */
X    if (FILLTYPE > 4 && !(glassestype==1 || glassestype==2)) /* Adjust for Ambient */
X        V = (V * (65535 - (unsigned)(color * IAmbient))) / 65535;
X
X    if (haze)
X    {
X        S = (unsigned long)(S * HAZE_MULT) / 100; /* Haze lowers sat of colors */
X        if (V >= 32640) /* Haze reduces contrast */
X        {
X            V = V - 32640;
X            V = (unsigned long)((V * HAZE_MULT) / 100);
X            V = V + 32640;
X        }
X        else
X        {
X            V = 32640 - V;
X            V = (unsigned long)((V * HAZE_MULT) / 100);
X            V = 32640 - V;
X        }
X    }
X    /* Now lets convert it back to RGB. Original Hue, modified Sat and Val */
X    H_R(&RGB[0], &RGB[1], &RGB[2], H, S, V);
X
X    if (Real_V)
X        V = (35 * (int)RGB[0] + 45 * (int)RGB[1] + 20 * (int)RGB[2]) / 100;
X
X    /* Now write the color triple to its transformed location */
X    /* on the disk. */
X    targa_writedisk (x+sxoffs, y+syoffs, RGB[0], RGB[1], RGB[2]);
X
X    return(255-V);
X}
X
X
X
Xstatic int set_pixel_buff(BYTE *pixels,BYTE far *fraction,unsigned linelen)
X{
X    int i;
X    if ((evenoddrow++ & 1) == 0) /* even rows are color value */
X    {
X        for(i=0;i<linelen;i++) /* add the fractional part in odd row */
X            fraction[i] = pixels[i];
X        return(1);
X    }
X    else /* swap */
X    {
X        BYTE tmp;
X        for(i=0;i<linelen;i++) /* swap so pixel has color */
X        {
X            tmp = pixels[i];
X            pixels[i]=fraction[i];
X            fraction[i]=tmp;
X        }
X    }
X    return(0);
X}
X
X
X/* cross product  - useful because cross is perpendicular to v and w */
X/**** PB commented this out - it is unused
Xstatic int chk_cross_product (int col, int row,VECTOR v, VECTOR w, VECTOR cross, VECTOR crossavg)
X{
X    static start = 1;
X    static FILE *fp;
X
X    if(start)
X    {
X        fp = fopen("blob","w");
X        start = 0;
X    }
X
X    fprintf(fp,"row %+4d col %+4d v1 %+8.3e %+8.3e %+8.3e v2 %+8.3e %+8.3e %+8.3e cross %+8.3e %+8.3e %+8.3e crossavg %+8.3e %+8.3e %+8.3e \n",
X    row,col,v[0],v[1],v[2],w[0],w[1],w[2],cross[0],cross[1],cross[2],crossavg[0],crossavg[1],crossavg[2]);
X    return(0);
X}
X***/
X
X/**************************************************************************
X
X        Common routine for printing error messages to the screen for Targa
X        and other files
X
X**************************************************************************/
X
X
X#ifndef XFRACT
Xstatic char f[]                 = "%Fs%Fs";
Xstatic char fff[]               = "%Fs%Fs%Fs";
X#else
Xstatic char f[]                 = "%s%s";
Xstatic char fff[]               = "%s%s%s";
X#endif
Xstatic char far OOPS[]  = {"OOPS, "};
Xstatic char far E1[]        = {"can't handle this type of file.\n"};
Xstatic char far str1[]  = {"couldn't open  < "};
Xstatic char far str3[]  = {"image wrong size\n"};
Xstatic char far temp1[] = {"ran out of disk space. < "};
X
Xstatic void File_Error (char *File_Name1, int ERROR)
X{
X   char msgbuf[200];
X
X    error = ERROR;
X    switch(ERROR)
X    {
X    case 1: /* Can't Open */
X#ifndef XFRACT
X                sprintf(msgbuf,"%Fs%Fs%s >", OOPS, str1, File_Name1);
X#else
X                sprintf(msgbuf,"%s%s%s >", OOPS, str1, File_Name1);
X#endif
X        break;
X    case 2: /* Not enough room */
X#ifndef XFRACT
X        sprintf(msgbuf,"%Fs%Fs%s >", OOPS, temp1, File_Name1);
X#else
X                sprintf(msgbuf,"%s%s%s >", OOPS, temp1, File_Name1);
X#endif
X        break;
X    case 3: /* Image wrong size */
X        sprintf(msgbuf, f, OOPS, str3);
X        break;
X    case 4: /* Wrong file type */
X        sprintf(msgbuf, f, OOPS, E1);
X        break;
X    }
X    stopmsg(0,msgbuf);
X    return;
X}
X
X
X/************************************************************************/
X/*                                                                        */
X/*        This function opens a TARGA_24 file for reading and writing. If    */
X/*        its a new file, (overlay == 0) it writes a header. If it is to    */
X/*        overlay an existing file (overlay == 1) it copies the original    */
X/*        header whose lenght and validity was determined in                */
X/*        Targa_validate.                                                    */
X/*                                                                        */
X/*        It Verifies there is enough disk space, and leaves the file     */
X/*        at the start of the display data area.                            */
X/*                                                                        */
X/*        If this is an overlay, closes source and copies to "targa_temp"    */
X/*        If there is an error close the file.                             */
X/*                                                                        */
X/* **********************************************************************/
X
X
Xstatic int startdisk1 (char *File_Name2, FILE *Source, int overlay)
X{
X    int i,j,k, inc;
X    FILE *fps;
X
X    /* Open File for both reading and writing */
X    if ((fps=fopen(File_Name2,"w+b"))==NULL)
X    {
X        File_Error(File_Name2, 1);
X        return(-1); /* Oops, somethings wrong! */
X    }
X
X    inc = 1; /* Assume we are overlaying a file */
X
X    /* Write the header */
X    if (overlay) /* We are overlaying a file */
X        for (i=0;i<T_header_24;i++) /* Copy the header from the Source */
X            fputc(fgetc(Source),fps);
X    else
X    {    /* Write header for a new file */
X        /* ID field size = 0, No color map, Targa type 2 file */
X        for (i=0;i<12;i++)
X        {
X            if (i == 2)
X                fputc(i,fps);
X            else
X                fputc(0,fps);
X        }
X        /*  Write image size  */
X        for (i=0;i<4;i++)
X            fputc(upr_lwr[i],fps);
X        fputc(T24,fps); /* Targa 24 file */
X        fputc(T32,fps); /* Image at upper left */
X        inc = 3;
X    }
X
X    /*  Finished with the header, now lets work on the display area  */
X    for (i=0;i<ydots;i++)    /* "clear the screen" (write to the disk) */
X    {
X        for (j=0;j<line_length1;j=j+inc)
X        {
X            if (overlay)
X                fputc(fgetc(Source), fps);
X            else
X                for (k=2;k>-1;k--)
X                    fputc(back_color[k], fps);            /* Targa order (B, G, R) */
X        }
X        if (ferror (fps))
X        {
X            /*  Almost certainly not enough disk space  */
X            fclose (fps);
X            fclose (Source);
X            remove (File_Name2);
X            File_Error(File_Name2, 2);
X            return(-2);
X        }
X        if (check_key())        return(-3);
X    }
X
X    if (targa_startdisk(fps, T_header_24) != 0)
X    {
X        enddisk();
X        remove (File_Name2);
X        return(-4);
X    }
X    return(0);
X}
X
X/**************************************************************************
X
X
X**************************************************************************/
X
Xint targa_validate(char *File_Name)
X{
X    FILE *fp;
X    int i, j = 0;
X
X    /* Attempt to open source file for reading */
X    if ((fp=fopen(File_Name,"rb"))==NULL)
X    {
X        File_Error(File_Name, 1);
X        return(-1); /* Oops, file does not exist */
X    }
X
X    T_header_24 += fgetc(fp); /* Check ID field and adjust header size */
X
X    if (fgetc(fp)) /* Make sure this is an unmapped file */
X    {
X        File_Error(File_Name, 4);
X        return(-1);
X    }
X
X    if (fgetc(fp)!=2) /* Make sure it is a type 2 file */
X    {
X        File_Error(File_Name, 4);
X        return(-1);
X    }
X
X    /* Skip color map specification */
X    for (i=0;i<5;i++)
X            fgetc(fp);
X
X    for (i=0;i<4;i++)
X    {
X        /* Check image origin */
X        fgetc(fp);
X        if(j != 0)
X        {
X            File_Error(File_Name, 4);
X            return(-1);
X        }
X    }
X    /* Check Image specs */
X    for (i=0;i<4;i++)
X        if(fgetc(fp) != upr_lwr[i])
X        {
X            File_Error(File_Name,3);
X            return(-1);
X        }
X
X    if(fgetc(fp) != T24) error=4; /* Is it a targa 24 file? */
X    if(fgetc(fp) != T32) error=4; /* Is the origin at the upper left? */
X    if (error == 4)
X    {
X        File_Error(File_Name,4);
X        return(-1);
X    }
X    rewind(fp);
X
X    /* Now that we know its a good file, create a working copy */
X    if (startdisk1(targa_temp, fp, 1))
X        return(-1);
X
X    fclose(fp);    /* Close the source */
X
X    T_Safe=1; /* Original file successfully copied to targa_temp */
X    return(0);
X}
X
Xstatic int R_H (R, G, B, H, S, V)
XBYTE R,G,B;
Xunsigned long *H, *S, *V;
X{
X    unsigned long    R1, G1, B1, DENOM;
X    BYTE MIN;
X
X    *V = R;
X    MIN = G;
X    if (R < G)
X    {
X        *V = G;
X        MIN = R;
X        if (G < B)            *V = B;
X        if (B < R)            MIN = B;
X    }
X    else
X    {
X        if (B < G)            MIN = B;
X        if (R < B)            *V = B;
X    }
X    DENOM = *V - MIN;
X    if (*V != 0 && DENOM !=0)
X    {
X        *S = ((DENOM << 16) / *V) - 1;
X    }
X    else  *S = 0;/* Color is black! and Sat has no meaning */
X    if(*S == 0) /*  R=G=B => shade of grey and Hue has no meaning */
X    {
X        *H = 0;
X        *V = *V << 8;
X        return(1);  /* v or s or both are 0 */
X    }
X    if (*V == MIN)
X    {
X        *H = 0;
X        *V = *V << 8;
X        return(0);
X    }
X    R1 = (((*V - R) * 60) << 6) / DENOM;        /* distance of color from red    */
X    G1 = (((*V - G) * 60) << 6) / DENOM;        /* distance of color from green */
X    B1 = (((*V - B) * 60) << 6) / DENOM;        /* distance of color from blue  */
X    if(*V == R)
X        if (MIN == G)        *H = (300 << 6) + B1;
X        else            *H = (60 << 6) - G1;
X    if(*V == G)
X        if (MIN == B)        *H = (60 << 6) + R1;
X        else            *H = (180 << 6) - B1;
X    if(*V == B)
X        if(MIN == R)        *H = (180 << 6) + G1;
X        else            *H = (300 << 6) - R1;
X
X    *V = *V << 8;
X    return(0);
X}
X
Xstatic int H_R (R, G, B, H, S, V)
XBYTE *R, *G, *B;
Xunsigned long  H, S, V;
X{
X    unsigned long        P1, P2, P3;
X    int    RMD, I;
X
X    if(H >= 23040)            H = H % 23040; /*  Makes h circular  */
X    I = H / 3840;
X    RMD = H % 3840;            /*  RMD = fractional part of H    */
X
X    P1 = ((V * (65535 - S)) / 65280) >> 8;
X    P2 = (((V * (65535 - (S * RMD) / 3840)) / 65280) - 1) >> 8;
X    P3 = (((V * (65535 - (S * (3840 - RMD)) / 3840)) / 65280)) >> 8;
X    V = V >> 8;
X    switch (I)
X    {
X    case 0:
X        *R = V;
X        *G = P3;
X        *B = P1;
X        break;
X    case 1:
X        *R = P2;
X        *G = V;
X        *B = P1;
X        break;
X    case 2:
X        *R = P1;
X        *G = V;
X        *B = P3;
X        break;
X    case 3:
X        *R = P1;
X        *G = P2;
X        *B = V;
X        break;
X    case 4:
X        *R = P3;
X        *G = P1;
X        *B = V;
X        break;
X    case 5:
X        *R = V ;
X        *G = P1;
X        *B = P2;
X        break;
X    }
X    return(0);
X}
X
X
X/***************************************************************************/
X/*                                        */
X/* EB & DG fiddled with outputs for Rayshade so they work. with v4.x.      */
X/* EB == eli brandt.     [e-mail]                                          */
X/* DG == dan goldwater.  [e-mail] & [e-mail] */
X/*    (NOTE: all the stuff we fiddled with is commented with "EB & DG" (plus even some extra bonus comments!) */
X/* general raytracing code info/notes:                         */
X/*                                            */
X/*  ray == 0 means no raytracer output    ray == 7 is for dxf                    */
X/*  ray == 1 is for dkb/pov        ray == 4 is for mtv            */
X/*  ray == 2 is for vivid        ray == 5 is for rayshade        */
X/*  ray == 3 is for raw            ray == 6 is for acrospin        */
X/*                                          */
X/*  rayshade needs counterclockwise triangles.  raytracers that support     */
X/*  the 'heightfield' primitive include rayshade and pov.  anyone want to write */
X/*  code to make heightfields?  they are *MUCH* faster to trace than triangles  */
X/*  when doing landscapes...                            */
X/*  */
X/*  stuff EB & DG changed:  */
X/*  made the rayshade output create a "grid" aggregate object (one of rayshade's primitives), instead */
X/*  of a global grid.  as a result, the grid can be optimized based on the number of triangles.  */
X/*  the z component of the grid can always be 1 since the surface formed by the triangles is flat */
X/*  (ie, it doesnt curve over itself).  this is a major optimization.  the x and y grid size is */
X/*  also optimized for a 4:3 aspect ratio image, to get the fewest possible traingles in each grid square. */
X/*  also, we fixed the rayshade code so it actually produces output that works with rayshade. */
X/*  (maybe the old code was for a really old version of rayshade?).  */
X/*  */
X/*  */
X/***************************************************************************/
X
X/********************************************************************/
X/*                                                                    */
X/*  This routine writes a header to a ray tracer data file. It        */
X/*  Identifies the version of FRACTINT which created it an the        */
X/*  key 3D parameters in effect at the time.                        */
X/*                                                                    */
X/********************************************************************/
X
X
Xstatic char far declare[] = {"DECLARE    "};
Xstatic char far frac_default[] = {"F_Dflt"};
Xstatic char far color[] = {"COLOR  "};
Xstatic char far dflt[] = {"RED 0.8 GREEN 0.4 BLUE 0.1\n"};
Xstatic char far d_color[] = {"0.8 0.4 0.1"};
Xstatic char far r_surf[] = {"0.95 0.05 5 0 0\n"};
Xstatic char far surf[] = {"surf={diff="};
Xstatic char far rs_surf[] = {"applysurf diffuse "};   /* EB & DG: changed "surface T" to "applysurf" and "diff" to "diffuse" */
Xstatic char far end[] = {"END_"};
Xstatic char far plane[] = {"PLANE"};
Xstatic char far m1[] = {"-1.0 "};
Xstatic char far one[] = {" 1.0 "};
Xstatic char far z[]  = {" 0.0 "};
Xstatic char far bnd_by[]  = {" BOUNDED_BY\n"};
Xstatic char far end_bnd[]  = {" END_BOUND\n"};
Xstatic char far inter[]  = {"INTERSECTION\n"};
X#ifndef XFRACT
Xstatic char fmt[] = "   %Fs <%Fs%Fs%Fs> % #4.3f %Fs%Fs\n";
X#else
Xstatic char fmt[] = "   %s <%s%s%s> % #4.3f %s%s\n";
X#endif
Xstatic char dxf_begin[] = {"  0\nSECTION\n  2\nTABLES\n  0\nTABLE\n  2\nLAYER\n\
X 70\n     2\n  0\nLAYER\n  2\n0\n 70\n     0\n 62\n     7\n  6\nCONTINUOUS\n\
X  0\nLAYER\n  2\nFRACTAL\n 70\n    64\n 62\n     1\n  6\nCONTINUOUS\n  0\n\
XENDTAB\n  0\nENDSEC\n  0\nSECTION\n  2\nENTITIES\n"};
Xstatic char dxf_3dface[] = {"  0\n3DFACE\n  8\nFRACTAL\n 62\n%3d\n"};
Xstatic char dxf_vertex[] = {"%3d\n%g\n"};
Xstatic char dxf_end[] = {"  0\nENDSEC\n  0\nEOF\n"};
X
Xstatic char far composite[] = {"COMPOSITE"};
Xstatic char far object[]  = {"OBJECT"};
Xstatic char far triangle[] = {"TRIANGLE "};
Xstatic char far l_tri[] = {"triangle"};
Xstatic char far texture[] = {"TEXTURE\n"};
X/* static char far end_texture[] = {" END_TEXTURE\n"}; */
Xstatic char far red[] = {"RED"};
Xstatic char far green[] = {"GREEN"};
Xstatic char far blue[] = {"BLUE"};
X
Xstatic char far frac_texture[] = {"    AMBIENT 0.25 DIFFUSE 0.75"};
X
Xstatic char far polygon[] = {"polygon={points=3;"};
Xstatic char far vertex[] = {" vertex =  "};
Xstatic char far d_vert[] = {"    <"};
Xstatic char f1[] = "% #4.4f ";
X/* EB & DG: changed this to much better values. now it actually makes a good trace */
Xstatic char far grid[] = {"screen 640 480\neyep 0 2.1 0.8\nlookp 0 0 -0.95\nlight 1 point -2 1 1.5\n"};
Xstatic char far grid2[] = {"background .3 0 0\nreport verbose\n"};
X
Xstatic char n[] = "\n";
Xstatic char f2[] = "R%dC%d R%dC%d\n";
Xstatic char far ray_comment1[] = {"/* make a gridded aggregate. this size grid is fast for landscapes. */\n"};
Xstatic char far ray_comment2[] = {"/* make z grid = 1 always for landscapes. */\n\n"};
Xstatic char far grid3[] = {"grid 33 25 1\n"};
X
X
Xstatic int _fastcall RAY_Header(void)
X
X
X{  /* Open the ray tracing output file */
X    check_writefile(ray_name,".ray");
X    if ((File_Ptr1=fopen(ray_name,"w"))==NULL)
X        return(-1); /* Oops, somethings wrong! */
X
X    if (RAY == 2)
X        fprintf(File_Ptr1, "//");
X    if (RAY == 4)
X        fprintf(File_Ptr1, "#");
X    if (RAY == 5)
X        fprintf(File_Ptr1, "/*\n");
X    if (RAY == 6)
X        fprintf(File_Ptr1, "--");
X      if (RAY == 7)
X          fprintf(File_Ptr1, dxf_begin);
X
X      if (RAY != 7)
X         fprintf(File_Ptr1, banner, s3, release/100., s3a);
X
X    if (RAY == 5)
X        fprintf(File_Ptr1, "*/\n");
X
X
X    /* Set the default color */
X    if (RAY == 1)
X    {
X        fprintf (File_Ptr1, f, declare, frac_default);
X        fprintf (File_Ptr1, " = ");
X        fprintf (File_Ptr1, f, color, dflt);
X    }
X    if (BRIEF)
X    {
X        if (RAY == 2)
X        {
X            fprintf (File_Ptr1, f, surf, d_color);
X            fprintf (File_Ptr1, ";}\n");
X        }
X        if (RAY == 4)
X        {
X            fprintf (File_Ptr1, "f ");
X            fprintf (File_Ptr1, f, d_color, r_surf);
X        }
X        if (RAY == 5)
X            fprintf (File_Ptr1, f, rs_surf, d_color);
X    }
X      if (RAY != 7)
X        fprintf (File_Ptr1, n);
X
X    if (RAY == 5)             /* EB & DG: open "grid" opject, a speedy way to do aggregates in rayshade */
X        fprintf (File_Ptr1, fff, ray_comment1,ray_comment2,grid3);
X
X    if (RAY == 6)
X#ifndef XFRACT
X                fprintf (File_Ptr1, "%Fs", acro_s1);
X#else
X        fprintf (File_Ptr1, "%s", acro_s1);
X#endif
X
X    return(0);
X}
X
X
X/********************************************************************/
X/*                                                                    */
X/*  This routine describes the triangle to the ray tracer, it        */
X/*  sets the color of the triangle to the average of the color        */
X/*  of its verticies and sets the light parameters to arbitrary        */
X/*  values.                                                            */
X/*                                                                    */
X/*  Note: numcolors (number of colors in the source                    */
X/*  file) is used instead of colors (number of colors avail. with    */
X/*  display) so you can generate ray trace files with your LCD        */
X/*  or monochrome display                                            */
X/*                                                                    */
X/********************************************************************/
X
Xstatic int _fastcall out_triangle(struct f_point pt1, struct f_point pt2,
X            struct f_point pt3, int c1, int c2, int c3)
X
X{
Xint i, j;
Xfloat c[3];
Xfloat pt_t[3][3];
X
X    /* Normalize each vertex to screen size and adjust coordinate system */
X    pt_t[0][0]            =    2 * pt1.x            / xdots  - 1;
X    pt_t[0][1]            =  (2 * pt1.y            / ydots  - 1);
X    pt_t[0][2]            =  -2 * pt1.color / numcolors - 1;
X    pt_t[1][0]            =    2 * pt2.x            / xdots  - 1;
X    pt_t[1][1]            =  (2 * pt2.y            / ydots  - 1);
X    pt_t[1][2]            =  -2 * pt2.color / numcolors - 1;
X    pt_t[2][0]            =    2 * pt3.x            / xdots  - 1;
X    pt_t[2][1]            =  (2 * pt3.y            / ydots  - 1);
X    pt_t[2][2]            =  -2 * pt3.color / numcolors - 1;
X
X    /* Color of triangle is average of colors of its verticies */
X    if (!BRIEF)
X        for (i=0;i<=2;i++)
X        c[i] = (float)(dacbox[c1][i] + dacbox[c2][i] + dacbox[c3][i])
X                / (3 * 63);
X
X        /* get rid of degenerate triangles: any two points equal */
X        if (pt_t[0][0] == pt_t[1][0] &&
X                pt_t[0][1] == pt_t[1][1] &&
X                pt_t[0][2] == pt_t[1][2] ||
X
X                pt_t[0][0] == pt_t[2][0] &&
X                pt_t[0][1] == pt_t[2][1] &&
X                pt_t[0][2] == pt_t[2][2] ||
X
X                pt_t[2][0] == pt_t[1][0] &&
X                pt_t[2][1] == pt_t[1][1] &&
X                pt_t[2][2] == pt_t[1][2])
X            return(0);
X
X    /* Describe the triangle */
X#ifndef XFRACT
X    if (RAY == 1)
X        fprintf (File_Ptr1, " %Fs\n  %Fs", object, triangle);
X        if (RAY == 2 && !BRIEF)
X        fprintf (File_Ptr1, "%Fs", surf);
X#else
X    if (RAY == 1)
X        fprintf (File_Ptr1, " %s\n  %s", object, triangle);
X        if (RAY == 2 && !BRIEF)
X        fprintf (File_Ptr1, "%s", surf);
X#endif
X    if (RAY == 4 && !BRIEF)
X        fprintf (File_Ptr1, "f");
X    if (RAY == 5 && !BRIEF)
X#ifndef XFRACT
X        fprintf (File_Ptr1, "%Fs", rs_surf);
X#else
X        fprintf (File_Ptr1, "%s", rs_surf);
X#endif
X
X    if (!BRIEF && RAY != 1 && RAY != 7)
X        for (i=0;i<=2;i++)
X        fprintf (File_Ptr1, f1, c[i]);
X
X    if (RAY == 2)
X    {
X        if (!BRIEF)
X        fprintf (File_Ptr1, ";}\n");
X#ifndef XFRACT
X        fprintf (File_Ptr1, "%Fs", polygon);
X#else
X        fprintf (File_Ptr1, "%s", polygon);
X#endif
X    }
X    if (RAY == 4)
X    {
X        if (!BRIEF)
X#ifndef XFRACT
X            fprintf (File_Ptr1, "%Fs", r_surf);
X#else
X            fprintf (File_Ptr1, "%s", r_surf);
X#endif
X        fprintf (File_Ptr1, "p 3");
X    }
X    if (RAY == 5)
X    {
X        if (!BRIEF)
X            fprintf (File_Ptr1, n);
X#ifndef XFRACT
X        fprintf (File_Ptr1, "%Fs", l_tri);   /* EB & DG: removed "T" after "triangle" */
X#else
X        fprintf (File_Ptr1, "%s", l_tri);    /* EB & DG: removed "T" after "triangle" */
X#endif
X    }
X
X      if (RAY == 7)
X          fprintf (File_Ptr1, dxf_3dface, min(255, max(1, c1)));
X
X    for(i=0;i<=2;i++)  /*  Describe each  Vertex  */
X    {
X          if (RAY != 7)
X        fprintf (File_Ptr1, n);
X
X#ifndef XFRACT
X        if (RAY == 1)
X            fprintf (File_Ptr1, "%Fs", d_vert);
X        if (RAY == 2)
X            fprintf (File_Ptr1, "%Fs", vertex);
X#else
X        if (RAY == 1)
X            fprintf (File_Ptr1, "%s", d_vert);
X        if (RAY == 2)
X            fprintf (File_Ptr1, "%s", vertex);
X#endif
X        if (RAY > 3 && RAY != 7)
X            fprintf (File_Ptr1, " ");
X
X        for(j=0;j<=2;j++)
X               {
X              if (RAY == 7)
X                  {
X                  /* write 3dface entity to dxf file */
X                  fprintf (File_Ptr1, dxf_vertex, 10*(j+1)+i, pt_t[i][j]);
X                  if (i == 2)                /* 3dface needs 4 vertecies */
X                      fprintf (File_Ptr1, dxf_vertex, 10*(j+1)+i+1, pt_t[i][j]);
X                  }
X              else if (!(RAY == 4 || RAY == 5))
X                  fprintf (File_Ptr1, f1, pt_t[i][j]); /* Right handed */
X              else
X                  fprintf (File_Ptr1, f1, pt_t[2-i][j]); /* Left handed */
X              }
X
X        if (RAY == 1)
X        fprintf (File_Ptr1, ">");
X        if (RAY == 2)
X        fprintf (File_Ptr1, ";");
X    }
X
X    if (RAY == 1)
X    {
X#ifndef XFRACT
X        fprintf (File_Ptr1, " %Fs%Fs\n", end, triangle);
X#else
X        fprintf (File_Ptr1, " %s%s\n", end, triangle);
X#endif
X        if (!BRIEF)
X        {
X#ifndef XFRACT
X        fprintf (File_Ptr1, "  %Fs"
X            "    %Fs%Fs% #4.4f %Fs% #4.4f %Fs% #4.4f\n"
X            "%Fs"
X            " %Fs%Fs",
X#else
X        fprintf (File_Ptr1,
X            "  %s   %s%s% #4.4f %s% #4.4f %s% #4.4f\n%s %s%s",
X#endif
X            texture,
X            color, red, c[0], green, c[1], blue, c[2],
X            frac_texture,
X            end, texture);
X        }
X#ifndef XFRACT
X        fprintf (File_Ptr1, "  %Fs%Fs  %Fs%Fs",
X#else
X        fprintf (File_Ptr1, "  %s%s  %s%s",
X#endif
X        color, frac_default,
X        end, object);
X        triangle_bounds(pt_t); /* update bounding info */
X    }
X    if (RAY == 2)
X        fprintf (File_Ptr1, "}");
X    if (RAY == 3 && !BRIEF)
X        fprintf (File_Ptr1, n);
X
X      if (RAY != 7)
X        fprintf (File_Ptr1, n);
X
X    return(0);
X}
X
X
X/********************************************************************/
X/*                                                                    */
X/*  This routine calculates the min and max values of a triangle    */
X/*  for use in creating ray tracer data files. The values of min    */
X/*  and max x, y, and z are assumed to be global.                    */
X/*                                                                    */
X/********************************************************************/
X
Xstatic void _fastcall triangle_bounds(float pt_t[3][3])
X
X{
Xint i,j;
X
X    for (i=0;i<=2;i++)
X    for (j=0;j<=2;j++)
X    {
X        if(pt_t[i][j] < min_xyz[j]) min_xyz[j] = pt_t[i][j];
X        if(pt_t[i][j] > max_xyz[j]) max_xyz[j] = pt_t[i][j];
X    }
X    return;
X}
X
X/********************************************************************/
X/*                                                                    */
X/*  This routine starts a composite object for ray trace data files.*/
X/*                                                                    */
X/********************************************************************/
X
Xstatic int _fastcall start_object(void)
X
X{
X    if (RAY != 1)            return(0);
X
X    /*    Reset the min/max values, for bounding box  */
X    min_xyz[0] = min_xyz[1] = min_xyz[2] =  999999;
X    max_xyz[0] = max_xyz[1] = max_xyz[2] = -999999;
X
X#ifndef XFRACT
X    fprintf (File_Ptr1, "%Fs\n", composite);
X#else
X    fprintf (File_Ptr1, "%s\n", composite);
X#endif
X    return(0);
X}
X
X/********************************************************************/
X/*                                                                    */
X/*  This routine adds a bounding box for the triangles drawn        */
X/*  in the last block and completes the composite object created.    */
X/*  It uses the globals min and max x,y and z calculated in            */
X/*  z calculated in Triangle_Bounds().                                */
X/*                                                                    */
X/********************************************************************/
X
Xstatic int _fastcall end_object(int triout)
X{
X      if (RAY == 7)
X          return(0);
X    if (RAY == 1)
X    {
X    if (triout)
X        {
X        /* Make sure the bounding box is slightly larger than the object */
X        int i;
X        for (i=0;i<=2;i++)
X        {
X            if (min_xyz[i] == max_xyz[i])
X            {
X                min_xyz[i] -= 0.01;
X            max_xyz[i] += 0.01;
X            }
X            else
X            {
X                min_xyz[i] -= (max_xyz[i] - min_xyz[i]) * 0.01;
X                max_xyz[i] += (max_xyz[i] - min_xyz[i]) * 0.01;
X            }
X        }
X
X        /* Add the bounding box info */
X#ifndef XFRACT
X        fprintf (File_Ptr1, "%Fs  %Fs", bnd_by, inter);
X#else
X        fprintf (File_Ptr1, "%s  %s", bnd_by, inter);
X#endif
X        fprintf (File_Ptr1, fmt, plane,m1,z,z,-min_xyz[0],end,plane);
X        fprintf (File_Ptr1, fmt, plane,one,z,z,max_xyz[0],end,plane);
X        fprintf (File_Ptr1, fmt, plane,z,m1,z,-min_xyz[1],end,plane);
X        fprintf (File_Ptr1, fmt, plane,z,one,z,max_xyz[1],end,plane);
X        fprintf (File_Ptr1, fmt, plane,z,z,m1,-min_xyz[2],end,plane);
X        fprintf (File_Ptr1, fmt, plane,z,z,one,max_xyz[2],end,plane);
X#ifndef XFRACT
X        fprintf (File_Ptr1, "  %Fs%Fs%Fs", end, inter, end_bnd);
X#else
X        fprintf (File_Ptr1, "  %s%s%s", end, inter, end_bnd);
X#endif
X        }
X
X        /* Complete the composite object statement */
X#ifndef XFRACT
X        fprintf (File_Ptr1, "%Fs%Fs\n", end, composite);
X#else
X        fprintf (File_Ptr1, "%s%s\n", end, composite);
X#endif
X    }
X
X    if (RAY!=6 && RAY!=5)
X        fprintf (File_Ptr1, n);  /* EB & DG: too many newlines */
X
X    return(0);
X}
X
X
Xstatic void line3d_cleanup()
X{
X int i,j;
X    if(RAY && File_Ptr1)
X    {  /*  Finish up the ray tracing files */
X        static char far n_ta[] ={"{ No. Of Triangles = "};
X        if (RAY != 5 && RAY != 7)
X            fprintf (File_Ptr1, n);  /* EB & DG: too many newlines */
X        if (RAY == 2)
X            fprintf(File_Ptr1, "\n\n//");
X        if (RAY == 4)
X            fprintf(File_Ptr1, "\n\n#");
X
X        if (RAY == 5)
X#ifndef XFRACT
X            fprintf (File_Ptr1, "end\n\n/*good landscape:*/\n%Fs%Fs\n/*", grid,grid2); /* EB & DG: end grid aggregate */
X#else
X            fprintf (File_Ptr1, "end\n\n/*good landscape:*/\n%s%s\n/*", grid,grid2);  /* EB & DG: end grid aggregate */
X#endif
X        if (RAY == 6)
X        {
X#ifndef XFRACT
X            fprintf (File_Ptr1, "%Fs", acro_s2);
X#else
X            fprintf (File_Ptr1, "%s", acro_s2);
X#endif
X            for (i=0;i<RO;i++)
X                for (j=0;j<=CO_MAX;j++)
X                {
X                    if (j < CO_MAX)
X                        fprintf (File_Ptr1, f2, i, j, i, j+1);
X                    if (i < RO - 1)
X                        fprintf (File_Ptr1, f2, i, j, i+1, j);
X                    if (i && i < RO && j < CO_MAX)
X                        fprintf (File_Ptr1, f2, i, j, i-1, j+1);
X                }
X            fprintf (File_Ptr1, "\n\n--");
X        }
X            if (RAY != 7)
X#ifndef XFRACT
X            fprintf(File_Ptr1, "%Fs%d }*/\n\n",n_ta, num_tris); /* EB & DG: this is what s3a should be */
X/* see note        fprintf(File_Ptr1, "%Fs%d%Fs",n_ta, num_tris, s3a);   BUG! s3a=null here! why?! */
X#else
X            fprintf(File_Ptr1, "%s%d }*/\n\n",n_ta, num_tris);  /* EB & DG: this is what s3a should be */
X/* see note        fprintf(File_Ptr1, "%s%d%s",n_ta, num_tris, s3a);     BUG! s3a=null here! why?! */
X#endif
X          if (RAY == 7)
X               fprintf (File_Ptr1, dxf_end);
X        fclose(File_Ptr1);
X        File_Ptr1 = NULL;
X    }
X    if (Targa_Out)
X    {    /*  Finish up targa files */
X        T_header_24 = 18; /* Reset Targa header size */
X        enddisk();
X        if (!debugflag && T_Safe && !error && Targa_Overlay)
X        {
X            remove(light_name);
X            rename(targa_temp,light_name);
X        }
X        if (!debugflag && Targa_Overlay)
X            remove (targa_temp);
X    }
X    usr_floatflag &= 1; /* strip second bit */
X    error = T_Safe = 0;
X}
X
SHAR_EOF
$TOUCH -am 1028230093 line3d.c &&
chmod 0644 line3d.c ||
echo "restore of line3d.c failed"
set `wc -c line3d.c`;Wc_c=$1
if test "$Wc_c" != "77259"; then
    echo original size 77259, current size $Wc_c
fi
# ============= loadfdos.c ==============
echo "x - extracting loadfdos.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > loadfdos.c &&
X/*
X    loadfdos.c - subroutine of loadfile.c (read_overlay) which sets
X         up video (mode, screen size).
X    This module is linked as an overlay, should only be called from loadfile.c
X
X    This code was split to a separate module to isolate the DOS only aspects
X    of loading an image.  get_video_mode should return with:
X      return code 0 for ok, -1 for error or cancelled by user
X      video parameters setup for the mainline, in the dos case this means
X    setting initmode to video mode, based on this fractint.c will set up
X    for and call setvideomode
X      set viewwindow on if file going to be loaded into a view smaller than
X    physical screen, in this case also set viewreduction, viewxdots,
X    viewydots, and finalaspectratio
X      set skipxdots and skipydots, to 0 if all pixels are to be loaded,
X    to 1 for every 2nd pixel, 2 for every 3rd, etc
X
X    In WinFract, at least initially, get_video_mode can do just the
X    following:
X      set overall image x & y dimensions (sxdots and sydots) to filexdots
X    and fileydots (note that filecolors is the number of colors in the
X    gif, not sure if that is of any use...)
X      if current window smaller than new sxdots and sydots, use scroll bars,
X    if larger perhaps reduce the window size? whatever
X      set viewwindow to 0 (no need? it always is for now in windows vsn?)
X      set finalaspectratio to .75 (ditto?)
X      set skipxdots and skipydots to 0
X      return 0
X
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#include <math.h>
X#include "fractint.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic int    vidcompare(VOIDCONSTPTR ,VOIDCONSTPTR );
Xstatic void   format_vid_inf(int i,char *err,char *buf);
Xstatic double vid_aspect(int tryxdots,int tryydots);
Xstatic void   format_item(int,char *);
Xstatic int    check_modekey(int,int);
X
X
Xextern int    initmode;         /* initial video mode        */
Xextern int    askvideo;
Xextern int    initbatch;        /* 1 if batch run (no kbd)  */
Xextern int    fractype;         /* fractal type         */
Xextern int    viewwindow;        /* 0 for full screen, 1 for window */
Xextern float  viewreduction;        /* window auto-sizing */
Xextern float  finalaspectratio;     /* for view shape and rotation */
Xextern int    viewxdots,viewydots;    /* explicit view sizing */
Xextern int    fileydots, filexdots, filecolors;
Xextern float  fileaspectratio;
Xextern int    skipxdots,skipydots;    /* for decoder, when reducing image */
Xextern char   readname[];        /* name of fractal input file */
Xextern int    save_system,save_release;
Xextern int    display3d;        /* 3D display flag: 0 = OFF */
Xextern struct videoinfo far videotable[];
Xextern struct videoinfo far *vidtbl;
Xextern int    vidtbllen;
Xextern float  screenaspect;
X
X
Xstruct vidinf {
X   int entnum;       /* videoentry subscript */
X   unsigned flags; /* flags for sort's compare, defined below */
X   };
X/* defines for flags; done this way instead of bit union to ensure ordering;
X   these bits represent the sort sequence for video mode list */
X#define VI_EXACT 0x8000 /* unless the one and only exact match */
X#define VI_NOKEY   512    /* if no function key assigned */
X#define VI_DISK1   256    /* disk video and size not exact */
X#define VI_SSMALL  128    /* screen smaller than file's screen */
X#define VI_SBIG     64    /* screen bigger than file's screen */
X#define VI_VSMALL   32    /* screen smaller than file's view */
X#define VI_VBIG     16    /* screen bigger than file's view */
X#define VI_CSMALL    8    /* mode has too few colors */
X#define VI_CBIG      4    /* mode has excess colors */
X#define VI_DISK2     2    /* disk video */
X#define VI_ASPECT    1    /* aspect ratio bad */
X
X
Xstatic int vidcompare(VOIDCONSTPTR p1,VOIDCONSTPTR p2)
X{
X   struct vidinf *ptr1,*ptr2;
X   ptr1 = (struct vidinf *)p1;
X   ptr2 = (struct vidinf *)p2;
X   if (ptr1->flags < ptr2->flags) return(-1);
X   if (ptr1->flags > ptr2->flags) return(1);
X   if (vidtbl[ptr1->entnum].keynum < vidtbl[ptr2->entnum].keynum) return(-1);
X   if (vidtbl[ptr1->entnum].keynum > vidtbl[ptr2->entnum].keynum) return(1);
X   if (ptr1->entnum < ptr2->entnum) return(-1);
X   return(1);
X}
X
Xstatic void format_vid_inf(int i,char *err,char *buf)
X{
X   char kname[5];
X   far_memcpy((char far *)&videoentry,(char far *)&vidtbl[i],
X          sizeof(videoentry));
X   vidmode_keyname(videoentry.keynum,kname);
X   sprintf(buf,"%-5s %-25s %-4s %4d %4d %3d %-25s",  /* 76 chars */
X       kname, videoentry.name, err,
X       videoentry.xdots, videoentry.ydots,
X       videoentry.colors, videoentry.comment);
X   videoentry.xdots = 0; /* so tab_display knows to display nothing */
X}
X
Xstatic double vid_aspect(int tryxdots,int tryydots)
X{  /* calc resulting aspect ratio for specified dots in current mode */
X   return (double)tryydots / (double)tryxdots
X    * (double)videoentry.xdots / (double)videoentry.ydots
X    * screenaspect;
X   }
X
X
Xstatic struct vidinf *vidptr;
X
Xint get_video_mode(struct fractal_info *info)
X{
X   static char far hdg2[]={"key...name......................err..xdot.ydot.clr.comment.................."};
X   static char far warning[]={"\nWARNING: non-standard aspect ratio; loading will change your <v>iew settings"};
X   static char far select_msg[]={"\
XSelect a video mode.  Use the cursor keypad to move the pointer.\n\
XPress ENTER for selected mode, or use a video mode function key.\n\
XPress F1 for help, "};
X
X   struct vidinf vid[MAXVIDEOMODES];
X   int i,j;
X   int gotrealmode;
X   double ftemp,ftemp2;
X   unsigned tmpflags;
X
X   int tmpxdots,tmpydots;
X   float tmpreduce;
X   char *nameptr;
X   int    *attributes;
X   extern char temp1[256];
X   extern char dstack[]; /* for heading, avoid a 320 byte variable here  */
X             /* also, for attributes array, saves 600     */
X             /* both above necessary to avoid stack problems */
X   int oldhelpmode;
X   struct videoinfo far *vident;
X
X   initmode = -1;
X   load_fractint_cfg(0); /* get fractint.cfg into *vidtbl (== extraseg) */
X
X   /* try to find exact match for vid mode */
X   for (i = 0; i < vidtbllen; ++i) {
X      vident = &vidtbl[i];
X      if (info->xdots == vident->xdots && info->ydots == vident->ydots
X    && filecolors == vident->colors
X    && info->videomodeax == vident->videomodeax
X    && info->videomodebx == vident->videomodebx
X    && info->videomodecx == vident->videomodecx
X    && info->videomodedx == vident->videomodedx
X    && info->dotmode%100 == vident->dotmode%100) {
X     initmode = i;
X     break;
X     }
X      }
X
X   if (initmode == -1) /* try to find very good match for vid mode */
X      for (i = 0; i < vidtbllen; ++i) {
X     vident = &vidtbl[i];
X     if (info->xdots == vident->xdots && info->ydots == vident->ydots
X       && filecolors == vident->colors) {
X        initmode = i;
X        break;
X        }
X     }
X
X   /* setup table entry for each vid mode, flagged for how well it matches */
X   for (i = 0; i < vidtbllen; ++i) {
X      far_memcpy((char far *)&videoentry,(char far *)&vidtbl[i],
X         sizeof(videoentry));
X      tmpflags = VI_EXACT;
X      if (videoentry.keynum == 0)
X     tmpflags |= VI_NOKEY;
X      if (info->xdots > videoentry.xdots || info->ydots > videoentry.ydots)
X     tmpflags |= VI_SSMALL;
X      else if (info->xdots < videoentry.xdots || info->ydots < videoentry.ydots)
X     tmpflags |= VI_SBIG;
X      if (filexdots > videoentry.xdots || fileydots > videoentry.ydots)
X     tmpflags |= VI_VSMALL;
X      else if (filexdots < videoentry.xdots || fileydots < videoentry.ydots)
X     tmpflags |= VI_VBIG;
X      if (filecolors > videoentry.colors)
X     tmpflags |= VI_CSMALL;
X      if (filecolors < videoentry.colors)
X     tmpflags |= VI_CBIG;
X      if (i == initmode)
X     tmpflags -= VI_EXACT;
X      if (videoentry.dotmode%100 == 11) {
X     tmpflags |= VI_DISK2;
X     if ((tmpflags & (VI_SBIG+VI_SSMALL+VI_VBIG+VI_VSMALL)) != 0)
X        tmpflags |= VI_DISK1;
X     }
X      if (fileaspectratio != 0 && videoentry.dotmode%100 != 11
X    && (tmpflags & VI_VSMALL) == 0) {
X     ftemp = vid_aspect(filexdots,fileydots);
X     if ( ftemp < fileaspectratio * 0.98
X       || ftemp > fileaspectratio * 1.02)
X        tmpflags |= VI_ASPECT;
X     }
X      vid[i].entnum = i;
X      vid[i].flags  = tmpflags;
X      }
X
X#ifndef XFRACT
X   gotrealmode = 0;
X   if (initmode < 0 || (askvideo && !initbatch)) {
X      /* no exact match or (askvideo=yes and batch=no), talk to user */
X
X      qsort(vid,vidtbllen,sizeof(vid[0]),vidcompare); /* sort modes */
X
X      attributes = (int *)&dstack[1000];
X      for (i = 0; i < vidtbllen; ++i)
X     attributes[i] = 1;
X      vidptr = &vid[0]; /* for format_item */
X
X      /* format heading */
X      if (info->info_id[0] == 'G')
X     strcpy(temp1,"      Non-fractal GIF");
X      else {
X     nameptr = curfractalspecific->name;
X     if (*nameptr == '*') ++nameptr;
X     if (display3d) nameptr = "3D Transform";
X     sprintf(temp1,"Type: %s",nameptr);
X     }
X      sprintf(dstack,"File: %-44s  %d x %d x %d\n%-52s",
X         readname,filexdots,fileydots,filecolors,temp1);
X      if (info->info_id[0] != 'G') {
X     if (save_system)
X        strcat(dstack,"WinFract ");
X     sprintf(temp1,"v%d.%01d",save_release/100,(save_release%100)/10);
X     if (save_release%100) {
X        i = strlen(temp1);
X        temp1[i] = (save_release%10) + '0';
X        temp1[i+1] = 0;
X        }
X     if (save_system == 0 && save_release <= 1410)
X        strcat(temp1," or earlier");
X     strcat(dstack,temp1);
X     }
X      strcat(dstack,"\n");
X      if (info->info_id[0] != 'G' && save_system == 0)
X     if (initmode < 0)
X        strcat(dstack,"Saved in unknown video mode.");
X     else {
X        format_vid_inf(initmode,"",temp1);
X        strcat(dstack,temp1);
X        }
X      if (fileaspectratio != 0 && fileaspectratio != screenaspect)
X     far_strcat(dstack,warning);
X      strcat(dstack,"\n");
X      /* set up instructions */
X      far_strcpy(temp1,select_msg);
X      if (info->info_id[0] != 'G')
X     strcat(temp1,"TAB for fractal information, ");
X      strcat(temp1,"ESCAPE to back out.");
X
X      oldhelpmode = helpmode;
X      helpmode = HELPLOADFILE;
X      i = fullscreen_choice(0,dstack,hdg2,temp1,vidtbllen,NULL,attributes,
X                     1,13,76,0,format_item,NULL,NULL,check_modekey);
X      helpmode = oldhelpmode;
X      if (i == -1)
X     return(-1);
X      if (i < 0) { /* returned -100 - videotable entry number */
X     initmode = -100 - i;
X     gotrealmode = 1;
X     }
X      else
X     initmode = vid[i].entnum;
X      }
X#else
X      initmode = 0;
X      j = vidtbl[0].keynum;
X      gotrealmode = 0;
X#endif
X
X   if (gotrealmode == 0) { /* translate from temp table to permanent */
X      if ((j = vidtbl[i=initmode].keynum) != 0) {
X     for (initmode = 0; initmode < MAXVIDEOTABLE-1; ++initmode)
X        if (videotable[initmode].keynum == j) break;
X     if (initmode >= MAXVIDEOTABLE-1) j = 0;
X     }
X      if (j == 0) /* mode has no key, add to reserved slot at end */
X     far_memcpy((char far *)&videotable[initmode=MAXVIDEOTABLE-1],
X            (char far *)&vidtbl[i],sizeof(*vidtbl));
X      }
X
X   /* ok, we're going to return with a video mode */
X
X   far_memcpy((char far *)&videoentry,(char far *)&videotable[initmode],
X          sizeof(videoentry));
X
X   skipxdots = skipydots = 0; /* set for no reduction */
X   if (videoentry.xdots < filexdots || videoentry.ydots < fileydots) {
X      /* set up to load only every nth pixel to make image fit */
X      skipxdots = skipydots = 1;
X      while (skipxdots * videoentry.xdots < filexdots) ++skipxdots;
X      while (skipydots * videoentry.ydots < fileydots) ++skipydots;
X      i = j = 0;
X      while (1) {
X     tmpxdots = (filexdots + skipxdots - 1) / skipxdots;
X     tmpydots = (fileydots + skipydots - 1) / skipydots;
X     if (fileaspectratio == 0 || videoentry.dotmode%100 == 11)
X        break;
X     /* reduce further if that improves aspect */
X     if ((ftemp = vid_aspect(tmpxdots,tmpydots)) > fileaspectratio) {
X        if (j) break; /* already reduced x, don't reduce y */
X        ftemp2 = vid_aspect(tmpxdots,(fileydots+skipydots)/(skipydots+1));
X        if (ftemp2 < fileaspectratio
X          && ftemp/fileaspectratio *0.9 <= fileaspectratio/ftemp2)
X           break; /* further y reduction is worse */
X        ++skipydots;
X        ++i;
X        }
X     else {
X        if (i) break; /* already reduced y, don't reduce x */
X        ftemp2 = vid_aspect((filexdots+skipxdots)/(skipxdots+1),tmpydots);
X        if (ftemp2 > fileaspectratio
X          && fileaspectratio/ftemp *0.9 <= ftemp2/fileaspectratio)
X           break; /* further x reduction is worse */
X        ++skipxdots;
X        ++j;
X        }
X     }
X      filexdots = tmpxdots;
X      fileydots = tmpydots;
X      --skipxdots;
X      --skipydots;
X      }
X
X   if ((finalaspectratio = fileaspectratio) == 0) /* assume display correct */
X      finalaspectratio = vid_aspect(filexdots,fileydots);
X   if (finalaspectratio >= screenaspect-0.02
X     && finalaspectratio <= screenaspect+0.02)
X      finalaspectratio = screenaspect;
X   i = finalaspectratio * 1000.0 + 0.5;
X   finalaspectratio = (double)i/1000.0; /* chop precision to 3 decimals */
X
X   /* setup view window stuff */
X   viewwindow = viewxdots = viewydots = 0;
X   if (filexdots != videoentry.xdots || fileydots != videoentry.ydots) {
X      /* image not exactly same size as screen */
X      viewwindow = 1;
X      ftemp = finalaspectratio
X        * (double)videoentry.ydots / (double)videoentry.xdots
X        / screenaspect;
X      if (finalaspectratio <= screenaspect) {
X     i = (double)videoentry.xdots / (double)filexdots * 20.0 + 0.5;
X     tmpreduce = (double)i/20.0; /* chop precision to nearest .05 */
X     i = (double)videoentry.xdots / tmpreduce + 0.5;
X     j = (double)i * ftemp + 0.5;
X     }
X      else {
X     i = (double)videoentry.ydots / (double)fileydots * 20.0 + 0.5;
X     tmpreduce = (double)i/20.0; /* chop precision to nearest .05 */
X     j = (double)videoentry.ydots / tmpreduce + 0.5;
X     i = (double)j / ftemp + 0.5;
X     }
X      if (i != filexdots || j != fileydots) { /* too bad, must be explicit */
X     viewxdots = filexdots;
X     viewydots = fileydots;
X     }
X      else
X     viewreduction = tmpreduce; /* ok, this works */
X      }
X   if (fabs(finalaspectratio - screenaspect) > .00001 || viewxdots != 0 ) {
X      static char far msg[] = {"\
XWarning: <V>iew parameters are being set to non-standard values.\n\
XRemember to reset them when finished with this image.1"};
X      stopmsg(4,msg);
X      }
X
X   return(0);
X}
X
Xstatic void format_item(int choice,char *buf)
X{
X   char errbuf[10];
X   unsigned tmpflags;
X   errbuf[0] = 0;
X   tmpflags = vidptr[choice].flags;
X   if (tmpflags & (VI_VSMALL+VI_CSMALL+VI_ASPECT)) strcat(errbuf,"*");
X   if (tmpflags & VI_VSMALL) strcat(errbuf,"R");
X   if (tmpflags & VI_CSMALL) strcat(errbuf,"C");
X   if (tmpflags & VI_ASPECT) strcat(errbuf,"A");
X   if (tmpflags & VI_VBIG)   strcat(errbuf,"v");
X   if (tmpflags & VI_CBIG)   strcat(errbuf,"c");
X   format_vid_inf(vidptr[choice].entnum,errbuf,buf);
X}
X
Xstatic int check_modekey(int curkey,int choice)
X{
X   int i;
X   return (((i = check_vidmode_key(0,curkey)) >= 0) ? -100-i : 0);
X}
X
SHAR_EOF
$TOUCH -am 1028230093 loadfdos.c &&
chmod 0644 loadfdos.c ||
echo "restore of loadfdos.c failed"
set `wc -c loadfdos.c`;Wc_c=$1
if test "$Wc_c" != "14560"; then
    echo original size 14560, current size $Wc_c
fi
# ============= loadfile.c ==============
echo "x - extracting loadfile.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > loadfile.c &&
X/*
X    loadfile.c - load an existing fractal image, control level
X    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#ifdef XFRACT
X#include <unistd.h>
X#endif
X#include "fractint.h"
X#include "fractype.h"
X#include "targa_lc.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic int  find_fractal_info(char *,struct fractal_info *);
Xstatic void load_ext_blk(char far *loadptr,int loadlen);
Xstatic void skip_ext_blk(int *,int *);
Xstatic void backwardscompat();
X
Xint filetype;
Xint loaded3d;
X
Xextern char   maxfn;                    /* num trig functions if formula */
Xextern int    showfile;         /* has file been displayed yet? */
Xextern char   readname[];        /* name of fractal input file */
Xextern char   far *resume_info;     /* pointer to resume info if alloc'd */
Xextern int    resume_len;        /* length of resume info */
Xextern int    adapter;
Xextern int    calc_status;
Xextern int    initmode;         /* initial video mode        */
Xextern long   calctime;
Xextern int    initbatch;        /* 1 if batch run (no kbd)  */
Xextern int    maxit;
Xextern int    initincr;         /* maxiter incrmnt        */
Xextern char   usr_stdcalcmode;        /* pass mode            */
Xextern int    fractype;         /* fractal type         */
Xextern double xxmin,xxmax;        /* corner values        */
Xextern double yymin,yymax;        /* corner values        */
Xextern double xx3rd,yy3rd;        /* corner values        */
Xextern double param[];             /* parameters            */
Xextern int    fillcolor;        /* fill color: -1 = normal  */
Xextern int    inside;            /* inside color: 1=blue     */
Xextern int    outside;            /* outside color, if set    */
Xextern int    finattract;        /* finite attractor option  */
Xextern int    forcesymmetry;
Xextern int    LogFlag;            /* non-zero if logarithmic palettes */
Xextern int    rflag, rseed;
Xextern int    usr_periodicitycheck;
Xextern char   useinitorbit;
Xextern _CMPLX initorbit;
Xextern int    potflag;            /* continuous potential flag */
Xextern int    pot16bit;
Xextern double potparam[3];        /* three potential parameters*/
Xextern double inversion[];
Xextern int    decomp[];
Xextern int    usr_distest;        /* non-zero if distance estimator   */
Xextern int    distestwidth;
Xextern int    init3d[20];        /* '3d=nn/nn/nn/...' values */
Xextern char   usr_floatflag;        /* floating-point fractals? */
Xextern char   floatflag;
Xextern int    usr_biomorph;
Xextern char   FormName[];
Xextern char   LName[];
Xextern char   IFSName[];
Xextern int    bailout;            /* user input bailout value */
Xextern int    previewfactor;
Xextern int    xtrans;
Xextern int    ytrans;
Xextern int    red_crop_left;
Xextern int    red_crop_right;
Xextern int    blue_crop_left;
Xextern int    blue_crop_right;
Xextern int    red_bright;
Xextern int    blue_bright;
Xextern int    xadjust;
Xextern int    eyeseparation;
Xextern int    glassestype;
Xextern int    display3d;        /* 3D display flag: 0 = OFF */
Xextern int    overlay3d;        /* 3D overlay flag: 0 = OFF */
Xextern int    viewwindow;        /* 0 for full screen, 1 for window */
Xextern float  viewreduction;        /* window auto-sizing */
Xextern float  finalaspectratio;     /* for view shape and rotation */
Xextern int    xdots, ydots;        /* # of dots on the logical screen */
Xextern int    viewxdots,viewydots;    /* explicit view sizing */
Xextern int    save_system,save_release;
Xextern int    Ambient;
Xextern int    RANDOMIZE;
Xextern int    haze;
Xextern int    transparent[2];
Xextern int    rotate_lo,rotate_hi;
Xextern int far *ranges;
Xextern int    rangeslen;
Xextern int    invert;
Xextern int    num_fractal_types;
Xextern float  screenaspect;
Xextern     double mxmaxfp;
Xextern     double mxminfp;
Xextern     double mymaxfp;
Xextern     double myminfp;
Xextern     int   zdots;
Xextern     float originfp;
Xextern     float depthfp;
Xextern     float heightfp;
Xextern     float widthfp;
Xextern     float distfp;
Xextern     float eyesfp;
Xextern     int   neworbittype;
Xextern     short juli3Dmode;
Xextern     int   major_method;  /* inverse julia method */
Xextern     int   minor_method;
X
Xstatic FILE *fp;
X
Xint fileydots, filexdots, filecolors;
Xfloat fileaspectratio;
X
Xint skipxdots,skipydots;    /* for decoder, when reducing image */
X
X
Xvoid loadfile_overlay() { }    /* for restore_active_ovly */
X
X#ifdef XFRACT
Xextern int decode_fractal_info();
X#endif
X
Xint read_overlay()    /* read overlay/3D files, if reqr'd */
X{
X   struct fractal_info read_info;
X   char oldfloatflag;
X   char msg[110];
X
X   ENTER_OVLY(OVLY_LOADFILE);
X
X   showfile = 1;        /* for any abort exit, pretend done */
X   initmode = -1;        /* no viewing mode set yet */
X   oldfloatflag = usr_floatflag;
X   loaded3d = 0;
X
X   if(strchr(readname,'.') == NULL)
X      strcat(readname,".gif");
X
X   if(find_fractal_info(readname,&read_info)) { /* didn't find a useable file */
X      sprintf(msg,"Sorry, %s isn't a file I can decode.",readname);
X      stopmsg(0,msg);
X      EXIT_OVLY;
X      return(-1);
X      }
X
X   maxit    = read_info.iterations;
X   fractype    = read_info.fractal_type;
X   if (fractype < 0 || fractype >= num_fractal_types) {
X      sprintf(msg,"Warning: %s has a bad fractal type; using 0",readname);
X      fractype = 0;
X   }
X   curfractalspecific = &fractalspecific[fractype];
X   xxmin    = read_info.xmin;
X   xxmax    = read_info.xmax;
X   yymin    = read_info.ymin;
X   yymax    = read_info.ymax;
X   param[0]    = read_info.creal;
X   param[1]    = read_info.cimag;
X   save_release = 1100; /* unless we find out better later on */
X
X   invert = 0;
X   if(read_info.version > 0) {
X      param[2]        = read_info.parm3;
X      roundfloatd(¶m[2]);
X      param[3]        = read_info.parm4;
X      roundfloatd(¶m[3]);
X      potparam[0]   = read_info.potential[0];
X      potparam[1]   = read_info.potential[1];
X      potparam[2]   = read_info.potential[2];
X      potflag        = (potparam[0] != 0.0);
X      rflag        = read_info.rflag;
X      rseed        = read_info.rseed;
X      inside        = read_info.inside;
X      LogFlag        = read_info.logmap;
X      inversion[0]  = read_info.invert[0];
X      inversion[1]  = read_info.invert[1];
X      inversion[2]  = read_info.invert[2];
X      if (inversion[0] != 0.0)
X     invert = 3;
X      decomp[0]     = read_info.decomp[0];
X      decomp[1]     = read_info.decomp[1];
X      usr_biomorph  = read_info.biomorph;
X      forcesymmetry = read_info.symmetry;
X      }
X
X   if(read_info.version > 1) {
X      save_release  = 1200;
X      if (!display3d
X    && (read_info.version <= 4 || read_info.flag3d > 0
X        || (curfractalspecific->flags&PARMS3D) )) {
X     int i;
X     for (i = 0; i < 16; i++)
X        init3d[i] = read_info.init3d[i];
X     previewfactor     = read_info.previewfactor;
X     xtrans      = read_info.xtrans;
X     ytrans      = read_info.ytrans;
X     red_crop_left     = read_info.red_crop_left;
X     red_crop_right  = read_info.red_crop_right;
X     blue_crop_left  = read_info.blue_crop_left;
X     blue_crop_right = read_info.blue_crop_right;
X     red_bright     = read_info.red_bright;
X     blue_bright     = read_info.blue_bright;
X     xadjust     = read_info.xadjust;
X     eyeseparation     = read_info.eyeseparation;
X     glassestype     = read_info.glassestype;
X     }
X      }
X
X   if(read_info.version > 2) {
X      save_release = 1300;
X      outside       = read_info.outside;
X      }
X
X   calc_status = 0;      /* defaults if version < 4 */
X   xx3rd = xxmin;
X   yy3rd = yymin;
X   usr_distest = 0;
X   calctime = 0;
X   if(read_info.version > 3) {
X      save_release = 1400;
X      xx3rd      = read_info.x3rd;
X      yy3rd      = read_info.y3rd;
X      calc_status = read_info.calc_status;
X      usr_stdcalcmode = read_info.stdcalcmode;
X      usr_distest     = read_info.distest;
X      usr_floatflag   = read_info.floatflag;
X      bailout      = read_info.bailout;
X      calctime      = read_info.calctime;
X      trigndx[0]  = read_info.trigndx[0];
X      trigndx[1]  = read_info.trigndx[1];
X      trigndx[2]  = read_info.trigndx[2];
X      trigndx[3]  = read_info.trigndx[3];
X      finattract  = read_info.finattract;
X      initorbit.x = read_info.initorbit[0];
X      initorbit.y = read_info.initorbit[1];
X      useinitorbit = read_info.useinitorbit;
X      usr_periodicitycheck = read_info.periodicity;
X      }
X
X   pot16bit = 0;
X   save_system = 0;
X   if(read_info.version > 4) {
X      pot16bit       = read_info.pot16bit;
X      if (pot16bit)
X     filexdots >>= 1;
X      fileaspectratio = read_info.faspectratio;
X      if (fileaspectratio < 0.01)    /* fix files produced in early v14.1 */
X     fileaspectratio = screenaspect;
X      save_system  = read_info.system;
X      save_release = read_info.release; /* from fmt 5 on we know real number */
X      if (read_info.version == 5    /* except a few early fmt 5 cases: */
X      && (save_release <= 0 || save_release >= 2000)) {
X     save_release = 1410;
X     save_system = 0;
X     }
X      if (!display3d && read_info.flag3d > 0) {
X     loaded3d    = 1;
X     Ambient    = read_info.ambient;
X     RANDOMIZE    = read_info.randomize;
X     haze        = read_info.haze;
X     transparent[0] = read_info.transparent[0];
X     transparent[1] = read_info.transparent[1];
X     }
X      }
X
X   rotate_lo = 1; rotate_hi = 255;
X   distestwidth = 71;
X   if(read_info.version > 5) {
X      rotate_lo     = read_info.rotate_lo;
X      rotate_hi     = read_info.rotate_hi;
X      distestwidth    = read_info.distestwidth;
X      }
X
X   if(read_info.version > 6) {
X      param[2]        = read_info.dparm3;
X      param[3]        = read_info.dparm4;
X      }
X
X   if(read_info.version > 7) {
X      fillcolor        = read_info.fillcolor;
X      }
X
X   if(read_info.version > 8) {
X   mxmaxfp   =  read_info.mxmaxfp        ;
X   mxminfp   =  read_info.mxminfp        ;
X   mymaxfp   =  read_info.mymaxfp        ;
X   myminfp   =  read_info.myminfp        ;
X   zdots     =  read_info.zdots          ;
X   originfp  =  read_info.originfp       ;
X   depthfp   =  read_info.depthfp        ;
X   heightfp  =  read_info.heightfp       ;
X   widthfp   =  read_info.widthfp        ;
X   distfp    =  read_info.distfp         ;
X   eyesfp    =  read_info.eyesfp         ;
X   neworbittype = read_info.orbittype    ;
X   juli3Dmode   = read_info.juli3Dmode   ;
X   maxfn    =   read_info.maxfn          ;
X   major_method = read_info.inversejulia >> 8;
X   minor_method = read_info.inversejulia & 255;
X   param[4] = read_info.dparm5;
X   param[5] = read_info.dparm6;
X   param[6] = read_info.dparm7;
X   param[7] = read_info.dparm8;
X   param[8] = read_info.dparm9;
X   param[9] = read_info.dparm10;
X      }
X
X   if(read_info.version < 4) { /* pre-version 14.0? */
X      backwardscompat(&read_info); /* translate obsolete types */
X      if(LogFlag)
X     LogFlag = 2;
X      usr_floatflag = (curfractalspecific->isinteger) ? 0 : 1;
X      }
X
X   if (read_info.version < 5) { /* pre-version 15.0? */
X      if (LogFlag == 2) /* logmap=old changed again in format 5! */
X     LogFlag = -1;
X      if (decomp[0] > 0 && decomp[1] > 0)
X     bailout = decomp[1];
X      }
X   if(potflag) /* in version 15.x and 16.x logmap didn't work with pot */
X      if(read_info.version == 6 || read_info.version == 7)
X         LogFlag = 0;
X   set_trig_pointers(-1);
X
X   if(read_info.version < 9) { /* pre-version 18.0? */
X      /* forcesymmetry==1000 means we want to force symmetry but don't
X         know which symmetry yet, will find out in setsymmetry() */
X      if(outside==REAL || outside==IMAG || outside==MULT || outside==SUM)
X         if(forcesymmetry == 999)
X            forcesymmetry = 1000;
X      }
X   if(save_release < 1725) { /* pre-version 17.25 */
X      set_if_old_bif(); /* translate bifurcation types */
X   }
X
X   if (display3d)            /* PB - a klooge till the meaning of */
X      usr_floatflag = oldfloatflag; /*    floatflag in line3d is clarified */
X
X   if (overlay3d) {
X      initmode = adapter;       /* use previous adapter mode for overlays */
X      if (filexdots > xdots || fileydots > ydots) {
X     static char far msg[]={"Can't overlay with a larger image"};
X     stopmsg(0,msg);
X     EXIT_OVLY;
X     initmode = -1;
X     return(-1);
X     }
X      }
X   else {
X      int olddisplay3d,oldfloatflag,i;
X      olddisplay3d = display3d;
X      oldfloatflag = floatflag;
X      display3d = loaded3d;      /* for <tab> display during next */
X      floatflag = usr_floatflag; /* ditto */
X      i = get_video_mode(&read_info);
X      display3d = olddisplay3d;
X      floatflag = oldfloatflag;
X      if (i) {
X     EXIT_OVLY;
X     initmode = -1;
X     return(-1);
X     }
X      }
X
X   if (display3d) {
X      calc_status = 0;
X      fractype = PLASMA;
X      curfractalspecific = &fractalspecific[PLASMA];
X      param[0] = 0;
X      if (!initbatch)
X     if (get_3d_params() < 0) {
X        EXIT_OVLY;
X        initmode = -1;
X        return(-1);
X        }
X      }
X
X   showfile = 0;           /* trigger the file load */
X
X   EXIT_OVLY;
X   return(0);
X}
X
X
Xstatic int find_fractal_info(gif_file,info)
Xchar *gif_file;
Xstruct fractal_info *info;
X{
X   BYTE gifstart[18];
X   char temp1[81];
X   int scan_extend, block_type, block_len, data_len;
X   int fractinf_len;
X   int hdr_offset;
X
X   if((fp = fopen(gif_file,"rb"))==NULL)
X      return(-1);
X
X   fread(gifstart,18,1,fp);
X#ifndef XFRACT
X   if (strncmp(gifstart,"GIF",3)!=0) { /* not GIF, maybe old .tga? */
X#else
X   if (strncmp((char *)gifstart,"GIF",3)!=0) { /* not GIF, maybe old .tga? */
X#endif
X      if(fread(info,FRACTAL_INFO_SIZE,1,fp)==1 &&
X         strncmp(info->info_id,"Fractal",8)==0) {
X     filetype = 1; /* Targa 16 */
X     GET16(gifstart[O_VSIZE],fileydots);
X     GET16(gifstart[O_HSIZE],filexdots);
X     filecolors = info->colors;
X     fileaspectratio = screenaspect;
X     if(fileydots == info->ydots && filexdots == info->xdots) {
X        fclose(fp);
X        return(0);
X        }
X     }
X      fclose(fp);
X      return(-1);
X      }
X
X   filetype = 0; /* GIF */
X   GET16(gifstart[6],filexdots);
X   GET16(gifstart[8],fileydots);
X   filecolors = 2 << (gifstart[10] & 7);
X   fileaspectratio = 0; /* unknown */
X   if (gifstart[12]) { /* calc reasonably close value from gif header */
X      fileaspectratio = (64.0 / ((double)(gifstart[12]) + 15.0))
X              * (double)fileydots / (double)filexdots;
X      if ( fileaspectratio > screenaspect-0.03
X    && fileaspectratio < screenaspect+0.03)
X     fileaspectratio = screenaspect;
X      }
X   else
X      if (fileydots * 4 == filexdots * 3) /* assume the common square pixels */
X     fileaspectratio = screenaspect;
X
X   if (resume_info != NULL) { /* free the prior area if there is one */
X      farmemfree(resume_info);
X      resume_info = NULL;
X      }
X   if (rangeslen) { /* free prior ranges */
X      farmemfree((char far *)ranges);
X      rangeslen = 0;
X      }
X
X   /* Format of .gif extension blocks is:
X      1 byte    '!', extension block identifier
X      1 byte    extension block number, 255
X      1 byte    length of id, 11
X     11 bytes   alpha id, "fractintnnn" with fractint, nnn is secondary id
X       n * {
X      1 byte    length of block info in bytes
X      x bytes   block info
X       }
X      1 byte    0, extension terminator
X      To scan extension blocks, we first look in file at length of fractal_info
X      (the main extension block) from end of file, looking for a literal known
X      to be at start of our block info.  Then we scan forward a bit, in case
X      the file is from an earlier fractint vsn with shorter fractal_info.
X      If fractal_info is found and is from vsn>=14, it includes the total length
X      of all extension blocks; we then scan them all first to last to load
X      any optional ones which are present.
X      Defined extension blocks:
X    fractint001    header, always present
X    fractint002    resume info for interrupted resumable image
X    fractint003    additional formula type info
X    fractint004    ranges info
X   */
X
X   memset(info,0,FRACTAL_INFO_SIZE);
X   fractinf_len = FRACTAL_INFO_SIZE + (FRACTAL_INFO_SIZE+254)/255;
X   fseek(fp,(long)(-1-fractinf_len),SEEK_END);
X   fread(info,1,FRACTAL_INFO_SIZE,fp);
X   if (strcmp(INFO_ID,info->info_id) == 0) {
X#ifdef XFRACT
X       decode_fractal_info(info,1);
X#endif
X      hdr_offset = -1-fractinf_len;
X   } else {
X      /* didn't work 1st try, maybe an older vsn, maybe junk at eof, scan: */
X      int offset,i;
X      char tmpbuf[110];
X      hdr_offset = 0;
X      offset = 80; /* don't even check last 80 bytes of file for id */
X      while (offset < fractinf_len+513) { /* allow 512 garbage at eof */
X     offset += 100; /* go back 100 bytes at a time */
X     fseek(fp,(long)(0-offset),SEEK_END);
X     fread(tmpbuf,1,110,fp); /* read 10 extra for string compare */
X     for (i = 0; i < 100; ++i)
X        if (!strcmp(INFO_ID,&tmpbuf[i])) { /* found header? */
X           strcpy(info->info_id,INFO_ID);
X           fseek(fp,(long)(hdr_offset=i-offset),SEEK_END);
X           fread(info,1,FRACTAL_INFO_SIZE,fp);
X#ifdef XFRACT
X           decode_fractal_info(info,1);
X#endif
X           offset = 10000; /* force exit from outer loop */
X           break;
X           }
X     }
X      }
X
X   if (hdr_offset) { /* we found INFO_ID */
X
X      if (info->version >= 4) {
X     /* first reload main extension block, reasons:
X          might be over 255 chars, and thus earlier load might be bad
X          find exact endpoint, so scan back to start of ext blks works
X        */
X     fseek(fp,(long)(hdr_offset-15),SEEK_END);
X     scan_extend = 1;
X     while (scan_extend) {
X        if (fgetc(fp) != '!' /* if not what we expect just give up */
X          || fread(temp1,1,13,fp) != 13
X          || strncmp(&temp1[2],"fractint",8))
X           break;
X        temp1[13] = 0;
X        block_type = atoi(&temp1[10]); /* e.g. "fractint002" */
X        switch (block_type) {
X           case 1: /* "fractint001", the main extension block */
X          if (scan_extend == 2) { /* we've been here before, done now */
X             scan_extend = 0;
X             break;
X             }
X          load_ext_blk((char far *)info,FRACTAL_INFO_SIZE);
X#ifdef XFRACT
X          decode_fractal_info(info,1);
X#endif
X          scan_extend = 2;
X          /* now we know total extension len, back up to first block */
X          fseek(fp,0L-info->tot_extend_len,SEEK_CUR);
X          break;
X           case 2: /* resume info */
X          skip_ext_blk(&block_len,&data_len); /* once to get lengths */
X          if ((resume_info = farmemalloc((long)data_len)) == NULL)
X             info->calc_status = 3; /* not resumable after all */
X          else {
X             fseek(fp,(long)(0-block_len),SEEK_CUR);
X             load_ext_blk(resume_info,data_len);
X             resume_len = data_len;
X             }
X          break;
X           case 3: /* formula info */
X          {
X          char *nameptr;
X          char tmpname[40];
X          load_ext_blk(tmpname,40);
X          switch (info->fractal_type) {
X             case LSYSTEM:
X            nameptr = LName;
X            break;
X             case IFS:
X             case IFS3D:
X            nameptr = IFSName;
X            break;
X             default:
X            nameptr = FormName;
X            break;
X             }
X          tmpname[ITEMNAMELEN] = 0;
X          strcpy(nameptr,tmpname);
X          /* perhaps in future add more here, check block_len for
X             backward compatibility */
X          }
X          break;
X           case 4: /* ranges info */
X          skip_ext_blk(&block_len,&data_len); /* once to get lengths */
X          if ((ranges = (int far *)farmemalloc((long)data_len))) {
X             fseek(fp,(long)(0-block_len),SEEK_CUR);
X             load_ext_blk((char far *)ranges,data_len);
X             rangeslen = data_len/2;
X#ifdef XFRACTINT
X             fix_ranges(ranges,rangeslen,1);
X#endif
X             }
X          break;
X           default:
X          skip_ext_blk(&block_len,&data_len);
X           }
X        }
X     }
X
X      fclose(fp);
X      fileaspectratio = screenaspect; /* if not >= v15, this is correct */
X      return(0);
X      }
X
X   strcpy(info->info_id, "GIFFILE");
X   info->iterations = 150;
X   info->fractal_type = PLASMA;
X   info->xmin = -1;
X   info->xmax = 1;
X   info->ymin = -1;
X   info->ymax = 1;
X   info->x3rd = -1;
X   info->y3rd = -1;
X   info->creal = 0;
X   info->cimag = 0;
X   info->videomodeax=255;
X   info->videomodebx=255;
X   info->videomodecx=255;
X   info->videomodedx=255;
X   info->dotmode = 0;
X   info->xdots = filexdots;
X   info->ydots = fileydots;
X   info->colors = filecolors;
X   info->version = 0; /* this forces lots more init at calling end too */
X
X   /* zero means we won */
X   fclose(fp);
X   return(0);
X}
X
Xstatic void load_ext_blk(char far *loadptr,int loadlen)
X{
X   int len;
X   while ((len = fgetc(fp)) > 0) {
X      while (--len >= 0) {
X     if (--loadlen >= 0)
X        *(loadptr++) = fgetc(fp);
X     else
X        fgetc(fp); /* discard excess characters */
X     }
X      }
X}
X
Xstatic void skip_ext_blk(int *block_len, int *data_len)
X{
X   int len;
X   *data_len = 0;
X   *block_len = 1;
X   while ((len = fgetc(fp)) > 0) {
X      fseek(fp,(long)len,SEEK_CUR);
X      *data_len += len;
X      *block_len += len + 1;
X      }
X}
X
X
X/* switch obsolete fractal types to new generalizations */
Xstatic void backwardscompat(struct fractal_info *info)
X{
X   switch(fractype) {
X      case LAMBDASINE:
X     fractype = LAMBDATRIGFP;
X     trigndx[0] = SIN;
X     break;
X      case LAMBDACOS    :
X     fractype = LAMBDATRIGFP;
X     trigndx[0] = COS;
X     break;
X      case LAMBDAEXP    :
X     fractype = LAMBDATRIGFP;
X     trigndx[0] = EXP;
X     break;
X      case MANDELSINE    :
X     fractype = MANDELTRIGFP;
X     trigndx[0] = SIN;
X     break;
X      case MANDELCOS    :
X     fractype = MANDELTRIGFP;
X     trigndx[0] = COS;
X     break;
X      case MANDELEXP    :
X     fractype = MANDELTRIGFP;
X     trigndx[0] = EXP;
X     break;
X      case MANDELSINH    :
X     fractype = MANDELTRIGFP;
X     trigndx[0] = SINH;
X     break;
X      case LAMBDASINH    :
X     fractype = LAMBDATRIGFP;
X     trigndx[0] = SINH;
X     break;
X      case MANDELCOSH    :
X     fractype = MANDELTRIGFP;
X     trigndx[0] = COSH;
X     break;
X      case LAMBDACOSH    :
X     fractype = LAMBDATRIGFP;
X     trigndx[0] = COSH;
X     break;
X      case LMANDELSINE    :
X     fractype = MANDELTRIG;
X     trigndx[0] = SIN;
X     break;
X      case LLAMBDASINE    :
X     fractype = LAMBDATRIG;
X     trigndx[0] = SIN;
X     break;
X      case LMANDELCOS    :
X     fractype = MANDELTRIG;
X     trigndx[0] = COS;
X     break;
X      case LLAMBDACOS    :
X     fractype = LAMBDATRIG;
X     trigndx[0] = COS;
X     break;
X      case LMANDELSINH    :
X     fractype = MANDELTRIG;
X     trigndx[0] = SINH;
X     break;
X      case LLAMBDASINH    :
X     fractype = LAMBDATRIG;
X     trigndx[0] = SINH;
X     break;
X      case LMANDELCOSH    :
X     fractype = MANDELTRIG;
X     trigndx[0] = COSH;
X     break;
X      case LLAMBDACOSH    :
X     fractype = LAMBDATRIG;
X     trigndx[0] = COSH;
X     break;
X      case LMANDELEXP    :
X     fractype = MANDELTRIG;
X     trigndx[0] = EXP;
X     break;
X      case LLAMBDAEXP    :
X     fractype = LAMBDATRIG;
X     trigndx[0] = EXP;
X     break;
X      case DEMM     :
X     fractype = MANDELFP;
X     usr_distest = (info->ydots - 1) * 2;
X     break;
X      case DEMJ     :
X     fractype = JULIAFP;
X     usr_distest = (info->ydots - 1) * 2;
X     break;
X      case MANDELLAMBDA :
X     useinitorbit = 2;
X     break;
X      }
X   curfractalspecific = &fractalspecific[fractype];
X}
X
X/* switch old bifurcation fractal types to new generalizations */
Xvoid set_if_old_bif(void)
X{
X/* set functions if not set already, may need to check 'functionpreloaded'
X   before calling this routine.  JCO 7/5/92 */
X
X   ENTER_OVLY(OVLY_LOADFILE);
X   switch(fractype) {
X      case BIFURCATION:
X      case LBIFURCATION:
X      case BIFSTEWART:
X      case LBIFSTEWART:
X      case BIFLAMBDA:
X      case LBIFLAMBDA:
X        set_trig_array(0,"ident");
X        break;
X
X      case BIFEQSINPI:
X      case LBIFEQSINPI:
X      case BIFADSINPI:
X      case LBIFADSINPI:
X        set_trig_array(0,"sin");
X        break;
X   }
X   EXIT_OVLY;
X}
SHAR_EOF
$TOUCH -am 1028230093 loadfile.c &&
chmod 0644 loadfile.c ||
echo "restore of loadfile.c failed"
set `wc -c loadfile.c`;Wc_c=$1
if test "$Wc_c" != "22666"; then
    echo original size 22666, current size $Wc_c
fi
# ============= loadmap.c ==============
echo "x - extracting loadmap.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > loadmap.c &&
X/** loadmap.c **/
X
X
X#include    <stdio.h>
X#include    <stdlib.h>
X#ifndef XFRACT
X#include    <dos.h>
X#endif
X#include    <string.h>
X#include    "fractint.h"
X#include    "prototyp.h"
X
Xtypedef struct palett {
X   BYTE red;
X   BYTE green;
X   BYTE blue;
X} Palettetype;
X
Xextern Palettetype    dacbox[ 256 ];
Xextern unsigned far    *tga16;
Xextern long    far    *tga32;
Xextern char    far    *mapdacbox;
Xextern int        colorstate; /* comments in cmdfiles */
Xextern char        colorfile[];
X
X/***************************************************************************/
X
Xvoid SetTgaColors() {
Xunsigned    r, g, b, index;
X    if (tga16 != NULL)
X    for( index = 0; index < 256; index++ ) {
X        r = dacbox[index].red    << 2;
X        g = dacbox[index].green << 2;
X        b = dacbox[index].blue    << 2;
X        tga16[index] = ((r&248)<<7) | ((g&248)<<2) | (b>>3);
X        tga32[index] = ((long)r<<16) | (g<<8) | b;
X    }
X}
X
Xint ValidateLuts( char * fn )
X{
XFILE * f;
Xunsigned    r, g, b, index;
XCHAR    line[160];
XCHAR    temp[81];
X    strcpy (temp,fn);
X    if (strchr(temp,'.') == NULL) /* Did name have an extension? */
X        strcat(temp,".map");  /* No? Then add .map */
X    findpath( temp, line);          /* search the dos path */
X    f = fopen( line, "r" );
X    if (f == NULL) {
X        sprintf(line,"Could not load color map %s",fn);
X        stopmsg(0,line);
X        return 1;
X        }
X    for( index = 0; index < 256; index++ ) {
X        if (fgets(line,100,f) == NULL)
X            break;
X        sscanf( line, "%u %u %u", &r, &g, &b );
X        /** load global dac values **/
X        dacbox[index].red   = (r%256) >> 2;    /* maps default to 8 bits */
X        dacbox[index].green = (g%256) >> 2;    /* DAC wants 6 bits */
X        dacbox[index].blue  = (b%256) >> 2;
X    }
X    fclose( f );
X    while (index < 256)  { /* zap unset entries */
X        dacbox[index].red = dacbox[index].blue = dacbox[index].green = 40;
X        ++index;
X    }
X    SetTgaColors();
X    colorstate = 2;
X    strcpy(colorfile,fn);
X    return 0;
X}
X
X
X/***************************************************************************/
X
Xint SetColorPaletteName( char * fn )
X{
X    if( ValidateLuts( fn ) != 0)
X        return 1;
X    if( mapdacbox == NULL && (mapdacbox = farmemalloc(768L)) == NULL) {
X        static char far msg[]={"Insufficient memory for color map."};
X        stopmsg(0,msg);
X        return 1;
X        }
X    far_memcpy((char far *)mapdacbox,(char far *)dacbox,768);
X    /* PB, 900829, removed atexit(RestoreMap) stuff, goodbye covers it */
X    return 0;
X}
X
X
SHAR_EOF
$TOUCH -am 1028230093 loadmap.c &&
chmod 0644 loadmap.c ||
echo "restore of loadmap.c failed"
set `wc -c loadmap.c`;Wc_c=$1
if test "$Wc_c" != "2268"; then
    echo original size 2268, current size $Wc_c
fi
# ============= lorenz.c ==============
echo "x - extracting lorenz.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lorenz.c &&
X/*
X   This file contains two 3 dimensional orbit-type fractal
X   generators - IFS and LORENZ3D, along with code to generate
X   red/blue 3D images. Tim Wegner
X*/
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <float.h>
X#include <math.h>
X#include <string.h>
X#include "mpmath.h"
X#include "fractint.h"
X#include "fractype.h"
X#include "prototyp.h"
X
X#define RANDOM(x)  (rand()%(x))
X
X/* BAD_PIXEL is used to cutoff orbits that are diverging. It might be better
Xto test the actual floating point prbit values, but this seems safe for now.
XA higher value cannot be used - to test, turn off math coprocessor and
Xuse +2.24 for type ICONS. If BAD_PIXEL is set to 20000, this will abort
XFractint with a math error. Note that this approach precludes zooming in very
Xfar to an orbit type. */
X
X#define BAD_PIXEL  10000L    /* pixels can't get this big */
X
Xstruct affine
X{
X   /* weird order so a,b,e and c,d,f are vectors */
X   double a;
X   double b;
X   double e;
X   double c;
X   double d;
X   double f;
X};
Xstruct l_affine
X{
X   /* weird order so a,b,e and c,d,f are vectors */
X   long a;
X   long b;
X   long e;
X   long c;
X   long d;
X   long f;
X};
Xstruct long3dvtinf /* data used by 3d view transform subroutine */
X{
X   long ct;        /* iteration counter */
X   long orbit[3];    /* interated function orbit value */
X   long iview[3];    /* perspective viewer's coordinates */
X   long viewvect[3];    /* orbit transformed for viewing */
X   long viewvect1[3];    /* orbit transformed for viewing */
X   long maxvals[3];
X   long minvals[3];
X   MATRIX doublemat;    /* transformation matrix */
X   MATRIX doublemat1;    /* transformation matrix */
X   long longmat[4][4];    /* long version of matrix */
X   long longmat1[4][4]; /* long version of matrix */
X   int row,col;     /* results */
X   int row1,col1;
X   struct l_affine cvt;
X};
Xstruct float3dvtinf /* data used by 3d view transform subroutine */
X{
X   long ct;        /* iteration counter */
X   double orbit[3];           /* interated function orbit value */
X   double viewvect[3];          /* orbit transformed for viewing */
X   double viewvect1[3];        /* orbit transformed for viewing */
X   double maxvals[3];
X   double minvals[3];
X   MATRIX doublemat;    /* transformation matrix */
X   MATRIX doublemat1;    /* transformation matrix */
X   int row,col;     /* results */
X   int row1,col1;
X   struct affine cvt;
X};
X
X/* Routines in this module    */
X
Xstatic int  ifs3dlong(void);
Xstatic int  ifs3dfloat(void);
Xstatic double determinant(double mat[3][3]);
Xstatic int  solve3x3(double mat[3][3],double vec[3],double ans[3]);
Xextern int  setup_convert_to_screen(struct affine *);
Xstatic int  l_setup_convert_to_screen(struct l_affine *);
Xstatic void setupmatrix(MATRIX);
Xstatic int  long3dviewtransf(struct long3dvtinf *inf);
Xstatic int  float3dviewtransf(struct float3dvtinf *inf);
Xstatic FILE *open_orbitsave();
Xstatic void _fastcall plothist(int x, int y, int color);
Xextern char far insufficient_ifs_mem[];
Xextern int numaffine;
Xstatic int realtime;
Xextern int orbitsave;
Xstatic char orbitsavename[]    = {"orbits.raw"};
Xstatic char orbitsave_format[] = {"%g %g %g 15\n"};
Xextern int active_system;
Xextern int overflow;
Xextern int soundflag;
Xextern int basehertz;
Xextern int fractype;
Xextern int glassestype;
Xextern int whichimage;
Xextern int init3d[];
Xextern char floatflag;
Xextern VECTOR view;
Xextern int xxadjust, yyadjust;
Xextern int xxadjust1, yyadjust1;
Xextern int xshift,yshift;
Xextern int xshift1,yshift1;
Xextern int    debugflag;            /* for debugging purposes */
Xextern int    xdots, ydots;        /* coordinates of dots on the screen  */
Xextern int    maxit;                /* try this many iterations */
Xextern double param[];
Xextern double    xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* selected screen corners  */
Xextern    int    diskvideo;            /* for disk-video klooges */
Xextern int    bitshift;            /* bit shift for fudge */
Xextern long    fudge;                /* fudge factor (2**n) */
Xextern int    colors;             /* maximum colors available */
Xextern int display3d;
Xextern double dxsize,dysize,delxx,delxx2,delyy,delyy2;
X
Xextern float far *ifs_defn;
Xextern int ifs_type;
X
Xstatic int t;
Xstatic long l_dx,l_dy,l_dz,l_dt,l_a,l_b,l_c,l_d;
Xstatic long l_adt,l_bdt,l_cdt,l_xdt,l_ydt;
Xstatic long l_initx,l_inity,l_initz;
Xstatic long initorbitlong[3];
X
Xstatic double dx,dy,dz,dt,a,b,c,d;
Xstatic double adt,bdt,cdt,xdt,ydt,zdt;
Xstatic double initx,inity,initz;
Xstatic double initorbit[3];
Xextern int inside;
Xextern int outside;
Xextern int orbit_delay;
X
Xextern void (_fastcall * standardplot)(int,int,int);
Xextern int  calc_status, resuming;
Xextern int  diskisactive;
Xextern char savename[];
X
X/*
X * The following declarations used for Inverse Julia.  MVS
X */
X
Xextern int    Init_Queue      (unsigned long);
Xextern void   Free_Queue      (void);
Xextern void   ClearQueue      (void);
Xextern int    QueueEmpty      (void);
Xextern int    QueueFull       (void);
Xextern int    QueueFullAlmost (void);
Xextern int    PushLong        (long ,  long);
Xextern int    PushFloat       (float,  float);
Xextern int    EnQueueLong     (long ,  long);
Xextern int    EnQueueFloat    (float,  float);
Xextern LCMPLX PopLong         (void);
Xextern _CMPLX PopFloat        (void);
Xextern LCMPLX DeQueueLong     (void);
Xextern _CMPLX DeQueueFloat    (void);
Xextern LCMPLX ComplexSqrtLong (long ,  long);
Xextern _CMPLX ComplexSqrtFloat(double, double);
Xstatic char far NoQueue[] =
X  "Not enough memory: switching to random walk.\n";
X
Xstatic int    maxhits;
Xint    run_length;
Xenum   {breadth_first, depth_first, random_walk, random_run} major_method;
Xenum   {left_first, right_first}                             minor_method;
Xstruct affine cvt;
Xstruct l_affine lcvt;
X
Xextern _CMPLX  old,  new;
Xextern LCMPLX lold, lnew;
X
Xdouble Cx, Cy;
Xlong   CxLong, CyLong;
X
X/*
X * end of Inverse Julia declarations;
X */
X
X/* these are potential user parameters */
Xint connect = 1;    /* flag to connect points with a line */
Xint euler = 0;        /* use implicit euler approximation for dynamic system */
Xint waste = 100;    /* waste this many points before plotting */
Xint projection = 2; /* projection plane - default is to plot x-y */
X
X/******************************************************************/
X/*           zoom box conversion functions          */
X/******************************************************************/
X
Xstatic double determinant(mat) /* determinant of 3x3 matrix */
Xdouble mat[3][3];
X{
X   /* calculate determinant of 3x3 matrix */
X   return(mat[0][0]*mat[1][1]*mat[2][2] +
X      mat[0][2]*mat[1][0]*mat[2][1] +
X      mat[0][1]*mat[1][2]*mat[2][0] -
X      mat[2][0]*mat[1][1]*mat[0][2] -
X      mat[1][0]*mat[0][1]*mat[2][2] -
X      mat[0][0]*mat[1][2]*mat[2][1]);
X
X}
X
Xstatic int solve3x3(mat,vec,ans) /* solve 3x3 inhomogeneous linear equations */
Xdouble mat[3][3], vec[3], ans[3];
X{
X   /* solve 3x3 linear equation [mat][ans] = [vec] */
X   double denom;
X   double tmp[3][3];
X   int i;
X   denom = determinant(mat);
X   if(fabs(denom) < DBL_EPSILON) /* test if can solve */
X     return(-1);
X   memcpy(tmp,mat,sizeof(double)*9);
X   for(i=0;i<3;i++)
X   {
X      tmp[0][i] = vec[0];
X      tmp[1][i] = vec[1];
X      tmp[2][i] = vec[2];
X      ans[i]  =  determinant(tmp)/denom;
X      tmp[0][i] = mat[0][i];
X      tmp[1][i] = mat[1][i];
X      tmp[2][i] = mat[2][i];
X    }
X    return(0);
X}
X
X
X/* Conversion of complex plane to screen coordinates for rotating zoom box.
X   Assume there is an affine transformation mapping complex zoom parallelogram
X   to rectangular screen. We know this map must map parallelogram corners to
X   screen corners, so we have following equations:
X
X      a*xxmin+b*yymax+e == 0        (upper left)
X      c*xxmin+d*yymax+f == 0
X
X      a*xx3rd+b*yy3rd+e == 0        (lower left)
X      c*xx3rd+d*yy3rd+f == ydots-1
X
X      a*xxmax+b*yymin+e == xdots-1  (lower right)
X      c*xxmax+d*yymin+f == ydots-1
X
X      First we must solve for a,b,c,d,e,f - (which we do once per image),
X      then we just apply the transformation to each orbit value.
X*/
X
Xint setup_convert_to_screen(struct affine *scrn_cnvt)
X{
X   /* we do this twice - rather than having six equations with six unknowns,
X      everything partitions to two sets of three equations with three
X      unknowns. Nice, because who wants to calculate a 6x6 determinant??
X    */
X   double mat[3][3];
X   double vec[3];
X   /*
X      first these equations - solve for a,b,e
X      a*xxmin+b*yymax+e == 0        (upper left)
X      a*xx3rd+b*yy3rd+e == 0        (lower left)
X      a*xxmax+b*yymin+e == xdots-1  (lower right)
X   */
X   mat[0][0] = xxmin;
X   mat[0][1] = yymax;
X   mat[0][2] = 1.0;
X   mat[1][0] = xx3rd;
X   mat[1][1] = yy3rd;
X   mat[1][2] = 1.0;
X   mat[2][0] = xxmax;
X   mat[2][1] = yymin;
X   mat[2][2] = 1.0;
X   vec[0]    = 0.0;
X   vec[1]    = 0.0;
X   vec[2]    = (double)(xdots-1);
X
X   if(solve3x3(mat,vec, &(scrn_cnvt->a)))
X      return(-1);
X   /*
X      now solve these:
X      c*xxmin+d*yymax+f == 0
X      c*xx3rd+d*yy3rd+f == ydots-1
X      c*xxmax+d*yymin+f == ydots-1
X      (mat[][] has not changed - only vec[])
X   */
X   vec[0]    = 0.0;
X   vec[1]    = (double)(ydots-1);
X   vec[2]    = (double)(ydots-1);
X
X   if(solve3x3(mat,vec, &scrn_cnvt->c))
X      return(-1);
X   return(0);
X}
X
Xstatic int l_setup_convert_to_screen(struct l_affine *l_cvt)
X{
X   struct affine cvt;
X
X   /* MCP 7-7-91, This function should return a something! */
X   if(setup_convert_to_screen(&cvt))
X      return(-1);
X   l_cvt->a = cvt.a*fudge; l_cvt->b = cvt.b*fudge; l_cvt->c = cvt.c*fudge;
X   l_cvt->d = cvt.d*fudge; l_cvt->e = cvt.e*fudge; l_cvt->f = cvt.f*fudge;
X
X   /* MCP 7-7-91 */
X   return(0);
X}
X
X
X/******************************************************************/
X/*   setup functions - put in fractalspecific[fractype].per_image */
X/******************************************************************/
X
Xstatic double orbit;
Xstatic long   l_orbit;
X
Xextern double sinx,cosx;
Xstatic long l_sinx,l_cosx;
X
Xint orbit3dlongsetup()
X{
X   connect = 1;
X   waste = 100;
X   projection = 2;
X   if (fractype==LHENON || fractype==KAM || fractype==KAM3D ||
X       fractype==INVERSEJULIA)
X      connect=0;
X   if(fractype==LROSSLER)
X      waste = 500;
X   if(fractype==LLORENZ)
X      projection = 1;
X
X   initorbitlong[0] = fudge;  /* initial conditions */
X   initorbitlong[1] = fudge;
X   initorbitlong[2] = fudge;
X
X   if(fractype==LHENON)
X   {
X      l_a =  param[0]*fudge;
X      l_b =  param[1]*fudge;
X      l_c =  param[2]*fudge;
X      l_d =  param[3]*fudge;
X   }
X   else if(fractype==KAM || fractype==KAM3D)
X   {
X      a   = param[0];        /* angle */
X      if(param[1] <= 0.0)
X     param[1] = .01;
X      l_b =  param[1]*fudge;    /* stepsize */
X      l_c =  param[2]*fudge;    /* stop */
X      t = l_d =  param[3];     /* points per orbit */
X
X      l_sinx = sin(a)*fudge;
X      l_cosx = cos(a)*fudge;
X      l_orbit = 0;
X      initorbitlong[0] = initorbitlong[1] = initorbitlong[2] = 0;
X   }
X   else if (fractype == INVERSEJULIA)
X   {
X      LCMPLX Sqrt;
X
X      CxLong = param[0] * fudge;
X      CyLong = param[1] * fudge;
X
X      maxhits    = (int) param[2];
X      run_length = (int) param[3];
X      if (maxhits == 0)
X      maxhits = 1;
X      else if (maxhits >= colors)
X      maxhits = colors - 1;
X
X      setup_convert_to_screen(&cvt);
X      /* Note: using bitshift of 21 for affine, 24 otherwise */
X
X      lcvt.a = cvt.a * (1L << 21);
X      lcvt.b = cvt.b * (1L << 21);
X      lcvt.c = cvt.c * (1L << 21);
X      lcvt.d = cvt.d * (1L << 21);
X      lcvt.e = cvt.e * (1L << 21);
X      lcvt.f = cvt.f * (1L << 21);
X
X      Sqrt = ComplexSqrtLong(fudge - 4 * CxLong, -4 * CyLong);
X
X      switch (major_method) {
X     case breadth_first:
X        if (Init_Queue((long)32*1024) == 0)
X        { /* can't get queue memory: fall back to random walk */
X           stopmsg(20, NoQueue);
X           major_method = random_walk;
X           goto lrwalk;
X        }
X        EnQueueLong((fudge + Sqrt.x) / 2,  Sqrt.y / 2);
X        EnQueueLong((fudge - Sqrt.x) / 2, -Sqrt.y / 2);
X        break;
X     case depth_first:
X        if (Init_Queue((long)32*1024) == 0)
X        { /* can't get queue memory: fall back to random walk */
X           stopmsg(20, NoQueue);
X           major_method = random_walk;
X           goto lrwalk;
X        }
X        switch (minor_method) {
X           case left_first:
X          PushLong((fudge + Sqrt.x) / 2,  Sqrt.y / 2);
X          PushLong((fudge - Sqrt.x) / 2, -Sqrt.y / 2);
X          break;
X           case right_first:
X          PushLong((fudge - Sqrt.x) / 2, -Sqrt.y / 2);
X          PushLong((fudge + Sqrt.x) / 2,  Sqrt.y / 2);
X          break;
X        }
X        break;
X     case random_walk:
Xlrwalk:
X        lnew.x = initorbitlong[0] = fudge + Sqrt.x / 2;
X        lnew.y = initorbitlong[1] =         Sqrt.y / 2;
X        break;
X     case random_run:
X        lnew.x = initorbitlong[0] = fudge + Sqrt.x / 2;
X        lnew.y = initorbitlong[1] =         Sqrt.y / 2;
X        break;
X      }
X   }
X   else
X   {
X      l_dt = param[0]*fudge;
X      l_a =  param[1]*fudge;
X      l_b =  param[2]*fudge;
X      l_c =  param[3]*fudge;
X   }
X
X   /* precalculations for speed */
X   l_adt = multiply(l_a,l_dt,bitshift);
X   l_bdt = multiply(l_b,l_dt,bitshift);
X   l_cdt = multiply(l_c,l_dt,bitshift);
X   return(1);
X}
X
Xint orbit3dfloatsetup()
X{
X   connect = 1;
X   waste = 100;
X   projection = 2;
X
X   if(fractype==FPHENON || fractype==FPPICKOVER || fractype==FPGINGERBREAD
X        || fractype == KAMFP || fractype == KAM3DFP
X        || fractype == FPHOPALONG || fractype == INVERSEJULIAFP)
X      connect=0;
X   if(fractype==FPLORENZ3D1 || fractype==FPLORENZ3D3 ||
X      fractype==FPLORENZ3D4)
X      waste = 750;
X   if(fractype==FPROSSLER)
X      waste = 500;
X   if(fractype==FPLORENZ)
X      projection = 1; /* plot x and z */
X
X   initorbit[0] = 1;  /* initial conditions */
X   initorbit[1] = 1;
X   initorbit[2] = 1;
X   if(fractype==FPGINGERBREAD)
X   {
X      initorbit[0] = param[0];    /* initial conditions */
X      initorbit[1] = param[1];
X   }
X
X   if(fractype==ICON || fractype==ICON3D)        /* DMF */
X   {
X      initorbit[0] = 0.01;  /* initial conditions */
X      initorbit[1] = 0.003;
X      connect = 0;
X      waste = 2000;
X   }
X
X   if(fractype==FPHENON || fractype==FPPICKOVER)
X   {
X      a =  param[0];
X      b =  param[1];
X      c =  param[2];
X      d =  param[3];
X   }
X   else if(fractype==ICON || fractype==ICON3D)        /* DMF */
X   {
X      initorbit[0] = 0.01;  /* initial conditions */
X      initorbit[1] = 0.003;
X      connect = 0;
X      waste = 2000;
X      /* Initialize parameters */
X      a  =   param[0];
X      b  =   param[1];
X      c  =   param[2];
X      d  =   param[3];
X   }
X   else if(fractype==KAMFP || fractype==KAM3DFP)
X   {
X      a = param[0];          /* angle */
X      if(param[1] <= 0.0)
X     param[1] = .01;
X      b =  param[1];    /* stepsize */
X      c =  param[2];    /* stop */
X      t = l_d =  param[3];     /* points per orbit */
X      sinx = sin(a);
X      cosx = cos(a);
X      orbit = 0;
X      initorbit[0] = initorbit[1] = initorbit[2] = 0;
X   }
X   else if(fractype==FPHOPALONG || fractype==FPMARTIN)
X   {
X      initorbit[0] = 0;  /* initial conditions */
X      initorbit[1] = 0;
X      initorbit[2] = 0;
X      connect = 0;
X      a =  param[0];
X      b =  param[1];
X      c =  param[2];
X      d =  param[3];
X   }
X   else if (fractype == INVERSEJULIAFP)
X   {
X      _CMPLX Sqrt;
X
X      Cx = param[0];
X      Cy = param[1];
X
X      maxhits    = (int) param[2];
X      run_length = (int) param[3];
X      if (maxhits == 0)
X      maxhits = 1;
X      else if (maxhits >= colors)
X      maxhits = colors - 1;
X
X      setup_convert_to_screen(&cvt);
X
X      /* find fixed points: guaranteed to be in the set */
X      Sqrt = ComplexSqrtFloat(1 - 4 * Cx, -4 * Cy);
X      switch ((int) major_method) {
X     case breadth_first:
X        if (Init_Queue((long)32*1024) == 0)
X        { /* can't get queue memory: fall back to random walk */
X           stopmsg(20, NoQueue);
X           major_method = random_walk;
X           goto rwalk;
X        }
X        EnQueueFloat((1 + Sqrt.x) / 2,  Sqrt.y / 2);
X        EnQueueFloat((1 - Sqrt.x) / 2, -Sqrt.y / 2);
X        break;
X     case depth_first:            /* depth first (choose direction) */
X        if (Init_Queue((long)32*1024) == 0)
X        { /* can't get queue memory: fall back to random walk */
X           stopmsg(20, NoQueue);
X           major_method = random_walk;
X           goto rwalk;
X        }
X        switch (minor_method) {
X           case left_first:
X          PushFloat((1 + Sqrt.x) / 2,  Sqrt.y / 2);
X          PushFloat((1 - Sqrt.x) / 2, -Sqrt.y / 2);
X          break;
X           case right_first:
X          PushFloat((1 - Sqrt.x) / 2, -Sqrt.y / 2);
X          PushFloat((1 + Sqrt.x) / 2,  Sqrt.y / 2);
X          break;
X        }
X        break;
X     case random_walk:
Xrwalk:
X        new.x = initorbit[0] = 1 + Sqrt.x / 2;
X        new.y = initorbit[1] = Sqrt.y / 2;
X        break;
X     case random_run:    /* random run, choose intervals */
X        major_method = random_run;
X        new.x = initorbit[0] = 1 + Sqrt.x / 2;
X        new.y = initorbit[1] = Sqrt.y / 2;
X        break;
X      }
X   }
X   else
X   {
X      dt = param[0];
X      a =  param[1];
X      b =  param[2];
X      c =  param[3];
X
X   }
X
X   /* precalculations for speed */
X   adt = a*dt;
X   bdt = b*dt;
X   cdt = c*dt;
X
X   return(1);
X}
X
X/******************************************************************/
X/*   orbit functions - put in fractalspecific[fractype].orbitcalc */
X/******************************************************************/
X
X/* Julia sets by inverse iterations added by Juan J. Buhler 4/3/92 */
X/* Integrated with Lorenz by Tim Wegner 7/20/92 */
X/* Add Modified Inverse Iteration Method, 11/92 by Michael Snyder  */
X
Xint
XMinverse_julia_orbit()
X{
X   static int   random_dir = 0, random_len = 0;
X   int    newrow, newcol;
X   int    color,  leftright;
X
X   /*
X    * First, compute new point
X    */
X   switch (major_method) {
X      case breadth_first:
X     if (QueueEmpty())
X        return -1;
X     new = DeQueueFloat();
X     break;
X      case depth_first:
X     if (QueueEmpty())
X        return -1;
X     new = PopFloat();
X     break;
X      case random_walk:
X#if 0
X     new = ComplexSqrtFloat(new.x - Cx, new.y - Cy);
X     if (RANDOM(2))
X     {
X        new.x = -new.x;
X        new.y = -new.y;
X     }
X#endif
X     break;
X      case random_run:
X#if 0
X     new = ComplexSqrtFloat(new.x - Cx, new.y - Cy);
X     if (random_len == 0)
X     {
X        random_len = RANDOM(run_length);
X        random_dir = RANDOM(3);
X     }
X     switch (random_dir) {
X        case 0:    /* left */
X           break;
X        case 1:    /* right */
X           new.x = -new.x;
X           new.y = -new.y;
X           break;
X        case 2:    /* random direction */
X           if (RANDOM(2))
X           {
X          new.x = -new.x;
X          new.y = -new.y;
X           }
X           break;
X     }
X#endif
X     break;
X   }
X
X   /*
X    * Next, find its pixel position
X    */
X   newcol = cvt.a * new.x + cvt.b * new.y + cvt.e;
X   newrow = cvt.c * new.x + cvt.d * new.y + cvt.f;
X
X   /*
X    * Now find the next point(s), and flip a coin to choose one.
X    */
X
X   new       = ComplexSqrtFloat(new.x - Cx, new.y - Cy);
X   leftright = (RANDOM(2)) ? 1 : -1;
X
X   if (newcol < 1 || newcol >= xdots || newrow < 1 || newrow >= ydots)
X   {
X      /*
X       * MIIM must skip points that are off the screen boundary,
X       * since it cannot read their color.
X       */
X      switch (major_method) {
X     case breadth_first:
X        EnQueueFloat(leftright * new.x, leftright * new.y);
X        return 1;
X     case depth_first:
X        PushFloat   (leftright * new.x, leftright * new.y);
X        return 1;
X     case random_run:
X     case random_walk:
X        break;
X      }
X   }
X
X   /*
X    * Read the pixel's color:
X    * For MIIM, if color >= maxhits, discard the point
X    *           else put the point's children onto the queue
X    */
X   color  = getcolor(newcol, newrow);
X   switch (major_method) {
X      case breadth_first:
X     if (color < maxhits)
X     {
X        putcolor(newcol, newrow, color+1);
X/*        new = ComplexSqrtFloat(new.x - Cx, new.y - Cy); */
X        EnQueueFloat( new.x,  new.y);
X        EnQueueFloat(-new.x, -new.y);
X     }
X     break;
X      case depth_first:
X     if (color < maxhits)
X     {
X        putcolor(newcol, newrow, color+1);
X/*        new = ComplexSqrtFloat(new.x - Cx, new.y - Cy); */
X        if (minor_method == left_first)
X        {
X           if (QueueFullAlmost())
X          PushFloat(-new.x, -new.y);
X           else
X           {
X          PushFloat( new.x,  new.y);
X          PushFloat(-new.x, -new.y);
X           }
X        }
X        else
X        {
X           if (QueueFullAlmost())
X          PushFloat( new.x,  new.y);
X           else
X           {
X          PushFloat(-new.x, -new.y);
X          PushFloat( new.x,  new.y);
X           }
X        }
X     }
X     break;
X      case random_run:
X     if (random_len-- == 0)
X     {
X        random_len = RANDOM(run_length);
X        random_dir = RANDOM(3);
X     }
X     switch (random_dir) {
X        case 0:    /* left */
X           break;
X        case 1:    /* right */
X           new.x = -new.x;
X           new.y = -new.y;
X           break;
X        case 2:    /* random direction */
X           new.x = leftright * new.x;
X           new.y = leftright * new.y;
X           break;
X     }
X     if (color < colors-1)
X        putcolor(newcol, newrow, color+1);
X     break;
X      case random_walk:
X     if (color < colors-1)
X        putcolor(newcol, newrow, color+1);
X     new.x = leftright * new.x;
X     new.y = leftright * new.y;
X     break;
X   }
X   return 1;
X
X}
X
Xint
XLinverse_julia_orbit()
X{
X   static int   random_dir = 0, random_len = 0;
X   int    newrow, newcol;
X   int    color;
X
X   /*
X    * First, compute new point
X    */
X   switch (major_method) {
X      case breadth_first:
X     if (QueueEmpty())
X        return -1;
X     lnew = DeQueueLong();
X     break;
X      case depth_first:
X     if (QueueEmpty())
X        return -1;
X     lnew = PopLong();
X     break;
X      case random_walk:
X     lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
X     if (RANDOM(2))
X     {
X        lnew.x = -lnew.x;
X        lnew.y = -lnew.y;
X     }
X     break;
X      case random_run:
X     lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
X     if (random_len == 0)
X     {
X        random_len = RANDOM(run_length);
X        random_dir = RANDOM(3);
X     }
X     switch (random_dir) {
X        case 0:    /* left */
X           break;
X        case 1:    /* right */
X           lnew.x = -lnew.x;
X           lnew.y = -lnew.y;
X           break;
X        case 2:    /* random direction */
X           if (RANDOM(2))
X           {
X          lnew.x = -lnew.x;
X          lnew.y = -lnew.y;
X           }
X           break;
X     }
X   }
X
X   /*
X    * Next, find its pixel position
X    *
X    * Note: had to use a bitshift of 21 for this operation because
X    * otherwise the values of lcvt were truncated.  Used bitshift
X    * of 24 otherwise, for increased precision.
X    */
X   newcol = (multiply(lcvt.a, lnew.x >> (bitshift - 21), 21) +
X         multiply(lcvt.b, lnew.y >> (bitshift - 21), 21) + lcvt.e) >> 21;
X   newrow = (multiply(lcvt.c, lnew.x >> (bitshift - 21), 21) +
X         multiply(lcvt.d, lnew.y >> (bitshift - 21), 21) + lcvt.f) >> 21;
X
X   if (newcol < 1 || newcol >= xdots || newrow < 1 || newrow >= ydots)
X   {
X      /*
X       * MIIM must skip points that are off the screen boundary,
X       * since it cannot read their color.
X       */
X      if (RANDOM(2))
X     color =  1;
X      else
X     color = -1;
X      switch (major_method) {
X     case breadth_first:
X        lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
X        EnQueueLong(color * lnew.x, color * lnew.y);
X        break;
X     case depth_first:
X        lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
X        PushLong(color * lnew.x, color * lnew.y);
X        break;
X     case random_run:
X        random_len--;
X     case random_walk:
X        break;
X      }
X      return 1;
X   }
X
X   /*
X    * Read the pixel's color:
X    * For MIIM, if color >= maxhits, discard the point
X    *           else put the point's children onto the queue
X    */
X   color  = getcolor(newcol, newrow);
X   switch (major_method) {
X      case breadth_first:
X     if (color < maxhits)
X     {
X        putcolor(newcol, newrow, color+1);
X        lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
X        EnQueueLong( lnew.x,  lnew.y);
X        EnQueueLong(-lnew.x, -lnew.y);
X     }
X     break;
X      case depth_first:
X     if (color < maxhits)
X     {
X        putcolor(newcol, newrow, color+1);
X        lnew = ComplexSqrtLong(lnew.x - CxLong, lnew.y - CyLong);
X        if (minor_method == left_first)
X        {
X           if (QueueFullAlmost())
X          PushLong(-lnew.x, -lnew.y);
X           else
X           {
X          PushLong( lnew.x,  lnew.y);
X          PushLong(-lnew.x, -lnew.y);
X           }
X        }
X        else
X        {
X           if (QueueFullAlmost())
X          PushLong( lnew.x,  lnew.y);
X           else
X           {
X          PushLong(-lnew.x, -lnew.y);
X          PushLong( lnew.x,  lnew.y);
X           }
X        }
X     }
X     break;
X      case random_run:
X     random_len--;
X     /* fall through */
X      case random_walk:
X     if (color < colors-1)
X        putcolor(newcol, newrow, color+1);
X     break;
X   }
X   return 1;
X}
X
X#if 0
Xint inverse_julia_orbit(double *x, double *y, double *z)
X{
X   double r, xo, yo;
X   int waste;
X   if(*z >= 1.0) /* this assumes intial value is 1.0!!! */
X   {
X      waste = 20; /* skip these points at first */
X      *z = 0;
X   }
X   else
X      waste = 1;
X   while(waste--)
X   {
X      xo = *x - param[0];
X      yo = *y - param[1];
X      r  = sqrt(xo*xo + yo*yo);
X      *x  = sqrt((r + xo)/2);
X      if (yo < 0)
X         *x = - *x;
X      *y = sqrt((r - xo)/2);
X      if(RANDOM(10) > 4)
X      {
X          *x = -(*x);
X          *y = -(*y);
X      }
X   }
X   return(0);
X}
X#endif
X
Xint lorenz3dlongorbit(long *l_x, long *l_y, long *l_z)
X{
X      l_xdt = multiply(*l_x,l_dt,bitshift);
X      l_ydt = multiply(*l_y,l_dt,bitshift);
X      l_dx  = -multiply(l_adt,*l_x,bitshift) + multiply(l_adt,*l_y,bitshift);
X      l_dy  =  multiply(l_bdt,*l_x,bitshift) -l_ydt -multiply(*l_z,l_xdt,bitshift);
X      l_dz  = -multiply(l_cdt,*l_z,bitshift) + multiply(*l_x,l_ydt,bitshift);
X
X      *l_x += l_dx;
X      *l_y += l_dy;
X      *l_z += l_dz;
X      return(0);
X}
X
Xint lorenz3d1floatorbit(double *x, double *y, double *z)
X{
X      double norm;
X
X      xdt = (*x)*dt;
X      ydt = (*y)*dt;
X      zdt = (*z)*dt;
X
X      /* 1-lobe Lorenz */
X      norm = sqrt((*x)*(*x)+(*y)*(*y));
X      dx   = (-adt-dt)*(*x) + (adt-bdt)*(*y) + (dt-adt)*norm + ydt*(*z);
X      dy   = (bdt-adt)*(*x) - (adt+dt)*(*y) + (bdt+adt)*norm - xdt*(*z) -
X         norm*zdt;
X      dz   = (ydt/2) - cdt*(*z);
X
X      *x += dx;
X      *y += dy;
X      *z += dz;
X      return(0);
X}
X
Xint lorenz3dfloatorbit(double *x, double *y, double *z)
X{
X      xdt = (*x)*dt;
X      ydt = (*y)*dt;
X      zdt = (*z)*dt;
X
X      /* 2-lobe Lorenz (the original) */
X      dx  = -adt*(*x) + adt*(*y);
X      dy  =  bdt*(*x) - ydt - (*z)*xdt;
X      dz  = -cdt*(*z) + (*x)*ydt;
X
X      *x += dx;
X      *y += dy;
X      *z += dz;
X      return(0);
X}
X
Xint lorenz3d3floatorbit(double *x, double *y, double *z)
X{
X      double norm;
X
X      xdt = (*x)*dt;
X      ydt = (*y)*dt;
X      zdt = (*z)*dt;
X
X      /* 3-lobe Lorenz */
X      norm = sqrt((*x)*(*x)+(*y)*(*y));
X      dx   = (-(adt+dt)*(*x) + (adt-bdt+zdt)*(*y)) / 3 +
X         ((dt-adt)*((*x)*(*x)-(*y)*(*y)) +
X         2*(bdt+adt-zdt)*(*x)*(*y))/(3*norm);
X      dy   = ((bdt-adt-zdt)*(*x) - (adt+dt)*(*y)) / 3 +
X         (2*(adt-dt)*(*x)*(*y) +
X         (bdt+adt-zdt)*((*x)*(*x)-(*y)*(*y)))/(3*norm);
X      dz   = (3*xdt*(*x)*(*y)-ydt*(*y)*(*y))/2 - cdt*(*z);
X
X      *x += dx;
X      *y += dy;
X      *z += dz;
X      return(0);
X}
X
Xint lorenz3d4floatorbit(double *x, double *y, double *z)
X{
X      xdt = (*x)*dt;
X      ydt = (*y)*dt;
X      zdt = (*z)*dt;
X
X      /* 4-lobe Lorenz */
X      dx   = (-adt*(*x)*(*x)*(*x) + (2*adt+bdt-zdt)*(*x)*(*x)*(*y) +
X         (adt-2*dt)*(*x)*(*y)*(*y) + (zdt-bdt)*(*y)*(*y)*(*y)) /
X         (2 * ((*x)*(*x)+(*y)*(*y)));
X      dy   = ((bdt-zdt)*(*x)*(*x)*(*x) + (adt-2*dt)*(*x)*(*x)*(*y) +
X         (-2*adt-bdt+zdt)*(*x)*(*y)*(*y) - adt*(*y)*(*y)*(*y)) /
X         (2 * ((*x)*(*x)+(*y)*(*y)));
X      dz   = (2*xdt*(*x)*(*x)*(*y) - 2*xdt*(*y)*(*y)*(*y) - cdt*(*z));
X
X      *x += dx;
X      *y += dy;
X      *z += dz;
X      return(0);
X}
X
Xint henonfloatorbit(double *x, double *y, double *z)
X{
X      double newx,newy;
X      newx  = 1 + *y - a*(*x)*(*x);
X      newy  = b*(*x);
X      *x = newx;
X      *y = newy;
X      return(0);
X}
X
Xint henonlongorbit(long *l_x, long *l_y, long *l_z)
X{
X      long newx,newy;
X      newx = multiply(*l_x,*l_x,bitshift);
X      newx = multiply(newx,l_a,bitshift);
X      newx  = fudge + *l_y - newx;
X      newy  = multiply(l_b,*l_x,bitshift);
X      *l_x = newx;
X      *l_y = newy;
X      return(0);
X}
X
Xint rosslerfloatorbit(double *x, double *y, double *z)
X{
X      xdt = (*x)*dt;
X      ydt = (*y)*dt;
X
X      dx = -ydt - (*z)*dt;
X      dy = xdt + (*y)*adt;
X      dz = bdt + (*z)*xdt - (*z)*cdt;
X
X      *x += dx;
X      *y += dy;
X      *z += dz;
X      return(0);
X}
X
Xint pickoverfloatorbit(double *x, double *y, double *z)
X{
X      double newx,newy,newz;
X      newx = sin(a*(*y)) - (*z)*cos(b*(*x));
X      newy = (*z)*sin(c*(*x)) - cos(d*(*y));
X      newz = sin(*x);
X      *x = newx;
X      *y = newy;
X      *z = newz;
X      return(0);
X}
X/* page 149 "Science of Fractal Images" */
Xint gingerbreadfloatorbit(double *x, double *y, double *z)
X{
X      double newx;
X      newx = 1 - (*y) + fabs(*x);
X      *y = *x;
X      *x = newx;
X      return(0);
X}
X
Xint rosslerlongorbit(long *l_x, long *l_y, long *l_z)
X{
X      l_xdt = multiply(*l_x,l_dt,bitshift);
X      l_ydt = multiply(*l_y,l_dt,bitshift);
X
X      l_dx  = -l_ydt - multiply(*l_z,l_dt,bitshift);
X      l_dy  =  l_xdt + multiply(*l_y,l_adt,bitshift);
X      l_dz  =  l_bdt + multiply(*l_z,l_xdt,bitshift)
X             - multiply(*l_z,l_cdt,bitshift);
X
X      *l_x += l_dx;
X      *l_y += l_dy;
X      *l_z += l_dz;
X
X      return(0);
X}
X
X/* OSTEP  = Orbit Step (and inner orbit value) */
X/* NTURNS = Outside Orbit */
X/* TURN2  = Points per orbit */
X/* a      = Angle */
X
X
Xint kamtorusfloatorbit(double *r, double *s, double *z)
X{
X   double srr;
X   if(t++ >= l_d)
X   {
X      orbit += b;
X      (*r) = (*s) = orbit/3;
X      t = 0;
X      *z = orbit;
X      if(orbit > c)
X     return(1);
X   }
X   srr = (*s)-(*r)*(*r);
X   (*s)=(*r)*sinx+srr*cosx;
X   (*r)=(*r)*cosx-srr*sinx;
X   return(0);
X}
X
Xint kamtoruslongorbit(long *r, long *s, long *z)
X{
X   long srr;
X   if(t++ >= l_d)
X   {
X      l_orbit += l_b;
X      (*r) = (*s) = l_orbit/3;
X      t = 0;
X      *z = l_orbit;
X      if(l_orbit > l_c)
X     return(1);
X   }
X   srr = (*s)-multiply((*r),(*r),bitshift);
X   (*s)=multiply((*r),l_sinx,bitshift)+multiply(srr,l_cosx,bitshift);
X   (*r)=multiply((*r),l_cosx,bitshift)-multiply(srr,l_sinx,bitshift);
X   return(0);
X}
X/*#define sign(x) ((x)>0?1:((x)<0?(-1):0))*/
X#define sign(x) ((x)>=0?1:-1)
Xint hopalong2dfloatorbit(double *x, double *y, double *z)
X{
X   double tmp;
X   tmp = *y - sign(*x)*sqrt(fabs(b*(*x)-c));
X   *y = a - *x;
X   *x = tmp;
X   return(0);
X}
X
Xint martin2dfloatorbit(double *x, double *y, double *z)
X{
X   double tmp;
X   tmp = *y - sin(*x);
X   *y = a - *x;
X   *x = tmp;
X   return(0);
X}
X
Xint mandelcloudfloat(double *x, double *y, double *z)
X{
X    double newx,newy,x2,y2;
X    x2 = (*x)*(*x);
X    y2 = (*y)*(*y);
X    if (x2+y2>2) return 1;
X    newx = x2-y2+a;
X    newy = 2*(*x)*(*y)+b;
X    *x = newx;
X    *y = newy;
X    return(0);
X}
X
Xint dynamfloat(double *x, double *y, double *z)
X{
X      _CMPLX cp,tmp;
X      double newx,newy;
X      cp.x = b* *x;
X      cp.y = 0;
X      CMPLXtrig0(cp, tmp);
X      newy = *y + dt*sin(*x + a*tmp.x);
X      if (euler) {
X      *y = newy;
X      }
X
X      cp.x = b* *y;
X      cp.y = 0;
X      CMPLXtrig0(cp, tmp);
X      newx = *x - dt*sin(*y + a*tmp.x);
X      *x = newx;
X      *y = newy;
X      return(0);
X}
X
X/* dmf */
X#undef  LAMBDA
X#define LAMBDA  param[0]
X#define ALPHA   param[1]
X#define BETA    param[2]
X#define GAMMA   param[3]
X#define OMEGA   param[4]
X#define DEGREE  param[5]
X
Xint iconfloatorbit(double *x, double *y, double *z)
X{
X
X    double oldx, oldy, zzbar, zreal, zimag, za, zb, zn, p;
X    unsigned char i;
X
X    oldx = *x;
X    oldy = *y;
X
X    zzbar = oldx * oldx + oldy * oldy;
X    zreal = oldx;
X    zimag = oldy;
X
X    for(i=1; i <= DEGREE-2; i++) {
X        za = zreal * oldx - zimag * oldy;
X        zb = zimag * oldx + zreal * oldy;
X        zreal = za;
X        zimag = zb;
X    }
X    zn = oldx * zreal - oldy * zimag;
X    p = LAMBDA + ALPHA * zzbar + BETA * zn;
X    *x = p * oldx + GAMMA * zreal - OMEGA * oldy;
X    *y = p * oldy - GAMMA * zimag + OMEGA * oldx;
X
X/*    if (fractype==ICON3D) */
X    *z = zzbar;
X    return(0);
X}
X#ifdef LAMBDA  /* Tim says this will make me a "good citizen" */
X#undef LAMBDA  /* Yeah, but you were bad, Dan - LAMBDA was already */
X#undef ALPHA   /* defined! <grin!> TW */
X#undef BETA
X#undef GAMMA
X#endif
X/**********************************************************************/
X/*   Main fractal engines - put in fractalspecific[fractype].calctype */
X/**********************************************************************/
X
Xint inverse_julia_per_image()
X{
X   int color = 0;
X
X   if (resuming)            /* can't resume */
X      return -1;
X
X   while (color >= 0)       /* generate points */
X   {
X      if (check_key())
X      {
X     Free_Queue();
X     return -1;
X      }
X      color = curfractalspecific->orbitcalc();
X      old = new;
X   }
X   Free_Queue();
X   return 0;
X}
X
Xint orbit2dfloat()
X{
X   FILE *fp;
X   double *soundvar;
X   double x,y,z;
X   int color,col,row;
X   int count;
X   int oldrow, oldcol;
X   double *p0,*p1,*p2;
X   struct affine cvt;
X   int ret,start;
X   start = 1;
X
X   fp = open_orbitsave();
X   /* setup affine screen coord conversion */
X   setup_convert_to_screen(&cvt);
X
X   /* set up projection scheme */
X   if(projection==0)
X   {
X      p0 = &z;
X      p1 = &x;
X      p2 = &y;
X   }
X   else if(projection==1)
X   {
X      p0 = &x;
X      p1 = &z;
X      p2 = &y;
X   }
X   else if(projection==2)
X   {
X      p0 = &x;
X      p1 = &y;
X      p2 = &z;
X   }
X   if(soundflag==1)
X      soundvar = &x;
X   else if(soundflag==2)
X      soundvar = &y;
X   else if(soundflag==3)
X      soundvar = &z;
X
X   count = 0;
X   if(inside > 0)
X      color = inside;
X   if(color >= colors)
X      color = 1;
X   oldcol = oldrow = -1;
X   x = initorbit[0];
X   y = initorbit[1];
X   z = initorbit[2];
X
X   if (resuming)
X   {
X      start_resume();
X      get_resume(sizeof(count),&count,sizeof(color),&color,
X          sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
X          sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
X          sizeof(t),&t,sizeof(orbit),&orbit,
X          0);
X      end_resume();
X   }
X
X   ret = 0;
X   while(1)
X   {
X      if(check_key())
X      {
X         nosnd();
X         alloc_resume(100,1);
X         put_resume(sizeof(count),&count,sizeof(color),&color,
X             sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
X             sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
X             sizeof(t),&t,sizeof(orbit),&orbit,
X             0);
X         ret = -1;
X         break;
X      }
X
X      if (++count > 1000)
X      {        /* time to switch colors? */
X         count = 0;
X         if (++color >= colors)   /* another color to switch to? */
X        color = 1;  /* (don't use the background color) */
X      }
X
X      col = cvt.a*x + cvt.b*y + cvt.e;
X      row = cvt.c*x + cvt.d*y + cvt.f;
X      if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
X      {
X         if (soundflag > 0)
X            snd((int)(*soundvar*100+basehertz));
X/* dmf */
X         if(fractype!=ICON)
X         {
X         if(oldcol != -1 && connect)
X            draw_line(col,row,oldcol,oldrow,color&(colors-1));
X            else
X            (*plot)(col,row,color&(colors-1));
X         } else {
X            /* should this be using plothist()? */
X            color = getcolor(col,row)+1;
X            if( color < colors ) /* color sticks on last value */
X               (*plot)(col,row,color);
X
X         }
X
X         oldcol = col;
X         oldrow = row;
X         start = 0;
X      }
X      else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
X         return(ret);
X      else
X         oldrow = oldcol = -1;
X
X      if(curfractalspecific->orbitcalc(p0, p1, p2))
X         break;
X      if(fp)
X         fprintf(fp,orbitsave_format,*p0,*p1,0.0);
X   }
X   if(fp)
X      fclose(fp);
X   return(ret);
X}
X
Xint orbit2dlong()
X{
X   FILE *fp;
X   long *soundvar;
X   long x,y,z;
X   int color,col,row;
X   int count;
X   int oldrow, oldcol;
X   long *p0,*p1,*p2;
X   struct l_affine cvt;
X   int ret,start;
X   start = 1;
X   fp = open_orbitsave();
X
X   /* setup affine screen coord conversion */
X   l_setup_convert_to_screen(&cvt);
X
X   /* set up projection scheme */
X   if(projection==0)
X   {
X      p0 = &z;
X      p1 = &x;
X      p2 = &y;
X   }
X   else if(projection==1)
X   {
X      p0 = &x;
X      p1 = &z;
X      p2 = &y;
X   }
X   else if(projection==2)
X   {
X      p0 = &x;
X      p1 = &y;
X      p2 = &z;
X   }
X   if(soundflag==1)
X      soundvar = &x;
X   else if(soundflag==2)
X      soundvar = &y;
X   else if(soundflag==3)
X      soundvar = &z;
X   count = 0;
X   if(inside > 0)
X      color = inside;
X   if(color >= colors)
X      color = 1;
X   oldcol = oldrow = -1;
X   x = initorbitlong[0];
X   y = initorbitlong[1];
X   z = initorbitlong[2];
X
X   if (resuming)
X   {
X      start_resume();
X      get_resume(sizeof(count),&count,sizeof(color),&color,
X          sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
X          sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
X          sizeof(t),&t,sizeof(l_orbit),&l_orbit,
X          0);
X      end_resume();
X   }
X
X   ret = 0;
X   while(1)
X   {
X      if(check_key())
X      {
X         nosnd();
X         alloc_resume(100,1);
X         put_resume(sizeof(count),&count,sizeof(color),&color,
X         sizeof(oldrow),&oldrow,sizeof(oldcol),&oldcol,
X             sizeof(x),&x,sizeof(y),&y,sizeof(z),&z,
X             sizeof(t),&t,sizeof(l_orbit),&l_orbit,
X             0);
X         ret = -1;
X         break;
X      }
X      if (++count > 1000)
X      {        /* time to switch colors? */
X         count = 0;
X         if (++color >= colors)   /* another color to switch to? */
X            color = 1;  /* (don't use the background color) */
X      }
X
X      col = (multiply(cvt.a,x,bitshift) + multiply(cvt.b,y,bitshift) + cvt.e) >> bitshift;
X      row = (multiply(cvt.c,x,bitshift) + multiply(cvt.d,y,bitshift) + cvt.f) >> bitshift;
X      if(overflow)
X      {
X         overflow = 0;
X         return(ret);
X      }
X      if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
X      {
X         if (soundflag > 0)
X         {
X            double yy;
X            yy = *soundvar;
X            yy = yy/fudge;
X            snd((int)(yy*100+basehertz));
X         }
X         if(oldcol != -1 && connect)
X            draw_line(col,row,oldcol,oldrow,color&(colors-1));
X         else if(!start)
X            (*plot)(col,row,color&(colors-1));
X         oldcol = col;
X         oldrow = row;
X         start = 0;
X      }
X      else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
X         return(ret);
X      else
X     oldrow = oldcol = -1;
X
X      /* Calculate the next point */
X      if(curfractalspecific->orbitcalc(p0, p1, p2))
X         break;
X      if(fp)
X         fprintf(fp,orbitsave_format,(double)*p0/fudge,(double)*p1/fudge,0.0);
X   }
X   if(fp)
X      fclose(fp);
X   return(ret);
X}
X
Xint orbit3dlongcalc()
X{
X   FILE *fp;
X   unsigned count;
X   int oldcol,oldrow;
X   int oldcol1,oldrow1;
X   struct long3dvtinf inf;
X   unsigned long maxct;
X   int color;
X   int ret;
X
X   /* setup affine screen coord conversion */
X   l_setup_convert_to_screen(&inf.cvt);
X
X   oldcol1 = oldrow1 = oldcol = oldrow = -1;
X   color = 2;
X   if(color >= colors)
X      color = 1;
X
X   inf.orbit[0] = initorbitlong[0];
X   inf.orbit[1] = initorbitlong[1];
X   inf.orbit[2] = initorbitlong[2];
X
X   if(diskvideo)                /* this would KILL a disk drive! */
X      notdiskmsg();
X
X   fp = open_orbitsave();
X
X   /* make maxct a function of screen size               */
X   maxct = maxit*40L;
X   count = inf.ct = 0L;
X   ret = 0;
X   while(inf.ct++ < maxct) /* loop until keypress or maxit */
X   {
X      /* calc goes here */
X      if (++count > 1000)
X      {        /* time to switch colors? */
X         count = 0;
X         if (++color >= colors)   /* another color to switch to? */
X            color = 1;        /* (don't use the background color) */
X      }
X      if(check_key())
X      {
X         nosnd();
X         ret = -1;
X         break;
X      }
X
X      curfractalspecific->orbitcalc(&inf.orbit[0],&inf.orbit[1],&inf.orbit[2]);
X      if(fp)
X         fprintf(fp,orbitsave_format,(double)inf.orbit[0]/fudge,(double)inf.orbit[1]/fudge,(double)inf.orbit[2]/fudge);
X      if (long3dviewtransf(&inf))
X      {
X         /* plot if inside window */
X         if (inf.col >= 0)
X         {
X            if(realtime)
X               whichimage=1;
X            if (soundflag > 0)
X            {
X               double yy;
X               yy = inf.viewvect[soundflag-1];
X               yy = yy/fudge;
X               snd((int)(yy*100+basehertz));
X            }
X            if(oldcol != -1 && connect)
X               draw_line(inf.col,inf.row,oldcol,oldrow,color&(colors-1));
X            else
X               (*plot)(inf.col,inf.row,color&(colors-1));
X         }
X         else if (inf.col == -2)
X            return(ret);
X         oldcol = inf.col;
X         oldrow = inf.row;
X         if(realtime)
X         {
X            whichimage=2;
X            /* plot if inside window */
X            if (inf.col1 >= 0)
X            {
X               if(oldcol1 != -1 && connect)
X                  draw_line(inf.col1,inf.row1,oldcol1,oldrow1,color&(colors-1));
X               else
X                  (*plot)(inf.col1,inf.row1,color&(colors-1));
X            }
X            else if (inf.col1 == -2)
X               return(ret);
X            oldcol1 = inf.col1;
X            oldrow1 = inf.row1;
X         }
X      }
X   }
X   if(fp)
X      fclose(fp);
X   return(ret);
X}
X
X
Xint orbit3dfloatcalc()
X{
X   FILE *fp;
X   unsigned count;
X   int oldcol,oldrow;
X   int oldcol1,oldrow1;
X   extern int init3d[];
X   unsigned long maxct;
X   int color;
X   int ret;
X   struct float3dvtinf inf;
X
X   /* setup affine screen coord conversion */
X   setup_convert_to_screen(&inf.cvt);
X
X   oldcol = oldrow = -1;
X   oldcol1 = oldrow1 = -1;
X   color = 2;
X   if(color >= colors)
X      color = 1;
X   inf.orbit[0] = initorbit[0];
X   inf.orbit[1] = initorbit[1];
X   inf.orbit[2] = initorbit[2];
X
X   if(diskvideo)                /* this would KILL a disk drive! */
X      notdiskmsg();
X
X   fp = open_orbitsave();
X
X   maxct = maxit*40L;
X   count = inf.ct = 0L;
X   ret = 0;
X   while(inf.ct++ < maxct) /* loop until keypress or maxit */
X   {
X      /* calc goes here */
X      if (++count > 1000)
X      {        /* time to switch colors? */
X         count = 0;
X         if (++color >= colors)   /* another color to switch to? */
X            color = 1;        /* (don't use the background color) */
X      }
X
X      if(check_key())
X      {
X         nosnd();
X         ret = -1;
X         break;
X      }
X
X      curfractalspecific->orbitcalc(&inf.orbit[0],&inf.orbit[1],&inf.orbit[2]);
X      if(fp)
X         fprintf(fp,orbitsave_format,inf.orbit[0],inf.orbit[1],inf.orbit[2]);
X      if (float3dviewtransf(&inf))
X      {
X         /* plot if inside window */
X         if (inf.col >= 0)
X         {
X        if(realtime)
X               whichimage=1;
X            if (soundflag > 0)
X               snd((int)(inf.viewvect[soundflag-1]*100+basehertz));
X            if(oldcol != -1 && connect)
X               draw_line(inf.col,inf.row,oldcol,oldrow,color&(colors-1));
X            else
X               (*plot)(inf.col,inf.row,color&(colors-1));
X         }
X         else if (inf.col == -2)
X            return(ret);
X         oldcol = inf.col;
X         oldrow = inf.row;
X         if(realtime)
X         {
X            whichimage=2;
X            /* plot if inside window */
X            if (inf.col1 >= 0)
X            {
X               if(oldcol1 != -1 && connect)
X                  draw_line(inf.col1,inf.row1,oldcol1,oldrow1,color&(colors-1));
X               else
X                  (*plot)(inf.col1,inf.row1,color&(colors-1));
X            }
X            else if (inf.col1 == -2)
X               return(ret);
X            oldcol1 = inf.col1;
X            oldrow1 = inf.row1;
X         }
X      }
X   }
X   if(fp)
X      fclose(fp);
X   return(ret);
X}
X
Xint dynam2dfloatsetup()
X{
X   connect = 0;
X   euler = 0;
X   d = param[0]; /* number of intervals */
X   if (d<0) {
X      d = -d;
X      connect = 1;
X   }
X   else if (d==0) {
X      d = 1;
X   }
X   if (fractype==DYNAMICFP) {
X       a = param[2]; /* parameter */
X       b = param[3]; /* parameter */
X       dt = param[1]; /* step size */
X       if (dt<0) {
X      dt = -dt;
X      euler = 1;
X       }
X       if (dt==0) dt = 0.01;
X   }
X   if (outside == -5) {
X       plot = plothist;
X   }
X   return(1);
X}
X
X/*
X * This is the routine called to perform a time-discrete dynamical
X * system image.
X * The starting positions are taken by stepping across the image in steps
X * of parameter1 pixels.  maxit differential equation steps are taken, with
X * a step size of parameter2.
X */
Xint dynam2dfloat()
X{
X   FILE *fp;
X   double *soundvar;
X   double x,y,z;
X   int color,col,row;
X   int count;
X   int oldrow, oldcol;
X   double *p0,*p1;
X   struct affine cvt;
X   int ret;
X   int xstep, ystep; /* The starting position step number */
X   double xpixel, ypixel; /* Our pixel position on the screen */
X
X   fp = open_orbitsave();
X   /* setup affine screen coord conversion */
X   setup_convert_to_screen(&cvt);
X
X   p0 = &x;
X   p1 = &y;
X
X
X   if(soundflag==1)
X      soundvar = &x;
X   else if(soundflag==2)
X      soundvar = &y;
X   else if(soundflag==3)
X      soundvar = &z;
X
X   count = 0;
X   if(inside > 0)
X      color = inside;
X   if(color >= colors)
X      color = 1;
X   oldcol = oldrow = -1;
X
X   xstep = -1;
X   ystep = 0;
X
X   if (resuming) {
X       start_resume();
X       get_resume(sizeof(count),&count, sizeof(color),&color,
X         sizeof(oldrow),&oldrow, sizeof(oldcol),&oldcol,
X         sizeof(x),&x, sizeof(y), &y, sizeof(xstep), &xstep,
X         sizeof(ystep), &ystep, 0);
X       end_resume();
X   }
X
X   ret = 0;
X   while(1)
X   {
X      if(check_key())
X      {
X         nosnd();
X         alloc_resume(100,1);
X         put_resume(sizeof(count),&count, sizeof(color),&color,
X             sizeof(oldrow),&oldrow, sizeof(oldcol),&oldcol,
X             sizeof(x),&x, sizeof(y), &y, sizeof(xstep), &xstep,
X             sizeof(ystep), &ystep, 0);
X         ret = -1;
X         break;
X      }
X
X      xstep ++;
X      if (xstep>=d) {
X      xstep = 0;
X      ystep ++;
X      if (ystep>d) {
X          nosnd();
X          ret = -1;
X          break;
X      }
X      }
X
X      xpixel = dxsize*(xstep+.5)/d;
X      ypixel = dysize*(ystep+.5)/d;
X      x = (xxmin+delxx*xpixel) + (delxx2*ypixel);
X      y = (yymax-delyy*ypixel) + (-delyy2*xpixel);
X      if (fractype==MANDELCLOUD) {
X      a = x;
X      b = y;
X      }
X      oldcol = -1;
X
X      if (++color >= colors)   /* another color to switch to? */
X      color = 1;    /* (don't use the background color) */
X
X      for (count=0;count<maxit;count++) {
X
X      col = cvt.a*x + cvt.b*y + cvt.e;
X      row = cvt.c*x + cvt.d*y + cvt.f;
X      if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
X      {
X         if (soundflag > 0)
X           snd((int)(*soundvar*100+basehertz));
X
X         if (count>=orbit_delay) {
X         if(oldcol != -1 && connect)
X            draw_line(col,row,oldcol,oldrow,color&(colors-1));
X         else if(count > 0 || fractype != MANDELCLOUD)
X            (*plot)(col,row,color&(colors-1));
X         }
X         oldcol = col;
X         oldrow = row;
X      }
X      else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
X            return(ret);
X      else
X         oldrow = oldcol = -1;
X
X      if(curfractalspecific->orbitcalc(p0, p1, NULL))
X         break;
X      if(fp)
X          fprintf(fp,orbitsave_format,*p0,*p1,0.0);
X    }
X   }
X   if(fp)
X      fclose(fp);
X   return(ret);
X}
X
X/* this function's only purpose is to manage funnyglasses related */
X/* stuff so the code is not duplicated for ifs3d() and lorenz3d() */
Xint funny_glasses_call(int (*calc)())
X{
X   int status;
X   status = 0;
X   if(glassestype)
X      whichimage = 1;
X   else
X      whichimage = 0;
X   plot_setup();
X   plot = standardplot;
X   status = calc();
X   if(realtime && glassestype != 3)
X   {
X      realtime = 0;
X      return(status);
X   }
X   if(glassestype && status == 0 && display3d)
X   {
X      if(glassestype==3) /* photographer's mode */
X     if(active_system == 0) { /* dos version */
X        int i;
Xstatic char far firstready[]={"\
XFirst image (left eye) is ready.  Hit any key to see it,\n\
Xthen hit <s> to save, hit any other key to create second image."};
X        stopmsg(16,firstready);
X        while ((i = getakey()) == 's' || i == 'S') {
X           diskisactive = 1;
X           savetodisk(savename);
X           diskisactive = 0;
X           }
X        /* is there a better way to clear the screen in graphics mode? */
X        setvideomode(videoentry.videomodeax,
X        videoentry.videomodebx,
X        videoentry.videomodecx,
X        videoentry.videomodedx);
X     }
X     else {           /* Windows version */
Xstatic char far firstready2[]={"First (Left Eye) image is complete"};
X        stopmsg(0,firstready2);
X        clear_screen();
X        }
X      whichimage = 2;
X      plot_setup();
X      plot = standardplot;
X      /* is there a better way to clear the graphics screen ? */
X      if(status = calc())
X     return(status);
X      if(glassestype==3) /* photographer's mode */
X     if(active_system == 0) { /* dos version */
Xstatic char far secondready[]={"Second image (right eye) is ready"};
X        stopmsg(16,secondready);
X     }
X   }
X   return(status);
X}
X
X/* double version - mainly for testing */
Xstatic int ifs3dfloat()
X{
X   int color_method;
X   FILE *fp;
X   unsigned long maxct;
X   int color;
X
X   double newx,newy,newz,r,sum;
X
X   int k;
X   int ret;
X
X   struct float3dvtinf inf;
X
X   float far *ffptr;
X
X   /* setup affine screen coord conversion */
X   setup_convert_to_screen(&inf.cvt);
X   srand(1);
X   color_method = param[0];
X   if(diskvideo)                /* this would KILL a disk drive! */
X      notdiskmsg();
X
X   inf.orbit[0] = 0;
X   inf.orbit[1] = 0;
X   inf.orbit[2] = 0;
X
X   fp = open_orbitsave();
X
X   maxct = maxit*40L;
X   inf.ct = 0L;
X   ret = 0;
X   while(inf.ct++ < maxct) /* loop until keypress or maxit */
X   {
X      if( check_key() )  /* keypress bails out */
X      {
X     ret = -1;
X     break;
X      }
X      r = rand15();     /* generate fudged random number between 0 and 1 */
X      r /= 32767;
X
X      /* pick which iterated function to execute, weighted by probability */
X      sum = ifs_defn[12]; /* [0][12] */
X      k = 0;
X      while ( sum < r)
X      {
X     k++;
X     sum += ifs_defn[k*IFS3DPARM+12];
X     if (ifs_defn[(k+1)*IFS3DPARM+12] == 0) break; /* for safety */
X      }
X
X      /* calculate image of last point under selected iterated function */
X      ffptr = ifs_defn + k*IFS3DPARM; /* point to first parm in row */
X      newx = *ffptr * inf.orbit[0] +
X         *(ffptr+1) * inf.orbit[1] +
X         *(ffptr+2) * inf.orbit[2] + *(ffptr+9);
X      newy = *(ffptr+3) * inf.orbit[0] +
X         *(ffptr+4) * inf.orbit[1] +
X         *(ffptr+5) * inf.orbit[2] + *(ffptr+10);
X      newz = *(ffptr+6) * inf.orbit[0] +
X         *(ffptr+7) * inf.orbit[1] +
X         *(ffptr+8) * inf.orbit[2] + *(ffptr+11);
X
X      inf.orbit[0] = newx;
X      inf.orbit[1] = newy;
X      inf.orbit[2] = newz;
X      if(fp)
X      fprintf(fp,orbitsave_format,newx,newy,newz);
X      if (float3dviewtransf(&inf))
X      {
X     /* plot if inside window */
X     if (inf.col >= 0)
X     {
X        if(realtime)
X           whichimage=1;
X            if(color_method)
X               color = (k&(colors-1))+1;
X            else
X        color = getcolor(inf.col,inf.row)+1;
X        if( color < colors ) /* color sticks on last value */
X           (*plot)(inf.col,inf.row,color);
X     }
X         else if (inf.col == -2)
X            return(ret);
X     if(realtime)
X     {
X        whichimage=2;
X        /* plot if inside window */
X        if (inf.col1 >= 0)
X        {
X              if(color_method)
X                 color = (k&(colors-1))+1;
X              else
X            color = getcolor(inf.col1,inf.row1)+1;
X            if( color < colors ) /* color sticks on last value */
X          (*plot)(inf.col1,inf.row1,color);
X        }
X        else if (inf.col1 == -2)
X               return(ret);
X     }
X      }
X   } /* end while */
X   if(fp)
X      fclose(fp);
X   return(ret);
X}
X
Xint ifs()            /* front-end for ifs2d and ifs3d */
X{
X   if (ifs_defn == NULL && ifsload() < 0)
X      return(-1);
X   if(diskvideo)                /* this would KILL a disk drive! */
X      notdiskmsg();
X   return((ifs_type == 0) ? ifs2d() : ifs3d());
X}
X
X
X/* IFS logic shamelessly converted to integer math */
Xint ifs2d()
X{
X   int color_method;
X   FILE *fp;
X   unsigned long maxct,ct;
X   int col;
X   int row;
X   int color;
X   int ret;
X   long far *localifs;
X   long far *lfptr;
X   long x,y,newx,newy,r,sum, tempr;
X
X   int i,j,k;
X   struct l_affine cvt;
X   /* setup affine screen coord conversion */
X   l_setup_convert_to_screen(&cvt);
X
X   srand(1);
X   color_method = param[0];
X   if((localifs=(long far *)farmemalloc((long)numaffine*IFSPARM*sizeof(long)))==NULL)
X   {
X      stopmsg(0,insufficient_ifs_mem);
X      return(-1);
X   }
X
X   for (i = 0; i < numaffine; i++)    /* fill in the local IFS array */
X      for (j = 0; j < IFSPARM; j++)
X     localifs[i*IFSPARM+j] = ifs_defn[i*IFSPARM+j] * fudge;
X
X   tempr = fudge / 32767;     /* find the proper rand() fudge */
X
X   fp = open_orbitsave();
X
X   /* make maxct a function of screen size         */
X   /* 1k times maxit at EGA resolution seems about right */
X   maxct = (float)maxit*(1024.0*xdots*ydots)/(640.0*350.0);
X   ct = 0L;
X   x = y = 0;
X   ret = 0;
X   while(ct++ < maxct) /* loop until keypress or maxit */
X   {
X      if( check_key() )  /* keypress bails out */
X      {
X     ret = -1;
X     break;
X      }
X      r = rand15();     /* generate fudged random number between 0 and 1 */
X      r *= tempr;
X
X      /* pick which iterated function to execute, weighted by probability */
X      sum = localifs[6];  /* [0][6] */
X      k = 0;
X      while ( sum < r && k < numaffine-1) /* fixed bug of error if sum < 1 */
X     sum += localifs[++k*IFSPARM+6];
X      /* calculate image of last point under selected iterated function */
X      lfptr = localifs + k*IFSPARM; /* point to first parm in row */
X      newx = multiply(lfptr[0],x,bitshift) +
X             multiply(lfptr[1],y,bitshift) + lfptr[4];
X      newy = multiply(lfptr[2],x,bitshift) +
X             multiply(lfptr[3],y,bitshift) + lfptr[5];
X      x = newx;
X      y = newy;
X      if(fp)
X     fprintf(fp,orbitsave_format,(double)newx/fudge,(double)newy/fudge,0.0);
X
X      /* plot if inside window */
X      col = (multiply(cvt.a,x,bitshift) + multiply(cvt.b,y,bitshift) + cvt.e) >> bitshift;
X      row = (multiply(cvt.c,x,bitshift) + multiply(cvt.d,y,bitshift) + cvt.f) >> bitshift;
X      if ( col >= 0 && col < xdots && row >= 0 && row < ydots )
X      {
X     /* color is count of hits on this pixel */
X         if(color_method)
X            color = (k&(colors-1))+1;
X         else
X     color = getcolor(col,row)+1;
X     if( color < colors ) /* color sticks on last value */
X        (*plot)(col,row,color);
X      }
X      else if((long)abs(row) + (long)abs(col) > BAD_PIXEL) /* sanity check */
X            return(ret);
X   }
X   if(fp)
X      fclose(fp);
X   farmemfree(localifs);
X   return(ret);
X}
X
Xstatic int ifs3dlong()
X{
X   int color_method;
X   FILE *fp;
X   extern int init3d[];
X   unsigned long maxct;
X   int color;
X   int ret;
X
X   long far *localifs;
X   long far *lfptr;
X   long newx,newy,newz,r,sum, tempr;
X
X   int i,j,k;
X
X   struct long3dvtinf inf;
X   srand(1);
X   color_method = param[0];
X   if((localifs=(long far *)farmemalloc((long)numaffine*IFS3DPARM*sizeof(long)))==NULL)
X   {
X      stopmsg(0,insufficient_ifs_mem);
X      return(-1);
X   }
X
X   /* setup affine screen coord conversion */
X   l_setup_convert_to_screen(&inf.cvt);
X
X   for (i = 0; i < numaffine; i++)    /* fill in the local IFS array */
X      for (j = 0; j < IFS3DPARM; j++)
X     localifs[i*IFS3DPARM+j] = ifs_defn[i*IFS3DPARM+j] * fudge;
X
X   tempr = fudge / 32767;     /* find the proper rand() fudge */
X
X   inf.orbit[0] = 0;
X   inf.orbit[1] = 0;
X   inf.orbit[2] = 0;
X
X   fp = open_orbitsave();
X
X   maxct = maxit*40L;
X   inf.ct = 0L;
X   ret = 0;
X   while(inf.ct++ < maxct) /* loop until keypress or maxit */
X   {
X      if( check_key() )  /* keypress bails out */
X      {
X     ret = -1;
X     break;
X      }
X      r = rand15();     /* generate fudged random number between 0 and 1 */
X      r *= tempr;
X
X      /* pick which iterated function to execute, weighted by probability */
X      sum = localifs[12];  /* [0][12] */
X      k = 0;
X      while ( sum < r && ++k < numaffine*IFS3DPARM)
X     sum += localifs[k*IFS3DPARM+12];
X
X      /* calculate image of last point under selected iterated function */
X      lfptr = localifs + k*IFS3DPARM; /* point to first parm in row */
X
X      /* calculate image of last point under selected iterated function */
X      newx = multiply(lfptr[0], inf.orbit[0], bitshift) +
X             multiply(lfptr[1], inf.orbit[1], bitshift) +
X         multiply(lfptr[2], inf.orbit[2], bitshift) + lfptr[9];
X      newy = multiply(lfptr[3], inf.orbit[0], bitshift) +
X         multiply(lfptr[4], inf.orbit[1], bitshift) +
X         multiply(lfptr[5], inf.orbit[2], bitshift) + lfptr[10];
X      newz = multiply(lfptr[6], inf.orbit[0], bitshift) +
X         multiply(lfptr[7], inf.orbit[1], bitshift) +
X         multiply(lfptr[8], inf.orbit[2], bitshift) + lfptr[11];
X
X      inf.orbit[0] = newx;
X      inf.orbit[1] = newy;
X      inf.orbit[2] = newz;
X      if(fp)
X     fprintf(fp,orbitsave_format,(double)newx/fudge,(double)newy/fudge,(double)newz/fudge);
X
X      if (long3dviewtransf(&inf))
X      {
X     if((long)abs(inf.row) + (long)abs(inf.col) > BAD_PIXEL) /* sanity check */
X            return(ret);
X     /* plot if inside window */
X     if (inf.col >= 0)
X     {
X        if(realtime)
X           whichimage=1;
X            if(color_method)
X               color = (k&(colors-1))+1;
X            else
X        color = getcolor(inf.col,inf.row)+1;
X        if( color < colors ) /* color sticks on last value */
X           (*plot)(inf.col,inf.row,color);
X     }
X     if(realtime)
X     {
X        whichimage=2;
X        /* plot if inside window */
X        if (inf.col1 >= 0)
X        {
X               if(color_method)
X                  color = (k&(colors-1))+1;
X               else
X           color = getcolor(inf.col1,inf.row1)+1;
X           if( color < colors ) /* color sticks on last value */
X          (*plot)(inf.col1,inf.row1,color);
X        }
X     }
X      }
X   }
X   if(fp)
X      fclose(fp);
X   farmemfree(localifs);
X   return(ret);
X}
X
Xstatic void setupmatrix(MATRIX doublemat)
X{
X   /* build transformation matrix */
X   identity (doublemat);
X
X   /* apply rotations - uses the same rotation variables as line3d.c */
X   xrot ((double)XROT / 57.29577,doublemat);
X   yrot ((double)YROT / 57.29577,doublemat);
X   zrot ((double)ZROT / 57.29577,doublemat);
X
X   /* apply scale */
X/*   scale((double)XSCALE/100.0,(double)YSCALE/100.0,(double)ROUGH/100.0,doublemat);*/
X
X}
X
Xint orbit3dfloat()
X{
X   display3d = -1;
X   if(0 < glassestype && glassestype < 3)
X      realtime = 1;
X   else
X      realtime = 0;
X   return(funny_glasses_call(orbit3dfloatcalc));
X}
X
Xint orbit3dlong()
X{
X   display3d = -1;
X   if(0 < glassestype && glassestype < 3)
X      realtime = 1;
X   else
X      realtime = 0;
X   return(funny_glasses_call(orbit3dlongcalc));
X}
X
Xint ifs3d()
X{
X   display3d = -1;
X
X   if(0 < glassestype && glassestype < 3)
X      realtime = 1;
X   else
X      realtime = 0;
X   if(floatflag)
X      return(funny_glasses_call(ifs3dfloat)); /* double version of ifs3d */
X   else
X      return(funny_glasses_call(ifs3dlong));  /* long version of ifs3d     */
X}
X
X
X
Xstatic int long3dviewtransf(struct long3dvtinf *inf)
X{
X   int i,j;
X   double tmpx, tmpy, tmpz;
X   long tmp;
X
X   if (inf->ct == 1)    /* initialize on first call */
X   {
X      for(i=0;i<3;i++)
X      {
X     inf->minvals[i] =  1L << 30;
X     inf->maxvals[i] = -inf->minvals[i];
X      }
X      setupmatrix(inf->doublemat);
X      if(realtime)
X     setupmatrix(inf->doublemat1);
X      /* copy xform matrix to long for for fixed point math */
X      for (i = 0; i < 4; i++)
X     for (j = 0; j < 4; j++)
X     {
X        inf->longmat[i][j] = inf->doublemat[i][j] * fudge;
X        if(realtime)
X           inf->longmat1[i][j] = inf->doublemat1[i][j] * fudge;
X     }
X   }
X
X   /* 3D VIEWING TRANSFORM */
X   longvmult(inf->orbit,inf->longmat,inf->viewvect,bitshift);
X   if(realtime)
X      longvmult(inf->orbit,inf->longmat1,inf->viewvect1,bitshift);
X
X   if(inf->ct <= waste) /* waste this many points to find minz and maxz */
X   {
X      /* find minz and maxz */
X      for(i=0;i<3;i++)
X     if ((tmp = inf->viewvect[i]) < inf->minvals[i])
X        inf->minvals[i] = tmp;
X     else if (tmp > inf->maxvals[i])
X        inf->maxvals[i] = tmp;
X
X      if(inf->ct == waste) /* time to work it out */
X      {
X     inf->iview[0] = inf->iview[1] = 0L; /* center viewer on origin */
X
X     /* z value of user's eye - should be more negative than extreme
X            negative part of image */
X     inf->iview[2] = (long)((inf->minvals[2]-inf->maxvals[2])*(double)ZVIEWER/100.0);
X
X     /* center image on origin */
X     tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0*fudge); /* center x */
X     tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0*fudge); /* center y */
X
X     /* apply perspective shift */
X     tmpx += ((double)xshift*(xxmax-xxmin))/(xdots);
X     tmpy += ((double)yshift*(yymax-yymin))/(ydots);
X     tmpz = -((double)inf->maxvals[2]) / fudge;
X     trans(tmpx,tmpy,tmpz,inf->doublemat);
X
X     if(realtime)
X     {
X        /* center image on origin */
X        tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0*fudge); /* center x */
X        tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0*fudge); /* center y */
X
X        tmpx += ((double)xshift1*(xxmax-xxmin))/(xdots);
X        tmpy += ((double)yshift1*(yymax-yymin))/(ydots);
X        tmpz = -((double)inf->maxvals[2]) / fudge;
X        trans(tmpx,tmpy,tmpz,inf->doublemat1);
X     }
X     for(i=0;i<3;i++)
X        view[i] = (double)inf->iview[i] / fudge;
X
X     /* copy xform matrix to long for for fixed point math */
X     for (i = 0; i < 4; i++)
X        for (j = 0; j < 4; j++)
X        {
X           inf->longmat[i][j] = inf->doublemat[i][j] * fudge;
X           if(realtime)
X          inf->longmat1[i][j] = inf->doublemat1[i][j] * fudge;
X        }
X      }
X      return(0);
X   }
X
X   /* inf->ct > waste */
X   /* apply perspective if requested */
X   if(ZVIEWER)
X   {
X      if(debugflag==22 || ZVIEWER < 100) /* use float for small persp */
X      {
X     /* use float perspective calc */
X     VECTOR tmpv;
X     for(i=0;i<3;i++)
X        tmpv[i] = (double)inf->viewvect[i] / fudge;
X     perspective(tmpv);
X     for(i=0;i<3;i++)
X        inf->viewvect[i] = tmpv[i]*fudge;
X     if(realtime)
X     {
X        for(i=0;i<3;i++)
X           tmpv[i] = (double)inf->viewvect1[i] / fudge;
X        perspective(tmpv);
X        for(i=0;i<3;i++)
X           inf->viewvect1[i] = tmpv[i]*fudge;
X     }
X      }
X      else
X      {
X     longpersp(inf->viewvect,inf->iview,bitshift);
X     if(realtime)
X        longpersp(inf->viewvect1,inf->iview,bitshift);
X      }
X   }
X
X   /* work out the screen positions */
X   inf->row = ((multiply(inf->cvt.c,inf->viewvect[0],bitshift) +
X        multiply(inf->cvt.d,inf->viewvect[1],bitshift) + inf->cvt.f)
X        >> bitshift)
X          + yyadjust;
X   inf->col = ((multiply(inf->cvt.a,inf->viewvect[0],bitshift) +
X        multiply(inf->cvt.b,inf->viewvect[1],bitshift) + inf->cvt.e)
X        >> bitshift)
X          + xxadjust;
X   if (inf->col < 0 || inf->col >= xdots || inf->row < 0 || inf->row >= ydots)
X   {
X      if((long)abs(inf->col)+(long)abs(inf->row) > BAD_PIXEL)
X        inf->col= inf->row = -2;
X      else
X        inf->col= inf->row = -1;
X   }
X   if(realtime)
X   {
X      inf->row1 = ((multiply(inf->cvt.c,inf->viewvect1[0],bitshift) +
X            multiply(inf->cvt.d,inf->viewvect1[1],bitshift) +
X            inf->cvt.f) >> bitshift)
X          + yyadjust1;
X      inf->col1 = ((multiply(inf->cvt.a,inf->viewvect1[0],bitshift) +
X            multiply(inf->cvt.b,inf->viewvect1[1],bitshift) +
X            inf->cvt.e) >> bitshift)
X          + xxadjust1;
X      if (inf->col1 < 0 || inf->col1 >= xdots || inf->row1 < 0 || inf->row1 >= ydots)
X      {
X         if((long)abs(inf->col1)+(long)abs(inf->row1) > BAD_PIXEL)
X           inf->col1= inf->row1 = -2;
X         else
X           inf->col1= inf->row1 = -1;
X      }
X   }
X   return(1);
X}
X
Xstatic int float3dviewtransf(struct float3dvtinf *inf)
X{
X   int i;
X   double tmpx, tmpy, tmpz;
X   double tmp;
X
X   if (inf->ct == 1)    /* initialize on first call */
X   {
X      for(i=0;i<3;i++)
X      {
X     inf->minvals[i] =  100000.0; /* impossible value */
X     inf->maxvals[i] = -100000.0;
X      }
X      setupmatrix(inf->doublemat);
X      if(realtime)
X     setupmatrix(inf->doublemat1);
X   }
X
X   /* 3D VIEWING TRANSFORM */
X   vmult(inf->orbit,inf->doublemat,inf->viewvect );
X   if(realtime)
X      vmult(inf->orbit,inf->doublemat1,inf->viewvect1);
X
X   if(inf->ct <= waste) /* waste this many points to find minz and maxz */
X   {
X      /* find minz and maxz */
X      for(i=0;i<3;i++)
X     if ((tmp = inf->viewvect[i]) < inf->minvals[i])
X        inf->minvals[i] = tmp;
X     else if (tmp > inf->maxvals[i])
X        inf->maxvals[i] = tmp;
X      if(inf->ct == waste) /* time to work it out */
X      {
X     view[0] = view[1] = 0; /* center on origin */
X     /* z value of user's eye - should be more negative than extreme
X               negative part of image */
X     view[2] = (inf->minvals[2]-inf->maxvals[2])*(double)ZVIEWER/100.0;
X
X     /* center image on origin */
X     tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0); /* center x */
X     tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0); /* center y */
X
X     /* apply perspective shift */
X     tmpx += ((double)xshift*(xxmax-xxmin))/(xdots);
X     tmpy += ((double)yshift*(yymax-yymin))/(ydots);
X     tmpz = -(inf->maxvals[2]);
X     trans(tmpx,tmpy,tmpz,inf->doublemat);
X
X     if(realtime)
X     {
X        /* center image on origin */
X        tmpx = (-inf->minvals[0]-inf->maxvals[0])/(2.0); /* center x */
X        tmpy = (-inf->minvals[1]-inf->maxvals[1])/(2.0); /* center y */
X
X        tmpx += ((double)xshift1*(xxmax-xxmin))/(xdots);
X        tmpy += ((double)yshift1*(yymax-yymin))/(ydots);
X        tmpz = -(inf->maxvals[2]);
X        trans(tmpx,tmpy,tmpz,inf->doublemat1);
X        }
X     }
X      return(0);
X      }
X
X   /* inf->ct > waste */
X   /* apply perspective if requested */
X   if(ZVIEWER)
X   {
X      perspective(inf->viewvect);
X      if(realtime)
X     perspective(inf->viewvect1);
X   }
X   inf->row = inf->cvt.c*inf->viewvect[0] + inf->cvt.d*inf->viewvect[1]
X        + inf->cvt.f + yyadjust;
X   inf->col = inf->cvt.a*inf->viewvect[0] + inf->cvt.b*inf->viewvect[1]
X        + inf->cvt.e + xxadjust;
X   if (inf->col < 0 || inf->col >= xdots || inf->row < 0 || inf->row >= ydots)
X   {
X      if((long)abs(inf->col)+(long)abs(inf->row) > BAD_PIXEL)
X        inf->col= inf->row = -2;
X      else
X        inf->col= inf->row = -1;
X   }
X   if(realtime)
X   {
X      inf->row1 = inf->cvt.c*inf->viewvect1[0] + inf->cvt.d*inf->viewvect1[1]
X        + inf->cvt.f + yyadjust1;
X      inf->col1 = inf->cvt.a*inf->viewvect1[0] + inf->cvt.b*inf->viewvect1[1]
X        + inf->cvt.e + xxadjust1;
X      if (inf->col1 < 0 || inf->col1 >= xdots || inf->row1 < 0 || inf->row1 >= ydots)
X      {
X         if((long)abs(inf->col1)+(long)abs(inf->row1) > BAD_PIXEL)
X           inf->col1= inf->row1 = -2;
X         else
X           inf->col1= inf->row1 = -1;
X      }
X   }
X   return(1);
X}
X
Xstatic FILE *open_orbitsave()
X{
X   FILE *fp;
X   if (orbitsave && (fp = fopen(orbitsavename,"w")))
X   {
X      fprintf(fp,"pointlist x y z color\n");
X      return fp;
X   }
X   return NULL;
X}
X
X/* Plot a histogram by incrementing the pixel each time it it touched */
Xstatic void _fastcall plothist(x, y, color)
Xint x,y,color;
X{
X    color = getcolor(x,y)+1;
X    if (color<colors)
X    putcolor(x,y,color);
X}
X
X
X
X
SHAR_EOF
$TOUCH -am 1028230093 lorenz.c &&
chmod 0644 lorenz.c ||
echo "restore of lorenz.c failed"
set `wc -c lorenz.c`;Wc_c=$1
if test "$Wc_c" != "66158"; then
    echo original size 66158, current size $Wc_c
fi
# ============= lsys.c ==============
echo "x - extracting lsys.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lsys.c &&
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X#include <math.h>
X#ifdef __TURBOC__
X#include <alloc.h>
X#elif !defined(__386BSD__)
X#include <malloc.h>
X#endif
X#include "fractint.h"
X#include "prototyp.h"
X
X#define size    ssize
X/* Needed for use of asm -- helps decide which pointer to function
X * to put into the struct lsys_cmds.
X */
Xextern int cpu;
Xextern int fpu;
Xextern int debugflag;
Xextern int xdots,ydots;
Xextern int colors;
Xextern char LFileName[];
Xextern char LName[];
Xextern double param[];
Xextern int overflow;
Xextern float  screenaspect;
X
Xstruct lsys_cmd {
X  char ch;
X  void (*f)(long n);
X  long n;
X};
X
Xstatic double      _fastcall getnumber(char far **);
Xstatic struct lsys_cmd far * _fastcall findsize(struct lsys_cmd far *,struct lsys_cmd far **,int);
Xstatic int      _fastcall findscale(struct lsys_cmd far *, struct lsys_cmd far **, int);
Xstatic struct lsys_cmd far * _fastcall drawLSys(struct lsys_cmd far *, struct lsys_cmd far **, int);
Xstatic int      _fastcall readLSystemFile(char *);
Xstatic void      _fastcall free_rules_mem(void);
Xstatic int      _fastcall save_rule(char *,char far **);
Xstatic struct lsys_cmd far *SizeTransform(char far *s);
Xstatic struct lsys_cmd far *DrawTransform(char far *s);
Xstatic void free_lcmds();
X
Xstatic long aspect; /* aspect ratio of each pixel, ysize/xsize */
X
X/* Some notes to Adrian from PB, made when I integrated with v15:
X     printfs changed to work with new user interface
X     bug at end of readLSystemFile, the line which said rulind=0 fixed
X       to say *rulind=0
X     the calloc was not worthwhile, it was just for a 54 byte area, cheaper
X       to keep it as a static;    but there was a static 201 char buffer I
X       changed to not be static
X     use of strdup was a nono, caused problems running out of space cause
X       the memory allocated each time was never freed; I've changed to
X       use far memory and to free when done
X   */
X
Xlong sins[50];
Xlong coss[50];
X/* dmaxangle is maxangle - 1. */
Xchar maxangle,dmaxangle,curcolor;
Xlong size;
Xunsigned long realangle;
Xlong xpos,ypos;
Xchar counter,angle,reverse,stackoflow;
Xlong lsys_Xmin, lsys_Xmax, lsys_Ymin, lsys_Ymax;
X
X/* Macro to take an FP number and turn it into a
X * 16/16-bit fixed-point number.
X */
X#define FIXEDMUL    524288L
X#define FIXEDPT(x)    ((long) (FIXEDMUL * (x)))
X
X/* The number by which to multiply sines, cosines and other
X * values with magnitudes less than or equal to 1.
X * sins and coss are a 3/29 bit fixed-point scheme (so the
X * range is +/- 2, with good accuracy.    The range is to
X * avoid overflowing when the aspect ratio is taken into
X * account.
X */
X#define FIXEDLT1    536870912.0
X
X/* Multiply by this number to convert an unsigned 32-bit long
X * to an angle from 0-2PI.
X */
X#define ANGLE2DOUBLE    (2*PI / 4294967296.)
X
Xstatic int ispow2(long n)
X{
X  return (n == (n & -n));
X}
X
X
X#ifdef XFRACT
Xstatic void lsys_doplus(long n)
X{
X  if (reverse) {
X    if (++angle == maxangle)
X      angle = 0;
X  }
X  else {
X    if (angle)
X      angle--;
X    else
X      angle = dmaxangle;
X  }
X}
X#endif
X
X
X#ifdef XFRACT
X/* This is the same as lsys_doplus, except maxangle is a power of 2. */
Xstatic void lsys_doplus_pow2(long n)
X{
X  if (reverse) {
X    angle++;
X    angle &= dmaxangle;
X  }
X  else {
X    angle--;
X    angle &= dmaxangle;
X  }
X}
X#endif
X
X
X#ifdef XFRACT
Xstatic void lsys_dominus(long n)
X{
X  if (reverse) {
X    if (angle)
X      angle--;
X    else
X      angle = dmaxangle;
X  }
X  else {
X    if (++angle == maxangle)
X      angle = 0;
X  }
X}
X#endif
X
X
X#ifdef XFRACT
Xstatic void lsys_dominus_pow2(long n)
X{
X  if (reverse) {
X    angle--;
X    angle &= dmaxangle;
X  }
X  else {
X    angle++;
X    angle &= dmaxangle;
X  }
X}
X#endif
X
Xstatic void lsys_doslash(long n)
X{
X  if (reverse)
X    realangle -= n;
X  else
X    realangle += n;
X}
X#ifdef XFRACT
X#define lsys_doslash_386 lsys_doslash
X#endif
X
Xstatic void lsys_dobslash(long n)
X{
X  if (reverse)
X    realangle += n;
X  else
X    realangle -= n;
X}
X
X#ifdef XFRACT
X#define lsys_dobslash_386 lsys_dobslash
X#endif
X
Xstatic void lsys_doat(long n)
X{
X  size = multiply(size, n, 19);
X}
X
X#ifdef XFRACT
X#define lsys_doat_386 lsys_doat
X#endif
X
Xstatic void lsys_dopipe(long n)
X{
X  angle += maxangle / 2;
X  angle %= maxangle;
X}
X
X
X#ifdef XFRACT
Xstatic void lsys_dopipe_pow2(long n)
X{
X  angle += maxangle >> 1;
X  angle &= dmaxangle;
X}
X#endif
X
X
X#ifdef XFRACT
Xstatic void lsys_dobang(long n)
X{
X  reverse = ! reverse;
X}
X#endif
X
Xstatic void lsys_dosizedm(long n)
X{
X  double angle = (double) realangle * ANGLE2DOUBLE;
X  double s, c;
X  long fixedsin, fixedcos;
X  FPUsincos(&angle, &s, &c);
X  fixedsin = (long) (s * FIXEDLT1);
X  fixedcos = (long) (c * FIXEDLT1);
X
X  xpos += multiply(multiply(size, aspect, 19), fixedcos, 29);
X  ypos += multiply(size, fixedsin, 29);
X
X/* xpos+=size*aspect*cos(realangle*PI/180);  */
X/* ypos+=size*sin(realangle*PI/180);         */
X  if (xpos>lsys_Xmax) lsys_Xmax=xpos;
X  if (ypos>lsys_Ymax) lsys_Ymax=ypos;
X  if (xpos<lsys_Xmin) lsys_Xmin=xpos;
X  if (ypos<lsys_Ymin) lsys_Ymin=ypos;
X}
X
Xstatic void lsys_dosizegf(long n)
X{
X  xpos += multiply(size, (long) coss[angle], 29);
X  ypos += multiply(size, (long) sins[angle], 29);
X/* xpos+=size*coss[angle];                   */
X/* ypos+=size*sins[angle];                   */
X  if (xpos>lsys_Xmax) lsys_Xmax=xpos;
X  if (ypos>lsys_Ymax) lsys_Ymax=ypos;
X  if (xpos<lsys_Xmin) lsys_Xmin=xpos;
X  if (ypos<lsys_Ymin) lsys_Ymin=ypos;
X}
X
X#ifdef XFRACT
X#define lsys_dosizegf_386 lsys_dosizegf
X#endif
X
Xstatic void lsys_dodrawd(long n)
X{
X  double angle = (double) realangle * ANGLE2DOUBLE;
X  double s, c;
X  long fixedsin, fixedcos;
X  int lastx, lasty;
X  FPUsincos(&angle, &s, &c);
X  fixedsin = (long) (s * FIXEDLT1);
X  fixedcos = (long) (c * FIXEDLT1);
X
X  lastx=(int) (xpos >> 19);
X  lasty=(int) (ypos >> 19);
X  xpos += multiply(multiply(size, aspect, 19), fixedcos, 29);
X  ypos += multiply(size, fixedsin, 29);
X/* xpos+=size*aspect*cos(realangle*PI/180);   */
X/* ypos+=size*sin(realangle*PI/180);          */
X  draw_line(lastx,lasty,(int)(xpos >> 19),(int)(ypos>>19),curcolor);
X}
X
Xstatic void lsys_dodrawm(long n)
X{
X  double angle = (double) realangle * ANGLE2DOUBLE;
X  double s, c;
X  long fixedsin, fixedcos;
X  FPUsincos(&angle, &s, &c);
X  fixedsin = (long) (s * FIXEDLT1);
X  fixedcos = (long) (c * FIXEDLT1);
X
X/* xpos+=size*aspect*cos(realangle*PI/180);   */
X/* ypos+=size*sin(realangle*PI/180);          */
X  xpos += multiply(multiply(size, aspect, 19), fixedcos, 29);
X  ypos += multiply(size, fixedsin, 29);
X}
X
Xstatic void lsys_dodrawg(long n)
X{
X  xpos += multiply(size, (long) coss[angle], 29);
X  ypos += multiply(size, (long) sins[angle], 29);
X/* xpos+=size*coss[angle];                    */
X/* ypos+=size*sins[angle];                    */
X}
X
X#ifdef XFRACT
X#define  lsys_dodrawg_386 lsys_dodrawg
X#endif
X
Xstatic void lsys_dodrawf(long n)
X{
X  int lastx = (int) (xpos >> 19);
X  int lasty = (int) (ypos >> 19);
X  xpos += multiply(size, (long) coss[angle], 29);
X  ypos += multiply(size, (long) sins[angle], 29);
X/* xpos+=size*coss[angle];                    */
X/* ypos+=size*sins[angle];                    */
X  draw_line(lastx,lasty,(int)(xpos>>19),(int)(ypos>>19),curcolor);
X}
X
Xstatic void lsys_dodrawc(long n)
X{
X  curcolor = ((int) n) % colors;
X}
X
Xstatic void lsys_dodrawgt(long n)
X{
X  curcolor -= n;
X  if ((curcolor &= colors-1) == 0)
X    curcolor = colors-1;
X}
X
Xstatic void lsys_dodrawlt(long n)
X{
X  curcolor += n;
X  if ((curcolor &= colors-1) == 0)
X    curcolor = 1;
X}
X
Xstatic double _fastcall getnumber(char far **str)
X{
X   char numstr[30];
X   float ret;
X   int i,root,inverse;
X
X   root=0;
X   inverse=0;
X   strcpy(numstr,"");
X   (*str)++;
X   switch (**str)
X   {
X   case 'q':
X      root=1;
X      (*str)++;
X      break;
X   case 'i':
X      inverse=1;
X      (*str)++;
X      break;
X   }
X   switch (**str)
X   {
X   case 'q':
X      root=1;
X      (*str)++;
X      break;
X   case 'i':
X      inverse=1;
X      (*str)++;
X      break;
X   }
X   i=0;
X   while (**str<='9' && **str>='0' || **str=='.')
X   {
X      numstr[i++]= **str;
X      (*str)++;
X   }
X   (*str)--;
X   numstr[i]=0;
X   ret=atof(numstr);
X   if (root)
X     ret=sqrt(ret);
X   if (inverse)
X     ret = 1/ret;
X   return ret;
X}
X
Xstatic struct lsys_cmd far * _fastcall findsize(struct lsys_cmd far *command, struct lsys_cmd far **rules, int depth)
X{
X   struct lsys_cmd far **rulind;
X   int tran;
X
Xif (overflow)     /* integer math routines overflowed */
X    return NULL;
X
X#ifndef __TURBOC__
X   if (stackavail() < 400) { /* leave some margin for calling subrtns */
X      stackoflow = 1;
X      return NULL;
X      }
X#endif
X
X   while (command->ch && command->ch !=']') {
X      if (! (counter++)) {
X     /* let user know we're not dead */
X     if (thinking(1,"L-System thinking (higher orders take longer)")) {
X        counter--;
X        return NULL;
X     }
X      }
X      tran=0;
X      if (depth) {
X     for(rulind=rules;*rulind;rulind++)
X        if ((*rulind)->ch==command->ch) {
X           tran=1;
X           if (findsize((*rulind)+1,rules,depth-1) == NULL)
X          return(NULL);
X        }
X      }
X      if (!depth || !tran) {
X    if (command->f)
X      (*command->f)(command->n);
X    else if (command->ch == '[') {
X      char saveang,saverev;
X      long savesize,savex,savey;
X      unsigned long saverang;
X
X      saveang=angle;
X      saverev=reverse;
X      savesize=size;
X      saverang=realangle;
X      savex=xpos;
X      savey=ypos;
X      if ((command=findsize(command+1,rules,depth)) == NULL)
X         return(NULL);
X      angle=saveang;
X      reverse=saverev;
X      size=savesize;
X      realangle=saverang;
X      xpos=savex;
X      ypos=savey;
X    }
X      }
X      command++;
X   }
X   return command;
X}
X
Xstatic int _fastcall findscale(struct lsys_cmd far *command, struct lsys_cmd far **rules, int depth)
X{
X   float horiz,vert;
X   double xmin, xmax, ymin, ymax;
X   double locsize;
X   double locaspect;
X   int i;
X   struct lsys_cmd far *fsret;
X   locaspect=screenaspect*xdots/ydots;
X   aspect = FIXEDPT(locaspect);
X   for(i=0;i<maxangle;i++) {
X      sins[i]=(long) ((sin(2*i*PI/maxangle)) * FIXEDLT1);
X      coss[i]=(long) ((locaspect * cos(2*i*PI/maxangle)) * FIXEDLT1);
X   }
X   xpos=ypos=lsys_Xmin=lsys_Xmax=lsys_Ymax=lsys_Ymin=angle=reverse=realangle=counter=0;
X   size=FIXEDPT(1);
X   fsret = findsize(command,rules,depth);
X   thinking(0, NULL); /* erase thinking message if any */
X   xmin = (double) lsys_Xmin / FIXEDMUL;
X   xmax = (double) lsys_Xmax / FIXEDMUL;
X   ymin = (double) lsys_Ymin / FIXEDMUL;
X   ymax = (double) lsys_Ymax / FIXEDMUL;
X   locsize = (double) size / FIXEDMUL;
X   if (fsret == NULL)
X      return 0;
X   if (xmax == xmin)
X      horiz = 1E37;
X   else
X      horiz = (xdots-10)/(xmax-xmin);
X   if (ymax == ymin)
X      vert = 1E37;
X   else
X      vert = (ydots-6) /(ymax-ymin);
X   locsize = (vert<horiz) ? vert : horiz;
X
X   if (horiz == 1E37)
X      xpos = FIXEDPT(xdots/2);
X   else
X      xpos = FIXEDPT(-xmin*(locsize)+5+((xdots-10)-(locsize)*(xmax-xmin))/2);
X   if (vert == 1E37)
X      ypos = FIXEDPT(ydots/2);
X   else
X      ypos = FIXEDPT(-ymin*(locsize)+3+((ydots-6)-(locsize)*(ymax-ymin))/2);
X   size = FIXEDPT(locsize);
X   return 1;
X}
X
Xstatic struct lsys_cmd far * _fastcall drawLSys(struct lsys_cmd far *command,struct lsys_cmd far **rules,int depth)
X{
X   struct lsys_cmd far **rulind;
X   int tran;
X
Xif (overflow)     /* integer math routines overflowed */
X    return NULL;
X
X#ifndef __TURBOC__
X   if (stackavail() < 400) { /* leave some margin for calling subrtns */
X      stackoflow = 1;
X      return NULL;
X      }
X#endif
X
X   while (command->ch && command->ch !=']') {
X      if (!(counter++)) {
X     if (check_key()) {
X        counter--;
X        return NULL;
X     }
X      }
X      tran=0;
X      if (depth) {
X     for(rulind=rules;*rulind;rulind++)
X        if ((*rulind)->ch == command->ch) {
X           tran=1;
X           if (drawLSys((*rulind)+1,rules,depth-1) == NULL)
X          return NULL;
X        }
X      }
X      if (!depth||!tran) {
X    if (command->f)
X      (*command->f)(command->n);
X    else if (command->ch == '[') {
X      char saveang,saverev,savecolor;
X      long savesize,savex,savey;
X      unsigned long saverang;
X
X      saveang=angle;
X      saverev=reverse;
X      savesize=size;
X      saverang=realangle;
X      savex=xpos;
X      savey=ypos;
X      savecolor=curcolor;
X      if ((command=drawLSys(command+1,rules,depth)) == NULL)
X         return(NULL);
X      angle=saveang;
X      reverse=saverev;
X      size=savesize;
X      realangle=saverang;
X      xpos=savex;
X      ypos=savey;
X      curcolor=savecolor;
X    }
X      }
X      command++;
X   }
X   return command;
X}
X
X#define MAXRULES 27 /* this limits rules to 25 */
Xstatic char far *ruleptrs[MAXRULES];
Xstatic struct lsys_cmd far *rules2[MAXRULES];
X
Xstatic int _fastcall readLSystemFile(char *str)
X{
X   int c;
X   char far **rulind;
X   int err=0;
X   int linenum,check=0;
X   char inline[161],fixed[161],*word;
X   FILE *infile;
X   char msgbuf[481]; /* enough for 6 full lines */
X
X   if (find_file_item(LFileName,str,&infile) < 0)
X      return -1;
X   while ((c = fgetc(infile)) != '{')
X      if (c == EOF) return -1;
X
X   maxangle=0;
X   for(linenum=0;linenum<MAXRULES;++linenum) ruleptrs[linenum]=NULL;
X   rulind= &ruleptrs[1];
X   msgbuf[0]=linenum=0;
X
X   while(fgets(inline,160,infile))  /* Max line length 160 chars */
X   {
X      linenum++;
X      if ((word = strchr(inline,';'))) /* strip comment */
X     *word = 0;
X      strlwr(inline);
X
X      if (strspn(inline," \t\n") < strlen(inline)) /* not a blank line */
X      {
X     word=strtok(inline," =\t\n");
X     if (!strcmp(word,"axiom"))
X     {
X        save_rule(strtok(NULL," \t\n"),&ruleptrs[0]);
X        check=1;
X     }
X     else if (!strcmp(word,"angle"))
X     {
X        maxangle=atoi(strtok(NULL," \t\n"));
X        dmaxangle = maxangle - 1;
X        check=1;
X     }
X     else if (!strcmp(word,"}"))
X        break;
X     else if (strlen(word)==1)
X     {
X        char *tok;
X        tok = strtok(NULL, " \t\n");
X        strcpy(fixed, word);
X        if (tok != NULL) {     /* Some strcat's die if they cat with NULL */
X        strcat(fixed, tok);
X        }
X        save_rule(fixed, rulind++);
X        check=1;
X     }
X     else
X        if (err<6)
X        {
X           sprintf(&msgbuf[strlen(msgbuf)],
X               "Syntax error line %d: %s\n",linenum,word);
X           ++err;
X        }
X     if (check)
X     {
X        check=0;
X        if(word=strtok(NULL," \t\n"))
X           if (err<6)
X           {
X          sprintf(&msgbuf[strlen(msgbuf)],
X             "Extra text after command line %d: %s\n",linenum,word);
X          ++err;
X           }
X     }
X      }
X   }
X   fclose(infile);
X   if (!ruleptrs[0] && err<6)
X   {
X      strcat(msgbuf,"Error:  no axiom\n");
X      ++err;
X   }
X   if ((maxangle<3||maxangle>50) && err<6)
X   {
X      strcat(msgbuf,"Error:  illegal or missing angle\n");
X      ++err;
X   }
X   if (err)
X   {
X      msgbuf[strlen(msgbuf)-1]=0; /* strip trailing \n */
X      stopmsg(0,msgbuf);
X      return -1;
X   }
X   *rulind=NULL;
X   return 0;
X}
X
Xstatic char loaded=0;
X
Xint Lsystem()
X{
X   int order;
X   char far **rulesc;
X   struct lsys_cmd far **sc;
X
X   if ( (!loaded) && LLoad())
X     return -1;
X
X   overflow = 0;        /* reset integer math overflow flag */
X
X   order=param[0];
X   if (order<=0)
X     order=0;
X   stackoflow = 0;
X
X   sc = rules2;
X   for (rulesc = ruleptrs; *rulesc; rulesc++)
X     *sc++ = SizeTransform(*rulesc);
X   *sc = NULL;
X
X   if (findscale(rules2[0], &rules2[1], order)) {
X      realangle = angle = reverse = 0;
X
X      free_lcmds();
X      sc = rules2;
X      for (rulesc = ruleptrs; *rulesc; rulesc++)
X    *sc++ = DrawTransform(*rulesc);
X      *sc = NULL;
X
X      /* !! HOW ABOUT A BETTER WAY OF PICKING THE DEFAULT DRAWING COLOR */
X      if ((curcolor=15) > colors) curcolor=colors-1;
X      drawLSys(rules2[0], &rules2[1], order);
X   }
X   if (stackoflow)
X   {
X      static char far msg[]={"insufficient memory, try a lower order"};
X      stopmsg(0,msg);
X   }
X   if (overflow) {
X      static char far msg[]={"Integer math routines failed, try a lower order"};
X      stopmsg(0,msg);
X      }
X   free_rules_mem();
X   free_lcmds();
X   loaded=0;
X   return 0;
X}
X
Xint LLoad()
X{
X   char i;
X   if (readLSystemFile(LName)) { /* error occurred */
X      free_rules_mem();
X      loaded=0;
X      return -1;
X   }
X   for(i=0;i<maxangle;i++) {
X      sins[i]=(long) ((sin(2*i*PI/maxangle)) * FIXEDLT1);
X      coss[i]=(long) (((double) aspect / (double) FIXEDMUL * cos(2*i*PI/maxangle)) * FIXEDLT1);
X   }
X   loaded=1;
X   return 0;
X}
X
Xstatic void _fastcall free_rules_mem()
X{
X   int i;
X   for(i=0;i<MAXRULES;++i)
X      if(ruleptrs[i]) farmemfree(ruleptrs[i]);
X}
X
Xstatic int _fastcall save_rule(char *rule,char far **saveptr)
X{
X   int i;
X   char far *tmpfar;
X   i=strlen(rule)+1;
X   if((tmpfar=farmemalloc((long)i))==NULL) {
X       stackoflow = 1;
X       return -1;
X       }
X   *saveptr=tmpfar;
X   while(--i>=0) *(tmpfar++)= *(rule++);
X   return 0;
X}
X
Xstatic struct lsys_cmd far *SizeTransform(char far *s)
X{
X  struct lsys_cmd far *ret;
X  struct lsys_cmd far *doub;
X  int maxval = 10;
X  int n = 0;
X  void (*f)(long);
X  long num;
X
X  void (*plus)(long) = (ispow2(maxangle)) ? lsys_doplus_pow2 : lsys_doplus;
X  void (*minus)(long) = (ispow2(maxangle)) ? lsys_dominus_pow2 : lsys_dominus;
X  void (*pipe)(long) = (ispow2(maxangle)) ? lsys_dopipe_pow2 : lsys_dopipe;
X
X  void (*slash)(long) =  (cpu == 386) ? lsys_doslash_386 : lsys_doslash;
X  void (*bslash)(long) = (cpu == 386) ? lsys_dobslash_386 : lsys_dobslash;
X  void (*at)(long) =     (cpu == 386) ? lsys_doat_386 : lsys_doat;
X  void (*dogf)(long) =   (cpu == 386) ? lsys_dosizegf_386 : lsys_dosizegf;
X
X  ret = (struct lsys_cmd far *) farmemalloc((long) maxval * sizeof(struct lsys_cmd));
X  if (ret == NULL) {
X       stackoflow = 1;
X       return NULL;
X       }
X  while (*s) {
X    f = NULL;
X    num = 0;
X    ret[n].ch = *s;
X    switch (*s) {
X      case '+': f = plus;            break;
X      case '-': f = minus;           break;
X      case '/': f = slash;           num = (long) (getnumber(&s) * 11930465L);    break;
X      case '\\': f = bslash;         num = (long) (getnumber(&s) * 11930465L);    break;
X      case '@': f = at;              num = FIXEDPT(getnumber(&s));    break;
X      case '|': f = pipe;            break;
X      case '!': f = lsys_dobang;     break;
X      case 'd':
X      case 'm': f = lsys_dosizedm;   break;
X      case 'g':
X      case 'f': f = dogf;       break;
X      case '[': num = 1;        break;
X      case ']': num = 2;        break;
X      default:
X    num = 3;
X    break;
X    }
X    ret[n].f = f;
X    ret[n].n = num;
X    if (++n == maxval) {
X      doub = (struct lsys_cmd far *) farmemalloc((long) maxval*2*sizeof(struct lsys_cmd));
X      if (doub == NULL) {
X         farmemfree(ret);
X         stackoflow = 1;
X         return NULL;
X         }
X      far_memcpy(doub, ret, maxval*sizeof(struct lsys_cmd));
X      farmemfree(ret);
X      ret = doub;
X      maxval <<= 1;
X    }
X    s++;
X  }
X  ret[n].ch = 0;
X  ret[n].f = NULL;
X  ret[n].n = 0;
X  n++;
X
X  doub = (struct lsys_cmd far *) farmemalloc((long) n*sizeof(struct lsys_cmd));
X  if (doub == NULL) {
X       farmemfree(ret);
X       stackoflow = 1;
X       return NULL;
X       }
X  far_memcpy(doub, ret, n*sizeof(struct lsys_cmd));
X  farmemfree(ret);
X  return doub;
X}
X
Xstatic struct lsys_cmd far *DrawTransform(char far *s)
X{
X  struct lsys_cmd far *ret;
X  struct lsys_cmd far *doub;
X  int maxval = 10;
X  int n = 0;
X  void (*f)(long);
X  long num;
X
X  void (*plus)(long) = (ispow2(maxangle)) ? lsys_doplus_pow2 : lsys_doplus;
X  void (*minus)(long) = (ispow2(maxangle)) ? lsys_dominus_pow2 : lsys_dominus;
X  void (*pipe)(long) = (ispow2(maxangle)) ? lsys_dopipe_pow2 : lsys_dopipe;
X
X  void (*slash)(long) =  (cpu == 386) ? lsys_doslash_386 : lsys_doslash;
X  void (*bslash)(long) = (cpu == 386) ? lsys_dobslash_386 : lsys_dobslash;
X  void (*at)(long) =     (cpu == 386) ? lsys_doat_386 : lsys_doat;
X  void (*drawg)(long) =  (cpu == 386) ? lsys_dodrawg_386 : lsys_dodrawg;
X
X  ret = (struct lsys_cmd far *) farmemalloc((long) maxval * sizeof(struct lsys_cmd));
X  if (ret == NULL) {
X       stackoflow = 1;
X       return NULL;
X       }
X  while (*s) {
X    f = NULL;
X    num = 0;
X    ret[n].ch = *s;
X    switch (*s) {
X      case '+': f = plus;            break;
X      case '-': f = minus;           break;
X      case '/': f = slash;           num = (long) (getnumber(&s) * 11930465L);    break;
X      case '\\': f = bslash;         num = (long) (getnumber(&s) * 11930465L);    break;
X      case '@': f = at;              num = FIXEDPT(getnumber(&s));    break;
X      case '|': f = pipe;            break;
X      case '!': f = lsys_dobang;     break;
X      case 'd': f = lsys_dodrawd;    break;
X      case 'm': f = lsys_dodrawm;    break;
X      case 'g': f = drawg;           break;
X      case 'f': f = lsys_dodrawf;    break;
X      case 'c': f = lsys_dodrawc;    num = getnumber(&s);    break;
X      case '<': f = lsys_dodrawlt;   num = getnumber(&s);    break;
X      case '>': f = lsys_dodrawgt;   num = getnumber(&s);    break;
X      case '[': num = 1;        break;
X      case ']': num = 2;        break;
X      default:
X    num = 3;
X    break;
X    }
X    ret[n].f = f;
X    ret[n].n = num;
X    if (++n == maxval) {
X      doub = (struct lsys_cmd far *) farmemalloc((long) maxval*2*sizeof(struct lsys_cmd));
X      if (doub == NULL) {
X           farmemfree(ret);
X           stackoflow = 1;
X           return NULL;
X           }
X      far_memcpy(doub, ret, maxval*sizeof(struct lsys_cmd));
X      farmemfree(ret);
X      ret = doub;
X      maxval <<= 1;
X    }
X    s++;
X  }
X  ret[n].ch = 0;
X  ret[n].f = NULL;
X  ret[n].n = 0;
X  n++;
X
X  doub = (struct lsys_cmd far *) farmemalloc((long) n*sizeof(struct lsys_cmd));
X  if (doub == NULL) {
X       farmemfree(ret);
X       stackoflow = 1;
X       return NULL;
X       }
X  far_memcpy(doub, ret, n*sizeof(struct lsys_cmd));
X  farmemfree(ret);
X  return doub;
X}
X
Xstatic void free_lcmds()
X{
X  struct lsys_cmd far **sc = rules2;
X
X  while (*sc)
X    farmemfree(*sc++);
X}
X
SHAR_EOF
$TOUCH -am 1028230093 lsys.c &&
chmod 0644 lsys.c ||
echo "restore of lsys.c failed"
set `wc -c lsys.c`;Wc_c=$1
if test "$Wc_c" != "21423"; then
    echo original size 21423, current size $Wc_c
fi
# ============= miscfrac.c ==============
echo "x - extracting miscfrac.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > miscfrac.c &&
X/*
X
XMiscellaneous fractal-specific code (formerly in CALCFRAC.C)
X
X
X*/
X
X#include <stdio.h>
X#include <string.h>
X#include <stdlib.h>
X#include <float.h>
X#ifndef XFRACT
X#include <dos.h>
X#endif
X#include <limits.h>
X#include "fractint.h"
X#include "fractype.h"
X#include "mpmath.h"
X#include "targa_lc.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic void set_Plasma_palette(void);
Xstatic U16 _fastcall adjust(int xa,int ya,int x,int y,int xb,int yb);
Xstatic void _fastcall subDivide(int x1,int y1,int x2,int y2);
Xstatic int _fastcall new_subD (int x1,int y1,int x2,int y2, int recur);
Xstatic void verhulst(void);
Xstatic void Bif_Period_Init(void);
Xstatic int  _fastcall Bif_Periodic(int);
Xstatic void set_Cellular_palette(void);
X
XU16  (_fastcall *getpix)(int,int)  = (U16(_fastcall *)(int,int))getcolor;
X
Xextern int resuming;
Xextern char stdcalcmode;
Xextern int color, oldcolor, row, col, passes;
Xextern int ixstart, ixstop, iystart, iystop;
Xextern _CMPLX init,tmp,old,new,saved;
Xextern _CMPLX parm,parm2;
X
Xextern double far *dx0, far *dy0;
Xextern double far *dx1, far *dy1;
Xextern long far *lx0, far *ly0;
Xextern long far *lx1, far *ly1;
Xextern long delx, dely;
Xextern double deltaX, deltaY;
Xextern int sxoffs, syoffs, sxdots, sydots;
Xextern int xdots, ydots;
Xextern int maxit, inside, colors, andcolor, dotmode;
Xextern double param[];
Xextern int rflag, rseed;
Xextern int pot16bit, potflag;
Xextern int diskvideo;
Xextern int bitshift;
Xextern long fudge;
Xextern int show_orbit;
Xextern int periodicitycheck, integerfractal;
Xextern _LCMPLX linit;
Xextern _LCMPLX ltmp;
Xextern _LCMPLX lold,lnew,lparm,lparm2;
Xextern long ltempsqrx,ltempsqry;
Xextern double tempsqrx,tempsqry;
Xextern int overflow;
Xextern int kbdcount, max_kbdcount;
Xextern int reset_periodicity;
Xextern int calc_status;
Xextern int iterations, invert;
Xextern int save_release;
Xextern int LogFlag;
Xextern int (calctype());
Xextern int realcolor;
Xextern int nxtscreenflag;
Xextern double magnitude, rqlim, rqlim2, rqlim_save;
Xextern long lmagnitud, llimit, llimit2, lclosenuff, l16triglim;
Xextern int orbit_color, orbit_ptr, showdot;
Xextern int debugflag;
X
X#ifndef XFRACT
Xextern char dstack[4096];
Xextern char boxy[4096];
X#else
XBYTE dstack[4096];
X#endif
X
Xtypedef void (_fastcall *PLOT)(int,int,int);
X
X/***************** standalone engine for "test" ********************/
X
Xint test()
X{
X   int startrow,startpass,numpasses;
X   startrow = startpass = 0;
X   if (resuming)
X   {
X      start_resume();
X      get_resume(sizeof(int),&startrow,sizeof(int),&startpass,0);
X      end_resume();
X   }
X   if(teststart()) /* assume it was stand-alone, doesn't want passes logic */
X      return(0);
X   numpasses = (stdcalcmode == '1') ? 0 : 1;
X   for (passes=startpass; passes <= numpasses ; passes++)
X   {
X      for (row = startrow; row <= iystop; row=row+1+numpasses)
X      {
X     register int col;
X     for (col = 0; col <= ixstop; col++)       /* look at each point on screen */
X     {
X        register color;
X        init.y = dy0[row]+dy1[col];
X        init.x = dx0[col]+dx1[row];
X        if(check_key())
X        {
X           testend();
X           alloc_resume(20,1);
X           put_resume(sizeof(int),&row,sizeof(int),&passes,0);
X           return(-1);
X        }
X        color = testpt(init.x,init.y,parm.x,parm.y,maxit,inside);
X        if (color >= colors) /* avoid trouble if color is 0 */
X           if (colors < 16)
X          color &= andcolor;
X           else
X          color = ((color-1) % andcolor) + 1; /* skip color zero */
X        (*plot)(col,row,color);
X        if(numpasses && (passes == 0))
X           (*plot)(col,row+1,color);
X     }
X      }
X      startrow = passes + 1;
X   }
X   testend();
X   return(0);
X}
X
X/***************** standalone engine for "plasma" ********************/
X
Xstatic int iparmx;      /* iparmx = parm.x * 16 */
Xstatic int shiftvalue;  /* shift based on #colors */
Xextern int max_colors;
Xstatic int recur1=1;
Xstatic int pcolors;
Xstatic int recur_level = 0;
XU16 max_plasma;
X
X/* returns a random 16 bit value that is never 0 */
XU16 rand16()
X{
X   U16 value;
X   value = rand15();
X   value <<= 1;
X   value += rand15()&1;
X   if(value < 1)
X      value = 1;
X   return(value);
X}
X
Xvoid _fastcall putpot(int x, int y, U16 color)
X{
X   if(color < 1)
X      color = 1;
X   putcolor(x, y, color >> 8 ? color >> 8 : 1);  /* don't write 0 */
X   /* we don't write this if dotmode==11 because the above putcolor
X         was already a "writedisk" in that case */
X   if (dotmode != 11)
X      writedisk(x+sxoffs,y+syoffs,color >> 8);    /* upper 8 bits */
X   writedisk(x+sxoffs,y+sydots+syoffs,color&255); /* lower 8 bits */
X}
X
XU16 _fastcall getpot(int x, int y)
X{
X   U16 color;
X
X   color = (U16)readdisk(x+sxoffs,y+syoffs);
X   color = (color << 8) + (U16) readdisk(x+sxoffs,y+sydots+syoffs);
X   return(color);
X}
X
X
Xtypedef struct palett
X{
X   BYTE red;
X   BYTE green;
X   BYTE blue;
X}
XPalettetype;
X
Xextern Palettetype dacbox[256];
Xstatic int plasma_check;                        /* to limit kbd checking */
X
Xstatic U16 _fastcall adjust(int xa,int ya,int x,int y,int xb,int yb)
X{
X   S32 pseudorandom;
X   pseudorandom = ((S32)iparmx)*((rand15()-16383));
X/*   pseudorandom = pseudorandom*(abs(xa-xb)+abs(ya-yb));*/
X   pseudorandom = pseudorandom * recur1;
X   pseudorandom = pseudorandom >> shiftvalue;
X   pseudorandom = (((S32)getpix(xa,ya)+(S32)getpix(xb,yb)+1)>>1)+pseudorandom;
X   if(max_plasma == 0)
X   {
X      if (pseudorandom >= pcolors)
X         pseudorandom = pcolors-1;
X   }
X   else if (pseudorandom >= max_plasma)
X      pseudorandom = max_plasma;
X   if(pseudorandom < 1)
X      pseudorandom = 1;
X   plot(x,y,(U16)pseudorandom);
X   return((U16)pseudorandom);
X}
X
X
Xstatic int _fastcall new_subD (int x1,int y1,int x2,int y2, int recur)
X{
X   int x,y;
X   int nx1;
X   int nx;
X   int ny1, ny;
X   S32 i, v;
X
X   struct sub {
X      BYTE t; /* top of stack */
X      int v[16]; /* subdivided value */
X      BYTE r[16];  /* recursion level */
X   };
X
X   static struct sub subx, suby;
X
X   /*
X   recur1=1;
X   for (i=1;i<=recur;i++)
X      recur1 = recur1 * 2;
X   recur1=320/recur1;
X   */
X   recur1 = 320L >> recur;
X   suby.t = 2;
X   ny   = suby.v[0] = y2;
X   ny1 = suby.v[2] = y1;
X   suby.r[0] = suby.r[2] = 0;
X   suby.r[1] = 1;
X   y = suby.v[1] = (ny1 + ny) >> 1;
X
X   while (suby.t >= 1)
X   {
X      if ((++plasma_check & 0x0f) == 1)
X         if(check_key())
X         {
X/*   naah, we don't want to flush this key!!!
X                        getch();
X            */
X            plasma_check--;
X            return(1);
X         }
X      while (suby.r[suby.t-1] < recur)
X      {
X         /*     1.  Create new entry at top of the stack  */
X         /*     2.  Copy old top value to new top value.  */
X         /*            This is largest y value.           */
X         /*     3.  Smallest y is now old mid point       */
X         /*     4.  Set new mid point recursion level     */
X         /*     5.  New mid point value is average        */
X         /*            of largest and smallest            */
X
X         suby.t++;
X         ny1  = suby.v[suby.t] = suby.v[suby.t-1];
X         ny   = suby.v[suby.t-2];
X         suby.r[suby.t] = suby.r[suby.t-1];
X         y    = suby.v[suby.t-1]   = (ny1 + ny) >> 1;
X         suby.r[suby.t-1]   = (int)max(suby.r[suby.t], suby.r[suby.t-2])+1;
X      }
X      subx.t = 2;
X      nx  = subx.v[0] = x2;
X      nx1 = subx.v[2] = x1;
X      subx.r[0] = subx.r[2] = 0;
X      subx.r[1] = 1;
X      x = subx.v[1] = (nx1 + nx) >> 1;
X
X      while (subx.t >= 1)
X      {
X         while (subx.r[subx.t-1] < recur)
X         {
X            subx.t++; /* move the top ofthe stack up 1 */
X            nx1  = subx.v[subx.t] = subx.v[subx.t-1];
X            nx   = subx.v[subx.t-2];
X            subx.r[subx.t] = subx.r[subx.t-1];
X            x    = subx.v[subx.t-1]   = (nx1 + nx) >> 1;
X            subx.r[subx.t-1]   = (int)max(subx.r[subx.t],
X                subx.r[subx.t-2])+1;
X         }
X
X         if ((i = getpix(nx, y)) == 0)
X            i = adjust(nx,ny1,nx,y ,nx,ny);
X         v = i;
X         if ((i = getpix(x, ny)) == 0)
X            i = adjust(nx1,ny,x ,ny,nx,ny);
X         v += i;
X         if(getpix(x,y) == 0)
X         {
X            if ((i = getpix(x, ny1)) == 0)
X               i = adjust(nx1,ny1,x ,ny1,nx,ny1);
X            v += i;
X            if ((i = getpix(nx1, y)) == 0)
X               i = adjust(nx1,ny1,nx1,y ,nx1,ny);
X            v += i;
X            plot(x,y,(U16)((v + 2) >> 2));
X         }
X
X         if (subx.r[subx.t-1] == recur) subx.t = subx.t - 2;
X      }
X
X      if (suby.r[suby.t-1] == recur) suby.t = suby.t - 2;
X   }
X   return(0);
X}
X
Xstatic void _fastcall subDivide(int x1,int y1,int x2,int y2)
X{
X   int x,y;
X   S32 v,i;
X   if ((++plasma_check & 0x7f) == 1)
X      if(check_key())
X      {
X         plasma_check--;
X         return;
X      }
X   if(x2-x1<2 && y2-y1<2)
X      return;
X   recur_level++;
X   recur1 = 320L >> recur_level;
X
X   x = (x1+x2)>>1;
X   y = (y1+y2)>>1;
X   if((v=getpix(x,y1)) == 0)
X      v=adjust(x1,y1,x ,y1,x2,y1);
X   i=v;
X   if((v=getpix(x2,y)) == 0)
X      v=adjust(x2,y1,x2,y ,x2,y2);
X   i+=v;
X   if((v=getpix(x,y2)) == 0)
X      v=adjust(x1,y2,x ,y2,x2,y2);
X   i+=v;
X   if((v=getpix(x1,y)) == 0)
X      v=adjust(x1,y1,x1,y ,x1,y2);
X   i+=v;
X
X   if(getpix(x,y) == 0)
X      plot(x,y,(U16)((i+2)>>2));
X
X   subDivide(x1,y1,x ,y);
X   subDivide(x ,y1,x2,y);
X   subDivide(x ,y ,x2,y2);
X   subDivide(x1,y ,x ,y2);
X   recur_level--;
X}
X
Xint plasma()
X{
X   int i,k, n;
X   U16 rnd[4];
X   int OldPotFlag, OldPot16bit;
X
X   plasma_check = 0;
X
X   if(colors < 4) {
X      static char far plasmamsg[]={
X         "\
XPlasma Clouds can currently only be run in a 4-or-more-color video\n\
Xmode (and color-cycled only on VGA adapters [or EGA adapters in their\n\
X640x350x16 mode])."      };
X      stopmsg(0,plasmamsg);
X      return(-1);
X   }
X   iparmx = param[0] * 8;
X   if (parm.x <= 0.0) iparmx = 16;
X   if (parm.x >= 100) iparmx = 800;
X
X   if ((!rflag) && param[2] == 1)
X      --rseed;
X   if (param[2] != 0 && param[2] != 1)
X      rseed = param[2];
X   max_plasma = (U16)param[3];  /* max_plasma is used as a flag for potential */
X
X   if(max_plasma != 0)
X   {
X      if (pot_startdisk() >= 0)
X      {
X     max_plasma = (U16)(1L << 16) -1;
X     plot    = (PLOT)putpot;
X     getpix =  getpot;
X     OldPotFlag = potflag;
X     OldPot16bit = pot16bit;
X      }
X      else
X      {
X     max_plasma = 0;    /* can't do potential (startdisk failed) */
X     param[3]   = 0;
X     plot    = putcolor;
X       getpix  = (U16(_fastcall *)(int,int))getcolor;
X      }
X   }
X   else
X   {
X      plot    = putcolor;
X      getpix  = (U16(_fastcall *)(int,int))getcolor;
X   }
X   srand(rseed);
X   if (!rflag) ++rseed;
X
X   if (colors == 256)                   /* set the (256-color) palette */
X      set_Plasma_palette();             /* skip this if < 256 colors */
X
X   if (colors > 16)
X      shiftvalue = 18;
X   else
X   {
X      if (colors > 4)
X         shiftvalue = 22;
X      else
X      {
X         if (colors > 2)
X            shiftvalue = 24;
X         else
X            shiftvalue = 25;
X      }
X   }
X   if(max_plasma != 0)
X      shiftvalue = 10;
X
X   if(max_plasma == 0)
X   {
X      pcolors = min(colors, max_colors);
X      for(n = 0; n < 4; n++)
X         rnd[n] = 1+(((rand15()/pcolors)*(pcolors-1))>>(shiftvalue-11));
X   }
X   else
X      for(n = 0; n < 4; n++)
X         rnd[n] = rand16();
X   plot(      0,      0,  rnd[0]);
X   plot(xdots-1,      0,  rnd[1]);
X   plot(xdots-1,ydots-1,  rnd[2]);
X   plot(      0,ydots-1,  rnd[3]);
X
X   recur_level = 0;
X   if (param[1] == 0)
X      subDivide(0,0,xdots-1,ydots-1);
X   else
X   {
X      recur1 = i = k = 1;
X      while(new_subD(0,0,xdots-1,ydots-1,i)==0)
X      {
X         k = k * 2;
X         if (k  >(int)max(xdots-1,ydots-1))
X            break;
X         if (check_key())
X         {
X            n = 1;
X            goto done;
X         }
X         i++;
X      }
X   }
X   if (! check_key())
X      n = 0;
X   else
X      n = 1;
X   done:
X   if(max_plasma != 0)
X   {
X      potflag = OldPotFlag;
X      pot16bit = OldPot16bit;
X   }
X   plot    = putcolor;
X   getpix  = (U16(_fastcall *)(int,int))getcolor;
X   return(n);
X}
X
Xstatic void set_Plasma_palette()
X{
X   extern char far *mapdacbox;
X   static Palettetype Red    = {
X      63, 0, 0      };
X   static Palettetype Green  = {
X      0,63, 0      };
X   static Palettetype Blue   = {
X      0, 0,63      };
X   int i;
X
X   if (mapdacbox) return;               /* map= specified */
X
X   dacbox[0].red  = 0 ;
X   dacbox[0].green= 0 ;
X   dacbox[0].blue = 0 ;
X   for(i=1;i<=85;i++)
X   {
X      dacbox[i].red       = (i*Green.red   + (86-i)*Blue.red)/85;
X      dacbox[i].green     = (i*Green.green + (86-i)*Blue.green)/85;
X      dacbox[i].blue      = (i*Green.blue  + (86-i)*Blue.blue)/85;
X
X      dacbox[i+85].red    = (i*Red.red   + (86-i)*Green.red)/85;
X      dacbox[i+85].green  = (i*Red.green + (86-i)*Green.green)/85;
X      dacbox[i+85].blue   = (i*Red.blue  + (86-i)*Green.blue)/85;
X
X      dacbox[i+170].red   = (i*Blue.red   + (86-i)*Red.red)/85;
X      dacbox[i+170].green = (i*Blue.green + (86-i)*Red.green)/85;
X      dacbox[i+170].blue  = (i*Blue.blue  + (86-i)*Red.blue)/85;
X   }
X   SetTgaColors();      /* TARGA 3 June 89  j mclain */
X   spindac(0,1);
X}
X
X
X/***************** standalone engine for "diffusion" ********************/
X
X#define RANDOM(x)  (rand()%(x))
X
X/* This constant assumes that rand() returns a value from 0 to 32676 */
X#define FOURPI  (long)(4*PI*(double)(1L << 16))
X
Xint diffusion()
X{
X   int xmax,ymax,xmin,ymin;     /* Current maximum coordinates */
X   int border;   /* Distance between release point and fractal */
X   int mode;     /* Determines diffusion type:  0 = central (classic) */
X                 /*                             1 = falling particles */
X                 /*                             2 = square cavity     */
X   int i;
X   double cosine,sine,angle;
X   long lcosine,lsine;
X   int x,y;
X   float r, radius, f_tmp;
X   extern char floatflag;
X
X   if (diskvideo)
X      notdiskmsg();
X
X   bitshift = 16;
X   fudge = 1L << 16;
X
X   border = param[0];
X   mode = param[1];
X   if (mode > 2)
X      mode=0;
X
X   if (border <= 0)
X      border = 10;
X
X   srand(rseed);
X   if (!rflag) ++rseed;
X
X   if (mode == 0) {
X      xmax = xdots / 2 + border;  /* Initial box */
X      xmin = xdots / 2 - border;
X      ymax = ydots / 2 + border;
X      ymin = ydots / 2 - border;
X   }
X   if (mode == 1) {
X      xmax = xdots / 2 + border;  /* Initial box */
X      xmin = xdots / 2 - border;
X      ymin = ydots - 20;
X   }
X   if (mode == 2) {
X      if (xdots>ydots)
X         radius = ydots - 5;
X      else
X         radius = xdots - 5;
X   }
X   if (resuming) /* restore worklist, if we can't the above will stay in place */
X   {
X      start_resume();
X      if (mode != 2)
X         get_resume(sizeof(int),&xmax,sizeof(int),&xmin,sizeof(int),&ymax,
X             sizeof(int),&ymin,0);
X      else
X         get_resume(sizeof(int),&xmax,sizeof(int),&xmin,sizeof(int),&ymax,
X             sizeof(int),&radius,0);
X      end_resume();
X   }
X
X   if (mode==0)
X      putcolor(xdots / 2, ydots / 2,RANDOM(colors-1)+1);  /* Seed point */
X
X   if (mode==1)
X      for (i=0;i<=xdots;i++)
X         putcolor(i,ydots-1,colors-1);
X
X   if (mode==2){
X      if (xdots>ydots){
X         for (i=0;i<ydots;i++){
X            putcolor(xdots/2-ydots/2 , i , colors-1);
X            putcolor(xdots/2+ydots/2 , i , colors-1);
X            putcolor(xdots/2-ydots/2+i , 0 , colors-1);
X            putcolor(xdots/2-ydots/2+i , ydots-1 , colors-1);
X         }
X      }
X      else {
X         for (i=0;i<xdots;i++){
X            putcolor(0 , ydots/2-xdots/2+i , colors-1);
X            putcolor(xdots-1 , ydots/2-xdots/2+i , colors-1);
X            putcolor(i , ydots/2-xdots/2 , colors-1);
X            putcolor(i , ydots/2+xdots/2 , colors-1);
X         }
X      }
X   }
X
X   while (1)
X   {
X      /* Release new point on circle just inside the box */
X
X      if (mode==0)
X      {
X         if (floatflag)
X         {
X            angle=2*(double)rand()/(RAND_MAX/PI);
X            FPUsincos(&angle,&sine,&cosine);
X            x = cosine*(xmax-xmin) + xdots;
X            y = sine  *(ymax-ymin) + ydots;
X         }
X         else
X         {
X            SinCos086(multiply((long)rand15(),FOURPI,16),&lsine,&lcosine);
X            x = (lcosine*(long)(xmax-xmin) >> 16) + xdots;
X            y = (lsine  *(long)(ymax-ymin) >> 16) + ydots;
X         }
X
X         x = x >> 1; /* divide by 2 */
X         y = y >> 1;
X      }
X      if (mode==1)
X      {
X         y=ymin;
X         x=RANDOM(xmax-xmin) + (xdots-xmax+xmin)/2;
X      }
X      if (mode==2)
X      {
X         if (floatflag)
X         {
X            angle=2*(double)rand()/(RAND_MAX/PI);
X            FPUsincos(&angle,&sine,&cosine);
X            x = cosine*radius + xdots;
X            y = sine  *radius + ydots;
X         }
X         else
X         {
X            SinCos086(multiply((long)rand15(),FOURPI,16),&lsine,&lcosine);
X            x = (lcosine*(long)(radius) >> 16) + xdots;
X            y = (lsine  *(long)(radius) >> 16) + ydots;
X         }
X         x = x >> 1;
X         y = y >> 1;
X      }
X      /* Loop as long as the point (x,y) is surrounded by color 0 */
X      /* on all eight sides                                       */
X      while((getcolor(x+1,y+1) == 0) && (getcolor(x+1,y) == 0) &&
X          (getcolor(x+1,y-1) == 0) && (getcolor(x  ,y+1) == 0) &&
X          (getcolor(x  ,y-1) == 0) && (getcolor(x-1,y+1) == 0) &&
X          (getcolor(x-1,y) == 0) && (getcolor(x-1,y-1) == 0))
X      {
X         /* Erase moving point */
X         if (show_orbit)
X            putcolor(x,y,0);
X
X         /* Make sure point is inside the box (if mode==0)*/
X         if (mode==0){
X            if (x==xmax)
X               x--;
X            else if (x==xmin)
X               x++;
X            if (y==ymax)
X               y--;
X            else if (y==ymin)
X               y++;
X         }
X
X         if (mode==1)
X         {
X            if (x>xdots-2)
X               x--;
X            else if (x<1)
X               x++;
X            if (y<ymin)
X               y++;
X         }
X
X         /* Take one random step */
X         x += RANDOM(3) - 1;
X         y += RANDOM(3) - 1;
X
X         /* Check keyboard */
X         if ((++plasma_check & 0x7f) == 1)
X            if(check_key())
X            {
X               alloc_resume(20,1);
X               if (mode!=2)
X                  put_resume(sizeof(int),&xmax,sizeof(int),&xmin, sizeof(int),&ymax,
X                      sizeof(int),&ymin,0);
X               else
X                  put_resume(sizeof(int),&xmax,sizeof(int),&xmin, sizeof(int),&ymax,
X                      sizeof(int),&radius,0);
X
X               plasma_check--;
X               return 1;
X            }
X
X         /* Show the moving point */
X         if (show_orbit)
X            putcolor(x,y,RANDOM(colors-1)+1);
X
X      }
X      putcolor(x,y,RANDOM(colors-1)+1);
X
X      /* Is point too close to the edge? */
X
X      if (mode==0)
X      {
X         if (((x+border)>xmax) || ((x-border)<xmin)
X             || ((y-border)<ymin) || ((y+border)>ymax))
X         {
X            /* Increase box size, but not past the edge of the screen */
X            if (ymin != 1)
X            {
X               ymin--;
X               ymax++;
X            }
X            if (xmin != 1)
X            {
X               xmin--;
X               xmax++;
X            }
X            if ((ymin==1) || (xmin==1))
X               return 0;
X         }
X      }
X      if (mode==1)
X      {
X         if (y < ymin+5)
X            ymin = y - 5;
X         if (ymin<2)
X            return 0;
X      }
X      if (mode==2)
X      {
X         if (abs(x-xdots/2)<5 && abs(y-ydots/2)<5)
X            return 0;
X
X         r = (x-xdots/2)*(x-xdots/2)+(y-ydots/2)*(y-ydots/2);
X         fSqrt14(r,f_tmp);
X         r = 2 * f_tmp;
X         if (r < radius)
X            radius = r;
X      }
X   }
X}
X
X/************ standalone engine for "bifurcation" types ***************/
X
X/***************************************************************/
X/* The following code now forms a generalised Fractal Engine   */
X/* for Bifurcation fractal typeS.  By rights it now belongs in */
X/* CALCFRACT.C, but it's easier for me to leave it here !      */
X
X/* Original code by Phil Wilson, hacked around by Kev Allen.   */
X
X/* Besides generalisation, enhancements include Periodicity    */
X/* Checking during the plotting phase (AND halfway through the */
X/* filter cycle, if possible, to halve calc times), quicker    */
X/* floating-point calculations for the standard Verhulst type, */
X/* and new bifurcation types (integer bifurcation, f.p & int   */
X/* biflambda - the real equivalent of complex Lambda sets -    */
X/* and f.p renditions of bifurcations of r*sin(Pi*p), which    */
X/* spurred Mitchel Feigenbaum on to discover his Number).      */
X
X/* To add further types, extend the fractalspecific[] array in */
X/* usual way, with Bifurcation as the engine, and the name of  */
X/* the routine that calculates the next bifurcation generation */
X/* as the "orbitcalc" routine in the fractalspecific[] entry.  */
X
X/* Bifurcation "orbitcalc" routines get called once per screen */
X/* pixel column.  They should calculate the next generation    */
X/* from the doubles Rate & Population (or the longs lRate &    */
X/* lPopulation if they use integer math), placing the result   */
X/* back in Population (or lPopulation).  They should return 0  */
X/* if all is ok, or any non-zero value if calculation bailout  */
X/* is desirable (eg in case of errors, or the series tending   */
X/* to infinity).        Have fun !               */
X/***************************************************************/
X
X#define DEFAULTFILTER 1000     /* "Beauty of Fractals" recommends using 5000
X                   (p.25), but that seems unnecessary. Can
X                   override this value with a nonzero param1 */
X
X#define SEED 0.66        /* starting value for population */
X
Xstatic int far *verhulst_array;
Xunsigned int filter_cycles;
Xstatic unsigned int half_time_check;
Xstatic long   lPopulation, lRate;
Xdouble Population,  Rate;
Xstatic int    mono, outside_x;
Xstatic long   LPI;
X
Xint Bifurcation(void)
X{
X   unsigned long array_size;
X   int row, column;
X   column = 0;
X   if (resuming)
X   {
X      start_resume();
X      get_resume(sizeof(int),&column,0);
X      end_resume();
X   }
X   array_size =  (iystop + 1) * sizeof(int); /* should be iystop + 1 */
X   if ((verhulst_array = (int far *) farmemalloc(array_size)) == NULL)
X   {
X      static char far msg[]={"Insufficient free memory for calculation."};
X      stopmsg(0,msg);
X      return(-1);
X   }
X
X   LPI = PI * fudge;
X
X   for (row = 0; row <= iystop; row++) /* should be iystop */
X      verhulst_array[row] = 0;
X
X   mono = 0;
X   if (colors == 2)
X      mono = 1;
X   if (mono)
X   {
X      if (inside)
X      {
X     outside_x = 0;
X     inside = 1;
X      }
X      else
X     outside_x = 1;
X   }
X
X   filter_cycles = (parm.x <= 0) ? DEFAULTFILTER : parm.x;
X   half_time_check = FALSE;
X   if (periodicitycheck && maxit < filter_cycles)
X   {
X      filter_cycles = (filter_cycles - maxit + 1) / 2;
X      half_time_check = TRUE;
X   }
X
X   if (integerfractal)
X      linit.y = ly0[iystop];   /* Y-value of    */
X   else
X      init.y = dy0[iystop];   /* bottom pixels */
X
X   while (column <= ixstop)
X   {
X      if(check_key())
X      {
X     farmemfree((char far *)verhulst_array);
X     alloc_resume(10,1);
X     put_resume(sizeof(int),&column,0);
X     return(-1);
X      }
X      if (integerfractal)
X     lRate = lx0[column];
X      else
X     Rate = dx0[column];
X      verhulst();     /* calculate array once per column */
X
X      for (row = iystop; row >= 0; row--) /* should be iystop & >=0 */
X      {
X     int color;
X     color = verhulst_array[row];
X     if(color && mono)
X        color = inside;
X     else if((!color) && mono)
X        color = outside_x;
X     else if (color>=colors)
X        color = colors-1;
X     verhulst_array[row] = 0;
X     (*plot)(column,row,color); /* was row-1, but that's not right? */
X      }
X      column++;
X   }
X   farmemfree((char far *)verhulst_array);
X   return(0);
X}
X
Xstatic void verhulst()        /* P. F. Verhulst (1845) */
X{
X   unsigned int pixel_row, counter, errors;
X
X    if (integerfractal)
X       lPopulation = (parm.y == 0) ? SEED * fudge : parm.y * fudge;
X    else
X       Population = (parm.y == 0 ) ? SEED : parm.y;
X
X   errors = overflow = FALSE;
X
X   for (counter=0 ; counter < filter_cycles ; counter++)
X   {
X      errors = (*(curfractalspecific->orbitcalc))();
X      if (errors)
X     return;
X   }
X   if (half_time_check) /* check for periodicity at half-time */
X   {
X      Bif_Period_Init();
X      for (counter=0 ; counter < maxit ; counter++)
X      {
X     errors = (*(curfractalspecific->orbitcalc))();
X     if (errors) return;
X     if (periodicitycheck && Bif_Periodic(counter)) break;
X      }
X      if (counter >= maxit)   /* if not periodic, go the distance */
X      {
X     for (counter=0 ; counter < filter_cycles ; counter++)
X     {
X        errors = (*(curfractalspecific->orbitcalc))();
X        if (errors) return;
X     }
X      }
X   }
X
X   if (periodicitycheck) Bif_Period_Init();
X   for (counter=0 ; counter < maxit ; counter++)
X   {
X      errors = (*(curfractalspecific->orbitcalc))();
X      if (errors) return;
X
X      /* assign population value to Y coordinate in pixels */
X      if (integerfractal)
X     pixel_row = iystop - (lPopulation - linit.y) / dely; /* iystop */
X      else
X     pixel_row = iystop - (int)((Population - init.y) / deltaY);
X
X      /* if it's visible on the screen, save it in the column array */
X      if (pixel_row <= iystop) /* JCO 6/6/92 */
X     verhulst_array[ pixel_row ] ++;
X      if (periodicitycheck && Bif_Periodic(counter))
X      {
X     if (pixel_row <= iystop) /* JCO 6/6/92 */
X        verhulst_array[ pixel_row ] --;
X     break;
X      }
X   }
X}
Xstatic    long    lBif_closenuf, lBif_savedpop;    /* poss future use  */
Xstatic    double     Bif_closenuf,    Bif_savedpop;
Xstatic    int     Bif_savedinc,    Bif_savedand;
X
Xstatic void Bif_Period_Init()
X{
X   Bif_savedinc = 1;
X   Bif_savedand = 1;
X   if (integerfractal)
X   {
X      lBif_savedpop = -1;
X      lBif_closenuf = dely / 8;
X   }
X   else
X   {
X      Bif_savedpop = -1.0;
X      Bif_closenuf = deltaY / 8.0;
X   }
X}
X
Xstatic int _fastcall Bif_Periodic (time)  /* Bifurcation Population Periodicity Check */
Xint time;        /* Returns : 1 if periodicity found, else 0 */
X{
X   if ((time & Bif_savedand) == 0)    /* time to save a new value */
X   {
X      if (integerfractal) lBif_savedpop = lPopulation;
X      else             Bif_savedpop =  Population;
X      if (--Bif_savedinc == 0)
X      {
X     Bif_savedand = (Bif_savedand << 1) + 1;
X     Bif_savedinc = 4;
X      }
X   }
X   else             /* check against an old save */
X   {
X      if (integerfractal)
X      {
X     if (labs(lBif_savedpop-lPopulation) <= lBif_closenuf)
X        return(1);
X      }
X      else
X      {
X     if (fabs(Bif_savedpop-Population) <= Bif_closenuf)
X        return(1);
X      }
X   }
X   return(0);
X}
X
X/**********************************************************************/
X/*                                                      */
X/* The following are Bifurcation "orbitcalc" routines...              */
X/*                                                      */
X/**********************************************************************/
X#ifdef XFRACT
Xint BifurcLambda() /* Used by lyanupov */
X  {
X    Population = Rate * Population * (1 - Population);
X    return (fabs(Population) > BIG);
X  }
X#endif
X
X/* Modified formulas below to generalize bifurcations. JCO 7/3/92 */
X
X#define LCMPLXtrig0(arg,out) Arg1->l = (arg); ltrig0(); (out)=Arg1->l
X#define  CMPLXtrig0(arg,out) Arg1->d = (arg); dtrig0(); (out)=Arg1->d
X
Xint BifurcVerhulstTrig()
X  {
X/*  Population = Pop + Rate * fn(Pop) * (1 - fn(Pop)) */
X    tmp.x = Population;
X    tmp.y = 0;
X    CMPLXtrig0(tmp, tmp);
X    Population += Rate * tmp.x * (1 - tmp.x);
X    return (fabs(Population) > BIG);
X  }
X
Xint LongBifurcVerhulstTrig()
X  {
X#ifndef XFRACT
X    ltmp.x = lPopulation;
X    ltmp.y = 0;
X    LCMPLXtrig0(ltmp, ltmp);
X    ltmp.y = ltmp.x - multiply(ltmp.x,ltmp.x,bitshift);
X    lPopulation += multiply(lRate,ltmp.y,bitshift);
X    return (overflow);
X#endif
X  }
X
Xint BifurcStewartTrig()
X  {
X/*  Population = (Rate * fn(Population) * fn(Population)) - 1.0 */
X    tmp.x = Population;
X    tmp.y = 0;
X    CMPLXtrig0(tmp, tmp);
X    Population = (Rate * tmp.x * tmp.x) - 1.0;
X    return (fabs(Population) > BIG);
X  }
X
Xint LongBifurcStewartTrig()
X  {
X#ifndef XFRACT
X    ltmp.x = lPopulation;
X    ltmp.y = 0;
X    LCMPLXtrig0(ltmp, ltmp);
X    lPopulation = multiply(ltmp.x,ltmp.x,bitshift);
X    lPopulation = multiply(lPopulation,lRate,       bitshift);
X    lPopulation -= fudge;
X    return (overflow);
X#endif
X  }
X
Xint BifurcSetTrigPi()
X  {
X    tmp.x = Population * PI;
X    tmp.y = 0;
X    CMPLXtrig0(tmp, tmp);
X    Population = Rate * tmp.x;
X    return (fabs(Population) > BIG);
X  }
X
Xint LongBifurcSetTrigPi()
X  {
X#ifndef XFRACT
X    ltmp.x = multiply(lPopulation,LPI,bitshift);
X    ltmp.y = 0;
X    LCMPLXtrig0(ltmp, ltmp);
X    lPopulation = multiply(lRate,ltmp.x,bitshift);
X    return (overflow);
X#endif
X  }
X
Xint BifurcAddTrigPi()
X  {
X    tmp.x = Population * PI;
X    tmp.y = 0;
X    CMPLXtrig0(tmp, tmp);
X    Population += Rate * tmp.x;
X    return (fabs(Population) > BIG);
X  }
X
Xint LongBifurcAddTrigPi()
X  {
X#ifndef XFRACT
X    ltmp.x = multiply(lPopulation,LPI,bitshift);
X    ltmp.y = 0;
X    LCMPLXtrig0(ltmp, ltmp);
X    lPopulation += multiply(lRate,ltmp.x,bitshift);
X    return (overflow);
X#endif
X  }
X
Xint BifurcLambdaTrig()
X  {
X/*  Population = Rate * fn(Population) * (1 - fn(Population)) */
X    tmp.x = Population;
X    tmp.y = 0;
X    CMPLXtrig0(tmp, tmp);
X    Population = Rate * tmp.x * (1 - tmp.x);
X    return (fabs(Population) > BIG);
X  }
X
Xint LongBifurcLambdaTrig()
X  {
X#ifndef XFRACT
X    ltmp.x = lPopulation;
X    ltmp.y = 0;
X    LCMPLXtrig0(ltmp, ltmp);
X    ltmp.y = ltmp.x - multiply(ltmp.x,ltmp.x,bitshift);
X    lPopulation = multiply(lRate,ltmp.y,bitshift);
X    return (overflow);
X#endif
X  }
X
X#define LCMPLXpwr(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
X     lStkPwr(); Arg1++; Arg2++; (out) = Arg2->l
X
Xlong beta;
X
Xint BifurcMay()
X  { /* X = (lambda * X) / (1 + X)^beta, from R.May as described in Pickover,
X            Computers, Pattern, Chaos, and Beauty, page 153 */
X    tmp.x = 1.0 + Population;
X    tmp.x = pow(tmp.x, -beta); /* pow in math.h included with mpmath.h */
X    Population = (Rate * Population) * tmp.x;
X    return (fabs(Population) > BIG);
X  }
X
Xint LongBifurcMay()
X  {
X#ifndef XFRACT
X    ltmp.x = lPopulation + fudge;
X    ltmp.y = 0;
X    lparm2.x = beta * fudge;
X    LCMPLXpwr(ltmp, lparm2, ltmp);
X    lPopulation = multiply(lRate,lPopulation,bitshift);
X    lPopulation = divide(lPopulation,ltmp.x,bitshift);
X    return (overflow);
X#endif
X  }
X
Xint BifurcMaySetup()
X  {
X
X   beta = (long)param[2];
X   if(beta < 2)
X      beta = 2;
X   param[2] = (double)beta;
X
X   timer(0,curfractalspecific->calctype);
X   return(0);
X  }
X
X/* Here Endeth the Generalised Bifurcation Fractal Engine   */
X
X/* END Phil Wilson's Code (modified slightly by Kev Allen et. al. !) */
X
X
X/******************* standalone engine for "popcorn" ********************/
X
Xint popcorn()    /* subset of std engine */
X{
X   int start_row;
X   start_row = 0;
X   if (resuming)
X   {
X      start_resume();
X      get_resume(sizeof(int),&start_row,0);
X      end_resume();
X   }
X   kbdcount=max_kbdcount;
X   plot = noplot;
X   tempsqrx = ltempsqrx = 0; /* PB added this to cover weird BAILOUTs */
X   for (row = start_row; row <= iystop; row++)
X   {
X      reset_periodicity = 1;
X      for (col = 0; col <= ixstop; col++)
X      {
X     if (StandardFractal() == -1) /* interrupted */
X     {
X        alloc_resume(10,1);
X        put_resume(sizeof(int),&row,0);
X        return(-1);
X     }
X     reset_periodicity = 0;
X      }
X   }
X   calc_status = 4;
X   return(0);
X}
X
X/******************* standalone engine for "lyapunov" *********************/
X/*** Roy Murphy [76376,721]                        ***/
X/*** revision history:                            ***/
X/*** initial version: Winter '91                    ***/
X/***    Fall '92 integration of Nicholas Wilt's ASM speedups        ***/
X/***    Jan 93' integration with calcfrac() yielding boundary tracing,    ***/
X/***    tesseral, and solid guessing, and inversion, inside=nnn        ***/
X/*** save_release behavior:                        ***/
X/***    1730 & prior: ignores inside=, calcmode='1', (a,b)->(x,y)    ***/
X/***    1731: other calcmodes and inside=nnn                ***/
X/***    1732: the infamous axis swap: (b,a)->(x,y),            ***/
X/***        the order parameter becomes a long int            ***/
X/**************************************************************************/
Xint lyaLength, lyaSeedOK;
Xint lyaRxy[34];
X
X#define WES 1   /* define WES to be 0 to use Nick's lyapunov.obj */
X#if WES
Xextern int lyapunov_cycles(double, double);
X#else
Xextern int lyapunov_cycles(int, double, double, double);
X#endif
X
Xint lyapunov_cycles_in_c(int, double, double);
X
Xlyapunov () {
X    double a, b;
X
X    if (check_key()) {
X    return -1;
X        }
X    overflow=FALSE;
X    if (param[1]==1) Population = (1.0+rand())/(2.0+RAND_MAX);
X    else if (param[1]==0) {
X    if (fabs(Population)>BIG || Population==0 || Population==1)
X        Population = (1.0+rand())/(2.0+RAND_MAX);
X    }
X    else Population = param[1];
X    (*plot)(col, row, 1);
X    if (invert) {
X    invertz2(&init);
X    a = init.y;
X    b = init.x;
X    }
X    else {
X    a = dy0[row]+dy1[col];
X    b = dx0[col]+dx1[row];
X    }
X#ifndef XFRACT
X    /*  the assembler routines don't work for a & b outside the
X    ranges 0 < a < 4 and 0 < b < 4. So, fall back on the C
X    routines if part of the image sticks out.
X    */
X#if WES
X        color=lyapunov_cycles(a, b);
X#else
X    if (lyaSeedOK && a>0 && b>0 && a<=4 && b<=4)
X    color=lyapunov_cycles(filter_cycles, Population, a, b);
X    else
X    color=lyapunov_cycles_in_c(filter_cycles, a, b);
X#endif
X#else
X    color=lyapunov_cycles_in_c(filter_cycles, a, b);
X#endif
X    if (inside>0 && color==0)
X    color = inside;
X    else if (color>=colors)
X    color = colors-1;
X    (*plot)(col, row, color);
X    return color;
X}
X
X
Xlya_setup () {
X    /* This routine sets up the sequence for forcing the Rate parameter
X    to vary between the two values.  It fills the array lyaRxy[] and
X    sets lyaLength to the length of the sequence.
X
X    The sequence is coded in the bit pattern in an integer.
X    Briefly, the sequence starts with an A the leading zero bits
X    are ignored and the remaining bit sequence is decoded.  The
X    sequence ends with a B.  Not all possible sequences can be
X    represented in this manner, but every possible sequence is
X    either represented as itself, as a rotation of one of the
X    representable sequences, or as the inverse of a representable
X    sequence (swapping 0s and 1s in the array.)  Sequences that
X    are the rotation and/or inverses of another sequence will generate
X    the same lyapunov exponents.
X
X    A few examples follow:
X        number    sequence
X          0    ab
X          1    aab
X          2    aabb
X          3    aaab
X          4    aabbb
X          5    aabab
X          6    aaabb (this is a duplicate of 4, a rotated inverse)
X          7    aaaab
X          8    aabbbb    etc.
X     */
X
X    long i;
X    int t;
X
X    if ((filter_cycles=param[2])==0)
X    filter_cycles=maxit/2;
X    lyaSeedOK = param[1]>0 && param[1]<=1 && debugflag!=90;
X    lyaLength = 1;
X
X    i = param[0];
X#ifndef XFRACT
X    if (save_release<1732) i &= 0x0FFFFL; /* make it a short to reporduce prior stuff*/
X#endif
X    lyaRxy[0] = 1;
X    for (t=31; t>=0; t--)
X    if (i & (1<<t)) break;
X    for (; t>=0; t--)
X    lyaRxy[lyaLength++] = (i & (1<<t)) != 0;
X    lyaRxy[lyaLength++] = 0;
X    if (save_release<1732)        /* swap axes prior to 1732 */
X    for (t=lyaLength; t>=0; t--)
X        lyaRxy[t] = !lyaRxy[t];
X    if (save_release<1731) {        /* ignore inside=, stdcalcmode */
X        stdcalcmode='1';
X    if (inside==1) inside = 0;
X    }
X    if (inside<0) {
X        static char far msg[]=
X        {"Sorry, inside options other than inside=nnn are not supported by the lyapunov"};
X        stopmsg(0,(char far *)msg);
X        inside=1;
X    }
X    return 1;
X}
X
Xint lyapunov_cycles_in_c(int filter_cycles, double a, double b) {
X    int color, count, i, lnadjust;
X    double lyap, total, temp;
X    /* e10=22026.4657948  e-10=0.0000453999297625 */
X
X    for (i=0; i<filter_cycles; i++) {
X    for (count=0; count<lyaLength; count++) {
X        Rate = lyaRxy[count] ? a : b;
X        if (curfractalspecific->orbitcalc()) {
X        overflow = TRUE;
X        goto jumpout;
X        }
X        }
X    }
X    total = 1.0;
X    lnadjust = 0;
X    for (i=0; i < maxit/2; i++) {
X    for (count = 0; count < lyaLength; count++) {
X        Rate = lyaRxy[count] ? a : b;
X        if (curfractalspecific->orbitcalc()) {
X        overflow = TRUE;
X        goto jumpout;
X        }
X        temp = fabs(Rate-2.0*Rate*Population);
X        if ((total *= (temp))==0) {
X        overflow = TRUE;
X        goto jumpout;
X        }
X        }
X    while (total > 22026.4657948) {
X        total *= 0.0000453999297625;
X        lnadjust += 10;
X        }
X    while (total < 0.0000453999297625) {
X        total *= 22026.4657948;
X        lnadjust -= 10;
X        }
X    }
X
Xjumpout:
X    if (overflow || total <= 0 || (temp = log(total) + lnadjust) > 0)
X    color = 0;
X    else {
X    if (LogFlag)
X    lyap = -temp/((double) lyaLength*i);
X    else
X    lyap = 1 - exp(temp/((double) lyaLength*i));
X    color = 1 + (int)(lyap * (colors-1));
X    }
X    return color;
X}
X
X
X/******************* standalone engine for "cellular" ********************/
X/* Originally coded by Ken Shirriff.
X   Modified beyond recognition by Jonathan Osuch.
X     Original or'd the neighborhood, changed to sum the neighborhood
X     Changed prompts and error messages
X     Added CA types
X     Set the palette to some standard? CA colors
X     Changed *cell_array to near and used dstack so put_line and get_line
X       could be used all the time
X     Made space bar generate next screen
X     Increased string/rule size to 16 digits and added CA types 9/20/92
X*/
X
X#define BAD_T         1
X#define BAD_MEM       2
X#define STRING1       3
X#define STRING2       4
X#define TABLEK        5
X#define TYPEKR        6
X#define RULELENGTH    7
X
X#define CELLULAR_DONE 10
X
X#ifndef XFRACT
Xstatic BYTE *cell_array[2];
X#else
Xstatic BYTE far *cell_array[2];
X#endif
X
XS16 r, k_1, rule_digits;
Xint lstscreenflag;
X
Xvoid abort_cellular(int err, int t)
X{
X   int i;
X   switch (err)
X   {
X      case BAD_T:
X         {
X         char msg[30];
X         sprintf(msg,"Bad t=%d, aborting\n", t);
X         stopmsg(0,(char far *)msg);
X         }
X         break;
X      case BAD_MEM:
X         {
X         static char far msg[]={"Insufficient free memory for calculation" };
X         stopmsg(0,msg);
X         }
X         break;
X      case STRING1:
X         {
X         static char far msg[]={"String can be a maximum of 16 digits" };
X         stopmsg(0,msg);
X         }
X         break;
X      case STRING2:
X         {
X         static char far msg[]={"Make string of 0's through  's" };
X         msg[27] = k_1 + 48; /* turn into a character value */
X         stopmsg(0,msg);
X         }
X         break;
X      case TABLEK:
X         {
X         static char far msg[]={"Make Rule with 0's through  's" };
X         msg[27] = k_1 + 48; /* turn into a character value */
X         stopmsg(0,msg);
X         }
X         break;
X      case TYPEKR:
X         {
X         static char far msg[]={"Type must be 21, 31, 41, 51, 61, 22, 32, \
X42, 23, 33, 24, 25, 26, 27" };
X         stopmsg(0,msg);
X         }
X         break;
X      case RULELENGTH:
X         {
X         static char far msg[]={"Rule must be    digits long" };
X         i = rule_digits / 10;
X         if(i==0)
X            msg[14] = rule_digits + 48;
X         else {
X            msg[13] = i;
X            msg[14] = rule_digits % 10 + 48;
X         }
X         stopmsg(0,msg);
X         }
X         break;
X      case CELLULAR_DONE:
X         break;
X   }
X   if(cell_array[0] != NULL)
X#ifndef XFRACT
X      cell_array[0] = NULL;
X#else
X      farmemfree((char far *)cell_array[0]);
X#endif
X   if(cell_array[1] != NULL)
X#ifndef XFRACT
X      cell_array[1] = NULL;
X#else
X      farmemfree((char far *)cell_array[1]);
X#endif
X}
X
Xcellular () {
X   S16 start_row;
X   S16 filled, notfilled;
X   U16 cell_table[32];
X   U16 init_string[16];
X   U16 kr, k;
X   U32 lnnmbr;
X   U16 i,j,l;
X   S16 t, t2;
X   S32 randparam;
X   double n;
X   char buf[30];
X
X   set_Cellular_palette();
X
X   randparam = param[0];
X   lnnmbr = param[3];
X   kr = param[2];
X   switch (kr) {
X     case 21:
X     case 31:
X     case 41:
X     case 51:
X     case 61:
X     case 22:
X     case 32:
X     case 42:
X     case 23:
X     case 33:
X     case 24:
X     case 25:
X     case 26:
X     case 27:
X        break;
X     default:
X        abort_cellular(TYPEKR, 0);
X        return -1;
X        break;
X   }
X
X   r = kr % 10; /* Number of nearest neighbors to sum */
X   k = kr / 10; /* Number of different states, k=3 has states 0,1,2 */
X   k_1 = k - 1; /* Highest state value, k=3 has highest state value of 2 */
X   rule_digits = (r * 2 + 1) * k_1 + 1; /* Number of digits in the rule */
X
X   if ((!rflag) && randparam == -1)
X       --rseed;
X   if (randparam != 0 && randparam != -1) {
X      n = param[0];
X      sprintf(buf,"%.16g",n); /* # of digits in initial string */
X      t = strlen(buf);
X      if (t>16 || t <= 0) {
X         abort_cellular(STRING1, 0);
X         return -1;
X      }
X      for (i=0;i<16;i++)
X         init_string[i] = 0; /* zero the array */
X      t2 = (S16) ((16 - t)/2);
X      for (i=0;i<t;i++) { /* center initial string in array */
X         init_string[i+t2] = buf[i] - 48; /* change character to number */
X         if (init_string[i+t2]>k_1) {
X            abort_cellular(STRING2, 0);
X            return -1;
X         }
X      }
X   }
X
X   srand(rseed);
X   if (!rflag) ++rseed;
X
X/* generate rule table from parameter 1 */
X#ifndef XFRACT
X   n = param[1];
X#else
X   /* gcc can't manage to convert a big double to an unsigned long properly. */
X   if (param[1]>0x7fffffff) {
X       n = (param[1]-0x7fffffff);
X       n += 0x7fffffff;
X   } else {
X       n = param[1];
X   }
X#endif
X   if (n == 0) { /* calculate a random rule */
X      n = rand15()%k;
X      for (i=1;i<rule_digits;i++) {
X         n *= 10;
X         n += rand15()%k;
X      }
X      param[1] = n;
X   }
X   sprintf(buf,"%.*g",rule_digits ,n);
X   t = strlen(buf);
X   if (rule_digits < t || t < 0) { /* leading 0s could make t smaller */
X      abort_cellular(RULELENGTH, 0);
X      return -1;
X   }
X   for (i=0;i<rule_digits;i++) /* zero the table */
X      cell_table[i] = 0;
X   for (i=0;i<t;i++) { /* reverse order */
X      cell_table[i] = buf[t-i-1] - 48; /* change character to number */
X      if (cell_table[i]>k_1) {
X         abort_cellular(TABLEK, 0);
X         return -1;
X      }
X   }
X
X
X   start_row = 0;
X#ifndef XFRACT
X  /* two 4096 byte arrays, at present at most 2024 + 1 bytes should be */
X  /* needed in each array (max screen width + 1) */
X   cell_array[0] = (BYTE *)&dstack[0]; /* dstack is in general.asm */
X   cell_array[1] = (BYTE *)&boxy[0]; /* boxy is in general.asm */
X#else
X   cell_array[0] = (BYTE far *)farmemalloc(ixstop+1);
X   cell_array[1] = (BYTE far *)farmemalloc(ixstop+1);
X#endif
X   if (cell_array[0]==NULL || cell_array[1]==NULL) {
X      abort_cellular(BAD_MEM, 0);
X      return(-1);
X   }
X
X/* nxtscreenflag toggled by space bar in fractint.c, 1 for continuous */
X/* 0 to stop on next screen */
X
X   filled = 0;
X   notfilled = 1-filled;
X   if (resuming && !nxtscreenflag && !lstscreenflag) {
X      start_resume();
X      get_resume(sizeof(int),&start_row,0);
X      end_resume();
X      get_line(start_row,0,ixstop,cell_array[filled]);
X   }
X   else if (nxtscreenflag && !lstscreenflag) {
X      start_resume();
X      end_resume();
X      get_line(iystop,0,ixstop,cell_array[filled]);
X      param[3] += iystop + 1;
X      start_row = -1; /* after 1st iteration its = 0 */
X   }
X   else {
X    if(rflag || randparam==0 || randparam==-1){
X      for (col=0;col<=ixstop;col++) {
X         cell_array[filled][col] = rand15()%k;
X      }
X    } /* end of if random */
X
X    else {
X      for (col=0;col<=ixstop;col++) { /* Clear from end to end */
X         cell_array[filled][col] = 0;
X      }
X      i = 0;
X      for (col=(ixstop-16)/2;col<(ixstop+16)/2;col++) { /* insert initial */
X         cell_array[filled][col] = init_string[i++];    /* string */
X      }
X    } /* end of if not random */
X    if (lnnmbr != 0)
X      lstscreenflag = 1;
X    else
X      lstscreenflag = 0;
X    put_line(start_row,0,ixstop,cell_array[filled]);
X   }
X   start_row++;
X
X/* This section calculates the starting line when it is not zero */
X/* This section can't be resumed since no screen output is generated */
X/* calculates the (lnnmbr - 1) generation */
X   if (lstscreenflag) { /* line number != 0 & not resuming & not continuing */
X     for (row = start_row; row < lnnmbr; row++) {
X      thinking(1,"Cellular thinking (higher start row takes longer)");
X      if(rflag || randparam==0 || randparam==-1){
X       /* Use a random border */
X       for (i=0;i<=r;i++) {
X         cell_array[notfilled][i]=rand15()%k;
X         cell_array[notfilled][ixstop-i]=rand15()%k;
X       }
X      }
X      else {
X       /* Use a zero border */
X       for (i=0;i<=r;i++) {
X         cell_array[notfilled][i]=0;
X         cell_array[notfilled][ixstop-i]=0;
X       }
X      }
X
X       t = 0; /* do first cell */
X       for (i=0;i<=r+r;i++)
X           t += cell_array[filled][i];
X       if (t>rule_digits || t<0) {
X         thinking(0, NULL);
X         abort_cellular(BAD_T, t);
X         return(-1);
X       }
X       cell_array[notfilled][r] = cell_table[t];
X
X           /* use a rolling sum in t */
X       for (col=r+1;col<ixstop-r;col++) { /* now do the rest */
X         t = t + cell_array[filled][col+r] - cell_array[filled][col-r-1];
X         if (t>rule_digits || t<0) {
X           thinking(0, NULL);
X           abort_cellular(BAD_T, t);
X           return(-1);
X         }
X         cell_array[notfilled][col] = cell_table[t];
X       }
X
X       filled = notfilled;
X       notfilled = 1-filled;
X       if (check_key()) {
X          thinking(0, NULL);
X          abort_cellular(CELLULAR_DONE, 0);
X          alloc_resume(10,1);
X          put_resume(sizeof(int),&row,0);
X          return -1;
X       }
X     }
X   start_row = 0;
X   thinking(0, NULL);
X   lstscreenflag = 0;
X   }
X
X/* This section does all the work */
Xcontloop:
X   for (row = start_row; row <= iystop; row++) {
X
X      if(rflag || randparam==0 || randparam==-1){
X       /* Use a random border */
X       for (i=0;i<=r;i++) {
X         cell_array[notfilled][i]=rand15()%k;
X         cell_array[notfilled][ixstop-i]=rand15()%k;
X       }
X      }
X      else {
X       /* Use a zero border */
X       for (i=0;i<=r;i++) {
X         cell_array[notfilled][i]=0;
X         cell_array[notfilled][ixstop-i]=0;
X       }
X      }
X
X       t = 0; /* do first cell */
X       for (i=0;i<=r+r;i++)
X           t += cell_array[filled][i];
X       if (t>rule_digits || t<0) {
X         thinking(0, NULL);
X         abort_cellular(BAD_T, t);
X         return(-1);
X       }
X       cell_array[notfilled][r] = cell_table[t];
X
X           /* use a rolling sum in t */
X       for (col=r+1;col<ixstop-r;col++) { /* now do the rest */
X         t = t + cell_array[filled][col+r] - cell_array[filled][col-r-1];
X         if (t>rule_digits || t<0) {
X           thinking(0, NULL);
X           abort_cellular(BAD_T, t);
X           return(-1);
X         }
X         cell_array[notfilled][col] = cell_table[t];
X       }
X
X       filled = notfilled;
X       notfilled = 1-filled;
X       put_line(row,0,ixstop,cell_array[filled]);
X       if (check_key()) {
X          abort_cellular(CELLULAR_DONE, 0);
X          alloc_resume(10,1);
X          put_resume(sizeof(int),&row,0);
X          return -1;
X       }
X   }
X   if(nxtscreenflag) {
X     param[3] += iystop + 1;
X     start_row = -1; /* after 1st iteration its = 0 */
X     goto contloop;
X   }
X  abort_cellular(CELLULAR_DONE, 0);
X  return 1;
X}
X
Xint CellularSetup(void)
X{
X   if (!resuming) {
X      nxtscreenflag = 0; /* initialize flag */
X   }
X   timer(0,curfractalspecific->calctype);
X   return(0);
X}
X
Xstatic void set_Cellular_palette()
X{
X   extern char far *mapdacbox;
X   static Palettetype Red    = {
X      42, 0, 0     };
X   static Palettetype Green  = {
X      10,35,10    };
X   static Palettetype Blue   = {
X      13,12,29    };
X   static Palettetype Yellow = {
X      60,58,18    };
X   static Palettetype Brown = {
X      42,21, 0    };
X   int i;
X
X   if (mapdacbox) return;        /* map= specified */
X
X   dacbox[0].red  = 0 ;
X   dacbox[0].green= 0 ;
X   dacbox[0].blue = 0 ;
X
X   dacbox[1].red     = Red.red;
X   dacbox[1].green = Red.green;
X   dacbox[1].blue  = Red.blue;
X
X   dacbox[2].red   = Green.red;
X   dacbox[2].green = Green.green;
X   dacbox[2].blue  = Green.blue;
X
X   dacbox[3].red   = Blue.red;
X   dacbox[3].green = Blue.green;
X   dacbox[3].blue  = Blue.blue;
X
X   dacbox[4].red   = Yellow.red;
X   dacbox[4].green = Yellow.green;
X   dacbox[4].blue  = Yellow.blue;
X
X   dacbox[5].red   = Brown.red;
X   dacbox[5].green = Brown.green;
X   dacbox[5].blue  = Brown.blue;
X
X   SetTgaColors();
X   spindac(0,1);
X}
X
X/* frothy basin routines */
Xstatic char froth3_256c[] = "froth3.map";
Xstatic char froth6_256c[] = "froth6.map";
Xstatic char froth3_16c[] =  "froth316.map";
Xstatic char froth6_16c[] =  "froth616.map";
Xint frothsix=0;
Xint froth_altcolor;
Xint froth_shades;
Xextern int colorstate;
X
X/* color maps which attempt to replicate the images of James Alexander. */
Xstatic void set_Froth_palette(void)
X   {
X   char *mapname;
X
X   if (colorstate != 0) /* 0 means dacbox matches default */
X      return;
X
X   if (colors >= 16)
X      {
X      if (colors >= 256)
X         {
X         if (frothsix)
X            mapname = froth6_256c;
X         else
X            mapname = froth3_256c;
X         }
X      else /* colors >= 16 */
X         {
X         if (frothsix)
X            mapname = froth6_16c;
X         else
X            mapname = froth3_16c;
X         }
X      if (ValidateLuts(mapname) != 0)
X         return;
X      colorstate = 0; /* treat map it as default */
X      spindac(0,1);
X      }
X   }
X
Xint froth_setup(void)
X   {
X   if (param[0] != 3 && param[0] != 6) /* if no match then*/
X      param[0] = 3;                    /* make it 3 */
X   frothsix = param[0] == 6;
X   froth_altcolor = param[1] != 0;
X   froth_shades = (colors-1) / (frothsix ? 6 : 3);
X   /* rqlim needs to be at least 6 or so */
X   if (rqlim < 6.0)
X      rqlim=6.0;
X   set_Froth_palette();
X   /* make the best of the .map situation */
X   orbit_color = !frothsix && colors >= 16 ? (froth_shades<<1)+1 : colors-1;
X   return 1;
X   }
X
X/* Froth Fractal type */
X  int calcfroth(void)   /* per pixel 1/2/g, called with row & col set */
X     {
X     int found_attractor=0;
X     double x, y, nx, ny, x2, y2;
X     long lx, ly, lnx, lny, lx2, ly2;
X
X/* These points were determined imperically and verified experimentally */
X/* using the program WL-Plot, a plotting program which has a mode for */
X/* orbits of recursive relations. */
X#define CLOSE    1e-6      /* seems like a good value */
X#define SQRT3    1.732050807568877193
X#define A        1.02871376822
X#define B1       (A/2)
X#define M2       SQRT3
X#define B2       (-A)
X#define M3       (-SQRT3)
X#define B3       (-A)
X#define X1MIN   -1.04368901270
X#define X1MAX    1.33928675524
X#define XMIDT   -0.339286755220
X#define X2MAX1   0.96729063460
X#define XMIDR    0.61508950585
X#define X3MIN1  -0.22419724936
X#define X2MIN2  -1.11508950586
X#define XMIDL   -0.27580275066
X#define X3MAX2   0.07639837810
X#define FROTH_BITSHIFT  28
X/* compiler should handle this at compile time */
X#define D_TO_L(x) ((long)((x)*(1L<<FROTH_BITSHIFT)))
X
X   orbit_ptr = 0;
X   color = 0;
X   if(showdot>0)
X      (*plot) (col, row, showdot&(colors-1));
X   if (!integerfractal) /* fp mode */
X      {
X      double close=  CLOSE;
X      double a=      A;
X      double b1=     B1;
X      double xmidt=  XMIDT;
X      double m2=     M2;
X      double b2=     B2;
X      double m3=     M3;
X      double b3=     B3;
X      double x1min=  X1MIN;
X      double x1max=  X1MAX;
X      double x2max1= X2MAX1;
X      double xmidr=  XMIDR;
X      double x3min1= X3MIN1;
X      double x2min2= X2MIN2;
X      double xmidl=  XMIDL;
X      double x3max2= X3MAX2;
X
X      if(invert)
X     {
X     invertz2(&tmp);
X     x = tmp.x;
X     y = tmp.y;
X     }
X      else
X     {
X     x = dx0[col]+dx1[row];
X     y = dy0[row]+dy1[col];
X     }
X
X      magnitude = (x2=sqr(x)) + (y2=sqr(y));
X      while (!found_attractor && (magnitude < rqlim) && (color < maxit))
X     {
X         /* simple formula: z = z^2 + conj(z*(-1+ai)) */
X     /* but it's the attractor that makes this so interesting */
X     nx = x2 - y2 - x - a*y;
X     ny = (x+x)*y - a*x + y;
X     x = nx;
X     y = ny;
X     if (frothsix) /* repeat mapping */
X        {
X        nx = sqr(x) - sqr(y) - x - a*y;
X        ny = (x+x)*y - a*x + y;
X        x = nx;
X        y = ny;
X        }
X     magnitude = (x2=sqr(x)) + (y2=sqr(y));
X     color++;
X
X     if (show_orbit)
X        plot_orbit(x, y, -1);
X
X         if (x > x1min && x < x1max && fabs(b1-y) < close)
X        {
X        if (!frothsix || x < xmidt)
X           found_attractor = 1;
X        else
X           found_attractor = 2;
X
X        }
X     else if (fabs(m2*x+b2-y) < close)
X        {
X        if (x > xmidr && x < x2max1)
X           found_attractor = !frothsix ? 2 : 4;
X        else if (x > x3min1 && x < xmidr)
X           found_attractor = !frothsix ? 3 : 6;
X        }
X     else if (fabs(m3*x+b3-y) < close)
X        {
X        if (x > x2min2 && x < xmidl)
X           found_attractor = !frothsix ? 2 : 3;
X        else if (x > xmidl && x < x3max2)
X           found_attractor = !frothsix ? 3 : 5;
X        }
X     }
X      }
X   else /* integer mode */
X      {
X      long lclose=   D_TO_L(CLOSE);
X      long la=       D_TO_L(A);
X      long lb1=      D_TO_L(B1);
X      long lxmidt=   D_TO_L(XMIDT);
X      long lm2=      D_TO_L(M2);
X      long lb2=      D_TO_L(B2);
X      long lm3=      D_TO_L(M3);
X      long lb3=      D_TO_L(B3);
X      long lx1min=   D_TO_L(X1MIN);
X      long lx1max=   D_TO_L(X1MAX);
X      long lx2max1=  D_TO_L(X2MAX1);
X      long lxmidr=   D_TO_L(XMIDR);
X      long lx3min1=  D_TO_L(X3MIN1);
X      long lx2min2=  D_TO_L(X2MIN2);
X      long lxmidl=   D_TO_L(XMIDL);
X      long lx3max2=  D_TO_L(X3MAX2);
X
X      if(invert)
X     {
X     invertz2(&tmp);
X     lx = tmp.x * fudge;
X     ly = tmp.y * fudge;
X     }
X      else
X     {
X     lx = lx0[col] + lx1[row];
X     ly = ly0[row] + ly1[col];
X     }
X
X      lmagnitud = (lx2=lsqr(lx)) + (ly2=lsqr(ly));
X      while (!found_attractor && (lmagnitud < llimit)
X         && (lmagnitud > 0) && (color < maxit))
X     {
X         /* simple formula: z = z^2 + conj(z*(-1+ai)) */
X     /* but it's the attractor that makes this so interesting */
X     lnx = lx2 - ly2 - lx - multiply(la,ly,bitshift);
X     lny = (multiply(lx,ly,bitshift)<<1) - multiply(la,lx,bitshift) + ly;
X     lx = lnx;
X     ly = lny;
X     if (frothsix)
X        {
X        lmagnitud = (lx2=lsqr(lx)) + (ly2=lsqr(ly));
X        if ((lmagnitud > llimit) || (lmagnitud < 0))
X           break;
X        lnx = lx2 - ly2 - lx - multiply(la,ly,bitshift);
X        lny = (multiply(lx,ly,bitshift)<<1) - multiply(la,lx,bitshift) + ly;
X        lx = lnx;
X        ly = lny;
X        }
X     lmagnitud = (lx2=lsqr(lx)) + (ly2=lsqr(ly));
X     color++;
X
X     if (show_orbit)
X        iplot_orbit(lx, ly, -1);
X
X         if (lx > lx1min && lx < lx1max && labs(lb1-ly) < lclose)
X        {
X        if (!frothsix || lx < lxmidt)
X           found_attractor = 1;
X        else
X           found_attractor = 2;
X        }
X     else if (labs(multiply(lm2,lx,bitshift)+lb2-ly) < lclose)
X        {
X        if (lx > lxmidr && lx < lx2max1)
X           found_attractor = !frothsix ? 2 : 4;
X        else if (lx > lx3min1 && lx < lxmidr)
X           found_attractor = !frothsix ? 3 : 6;
X        }
X     else if (labs(multiply(lm3,lx,bitshift)+lb3-ly) < lclose)
X        {
X        if (lx > lx2min2 && lx < lxmidl)
X           found_attractor = !frothsix ? 2 : 3;
X        else if (lx > lxmidl && lx < lx3max2)
X           found_attractor = !frothsix ? 3 : 5;
X        }
X     }
X      }
X   if (show_orbit)
X      scrub_orbit();
X
X   realcolor = color;
X   if ((kbdcount -= realcolor) <= 0)
X      {
X      if (check_key())
X     return (-1);
X      kbdcount = max_kbdcount;
X      }
X
X/* inside - Here's where non-palette based images would be nice.  Instead, */
X/* we'll use blocks of (colors-1)/3 or (colors-1)/6 and use special froth  */
X/* color maps in attempt to replicate the images of James Alexander.       */
X   if (found_attractor)
X      {
X      if (colors >= 256)
X     {
X     if (!froth_altcolor)
X        {
X        if (color > froth_shades)
X        color = froth_shades;
X        }
X     else
X        color = froth_shades * color / maxit;
X     if (color == 0)
X        color = 1;
X     color += froth_shades * (found_attractor-1);
X     }
X      else if (colors >= 16)
X     { /* only alternate coloring scheme available for 16 colors */
X     long lshade;
X
X/* Trying to make a better 16 color distribution. */
X/* Since their are only a few possiblities, just handle each case. */
X/* This is a mostly guess work here. */
X     lshade = ((long)color<<16)/maxit;
X     if (!frothsix)
X        {
X        if (lshade < 2622)       /* 0.04 */
X           color = 1;
X        else if (lshade < 10486) /* 0.16 */
X           color = 2;
X        else if (lshade < 23593) /* 0.36 */
X           color = 3;
X        else if (lshade < 41943) /* 0.64 */
X           color = 4;
X        else
X           color = 5;
X        color += 5 * (found_attractor-1);
X        }
X     else
X        {
X        if (lshade < 10486)      /* 0.16 */
X           color = 1;
X        else
X           color = 2;
X        color += 2 * (found_attractor-1);
X        }
X     }
X      else /* use a color corresponding to the attractor */
X     color = found_attractor;
X      oldcolor = color;
X      }
X   else if (color >= maxit)
X      color = oldcolor; /* inside, but didn't get sucked in by attractor. */
X   else /* outside */
X      color = 0; /* all outside points are color 0 */
X
X   (*plot)(col, row, color);
X
X   return color;
X
X#undef CLOSE
X#undef SQRT3
X#undef A
X#undef B1
X#undef XMIDT
X#undef M2
X#undef B2
X#undef M3
X#undef B3
X#undef X1MIN
X#undef X1MAX
X#undef X2MAX1
X#undef XMIDR
X#undef X3MIN1
X#undef X2MIN2
X#undef XMIDL
X#undef X3MAX2
X#undef FROTH_BITSHIFT
X#undef D_TO_L
X   }
SHAR_EOF
$TOUCH -am 1028230093 miscfrac.c &&
chmod 0644 miscfrac.c ||
echo "restore of miscfrac.c failed"
set `wc -c miscfrac.c`;Wc_c=$1
if test "$Wc_c" != "56787"; then
    echo original size 56787, current size $Wc_c
fi
# ============= miscovl.c ==============
echo "x - extracting miscovl.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > miscovl.c &&
X/*
X    Overlayed odds and ends that don't fit anywhere else.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#ifndef XFRACT
X#include <process.h>
X#include <dos.h>
X#include <stdarg.h>
X#include <io.h>
X#else
X#include <varargs.h>
X#endif
X#include "fractint.h"
X#include "fractype.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic void write_batch_parms(FILE *,char *,int);
X#ifndef XFRACT
Xstatic void put_parm(char *parm,...);
X#else
Xstatic void put_parm();
X#endif
X
Xstatic void put_parm_line(void);
Xstatic int getprec(double,double,double);
Xstatic void put_float(int,double,int);
Xstatic void put_filename(char *keyword,char *fname);
Xstatic void format_item(int choice,char *buf);
Xstatic int check_modekey(int curkey,int choice);
Xstatic int entcompare(VOIDCONSTPTR p1,VOIDCONSTPTR p2);
Xstatic void update_fractint_cfg(void);
Xextern int  debugflag;
Xextern int  xdots,ydots;
Xextern int  cpu;        /* cpu type            */
Xextern int  fpu;        /* fpu type            */
Xextern int  iit;        /* iit fpu?            */
Xextern int  video_type;
Xextern int  askvideo;
Xextern char overwrite;        /* 1 means ok to overwrite */
Xextern int  fillcolor;        /* fill color: -1 = normal*/
Xextern int  inside;        /* inside color: 1=blue     */
Xextern int  outside;        /* outside color, if set    */
Xextern double xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* selected screen corners */
Xextern double sxmin, sxmax, sx3rd, symin, symax, sy3rd; /* zoom box corners */
Xextern double param[];       /* up to four parameters    */
Xextern int  finattract;     /* finite attractor option  */
Xextern int  forcesymmetry;
Xextern int  LogFlag;        /* non-zero if logarithmic palettes */
Xextern int  rflag, rseed;
Xextern int  periodicitycheck;
Xextern int  potflag;        /* continuous potential flag */
Xextern int  pot16bit;        /* save 16 bit values for continuous potential */
Xextern double potparam[3];    /* three potential parameters*/
Xextern int  fractype;        /* if == 0, use Mandelbrot  */
Xextern BYTE usemag;
Xextern long delmin;
Xextern int  maxit;        /* try this many iterations */
Xextern int  invert;        /* non-zero if inversion active */
Xextern double inversion[];
Xextern int  decomp[];
Xextern int  distest;        /* non-zero if distance estimator   */
Xextern int  distestwidth;
Xextern int  init3d[20];     /* '3d=nn/nn/nn/...' values */
Xextern char floatflag;        /* floating-point fractals? */
Xextern int  usr_biomorph;
Xextern char FormFileName[];    /* file to find (type=)formulas in */
Xextern char FormName[];     /* Name of the Formula (if not null) */
Xextern char LFileName[];
Xextern char LName[];
Xextern char IFSFileName[];
Xextern char IFSName[];
Xextern int  bailout;        /* user input bailout value */
Xextern char useinitorbit;
Xextern _CMPLX initorbit;
Xextern int  display3d;        /* 3D display flag: 0 = OFF */
Xextern int  overlay3d;        /* 3D overlay flag: 0 = OFF */
Xextern int  loaded3d;
Xextern char readname[];     /* name of fractal input file */
Xextern int  showfile;        /* has file been displayed yet? */
Xextern int  transparent[];
Xextern char preview;        /* 3D preview mode flag */
Xextern char showbox;        /* flag to show box and vector in preview */
Xextern int  RANDOMIZE;        /* Color randomizing factor */
Xextern int  Targa_Out;  /* Selects full color with light source fills */
Xextern int  Ambient;        /* Darkness of shadows in light source */
Xextern int  haze;        /* Amount of haze to factor in in full color */
Xextern char light_name[];    /* Name of full color .TGA file */
Xextern int previewfactor;
Xextern int BRIEF;
Xextern int RAY;
Xextern int xtrans;
Xextern int ytrans;
Xextern int red_crop_left;
Xextern int red_crop_right;
Xextern int blue_crop_left;
Xextern int blue_crop_right;
Xextern int red_bright;
Xextern int blue_bright;
Xextern int xadjust;
Xextern int eyeseparation;
Xextern int glassestype;
Xextern BYTE trigndx[];
Xextern int rotate_lo,rotate_hi;
Xextern int far *ranges;
Xextern int rangeslen;
Xextern char CommandFile[80];
Xextern char CommandName[ITEMNAMELEN+1];
Xextern char far CommandComment1[57];
Xextern char far CommandComment2[57];
Xextern char far CommandComment3[57];
Xextern char far CommandComment4[57];
Xextern char usr_stdcalcmode;
X
Xextern int calc_status;
Xextern double    sxmin,sxmax,symin,symax,sx3rd,sy3rd;
X
X/* Julibrot variables TIW 1/24/93 */
Xextern double mxmaxfp, mxminfp, mymaxfp, myminfp, originfp;
Xextern double depthfp, heightfp, widthfp, distfp, eyesfp;
X
Xextern int zdots;
Xextern int lastorbittype, neworbittype;
Xextern char *juli3Doptions[];
Xextern int juli3Dmode;
X
X/* viewwindows parameters */
Xextern int   viewwindow;
Xextern float viewreduction;
Xextern int   viewcrop;
Xextern float finalaspectratio;
Xextern int   viewxdots,viewydots;
X
Xextern int  colorstate;     /* comments in cmdfiles */
Xextern int  colors;
Xextern int  gotrealdac;
Xextern int  reallyega;
Xextern char colorfile[];
Xextern int  mapset;
Xextern char MAP_name[];
Xextern BYTE dacbox[256][3];
Xextern char far *mapdacbox;
Xextern int save_release;
X
Xextern char tstack[4096];
Xextern char s_cantopen[];
Xextern char s_cantwrite[];
Xextern char s_cantcreate[];
Xextern char s_cantunderstand[];
Xextern char s_cantfind[];
Xextern int calc_status;
X
Xextern struct videoinfo far videotable[];
X
X/* fullscreen_choice options */
X#define CHOICERETURNKEY 1
X#define CHOICEMENU    2
X#define CHOICEHELP    4
Xvoid miscovl_overlay() { }    /* for restore_active_ovly */
X
Xextern char s_real[];
Xextern char s_imag[];
Xextern char s_mult[];
Xextern char s_sum[];
Xextern char s_zmag[];
Xextern char s_bof60[];
Xextern char s_bof61[];
Xextern char s_maxiter[];
Xextern char s_epscross[];
Xextern char s_startrail[];
Xextern char s_normal[];
Xextern char s_period[];
X
Xchar *major[] = {"breadth","depth","walk","run"};
Xchar *minor[] = {"left","right"};
X
Xstatic FILE *parmfile;
X
X#define PAR_KEY(x)  ( x < 10 ? '0' + x : 'a' - 10 + x)
X
X#ifdef C6
X#pragma optimize("e",off)  /* MSC 6.00A messes up next rtn with "e" on */
X#endif
Xvoid make_batch_file()
X{
X   static char far hdg[]={"Save Current Parameters"};
X   /** added for pieces feature **/
X   double pdelx;
X   double pdely;
X   double pdelx2;
X   double pdely2;
X   unsigned int j, pxdots, pydots, xm, ym;
X   double pxxmin, pxxmax, pyymin, pyymax, pxx3rd, pyy3rd;
X   char vidmde[4];
X   int promptnum;
X   int piecespromts;
X   int have3rd;
X   /****/
X
X   int i;
X   char inpcommandfile[80], inpcommandname[ITEMNAMELEN + 1];
X   char inpcomment1[57], inpcomment2[57], inpcomment3[57], inpcomment4[57];
X   struct fullscreenvalues paramvalues[18];
X   char far *choices[18];
X   int gotinfile;
X   char outname[81], buf[256], buf2[128];
X   FILE *infile;
X   FILE *fpbat=NULL;
X   char colorspec[14];
X   int maxcolor;
X   int maxcolorindex;
X   char *sptr, *sptr2;
X   int oldhelpmode;
X
X   ENTER_OVLY(OVLY_MISCOVL);
X   stackscreen();
X   oldhelpmode = helpmode;
X   helpmode = HELPPARMFILE;
X
X   strcpy(colorspec, "n");
X   maxcolor = colors;
X   if (gotrealdac && !reallyega)
X   {
X      --maxcolor;
X/*    if (maxit < maxcolor)  remove 2 lines */
X/*       maxcolor = maxit;   so that whole palette is always saved */
X      if (inside > 0 && inside > maxcolor)
X         maxcolor = inside;
X      if (outside > 0 && outside > maxcolor)
X         maxcolor = outside;
X      if (distest < 0 && 0 - distest > maxcolor)
X         maxcolor = 0 - distest;
X      if (decomp[0] > maxcolor)
X         maxcolor = decomp[0] - 1;
X      if (potflag && potparam[0] >= maxcolor)
X         maxcolor = potparam[0];
X      if (++maxcolor > 256)
X         maxcolor = 256;
X      if (colorstate == 0)
X      {                         /* default colors */
X         if (mapdacbox)
X         {
X            colorspec[0] = '@';
X            sptr = MAP_name;
X         }
X      }
X      else
X      if (colorstate == 2)
X      {                         /* colors match colorfile */
X         colorspec[0] = '@';
X         sptr = colorfile;
X      }
X      else                      /* colors match no .map that we know of */
X         colorspec[0] = 'y';
X      if (colorspec[0] == '@')
X      {
X         if ((sptr2 = strrchr(sptr, SLASHC)))
X            sptr = sptr2 + 1;
X         if ((sptr2 = strrchr(sptr, ':')))
X            sptr = sptr2 + 1;
X         strncpy(&colorspec[1], sptr, 12);
X         colorspec[13] = 0;
X      }
X   }
X   strcpy(inpcommandfile, CommandFile);
X   strcpy(inpcommandname, CommandName);
X   far_strcpy(inpcomment1, CommandComment1);
X   far_strcpy(inpcomment2, CommandComment2);
X   far_strcpy(inpcomment3, CommandComment3);
X   far_strcpy(inpcomment4, CommandComment4);
X   if (CommandName[0] == 0)
X      strcpy(inpcommandname, "test");
X      /* TW added these  - and Bert moved them */
X      pxdots = xdots;
X      pydots = ydots;
X      vidmode_keyname(videoentry.keynum, vidmde);
X
X      xm = ym = 1;
X
X   while (1)
X   {
Xprompt_user:
X      promptnum = 0;
X      {
X         static char far tmp[] = {"Parameter file"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + 56;
X      paramvalues[promptnum++].uval.sbuf = inpcommandfile;
X      {
X         static char far tmp[] = {"Name"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + ITEMNAMELEN;
X      paramvalues[promptnum++].uval.sbuf = inpcommandname;
X      {
X         static char far tmp[] = {"Main comment"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + 56;
X      paramvalues[promptnum++].uval.sbuf = inpcomment1;
X      {
X         static char far tmp[] = {"Second comment"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + 56;;
X      paramvalues[promptnum++].uval.sbuf = inpcomment2;
X      {
X         static char far tmp[] = {"Third comment"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + 56;;
X      paramvalues[promptnum++].uval.sbuf = inpcomment3;
X      {
X         static char far tmp[] = {"Fourth comment"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + 56;;
X      paramvalues[promptnum++].uval.sbuf = inpcomment4;
X      if (gotrealdac && !reallyega)
X      {
X         {
X            static char far tmp[] = {"Record colors?"};
X            choices[promptnum] = tmp;
X         }
X         paramvalues[promptnum].type = 0x100 + 13;
X         paramvalues[promptnum++].uval.sbuf = colorspec;
X         {
X            static char far tmp[] = {"    (no | yes for full info | @filename to point to a map file)"};
X            choices[promptnum] = tmp;
X         }
X         paramvalues[promptnum++].type = '*';
X         {
X            static char far tmp[] = {"# of colors"};
X            choices[promptnum] = tmp;
X         }
X         maxcolorindex = promptnum;
X         paramvalues[promptnum].type = 'i';
X         paramvalues[promptnum++].uval.ival = maxcolor;
X         {
X            static char far tmp[] = {"    (if recording full color info)"};
X            choices[promptnum] = tmp;
X         }
X         paramvalues[promptnum++].type = '*';
X      }
X      {
X         static char tmp[] = {""};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum++].type = '*';
X
X      {
X         static char far tmp[] = {"    **** The following is for generating images in pieces ****"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum++].type = '*';
X      {
X         static char far tmp[] = {"X Multiples"};
X         choices[promptnum] = tmp;
X      }
X      piecespromts = promptnum;
X      paramvalues[promptnum].type = 'i';
X      paramvalues[promptnum++].uval.ival = xm;
X
X      {
X         static char far tmp[] = {"Y Multiples"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 'i';
X      paramvalues[promptnum++].uval.ival = ym;
X
X#ifndef XFRACT
X      {
X         static char far tmp[] = {"Video mode"};
X         choices[promptnum] = tmp;
X      }
X      paramvalues[promptnum].type = 0x100 + 4;
X      paramvalues[promptnum++].uval.sbuf = vidmde;
X#endif
X
X      if (fullscreen_prompt(hdg,promptnum, choices, paramvalues, 0, 0, NULL) < 0)
X         break;
X
X      strcpy(CommandFile, inpcommandfile);
X      if (strchr(CommandFile, '.') == NULL)
X         strcat(CommandFile, ".par");   /* default extension .par */
X      strcpy(CommandName, inpcommandname);
X      far_strcpy(CommandComment1, inpcomment1);
X      far_strcpy(CommandComment2, inpcomment2);
X      far_strcpy(CommandComment3, inpcomment3);
X      far_strcpy(CommandComment4, inpcomment4);
X      if (gotrealdac && !reallyega)
X         if (paramvalues[maxcolorindex].uval.ival > 0 &&
X             paramvalues[maxcolorindex].uval.ival <= 256)
X            maxcolor = paramvalues[maxcolorindex].uval.ival;
X
X      promptnum = piecespromts;
X      xm = paramvalues[promptnum++].uval.ival;
X
X      ym = paramvalues[promptnum++].uval.ival;
X
X      /* sanity checks */
X      {
X      int i;
X      long xtotal, ytotal;
X
X      /* get resolution from the video name (which must be valid) */
X#ifndef XFRACT
X      pxdots = pydots = 0;
X      if ((i = check_vidmode_keyname(vidmde)) > 0)
X          if ((i = check_vidmode_key(0, i)) >= 0) {
X              /* get the resolution of this video mode */
X              pxdots = videotable[i].xdots;
X              pydots = videotable[i].ydots;
X              }
X      if (pxdots == 0 ) {
X          /* no corresponding video mode! */
X          static char far msg[] = {"Invalid video mode entry!"};
X          stopmsg(0,msg);
X          goto prompt_user;
X          }
X#endif
X
X      /* bounds range on xm, ym */
X      if (xm < 1 || xm > 36 || ym < 1 || ym > 36) {
X          static char far msg[] = {"X and Y components must be 1 to 36"};
X          stopmsg(0,msg);
X          goto prompt_user;
X          }
X
X      /* another sanity check: total resolution cannot exceed 65535 */
X      xtotal = xm;  ytotal = ym;
X      xtotal *= pxdots;  ytotal *= pydots;
X      if (xtotal > 65535L || ytotal > 65535L) {
X      static char far msg[] = {"Total resolution (X or Y) cannot exceed 65535"};
X          stopmsg(0,msg);
X          goto prompt_user;
X          }
X      }
X
X      strcpy(outname, CommandFile);
X      gotinfile = 0;
X      if (access(CommandFile, 0) == 0)
X      {                         /* file exists */
X         gotinfile = 1;
X         if (access(CommandFile, 6))
X         {
X            sprintf(buf, s_cantwrite, CommandFile);
X            stopmsg(0, buf);
X            continue;
X         }
X         i = strlen(outname);
X         while (--i >= 0 && outname[i] != SLASHC)
X            outname[i] = 0;
X         strcat(outname, "fractint.tmp");
X         infile = fopen(CommandFile, "rt");
X#ifndef XFRACT
X         setvbuf(infile, tstack, _IOFBF, 4096); /* improves speed */
X#endif
X      }
X      if ((parmfile = fopen(outname, "wt")) == NULL)
X      {
X         sprintf(buf, s_cantcreate, outname);
X         stopmsg(0, buf);
X         if (gotinfile)
X            fclose(infile);
X         continue;
X      }
X
X      if (gotinfile)
X      {
X         while (file_gets(buf, 255, infile) >= 0)
X         {
X            if (strchr(buf, '{')/* entry heading? */
X                && sscanf(buf, " %40[^ \t({]", buf2)
X                && stricmp(buf2, CommandName) == 0)
X            {                   /* entry with same name */
X               sprintf(buf2, "File already has an entry named %s\n\
XContinue to replace it, Cancel to back out", CommandName);
X               if (stopmsg(18, buf2) < 0)
X               {                /* cancel */
X                  fclose(infile);
X                  fclose(parmfile);
X                  unlink(outname);
X                  goto prompt_user;
X               }
X               while (strchr(buf, '}') == NULL
X                      && file_gets(buf, 255, infile) > 0)
X               {
X               }                /* skip to end of set */
X               break;
X            }
X            fputs(buf, parmfile);
X            fputc('\n', parmfile);
X         }
X      }
X/***** start here*/
X      if (xm > 1 || ym > 1)
X      {
X         if (xxmin != xx3rd || yymin != yy3rd)
X            have3rd = 1;
X         else
X            have3rd = 0;
X         if ((fpbat = fopen("makemig.bat", "w")) == NULL)
X            xm = ym = 0;
X         pdelx  = (xxmax - xx3rd) / (xm * pxdots - 1);   /* calculate stepsizes */
X         pdely  = (yymax - yy3rd) / (ym * pydots - 1);
X         pdelx2 = (xx3rd - xxmin) / (ym * pydots - 1);
X         pdely2 = (yy3rd - yymin) / (xm * pxdots - 1);
X
X         /* save corners */
X         pxxmin = xxmin;
X         pxxmax = xxmax;
X         pyymin = yymin;
X         pyymax = yymax;
X      }
X      for (i = 0; i < xm; i++)  /* columns */
X      for (j = 0; j < ym; j++)  /* rows    */
X      {
X         if (xm > 1 || ym > 1)
X         {
X            int w;
X            char c;
X            char PCommandName[80];
X            w=0;
X            while(w < strlen(CommandName))
X            {
X               c = CommandName[w];
X               if(isspace(c) || c == 0)
X                  break;
X               PCommandName[w] = c;
X               w++;
X            }
X            PCommandName[w] = 0;
X            {
X               char buf[20];
X               sprintf(buf,"_%c%c",PAR_KEY(i),PAR_KEY(j));
X               strcat(PCommandName,buf);
X            }
X            fprintf(parmfile, "%-19s{",PCommandName);
X            xxmin = pxxmin + pdelx*(i*pxdots) + pdelx2*(j*pydots);
X            xxmax = pxxmin + pdelx*((i+1)*pxdots - 1) + pdelx2*((j+1)*pydots - 1);
X            yymin = pyymax - pdely*((j+1)*pydots - 1) - pdely2*((i+1)*pxdots - 1);
X            yymax = pyymax - pdely*(j*pydots) - pdely2*(i*pxdots);
X            if (have3rd)
X            {
X               xx3rd = pxxmin + pdelx*(i*pxdots) + pdelx2*((j+1)*pydots - 1);
X               yy3rd = pyymax - pdely*((j+1)*pydots - 1) - pdely2*(i*pxdots);
X            }
X            else
X            {
X               xx3rd = xxmin;
X               yy3rd = yymin;
X            }
X            fprintf(fpbat,"Fractint batch=yes overwrite=yes @%s/%s\n",CommandFile,PCommandName);
X            fprintf(fpbat,"If Errorlevel 2 goto oops\n");
X         }
X         else
X            fprintf(parmfile, "%-19s{", CommandName);
X         if (CommandComment1[0])
X            fprintf(parmfile, " ; %Fs", CommandComment1);
X         fputc('\n', parmfile);
X         {
X            char buf[25];
X            memset(buf, ' ', 23);
X            buf[23] = 0;
X            buf[21] = ';';
X            if (CommandComment2[0])
X               fprintf(parmfile, "%s%Fs\n", buf, CommandComment2);
X            if (CommandComment3[0])
X               fprintf(parmfile, "%s%Fs\n", buf, CommandComment3);
X            if (CommandComment4[0])
X               fprintf(parmfile, "%s%Fs\n", buf, CommandComment4);
X         }
X         write_batch_parms(parmfile, colorspec, maxcolor);   /* write the parameters */
X         if(xm > 1 || ym > 1)
X         {
X            fprintf(parmfile,"  video=%s", vidmde);
X            fprintf(parmfile," savename=frmig_%c%c\n", PAR_KEY(i), PAR_KEY(j));
X         }
X         fprintf(parmfile, "  }\n\n");
X      }
X      if(xm > 1 || ym > 1)
X         {
X         fprintf(fpbat,"Fractint makemig=%d/%d\n",xm,ym);
X         fprintf(fpbat,"Rem Simplgif fractmig.gif simplgif.gif  in case you need it\n");
X         fprintf(fpbat,":oops\n");
X         fclose(fpbat);
X         }
X/*******end here */
X
X      if (gotinfile)
X      {                         /* copy the rest of the file */
X         while ((i = file_gets(buf, 255, infile)) == 0)
X         {
X         }                      /* skip blanks */
X         while (i >= 0)
X         {
X            fputs(buf, parmfile);
X            fputc('\n', parmfile);
X            i = file_gets(buf, 255, infile);
X         }
X         fclose(infile);
X      }
X      fclose(parmfile);
X      if (gotinfile)
X      {                         /* replace the original file with the new */
X         unlink(CommandFile);   /* success assumed on these lines       */
X         rename(outname, CommandFile);  /* since we checked earlier with
X                                         * access */
X      }
X      break;
X   }
X   helpmode = oldhelpmode;
X   unstackscreen();
X   EXIT_OVLY;
X}
X#ifdef C6
X#pragma optimize("e",on)  /* back to normal */
X#endif
X
Xstatic struct write_batch_data { /* buffer for parms to break lines nicely */
X   int len;
X   char buf[513];
X   } *wbdata;
X
Xstatic void write_batch_parms(FILE *batch,char *colorinf,int maxcolor)
X{
X   int i,j,k;
X   double Xctr, Yctr, Magnification;
X   struct write_batch_data wb_data;
X   char *sptr;
X   char buf[81];
X
X   wbdata = &wb_data;
X   wb_data.len = 0; /* force first parm to start on new line */
X
X   if (display3d <= 0) { /* a fractal was generated */
X
X      /****** fractal only parameters in this section *******/
X      put_parm(" reset");
X      if (save_release!=0) put_parm("=%d",save_release);
X
X      if (*(sptr = curfractalspecific->name) == '*') ++sptr;
X      put_parm( " type=%s",sptr);
X
X      if (fractype == JULIBROT || fractype == JULIBROTFP)
X      {
X           put_parm(" julibrotfromto=%.15g/%.15g/%.15g/%.15g",
X               mxmaxfp,mxminfp,mymaxfp,myminfp);
X         /* these rarely change */
X         if(originfp != 8 || heightfp != 7 || widthfp != 10 || distfp != 24
X                          || depthfp != 8 || zdots != 128)
X            put_parm(" julibrot3d=%d/%g/%g/%g/%g/%g",
X                zdots, originfp, depthfp, heightfp, widthfp,distfp);
X         if(eyesfp != 0)
X            put_parm(" julibroteyes=%g",eyesfp);
X         if(neworbittype != JULIA)
X         {
X            char *name;
X            name = fractalspecific[neworbittype].name;
X            if(*name=='*')
X               name++;
X            put_parm(" orbitname=%s",name);
X         }
X         if(juli3Dmode !=0)
X            put_parm(" 3Dmode=%s",juli3Doptions[juli3Dmode]);
X      }
X      if (fractype == FORMULA || fractype == FFORMULA)
X     put_parm( " formulafile=%s formulaname=%s",extract_filename(FormFileName),FormName);
X      if (fractype == LSYSTEM)
X     put_parm( " lfile=%s lname=%s",extract_filename(LFileName),LName);
X      if (fractype == IFS || fractype == IFS3D)
X     put_parm( " ifsfile=%s ifs=%s",extract_filename(IFSFileName),IFSName);
X      if (fractype == INVERSEJULIA || fractype == INVERSEJULIAFP)
X      {
X     extern int major_method, minor_method;
X     put_parm( " miim=%s/%s", major[major_method], minor[minor_method]);
X      }
X
X      showtrig(buf); /* this function is in miscres.c */
X      if (buf[0])
X     put_parm(buf);
X
X      if (usr_stdcalcmode != 'g')
X     put_parm(" passes=%c",usr_stdcalcmode);
X
X      if (usemag && cvtcentermag(&Xctr, &Yctr, &Magnification)) {
X     put_parm(" center-mag=");
X     put_parm((delmin > 1000) ? "%g/%g/%g"
X                  : "%+20.17lf/%+20.17lf/%+20.17lf",
X          Xctr,Yctr,Magnification);
X     }
X      else {
X     int xdigits,ydigits;
X     put_parm( " corners=");
X     xdigits = getprec(xxmin,xxmax,xx3rd);
X     ydigits = getprec(yymin,yymax,yy3rd);
X     put_float(0,xxmin,xdigits);
X     put_float(1,xxmax,xdigits);
X     put_float(1,yymin,ydigits);
X     put_float(1,yymax,ydigits);
X     if (xx3rd != xxmin || yy3rd != yymin) {
X        put_float(1,xx3rd,xdigits);
X        put_float(1,yy3rd,ydigits);
X        }
X     }
X
X      for (i = (MAXPARAMS-1); i >= 0; --i)
X     if (param[i] != 0.0) break;
X      if (i >= 0) {
X        if (fractype == CELLULAR)
X          put_parm(" params=%.1f",param[0]);
X        else
X#ifndef XFRACT
X     put_parm(" params=%.17Lg",(long double)param[0]);
X#else
X       put_parm(" params=%.17g",(double)param[0]);
X#endif
X     for (j = 1; j <= i; ++j)
X        if (fractype == CELLULAR)
X          put_parm("/%.1f",param[j]);
X        else
X#ifndef XFRACT
X        put_parm("/%.17Lg",(long double)param[j]);
X#else
X          put_parm("/%.17g",(double)param[j]);
X#endif
X     }
X
X      if(useinitorbit == 2)
X     put_parm( " initorbit=pixel");
X      else if(useinitorbit == 1)
X     put_parm( " initorbit=%.15g/%.15g",initorbit.x,initorbit.y);
X
X      if (floatflag)
X     put_parm( " float=y");
X
X      if (maxit != 150)
X     put_parm(" maxiter=%d",maxit);
X
X      if(bailout && (potflag == 0 || potparam[2] == 0.0))
X     put_parm( " bailout=%d",bailout);
X      if(fillcolor != -1) {
X       put_parm(" fillcolor=");
X    put_parm( "%d",fillcolor);
X      }
X      if (inside != 1) {
X     put_parm(" inside=");
X     if (inside == -1)
X        put_parm( s_maxiter);
X     else if (inside == -59)
X        put_parm(s_zmag);
X     else if (inside == -60)
X        put_parm(s_bof60);
X     else if (inside == -61)
X        put_parm(s_bof61);
X     else if (inside == -100)
X        put_parm(s_epscross);
X     else if (inside == -101)
X        put_parm(s_startrail);
X     else if (inside == -102)
X        put_parm(s_period);
X     else
X        put_parm( "%d",inside);
X     }
X      if (outside != -1)
X      {
X     put_parm(" outside=");
X     if (outside == -2)
X        put_parm(s_real);
X     else if (outside == -3)
X        put_parm(s_imag);
X     else if (outside == -4)
X        put_parm(s_mult);
X     else if (outside == -5)
X        put_parm(s_sum);
X     else
X        put_parm( "%d",outside);
X      }
X
X      if(LogFlag) {
X     put_parm( " logmap=");
X     if(LogFlag == -1)
X        put_parm( "old");
X     else if(LogFlag == 1)
X        put_parm( "yes");
X     else
X        put_parm( "%d", LogFlag);
X     }
X
X      if (potflag) {
X       put_parm( " potential=%d/%g/%d",
X           (int)potparam[0],potparam[1],(int)potparam[2]);
X       if(pot16bit)
X        put_parm( "/16bit");
X     }
X      if (invert)
X     put_parm( " invert=%g/%g/%g",
X         inversion[0], inversion[1], inversion[2]);
X      if (decomp[0])
X     put_parm( " decomp=%d", decomp[0]);
X      if (distest)
X     put_parm( " distest=%d/%d", distest, distestwidth);
X      if (usr_biomorph != -1)
X     put_parm( " biomorph=%d", usr_biomorph);
X      if (finattract)
X     put_parm(" finattract=y");
X
X      if (forcesymmetry != 999) {
X         static char far msg[] =
X            {"Regenerate before <b> to get correct symmetry"};
X         if(forcesymmetry == 1000)
X            stopmsg(0,msg);
X     put_parm( " symmetry=");
X     if (forcesymmetry==XAXIS)
X        put_parm("xaxis");
X     else if(forcesymmetry==YAXIS)
X        put_parm("yaxis");
X     else if(forcesymmetry==XYAXIS)
X        put_parm("xyaxis");
X     else if(forcesymmetry==ORIGIN)
X        put_parm("origin");
X     else if(forcesymmetry==PI_SYM)
X        put_parm("pi");
X     else
X        put_parm("none");
X     }
X
X      if (periodicitycheck != 1)
X     put_parm( " periodicity=%d",periodicitycheck);
X
X      if (rflag)
X     put_parm( " rseed=%d",rseed);
X
X      if (rangeslen) {
X     put_parm(" ranges=");
X     i = 0;
X     while (i < rangeslen) {
X        if (i)
X           put_parm("/");
X        if (ranges[i] == -1) {
X           put_parm("-%d/",ranges[++i]);
X           ++i;
X           }
X        put_parm("%d",ranges[i++]);
X        }
X     }
X      }
X
X   if (display3d >= 1) {
X      /***** 3d transform only parameters in this section *****/
X      if(display3d == 2)
X         put_parm( " 3d=overlay");
X      else
X      put_parm( " 3d=yes");
X      if (loaded3d == 0)
X     put_filename("filename",readname);
X      if (SPHERE) {
X     put_parm( " sphere=y");
X     put_parm( " latitude=%d/%d", THETA1, THETA2);
X     put_parm( " longitude=%d/%d", PHI1, PHI2);
X     put_parm( " radius=%d", RADIUS);
X     }
X      put_parm( " scalexyz=%d/%d", XSCALE, YSCALE);
X      put_parm( " roughness=%d", ROUGH);
X      put_parm( " waterline=%d", WATERLINE);
X      if (FILLTYPE)
X     put_parm( " filltype=%d", FILLTYPE);
X      if (transparent[0] || transparent[1])
X     put_parm( " transparent=%d/%d", transparent[0],transparent[1]);
X      if (preview) {
X     put_parm( " preview=y");
X     if (showbox)
X        put_parm( " showbox=y");
X     put_parm( " coarse=%d",previewfactor);
X     }
X      if (RAY) {
X     put_parm( " ray=%d",RAY);
X     if (BRIEF)
X        put_parm(" brief=y");
X     }
X      if (FILLTYPE > 4) {
X     put_parm( " lightsource=%d/%d/%d", XLIGHT, YLIGHT, ZLIGHT);
X     if (LIGHTAVG)
X        put_parm( " smoothing=%d", LIGHTAVG);
X     }
X      if (RANDOMIZE)
X     put_parm( " randomize=%d",RANDOMIZE);
X
X      if (Targa_Out)
X     put_parm( " fullcolor=y");
X      if (Ambient)
X     put_parm( " ambient=%d",Ambient);
X      if (haze)
X     put_parm( " haze=%d",haze);
X      }
X
X   if (display3d) {        /* universal 3d */
X      /***** common (fractal & transform) 3d parameters in this section *****/
X      if (!SPHERE || display3d < 0)
X     put_parm( " rotation=%d/%d/%d", XROT, YROT, ZROT);
X      put_parm( " perspective=%d", ZVIEWER);
X      put_parm( " xyshift=%d/%d", XSHIFT, YSHIFT);
X      if(xtrans || ytrans)
X     put_parm( " xyadjust=%d/%d",xtrans,ytrans);
X      if(glassestype) {
X     put_parm( " stereo=%d",glassestype);
X     put_parm( " interocular=%d",eyeseparation);
X     put_parm( " converge=%d",xadjust);
X     put_parm( " crop=%d/%d/%d/%d",
X         red_crop_left,red_crop_right,blue_crop_left,blue_crop_right);
X     put_parm( " bright=%d/%d",
X         red_bright,blue_bright);
X     }
X      }
X
X   /***** universal parameters in this section *****/
X
X   if(viewwindow == 1)
X   {
X      put_parm(" viewwindows=%g/%g",viewreduction,finalaspectratio);
X      if(viewcrop)
X         put_parm("/yes");
X      else
X         put_parm("/no");
X      put_parm("/%d/%d",viewxdots,viewydots);
X   }
X   if (*colorinf != 'n') {
X      put_parm(" colors=");
X      if (*colorinf == '@')
X     put_parm(colorinf);
X      else {
X     int curc,scanc,force,diffmag;
X     int delta,diff1[4][3],diff2[4][3];
X     curc = force = 0;
X     while (1) {
X        /* emit color in rgb 3 char encoded form */
X        for (j = 0; j < 3; ++j) {
X           if ((k = dacbox[curc][j]) < 10) k += '0';
X           else if (k < 36)            k += ('A' - 10);
X           else                   k += ('_' - 36);
X           buf[j] = k;
X           }
X        buf[3] = 0;
X        put_parm(buf);
X        if (++curc >= maxcolor)     /* quit if done last color */
X           break;
X        /* Next a P Branderhorst special, a tricky scan for smooth-shaded
X           ranges which can be written as <nn> to compress .par file entry.
X           Method used is to check net change in each color value over
X           spans of 2 to 5 color numbers.  First time for each span size
X           the value change is noted.  After first time the change is
X           checked against noted change.  First time it differs, a
X           a difference of 1 is tolerated and noted as an alternate
X           acceptable change.  When change is not one of the tolerated
X           values, loop exits. */
X        if (force) {
X           --force;
X           continue;
X           }
X        scanc = curc;
X        while (scanc < maxcolor) {     /* scan while same diff to next */
X           if ((i = scanc - curc) > 3) /* check spans up to 4 steps */
X          i = 3;
X           for (k = 0; k <= i; ++k) {
X          for (j = 0; j < 3; ++j) { /* check pattern of chg per color */
X             delta = (int)dacbox[scanc][j] - (int)dacbox[scanc-k-1][j];
X             if (k == scanc - curc)
X            diff1[k][j] = diff2[k][j] = delta;
X             else
X            if (delta != diff1[k][j] && delta != diff2[k][j]) {
X               diffmag = abs(delta - diff1[k][j]);
X               if (diff1[k][j] != diff2[k][j] || diffmag != 1)
X                  break;
X               diff2[k][j] = delta;
X               }
X             }
X          if (j < 3) break; /* must've exited from inner loop above */
X          }
X           if (k <= i) break;   /* must've exited from inner loop above */
X           ++scanc;
X           }
X        /* now scanc-1 is next color which must be written explicitly */
X        if (scanc - curc > 2) { /* good, we have a shaded range */
X           if (scanc != maxcolor) {
X          if (diffmag < 3) {  /* not a sharp slope change? */
X             force = 2;       /* force more between ranges, to stop  */
X             --scanc;          /* "drift" when load/store/load/store/ */
X             }
X          if (k) {          /* more of the same             */
X             force += k;
X             --scanc;
X             }
X          }
X           if (--scanc - curc > 1) {
X          put_parm("<%d>",scanc-curc);
X          curc = scanc;
X          }
X           else           /* changed our mind */
X          force = 0;
X           }
X        }
X     }
X      }
X
X   if (rotate_lo != 1 || rotate_hi != 255)
X      put_parm( " cyclerange=%d/%d",rotate_lo,rotate_hi);
X
X   while (wbdata->len) /* flush the buffer */
X      put_parm_line();
X}
X
Xstatic void put_filename(char *keyword,char *fname)
X{
X   char *p;
X   if (*fname && !endswithslash(fname)) {
X      if ((p = strrchr(fname, SLASHC)))
X     if (*(fname = p+1) == 0) return;
X      put_parm(" %s=%s",keyword,fname);
X      }
X}
X
X#ifndef XFRACT
Xstatic void put_parm(char *parm,...)
X#else
Xstatic void put_parm(va_alist)
Xva_dcl
X#endif
X{
X   char *bufptr;
X   va_list args;
X
X#ifndef XFRACT
X   va_start(args,parm);
X#else
X   char * parm;
X
X   va_start(args);
X   parm = va_arg(args,char *);
X#endif
X   if (*parm == ' '             /* starting a new parm */
X     && wbdata->len == 0)    /* skip leading space */
X      ++parm;
X   bufptr = wbdata->buf + wbdata->len;
X   vsprintf(bufptr,parm,args);
X   while (*(bufptr++))
X      ++wbdata->len;
X   while (wbdata->len > 200)
X      put_parm_line();
X}
X
X#define NICELINELEN 68
X#define MAXLINELEN  72
X
Xstatic void put_parm_line()
X{
X   int len,c;
X   if ((len = wbdata->len) > NICELINELEN) {
X      len = NICELINELEN+1;
X      while (--len != 0 && wbdata->buf[len] != ' ') { }
X      if (len == 0) {
X     len = NICELINELEN-1;
X     while (++len < MAXLINELEN
X       && wbdata->buf[len] && wbdata->buf[len] != ' ') { }
X     }
X      }
X   c = wbdata->buf[len];
X   wbdata->buf[len] = 0;
X   fputs("  ",parmfile);
X   fputs(wbdata->buf,parmfile);
X   if (c && c != ' ')
X      fputc('\\',parmfile);
X   fputc('\n',parmfile);
X   if ((wbdata->buf[len] = c) == ' ')
X      ++len;
X   wbdata->len -= len;
X   strcpy(wbdata->buf,wbdata->buf+len);
X}
X
Xstatic int getprec(double a,double b,double c)
X{
X   double diff,temp;
X   int digits;
X   double highv = 1.0E20;
X   if ((diff = fabs(a - b)) == 0.0) diff = highv;
X   if ((temp = fabs(a - c)) == 0.0) temp = highv;
X   if (temp < diff) diff = temp;
X   if ((temp = fabs(b - c)) == 0.0) temp = highv;
X   if (temp < diff) diff = temp;
X   digits = 7;
X   if(debugflag >= 700 && debugflag < 720 )
X      digits =  debugflag - 700;
X   while (diff < 1.0 && digits < 17) {
X      diff *= 10;
X      ++digits;
X      }
X   return(digits);
X}
X
Xstatic void put_float(int slash,double fnum,int prec)
X{  char buf[40];
X   char *bptr, *dptr;
X   bptr = buf;
X   if (slash)
X      *(bptr++) = '/';
X/*   sprintf(bptr,"%1.*f",prec,fnum); */
X#ifndef XFRACT
X     sprintf(bptr,"%1.*Lg",prec,(long double)fnum);
X#else
X     sprintf(bptr,"%1.*g",prec,(double)fnum);
X#endif
X
X   if ((dptr = strchr(bptr,'.'))) {
X      ++dptr;
X      bptr = buf + strlen(buf);
X      while (--bptr > dptr && *bptr == '0')
X     *bptr = 0;
X      }
X   put_parm(buf);
X}
X
X#ifndef XFRACT
Xvoid shell_to_dos()
X{
X   char *comspec;
X   /* from fractint.c & calls no ovlys, doesn't need ENTER_OVLY */
X   if ((comspec = getenv("COMSPEC")) == NULL)
X      printf("Cannot find COMMAND.COM.\n");
X   else {
X      putenv("PROMPT='EXIT' returns to FRACTINT.$_$p$g");
X      spawnl(P_WAIT, comspec, NULL);
X      }
X}
X#endif
X
X
Xvoid showfreemem()
X{
X#ifndef XFRACT
X   extern int num_adapters;
X   extern char *adapters[];
X   char *tempptr;
X   BYTE huge *fartempptr;
X   unsigned i,i2;
X   long j,j2;
X
X   extern char supervga_list;    /* from the list in VIDEO.ASM */
X   char adapter_name[8];      /* entry lenth from VIDEO.ASM */
X   char *adapter_ptr;
X
X   ENTER_OVLY(OVLY_MISCOVL);
X   printf("\n CPU type: %d  FPU type: %d  IIT FPU: %d  Video: %d",
X      cpu, fpu, iit, video_type);
X
X   adapter_ptr = &supervga_list;
X
X   for(i = 0 ; ; i++) {        /* find the SuperVGA entry */
X       int j;
X       memcpy(adapter_name , adapter_ptr, 8);
X       adapter_ptr += 8;
X       if (adapter_name[0] == ' ') break;    /* end-of-the-list */
X       if (adapter_name[6] == 0) continue;    /* not our adapter */
X       adapter_name[6] = ' ';
X       for (j = 0; j < 8; j++)
X           if(adapter_name[j] == ' ')
X               adapter_name[j] = 0;
X       printf("  Video chip: %d (%s)",i+1,adapter_name);
X       }
X   printf("\n\n");
X
X   i = j = 0;
X   i2 = 0x8000;
X   while ((i2 >>= 1) != 0)
X      if ((tempptr = malloc(i+i2)) != NULL) {
X     free(tempptr);
X     i += i2;
X     }
X   printf(" %d NEAR bytes free \n", i);
X   j2 = 0x80000;
X   while ((j2 >>= 1) != 0)
X      if ((fartempptr = (BYTE huge *)farmemalloc(j+j2)) != NULL) {
X     farmemfree((void far*)fartempptr);
X     j += j2;
X     }
X   printf(" %ld FAR bytes free \n\n press any key to continue...\n", j);
X   getakey();
X   EXIT_OVLY;
X#endif
X}
X
X
Xedit_text_colors()
X{
X   extern int debugflag;
X   extern int lookatmouse;
X   int save_debugflag,save_lookatmouse;
X   int row,col,bkgrd;
X   int rowf,colf,rowt,colt;
X   char far *vidmem;
X   char far *savescreen;
X   char far *farp1; char far *farp2;
X   int i,j,k;
X   ENTER_OVLY(OVLY_MISCOVL);
X   save_debugflag = debugflag;
X   save_lookatmouse = lookatmouse;
X   debugflag = 0;   /* don't get called recursively */
X   lookatmouse = 2; /* text mouse sensitivity */
X   row = col = bkgrd = rowt = rowf = colt = colf = 0;
X   vidmem = MK_FP(0xB800,0);
X   while (1) {
X      if (row < 0)  row = 0;
X      if (row > 24) row = 24;
X      if (col < 0)  col = 0;
X      if (col > 79) col = 79;
X      movecursor(row,col);
X      i = getakey();
X      if (i >= 'a' && i <= 'z') i -= 32; /* uppercase */
X      switch (i) {
X     case 27: /* esc */
X        debugflag = save_debugflag;
X        lookatmouse = save_lookatmouse;
X        movecursor(25,80);
X        EXIT_OVLY;
X        return 0;
X     case '/':
X        farp1 = savescreen = farmemalloc(4000L);
X        farp2 = vidmem;
X        for (i = 0; i < 4000; ++i) { /* save and blank */
X           *(farp1++) = *farp2;
X           *(farp2++) = 0;
X           }
X        for (i = 0; i < 8; ++i)      /* 8 bkgrd attrs */
X           for (j = 0; j < 16; ++j) { /* 16 fgrd attrs */
X          k = i*16 + j;
X          farp1 = vidmem + i*320 + j*10;
X          *(farp1++) = ' '; *(farp1++) = k;
X          *(farp1++) = i+'0'; *(farp1++) = k;
X          *(farp1++) = (j < 10) ? j+'0' : j+'A'-10; *(farp1++) = k;
X          *(farp1++) = ' '; *(farp1++) = k;
X          }
X        getakey();
X        farp1 = vidmem;
X        farp2 = savescreen;
X        for (i = 0; i < 4000; ++i) /* restore */
X           *(farp1++) = *(farp2++);
X        farmemfree(savescreen);
X        break;
X     case ',':
X        rowf = row; colf = col; break;
X     case '.':
X        rowt = row; colt = col; break;
X     case ' ': /* next color is background */
X        bkgrd = 1; break;
X     case 1075: /* cursor left  */
X        --col; break;
X     case 1077: /* cursor right */
X        ++col; break;
X     case 1072: /* cursor up    */
X        --row; break;
X     case 1080: /* cursor down  */
X        ++row; break;
X     case 13:   /* enter */
X        *(vidmem + row*160 + col*2) = getakey();
X        break;
X     default:
X        if (i >= '0' && i <= '9')      i -= '0';
X        else if (i >= 'A' && i <= 'F') i -= 'A'-10;
X        else break;
X        for (j = rowf; j <= rowt; ++j)
X           for (k = colf; k <= colt; ++k) {
X          farp1 = vidmem + j*160 + k*2 + 1;
X          if (bkgrd) *farp1 = (*farp1 & 15) + i * 16;
X          else         *farp1 = (*farp1 & 0xf0) + i;
X          }
X        bkgrd = 0;
X     }
X      }
X}
X
X
Xextern int badconfig;
Xextern struct videoinfo far videotable[];
Xextern struct videoinfo far *vidtbl;
Xextern int vidtbllen;
Xextern int tabmode;
Xextern int adapter;
Xstatic int *entsptr;
Xstatic int modes_changed;
Xextern int mode7text;
X
Xint select_video_mode(int curmode)
X{
X   static char far hdg2[]={"key...name......................xdot.ydot.colr.comment.................."};
X   static char far hdg1[]={"Select Video Mode"};
X   int entnums[MAXVIDEOMODES];
X   int attributes[MAXVIDEOMODES];
X   int i,j,k,ret;
X   int oldtabmode,oldhelpmode;
X
X   ENTER_OVLY(OVLY_MISCOVL);
X
X   load_fractint_cfg(0);    /* load fractint.cfg to extraseg */
X
X   for (i = 0; i < vidtbllen; ++i) { /* init tables */
X      entnums[i] = i;
X      attributes[i] = 1;
X      }
X   entsptr = entnums;        /* for indirectly called subroutines */
X
X   qsort(entnums,vidtbllen,sizeof(entnums[0]),entcompare); /* sort modes */
X
X   /* pick default mode */
X   if (curmode < 0) {
X      switch (video_type) { /* set up a reasonable default (we hope) */
X     case 1:  videoentry.videomodeax = 8;    /* hgc */
X          videoentry.colors = 2;
X          break;
X     case 2:  videoentry.videomodeax = 4;    /* cga */
X          videoentry.colors = 4;
X          break;
X     case 3:  videoentry.videomodeax = 16;    /* ega */
X          videoentry.colors = 16;
X          if (mode7text) {        /* egamono */
X             videoentry.videomodeax = 15;
X             videoentry.colors = 2;
X             }
X          break;
X     default: videoentry.videomodeax = 19;    /* mcga/vga? */
X          videoentry.colors = 256;
X          break;
X     }
X      }
X   else
X      far_memcpy((char far *)&videoentry,(char far *)&videotable[curmode],
X         sizeof(videoentry));
X#ifndef XFRACT
X   for (i = 0; i < vidtbllen; ++i) { /* find default mode */
X      if ( videoentry.videomodeax == vidtbl[entnums[i]].videomodeax
X    && videoentry.colors      == vidtbl[entnums[i]].colors
X    && (curmode < 0
X        || far_memcmp((char far *)&videoentry,(char far *)&vidtbl[entnums[i]],
X              sizeof(videoentry)) == 0))
X     break;
X      }
X   if (i >= vidtbllen) /* no match, default to first entry */
X      i = 0;
X
X   oldtabmode = tabmode;
X   oldhelpmode = helpmode;
X   modes_changed = 0;
X   tabmode = 0;
X   helpmode = HELPVIDSEL;
X   i = fullscreen_choice(CHOICEHELP,hdg1,hdg2,NULL,vidtbllen,NULL,attributes,
X                         1,16,72,i,format_item,NULL,NULL,check_modekey);
X   tabmode = oldtabmode;
X   helpmode = oldhelpmode;
X   if (i == -1) {
X   static char far msg[]={"Save new function key assignments or cancel changes?"};
X      if (modes_changed /* update fractint.cfg for new key assignments */
X    && badconfig == 0
X    && stopmsg(22,msg) == 0)
X     update_fractint_cfg();
X      EXIT_OVLY;
X      return(-1);
X      }
X   if (i < 0)    /* picked by function key */
X      i = -1 - i;
X   else     /* picked by Enter key */
X      i = entnums[i];
X#endif
X   far_memcpy((char far *)&videoentry,(char far *)&vidtbl[i],
X          sizeof(videoentry));  /* the selected entry now in videoentry */
X
X#ifndef XFRACT
X   /* copy fractint.cfg table to resident table, note selected entry */
X   j = k = 0;
X   far_memset((char far *)videotable,0,sizeof(*vidtbl)*MAXVIDEOTABLE);
X   for (i = 0; i < vidtbllen; ++i) {
X      if (vidtbl[i].keynum > 0) {
X     far_memcpy((char far *)&videotable[j],(char far *)&vidtbl[i],
X            sizeof(*vidtbl));
X     if (far_memcmp((char far *)&videoentry,(char far *)&vidtbl[i],
X            sizeof(videoentry)) == 0)
X        k = vidtbl[i].keynum;
X     if (++j >= MAXVIDEOTABLE-1)
X        break;
X     }
X      }
X#else
X    k = vidtbl[0].keynum;
X#endif
X   if ((ret = k) == 0) { /* selected entry not a copied (assigned to key) one */
X      far_memcpy((char far *)&videotable[MAXVIDEOTABLE-1],
X         (char far *)&videoentry,sizeof(*vidtbl));
X      ret = 1400; /* special value for check_vidmode_key */
X      }
X
X   if (modes_changed /* update fractint.cfg for new key assignments */
X     && badconfig == 0)
X      update_fractint_cfg();
X
X   EXIT_OVLY;
X   return(ret);
X}
X
Xstatic void format_item(int choice,char *buf)
X{
X   char kname[5];
X   char biosflag;
X   far_memcpy((char far *)&videoentry,(char far *)&vidtbl[entsptr[choice]],
X          sizeof(videoentry));
X   vidmode_keyname(videoentry.keynum,kname);
X   biosflag = (videoentry.dotmode % 100 == 1) ? 'B' : ' ';
X   sprintf(buf,"%-5s %-25s %4d %4d %3d%c %-25s",  /* 72 chars */
X       kname, videoentry.name, videoentry.xdots, videoentry.ydots,
X       videoentry.colors, biosflag, videoentry.comment);
X}
X
Xstatic int check_modekey(int curkey,int choice)
X{
X   int i,j,k,ret;
X   if ((i = check_vidmode_key(1,curkey)) >= 0)
X      return(-1-i);
X   i = entsptr[choice];
X   ret = 0;
X   if ( (curkey == '-' || curkey == '+')
X     && (vidtbl[i].keynum == 0 || vidtbl[i].keynum >= 1084)) {
X      static char far msg[]={"Missing or bad FRACTINT.CFG file. Can't reassign keys."};
X      if (badconfig)
X     stopmsg(0,msg);
X      else {
X     if (curkey == '-') {                   /* deassign key? */
X        if (vidtbl[i].keynum >= 1084) {
X           vidtbl[i].keynum = 0;
X           modes_changed = 1;
X           }
X        }
X     else {                 /* assign key? */
X        j = getakeynohelp();
X        if (j >= 1084 && j <= 1113) {
X           for (k = 0; k < vidtbllen; ++k) {
X          if (vidtbl[k].keynum == j) {
X             vidtbl[k].keynum = 0;
X             ret = -1; /* force redisplay */
X             }
X          }
X           vidtbl[i].keynum = j;
X           modes_changed = 1;
X           }
X        }
X     }
X      }
X   return(ret);
X}
X
Xstatic int entcompare(VOIDCONSTPTR p1,VOIDCONSTPTR p2)
X{
X   int i,j;
X   if ((i = vidtbl[*((int *)p1)].keynum) == 0) i = 9999;
X   if ((j = vidtbl[*((int *)p2)].keynum) == 0) j = 9999;
X   if (i < j || (i == j && *((int *)p1) < *((int *)p2)))
X      return(-1);
X   return(1);
X}
X
Xstatic void update_fractint_cfg()
X{
X#ifndef XFRACT
X   char cfgname[100],outname[100],buf[121],kname[5];
X   FILE *cfgfile,*outfile;
X   int far *cfglinenums;
X   int i,j,linenum,nextlinenum,nextmode;
X   struct videoinfo vident;
X
X   findpath("fractint.cfg",cfgname);
X
X   if (access(cfgname,6)) {
X      sprintf(buf,s_cantwrite,cfgname);
X      stopmsg(0,buf);
X      return;
X      }
X   strcpy(outname,cfgname);
X   i = strlen(outname);
X   while (--i >= 0 && outname[i] != SLASHC)
X   outname[i] = 0;
X   strcat(outname,"fractint.tmp");
X   if ((outfile = fopen(outname,"w")) == NULL) {
X      sprintf(buf,s_cantcreate,outname);
X      stopmsg(0,buf);
X      return;
X      }
X   cfgfile = fopen(cfgname,"r");
X
X   cfglinenums = (int far *)(&vidtbl[MAXVIDEOMODES]);
X   linenum = nextmode = 0;
X   nextlinenum = cfglinenums[0];
X   while (fgets(buf,120,cfgfile)) {
X      ++linenum;
X      if (linenum == nextlinenum) { /* replace this line */
X     far_memcpy((char far *)&vident,(char far *)&vidtbl[nextmode],
X            sizeof(videoentry));
X     vidmode_keyname(vident.keynum,kname);
X     strcpy(buf,vident.name);
X     i = strlen(buf);
X     while (i && buf[i-1] == ' ') /* strip trailing spaces to compress */
X        --i;
X     j = i + 5;
X     while (j < 32) {        /* tab to column 33 */
X        buf[i++] = '\t';
X        j += 8;
X        }
X     buf[i] = 0;
X     fprintf(outfile,"%-4s,%s,%4x,%4x,%4x,%4x,%4d,%4d,%4d,%3d,%s\n",
X        kname,
X        buf,
X        vident.videomodeax,
X        vident.videomodebx,
X        vident.videomodecx,
X        vident.videomodedx,
X        vident.dotmode,
X        vident.xdots,
X        vident.ydots,
X        vident.colors,
X        vident.comment);
X     if (++nextmode >= vidtbllen)
X        nextlinenum = 32767;
X     else
X        nextlinenum = cfglinenums[nextmode];
X     }
X      else
X     fputs(buf,outfile);
X      }
X
X   fclose(cfgfile);
X   fclose(outfile);
X   unlink(cfgname);        /* success assumed on these lines        */
X   rename(outname,cfgname); /* since we checked earlier with access */
X#endif
X}
X
Xextern unsigned char olddacbox[256][3];
Xextern int gif87a_flag;
X
X/* make_mig() takes a collection of individual GIF images (all
X   presumably the same resolution and all presumably generated
X   by Fractint and its "divide and conquer" algorithm) and builds
X   a single multiple-image GIF out of them.  This routine is
X   invoked by the "batch=stitchmode/x/y" option, and is called
X   with the 'x' and 'y' parameters
X*/
X
Xmake_mig(unsigned int xmult, unsigned int ymult)
X{
Xunsigned int xstep, ystep;
Xunsigned int xres, yres;
Xunsigned int allxres, allyres, xtot, ytot;
Xunsigned int xloc, yloc;
Xunsigned int x, y;
Xunsigned char ichar;
Xunsigned int allitbl, itbl;
Xunsigned int i, j, k;
Xchar gifin[15], gifout[15];
Xint errorflag, inputerrorflag;
Xunsigned char *temp;
XFILE *out, *in;
Xchar msgbuf[81];
X
Xerrorflag = 0;                /* no errors so far */
X
Xstrcpy(gifout,"fractmig.gif");
X
Xtemp= &olddacbox[0][0];            /* a safe place for our temp data */
X
Xgif87a_flag = 1;            /* for now, force this */
X
X/* process each input image, one at a time */
Xfor (ystep = 0; ystep < ymult; ystep++) {
X    for (xstep = 0; xstep < xmult; xstep++) {
X
Xif (xstep == 0 && ystep == 0) {        /* first time through? */
X    static char far msg1[] = "Cannot create output file %s!\n";
X    static char far msg2[] = " \n Generating multi-image GIF file %s using";
X    static char far msg3[] = " %d X and %d Y components\n\n";
X    _fstrcpy(msgbuf, msg2);
X    printf(msgbuf, gifout);
X    _fstrcpy(msgbuf, msg3);
X    printf(msgbuf, xmult, ymult);
X    /* attempt to create the output file */
X    if ((out = fopen(gifout,"wb")) == NULL) {
X        _fstrcpy(msgbuf, msg1);
X        printf(msgbuf, gifout);
X        exit(1);
X        }
X    }
X
X        sprintf(gifin, "frmig_%c%c.gif", PAR_KEY(xstep), PAR_KEY(ystep));
X
X        if ((in = fopen(gifin,"rb")) == NULL) {
X            static char far msg1[] = "Can't open file %s!\n";
X            _fstrcpy(msgbuf, msg1);
X            printf(msgbuf, gifin);
X            exit(1);
X            }
X
X        inputerrorflag = 0;
X
X        /* (read, but only copy this if it's the first time through) */
X        if (fread(temp,13,1,in) != 1)    /* read the header and LDS */
X            inputerrorflag = 1;
X        memcpy(&xres, &temp[6], 2);    /* X-resolution */
X        memcpy(&yres, &temp[8], 2);    /* Y-resolution */
X
X        if (xstep == 0 && ystep == 0) {    /* first time through? */
X            allxres = xres;        /* save the "master" resolution */
X            allyres = yres;
X            xtot = xres * xmult;    /* adjust the image size */
X            ytot = yres * ymult;
X            memcpy(&temp[6], &xtot, 2);
X            memcpy(&temp[8], &ytot, 2);
X            if (gif87a_flag) {
X                temp[3] = '8';
X                temp[4] = '7';
X                temp[5] = 'a';
X                }
X            if (fwrite(temp,13,1,out) != 1)    /* write out the header */
X                errorflag = 1;
X            }                /* end of first-time-through */
X
X
X        ichar = temp[10] & 0x07;    /* find the color table size */
X        itbl = 1 << (++ichar);
X        ichar = temp[10] & 0x80;    /* is there a global color table? */
X        if (xstep == 0 && ystep == 0)    /* first time through? */
X            allitbl = itbl;        /* save the color table size */
X        if (ichar != 0) {        /* yup */
X            /* (read, but only copy this if it's the first time through) */
X            if(fread(temp,3*itbl,1,in) != 1)    /* read the global color table */
X                inputerrorflag = 2;
X            if (xstep == 0 && ystep == 0)    /* first time through? */
X                if (fwrite(temp,3*itbl,1,out) != 1)    /* write out the GCT */
X                    errorflag = 2;
X            }
X
X        if (xres != allxres || yres != allyres || itbl != allitbl) {
X            /* Oops - our pieces don't match */
X            static char far msg1[] = "File %s doesn't have the same resolution as its predecessors!\n";
X            _fstrcpy(msgbuf, msg1);
X            printf(msgbuf, gifin);
X            exit(1);
X            }
X
X        for (;;) {            /* process each information block */
X        if (fread(temp,1,1,in) != 1)    /* read the block identifier */
X            inputerrorflag = 3;
X
X        if (temp[0] == 0x2c) {        /* image descriptor block */
X            if (fread(&temp[1],9,1,in) != 1)    /* read the Image Descriptor */
X                inputerrorflag = 4;
X            memcpy(&xloc, &temp[1], 2);    /* X-location */
X            memcpy(&yloc, &temp[3], 2);    /* Y-location */
X            xloc += (xstep * xres);    /* adjust the locations */
X            yloc += (ystep * yres);
X            memcpy(&temp[1], &xloc, 2);
X            memcpy(&temp[3], &yloc, 2);
X            if (fwrite(temp,10,1,out) != 1)    /* write out the Image Descriptor */
X                errorflag = 4;
X
X            ichar = temp[9] & 0x80;    /* is there a local color table? */
X            if (ichar != 0) {        /* yup */
X                if (fread(temp,3*itbl,1,in) != 1)    /* read the local color table */
X                    inputerrorflag = 5;
X                if (fwrite(temp,3*itbl,1,out) != 1)    /* write out the LCT */
X                    errorflag = 5;
X                }
X
X            if (fread(temp,1,1,in) != 1)    /* LZH table size */
X                inputerrorflag = 6;
X            if (fwrite(temp,1,1,out) != 1)
X                errorflag = 6;
X            while (1) {
X                if (errorflag != 0 || inputerrorflag != 0)    /* oops - did something go wrong? */
X                    break;
X                if (fread(temp,1,1,in) != 1)    /* block size */
X                    inputerrorflag = 7;
X                if (fwrite(temp,1,1,out) != 1)
X                    errorflag = 7;
X                if ((i = temp[0]) == 0)
X                    break;
X                if (fread(temp,i,1,in) != 1)    /* LZH data block */
X                    inputerrorflag = 8;
X                if (fwrite(temp,i,1,out) != 1)
X                    errorflag = 8;
X                }
X            }
X
X        if (temp[0] == 0x21) {        /* extension block */
X            /* (read, but only copy this if it's the last time through) */
X            if (fread(&temp[2],1,1,in) != 1)    /* read the block type */
X                inputerrorflag = 9;
X            if ((!gif87a_flag) && xstep == xmult-1 && ystep == ymult-1)
X                if (fwrite(temp,2,1,out) != 1)
X                    errorflag = 9;
X            while (1) {
X                if (errorflag != 0 || inputerrorflag != 0)    /* oops - did something go wrong? */
X                    break;
X                if (fread(temp,1,1,in) != 1)    /* block size */
X                    inputerrorflag = 10;
X                if ((!gif87a_flag) && xstep == xmult-1 && ystep == ymult-1)
X                    if (fwrite(temp,1,1,out) != 1)
X                        errorflag = 10;
X                if ((i = temp[0]) == 0)
X                    break;
X                if (fread(temp,i,1,in) != 1)    /* data block */
X                    inputerrorflag = 11;
X                if ((!gif87a_flag) && xstep == xmult-1 && ystep == ymult-1)
X                    if (fwrite(temp,i,1,out) != 1)
X                        errorflag = 11;
X                }
X            }
X
X        if (temp[0] == 0x3b) {        /* end-of-stream indicator */
X            break;            /* done with this file */
X            }
X
X        if (errorflag != 0 || inputerrorflag != 0)    /* oops - did something go wrong? */
X            break;
X
X        }
X        fclose(in);            /* done with an input GIF */
X
X        if (errorflag != 0 || inputerrorflag != 0)    /* oops - did something go wrong? */
X            break;
X        }
X
X    if (errorflag != 0 || inputerrorflag != 0)    /* oops - did something go wrong? */
X        break;
X    }
X
Xtemp[0] = 0x3b;            /* end-of-stream indicator */
Xif (fwrite(temp,1,1,out) != 1)
X    errorflag = 12;
Xfclose(out);            /* done with the output GIF */
X
Xif (inputerrorflag != 0) {    /* uh-oh - something failed */
X    static char far msg1[] = "\007 Process failed = early EOF on input file %s\n";
X    _fstrcpy(msgbuf, msg1);
X    printf(msgbuf, gifin);
X/* following line was for debugging
X    printf("inputerrorflag = %d\n", inputerrorflag);
X*/
X    }
X
Xif (errorflag != 0) {        /* uh-oh - something failed */
X    static char far msg1[] = "\007 Process failed = out of disk space?\n";
X    _fstrcpy(msgbuf, msg1);
X    printf(msgbuf);
X/* following line was for debugging
X    printf("errorflag = %d\n", errorflag);
X*/
X    }
X
X/* now delete each input image, one at a time */
Xif (errorflag == 0 && inputerrorflag == 0)
X  for (ystep = 0; ystep < ymult; ystep++) {
X    for (xstep = 0; xstep < xmult; xstep++) {
X        sprintf(gifin, "frmig_%c%c.gif", PAR_KEY(xstep), PAR_KEY(ystep));
X        remove(gifin);
X        }
X    }
X
X/* tell the world we're done */
Xif (errorflag == 0 && inputerrorflag == 0) {
X    static char far msg1[] = "File %s has been created (and its component files deleted)\n";
X    _fstrcpy(msgbuf, msg1);
X    printf(msgbuf, gifout);
X    }
X}
X
X/* This routine copies the current screen to by flipping x-axis, y-axis,
X   or both. Refuses to work if calculation in progress or if fractal
X   non-resumable. Clears zoombox if any. Resets corners so resulting fractal
X   is still valid. */
Xvoid flip_image(int key)
X{
X   int i, j, ix, iy, ixhalf, iyhalf, tempdot;
X
X   ENTER_OVLY(OVLY_MISCOVL);
X   /* fractal must be rotate-able and be finished */
X   if ((curfractalspecific->flags&NOROTATE) > 0
X       || calc_status == 1
X       || calc_status == 2)
X      return;
X   clear_zoombox(); /* clear, don't copy, the zoombox */
X   ixhalf = xdots / 2;
X   iyhalf = ydots / 2;
X   switch(key)
X   {
X   case 24:            /* control-X - reverse X-axis */
X      for (i = 0; i < ixhalf; i++)
X      {
X         if(keypressed())
X            break;
X         for (j = 0; j < ydots; j++)
X         {
X            tempdot=getcolor(i,j);
X            putcolor(i, j, getcolor(xdots-1-i,j));
X            putcolor(xdots-1-i, j, tempdot);
X         }
X      }
X      sxmin = xxmax + xxmin - xx3rd;
X      symax = yymax + yymin - yy3rd;
X      sxmax = xx3rd;
X      symin = yy3rd;
X      sx3rd = xxmax;
X      sy3rd = yymin;
X      reset_zoom_corners();
X      calc_status = 0;
X      break;
X   case 25:            /* control-Y - reverse Y-aXis */
X      for (j = 0; j < iyhalf; j++)
X      {
X         if(keypressed())
X            break;
X         for (i = 0; i < xdots; i++)
X         {
X            tempdot=getcolor(i,j);
X            putcolor(i, j, getcolor(i,ydots-1-j));
X            putcolor(i,ydots-1-j, tempdot);
X         }
X      }
X      sxmin = xx3rd;
X      symax = yy3rd;
X      sxmax = xxmax + xxmin - xx3rd;
X      symin = yymax + yymin - yy3rd;
X      sx3rd = xxmin;
X      sy3rd = yymax;
X      calc_status = 0;
X      break;
X   case 26:            /* control-Z - reverse X and Y aXis */
X      for (i = 0; i < ixhalf; i++)
X      {
X         if(keypressed())
X            break;
X         for (j = 0; j < ydots; j++)
X         {
X            tempdot=getcolor(i,j);
X            putcolor(i, j, getcolor(xdots-1-i,ydots-1-j));
X            putcolor(xdots-1-i, ydots-1-j, tempdot);
X         }
X      }
X      sxmin = xxmax;
X      symax = yymin;
X      sxmax = xxmin;
X      symin = yymax;
X      sx3rd = xxmax + xxmin - xx3rd;
X      sy3rd = yymax + yymin - yy3rd;
X      break;
X   }
X   reset_zoom_corners();
X   calc_status = 0;
X   EXIT_OVLY;
X}
X
SHAR_EOF
$TOUCH -am 1028230093 miscovl.c &&
chmod 0644 miscovl.c ||
echo "restore of miscovl.c failed"
set `wc -c miscovl.c`;Wc_c=$1
if test "$Wc_c" != "56485"; then
    echo original size 56485, current size $Wc_c
fi
# ============= miscres.c ==============
echo "x - extracting miscres.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > miscres.c &&
X/*
X    Resident odds and ends that don't fit anywhere else.
X*/
X
X#include <string.h>
X#include <stdlib.h>
X#include <stdio.h>
X#include <ctype.h>
X#include <time.h>
X#ifndef XFRACT
X#include <stdarg.h>
X#include <io.h>
X#else
X#include <varargs.h>
X#endif
X#include <math.h>
X#ifdef __TURBOC__
X#include <dir.h>
X#endif
X
X#include "fractint.h"
X#include "fractype.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic    void trigdetails(char *);
Xstatic void area();
X
Xint active_ovly = -1;
X
Xextern char IFSFileName[80];
Xextern char IFSName[40];
Xextern float far *ifs_defn;
Xextern int  ifs_changed;
Xextern int  ifs_type;
Xextern int neworbittype;
Xextern char temp[], temp1[256];   /* temporary strings          */
X
Xextern int  active_ovly;
Xextern int  xdots, ydots;
Xextern int  dotmode;
Xextern int  show_orbit;
Xextern int  debugflag;
Xextern int  maxit;
Xextern int  fractype;
Xextern int  got_status,curpass,totpasses,currow,curcol;
Xextern int  fileydots;
Xextern int  xxstart,xxstop,yystart,yystop;
Xextern int  display3d;
Xextern char overwrite;
Xextern int  inside;
Xextern int  outside;
Xextern double xxmax,xxmin,yymax,yymin,xx3rd,yy3rd;
X
X
X/* TW's static string consolidation campaign to help brain-dead compilers */
Xchar s_cantopen[]       = {"Can't open %s"};
Xchar s_cantwrite[]      = {"Can't write %s"};
Xchar s_cantcreate[]     = {"Can't create %s"};
Xchar s_cantunderstand[] = {"Can't understand %s"};
Xchar s_cantfind[]       = {"Can't find %s"};
X
X/* call next when returning from resident routine and unsure whether
X   caller is an overlay which has been displaced */
Xvoid restore_active_ovly()
X{
X
X   switch (active_ovly) {
X      case OVLY_MISCOVL:  miscovl_overlay();  break;
X      case OVLY_CMDFILES: cmdfiles_overlay(); break;
X      case OVLY_HELP:      help_overlay();     break;
X      case OVLY_PROMPTS1: prompts1_overlay(); break;
X      case OVLY_PROMPTS2: prompts2_overlay(); break;
X      case OVLY_LOADFILE: loadfile_overlay(); break;
X      case OVLY_ROTATE:   rotate_overlay();   break;
X      case OVLY_PRINTER:  printer_overlay();  break;
X      case OVLY_LINE3D:   line3d_overlay();   break;
X      case OVLY_ENCODER:  encoder_overlay();  break;
X      case OVLY_CALCFRAC: calcfrac_overlay(); break;
X      case OVLY_INTRO:      intro_overlay();    break;
X      case OVLY_DECODER:  decoder_overlay();  break;
X      }
X}
X
X
X#ifndef XFRACT
Xextern int splitpath(char *template,char *drive,char *dir,char *fname,char *ext);
Xextern int makepath(char *template,char *drive,char *dir,char *fname,char *ext);
X
Xvoid findpath(char *filename, char *fullpathname) /* return full pathnames */
X{
X   char fname[FILE_MAX_FNAME];
X   char ext[FILE_MAX_EXT];
X   extern int first_init;
X   if (filename[0] == SLASHC || (filename[0] && filename[1] == ':')) {
X      if(access(filename,0)==0) {   /* file exists */
X         strcpy(fullpathname,filename);
X         return;
X         }
X      else {
X         splitpath(filename ,NULL,NULL,fname,ext);
X         makepath(filename,""   ,"" ,fname,ext);
X         }
X      }
X   fullpathname[0] = 0;             /* indicate none found */
X#ifdef __TURBOC__                /* look for the file */
X   strcpy(fullpathname,searchpath(filename));
X#else
X   _searchenv(filename,"PATH",fullpathname);
X#endif
X   if (fullpathname[0] != 0)            /* found it! */
X      if (strncmp(&fullpathname[2],SLASHSLASH,2) == 0) /* stupid klooge! */
X     strcpy(&fullpathname[3],filename);
X}
X#endif
X
X
Xvoid notdiskmsg()
X{
Xstatic char far sorrymsg[]={
X"This type may be slow using a real-disk based 'video' mode, but may not \n\
Xbe too bad if you have enough expanded or extended memory. Press <Esc> to \n\
Xabort if it appears that your disk drive is working too hard."};
X   stopmsg(0,sorrymsg);
X}
X
X
X/* convert corners to center/mag */
Xint cvtcentermag(double *Xctr, double *Yctr, double *Magnification)
X{
X   double Width, Height, Radius, Ratio;
X   Width  = xxmax - xxmin;
X   Height = yymax - yymin;
X   Ratio = Height / Width;
X   if(xx3rd != xxmin || yy3rd != yymin || Width < 0
X     || (Width > 1e-8 && (Ratio <= 0.74 || Ratio >= 0.76))
X     || Ratio < 0.66 || Ratio > 0.84)
X      return(0);
X   /* calculate center and magnification */
X   Radius = Height / 2.0;
X   *Xctr = xxmin + (Width / 2.0);
X   *Yctr = yymin + Radius;
X   *Magnification = 1.0 / Radius;
X   return(1);
X}
X
X
Xvoid updatesavename(char *filename) /* go to the next file name */
X{
X   char *save, *hold;
X   char name[80],suffix[80];
X   char *dotptr;
X
X   strcpy(name,filename);
X   suffix[0] = 0;
X   if ((dotptr = strrchr(name,'.')) != NULL
X     && dotptr > strrchr(name,SLASHC)) {
X      strcpy(suffix,dotptr);
X      *dotptr = 0;
X      }
X
X   hold = name + strlen(name) - 1; /* start at the end */
X   while(hold >= name && (*hold == ' ' || isdigit(*hold))) /* skip backwards */
X      hold--;
X   hold++;            /* recover first digit */
X   while (*hold == '0')         /* skip leading zeros */
X      hold++;
X   save = hold;
X   while (*save) {        /* check for all nines */
X      if (*save != '9')
X     break;
X      save++;
X      }
X   if (!*save)            /* if the whole thing is nines then back */
X      save = hold - 1;        /* up one place. Note that this will eat */
X                /* your last letter if you go to far.     */
X   else
X      save = hold;
X   sprintf(save,"%d",atoi(hold)+1); /* increment the number */
X   strcpy(filename,name);
X   strcat(filename,suffix);
X}
X
Xint check_writefile(char *name,char *ext)
X{
X /* after v16 release, change encoder.c to also use this routine */
X   char openfile[80];
X   char opentype[20];
X   int i;
Xnextname:
X   strcpy(openfile,name);
X   strcpy(opentype,ext);
X   for (i = 0; i < strlen(openfile); i++)
X      if (openfile[i] == '.') {
X     strcpy(opentype,&openfile[i]);
X     openfile[i] = 0;
X     }
X   strcat(openfile,opentype);
X   if (access(openfile,0) != 0) /* file doesn't exist */
X   {
X      strcpy(name,openfile);
X      return 0;
X    }
X   /* file already exists */
X   if (overwrite == 0) {
X      updatesavename(name);
X      goto nextname;
X      }
X   return 1;
X}
X
X/* ('check_key()' was moved to FRACTINT.C for MSC7-overlay speed purposes) */
X/* ('timer()'     was moved to FRACTINT.C for MSC7-overlay speed purposes) */
X
XBYTE trigndx[] = {SIN,SQR,SINH,COSH};
X#ifndef XFRACT
Xvoid (*ltrig0)(void) = lStkSin;
Xvoid (*ltrig1)(void) = lStkSqr;
Xvoid (*ltrig2)(void) = lStkSinh;
Xvoid (*ltrig3)(void) = lStkCosh;
Xvoid (*mtrig0)(void) = mStkSin;
Xvoid (*mtrig1)(void) = mStkSqr;
Xvoid (*mtrig2)(void) = mStkSinh;
Xvoid (*mtrig3)(void) = mStkCosh;
X#endif
Xvoid (*dtrig0)(void) = dStkSin;
Xvoid (*dtrig1)(void) = dStkSqr;
Xvoid (*dtrig2)(void) = dStkSinh;
Xvoid (*dtrig3)(void) = dStkCosh;
X
Xstruct trig_funct_lst trigfn[] =
X/* changing the order of these alters meaning of *.fra file */
X/* maximum 6 characters in function names or recheck all related code */
X{
X#ifndef XFRACT
X   {"sin",   lStkSin,   dStkSin,   mStkSin   },
X   {"cosxx", lStkCosXX, dStkCosXX, mStkCosXX },
X   {"sinh",  lStkSinh,  dStkSinh,  mStkSinh  },
X   {"cosh",  lStkCosh,  dStkCosh,  mStkCosh  },
X   {"exp",   lStkExp,   dStkExp,   mStkExp   },
X   {"log",   lStkLog,   dStkLog,   mStkLog   },
X   {"sqr",   lStkSqr,   dStkSqr,   mStkSqr   },
X   {"recip", lStkRecip, dStkRecip, mStkRecip }, /* from recip on new in v16 */
X   {"ident", StkIdent,  StkIdent,  StkIdent  },
X   {"cos",   lStkCos,   dStkCos,   mStkCos   },
X   {"tan",   lStkTan,   dStkTan,   mStkTan   },
X   {"tanh",  lStkTanh,  dStkTanh,  mStkTanh  },
X   {"cotan", lStkCoTan, dStkCoTan, mStkCoTan },
X   {"cotanh",lStkCoTanh,dStkCoTanh,mStkCoTanh},
X   {"flip",  lStkFlip,  dStkFlip,  mStkFlip  },
X   {"conj",  lStkConj,  dStkConj,  mStkConj  },
X   {"zero",  lStkZero,  dStkZero,  mStkZero  },
X#else
X   {"sin",   dStkSin,   dStkSin,   dStkSin   },
X   {"cosxx", dStkCosXX, dStkCosXX, dStkCosXX },
X   {"sinh",  dStkSinh,  dStkSinh,  dStkSinh  },
X   {"cosh",  dStkCosh,  dStkCosh,  dStkCosh  },
X   {"exp",   dStkExp,   dStkExp,   dStkExp   },
X   {"log",   dStkLog,   dStkLog,   dStkLog   },
X   {"sqr",   dStkSqr,   dStkSqr,   dStkSqr   },
X   {"recip", dStkRecip, dStkRecip, dStkRecip }, /* from recip on new in v16 */
X   {"ident", StkIdent,  StkIdent,  StkIdent  },
X   {"cos",   dStkCos,   dStkCos,   dStkCos   },
X   {"tan",   dStkTan,   dStkTan,   dStkTan   },
X   {"tanh",  dStkTanh,  dStkTanh,  dStkTanh  },
X   {"cotan", dStkCoTan, dStkCoTan, dStkCoTan },
X   {"cotanh",dStkCoTanh,dStkCoTanh,dStkCoTanh},
X   {"flip",  dStkFlip,  dStkFlip,  dStkFlip  },
X   {"conj",  dStkConj,  dStkConj,  dStkConj  },
X   {"zero",  dStkZero,  dStkZero,  dStkZero  },
X#endif
X};
Xint numtrigfn = sizeof(trigfn)/sizeof(struct trig_funct_lst);
X
Xvoid showtrig(char *buf) /* return display form of active trig functions */
X{
X   char tmpbuf[30];
X   *buf = 0; /* null string if none */
X   trigdetails(tmpbuf);
X   if (tmpbuf[0])
X      sprintf(buf," function=%s",tmpbuf);
X}
X
Xstatic void trigdetails(char *buf)
X{
X   extern char maxfn;
X   int i, numfn;
X   char tmpbuf[20];
X   if(fractype==JULIBROT || fractype==JULIBROTFP)
X      numfn = (fractalspecific[neworbittype].flags >> 6) & 7;
X   else
X      numfn = (curfractalspecific->flags >> 6) & 7;
X   if(curfractalspecific == &fractalspecific[FORMULA] ||
X      curfractalspecific == &fractalspecific[FFORMULA]    )
X      numfn = maxfn;
X   *buf = 0; /* null string if none */
X   if (numfn>0) {
X      strcpy(buf,trigfn[trigndx[0]].name);
X      i = 0;
X      while(++i < numfn) {
X     sprintf(tmpbuf,"/%s",trigfn[trigndx[i]].name);
X     strcat(buf,tmpbuf);
X     }
X      }
X}
X
X/* set array of trig function indices according to "function=" command */
Xint set_trig_array(int k, char *name)
X{
X   char trigname[10];
X   int i;
X   char *slash;
X   strncpy(trigname,name,6);
X   trigname[6] = 0; /* safety first */
X
X   if ((slash = strchr(trigname,'/')))
X      *slash = 0;
X
X   strlwr(trigname);
X
X   for(i=0;i<numtrigfn;i++)
X   {
X      if(strcmp(trigname,trigfn[i].name)==0)
X      {
X     trigndx[k] = i;
X     set_trig_pointers(k);
X     break;
X      }
X   }
X   return(0);
X}
Xvoid set_trig_pointers(int which)
X{
X  /* set trig variable functions to avoid array lookup time */
X   int i;
X   switch(which)
X   {
X   case 0:
X#ifndef XFRACT
X      ltrig0 = trigfn[trigndx[0]].lfunct;
X      mtrig0 = trigfn[trigndx[0]].mfunct;
X#endif
X      dtrig0 = trigfn[trigndx[0]].dfunct;
X      break;
X   case 1:
X#ifndef XFRACT
X      ltrig1 = trigfn[trigndx[1]].lfunct;
X      mtrig1 = trigfn[trigndx[1]].mfunct;
X#endif
X      dtrig1 = trigfn[trigndx[1]].dfunct;
X      break;
X   case 2:
X#ifndef XFRACT
X      ltrig2 = trigfn[trigndx[2]].lfunct;
X      mtrig2 = trigfn[trigndx[2]].mfunct;
X#endif
X      dtrig2 = trigfn[trigndx[2]].dfunct;
X      break;
X   case 3:
X#ifndef XFRACT
X      ltrig3 = trigfn[trigndx[3]].lfunct;
X      mtrig3 = trigfn[trigndx[3]].mfunct;
X#endif
X      dtrig3 = trigfn[trigndx[3]].dfunct;
X      break;
X   default: /* do 'em all */
X      for(i=0;i<4;i++)
X     set_trig_pointers(i);
X      break;
X   }
X}
X
X
Xint tab_display()    /* display the status of the current image */
X{
X/* TW's static string consolidation campaign to help brain-dead compilers */
X   static char far sfractal_type[] =     {"Fractal type:"};
X   static char far s3D_transform[] =     {"3D Transform"};
X   static char far syou_are_cycling[] =  {"You are in color-cycling mode"};
X   static char far sfloating_point[] =   {"Floating-point"};
X   static char far sruns_forever[] =     {"Note: this type runs forever."};
X   static char far ssolid_guessing[] =   {"Solid Guessing"};
X   static char far sboundary_tracing[] = {"Boundary Tracing"};
X   static char far stesseral[] =         {"Tesseral"};
X   static char far scalculation_time[] = {"Calculation time:"};
X   static char far scornersxy[] =        {"Corners:                X                     Y"};
X   static char far stop_left[] =         {"top-left"};
X   static char far sbottom_right[] =     {"bottom-right"};
X   static char far scenter[] =           {"Center: "};
X   static char far smag[] =              {"  Mag: "};
X   static char far sbottom_left[] =      {"bottom-left"};
X   static char far sparams[] =           {"Params,"};
X   static char far siteration_maximum[] ={"Iteration maximum: "};
X   static char far seffective_bailout[] ={"     Effective bailout: "};
X   static char far scurrent_rseed[] =    {"Current 'rseed': "};
X   static char far sinversion_radius[] = {"Inversion radius: "};
X   static char far sxcenter[] =          {"  xcenter: "};
X   static char far sycenter[] =          {"  ycenter: "};
X   static char far sparms_chgd[] = {"Parms chgd since generated"};
X   static char far sstill_being[] = {"Still being generated"};
X   static char far sinterrupted_resumable[] = {"Interrupted, resumable"};
X   static char far sinterrupted_non_resumable[] = {"Interrupted, non-resumable"};
X   static char far simage_completed[] = {"Image completed"};
X   static char far sflag_is_activated[] = {" flag is activated"};
X   static char far sinteger_math[]      = {"Integer math is in use"};
X   static char far sin_use_required[] = {" in use (required)"};
X
X   extern char floatflag;
X   extern char usr_floatflag;
X   extern double param[];
X   extern double rqlim;
X   extern long calctime, timer_start;
X   extern int  calc_status;
X   extern char FormName[];
X   extern char LName[];
X   extern char IFSName[];
X   extern int  rseed;
X   extern int  invert;
X   int row, i, j;
X   double Xctr, Yctr, Magnification;
X   char msg[81];
X   char far *msgptr;
X   int key;
X
X   if (calc_status < 0)     /* no active fractal image */
X      return(0);        /* (no TAB on the credits screen) */
X   if (calc_status == 1)    /* next assumes CLK_TCK is 10^n, n>=2 */
X      calctime += (clock_ticks() - timer_start) / (CLK_TCK/100);
X   stackscreen();
Xtop:
X   helptitle();
X   setattr(1,0,C_GENERAL_MED,24*80); /* init rest to background */
X
X   row = 2;
X   putstring(row,2,C_GENERAL_MED,sfractal_type);
X   if (display3d > 0)
X      putstring(row,16,C_GENERAL_HI,s3D_transform);
X   else {
X      putstring(row,16,C_GENERAL_HI,
X       curfractalspecific->name[0] == '*' ?
X         &curfractalspecific->name[1] :
X         curfractalspecific->name);
X      i = 0;
X      if (fractype == FORMULA || fractype == FFORMULA)
X      {
X     putstring(row+1,16,C_GENERAL_HI,FormName);
X      i = strlen(FormName)+1;
X      }
X      trigdetails(msg);
X      putstring(row+1,16+i,C_GENERAL_HI,msg);
X      if (fractype == LSYSTEM)
X     putstring(row+1,16,C_GENERAL_HI,LName);
X      if (fractype == IFS || fractype == IFS3D)
X     putstring(row+1,16,C_GENERAL_HI,IFSName);
X      }
X
X   switch (calc_status) {
X      case 0:  msgptr = sparms_chgd;
X           break;
X      case 1:  msgptr = sstill_being;
X           break;
X      case 2:  msgptr = sinterrupted_resumable;
X           break;
X      case 3:  msgptr = sinterrupted_non_resumable;
X           break;
X      case 4:  msgptr = simage_completed;
X           break;
X      default: msgptr = "";
X      }
X   putstring(row,45,C_GENERAL_HI,msgptr);
X   if (helpmode == HELPCYCLING)
X      putstring(row+1,45,C_GENERAL_HI,syou_are_cycling);
X   row += 2;
X
X    i = j = 0;
X    if (display3d > 0) {
X       if (usr_floatflag)
X      j = 1;
X       }
X    else
X       if (floatflag)
X      j = (usr_floatflag) ? 1 : 2;
X    if (j) {
X       putstring(row,45,C_GENERAL_HI,sfloating_point);
X
X       putstring(-1,-1,C_GENERAL_HI,(j == 1) ? sflag_is_activated
X                         : sin_use_required );
X      i = 1;
X      }
X      else
X      {
X       putstring(row,45,C_GENERAL_HI,sinteger_math);
X      i = 1;
X      }
X   if (calc_status == 1 || calc_status == 2)
X      if (curfractalspecific->flags&INFCALC) {
X     putstring(row,2,C_GENERAL_HI,sruns_forever);
X     i = 1;
X     }
X   row += i;
X
X   if (calc_status == 1 || calc_status == 2)
X      if (curfractalspecific->flags&NORESUME)
X      {
X     static char far msg[] = {"Note: can't resume this type after interrupts other than <tab> and <F1>"};
X     putstring(row++,2,C_GENERAL_HI,msg);
X      }
X   ++row;
X
X   if (got_status >= 0 && (calc_status == 1 || calc_status == 2)) {
X      switch (got_status) {
X     case 0:
X        sprintf(msg,"%d Pass Mode",totpasses);
X        putstring(row,2,C_GENERAL_HI,msg);
X        break;
X     case 1:
X        putstring(row,2,C_GENERAL_HI,ssolid_guessing);
X        break;
X     case 2:
X        putstring(row,2,C_GENERAL_HI,sboundary_tracing);
X        break;
X     case 3:
X        sprintf(msg,"Processing row %d (of %d) of input image",currow,fileydots);
X        putstring(row,2,C_GENERAL_HI,msg);
X        break;
X     case 4:
X        putstring(row,2,C_GENERAL_HI,stesseral);
X        break;
X     }
X      ++row;
X      if (got_status != 3) {
X     sprintf(msg,"Working on block (y,x) [%d,%d]...[%d,%d], ",
X        yystart,xxstart,yystop,xxstop);
X     putstring(row,2,C_GENERAL_MED,msg);
X     if (got_status == 2 || got_status == 4) { /* btm or tesseral */
X        putstring(-1,-1,C_GENERAL_MED,"at ");
X        sprintf(msg,"[%d,%d]",currow,curcol);
X        putstring(-1,-1,C_GENERAL_HI,msg);
X        }
X     else {
X        if (totpasses > 1) {
X           putstring(-1,-1,C_GENERAL_MED,"pass ");
X           sprintf(msg,"%d",curpass);
X           putstring(-1,-1,C_GENERAL_HI,msg);
X           putstring(-1,-1,C_GENERAL_MED," of ");
X           sprintf(msg,"%d",totpasses);
X           putstring(-1,-1,C_GENERAL_HI,msg);
X           putstring(-1,-1,C_GENERAL_MED,", ");
X           }
X        putstring(-1,-1,C_GENERAL_MED,"at row ");
X        sprintf(msg,"%d",currow);
X        putstring(-1,-1,C_GENERAL_HI,msg);
X        }
X     ++row;
X     }
X      }
X   putstring(row,2,C_GENERAL_MED,scalculation_time);
X   sprintf(msg,"%3ld:%02ld:%02ld.%02ld", calctime/360000,
X      (calctime%360000)/6000, (calctime%6000)/100, calctime%100);
X   putstring(-1,-1,C_GENERAL_HI,msg);
X   row += 2;
X
X   if (videoentry.xdots) {
X      sprintf(msg,"Video: %dx%dx%d %s %s",
X          videoentry.xdots, videoentry.ydots, videoentry.colors,
X          videoentry.name, videoentry.comment);
X      putstring(row,2,C_GENERAL_MED,msg);
X      }
X   ++row;
X
X   putstring(row,2,C_GENERAL_MED,scornersxy);
X   putstring(++row,3,C_GENERAL_MED,stop_left);
X   sprintf(msg,"%20.16f  %20.16f",xxmin,yymax);
X   putstring(-1,17,C_GENERAL_HI,msg);
X   putstring(++row,3,C_GENERAL_MED,sbottom_right);
X   sprintf(msg,"%20.16f  %20.16f",xxmax,yymin);
X   putstring(-1,17,C_GENERAL_HI,msg);
X   adjust_corner(); /* make bottom left exact if very near exact */
X   if (cvtcentermag(&Xctr, &Yctr, &Magnification)) {
X      putstring(row+=2,2,C_GENERAL_MED,scenter);
X      sprintf(msg,"%20.16f %20.16f",Xctr,Yctr);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      putstring(-1,-1,C_GENERAL_MED,smag);
X      if (Magnification < 1e6)
X     sprintf(msg,"%20.14f",Magnification);
X      else if (Magnification < 1e12)
X     sprintf(msg,"%20.8f",Magnification);
X      else
X     sprintf(msg,"%20.2f",Magnification);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      }
X   else if (xxmin != xx3rd || yymin != yy3rd) {
X      putstring(++row,3,C_GENERAL_MED,sbottom_left);
X      sprintf(msg,"%20.16f  %20.16f",xx3rd,yy3rd);
X      putstring(-1,17,C_GENERAL_HI,msg);
X      }
X   putstring(row+=2,2,C_GENERAL_MED,sparams);
X   for (i = 0; i < 4; i++) {
X      sprintf(msg,"%3d: ",i+1);
X      putstring(-1,-1,C_GENERAL_MED,msg);
X      sprintf(msg,"%12.9f",param[i]);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      }
X
X   putstring(row+=2,2,C_GENERAL_MED,siteration_maximum);
X   sprintf(msg,"%d",maxit);
X   putstring(-1,-1,C_GENERAL_HI,msg);
X   putstring(-1,-1,C_GENERAL_MED,seffective_bailout);
X   sprintf(msg,"%f",rqlim);
X   putstring(-1,-1,C_GENERAL_HI,msg);
X
X   if (fractype == PLASMA) {
X      putstring(++row,2,C_GENERAL_MED,scurrent_rseed);
X      sprintf(msg,"%d",rseed);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      }
X
X   if(invert) {
X      extern double f_radius,f_xcenter,f_ycenter;
X      putstring(++row,2,C_GENERAL_MED,sinversion_radius);
X      sprintf(msg,"%12.9f",f_radius);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      putstring(-1,-1,C_GENERAL_MED,sxcenter);
X      sprintf(msg,"%12.9f",f_xcenter);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      putstring(-1,-1,C_GENERAL_MED,sycenter);
X      sprintf(msg,"%12.9f",f_ycenter);
X      putstring(-1,-1,C_GENERAL_HI,msg);
X      }
X
X   if ((row += 2) < 23) ++row;
Xwaitforkey:
X   putstringcenter(row,0,80,C_GENERAL_LO,
X       "...Press any key to continue, F6 for area...");
X   movecursor(25,80);
X#ifdef XFRACT
X   while (keypressed()) {
X       getakey();
X   }
X#endif
X   key = getakeynohelp();
X   if (key==F6) {
X       unstackscreen();
X       area();
X       stackscreen();
X/*       goto waitforkey;*/
X        goto top;
X   }
X   unstackscreen();
X   timer_start = clock_ticks(); /* tab display was "time out" */
X   return(0);
X}
X
Xstatic void area()
X{
X    /* apologies to UNIX folks, we PC guys have to save near space */
X    static char far warning[] = {"Warning: inside may not be unique\n"};
X    static char far total_area[] = {".  Total area "};
X    char far *msg;
X    int x,y;
X    char buf[160];
X    long cnt=0;
X    if (inside<0) {
X      static char far msg[] = {"Need solid inside to compute area"};
X      stopmsg(0,msg);
X      return;
X    }
X    for (y=0;y<ydots;y++) {
X      for (x=0;x<xdots;x++) {
X          if (getcolor(x,y)==inside) {
X              cnt++;
X          }
X      }
X    }
X    if (inside>0 && outside<0 && maxit>inside) {
X      msg = warning;
X    } else {
X      msg = (char far *)"";
X    }
X#ifndef XFRACT
X      sprintf(buf,"%Fs%ld inside pixels of %ld%Fs%f",
X              msg,cnt,(long)xdots*(long)ydots,total_area,
X              cnt/((float)xdots*(float)ydots)*(xxmax-xxmin)*(yymax-yymin));
X#else
X      sprintf(buf,"%s%ld inside pixels of %ld%s%f",
X              msg,cnt,(long)xdots*(long)ydots,total_area,
X              cnt/((float)xdots*(float)ydots)*(xxmax-xxmin)*(yymax-yymin));
X#endif
X    stopmsg(4,buf);
X}
X
Xint endswithslash(char *fl)
X{
X   int len;
X   len = strlen(fl);
X   if(len)
X      if(fl[--len] == SLASHC)
X     return(1);
X   return(0);
X}
X
Xchar far insufficient_ifs_mem[]={"Insufficient memory for IFS"};
X/* --------------------------------------------------------------------- */
Xint numaffine;
Xint ifsload()            /* read in IFS parameters */
X{
X   int i;
X   FILE *ifsfile;
X   char buf[201];
X   char *bufptr;
X   extern float tstack[];    /* shared temp */
X   int ret,rowsize;
X
X   if (ifs_defn) { /* release prior parms */
X      farmemfree((char far *)ifs_defn);
X      ifs_defn = NULL;
X      }
X
X   ifs_changed = ifs_type = 0;
X   rowsize = IFSPARM;
X   if (find_file_item(IFSFileName,IFSName,&ifsfile) < 0)
X      return(-1);
X
X   fgets(buf,200,ifsfile);
X   strlwr(buf);
X   bufptr = &buf[0];
X   while (*bufptr) {
X      if (strncmp(bufptr,"(3d)",4) == 0) {
X     ifs_type = 1;
X     rowsize = IFS3DPARM;
X     }
X      ++bufptr;
X      }
X
X   for (i = 0; i < (NUMIFS+1)*IFS3DPARM; ++i)
X      tstack[i] = 0.0;
X   i = ret = 0;
X   while (fscanf(ifsfile," %f ",&tstack[i])) {
X      if (++i >= NUMIFS*rowsize) {
X      static char far msg[]={"IFS definition has too many lines"};
X     stopmsg(0,msg);
X     ret = -1;
X     break;
X     }
X      }
X   if ((i % rowsize) != 0 || getc(ifsfile) != '}') {
X      static char far msg[]={"invalid IFS definition"};
X      stopmsg(0,msg);
X      ret = -1;
X      }
X   if (i == 0 && ret == 0) {
X      static char far msg[]={"Empty IFS definition"};
X      stopmsg(0,msg);
X      ret = -1;
X      }
X   fclose(ifsfile);
X
X   if (ret == 0) {
X      numaffine = i/rowsize;
X      if ((ifs_defn = (float far *)farmemalloc(
X            (long)((NUMIFS+1)*IFS3DPARM*sizeof(float)))) == NULL) {
X     stopmsg(0,insufficient_ifs_mem);
X     ret = -1;
X     }
X      else
X     for (i = 0; i < (NUMIFS+1)*IFS3DPARM; ++i)
X        ifs_defn[i] = tstack[i];
X   }
X   return(ret);
X}
X
Xint find_file_item(char *filename,char *itemname,FILE **infile)
X{
X   char tmpname[41];
X   char fullpathname[FILE_MAX_PATH];
X   long notepoint;
X   char buf[201];
X   int c;
X   findpath(filename, fullpathname);
X   if ((*infile = fopen(fullpathname,"rt")) == NULL) {
X      sprintf(buf,s_cantopen,fullpathname);
X      stopmsg(0,buf);
X      return(-1);
X      }
X
X   while (1) {
X      while ((c = getc(*infile)) == ' ' || c == '\t' || c == '\n') { }
X      if (c == EOF) break;
X      if (c == ';') {
X     while ((c = fgetc(*infile)) != '\n' && c != EOF) { }
X     if (c == EOF) break;
X     continue;
X     }
X      notepoint = ftell(*infile) - 1;
X      ungetc(c,*infile);
X      if (fscanf(*infile," %40[^ \n\t({]",tmpname) == EOF) break;
X      while ((c = getc(*infile)) != EOF && c != '{' && c != '\n') { }
X      if (c == EOF) break;
X      if (c == '{') {
X     if (stricmp(tmpname,itemname) == 0) {
X        fseek(*infile,notepoint,SEEK_SET);
X        return(0);
X        }
X     while ((c = getc(*infile)) != '}' && c != EOF) { }
X     if (c == EOF) break;
X     }
X      }
X   fclose(*infile);
X   sprintf(buf,"'%s' definition not found",itemname);
X   stopmsg(0,buf);
X   return(-1);
X}
X
Xint file_gets(char *buf,int maxlen,FILE *infile)
X{
X   int len,c;
X   /* similar to 'fgets', but file may be in either text or binary mode */
X   /* returns -1 at eof, length of string otherwise */
X   if (feof(infile)) return -1;
X   len = 0;
X   while (len < maxlen) {
X      if ((c = getc(infile)) == EOF || c == '\032') {
X     if (len) break;
X     return -1;
X     }
X      if (c == '\n') break;             /* linefeed is end of line */
X      if (c != '\r') buf[len++] = c;    /* ignore c/r */
X      }
X   buf[len] = 0;
X   return len;
X}
X
Xint first_err = 1;
X
X#ifndef XFRACT
X#ifdef WINFRACT
X/* call this something else to dodge the QC4WIN bullet... */
Xint win_matherr( struct exception *except )
X#else
Xint matherr( struct exception *except )
X#endif
X{
X    extern int debugflag;
X    static char far msg[]={"Math error, but we'll try to keep going"};
X    if(first_err)
X    {
X       if(debugflag == 4000)stopmsg(0,msg);
X       first_err = 0;
X    }
X    if(debugflag)
X    {
X       static int ct = 0;
X       static FILE *fp=NULL;
X       if(fp==NULL)
X      fp = fopen("matherr","w");
X       if(ct++ < 100)
X       {
X      fprintf(fp,"err:  %d\nname: %s\narg:  %le\n",
X          except->type, except->name, except->arg1);
X      fflush(fp);
X       }
X    }
X    if( except->type == DOMAIN )
X    {
X    char buf[40];
X    sprintf(buf,"%le",except->arg1);
X    /* This test may be unnecessary - from my experiments if the
X       argument is too large or small the error is TLOSS not DOMAIN */
X    if(strstr(buf,"IN")||strstr(buf,"NAN"))  /* trashed arg? */
X               /* "IND" with MSC, "INF" with BC++ */
X    {
X       if( strcmp( except->name, "sin" ) == 0 )
X       {
X          except->retval = 0.0;
X          return(1);
X       }
X       else if( strcmp( except->name, "cos" ) == 0 )
X       {
X          except->retval = 1.0;
X          return(1);
X       }
X       else if( strcmp( except->name, "log" ) == 0 )
X       {
X          except->retval = 1.0;
X          return(1);
X       }
X       }
X    }
X    if( except->type == TLOSS )
X    {
X       /* try valiantly to keep going */
X       if( strcmp( except->name, "sin" ) == 0 )
X       {
X          except->retval = 0.5;
X          return(1);
X       }
X       else if( strcmp( except->name, "cos" ) == 0 )
X       {
X          except->retval = 0.5;
X          return(1);
X       }
X    }
X    /* shucks, no idea what went wrong, but our motto is "keep going!" */
X    except->retval = 1.0;
X    return(1);
X}
X#endif
X
Xvoid roundfloatd(double *x) /* make double converted from float look ok */
X{
X   char buf[30];
X   sprintf(buf,"%-10.7g",*x);
X   *x = atof(buf);
X}
X
X/* fake a keystroke, returns old pending key */
Xint ungetakey(int key)
X{
X   int old;
X   extern int keybuffer;
X   old = keybuffer;
X   keybuffer = key;
X   return(old);
X}
X
X/* use this indirect aproach so that we can put GIFVIEW.C in an overlay */
X
Xint gifview()
X{
X    return(gifview1());
X}
X
Xchar *extract_filename(char * fullfilename)
X{
X   static char fname_ext[FILE_MAX_FNAME+FILE_MAX_EXT];
X   char fname[FILE_MAX_FNAME];
X   char ext[FILE_MAX_EXT];
X   fname_ext[0] = 0;
X   splitpath(fullfilename ,NULL,NULL,fname,ext);
X   makepath(fname_ext,""   ,"" ,fname,ext);
X   return(fname_ext);
X}
SHAR_EOF
$TOUCH -am 1028230093 miscres.c &&
chmod 0644 miscres.c ||
echo "restore of miscres.c failed"
set `wc -c miscres.c`;Wc_c=$1
if test "$Wc_c" != "27230"; then
    echo original size 27230, current size $Wc_c
fi
# ============= mpmath_c.c ==============
echo "x - extracting mpmath_c.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > mpmath_c.c &&
X/* MPMath_c.c (C) 1989, Mark C. Peterson, CompuServe [70441,3353]
X     All rights reserved.
X
X   Code may be used in any program provided the author is credited
X     either during program execution or in the documentation.  Source
X     code may be distributed only in combination with public domain or
X     shareware source code.  Source code may be modified provided the
X     copyright notice and this message is left unchanged and all
X     modifications are clearly documented.
X
X     I would appreciate a copy of any work which incorporates this code,
X     however this is optional.
X
X     Mark C. Peterson
X     405-C Queen St. Suite #181
X     Southington, CT 06489
X     [phone]
X*/
X
X#include <stdlib.h>
X#include "mpmath.h"
X#include "prototyp.h"
X
X#ifndef XFRACT
X
Xint MPaccuracy = 32;
X
Xstruct MP *MPsub(struct MP x, struct MP y) {
X   y.Exp ^= 0x8000;
X   return(MPadd(x, y));
X}
X
X/* added by TW */
Xstruct MP *MPsub086(struct MP x, struct MP y) {
X   y.Exp ^= 0x8000;
X   return(MPadd086(x, y));
X}
X
X/* added by TW */
Xstruct MP *MPsub386(struct MP x, struct MP y) {
X   y.Exp ^= 0x8000;
X   return(MPadd386(x, y));
X}
X
Xstruct MP *MPabs(struct MP x) {
X   x.Exp &= 0x7fff;
X   return(&x);
X}
X
Xstruct MPC MPCsqr(struct MPC x) {
X   struct MPC z;
X
X        z.x = *pMPsub(*pMPmul(x.x, x.x), *pMPmul(x.y, x.y));
X        z.y = *pMPmul(x.x, x.y);
X        z.y.Exp++;
X   return(z);
X}
X
Xstruct MP MPCmod(struct MPC x) {
X        return(*pMPadd(*pMPmul(x.x, x.x), *pMPmul(x.y, x.y)));
X}
X
Xstruct MPC MPCmul(struct MPC x, struct MPC y) {
X   struct MPC z;
X
X        z.x = *pMPsub(*pMPmul(x.x, y.x), *pMPmul(x.y, y.y));
X        z.y = *pMPadd(*pMPmul(x.x, y.y), *pMPmul(x.y, y.x));
X   return(z);
X}
X
Xstruct MPC MPCdiv(struct MPC x, struct MPC y) {
X   struct MP mod;
X
X   mod = MPCmod(y);
X        y.y.Exp ^= 0x8000;
X        y.x = *pMPdiv(y.x, mod);
X        y.y = *pMPdiv(y.y, mod);
X   return(MPCmul(x, y));
X}
X
Xstruct MPC MPCadd(struct MPC x, struct MPC y) {
X   struct MPC z;
X
X        z.x = *pMPadd(x.x, y.x);
X        z.y = *pMPadd(x.y, y.y);
X   return(z);
X}
X
Xstruct MPC MPCsub(struct MPC x, struct MPC y) {
X   struct MPC z;
X
X        z.x = *pMPsub(x.x, y.x);
X        z.y = *pMPsub(x.y, y.y);
X   return(z);
X}
X
Xstruct MPC MPCone = { 0x3fff, 0x80000000l, 0, 0l };
X
Xstruct MPC MPCpow(struct MPC x, int exp) {
X   struct MPC z;
X   struct MPC zz;
X
X   if(exp & 1)
X      z = x;
X   else
X      z = MPCone;
X   exp >>= 1;
X   while(exp) {
X                zz.x = *pMPsub(*pMPmul(x.x, x.x), *pMPmul(x.y, x.y));
X                zz.y = *pMPmul(x.x, x.y);
X                zz.y.Exp++;
X      x = zz;
X      if(exp & 1) {
X                        zz.x = *pMPsub(*pMPmul(z.x, x.x), *pMPmul(z.y, x.y));
X                        zz.y = *pMPadd(*pMPmul(z.x, x.y), *pMPmul(z.y, x.x));
X         z = zz;
X      }
X      exp >>= 1;
X   }
X   return(z);
X}
X
Xint MPCcmp(struct MPC x, struct MPC y) {
X   struct MPC z;
X
X        if(pMPcmp(x.x, y.x) || pMPcmp(x.y, y.y)) {
X                z.x = MPCmod(x);
X                z.y = MPCmod(y);
X                return(pMPcmp(z.x, z.y));
X   }
X   else
X      return(0);
X}
X
X_CMPLX MPC2cmplx(struct MPC x) {
X   _CMPLX z;
X
X        z.x = *pMP2d(x.x);
X        z.y = *pMP2d(x.y);
X   return(z);
X}
X
Xstruct MPC cmplx2MPC(_CMPLX z) {
X   struct MPC x;
X
X        x.x = *pd2MP(z.x);
X        x.y = *pd2MP(z.y);
X   return(x);
X}
X
X/* function pointer versions added by Tim Wegner 12/07/89 */
Xint        (*ppMPcmp)() = MPcmp086;
Xint        (*pMPcmp)(struct MP x, struct MP y) = MPcmp086;
Xstruct MP  *(*pMPmul)(struct MP x, struct MP y)= MPmul086;
Xstruct MP  *(*pMPdiv)(struct MP x, struct MP y)= MPdiv086;
Xstruct MP  *(*pMPadd)(struct MP x, struct MP y)= MPadd086;
Xstruct MP  *(*pMPsub)(struct MP x, struct MP y)= MPsub086;
Xstruct MP  *(*pd2MP)(double x)                 = d2MP086 ;
Xdouble *(*pMP2d)(struct MP m)                  = MP2d086 ;
Xstruct MP  *(*pfg2MP)(long x, int fg)          = fg2MP086;
X
Xvoid setMPfunctions(void) {
X   if(cpu == 386)
X   {
X      pMPmul = MPmul386;
X      pMPdiv = MPdiv386;
X      pMPadd = MPadd386;
X      pMPsub = MPsub386;
X      pMPcmp = MPcmp386;
X      pd2MP  = d2MP386 ;
X      pMP2d  = MP2d386 ;
X      pfg2MP = fg2MP386;
X   }
X   else
X   {
X      pMPmul = MPmul086;
X      pMPdiv = MPdiv086;
X      pMPadd = MPadd086;
X      pMPsub = MPsub086;
X      pMPcmp = MPcmp086;
X      pd2MP  = d2MP086 ;
X      pMP2d  = MP2d086 ;
X      pfg2MP = fg2MP086;
X   }
X}
X
X#endif /* XFRACT */
X
X#ifndef sqr
X#define sqr(x) ((x)*(x))
X#endif
X
Xextern int debugflag, fpu;
X
X_CMPLX ComplexPower(_CMPLX xx, _CMPLX yy) {
X   _CMPLX z, cLog, t;
X   double e2x, siny, cosy;
X
X   FPUcplxlog(&xx, &cLog);
X   FPUcplxmul(&cLog, &yy, &t);
X
X   if(fpu == 387)
X      FPUcplxexp387(&t, &z);
X   else {
X      if(t.x < -690)
X         e2x = 0;
X      else
X         e2x = exp(t.x);
X      FPUsincos(&t.y, &siny, &cosy);
X      z.x = e2x * cosy;
X      z.y = e2x * siny;
X   }
X   return(z);
X}
X
X/***** FRACTINT specific routines and variables *****/
X
X#ifndef TESTING_MATH
X
X#include <stdlib.h>
X
X#include "fractint.h"
X
Xextern double param[];
Xextern _CMPLX old, new, init;
Xextern double threshold, roverd, d1overd, dx0[], dy0[];
Xextern int periodicitycheck, row, col, debugflag;
X
X
X#include <stdlib.h>
X
Xextern int  xdots, ydots;     /* coordinates of dots on the screen  */
Xextern int  colors;           /* maximum colors available */
Xextern int  maxit;
X
XBYTE far *LogTable = (BYTE far *)0;
Xextern int LogFlag;
X   /* LogFlag == 1  -- standard log palettes
X      LogFlag == -1 -- 'old' log palettes
X      LogFlag >  1  -- compress counts < LogFlag into color #1
X      LogFlag < -1  -- use quadratic palettes based on square roots && compress
X   */
X
Xvoid SetupLogTable(void) {
X   float l, f, c, m;
X   unsigned n, prev, limit, lf;
X
X   if (LogFlag > -2) {
X      lf = (LogFlag > 1) ? LogFlag : 0;
X      if (lf >= maxit)
X         lf = maxit - 1;
X      Fg2Float((long)(maxit-lf), 0, m);
X      fLog14(m, m);
X      Fg2Float((long)(colors-(lf?2:1)), 0, c);
X      fDiv(m, c, m);
X      for (prev = 1; prev <= lf; prev++)
X         LogTable[prev] = 1;
X      for (n = (lf?2:1); n < colors; n++) {
X         Fg2Float((long)n, 0, f);
X         fMul16(f, m, f);
X         fExp14(f, l);
X         limit = Float2Fg(l, 0) + lf;
X         if (limit > maxit || n == colors-1)
X            limit = maxit;
X         while (prev <= limit)
X            LogTable[prev++] = n;
X      }
X   } else {
X      if ((lf = 0 - LogFlag) >= maxit)
X         lf = maxit - 1;
X      Fg2Float((long)(maxit-lf), 0, m);
X      fSqrt14(m, m);
X      Fg2Float((long)(colors-2), 0, c);
X      fDiv(m, c, m);
X      for (prev = 1; prev <= lf; prev++)
X         LogTable[prev] = 1;
X      for (n = 2; n < colors; n++) {
X         Fg2Float((long)n, 0, f);
X         fMul16(f, m, f);
X         fMul16(f, f, l);
X         limit = Float2Fg(l, 0) + lf;
X         if (limit > maxit || n == colors-1)
X            limit = maxit;
X         while (prev <= limit)
X            LogTable[prev++] = n;
X      }
X   }
X   LogTable[0] = 0;
X   if (LogFlag != -1)
X      for (n = 1; n < maxit; n++) /* spread top to incl unused colors */
X         if (LogTable[n] > LogTable[n-1])
X            LogTable[n] = LogTable[n-1]+1;
X}
X
Xlong far ExpFloat14(long xx) {
X   static float fLogTwo = (float)0.6931472;
X   int f;
X   long Ans;
X
X   f = 23 - (int)RegFloat2Fg(RegDivFloat(xx, *(long*)&fLogTwo), 0);
X   Ans = ExpFudged(RegFloat2Fg(xx, 16), f);
X   return(RegFg2Float(Ans, (char)f));
X}
X
Xextern _CMPLX tmp;
Xextern int color, colors;
Xdouble TwoPi;
X_CMPLX temp, t2, BaseLog;
X_CMPLX cdegree = { 3.0, 0.0 },
X               croot   = { 1.0, 0.0 };
X
Xint ComplexNewtonSetup(void) {
X   threshold = .001;
X   periodicitycheck = 0;
X   if(param[0] != 0.0 || param[1] != 0.0 || param[2] != 0.0 ||
X      param[3] != 0.0) {
X      croot.x = param[2];
X      croot.y = param[3];
X      cdegree.x = param[0];
X      cdegree.y = param[1];
X      FPUcplxlog(&croot, &BaseLog);
X      TwoPi = asin(1.0) * 4;
X   }
X   return(1);
X}
X
Xint ComplexNewton(void) {
X   _CMPLX cd1;
X
X   /* new = ((cdegree-1) * old**cdegree) + croot
X            ----------------------------------
X                 cdegree * old**(cdegree-1)         */
X
X   cd1.x = cdegree.x - 1.0;
X   cd1.y = cdegree.y;
X
X   temp = ComplexPower(old, cd1);
X   FPUcplxmul(&temp, &old, &new);
X
X   tmp.x = new.x - croot.x;
X   tmp.y = new.y - croot.y;
X   if((sqr(tmp.x) + sqr(tmp.y)) < threshold)
X      return(1);
X
X   FPUcplxmul(&new, &cd1, &tmp);
X   tmp.x += croot.x;
X   tmp.y += croot.y;
X
X   FPUcplxmul(&temp, &cdegree, &t2);
X   FPUcplxdiv(&tmp, &t2, &old);
X   if(DivideOverflow)
X   {
X      DivideOverflow = 0;
X      return(1);
X   }
X   new = old;
X   return(0);
X}
X
Xint ComplexBasin(void) {
X   _CMPLX cd1;
X   double mod;
X
X   /* new = ((cdegree-1) * old**cdegree) + croot
X            ----------------------------------
X                 cdegree * old**(cdegree-1)         */
X
X   cd1.x = cdegree.x - 1.0;
X   cd1.y = cdegree.y;
X
X   temp = ComplexPower(old, cd1);
X   FPUcplxmul(&temp, &old, &new);
X
X   tmp.x = new.x - croot.x;
X   tmp.y = new.y - croot.y;
X   if((sqr(tmp.x) + sqr(tmp.y)) < threshold) {
X      if(fabs(old.y) < .01)
X         old.y = 0.0;
X      FPUcplxlog(&old, &temp);
X      FPUcplxmul(&temp, &cdegree, &tmp);
X      mod = tmp.y/TwoPi;
X      color = (int)mod;
X      if(fabs(mod - color) > 0.5) {
X         if(mod < 0.0)
X            color--;
X         else
X            color++;
X      }
X      color += 2;
X      if(color < 0)
X         color += 128;
X      return(1);
X   }
X
X   FPUcplxmul(&new, &cd1, &tmp);
X   tmp.x += croot.x;
X   tmp.y += croot.y;
X
X   FPUcplxmul(&temp, &cdegree, &t2);
X   FPUcplxdiv(&tmp, &t2, &old);
X   if(DivideOverflow)
X   {
X      DivideOverflow = 0;
X      return(1);
X   }
X   new = old;
X   return(0);
X}
X
Xextern int Distribution, Offset, Slope;
Xextern long con;
X
X/*** PB, commented this out, it was unused, actual work is in prompts.c
Xint Starfield(void) {
X   int c;
X
X   plasma();
X   Distribution = (int)param[1];
X   con = (long)(param[2] / 100 * (1L << 16));
X   Slope = (int)param[3];
X   for(row = 0; row < ydots; row++) {
X      for(col = 0; col < xdots; col++) {
X         if(check_key())
X            return(-1);
X         c = getcolor(col, row);
X         putcolor(col, row, GausianNumber(c, colors));
X      }
X   }
X   return(0);
X}
X  ***/
X
X/*
X * Generate a gaussian distributed number.
X * The right half of the distribution is folded onto the lower half.
X * That is, the curve slopes up to the peak and then drops to 0.
X * The larger slope is, the smaller the standard deviation.
X * The values vary from 0+offset to range+offset, with the peak
X * at range+offset.
X * To make this more complicated, you only have a
X * 1 in Distribution*(1-Probability/Range*con)+1 chance of getting a
X * Gaussian; otherwise you just get offset.
X */
Xint GausianNumber(int Probability, int Range) {
X   int n, r;
X   long Accum = 0, p;
X
X   p = divide((long)Probability << 16, (long)Range << 16, 16);
X   p = multiply(p, con, 16);
X   p = multiply((long)Distribution << 16, p, 16);
X   if(!(rand15() % (Distribution - (int)(p >> 16) + 1))) {
X      for(n = 0; n < Slope; n++)
X         Accum += rand15();
X      Accum /= Slope;
X      r = (int)(multiply((long)Range << 15, Accum, 15) >> 14);
X      r = r - Range;
X      if(r < 0)
X         r = -r;
X      return(Range - r + Offset);
X   }
X   return(Offset);
X}
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 mpmath_c.c &&
chmod 0644 mpmath_c.c ||
echo "restore of mpmath_c.c failed"
set `wc -c mpmath_c.c`;Wc_c=$1
if test "$Wc_c" != "11132"; then
    echo original size 11132, current size $Wc_c
fi
# ============= parser.c ==============
echo "x - extracting parser.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > parser.c &&
X/* Parser.c (C) 1990, Mark C. Peterson, CompuServe [70441,3353]
X   All rights reserved.
X
X   Code may be used in any program provided the author is credited
X    either during program execution or in the documentation.  Source
X    code may be distributed only in combination with public domain or
X    shareware source code.  Source code may be modified provided the
X    copyright notice and this message is left unchanged and all
X    modifications are clearly documented.
X
X    I would appreciate a copy of any work which incorporates this code,
X    however this is optional.
X
X    Mark C. Peterson
X    405-C Queen St. Suite #181
X    Southington, CT 06489
X    [phone]
X*/
X
X/*    Chuck Ebbert (CompuServe [76306,1226] ) changed code marked 'CAE fp'    */
X/*   for fast 387 floating-point math.  See PARSERA.ASM and PARSERFP.C */
X/*   (13 Dec 1992.)  */
X/* */
X/*   Modified 12 July 1993 by CAE to fix crash when formula not found.  */
X
X#include <string.h>
X#include <ctype.h>
X#include <stdio.h>
X#include <stdlib.h>
X#include <float.h>                              /* TIW 04-22-91 */
X#include <time.h>
X#include "mpmath.h"
X#include "prototyp.h"
X
Xextern int CvtStk(void);    /* CAE fp */
Xextern int Transparent3D;                         /* MCP 5-30-91 */
X
X#ifdef WATCH_MP
Xdouble x1, y1, x2, y2;
X#endif
X
XMATH_TYPE MathType = D_MATH;
X/* moved _LCMPLX and union ARg to mpmath.h -6-20-90 TIW */
X
X/* PB 910417 added MAX_OPS and MAX_ARGS defines */
X#define MAX_ARGS 100
X#define MAX_OPS 250
Xstruct PEND_OP {
X   void (far *f)(void);
X   int p;
X};
X/* CAE fp added MAX_STORES and LOADS */
X#define MAX_STORES 125  /* at most only half the ops can be stores */
X#define MAX_LOADS  200  /* and 80% can be loads */
X
X/* PB 901103 made some of the following static for safety */
Xstatic struct PEND_OP far *o;
X
Xstatic void parser_allocate(void);
X
Xunion Arg *Arg1, *Arg2;
X/* PB 910417 removed unused "a" array */
X
X/* CAE fp  made some of the following non-static for PARSERA.ASM */
X/* Some of these variables should be renamed for safety */
Xunion Arg s[20], far * far *Store, far * far *Load;    /* static CAE fp */
Xint StoPtr, LodPtr, OpPtr;    /* static CAE fp */
X
Xstruct fls { /* function, load, store pointers  CAE fp */
X   void (near *function)(void);
X   union Arg near *operand;
X};
Xextern struct fls far *pfls; /* init in parserfp.c  CAE fp */
Xvoid (far * far *f)(void) = (void(far * far *)(void))0;    /* static CAE fp */
X
Xunsigned vsp, LastOp;    /* CAE fp made non-static */
Xstatic unsigned n, ErrPtr, posp, NextOp, InitN;
Xstatic int paren, SyntaxErr, ExpectingArg;
Xstruct ConstArg far *v = (struct ConstArg far *)0;    /* was static CAE fp */
Xint InitLodPtr, InitStoPtr, InitOpPtr, LastInitOp;    /* was static CAE fp */
Xstatic int Delta16;
Xdouble fgLimit;           /* TIW 05-04-91 */
Xstatic double fg;
Xstatic int ShiftBack;     /* TIW 06-18-90 */
Xstatic int SetRandom;     /* MCP 11-21-91 */
Xstatic int Randomized;
Xstatic unsigned long RandNum;
X
Xextern int bitshift;
Xextern int bitshiftless1;
Xextern int symmetry;          /* symmetry flag for calcmand()  */
Xextern double param[];
X
Xextern int debugflag;         /* BDT for debugging */
Xextern char boxx[8192];       /* PB 4-9-91, good place for the formula string */
Xextern int row, col, overflow, cpu, fpu;
Xextern _CMPLX old, new;
Xextern double far *dx0, far *dy0;
Xextern long far *lx0, far *ly0;     /* BDT moved these to FAR */
X
X#ifndef TESTING_MATH
Xextern double far *dx1, far *dy1;
Xextern long far *lx1, far *ly1;
X#define dShiftx dx1[row]
X#define dShifty dy1[col]
X#define lShiftx lx1[row]
X#define lShifty ly1[col]
X#else
X#define dShiftx 0.0
X#define dShifty 0.0
X#define lShiftx 0L
X#define lShifty 0L
X#endif
X
Xextern _LCMPLX lold, lnew;
Xextern char FormName[];
X
Xextern VOIDFARPTR typespecific_workarea;
X
X#define LastSqr v[4].a
X
Xstatic char far * far ErrStrings[] = {   /* TIW 03-31-91 added far */
X   "Should be an Argument",
X   "Should be an Operator",
X   "')' needs a matching '('",
X   "Need more ')'",
X   "Undefined Operator",
X   "Undefined Function",
X   "More than one ','",
X   "Table overflow"
X};
X
Xunsigned SkipWhiteSpace(char *Str) {
X   unsigned n, Done;
X
X   for(Done = n = 0; !Done; n++) {
X      switch(Str[n]) {
X      case ' ':
X      case '\t':
X      case '\n':
X      case '\r':
X         break;
X      default:
X         Done = 1;
X      }
X   }
X   return(n - 1);
X}
X
X/* Random number code, MCP 11-21-91 */
X
Xunsigned long NewRandNum(void)
X{
X   return(RandNum = ((RandNum << 15) + rand15()) ^ RandNum);
X}
X
Xvoid lRandom(void)
X{
X   v[7].a.l.x = NewRandNum() >> (32 - bitshift);
X   v[7].a.l.y = NewRandNum() >> (32 - bitshift);
X}
X
Xvoid dRandom(void)
X{
X   long x, y;
X
X   /* Use the same algorithm as for fixed math so that they will generate
X      the same fractals when the srand() function is used. */
X   x = NewRandNum() >> (32 - bitshift);
X   y = NewRandNum() >> (32 - bitshift);
X   v[7].a.d.x = ((double)x / (1L << bitshift));
X   v[7].a.d.y = ((double)y / (1L << bitshift));
X}
X
X#ifndef XFRACT
Xvoid mRandom(void)
X{
X   long x, y;
X
X   /* Use the same algorithm as for fixed math so that they will generate
X      the same fractals when the srand() function is used. */
X   x = NewRandNum() >> (32 - bitshift);
X   y = NewRandNum() >> (32 - bitshift);
X   v[7].a.m.x = *fg2MP(x, bitshift);
X   v[7].a.m.y = *fg2MP(y, bitshift);
X}
X#endif
X
Xvoid SetRandFnct(void)
X{
X   unsigned Seed;
X
X   if(!SetRandom)
X      RandNum = Arg1->l.x ^ Arg1->l.y;
X
X   Seed = (unsigned)RandNum ^ (unsigned)(RandNum >> 16);
X   srand(Seed);
X   SetRandom = 1;
X
X   /* Clear out the seed */
X   NewRandNum();
X   NewRandNum();
X   NewRandNum();
X}
X
Xvoid RandomSeed(void)
X{
X   time_t ltime;
X
X   /* Use the current time to randomize the random number sequence. */
X   time(<ime);
X   srand((unsigned int)ltime);
X
X   NewRandNum();
X   NewRandNum();
X   NewRandNum();
X   Randomized = 1;
X}
X
X#ifndef XFRACT
Xvoid lStkSRand(void)
X{
X   SetRandFnct();
X   lRandom();
X   Arg1->l = v[7].a.l;
X}
X#endif
X
X#ifndef XFRACT
Xvoid mStkSRand(void)
X{
X   Arg1->l.x = Arg1->m.x.Mant ^ (long)Arg1->m.x.Exp;
X   Arg1->l.y = Arg1->m.y.Mant ^ (long)Arg1->m.y.Exp;
X   SetRandFnct();
X   mRandom();
X   Arg1->m = v[7].a.m;
X}
X#endif
X
Xvoid dStkSRand(void)
X{
X   Arg1->l.x = (long)(Arg1->d.x * (1L << bitshift));
X   Arg1->l.y = (long)(Arg1->d.y * (1L << bitshift));
X   SetRandFnct();
X   dRandom();
X   Arg1->d = v[7].a.d;
X}
X
Xvoid (*StkSRand)(void) = dStkSRand;
X
Xvoid dStkAbs(void) {
X   Arg1->d.x = fabs(Arg1->d.x);
X   Arg1->d.y = fabs(Arg1->d.y);
X}
X
X#ifndef XFRACT
Xvoid mStkAbs(void) {
X   if(Arg1->m.x.Exp < 0)
X      Arg1->m.x.Exp = -Arg1->m.x.Exp;
X   if(Arg1->m.y.Exp < 0)
X      Arg1->m.y.Exp = -Arg1->m.y.Exp;
X}
X
Xvoid lStkAbs(void) {
X   Arg1->l.x = labs(Arg1->l.x);
X   Arg1->l.y = labs(Arg1->l.y);
X}
X#endif
X
Xvoid (*StkAbs)(void) = dStkAbs;
X
Xvoid dStkSqr(void) {
X   LastSqr.d.x = Arg1->d.x * Arg1->d.x;
X   LastSqr.d.y = Arg1->d.y * Arg1->d.y;
X   Arg1->d.y = Arg1->d.x * Arg1->d.y * 2.0;
X   Arg1->d.x = LastSqr.d.x - LastSqr.d.y;
X   LastSqr.d.x += LastSqr.d.y;
X   LastSqr.d.y = 0;
X}
X
X#ifndef XFRACT
Xvoid mStkSqr(void) {
X   LastSqr.m.x = *MPmul(Arg1->m.x, Arg1->m.x);
X   LastSqr.m.y = *MPmul(Arg1->m.y, Arg1->m.y);
X   Arg1->m.y = *MPmul(Arg1->m.x, Arg1->m.y);
X   Arg1->m.y.Exp++;
X   Arg1->m.x = *MPsub(LastSqr.m.x, LastSqr.m.y);
X   LastSqr.m.x = *MPadd(LastSqr.m.x, LastSqr.m.y);
X   LastSqr.m.y.Mant = (long)(LastSqr.m.y.Exp = 0);
X}
X
Xvoid lStkSqr(void) {
X   LastSqr.l.x = multiply(Arg1->l.x, Arg1->l.x, bitshift);
X   LastSqr.l.y = multiply(Arg1->l.y, Arg1->l.y, bitshift);
X   Arg1->l.y = multiply(Arg1->l.x, Arg1->l.y, bitshift) << 1;
X   Arg1->l.x = LastSqr.l.x - LastSqr.l.y;
X   LastSqr.l.x += LastSqr.l.y;
X   LastSqr.l.y = 0L;
X}
X#endif
X
Xvoid (*StkSqr)(void) = dStkSqr;
X
Xvoid dStkAdd(void) {
X   Arg2->d.x += Arg1->d.x;
X   Arg2->d.y += Arg1->d.y;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkAdd(void) {
X   Arg2->m = MPCadd(Arg2->m, Arg1->m);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkAdd(void) {
X   Arg2->l.x += Arg1->l.x;
X   Arg2->l.y += Arg1->l.y;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkAdd)(void) = dStkAdd;
X
Xvoid dStkSub(void) {
X   Arg2->d.x -= Arg1->d.x;
X   Arg2->d.y -= Arg1->d.y;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkSub(void) {
X   Arg2->m = MPCsub(Arg2->m, Arg1->m);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkSub(void) {
X   Arg2->l.x -= Arg1->l.x;
X   Arg2->l.y -= Arg1->l.y;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkSub)(void) = dStkSub;
X
Xvoid dStkConj(void) {
X   Arg1->d.y = -Arg1->d.y;
X}
X
X#ifndef XFRACT
Xvoid mStkConj(void) {
X   Arg1->m.y.Exp ^= 0x8000;
X}
X
Xvoid lStkConj(void) {
X   Arg1->l.y = -Arg1->l.y;
X}
X#endif
X
Xvoid dStkZero(void) {
X   Arg1->d.y = Arg1->d.x = 0.0;
X}
X
X#ifndef XFRACT
Xvoid mStkZero(void) {
X   Arg1->m.x.Mant = Arg1->m.x.Exp = 0;
X   Arg1->m.y.Mant = Arg1->m.y.Exp = 0;
X}
X
Xvoid lStkZero(void) {
X   Arg1->l.y = Arg1->l.x = 0.0;
X}
X#endif
X
Xvoid (*StkConj)(void) = dStkConj;
X
Xvoid dStkReal(void) {
X   Arg1->d.y = 0.0;
X}
X
X#ifndef XFRACT
Xvoid mStkReal(void) {
X   Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
X}
X
Xvoid lStkReal(void) {
X   Arg1->l.y = 0l;
X}
X#endif
X
Xvoid (*StkReal)(void) = dStkReal;
X
Xvoid dStkImag(void) {
X   Arg1->d.x = Arg1->d.y;
X   Arg1->d.y = 0.0;
X}
X
X#ifndef XFRACT
Xvoid mStkImag(void) {
X   Arg1->m.x = Arg1->m.y;
X   Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
X}
X
Xvoid lStkImag(void) {
X   Arg1->l.x = Arg1->l.y;
X   Arg1->l.y = 0l;
X}
X#endif
X
Xvoid (*StkImag)(void) = dStkImag;
X
Xvoid dStkNeg(void) {
X   Arg1->d.x = -Arg1->d.x;
X   Arg1->d.y = -Arg1->d.y;
X}
X
X#ifndef XFRACT
Xvoid mStkNeg(void) {
X   Arg1->m.x.Exp ^= 0x8000;
X   Arg1->m.y.Exp ^= 0x8000;
X}
X
Xvoid lStkNeg(void) {
X   Arg1->l.x = -Arg1->l.x;
X   Arg1->l.y = -Arg1->l.y;
X}
X#endif
X
Xvoid (*StkNeg)(void) = dStkNeg;
X
Xvoid dStkMul(void) {
X   FPUcplxmul(&Arg2->d, &Arg1->d, &Arg2->d);
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkMul(void) {
X   Arg2->m = MPCmul(Arg2->m, Arg1->m);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkMul(void) {
X   long x, y;
X
X   x = multiply(Arg2->l.x, Arg1->l.x, bitshift) -
X   multiply(Arg2->l.y, Arg1->l.y, bitshift);
X   y = multiply(Arg2->l.y, Arg1->l.x, bitshift) +
X   multiply(Arg2->l.x, Arg1->l.y, bitshift);
X   Arg2->l.x = x;
X   Arg2->l.y = y;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkMul)(void) = dStkMul;
X
Xvoid dStkDiv(void) {
X   FPUcplxdiv(&Arg2->d, &Arg1->d, &Arg2->d);
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkDiv(void) {
X   Arg2->m = MPCdiv(Arg2->m, Arg1->m);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkDiv(void) {
X   long x, y, mod, x2, y2;
X
X   mod = multiply(Arg1->l.x, Arg1->l.x, bitshift) +
X   multiply(Arg1->l.y, Arg1->l.y, bitshift);
X   x = divide(Arg1->l.x, mod, bitshift);
X   y = -divide(Arg1->l.y, mod, bitshift);
X   /* pb 900617 changed next 4 lines to use x2,y2 instead of x,y */
X   x2 = multiply(Arg2->l.x, x, bitshift) - multiply(Arg2->l.y, y, bitshift);
X   y2 = multiply(Arg2->l.y, x, bitshift) + multiply(Arg2->l.x, y, bitshift);
X   Arg2->l.x = x2;
X   Arg2->l.y = y2;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkDiv)(void) = dStkDiv;
X
Xvoid StkSto(void) {
X   *Store[StoPtr++] = *Arg1;
X}
X
Xvoid StkLod(void) {
X   Arg1++;
X   Arg2++;
X   *Arg1 = *Load[LodPtr++];
X}
X
Xvoid dStkMod(void) {
X   Arg1->d.x = (Arg1->d.x * Arg1->d.x) + (Arg1->d.y * Arg1->d.y);
X   Arg1->d.y = 0.0;
X}
X
X#ifndef XFRACT
Xvoid mStkMod(void) {
X   Arg1->m.x = MPCmod(Arg1->m);
X   Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
X}
X
Xvoid lStkMod(void) {
X   Arg1->l.x = multiply(Arg2->l.x, Arg1->l.x, bitshift) +
X   multiply(Arg2->l.y, Arg1->l.y, bitshift);
X   if(Arg1->l.x < 0)
X      overflow = 1;
X   Arg1->l.y = 0L;
X}
X#endif
X
Xvoid (*StkMod)(void) = dStkMod;
X
Xvoid StkClr(void) {
X   s[0] = *Arg1;
X   Arg1 = &s[0];
X   Arg2 = Arg1;
X   Arg2--;
X}
X
X
X/* MCP 4-9-91, Added Flip() */
X
Xvoid dStkFlip(void) {
X   double t;
X
X   t = Arg1->d.x;
X   Arg1->d.x = Arg1->d.y;
X   Arg1->d.y = t;
X}
X
X#ifndef XFRACT
Xvoid mStkFlip(void) {
X   struct MP t;
X
X   t = Arg1->m.x;
X   Arg1->m.x = Arg1->m.y;
X   Arg1->m.y = t;
X}
X
Xvoid lStkFlip(void) {
X   long t;
X
X   t = Arg1->l.x;
X   Arg1->l.x = Arg1->l.y;
X   Arg1->l.y = t;
X}
X#endif
X
Xvoid (*StkFlip)(void) = dStkFlip;
X
Xvoid dStkSin(void) {
X   double sinx, cosx, sinhy, coshy;
X
X   FPUsincos(&Arg1->d.x, &sinx, &cosx);
X   FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
X   Arg1->d.x = sinx*coshy;
X   Arg1->d.y = cosx*sinhy;
X}
X
X#ifndef XFRACT
Xvoid mStkSin(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkSin();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkSin(void) {
X   long x, y, sinx, cosx, sinhy, coshy;
X   x = Arg1->l.x >> Delta16;
X   y = Arg1->l.y >> Delta16;
X   SinCos086(x, &sinx, &cosx);
X   SinhCosh086(y, &sinhy, &coshy);
X   Arg1->l.x = multiply(sinx, coshy, ShiftBack); /* TIW 06-18-90 */
X   Arg1->l.y = multiply(cosx, sinhy, ShiftBack); /* TIW 06-18-90 */
X}
X#endif
X
Xvoid (*StkSin)(void) = dStkSin;
X
X/* The following functions are supported by both the parser and for fn
X   variable replacement. TIW 04-22-91 */
X
Xvoid dStkTan(void) {
X   double sinx, cosx, sinhy, coshy, denom;
X   Arg1->d.x *= 2;
X   Arg1->d.y *= 2;
X   FPUsincos(&Arg1->d.x, &sinx, &cosx);
X   FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
X   denom = cosx + coshy;
X   if(fabs(denom) <= DBL_MIN) return;
X   Arg1->d.x = sinx/denom;
X   Arg1->d.y = sinhy/denom;
X}
X
X#ifndef XFRACT
Xvoid mStkTan(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkTan();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkTan(void) {
X   long x, y, sinx, cosx, sinhy, coshy, denom;
X   x = Arg1->l.x >> Delta16;
X   x = x << 1;
X   y = Arg1->l.y >> Delta16;
X   y = y << 1;
X   SinCos086(x, &sinx, &cosx);
X   SinhCosh086(y, &sinhy, &coshy);
X   denom = cosx + coshy;
X   if(denom == 0) return;
X   Arg1->l.x = divide(sinx,denom,bitshift);
X   Arg1->l.y = divide(sinhy,denom,bitshift);
X}
X#endif
X
Xvoid (*StkTan)(void) = dStkTan;
X
Xvoid dStkTanh(void) {
X   double siny, cosy, sinhx, coshx, denom;
X   Arg1->d.x *= 2;
X   Arg1->d.y *= 2;
X   FPUsincos(&Arg1->d.y, &siny, &cosy);
X   FPUsinhcosh(&Arg1->d.x, &sinhx, &coshx);
X   denom = coshx + cosy;
X   if(fabs(denom) <= DBL_MIN) return;
X   Arg1->d.x = sinhx/denom;
X   Arg1->d.y = siny/denom;
X}
X
X#ifndef XFRACT
Xvoid mStkTanh(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkTanh();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkTanh(void) {
X   long x, y, siny, cosy, sinhx, coshx, denom;
X   x = Arg1->l.x >> Delta16;
X   x = x << 1;
X   y = Arg1->l.y >> Delta16;
X   y = y << 1;
X   SinCos086(y, &siny, &cosy);
X   SinhCosh086(x, &sinhx, &coshx);
X   denom = coshx + cosy;
X   if(denom == 0) return;
X   Arg1->l.x = divide(sinhx,denom,bitshift);
X   Arg1->l.y = divide(siny,denom,bitshift);
X}
X#endif
X
Xvoid (*StkTanh)(void) = dStkTanh;
X
Xvoid dStkCoTan(void) {
X   double sinx, cosx, sinhy, coshy, denom;
X   Arg1->d.x *= 2;
X   Arg1->d.y *= 2;
X   FPUsincos(&Arg1->d.x, &sinx, &cosx);
X   FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
X   denom = coshy - cosx;
X   if(fabs(denom) <= DBL_MIN) return;
X   Arg1->d.x = sinx/denom;
X   Arg1->d.y = -sinhy/denom;
X}
X
X#ifndef XFRACT
Xvoid mStkCoTan(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkCoTan();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkCoTan(void) {
X   long x, y, sinx, cosx, sinhy, coshy, denom;
X   x = Arg1->l.x >> Delta16;
X   x = x << 1;
X   y = Arg1->l.y >> Delta16;
X   y = y << 1;
X   SinCos086(x, &sinx, &cosx);
X   SinhCosh086(y, &sinhy, &coshy);
X   denom = coshy - cosx;
X   if(denom == 0) return;
X   Arg1->l.x = divide(sinx,denom,bitshift);
X   Arg1->l.y = -divide(sinhy,denom,bitshift);
X}
X#endif
X
Xvoid (*StkCoTan)(void) = dStkCoTan;
X
Xvoid dStkCoTanh(void) {
X   double siny, cosy, sinhx, coshx, denom;
X   Arg1->d.x *= 2;
X   Arg1->d.y *= 2;
X   FPUsincos(&Arg1->d.y, &siny, &cosy);
X   FPUsinhcosh(&Arg1->d.x, &sinhx, &coshx);
X   denom = coshx - cosy;
X   if(fabs(denom) <= DBL_MIN) return;
X   Arg1->d.x = sinhx/denom;
X   Arg1->d.y = -siny/denom;
X}
X
X#ifndef XFRACT
Xvoid mStkCoTanh(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkCoTanh();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkCoTanh(void) {
X   long x, y, siny, cosy, sinhx, coshx, denom;
X   x = Arg1->l.x >> Delta16;
X   x = x << 1;
X   y = Arg1->l.y >> Delta16;
X   y = y << 1;
X   SinCos086(y, &siny, &cosy);
X   SinhCosh086(x, &sinhx, &coshx);
X   denom = coshx - cosy;
X   if(denom == 0) return;
X   Arg1->l.x = divide(sinhx,denom,bitshift);
X   Arg1->l.y = -divide(siny,denom,bitshift);
X}
X#endif
X
Xvoid (*StkCoTanh)(void) = dStkCoTanh;
X
X/* The following functions are not directly used by the parser - support
X   for the parser was not provided because the existing parser language
X   represents these quite easily. They are used for fn variable support
X   in miscres.c but are placed here because they follow the pattern of
X   the other parser functions. TIW 04-22-91 */
X
Xvoid dStkRecip(void) {
X   double mod;
X   mod =Arg1->d.x * Arg1->d.x + Arg1->d.y * Arg1->d.y;
X   if(mod <= DBL_MIN) return;
X   Arg1->d.x =  Arg1->d.x/mod;
X   Arg1->d.y = -Arg1->d.y/mod;
X}
X
X#ifndef XFRACT
Xvoid mStkRecip(void) {
X   struct MP mod;
X   mod = *MPadd(*MPmul(Arg1->m.x, Arg1->m.x),*MPmul(Arg1->m.y, Arg1->m.y));
X   if(mod.Mant <= 0L) return;
X   Arg1->m.x = *MPdiv(Arg1->m.x,mod);
X   Arg1->m.y = *MPdiv(Arg1->m.y,mod);
X   Arg1->m.y.Exp ^= 0x8000;
X}
X
Xvoid lStkRecip(void) {
X   long mod;
X   mod = multiply(Arg1->l.x,Arg1->l.x,bitshift)
X      + multiply(Arg1->l.y,Arg1->l.y,bitshift);
X   if(mod<=0L) return;
X   Arg1->l.x =  divide(Arg1->l.x,mod,bitshift);
X   Arg1->l.y = -divide(Arg1->l.y,mod,bitshift);
X}
X#endif
X
Xvoid StkIdent(void) { /* do nothing - the function Z */
X}
X/* End TIW 04-22-91 */
X
Xvoid dStkSinh(void) {
X   double siny, cosy, sinhx, coshx;
X
X   FPUsincos(&Arg1->d.y, &siny, &cosy);
X   FPUsinhcosh(&Arg1->d.x, &sinhx, &coshx);
X   Arg1->d.x = sinhx*cosy;
X   Arg1->d.y = coshx*siny;
X}
X
X#ifndef XFRACT
Xvoid mStkSinh(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkSinh();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkSinh(void) {
X   long x, y, sinhx, coshx, siny, cosy;
X
X   x = Arg1->l.x >> Delta16;
X   y = Arg1->l.y >> Delta16;
X   SinCos086(y, &siny, &cosy);
X   SinhCosh086(x, &sinhx, &coshx);
X   Arg1->l.x = multiply(cosy, sinhx, ShiftBack); /* TIW 06-18-90 */
X   Arg1->l.y = multiply(siny, coshx, ShiftBack); /* TIW 06-18-90 */
X}
X#endif
X
Xvoid (*StkSinh)(void) = dStkSinh;
X
Xvoid dStkCos(void) {
X   double sinx, cosx, sinhy, coshy;
X
X   FPUsincos(&Arg1->d.x, &sinx, &cosx);
X   FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
X   Arg1->d.x = cosx*coshy;
X   Arg1->d.y = -sinx*sinhy; /* TIW 04-25-91 sign */
X}
X
X#ifndef XFRACT
Xvoid mStkCos(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkCos();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkCos(void) {
X   long x, y, sinx, cosx, sinhy, coshy;
X
X   x = Arg1->l.x >> Delta16;
X   y = Arg1->l.y >> Delta16;
X   SinCos086(x, &sinx, &cosx);
X   SinhCosh086(y, &sinhy, &coshy);
X   Arg1->l.x = multiply(cosx, coshy, ShiftBack); /* TIW 06-18-90 */
X   Arg1->l.y = -multiply(sinx, sinhy, ShiftBack); /* TIW 04-25-91 sign */
X}
X#endif
X
Xvoid (*StkCos)(void) = dStkCos;
X
X/* Bogus version of cos, to replicate bug which was in regular cos till v16: */
X
Xvoid dStkCosXX(void) {
X   dStkCos();
X   Arg1->d.y = -Arg1->d.y;
X}
X
X#ifndef XFRACT
Xvoid mStkCosXX(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkCosXX();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkCosXX(void) {
X   lStkCos();
X   Arg1->l.y = -Arg1->l.y;
X}
X#endif
X
Xvoid (*StkCosXX)(void) = dStkCosXX;
X
Xvoid dStkCosh(void) {
X   double siny, cosy, sinhx, coshx;
X
X   FPUsincos(&Arg1->d.y, &siny, &cosy);
X   FPUsinhcosh(&Arg1->d.x, &sinhx, &coshx);
X   Arg1->d.x = coshx*cosy;
X   Arg1->d.y = sinhx*siny;
X}
X
X#ifndef XFRACT
Xvoid mStkCosh(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkCosh();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkCosh(void) {
X   long x, y, sinhx, coshx, siny, cosy;
X
X   x = Arg1->l.x >> Delta16;
X   y = Arg1->l.y >> Delta16;
X   SinCos086(y, &siny, &cosy);
X   SinhCosh086(x, &sinhx, &coshx);
X   Arg1->l.x = multiply(cosy, coshx, ShiftBack); /* TIW 06-18-90 */
X   Arg1->l.y = multiply(siny, sinhx, ShiftBack); /* TIW 06-18-90 */
X}
X#endif
X
Xvoid (*StkCosh)(void) = dStkCosh;
X
Xvoid dStkLT(void) {
X   Arg2->d.x = (double)(Arg2->d.x < Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkLT(void) {
X   Arg2->m.x = *fg2MP((long)(MPcmp(Arg2->m.x, Arg1->m.x) == -1), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkLT(void) {
X   Arg2->l.x = Arg2->l.x < Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkLT)(void) = dStkLT;
X
Xvoid dStkGT(void) {
X   Arg2->d.x = (double)(Arg2->d.x > Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkGT(void) {
X   Arg2->m.x = *fg2MP((long)(MPcmp(Arg2->m.x, Arg1->m.x) == 1), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkGT(void) {
X   Arg2->l.x = Arg2->l.x > Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkGT)(void) = dStkGT;
X
Xvoid dStkLTE(void) {
X   Arg2->d.x = (double)(Arg2->d.x <= Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkLTE(void) {
X   int comp;
X
X   comp = MPcmp(Arg2->m.x, Arg1->m.x);
X   Arg2->m.x = *fg2MP((long)(comp == -1 || comp == 0), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkLTE(void) {
X   Arg2->l.x = Arg2->l.x <= Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkLTE)(void) = dStkLTE;
X
Xvoid dStkGTE(void) {
X   Arg2->d.x = (double)(Arg2->d.x >= Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkGTE(void) {
X   int comp;
X
X   comp = MPcmp(Arg2->m.x, Arg1->m.x);
X   Arg2->m.x = *fg2MP((long)(comp == 1 || comp == 0), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkGTE(void) {
X   Arg2->l.x = Arg2->l.x >= Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkGTE)(void) = dStkGTE;
X
Xvoid dStkEQ(void) {
X   Arg2->d.x = (double)(Arg2->d.x == Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkEQ(void) {
X   int comp;
X
X   comp = MPcmp(Arg2->m.x, Arg1->m.x);
X   Arg2->m.x = *fg2MP((long)(comp == 0), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkEQ(void) {
X   Arg2->l.x = Arg2->l.x == Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkEQ)(void) = dStkEQ;
X
Xvoid dStkNE(void) {
X   Arg2->d.x = (double)(Arg2->d.x != Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkNE(void) {
X   int comp;
X
X   comp = MPcmp(Arg2->m.x, Arg1->m.x);
X   Arg2->m.x = *fg2MP((long)(comp != 0), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkNE(void) {
X   Arg2->l.x = Arg2->l.x != Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkNE)(void) = dStkNE;
X
Xvoid dStkOR(void) {
X   Arg2->d.x = (double)(Arg2->d.x || Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkOR(void) {
X   Arg2->m.x = *fg2MP((long)(Arg2->m.x.Mant || Arg1->m.x.Mant), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkOR(void) {
X   Arg2->l.x = Arg2->l.x || Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkOR)(void) = dStkOR;
X
Xvoid dStkAND(void) {
X   Arg2->d.x = (double)(Arg2->d.x && Arg1->d.x);
X   Arg2->d.y = 0.0;
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkAND(void) {
X   Arg2->m.x = *fg2MP((long)(Arg2->m.x.Mant && Arg1->m.x.Mant), 0);
X   Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkAND(void) {
X   Arg2->l.x = Arg2->l.x && Arg1->l.x;
X   Arg2->l.y = 0l;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkAND)(void) = dStkAND;
X
Xvoid dStkLog(void) {
X   FPUcplxlog(&Arg1->d, &Arg1->d);
X}
X
X#ifndef XFRACT
Xvoid mStkLog(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   dStkLog();
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkLog(void) {
X   _CMPLX x;
X
X   x.x = (double)Arg1->l.x / fg;
X   x.y = (double)Arg1->l.y / fg;
X   FPUcplxlog(&x, &x);
X   if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
X      Arg1->l.x = (long)(x.x * fg);
X      Arg1->l.y = (long)(x.y * fg);
X   }
X   else
X      overflow = 1;
X}
X#endif
X
Xvoid (*StkLog)(void) = dStkLog;
X
Xvoid FPUcplxexp(_CMPLX *x, _CMPLX *z) {
X   double e2x, siny, cosy;
X
X   if(fpu == 387)
X      FPUcplxexp387(x, z);
X   else {
X      e2x = exp(x->x);
X      FPUsincos(&x->y, &siny, &cosy);
X      z->x = e2x * cosy;
X      z->y = e2x * siny;
X   }
X}
X
X   void dStkExp(void) {
X      FPUcplxexp(&Arg1->d, &Arg1->d);
X   }
X
X#ifndef XFRACT
Xvoid mStkExp(void) {
X   Arg1->d = MPC2cmplx(Arg1->m);
X   FPUcplxexp(&Arg1->d, &Arg1->d);
X   Arg1->m = cmplx2MPC(Arg1->d);
X}
X
Xvoid lStkExp(void) {
X   _CMPLX x;
X
X   x.x = (double)Arg1->l.x / fg;
X   x.y = (double)Arg1->l.y / fg;
X   FPUcplxexp(&x, &x);
X   if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
X      Arg1->l.x = (long)(x.x * fg);
X      Arg1->l.y = (long)(x.y * fg);
X   }
X   else
X      overflow = 1;
X}
X#endif
X
Xvoid (*StkExp)(void) = dStkExp;
X
Xvoid dStkPwr(void) {
X   Arg2->d = ComplexPower(Arg2->d, Arg1->d);
X   Arg1--;
X   Arg2--;
X}
X
X#ifndef XFRACT
Xvoid mStkPwr(void) {
X   _CMPLX x, y;
X
X   x = MPC2cmplx(Arg2->m);
X   y = MPC2cmplx(Arg1->m);
X   x = ComplexPower(x, y);
X   Arg2->m = cmplx2MPC(x);
X   Arg1--;
X   Arg2--;
X}
X
Xvoid lStkPwr(void) {
X   _CMPLX x, y;
X
X   x.x = (double)Arg2->l.x / fg;
X   x.y = (double)Arg2->l.y / fg;
X   y.x = (double)Arg1->l.x / fg;
X   y.y = (double)Arg1->l.y / fg;
X   x = ComplexPower(x, y);
X   if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
X      Arg2->l.x = (long)(x.x * fg);
X      Arg2->l.y = (long)(x.y * fg);
X   }
X   else
X      overflow = 1;
X   Arg1--;
X   Arg2--;
X}
X#endif
X
Xvoid (*StkPwr)(void) = dStkPwr;
X
Xvoid EndInit(void) {
X   LastInitOp = OpPtr;
X}
X
Xstruct ConstArg far *isconst(char *Str, int Len) {
X   _CMPLX z;
X   unsigned n, j;
X
X   for(n = 0; n < vsp; n++) {
X      if(v[n].len == Len) {
X         if(!strnicmp(v[n].s, Str, Len))
X         {
X            if(n == 7)        /* The formula uses 'rand'. */
X               RandomSeed();
X            return(&v[n]);
X         }
X      }
X   }
X   v[vsp].s = Str;
X   v[vsp].len = Len;
X   v[vsp].a.d.x = v[vsp].a.d.y = 0.0;
X   if(isdigit(Str[0]) || Str[0] == '.') {
X      if(o[posp-1].f == StkNeg) {
X         posp--;
X         Str = Str - 1;
X         InitN--;
X         v[vsp].len++;
X      }
X      for(n = 1; isdigit(Str[n]) || Str[n] == '.'; n++);
X      if(Str[n] == ',') {
X         j = n + SkipWhiteSpace(&Str[n+1]) + 1;
X         if(isdigit(Str[j]) || (Str[j] == '-' && isdigit(Str[j+1]))) {
X            z.y = atof(&Str[j]);
X            for(; isdigit(Str[j]) || Str[j] == '.' || Str[j] == '-'; j++);
X            v[vsp].len = j;
X         }
X         else
X            z.y = 0.0;
X      }
X      else
X         z.y = 0.0;
X      z.x = atof(Str);
X      switch(MathType) {
X      case D_MATH:
X         v[vsp].a.d = z;
X         break;
X#ifndef XFRACT
X      case M_MATH:
X         v[vsp].a.m = cmplx2MPC(z);
X         break;
X      case L_MATH:
X         v[vsp].a.l.x = (long)(z.x * fg);
X         v[vsp].a.l.y = (long)(z.y * fg);
X         break;
X#endif
X      }
X      v[vsp].s = Str;
X   }
X   return(&v[vsp++]);
X}
X
Xstruct FNCT_LIST {
X   char far *s;              /* TIW 03-31-91 added far */
X   void (**ptr)(void);
X};
X
X/* TIW 03-30-91 START */
Xextern BYTE trigndx[];
X
X#if 0
Xextern void (*ltrig0)(void);
Xextern void (*ltrig1)(void);
Xextern void (*ltrig2)(void);
Xextern void (*ltrig3)(void);
Xextern void (*dtrig0)(void);
Xextern void (*dtrig1)(void);
Xextern void (*dtrig2)(void);
Xextern void (*dtrig3)(void);
Xextern void (*mtrig0)(void);
Xextern void (*mtrig1)(void);
Xextern void (*mtrig2)(void);
Xextern void (*mtrig3)(void);
X#endif
X
Xvoid (*StkTrig0)(void) = dStkSin;
Xvoid (*StkTrig1)(void) = dStkSqr;
Xvoid (*StkTrig2)(void) = dStkSinh;
Xvoid (*StkTrig3)(void) = dStkCosh;
X
Xchar maxfn = 0;
X/* TIW 03-30-91 STOP */
X
Xstruct FNCT_LIST far FnctList[] = {   /* TIW 03-31-91 added far */
X   "sin",  &StkSin,
X   "sinh", &StkSinh,
X   "cos",  &StkCos,
X   "cosh", &StkCosh,
X   "sqr",  &StkSqr,
X   "log",  &StkLog,
X   "exp",  &StkExp,
X   "abs",  &StkAbs,
X   "conj", &StkConj,
X   "real", &StkReal,
X   "imag", &StkImag,
X   "fn1",  &StkTrig0,   /* TIW 03-30-91 */
X   "fn2",  &StkTrig1,   /* TIW 03-30-91 */
X   "fn3",  &StkTrig2,   /* TIW 03-30-91 */
X   "fn4",  &StkTrig3,   /* TIW 03-30-91 */
X   "flip", &StkFlip,    /* MCP 4-9-91 */
X   "tan",  &StkTan,     /* TIW 04-22-91 */
X   "tanh", &StkTanh,    /* TIW 04-22-91 */
X   "cotan",  &StkCoTan, /* TIW 04-24-91 */
X   "cotanh", &StkCoTanh,/* TIW 04-24-91 */
X   "cosxx", &StkCosXX,  /* PB  04-28-91 */
X   "srand", &StkSRand,  /* MCP 11-21-91 */
X};
X
Xvoid NotAFnct(void) { }
Xvoid FnctNotFound(void) { }
X
X/* determine if s names a function and if so which one */
X/* TIW 04-22-91 */
Xwhichfn(char *s, int len)
X{
X   int out;
X   if(len != 3)
X      out = 0;
X   else if(strnicmp(s,"fn",2))
X      out = 0;
X   else
X      out = atoi(s+2);
X   if(out < 1 || out > 4)
X      out = 0;
X   return(out);
X}
X
X#ifndef XFRACT
Xvoid (far *isfunct(char *Str, int Len))(void)
X#else
Xvoid (*isfunct(Str, Len))()
Xchar *Str;
Xint Len;
X#endif
X{
X   unsigned n;
X   int functnum;    /* TIW 04-22-91 */
X
X   n = SkipWhiteSpace(&Str[Len]);
X   if(Str[Len+n] == '(') {
X      for(n = 0; n < sizeof(FnctList) / sizeof(struct FNCT_LIST); n++) {
X         if(far_strlen(FnctList[n].s) == Len) {        /* TIW 03-31-91 added far */
X            if(!far_strnicmp(FnctList[n].s, Str, Len)) {  /* TIW 03-31-91 added far */
X               /* count function variables */
X               if((functnum = whichfn(Str, Len)) != 0)    /* TIW 04-22-91 */
X                  if(functnum > maxfn)                  /* TIW 04-22-91 */
X                     maxfn = functnum;                  /* TIW 04-22-91 */
X               return(*FnctList[n].ptr);
X            }
X         }
X      }
X      return(FnctNotFound);
X   }
X   return(NotAFnct);
X}
X
Xvoid RecSortPrec(void) {
X   int ThisOp = NextOp++;
X
X   while(o[ThisOp].p > o[NextOp].p && NextOp < posp)
X      RecSortPrec();
X   f[OpPtr++] = o[ThisOp].f;
X}
X
Xstatic char *Constants[] = {
X   "pixel",        /* v[0] */
X   "p1",           /* v[1] */
X   "p2",           /* v[2] */
X   "z",            /* v[3] */
X   "LastSqr",      /* v[4] */
X   "xy",           /* v[5] */
X   "zt",           /* v[6] */
X   "rand",         /* v[7] */
X};
X
Xstruct SYMETRY {
X   char *s;
X   int n;
X} SymStr[] = {
X   "NOSYM",         0,
X   "XAXIS_NOPARM", -1,
X   "XAXIS",         1,
X   "YAXIS_NOPARM", -2,
X   "YAXIS",         2,
X   "XYAXIS_NOPARM",-3,
X   "XYAXIS",        3,
X   "ORIGIN_NOPARM",-4,
X   "ORIGIN",        4,
X   "PI_SYM_NOPARM",-5,
X   "PI_SYM",        5,
X   "NOPLOT",       99,
X   "", 0
X};
X
Xint ParseStr(char *Str) {
X   struct ConstArg far *c;
X   int ModFlag = 999, Len, Equals = 0, Mod[20], mdstk = 0;
X   int NewStatement;
X   struct ERROR { int n, s; } far *e;
X
X   SetRandom = Randomized = 0;
X   e = (struct ERROR far *)farmemalloc(sizeof(struct ERROR) * 100L);
X   /* PB 910417 changed "o" to be a temporary alloc, during ParseStr only */
X   o = (struct PEND_OP far *)farmemalloc(sizeof(struct PEND_OP) * (long)MAX_OPS);
X   if(!e || !o || !typespecific_workarea) {
X      static char far msg[]={"Insufficient memory to run fractal type 'formula'"};
X      stopmsg(0,msg);
X      return(1);
X   }
X   switch(MathType) {
X   case D_MATH:
X      StkAdd = dStkAdd;
X      StkSub = dStkSub;
X      StkNeg = dStkNeg;
X      StkMul = dStkMul;
X      StkSin = dStkSin;
X      StkSinh = dStkSinh;
X      StkLT = dStkLT;
X      StkLTE = dStkLTE;
X      StkMod = dStkMod;
X      StkSqr = dStkSqr;
X      StkCos = dStkCos;
X      StkCosh = dStkCosh;
X      StkLog = dStkLog;
X      StkExp = dStkExp;
X      StkPwr = dStkPwr;
X      StkDiv = dStkDiv;
X      StkAbs = dStkAbs;
X      StkReal = dStkReal;
X      StkImag = dStkImag;
X      StkConj = dStkConj;
X      StkTrig0 = dtrig0;   /* TIW 03-30-91 */
X      StkTrig1 = dtrig1;   /* TIW 03-30-91 */
X      StkTrig2 = dtrig2;   /* TIW 03-30-91 */
X      StkTrig3 = dtrig3;   /* TIW 03-30-91 */
X      StkFlip = dStkFlip;
X      StkTan = dStkTan;    /* TIW 04-22-91 */
X      StkTanh = dStkTanh;  /* TIW 04-22-91 */
X      StkCoTan = dStkCoTan;    /* TIW 04-24-91 */
X      StkCoTanh = dStkCoTanh;  /* TIW 04-24-91 */
X      StkCosXX = dStkCosXX;    /* PB  04-28-91 */
X      StkGT  = dStkGT;         /* MCP 11-3-91 */
X      StkGTE = dStkGTE;        /* MCP 11-3-91 */
X      StkEQ  = dStkEQ;         /* MCP 11-3-91 */
X      StkNE  = dStkNE;         /* MCP 11-3-91 */
X      StkAND = dStkAND;        /* MCP 11-3-91 */
X      StkOR  = dStkOR ;        /* MCP 11-3-91 */
X      StkSRand = dStkSRand;    /* MCP 11-21-91 */
X      break;
X#ifndef XFRACT
X   case M_MATH:
X      StkAdd = mStkAdd;
X      StkSub = mStkSub;
X      StkNeg = mStkNeg;
X      StkMul = mStkMul;
X      StkSin = mStkSin;
X      StkSinh = mStkSinh;
X      StkLT = mStkLT;
X      StkLTE = mStkLTE;
X      StkMod = mStkMod;
X      StkSqr = mStkSqr;
X      StkCos = mStkCos;
X      StkCosh = mStkCosh;
X      StkLog = mStkLog;
X      StkExp = mStkExp;
X      StkPwr = mStkPwr;
X      StkDiv = mStkDiv;
X      StkAbs = mStkAbs;
X      StkReal = mStkReal;
X      StkImag = mStkImag;
X      StkConj = mStkConj;
X      StkTrig0 = mtrig0;  /* TIW 03-30-91 */
X      StkTrig1 = mtrig1;  /* TIW 03-30-91 */
X      StkTrig2 = mtrig2;  /* TIW 03-30-91 */
X      StkTrig3 = mtrig3;  /* TIW 03-30-91 */
X      StkFlip = mStkFlip;
X      StkTan  = mStkTan;  /* TIW 04-22-91 */
X      StkTanh  = mStkTanh;/* TIW 04-22-91 */
X      StkCoTan  = mStkCoTan;  /* TIW 04-24-91 */
X      StkCoTanh  = mStkCoTanh;/* TIW 04-24-91 */
X      StkCosXX = mStkCosXX;   /* PB  04-28-91 */
X      StkGT  = mStkGT;         /* MCP 11-3-91 */
X      StkGTE = mStkGTE;        /* MCP 11-3-91 */
X      StkEQ  = mStkEQ;         /* MCP 11-3-91 */
X      StkNE  = mStkNE;         /* MCP 11-3-91 */
X      StkAND = mStkAND;        /* MCP 11-3-91 */
X      StkOR  = mStkOR ;        /* MCP 11-3-91 */
X      StkSRand = mStkSRand;    /* MCP 11-21-91 */
X      break;
X   case L_MATH:
X      Delta16 = bitshift - 16;
X      ShiftBack = 32 - bitshift; /* TW 06-18-90 */
X      StkAdd = lStkAdd;
X      StkSub = lStkSub;
X      StkNeg = lStkNeg;
X      StkMul = lStkMul;
X      StkSin = lStkSin;
X      StkSinh = lStkSinh;
X      StkLT = lStkLT;
X      StkLTE = lStkLTE;
X      StkMod = lStkMod;
X      StkSqr = lStkSqr;
X      StkCos = lStkCos;
X      StkCosh = lStkCosh;
X      StkLog = lStkLog;
X      StkExp = lStkExp;
X      StkPwr = lStkPwr;
X      StkDiv = lStkDiv;
X      StkAbs = lStkAbs;
X      StkReal = lStkReal;
X      StkImag = lStkImag;
X      StkConj = lStkConj;
X      StkTrig0 = ltrig0;   /* TIW 03-30-91 */
X      StkTrig1 = ltrig1;   /* TIW 03-30-91 */
X      StkTrig2 = ltrig2;   /* TIW 03-30-91 */
X      StkTrig3 = ltrig3;   /* TIW 03-30-91 */
X      StkFlip = lStkFlip;
X      StkTan  = lStkTan;   /* TIW 04-22-91 */
X      StkTanh  = lStkTanh; /* TIW 04-22-91 */
X      StkCoTan  = lStkCoTan;   /* TIW 04-24-91 */
X      StkCoTanh  = lStkCoTanh; /* TIW 04-24-91 */
X      StkCosXX = lStkCosXX;    /* PB  04-28-91 */
X      StkGT  = lStkGT;         /* MCP 11-3-91 */
X      StkGTE = lStkGTE;        /* MCP 11-3-91 */
X      StkEQ  = lStkEQ;         /* MCP 11-3-91 */
X      StkNE  = lStkNE;         /* MCP 11-3-91 */
X      StkAND = lStkAND;        /* MCP 11-3-91 */
X      StkOR  = lStkOR ;        /* MCP 11-3-91 */
X      StkSRand = lStkSRand;    /* MCP 11-21-91 */
X      break;
X#endif
X   }
X   maxfn = 0;   /* TIW 03-30-91 */
X   for(vsp = 0; vsp < sizeof(Constants) / sizeof(char*); vsp++) {
X      v[vsp].s = Constants[vsp];
X      v[vsp].len = strlen(Constants[vsp]);
X   }
X
X   v[6].a.d.x = v[6].a.d.y = 0.0;
X   v[7].a = v[6].a;
X
X   switch(MathType) {
X   case D_MATH:
X      v[1].a.d.x = param[0];
X      v[1].a.d.y = param[1];
X      v[2].a.d.x = param[2];
X      v[2].a.d.y = param[3];
X      break;
X#ifndef XFRACT
X   case M_MATH:
X      v[1].a.m.x = *d2MP(param[0]);
X      v[1].a.m.y = *d2MP(param[1]);
X      v[2].a.m.x = *d2MP(param[2]);
X      v[2].a.m.y = *d2MP(param[3]);
X      break;
X   case L_MATH:
X      v[1].a.l.x = (long)(param[0] * fg);
X      v[1].a.l.y = (long)(param[1] * fg);
X      v[2].a.l.x = (long)(param[2] * fg);
X      v[2].a.l.y = (long)(param[3] * fg);
X      break;
X#endif
X   }
X
X   LastInitOp = ErrPtr = paren = OpPtr = LodPtr = StoPtr = posp = 0;
X   NewStatement = 1;
X   SyntaxErr = -1;
X   ExpectingArg = 1;
X   for(n = 0; Str[n]; n++) {
X      if(!Str[n])
X         break;
X      InitN = n;
X      switch(Str[n]) {
X      case ' ':
X      case '\t':
X      case '\r':
X      case '\n':
X         break;
X      case '(':
X         paren++;
X         if(!ExpectingArg)
X            SyntaxErr = 1;
X         break;
X      case ')':
X         if(paren)
X            paren--;
X         else
X            SyntaxErr = 2;
X         if(ExpectingArg) {
X            e[ErrPtr].n = InitN;
X            e[ErrPtr++].s = 0;
X         }
X         break;
X      case '|':
X         if(Str[n+1] == '|') {
X            if(ExpectingArg)
X               SyntaxErr = 0;
X            ExpectingArg = 1;
X            n++;
X            o[posp].f = StkOR;
X            o[posp++].p = 7 - (paren + Equals)*15;
X         }
X         else if(ModFlag == paren-1) {
X            if(ExpectingArg)
X               SyntaxErr = 0;
X            paren--;
X            ModFlag = Mod[--mdstk];
X         }
X         else {
X            if(!ExpectingArg)
X               SyntaxErr = 1;
X            Mod[mdstk++] = ModFlag;
X            o[posp].f = StkMod;
X            o[posp++].p = 2 - (paren + Equals)*15;
X            ModFlag = paren++;
X         }
X         break;
X      case ',':
X      case ';':
X         if(paren) {
X            e[ErrPtr].n = InitN;
X            e[ErrPtr++].s = 3;
X         }
X         if(!ExpectingArg) {
X            NewStatement = 1;
X            ExpectingArg = 1;
X            o[posp].f = (void(far*)(void))0;
X            o[posp++].p = 15;
X            o[posp].f = StkClr;
X            o[posp++].p = -30000;
X            Equals = paren = 0;
X         }
X         else if(!NewStatement)
X            SyntaxErr = 0;
X         break;
X      case ':':
X         if(paren) {
X            e[ErrPtr].n = InitN;
X            e[ErrPtr++].s = 3;
X         }
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         else
X            ExpectingArg = 1;
X         o[posp].f = (void(far*)(void))0;
X         o[posp++].p = 15;
X         o[posp].f = EndInit;
X         o[posp++].p = -30000;
X         Equals = paren = 0;
X         LastInitOp = 10000;
X         NewStatement = 1;
X         break;
X      case '+':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         o[posp].f = StkAdd;
X         o[posp++].p = 4 - (paren + Equals)*15;
X         break;
X      case '-':
X         if(ExpectingArg) {
X            o[posp].f = StkNeg;
X            o[posp++].p = 2 - (paren + Equals)*15;
X         }
X         else {
X            o[posp].f = StkSub;
X            o[posp++].p = 4 - (paren + Equals)*15;
X            ExpectingArg = 1;
X         }
X         break;
X      case '&':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         if(Str[n+1] == '&') {
X            n++;
X            o[posp].f = StkAND;
X            o[posp++].p = 7 - (paren + Equals)*15;
X         }
X         else
X            SyntaxErr = 4;
X         break;
X      case '!':
X         if(Str[n+1] == '=') {
X            if(ExpectingArg)
X               SyntaxErr = 0;
X            ExpectingArg = 1;
X            n++;
X            o[posp].f = StkNE;
X            o[posp++].p = 6 - (paren + Equals)*15;
X         }
X         else
X            SyntaxErr = 4;
X         break;
X      case '<':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         if(Str[n+1] == '=') {
X            n++;
X            o[posp].f = StkLTE;
X         }
X         else
X            o[posp].f = StkLT;
X         o[posp++].p = 6 - (paren + Equals)*15;
X         break;
X      case '>':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         if(Str[n+1] == '=') {
X            n++;
X            o[posp].f = StkGTE;
X         }
X         else
X            o[posp].f = StkGT;
X         o[posp++].p = 6 - (paren + Equals)*15;
X         break;
X      case '*':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         o[posp].f = StkMul;
X         o[posp++].p = 3 - (paren + Equals)*15;
X         break;
X      case '/':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         o[posp].f = StkDiv;
X         o[posp++].p = 3 - (paren + Equals)*15;
X         break;
X      case '^':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         o[posp].f = StkPwr;
X         o[posp++].p = 2 - (paren + Equals)*15;
X         break;
X      case '=':
X         if(ExpectingArg)
X            SyntaxErr = 0;
X         ExpectingArg = 1;
X         if(Str[n+1] == '=') {
X            n++;
X            o[posp].f = StkEQ;
X            o[posp++].p = 6 - (paren + Equals)*15;
X         }
X         else
X         {
X            o[posp-1].f = StkSto;
X            o[posp-1].p = 5 - (paren + Equals)*15;
X            Store[StoPtr++] = Load[--LodPtr];
X            Equals++;
X         }
X         break;
X      default:
X         if(isalnum(Str[n]) || Str[n] == '.') {
X            while(isalnum(Str[n+1]) || Str[n+1] == '.')
X               n++;
X            if(!ExpectingArg) {
X               SyntaxErr = 1;
X            }
X            NewStatement = ExpectingArg = 0;
X            Len = (n+1)-InitN;
X            o[posp].f = isfunct(&Str[InitN], Len);
X            if(o[posp].f != NotAFnct) {
X               if(o[posp].f == FnctNotFound) {
X                  e[ErrPtr].n = InitN;
X                  e[ErrPtr++].s = 5;
X               }
X               else
X                  o[posp++].p = 1 - (paren + Equals)*15;
X               ExpectingArg = 1;
X            }
X            else {
X               c = isconst(&Str[InitN], Len);
X               Load[LodPtr++] = &(c->a);
X               o[posp].f = StkLod;
X               o[posp++].p = 1 - (paren + Equals)*15;
X               n = InitN + c->len - 1;
X               if(vsp >= MAX_ARGS-1) { /* PB 910417 safety test */
X                  e[ErrPtr].n = InitN;
X                  e[ErrPtr++].s = 7;
X                  break;
X               }
X            }
X         }
X         else {
X            if(ExpectingArg)
X               SyntaxErr = 0;
X            ExpectingArg = 1;
X            e[ErrPtr].n = InitN;
X            e[ErrPtr++].s = 4;
X         }
X         break;
X      }
X      if(SyntaxErr >= 0) {
X         e[ErrPtr].n = InitN;
X         e[ErrPtr++].s = SyntaxErr;
X         SyntaxErr = -1;
X      }
X      if(posp >= MAX_OPS-1) { /* PB 901103 added safety test here */
X         e[ErrPtr].n = InitN;
X         e[ErrPtr++].s = 7;
X         break;
X      }
X      if(ErrPtr > 50)         /* PB 910417 safety test */
X         break;
X   }
X
X   o[posp].f = (void(far*)(void))0;
X   o[posp++].p = 16;
X   if(paren > 0) {
X      e[ErrPtr].n = n;
X      e[ErrPtr++].s = 3;
X   }
X   if (ErrPtr) {
X      int i, j, k, m;
X      char msgbuf[700];  /* PB replaced printf loop by build msgbuf & stopmsg */
X      /* stopmsg defined to have max 9 lines, show at most first 3 errors */
X      msgbuf[0] = 0;
X      for(n = 0; n < ErrPtr && n < 3; n++) {
X         if (n)
X            strcat(msgbuf,"\n");
X#ifndef XFRACT
X         sprintf(&msgbuf[strlen(msgbuf)], "Error(%d):  %Fs\n  ", e[n].s, /*TIW 03-31-91 added %Fs*/
X            ErrStrings[e[n].s]);
X#else
X         sprintf(&msgbuf[strlen(msgbuf)], "Error(%d):  %s\n  ", e[n].s,
X            ErrStrings[e[n].s]);
X#endif
X         j = 24;
X         if ((i = e[n].n - j) < 0) {
X            j = e[n].n;
X            i = 0;
X         }
X         else {
X            strcat(msgbuf,"...");
X            j += 3;
X         }
X         k = strlen(msgbuf);
X         m = i + 66;
X         while (i < m && Str[i]) {
X            if ((msgbuf[k] = Str[i]) == '\n' || msgbuf[k] == '\t')
X               msgbuf[k] = ' ';
X            ++i;
X            ++k;
X         }
X         if (Str[i]) {
X            msgbuf[k++] = '.';
X            msgbuf[k++] = '.';
X            msgbuf[k++] = '.';
X         }
X         msgbuf[k++] = '\n';
X         while (--j >= -2)
X            msgbuf[k++] = ' ';
X         msgbuf[k++] = '^';
X         msgbuf[k] = 0;
X      }
X      stopmsg(8,msgbuf);
X   }
X   if(!ErrPtr) {
X      NextOp = 0;
X      LastOp = posp;
X      while(NextOp < posp) {
X         if(o[NextOp].f)
X            RecSortPrec();
X         else {
X            NextOp++;
X            LastOp--;
X         }
X      }
X   }
X   else
X      posp = 0;
X   farmemfree(o);
X   farmemfree(e);
X   /* PB 910417 free all arrays if error */
X   if (ErrPtr)
X      free_workarea();
X   return(ErrPtr);
X}
X
Xint Formula(void) {
X   if(FormName[0] == 0 || overflow) return(1);
X
X   LodPtr = InitLodPtr;
X   StoPtr = InitStoPtr;
X   OpPtr = InitOpPtr;
X
X   /* Set the random number, MCP 11-21-91 */
X   if(SetRandom || Randomized)
X   {
X      switch(MathType)
X      {
X      case D_MATH:
X         dRandom();
X         break;
X#ifndef XFRACT
X      case L_MATH:
X         lRandom();
X         break;
X      case M_MATH:
X         mRandom();
X#endif
X      }
X   }
X
X   Arg1 = &s[0];
X   Arg2 = Arg1-1;
X   while(OpPtr < LastOp) {
X      f[OpPtr++]();
X#ifdef WATCH_MP
X      x1 = *MP2d(Arg1->m.x);
X      y1 = *MP2d(Arg1->m.y);
X      x2 = *MP2d(Arg2->m.x);
X      y2 = *MP2d(Arg2->m.y);
X#endif
X   }
X
X   switch(MathType) {
X   case D_MATH:
X      old = new = v[3].a.d;
X      return(Arg1->d.x == 0.0);
X#ifndef XFRACT
X   case M_MATH:
X      old = new = MPC2cmplx(v[3].a.m);
X      return(Arg1->m.x.Exp == 0 && Arg1->m.x.Mant == 0);
X   case L_MATH:
X      lold = lnew = v[3].a.l;
X      if(overflow)
X         return(1);
X      return(Arg1->l.x == 0L);
X#endif
X   }
X   return(1);
X}
X
Xint form_per_pixel(void) {
X   if (FormName[0] == 0) return(1);
X   overflow = LodPtr = StoPtr = OpPtr = 0;
X   Arg1 = &s[0];
X   Arg2 = Arg1;
X   Arg2--;
X   if(Transparent3D)
X   {
X      TranspPerPixel(MathType, &v[5].a, &v[6].a);
X      v[0].a = v[5].a;
X   }
X   else
X   {
X      switch(MathType)
X      {
X      case D_MATH:
X         v[5].a.d.x = (v[0].a.d.x = dx0[col]+dShiftx);
X         v[5].a.d.x = (v[0].a.d.y = dy0[row]+dShifty);
X         break;
X#ifndef XFRACT
X      case M_MATH:
X         v[5].a.m.x = (v[0].a.m.x = *d2MP(dx0[col]+dShiftx));
X         v[5].a.m.x = (v[0].a.m.y = *d2MP(dy0[row]+dShifty));
X         break;
X      case L_MATH:
X         v[5].a.l.x = (v[0].a.l.x = lx0[col]+lShiftx);
X         v[5].a.l.x = (v[0].a.l.y = ly0[row]+lShifty);
X         break;
X#endif
X      }
X   }
X
X   if(LastInitOp)
X      LastInitOp = LastOp;
X   while(OpPtr < LastInitOp)
X      f[OpPtr++]();
X
X   InitLodPtr = LodPtr;
X   InitStoPtr = StoPtr;
X   InitOpPtr = OpPtr;
X
X   if(overflow)
X      return(0);
X   else
X      return(1);
X}
X
Xchar *FormStr;
X
Xextern char FormFileName[];   /* BDT file to find the formulas in */
Xextern char FormName[];    /* BDT Name of the Formula (if not null) */
X
Xchar *FindFormula(char *Str) {
X   char *FormulaStr = (char *)0;
X   char StrBuff[201];      /* PB, to match a safety fix in parser */
X   /* MCP, changed to an automatic variable */
X   char fullfilename[100]; /* BDT Full file name */
X   unsigned Done;
X   int c;
X   FILE *File;
X
X   findpath(FormFileName, fullfilename);  /* BDT get full path name */
X
X   symmetry = 0;
X   if((File = fopen(fullfilename, "rt")) != NULL) { /* BDT use variable files */
X      while(StrBuff[0]=0,/* TIW 04-22-91 */ fscanf(File, "%200[^ \n\t({]", StrBuff) != EOF) {
X         if(!stricmp(StrBuff, Str) || !Str[0]) {
X            while((c = getc(File)) != EOF) {
X               if(c == '(') {
X                  StrBuff[0]=0; /* TIW 04-22-91 */
X                  fscanf(File, "%200[^)]", StrBuff);
X                  for(n = 0; SymStr[n].s[0]; n++) {
X                     if(!stricmp(SymStr[n].s, StrBuff)) {
X                        symmetry = SymStr[n].n;
X                        break;
X                     }
X                  }
X                  if(!SymStr[n].s[0]) {
X                     sprintf(fullfilename,"Undefined symmetry:\n  %.76s",
X                        StrBuff);
X                     stopmsg(0,fullfilename); /* PB printf -> stopmsg */
X                     FormulaStr = (char *)0;  /* PB 910511 */
XExit:
X                     fclose(File);
X                     return(FormulaStr);
X                  }
X               }
X               else if(c == '{')
X                  break;
X            }
X
X            /* MCP 4-9-91, Strip the comments inside the formula.  Might
X                           as well allow unlimited formula lengths while
X                           we're at it.
X            */
X
X            FormulaStr = boxx;
X            n = Done = 0;
X            while(!Done) {
X               switch(c = getc(File)) {
X                  static char far msg[]={"Unexpected EOF:  missing a '}'"};
X               case EOF:
XUnexpectedEOF:
X                  stopmsg(0, msg);
X                  FormulaStr = (char *)0;
X                  goto Exit;
X               case '}':
X                  FormulaStr[n++] = 0;
X                  Done = 1;
X                  break;
X               case ';':
X                  while((c = getc(File)) != '\n') {
X                     if(c == EOF)
X                        goto UnexpectedEOF;
X                  }
X                  FormulaStr[n++] = ',';
X                  break;
X               case ' ':                     /* Also strip out the
X                                                   white spaces */
X
X               case '\t':
X                  break;
X               case '\n':
X                  FormulaStr[n++] = ',';
X                  break;
X               default:
X                  FormulaStr[n++] = c;
X               }
X               if (n >= 8192) { /* PB 4-9-91, added safety test */
X                  static char far msg[]={"Definition too large, missing a '}'?"};
X                  stopmsg(0, msg);
X                  FormulaStr = (char *)0;
X                  goto Exit;
X               }
X            }
X            goto Exit;
X         }
X
X         StrBuff[0]=0;  /* TIW 04-22-91 */
X         fscanf(File, "%200[ \n\t({]", StrBuff);
X         if(StrBuff[strcspn(StrBuff, "({")]) {
Xskipcomments:
X            fscanf(File, "%200[^}]", StrBuff);
X            if (getc(File)!= '}') goto skipcomments;
X         }
X      }
X      sprintf(fullfilename, "Formula \"%s\" not found", Str);
X      stopmsg(0,fullfilename);      /* PB printf -> stopmsg */
X      FormulaStr = (char *)0;       /* PB 910511 */
X      goto Exit;
X   }
X   sprintf(fullfilename, "Unable to open %s", FormFileName);
X   stopmsg(0,fullfilename);      /* PB printf -> stopmsg */
X   return((char *)0);            /* PB 910511 */
X}
X
Xint BadFormula() {
X   /*  moved from Parsera.Asm by CAE  12 July 1993  */
X
X   /*  this is called when a formula is bad, instead of calling  */
X   /*     the normal functions which will produce undefined results  */
X   return 1;
X}
X
Xint RunForm(char *Name) {  /*  returns 1 if an error occurred  */
X   /*  CAE changed fn 12 July 1993 to fix problem when formula not found  */
X
X   /*  first set the pointers so they point to a fn which always returns 1  */
X   curfractalspecific->per_pixel = BadFormula;
X   curfractalspecific->orbitcalc = BadFormula;
X
X   if (FormName[0] == 0 ){
X      return 1;  /*  and don't reset the pointers  */
X   }
X
X   parser_allocate();  /*  ParseStr() will test if this alloc worked  */
X
X   if((FormStr = FindFormula(Name)) != NULL ){
X      /*  formula was found  */
X      if (ParseStr(FormStr)){
X         /*  parse failed, don't change fn pointers  */
X         return 1;
X      }
X      else {
X         /*  parse succeeded so set the pointers back to good functions  */
X         curfractalspecific->per_pixel = form_per_pixel;
X         curfractalspecific->orbitcalc = Formula;
X         return 0;
X      }
X   }
X   else {
X      /*  formula not found, leave pointers set to BadFormula  */
X      return 1;                    /* PB, msg moved to FindFormula */
X   }
X}
X
Xint fpFormulaSetup(void) {
X#ifndef XFRACT
X   int RunFormRes;        /* CAE fp */
X
X   if (fpu > 0) {
X      MathType = D_MATH;
X      /* CAE changed below for fp */
X      RunFormRes = !RunForm(FormName); /* RunForm() returns 1 for failure */
X      if (RunFormRes && fpu >=387 && debugflag != 90 )
X         return CvtStk(); /* run fast assembler code in parsera.asm */
X      return RunFormRes;
X   }
X   else {
X      MathType = M_MATH;
X      return !RunForm(FormName);
X   }
X#else
X   MathType = D_MATH;
X   return(!RunForm(FormName));
X#endif
X}
X
Xint intFormulaSetup(void) {
X#ifdef XFRACT
X      printf("intFormulaSetup called!!!\n");
X      exit(-1);
X#endif
X      MathType = L_MATH;
X      fg = (double)(1L << bitshift);
X      fgLimit = (double)0x7fffffffL / fg;
X      ShiftBack = 32 - bitshift;
X      return(!RunForm(FormName));
X   }
X
X
X/* TIW added 06-20-90 so functions can be called from fractals.c */
Xvoid init_misc()
X{
X   static struct ConstArg far vv[5];
X   static union Arg argfirst,argsecond;
X   if(!v) /* PB 901103 added this test to avoid clobbering the real thing */
X      v = vv;  /* this is needed by lStkSqr and dStkSqr */
X   Arg1 = &argfirst; Arg2 = &argsecond; /* needed by all the ?Stk* functions */
X   fg = (double)(1L << bitshift);
X   fgLimit = (double)0x7fffffffL / fg;
X   ShiftBack = 32 - bitshift;
X   Delta16 = bitshift - 16;
X   bitshiftless1 = bitshift-1;
X}
X
X/* PB 910417 here to end changed.
X    Allocate sub-arrays from one main farmemalloc, using global variable
X    typespecific_workarea; calcfrac.c releases this area when calculation
X    ends or is terminated.
X    Moved the "f" array to be allocated as part of this.
X    */
X
Xstatic void parser_allocate(void)
X{
X   /* CAE fp changed below for v18 */
X   /* Note that XFRACT will waste about 6k here for pfls */
X   /* Somewhat more memory is now allocated than in v17 here */
X   /* however Store and Load were reduced in size to help make up for it */
X
X   unsigned int f_size,Store_size,Load_size,v_size, p_size;
X   free_workarea();
X   f_size = sizeof(void(far * far *)(void)) * MAX_OPS;
X   Store_size = sizeof(union Arg far *) * MAX_STORES;
X   Load_size = sizeof(union Arg far *) * MAX_LOADS;
X   v_size = sizeof(struct ConstArg) * MAX_ARGS;
X   p_size = sizeof(struct fls far *) * MAX_OPS;
X   typespecific_workarea =
X   farmemalloc((long)(f_size+Load_size+Store_size+v_size+p_size));
X   f = (void(far * far *)(void))typespecific_workarea;
X   Store = (union Arg far * far *)(f + MAX_OPS);
X   Load = (union Arg far * far *)(Store + MAX_STORES);
X   v = (struct ConstArg far *)(Load + MAX_LOADS);
X   pfls = (struct fls far *)(v + MAX_ARGS);
X}
X
Xvoid free_workarea()
X{
X   if(typespecific_workarea) {
X      farmemfree(typespecific_workarea);
X      typespecific_workarea = NULL;
X   }
X   Store = (union Arg far * far *)0;
X   Load = (union Arg far * far *)0;
X   v = (struct ConstArg far *)0;
X   f = (void(far * far *)(void))0;    /* CAE fp */
X   pfls = (struct fls far * )0;   /* CAE fp */
X
X}
SHAR_EOF
$TOUCH -am 1028230093 parser.c &&
chmod 0644 parser.c ||
echo "restore of parser.c failed"
set `wc -c parser.c`;Wc_c=$1
if test "$Wc_c" != "54067"; then
    echo original size 54067, current size $Wc_c
fi
# ============= parserfp.c ==============
echo "x - extracting parserfp.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > parserfp.c &&
X/* */
X/* PARSERFP.C  -- Part of FRACTINT fractal drawer. */
X/* */
X/*   By Chuck Ebbert  CompuServe [76306,1226] */
X/*                     internet: [e-mail]  */
X/* */
X/* Fast floating-point parser code.  The functions beginning with */
X/*    "fStk" are in PARSERA.ASM.  PARSER.C calls this code after */
X/*    it has parsed the formula. */
X/* */
X/*   Converts the function pointers/load pointers/store pointers */
X/*       built by parsestr() into an optimized array of function */
X/*       pointer/operand pointer pairs. */
X/* */
X/* ******************************************************************* */
X/*                                                                     */
X/*  Copyright (C) 1992, 1993 Chuck Ebbert.  All rights reserved.       */
X/*                                                                     */
X/*    This code may be freely distributed and used in non-commercial   */
X/*    programs provided the author is credited either during program   */
X/*    execution or in the documentation, and this copyright notice     */
X/*    is left intact.  Sale of this code, or its use in any commercial */
X/*    product requires permission from the author.  Nominal            */
X/*    distribution and handling fees may be charged by shareware and   */
X/*    freeware distributors.                                           */
X/*                                                                     */
X/*       Chuck Ebbert                                                  */
X/*       1915 Blust Ln.                                                */
X/*       Enola, PA  17025                                              */
X/*                                                                     */
X/* ******************************************************************* */
X/* */
X/* Revised 12 July 1993 (for v18.1) by CAE to fix optimizer bug  */
X/* */
X/* Revised 22 MAR 1993 (for Fractint v18.0)  */
X/* */
X/* Uncomment the next line to enable debug. */
X/*      #define TESTFP 1  */
X/* */
X
X#include <string.h>
X#include <ctype.h>
X#include <stdio.h>
X#include <stdlib.h>
X#include <float.h>
X#include <time.h>
X#include "mpmath.h"
X#include "prototyp.h"
X
Xextern union Arg *Arg1, *Arg2;
X/* Some of these variables should be renamed for safety */
Xextern union Arg s[20], far * far *Store, far * far *Load;
Xextern int StoPtr, LodPtr, OpPtr;
Xextern int debugflag;
Xextern unsigned vsp, LastOp;
Xextern struct ConstArg far *v;
Xextern int inside;         /* "inside" color to use    */
Xextern int outside;        /* "outside" color to use   */
Xextern int potflag;        /* potential enabled? */
Xextern char useinitorbit;
Xextern int InitLodPtr, InitStoPtr, InitOpPtr, LastInitOp;
Xextern void (far * far *f)(void);
X
Xstruct fls { /* function, load, store pointers  CAE fp */
X   void (near *function)(void);
X   union Arg near *operand;
X} far *pfls = (struct fls far *)0;
X
Xvoid  StkLod(void);
Xvoid  StkClr(void);
Xvoid  dStkAdd(void);
Xvoid  dStkSub(void);
Xvoid  dStkMul(void);
Xvoid  dStkDiv(void);
Xvoid  StkSto(void);
Xvoid  dStkSqr(void);
Xvoid  EndInit(void);
Xvoid  dStkMod(void);
Xvoid  dStkLTE(void);
Xvoid  dStkSin(void);
Xvoid  dStkCos(void);
Xvoid  dStkSinh(void);
Xvoid  dStkCosh(void);
Xvoid  dStkCosXX(void);
Xvoid  dStkTan(void);
Xvoid  dStkTanh(void);
Xvoid  dStkCoTan(void);
Xvoid  dStkCoTanh(void);
Xvoid  dStkLog(void);
Xvoid  dStkExp(void);
Xvoid  dStkPwr(void);
Xvoid  dStkLT(void);
Xvoid  dStkFlip(void);
Xvoid  dStkReal(void);
Xvoid  dStkImag(void);
Xvoid  dStkConj(void);
Xvoid  dStkNeg(void);
Xvoid  dStkAbs(void);
Xvoid  dStkRecip(void);
Xvoid  StkIdent(void);
Xvoid  dStkGT(void);
Xvoid  dStkGTE(void);
Xvoid  dStkNE(void);
Xvoid  dStkEQ(void);
Xvoid  dStkAND(void);
Xvoid  dStkOR(void);
X
X#define fgf(x) pfls[(x)].function
X#define opp(x) pfls[(x)].operand
X#define NO_OPERAND (void near *)0
X#define LastSqr v[4].a
X#define MAX_ARGS 100
X#define MAX_STACK 8
X#define TWO_FREE 6
X
X#ifndef XFRACT
X
Xvoid (near fStkPull2 )(void); /* pull up fpu stack from 2 to 4 */
Xvoid (near fStkPush2 )(void); /* push down fpu stack from 8 to 6 */
Xvoid (near fStkPush2a )(void); /* push down fpu stack from 6 to 4 */
Xvoid (near fStkPush4 )(void); /* push down fpu stack from 8 to 4 */
Xvoid (near fStkLodDup )(void); /* lod, dup */
Xvoid (near fStkLodSqr )(void); /* lod, sqr, dont save magnitude */
Xvoid (near fStkLodSqr2 )(void); /* lod, sqr, save magnitude */
Xvoid (near fStkStoDup )(void); /* store, duplicate */
Xvoid (near fStkStoSqr )(void); /* store, sqr, save lastsqr */
Xvoid (near fStkStoSqr0 )(void); /* store, sqr, dont save lastsqr */
Xvoid (near fStkLodDbl )(void); /* load, double */
Xvoid (near fStkStoDbl )(void); /* store, double */
Xvoid (near fStkReal2 )(void); /* fast ver. of real */
Xvoid (near fStkSqr )(void); /* sqr, save magnitude in lastsqr */
Xvoid (near fStkSqr0 )(void); /* sqr, no save magnitude */
Xvoid (near fStkClr1 )(void); /* clear fpu */
Xvoid (near fStkClr2 )(void); /* test stack top, clear fpu */
Xvoid (near fStkStoClr1 )(void); /* store, clr1 */
Xvoid (near fStkAdd )(void);
Xvoid (near fStkSub )(void);
Xvoid (near fStkSto )(void);
Xvoid (near fStkSto2 )(void); /* fast ver. of sto */
Xvoid (near fStkLod )(void);
Xvoid (near fStkEndInit )(void);
Xvoid (near fStkMod )(void);
Xvoid (near fStkMod2 )(void);
Xvoid (near fStkLodMod2 )(void);
Xvoid (near fStkStoMod2 )(void);
Xvoid (near fStkLTE )(void);
Xvoid (near fStkLodLTEMul )(void);
Xvoid (near fStkLTE2 )(void);
Xvoid (near fStkLodLTE )(void);
Xvoid (near fStkLodLTE2 )(void);
Xvoid (near fStkLodLTEAnd2 )(void);
Xvoid (near fStkLT )(void);
Xvoid (near fStkLodLTMul )(void);
Xvoid (near fStkLT2 )(void);
Xvoid (near fStkLodLT )(void);
Xvoid (near fStkLodLT2 )(void);
Xvoid (near fStkGTE )(void);
Xvoid (near fStkLodGTE )(void);
Xvoid (near fStkLodGTE2 )(void);
Xvoid (near fStkGT )(void);
Xvoid (near fStkGT2 )(void);
Xvoid (near fStkLodGT )(void);
Xvoid (near fStkLodGT2 )(void);
Xvoid (near fStkEQ )(void);
Xvoid (near fStkLodEQ )(void);
Xvoid (near fStkNE )(void);
Xvoid (near fStkLodNE )(void);
Xvoid (near fStkAND )(void);
Xvoid (near fStkANDClr2 )(void);
Xvoid (near fStkOR )(void);
Xvoid (near fStkSin )(void);
Xvoid (near fStkSinh )(void);
Xvoid (near fStkCos )(void);
Xvoid (near fStkCosXX )(void);
Xvoid (near fStkCosh )(void);
Xvoid (near fStkTan )(void);
Xvoid (near fStkTanh )(void);
Xvoid (near fStkCoTan )(void);
Xvoid (near fStkCoTanh )(void);
Xvoid (near fStkLog )(void);
Xvoid (near fStkExp )(void);
Xvoid (near fStkPwr )(void);
Xvoid (near fStkMul )(void);
Xvoid (near fStkDiv )(void);
Xvoid (near fStkFlip )(void);
Xvoid (near fStkReal )(void);
Xvoid (near fStkImag )(void);
Xvoid (near fStkRealFlip )(void);
Xvoid (near fStkImagFlip )(void);
Xvoid (near fStkConj )(void);
Xvoid (near fStkNeg )(void);
Xvoid (near fStkAbs )(void);
Xvoid (near fStkRecip )(void);
Xvoid (near fStkLodReal )(void);
Xvoid (near fStkLodRealC )(void);
Xvoid (near fStkLodImag )(void);
Xvoid (near fStkLodRealFlip )(void);
Xvoid (near fStkLodRealAbs )(void);
Xvoid (near fStkLodRealMul )(void);
Xvoid (near fStkLodRealAdd )(void);
Xvoid (near fStkLodRealSub )(void);
Xvoid (near fStkLodImagFlip )(void);
Xvoid (near fStkLodImagAbs )(void);
Xvoid (near fStkLodConj )(void);
Xvoid (near fStkLodAdd )(void);
Xvoid (near fStkLodSub )(void);
Xvoid (near fStkLodSubMod )(void);
Xvoid (near fStkLodMul )(void);
Xvoid (near fStkPLodAdd )(void);
Xvoid (near fStkPLodSub )(void);
Xvoid (near Img_Setup )(void);
X
X
Xstatic void (near *prevfptr )(void);
Xstatic int stkcnt, prevstkcnt, cvtptrx, prevlodptr, lastsqrused;
X
Xstatic void CvtFptr(void (near * ffptr)(void), int MinStk, int MaxStk,
X      int Delta )
X/* (MinStk <= 4, MaxStk >= TWO_FREE) */
X{
X   char testconst = 0;
X
X   if (stkcnt < MinStk ) { /* not enough operands on fpu stack */
X#ifdef TESTFP
X      stopmsg(0, "Inserted pull." );
X#endif
X      opp(cvtptrx) = NO_OPERAND;
X      fgf(cvtptrx++) = fStkPull2;  /* so adjust the stack, pull operand */
X      stkcnt += 2;
X   }
X   else if (stkcnt > MaxStk ) { /* too many operands */
X#ifdef TESTFP
X      stopmsg(0, "Inserted push." );
X#endif
X      opp(cvtptrx) = NO_OPERAND;
X      fgf(cvtptrx++) = fStkPush2;  /* push operand to adjust stack */
X      stkcnt -= 2;
X   }
X
X   /* set the operand pointer here */
X   if (ffptr == fStkSto ){ /* this must be before test for load */
X      opp(cvtptrx) = (void near *)(Store[StoPtr++]);
X   }
X   else if (ffptr == fStkLod && debugflag == 322 ){
X      /* if disabling optimizer, set load pointer here */
X      opp(cvtptrx) = (void near *)(Load[LodPtr++]);
X   }
X   else {
X      opp(cvtptrx) = NO_OPERAND;
X   }
X
X   if (debugflag == 322 ){
X      goto SkipOptimizer;
X   } /* --------------------------  begin optimizer  -------------- */
X
X   /* For the following: */
X   /*   * == cvtptrx points to this */
X   /*  () == this is about to be added to the array */
X
X   if (ffptr == fStkLod) { /* we are about to add Lod to the array */
X      if (prevfptr == fStkLod && Load[LodPtr-1] == Load[LodPtr] ) {
X         /* previous non-adjust operator was Lod of same operand */
X         /* i.e. found {? lodx ? (*lodx) } */
X         if (fgf(--cvtptrx) == fStkPush2 ){ /* prev fn was push */
X            /* {? lod *push (lod) } */
X            --cvtptrx; /* found {? *lod push (lod) } */
X            if (fgf(cvtptrx-1) == fStkPush2){ /* always more ops here */
X#ifdef TESTFP
X               stopmsg(0, "push *lod push (lod) -> push4 (*loddup)" );
X#endif
X               fgf(cvtptrx-1) = fStkPush4;
X            }
X            else { /* prev op not push */
X#ifdef TESTFP
X               stopmsg(0, "op *lod push (lod) -> op pusha(p=0) (*loddup)" );
X#endif
X               opp(cvtptrx) = NO_OPERAND; /* use 'alternate' push fn. */
X               fgf(cvtptrx++) = fStkPush2a; /* push with TWO_FREE on stack */
X               /* operand ptr will be set below */
X            }
X         }
X         else {  /* never {push *lod (lod) } so must be */
X#ifdef TESTFP
X            stopmsg(0, "op *lod (lod) -> op (*loddup)" );
X#endif
X         }
X         ffptr = fStkLodDup;
X      }
X      else if (prevfptr == fStkSto2
X               && Store[StoPtr-1] == Load[LodPtr] ){
X         /* store, load of same value */
X         /* only one operand on stack here when prev oper is Sto2 */
X         --cvtptrx;
X#ifdef TESTFP
X         stopmsg(0, "*sto2 (lod) -> (*stodup)" );
X#endif
X         ffptr = fStkStoDup;
X      }
X      /* This may cause roundoff problems when later operators */
X      /*  use the rounded value that was stored here, while the next */
X      /*  operator uses the more accurate internal value. */
X      else if (prevfptr == fStkStoClr1 && prevstkcnt == 2
X               && Store[StoPtr-1] == Load[LodPtr] ){
X         /* store, clear, load same value found */
X         /* only one operand was on stack so this is safe */
X         --cvtptrx;
X#ifdef TESTFP
X         stopmsg (0, "*StoClr1 (Lod) -> (*Sto2)" );
X#endif
X         ffptr = fStkSto2; /* use different Sto fn */
X      }
X      else {
X         /* the really awful hack below gets the first char of the name */
X         /*    of the variable being loaded */
X         testconst = **(((char * far *)Load[LodPtr] ) - 2 );
X         if ( !isalpha(testconst) && Load[LodPtr]->d.y == 0.0 ){
X            /* if first character not alpha, the var is a constant */
X#ifdef TESTFP
X            stopmsg (0, "(*lod) -> (*lodrealc)" );
X#endif
X            ffptr = fStkLodRealC; /* a real const is being loaded */
X         }
X      }
X      /* set the operand ptr here */
X      opp(cvtptrx) = (void near *)(Load[LodPtr++]);
X   }
X   else if (ffptr == fStkAdd ){
X      if (prevfptr == fStkLodDup ){ /* there is never a push before add */
X         --cvtptrx; /* found {? *loddup (add) } */
X         if (cvtptrx>0 && fgf(cvtptrx-1) == fStkPush2a ){
X            /* because {push lod lod } impossible so is {push loddup } */
X#ifdef TESTFP
X            stopmsg (0, "pusha *loddup (add) -> (*loddbl),stk+=2" );
X#endif
X            --cvtptrx;
X            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptr */
X            stkcnt += 2;
X         }
X         else if (cvtptrx>0 && fgf(cvtptrx-1) == fStkPush4 ){
X#ifdef TESTFP
X            stopmsg (0, "push4 *loddup (add) -> push2 (*loddbl),stk+=2" );
X#endif
X            fgf(cvtptrx-1) = fStkPush2;
X            stkcnt += 2;  /*  CAE added 12 July 1993 to fix bug  */
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "op *loddup (add) -> {op (*loddbl)" );
X#endif
X         }
X         ffptr = fStkLodDbl;
X      }
X      else if (prevfptr == fStkStoDup ){
X#ifdef TESTFP
X         stopmsg (0, "stodup (add) -> (stodbl)" );
X#endif
X         /* there are always exactly 4 on stack here */
X         --cvtptrx;
X         ffptr = fStkStoDbl;
X      }
X      else if (prevfptr == fStkLod ){ /* have found {lod (*add) } */
X         --cvtptrx;    /* {? *lod (add) } */
X         if (fgf(cvtptrx-1) == fStkPush2 ){
X#ifdef TESTFP
X            stopmsg (0, "*push load (add) -> (*plodadd),stk+=2" );
X#endif
X            --cvtptrx;
X            stkcnt += 2; /* eliminated a push */
X            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptrs */
X            ffptr = fStkPLodAdd;
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "op *lod (add) -> op (*lodadd)" );
X#endif
X            ffptr = fStkLodAdd;
X         }
X      }
X      else if (prevfptr == fStkLodReal || prevfptr == fStkLodRealC ){
X         --cvtptrx; /* found {? *lodreal (add) } */
X         if (fgf(cvtptrx-1) == fStkPush2 ){
X#ifdef TESTFP
X         stopmsg (0, "*push lodreal (add) -> (*lodrealadd),stk+=2" );
X#endif
X            --cvtptrx;
X            stkcnt += 2;    /* push eliminated */
X            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptrs */
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*lodreal (add) -> (*lodrealadd)" );
X#endif
X         }
X         ffptr = fStkLodRealAdd;
X      }
X   }
X   else if (ffptr == fStkSub ){
X      if (prevfptr == fStkLod ){
X         /* found {lod (*sub) } */
X         --cvtptrx; /* {*lod (sub) } */
X         /* there is never a sequence (lod push sub ) */
X         if (fgf(cvtptrx-1) == fStkPush2 ){
X#ifdef TESTFP
X            stopmsg (0, "*push lod (sub) -> (*plodsub),stk+=2" );
X#endif
X            --cvtptrx;
X            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptrs */
X            stkcnt += 2; /* push was deleted so adj. stkcnt */
X            ffptr = fStkPLodSub;
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*lod (sub) -> (*lodsub)" );
X#endif
X            ffptr = fStkLodSub;
X         }
X      }
X      else if (prevfptr == fStkLodReal || prevfptr == fStkLodRealC ){
X         --cvtptrx; /* {? *lodreal (sub) } */
X         if (fgf(cvtptrx-1) == fStkPush2 ){
X#ifdef TESTFP
X            stopmsg (0, "*push lodreal (sub) -> (*lodrealsub),stk+=2" );
X#endif
X            --cvtptrx;
X            stkcnt += 2;    /* push eliminated */
X            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptrs */
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*lodreal (sub) -> (*lodrealsub)" );
X#endif
X         }
X         ffptr = fStkLodRealSub;
X      }
X   }
X   else if (ffptr == fStkMul ){
X      if (prevfptr == fStkLodDup ){
X         /* found {loddup ? (*mul) } */
X         if (fgf(--cvtptrx) == fStkPush2 ){
X#ifdef TESTFP
X            stopmsg (0, "loddup *push (mul) -> (*lodsqr),stk+=2" );
X#endif
X            stkcnt += 2; /* eliminate this push */
X            --cvtptrx;    /* prev is a LodDup */
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*loddup (mul) -> (*lodsqr)" );
X#endif
X         }
X         ffptr = fStkLodSqr;
X      }
X      else if (prevfptr == fStkStoDup ){ /* no pushes here, 4 on stk. */
X#ifdef TESTFP
X         stopmsg (0, "stodup (mul) -> (*stosqr0)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkStoSqr0; /* dont save lastsqr here ever */
X      }
X      else if (prevfptr == fStkLod ){
X         --cvtptrx; /* {lod *? (mul) } */
X         if (fgf(cvtptrx) == fStkPush2 ){ /* {lod *push (mul) } */
X            --cvtptrx; /* {? *lod push (mul) } */
X            if(fgf(cvtptrx-1) == fStkPush2 ){
X#ifdef TESTFP
X               stopmsg (0, "push *lod push (mul) -> push4 (*lodmul)" );
X#endif
X               fgf(cvtptrx-1) = fStkPush4;
X            }
X            else {
X#ifdef TESTFP
X               stopmsg (0, "op *lod push (mul) -> op pusha (*lodmul)" );
X#endif
X               opp(cvtptrx+1) = opp(cvtptrx); /* fix operand ptr */
X               fgf(cvtptrx) = fStkPush2a;
X               opp(cvtptrx++) = NO_OPERAND;
X            }
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*lod (mul) -> (*lodmul)" );
X#endif
X         }
X         ffptr = fStkLodMul;
X      }
X      else if (prevfptr == fStkLodReal || prevfptr == fStkLodRealC ){
X         --cvtptrx; /* found {lodreal *? (mul) } */
X         if (fgf(cvtptrx) == fStkPush2 ){
X#ifdef TESTFP
X            stopmsg (0, "lodreal *push2 (mul) -> (*lodrealmul),stk+=2" );
X#endif
X            --cvtptrx;
X            stkcnt += 2;    /* stack ends with TWO_FREE, not 4 */
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*lodreal (mul) }-> {(*lodrealmul)" );
X#endif
X         }
X         ffptr = fStkLodRealMul;
X      }
X      else if (prevfptr == fStkLodLT && fgf(cvtptrx-1) != fStkPull2 ){
X         /* this shortcut fails if {Lod LT Pull Mul } found */
X#ifdef TESTFP
X         stopmsg (0, "LodLT (*Mul) -> (*LodLTMul)" );
X#endif
X         --cvtptrx; /* never { lod LT Push Mul } here */
X         ffptr = fStkLodLTMul;
X      }
X      else if (prevfptr == fStkLodLTE && fgf(cvtptrx-1) != fStkPull2 ){
X#ifdef TESTFP
X         stopmsg (0, "LodLTE (*mul) -> (*LodLTEmul)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodLTEMul;
X      }
X   }
X   else if (ffptr == fStkClr1 && prevfptr == fStkSto ){
X#ifdef TESTFP
X         stopmsg (0, "sto (*clr1) -> (*stoclr1)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkStoClr1;
X   }
X   else if (ffptr == fStkDiv ){
X      if (prevfptr == fStkLodRealC && vsp < MAX_ARGS - 1 ){
X         /* have found a divide by a real constant */
X         /*  and there is space to create a new one */
X         /* {lodrealc ? (*div) } */
X         --cvtptrx; /* change '/ const' to '* 1/const' */
X         if (fgf(cvtptrx) == fStkPush2 ){
X#ifdef TESTFP
X            stopmsg (0, "lodrealc *push (div) -> (*lodrealmul),stk+=2" );
X#endif
X            --cvtptrx;
X            stkcnt += 2;
X         }
X         else {
X#ifdef TESTFP
X            stopmsg (0, "*lodrealc (div) -> {(*lodrealmul)" );
X#endif
X         }
X         v[vsp].s = (void near *)0; /* this constant has no name */
X         v[vsp].len = 0;
X         v[vsp].a.d.x = 1.0 / Load[LodPtr-1]->d.x;
X         v[vsp].a.d.y = 0.0;
X         opp(cvtptrx) = (void near *)&v[vsp++].a; /* isn't C fun! */
X         ffptr = fStkLodRealMul;
X      }
X   }
X   else if (ffptr == fStkReal ){
X      if (prevfptr == fStkLod ){
X#ifdef TESTFP
X         stopmsg (0, "lod (*real) -> (*lodreal)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodReal;
X      }
X      else if (stkcnt < MAX_STACK ){
X#ifdef TESTFP
X         stopmsg (0, "(*real) -> (*real2)" );
X#endif
X         ffptr = fStkReal2;
X      }
X   }
X   else if (ffptr == fStkImag && prevfptr == fStkLod ){
X#ifdef TESTFP
X         stopmsg (0, "lod (*imag) -> lodimag" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodImag;
X   }
X   else if (ffptr == fStkConj && prevfptr == fStkLod ){
X#ifdef TESTFP
X         stopmsg (0, "lod (*conj) -> (*lodconj)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodConj;
X   }
X   else if (ffptr == fStkMod && stkcnt < MAX_STACK ){
X#ifdef TESTFP
X      stopmsg (0, "(*mod) -> (*mod2)" );
X#endif
X      ffptr = fStkMod2; /* use faster version if room on stack */
X      if (prevfptr == fStkLod ){
X#ifdef TESTFP
X         stopmsg (0, "lod (*mod2) -> (*lodmod2)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodMod2;
X      }
X      else if (prevfptr == fStkSto || prevfptr == fStkSto2 ){
X#ifdef TESTFP
X         stopmsg (0, "sto (*mod2) -> (*stomod2)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkStoMod2;
X      }
X      else if (prevfptr == fStkLodSub ){
X#ifdef TESTFP
X         stopmsg (0, "lodsub (*mod2) -> (*lodsubmod)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodSubMod;
X      }
X   }
X   else if (ffptr == fStkFlip ){
X      if (prevfptr == fStkReal || prevfptr == fStkReal2 ){
X#ifdef TESTFP
X         stopmsg (0, "real (*flip) -> (*realflip)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkRealFlip;
X      }
X      else if (prevfptr == fStkImag ){
X#ifdef TESTFP
X         stopmsg (0, "imag (*flip) -> (*imagflip)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkImagFlip;
X      }
X      else if (prevfptr == fStkLodReal ){
X#ifdef TESTFP
X         stopmsg (0, "lodreal (*flip) -> (*lodrealflip)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodRealFlip;
X      }
X      else if (prevfptr == fStkLodImag ){
X#ifdef TESTFP
X         stopmsg (0, "lodimag (*flip) -> (*lodimagflip)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodImagFlip;
X      }
X   }
X   else if (ffptr == fStkAbs ){
X      if (prevfptr == fStkLodReal ){
X#ifdef TESTFP
X         stopmsg (0, "lodreal (*abs) -> (*lodrealabs)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodRealAbs;
X      }
X      else if (prevfptr == fStkLodImag ){
X#ifdef TESTFP
X         stopmsg (0, "lodimag (*abs) -> (*lodimagabs)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodImagAbs;
X      }
X   }
X   else if (ffptr == fStkSqr ){
X      if (prevfptr == fStkLod && fgf(cvtptrx-1) != fStkPush2 ){
X#ifdef TESTFP
X         stopmsg (0, "lod (*sqr) -> (*lodsqr)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkLodSqr; /* assume no need to save lastsqr */
X         if (lastsqrused) {
X#ifdef TESTFP
X            stopmsg (0, "(*lodsqr) -> (*lodsqr2)" );
X#endif
X            ffptr = fStkLodSqr2; /* lastsqr is being used */
X         }
X      }
X      else if (prevfptr == fStkSto2 ){
X#ifdef TESTFP
X         stopmsg (0, "sto2 (*sqr) -> (*stosqr0)" );
X#endif
X         --cvtptrx;
X         ffptr = fStkStoSqr0; /* assume no need to save lastsqr */
X         if (lastsqrused) {
X#ifdef TESTFP
X            stopmsg (0, "(*stosqr0) -> (*stosqr)" );
X#endif
X            ffptr = fStkStoSqr; /* save lastsqr */
X         }
X      }
X      else {
X         if (!lastsqrused) {
X#ifdef TESTFP
X            stopmsg (0, "(*sqr) -> (*sqr0)" );
X#endif
X            ffptr = fStkSqr0; /* don't save lastsqr */
X         }
X      }
X   }
X   else if (ffptr == fStkLTE && ( prevfptr == fStkLod
X         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
X#ifdef TESTFP
X      stopmsg(0, "Lod (*LTE) -> (*LodLTE)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodLTE;
X   }
X   else if (ffptr == fStkLT && ( prevfptr == fStkLod
X         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
X#ifdef TESTFP
X      stopmsg(0, "Lod (*LT) -> (*LodLT)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodLT;
X   }
X   else if (ffptr == fStkGT && ( prevfptr == fStkLod
X         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
X#ifdef TESTFP
X      stopmsg(0, "Lod (*GT) -> (*LodGT)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodGT;
X   }
X   else if (ffptr == fStkGTE && ( prevfptr == fStkLod
X         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
X#ifdef TESTFP
X      stopmsg(0, "Lod (*GTE) -> (*LodGTE)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodGTE;
X   }
X   else if (ffptr == fStkNE && ( prevfptr == fStkLod
X         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
X#ifdef TESTFP
X      stopmsg(0, "Lod (*NE) -> (*LodNE)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodNE;
X   }
X   else if (ffptr == fStkEQ && ( prevfptr == fStkLod
X         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
X#ifdef TESTFP
X      stopmsg(0, "Lod (*EQ) -> (*LodEQ)" );
X#endif
X      --cvtptrx;
X      ffptr = fStkLodEQ;
X   }
X
XSkipOptimizer:  /* -----------  end of optimizer code  ------------ */
X
X   fgf(cvtptrx++) = prevfptr = ffptr;
X   prevstkcnt = stkcnt;
X
X   if (Delta == 999 ){
X      stkcnt = 0;
X   }
X   else {
X      stkcnt += Delta;
X   }
X   return;
X}
X
Xint CvtStk() {    /* convert the array of ptrs */
X   extern int fform_per_pixel(void);    /* these fns are in parsera.asm */
X   extern int fFormula(void);
X   extern int BadFormula(void);
X   extern char FormName[];
X   void (far *ftst)(void);
X   void (near *ntst)(void);
X
X#ifdef TESTFP
X   if (debugflag == 322) {
X      stopmsg(0, "Skipping optimizer." );
X   }
X#endif
X
X   for (OpPtr = LodPtr = lastsqrused = 0; OpPtr < LastOp; OpPtr++) {
X      ftst = f[OpPtr];
X      if (ftst == StkLod && Load[LodPtr++] == &LastSqr ){
X         lastsqrused = 1; /* lastsqr is being used in the formula */
X      }
X      if (  ftst != StkLod  /* these are the supported parser fns */
X            && ftst != StkClr
X            && ftst != dStkAdd
X            && ftst != dStkSub
X            && ftst != dStkMul
X            && ftst != dStkDiv
X            && ftst != StkSto
X            && ftst != dStkSqr
X            && ftst != EndInit
X            && ftst != dStkMod
X            && ftst != dStkLTE
X            && ftst != dStkSin
X            && ftst != dStkCos
X            && ftst != dStkSinh
X            && ftst != dStkCosh
X            && ftst != dStkCosXX
X            && ftst != dStkTan
X            && ftst != dStkTanh
X            && ftst != dStkCoTan
X            && ftst != dStkCoTanh
X            && ftst != dStkLog
X            && ftst != dStkExp
X            && ftst != dStkPwr
X            && ftst != dStkLT
X            && ftst != dStkFlip
X            && ftst != dStkReal
X            && ftst != dStkImag
X            && ftst != dStkConj
X            && ftst != dStkNeg
X            && ftst != dStkAbs
X            && ftst != dStkRecip
X            && ftst != StkIdent
X            && ftst != dStkGT
X            && ftst != dStkGTE
X            && ftst != dStkNE
X            && ftst != dStkEQ
X            && ftst != dStkAND
X            && ftst != dStkOR ){
X         stopmsg(0, "Fast failure, using old code" );
X         return 1; /* Use old code */
X      }
X   }
X
X#ifdef TESTFP
X   if (lastsqrused) {
X      stopmsg(0, "LastSqr used" );
X   }
X   else {
X      stopmsg(0, "LastSqr not used" );
X   }
X#endif
X
X   if (f[LastOp-1] != StkClr ){ /* some formulas don't clear at the end! */
X#ifdef TESTFP
X      stopmsg (0, "clr added at end" );
X#endif
X      f[LastOp++] = StkClr;
X   }
X   prevfptr = (void (near *)(void))0;
X   prevstkcnt = 999; /* there was not previous stk cnt */
X   stkcnt = cvtptrx = 0;
X
X   for (OpPtr = LodPtr = StoPtr = 0; OpPtr < LastOp; OpPtr++) {
X      ftst = f[OpPtr];
X      if (ftst == StkLod ) {
X#ifdef TESTFP
X         stopmsg(0, "lod,0,TWO_FREE,2" );
X#endif
X         CvtFptr(fStkLod, 0, TWO_FREE, 2 );
X         continue;
X      }
X      if (ftst == StkClr ) {
X         if (OpPtr == LastOp - 1 ){
X#ifdef TESTFP
X            stopmsg(0, "clr2,0,MAX_STACK,999" );
X#endif
X            CvtFptr(fStkClr2, 0, MAX_STACK, 999 );
X         } else {
X#ifdef TESTFP
X            stopmsg(0, "clr1,0,MAX_STACK,999" );
X#endif
X            CvtFptr(fStkClr1, 0, MAX_STACK, 999 );
X         }
X         continue;
X      }
X      if (ftst == dStkAdd ) {
X#ifdef TESTFP
X         stopmsg(0, "add,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkAdd, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkSub ) {
X#ifdef TESTFP
X         stopmsg(0, "sub,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkSub, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkDiv ) {
X#ifdef TESTFP
X         stopmsg(0, "div,4,TWO_FREE,-2" );
X#endif
X         CvtFptr(fStkDiv, 4, TWO_FREE, -2 );
X         continue;
X      }
X      if (ftst == dStkMul ) {
X#ifdef TESTFP
X         stopmsg(0, "mul,4,TWO_FREE,-2" );
X#endif
X         CvtFptr(fStkMul, 4, TWO_FREE, -2 );
X         continue;
X      }
X      if (ftst == StkSto ) {
X#ifdef TESTFP
X         stopmsg(0, "sto,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkSto, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkSqr ) {
X#ifdef TESTFP
X         stopmsg(0, "sqr,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkSqr, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == EndInit) {
X#ifdef TESTFP
X         stopmsg(0, "endinit,0,MAX_STACK,999" );
X#endif
X         CvtFptr(fStkEndInit, 0, MAX_STACK, 999 );
X         continue;
X      }
X      if (ftst == dStkMod ) {
X#ifdef TESTFP
X         stopmsg(0, "mod,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkMod, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkLTE ) {
X#ifdef TESTFP
X         stopmsg(0, "LTE,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkLTE, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkSin ) {
X#ifdef TESTFP
X         stopmsg(0, "sin,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkSin, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkCos ) {
X#ifdef TESTFP
X         stopmsg(0, "cos,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkCos, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkSinh ) {
X#ifdef TESTFP
X         stopmsg(0, "sinh,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkSinh, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkCosh ) {
X#ifdef TESTFP
X         stopmsg(0, "cosh,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkCosh, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkCosXX ) {
X#ifdef TESTFP
X         stopmsg(0, "cosxx,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkCosXX, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkTan ) {
X#ifdef TESTFP
X         stopmsg(0, "tan,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkTan, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkTanh ) {
X#ifdef TESTFP
X         stopmsg(0, "tanh,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkTanh, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkCoTan ) {
X#ifdef TESTFP
X         stopmsg(0, "cotan,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkCoTan, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkCoTanh ) {
X#ifdef TESTFP
X         stopmsg(0, "cotanh,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkCoTanh, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkExp ) {
X#ifdef TESTFP
X         stopmsg(0, "exp,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkExp, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkLog ) {
X#ifdef TESTFP
X         stopmsg(0, "log,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkLog, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == dStkPwr ) {
X#ifdef TESTFP
X         stopmsg(0, "pwr,4,TWO_FREE,-2" );
X#endif
X         CvtFptr(fStkPwr, 4, TWO_FREE, -2 );
X         continue;
X      }
X      if (ftst == dStkLT ) {
X#ifdef TESTFP
X         stopmsg(0, "LT,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkLT, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkFlip ) {
X#ifdef TESTFP
X         stopmsg(0, "flip,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkFlip, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkReal ) {
X#ifdef TESTFP
X         stopmsg(0, "real,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkReal, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkImag ) {
X#ifdef TESTFP
X         stopmsg(0, "imag,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkImag, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkConj ) {
X#ifdef TESTFP
X         stopmsg(0, "conj,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkConj, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkNeg ) {
X#ifdef TESTFP
X         stopmsg(0, "neg,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkNeg, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkAbs ) {
X#ifdef TESTFP
X         stopmsg(0, "abs,2,MAX_STACK,0" );
X#endif
X         CvtFptr(fStkAbs, 2, MAX_STACK, 0 );
X         continue;
X      }
X      if (ftst == dStkRecip ) {
X#ifdef TESTFP
X         stopmsg(0, "recip,2,TWO_FREE,0" );
X#endif
X         CvtFptr(fStkRecip, 2, TWO_FREE, 0 );
X         continue;
X      }
X      if (ftst == StkIdent ) {
X#ifdef TESTFP
X         stopmsg(0, "ident skipped" );
X#endif
X         /* don't bother converting this one */
X         continue;
X      }
X      if (ftst == dStkGT ) {
X#ifdef TESTFP
X         stopmsg(0, "GT,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkGT, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkGTE ) {
X#ifdef TESTFP
X         stopmsg(0, "GTE,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkGTE, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkEQ ) {
X#ifdef TESTFP
X         stopmsg(0, "EQ,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkEQ, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkNE ) {
X#ifdef TESTFP
X         stopmsg(0, "NE,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkNE, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkOR ) {
X#ifdef TESTFP
X         stopmsg(0, "OR,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkOR, 4, MAX_STACK, -2 );
X         continue;
X      }
X      if (ftst == dStkAND ) {
X#ifdef TESTFP
X         stopmsg(0, "AND,4,MAX_STACK,-2" );
X#endif
X         CvtFptr(fStkAND, 4, MAX_STACK, -2 );
X         continue;
X      }
X      stopmsg(0, "Fast failure, using old code." );
X      return 1; /* this should never happen but is not fatal now */
X   }
X
X   if (debugflag == 322 ){
X      /* skip these optimizations too */
X      goto skipfinalopt;
X   } /* ---------------------------------- final optimizations ---- */
X
X   ntst = fgf(cvtptrx-2 ); /* cvtptrx -> one past last operator (clr2) */
X   if (ntst == fStkLT ){
X#ifdef TESTFP
X      stopmsg (0, "LT Clr2 -> LT2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkLT2;
X   }
X   else if (ntst == fStkLodLT ){
X#ifdef TESTFP
X      stopmsg (0, "LodLT Clr2 -> LodLT2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkLodLT2;
X   }
X   else if (ntst == fStkLTE ){
X#ifdef TESTFP
X      stopmsg (0, "LTE Clr2 -> LTE2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkLTE2;
X   }
X   else if (ntst == fStkLodLTE ){
X#ifdef TESTFP
X      stopmsg (0, "LodLTE Clr2 -> LodLTE2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkLodLTE2;
X   }
X   else if (ntst == fStkGT ){
X#ifdef TESTFP
X      stopmsg (0, "GT Clr2 -> GT2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkGT2;
X   }
X   else if (ntst == fStkLodGT ){
X#ifdef TESTFP
X      stopmsg (0, "LodGT Clr2 -> LodGT2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkLodGT2;
X   }
X   else if (ntst == fStkLodGTE ){
X#ifdef TESTFP
X      stopmsg (0, "LodGTE Clr2 -> LodGTE2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkLodGTE2;
X   }
X   else if (fgf(cvtptrx-2 ) == fStkAND ){
X#ifdef TESTFP
X      stopmsg (0, "AND Clr2 -> ANDClr2" );
X#endif
X      --cvtptrx;
X      fgf(cvtptrx-1) = fStkANDClr2;
X      ntst = fgf(cvtptrx-2);
X      if (ntst == fStkLodLTE ){
X#ifdef TESTFP
X         stopmsg (0, "LodLTE ANDClr2 -> LodLTEAnd2" );
X#endif
X         --cvtptrx;
X         fgf(cvtptrx-1) = fStkLodLTEAnd2;
X      }
X   }
X
Xskipfinalopt: /* ---------------- end of final optimizations ----- */
X
X   LastOp = cvtptrx; /* save the new operator count */
X   LastSqr.d.y = 0.0; /* do this once per image */
X
X   /* now change the pointers */
X   if (FormName[0] != 0 ){ /* but only if parse succeeded */
X      curfractalspecific->per_pixel = fform_per_pixel;
X      curfractalspecific->orbitcalc = fFormula;
X   }
X   else {
X      curfractalspecific->per_pixel = BadFormula;
X      curfractalspecific->orbitcalc = BadFormula;
X   }
X   Img_Setup(); /* call assembler setup code */
X   return 1;
X}
X
X#endif  /*  XFRACT  */
SHAR_EOF
$TOUCH -am 1028230093 parserfp.c &&
chmod 0644 parserfp.c ||
echo "restore of parserfp.c failed"
set `wc -c parserfp.c`;Wc_c=$1
if test "$Wc_c" != "35051"; then
    echo original size 35051, current size $Wc_c
fi
# ============= plot3d.c ==============
echo "x - extracting plot3d.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > plot3d.c &&
X/*
X    This file includes miscellaneous plot functions and logic
X    for 3D, used by lorenz.c and line3d.c
X    By Tim Wegner and Marc Reinig.
X*/
X
X#include <stdio.h>
X#include <stdlib.h>
X#include "fractint.h"
X#include "fractype.h"
X#include "prototyp.h"
X
X/* Use these palette indices for red/blue - same on ega/vga */
X#define PAL_BLUE    1
X#define PAL_RED 2
X#define PAL_MAGENTA 3
X
Xextern void (_fastcall * standardplot)(int,int,int);
Xextern int Targa_Out, sxoffs, syoffs;
X
Xint whichimage;
Xextern int fractype;
Xextern int mapset;
Xextern int xadjust;
Xextern int yadjust;
Xextern int xxadjust;
Xextern int yyadjust;
Xextern int xshift;
Xextern int yshift;
Xextern char MAP_name[];
Xextern int init3d[];
Xextern int xdots;
Xextern int ydots;
Xextern int colors;
Xextern BYTE dacbox[256][3];
Xextern int debugflag;
X
Xextern int max_colors;
X
Xint xxadjust1;
Xint yyadjust1;
Xint eyeseparation = 0;
Xint glassestype = 0;
Xint xshift1;
Xint yshift1;
Xint xtrans = 0;
Xint ytrans = 0;
Xint red_local_left;
Xint red_local_right;
Xint blue_local_left;
Xint blue_local_right;
Xint red_crop_left   = 4;
Xint red_crop_right  = 0;
Xint blue_crop_left  = 0;
Xint blue_crop_right = 4;
Xint red_bright      = 80;
Xint blue_bright     = 100;
X
XBYTE T_RED;
X
X/* Bresenham's algorithm for drawing line */
Xvoid _fastcall draw_line (int X1, int Y1, int X2, int Y2, int color)
X
X{               /* uses Bresenham algorithm to draw a line */
X    int dX, dY;                     /* vector components */
X    int row, col,
X        final,                      /* final row or column number */
X        G,                  /* used to test for new row or column */
X        inc1,           /* G increment when row or column doesn't change */
X        inc2;               /* G increment when row or column changes */
X    char pos_slope;
X    extern int xdots,ydots;
X
X    dX = X2 - X1;                   /* find vector components */
X    dY = Y2 - Y1;
X    pos_slope = (dX > 0);                   /* is slope positive? */
X    if (dY < 0)
X    pos_slope = !pos_slope;
X    if (abs (dX) > abs (dY))                /* shallow line case */
X    {
X        if (dX > 0)         /* determine start point and last column */
X        {
X            col = X1;
X            row = Y1;
X            final = X2;
X        }
X        else
X        {
X            col = X2;
X            row = Y2;
X            final = X1;
X        }
X        inc1 = 2 * abs (dY);            /* determine increments and initial G */
X        G = inc1 - abs (dX);
X        inc2 = 2 * (abs (dY) - abs (dX));
X        if (pos_slope)
X            while (col <= final)    /* step through columns checking for new row */
X            {
X                (*plot) (col, row, color);
X                col++;
X                if (G >= 0)             /* it's time to change rows */
X                {
X                    row++;      /* positive slope so increment through the rows */
X                    G += inc2;
X                }
X                else                        /* stay at the same row */
X                    G += inc1;
X            }
X        else
X            while (col <= final)    /* step through columns checking for new row */
X            {
X                (*plot) (col, row, color);
X                col++;
X                if (G > 0)              /* it's time to change rows */
X                {
X                    row--;      /* negative slope so decrement through the rows */
X                    G += inc2;
X                }
X                else                        /* stay at the same row */
X                    G += inc1;
X            }
X    }   /* if |dX| > |dY| */
X    else                            /* steep line case */
X    {
X        if (dY > 0)             /* determine start point and last row */
X        {
X            col = X1;
X            row = Y1;
X            final = Y2;
X        }
X        else
X        {
X            col = X2;
X            row = Y2;
X            final = Y1;
X        }
X        inc1 = 2 * abs (dX);            /* determine increments and initial G */
X        G = inc1 - abs (dY);
X        inc2 = 2 * (abs (dX) - abs (dY));
X        if (pos_slope)
X            while (row <= final)    /* step through rows checking for new column */
X            {
X                (*plot) (col, row, color);
X                row++;
X                if (G >= 0)                 /* it's time to change columns */
X                {
X                    col++;  /* positive slope so increment through the columns */
X                    G += inc2;
X                }
X                else                    /* stay at the same column */
X                    G += inc1;
X            }
X        else
X            while (row <= final)    /* step through rows checking for new column */
X            {
X                (*plot) (col, row, color);
X                row++;
X                if (G > 0)                  /* it's time to change columns */
X                {
X                    col--;  /* negative slope so decrement through the columns */
X                    G += inc2;
X                }
X                else                    /* stay at the same column */
X                    G += inc1;
X            }
X    }
X}   /* draw_line */
X
X
X/* use this for continuous colors later */
Xvoid _fastcall plot3dsuperimpose16b(int x,int y,int color)
X{
X    int tmp;
X    if (color != 0)         /* Keeps index 0 still 0 */
X    {
X        color = colors - color; /*  Reverses color order */
X        color = color / 4;
X        if(color == 0)
X            color = 1;
X    }
X    color = 3;
X    tmp = getcolor(x,y);
X
X    /* map to 4 colors */
X    if(whichimage == 1) /* RED */
X    {
X        if(red_local_left < x && x < red_local_right)
X        {
X            putcolor(x,y,color|tmp);
X            if (Targa_Out)
X                targa_color(x, y, color|tmp);
X        }
X    }
X    else if(whichimage == 2) /* BLUE */
X        if(blue_local_left < x && x < blue_local_right)
X        {
X            color = color <<2;
X            putcolor(x,y,color|tmp);
X            if (Targa_Out)
X                targa_color(x, y, color|tmp);
X        }
X}
X
Xvoid _fastcall plot3dsuperimpose16(int x,int y,int color)
X{
X    int tmp;
X
X    tmp = getcolor(x,y);
X
X    if(whichimage == 1) /* RED */
X    {
X        color = PAL_RED;
X        if(tmp > 0 && tmp != color)
X            color = PAL_MAGENTA;
X        if(red_local_left < x && x < red_local_right)
X        {
X            putcolor(x,y,color);
X            if (Targa_Out)
X                targa_color(x, y, color);
X        }
X    }
X    else if(whichimage == 2) /* BLUE */
X        if(blue_local_left < x && x < blue_local_right)
X        {
X            color = PAL_BLUE;
X            if(tmp > 0 && tmp != color)
X                color = PAL_MAGENTA;
X            putcolor(x,y,color);
X            if (Targa_Out)
X                targa_color(x, y, color);
X        }
X}
X
X
Xvoid _fastcall plot3dsuperimpose256(int x,int y,int color)
X{
X    int tmp;
X    BYTE t_c;
X
X    t_c = 255-color;
X
X    if (color != 0)         /* Keeps index 0 still 0 */
X    {
X        color = colors - color; /*  Reverses color order */
X        if (max_colors == 236)
X        color = 1 + color / 21; /*  Maps colors 1-255 to 13 even ranges */
X        else
X        color = 1 + color / 18; /*  Maps colors 1-255 to 15 even ranges */
X    }
X
X    tmp = getcolor(x,y);
X    /* map to 16 colors */
X    if(whichimage == 1) /* RED */
X    {
X        if(red_local_left < x && x < red_local_right)
X        {
X            /* Overwrite prev Red don't mess w/blue */
X            putcolor(x,y,color|(tmp&240));
X            if (Targa_Out)
X                if (!ILLUMINE)
X                    targa_color(x, y, color|(tmp&240));
X                else
X                    targa_writedisk (x+sxoffs, y+syoffs, t_c, 0, 0);
X        }
X    }
X    else if(whichimage == 2) /* BLUE */
X        if(blue_local_left < x && x < blue_local_right)
X        {
X            /* Overwrite previous blue, don't mess with existing red */
X            color = color <<4;
X            putcolor(x,y,color|(tmp&15));
X            if (Targa_Out)
X                if (!ILLUMINE)
X                    targa_color(x, y, color|(tmp&15));
X                else
X                {
X                    targa_readdisk (x+sxoffs, y+syoffs, &T_RED, (BYTE *)&tmp, (BYTE *)&tmp);
X                    targa_writedisk (x+sxoffs, y+syoffs, T_RED, 0, t_c);
X                }
X        }
X}
X
Xvoid _fastcall plotIFS3dsuperimpose256(int x,int y,int color)
X{
X    int tmp;
X    BYTE t_c;
X
X    t_c = 255-color;
X
X    if (color != 0)         /* Keeps index 0 still 0 */
X    {
X        /* my mind is fried - lower indices = darker colors is EASIER! */
X        color = colors - color; /*  Reverses color order */
X        if (max_colors == 236)
X        color = 1 + color / 21; /*  Maps colors 1-255 to 13 even ranges */
X        else
X        color = 1 + color / 18; /*  Looks weird but maps colors 1-255 to 15
X                    relatively even ranges */
X    }
X
X    tmp = getcolor(x,y);
X    /* map to 16 colors */
X    if(whichimage == 1) /* RED */
X    {
X        if(red_local_left < x && x < red_local_right)
X        {
X            putcolor(x,y,color|tmp);
X            if (Targa_Out)
X                if (!ILLUMINE)
X                    targa_color(x, y, color|tmp);
X                else
X                    targa_writedisk (x+sxoffs, y+syoffs, t_c, 0, 0);
X        }
X    }
X    else if(whichimage == 2) /* BLUE */
X        if(blue_local_left < x && x < blue_local_right)
X        {
X            color = color <<4;
X            putcolor(x,y,color|tmp);
X            if (Targa_Out)
X                if (!ILLUMINE)
X                    targa_color(x, y, color|tmp);
X                else
X                {
X                    targa_readdisk (x+sxoffs, y+syoffs, &T_RED, (BYTE *)&tmp, (BYTE *)&tmp);
X                    targa_writedisk (x+sxoffs, y+syoffs, T_RED, 0, t_c);
X                }
X        }
X}
X
Xvoid _fastcall plot3dalternate(int x,int y,int color)
X{
X    int tmp;
X    BYTE t_c;
X
X    t_c = 255-color;
X    /* lorez high color red/blue 3D plot function */
X    /* if which image = 1, compresses color to lower 128 colors */
X
X    /* my mind is STILL fried - lower indices = darker colors is EASIER! */
X    color = colors - color;
X    if((whichimage == 1) && !((x+y)&1)) /* - lower half palette */
X    {
X        if(red_local_left < x && x < red_local_right)
X        {
X            putcolor(x,y,color>>1);
X            if (Targa_Out)
X                if (!ILLUMINE)
X                    targa_color(x, y, color>>1);
X                else
X                    targa_writedisk (x+sxoffs, y+syoffs, t_c, 0, 0);
X        }
X    }
X    else if((whichimage == 2) && ((x+y)&1) ) /* - upper half palette */
X    {
X        if(blue_local_left < x && x < blue_local_right)
X        {
X            putcolor(x,y,(color>>1)+(colors>>1));
X            if (Targa_Out)
X                if (!ILLUMINE)
X                    targa_color(x, y, (color>>1)+(colors>>1));
X                else
X                    targa_writedisk (x+sxoffs, y+syoffs, T_RED, 0, t_c);
X        }
X    }
X}
X
Xvoid plot_setup()
X{
X    double d_red_bright, d_blue_bright;
X    int i;
X
X    /* set funny glasses plot function */
X    switch(glassestype)
X    {
X    case 1:
X        standardplot = plot3dalternate;
X        break;
X
X    case 2:
X        if(colors == 256)
X            if (fractype != IFS3D)
X                standardplot = plot3dsuperimpose256;
X            else
X                standardplot = plotIFS3dsuperimpose256;
X        else
X            standardplot = plot3dsuperimpose16;
X        break;
X
X    default:
X        standardplot = putcolor;
X        break;
X    }
X
X    xshift1 = xshift = (XSHIFT * (double)xdots)/100;
X    yshift1 = yshift = (YSHIFT * (double)ydots)/100;
X
X    if(glassestype)
X    {
X        red_local_left  =   (red_crop_left      * (double)xdots)/100.0;
X        red_local_right =   ((100 - red_crop_right) * (double)xdots)/100.0;
X        blue_local_left =   (blue_crop_left     * (double)xdots)/100.0;
X        blue_local_right =  ((100 - blue_crop_right) * (double)xdots)/100.0;
X        d_red_bright    =   (double)red_bright/100.0;
X        d_blue_bright   =   (double)blue_bright/100.0;
X
X        switch(whichimage)
X        {
X        case 1:
X            xshift  += (eyeseparation* (double)xdots)/200;
X            xxadjust = ((xtrans+xadjust)* (double)xdots)/100;
X            xshift1 -= (eyeseparation* (double)xdots)/200;
X            xxadjust1 = ((xtrans-xadjust)* (double)xdots)/100;
X            break;
X
X        case 2:
X            xshift  -= (eyeseparation* (double)xdots)/200;
X            xxadjust = ((xtrans-xadjust)* (double)xdots)/100;
X            break;
X        }
X    }
X    else
X        xxadjust = (xtrans* (double)xdots)/100;
X        yyadjust = -(ytrans* (double)ydots)/100;
X
X    if (mapset)
X    {
X        ValidateLuts(MAP_name); /* read the palette file */
X        if(glassestype==1 || glassestype==2)
X        {
X            if(glassestype == 2 && colors < 256)
X            {
X                dacbox[PAL_RED  ][0] = 63;
X                dacbox[PAL_RED  ][1] =  0;
X                dacbox[PAL_RED  ][2] =  0;
X
X                dacbox[PAL_BLUE ][0] =  0;
X                dacbox[PAL_BLUE ][1] =  0;
X                dacbox[PAL_BLUE ][2] = 63;
X
X                dacbox[PAL_MAGENTA][0] = 63;
X                dacbox[PAL_MAGENTA][1] =    0;
X                dacbox[PAL_MAGENTA][2] = 63;
X            }
X            for (i=0;i<256;i++)
X            {
X                dacbox[i][0] = dacbox[i][0] * d_red_bright;
X                dacbox[i][2] = dacbox[i][2] * d_blue_bright;
X            }
X        }
X        spindac(0,1); /* load it, but don't spin */
X    }
X}
SHAR_EOF
$TOUCH -am 1028230093 plot3d.c &&
chmod 0644 plot3d.c ||
echo "restore of plot3d.c failed"
set `wc -c plot3d.c`;Wc_c=$1
if test "$Wc_c" != "13679"; then
    echo original size 13679, current size $Wc_c
fi
# ============= printer.c ==============
echo "x - extracting printer.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > printer.c &&
X/*  Printer.c
X *    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X *    Simple screen printing functions for FRACTINT
X *    By Matt Saucier CIS: [72371,3101]      7/2/89
X *    "True-to-the-spirit" of FRACTINT, this code makes few checks that you
X *    have specified a valid resolution for the printer (just in case yours
X *    has more dots/line than the Standard HP and IBM/EPSON,
X *    (eg, Wide Carriage, etc.))
X *
X *    PostScript support by Scott Taylor [72401,410] / (DGWM18A)   10/8/90
X *    For PostScript, use 'printer=PostScript/resolution' where resolution
X *    is ANY NUMBER between 10 and 600. Common values: 300,150,100,75.
X *    Default resolution for PostScript is 150 pixels/inch.
X *    At 200 DPI, a fractal that is 640x480 prints as a 3.2"x2.4" picture.
X *    PostScript printer names:
X *
X *    PostScript/PS            = Portrait printing
X *    PostScriptH/PostScriptL/PSH/PSL = Landscape printing
X *
X *    This code supports printers attached to a LPTx (1-3) parallel port.
X *    It also now supports serial printers AFTER THEY ARE CONFIGURED AND
X *    WORKING WITH THE DOS MODE COMMAND, eg. MODE COM1:9600,n,8,1 (for HP)
X *    (NOW you can also configure the serial port with the comport= command)
X *    Printing calls are made directly to the BIOS for DOS can't handle fast
X *    transfer of data to the HP.  (Or maybe visa-versa, HP can't handle the
X *    slow transfer of data from DOS)
X *
X *    I just added direct port access for COM1 and COM2 **ONLY**. This method
X *    does a little more testing than BIOS, and may work (especially on
X *    serial printer sharing devices) where the old method doesn't. I noticed
X *    maybe a 5% speed increase at 9600 baud. These are selected in the
X *    printer=.../.../31 for COM1 or 32 for COM2.
X *
X *    I also added direct parallel port access for LPT1 and LPT2 **ONLY**.
X *    This toggles the "INIT" line of the parallel port to reset the printer
X *    for each print session. It will also WAIT for a error / out of paper /
X *    not selected condition instead of quitting with an error.
X *
X *    Supported Printers:    Tested Ok:
X *     HP LaserJet
X *        LJ+,LJII         MDS
X *     Toshiba PageLaser     MDS (Set FRACTINT to use HP)
X *     IBM Graphics         MDS
X *     EPSON
X *        Models?         Untested.
X *     IBM LaserPrinter
X *        with PostScript     SWT
X *     HP Plotter         SWT
X *
X *    Future support to include OKI 20 (color) printer, and just about
X *    any printer you request.
X *
X *    Future modifications to include a more flexible, standard interface
X *    with the surrounding program, for easier portability to other
X *    programs.
X *
X * PostScript Styles:
X *  0  Dot
X *  1  Dot*           [Smoother]
X *  2  Inverted Dot
X *  3  Ring
X *  4  Inverted Ring
X *  5  Triangle        [45-45-90]
X *  6  Triangle*       [30-75-75]
X *  7  Grid
X *  8  Diamond
X *  9  Line
X * 10  Microwaves
X * 11  Ellipse
X * 12  RoundBox
X * 13  Custom
X * 14  Star
X * 15  Random
X * 16  Line*           [Not much different]
X *
X *  *  Alternate style
X *
X
X */
X
X#include <stdlib.h>
X
X#ifndef XFRACT
X#include <bios.h>
X#include <dos.h>
X#include <io.h>
X#endif
X
X#include <fcntl.h>
X#include <sys/types.h>
X#include <errno.h>
X#include <stdio.h>    /*** for vsprintf prototype ***/
X
X#ifndef XFRACT
X#include <conio.h>
X#include <stdarg.h>
X#else
X#include <varargs.h>
X#endif
X
X#include <string.h>
X#include <float.h>    /* for pow() */
X#include <math.h>    /*  "    "   */
X#include "fractint.h"
X#include "fractype.h"
X#include "prototyp.h"
X
X/* macros for near-space-saving purposes */
X/* CAE 9211 changed these for BC++ */
X#define PRINTER_PRINTF2(X,Y) {\
X   static char far tmp[] = X;\
X   Printer_printf(tmp,(Y));\
X}
X#define PRINTER_PRINTF3(X,Y,Z) {\
X   static char far tmp[] = X;\
X   Printer_printf(tmp,(Y),(Z));\
X}
X#define PRINTER_PRINTF4(X,Y,Z,W) {\
X   static char far tmp[] = X;\
X   Printer_printf(tmp,(Y),(Z),(W));\
X}
X
X/********      PROTOTYPES     ********/
X
X#ifndef XFRACT
Xstatic void Printer_printf(char far *fmt,...);
X#else
Xstatic void Printer_printf();
X#endif
Xstatic int  _fastcall printer(int c);
Xstatic void _fastcall print_title(int,int,char *);
Xstatic void printer_reset();
Xstatic rleprolog(int x,int y);
Xstatic void _fastcall graphics_init(int,int,char *);
X
X/********  EXTRN GLOBAL VARS  ********/
X
Xextern int xdots,ydots,            /* size of screen           */
X       fractype;               /* used for title block           */
Xextern SEGTYPE       extraseg;           /* used for buffering           */
Xextern BYTE dacbox[256][3];   /* for PostScript printing       */
Xextern BYTE dstack[2][3][400];
Xextern char FormName[];            /* for Title block info           */
Xextern char LName[];               /* for Title block info           */
Xextern char IFSName[];               /* for Title block info           */
Xextern char PrintName[];           /* Filename for print-to-file       */
Xextern float finalaspectratio;
Xextern double xxmin,xxmax,xx3rd,
X          yymin,yymax,yy3rd,param[]; /* for Title block info       */
Xextern int colors;
Xextern int dotmode;
Xextern unsigned int debugflag;
X
Xextern unsigned int  far pj_patterns[];
Xextern BYTE far pj_reds[];
Xextern BYTE far pj_blues[];
Xextern BYTE far pj_greens[];
X
X/********    GLOBALS       ********/
X
Xint Printer_Resolution,        /* 75,100,150,300 for HP;           */
X                   /* 60,120,240 for IBM;               */
X                   /* 90 or 180 for the PaintJet;           */
X                   /* 10-600 for PS                */
X                   /* 1-20 for Plotter               */
X    LPTNumber,               /* ==1,2,3 LPTx; or 11,12,13,14 for COM1-4  */
X                   /* 21,22 for direct port access for LPT1-2  */
X                   /* 31,32 for direct port access for COM1-2  */
X    Printer_Type,               /* ==1 HP,
X                      ==2 IBM/EPSON,
X                      ==3 Epson color,
X                      ==4 HP PaintJet,
X                      ==5,6 PostScript,
X                      ==7 HP Plotter           */
X    Printer_Titleblock,       /* Print info about the fractal?           */
X    Printer_Compress,          /* PostScript only - rle encode output       */
X    Printer_ColorXlat,          /* PostScript only - invert colors       */
X    Printer_SetScreen,          /* PostScript only - reprogram halftone ?    */
X    Printer_SFrequency,       /* PostScript only - Halftone Frequency K    */
X    Printer_SAngle,           /* PostScript only - Halftone angle     K    */
X    Printer_SStyle,           /* PostScript only - Halftone style     K    */
X    Printer_RFrequency,       /* PostScript only - Halftone Frequency R    */
X    Printer_RAngle,           /* PostScript only - Halftone angle     R    */
X    Printer_RStyle,           /* PostScript only - Halftone style     R    */
X    Printer_GFrequency,       /* PostScript only - Halftone Frequency G    */
X    Printer_GAngle,           /* PostScript only - Halftone angle     G    */
X    Printer_GStyle,           /* PostScript only - Halftone style     G    */
X    Printer_BFrequency,       /* PostScript only - Halftone Frequency B    */
X    Printer_BAngle,           /* PostScript only - Halftone angle     B    */
X    Printer_BStyle,           /* PostScript only - Halftone style     B    */
X    Print_To_File,          /* Print to file toggle               */
X    EPSFileType,          /* EPSFileType -
X                           1 = well-behaved,
X                           2 = much less behaved,
X                           3 = not well behaved       */
X    Printer_CRLF,             /* (0) CRLF (1) CR (2) LF                    */
X    ColorPS;                  /* (0) B&W  (1) Color                        */
Xint pj_width;
Xdouble ci,ck;
X
Xstatic int repeat, item, count, repeatitem, itembuf[128], rlebitsperitem,
X    rlebitshift, bitspersample, rleitem, repeatcount, itemsperline, items,
X    bitsperitem, bitshift;
X
Xstatic void putitem(), rleputxelval(), rleflush(), rleputrest();
X
Xstatic int LPTn;           /* printer number we're gonna use */
X
Xstatic FILE *PRFILE;
X
X#define TONES 17           /* Number of PostScript halftone styles */
X
Xstatic char *HalfTone[TONES]=  {
X             "D mul exch D mul add 1 exch sub",
X             "abs exch abs 2 copy add 1 gt {1 sub D mul exch 1 sub D mul add 1 sub} {D mul exch D mul add 1 exch sub} ifelse",
X             "D mul exch D mul add 1 sub",
X             "D mul exch D mul add 0.6 exch sub abs -0.5 mul",
X             "D mul exch D mul add 0.6 exch sub abs 0.5 mul",
X             "add 2 div",
X             "2 exch sub exch abs 2 mul sub 3 div",
X             "2 copy abs exch abs gt {exch} if pop 2 mul 1 exch sub 3.5 div",
X             "abs exch abs add 1 exch sub",
X             "pop",
X             "/wy exch def 180 mul cos 2 div wy D D D mul mul sub mul wy add 180 mul cos",
X             "D 5 mul 8 div mul exch D mul exch add sqrt 1 exch sub",
X             "D mul D mul exch D mul D mul add 1 exch sub",
X             "D mul exch D mul add sqrt 1 exch sub",
X             "abs exch abs 2 copy gt {exch} if 1 sub D 0 eq {0.01 add} if atan 360 div",
X             "pop pop rand 1 add 10240 mod 5120 div 1 exch sub",
X             "pop abs 2 mul 1 exch sub"
X            };
X
Xvoid printer_overlay() { }    /* for restore_active_ovly */
X
X#ifdef __BORLANDC__
X#if(__BORLANDC__ > 2)
X   #pragma warn -eff
X#endif
X#endif
X
Xstatic char EndOfLine[3];
X
Xvoid Print_Screen()
X{
X    int y,j;
X    char buff[192];        /* buffer for 192 sets of pixels  */
X                /* This is very large so that we can*/
X                /* get reasonable times printing  */
X                /* from modes like MAXPIXELSxMAXPIXELS disk-*/
X                /* video.  When this was 24, a MAXPIXELS*/
X                /* by MAXPIXELS pic took over 2 hours to*/
X                /* print.  It takes about 15 min now*/
X    int BuffSiz;        /* how much of buff[] we'll use   */
X    char far *es;        /* pointer to extraseg for buffer */
X    int i,x,k,            /* more indices           */
X    imax,            /* maximum i value (ydots/8)      */
X    res,            /* resolution we're gonna' use    */
X    high,            /* if LPTn>10 COM == com port to use*/
X    low,            /* misc               */
X                /************************************/
X    ptrid;            /* Printer Id code.          */
X                /* Currently, the following are   */
X                /* assigned:              */
X                /*          1. HPLJ (all)      */
X                /*         Toshiba PageLaser*/
X                /*          2. IBM Graphics      */
X                /*          3. Color Printer      */
X                /*          4. HP PaintJet      */
X                /*          5. PostScript      */
X                /************************************/
X    int pj_color_ptr[256];    /* Paintjet color translation */
X
X    ENTER_OVLY(OVLY_PRINTER);
X                /********   SETUP VARIABLES  ********/
X    memset(buff,0,192);
X
X    EndOfLine[0]=(((Printer_CRLF==1) || (Printer_CRLF==0)) ? 0x0D : 0x0A);
X    EndOfLine[1]=((Printer_CRLF==0) ? 0x0A : 0x00);
X    EndOfLine[2]=0x00;
X
X    if (Print_To_File>0)
X      {
X      while ((PRFILE = fopen(PrintName,"r"))) {
X     j = fgetc(PRFILE);
X     fclose(PRFILE);
X     if (j == EOF) break;
X     updatesavename((char *)PrintName);
X     }
X      if ((PRFILE = fopen(PrintName,"wb"))==NULL) Print_To_File = 0;
X      }
X
X#ifdef XFRACT
X      putstring(3,0,0,"Printing to:");
X      putstring(4,0,0,PrintName);
X      putstring(5,0,0,"               ");
X#endif
X
X    es=MK_FP(extraseg,0);
X
X    LPTn=LPTNumber-1;
X    if (((LPTn>2)&&(LPTn<10))||
X    ((LPTn>13)&&(LPTn<20))||
X    ((LPTn>21)&&(LPTn<30))||
X    (LPTn<0)||(LPTn>31)) LPTn=0;   /* default of LPT1 (==0)      */
X    ptrid=Printer_Type;
X    if ((ptrid<1)||(ptrid>7)) ptrid=2; /* default of IBM/EPSON         */
X    res=Printer_Resolution;
X#ifndef XFRACT
X    if ((LPTn==20)||(LPTn==21))
X    {
X    k = (inp((LPTn==20) ? 0x37A : 0x27A)) & 0xF7;
X    outp((LPTn==20) ? 0x37A : 0x27A,k);
X    k = k & 0xFB;
X    outp((LPTn==20) ? 0x37A : 0x27A,k);
X    k = k | 0x0C;
X    outp((LPTn==20) ? 0x37A : 0x27A,k);
X    }
X    if ((LPTn==30)||(LPTn==31))
X    {
X    outp((LPTn==30) ? 0x3F9 : 0x2F9,0x00);
X    outp((LPTn==30) ? 0x3FC : 0x2FC,0x00);
X    outp((LPTn==30) ? 0x3FC : 0x2FC,0x03);
X    }
X#endif
X
X    switch (ptrid) {
X
X    case 1:
X        if (res<75) res=75;
X        if ( (res<= 75)&&(ydots> 600)) res=100;
X        if ( (res<=100)&&(ydots> 800)) res=150;
X        if (((res<=150)&&(ydots>1200))||(res>300)) res=300;
X        break;
X
X    case 2:
X    case 3:
X        if (res<60) res=60;
X        if ((res<=60)&&(ydots>480)) res=120;
X        if (((res<=120)&&(ydots>960))||(res>240)) res=240;
X        break;
X
X    case 4: /****** PaintJet  *****/
X        {
X#ifndef XFRACT
X        /* Pieter Branderhorst:
X           My apologies if the numbers and approach here seem to be
X           picked out of a hat.  They were.  They happen to result in
X           a tolerable mapping of screen colors to printer colors on
X           my machine.  There are two sources of error in getting colors
X           to come out right.
X           1) Must match some dacbox values to the 330 PaintJet dithered
X          colors so that they look the same.  For this we use HP's
X          color values in printera.asm and modify by gamma separately
X          for each of red/green/blue.  This mapping is ok if the
X          preview shown on screen is a fairly close match to what
X          gets printed. The defaults are what work for me.
X           2) Must find nearest color in HP palette to each color in
X          current image. For this we use Lee Crocker's least sum of
X          differences squared approach, modified to spread the
X          values using gamma 1.7.  This mods was arrived at by
X          trial and error, just because it improves the mapping.
X           */
X        long ldist;
X        int r,g,b;
X        double gamma_val,gammadiv;
X        BYTE convert[256];
X        BYTE scale[64];
X
X        BYTE far *table_ptr;
X        res = (res < 150) ? 90 : 180;   /* 90 or 180 dpi */
X        if (Printer_SetScreen == 0) {
X        Printer_SFrequency = 21;  /* default red gamma */
X        Printer_SAngle       = 19;  /*       green gamma */
X        Printer_SStyle       = 16;  /*        blue gamma */
X        }
X        /* Convert the values in printera.asm.  We might do this just   */
X        /* once per run, but we'd need separate memory for that - can't */
X        /* just convert table in-place cause it could be in an overlay, */
X        /* might be paged out and then back in in original form.  Also, */
X        /* user might change gammas with a .par file entry mid-run.     */
X        for (j = 0; j < 3; ++j) {
X        switch (j) {
X            case 0: table_ptr = pj_reds;
X                i = Printer_SFrequency;
X                break;
X            case 1: table_ptr = pj_greens;
X                i = Printer_SAngle;
X                break;
X            case 2: table_ptr = pj_blues;
X                i = Printer_SStyle;
X            }
X        gamma_val = 10.0 / i;
X        gammadiv = pow(255,gamma_val) / 255;
X        for (i = 0; i < 256; ++i) { /* build gamma conversion table */
X            if ((i & 15) == 15)
X            thinking(1,"Calculating color translation");
X            convert[i] = (int)((pow((double)i,gamma_val) / gammadiv) + 0.5);
X            }
X        for (i = 0; i < 330; ++i) {
X            k = convert[table_ptr[i]];
X            if (k > 252) k = 252;
X            dstack[0][j][i] = (k + 2) >> 2;
X        }
X        }
X        /* build comparison lookup table */
X        gamma_val = 1.7;
X        gammadiv = pow(63,gamma_val) / 63;
X        for (i = 0; i < 64; ++i) {
X           if ((j = (int)((pow((double)i,gamma_val) / gammadiv) * 4 + 0.5)) < i)
X          j = i;
X           scale[i] = j;
X        }
X        for (i = 0; i < 3; ++i) /* convert values via lookup */
X        for (j = 0; j < 330; ++j)
X            dstack[1][i][j] = scale[dstack[0][i][j]];
X        /* Following code and the later code which writes to Paintjet    */
X        /* using pj_patterns was adapted from Lee Crocker's PGIF program */
X        for (i = 0; i < colors; ++i) { /* find nearest match colors */
X        r = scale[dacbox[i][0]];
X        g = scale[dacbox[i][1]];
X        b = scale[dacbox[i][2]];
X        ldist = 9999999;
X        /* check variance vs each PaintJet color */
X        /* if high-res 8 color mode, consider only 1st 8 colors */
X        j = (res == 90) ? 330 : 8;
X        while (--j >= 0) {
X            long dist;
X            dist  = (unsigned)(r-dstack[1][0][j]) * (r-dstack[1][0][j]);
X            dist += (unsigned)(g-dstack[1][1][j]) * (g-dstack[1][1][j]);
X            dist += (unsigned)(b-dstack[1][2][j]) * (b-dstack[1][2][j]);
X            if (dist < ldist) {
X            ldist = dist;
X            k = j;
X            }
X        }
X        pj_color_ptr[i] = k; /* remember best fit */
X        }
X        thinking(0,NULL);
X    /*  if (debugflag == 900 || debugflag == 902) {
X        color_test();
X        EXIT_OVLY;
X        return;
X        }  */
X        if (dotmode != 11) { /* preview */
X        memcpy(dstack[1],dacbox,768);
X        for (i = 0; i < colors; ++i)
X            for (j = 0; j < 3; ++j)
X            dacbox[i][j] = dstack[0][j][pj_color_ptr[i]];
X        spindac(0,1);
X        texttempmsg("Preview. Enter=go, Esc=cancel, k=keep");
X        i = getakeynohelp();
X        if (i == 'K' || i == 'k') {
X            EXIT_OVLY;
X            return;
X        }
X        memcpy(dacbox,dstack[1],768);
X        spindac(0,1);
X        if (i == 0x1B) {
X            EXIT_OVLY;
X            return;
X        }
X        }
X        break;
X#endif
X        }
X
X    case 5:
X    case 6: /***** PostScript *****/
X        if ( res < 10 && res != 0 ) res = 10; /* PostScript scales... */
X        if ( res > 600 ) res = 600; /* it can handle any range! */
X        if ((Printer_SStyle < 0) || (Printer_SStyle >= TONES))
X        Printer_SStyle = 0;
X        break;
X    }
X
X    /*****  Set up buffer size for immediate user gratification *****/
X    /*****    AKA, if we don't have to, don't buffer the data   *****/
X    BuffSiz=8;
X    if (xdots>1024) BuffSiz=192;
X
X    /*****   Initialize printer  *****/
X    if (Print_To_File < 1) {
X    printer_reset();
X    /* wait a bit, some printers need time after reset */
X    delay((ptrid == 4) ? 2000 : 500);
X    }
X
X    /******  INITIALIZE GRAPHICS MODES    ******/
X
X    graphics_init(ptrid,res,EndOfLine);
X
X    if (keypressed()) {     /* one last chance before we start...*/
X    EXIT_OVLY;
X    return;
X    }
X
X    memset(buff,0,192);
X
X                /*****    Get And Print Screen **** */
X    switch (ptrid) {
X
X    case 1:                /* HP LaserJet (et al)         */
X        imax=(ydots/8)-1;
X        for (x=0;((x<xdots)&&(!keypressed()));x+=BuffSiz) {
X        for (i=imax;((i>=0)&&(!keypressed()));i--) {
X            for (y=7;((y>=0)&&(!keypressed()));y--) {
X            for (j=0;j<BuffSiz;j++) {
X                if ((x+j)<xdots) {
X                buff[j]<<=1;
X                buff[j]+=(getcolor(x+j,i*8+y)&1);
X                }
X                }
X            }
X            for (j=0;j<BuffSiz;j++) {
X            *(es+j+BuffSiz*i)=buff[j];
X            buff[j]=0;
X            }
X            }
X        for (j=0;((j<BuffSiz)&&(!keypressed()));j++) {
X            if ((x+j)<xdots) {
X            PRINTER_PRINTF2("\033*b%iW",imax+1);
X            for (i=imax;((i>=0)&&(!keypressed()));i--) {
X                printer(*(es+j+BuffSiz*i));
X                }
X            }
X            }
X        }
X        if (!keypressed()) Printer_printf("\033*rB\014");
X        break;
X
X    case 2:                /* IBM Graphics/Epson         */
X        for (x=0;((x<xdots)&&(!keypressed()));x+=8) {
X        switch (res) {
X            case 60:  Printer_printf("\033K"); break;
X            case 120: Printer_printf("\033L"); break;
X            case 240: Printer_printf("\033Z"); break;
X            }
X        high=ydots/256;
X        low=ydots-(high*256);
X        printer(low);
X        printer(high);
X        for (y=ydots-1;(y>=0);y--) {
X            buff[0]=0;
X            for (i=0;i<8;i++) {
X            buff[0]<<=1;
X            buff[0]+=(getcolor(x+i,y)&1);
X            }
X            printer(buff[0]);
X            }
X        if (keypressed()) break;
X        Printer_printf(EndOfLine);
X        }
X        if (!keypressed()) printer(12);
X        break;
X
X    case 3:                /* IBM Graphics/Epson Color    */
X        high=ydots/256;
X        low=ydots%256;
X        for (x=0;((x<xdots)&&(!keypressed()));x+=8)
X        {
X        for (k=0; k<8; k++)  /* colors */
X            {
X            Printer_printf("\033r%d",k); /* set printer color */
X            switch (res)
X            {
X            case 60:  Printer_printf("\033K"); break;
X            case 120: Printer_printf("\033L"); break;
X            case 240: Printer_printf("\033Z"); break;
X            }
X            printer(low);
X            printer(high);
X            for (y=ydots-1;y>=0;y--)
X            {
X            buff[0]=0;
X            for (i=0;i<8;i++)
X                {
X                buff[0]<<=1;
X                if ((getcolor(x+i,y)%8)==k)
X                buff[0]++;
X                }
X            printer(buff[0]);
X            }
X            if (Printer_CRLF<2) printer(13);
X            }
X        if ((Printer_CRLF==0) || (Printer_CRLF==2)) printer(10);
X        }
X        printer(12);
X        printer(12);
X        printer_reset();
X        break;
X
X    case 4:               /* HP PaintJet       */
X        {
X        unsigned int fetchrows,fetched;
X        BYTE far *pixels, far *nextpixel;
X        /* for reasonable speed when using disk video, try to fetch
X           and store the info for 8 columns at a time instead of
X           doing getcolor calls down each column in separate passes */
X        fetchrows = 16;
X        while (1) {
X        if ((pixels = farmemalloc((long)(fetchrows)*ydots))) break;
X        if ((fetchrows >>= 1) == 0) {
X            static char far msg[]={"insufficient memory"};
X            stopmsg(0,msg);
X            break;
X        }
X        }
X        if (!pixels) break;
X        fetched = 0;
X        for (x = 0; (x < xdots && !keypressed()); ++x) {
X        if (fetched == 0) {
X            if ((fetched = xdots-x) > fetchrows)
X            fetched = fetchrows;
X            for (y = ydots-1; y >= 0; --y) {
X            if (debugflag == 602) /* flip image */
X                nextpixel = pixels + y;
X            else              /* reverse order for unflipped */
X                nextpixel = pixels + ydots-1 - y;
X            for (i = 0; i < fetched; ++i) {
X                *nextpixel = getcolor(x+i,y);
X                nextpixel += ydots;
X            }
X            }
X            nextpixel = pixels;
X        }
X        --fetched;
X        if (res == 180) { /* high-res 8 color mode */
X            int offset;
X            BYTE bitmask;
X            offset = -1;
X            bitmask = 0;
X            for (y = ydots - 1; y >= 0; --y) {
X            BYTE color;
X            if ((bitmask >>= 1) == 0) {
X                ++offset;
X                dstack[0][0][offset] = dstack[0][1][offset]
X                         = dstack[0][2][offset] = 0;
X                bitmask = 0x80;
X            }
X            /* translate 01234567 to 70123456 */
X            color = pj_color_ptr[*(nextpixel++)] - 1;
X            if ((color & 1)) dstack[0][0][offset] += bitmask;
X            if ((color & 2)) dstack[0][1][offset] += bitmask;
X            if ((color & 4)) dstack[0][2][offset] += bitmask;
X            }
X        }
X        else { /* 90 dpi, build 2 lines, 2 dots per pixel */
X            int bitct,offset;
X            bitct = offset = 0;
X            for (y = ydots - 1; y >= 0; --y) {
X            unsigned int color;
X            color = pj_patterns[pj_color_ptr[*(nextpixel++)]];
X            for (i = 0; i < 3; ++i) {
X                BYTE *bufptr;
X                bufptr = &dstack[0][i][offset];
X                *bufptr <<= 2;
X                if ((color & 0x1000)) *bufptr += 2;
X                if ((color & 0x0100)) ++*bufptr;
X                bufptr = &dstack[1][i][offset];
X                *bufptr <<= 2;
X                if ((color & 0x0010)) *bufptr += 2;
X                if ((color & 0x0001)) ++*bufptr;
X                color >>= 1;
X            }
X            if (++bitct == 4) {
X                bitct = 0;
X                ++offset;
X            }
X            }
X        }
X        for (i = 0; i < ((res == 90) ? 2 : 1); ++i) {
X            for (j = 0; j < 3; ++j) {
X            BYTE *bufptr,*bufend;
X            Printer_printf((j < 2) ? "\033*b%dV" : "\033*b%dW",
X                       pj_width);
X            bufend = pj_width + (bufptr = dstack[i][j]);
X            do {
X                while (printer(*bufptr)) { }
X            } while (++bufptr < bufend);
X            }
X        }
X        }
X        Printer_printf("\033*r0B"); /* end raster graphics */
X        if (!keypressed())
X           if (debugflag != 600)
X          printer(12); /* form feed */
X           else
X          Printer_printf("\n\n");
X        farmemfree(pixels);
X        break;
X        }
X
X    case 5:
X    case 6:     /***** PostScript Portrait & Landscape *****/
X        {
X        char convert[513];
X        if (!ColorPS)
X          for (i=0; i<256; ++i)
X                if (Printer_Compress) {
X                    convert[i] = (int)((.3*255./63. * (double)dacbox[i][0])+
X                                        (.59*255./63. * (double)dacbox[i][1])+
X                                        (.11*255./63. * (double)dacbox[i][2]));
X                } else
X                {
X                    sprintf(&convert[2*i], "%02X",
X                              (int)((.3*255./63. * (double)dacbox[i][0])+
X                                    (.59*255./63. * (double)dacbox[i][1])+
X                                    (.11*255./63. * (double)dacbox[i][2])));
X                }
X        i=0;
X        j=0;
X        for (y=0;((y<ydots)&&(!keypressed()));y++)
X        {   unsigned char bit8;
X        if (Printer_Compress) {
X            if (ColorPS) {
X            for (x=0;x<xdots;x++) {
X                k=getcolor(x,y);
X                rleputxelval((int)dacbox[k][0]<<2);
X            }
X            rleflush();
X            for (x=0;x<xdots;x++) {
X                k=getcolor(x,y);
X                rleputxelval((int)dacbox[k][1]<<2);
X            }
X            rleflush();
X            for (x=0;x<xdots;x++) {
X                k=getcolor(x,y);
X                rleputxelval((int)dacbox[k][2]<<2);
X            }
X            rleflush();
X             } else {
X            if (Printer_ColorXlat==-2 || Printer_ColorXlat==2) {
X               for (x=0;x<xdots;x++) {
X                  k=getcolor(x,y);
X                  if (x % 8 == 0) {
X                 if (x) rleputxelval((int)bit8);
X                                 if (k == 0) bit8 = 0; else bit8 = 1;
X                  }
X                  else
X                 bit8 = (bit8 << 1) + ((k==0) ? 0 : 1);
X               }
X               if (xdots % 8) bit8 <<= (8 - (xdots % 8));
X                       rleputxelval((int)bit8);
X               rleflush();
X            } else {
X               for (x=0;x<xdots;x++) {
X                  k=getcolor(x,y);
X                  rleputxelval((int)(unsigned char)convert[k]);
X               }
X                 rleflush();
X            }
X             }
X        } else
X        {
X            for (x=0;x<xdots;x++)
X            {
X            k=getcolor(x,y);
X            if (ColorPS)
X              {
X              sprintf(&buff[i], "%02X%02X%02X", dacbox[k][0]<<2,
X                                dacbox[k][1]<<2,
X                                dacbox[k][2]<<2);
X              i+=6;
X              }
X            else
X              {
X              k*=2;
X              buff[i++]=convert[k];
X              buff[i++]=convert[k+1];
X              }
X            if (i>=64)
X            {
X                strcpy(&buff[i],"  ");
X                Printer_printf("%s%s",buff,EndOfLine);
X                i=0;
X                j++;
X                if (j>9)
X                {
X                j=0;
X                Printer_printf(EndOfLine);
X                }
X            }
X            }
X        }
X        }
X        if (Printer_Compress) {
X        rleputrest();
X        } else {
X        strcpy(&buff[i],"  ");
X        Printer_printf("%s%s",buff,EndOfLine);
X        i=0;
X        j++;
X        if (j>9)
X        {
X            j=0;
X            Printer_printf(EndOfLine);
X        }
X        }
X        if ( (EPSFileType > 0) && (EPSFileType <3) )
X        Printer_printf("%s%%%%Trailer%sEPSFsave restore%s",EndOfLine,
X            EndOfLine,EndOfLine);
X        else
X#ifndef XFRACT
X        PRINTER_PRINTF4("%sshowpage%s%c",EndOfLine,EndOfLine,4);
X#else
X        PRINTER_PRINTF3("%sshowpage%s",EndOfLine,EndOfLine);
X#endif
X        break;
X        }
X
X    case 7: /* HP Plotter */
X        {
X        double parm1,parm2;
X        for (i=0;i<3;i++)
X        {
X          PRINTER_PRINTF4("%sSP %d;%s\0",EndOfLine,(i+1),EndOfLine);
X          for (y=0;(y<ydots)&&(!keypressed());y++)
X          {
X        for (x=0;x<xdots;x++)
X        {
X          j=dacbox[getcolor(x,y)][i];
X          if (j>0)
X          {
X            switch(Printer_SStyle)
X            {
X              case 0:
X            ci=0.004582144*(double)j;
X            ck= -.007936057*(double)j;
X            parm1 = (double)x+.5+ci+(((double)i-1.0)/3);
X            parm2 = (double)y+.5+ck;
X            break;
X              case 1:
X            ci= -.004582144*(double)j+(((double)i+1.0)/8.0);
X            ck= -.007936057*(double)j;
X            parm1 = (double)x+.5+ci;
X            parm2 = (double)y+.5+ck;
X            break;
X              case 2:
X            ci= -.0078125*(double)j+(((double)i+1.0)*.003906250);
X            ck= -.0078125*(double)j;
X            parm1 = (double)x+.5+ci;
X            parm2 = (double)y+.5+ck;
X            break;
X            }
X            Printer_printf("PA %f,%f;PD;PR %f,%f;PU;\0",
X            parm1,parm2, ci*((double)-2), ck*((double)-2));
X          }
X        }
X          }
X        }
X        PRINTER_PRINTF3("%s;SC;PA 0,0;SP0;%s\0",EndOfLine,EndOfLine);
X        PRINTER_PRINTF2(";;SP 0;%s\0",EndOfLine);
X        break;
X        }
X    }
X
X    if (Print_To_File > 0) fclose(PRFILE);
X#ifndef XFRACT
X    if ((LPTn==30)||(LPTn==31))
X    {
X    for (x=0;x<2000;x++);
X    outp((LPTn==30) ? 0x3FC : 0x2FC,0x00);
X    outp((LPTn==30) ? 0x3F9 : 0x2F9,0x00);
X    }
X#else
X    putstring(5,0,0,"Printing done\n");
X#endif
X    EXIT_OVLY;
X}
X
X
Xstatic void _fastcall graphics_init(int ptrid,int res,char *EndOfLine)
X{
X    int i,j;
X
X    switch (ptrid) {
X
X    case 1:
X        print_title(ptrid,res,EndOfLine);
X        PRINTER_PRINTF2("\033*t%iR\033*r0A",res);/* HP           */
X        break;
X
X    case 2:
X    case 3:
X        print_title(ptrid,res,EndOfLine);
X        Printer_printf("\033\063\030");/* IBM                   */
X        break;
X
X    case 4: /****** PaintJet *****/
X        print_title(ptrid,res,EndOfLine);
X        pj_width = ydots;
X        if (res == 90) pj_width <<= 1;
X        PRINTER_PRINTF2("\033*r0B\033*t180R\033*r3U\033*r%dS\033*b0M\033*r0A",
X        pj_width);
X        pj_width >>= 3;
X        break;
X
X    case 5:   /***** PostScript *****/
X    case 6:   /***** PostScript Landscape *****/
X        if (!((EPSFileType > 0) && (ptrid==5)))
X        PRINTER_PRINTF2("%%!PS-Adobe%s",EndOfLine);
X        if ((EPSFileType > 0) &&     /* Only needed if saving to .EPS */
X        (ptrid == 5))
X        {
X        PRINTER_PRINTF2("%%!PS-Adobe-1.0 EPSF-2.0%s",EndOfLine);
X
X        if (EPSFileType==1)
X            i=xdots+78;
X        else
X            i=(int)((double)xdots * (72.0 / (double)res))+78;
X
X        if (Printer_Titleblock==0)
X            {
X            if (EPSFileType==1) { j = ydots + 78; }
X            else { j = (int)(((double)ydots * (72.0 / (double)res) / (double)finalaspectratio)+78); }
X            }
X        else
X            {
X            if (EPSFileType==1) { j = ydots + 123; }
X            else { j = (int)(((double)ydots * (72.0 / (double)res))+123); }
X            }
X        PRINTER_PRINTF4("%%%%TemplateBox: 12 12 %d %d%s",i,j,EndOfLine);
X        PRINTER_PRINTF4("%%%%BoundingBox: 12 12 %d %d%s",i,j,EndOfLine);
X        PRINTER_PRINTF4("%%%%PrinterRect: 12 12 %d %d%s",i,j,EndOfLine);
X        PRINTER_PRINTF2("%%%%Creator: Fractint PostScript%s",EndOfLine);
X        Printer_printf("%%%%Title: A %s fractal - %s - Fractint EPSF Type %d%s",
X                       curfractalspecific->name[0]=='*' ?
X                       &curfractalspecific->name[1] :
X                       curfractalspecific->name,
X                       PrintName,
X                       EPSFileType,
X                       EndOfLine);
X        if (Printer_Titleblock==1)
X            PRINTER_PRINTF2("%%%%DocumentFonts: Helvetica%s",EndOfLine);
X        PRINTER_PRINTF2("%%%%EndComments%s",EndOfLine);
X        PRINTER_PRINTF2("/EPSFsave save def%s",EndOfLine);
X        PRINTER_PRINTF2("0 setgray 0 setlinecap 1 setlinewidth 0 setlinejoin%s",EndOfLine);
X        PRINTER_PRINTF2("10 setmiterlimit [] 0 setdash newpath%s",EndOfLine);
X        }
X
X        /* Common code for all PostScript */
X        PRINTER_PRINTF2("/Tr {translate} def%s",EndOfLine);
X        PRINTER_PRINTF2("/Mv {moveto} def%s",EndOfLine);
X        PRINTER_PRINTF2("/D {dup} def%s",EndOfLine);
X        PRINTER_PRINTF2("/Rh {readhexstring} def%s",EndOfLine);
X        PRINTER_PRINTF2("/Cf {currentfile} def%s",EndOfLine);
X        PRINTER_PRINTF2("/Rs {readstring} def%s",EndOfLine);
X
X        if (Printer_Compress) {
X        rleprolog(xdots,ydots);
X        } else
X        {
X        PRINTER_PRINTF3("/picstr %d string def%s",
X            ColorPS?xdots*3:xdots,EndOfLine);
X        Printer_printf("/dopic { gsave %d %d 8 [%d 0 0 %d 0 %d]%s",
X                     xdots, ydots, xdots, -ydots, ydots,
X                     EndOfLine);
X        PRINTER_PRINTF2("{ Cf picstr Rh pop }%s", EndOfLine);
X        if (ColorPS)
X        {
X            PRINTER_PRINTF2(" false 3 colorimage grestore } def%s",
X             EndOfLine);
X        }
X        else
X        {
X            PRINTER_PRINTF2(" image grestore } def%s", EndOfLine);
X        }
X            }
X        if (Printer_Titleblock==1)
X        {
X        PRINTER_PRINTF2("/Helvetica findfont 8 scalefont setfont%s",EndOfLine);
X        if (ptrid==5) Printer_printf("30 60 Mv ");
X        else          Printer_printf("552 30 Mv 90 rotate ");
X        print_title(ptrid,res,EndOfLine);
X        if (ptrid==6) Printer_printf("-90 rotate ");
X        }
X
X        if (EPSFileType != 1) /* Do not use on a WELL BEHAVED .EPS */
X          {
X          if ((ptrid == 5)&&(EPSFileType==2)&&
X          ((Printer_ColorXlat!=0)||(Printer_SetScreen!=0)))
X            PRINTER_PRINTF2("%%%%BeginFeature%s",EndOfLine);
X          if (ColorPS)
X        {
X        if (Printer_ColorXlat==1)
X            PRINTER_PRINTF2("{1 exch sub} D D D setcolortransfer%s",EndOfLine);
X        if (Printer_ColorXlat>1)
X            PRINTER_PRINTF4("{%d mul round %d div} D D D setcolortransfer%s",
X                       Printer_ColorXlat,Printer_ColorXlat,EndOfLine);
X        if (Printer_ColorXlat<-1)
X            PRINTER_PRINTF4("{%d mul round %d div 1 exch sub} D D D setcolortransfer",
X                       Printer_ColorXlat,Printer_ColorXlat,EndOfLine);
X
X        if (Printer_SetScreen==1)
X            {
X            Printer_printf("%d %d {%s}%s",
X                       Printer_RFrequency,
X                       Printer_RAngle,
X                       HalfTone[Printer_RStyle],
X                       EndOfLine);
X            Printer_printf("%d %d {%s}%s",
X                       Printer_GFrequency,
X                       Printer_GAngle,
X                       HalfTone[Printer_GStyle],
X                       EndOfLine);
X            Printer_printf("%d %d {%s}%s",
X                       Printer_BFrequency,
X                       Printer_BAngle,
X                       HalfTone[Printer_BStyle],
X                       EndOfLine);
X            Printer_printf("%d %d {%s}%s",
X                       Printer_SFrequency,
X                       Printer_SAngle,
X                       HalfTone[Printer_SStyle],
X                       EndOfLine);
X            PRINTER_PRINTF2("setcolorscreen%s", EndOfLine);
X            }
X            }
X          else
X          {
X         if (Printer_ColorXlat==-2 || Printer_ColorXlat==2) {
X            /* b&w case requires no mask building */
X        }
X        else {
X           if (Printer_ColorXlat==1)
X              PRINTER_PRINTF2("{1 exch sub} settransfer%s",EndOfLine);
X           if (Printer_ColorXlat>1)
X              PRINTER_PRINTF4("{%d mul round %d div} settransfer%s",
X                      Printer_ColorXlat,Printer_ColorXlat,EndOfLine);
X           if (Printer_ColorXlat<-1)
X              PRINTER_PRINTF4("{%d mul round %d div 1 exch sub} settransfer",
X                      Printer_ColorXlat,Printer_ColorXlat,EndOfLine);
X
X           if (Printer_SetScreen==1)
X              Printer_printf("%d %d {%s} setscreen%s",
X                     Printer_SFrequency,
X                     Printer_SAngle,
X                     HalfTone[Printer_SStyle],
X                     EndOfLine);
X        }
X          }
X
X          if (ptrid == 5)
X         {
X            if ((EPSFileType==2)&&((Printer_ColorXlat!=0)||(Printer_SetScreen!=0)))
X            PRINTER_PRINTF2("%%%%EndFeature%s",EndOfLine);
X            if (res == 0)
X            {
X            PRINTER_PRINTF2("30 191.5 Tr 552 %4.1f",
X                    (552.0*(double)finalaspectratio));
X            }
X            else
X            {
X            PRINTER_PRINTF4("30 %d Tr %f %f",
X                     75 - ((Printer_Titleblock==1) ? 0 : 45),
X                     ((double)xdots*(72.0/(double)res)),
X                     ((double)xdots*(72.0/(double)res)*(double)finalaspectratio));
X            }
X          }
X        else                 /* For Horizontal PostScript */
X        {
X            if (res == 0)
X            {
X            PRINTER_PRINTF2("582 30 Tr 90 rotate 732 %4.1f",
X                    (732.0*(double)finalaspectratio));
X            }
X            else
X            {
X            PRINTER_PRINTF4("%d 30 Tr 90 rotate %f %f",
X                     537 + ((Printer_Titleblock==1) ? 0 : 45),
X                     ((double)xdots*(72.0/(double)res)),
X                     ((double)xdots*(72.0/(double)res)*(double)finalaspectratio));
X            }
X        }
X        PRINTER_PRINTF2(" scale%s",EndOfLine);
X          }
X
X        else if (ptrid == 5)       /* To be used on WELL-BEHAVED .EPS */
X        Printer_printf("30 %d Tr %d %d scale%s",
X                    75 - ((Printer_Titleblock==1) ? 0 : 45),
X                    xdots,ydots,EndOfLine);
X
X        PRINTER_PRINTF2("dopic%s",EndOfLine);
X        break;
X
X    case 7: /* HP Plotter */
X        if (res<1) res=1;
X        if (res>10) res=10;
X        ci = (((double)xdots*((double)res-1.0))/2.0);
X        ck = (((double)ydots*((double)res-1.0))/2.0);
X        Printer_printf(";IN;SP0;SC%d,%d,%d,%d;%s\0",
X        (int)(-ci),(int)((double)xdots+ci),
X        (int)((double)ydots+ck),(int)(-ck),EndOfLine);
X        break;
X    }
X}
X
X
Xstatic void _fastcall print_title(int ptrid,int res,char *EndOfLine)
X{
X    char buff[80];
X    int postscript;
X    if (Printer_Titleblock == 0)
X    return;
X    postscript = (ptrid == 5 || ptrid ==6);
X    if (!postscript)
X    Printer_printf(EndOfLine);
X    else
X    Printer_printf("(");
X    Printer_printf((curfractalspecific->name[0]=='*')
X             ? &curfractalspecific->name[1]
X             : curfractalspecific->name);
X    if (fractype == FORMULA || fractype == FFORMULA)
X    Printer_printf(" %s",FormName);
X    if (fractype == LSYSTEM)
X    Printer_printf(" %s",LName);
X    if (fractype == IFS || fractype == IFS3D)
X    Printer_printf(" %s",IFSName);
X    Printer_printf(" - %dx%d - %d DPI", xdots, ydots, res);
X    if (!postscript)
X    Printer_printf(EndOfLine);
X    else {
X    Printer_printf(") show%s",EndOfLine);
X    if (ptrid==5) Printer_printf("30 50 moveto (");
X    else          Printer_printf("-90 rotate 562 30 moveto 90 rotate (");
X    }
X    Printer_printf("Corners: Top-Left=%.16g/%.16g Bottom-Right=%.16g/%.16g",
X           xxmin,yymax,xxmax,yymin);
X    if (xx3rd != xxmin || yy3rd != yymin) {
X    if (!postscript)
X        Printer_printf("%s        ",EndOfLine);
X    Printer_printf(" Bottom-Left=%4.4f/%4.4f",xx3rd,yy3rd);
X    }
X    if (!postscript)
X    Printer_printf(EndOfLine);
X    else {
X    Printer_printf(") show%s",EndOfLine);
X    if (ptrid==5) Printer_printf("30 40 moveto (");
X    else          Printer_printf("-90 rotate 572 30 moveto 90 rotate (");
X    }
X    showtrig(buff);
X    Printer_printf("Parameters: %4.4f/%4.4f/%4.4f/%4.4f %s",
X           param[0],param[1],param[2],param[3],buff);
X    if (!postscript)
X    Printer_printf(EndOfLine);
X    else
X    Printer_printf(") show%s",EndOfLine);
X}
X
X/* This function prints a string to the the printer with BIOS calls. */
X
X#ifndef XFRACT
Xstatic void Printer_printf(char far *fmt,...)
X#else
Xstatic void Printer_printf(va_alist)
Xva_dcl
X#endif
X{
Xint i;
Xchar s[500];
Xint x=0;
Xva_list arg;
X
X#ifndef XFRACT
Xva_start(arg,fmt);
X#else
Xchar far *fmt;
Xva_start(arg);
Xfmt = va_arg(arg,char far *);
X#endif
X
X{
X   /* copy far to near string */
X   char fmt1[100];
X   i=0;
X   while(fmt[i]) {
X     fmt1[i] = fmt[i];
X     i++;
X   }
X   fmt1[i] = '\0';
X   vsprintf(s,fmt1,arg);
X}
X
Xif (Print_To_File>0)    /* This is for printing to file */
X    fprintf(PRFILE,"%s",s);
Xelse            /* And this is for printing to printer */
X    while (s[x])
X    if (printer(s[x++])!=0)
X        while (!keypressed()) { if (printer(s[x-1])==0) break; }
X}
X
X/* This function standardizes both _bios_printer and _bios_serialcom
X * in one function.  It takes its arguments and rearranges them and calls
X * the appropriate bios call.  If it then returns result !=0, there is a
X * problem with the printer.
X */
Xstatic int _fastcall printer(int c)
X{
X    if (Print_To_File>0) return ((fprintf(PRFILE,"%c",c))<1);
X#ifndef XFRACT
X    if (LPTn<9)  return (((_bios_printer(0,LPTn,c))+0x0010)&0x0010);
X    if (LPTn<19) return ((_bios_serialcom(1,(LPTn-10),c))&0x9E00);
X    if ((LPTn==20)||(LPTn==21))
X    {
X    int PS=0;
X    while ((PS & 0xF8) != 0xD8)
X        { PS = inp((LPTn==20) ? 0x379 : 0x279);
X          if (keypressed()) return(1); }
X    outp((LPTn==20) ? 0x37C : 0x27C,c);
X    PS = inp((LPTn==20) ? 0x37A : 0x27A);
X    outp((LPTn==20) ? 0x37A : 0x27A,(PS | 0x01));
X    outp((LPTn==20) ? 0x37A : 0x27A,PS);
X    return(0);
X    }
X    if ((LPTn==30)||(LPTn==31))
X    {
X    while (((inp((LPTn==30) ? 0x3FE : 0x2FE)&0x30)!=0x30) ||
X           ((inp((LPTn==30) ? 0x3FD : 0x2FD)&0x60)!=0x60))
X        { if (keypressed()) return (1); }
X    outp((LPTn==30) ? 0x3F8 : 0x2F8,c);
X    return(0);
X    }
X#endif
X
X    /* MCP 7-7-91, If we made it down to here, we may as well error out. */
X    return(-1);
X}
X
X#ifdef __BORLANDC__
X#if(__BORLANDC__ > 2)
X   #pragma warn +eff
X#endif
X#endif
X
Xstatic void printer_reset()
X{
X#ifndef XFRACT
X    if (Print_To_File < 1)
X    if (LPTn<9)      _bios_printer(1,LPTn,0);
X    else if (LPTn<19) _bios_serialcom(3,(LPTn-10),0);
X#endif
X}
X
X
X/** debug code for pj_ color table checkout
Xcolor_test()
X{
X   int x,y,color,i,j,xx,yy;
X   int bw,cw,bh,ch;
X   setvideomode(videoentry.videomodeax,
X        videoentry.videomodebx,
X        videoentry.videomodecx,
X        videoentry.videomodedx);
X   bw = xdots/25; cw = bw * 2 / 3;
X   bh = ydots/10; ch = bh * 2 / 3;
X   dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 60;
X   if (debugflag == 902)
X      dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
X   for (x = 0; x < 25; ++x)
X      for (y = 0; y < 10; ++y) {
X     if (x < 11) i = (32 - x) * 10 + y;
X         else    i = (24 - x) * 10 + y;
X     color = x * 10 + y + 1;
X     dacbox[color][0] = dstack[0][0][i];
X     dacbox[color][1] = dstack[0][1][i];
X     dacbox[color][2] = dstack[0][2][i];
X     for (i = 0; i < cw; ++i) {
X        xx = x * bw + bw / 6 + i;
X        yy = y * bh + bh / 6;
X        for (j = 0; j < ch; ++j)
X           putcolor(xx,yy++,color);
X        }
X     }
X   spindac(0,1);
X   getakey();
X}
X**/
X
X
X/*
X * The following code for compressed PostScript is based on pnmtops.c.  It is
X * copyright (C) 1989 by Jef Poskanzer, and carries the following notice:
X * "Permission to use, copy, modify, and distribute this software and its
X *  documentation for any purpose and without fee is hereby granted, provided
X *  that the above copyright notice appear in all copies and that both that
X *  copyright notice and this permission notice appear in supporting
X *  documentation.  This software is provided "as is" without express or
X *  implied warranty."
X */
X
X
Xstatic rleprolog(x,y)
Xint x,y;
X{
X    itemsperline = 0;
X    items = 0;
X    bitspersample = 8;
X    repeat = 1;
X    rlebitsperitem = 0;
X    rlebitshift = 0;
X    count = 0;
X
X    PRINTER_PRINTF2( "/rlestr1 1 string def%s", EndOfLine );
X    PRINTER_PRINTF2( "/rdrlestr {%s", EndOfLine );    /* s -- nr */
X    PRINTER_PRINTF2( "  /rlestr exch def%s", EndOfLine );    /* - */
X    PRINTER_PRINTF2( "  Cf rlestr1 Rh pop%s", EndOfLine );  /* s1 */
X    PRINTER_PRINTF2( "  0 get%s", EndOfLine );                     /* c */
X    PRINTER_PRINTF2( "  D 127 le {%s", EndOfLine );         /* c */
X    PRINTER_PRINTF2( "    Cf rlestr 0%s", EndOfLine );      /* c f s 0 */
X    PRINTER_PRINTF2( "    4 3 roll%s", EndOfLine );                /* f s 0 c */
X    PRINTER_PRINTF2( "    1 add  getinterval%s", EndOfLine );      /* f s */
X    PRINTER_PRINTF2( "    Rh pop%s", EndOfLine );    /* s */
X    PRINTER_PRINTF2( "    length%s", EndOfLine );                  /* nr */
X    PRINTER_PRINTF2( "  } {%s", EndOfLine );                       /* c */
X    PRINTER_PRINTF2( "    256 exch sub D%s", EndOfLine );     /* n n */
X    PRINTER_PRINTF2( "    Cf rlestr1 Rh pop%s", EndOfLine );/* n n s1 */
X    PRINTER_PRINTF2( "    0 get%s", EndOfLine );                   /* n n c */
X    PRINTER_PRINTF2( "    exch 0 exch 1 exch 1 sub {%s", EndOfLine );           /* n c 0 1 n-1*/
X    PRINTER_PRINTF2( "      rlestr exch 2 index put%s", EndOfLine );
X    PRINTER_PRINTF2( "    } for%s", EndOfLine );                   /* n c */
X    PRINTER_PRINTF2( "    pop%s", EndOfLine );                     /* nr */
X    PRINTER_PRINTF2( "  } ifelse%s", EndOfLine );                  /* nr */
X    PRINTER_PRINTF2( "} bind def%s", EndOfLine );
X    PRINTER_PRINTF2( "/Rs {%s", EndOfLine );           /* s -- s */
X    PRINTER_PRINTF2( "  D length 0 {%s", EndOfLine );         /* s l 0 */
X    PRINTER_PRINTF2( "    3 copy exch%s", EndOfLine );          /* s l n s n l*/
X    PRINTER_PRINTF2( "    1 index sub%s", EndOfLine );          /* s l n s n r*/
X    PRINTER_PRINTF2( "    getinterval%s", EndOfLine );          /* s l n ss */
X    PRINTER_PRINTF2( "    rdrlestr%s", EndOfLine );       /* s l n nr */
X    PRINTER_PRINTF2( "    add%s", EndOfLine );                     /* s l n */
X    PRINTER_PRINTF2( "    2 copy le { exit } if%s", EndOfLine );   /* s l n */
X    PRINTER_PRINTF2( "  } loop%s", EndOfLine );                    /* s l l */
X    PRINTER_PRINTF2( "  pop pop%s", EndOfLine );                   /* s */
X    PRINTER_PRINTF2( "} bind def%s", EndOfLine );
X    if (ColorPS) {
X    PRINTER_PRINTF3( "/rpicstr %d string def%s", x,EndOfLine );
X    PRINTER_PRINTF3( "/gpicstr %d string def%s", x,EndOfLine );
X    PRINTER_PRINTF3( "/bpicstr %d string def%s", x,EndOfLine );
X    } else {
X    PRINTER_PRINTF3( "/picstr %d string def%s", x,EndOfLine );
X    }
X    PRINTER_PRINTF2( "/dopic {%s", EndOfLine);
X    PRINTER_PRINTF2( "/gsave%s", EndOfLine);
X    if (ColorPS) {
X       PRINTER_PRINTF4( "%d %d 8%s", x, y, EndOfLine);
X    } else { /* b&w */
X       if (Printer_ColorXlat==-2) {
X          PRINTER_PRINTF4( "%d %d true%s", x, y, EndOfLine);
X       } else if (Printer_ColorXlat==2) {
X          PRINTER_PRINTF4( "%d %d false%s", x, y, EndOfLine);
X       } else {
X      PRINTER_PRINTF4( "%d %d 8%s", x, y, EndOfLine);
X       }
X    }
X    Printer_printf( "[%d 0 0 %d 0 %d]%s", x, -y, y, EndOfLine);
X    if (ColorPS) {
X    PRINTER_PRINTF2( "{rpicstr Rs}%s", EndOfLine);
X    PRINTER_PRINTF2( "{gpicstr Rs}%s", EndOfLine);
X    PRINTER_PRINTF2( "{bpicstr Rs}%s", EndOfLine);
X    PRINTER_PRINTF2( "true 3 colorimage%s", EndOfLine);
X    } else {
X       if (Printer_ColorXlat==-2 || Printer_ColorXlat==2) {
X      /* save file space and printing time (if scaling is right) */
X      PRINTER_PRINTF2( "{picstr Rs} imagemask%s", EndOfLine);
X       } else {
X      PRINTER_PRINTF2( "{picstr Rs} image%s", EndOfLine);
X       }
X    }
X    PRINTER_PRINTF2( "} def%s", EndOfLine);
X}
X
Xstatic void
Xrleputbuffer()
X    {
X    int i;
X
X    if ( repeat )
X    {
X    item = 256 - count;
X    putitem();
X    item = repeatitem;
X    putitem();
X    }
X    else
X    {
X    item = count - 1;
X    putitem();
X    for ( i = 0; i < count; ++i )
X        {
X        item = itembuf[i];
X        putitem();
X        }
X    }
X    repeat = 1;
X    count = 0;
X    }
X
Xstatic void
Xrleputitem()
X    {
X    int i;
X
X    if ( count == 128 )
X    rleputbuffer();
X
X    if ( repeat && count == 0 )
X    { /* Still initializing a repeat buf. */
X    itembuf[count] = repeatitem = rleitem;
X    ++count;
X    }
X    else if ( repeat )
X    { /* Repeating - watch for end of run. */
X    if ( rleitem == repeatitem )
X        { /* Run continues. */
X        itembuf[count] = rleitem;
X        ++count;
X        }
X    else
X        { /* Run ended - is it long enough to dump? */
X        if ( count > 2 )
X        { /* Yes, dump a repeat-mode buffer and start a new one. */
X        rleputbuffer();
X        itembuf[count] = repeatitem = rleitem;
X        ++count;
X        }
X        else
X        { /* Not long enough - convert to non-repeat mode. */
X        repeat = 0;
X        itembuf[count] = repeatitem = rleitem;
X        ++count;
X        repeatcount = 1;
X        }
X        }
X    }
X    else
X    { /* Not repeating - watch for a run worth repeating. */
X    if ( rleitem == repeatitem )
X        { /* Possible run continues. */
X        ++repeatcount;
X        if ( repeatcount > 3 )
X        { /* Long enough - dump non-repeat part and start repeat. */
X        count = count - ( repeatcount - 1 );
X        rleputbuffer();
X        count = repeatcount;
X        for ( i = 0; i < count; ++i )
X            itembuf[i] = rleitem;
X        }
X        else
X        { /* Not long enough yet - continue as non-repeat buf. */
X        itembuf[count] = rleitem;
X        ++count;
X        }
X        }
X    else
X        { /* Broken run. */
X        itembuf[count] = repeatitem = rleitem;
X        ++count;
X        repeatcount = 1;
X        }
X    }
X
X    rleitem = 0;
X    rlebitsperitem = 0;
X    }
X
Xstatic void
Xputitem()
X    {
X    char* hexits = "0123456789abcdef";
X
X    if ( itemsperline == 30 )
X        {
X    Printer_printf("%s",EndOfLine);
X        itemsperline = 0;
X        }
X    Printer_printf("%c%c", hexits[item >> 4], hexits[item & 15] );
X    ++itemsperline;
X    ++items;
X    item = 0;
X    bitsperitem = 0;
X    bitshift = 8 - bitspersample;
X    }
X
Xstatic void
Xrleputxelval( xv )
X    int xv;
X    {
X    if ( rlebitsperitem == 8 )
X    rleputitem();
X    rleitem += xv<<bitshift;
X    rlebitsperitem += bitspersample;
X    rlebitshift -= bitspersample;
X    }
X
Xstatic void
Xrleflush()
X    {
X    if ( rlebitsperitem > 0 )
X    rleputitem();
X    if ( count > 0 )
X    rleputbuffer();
X    }
X
Xstatic void
Xrleputrest()
X    {
X    rleflush();
X    Printer_printf( "%s",EndOfLine );
X    Printer_printf( "grestore%s",EndOfLine );
X    }
SHAR_EOF
$TOUCH -am 1028230093 printer.c &&
chmod 0644 printer.c ||
echo "restore of printer.c failed"
set `wc -c printer.c`;Wc_c=$1
if test "$Wc_c" != "44938"; then
    echo original size 44938, current size $Wc_c
fi
# ============= prompts1.c ==============
echo "x - extracting prompts1.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > prompts1.c &&
X/*
X    Various routines that prompt for things.
X    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#include <ctype.h>
X#ifndef XFRACT
X#include <dos.h>
X#elif !defined(__386BSD__)
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <sys/dir.h>
X#endif
X#ifdef __TURBOC__
X#include <alloc.h>
X#elif !defined(__386BSD__)
X#include <malloc.h>
X#endif
X
X#ifdef __hpux
X#include <sys/param.h>
X#define getwd(a) getcwd(a,MAXPATHLEN)
X#endif
X
X#include "fractint.h"
X#include "fractype.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
Xextern int Targa_Overlay;
Xextern int Targa_Out;
Xextern BYTE back_color[];
Xextern float  screenaspect;
X
X/* Routines defined in prompts2.c */
X
Xextern    int get_corners(void);
Xextern    int edit_ifs_params(void );
Xextern    int lccompare(VOIDCONSTPTR, VOIDCONSTPTR);
X
X/* Routines used in prompts2.c */
X
X    int prompt_checkkey(int curkey);
X    long get_file_entry(int,char *,char *,char *,char *);
X
X/* Routines in this module    */
X
Xstatic    int prompt_valuestring(char *buf,struct fullscreenvalues *val);
Xstatic    int input_field_list(int attr,char *fld,int vlen,char **list,int llen,
X                 int row,int col,int (*checkkey)(int));
Xstatic    int select_fracttype(int t);
Xstatic    int sel_fractype_help(int curkey, int choice);
X    int select_type_params(int newfractype,int oldfractype);
Xstatic    void set_default_parms(void);
Xstatic    long gfe_choose_entry(int,char *,char *,char *);
Xstatic    int check_gfe_key(int curkey,int choice);
Xstatic    void load_entry_text(FILE *entfile,char far *buf,int maxlines);
Xstatic    void format_parmfile_line(int,char *);
Xstatic    int get_light_params(void );
Xstatic    int check_mapfile(void );
Xstatic    int get_funny_glasses_params(void );
X
Xint julibrot;   /* flag for julibrot */
X
Xextern int numtrigfn;
Xextern int bailout;
X
Xextern struct moreparams far moreparams[];
Xstatic char funnyglasses_map_name[16];
Xextern char temp1[256];   /* temporary strings          */
Xextern int previewfactor;
Xextern int xtrans, ytrans;
Xextern int red_crop_left, red_crop_right;
Xextern int blue_crop_left, blue_crop_right;
Xextern int red_bright, blue_bright;
Xextern char showbox; /* flag to show box and vector in preview */
Xextern SEGTYPE extraseg;
Xextern int whichimage;
Xextern int xadjust;
Xextern int eyeseparation;
Xextern int glassestype;
Xchar   MAP_name[80] = "";
Xint    mapset = 0;
Xextern    int    overlay3d;        /* 3D overlay flag: 0 = OFF */
Xextern    int    lookatmouse;
Xextern    int haze;
Xextern    int RANDOMIZE;
Xextern    char light_name[];
Xextern    int Ambient;
Xextern    int RAY;
Xextern    int BRIEF;
Xextern    char ray_name[];
X
Xextern    int    init3d[20];    /* '3d=nn/nn/nn/...' values */
Xextern    double    xxmin,xxmax;    /* initial corner values    */
Xextern    double    yymin,yymax;    /* initial corner values    */
X
Xextern    double    xx3rd,yy3rd;    /* initial corner values    */
Xextern    int    invert;     /* non-zero if inversion active */
Xextern    double    inversion[3];    /* radius, xcenter, ycenter */
Xextern    double    param[];        /* up to six parameters    */
Xextern    double    potparam[3];    /* three potential parameters*/
Xextern    int    fractype;    /* if == 0, use Mandelbrot  */
Xextern    char    preview;    /* 3D preview mode flag */
Xextern    int    transparent[];    /* transparency values */
Xextern    int    usr_biomorph;    /* Biomorph flag */
Xextern    int    viewcrop;
Xextern    float    finalaspectratio;
Xextern    int    textcbase;
Xextern    char    boxy[];
Xextern    int    display3d;
X
Xextern char LFileName[];    /* file to find the formulas in */
Xextern char LName[];        /* Name of the Formula (if not null) */
Xextern char FormFileName[];
Xextern char FormName[];
Xextern char IFSFileName[];
Xextern char IFSName[];
Xextern float far *ifs_defn;
Xextern int ifs_type;
Xextern int ifs_changed;
X
X/* fullscreen_choice options */
X#define CHOICEHELP    4
X
X#define GETFORMULA 0
X#define GETLSYS    1
X#define GETIFS       2
X#define GETPARM    3
X
X
Xchar ifsmask[13]     = {"*.ifs"};
Xchar formmask[13]    = {"*.frm"};
Xchar lsysmask[13]    = {"*.l"};
Xchar Glasses1Map[] = "glasses1.map";
X
Xvoid prompts1_overlay() { }    /* for restore_active_ovly */
X
X
X/* --------------------------------------------------------------------- */
X
Xint promptfkeys;
X
Xint fullscreen_prompt(    /* full-screen prompting routine */
X    char far *hdg,        /* heading, lines separated by \n */
X    int numprompts,     /* there are this many prompts (max) */
X    char far **prompts,     /* array of prompting pointers */
X    struct fullscreenvalues *values, /* array of values */
X    int options,        /* for future */
X    int fkeymask,        /* bit n on if Fn to cause return */
X    char far *extrainfo    /* extra info box to display, \n separated */
X    )
X{
X   char far *hdgscan;
X   int titlelines,titlewidth,titlerow;
X   int maxpromptwidth,maxfldwidth,maxcomment;
X   int boxrow,boxlines;
X   int boxcol,boxwidth;
X   int extralines,extrawidth,extrarow;
X   int instrrow;
X   int promptrow,promptcol,valuecol;
X   int curchoice;
X   int done, i, j;
X   int anyinput;
X   int savelookatmouse;
X   int curtype, curlen;
X   char buf[81];
X#ifndef XFRACT
Xstatic char far instr1[]  = {"Use " UPARR " and " DNARR " to select values to change"};
Xstatic char far instr2a[]  = {"Type in replacement value for selected field"};
Xstatic char far instr2b[]  = {"Use " LTARR " or " RTARR " to change value of selected field"};
X#else
X/* Some compilers don't accept "a" "b", so we have to fill in UPARR ourself.  */
Xstatic char far instr1[]  = {"Use up(K) and down(J) to select values to change"};
Xstatic char far instr2a[]  = {"Type in replacement value for selected field"};
Xstatic char far instr2b[]  = {"Use left(H) or right(L) to change value of selected field"};
X#endif
Xstatic char far instr3a[] = {"Press ENTER when finished (or ESCAPE to back out)"};
Xstatic char far instr3b[] = {"Press ENTER when finished, ESCAPE to back out, or F1 for help"};
Xstatic char far instr0a[] = {"No changeable parameters; press ENTER to exit"};
Xstatic char far instr0b[] = {"No changeable parameters; press ENTER to exit or F1 for help"};
X
X   ENTER_OVLY(OVLY_PROMPTS1);
X
X   if (numprompts <= 0) {    /* ?? nothing to do! */
X      EXIT_OVLY;
X      return(0);
X      }
X
X   savelookatmouse = lookatmouse;
X   lookatmouse = 0;
X   promptfkeys = fkeymask;
X   helptitle();                /* clear screen, display title line  */
X   setattr(1,0,C_PROMPT_BKGRD,24*80);  /* init rest of screen to background */
X
X   hdgscan = hdg;               /* count title lines, find widest */
X   i = titlewidth = 0;
X   titlelines = 1;
X   while (*hdgscan) {
X      if (*(hdgscan++) == '\n') {
X     ++titlelines;
X     i = -1;
X     }
X      if (++i > titlewidth)
X     titlewidth = i;
X      }
X   extralines = extrawidth = i = 0;
X   if ((hdgscan = extrainfo))
X      if (*hdgscan == 0)
X     extrainfo = NULL;
X      else { /* count extra lines, find widest */
X     extralines = 3;
X     while (*hdgscan) {
X        if (*(hdgscan++) == '\n') {
X           if (extralines + numprompts + titlelines >= 20) {
X           *hdgscan = 0; /* full screen, cut off here */
X           break;
X           }
X           ++extralines;
X           i = -1;
X           }
X        if (++i > extrawidth)
X           extrawidth = i;
X        }
X     }
X
X   /* work out vertical positioning */
X   i = numprompts + titlelines + extralines + 3; /* total rows required */
X   j = (25 - i) / 2;               /* top row of it all when centered */
X   j -= j / 4;                   /* higher is better if lots extra */
X   boxlines = numprompts;
X   titlerow = 1 + j;
X   promptrow = boxrow = titlerow + titlelines;
X   if (titlerow > 2) {               /* room for blank between title & box? */
X      --titlerow;
X      --boxrow;
X      ++boxlines;
X      }
X   instrrow = boxrow+boxlines;
X   if (instrrow + 3 + extralines < 25) {
X      ++boxlines;    /* blank at bottom of box */
X      ++instrrow;
X      if (instrrow + 3 + extralines < 25)
X     ++instrrow; /* blank before instructions */
X      }
X   extrarow = instrrow + 2;
X   if (numprompts > 1) /* 3 instructions lines */
X      ++extrarow;
X   if (extrarow + extralines < 25)
X      ++extrarow;
X
X   /* work out horizontal positioning */
X   maxfldwidth = maxpromptwidth = maxcomment = anyinput = 0;
X   for (i = 0; i < numprompts; i++) {
X      if (values[i].type == 'y') {
X     static char *noyes[2] = {"no","yes"};
X     values[i].type = 'l';
X     values[i].uval.ch.vlen = 3;
X     values[i].uval.ch.list = noyes;
X     values[i].uval.ch.llen = 2;
X     }
X      j = far_strlen(prompts[i]);
X      if (values[i].type == '*') {
X     if (j > maxcomment)     maxcomment = j;
X     }
X      else {
X         anyinput = 1;
X     if (j > maxpromptwidth) maxpromptwidth = j;
X     j = prompt_valuestring(buf,&values[i]);
X     if (j > maxfldwidth)     maxfldwidth = j;
X     }
X      }
X   boxwidth = maxpromptwidth + maxfldwidth + 2;
X   if (maxcomment > boxwidth) boxwidth = maxcomment;
X   if ((boxwidth += 4) > 80) boxwidth = 80;
X   boxcol = (80 - boxwidth) / 2;       /* center the box */
X   promptcol = boxcol + 2;
X   valuecol = boxcol + boxwidth - maxfldwidth - 2;
X   if (boxwidth <= 76) {           /* make margin a bit wider if we can */
X      boxwidth += 2;
X      --boxcol;
X      }
X   if ((j = titlewidth) < extrawidth)
X      j = extrawidth;
X   if ((i = j + 4 - boxwidth) > 0) {   /* expand box for title/extra */
X      if (boxwidth + i > 80)
X     i = 80 - boxwidth;
X      boxwidth += i;
X      boxcol -= i / 2;
X      }
X   i = (90 - boxwidth) / 20;
X   boxcol    -= i;
X   promptcol -= i;
X   valuecol  -= i;
X
X   /* display box heading */
X   for (i = titlerow; i < boxrow; ++i)
X      setattr(i,boxcol,C_PROMPT_HI,boxwidth);
X   textcbase = boxcol + (boxwidth - titlewidth) / 2;
X   putstring(titlerow,0,C_PROMPT_HI,hdg);
X
X   /* display extra info */
X   if (extrainfo) {
X#ifndef XFRACT
X#define S1 '\xC4'
X#define S2 "\xC0"
X#define S3 "\xD9"
X#define S4 "\xB3"
X#define S5 "\xDA"
X#define S6 "\xBF"
X#else
X#define S1 '-'
X#define S2 "+" /* ll corner */
X#define S3 "+" /* lr corner */
X#define S4 "|"
X#define S5 "+" /* ul corner */
X#define S6 "+" /* ur corner */
X#endif
X      memset(buf,S1,80); buf[boxwidth-2] = 0;
X      textcbase = boxcol + 1;
X      putstring(extrarow,0,C_PROMPT_BKGRD,buf);
X      putstring(extrarow+extralines-1,0,C_PROMPT_BKGRD,buf);
X      --textcbase;
X      putstring(extrarow,0,C_PROMPT_BKGRD,S5);
X      putstring(extrarow+extralines-1,0,C_PROMPT_BKGRD,S2);
X      textcbase += boxwidth - 1;
X      putstring(extrarow,0,C_PROMPT_BKGRD,S6);
X      putstring(extrarow+extralines-1,0,C_PROMPT_BKGRD,S3);
X      textcbase = boxcol;
X      for (i = 1; i < extralines-1; ++i) {
X         putstring(extrarow+i,0,C_PROMPT_BKGRD,S4);
X         putstring(extrarow+i,boxwidth-1,C_PROMPT_BKGRD,S4);
X     }
X      textcbase += (boxwidth - extrawidth) / 2;
X      putstring(extrarow+1,0,C_PROMPT_TEXT,extrainfo);
X      }
X   textcbase = 0;
X
X   /* display empty box */
X   for (i = 0; i < boxlines; ++i)
X      setattr(boxrow+i,boxcol,C_PROMPT_LO,boxwidth);
X
X   /* display initial values */
X   for (i = 0; i < numprompts; i++) {
X      putstring(promptrow+i, promptcol, C_PROMPT_LO, prompts[i]);
X      prompt_valuestring(buf,&values[i]);
X      putstring(promptrow+i, valuecol, C_PROMPT_LO, buf);
X      }
X
X   if (!anyinput) {
X      putstringcenter(instrrow,0,80,C_PROMPT_BKGRD,
X        (helpmode > 0) ? instr0b : instr0a);
X      movecursor(25,80);
X      while (1) {
X        while (!keypressed()) { }
X        done = getakey();
X        switch(done) {
X           case ESC:
X              done = -1;
X           case ENTER:
X           case ENTER_2:
X              goto fullscreen_exit;
X           case F2:
X           case F3:
X           case F4:
X           case F5:
X           case F6:
X           case F7:
X           case F8:
X           case F9:
X           case F10:
X              if (promptfkeys & (1<<(done+1-F1)) )
X                 goto fullscreen_exit;
X           }
X        }
X      }
X
X
X   /* display footing */
X   if (numprompts > 1)
X      putstringcenter(instrrow++,0,80,C_PROMPT_BKGRD,instr1);
X   putstringcenter(instrrow+1,0,80,C_PROMPT_BKGRD,
X     (helpmode > 0) ? instr3b : instr3a);
X
X   curchoice = done = 0;
X   while (values[curchoice].type == '*') ++curchoice;
X
X   while (!done) {
X
X      curtype = values[curchoice].type;
X      curlen = prompt_valuestring(buf,&values[curchoice]);
X      putstringcenter(instrrow,0,80,C_PROMPT_BKGRD,
X              (curtype == 'l') ? instr2b : instr2a);
X      putstring(promptrow+curchoice,promptcol,C_PROMPT_HI,prompts[curchoice]);
X
X      if (curtype == 'l') {
X     i = input_field_list(
X        C_PROMPT_CHOOSE, buf, curlen,
X        values[curchoice].uval.ch.list, values[curchoice].uval.ch.llen,
X        promptrow+curchoice,valuecol, prompt_checkkey);
X     for (j = 0; j < values[curchoice].uval.ch.llen; ++j)
X        if (strcmp(buf,values[curchoice].uval.ch.list[j]) == 0) break;
X     values[curchoice].uval.ch.val = j;
X     }
X      else {
X     j = 0;
X     if (curtype == 'i') j = 3;
X     if (curtype == 'd') j = 5;
X     if (curtype == 'D') j = 7;
X     if (curtype == 'f') j = 1;
X     i = input_field(j, C_PROMPT_INPUT, buf, curlen,
X        promptrow+curchoice,valuecol,prompt_checkkey);
X     switch (values[curchoice].type) {
X        case 'd':
X        case 'D':
X           values[curchoice].uval.dval = atof(buf);
X           break;
X        case 'f':
X           values[curchoice].uval.dval = atof(buf);
X           roundfloatd(&values[curchoice].uval.dval);
X           break;
X        case 'i':
X           values[curchoice].uval.ival = atoi(buf);
X           break;
X        case 's':
X           strncpy(values[curchoice].uval.sval,buf,16);
X           break;
X        default: /* assume 0x100+n */
X           strcpy(values[curchoice].uval.sbuf,buf);
X        }
X     }
X
X      putstring(promptrow+curchoice,promptcol,C_PROMPT_LO,prompts[curchoice]);
X      j = strlen(buf);
X      memset(&buf[j],' ',80-j); buf[curlen] = 0;
X      putstring(promptrow+curchoice, valuecol, C_PROMPT_LO,  buf);
X
X      switch(i) {
X     case 0:  /* enter  */
X        done = 13;
X        break;
X     case -1: /* escape */
X     case F2:
X     case F3:
X     case F4:
X     case F5:
X     case F6:
X     case F7:
X     case F8:
X     case F9:
X     case F10:
X        done = i;
X        break;
X     case PAGE_UP:
X        curchoice = -1;
X     case DOWN_ARROW:
X     case DOWN_ARROW_2:
X        do {
X           if (++curchoice >= numprompts) curchoice = 0;
X           } while (values[curchoice].type == '*');
X        break;
X     case PAGE_DOWN:
X        curchoice = numprompts;
X     case UP_ARROW:
X     case UP_ARROW_2:
X        do {
X           if (--curchoice < 0) curchoice = numprompts - 1;
X           } while (values[curchoice].type == '*');
X        break;
X     }
X      }
X
Xfullscreen_exit:
X   movecursor(25,80);
X   lookatmouse = savelookatmouse;
X   EXIT_OVLY;
X   return(done);
X}
X
Xstatic int prompt_valuestring(char *buf,struct fullscreenvalues *val)
X{  /* format value into buf, return field width */
X   int i,ret;
X   switch (val->type) {
X      case 'd':
X     ret = 20;
X     i = 16;    /* cellular needs 16 (was 15)*/
X     while (1) {
X        sprintf(buf,"%.*g",i,val->uval.dval);
X        if (strlen(buf) <= ret) break;
X        --i;
X        }
X     break;
X      case 'D':
X     if (val->uval.dval<0) { /* We have to round the right way */
X         sprintf(buf,"%ld",(long)(val->uval.dval-.5));
X     }
X     else {
X         sprintf(buf,"%ld",(long)(val->uval.dval+.5));
X     }
X     ret = 20;
X     break;
X      case 'f':
X     sprintf(buf,"%.7g",val->uval.dval);
X     ret = 14;
X     break;
X      case 'i':
X     sprintf(buf,"%d",val->uval.ival);
X     ret = 6;
X     break;
X      case '*':
X     *buf = ret = 0;
X     break;
X      case 's':
X     strncpy(buf,val->uval.sval,16);
X     buf[15] = 0;
X     ret = 15;
X     break;
X      case 'l':
X     strcpy(buf,val->uval.ch.list[val->uval.ch.val]);
X     ret = val->uval.ch.vlen;
X     break;
X      default: /* assume 0x100+n */
X     strcpy(buf,val->uval.sbuf);
X     ret = val->type & 0xff;
X      }
X   return ret;
X}
X
Xint prompt_checkkey(int curkey)
X{
X   switch(curkey) {
X      case PAGE_UP:
X      case DOWN_ARROW:
X      case DOWN_ARROW_2:
X      case PAGE_DOWN:
X      case UP_ARROW:
X      case UP_ARROW_2:
X     return(curkey);
X      case F2:
X      case F3:
X      case F4:
X      case F5:
X      case F6:
X      case F7:
X      case F8:
X      case F9:
X      case F10:
X     if (promptfkeys & (1<<(curkey+1-F1)) )
X        return(curkey);
X      }
X   return(0);
X}
X
Xstatic int input_field_list(
X    int attr,          /* display attribute */
X    char *fld,          /* display form field value */
X    int vlen,          /* field length */
X    char **list,          /* list of values */
X    int llen,          /* number of entries in list */
X    int row,          /* display row */
X    int col,          /* display column */
X    int (*checkkey)(int)  /* routine to check non data keys, or NULL */
X    )
X{
X   int initval,curval;
X   char buf[81];
X   int curkey;
X   int i, j;
X   int ret,savelookatmouse;
X   savelookatmouse = lookatmouse;
X   lookatmouse = 0;
X   for (initval = 0; initval < llen; ++initval)
X      if (strcmp(fld,list[initval]) == 0) break;
X   if (initval >= llen) initval = 0;
X   curval = initval;
X   ret = -1;
X   while (1) {
X      strcpy(buf,list[curval]);
X      i = strlen(buf);
X      while (i < vlen)
X     buf[i++] = ' ';
X      buf[vlen] = 0;
X      putstring(row,col,attr,buf);
X      curkey = keycursor(row,col); /* get a keystroke */
X      switch (curkey) {
X     case ENTER:
X     case ENTER_2:
X        ret = 0;
X        goto inpfldl_end;
X     case ESC:
X        goto inpfldl_end;
X     case RIGHT_ARROW:
X     case RIGHT_ARROW_2:
X        if (++curval >= llen)
X           curval = 0;
X        break;
X     case LEFT_ARROW:
X     case LEFT_ARROW_2:
X        if (--curval < 0)
X           curval = llen - 1;
X        break;
X     case F5:
X        curval = initval;
X        break;
X     default:
X            if (nonalpha(curkey)) {
X           if (checkkey && (ret = (*checkkey)(curkey)))
X          goto inpfldl_end;
X           break;                     /* non alphanum char */
X           }
X        j = curval;
X        for (i = 0; i < llen; ++i) {
X           if (++j >= llen)
X          j = 0;
X           if ((*list[j] & 0xdf) == (curkey & 0xdf)) {
X          curval = j;
X          break;
X          }
X           }
X     }
X      }
Xinpfldl_end:
X   strcpy(fld,list[curval]);
X   lookatmouse = savelookatmouse;
X   return(ret);
X}
X
X
X/* --------------------------------------------------------------------- */
X
X/* MCP 7-7-91, This is static code, but not called anywhere */
X#ifdef DELETE_UNUSED_CODE
X
X/* compare for sort of type table */
Xstatic int compare(const VOIDPTR i, const VOIDPTR j)
X{
X   return(strcmp(fractalspecific[(int)*((BYTE*)i)].name,
X           fractalspecific[(int)*((BYTE*)j)].name));
X}
X
X/* --------------------------------------------------------------------- */
X
Xstatic void clear_line(int row, int start, int stop, int color) /* clear part of a line */
X{
X   int col;
X   for(col=start;col<= stop;col++)
X      putstring(row,col,color," ");
X}
X
X#endif
X
X/* --------------------------------------------------------------------- */
X
Xint get_fracttype()        /* prompt for and select fractal type */
X{
X   int done,i,oldfractype,t;
X   ENTER_OVLY(OVLY_PROMPTS1);
X   done = -1;
X   oldfractype = fractype;
X   while (1) {
X      if ((t = select_fracttype(fractype)) < 0)
X     break;
X      if ((i = select_type_params(t, fractype)) == 0) { /* ok, all done */
X     done = 0;
X     break;
X     }
X      if (i > 0) /* can't return to prior image anymore */
X     done = 1;
X      }
X   if (done < 0)
X      fractype = oldfractype;
X   curfractalspecific = &fractalspecific[fractype];
X   EXIT_OVLY;
X   return(done);
X}
X
Xstruct FT_CHOICE {
X      char name[15];
X      int  num;
X      };
Xstatic struct FT_CHOICE **ft_choices; /* for sel_fractype_help subrtn */
X
Xstatic int select_fracttype(int t) /* subrtn of get_fracttype, separated */
X                   /* so that storage gets freed up     */
X{
X   static char far head1[] = {"Select a Fractal Type"};
X   static char far head2[] = {"Select Orbit Algorithm for Julibrot"};
X   static char far instr[] = {"Press F2 for a description of the highlighted type"};
X   char head[40];
X   int oldhelpmode;
X   int numtypes, done;
X   int i, j;
X#define MAXFTYPES 200
X   char tname[40];
X   struct FT_CHOICE *choices[MAXFTYPES];
X   int attributes[MAXFTYPES];
X
X   /* steal existing array for "choices" */
X   choices[0] = (struct FT_CHOICE *)boxy;
X   attributes[0] = 1;
X   for (i = 1; i < MAXFTYPES; ++i) {
X      choices[i] = choices[i-1] + 1;
X      attributes[i] = 1;
X      }
X   ft_choices = &choices[0];
X
X   /* setup context sensitive help */
X   oldhelpmode = helpmode;
X   helpmode = HELPFRACTALS;
X
X   if(julibrot)
X      far_strcpy(head,head2);
X   else
X      far_strcpy(head,head1);
X   if (t == IFS3D) t = IFS;
X   i = j = -1;
X   while(fractalspecific[++i].name) {
X      if(julibrot)
X      {
X        int isinteger;
X        isinteger = curfractalspecific->isinteger;
X    if (!((fractalspecific[i].flags & OKJB) && *fractalspecific[i].name != '*'))
X       continue;
X      }
X      if (fractalspecific[i].name[0] == '*')
X     continue;
X      strcpy(choices[++j]->name,fractalspecific[i].name);
X      choices[j]->name[14] = 0; /* safety */
X      choices[j]->num = i;    /* remember where the real item is */
X      }
X   numtypes = j + 1;
X   qsort(choices,numtypes,sizeof(char *),lccompare); /* sort list */
X   j = 0;
X   for (i = 0; i < numtypes; ++i) /* find starting choice in sorted list */
X      if (choices[i]->num == t || choices[i]->num == fractalspecific[t].tofloat)
X     j = i;
X
X   tname[0] = 0;
X   done = fullscreen_choice(CHOICEHELP+8,head,NULL,instr,numtypes,
X         (char **)choices,attributes,0,0,0,j,NULL,tname,NULL,sel_fractype_help);
X   if (done >= 0)
X      done = choices[done]->num;
X   helpmode = oldhelpmode;
X   return(done);
X}
X
Xstatic int sel_fractype_help(int curkey,int choice)
X{
X   int oldhelpmode;
X   if (curkey == F2) {
X      oldhelpmode = helpmode;
X      helpmode = fractalspecific[(*(ft_choices+choice))->num].helptext;
X      help(0);
X      helpmode = oldhelpmode;
X      }
X   return(0);
X}
X
Xint select_type_params(    /* prompt for new fractal type parameters */
X    int newfractype,    /* new fractal type */
X    int oldfractype     /* previous fractal type */
X    )
X{
X   int ret,oldhelpmode;
X
X   oldhelpmode = helpmode;
X   ret = 0;
X   fractype = newfractype;
X   curfractalspecific = &fractalspecific[fractype];
X
X   if (fractype == LSYSTEM) {
X      helpmode = HT_LSYS;
X      if (get_file_entry(GETLSYS,"L-System",lsysmask,LFileName,LName) < 0) {
X     ret = 1;
X     goto sel_type_exit;
X     }
X      }
X   if (fractype == FORMULA || fractype == FFORMULA) {
X      helpmode = HT_FORMULA;
X      if (get_file_entry(GETFORMULA,"Formula",formmask,FormFileName,FormName) < 0) {
X     ret = 1;
X     goto sel_type_exit;
X     }
X      }
X   if (fractype == IFS || fractype == IFS3D) {
X      static char far ifsmsg[] = {
X#ifndef XFRACT
X         "Current IFS parameters have been edited but not saved.\n"
X         "Continue to replace them with new selection, cancel to keep them."};
X#else
X         "Current IFS parameters have been edited but not saved.\n\
XContinue to replace them with new selection, cancel to keep them."};
X#endif
X      helpmode = HT_IFS;
X      if (!ifs_defn || !ifs_changed || !stopmsg(22,ifsmsg))
X     if (get_file_entry(GETIFS,"IFS",ifsmask,IFSFileName,IFSName) < 0) {
X        ret = 1;
X        goto sel_type_exit;
X        }
X      }
X
X/* Added the following to accommodate fn bifurcations.  JCO 7/2/92 */
X   if(((fractype == BIFURCATION) || (fractype == LBIFURCATION)) &&
X     !((oldfractype == BIFURCATION) || (oldfractype == LBIFURCATION)))
X        set_trig_array(0,"ident");
X   if(((fractype == BIFSTEWART) || (fractype == LBIFSTEWART)) &&
X     !((oldfractype == BIFSTEWART) || (oldfractype == LBIFSTEWART)))
X        set_trig_array(0,"ident");
X   if(((fractype == BIFLAMBDA) || (fractype == LBIFLAMBDA)) &&
X     !((oldfractype == BIFLAMBDA) || (oldfractype == LBIFLAMBDA)))
X        set_trig_array(0,"ident");
X   if(((fractype == BIFEQSINPI) || (fractype == LBIFEQSINPI)) &&
X     !((oldfractype == BIFEQSINPI) || (oldfractype == LBIFEQSINPI)))
X        set_trig_array(0,"sin");
X   if(((fractype == BIFADSINPI) || (fractype == LBIFADSINPI)) &&
X     !((oldfractype == BIFADSINPI) || (oldfractype == LBIFADSINPI)))
X        set_trig_array(0,"sin");
X
X   set_default_parms();
X
X   if (get_fract_params(0) < 0)
X      ret = 1;
X   else {
X      if (newfractype != oldfractype) {
X     invert = 0;
X     inversion[0] = inversion[1] = inversion[2] = 0;
X     }
X      }
X
Xsel_type_exit:
X   helpmode = oldhelpmode;
X   return(ret);
X
X}
X
Xstatic void set_default_parms()
X{
X   int i;
X   xxmin = curfractalspecific->xmin;
X   xxmax = curfractalspecific->xmax;
X   yymin = curfractalspecific->ymin;
X   yymax = curfractalspecific->ymax;
X   xx3rd = xxmin;
X   yy3rd = yymin;
X   if (viewcrop && finalaspectratio != screenaspect)
X      aspectratio_crop(screenaspect,finalaspectratio);
X   for (i = 0; i < 4; i++) {
X      param[i] = curfractalspecific->paramvalue[i];
X      if (fractype != CELLULAR) /* don't round cellular */
X         roundfloatd(¶m[i]);
X   }
X   if(curfractalspecific->flags&MORE) {
X      int extra;
X      if((extra=find_extra_param(fractype)) > -1)
X         for(i=0;i<MAXPARAMS-4;i++) {
X            param[i+4] = moreparams[extra].paramvalue[i];
X         }
X   }
X}
X
X#define MAXFRACTALS 25
Xextern int neworbittype, num_fractal_types;
X
Xint build_fractal_list(int fractals[], int *last_val, char *nameptr[])
X{
X    int numfractals,i;
X
X    numfractals = 0;
X    for (i = 0; i < num_fractal_types; i++)
X    {
X        int isinteger;
X        isinteger = curfractalspecific->isinteger;
X    if ((fractalspecific[i].flags & OKJB) && *fractalspecific[i].name != '*')
X    {
X        fractals[numfractals] = i;
X        if (i == neworbittype || i == fractalspecific[neworbittype].tofloat)
X        *last_val = numfractals;
X        nameptr[numfractals] = fractalspecific[i].name;
X        numfractals++;
X        if (numfractals >= MAXFRACTALS)
X        break;
X    }
X    }
X    return (numfractals);
X}
Xchar far v00[] = {"Orbit Algorithm"};
Xchar far v0a[] = {"From cx (real part)"};
Xchar far v1a[] = {"From cy (imaginary part)"};
Xchar far v2a[] = {"To   cx (real part)"};
Xchar far v3a[] = {"To   cy (imaginary part)"};
X
X/* 4D Mandelbrot */
Xchar far v0b[] = {"From cj (3rd dim)"};
Xchar far v1b[] = {"From ck (4th dim)"};
Xchar far v2b[] = {"To   cj (3rd dim)"};
Xchar far v3b[] = {"To   ck (4th dim)"};
X
X/* 4D Julia */
Xchar far v0c[] = {"From zj (3rd dim)"};
Xchar far v1c[] = {"From zk (4th dim)"};
Xchar far v2c[] = {"To   zj (3rd dim)"};
Xchar far v3c[] = {"To   zk (4th dim)"};
X
Xchar far v4[] = {"Number of z pixels"};
Xchar far v5[] = {"Location of z origin"};
Xchar far v6[] = {"Depth of z"};
Xchar far v7[] = {"Screen height"};
Xchar far v8[] = {"Screen width"};
Xchar far v9[] = {"Distance to Screen"};
Xchar far v10[] = {"Distance between eyes"};
Xchar far v11[] = {"3D Mode"};
Xchar *juli3Doptions[] = {"monocular","lefteye","righteye","red-blue"};
X
X/* --------------------------------------------------------------------- */
Xint get_fract_params(int caller)    /* prompt for type-specific parms */
X{
X   char far *v0 = v0a;
X   char far *v1 = v1a;
X   char far *v2 = v2a;
X   char far *v3 = v3a;
X   char far *juliorbitname = NULL;
X   extern double mxmaxfp, mxminfp, mymaxfp, myminfp, originfp;
X   extern double depthfp, heightfp, widthfp, distfp, eyesfp;
X   extern int zdots;
X   char *nameptr[MAXFRACTALS];
X   int fractals[MAXFRACTALS];
X   int i,j,k;
X   int curtype,numparams,numtrig,last_val;
X   struct fullscreenvalues paramvalues[30];
X   char far *choices[30];
X   int oldbailout;
X   int extra;
X   int numextra;
X   int promptnum;
X   char msg[120];
X   char *typename, *tmpptr;
X   char bailoutmsg[50];
X   int ret = 0;
X   int oldhelpmode;
X   static char far t11[] = {"Function (if needed by orbit formula)"};
X   static char far t1[] = {"First Function"};
X   static char far t2[] = {"Second Function"};
X   static char far t3[] = {"Third Function"};
X   static char far t4[] = {"Fourth Function"};
X   static char far *trg[] = {t1, t2, t3, t4};
X   extern char tstack[4096];
X   char *filename,*entryname;
X   FILE *entryfile;
X   char *trignameptr[25];
X   extern int  juli3Dmode;
X   struct fractalspecificstuff far *jborbit;
X   struct fractalspecificstuff far *savespecific;
X   int firstparm;
X   double oldparam[MAXPARAMS];
X   ENTER_OVLY(OVLY_PROMPTS1);
X   firstparm = 0;
X   if(fractype==JULIBROT || fractype==JULIBROTFP)
X      julibrot = 1;
X   else
X      julibrot = 0;
X   curtype = fractype;
X   if (curfractalspecific->name[0] == '*'
X     && (i = fractalspecific->tofloat) != NOFRACTAL
X     && fractalspecific[i].name[0] != '*')
X      curtype = i;
X   curfractalspecific = &fractalspecific[curtype];
X#if 0
X   if (curtype == IFS || curtype == IFS3D) {
X      ret = ((caller) ? edit_ifs_params() : 0);
X      goto gfp_exit;
X      }
X#endif
X   tstack[0] = 0;
X   if ((i = curfractalspecific->helpformula) < -1) {
X      if (i == -2) { /* special for formula */
X     filename = FormFileName;
X     entryname = FormName;
X     }
X      else {     /* -3, special for lsystem */
X     filename = LFileName;
X     entryname = LName;
X     }
X      if (find_file_item(filename,entryname,&entryfile) == 0) {
X     load_entry_text(entryfile,tstack,16);
X     fclose(entryfile);
X     }
X      }
X   else if (i >= 0) {
X      int c,lines;
X      if (i = read_help_topic(i,0,2000,tstack) > 0) i = 0;
X      tstack[2000-i] = 0;
X      i = j = lines = 0; k = 1;
X      while ((c = tstack[i++])) {
X     /* stop at ctl, blank, or line with col 1 nonblank, max 16 lines */
X     if (k && c == ' ' && ++k <= 5) { } /* skip 4 blanks at start of line */
X     else {
X        if (c == '\n') {
X           if (k) break; /* blank line */
X           if (++lines >= 16) break;
X           k = 1;
X           }
X        else if (c < 16) /* a special help format control char */
X           break;
X        else {
X           if (k == 1) /* line starts in column 1 */
X          break;
X           k = 0;
X           }
X        tstack[j++] = c;
X        }
X     }
X      while (--j >= 0 && tstack[j] == '\n') { }
X      tstack[j+1] = 0;
X      }
Xgfp_top:
X   promptnum = 0;
X   if (julibrot)
X   {
X      i = select_fracttype(neworbittype);
X      if (i < 0)
X      {
X         if (ret == 0)
X            ret = -1;
X         julibrot = 0;
X         goto gfp_exit;
X      }
X      else
X         neworbittype = i;
X      jborbit = &fractalspecific[neworbittype];
X      juliorbitname = jborbit->name;
X   }
X   promptnum = 0;
X
X   if(julibrot)
X   {
X      savespecific = curfractalspecific;
X      curfractalspecific = jborbit;
X      firstparm = 2; /* in most case Julibrot does not need first two parms */
X      if(neworbittype == QUATJULFP     ||   /* all parameters needed */
X         neworbittype == HYPERCMPLXJFP)
X         firstparm = 0;
X      if(neworbittype == QUATFP        ||   /* no parameters needed */
X         neworbittype == HYPERCMPLXFP)
X         firstparm = 4;
X   }
X   numparams = 0;
X
X   for (i = firstparm; i < 4; i++)
X   {
X      char tmpbuf[30];
X      if (curfractalspecific->param[i][0] == 0)
X         break;
X      numparams++;
X      choices[promptnum] = curfractalspecific->param[i];
X      paramvalues[promptnum].type = 'd';
X
X      if (choices[promptnum][0] == '+')
X      {
X         choices[promptnum]++;
X         paramvalues[promptnum].type = 'D';
X      }
X      sprintf(tmpbuf,"%.17g",param[i]);
X      paramvalues[promptnum].uval.dval = atof(tmpbuf);
X      oldparam[i] = paramvalues[promptnum++].uval.dval;
X   }
X   numextra = 0;
X   if(curfractalspecific->flags&MORE && !julibrot)
X   {
X      if((extra=find_extra_param(fractype))<-1)
X      {
X         char msg[30];
X         sprintf(msg,"find_extra_param error");
X         stopmsg(0,msg);
X      }
X      else
X      for (i=0;i<MAXPARAMS-4;i++)
X      {
X         char tmpbuf[30];
X         if (moreparams[extra].param[i][0] == 0)
X            break;
X         numextra++;
X         choices[promptnum] = moreparams[extra].param[i];
X         paramvalues[promptnum].type = 'd';
X         if (choices[promptnum][0] == '+')
X         {
X            choices[promptnum]++;
X            paramvalues[promptnum].type = 'D';
X         }
X         sprintf(tmpbuf,"%.17g",param[i+4]);
X         paramvalues[promptnum].uval.dval = atof(tmpbuf);
X         oldparam[i+4] = paramvalues[promptnum++].uval.dval;
X      }
X   }
X   numtrig = (curfractalspecific->flags >> 6) & 7;
X   if(curtype==FORMULA || curtype==FFORMULA ) {
X      extern char maxfn;
X      numtrig = maxfn;
X      }
X
X   if ((i = numtrigfn) > 27) i = 27;
X   while (--i >= 0)
X      trignameptr[i] = trigfn[i].name;
X   for (i = 0; i < numtrig; i++) {
X      paramvalues[promptnum].type = 'l';
X      paramvalues[promptnum].uval.ch.val  = trigndx[i];
X      paramvalues[promptnum].uval.ch.llen = numtrigfn;
X      paramvalues[promptnum].uval.ch.vlen = 6;
X      paramvalues[promptnum].uval.ch.list = trignameptr;
X      choices[promptnum++] = trg[i];
X      }
X   if (*(typename = curfractalspecific->name) == '*')
X        ++typename;
X
X   if (curfractalspecific->orbit_bailout)
X      if (potparam[0] != 0.0 && potparam[2] != 0.0)
X      {
X     paramvalues[promptnum].type = '*';
X     choices[promptnum++] = "Bailout: continuous potential (Y screen) value in use";
X      }
X      else
X      {
X         static char far bailoutstr[] = {"Bailout value (0 means use default)"};
X     choices[promptnum] = bailoutstr;
X     paramvalues[promptnum].type = 'i';
X     paramvalues[promptnum++].uval.ival = oldbailout = bailout;
X     paramvalues[promptnum].type = '*';
X     i = curfractalspecific->orbit_bailout;
X     tmpptr = typename;
X     if (usr_biomorph != -1)
X     {
X        i = 100;
X        tmpptr = "biomorph";
X     }
X     sprintf(bailoutmsg,"    (%s default is %d)",tmpptr,i);
X     choices[promptnum++] = bailoutmsg;
X      }
X   if (julibrot)
X   {
X      switch(neworbittype)
X      {
X      case QUATFP:
X      case HYPERCMPLXFP:
X          v0 = v0b; v1 = v1b; v2 = v2b; v3 = v3b;
X          break;
X      case QUATJULFP:
X      case HYPERCMPLXJFP:
X          v0 = v0c; v1 = v1c; v2 = v2c; v3 = v3c;
X          break;
X      default:
X          v0 = v0a; v1 = v1a; v2 = v2a; v3 = v3a;
X         break;
X      }
X
X      curfractalspecific = savespecific;
X      paramvalues[promptnum].uval.dval = mxmaxfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v0;
X      paramvalues[promptnum].uval.dval = mymaxfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v1;
X      paramvalues[promptnum].uval.dval = mxminfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v2;
X      paramvalues[promptnum].uval.dval = myminfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v3;
X      paramvalues[promptnum].uval.ival = zdots;
X      paramvalues[promptnum].type = 'i';
X      choices[promptnum++] = v4;
X
X      paramvalues[promptnum].type = 'l';
X      paramvalues[promptnum].uval.ch.val  = juli3Dmode;
X      paramvalues[promptnum].uval.ch.llen = 4;
X      paramvalues[promptnum].uval.ch.vlen = 9;
X      paramvalues[promptnum].uval.ch.list = juli3Doptions;
X      choices[promptnum++] = v11;
X
X      paramvalues[promptnum].uval.dval = eyesfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v10;
X      paramvalues[promptnum].uval.dval = originfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v5;
X      paramvalues[promptnum].uval.dval = depthfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v6;
X      paramvalues[promptnum].uval.dval = heightfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v7;
X      paramvalues[promptnum].uval.dval = widthfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v8;
X      paramvalues[promptnum].uval.dval = distfp;
X      paramvalues[promptnum].type = 'f';
X      choices[promptnum++] = v9;
X   }
X
X   if (curtype == INVERSEJULIA || curtype == INVERSEJULIAFP)
X   {
X      extern int  major_method;
X      extern int  minor_method;
X
X#ifdef RANDOM_RUN
X      static char far JIIMstr1[] =
X    "Breadth first, Depth first, Random Walk, Random Run?";
X      static char *JIIMmethod[] = {"Breadth", "Depth", "Walk", "Run"};
X#else
X      static char far JIIMstr1[] =
X    "Breadth first, Depth first, Random Walk";
X      static char *JIIMmethod[] = {"Breadth", "Depth", "Walk"};
X#endif
X      static char far JIIMstr2[] =
X    "Left first or Right first?";
X      static char *JIIMleftright[] = {"Left", "Right"};
X
X      choices[promptnum] = JIIMstr1;
X      paramvalues[promptnum].type = 'l';
X      paramvalues[promptnum].uval.ch.list = JIIMmethod;
X      paramvalues[promptnum].uval.ch.vlen = 7;
X#ifdef RANDOM_RUN
X      paramvalues[promptnum].uval.ch.llen = 4;
X#else
X      paramvalues[promptnum].uval.ch.llen = 3; /* disable random run */
X#endif
X      paramvalues[promptnum++].uval.ch.val  = major_method;
X
X      choices[promptnum] = JIIMstr2;
X      paramvalues[promptnum].type = 'l';
X      paramvalues[promptnum].uval.ch.list = JIIMleftright;
X      paramvalues[promptnum].uval.ch.vlen = 5;
X      paramvalues[promptnum].uval.ch.llen = 2;
X      paramvalues[promptnum++].uval.ch.val  = minor_method;
X   }
X
X   if (caller                /* <z> command ? */
X      && (display3d > 0 || promptnum == 0))
X      {
X       static char far msg[]={"Current type has no type-specific parameters"};
X       stopmsg(20,msg);
X       goto gfp_exit;
X       }
X   if(julibrot)
X   sprintf(msg,
X       "Julibrot Parameters (orbit= %s)\n(Press F6 for corner parameters)",
X       juliorbitname);
X   else
X   sprintf(msg,
X       "Parameters for fractal type %s\n(Press F6 for corner parameters)",
X       typename);
X
X   while (1)
X   {
X      oldhelpmode = helpmode;
X      helpmode = curfractalspecific->helptext;
X      i = fullscreen_prompt(msg,promptnum,choices,paramvalues,0,0x40,tstack);
X      helpmode = oldhelpmode;
X      if (i < 0)
X      {
X         if(julibrot)
X           goto gfp_top;
X     if (ret == 0)
X        ret = -1;
X     goto gfp_exit;
X      }
X      if (i != F6)
X         break;
X      if (get_corners() > 0)
X     ret = 1;
X     }
X     promptnum = 0;
X     for ( i = firstparm; i < numparams+firstparm; i++)
X     {
X        if (oldparam[i] != paramvalues[promptnum].uval.dval)
X        {
X           param[i] = paramvalues[promptnum].uval.dval;
X          ret = 1;
X        }
X        ++promptnum;
X    }
X     for(i=0;i<numextra;i++)
X     {
X        if(oldparam[i+4] != paramvalues[promptnum].uval.dval)
X        {
X           param[i+4] = paramvalues[promptnum].uval.dval;
X           ret = 1;
X        }
X        ++promptnum;
X     }
X
X   for ( i = 0; i < numtrig; i++)
X   {
X      if (paramvalues[promptnum].uval.ch.val != trigndx[i])
X      {
X     set_trig_array(i,trigfn[paramvalues[promptnum].uval.ch.val].name);
X     ret = 1;
X      }
X      ++promptnum;
X   }
X
X   if(julibrot)
X   {
X      savespecific = curfractalspecific;
X      curfractalspecific = jborbit;
X   }
X
X   if (curfractalspecific->orbit_bailout)
X      if (potparam[0] != 0.0 && potparam[2] != 0.0)
X     promptnum++;
X      else
X      {
X         bailout = paramvalues[promptnum++].uval.ival;
X#ifndef XFRACT
X         if (bailout != 0 && (bailout < 4 || bailout > 32000))
X#else /* We have big integers, so why not allow big bailouts? */
X         if (bailout != 0 && (bailout < 4))
X#endif
X        bailout = oldbailout;
X         if (bailout != oldbailout)
X        ret = 1;
X     promptnum++;
X      }
X
X     if (julibrot)
X     {
X    mxmaxfp    = paramvalues[promptnum++].uval.dval;
X    mymaxfp    = paramvalues[promptnum++].uval.dval;
X    mxminfp    = paramvalues[promptnum++].uval.dval;
X    myminfp    = paramvalues[promptnum++].uval.dval;
X    zdots      = paramvalues[promptnum++].uval.ival;
X        juli3Dmode = paramvalues[promptnum++].uval.ch.val;
X    eyesfp     = paramvalues[promptnum++].uval.dval;
X    originfp   = paramvalues[promptnum++].uval.dval;
X    depthfp    = paramvalues[promptnum++].uval.dval;
X    heightfp   = paramvalues[promptnum++].uval.dval;
X    widthfp    = paramvalues[promptnum++].uval.dval;
X    distfp     = paramvalues[promptnum++].uval.dval;
X        ret = 1;  /* force new calc since not resumable anyway */
X     }
X      if (curtype == INVERSEJULIA || curtype == INVERSEJULIAFP)
X      {
X     extern int major_method, minor_method;
X
X     if (paramvalues[promptnum].uval.ch.val != major_method ||
X         paramvalues[promptnum+1].uval.ch.val != minor_method)
X        ret = 1;
X
X     major_method = paramvalues[promptnum  ].uval.ch.val;
X     minor_method = paramvalues[promptnum+1].uval.ch.val;
X      }
X
Xgfp_exit:
X   curfractalspecific = &fractalspecific[fractype];
X   EXIT_OVLY;
X   return(ret);
X}
X
Xint find_extra_param(int type)
X{
X   int i,ret,curtyp;
X   ret = -1;
X   i= -1;
X   while((curtyp=moreparams[++i].type) != type && curtyp != -1);
X   if(curtyp == type)
X     ret = i;
X   return(ret);
X}
X
X
Xint check_orbit_name(char *orbitname)
X{
X   int i, numtypes, bad;
X   char *nameptr[MAXFRACTALS];
X   int fractals[MAXFRACTALS];
X   int curtype,numparams,numtrig,last_val;
X
X   ENTER_OVLY(OVLY_PROMPTS1);
X   numtypes = build_fractal_list(fractals, &last_val, nameptr);
X   bad = 1;
X   for(i=0;i<numtypes;i++)
X   {
X      if(strcmp(orbitname,nameptr[i]) == 0)
X      {
X         neworbittype = fractals[i];
X         bad = 0;
X         break;
X      }
X   }
X   EXIT_OVLY;
X   return(bad);
X}
X
X/* --------------------------------------------------------------------- */
X
X   static FILE *gfe_file;
X
Xlong get_file_entry(int type,char *title,char *fmask,
X              char *filename,char *entryname)
X{
X   /* Formula, LSystem, etc type structure, select from file */
X   /* containing definitions in the form    name { ... }     */
X   int newfile,firsttry;
X   long entry_pointer;
X   extern char tstack[4096];
X   newfile = 0;
X   while (1) {
X      firsttry = 0;
X      /* pb: binary mode used here - it is more work, but much faster, */
X      /*     especially when ftell or fgetpos is used               */
X      while (newfile || (gfe_file = fopen(filename, "rb")) == NULL) {
X     char buf[60];
X     newfile = 0;
X     if (firsttry) {
X        extern char s_cantfind[];
X        sprintf(temp1,s_cantfind, filename);
X        stopmsg(0,temp1);
X        }
X     sprintf(buf,"Select %s File",title);
X     if (getafilename(buf,fmask,filename) < 0)
X        return -1;
X     firsttry = 1; /* if around open loop again it is an error */
X     }
X      setvbuf(gfe_file,tstack,_IOFBF,4096); /* improves speed when file is big */
X      newfile = 0;
X      if ((entry_pointer = gfe_choose_entry(type,title,filename,entryname)) == -2) {
X     newfile = 1; /* go to file list, */
X     continue;    /* back to getafilename */
X     }
X      if (entry_pointer == -1)
X     return -1;
X      switch (type) {
X     case GETFORMULA:
X        if (RunForm(entryname) == 0) return 0;
X        break;
X     case GETLSYS:
X        if (LLoad() == 0) return 0;
X        break;
X     case GETIFS:
X        if (ifsload() == 0) {
X           fractype = (ifs_type == 0) ? IFS : IFS3D;
X           curfractalspecific = &fractalspecific[fractype];
X           set_default_parms(); /* to correct them if 3d */
X           return 0;
X           }
X        break;
X     case GETPARM:
X        return entry_pointer;
X     }
X      }
X}
X
X   struct entryinfo {
X      char name[ITEMNAMELEN+1];
X      long point; /* points to the ( or the { following the name */
X      };
X   static struct entryinfo **gfe_choices; /* for format_getparm_line */
X   static char *gfe_title;
X
Xstatic long gfe_choose_entry(int type,char *title,char *filename,char *entryname)
X/* subrtn of get_file_entry, separated so that storage gets freed up */
X{
X#define MAXENTRIES 200
X   static char far instr[]={"Press F6 to select different file, F2 for details of highlighted choice"};
X   int numentries, i;
X   char buf[101];
X   struct entryinfo *choices[MAXENTRIES];
X   int attributes[MAXENTRIES];
X   void (*formatitem)();
X   int boxwidth,boxdepth,colwidth;
X   long file_offset,name_offset;
X   extern struct entryinfo boxx[MAXENTRIES];
X
X   gfe_choices = &choices[0];
X   gfe_title = title;
X   for (i = 0; i < MAXENTRIES; i++) {
X      attributes[i] = 1;
X      choices[i] = &boxx[i];
X      }
X   numentries = 0;
X   file_offset = -1;
X
X   helptitle(); /* to display a clue when file big and next is slow */
X
X   while (1) { /* scan the file for entry names */
X      int c,len;
X      do {
X     ++file_offset;
X     c = getc(gfe_file);
X     } while (c == ' ' /* skip white space */
X           || c == '\t' || c == '\n' || c == '\r');
X      if (c == ';') {
X     do {
X        ++file_offset;
X        c = getc(gfe_file);
X        } while (c != '\n' && c != EOF && c != '\032');
X     if (c == EOF || c == '\032') break;
X     continue;
X     }
X      name_offset = file_offset;
X      len = 0; /* next equiv roughly to fscanf(..,"%40[^ \n\r\t({\032]",buf) */
X      while (c != ' ' && c != '\t' && c != '('
X    && c != '{' && c != '\n' && c != '\r' && c != EOF && c != '\032') {
X     if (len < 40) buf[len++] = c;
X     c = getc(gfe_file);
X     ++file_offset;
X     }
X      buf[len] = 0;
X      while (c != '{' && c != '\n' && c != '\r' && c != EOF && c != '\032') {
X     c = getc(gfe_file);
X     ++file_offset;
X     }
X      if (c == '{') {
X     while (c != '}' && c != EOF && c != '\032') {
X        c = getc(gfe_file);
X        ++file_offset;
X        }
X     if (c != '}') break;
X     buf[ITEMNAMELEN] = 0;
X     if (buf[0] != 0 && stricmp(buf,"comment") != 0) {
X        strcpy(boxx[numentries].name,buf);
X        boxx[numentries].point = name_offset;
X        if (++numentries >= MAXENTRIES) {
X           sprintf(buf,"Too many entries in file, first %d used",MAXENTRIES);
X           stopmsg(0,buf);
X           break;
X           }
X        }
X     }
X      else
X     if (c == EOF || c == '\032') break;
X      }
X
X   if (numentries == 0) {
X      static char far msg[]={"File doesn't contain any valid entries"};
X      stopmsg(0,msg);
X      fclose(gfe_file);
X      return -2; /* back to file list */
X      }
X
X   qsort((char **)choices,numentries,sizeof(char *),lccompare);
X
X   strcpy(buf,entryname); /* preset to last choice made */
X   sprintf(temp1,"%s Selection\nFile: %s",title,filename);
X   formatitem = NULL;
X   boxwidth = colwidth = boxdepth = 0;
X   if (type == GETPARM) {
X      formatitem = format_parmfile_line;
X      boxwidth = 1;
X      boxdepth = 16;
X      colwidth = 76;
X      }
X   i = fullscreen_choice(8,temp1,NULL,instr,numentries,(char **)choices,
X                           attributes,boxwidth,boxdepth,colwidth,0,
X               formatitem,buf,NULL,check_gfe_key);
X   fclose(gfe_file);
X   if (i < 0) {
X      if (i == 0-F6)
X     return -2; /* go back to file list */
X      return -1;    /* cancel */
X      }
X   strcpy(entryname, choices[i]->name);
X   return(choices[i]->point);
X}
X
Xstatic int check_gfe_key(int curkey,int choice)
X{
X   char infhdg[60];
X   char far *infbuf;
X
X   if (curkey == F6)
X      return 0-F6;
X   if (curkey == F2) {
X      infbuf = MK_FP(extraseg,0);
X      fseek(gfe_file,gfe_choices[choice]->point,SEEK_SET);
X      load_entry_text(gfe_file,infbuf,16);
X      strcpy(infhdg,gfe_title);
X      strcat(infhdg," file entry:\n\n");
X /* ... instead, call help with buffer?  heading added */
X      stackscreen();
X      helptitle();
X      setattr(1,0,C_GENERAL_MED,24*80);
X      putstring(2,1,C_GENERAL_HI,infhdg);
X      textcbase = 2; /* left margin is 2 */
X      putstring(-1,0,C_GENERAL_MED,infbuf);
X      putstring(-1,0,C_GENERAL_LO,"\n\n\nPress any key to return to selection list");
X      textcbase = 0;
X      movecursor(25,80);
X      getakeynohelp();
X      unstackscreen();
X      }
X   return 0;
X}
X
Xstatic void load_entry_text(FILE *entfile,char far *buf,int maxlines)
X{
X   int linect,linelen,c;
X   linect = linelen = 0;
X   while ((c = fgetc(entfile)) != EOF && c != '\032') {
X      if (c != '\r') {
X     if (c == '\t') {
X        while ((linelen % 8) != 7 && linelen < 75) { /* 76 wide max */
X           *(buf++) = ' ';
X           ++linelen;
X           }
X        c = ' ';
X        }
X     if (c == '\n') {
X        if (++linect > maxlines) break;
X        linelen = -1;
X        }
X     if (++linelen > 75) {
X        if (linelen == 76) *(buf++) = '\021';
X        }
X     else
X        *(buf++) = c;
X     if (c == '}') break;
X     }
X      }
X   *buf = 0;
X}
X
Xstatic void format_parmfile_line(int choice,char *buf)
X{
X   int c,i;
X   char line[80];
X   fseek(gfe_file,gfe_choices[choice]->point,SEEK_SET);
X   while (getc(gfe_file) != '{') { }
X   while ((c = getc(gfe_file)) == ' ' || c == '\t' || c == ';') { }
X   i = 0;
X   while (i < 56 && c != '\n' && c != '\r' && c != EOF && c != '\032') {
X      line[i++] = (c == '\t') ? ' ' : c;
X      c = getc(gfe_file);
X      }
X   line[i] = 0;
X   sprintf(buf,"%-20s%-56s",gfe_choices[choice]->name,line);
X}
X
X/* --------------------------------------------------------------------- */
X
Xint get_fract3d_params() /* prompt for 3D fractal parameters */
X{
X   int i,k,ret,oldhelpmode;
X   static char far hdg[] = {"3D Parameters"};
X   static char far p1[] = {"X-axis rotation in degrees"};
X   static char far p2[] = {"Y-axis rotation in degrees"};
X   static char far p3[] = {"Z-axis rotation in degrees"};
X   static char far p4[] = {"Perspective distance [1 - 999, 0 for no persp]"};
X   static char far p5[] = {"X shift with perspective (positive = right)"};
X   static char far p6[] = {"Y shift with perspective (positive = up   )"};
X   static char far p7[] = {"Stereo (R/B 3D)? (0=no,1=alternate,2=superimpose,3=photo)"};
X   static char far *ifs3d_prompts[8] = {p1, p2, p3, p4, p5, p6, p7};
X   struct fullscreenvalues uvalues[20];
X
X   ENTER_OVLY(OVLY_PROMPTS1);
X   stackscreen();
X
X   k = 0;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = XROT;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = YROT;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = ZROT;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = ZVIEWER;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = XSHIFT;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = YSHIFT;
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = glassestype;
X
X   oldhelpmode = helpmode;
X   helpmode = HELP3DFRACT;
X   i = fullscreen_prompt(hdg,k,ifs3d_prompts,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (i < 0) {
X      ret = -1;
X      goto get_f3d_exit;
X      }
X
X   ret = k = 0;
X   XROT    =  uvalues[k++].uval.ival;
X   YROT    =  uvalues[k++].uval.ival;
X   ZROT    =  uvalues[k++].uval.ival;
X   ZVIEWER =  uvalues[k++].uval.ival;
X   XSHIFT  =  uvalues[k++].uval.ival;
X   YSHIFT  =  uvalues[k++].uval.ival;
X   glassestype = uvalues[k++].uval.ival;
X   if (glassestype < 0 || glassestype > 3) glassestype = 0;
X   if (glassestype)
X      if (get_funny_glasses_params() || check_mapfile())
X     ret = -1;
X
Xget_f3d_exit:
X   unstackscreen();
X   EXIT_OVLY;
X   return(ret);
X}
X
X/* --------------------------------------------------------------------- */
X/* These macros streamline the "save near space" campaign */
X
X#define LOADPROMPTS3D(X)     {\
X   static char far tmp[] = { X };\
X   prompts3d[++k]= tmp;\
X   }
X
X
Xint get_3d_params()    /* prompt for 3D parameters */
X{
X   static char far hdg[]={"3D Mode Selection"};
X   static char far hdg1[]={"Select 3D Fill Type"};
X   char *choices[10];
X   int attributes[21];
X   int sphere;
X   char far *s;
X   static char far s1[] = {"              Sphere 3D Parameters\n\
XSphere is on its side; North pole to right\n\
XLong. 180 is top, 0 is bottom; Lat. -90 is left, 90 is right"};
X   static char s2[]={"              Planar 3D Parameters\n\
XPre-rotation X axis is screen top; Y axis is left side\n\
XPre-rotation Z axis is coming at you out of the screen!"};
X   char far *prompts3d[21];
X   struct fullscreenvalues uvalues[21];
X   int i, k;
X   int oldhelpmode;
X
X   ENTER_OVLY(OVLY_PROMPTS1);
X
X#ifdef WINFRACT
X     {
X     extern int far wintext_textmode;
X
X     if (wintext_textmode != 2)  /* are we in textmode? */
X         return(0);              /* no - prompts are already handled */
X     }
X#endif
Xrestart_1:
X    if (Targa_Out && overlay3d)
X        Targa_Overlay = 1;
X
X   k= -1;
X
X   LOADPROMPTS3D("Preview Mode?");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = preview;
X
X   LOADPROMPTS3D("    Show Box?");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = showbox;
X
X   LOADPROMPTS3D("Coarseness, preview/grid/ray (in y dir)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = previewfactor;
X
X   LOADPROMPTS3D("Spherical Projection?");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = sphere = SPHERE;
X
X   LOADPROMPTS3D("Stereo (R/B 3D)? (0=no,1=alternate,2=superimpose,3=photo)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = glassestype;
X
X   LOADPROMPTS3D("Ray trace out? (0=No, 1=DKB/POVRay, 2=VIVID, 3=RAW,");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = RAY;
X
X   LOADPROMPTS3D("                4=MTV, 5=RAYSHADE, 6=ACROSPIN, 7=DXF)");
X   uvalues[k].type = '*';
X
X   LOADPROMPTS3D("    Brief output?");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = BRIEF;
X
X   check_writefile(ray_name,".ray");
X   LOADPROMPTS3D("    Output File Name");
X   uvalues[k].type = 's';
X   strcpy(uvalues[k].uval.sval,ray_name);
X
X   LOADPROMPTS3D("Targa output?");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = Targa_Out;
X
X   oldhelpmode = helpmode;
X   helpmode = HELP3DMODE;
X
X   k = fullscreen_prompt(hdg,k+1,prompts3d,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (k < 0) {
X      EXIT_OVLY;
X      return(-1);
X      }
X
X   k=0;
X
X   preview = uvalues[k++].uval.ch.val;
X
X   showbox = uvalues[k++].uval.ch.val;
X
X   previewfactor  = uvalues[k++].uval.ival;
X
X   sphere = uvalues[k++].uval.ch.val;
X
X   glassestype = uvalues[k++].uval.ival;
X
X   RAY = uvalues[k++].uval.ival;
X   k++;
X   {
X      static char far msg[] = {
X"DKB/POV-Ray output is obsolete but still works. See \"Ray Tracing Output\" in\n\
Xthe online documentation."};
X      if(RAY == 1)
X         stopmsg(0,msg);
X   }
X   BRIEF = uvalues[k++].uval.ch.val;
X
X   strcpy(ray_name,uvalues[k++].uval.sval);
X
X   Targa_Out = uvalues[k++].uval.ch.val;
X
X   /* check ranges */
X   if(previewfactor < 2)
X      previewfactor = 2;
X   if(previewfactor > 2000)
X      previewfactor = 2000;
X
X   if(sphere && !SPHERE)
X   {
X      SPHERE = TRUE;
X      set_3d_defaults();
X   }
X   else if(!sphere && SPHERE)
X   {
X      SPHERE = FALSE;
X      set_3d_defaults();
X   }
X
X   if(glassestype < 0)
X      glassestype = 0;
X   if(glassestype > 3)
X      glassestype = 3;
X   if(glassestype)
X      whichimage = 1;
X
X   if (RAY < 0)
X      RAY = 0;
X   if (RAY > 7)
X      RAY = 7;
X
X   if (!RAY)
X   {
X      k = 0;
X      choices[k++] = "make a surface grid";
X      choices[k++] = "just draw the points";
X      choices[k++] = "connect the dots (wire frame)";
X      choices[k++] = "surface fill (colors interpolated)";
X      choices[k++] = "surface fill (colors not interpolated)";
X      choices[k++] = "solid fill (bars up from \"ground\")";
X      if(SPHERE)
X      {
X         choices[k++] = "light source";
X      }
X      else
X      {
X         choices[k++] = "light source before transformation";
X         choices[k++] = "light source after transformation";
X      }
X      for (i = 0; i < k; ++i)
X     attributes[i] = 1;
X      helpmode = HELP3DFILL;
X      i = fullscreen_choice(CHOICEHELP,hdg1,NULL,NULL,k,choices,attributes,
X                  0,0,0,FILLTYPE+1,NULL,NULL,NULL,NULL);
X      helpmode = oldhelpmode;
X      if (i < 0)
X     goto restart_1;
X      FILLTYPE = i-1;
X
X      if(glassestype)
X      {
X     if(get_funny_glasses_params())
X            goto restart_1;
X         }
X         if (check_mapfile())
X             goto restart_1;
X      }
X   restart_3:
X
X   if(SPHERE)
X   {
X      k = -1;
X      LOADPROMPTS3D("Longitude start (degrees)");
X      LOADPROMPTS3D("Longitude stop  (degrees)");
X      LOADPROMPTS3D("Latitude start  (degrees)");
X      LOADPROMPTS3D("Latitude stop   (degrees)");
X      LOADPROMPTS3D("Radius scaling factor in pct");
X   }
X   else
X   {
X      k = -1;
X      if (!RAY)
X      {
X         LOADPROMPTS3D("X-axis rotation in degrees");
X         LOADPROMPTS3D("Y-axis rotation in degrees");
X         LOADPROMPTS3D("Z-axis rotation in degrees");
X      }
X      LOADPROMPTS3D("X-axis scaling factor in pct");
X      LOADPROMPTS3D("Y-axis scaling factor in pct");
X   }
X   k = -1;
X   if (!(RAY && !SPHERE))
X   {
X      uvalues[++k].uval.ival   = XROT     ;
X      uvalues[k].type = 'i';
X      uvalues[++k].uval.ival   = YROT     ;
X      uvalues[k].type = 'i';
X      uvalues[++k].uval.ival   = ZROT     ;
X      uvalues[k].type = 'i';
X   }
X   uvalues[++k].uval.ival   = XSCALE    ;
X   uvalues[k].type = 'i';
X
X   uvalues[++k].uval.ival   = YSCALE    ;
X   uvalues[k].type = 'i';
X
X   LOADPROMPTS3D("Surface Roughness scaling factor in pct");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = ROUGH     ;
X
X   LOADPROMPTS3D("'Water Level' (minimum color value)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = WATERLINE ;
X
X   if(!RAY)
X   {
X      LOADPROMPTS3D("Perspective distance [1 - 999, 0 for no persp])");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = ZVIEWER     ;
X
X      LOADPROMPTS3D("X shift with perspective (positive = right)");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = XSHIFT    ;
X
X      LOADPROMPTS3D("Y shift with perspective (positive = up   )");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = YSHIFT    ;
X
X      LOADPROMPTS3D("Image non-perspective X adjust (positive = right)");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = xtrans    ;
X
X      LOADPROMPTS3D("Image non-perspective Y adjust (positive = up)");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = ytrans    ;
X
X      LOADPROMPTS3D("First transparent color");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = transparent[0];
X
X      LOADPROMPTS3D("Last transparent color");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = transparent[1];
X   }
X
X   LOADPROMPTS3D("Randomize Colors      (0 - 7, '0' disables)");
X   uvalues[k].type = 'i';
X   uvalues[k++].uval.ival = RANDOMIZE;
X
X   if (SPHERE)
X      s = s1;
X   else
X      s = s2;
X
X   helpmode = HELP3DPARMS;
X   k = fullscreen_prompt(s,k,prompts3d,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (k < 0)
X      goto restart_1;
X
X   k = 0;
X   if (!(RAY && !SPHERE))
X   {
X      XROT    = uvalues[k++].uval.ival;
X      YROT    = uvalues[k++].uval.ival;
X      ZROT    = uvalues[k++].uval.ival;
X   }
X   XSCALE     = uvalues[k++].uval.ival;
X   YSCALE     = uvalues[k++].uval.ival;
X   ROUGH      = uvalues[k++].uval.ival;
X   WATERLINE  = uvalues[k++].uval.ival;
X   if (!RAY)
X   {
X      ZVIEWER = uvalues[k++].uval.ival;
X   XSHIFT     = uvalues[k++].uval.ival;
X   YSHIFT     = uvalues[k++].uval.ival;
X   xtrans     = uvalues[k++].uval.ival;
X   ytrans     = uvalues[k++].uval.ival;
X   transparent[0] = uvalues[k++].uval.ival;
X   transparent[1] = uvalues[k++].uval.ival;
X   }
X   RANDOMIZE  = uvalues[k++].uval.ival;
X   if (RANDOMIZE >= 7) RANDOMIZE = 7;
X   if (RANDOMIZE <= 0) RANDOMIZE = 0;
X
X   if ((Targa_Out || ILLUMINE || RAY))
X    if(get_light_params())
X        goto restart_3;
X
XEXIT_OVLY;
Xreturn(0);
X}
X
X/* --------------------------------------------------------------------- */
Xstatic int get_light_params()
X{
X   static char far hdg[]={"Light Source Parameters"};
X   char far *prompts3d[13];
X   struct fullscreenvalues uvalues[13];
X
X   int k;
X   int oldhelpmode;
X
X   /* defaults go here */
X
X   k = -1;
X
X   if (ILLUMINE || RAY)
X   {
X   LOADPROMPTS3D("X value light vector");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = XLIGHT    ;
X
X   LOADPROMPTS3D("Y value light vector");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = YLIGHT    ;
X
X   LOADPROMPTS3D("Z value light vector");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = ZLIGHT    ;
X
X        if (!RAY)
X        {
X   LOADPROMPTS3D("Light Source Smoothing Factor");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = LIGHTAVG  ;
X
X   LOADPROMPTS3D("Ambient");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = Ambient;
X        }
X   }
X
X   if (Targa_Out && !RAY)
X   {
X    LOADPROMPTS3D("Haze Factor        (0 - 100, '0' disables)");
X    uvalues[k].type = 'i';
X    uvalues[k].uval.ival= haze;
X
X        if (!Targa_Overlay)
X    check_writefile(light_name,".tga");
X      LOADPROMPTS3D("Targa File Name  (Assume .tga)");
X    uvalues[k].type = 's';
X    strcpy(uvalues[k].uval.sval,light_name);
X
X      LOADPROMPTS3D("Back Ground Color (0 - 255)");
X      uvalues[k].type = '*';
X
X      LOADPROMPTS3D("   Red");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = (int)back_color[0];
X
X      LOADPROMPTS3D("   Green");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = (int)back_color[1];
X
X      LOADPROMPTS3D("   Blue");
X      uvalues[k].type = 'i';
X      uvalues[k].uval.ival = (int)back_color[2];
X
X      LOADPROMPTS3D("Overlay Targa File? (Y/N)");
X      uvalues[k].type = 'y';
X      uvalues[k].uval.ch.val = Targa_Overlay;
X
X   }
X
X   LOADPROMPTS3D("");
X
X   oldhelpmode = helpmode;
X   helpmode = HELP3DLIGHT;
X   k = fullscreen_prompt(hdg,k,prompts3d,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (k < 0)
X      return(-1);
X
X   k = 0;
X   if (ILLUMINE)
X   {
X      XLIGHT   = uvalues[k++].uval.ival;
X      YLIGHT   = uvalues[k++].uval.ival;
X      ZLIGHT   = uvalues[k++].uval.ival;
X      if (!RAY)
X        {
X      LIGHTAVG = uvalues[k++].uval.ival;
X      Ambient  = uvalues[k++].uval.ival;
X      if (Ambient >= 100) Ambient = 100;
X      if (Ambient <= 0) Ambient = 0;
X        }
X   }
X
X   if (Targa_Out && !RAY)
X   {
X    haze  =  uvalues[k++].uval.ival;
X    if (haze >= 100) haze = 100;
X    if (haze <= 0) haze = 0;
X        strcpy(light_name,uvalues[k++].uval.sval);
X        /* In case light_name conflicts with an existing name it is checked
X            again in line3d */
X        k++;
X        back_color[0] = (char)uvalues[k++].uval.ival % 255;
X        back_color[1] = (char)uvalues[k++].uval.ival % 255;
X        back_color[2] = (char)uvalues[k++].uval.ival % 255;
X        Targa_Overlay = uvalues[k].uval.ch.val;
X   }
X   return(0);
X}
X
X/* --------------------------------------------------------------------- */
X
X
Xstatic int check_mapfile()
X{
X   extern BYTE dacbox[256][3];
X   extern BYTE olddacbox[256][3];
X   int askflag = 0;
X   int i,oldhelpmode;
X   strcpy(temp1,"*");
X   if (mapset)
X      strcpy(temp1,MAP_name);
X   if (!(glassestype == 1 || glassestype == 2))
X      askflag = 1;
X   else
X      strcpy(temp1,funnyglasses_map_name);
X   while (TRUE) {
X      if (askflag) {
X     oldhelpmode = helpmode;
X     helpmode = -1;
X     i = field_prompt(0,"\
XEnter name of .MAP file to use,\n\
Xor '*' to use palette from the image to be loaded.",
X         NULL,temp1,60,NULL);
X     helpmode = oldhelpmode;
X     if (i < 0)
X        return(-1);
X        if (temp1[0] == '*') {
X            mapset = 0;
X            break;
X            }
X        }
X        memcpy(olddacbox,dacbox,256*3); /* save the DAC */
X      i = ValidateLuts(temp1);
X      memcpy(dacbox,olddacbox,256*3); /* restore the DAC */
X      if (i != 0) { /* Oops, somethings wrong */
X         askflag = 1;
X     continue;
X     }
X      mapset = 1;
X      strcpy (MAP_name,temp1);
X      break;
X      }
X   return(0);
X}
X
Xstatic int get_funny_glasses_params()
X{
X   static char far hdg[]={"Funny Glasses Parameters"};
X   char far *prompts3d[10];
X
X   struct fullscreenvalues uvalues[10];
X
X   int k;
X   int oldhelpmode;
X
X   /* defaults */
X   if(ZVIEWER == 0)
X      ZVIEWER = 150;
X   if(eyeseparation == 0)
X   {
X      if(fractype==IFS3D || fractype==LLORENZ3D || fractype==FPLORENZ3D)
X      {
X     eyeseparation =  2;
X     xadjust       = -2;
X      }
X      else
X      {
X     eyeseparation =  3;
X     xadjust       =  0;
X      }
X   }
X
X   if(glassestype == 1)
X      strcpy(funnyglasses_map_name,Glasses1Map);
X   else if(glassestype == 2)
X   {
X      if(FILLTYPE == -1)
X     strcpy(funnyglasses_map_name,"grid.map");
X      else
X     strcpy(funnyglasses_map_name,"glasses2.map");
X   }
X
X   k = -1;
X   LOADPROMPTS3D("Interocular distance (as % of screen)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival= eyeseparation;
X
X   LOADPROMPTS3D("Convergence adjust (positive = spread greater)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = xadjust;
X
X   LOADPROMPTS3D("Left  red image crop (% of screen)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = red_crop_left;
X
X   LOADPROMPTS3D("Right red image crop (% of screen)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = red_crop_right;
X
X   LOADPROMPTS3D("Left  blue image crop (% of screen)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = blue_crop_left;
X
X   LOADPROMPTS3D("Right blue image crop (% of screen)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = blue_crop_right;
X
X   LOADPROMPTS3D("Red brightness factor (%)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = red_bright;
X
X   LOADPROMPTS3D("Blue brightness factor (%)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = blue_bright;
X
X   if(glassestype == 1 || glassestype == 2)
X   {
X      LOADPROMPTS3D("Map File name");
X      uvalues[k].type = 's';
X      strcpy(uvalues[k].uval.sval,funnyglasses_map_name);
X   }
X
X   oldhelpmode = helpmode;
X   helpmode = HELP3DGLASSES;
X   k = fullscreen_prompt(hdg,k+1,prompts3d,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (k < 0)
X      return(-1);
X
X   k = 0;
X   eyeseparation   =  uvalues[k++].uval.ival;
X   xadjust       =  uvalues[k++].uval.ival;
X   red_crop_left   =  uvalues[k++].uval.ival;
X   red_crop_right  =  uvalues[k++].uval.ival;
X   blue_crop_left  =  uvalues[k++].uval.ival;
X   blue_crop_right =  uvalues[k++].uval.ival;
X   red_bright       =  uvalues[k++].uval.ival;
X   blue_bright       =  uvalues[k++].uval.ival;
X
X   if(glassestype == 1 || glassestype == 2)
X      strcpy(funnyglasses_map_name,uvalues[k].uval.sval);
X   return(0);
X}
SHAR_EOF
$TOUCH -am 1028230093 prompts1.c &&
chmod 0644 prompts1.c ||
echo "restore of prompts1.c failed"
set `wc -c prompts1.c`;Wc_c=$1
if test "$Wc_c" != "63669"; then
    echo original size 63669, current size $Wc_c
fi
# ============= prompts2.c ==============
echo "x - extracting prompts2.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > prompts2.c &&
X/*
X    Various routines that prompt for things.
X    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#include <ctype.h>
X#ifndef XFRACT
X#include <dos.h>
X#elif !defined(__386BSD__)
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <sys/dir.h>
X#endif
X#ifdef __TURBOC__
X#include <alloc.h>
X#elif !defined(__386BSD__)
X#include <malloc.h>
X#endif
X
X#ifdef __hpux
X#include <sys/param.h>
X#define getwd(a) getcwd(a,MAXPATHLEN)
X#endif
X
X#include "fractint.h"
X#include "fractype.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* Routines defined in prompts1.c */
X
Xextern    int prompt_checkkey(int curkey);
Xextern    long get_file_entry(int,char *,char *,char *,char *);
X
X/* Routines used in prompts1.c */
X
X    int get_corners(void);
X    int edit_ifs_params(void );
X    int lccompare(VOIDCONSTPTR, VOIDCONSTPTR); /* Needed in prompts1.c PAV */
X
X/* Routines in this module    */
X
Xstatic    int findfirst(char *path);
Xstatic  int check_f6_key(int curkey,int choice);
Xstatic    int findnext(void );
X    int splitpath(char *template,char *drive,char *dir,char *fname,char *ext);
X        int makepath(char *template,char *drive,char *dir,char *fname,char *ext);
Xstatic    void fix_dirname(char *dirname);
Xstatic    int expand_dirname(char *dirname,char *drive);
Xstatic    int filename_speedstr(int, int, int, char *, int);
Xstatic    int isadirectory(char *s);
Xstatic  int check_f6_key(int curkey,int choice);
X
Xextern int dotmode;
Xextern int orbit_delay;
Xextern char diskfilename[];
X
Xextern char *fract_dir1, *fract_dir2;
X
X#ifndef XFRACT
Xextern int strncasecmp(char *s,char *t,int ct);
X#endif
X
Xextern char temp1[256];   /* temporary strings          */
X
Xextern    double    xxmin,xxmax;    /* initial corner values    */
Xextern    double    yymin,yymax;    /* initial corner values    */
Xextern    BYTE usemag;
X
Xextern    int AntiAliasing;
Xextern double zzmin, zzmax, ttmin, ttmax;
Xextern int Transparent3D;
X
Xextern    double    xx3rd,yy3rd;    /* initial corner values    */
Xextern    int    invert;     /* non-zero if inversion active */
Xextern    double    inversion[3];    /* radius, xcenter, ycenter */
Xextern    int    pot16bit;
Xextern    int    disk16bit;
Xextern    double    potparam[3];    /* three potential parameters*/
Xextern    int    fractype;    /* if == 0, use Mandelbrot  */
Xextern    char    usr_floatflag;    /* floating-point fractals? */
Xextern    int    maxit;        /* try this many iterations */
Xextern    int    inside;     /* inside color */
Xextern    int    fillcolor;     /* fill color */
Xextern    int    outside;    /* outside color */
Xextern    int    finattract;    /* finite attractor switch */
Xextern    char    savename[80];    /* save files using this name */
Xextern    int    decomp[];    /* decomposition parameters */
Xextern    int    usr_distest;    /* distance estimator option */
Xextern    int    distestwidth;
Xextern    char    usr_stdcalcmode; /* '1', '2', 'g', 'b' */
Xextern    char    overwrite;     /* overwrite= flag */
Xextern    int    soundflag;    /* sound option */
Xextern    int    LogFlag;    /* non-zero if logarithmic palettes */
Xextern    int    usr_biomorph;    /* Biomorph flag */
X#if 0
X//extern    long    xmin, xmax, ymin, ymax; /* screen corner values */
X#endif
Xextern    int    xdots, ydots;    /* coordinates of dots on the screen  */
Xextern    int    colors;     /* maximum colors available */
Xextern    int    row, col;
Xextern    int    viewwindow;
Xextern    float    viewreduction;
Xextern    int    viewcrop;
Xextern    float    finalaspectratio;
Xextern    int    viewxdots,viewydots;
Xextern    int    textcbase;
Xextern    int    textrow,textcol;
Xextern    int    resave_flag;    /* resaving after a timed save */
Xextern    int    started_resaves;
Xextern    char    boxy[];
Xextern    int    rotate_lo,rotate_hi;
Xextern    int    rangeslen;
Xextern float  screenaspect;
X
Xextern  int  cmdarg(char *,int);
X
Xextern char CommandFile[];
Xextern char CommandName[];
Xextern float far *ifs_defn;
Xextern int ifs_type;
Xextern int ifs_changed;
Xextern int initbatch;        /* 1 if batch run (no kbd)  */
X
X/* speed key state values */
X#define MATCHING     0    /* string matches list - speed key mode */
X#define TEMPLATE    -2    /* wild cards present - buiding template */
X#define SEARCHPATH    -3    /* no match - building path search name */
X
X#define   FILEATTR     0x37       /* File attributes; select all but volume labels */
X#define   HIDDEN     2
X#define   SYSTEM     4
X#define   SUBDIR     16
X#define   MAXNUMFILES     300
X
Xstruct                   /* Allocate DTA and define structure */
X{
X     char path[21];            /* DOS path and filespec */
X     char attribute;            /* File attributes wanted */
X     int  ftime;            /* File creation time */
X     int  fdate;            /* File creation date */
X     long size;             /* File size in bytes */
X     char filename[13];         /* Filename and extension */
X} DTA;                   /* Disk Transfer Area */
X
X#define GETFORMULA 0
X#define GETLSYS    1
X#define GETIFS       2
X#define GETPARM    3
X
X/* --------------------------------------------------------------------- */
Xextern char s_iter[];
Xextern char s_real[];
Xextern char s_mult[];
Xextern char s_sum[];
Xextern char s_imag[];
Xextern char s_zmag[];
Xextern char s_bof60[];
Xextern char s_bof61[];
Xextern char s_maxiter[];
Xextern char s_epscross[];
Xextern char s_startrail[];
Xextern char s_normal[];
Xextern char s_period[];
X
Xchar commandmask[13] = {"*.par"};
X
Xvoid prompts2_overlay() { }    /* for restore_active_ovly */
X
X#if 0
X/* --------------------------------------------------------------------- */
X
Xextern int promptfkeys;
X
Xint edit_ifs_params()    /* prompt for IFS params */
X{
X   int totcols;
X   int i, j, k, numlines, ret;
X   FILE *tempfile;
X   char msg[81];
X   char filename[81];
X   float ftemp;
X   int oldhelpmode;
X   int low, hi;
X
X   if (!ifs_defn && !ifsload())
X      return(-1);
X
X   totcols = (ifs_type == 0) ? IFSPARM : IFS3DPARM;
X   ret = 0;
X   oldhelpmode = helpmode;
X   helpmode = HT_IFS;
X
X   low = 0;
X
X   for ( ;; ) {
Xstatic char far ifshdg2[]={"2D IFS Parameters"};
Xstatic char far ifshdg3[]={"3D IFS Parameters"};
Xstatic char far ifsparmmsg1[]={"#    a     b     c     d     e     f"};
Xstatic char far ifsparmmsg2[]={"     g     h     i     j     k     l"};
Xstatic char far ifsprompt[]={"\
XEnter the number of the line you want to edit,\n\
XS to save, F6 for corners, or ENTER to end ==>"};
X      int leftcol,promptrow,promptcol;
X#define IFS_NUM 12
X
X      for (numlines = 0; numlines < NUMIFS; numlines++) /* find the first zero entry */
X     if (ifs_defn[(numlines * totcols) + totcols - 1] <= 0.0001) break;
X
X      helptitle();
X      setattr(1,0,C_PROMPT_BKGRD,24*80); /* init rest of screen to background */
X      putstringcenter(2,0,80,C_GENERAL_HI,(ifs_type == 0) ? ifshdg2 : ifshdg3);
X      leftcol = (ifs_type == 0) ? 15 : 0;
X      putstring(4,leftcol+1,C_GENERAL_HI,ifsparmmsg1);
X      if (ifs_type != 0)
X     putstring(-1,-1,C_GENERAL_HI,ifsparmmsg2);
X      putstring(-1,-1,C_GENERAL_HI,"   prob \n\n");
X
X      hi = low+IFS_NUM;
X      if (hi>numlines) hi = numlines;
X      for (i = low; i < hi; i++) {
X     sprintf(msg,"%2d", i+1);
X     putstring(5+i-low,leftcol,C_GENERAL_HI,msg);
X     for (j = 0; j < totcols; j++) {
X        sprintf(msg,"%6.2f",ifs_defn[(i*totcols)+j]);
X        putstring(-1,-1,C_GENERAL_MED,msg);
X        }
X     }
X      if (hi<numlines) {
X     putstring(5+IFS_NUM,leftcol,C_GENERAL_HI,"(more)");
X      }
X
X      textcbase = 14;
X      putstring(5+i-low+1,0,C_GENERAL_HI,ifsprompt);
X      promptrow = textrow;
X      promptcol = textcol + textcbase + 1;
X      temp1[0] = textcbase = 0;
X      promptfkeys = 1<<6;
X      i = input_field(0,C_GENERAL_INPUT,temp1,2,promptrow,promptcol,
X          prompt_checkkey);
X      if (i<0) {
X      break;
X      } else if (i==PAGE_UP) {
X      low -= IFS_NUM;
X      if (low<0) low=0;
X      } else if (i==UP_ARROW) {
X      low -= 1;
X      if (low<0) low=0;
X      } else if (i==DOWN_ARROW) {
X      low += 1;
X      if (low+IFS_NUM>numlines) low=numlines-IFS_NUM;
X      if (low<0) low=0;
X      } else if (i==PAGE_DOWN) {
X      low += IFS_NUM;
X      if (low+IFS_NUM>numlines) low=numlines-IFS_NUM;
X      if (low<0) low=0;
X      } else if (i==F6) {
X      if (get_corners()) {
X          ret = 1;
X      }
X      } else if (i==0) {
X      if (temp1[0]==0) break;
X      } else {
X      continue;
X      }
X
X      putstring(promptrow,promptcol,C_GENERAL_HI,temp1);
X      if (temp1[0] == 's' || temp1[0] == 'S') {
X     stackscreen();
X     filename[0] = 0;
X     i = field_prompt(0,"Enter the name of the .IFS file to save:",
X             NULL,filename,60,NULL);
X     unstackscreen();
X     if (i != -1) {
X        if (strchr(filename,'.') == NULL)
X           strcat(filename,".ifs");
X        if ((tempfile=fopen(filename,"w")) != NULL) {
X           for (i = 0; i < numlines; i++) {
X          for (j = 0; j < totcols; j++)
X             fprintf(tempfile, "%6.2f", (float)ifs_defn[(i*totcols)+j]);
X          fprintf(tempfile, "\n");
X          }
X           fclose(tempfile);
X           ifs_changed = 0;
X           }
X        else {
X           static char far msg[]={"Could not create file"};
X           stopmsg(0,msg);
X           }
X        }
X     continue;
X     }
X      i = atoi(temp1) - 1;
X      if (i >= 0 && i < numlines) {
X     for (j = 0; j < totcols; j++) {
X        if (j < totcols-1)
X           sprintf(msg,"Parameter %c",'a'+j);
X        else
X           sprintf(msg,"Probability");
X        putstring(promptrow+2,25,C_GENERAL_HI,msg);
X        sprintf(temp1,"%6.2f",(float)ifs_defn[k=(i*totcols)+j]);
X        if (input_field(1,C_GENERAL_INPUT,temp1,6,
X                textrow,textcol+1,NULL) < 0)
X           break;
X        if (ifs_defn[k] != (ftemp = atof(temp1))) {
X           ifs_defn[k] = ftemp;
X           ret = ifs_changed = 1;
X           }
X        }
X     memset(msg,' ',80); msg[81] = 0;
X     putstring(promptrow+2,0,C_PROMPT_BKGRD,msg);
X     }
X      }
X
X   helpmode = oldhelpmode;
X   return(ret);
X}
X#endif
X/* --------------------------------------------------------------------- */
X/*
X    get_toggles() is called from FRACTINT.C whenever the 'x' key
X    is pressed.  This routine prompts for several options,
X    sets the appropriate variables, and returns the following code
X    to the calling routine:
X
X    -1  routine was ESCAPEd - no need to re-generate the image.
X     0  nothing changed, or minor variable such as "overwrite=".
X        No need to re-generate the image.
X     1  major variable changed (such as "inside=").  Re-generate
X        the image.
X
X    Finally, remember to insert variables in the list *and* check
X    for them in the same order!!!
X*/
X#define LOADCHOICES(X)     {\
X   static char far tmp[] = { X };\
X   choices[++k]= tmp;\
X   }
Xint get_toggles()
X{
X   static char far hdg[]={"        Basic Options\n\
X(not all combinations make sense)"};
X   char far *choices[20];
X   int oldhelpmode;
X   char prevsavename[81];
X   struct fullscreenvalues uvalues[25];
X   int i, j, k;
X   char old_usr_stdcalcmode;
X   int old_maxit,old_inside,old_outside,old_soundflag;
X   int old_logflag,old_biomorph,old_decomp;
X   int old_fillcolor;
X   static char *calcmodes[] ={"1","2","g","b","t"};
X   static char *soundmodes[5]={"yes","no","x","y","z"};
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X
X   k = -1;
X
X   LOADCHOICES("Passes (1, 2, g[uessing], b[oundary trace], t[esseral])");
X   uvalues[k].type = 'l';
X   uvalues[k].uval.ch.vlen = 3;
X   uvalues[k].uval.ch.llen = sizeof(calcmodes)/sizeof(*calcmodes);
X   uvalues[k].uval.ch.list = calcmodes;
X   uvalues[k].uval.ch.val = (usr_stdcalcmode == '1') ? 0
X              : (usr_stdcalcmode == '2') ? 1
X                          : (usr_stdcalcmode == 'g') ? 2
X                          : (usr_stdcalcmode == 'b') ? 3 :4 ;
X   old_usr_stdcalcmode = usr_stdcalcmode;
X
X   LOADCHOICES("Floating Point Algorithm");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = usr_floatflag;
X
X   LOADCHOICES("Maximum Iterations (2 to 32767)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_maxit = maxit;
X
X   LOADCHOICES("Inside Color (<nnn>,maxiter,zmag,bof60,bof61,epscr,star,per)");
X   uvalues[k].type = 's';
X   if(inside == -59)
X      strcpy(uvalues[k].uval.sval,s_zmag);
X   else if(inside == -60)
X      strcpy(uvalues[k].uval.sval,s_bof60);
X   else if(inside == -61)
X      strcpy(uvalues[k].uval.sval,s_bof61);
X   else if(inside == -100)
X      strcpy(uvalues[k].uval.sval,s_epscross);
X   else if(inside == -101)
X      strcpy(uvalues[k].uval.sval,s_startrail);
X   else if(inside == -102)
X      strcpy(uvalues[k].uval.sval,s_period);
X   else if(inside == -1)
X      strcpy(uvalues[k].uval.sval,s_maxiter);
X   else
X      sprintf(uvalues[k].uval.sval,"%d",inside);
X   old_inside = inside;
X
X   LOADCHOICES("Outside Color (<nnn>,iter,real,imag,mult,summ)");
X   uvalues[k].type = 's';
X   if(outside == -1)
X      strcpy(uvalues[k].uval.sval,s_iter);
X   else if(outside == -2)
X      strcpy(uvalues[k].uval.sval,s_real);
X   else if(outside == -3)
X      strcpy(uvalues[k].uval.sval,s_imag);
X   else if(outside == -4)
X      strcpy(uvalues[k].uval.sval,s_mult);
X   else if(outside == -5)
X      strcpy(uvalues[k].uval.sval,s_sum);
X   else
X      sprintf(uvalues[k].uval.sval,"%d",outside);
X   old_outside = outside;
X
X   LOADCHOICES("Savename (.GIF implied)");
X   uvalues[k].type = 's';
X   strcpy(prevsavename,savename);
X   strcpy(uvalues[k].uval.sval,savename);
X
X   LOADCHOICES("File Overwrite ('overwrite=')");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = overwrite;
X
X   LOADCHOICES("Sound (no, yes, x, y, z)");
X   uvalues[k].type = 'l';
X   uvalues[k].uval.ch.vlen = 3;
X   uvalues[k].uval.ch.llen = 5;
X   uvalues[k].uval.ch.list = soundmodes;
X   uvalues[k].uval.ch.val = 1 + (old_soundflag = soundflag);
X
X   if (rangeslen == 0) {
X      LOADCHOICES("Log Palette (0=no,1=yes,-1=old,+n=cmprsd,-n=sqrt)");
X      uvalues[k].type = 'i';
X      }
X   else {
X      LOADCHOICES("Log Palette (n/a, ranges= parameter is in effect)");
X      uvalues[k].type = '*';
X      }
X   uvalues[k].uval.ival = old_logflag = LogFlag;
X
X   LOADCHOICES("Biomorph Color (-1 means OFF)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_biomorph = usr_biomorph;
X
X   LOADCHOICES("Decomp Option (2,4,8,..,256, 0=OFF)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_decomp = decomp[0];
X
X   LOADCHOICES("Fill Color (normal,<nnn>) (works with passes=t and =b)");
X   uvalues[k].type = 's';
X   if(fillcolor < 0)
X      strcpy(uvalues[k].uval.sval,s_normal);
X   else
X      sprintf(uvalues[k].uval.sval,"%d",fillcolor);
X   old_fillcolor = fillcolor;
X
X   LOADCHOICES("Orbit delay (0 = none)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = orbit_delay;
X
X/*
X   LOADCHOICES("Antialiasing (0 to 8)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = AntiAliasing;
X*/
X
X   oldhelpmode = helpmode;
X   helpmode = HELPXOPTS;
X   i = fullscreen_prompt(hdg,k+1,choices,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (i < 0) {
X      EXIT_OVLY;
X      return(-1);
X      }
X
X   /* now check out the results (*hopefully* in the same order <grin>) */
X   k = -1;
X   j = 0;   /* return code */
X
X   usr_stdcalcmode = calcmodes[uvalues[++k].uval.ch.val][0];
X   if (old_usr_stdcalcmode != usr_stdcalcmode) j = 1;
X
X   if (uvalues[++k].uval.ch.val != usr_floatflag) {
X      usr_floatflag = uvalues[k].uval.ch.val;
X      j = 1;
X      }
X
X   ++k;
X   maxit = uvalues[k].uval.ival;
X   if (maxit < 2) maxit = 2;
X
X/* 'maxit' is an int so it is always <= 32767, MCP 12-3-91
X   if (maxit > 32767) maxit = 32767;
X*/
X
X   if (maxit != old_maxit) j = 1;
X
X   if(strncmp(strlwr(uvalues[++k].uval.sval),s_zmag,4)==0)
X      inside = -59;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_bof60,5)==0)
X      inside = -60;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_bof61,5)==0)
X      inside = -61;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_epscross,3)==0)
X      inside = -100;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_startrail,4)==0)
X      inside = -101;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_period,3)==0)
X      inside = -102;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_maxiter,5)==0)
X      inside = -1;
X   else
X      inside = atoi(uvalues[k].uval.sval);
X   if (inside != old_inside) j = 1;
X
X   if(strncmp(strlwr(uvalues[++k].uval.sval),s_real,4)==0)
X      outside = -2;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_imag,4)==0)
X      outside = -3;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_mult,4)==0)
X      outside = -4;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_sum,4)==0)
X      outside = -5;
X   else if(strncmp(strlwr(uvalues[k].uval.sval),s_iter,4)==0)
X      outside = -1;
X   else
X      outside = atoi(uvalues[k].uval.sval);
X   if (outside != old_outside) j = 1;
X
X   strcpy(savename,uvalues[++k].uval.sval);
X   if (strcmp(savename,prevsavename))
X      resave_flag = started_resaves = 0; /* forget pending increment */
X
X   overwrite = uvalues[++k].uval.ch.val;
X
X   soundflag = uvalues[++k].uval.ch.val - 1;
X   if (soundflag != old_soundflag && (soundflag > 1 || old_soundflag > 1))
X      j = 1;
X
X   LogFlag = uvalues[++k].uval.ival;
X   if (LogFlag != old_logflag) j = 1;
X
X   usr_biomorph = uvalues[++k].uval.ival;
X   if (usr_biomorph != old_biomorph) j = 1;
X
X   decomp[0] = uvalues[++k].uval.ival;
X   if (decomp[0] != old_decomp) j = 1;
X
X   if(strncmp(strlwr(uvalues[++k].uval.sval),s_normal,4)==0)
X      fillcolor = -1;
X   else
X      fillcolor = atoi(uvalues[k].uval.sval);
X   if (fillcolor != old_fillcolor) j = 1;
X
X   orbit_delay = uvalues[++k].uval.ival;
X
X/*
X   if(AntiAliasing != uvalues[++k].uval.ival) j = 1;
X   AntiAliasing = uvalues[k].uval.ival;
X   if(AntiAliasing < 0) AntiAliasing = 0;
X   if(AntiAliasing > 8) AntiAliasing = 8;
X*/
X
X   EXIT_OVLY;
X   return(j);
X}
X
X/*
X    get_toggles2() is similar to get_toggles, invoked by 'y' key
X*/
X
Xint get_toggles2()
X{
X   static char far hdg[]={"       Extended Options\n\
X(not all combinations make sense)"};
X   char far *choices[20];
X   int oldhelpmode;
X
X   struct fullscreenvalues uvalues[25];
X   int i, j, k;
X
X   int old_rotate_lo,old_rotate_hi;
X   int old_usr_distest,old_distestwidth;
X   double old_potparam[3],old_inversion[3];
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X
X   /* fill up the choices (and previous values) arrays */
X   k = -1;
X
X   LOADCHOICES("Look for finite attractor (0=no,>0=yes,<0=phase)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ch.val = finattract;
X
X   LOADCHOICES("Potential Max Color (0 means off)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_potparam[0] = potparam[0];
X
X   LOADCHOICES("          Slope");
X   uvalues[k].type = 'd';
X   uvalues[k].uval.dval = old_potparam[1] = potparam[1];
X
X   LOADCHOICES("          Bailout");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_potparam[2] = potparam[2];
X
X   LOADCHOICES("          16 bit values");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = pot16bit;
X
X   LOADCHOICES("Distance Estimator (0=off, <0=edge, >0=on):");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_usr_distest = usr_distest;
X
X   LOADCHOICES("          width factor:");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_distestwidth = distestwidth;
X
X
X
X   LOADCHOICES("Inversion radius or \"auto\" (0 means off)");
X   LOADCHOICES("          center X coordinate or \"auto\"");
X   LOADCHOICES("          center Y coordinate or \"auto\"");
X   k = k - 3;
X   for (i= 0; i < 3; i++) {
X      uvalues[++k].type = 's';
X      if ((old_inversion[i] = inversion[i]) == AUTOINVERT)
X     sprintf(uvalues[k].uval.sval,"auto");
X      else
X     sprintf(uvalues[k].uval.sval,"%g",inversion[i]);
X      }
X   LOADCHOICES("  (use fixed radius & center when zooming)");
X   uvalues[k].type = '*';
X
X   LOADCHOICES("Color cycling from color (0 ... 254)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_rotate_lo = rotate_lo;
X
X   LOADCHOICES("              to   color (1 ... 255)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = old_rotate_hi = rotate_hi;
X
X   oldhelpmode = helpmode;
X   helpmode = HELPYOPTS;
X   i = fullscreen_prompt(hdg,k+1,choices,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (i < 0) {
X      EXIT_OVLY;
X      return(-1);
X      }
X
X   /* now check out the results (*hopefully* in the same order <grin>) */
X   k = -1;
X   j = 0;   /* return code */
X
X   if (uvalues[++k].uval.ch.val != finattract) {
X      finattract = uvalues[k].uval.ch.val;
X      j = 1;
X      }
X
X   potparam[0] = uvalues[++k].uval.ival;
X   if (potparam[0] != old_potparam[0]) j = 1;
X
X   potparam[1] = uvalues[++k].uval.dval;
X   if (potparam[0] != 0.0 && potparam[1] != old_potparam[1]) j = 1;
X
X   potparam[2] = uvalues[++k].uval.ival;
X   if (potparam[0] != 0.0 && potparam[2] != old_potparam[2]) j = 1;
X
X   if (uvalues[++k].uval.ch.val != pot16bit) {
X      pot16bit = uvalues[k].uval.ch.val;
X      if (pot16bit) { /* turned it on */
X     if (potparam[0] != 0.0) j = 1;
X     }
X      else /* turned it off */
X     if (dotmode != 11) /* ditch the disk video */
X        enddisk();
X     else /* keep disk video, but ditch the fraction part at end */
X        disk16bit = 0;
X      }
X
X   ++k;
X   usr_distest = (uvalues[k].uval.ival > 32000) ? 32000 : uvalues[k].uval.ival;
X   if (usr_distest != old_usr_distest) j = 1;
X   ++k;
X   distestwidth = uvalues[k].uval.ival;
X   if (usr_distest && distestwidth != old_distestwidth) j = 1;
X
X   for (i = 0; i < 3; i++) {
X      if (uvalues[++k].uval.sval[0] == 'a' || uvalues[k].uval.sval[0] == 'A')
X     inversion[i] = AUTOINVERT;
X      else
X     inversion[i] = atof(uvalues[k].uval.sval);
X      if (old_inversion[i] != inversion[i]
X    && (i == 0 || inversion[0] != 0.0))
X     j = 1;
X      }
X   invert = (inversion[0] == 0.0) ? 0 : 3;
X   ++k;
X
X   rotate_lo = uvalues[++k].uval.ival;
X   rotate_hi = uvalues[++k].uval.ival;
X   if (rotate_lo < 0 || rotate_hi > 255 || rotate_lo > rotate_hi) {
X      rotate_lo = old_rotate_lo;
X      rotate_hi = old_rotate_hi;
X      }
X
X   EXIT_OVLY;
X   return(j);
X}
X
X/* --------------------------------------------------------------------- */
X/*
X    get_view_params() is called from FRACTINT.C whenever the 'v' key
X    is pressed.  Return codes are:
X    -1  routine was ESCAPEd - no need to re-generate the image.
X     0  minor variable changed.  No need to re-generate the image.
X     1  View changed.  Re-generate the image.
X*/
X
Xint get_view_params()
X{
X   static char far hdg[]={"View Window Options"};
X   char far *choices[8];
X
X   int oldhelpmode;
X   struct fullscreenvalues uvalues[25];
X   int i, k;
X   float old_viewreduction,old_aspectratio;
X   int old_viewwindow,old_viewcrop,old_viewxdots,old_viewydots;
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X   stackscreen();
X
X   old_viewwindow    = viewwindow;
X   old_viewcrop      = viewcrop;
X   old_viewreduction = viewreduction;
X   old_aspectratio   = finalaspectratio;
X   old_viewxdots     = viewxdots;
X   old_viewydots     = viewydots;
X
Xget_view_restart:
X   /* fill up the previous values arrays */
X   k = -1;
X
X   LOADCHOICES("Preview display? (no for full screen)");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = viewwindow;
X
X   LOADCHOICES("Auto window size reduction factor");
X   uvalues[k].type = 'f';
X   uvalues[k].uval.dval = viewreduction;
X
X   LOADCHOICES("Final media overall aspect ratio, y/x");
X   uvalues[k].type = 'f';
X   uvalues[k].uval.dval = finalaspectratio;
X
X   LOADCHOICES("Crop starting coordinates to new aspect ratio?");
X   uvalues[k].type = 'y';
X   uvalues[k].uval.ch.val = viewcrop;
X
X   LOADCHOICES("Explicit size x pixels (0 for auto size)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = viewxdots;
X
X   LOADCHOICES("              y pixels (0 to base on aspect ratio)");
X   uvalues[k].type = 'i';
X   uvalues[k].uval.ival = viewydots;
X
X   LOADCHOICES("");
X   uvalues[k].type = '*';
X
X   LOADCHOICES("Press F4 to reset view parameters to defaults.");
X   uvalues[k].type = '*';
X
X   oldhelpmode = helpmode;     /* this prevents HELP from activating */
X   helpmode = HELPVIEW;
X   i = fullscreen_prompt(hdg,k+1,choices,uvalues,0,16,NULL);
X   helpmode = oldhelpmode;     /* re-enable HELP */
X   if (i < 0) {
X      viewwindow    = old_viewwindow;
X      viewcrop        = old_viewcrop;
X      viewreduction = old_viewreduction;
X      finalaspectratio = old_aspectratio;
X      viewxdots     = old_viewxdots;
X      viewydots     = old_viewydots;
X      unstackscreen();
X      EXIT_OVLY;
X      return(-1);
X      }
X
X   if (i == F4) {
X      viewwindow = viewxdots = viewydots = 0;
X      viewreduction = 4.2;
X      viewcrop = 1;
X      finalaspectratio = screenaspect;
X      goto get_view_restart;
X      }
X
X   /* now check out the results (*hopefully* in the same order <grin>) */
X   k = -1;
X
X   viewwindow = uvalues[++k].uval.ch.val;
X
X   viewreduction = uvalues[++k].uval.dval;
X
X   if ((finalaspectratio = uvalues[++k].uval.dval) == 0)
X      finalaspectratio = screenaspect;
X
X   viewcrop = uvalues[++k].uval.ch.val;
X
X   viewxdots = uvalues[++k].uval.ival;
X   viewydots = uvalues[++k].uval.ival;
X
X   if (finalaspectratio != old_aspectratio && viewcrop)
X      aspectratio_crop(old_aspectratio,finalaspectratio);
X
X   i = 0;
X   if (viewwindow != old_viewwindow
X      || (viewwindow
X     && (  viewreduction != old_viewreduction
X        || finalaspectratio != old_aspectratio
X        || viewxdots != old_viewxdots
X        || (viewydots != old_viewydots && viewxdots) ) ) )
X      i = 1;
X
X   unstackscreen();
X   EXIT_OVLY;
X   return(i);
X}
X
X/*
X    get_cmd_string() is called from FRACTINT.C whenever the 'g' key
X    is pressed.  Return codes are:
X    -1  routine was ESCAPEd - no need to re-generate the image.
X     0  parameter changed, no need to regenerate
X    >0  parameter changed, regenerate
X*/
X
Xint get_cmd_string()
X{
X   int oldhelpmode;
X   int i;
X   char cmdbuf[61];
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X
X   oldhelpmode = helpmode;
X   helpmode = HELPCOMMANDS;
X   cmdbuf[0] = 0;
X   i = field_prompt(0,"Enter command string to use.",NULL,cmdbuf,60,NULL);
X   helpmode = oldhelpmode;
X   if (i >= 0 && cmdbuf[0] != 0)
X       i = cmdarg(cmdbuf, 2);
X
X   EXIT_OVLY;
X   return(i);
X}
X
X
X/* --------------------------------------------------------------------- */
X
Xint Distribution = 30, Offset = 0, Slope = 25;
Xlong con;
X
Xstatic char far sf1[] = {"Star Density in Pixels per Star"};
Xstatic char far sf2[] = {"Percent Clumpiness"};
Xstatic char far sf3[] = {"Ratio of Dim stars to Bright"};
Xstatic char far *starfield_prompts[] = {sf1,sf2,sf3};
X
Xstatic double starfield_values[4] = {
X    30.0,100.0,5.0,0.0
X    };
X
Xchar GreyFile[] = "altern.map";
X
Xint starfield(void)
X{
X   int c;
X   extern char busy;
X   busy = 1;
X   if (starfield_values[0] <   1.0) starfield_values[0] =   1.0;
X   if (starfield_values[0] > 100.0) starfield_values[0] = 100.0;
X   if (starfield_values[1] <   1.0) starfield_values[1] =   1.0;
X   if (starfield_values[1] > 100.0) starfield_values[1] = 100.0;
X   if (starfield_values[2] <   1.0) starfield_values[2] =   1.0;
X   if (starfield_values[2] > 100.0) starfield_values[2] = 100.0;
X
X   Distribution = (int)(starfield_values[0]);
X   con    = (long)(((starfield_values[1]) / 100.0) * (1L << 16));
X   Slope = (int)(starfield_values[2]);
X
X   if (ValidateLuts(GreyFile) != 0) {
X      static char far msg[]={"Unable to load ALTERN.MAP"};
X      stopmsg(0,msg);
X      busy = 0;
X      return(-1);
X      }
X   spindac(0,1);         /* load it, but don't spin */
X   for(row = 0; row < ydots; row++) {
X      for(col = 0; col < xdots; col++) {
X     if(keypressed()) {
X        buzzer(1);
X        busy = 0;
X        return(1);
X        }
X     c = getcolor(col, row);
X         if(c == inside)
X            c = colors-1;
X     putcolor(col, row, GausianNumber(c, colors));
X      }
X   }
X   buzzer(0);
X   busy = 0;
X   return(0);
X}
X
Xint get_starfield_params(void) {
X   static char far hdg[]={"Starfield Parameters"};
X   struct fullscreenvalues uvalues[3];
X   int oldhelpmode, status;
X   int i;
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X
X   if(colors < 255) {
X      static char far msg[]={"starfield requires 256 color mode"};
X      stopmsg(0,msg);
X
X      EXIT_OVLY;
X      return(-1);
X   }
X   for (i = 0; i < 3; i++) {
X      uvalues[i].uval.dval = starfield_values[i];
X      uvalues[i].type = 'f';
X   }
X   stackscreen();
X   oldhelpmode = helpmode;
X   helpmode = HELPSTARFLD;
X   i = fullscreen_prompt(hdg,3,starfield_prompts,uvalues,0,0,NULL);
X   helpmode = oldhelpmode;
X   if (i < 0) {
X      unstackscreen();
X      EXIT_OVLY;
X      return(-1);
X      }
X   unstackscreen();
X
X   for (i = 0; i < 3; i++)
X      starfield_values[i] = uvalues[i].uval.dval;
X
X   EXIT_OVLY;
X   return(0);
X}
X
Xint get_a_number(double *x, double *y)
X{
X   static char far hdg[]={"Set Cursor Coordinates"};
X   double x1,y2;
X   char far *choices[2];
X
X   int oldhelpmode;
X   struct fullscreenvalues uvalues[2];
X   int i, k;
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X   stackscreen();
X
X   /* fill up the previous values arrays */
X   k = -1;
X
X   LOADCHOICES("X coordinate at cursor");
X   uvalues[k].type = 'd';
X   uvalues[k].uval.dval = *x;
X
X   LOADCHOICES("Y coordinate at cursor");
X   uvalues[k].type = 'd';
X   uvalues[k].uval.dval = *y;
X
X   i = fullscreen_prompt(hdg,k+1,choices,uvalues,0,25,NULL);
X   if (i < 0) {
X      unstackscreen();
X      EXIT_OVLY;
X      return(-1);
X      }
X
X   /* now check out the results (*hopefully* in the same order <grin>) */
X   k = -1;
X
X   *x = uvalues[++k].uval.dval;
X   *y = uvalues[++k].uval.dval;
X
X   unstackscreen();
X   EXIT_OVLY;
X   return(i);
X}
X
X/* --------------------------------------------------------------------- */
X
Xint get_commands()        /* execute commands from file */
X{
X   int ret;
X   FILE *parmfile;
X   long point;
X   int oldhelpmode;
X   ENTER_OVLY(OVLY_PROMPTS2);
X   ret = 0;
X   oldhelpmode = helpmode;
X   helpmode = HELPPARMFILE;
X   if ((point = get_file_entry(GETPARM,"Parameter Set",
X                   commandmask,CommandFile,CommandName)) >= 0
X     && (parmfile = fopen(CommandFile,"rb"))) {
X      fseek(parmfile,point,SEEK_SET);
X      ret = load_commands(parmfile);
X      }
X   helpmode = oldhelpmode;
X   EXIT_OVLY;
X   return(ret);
X}
X
X/* --------------------------------------------------------------------- */
X
Xvoid goodbye()            /* we done.  Bail out */
X{
X   static char far goodbyemessage[]={"   Thank You for using FRACTINT"};
X   extern BYTE exitmode;
X   extern int mode7text;
X   extern int made_dsktemp;
X#ifndef XFRACT
X   union REGS r;
X#endif
X
X#ifdef WINFRACT
X   return;
X#endif
X
X   setvideotext();
X#ifdef XFRACT
X   UnixDone();
X   printf("\n\n\n%s\n",goodbyemessage); /* printf takes far pointer */
X#else
X   r.h.al = (mode7text == 0) ? exitmode : 7;
X   r.h.ah = 0;
X   int86(0x10, &r, &r);
X   printf("\n\n\n%Fs\n",goodbyemessage); /* printf takes far pointer */
X#endif
X   movecursor(6,0);
X   discardgraphics(); /* if any emm/xmm tied up there, release it */
X   stopslideshow();
X#ifndef XFRACT
X   if (made_dsktemp)
X      remove(diskfilename);
X#endif
X   end_help();
X   if (initbatch == 3) /* exit with error code for batch file */
X     exit(2);
X   else if (initbatch == 4)
X     exit(1);
X   else
X     exit(0);
X}
X
X
X/* --------------------------------------------------------------------- */
X
X#ifdef XFRACT
Xstatic char searchdir[FILE_MAX_DIR];
Xstatic char searchname[FILE_MAX_PATH];
Xstatic char searchext[FILE_MAX_EXT];
Xstatic DIR *currdir = NULL;
X#endif
Xstatic int  findfirst(char *path)       /* Find 1st file (or subdir) meeting path/filespec */
X{
X#ifndef XFRACT
X     union REGS regs;
X     regs.h.ah = 0x1A;           /* Set DTA to filedata */
X     regs.x.dx = (unsigned)&DTA;
X     intdos(®s, ®s);
X     regs.h.ah = 0x4E;           /* Find 1st file meeting path */
X     regs.x.dx = (unsigned)path;
X     regs.x.cx = FILEATTR;
X     intdos(®s, ®s);
X     return(regs.x.ax);        /* Return error code */
X#else
X     if (currdir != NULL) {
X         closedir(currdir);
X         currdir = NULL;
X     }
X     splitpath(path,NULL,searchdir,searchname,searchext);
X     if (searchdir[0]=='\0') {
X         currdir = opendir(".");
X     } else {
X         currdir = opendir(searchdir);
X     }
X     if (currdir==NULL) {
X         return -1;
X     } else {
X         return findnext();
X     }
X#endif
X}
X
Xstatic int  findnext()        /* Find next file (or subdir) meeting above path/filespec */
X{
X#ifndef XFRACT
X     union REGS regs;
X     regs.h.ah = 0x4F;           /* Find next file meeting path */
X     regs.x.dx = (unsigned)&DTA;
X     intdos(®s, ®s);
X     return(regs.x.ax);
X#else
X#ifdef DIRENT
X     struct dirent *dirEntry;
X#else
X     struct direct *dirEntry;
X#endif
X     struct stat sbuf;
X     char thisname[FILE_MAX_PATH];
X     char tmpname[FILE_MAX_PATH];
X     char thisext[FILE_MAX_EXT];
X     while (1) {
X         dirEntry = readdir(currdir);
X         if (dirEntry == NULL) {
X             closedir(currdir);
X             currdir = NULL;
X             return -1;
X         } else if (dirEntry->d_ino != 0) {
X             splitpath(dirEntry->d_name,NULL,NULL,thisname,thisext);
X             if ((searchname[0]=='*' || strcmp(searchname,thisname)==0) &&
X                     (searchext[0]=='*' || strcmp(searchext,thisext)==0)) {
X                 strncpy(DTA.filename,dirEntry->d_name,20);
X                 DTA.filename[20]=='\0';
X                 strcpy(tmpname,searchdir);
X                 strcat(tmpname,"/");
X                 strcat(tmpname,dirEntry->d_name);
X                 stat(tmpname,&sbuf);
X                 if ((sbuf.st_mode&S_IFMT)==S_IFREG) {
X                     DTA.attribute = 0;
X                 } else if ((sbuf.st_mode&S_IFMT)==S_IFDIR) {
X                     DTA.attribute = SUBDIR;
X                 } else {
X                     continue;
X                 }
X                 DTA.size = sbuf.st_size;
X                 return 0;
X             }
X         }
X     }
X#endif
X}
X
Xint lccompare(VOIDCONSTPTR arg1, VOIDCONSTPTR arg2) /* for qsort */
X{
X   return(strncasecmp(*((char **)arg1),*((char **)arg2),40));
X}
X
Xstatic char *masks[] = {"*.pot","*.gif"};
Xstatic int speedstate;
X
Xint getafilename(char *hdg,char *template,char *flname)
X{
X   static char far instr[]={"Press F6 for default or environment directory"};
X   int masklen;
X   char filename[13];
X   char speedstr[81];
X   char tmpmask[FILE_MAX_PATH];   /* used to locate next file in list */
X   static int numtemplates = 1;
X   int i,j;
X   int out;
X   int retried;
X   struct CHOICE
X   {
X      char name[13];
X      char type;
X   }
X   *choices[MAXNUMFILES];
X   int attributes[MAXNUMFILES];
X   int filecount;   /* how many files */
X   int dircount;    /* how many directories */
X   int notroot;     /* not the root directory */
X
X   char drive[FILE_MAX_DRIVE];
X   char dir[FILE_MAX_DIR];
X   char fname[FILE_MAX_FNAME];
X   char ext[FILE_MAX_EXT];
X
X   ENTER_OVLY(OVLY_PROMPTS2);
X
X   /* steal existing array for "choices" */
X   choices[0] = (struct CHOICE *)boxy;
X   attributes[0] = 1;
X   for(i=1;i<MAXNUMFILES;i++)
X   {
X      choices[i] = choices[i-1] + 1;
X      attributes[i] = 1;
X   }
X
Xrestart:  /* return here if template or directory changes */
X
X   tmpmask[0] = 0;
X   if(flname[0] == 0)
X      strcpy(flname,DOTSLASH);
X   splitpath(flname ,drive,dir,fname,ext);
X   makepath(filename,""   ,"" ,fname,ext);
X   retried = 0;
Xretry_dir:
X   if (dir[0] == 0)
X      strcpy(dir,".");
X   expand_dirname(dir,drive);
X   makepath(tmpmask,drive,dir,"","");
X   fix_dirname(tmpmask);
X   if (retried == 0 && strcmp(dir,SLASH) && strcmp(dir,DOTSLASH))
X   {
X      tmpmask[(j = strlen(tmpmask) - 1)] = 0; /* strip trailing \ */
X      if (strchr(tmpmask,'*') || strchr(tmpmask,'?')
X    || findfirst(tmpmask) != 0
X    || (DTA.attribute & SUBDIR) == 0)
X      {
X         strcpy(dir,DOTSLASH);
X     ++retried;
X     goto retry_dir;
X      }
X      tmpmask[j] = SLASHC;
X   }
X   if(template[0])
X   {
X      numtemplates = 1;
X      splitpath(template,NULL,NULL,fname,ext);
X   }
X   else
X      numtemplates = sizeof(masks)/sizeof(masks[0]);
X   filecount = -1;
X   dircount  = 0;
X   notroot   = 0;
X   j = 0;
X   masklen = strlen(tmpmask);
X   strcat(tmpmask,"*.*");
X   out = findfirst(tmpmask);
X   while(out == 0 && filecount < MAXNUMFILES)
X   {
X      if((DTA.attribute & SUBDIR) && strcmp(DTA.filename,"."))
X      {
X#ifndef XFRACT
X     strlwr(DTA.filename);
X#endif
X     if(strcmp(DTA.filename,".."))
X            strcat(DTA.filename,SLASH);
X     strncpy(choices[++filecount]->name,DTA.filename,13);
X     choices[filecount]->name[12] = '\0';
X     choices[filecount]->type = 1;
X     dircount++;
X     if(strcmp(DTA.filename,"..")==0)
X        notroot = 1;
X      }
X      out = findnext();
X   }
X   tmpmask[masklen] = 0;
X   if(template[0])
X      makepath(tmpmask,drive,dir,fname,ext);
X   do
X   {
X      if(numtemplates > 1)
X     strcpy(&(tmpmask[masklen]),masks[j]);
X      out = findfirst(tmpmask);
X      while(out == 0 && filecount < MAXNUMFILES)
X      {
X     if(!(DTA.attribute & SUBDIR))
X     {
X        strlwr(DTA.filename);
X        strncpy(choices[++filecount]->name,DTA.filename,13);
X        choices[filecount]->type = 0;
X     }
X     out = findnext();
X      }
X   }
X   while (++j < numtemplates);
X   if (++filecount == 0)
X   {
X      strcpy(choices[filecount]->name,"*nofiles*");
X      choices[filecount]->type = 0;
X      ++filecount;
X   }
X   qsort(choices,filecount,sizeof(char *),lccompare); /* sort type list */
X   if(notroot == 0 && dir[0] && dir[0] != SLASHC) /* must be in root directory */
X   {
X      splitpath(tmpmask,drive,dir,fname,ext);
X      strcpy(dir,SLASH);
X      makepath(tmpmask,drive,dir,fname,ext);
X   }
X   if(numtemplates > 1)
X      strcat(tmpmask," *.pot");
X   strcpy(temp1,hdg);
X   strcat(temp1,"\nTemplate: ");
X   strcat(temp1,tmpmask);
X   strcpy(speedstr,filename);
X   if (speedstr[0] == 0)
X   {
X      for (i=0; i<filecount; i++) /* find first file */
X     if (choices[i]->type == 0)
X        break;
X      if (i >= filecount)
X     i = 0;
X   }
X   i = fullscreen_choice(8,temp1,NULL,instr,filecount,(char **)choices,
X          attributes,5,99,12,i,NULL,speedstr,filename_speedstr,check_f6_key);
X   if (i==-F6)
X   {
X      static int lastdir=0;
X      if (lastdir==0)
X      {
X     strcpy(dir,fract_dir1);
X      }
X      else
X      {
X     strcpy(dir,fract_dir2);
X      }
X      fix_dirname(dir);
X       makepath(flname,drive,dir,"","");
X       lastdir = 1-lastdir;
X       goto restart;
X   }
X   if (i < 0)
X   {
X      EXIT_OVLY;
X      return(-1);
X   }
X   if(speedstr[0] == 0 || speedstate == MATCHING)
X   {
X      if(choices[i]->type)
X      {
X     if(strcmp(choices[i]->name,"..") == 0) /* go up a directory */
X     {
X        if(strcmp(dir,DOTSLASH) == 0)
X           strcpy(dir,DOTDOTSLASH);
X        else
X        {
X           char *s;
X           if(s = strrchr(dir,SLASHC)) /* trailing slash */
X           {
X          *s = 0;
X          if(s = strrchr(dir,SLASHC))
X             *(s+1) = 0;
X           }
X        }
X     }
X     else  /* go down a directory */
X        strcat(dir,choices[i]->name);
X     fix_dirname(dir);
X     makepath(flname,drive,dir,"","");
X     goto restart;
X      }
X      splitpath(choices[i]->name,NULL,NULL,fname,ext);
X      makepath(flname,drive,dir,fname,ext);
X   }
X   else
X   {
X      if (speedstate == SEARCHPATH
X    && strchr(speedstr,'*') == 0 && strchr(speedstr,'?') == 0
X    && findfirst(speedstr) == 0
X    && (DTA.attribute & SUBDIR)) /* it is a directory */
X     speedstate = TEMPLATE;
X      if(speedstate == TEMPLATE)
X      {
X     /* extract from tempstr the pathname and template information,
X        being careful not to overwrite drive and directory if not
X        newly specified */
X     char drive1[FILE_MAX_DRIVE];
X     char dir1[FILE_MAX_DIR];
X     char fname1[FILE_MAX_FNAME];
X     char ext1[FILE_MAX_EXT];
X     splitpath(speedstr,drive1,dir1,fname1,ext1);
X     if(drive1[0])
X        strcpy(drive,drive1);
X     if(dir1[0])
X        strcpy(dir,dir1);
X     makepath(flname,drive,dir,fname1,ext1);
X     if(strchr(fname1,'*') || strchr(fname1,'?') ||
X         strchr(ext1  ,'*') || strchr(ext1  ,'?'))
X        makepath(template,"","",fname1,ext1);
X     else if(isadirectory(flname))
X        fix_dirname(flname);
X     goto restart;
X      }
X      else /* speedstate == SEARCHPATH */
X      {
X     char fullpath[80];
X      /* if (strchr(speedstr,'.') == NULL)
X        strcat(speedstr,".gif"); */
X     findpath(speedstr,fullpath);
X     if(fullpath[0])
X        strcpy(flname,fullpath);
X     else
X     {  /* failed, make diagnostic useful: */
X        strcpy(flname,speedstr);
X        if (strchr(speedstr,SLASHC) == NULL)
X        {
X           splitpath(speedstr,NULL,NULL,fname,ext);
X           makepath(flname,drive,dir,fname,ext);
X        }
X     }
X      }
X   }
X   EXIT_OVLY;
X   return(0);
X}
X
Xstatic int check_f6_key(int curkey,int choice)
X{
X   if (curkey == F6)
X      return 0-F6;
X   return 0;
X}
X
Xstatic int filename_speedstr(int row, int col, int vid,
X                 char *speedstring, int speed_match)
X{
X   extern char speed_prompt[];
X   char *prompt;
X   if ( strchr(speedstring,':')
X     || strchr(speedstring,'*') || strchr(speedstring,'*')
X     || strchr(speedstring,'?')) {
X      speedstate = TEMPLATE;  /* template */
X      prompt = "File Template";
X      }
X   else if (speed_match) {
X      speedstate = SEARCHPATH; /* does not match list */
X      prompt = "Search Path for";
X      }
X   else {
X      speedstate = MATCHING;
X      prompt = speed_prompt;
X      }
X   putstring(row,col,vid,prompt);
X   return(strlen(prompt));
X}
X
Xstatic int isadirectory(char *s)
X{
X   if(strchr(s,'*') || strchr(s,'?'))
X      return(0); /* for my purposes, not a directory */
X   if(findfirst(s) != 0) /* couldn't find it */
X   {
X      /* any better ideas?? */
X      if(strchr(s,SLASHC)) /* we'll guess it is a directory */
X     return(1);
X      else
X     return(0);  /* no slashes - we'll guess it's a file */
X   }
X   else if(DTA.attribute & SUBDIR)
X      return(1);   /* we're SURE it's a directory */
X   else
X      return(0);
X}
X
X
X#ifndef XFRACT    /* This routine moved to unix.c so we can use it in hc.c */
Xint splitpath(char *template,char *drive,char *dir,char *fname,char *ext)
X{
X   int length;
X   int len;
X   int offset;
X   char *tmp;
X
X   if(drive)
X      drive[0] = 0;
X   if(dir)
X      dir[0]   = 0;
X   if(fname)
X      fname[0] = 0;
X   if(ext)
X      ext[0]   = 0;
X
X   if((length = strlen(template)) == 0)
X      return(0);
X   offset = 0;
X
X   /* get drive */
X   if(length >= 2)
X      if(template[1] == ':')
X      {
X     if(drive)
X     {
X        drive[0] = template[offset++];
X        drive[1] = template[offset++];
X        drive[2] = 0;
X     }
X     else
X     {
X        offset++;
X        offset++;
X     }
X      }
X
X   /* get dir */
X   if(offset < length)
X   {
X      tmp = strrchr(template,SLASHC);
X      if(tmp)
X      {
X     tmp++;  /* first character after slash */
X     len = tmp - &template[offset];
X     if(len >=0 && len < 80 && dir)
X        strncpy(dir,&template[offset],len);
X     if(len < 80 && dir)
X        dir[len] = 0;
X     offset += len;
X      }
X   }
X   else
X      return(0);
X
X   /* get fname */
X   if(offset < length)
X   {
X      tmp = strrchr(template,'.');
X      if(tmp < strrchr(template,SLASHC) || tmp < strrchr(template,':'))
X     tmp = 0; /* in this case the '.' must be a directory */
X      if(tmp)
X      {
X     tmp++; /* first character past "." */
X     len = tmp - &template[offset];
X     if((len > 0) && (offset+len < length) && fname)
X     {
X        strncpy(fname,&template[offset],len);
X        fname[len] = 0;
X     }
X     offset += len;
X     if((offset < length) && ext)
X        strcpy(ext,&template[offset]);
X      }
X      else if((offset < length) && fname)
X     strcpy(fname,&template[offset]);
X   }
X   return(0);
X}
X#endif
X
Xmakepath(char *template,char *drive,char *dir,char *fname,char *ext)
X{
X#ifndef XFRACT
X   strcpy(template,drive);
X   strcat(template,dir);
X#else
X   strcpy(template,dir);
X#endif
X   strcat(template,fname);
X   strcat(template,ext);
X   return(0);
X}
X
X
X/* fix up directory names */
Xstatic void fix_dirname(char *dirname)
X{
X   int length;
X   /* scrub white space from end for safety */
X   length = strlen(dirname); /* index of last character */
X   while (--length >= 0 && isspace(dirname[length])) { }
X   dirname[++length] = 0;
X   /* make sure dirname ends with a slash */
X   if(length == 0 || dirname[length-1] != SLASHC)
X      strcat(dirname,SLASH);
X}
X
Xstatic int expand_dirname(char *dirname,char *drive)
X{
X   fix_dirname(dirname);
X   if (dirname[0] != SLASHC) {
X      char buf[81],curdir[81];
X#ifndef XFRACT
X      union REGS regs;
X      struct SREGS sregs;
X      curdir[0] = 0;
X      regs.h.ah = 0x47; /* get current directory */
X      regs.h.dl = 0;
X      if (drive[0] && drive[0] != ' ')
X     regs.h.dl = tolower(drive[0])-'a'+1;
X      regs.x.si = (unsigned int) &curdir[0];
X      segread(&sregs);
X      intdosx(®s, ®s, &sregs);
X#else
X      getwd(curdir);
X#endif
X      strcat(curdir,SLASH);
X      while (strncmp(dirname,DOTSLASH,2) == 0) {
X     strcpy(buf,&dirname[2]);
X     strcpy(dirname,buf);
X     }
X      while (strncmp(dirname,DOTDOTSLASH,3) == 0) {
X     char *s;
X     curdir[strlen(curdir)-1] = 0; /* strip trailing slash */
X     if (s = strrchr(curdir,SLASHC))
X        *s = 0;
X     strcat(curdir,SLASH);
X     strcpy(buf,&dirname[3]);
X     strcpy(dirname,buf);
X     }
X      strcpy(buf,dirname);
X      dirname[0] = 0;
X      if (curdir[0] != SLASHC)
X     strcpy(dirname,SLASH);
X      strcat(dirname,curdir);
X      strcat(dirname,buf);
X      }
X   return(0);
X}
X
X#define LOADPROMPTS(X)     {\
X   static char far tmp[] = { X };\
X   prompts[++nump]= tmp;\
X   }
X
Xint get_corners()
X{
X   struct fullscreenvalues values[15];
X   char far *prompts[15];
X   static char far xprompt[]={"          X"};
X   static char far yprompt[]={"          Y"};
X   static char far zprompt[]={"          Z"};
X   int i,nump,prompt_ret;
X   int cmag,transp3d;
X   double Xctr,Yctr,Mag;
X   BYTE ousemag;
X   double oxxmin,oxxmax,oyymin,oyymax,oxx3rd,oyy3rd;
X   double ozzmin,ozzmax,ottmin,ottmax;
X   /* note that hdg[15] is used for non-transparent heading: */
X   static char far hdg[]={"Transparent 3d Image Coordinates"};
X   int oldhelpmode;
X
X   transp3d = (Transparent3D && fractalspecific[fractype].orbitcalc == Formula);
X   oldhelpmode = helpmode;
X   ousemag = usemag;
X   oxxmin = xxmin; oxxmax = xxmax;
X   oyymin = yymin; oyymax = yymax;
X   oxx3rd = xx3rd; oyy3rd = yy3rd;
X   ozzmin = zzmin; ozzmax = zzmax;
X   ottmin = ttmin; ottmax = ttmax;
X
Xgc_loop:
X   for (i = 0; i < 15; ++i)
X      values[i].type = 'd'; /* most values on this screen are type d */
X   cmag = (!transp3d && usemag && cvtcentermag(&Xctr, &Yctr, &Mag));
X
X   nump = -1;
X   if (cmag) {
X      LOADPROMPTS("Center X");
X      values[nump].uval.dval = Xctr;
X      LOADPROMPTS("Center Y");
X      values[nump].uval.dval = Yctr;
X      LOADPROMPTS("Magnification");
X      values[nump].uval.dval = Mag;
X      LOADPROMPTS("");
X      values[nump].type = '*';
X      LOADPROMPTS("Press F7 to switch to \"corners\" mode");
X      values[nump].type = '*';
X      }
X
X   else {
X      LOADPROMPTS("Top-Left Corner");
X      values[nump].type = '*';
X      prompts[++nump] = xprompt;
X      values[nump].uval.dval = xxmin;
X      prompts[++nump] = yprompt;
X      values[nump].uval.dval = yymax;
X      if (transp3d) {
X         prompts[++nump] = zprompt;
X         values[nump].uval.dval = zzmin;
X      }
X      LOADPROMPTS("Bottom-Right Corner");
X      values[nump].type = '*';
X      prompts[++nump] = xprompt;
X      values[nump].uval.dval = xxmax;
X      prompts[++nump] = yprompt;
X      values[nump].uval.dval = yymin;
X      if (transp3d) {
X     prompts[++nump] = zprompt;
X     values[nump].uval.dval = zzmax;
X     }
X      if (transp3d) {
X     LOADPROMPTS("Time Step");
X     values[nump].type = '*';
X     LOADPROMPTS("          From");
X     values[nump].uval.dval = ttmin;
X     LOADPROMPTS("          To");
X     values[nump].uval.dval = ttmax;
X     }
X      else {
X     if (xxmin == xx3rd && yymin == yy3rd)
X        xx3rd = yy3rd = 0;
X     LOADPROMPTS("Bottom-left (zeros for top-left X, bottom-right Y)");
X     values[nump].type = '*';
X     prompts[++nump] = xprompt;
X     values[nump].uval.dval = xx3rd;
X     prompts[++nump] = yprompt;
X     values[nump].uval.dval = yy3rd;
X     LOADPROMPTS("Press F7 to switch to \"center-mag\" mode");
X     values[nump].type = '*';
X     }
X      }
X
X   LOADPROMPTS("Press F4 to reset to type default values");
X   values[nump].type = '*';
X
X   oldhelpmode = helpmode;
X   helpmode = HELPCOORDS;
X   prompt_ret = fullscreen_prompt((transp3d) ? hdg : &hdg[15],
X             nump+1, prompts, values, 0,
X             (transp3d) ? 0x10 : 0x90, /* function keys */
X             NULL);
X   helpmode = oldhelpmode;
X
X   if (prompt_ret < 0) {
X      usemag = ousemag;
X      xxmin = oxxmin; xxmax = oxxmax;
X      yymin = oyymin; yymax = oyymax;
X      xx3rd = oxx3rd; yy3rd = oyy3rd;
X      zzmin = ozzmin; zzmax = ozzmax;
X      ttmin = ottmin; ttmax = ottmax;
X      return -1;
X      }
X
X   if (prompt_ret == F4) { /* reset to type defaults */
X      xx3rd = xxmin = curfractalspecific->xmin;
X      xxmax        = curfractalspecific->xmax;
X      yy3rd = yymin = curfractalspecific->ymin;
X      yymax        = curfractalspecific->ymax;
X      if (viewcrop && finalaspectratio != screenaspect)
X     aspectratio_crop(screenaspect,finalaspectratio);
X      goto gc_loop;
X      }
X
X   if (cmag) {
X      if ( values[0].uval.dval != Xctr
X    || values[1].uval.dval != Yctr
X    || values[2].uval.dval != Mag) {
X     double radius,width;
X     radius = 1.0 / values[2].uval.dval;
X     width = radius * (1.0 / screenaspect);
X     yymax           = values[1].uval.dval + radius;
X     yy3rd = yymin = values[1].uval.dval - radius;
X     xxmax           = values[0].uval.dval + width;
X     xx3rd = xxmin = values[0].uval.dval - width;
X     }
X      }
X
X   else {
X      nump = 1;
X      xxmin = values[nump++].uval.dval;
X      yymax = values[nump++].uval.dval;
X      if (transp3d)
X     zzmin = values[nump++].uval.dval;
X      nump++;
X      xxmax = values[nump++].uval.dval;
X      yymin = values[nump++].uval.dval;
X      if (transp3d)
X     zzmax = values[nump++].uval.dval;
X      nump++;
X      if (transp3d) {
X     ttmin = values[nump++].uval.dval;
X     ttmax = values[nump++].uval.dval;
X     }
X      else {
X     xx3rd = values[nump++].uval.dval;
X     yy3rd = values[nump++].uval.dval;
X     if (xx3rd == 0 && yy3rd == 0) {
X        xx3rd = xxmin;
X        yy3rd = yymin;
X        }
X     }
X      }
X
X   if (prompt_ret == F7) { /* toggle corners/center-mag mode */
X      if (usemag == 0)
X     if (cvtcentermag(&Xctr, &Yctr, &Mag) == 0)
X     {
X        static char far msg[] =
X           {"Corners rotated or stretched, can't use center-mag"};
X        stopmsg(0,msg);
X     }
X     else
X        usemag = 1;
X      else
X     usemag = 0;
X      goto gc_loop;
X      }
X
X   return((xxmin == oxxmin && xxmax == oxxmax
X    && yymin == oyymin && yymax == oyymax
X    && xx3rd == oxx3rd && yy3rd == oyy3rd
X    && zzmin == ozzmin && zzmax == ozzmax
X    && ttmin == ottmin && ttmax == ottmax) ? 0 : 1);
X}
SHAR_EOF
$TOUCH -am 1028230093 prompts2.c &&
chmod 0644 prompts2.c ||
echo "restore of prompts2.c failed"
set `wc -c prompts2.c`;Wc_c=$1
if test "$Wc_c" != "49042"; then
    echo original size 49042, current size $Wc_c
fi
# ============= realdos.c ==============
echo "x - extracting realdos.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > realdos.c &&
X/*
X    Miscellaneous C routines used only in DOS Fractint.
X*/
X
X#include <string.h>
X#include <stdio.h>
X#ifndef XFRACT
X#include <dos.h>
X#include <io.h>
X#include <process.h>
X#endif
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <fcntl.h>
X#include <math.h>
X#include <stdlib.h>
X#include <ctype.h>
X#include "fractint.h"
X#include "fractype.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic int menu_checkkey(int curkey,int choice);
X
X/* uncomment following for book version */
X/* #define WAITE */
X
Xint release=1820; /* this has 2 implied decimals; increment it every synch */
Xint patchlevel=0; /* patchlevel for DOS version */
Xint xrelease=203;
X
X/* fullscreen_choice options */
X#define CHOICERETURNKEY 1
X#define CHOICEMENU    2
X#define CHOICEHELP    4
X
Xextern char diskfilename[];
Xextern int using_jiim;
Xextern int  xdots, ydots, sxdots, sydots, sxoffs, syoffs, vxdots;
Xextern int  colors;
Xextern int  dotmode;
Xextern int  oktoprint;
Xextern int  textrow, textcol, textrbase, textcbase;
Xextern int  debugflag;
Xextern int  fractype;
Xextern int  calc_status;
Xextern double param[];
Xextern int  tabmode;
Xextern int  color_dark,color_medium,color_bright;
Xextern int  lookatmouse;
Xextern int  gotrealdac;
Xextern int  reallyega;
Xextern SEGTYPE  extraseg;
Xextern int  active_system;
Xextern int  first_init;
Xextern int initbatch;        /* 1 if batch run (no kbd)  */
X
X
X/* int stopmsg(flags,message) displays message and waits for a key:
X     message should be a max of 9 lines with \n's separating them;
X       no leading or trailing \n's in message;
X       no line longer than 76 chars for best appearance;
X     flag options:
X       &1 if already in text display mode, stackscreen is not called
X      and message is displayed at (12,0) instead of (4,0)
X       &2 if continue/cancel indication is to be returned;
X      when not set, "Any key to continue..." is displayed
X      when set, "Escape to cancel, any other key to continue..."
X      -1 is returned for cancel, 0 for continue
X       &4 set to suppress buzzer
X       &8 for Fractint for Windows & parser - use a fixed pitch font
X      &16 for info only message (green box instead of red in DOS vsn)
X   */
Xint stopmsg (int flags, CHAR far *msg)
X{
X   int ret,toprow,color,savelookatmouse;
X   if (active_system == 0 /* DOS */
X     && first_init) {      /* & cmdfiles hasn't finished 1st try */
X      setvideotext();
X      buzzer(2);
X      putstring(0,0,15,"*** Error during startup:");
X      putstring(2,0,15,msg);
X      movecursor(8,0);
X#ifdef XFRACT
X      sleep(1);
X      UnixDone();
X#endif
X      exit(1);
X      }
X   if (initbatch == 1) { /* in batch mode */
X      initbatch = 4; /* used to set errorlevel */
X      return (-1);
X      }
X   ret = 0;
X   savelookatmouse = lookatmouse;
X   lookatmouse = -13;
X   if ((flags & 1))
X      blankrows(toprow=12,10,7);
X   else {
X      stackscreen();
X      toprow = 4;
X      movecursor(4,0);
X      }
X   textcbase = 2; /* left margin is 2 */
X   putstring(toprow,0,7,msg);
X   if (flags & 2)
X      putstring(textrow+2,0,7,"Escape to cancel, any other key to continue...");
X   else
X      putstring(textrow+2,0,7,"Any key to continue...");
X   textcbase = 0; /* back to full line */
X   color = (flags & 16) ? C_STOP_INFO : C_STOP_ERR;
X   setattr(toprow,0,color,(textrow+1-toprow)*80);
X   movecursor(25,80);    /* cursor off */
X   if ((flags & 4) == 0)
X      buzzer((flags & 16) ? 0 : 2);
X   while (keypressed()) /* flush any keyahead */
X      getakey();
X   if (getakeynohelp() == ESC)
X      ret = -1;
X   if ((flags & 1))
X      blankrows(toprow,10,7);
X   else
X      unstackscreen();
X   lookatmouse = savelookatmouse;
X   return ret;
X}
X
X
Xstatic char far *temptextsave = NULL;
Xstatic int  textxdots,textydots;
X
X/* texttempmsg(msg) displays a text message of up to 40 characters, waits
X      for a key press, restores the prior display, and returns (without
X      eating the key).
X      It works in almost any video mode - does nothing in some very odd cases
X      (HCGA hi-res with old bios), or when there isn't 10k of temp mem free. */
Xint texttempmsg(char *msgparm)
X{
X   if (showtempmsg(msgparm))
X      return(-1);
X#ifndef XFRACT
X   while (!keypressed()) {} /* wait for a keystroke but don't eat it */
X#else
X   waitkeypressed(0); /* wait for a keystroke but don't eat it */
X#endif
X   cleartempmsg();
X   return(0);
X}
X
Xvoid freetempmsg()
X{
X   if(temptextsave != NULL)
X      farmemfree(temptextsave);
X   temptextsave = NULL;
X}
X
Xint showtempmsg(char *msgparm)
X{
X   static long size = 0;
X   extern int color_dark,color_medium;
X   CHAR msg[41];
X   BYTE buffer[640];
X   char far *fartmp;
X   BYTE far *fontptr;
X   BYTE *bufptr;
X   int i,j,k,xrepeat,yrepeat,fontchar,charnum;
X   int save_sxoffs,save_syoffs;
X   strncpy(msg,msgparm,40);
X   msg[40] = 0; /* ensure max message len of 40 chars */
X   if (dotmode == 11) { /* disk video, screen in text mode, easy */
X      dvid_status(0,msg);
X      return(0);
X      }
X   if ((fontptr = findfont(0)) == NULL) { /* old bios, no font table? */
X      if (oktoprint == 0           /* can't printf */
X    || sxdots > 640 || sydots > 200) /* not willing to trust char cell size */
X     return(-1); /* sorry, message not displayed */
X      textydots = 8;
X      textxdots = sxdots;
X      }
X   else {
X      xrepeat = (sxdots >= 640) ? 2 : 1;
X      yrepeat = (sydots >= 300) ? 2 : 1;
X      textxdots = strlen(msg) * xrepeat * 8;
X      textydots = yrepeat * 8;
X      }
X   /* worst case needs 10k */
X   if(temptextsave !=NULL)
X      if(size != (long)textxdots * (long)textydots)
X         freetempmsg();
X   size = (long)textxdots * (long)textydots;
X   save_sxoffs = sxoffs;
X   save_syoffs = syoffs;
X   sxoffs = syoffs = 0;
X   if(temptextsave == NULL) /* only save screen first time called */
X   {
X      if ((temptextsave = farmemalloc(size)) == NULL)
X         return(-1); /* sorry, message not displayed */
X      fartmp = temptextsave;
X      for (i = 0; i < textydots; ++i) {
X         get_line(i,0,textxdots-1,buffer);
X         for (j = 0; j < textxdots; ++j) /* copy it out to far memory */
X         *(fartmp++) = buffer[j];
X         }
X      }
X   if (fontptr == NULL) { /* bios must do it for us */
X      home();
X      printf(msg);
X      }
X   else { /* generate the characters */
X      find_special_colors(); /* get color_dark & color_medium set */
X      for (i = 0; i < 8; ++i) {
X     memset(buffer,color_dark,640);
X     bufptr = buffer;
X     charnum = -1;
X     while (msg[++charnum] != 0) {
X        fontchar = *(fontptr + msg[charnum]*8 + i);
X        for (j = 0; j < 8; ++j) {
X           for (k = 0; k < xrepeat; ++k) {
X          if ((fontchar & 0x80) != 0)
X             *bufptr = color_medium;
X          ++bufptr;
X          }
X           fontchar <<= 1;
X           }
X        }
X     for (j = 0; j < yrepeat; ++j)
X        put_line(i*yrepeat+j,0,textxdots-1,buffer);
X     }
X      }
X   sxoffs = save_sxoffs;
X   syoffs = save_syoffs;
X   return(0);
X}
X
Xvoid cleartempmsg()
X{
X   BYTE buffer[640];
X   char far *fartmp;
X   int i,j;
X   int save_sxoffs,save_syoffs;
X   if (dotmode == 11) /* disk video, easy */
X      dvid_status(0,"");
X   else if (temptextsave != NULL) {
X      save_sxoffs = sxoffs;
X      save_syoffs = syoffs;
X      sxoffs = syoffs = 0;
X      fartmp = temptextsave;
X      for (i = 0; i < textydots; ++i) {
X     for (j = 0; j < textxdots; ++j) /* copy back from far memory */
X        buffer[j] = *(fartmp++);
X     put_line(i,0,textxdots-1,buffer);
X     }
X     if(using_jiim == 0)  /* jiim frees memory with freetempmsg() */
X     {
X         farmemfree(temptextsave);
X         temptextsave = NULL;
X      }
X      sxoffs = save_sxoffs;
X      syoffs = save_syoffs;
X      }
X}
X
X
Xvoid blankrows(int row,int rows,int attr)
X{
X   char buf[81];
X   memset(buf,' ',80);
X   buf[80] = 0;
X   while (--rows >= 0)
X      putstring(row++,0,attr,buf);
X   }
X
X
Xvoid helptitle()
X{
X   char msg[80],buf[80];
X   setclear(); /* clear the screen */
X#ifdef XFRACT
X   sprintf(msg,"XFRACTINT  Version %d.%02d (FRACTINT Version %d.%02d)",
X           xrelease/100,xrelease%100, release/100,release%100);
X   putstringcenter(0,0,80,C_TITLE,msg);
X#else
X#ifdef WAITE
X   release=1821;
X   patchlevel = 0;
X   sprintf(msg,"Special FRACTINT Version %d.%01d",release/100,(release%100)/10);
X#else
X   sprintf(msg,"FRACTINT Version %d.%01d",release/100,(release%100)/10);
X#endif
X   if (release%10) {
X      sprintf(buf,"%01d",release%10);
X      strcat(msg,buf);
X      }
X#ifndef XFRACT
X   if (patchlevel) {
X      sprintf(buf," Patch %d",patchlevel);
X      strcat(msg,buf);
X      }
X#endif
X#ifdef WAITE /* realdos.c */
X   strcat(msg," for the Waite Group's Fractal Creations 2nd Ed.");
X#endif /* WAITE - realdos.c */
X   putstringcenter(0,0,80,C_TITLE,msg);
X#ifdef WAITE
X   return;
X#endif
X#endif
X/* uncomment next for production executable: */
X    return;
X   /*NOTREACHED*/
X   if (debugflag == 3002) return;
X/* putstring(0,2,C_TITLE_DEV,"Development Version"); */
X/* replace above by next after creating production release, for release source */
X   putstring(0,3,C_TITLE_DEV, "Customized Version");
X   putstring(0,55,C_TITLE_DEV,"Not for Public Release");
X}
X
X
Xint putstringcenter(int row, int col, int width, int attr, char far *msg)
X{
X   char buf[81];
X   int i,j,k;
X   i = 0;
X#ifdef XFRACT
X   if (width==80) width=79; /* Some systems choke in column 80 */
X#endif
X   while (msg[i]) ++i; /* strlen for a far */
X   if (i == 0) return(-1);
X   j = (width - i) / 2;
X   j -= (width + 10 - i) / 20; /* when wide a bit left of center looks better */
X   memset(buf,' ',width);
X   buf[width] = 0;
X   i = 0;
X   k = j;
X   while (msg[i]) buf[k++] = msg[i++]; /* strcpy for a far */
X   putstring(row,col,attr,buf);
X   return j;
X}
X
X
X#ifndef XFRACT
Xstatic int screenctr=-1;
X#else
Xstatic int screenctr=0;
X#endif
X#define MAXSCREENS 3
Xstatic BYTE far *savescreen[MAXSCREENS];
Xstatic int saverc[MAXSCREENS+1];
Xstatic FILE *savescf=NULL;
Xstatic char scsvfile[]="fractscr.tmp";
Xextern int text_type;
Xextern int textaddr;
X
Xvoid stackscreen()
X{
X#ifndef XFRACT
X   BYTE far *vidmem;
X   int savebytes;
X   int i;
X   BYTE far *ptr;
X   char buf[100];
X   saverc[screenctr+1] = textrow*80 + textcol;
X   if (++screenctr) { /* already have some stacked */
X     static char far msg[]={"stackscreen overflow"};
X      if ((i = screenctr - 1) >= MAXSCREENS) { /* bug, missing unstack? */
X     stopmsg(1,msg);
X     exit(1);
X     }
X      vidmem = MK_FP(textaddr,0);
X      savebytes = (text_type == 0) ? 4000 : 16384;
X      if ((ptr = savescreen[i] = farmemalloc((long)savebytes)))
X     far_memcpy(ptr,vidmem,savebytes);
X      else {
X     if (savescf == NULL) { /* create file just once */
X        if ((savescf = fopen(scsvfile,"wb")) == NULL)
X           goto fileproblem;
X        if (fwrite(buf,MAXSCREENS,16384,savescf) != 16384)
X           goto fileproblem;
X        fclose(savescf);
X        if ((savescf = fopen(scsvfile,"r+b")) == NULL) {
X        static char far msg[]={"insufficient memory, aborting"};
Xfileproblem:   stopmsg(1,msg);
X           exit(1);
X           }
X        }
X     fseek(savescf,(long)(savebytes*i),SEEK_SET);
X     while (--savebytes >= 0)
X        putc(*(vidmem++),savescf);
X     }
X      setclear();
X      }
X   else
X      setfortext();
X#else
X   int i;
X   BYTE far *ptr;
X   saverc[screenctr+1] = textrow*80 + textcol;
X   if (++screenctr) { /* already have some stacked */
X         static char far msg[]={"stackscreen overflow"};
X      if ((i = screenctr - 1) >= MAXSCREENS) { /* bug, missing unstack? */
X         stopmsg(1,msg);
X         exit(1);
X         }
X      if (ptr = savescreen[i] = farmemalloc(sizeof(int *)))
X         savecurses(ptr);
X      else {
X         stopmsg(1,msg);
X         exit(1);
X        }
X      setclear();
X      }
X   else
X      setfortext();
X#endif
X}
X
Xvoid unstackscreen()
X{
X#ifndef XFRACT
X   char far *vidmem;
X   int savebytes;
X   BYTE far *ptr;
X   textrow = saverc[screenctr] / 80;
X   textcol = saverc[screenctr] % 80;
X   if (--screenctr >= 0) { /* unstack */
X      vidmem = MK_FP(textaddr,0);
X      savebytes = (text_type == 0) ? 4000 : 16384;
X      if ((ptr = savescreen[screenctr])) {
X     far_memcpy(vidmem,ptr,savebytes);
X     farmemfree(ptr);
X     }
X      else {
X     fseek(savescf,(long)(savebytes*screenctr),SEEK_SET);
X     while (--savebytes >= 0)
X        *(vidmem++) = getc(savescf);
X     }
X      }
X   else
X      setforgraphics();
X   movecursor(-1,-1);
X#else
X   BYTE far *ptr;
X   textrow = saverc[screenctr] / 80;
X   textcol = saverc[screenctr] % 80;
X   if (--screenctr >= 0) { /* unstack */
X      ptr = savescreen[screenctr];
X      restorecurses(ptr);
X      farmemfree(ptr);
X      }
X   else
X      setforgraphics();
X   movecursor(-1,-1);
X#endif
X}
X
Xvoid discardscreen()
X{
X   if (--screenctr >= 0) { /* unstack */
X      if (savescreen[screenctr])
X     farmemfree(savescreen[screenctr]);
X      }
X   else
X      discardgraphics();
X}
X
X
X/* --------------------------------------------------------------------- */
X
Xchar speed_prompt[]="Speed key string";
X
Xint fullscreen_choice(
X    int options,         /* &2 use menu coloring scheme           */
X                 /* &4 include F1 for help in instructions */
X                 /* &8 add caller's instr after normal set */
X    char far *hdg,         /* heading info, \n delimited           */
X    char far *hdg2,         /* column heading or NULL               */
X    char far *instr,     /* instructions, \n delimited, or NULL    */
X    int numchoices,      /* How many choices in list           */
X    char **choices,      /* array of choice strings            */
X    int *attributes,     /* &3: 0 normal color, 1,3 highlight      */
X                 /* &256 marks a dummy entry           */
X    int boxwidth,         /* box width, 0 for calc (in items)       */
X    int boxdepth,         /* box depth, 0 for calc, 99 for max      */
X    int colwidth,         /* data width of a column, 0 for calc     */
X    int current,         /* start with this item               */
X    void (*formatitem)(),/* routine to display an item or NULL     */
X    char *speedstring,   /* returned speed key value, or NULL >[30]*/
X    int (*speedprompt)(),/* routine to display prompt or NULL      */
X    int (*checkkey)()    /* routine to check keystroke or NULL     */
X)
X   /* return is: n>=0 for choice n selected,
X         -1 for escape
X          k for checkkey routine return value k (if not 0 nor -1)
X      speedstring[0] != 0 on return if string is present
X      */
X{
Xstatic char far choiceinstr1a[]="Use the cursor keys to highlight your selection";
Xstatic char far choiceinstr1b[]="Use the cursor keys or type a value to make a selection";
Xstatic char far choiceinstr2a[]="Press ENTER for highlighted choice, or ESCAPE to back out";
Xstatic char far choiceinstr2b[]="Press ENTER for highlighted choice, ESCAPE to back out, or F1 for help";
Xstatic char far choiceinstr2c[]="Press ENTER for highlighted choice, or F1 for help";
X
X   int titlelines,titlewidth;
X   int reqdrows;
X   int topleftrow,topleftcol;
X   int topleftchoice;
X   int speedrow;  /* speed key prompt */
X   int boxitems;  /* boxwidth*boxdepth */
X   int curkey,increment,rev_increment;
X   int redisplay;
X   int i,j,k;
X   char far *charptr;
X   char buf[81];
X   int speed_match = 0;
X   char curitem[81];
X   char *itemptr;
X   int ret,savelookatmouse;
X
X   savelookatmouse = lookatmouse;
X   lookatmouse = 0;
X   ret = -1;
X   if (speedstring
X     && (i = strlen(speedstring)) > 0) { /* preset current to passed string */
X      current = 0;
X      while (current < numchoices
X    && (k = strncasecmp(speedstring,choices[current],i)) > 0)
X     ++current;
X      if (k < 0 && current > 0)  /* oops - overshot */
X     --current;
X      if (current >= numchoices) /* bumped end of list */
X     current = numchoices - 1;
X      }
X
X   while (1) {
X      if (current >= numchoices)  /* no real choice in the list? */
X     goto fs_choice_end;
X      if ((attributes[current] & 256) == 0)
X     break;
X      ++current;          /* scan for a real choice */
X      }
X
X   titlelines = titlewidth = 0;
X   if (hdg) {
X      charptr = hdg;          /* count title lines, find widest */
X      i = 0;
X      titlelines = 1;
X      while (*charptr) {
X     if (*(charptr++) == '\n') {
X        ++titlelines;
X        i = -1;
X        }
X     if (++i > titlewidth)
X        titlewidth = i;
X     }
X      }
X
X   if (colwidth == 0)          /* find widest column */
X      for (i = 0; i < numchoices; ++i)
X     if (strlen(choices[i]) > colwidth)
X        colwidth = strlen(choices[i]);
X
X   /* title(1), blank(1), hdg(n), blank(1), body(n), blank(1), instr(?) */
X   reqdrows = 3;          /* calc rows available */
X   if (hdg)
X      reqdrows += titlelines + 1;
X   if (instr) {           /* count instructions lines */
X      charptr = instr;
X      ++reqdrows;
X      while (*charptr)
X     if (*(charptr++) == '\n')
X        ++reqdrows;
X      if ((options & 8))      /* show std instr too */
X     reqdrows += 2;
X      }
X   else
X      reqdrows += 2;          /* standard instructions */
X   if (speedstring) ++reqdrows;   /* a row for speedkey prompt */
X   if (boxdepth > (i = 25 - reqdrows)) /* limit the depth to max */
X      boxdepth = i;
X   if (boxwidth == 0) {       /* pick box width and depth */
X      if (numchoices <= i - 2) {  /* single column is 1st choice if we can */
X     boxdepth = numchoices;
X     boxwidth = 1;
X     }
X      else {              /* sort-of-wide is 2nd choice */
X     boxwidth = 60 / (colwidth + 1);
X     if (boxwidth == 0
X       || (boxdepth = (numchoices+boxwidth-1)/boxwidth) > i - 2) {
X        boxwidth = 80 / (colwidth + 1); /* last gasp, full width */
X        if ((boxdepth = (numchoices+boxwidth-1)/boxwidth) > i)
X           boxdepth = i;
X        }
X     }
X      }
X   if ((i = 77 / boxwidth - colwidth) > 3) /* spaces to add @ left each choice */
X      i = 3;
X   j = boxwidth * (colwidth += i) + i;       /* overall width of box */
X   if (j < titlewidth+2)
X      j = titlewidth + 2;
X   if (j > 80)
X      j = 80;
X   if (j <= 70 && boxwidth == 2) {       /* special case makes menus nicer */
X      ++j;
X      ++colwidth;
X      }
X   k = (80 - j) / 2;               /* center the box */
X   k -= (90 - j) / 20;
X   topleftcol = k + i;               /* column of topleft choice */
X   i = (25 - reqdrows - boxdepth) / 2;
X   i -= i / 4;                   /* higher is better if lots extra */
X   topleftrow = 3 + titlelines + i;       /* row of topleft choice */
X
X   /* now set up the overall display */
X   helptitle();                /* clear, display title line */
X   setattr(1,0,C_PROMPT_BKGRD,24*80);       /* init rest to background */
X   for (i = topleftrow-1-titlelines; i < topleftrow+boxdepth+1; ++i)
X      setattr(i,k,C_PROMPT_LO,j);       /* draw empty box */
X   if (hdg) {
X      textcbase = (80 - titlewidth) / 2;   /* set left margin for putstring */
X      textcbase -= (90 - titlewidth) / 20; /* put heading into box */
X      putstring(topleftrow-titlelines-1,0,C_PROMPT_HI,hdg);
X      textcbase = 0;
X      }
X   if (hdg2)                   /* display 2nd heading */
X      putstring(topleftrow-1,topleftcol,C_PROMPT_MED,hdg2);
X   i = topleftrow + boxdepth + 1;
X   if (instr == NULL || (options & 8)) {   /* display default instructions */
X      if (i < 20) ++i;
X      if (speedstring) {
X     speedrow = i;
X     *speedstring = 0;
X     if (++i < 22) ++i;
X     }
X      putstringcenter(i++,0,80,C_PROMPT_BKGRD,
X        (speedstring) ? choiceinstr1b : choiceinstr1a);
X      putstringcenter(i++,0,80,C_PROMPT_BKGRD,
X        (options&CHOICEMENU) ? choiceinstr2c
X        : ((options&CHOICEHELP) ? choiceinstr2b : choiceinstr2a));
X      }
X   if (instr) {                /* display caller's instructions */
X      charptr = instr;
X      j = -1;
X      while ((buf[++j] = *(charptr++)))
X     if (buf[j] == '\n') {
X        buf[j] = 0;
X        putstringcenter(i++,0,80,C_PROMPT_BKGRD,buf);
X        j = -1;
X        }
X      putstringcenter(i,0,80,C_PROMPT_BKGRD,buf);
X      }
X
X   boxitems = boxwidth * boxdepth;
X   topleftchoice = 0;               /* pick topleft for init display */
X   while (current - topleftchoice >= boxitems
X     || (current - topleftchoice > boxitems/2
X     && topleftchoice + boxitems < numchoices))
X      topleftchoice += boxwidth;
X   redisplay = 1;
X
X   while (1) { /* main loop */
X
X      if (redisplay) {                 /* display the current choices */
X     if ((options & CHOICEMENU) == 0) {
X        memset(buf,' ',80);
X        buf[boxwidth*colwidth] = 0;
X        for (i = (hdg2) ? 0 : -1; i <= boxdepth; ++i)  /* blank the box */
X           putstring(topleftrow+i,topleftcol,C_PROMPT_LO,buf);
X        }
X     for (i = 0; i+topleftchoice < numchoices && i < boxitems; ++i) {
X        /* display the choices */
X        if ((k = attributes[j = i+topleftchoice] & 3) == 1)
X           k = C_PROMPT_LO;
X        else if (k == 3)
X           k = C_PROMPT_HI;
X        else
X           k = C_PROMPT_MED;
X        if (formatitem)
X           (*formatitem)(j,charptr=buf);
X        else
X           charptr = choices[j];
X        putstring(topleftrow+i/boxwidth,topleftcol+(i%boxwidth)*colwidth,
X              k,charptr);
X        }
X     /***
X     ... format differs for summary/detail, whups, force box width to
X     ...  be 72 when detail toggle available?  (2 grey margin each
X     ...  side, 1 blue margin each side)
X     ***/
X     if (topleftchoice > 0 && hdg2 == NULL)
X        putstring(topleftrow-1,topleftcol,C_PROMPT_LO,"(more)");
X     if (topleftchoice + boxitems < numchoices)
X        putstring(topleftrow+boxdepth,topleftcol,C_PROMPT_LO,"(more)");
X     redisplay = 0;
X     }
X
X      i = current - topleftchoice;         /* highlight the current choice */
X      if (formatitem)
X     (*formatitem)(current,itemptr=curitem);
X      else
X     itemptr = choices[current];
X      putstring(topleftrow+i/boxwidth,topleftcol+(i%boxwidth)*colwidth,
X        C_CHOICE_CURRENT,itemptr);
X
X      if (speedstring) {             /* show speedstring if any */
X     memset(buf,' ',80);
X     buf[80] = 0;
X     putstring(speedrow,0,C_PROMPT_BKGRD,buf);
X     if (*speedstring) {             /* got a speedstring on the go */
X        putstring(speedrow,15,C_CHOICE_SP_INSTR," ");
X        if (speedprompt)
X           j = speedprompt(speedrow,16,C_CHOICE_SP_INSTR,speedstring,speed_match);
X        else {
X           putstring(speedrow,16,C_CHOICE_SP_INSTR,speed_prompt);
X           j = strlen(speed_prompt);
X           }
X        strcpy(buf,speedstring);
X        i = strlen(buf);
X        while (i < 30)
X           buf[i++] = ' ';
X        buf[i] = 0;
X        putstring(speedrow,16+j,C_CHOICE_SP_INSTR," ");
X        putstring(speedrow,17+j,C_CHOICE_SP_KEYIN,buf);
X        movecursor(speedrow,17+j+strlen(speedstring));
X        }
X     else
X        movecursor(25,80);
X     }
X      else
X     movecursor(25,80);
X
X#ifndef XFRACT
X      while (!keypressed()) { } /* enables help */
X#else
X      waitkeypressed(0); /* enables help */
X#endif
X      curkey = getakey();
X#ifdef XFRACT
X      if (curkey==F10) curkey=')';
X      if (curkey==F9) curkey='(';
X      if (curkey==F8) curkey='*';
X#endif
X
X      i = current - topleftchoice;         /* unhighlight current choice */
X      if ((k = attributes[current] & 3) == 1)
X     k = C_PROMPT_LO;
X      else if (k == 3)
X     k = C_PROMPT_HI;
X      else
X     k = C_PROMPT_MED;
X      putstring(topleftrow+i/boxwidth,topleftcol+(i%boxwidth)*colwidth,
X        k,itemptr);
X
X      increment = 0;
X      switch (curkey) {              /* deal with input key */
X     case ENTER:
X     case ENTER_2:
X        ret = current;
X        goto fs_choice_end;
X     case ESC:
X        goto fs_choice_end;
X     case DOWN_ARROW:
X     case DOWN_ARROW_2:
X        rev_increment = 0 - (increment = boxwidth);
X        break;
X     case UP_ARROW:
X     case UP_ARROW_2:
X        increment = 0 - (rev_increment = boxwidth);
X        break;
X     case RIGHT_ARROW:
X     case RIGHT_ARROW_2:
X        if (boxwidth == 1) break;
X        increment = 1; rev_increment = -1;
X        break;
X     case LEFT_ARROW:
X     case LEFT_ARROW_2:
X        if (boxwidth == 1) break;
X        increment = -1; rev_increment = 1;
X        break;
X     case PAGE_UP:
X        if (numchoices > boxitems) {
X           topleftchoice -= boxitems;
X           increment = -boxitems;
X           rev_increment = boxwidth;
X           redisplay = 1;
X           }
X        break;
X     case PAGE_DOWN:
X        if (numchoices > boxitems) {
X           topleftchoice += boxitems;
X           increment = boxitems;
X           rev_increment = -boxwidth;
X           redisplay = 1;
X           }
X        break;
X     case CTL_HOME:
X     case HOME:
X        current = -1;
X        increment = rev_increment = 1;
X        break;
X     case CTL_END:
X     case END:
X        current = numchoices;
X        increment = rev_increment = -1;
X        break;
X     default:
X        if (checkkey) {
X           if ((ret = (*checkkey)(curkey,current)) < -1 || ret > 0)
X          goto fs_choice_end;
X           if (ret == -1)
X          redisplay = -1;
X           }
X        ret = -1;
X        if (speedstring) {
X           i = strlen(speedstring);
X           if (curkey == 8 && i > 0) /* backspace */
X          speedstring[--i] = 0;
X           if (33 <= curkey && curkey <= 126 && i < 30) {
X          curkey = tolower(curkey);
X          speedstring[i] = curkey;
X          speedstring[++i] = 0;
X          }
X           if (i > 0) {         /* locate matching type */
X          current = 0;
X          while (current < numchoices
X            && (speed_match = strncasecmp(speedstring,choices[current],i)) > 0)
X             ++current;
X          if (speed_match < 0 && current > 0)  /* oops - overshot */
X             --current;
X          if (current >= numchoices) /* bumped end of list */
X             current = numchoices - 1;
X          }
X           }
X        break;
X     }
X
X      if (increment) {            /* apply cursor movement */
X     current += increment;
X     if (speedstring)        /* zap speedstring */
X        speedstring[0] = 0;
X     }
X      while (1) {            /* adjust to a non-comment choice */
X     if (current < 0 || current >= numchoices)
X         increment = rev_increment;
X     else if ((attributes[current] & 256) == 0)
X         break;
X     current += increment;
X     }
X      if (topleftchoice > numchoices - boxitems)
X     topleftchoice = ((numchoices+boxwidth-1)/boxwidth)*boxwidth - boxitems;
X      if (topleftchoice < 0)
X     topleftchoice = 0;
X      while (current < topleftchoice) {
X     topleftchoice -= boxwidth;
X     redisplay = 1;
X     }
X      while (current >= topleftchoice + boxitems) {
X     topleftchoice += boxwidth;
X     redisplay = 1;
X     }
X      }
X
Xfs_choice_end:
X   lookatmouse = savelookatmouse;
X   return(ret);
X
X}
X
X
X#ifndef XFRACT
X/* case independent version of strncmp */
Xint strncasecmp(char *s,char *t,int ct)
X{
X   for(; (tolower(*s) == tolower(*t)) && --ct ; s++,t++)
X      if(*s == '\0')
X     return(0);
X   return(tolower(*s) - tolower(*t));
X}
X#endif
X
X
Xstatic int menutype;
X#define MENU_HDG 3
X#define MENU_ITEM 1
X
Xint main_menu(int fullmenu)
X{
X   char *choices[44]; /* 2 columns * 22 rows */
X   int attributes[44];
X   int choicekey[44];
X   int i;
X   int nextleft,nextright;
X   int oldtabmode,oldhelpmode;
X   oldtabmode = tabmode;
X   oldhelpmode = helpmode;
Xtop:
X   menutype = fullmenu;
X   tabmode = 0;
X   for (i = 0; i < 44; ++i) {
X      attributes[i] = 256;
X      choices[i] = "";
X      choicekey[i] = -1;
X      }
X   nextleft = -2;
X   nextright = -1;
X
X   if (fullmenu) {
X      choices[nextleft+=2] = "      CURRENT IMAGE";
X      attributes[nextleft] = 256+MENU_HDG;
X      choicekey[nextleft+=2] = 13; /* enter */
X      attributes[nextleft] = MENU_ITEM;
X      if (calc_status == 2)
X     choices[nextleft] = "continue calculation";
X      else
X     choices[nextleft] = "return to image";
X      choicekey[nextleft+=2] = 9; /* tab */
X      attributes[nextleft] = MENU_ITEM;
X      choices[nextleft] = "info about image      <tab>";
X      choicekey[nextleft+=2] = -10;
X      attributes[nextleft] = MENU_ITEM;
X      choices[nextleft] = "zoom box functions...";
X      choicekey[nextleft+=2] = 'o';
X      attributes[nextleft] = MENU_ITEM;
X      choices[nextleft] = "orbits window          <o>";
X      if(!(fractype==JULIA || fractype==JULIAFP || fractype==INVERSEJULIA))
X          nextleft+=2;
X      }
X   choices[nextleft+=2] = "      NEW IMAGE";
X   attributes[nextleft] = 256+MENU_HDG;
X   choicekey[nextleft+=2] = DELETE;
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "select video mode...  <del>";
X   choicekey[nextleft+=2] = 't';
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "select fractal type    <t>";
X   if (fullmenu) {
X      if ((curfractalspecific->tojulia != NOFRACTAL
X      && param[0] == 0.0 && param[1] == 0.0)
X      || curfractalspecific->tomandel != NOFRACTAL) {
X         choicekey[nextleft+=2] = ' ';
X         attributes[nextleft] = MENU_ITEM;
X         choices[nextleft] = "toggle to/from julia <space>";
X      }
X      if(fractype==JULIA || fractype==JULIAFP || fractype==INVERSEJULIA) {
X         choicekey[nextleft+=2] = 'j';
X         attributes[nextleft] = MENU_ITEM;
X         choices[nextleft] = "toggle to/from inverse <j>";
X      }
X      choicekey[nextleft+=2] = '\\';
X      attributes[nextleft] = MENU_ITEM;
X      choices[nextleft] = "return to prior image  <\\>";
X   }
X   nextleft += 2;
X   choices[nextleft+=2] = "      OPTIONS";
X   attributes[nextleft] = 256+MENU_HDG;
X   choicekey[nextleft+=2] = 'x';
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "basic options...       <x>";
X   choicekey[nextleft+=2] = 'y';
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "extended options...    <y>";
X   choicekey[nextleft+=2] = 'z';
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "type-specific parms... <z>";
X   choicekey[nextleft+=2] = 'v';
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "view window options... <v>";
X   choicekey[nextleft+=2] = 'i';
X   attributes[nextleft] = MENU_ITEM;
X   choices[nextleft] = "fractal 3D parms...    <i>";
X
X   choices[nextright+=2] = "        FILE";
X   attributes[nextright] = 256+MENU_HDG;
X   choicekey[nextright+=2] = '@';
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "run saved command set... <@>";
X   if (fullmenu) {
X      choicekey[nextright+=2] = 's';
X      attributes[nextright] = MENU_ITEM;
X      choices[nextright] = "save image to file       <s>";
X      }
X   choicekey[nextright+=2] = 'r';
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "load image from file...  <r>";
X   choicekey[nextright+=2] = '3';
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "3d transform from file...<3>";
X   if (fullmenu) {
X      choicekey[nextright+=2] = '#';
X      attributes[nextright] = MENU_ITEM;
X      choices[nextright] = "3d overlay from file.....<#>";
X      choicekey[nextright+=2] = 'b';
X      attributes[nextright] = MENU_ITEM;
X      choices[nextright] = "save current parameters..<b>";
X      choicekey[nextright+=2] = 'p';
X      attributes[nextright] = MENU_ITEM;
X      choices[nextright] = "print image              <p>";
X      }
X   choicekey[nextright+=2] = 'd';
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "shell to dos             <d>";
X   choicekey[nextright+=2] = 'g';
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "give command string      <g>";
X   choicekey[nextright+=2] = ESC;
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "quit Fractint           <esc>";
X   choicekey[nextright+=2] = INSERT;
X   attributes[nextright] = MENU_ITEM;
X   choices[nextright] = "restart Fractint        <ins>";
X   if (fullmenu && gotrealdac && colors >= 16) {
X      nextright += 2;
X      choices[nextright+=2] = "       COLORS";
X      attributes[nextright] = 256+MENU_HDG;
X      /*** choicekey[nextright+=2] = -12;
X        attributes[nextright] = MENU_ITEM;
X        choices[nextright] = "color cycling menu...";
X        choicekey[nextright+=2] = -13;
X        attributes[nextright] = MENU_ITEM;
X        choices[nextright] = "palette editing menu..."; ***/
X      choicekey[nextright+=2] = 'c';
X      attributes[nextright] = MENU_ITEM;
X      choices[nextright] = "color cycling mode       <c>";
X      choicekey[nextright+=2] = '+';
X      attributes[nextright] = MENU_ITEM;
X      choices[nextright] = "rotate palette      <+>, <->";
X      if (colors > 16) {
X     if (!reallyega) {
X        choicekey[nextright+=2] = 'e';
X        attributes[nextright] = MENU_ITEM;
X        choices[nextright] = "palette editing mode     <e>";
X        }
X     choicekey[nextright+=2] = 'a';
X     attributes[nextright] = MENU_ITEM;
X     choices[nextright] = "make starfield           <a>";
X     }
X      }
X
X   i = (keypressed()) ? getakey() : 0;
X   if (menu_checkkey(i,0) == 0) {
X      helpmode = HELPMAIN;       /* switch help modes */
X      if ((nextleft += 2) < nextright)
X     nextleft = nextright + 1;
X      i = fullscreen_choice(CHOICEMENU,
X      "MAIN MENU",
X      NULL,NULL,nextleft,choices,attributes,
X      2,nextleft/2,29,0,NULL,NULL,NULL,menu_checkkey);
X      if (i == -1)     /* escape */
X     i = ESC;
X      else if (i < 0)
X     i = 0 - i;
X      else {              /* user selected a choice */
X     i = choicekey[i];
X     switch (i) {          /* check for special cases */
X        case -10:          /* zoombox functions */
X           helpmode = HELPZOOM;
X           help(0);
X           i = 0;
X           break;
X        }
X     }
X      }
X   if (i == ESC) {           /* escape from menu exits Fractint */
X      static char far s[] = "Exit from Fractint (y/n)? y";
X      helptitle();
X      setattr(1,0,C_GENERAL_MED,24*80);
X      for (i = 9; i <= 11; ++i)
X     setattr(i,18,C_GENERAL_INPUT,40);
X      putstringcenter(10,18,40,C_GENERAL_INPUT,s);
X      movecursor(25,80);
X      while ((i = getakey()) != 'y' && i != 'Y' && i != 13) {
X     if (i == 'n' || i == 'N')
X        goto top;
X     }
X      goodbye();
X      }
X   if (i == TAB) {
X      tab_display();
X      i = 0;
X      }
X   if (i == ENTER || i == ENTER_2)
X      i = 0;             /* don't trigger new calc */
X   tabmode = oldtabmode;
X   return(i);
X}
X
Xstatic int menu_checkkey(int curkey,int choice)
X{
X   int testkey;
X   testkey = (curkey>='A' && curkey<='Z') ? curkey+('a'-'A') : curkey;
X#ifdef XFRACT
X   /* We use F2 for shift-@, annoyingly enough */
X   if (testkey == F2) return(0-testkey);
X#endif
X   if (strchr("@txyzgvir3dj",testkey) || testkey == INSERT
X     || testkey == ESC || testkey == DELETE)
X      return(0-testkey);
X   if (menutype) {
X      if (strchr("\\sobp",testkey) || testkey == 9)
X     return(0-testkey);
X      if (testkey == ' ')
X     if ((curfractalspecific->tojulia != NOFRACTAL
X          && param[0] == 0.0 && param[1] == 0.0)
X       || curfractalspecific->tomandel != NOFRACTAL)
X     return(0-testkey);
X      if (gotrealdac && colors >= 16) {
X     if (strchr("c+-",testkey))
X        return(0-testkey);
X     if (colors > 16
X       && (testkey == 'a' || (!reallyega && testkey == 'e')))
X        return(0-testkey);
X     }
X      }
X   if (check_vidmode_key(0,testkey) >= 0)
X      return(0-testkey);
X   return(0);
X}
X
X
Xint input_field(
X    int options,          /* &1 numeric, &2 integer, &4 double */
X    int attr,          /* display attribute */
X    char *fld,          /* the field itself */
X    int len,          /* field length (declare as 1 larger for \0) */
X    int row,          /* display row */
X    int col,          /* display column */
X    int (*checkkey)(int)  /* routine to check non data keys, or NULL */
X    )
X{
X   char savefld[81];
X   char buf[81];
X   int insert, started, offset, curkey, display;
X   int i, j;
X   int ret,savelookatmouse;
X   savelookatmouse = lookatmouse;
X   lookatmouse = 0;
X   ret = -1;
X   strcpy(savefld,fld);
X   insert = started = offset = 0;
X   display = 1;
X   while (1) {
X      strcpy(buf,fld);
X      i = strlen(buf);
X      while (i < len)
X     buf[i++] = ' ';
X      buf[len] = 0;
X      if (display) {                    /* display current value */
X     putstring(row,col,attr,buf);
X     display = 0;
X     }
X      curkey = keycursor(row+insert,col+offset);  /* get a keystroke */
X      switch (curkey) {
X     case ENTER:
X     case ENTER_2:
X        ret = 0;
X        goto inpfld_end;
X     case ESC:
X        goto inpfld_end;
X     case RIGHT_ARROW:
X     case RIGHT_ARROW_2:
X        if (offset < len-1) ++offset;
X        started = 1;
X        break;
X     case LEFT_ARROW:
X     case LEFT_ARROW_2:
X        if (offset > 0) --offset;
X        started = 1;
X        break;
X     case HOME:
X        offset = 0;
X        started = 1;
X        break;
X     case END:
X        offset = strlen(fld);
X        started = 1;
X        break;
X     case 8:
X     case 127:                /* backspace */
X        if (offset > 0) {
X           j = strlen(fld);
X           for (i = offset-1; i < j; ++i)
X          fld[i] = fld[i+1];
X           --offset;
X           }
X        started = display = 1;
X        break;
X     case DELETE:                /* delete */
X        j = strlen(fld);
X        for (i = offset; i < j; ++i)
X           fld[i] = fld[i+1];
X        started = display = 1;
X        break;
X     case INSERT:                /* insert */
X        insert ^= 0x8000;
X        started = 1;
X        break;
X     case F5:
X        strcpy(fld,savefld);
X        insert = started = offset = 0;
X        display = 1;
X        break;
X     default:
X            if (nonalpha(curkey)) {
X           if (checkkey && (ret = (*checkkey)(curkey)))
X          goto inpfld_end;
X           break;                     /* non alphanum char */
X           }
X        if (offset >= len) break;             /* at end of field */
X        if (insert && started && strlen(fld) >= len)
X           break;                     /* insert & full */
X        if ((options & 1)
X          && (curkey < '0' || curkey > '9')
X          && curkey != '+' && curkey != '-') {
X           if ((options & 2))
X          break;
X           /* allow scientific notation, and specials "e" and "p" */
X           if ( ((curkey != 'e' && curkey != 'E') || offset >= 18)
X         && ((curkey != 'p' && curkey != 'P') || offset != 0 )
X         && curkey != '.')
X          break;
X           }
X        if (started == 0) /* first char is data, zap field */
X           fld[0] = 0;
X        if (insert) {
X           j = strlen(fld);
X           while (j >= offset) {
X          fld[j+1] = fld[j];
X          --j;
X          }
X           }
X        if (offset >= strlen(fld))
X           fld[offset+1] = 0;
X        fld[offset++] = curkey;
X        /* if "e" or "p" in first col make number e or pi */
X        if ((options & 3) == 1) { /* floating point */
X           double tmpd;
X           int specialv;
X           char tmpfld[30];
X           specialv = 0;
X           if (*fld == 'e' || *fld == 'E') {
X          tmpd = exp(1.0);
X          specialv = 1;
X          }
X           if (*fld == 'p' || *fld == 'P') {
X          tmpd = atan(1.0) * 4;
X          specialv = 1;
X          }
X           if (specialv) {
X          if ((options & 4) == 0)
X             roundfloatd(&tmpd);
X          sprintf(tmpfld,"%.15g",tmpd);
X          tmpfld[len-1] = 0; /* safety, field should be long enough */
X          strcpy(fld,tmpfld);
X          offset = 0;
X          }
X           }
X        started = display = 1;
X     }
X      }
Xinpfld_end:
X   lookatmouse = savelookatmouse;
X   return(ret);
X}
X
Xint field_prompt(
X    int options,        /* &1 numeric value, &2 integer */
X    char *hdg,        /* heading, \n delimited lines */
X    char *instr,        /* additional instructions or NULL */
X    char *fld,        /* the field itself */
X    int len,        /* field length (declare as 1 larger for \0) */
X    int (*checkkey)(int)   /* routine to check non data keys, or NULL */
X    )
X{
X   char *charptr;
X   int boxwidth,titlelines,titlecol,titlerow;
X   int promptcol;
X   int i,j;
X   char buf[81];
X   helptitle();               /* clear screen, display title */
X   setattr(1,0,C_PROMPT_BKGRD,24*80);      /* init rest to background */
X   charptr = hdg;              /* count title lines, find widest */
X   i = boxwidth = 0;
X   titlelines = 1;
X   while (*charptr) {
X      if (*(charptr++) == '\n') {
X     ++titlelines;
X     i = -1;
X     }
X      if (++i > boxwidth)
X     boxwidth = i;
X      }
X   if (len > boxwidth)
X      boxwidth = len;
X   i = titlelines + 4;              /* total rows in box */
X   titlerow = (25 - i) / 2;          /* top row of it all when centered */
X   titlerow -= titlerow / 4;          /* higher is better if lots extra */
X   titlecol = (80 - boxwidth) / 2;      /* center the box */
X   titlecol -= (90 - boxwidth) / 20;
X   promptcol = titlecol - (boxwidth-len)/2;
X   j = titlecol;              /* add margin at each side of box */
X   if ((i = (82-boxwidth)/4) > 3)
X      i = 3;
X   j -= i;
X   boxwidth += i * 2;
X   for (i = -1; i < titlelines+3; ++i)      /* draw empty box */
X      setattr(titlerow+i,j,C_PROMPT_LO,boxwidth);
X   textcbase = titlecol;          /* set left margin for putstring */
X   putstring(titlerow,0,C_PROMPT_HI,hdg); /* display heading */
X   textcbase = 0;
X   i = titlerow + titlelines + 4;
X   if (instr) {               /* display caller's instructions */
X      charptr = instr;
X      j = -1;
X      while ((buf[++j] = *(charptr++)))
X     if (buf[j] == '\n') {
X        buf[j] = 0;
X        putstringcenter(i++,0,80,C_PROMPT_BKGRD,buf);
X        j = -1;
X        }
X      putstringcenter(i,0,80,C_PROMPT_BKGRD,buf);
X      }
X   else                   /* default instructions */
X      putstringcenter(i,0,80,C_PROMPT_BKGRD,
X          "Press ENTER when finished (or ESCAPE to back out)");
X   return(input_field(options,C_PROMPT_INPUT,fld,len,
X              titlerow+titlelines+1,promptcol,checkkey));
X}
X
X
X/* thinking(1,message):
X      if thinking message not yet on display, it is displayed;
X      otherwise the wheel is updated
X      returns 0 to keep going, -1 if keystroke pending
X   thinking(0,NULL):
X      call this when thinking phase is done
X   */
X
Xint thinking(int options,char *msg)
X{
X   static int thinkstate = -1;
X   static char *wheel[] = {"-","\\","|","/"};
X   static int thinkcol;
X   static int count=0;
X   char buf[81];
X   if (options == 0) {
X      if (thinkstate >= 0) {
X     thinkstate = -1;
X     unstackscreen();
X     }
X      return(0);
X      }
X   if (thinkstate < 0) {
X      stackscreen();
X      thinkstate = 0;
X      helptitle();
X      strcpy(buf,"  ");
X      strcat(buf,msg);
X      strcat(buf,"    ");
X      putstring(4,10,C_GENERAL_HI,buf);
X      thinkcol = textcol - 3;
X      count = 0;
X      }
X   if ((count++)<100) {
X       return 0;
X   }
X   count = 0;
X   putstring(4,thinkcol,C_GENERAL_HI,wheel[thinkstate]);
X   movecursor(25,80); /* turn off cursor */
X   thinkstate = (thinkstate + 1) & 3;
X   return (keypressed());
X}
X
X
Xvoid clear_screen(void)  /* a stub for a windows only subroutine */
X{
X}
X
X
X/* savegraphics/restoregraphics: video.asm subroutines */
X
Xstatic BYTE far *swapsavebuf;
Xstatic unsigned int memhandle;
Xunsigned long swaptotlen;
Xunsigned long swapoffset;
XBYTE far *swapvidbuf;
Xint swaplength;
Xstatic int swaptype = -1;
Xstatic int swapblklen; /* must be a power of 2 */
X#ifndef XFRACT
Xextern BYTE suffix[4096];
X#else
XBYTE suffix[4096];
X#endif
X
X#ifndef XFRACT
X
Xint savegraphics()
X{
X   extern int made_dsktemp;
X   int i;
X   struct XMM_Move   xmmparms;
X
X   discardgraphics(); /* if any emm/xmm in use from prior call, release it */
X   swaptotlen = (long)(vxdots > sxdots ? vxdots : sxdots) * (long)sydots;
X   i = colors;
X   while (i <= 16) {
X      swaptotlen >>= 1;
X      i = i * i;
X      }
X   swapoffset = 0;
X   if (debugflag != 420 && debugflag != 422 /* 422=xmm test, 420=disk test */
X     && (swapsavebuf = emmquery()) != NULL
X     && (memhandle = emmallocate((unsigned int)((swaptotlen + 16383) >> 14)))
X     != 0) {
X      swaptype = 0; /* use expanded memory */
X      swapblklen = 16384;
X      }
X   else if (debugflag != 420
X     && xmmquery() !=0
X     && (memhandle = xmmallocate((unsigned int)((swaptotlen + 1023) >> 10)))
X     != 0) {
X      swaptype = 1; /* use extended memory */
X      swapblklen = 16384;
X      }
X   else {
X      swaptype = 2; /* use disk */
X      swapblklen = 4096;
X
X   /* MCP 7-7-91, If 'memhandle' is an 'unsigned int', how is it ever going
X      to be equal to -1?
X
X      if ((memhandle = open(diskfilename,O_CREAT|O_WRONLY|O_BINARY,S_IWRITE))
X     == -1) {
X   */
X      if ((memhandle = open(diskfilename,O_CREAT|O_WRONLY|O_BINARY,S_IWRITE))
X     == 0xffff) {
X
X
Xdskfile_error:
X     setvideotext(); /* text mode */
X     setclear();
X         {
X            extern char diskfilename[];
X            static char far s1[] = {"error in temp file "};
X            static char far s2[] = { " (disk full?) - aborted\n\n"};
X        printf("%Fs%s%Fs",s1,diskfilename,s2);
X     }
X     exit(1);
X     }
X      made_dsktemp = 1;
X      }
X   while (swapoffset < swaptotlen) {
X      swaplength = swapblklen;
X      if ((swapoffset & (swapblklen-1)) != 0)
X     swaplength = swapblklen - (swapoffset & (swapblklen-1));
X      if (swaplength > swaptotlen - swapoffset)
X     swaplength = swaptotlen - swapoffset;
X      (*swapsetup)(); /* swapoffset,swaplength -> sets swapvidbuf,swaplength */
X      switch(swaptype) {
X     case 0:
X        emmgetpage((unsigned int)(swapoffset>>14),memhandle);
X        movewords(swaplength>>1,swapvidbuf,
X              swapsavebuf+(swapoffset&(swapblklen-1)));
X        break;
X     case 1:
X        xmmparms.Length = swaplength;
X        xmmparms.SourceHandle = 0; /* Source is conventional memory */
X        xmmparms.SourceOffset = (unsigned long)swapvidbuf;
X        xmmparms.DestHandle = memhandle;
X        xmmparms.DestOffset = swapoffset;
X        xmmmoveextended(&xmmparms);
X        break;
X     default:
X        movewords(swaplength>>1,swapvidbuf,(BYTE far *)suffix);
X        if (write(memhandle,suffix,swaplength) == -1)
X           goto dskfile_error;
X     }
X      swapoffset += swaplength;
X      }
X   if (swaptype == 2)
X      close(memhandle);
X   return 0;
X}
X
Xvoid restoregraphics()
X{
X   struct XMM_Move   xmmparms;
X
X   swapoffset = 0;
X   if (swaptype == 2)
X      memhandle = open(diskfilename,O_RDONLY|O_BINARY,S_IREAD);
X   swapvidbuf = MK_FP(extraseg+0x1000,0); /* for swapnormwrite case */
X   while (swapoffset < swaptotlen) {
X      swaplength = swapblklen;
X      if ((swapoffset & (swapblklen-1)) != 0)
X     swaplength = swapblklen - (swapoffset & (swapblklen-1));
X      if (swaplength > swaptotlen - swapoffset)
X     swaplength = swaptotlen - swapoffset;
X      if (swapsetup != swapnormread)
X     (*swapsetup)(); /* swapoffset,swaplength -> sets swapvidbuf,swaplength */
X      switch(swaptype) {
X     case 0:
X        emmgetpage((unsigned int)(swapoffset>>14),memhandle);
X        movewords(swaplength>>1,swapsavebuf+(swapoffset&(swapblklen-1)),
X              swapvidbuf);
X        break;
X     case 1:
X        xmmparms.Length = swaplength;
X        xmmparms.SourceHandle = memhandle;
X        xmmparms.SourceOffset = swapoffset;
X        xmmparms.DestHandle = 0; /* conventional memory */
X        xmmparms.DestOffset = (unsigned long)swapvidbuf;
X        xmmmoveextended(&xmmparms);
X        break;
X     default:
X        read(memhandle,suffix,swaplength);
X        movewords(swaplength>>1,(BYTE far *)suffix,swapvidbuf);
X     }
X      if (swapsetup == swapnormread)
X     swapnormwrite();
X      swapoffset += swaplength;
X      }
X   if (swaptype == 2)
X      close(memhandle);
X   discardgraphics();
X}
X
X#endif
X
Xvoid discardgraphics() /* release expanded/extended memory if any in use */
X{
X#ifndef XFRACT
X   switch(swaptype) {
X      case 0:
X     emmdeallocate(memhandle);
X     break;
X      case 1:
X     xmmdeallocate(memhandle);
X      }
X   swaptype = -1;
X#endif
X}
X
Xextern int badconfig;
Xextern struct videoinfo far videotable[];
Xstruct videoinfo far *vidtbl;  /* temporarily loaded fractint.cfg info */
Xint vidtbllen;               /* number of entries in above           */
X
Xint load_fractint_cfg(int options)
X{
X   /* Reads fractint.cfg, loading videoinfo entries into extraseg. */
X   /* Sets vidtbl pointing to the loaded table, and returns the    */
X   /* number of entries (also sets vidtbllen to this).           */
X   /* Past vidtbl, cfglinenums are stored for update_fractint_cfg. */
X   /* If fractint.cfg is not found or invalid, issues a message    */
X   /* (first time the problem occurs only, and only if options is  */
X   /* zero) and uses the hard-coded table.               */
X
X   FILE *cfgfile;
X   struct videoinfo far *vident;
X   int far *cfglinenums;
X   int linenum;
X   int i, j, keynum, ax, bx, cx, dx, dotmode, xdots, ydots, colors;
X   int commas[10];
X   int textsafe2;
X   char tempstring[150];
X
X   vidtbl = MK_FP(extraseg,0);
X   cfglinenums = (int far *)(&vidtbl[MAXVIDEOMODES]);
X
X#ifdef XFRACT
X    badconfig = -1;
X#endif
X
X   if (badconfig)  /* fractint.cfg already known to be missing or bad */
X      goto use_resident_table;
X
X   findpath("fractint.cfg",tempstring);
X   if (tempstring[0] == 0                 /* can't find the file */
X     || (cfgfile = fopen(tempstring,"r")) == NULL)   /* can't open it */
X      goto bad_fractint_cfg;
X
X   vidtbllen = 0;
X   linenum = 0;
X   vident = vidtbl;
X   while (vidtbllen < MAXVIDEOMODES
X     && fgets(tempstring, 120, cfgfile)) {
X      ++linenum;
X      if (tempstring[0] == ';') continue;   /* comment line */
X      tempstring[120] = 0;
X      tempstring[strlen(tempstring)-1] = 0; /* zap trailing \n */
X      memset(commas,0,20);
X      i = j = -1;
X      while (1) {
X     if (tempstring[++i] < ' ') {
X        if (tempstring[i] == 0) break;
X        tempstring[i] = ' '; /* convert tab (or whatever) to blank */
X        }
X     else if (tempstring[i] == ',' && ++j < 10) {
X        commas[j] = i + 1;     /* remember start of next field */
X        tempstring[i] = 0;     /* make field a separate string */
X        }
X     }
X      keynum = check_vidmode_keyname(tempstring);
X      sscanf(&tempstring[commas[1]],"%x",&ax);
X      sscanf(&tempstring[commas[2]],"%x",&bx);
X      sscanf(&tempstring[commas[3]],"%x",&cx);
X      sscanf(&tempstring[commas[4]],"%x",&dx);
X      dotmode      = atoi(&tempstring[commas[5]]);
X      xdots      = atoi(&tempstring[commas[6]]);
X      ydots      = atoi(&tempstring[commas[7]]);
X      colors      = atoi(&tempstring[commas[8]]);
X      textsafe2   = dotmode / 100;
X      dotmode     %= 100;
X      if (j != 9 ||
X        keynum < 0 ||
X        dotmode < 0 || dotmode > 30 ||
X        textsafe2 < 0 || textsafe2 > 4 ||
X        xdots < 160 || xdots > MAXPIXELS ||
X        ydots < 160 || ydots > MAXPIXELS ||
X        (colors != 0 && colors != 2 && colors != 4 && colors != 16 &&
X         colors != 256)
X       )
X     goto bad_fractint_cfg;
X      cfglinenums[vidtbllen] = linenum; /* for update_fractint_cfg */
X      far_memcpy(vident->name,     (char far *)&tempstring[commas[0]],25);
X      far_memcpy(vident->comment,(char far *)&tempstring[commas[9]],25);
X      vident->name[25] = vident->comment[25] = 0;
X      vident->keynum      = keynum;
X      vident->videomodeax = ax;
X      vident->videomodebx = bx;
X      vident->videomodecx = cx;
X      vident->videomodedx = dx;
X      vident->dotmode      = textsafe2 * 100 + dotmode;
X      vident->xdots      = xdots;
X      vident->ydots      = ydots;
X      vident->colors      = colors;
X      ++vident;
X      ++vidtbllen;
X      }
X   fclose(cfgfile);
X   return (vidtbllen);
X
Xbad_fractint_cfg:
X   badconfig = -1; /* bad, no message issued yet */
X   if (options == 0)
X      bad_fractint_cfg_msg();
X
Xuse_resident_table:
X   vidtbllen = 0;
X   vident = vidtbl;
X   for (i = 0; i < MAXVIDEOTABLE; ++i) {
X      if (videotable[i].xdots) {
X     far_memcpy((char far *)vident,(char far *)&videotable[i],
X            sizeof(*vident));
X     ++vident;
X     ++vidtbllen;
X     }
X      }
X   return (vidtbllen);
X
X}
X
Xvoid bad_fractint_cfg_msg()
X{
Xstatic char far badcfgmsg[]={"\
XFile FRACTINT.CFG is missing or invalid.\n\
XSee Hardware Support and Video Modes in the full documentation for help.\n\
XI will continue with only the built-in video modes available."};
X   stopmsg(0,badcfgmsg);
X   badconfig = 1; /* bad, message issued */
X}
X
Xvoid load_videotable(int options)
X{
X   /* Loads fractint.cfg and copies the video modes which are */
X   /* assigned to function keys into videotable.          */
X   int keyents,i;
X   load_fractint_cfg(options); /* load fractint.cfg to extraseg */
X   keyents = 0;
X   far_memset((char far *)videotable,0,sizeof(*vidtbl)*MAXVIDEOTABLE);
X   for (i = 0; i < vidtbllen; ++i) {
X      if (vidtbl[i].keynum > 0) {
X     far_memcpy((char far *)&videotable[keyents],(char far *)&vidtbl[i],
X            sizeof(*vidtbl));
X     if (++keyents >= MAXVIDEOTABLE)
X        break;
X     }
X      }
X}
X
Xint check_vidmode_key(int option,int k)
X{
X   int i;
X   /* returns videotable entry number if the passed keystroke is a  */
X   /* function key currently assigned to a video mode, -1 otherwise */
X   if (k == 1400)           /* special value from select_vid_mode  */
X      return(MAXVIDEOTABLE-1); /* for last entry with no key assigned */
X   if (k != 0)
X      if (option == 0) { /* check resident video mode table */
X     for (i = 0; i < MAXVIDEOTABLE; ++i) {
X        if (videotable[i].keynum == k)
X           return(i);
X        }
X     }
X      else { /* check full vidtbl */
X     for (i = 0; i < vidtbllen; ++i) {
X        if (vidtbl[i].keynum == k)
X           return(i);
X        }
X     }
X   return(-1);
X}
X
Xint check_vidmode_keyname(char *kname)
X{
X   /* returns key number for the passed keyname, 0 if not a keyname */
X   int i,keyset;
X   keyset = 1058;
X   if (*kname == 'S' || *kname == 's') {
X      keyset = 1083;
X      ++kname;
X      }
X   else if (*kname == 'C' || *kname == 'c') {
X      keyset = 1093;
X      ++kname;
X      }
X   else if (*kname == 'A' || *kname == 'a') {
X      keyset = 1103;
X      ++kname;
X      }
X   if (*kname != 'F' && *kname != 'f')
X      return(0);
X   if (*++kname < '1' || *kname > '9')
X      return(0);
X   i = *kname - '0';
X   if (*++kname != 0 && *kname != ' ') {
X      if (*kname != '0' || i != 1)
X     return(0);
X      i = 10;
X      ++kname;
X      }
X   while (*kname)
X      if (*(kname++) != ' ')
X     return(0);
X   if ((i += keyset) < 2)
X      i = 0;
X   return(i);
X}
X
Xvoid vidmode_keyname(int k,char *buf)
X{
X   /* set buffer to name of passed key number */
X   *buf = 0;
X   if (k > 0) {
X      if (k > 1103) {
X     *(buf++) = 'A';
X     k -= 1103;
X     }
X      else if (k > 1093) {
X     *(buf++) = 'C';
X     k -= 1093;
X     }
X      else if (k > 1083) {
X     *(buf++) = 'S';
X     k -= 1083;
X     }
X      else
X     k -= 1058;
X      sprintf(buf,"F%d",k);
X      }
X}
SHAR_EOF
$TOUCH -am 1028230093 realdos.c &&
chmod 0644 realdos.c ||
echo "restore of realdos.c failed"
set `wc -c realdos.c`;Wc_c=$1
if test "$Wc_c" != "51622"; then
    echo original size 51622, current size $Wc_c
fi
# ============= rotate.c ==============
echo "x - extracting rotate.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > rotate.c &&
X/*
X    rotate.c - Routines that manipulate the Video DAC on VGA Adapters
X    This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
X*/
X
X#include <stdlib.h>
X#include <stdio.h>
X#include <string.h>
X#include <time.h>
X#include "fractint.h"
X#include "helpdefs.h"
X#include "prototyp.h"
X
X/* routines in this module    */
X
Xstatic void pauserotate(void);
Xstatic void set_palette(),set_palette2(),set_palette3();
X
Xextern char temp1[];
X
Xextern    int    colors;         /* maximum colors available */
X
Xextern BYTE dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
Xextern    int    gotrealdac;        /* dacbox valid? */
Xextern BYTE olddacbox[256][3];
Xextern int    daclearn, daccount;    /* used by the color-cyclers */
Xextern int    reallyega;        /* == 0 if it's really an EGA */
Xextern int    rotate_lo,rotate_hi;    /* range of colors to cycle */
Xextern int    colorstate; /* comments in cmdfiles */
Xextern char    colorfile[];
Xextern int    dotmode;
X
Xstatic int paused;            /* rotate-is-paused flag */
X
Xstatic BYTE Red[3]    = {63, 0, 0};    /* for shifted-Fkeys */
Xstatic BYTE Green[3]  = { 0,63, 0};
Xstatic BYTE Blue[3]   = { 0, 0,63};
Xstatic BYTE Black[3]  = { 0, 0, 0};
Xstatic BYTE White[3]  = {63,63,63};
Xstatic BYTE Yellow[3] = {63,63, 0};
Xstatic BYTE Brown[3]  = {31,31, 0};
X
Xchar mapmask[13] = {"*.map"};
X
X
Xvoid rotate_overlay() { }    /* for restore_active_ovly */
X
Xvoid rotate(int direction)    /* rotate-the-palette routine */
X{
Xint  kbdchar, more, last, next;
Xint fkey, step, fstep, istep, jstep, oldstep;
Xint incr, fromred, fromblue, fromgreen, tored, toblue, togreen;
Xint i, changecolor, changedirection;
Xint oldhelpmode;
Xint rotate_max,rotate_size;
X
Xstatic int fsteps[] = {2,4,8,12,16,24,32,40,54,100}; /* (for Fkeys) */
X
X   ENTER_OVLY(OVLY_ROTATE);
X
X   if (gotrealdac == 0            /* ??? no DAC to rotate! */
X     || colors < 16) {            /* strange things happen in 2x modes */
X      buzzer(2);
X      EXIT_OVLY;
X      return;
X      }
X
X   oldhelpmode = helpmode;        /* save the old help mode    */
X   helpmode = HELPCYCLING;        /* new help mode        */
X
X   paused = 0;                /* not paused            */
X   fkey = 0;                /* no random coloring        */
X   oldstep = step = 1;            /* single-step            */
X   fstep = 1;
X   changecolor = -1;            /* no color (rgb) to change    */
X   changedirection = 0;         /* no color direction to change */
X   incr = 999;                /* ready to randomize        */
X   srand((unsigned)time(NULL));     /* randomize things        */
X
X   if (direction == 0) {        /* firing up in paused mode?    */
X      pauserotate();            /* then force a pause        */
X      direction = 1;            /* and set a rotate direction    */
X      }
X
X   rotate_max = (rotate_hi < colors) ? rotate_hi : colors-1;
X   rotate_size = rotate_max - rotate_lo + 1;
X   last = rotate_max;            /* last box that was filled    */
X   next = rotate_lo;            /* next box to be filled    */
X   if (direction < 0) {
X      last = rotate_lo;
X      next = rotate_max;
X      }
X
X   more = 1;
X   while (more) {
X      if (dotmode == 11) {
X     if (!paused)
X        pauserotate();
X     }
X      else while(!keypressed()) { /* rotate until key hit, at least once so step=oldstep ok */
X     if (fkey > 0) {        /* randomizing is on */
X        for (istep = 0; istep < step; istep++) {
X           jstep = next + (istep * direction);
X           while (jstep < rotate_lo)  jstep += rotate_size;
X           while (jstep > rotate_max) jstep -= rotate_size;
X           if (++incr > fstep) {    /* time to randomize */
X          incr = 1;
X                  fstep = ((fsteps[fkey-1]* (rand15() >> 8)) >> 6) + 1;
X          fromred   = dacbox[last][0];
X          fromgreen = dacbox[last][1];
X          fromblue  = dacbox[last][2];
X                  tored     = rand15() >> 9;
X                  togreen   = rand15() >> 9;
X                  toblue    = rand15() >> 9;
X          }
X           dacbox[jstep][0] = fromred   + (((tored     - fromred  )*incr)/fstep);
X           dacbox[jstep][1] = fromgreen + (((togreen - fromgreen)*incr)/fstep);
X           dacbox[jstep][2] = fromblue  + (((toblue  - fromblue )*incr)/fstep);
X           }
X        }
X     if (step >= rotate_size) step = oldstep;
X     spindac(direction, step);
X     }
X      if (step >= rotate_size) step = oldstep;
X      kbdchar = getakey();
X      if (paused && (kbdchar != ' ' && kbdchar != 'c' && kbdchar != 'C' ))
X     paused = 0;            /* clear paused condition    */
X      switch (kbdchar) {
X     case '+':                      /* '+' means rotate forward     */
X         case RIGHT_ARROW:              /* RightArrow = rotate fwd      */
X        fkey = 0;
X        direction = 1;
X        last = rotate_max;
X        next = rotate_lo;
X        incr = 999;
X        break;
X     case '-':                      /* '-' means rotate backward    */
X         case LEFT_ARROW:               /* LeftArrow = rotate bkwd      */
X        fkey = 0;
X        direction = -1;
X        last = rotate_lo;
X        next = rotate_max;
X        incr = 999;
X        break;
X         case UP_ARROW:                 /* UpArrow means speed up       */
X        daclearn = 1;
X        if (++daccount >= colors) --daccount;
X        break;
X         case DOWN_ARROW:               /* DownArrow means slow down    */
X        daclearn = 1;
X        if (daccount > 1) daccount--;
X        break;
X     case '1':
X     case '2':
X     case '3':
X     case '4':
X     case '5':
X     case '6':
X     case '7':
X     case '8':
X     case '9':
X        step = kbdchar - '0';   /* change step-size */
X        if (step > rotate_size) step = rotate_size;
X        break;
X         case F1:                       /* F1 - F10:                    */
X         case F2:                       /* select a shading factor      */
X         case F3:
X         case F4:
X         case F5:
X         case F6:
X         case F7:
X         case F8:
X         case F9:
X         case F10:
X#ifndef XFRACT
X            fkey = kbdchar-1058;
X#else
X            switch (kbdchar) {
X               case F1:
X                  fkey = 1;break;
X               case F2:
X                  fkey = 2;break;
X               case F3:
X                  fkey = 3;break;
X               case F4:
X                  fkey = 4;break;
X               case F5:
X                  fkey = 5;break;
X               case F6:
X                  fkey = 6;break;
X               case F7:
X                  fkey = 7;break;
X               case F8:
X                  fkey = 8;break;
X               case F9:
X                  fkey = 9;break;
X               case F10:
X                  fkey = 10;break;
X            }
X#endif
X        if (reallyega) fkey = (fkey+1)>>1; /* limit on EGA */
X        fstep = 1;
X        incr = 999;
X        break;
X         case ENTER:                    /* enter key: randomize all colors */
X         case ENTER_2:                  /* also the Numeric-Keypad Enter */
X            fkey = rand15()/3277 + 1;
X        if (reallyega)        /* limit on EGAs */
X           fkey = (fkey+1)>>1;
X        fstep = 1;
X        incr = 999;
X        oldstep = step;
X        step = rotate_size;
X        break;
X     case 'r':                      /* color changes */
X        if (changecolor    == -1) changecolor = 0;
X     case 'g':                      /* color changes */
X        if (changecolor    == -1) changecolor = 1;
X     case 'b':                      /* color changes */
X        if (changecolor    == -1) changecolor = 2;
X        if (changedirection == 0) changedirection = -1;
X     case 'R':                      /* color changes */
X        if (changecolor    == -1) changecolor = 0;
X     case 'G':                      /* color changes */
X        if (changecolor    == -1) changecolor = 1;
X     case 'B':                      /* color changes */
X        if (dotmode == 11) break;
X        if (changecolor    == -1) changecolor = 2;
X        if (changedirection == 0) changedirection = 1;
X        if (reallyega) break;    /* no sense on real EGAs */
X        for (i = 1; i < 256; i++) {
X           dacbox[i][changecolor] += changedirection;
X           if (dacbox[i][changecolor] == 64)
X           dacbox[i][changecolor] = 63;
X           if (dacbox[i][changecolor] == 255)
X          dacbox[i][changecolor] = 0;
X           }
X        changecolor    = -1;    /* clear flags for next time */
X        changedirection = 0;
X        paused        = 0;    /* clear any pause */
X     case ' ':                      /* use the spacebar as a "pause" toggle */
X     case 'c':                      /* for completeness' sake, the 'c' too */
X     case 'C':
X        pauserotate();        /* pause */
X        break;
X     case '>':            /* single-step */
X     case '.':
X     case '<':
X     case ',':
X        if (kbdchar == '>' || kbdchar == '.') {
X           direction = 1;
X           last = rotate_max;
X           next = rotate_lo;
X           incr = 999;
X           }
X        else {
X           direction = -1;
X           last = rotate_lo;
X           next = rotate_max;
X           incr = 999;
X           }
X        fkey = 0;
X        spindac(direction,1);
X        if (! paused)
X           pauserotate();        /* pause */
X        break;
X     case 'd':                      /* load colors from "default.map" */
X     case 'D':
X        if (ValidateLuts("default") != 0)
X           break;
X        fkey = 0;            /* disable random generation */
X        pauserotate();        /* update palette and pause */
X        break;
X     case 'a':                      /* load colors from "altern.map" */
X     case 'A':
X        if (ValidateLuts("altern") != 0)
X           break;
X        fkey = 0;            /* disable random generation */
X        pauserotate();        /* update palette and pause */
X        break;
X     case 'l':                      /* load colors from a specified map */
X#ifndef XFRACT /* L is used for RIGHT_ARROW in Unix keyboard mapping */
X     case 'L':
X#endif
X        load_palette();
X        fkey = 0;            /* disable random generation */
X        pauserotate();        /* update palette and pause */
X        break;
X     case 's':                      /* save the palette */
X     case 'S':
X        save_palette();
X        fkey = 0;            /* disable random generation */
X        pauserotate();        /* update palette and pause */
X        break;
X         case ESC:                      /* escape */
X        more = 0;            /* time to bail out */
X        break;
X     default:            /* maybe a new palette */
X        if (reallyega) break;    /* no sense on real EGAs */
X        fkey = 0;            /* disable random generation */
X        if (kbdchar == 1084) set_palette(Black, White);
X        if (kbdchar == SF2) set_palette(Red, Yellow);
X        if (kbdchar == SF3) set_palette(Blue, Green);
X        if (kbdchar == SF4) set_palette(Black, Yellow);
X        if (kbdchar == SF5) set_palette(Black, Red);
X        if (kbdchar == SF6) set_palette(Black, Blue);
X        if (kbdchar == SF7) set_palette(Black, Green);
X        if (kbdchar == SF8) set_palette(Blue, Yellow);
X        if (kbdchar == SF9) set_palette(Red, Green);
X        if (kbdchar == 1093) set_palette(Green, White);
X        if (kbdchar == 1094) set_palette2(Black, White);
X        if (kbdchar == 1095) set_palette2(Red, Yellow);
X        if (kbdchar == 1096) set_palette2(Blue, Green);
X        if (kbdchar == 1097) set_palette2(Black, Yellow);
X        if (kbdchar == 1098) set_palette2(Black, Red);
X        if (kbdchar == 1099) set_palette2(Black, Blue);
X        if (kbdchar == 1100) set_palette2(Black, Green);
X        if (kbdchar == 1101) set_palette2(Blue, Yellow);
X        if (kbdchar == 1102) set_palette2(Red, Green);
X        if (kbdchar == 1103) set_palette2(Green, White);
X        if (kbdchar == 1104) set_palette3(Blue, Green, Red);
X        if (kbdchar == 1105) set_palette3(Blue, Yellow, Red);
X        if (kbdchar == 1106) set_palette3(Red, White, Blue);
X        if (kbdchar == 1107) set_palette3(Red, Yellow, White);
X        if (kbdchar == 1108) set_palette3(Black, Brown, Yellow);
X        if (kbdchar == 1109) set_palette3(Blue, Brown, Green);
X        if (kbdchar == 1110) set_palette3(Blue, Green, Green);
X        if (kbdchar == 1111) set_palette3(Blue, Green, White);
X        if (kbdchar == 1112) set_palette3(Green, Green, White);
X        if (kbdchar == 1113) set_palette3(Red, Blue, White);
X        pauserotate();  /* update palette and pause */
X        break;
X     }
X      }
X
X   helpmode = oldhelpmode;        /* return to previous help mode */
X   EXIT_OVLY;
X}
X
Xstatic void pauserotate()        /* pause-the-rotate routine */
X{
Xint olddaccount;            /* saved dac-count value goes here */
XBYTE olddac0,olddac1,olddac2;
X
X   if (paused)                /* if already paused , just clear */
X      paused = 0;
X   else {                /* else set border, wait for a key */
X      olddaccount = daccount;
X      olddac0 = dacbox[0][0];
X      olddac1 = dacbox[0][1];
X      olddac2 = dacbox[0][2];
X      daccount = 256;
X      dacbox[0][0] = 48;
X      dacbox[0][1] = 48;
X      dacbox[0][2] = 48;
X      spindac(0,1);            /* show white border */
X      if (dotmode == 11)
X         dvid_status(100," Paused in \"color cycling\" mode ");
X#ifndef XFRACT
X      while (!keypressed());          /* wait for any key */
X#else
X      waitkeypressed(0);                /* wait for any key */
X#endif
X      if (dotmode == 11)
X     dvid_status(0,"");
X      dacbox[0][0] = olddac0;
X      dacbox[0][1] = olddac1;
X      dacbox[0][2] = olddac2;
X      spindac(0,1);            /* show black border */
X      daccount = olddaccount;
X      paused = 1;
X      }
X}
X
Xstatic void set_palette(start, finish)
XBYTE start[3], finish[3];
X{
X   int i, j;
X   dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
X   for(i=1;i<=255;i++)            /* fill the palette    */
X      for (j = 0; j < 3; j++)
X     dacbox[i][j] = (i*start[j] + (256-i)*finish[j])/255;
X}
X
Xstatic void set_palette2(start, finish)
XBYTE start[3], finish[3];
X{
X   int i, j;
X   dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
X   for(i=1;i<=128;i++)
X      for (j = 0; j < 3; j++) {
X     dacbox[i][j]      = (i*finish[j] + (128-i)*start[j] )/128;
X     dacbox[i+127][j] = (i*start[j]  + (128-i)*finish[j])/128;
X      }
X}
X
Xstatic void set_palette3(start, middle, finish)
XBYTE start[3], middle[3], finish[3];
X{
X   int i, j;
X   dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
X   for(i=1;i<=85;i++)
X      for (j = 0; j < 3; j++) {
X     dacbox[i][j]      = (i*middle[j] + (86-i)*start[j] )/85;
X     dacbox[i+85][j]  = (i*finish[j] + (86-i)*middle[j])/85;
X     dacbox[i+170][j] = (i*start[j]  + (86-i)*finish[j])/85;
X      }
X}
X
X
Xvoid save_palette()
X{
X   FILE *dacfile;
X   int i,oldhelpmode;
X   oldhelpmode = helpmode;
X   stackscreen();
X   temp1[0] = 0;
X   helpmode = HELPCOLORMAP;
X   i = field_prompt(0,"Name of map file to write",NULL,temp1,60,NULL);
X   unstackscreen();
X   if (i != -1 && temp1[0]) {
X      if (strchr(temp1,'.') == NULL)
X     strcat(temp1,".map");
X      dacfile = fopen(temp1,"w");
X      if (dacfile == NULL)
X     buzzer(2);
X      else {
X#ifndef XFRACT
X     for (i = 0; i < colors; i++)
X#else
X     for (i = 0; i < 256; i++)
X#endif
X        fprintf(dacfile, "%3d %3d %3d\n",
X            dacbox[i][0] << 2,
X            dacbox[i][1] << 2,
X            dacbox[i][2] << 2);
X     memcpy(olddacbox,dacbox,256*3);
X     colorstate = 2;
X     strcpy(colorfile,temp1);
X     }
X      fclose(dacfile);
X      }
X   helpmode = oldhelpmode;
X}
X
X
Xvoid load_palette(void)
X{
X   int i,oldhelpmode;
X   char filename[80];
X   oldhelpmode = helpmode;
X   strcpy(filename,colorfile);
X   stackscreen();
X   helpmode = HELPCOLORMAP;
X   i = getafilename("Select a MAP File",mapmask,filename);
X   unstackscreen();
X   if (i >= 0)
X      if (ValidateLuts(filename) == 0)
X     memcpy(olddacbox,dacbox,256*3);
X   helpmode = oldhelpmode;
X}
X
X
SHAR_EOF
$TOUCH -am 1028230093 rotate.c &&
chmod 0644 rotate.c ||
echo "restore of rotate.c failed"
set `wc -c rotate.c`;Wc_c=$1
if test "$Wc_c" != "14636"; then
    echo original size 14636, current size $Wc_c
fi
# ============= slideshw.c ==============
echo "x - extracting slideshw.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > slideshw.c &&
X/***********************************************************************/
X/* These routines are called by getakey to allow keystrokes to control */
X/* Fractint to be read from a file.                       */
X/***********************************************************************/
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <ctype.h>
X#include <time.h>
X#include <string.h>
X#ifndef XFRACT
X#include <conio.h>
X#endif
X#include "fractint.h"
X#include "prototyp.h"
X
Xstatic void sleep(int);
Xstatic int  showtempmsg_txt(int,int,int,int,char *);
Xstatic void message(int secs, char far *buf);
Xstatic void slideshowerr(char far *msg);
Xstatic int  get_scancode(char *mn);
Xstatic char far *get_mnemonic(int code);
X
Xstruct scancodes
X{
X   int code;
X   char far *mnemonic;
X};
Xstatic struct scancodes far scancodes[] =
X{
X   {  ENTER,      "ENTER"       },
X   {  INSERT,      "INSERT"      },
X   {  DELETE,      "DELETE"      },
X   {  ESC,      "ESC"         },
X   {  TAB,      "TAB"         },
X   {  PAGE_UP,      "PAGEUP"      },
X   {  PAGE_DOWN,  "PAGEDOWN"    },
X   {  HOME,      "HOME"        },
X   {  END,      "END"         },
X   {  LEFT_ARROW, "LEFT"        },
X   {  RIGHT_ARROW,"RIGHT"       },
X   {  UP_ARROW,   "UP"          },
X   {  DOWN_ARROW, "DOWN"        },
X   {  F1,      "F1"          },
X   {  -1,      NULL        }
X};
X#define stop sizeof(scancodes)/sizeof(struct scancodes)-1
X
Xstatic int get_scancode(char *mn)
X{
X   int i;
X   i = 0;
X   for(i=0;i< stop;i++)
X      if(far_strcmp((char far *)mn,scancodes[i].mnemonic)==0)
X     break;
X   return(scancodes[i].code);
X}
X
Xstatic char far *get_mnemonic(int code)
X{
X   int i;
X   i = 0;
X   for(i=0;i< stop;i++)
X      if(code == scancodes[i].code)
X     break;
X   return(scancodes[i].mnemonic);
X}
X#undef stop
X
Xchar busy = 0;
Xstatic FILE *fp = NULL;
Xextern int slides;
Xextern int text_type;
Xextern int calc_status;
Xextern char autoname[];
Xstatic long starttick;
Xstatic long ticks;
Xstatic int slowcount;
Xstatic unsigned int quotes;
Xstatic char calcwait = 0;
Xstatic int repeats = 0;
Xstatic int last = 0;
Xstatic char far smsg[] = "MESSAGE";
Xstatic char far sgoto[] = "GOTO";
Xstatic char far scalcwait[] = "CALCWAIT";
Xstatic char far swait[] = "WAIT";
X
X/* places a temporary message on the screen in text mode */
Xstatic int showtempmsg_txt(int row, int col, int attr,int secs,char *txt)
X{
X   int savescrn[80];
X   int i;
X   if(text_type > 1)
X      return(1);
X   for(i=0;i<80;i++)
X   {
X      movecursor(row,i);
X      savescrn[i] = get_a_char();
X   }
X   putstring(row,col,attr,txt);
X   movecursor(25,80);
X   sleep(secs);
X   for(i=0;i<80;i++)
X   {
X      movecursor(row,i);
X      put_a_char(savescrn[i]);
X   }
X   return(0);
X}
X
Xstatic void message(int secs, char far *buf)
X{
X   int i;
X   char nearbuf[41];
X   i = -1;
X   while(buf[++i] && i< 40)
X      nearbuf[i] = buf[i];
X   nearbuf[i] = 0;
X   if(text_type < 2)
X      showtempmsg_txt(0,0,7,secs,nearbuf);
X   else if (showtempmsg(nearbuf) == 0)
X      {
X     sleep(secs);
X     cleartempmsg();
X      }
X}
X
X/* this routine reads the file autoname and returns keystrokes */
Xint slideshw()
X{
X   int out,err,i;
X   char buffer[81];
X   if(calcwait)
X   {
X      if(calc_status == 1 || busy) /* restart timer - process not done */
X     return(0); /* wait for calc to finish before reading more keystrokes */
X      calcwait = 0;
X   }
X   if(fp==NULL)   /* open files first time through */
X      if(startslideshow()==0)
X     {
X     stopslideshow();
X     return (0);
X     }
X
X   if(ticks) /* if waiting, see if waited long enough */
X   {
X      if(clock_ticks() - starttick < ticks) /* haven't waited long enough */
X     return(0);
X      ticks = 0;
X   }
X   if (++slowcount <= 18)
X   {
X      starttick = clock_ticks();
X      ticks = CLK_TCK/5; /* a slight delay so keystrokes are visible */
X      if (slowcount > 10)
X     ticks /= 2;
X   }
X   if(repeats>0)
X   {
X      repeats--;
X      return(last);
X   }
Xstart:
X   if(quotes) /* reading a quoted string */
X   {
X      if((out=fgetc(fp)) != '\"' && out != EOF)
X     return(last=out);
X      quotes = 0;
X   }
X   /* skip white space: */
X   while ((out=fgetc(fp)) == ' ' || out == '\t' || out == '\n') { }
X   switch(out)
X   {
X      case EOF:
X     stopslideshow();
X     return(0);
X      case '\"':        /* begin quoted string */
X     quotes = 1;
X     goto start;
X      case ';':         /* comment from here to end of line, skip it */
X     while((out=fgetc(fp)) != '\n' && out != EOF) { }
X     goto start;
X      case '*':
X     if (fscanf(fp,"%d",&repeats) != 1
X       || repeats <= 1 || repeats >= 256 || feof(fp))
X     {
X        static char far msg[] = "error in * argument";
X        slideshowerr(msg);
X        last = repeats = 0;
X     }
X     repeats -= 2;
X     return(out = last);
X   }
X
X   i = 0;
X   while(1) /* get a token */
X   {
X      if(i < 80)
X     buffer[i++] = out;
X      if((out=fgetc(fp)) == ' ' || out == '\t' || out == '\n' || out == EOF)
X     break;
X   }
X   buffer[i] = 0;
X   if(buffer[i-1] == ':')
X      goto start;
X   out = -12345;
X   if(isdigit(buffer[0]))    /* an arbitrary scan code number - use it */
X     out=atoi(buffer);
X   else if(far_strcmp((char far *)buffer,smsg)==0)
X      {
X     int secs;
X     out = 0;
X     if (fscanf(fp,"%d",&secs) != 1)
X     {
X        static char far msg[] = "MESSAGE needs argument";
X        slideshowerr(msg);
X     }
X     else
X     {
X        int len;
X        char buf[41];
X        buf[40] = 0;
X        fgets(buf,40,fp);
X        len = strlen(buf);
X        buf[len-1]=0; /* zap newline */
X        message(secs,(char far *)buf);
X     }
X     out = 0;
X      }
X   else if(far_strcmp((char far *)buffer,sgoto)==0)
X      {
X     if (fscanf(fp,"%s",buffer) != 1)
X     {
X        static char far msg[] = "GOTO needs target";
X        slideshowerr(msg);
X        out = 0;
X     }
X     else
X     {
X        char buffer1[80];
X        rewind(fp);
X        strcat(buffer,":");
X        do
X        {
X           err = fscanf(fp,"%s",buffer1);
X        } while( err == 1 && strcmp(buffer1,buffer) != 0);
X        if(feof(fp))
X        {
X           static char far msg[] = "GOTO target not found";
X           slideshowerr(msg);
X           return(0);
X        }
X        goto start;
X     }
X      }
X   else if((i = get_scancode(buffer)) > 0)
X     out = i;
X   else if(far_strcmp(swait,(char far *)buffer)==0)
X      {
X     float fticks;
X     err = fscanf(fp,"%f",&fticks); /* how many ticks to wait */
X     fticks *= CLK_TCK;        /* convert from seconds to ticks */
X     if(err==1)
X     {
X        ticks = fticks;
X        starttick = clock_ticks();    /* start timing */
X     }
X     else
X     {
X        static char far msg[] = "WAIT needs argument";
X        slideshowerr(msg);
X     }
X     slowcount = out = 0;
X      }
X   else if(far_strcmp(scalcwait,(char far *)buffer)==0) /* wait for calc to finish */
X      {
X     calcwait = 1;
X     slowcount = out = 0;
X      }
X   else if((i=check_vidmode_keyname(buffer)))
X      out = i;
X   if(out == -12345)
X   {
X      extern char s_cantunderstand[];
X      char msg[80];
X      sprintf(msg,s_cantunderstand,buffer);
X      slideshowerr(msg);
X      out = 0;
X   }
X   return(last=out);
X}
X
Xstartslideshow()
X{
X   if((fp=fopen(autoname,"r"))==NULL)
X      slides = 0;
X   ticks = 0;
X   quotes = 0;
X   calcwait = 0;
X   slowcount = 0;
X   return(slides);
X}
X
Xvoid stopslideshow()
X{
X   if(fp)
X      fclose(fp);
X   fp = NULL;
X   slides = 0;
X}
X
Xvoid recordshw(int key)
X{
X   char far *mn;
X   float dt;
X   dt = ticks;       /* save time of last call */
X   ticks=clock_ticks();  /* current time */
X   if(fp==NULL)
X      if((fp=fopen(autoname,"w"))==NULL)
X     return;
X   dt = ticks-dt;
X   dt /= CLK_TCK;  /* dt now in seconds */
X   if(dt > .5) /* don't bother with less than half a second */
X   {
X      if(quotes) /* close quotes first */
X      {
X     quotes=0;
X     fprintf(fp,"\"\n",dt);
X      }
X      fprintf(fp,"WAIT %4.1f\n",dt);
X   }
X   if(key >= 32 && key < 128)
X   {
X      if(!quotes)
X      {
X     quotes=1;
X     fputc('\"',fp);
X      }
X      fputc(key,fp);
X   }
X   else
X   {
X      if(quotes) /* not an ASCII character - turn off quotes */
X      {
X     fprintf(fp,"\"\n");
X     quotes=0;
X      }
X      if((mn=get_mnemonic(key)) != NULL)
X#ifndef XFRACT
X      fprintf(fp,"%Fs",mn);
X#else
X          fprintf(fp,"%s",mn);
X#endif
X      else if (check_vidmode_key(0,key) >= 0)
X     {
X        char buf[10];
X        vidmode_keyname(key,buf);
X        fprintf(fp,buf);
X     }
X      else /* not ASCII and not FN key */
X     fprintf(fp,"%4d",key);
X      fputc('\n',fp);
X   }
X}
X
X/* suspend process # of seconds */
Xstatic void sleep(int secs)
X{
X   long stop;
X   stop = clock_ticks() + (long)secs*CLK_TCK;
X   while(clock_ticks() < stop && kbhit() == 0) { } /* bailout if key hit */
X}
X
Xstatic void slideshowerr(char far *msg)
X{
X   char msgbuf[300];
X   static char far errhdg[] = "Slideshow error:\n";
X   stopslideshow();
X   far_strcpy(msgbuf,errhdg);
X   far_strcat(msgbuf,msg);
X   stopmsg(0,msgbuf);
X}
SHAR_EOF
$TOUCH -am 1028230093 slideshw.c &&
chmod 0644 slideshw.c ||
echo "restore of slideshw.c failed"
set `wc -c slideshw.c`;Wc_c=$1
if test "$Wc_c" != "8468"; then
    echo original size 8468, current size $Wc_c
fi
# ============= targa.c ==============
echo "x - extracting targa.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > targa.c &&
X/** targa.c **/
X
X#ifdef __TURBOC__
X#    pragma    warn -par
X#endif
X
X#define TARGA_DATA
X
X#include    <stdio.h>
X#include    <stdlib.h>
X#include    <string.h>
X#ifndef XFRACT
X#include    <conio.h>
X#endif
X#include    "targa.h"
X#include    "fractint.h"
X#include    "prototyp.h"
X
X
X/*************    ****************/
X
Xextern char far *mapdacbox;
X
X/*************    ****************/
X
Xvoid    WriteTGA( int x, int y, int index );
Xint    ReadTGA ( int x, int y );
Xvoid    EndTGA    ( void );
Xvoid    StartTGA( void );
Xvoid    ReopenTGA( void );
X
X/*************    ****************/
X
Xstatic unsigned _fastcall near Row16Calculate(unsigned,unsigned);
Xstatic void    _fastcall near PutPix16(int,int,int);
Xstatic unsigned _fastcall near GetPix16(int,int);
Xstatic unsigned _fastcall near Row32Calculate(unsigned,unsigned);
Xstatic void    _fastcall near PutPix32(int,int,int);
Xstatic unsigned _fastcall near GetPix32(int,int);
Xstatic void    _fastcall near DoFirstPixel(int,int,int);
Xstatic void _fastcall fatalerror(char far *);
Xstatic int  GetLine(int);
Xstatic void _fastcall near SetDispReg(int,int);
Xstatic int  VWait(void);
Xstatic void _fastcall SetVBorder(int,int);
Xstatic void _fastcall SetBorderColor(long);
Xstatic void _fastcall SetVertShift(int);
Xstatic void _fastcall SetInterlace(int);
Xstatic void _fastcall SetBlndReg(int);
Xstatic void _fastcall SetRGBorCV(int);
Xstatic void _fastcall SetVCRorCamera(int);
Xstatic void _fastcall SetMask(int);
Xstatic void _fastcall SetBlndReg(int);
Xstatic void _fastcall SetContrast(int);
Xstatic void _fastcall SetHue(int);
Xstatic void _fastcall SetSaturation(int);
Xstatic void _fastcall SetHBorder(int,int);
Xstatic void SetFixedRegisters(void);
Xstatic void _fastcall VCenterDisplay(int);
Xstatic void _fastcall SetOverscan(int);
Xstatic void _fastcall near TSetMode(int);
Xstatic int  GraphInit(void);
Xstatic void GraphEnd(void);
X
X/*************    ****************/
X
Xint         xorTARGA;
Xunsigned far *tga16 = NULL;  /* [256] */
Xlong     far *tga32;         /* [256] */
Xstatic int   last = 0;
X
X/*************    ****************/
X
Xextern int    sxdots,sydots;        /* # of dots on the physical screen */
Xstatic int    initialized;
X
X/*************    ****************/
X
Xstatic void    (near _fastcall *DoPixel) ( int x, int y, int index );
Xstatic void    (near _fastcall *PutPixel)( int x, int y, int index );
Xstatic unsigned (near _fastcall *GetPixel)( int x, int y );
X
X/**************************************************************************/
X#ifdef __BORLANDC__
X#if(__BORLANDC__ > 2)
X   #pragma warn -eff
X#endif
X#endif
X
Xstatic unsigned _fastcall near Row16Calculate( unsigned line, unsigned x1 )
X{
X    outp( DESTREG, (line >> 5) );
X    return( ((line & 31) << 10) | (x1 << 1) ); /* calc the pixel offset */
X}
X
X/**************************************************************************/
X
Xstatic void _fastcall near PutPix16( int x, int y, int index )
X{
Xunsigned far * ip;
X
X    /**************/
X    ip = MK_FP( MEMSEG, Row16Calculate( y, x ) );
X    if( ! xorTARGA )
X        *ip = tga16[index];
X    else
X        *ip = *ip ^ 0x7fff;
X}
X
X/**************************************************************************/
X
Xstatic unsigned _fastcall near GetPix16( int x, int y )
X{
Xregister unsigned pixel, index;
Xunsigned far * ip;
X    /**************/
X    ip = MK_FP( MEMSEG, Row16Calculate( y, x ) );
X    pixel = *ip & 0x7FFF;
X    if( pixel == tga16[last] ) return( last );
X    for( index = 0; index < 256; index++ )
X        if( pixel == tga16[index] ) {
X            last = index;
X            return( index );
X        }
X    return( 0 );
X}
X
X/**************************************************************************/
X
Xstatic unsigned _fastcall near Row32Calculate( unsigned line, unsigned x1 )
X{
X    outp( DESTREG, (line >> 4) );
X    return ( ((line & 15) << 11) | (x1 << 2) ); /* calc the pixel offset */
X}
X
X/**************************************************************************/
X
Xstatic void _fastcall near PutPix32( int x, int y, int index )
X{
Xlong far * lp;
X    lp = MK_FP( MEMSEG, Row32Calculate( y, x ) );
X    if( ! xorTARGA )
X        *lp = tga32[index];
X    else
X        *lp = *lp ^ 0x00FFFFFF;
X}
X
X/**************************************************************************/
X
Xstatic unsigned _fastcall near GetPix32( int x, int y )
X{
Xregister int index;
Xlong    pixel;
Xlong    far * lp;
X
X    lp = MK_FP( MEMSEG, Row32Calculate( y, x ) );
X    pixel = *lp & 0x00FFFFFF;
X    if( pixel == tga32[last] ) return( last );
X    for( index = 0; index < 256; index++ )
X        if( pixel == tga32[index] ) {
X            last = index;
X            return( index );
X        }
X    return( 0 );
X}
X
X/**************************************************************************/
X
Xstatic void _fastcall near DoFirstPixel( int x, int y, int index )
X{
Xint cnt;
X    TSetMode( targa.mode | 1 );
X    for( cnt = 0; cnt < targa.MaxBanks; cnt += 2 ) { /* erase */
X        outp( DESTREG, cnt );
X        outp( SRCREG,  cnt + 1 );
X        erasesegment(targa.memloc,0);  /** general.asm **/
X    }
X    TSetMode( targa.mode & 0xFFFE );
X    PutPixel = DoPixel;
X    (*PutPixel)( x, y, index );
X}
X
X#ifdef __BORLANDC__
X#if(__BORLANDC__ > 2)
X   #pragma warn +eff
X#endif
X#endif
X
X/***************************************************************************/
X
Xvoid WriteTGA( int x, int y, int index )
X{
X    OUTPORTB(MODEREG, targa.mode |= 1 );    /* TSetMode inline for speed */
X    (*PutPixel)( x, sydots-y, index&0xFF ); /* fix origin to match EGA/VGA */
X    OUTPORTB(MODEREG, targa.mode &= 0xFFFE );
X}
X
X/***************************************************************************/
X
Xint ReadTGA( int x, int y )
X{
Xint val;
X    OUTPORTB(MODEREG, targa.mode |= 1 );    /* TSetMode inline for speed */
X    val = (*GetPixel)( x, sydots-y );
X    OUTPORTB(MODEREG, targa.mode &= 0xFFFE );
X    return( val );
X}
X
X/***************************************************************************/
X
Xvoid EndTGA( void )
X{
X    if( initialized ) {
X        GraphEnd();
X        initialized = 0;
X    }
X}
X
X/***************************************************************************/
X
Xvoid StartTGA()
X{
Xint    i;
Xstatic char far couldntfind[]={"Could not find Targa card"};
Xstatic char far noenvvar[]={"TARGA environment variable missing"};
Xstatic char far insuffmem[]={"Insufficient memory for Targa"};
X
X    /****************/
X    if( initialized ) return;
X    initialized = 1;
X
X    /****************/
X    /* note that video.asm has already set the regualar video adapter */
X    /* to text mode (ax in Targa table entries is 3);          */
X    /* that's necessary because TARGA can live at 0xA000, we DO NOT   */
X    /* want to have an EGA/VGA in graphics mode!!              */
X    ReopenTGA(); /* clear text screen and display message */
X
X    /****************/
X    /*** look for and activate card ***/
X    if ((i = GraphInit()))
X        fatalerror((i == -1) ? couldntfind : noenvvar);
X
X    VCenterDisplay( sydots + 1 );
X
X    if (tga16 == NULL)
X        if ( (tga16 = (unsigned far *)farmemalloc(512L)) == NULL
X          || (tga32 = (long     far *)farmemalloc(1024L)) == NULL)
X        fatalerror(insuffmem);
X
X    SetTgaColors();
X
X    if( targa.boardType == 16 ) {
X        GetPixel = GetPix16;
X        DoPixel = PutPix16;
X    }
X    else {
X        GetPixel = GetPix32;
X        DoPixel = PutPix32;
X    }
X    PutPixel = DoFirstPixel;    /* on first pixel --> erase */
X
X    if( sydots == 482 ) SetOverscan( 1 );
X
X    TSetMode( targa.mode & 0xFFFE );
X
X    /****************/
X    if (mapdacbox == NULL && SetColorPaletteName("default") != 0)
X        exit( 1 ); /* stopmsg has already been issued */
X
X}
X
Xvoid ReopenTGA()
X{
Xstatic char far runningontarga[]={"Running On TrueVision TARGA Card"};
X    helptitle();
X    putstring(2,20,7,runningontarga);
X    movecursor(6,0); /* in case of brutal exit */
X}
X
Xstatic void _fastcall fatalerror(char far *msg)
X{
Xstatic char far abortmsg[]={"...aborting!"};
X    putstring(4,20,15,msg);
X    putstring(5,20,15,abortmsg);
X    movecursor(8,0);
X    exit(1);
X}
X
X
X
X/***  the rest of this module used to be separate, in tgasubs.c,  ***/
X/***  has now been merged into a single source              ***/
X
X/*******************************************************************/
X
Xstatic void _fastcall VCenterDisplay( int nLines )
X{
Xint    lines;
Xint top, bottom;
Xlong color;
X
X    lines  = nLines >> 1;        /* half value of last line 0..x */
X    top    = 140 - (lines >> 1);
X    bottom = top + lines;
X    SetVBorder( top, bottom );
X    SetVertShift( 255 - lines );    /* skip lines we're not using */
X
X    if( targa.boardType == 16 )
X        color = (12 << 10) | (12 << 5) | 12;
X    else
X        color = ((long)80 << 16) | (80 << 8) | 80;
X    SetBorderColor( color );
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall near SetDispReg(int reg, int value)
X{
X    targa.DisplayRegister[reg] = value;
X
X    TSetMode(targa.mode&MSK_REGWRITE);  /* select Index Register write */
X    OUTPORTB(DRREG, reg);    /* select sync register */
X    /*
X     *        Set Mask register to write value to
X     *        display register and to set Bit 9 in the DR
X     */
X    TSetMode( ((targa.mode|(~MSK_REGWRITE))     /* turn on write bit */
X                   & MSK_BIT9       )     /* turn off Bit 9 */
X               | ((value&0x0100)>>1)); /* set bit 9 for value */
X    OUTPORTB(DRREG, value); /* select sync register */
X }
X
X/*****************************************************************/
X
X#define   WAITCOUNT  60000
X
Xstatic int VWait()
X{
Xint    rasterreg;
Xunsigned GiveUp;
X
X    rasterreg = RASTERREG;
X
X    /*
X     *    If beyond bottom of frame wait for next field
X     */
X    GiveUp= WAITCOUNT;
X    while ( (--GiveUp) && (GetLine(rasterreg) == 0) ) { }
X    if (GiveUp) {
X       /*
X        *       Wait for the bottom of the border
X        */
X       GiveUp= WAITCOUNT;
X       while ( (--GiveUp) && (GetLine(rasterreg) > 0) ) { }
X       }
X
X    return ( ( GiveUp ) ? 0 : -1);
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetVBorder(int top, int bottom)
X{
X    /* top border */
X    if ( top < MIN_TOP ) top=MIN_TOP;
X    SetDispReg(TOPBORDER,top);
X    /* bottom border */
X    if ( bottom > MAX_BOTTOM ) bottom=MAX_BOTTOM;
X    SetDispReg(BOTTOMBORDER,bottom);
X
X    SetDispReg(DR10,top);
X    SetDispReg(DR11,bottom);
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetRGBorCV(int type)
X{
X    /*  set the contrast level */
X    targa.RGBorCV = type;
X    targa.VCRCon = ( targa.VCRCon  & MSK_RGBORCV ) |
X                    (targa.RGBorCV<<SHF_RGBORCV) ;
X    OUTPORTB(VCRCON, targa.VCRCon );
X}
X
X/*****************************************************************/
X
Xstatic void _fastcall SetVCRorCamera(int type)
X{
X    targa.VCRorCamera = type&1;
X    targa.VCRCon = ( targa.VCRCon  & MSK_VCRORCAMERA ) |
X                    (targa.VCRorCamera<<SHF_VCRORCAMERA) ;
X    OUTPORTB(VCRCON, targa.VCRCon );
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetBorderColor(long color)
X{
X    targa.BorderColor = color;
X    OUTPORTB(BORDER, (int)(0x0000ffffL&(color)));
X    OUTPORTB((BORDER+2), (int)((color)>>16));
X}
X
X/*****************************************************************/
X
Xstatic void _fastcall SetMask(int mask)
X{
X    /* mask to valid values and output to mode register */
X    targa.Mask = mask;
X    OUTPORTB(MASKREG, mask);
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetVertShift(int preshift)
X{
X    /*  set the Vertical Preshift count  level */
X    targa.VertShift = preshift;
X    OUTPORTB(VERTPAN, preshift);
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetOverscan(int mode)
X{
Xlong tempColor;
X
X    targa.ovrscnOn = mode;
X    if ( mode == 0 ) {
X            INPORTB(UNDERREG);  /*    select underscan mode */
X            SetHBorder(    (DEF_LEFT+targa.xOffset),
X                        (DEF_RIGHT+targa.xOffset));
X            SetDispReg(4,352);
X            SetDispReg(5,1);
X            SetBorderColor(targa.BorderColor);
X    }
X    else    {
X            INPORTB(OVERREG);   /*    select overrscan mode */
X            SetDispReg(0,64);   /*    Set four of the display registers */
X            SetDispReg(1,363);  /*    to values required for Overscan */
X            SetDispReg(4,363);
X            SetDispReg(5,17);
X            tempColor = targa.BorderColor;
X            SetBorderColor(0L);
X            targa.BorderColor = tempColor;
X    }
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetInterlace(int type)
X{
X    targa.InterlaceMode= type & MSK_INTERLACE;
X    SetDispReg(INTREG, targa.InterlaceMode);
X    /*
X     *    SET THE INTERLACE BIT TO MATCH THE INTERLACE MODE AND
X     *    SCREEN RESOLUTION -  SCREEN PAGE
X     */
X    if ( ( targa.InterlaceMode >= 2 ) &&
X         ( targa.PageMode> 1 )    &&
X         ( (targa.PageMode&1) != 0 )  )
X        TSetMode(targa.mode|(~MSK_IBIT) );
X    else
X        TSetMode(targa.mode& MSK_IBIT);
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetBlndReg(int value)
X{
X    /*  set the Vertical Preshift count  level */
X    if ( targa.boardType == 32 ) {
X        targa.VCRCon = (targa.VCRCon&0xfe) | value;
X        OUTPORTB(BLNDREG, value);
X        }
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall near TSetMode(int mode)
X{
X    /* mask to valid values and output to mode register */
X    OUTPORTB(MODEREG, mode );
X    targa.mode = mode;
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetContrast(int level)
X{
X    /*  set the contrast level */
X    targa.Contrast = level &((~MSK_CONTRAST)>>SHF_CONTRAST);
X    targa.VCRCon = ( targa.VCRCon  & MSK_CONTRAST ) |
X            (targa.Contrast<<SHF_CONTRAST) ;
X    OUTPORTB(VCRCON, targa.VCRCon );
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetHue(int level)
X{
X    /*  set the hue level -  Mask to valid value */
X    targa.Hue = level&((~MSK_HUE)>>SHF_HUE);
X    /* mask to valid range */
X    targa.SatHue = (targa.SatHue&MSK_HUE) | (targa.Hue<<SHF_HUE);
X    OUTPORTB(SATHUE, targa.SatHue );
X}
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetSaturation(int level)
X{
X    /*  set the saturation level */
X    targa.Saturation= level&( (~MSK_SATURATION)>>SHF_SATURATION);
X    targa.SatHue =    (targa.SatHue&MSK_SATURATION) |
X             (targa.Saturation<<SHF_SATURATION);
X    OUTPORTB(SATHUE , targa.SatHue );
X}
X
X
X/*************************************************************/
X
X/*** UNUSED
Xstatic void _fastcall SetPageMode(int pageMode)
X{
X    pageMode &= 0x07;
X    targa.PageMode = pageMode;
X    VWait();
X    TSetMode( (targa.mode)&(MSK_RES) |((pageMode<<SHF_RES)&(~MSK_RES)) ) ;
X    if ( ( targa.DisplayRegister[20] >= 2 ) &&
X         ( pageMode> 1 )  &&
X         ( (pageMode&1) != 0 )      )    TSetMode(targa.mode|(~MSK_IBIT) );
X    else
X        TSetMode(targa.mode& MSK_IBIT);
X}
X***/
X
X
X/*****************************************************************/
X
Xstatic void _fastcall SetHBorder(int left, int right)
X{
X    SetDispReg(LEFTBORDER, left);    /* set horizontal left border */
X    SetDispReg(RIGHTBORDER,right);    /* set horizontal right border */
X/*
X *                    Set DR 8 and 9 since they
X *                    default to tracking DR0 and DR 1
X */
X    SetDispReg(DR8,left);
X    SetDispReg(DR9,left);
X}
X
X
X/*****************************************************************/
X
X/*** UNUSED
Xstatic void _fastcall SetGenlock(int OnOrOff)
X{
X    TSetMode( (targa.mode)&(MSK_GENLOCK)
X            |((OnOrOff<<SHF_GENLOCK)&(~MSK_GENLOCK)) );
X}
X***/
X
X
X/*****************************************************************/
X/* was asm, TC fast enough on AT */
X
Xstatic int GetLine( int port )
X{
Xint cnt;
Xint val1, val2;
X
X    val1 = INPORTB( port );
X    for( cnt = 0; cnt < 20; cnt++ ) {
X        val2 = INPORTB( port );
X        if( val1 == val2 )
X            break;
X        val1 = val2;
X    }
X    return( val1 );
X}
X
X
X/**********************************************************************
X              TINIT
X**********************************************************************/
X
Xstatic int GraphInit()
X{
Xint i;
Xint bottom, top;
Xchar *envptr;
Xunsigned switches, got_switches;
X
X    memset( &targa, 0, sizeof(targa) );
X
X    targa.boardType = TYPE_16;        /* default to T16 */
X    targa.xOffset = 0;  targa.yOffset = 0;    /* default to no offset */
X    targa.LinesPerField= DEF_ROWS/2;    /*  number of lines per field */
X    targa.AlwaysGenLock = DEF_GENLOCK;    /* default to genlock off */
X    targa.PageMode = 0;
X    targa.InterlaceMode = DEF_INT;        /* Defalut:  Interlace Mode 0 */
X    targa.Contrast= DEF_CONTRAST;
X    targa.Saturation = DEF_SATURATION;
X    targa.Hue = DEF_HUE;
X    targa.RGBorCV = CV;            /* default to Composite video */
X    targa.VCRorCamera = CAMERA;
X    targa.PanXOrig = 0; targa.PanYOrig=0;
X    targa.PageUpper= 0xffff;        /* set the bank flags to illega& values */
X    targa.PageLower= 0xffff;        /* so that they will be set the first time */
X    targa.ovrscnAvail = 0;            /* Assume no Overscan option */
X    targa.ovrscnOn = 0;
X
X    if ((envptr = getenv("TARGA")) == NULL)
X       return(-2);
X    switches = got_switches = 0;
X    while (*envptr) {
X       if (*envptr != ' ') ++got_switches;
X       if (*envptr >= '2' && *envptr <= '8')
X          switches |= (1 << ('8' - *envptr));
X       ++envptr;
X       }
X    if (got_switches == 0) { /* all blanks, use default */
X       targa.memloc = (signed int)0xA000;
X       targa.iobase = 0x220;
X       }
X    else {
X       targa.memloc = 0x8000 + ((switches & 0x70) << 8);
X       targa.iobase = 0x200  + ((switches & 0x0f) << 4);
X       }
X
X    if ((envptr = getenv("TARGASET"))) {
X       while(1) { /* parse next parameter */
X          while (*envptr == ' ' || *envptr == ',') ++envptr;
X          if (*envptr == 0) break;
X          if (*envptr >= 'a' && *envptr <= 'z') *envptr -= ('a'-'A');
X          i = atoi(envptr+1);
X          switch (*envptr) {
X         case 'T':
X            if (i == 16) targa.boardType = TYPE_16;
X            if (i == 24) targa.boardType = TYPE_24;
X            if (i == 32) targa.boardType = TYPE_32;
X            break;
X         /* case 'E' not done, meaning not clear */
X         case 'X':
X            targa.xOffset = i;
X            break;
X         case 'Y':
X            targa.yOffset = i;
X            break;
X         case 'I':
X            targa.InterlaceMode = i;
X            break;
X         /* case 'N' not done, I don't know how to handle it */
X         case 'R':
X            targa.RGBorCV = RGB;
X            break;
X         case 'B':
X            targa.VCRorCamera = CAMERA;
X            break;
X         case 'V':
X            targa.VCRorCamera = VCR;
X            break;
X         case 'G':
X            targa.AlwaysGenLock = 1;
X            break;
X         case 'C':
X            targa.Contrast = i * 31 / 100;
X            break;
X         case 'S':
X            targa.Saturation = i * 7 / 100;
X            break;
X         case 'H':
X            targa.Hue = i * 31 / 100;
X            break;
X         /* note: 'A' and 'O' defined but apply only to type M8 */
X         /* case 'P' not handled cause I don't know how */
X         }
X          while (*(++envptr) >= '0' && *envptr <= '9') { }
X          }
X       }
X
X    if ( targa.boardType == TYPE_16 ) {
X        targa.MaxBanks = 16;
X        targa.BytesPerPixel = 2;
X    }
X    if ( targa.boardType == TYPE_24 ) {
X        targa.MaxBanks = 32;
X        targa.BytesPerPixel = 3;
X    }
X    if ( targa.boardType == TYPE_32 ) {
X        targa.MaxBanks = 32;
X        targa.BytesPerPixel = 4;
X    }
X
X    /****** Compute # of rows per 32K bank    ********/
X    targa.RowsPerBank = 512/(targa.MaxBanks);
X    targa.AddressShift =  targa.MaxBanks>>4;
X
X    /*    if initializing CVA:  set these before we quit    */
X    SetSaturation(targa.Saturation);
X    SetHue(targa.Hue);
X    SetContrast( targa.Contrast);
X
X    /*    Set Genlock bit if always genlocked */
X    /*    Set before flipping and jerking screen */
X    TSetMode( (targa.AlwaysGenLock<<SHF_GENLOCK) | DEF_MODE);
X
X    SetBlndReg(0);        /*  disable blend mode on TARGA 32 */
X
X    SetInterlace(targa.InterlaceMode);
X    SetFixedRegisters();
X    SetOverscan( 0 );
X
X    top    = 140 - (targa.LinesPerField / 2);
X    bottom = top + targa.LinesPerField;
X    SetVBorder(top,bottom);
X    SetVertShift(256-targa.LinesPerField);
X
X    SetMask(DEF_MASK);
X    SetRGBorCV (targa.RGBorCV );
X    SetVCRorCamera(targa.VCRorCamera);
X
X    /*    See if the raster register is working correctly and
X        return error flag if its not         */
X    return (( VWait() == -1) ? -1 : 0);
X
X}
X
X
X/**************************************************************/
X
Xstatic void GraphEnd()
X{
X    TSetMode( (targa.mode)&MSK_MSEL );     /*  disable memory */
X}
X
X
X/**************************************************************/
X/* Set the registers which have required values */
X
X#define FIXED_REGS    10
X
Xstatic int FixedRegs[] = {
X    DR6,DR7,DR12,DR13,DR14,DR15,DR16,DR17,DR18,DR19
X};
X
Xstatic int FixedValue[] = {
X    DEF_DR6,DEF_DR7,DEF_DR12,DEF_DR13,DEF_DR14,
X    DEF_DR15,DEF_DR16,DEF_DR17,DEF_DR18,DEF_DR19
X};
X
Xstatic void SetFixedRegisters()
X{
Xint reg;
X
X    for ( reg=0; reg<FIXED_REGS; reg++)
X        SetDispReg(FixedRegs[reg],FixedValue[reg]);
X}
X
X
SHAR_EOF
$TOUCH -am 1028230093 targa.c &&
chmod 0644 targa.c ||
echo "restore of targa.c failed"
set `wc -c targa.c`;Wc_c=$1
if test "$Wc_c" != "19635"; then
    echo original size 19635, current size $Wc_c
fi
# ============= testpt.c ==============
echo "x - extracting testpt.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > testpt.c &&
X/*
X
XWrite your fractal program here. initreal and initimag are the values in
Xthe complex plane; parm1, and parm2 are paramaters to be entered with the
X"params=" option (if needed). The function should return the color associated
Xwith initreal and initimag.  FRACTINT will repeatedly call your function with
Xthe values of initreal and initimag ranging over the rectangle defined by the
X"corners=" option. Assuming your formula is iterative, "maxit" is the maximum
Xiteration. If "maxit" is hit, color "inside" should be returned.
X
XNote that this routine could be sped up using external variables/arrays
Xrather than the current parameter-passing scheme.  The goal, however was
Xto make it as easy as possible to add fractal types, and this looked like
Xthe easiest way.
X
XThis module is part of an overlay, with calcfrac.c.  The routines in it
Xmust not be called by any part of Fractint other than calcfrac.
X
XThe sample code below is a straightforward Mandelbrot routine.
X
X*/
X
Xextern int xdots;        /* the screen is this many dots across */
Xextern int ydots;        /* the screen is this many dots down */
Xextern int colors;        /* the screen has this many colors */
X
Xint teststart()     /* this routine is called just before the fractal starts */
X{
X    return( 0 );
X}
X
Xvoid testend()         /* this routine is called just after the fractal ends */
X{
X}
X
X        /* this routine is called once for every pixel */
X    /* (note: possibly using the dual-pass / solif-guessing options */
X
Xtestpt(initreal,initimag,parm1,parm2,maxit,inside)
Xdouble initreal,initimag,parm1,parm2;
Xint maxit,inside;
X{
Xdouble oldreal, oldimag, newreal, newimag, magnitude;
Xint color;
X   oldreal=parm1;
X   oldimag=parm2;
X   magnitude = 0.0;
X   color = 0;
X   while ((magnitude < 4.0) && (color < maxit)) {
X      newreal = oldreal * oldreal - oldimag * oldimag + initreal;
X      newimag = 2 * oldreal * oldimag + initimag;
X      color++;
X      oldreal = newreal;
X      oldimag = newimag;
X      magnitude = newreal * newreal + newimag * newimag;
X      }
Xif (color >= maxit) color = inside;
Xreturn(color);
X}
SHAR_EOF
$TOUCH -am 1028230093 testpt.c &&
chmod 0644 testpt.c ||
echo "restore of testpt.c failed"
set `wc -c testpt.c`;Wc_c=$1
if test "$Wc_c" != "2048"; then
    echo original size 2048, current size $Wc_c
fi
# ============= tgaview.c ==============
echo "x - extracting tgaview.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > tgaview.c &&
X
X/* Routine to decode Targa 16 bit RGB file
X   */
X
X/* 16 bit .tga files were generated for continuous potential "potfile"s
X   from version 9.? thru version 14.  Replaced by double row gif type
X   file (.pot) in version 15.  Delete this code after a few more revs.
X*/
X
X#include <stdio.h>
X#include "fractint.h"
X#include "targa_lc.h"
X#include "prototyp.h"
X
Xextern char readname[];         /* file name          */
Xextern unsigned int boxx[];        /* write-line routines use this */
Xextern int colors;
Xextern int rowcount;
X
Xstatic FILE *fptarga = NULL;        /* FILE pointer       */
Xextern unsigned int height;        /* image height       */
Xextern int (*outln)();
X
X/* Main entry decoder */
Xtgaview()
X{
X   int i;
X   int cs;
X   unsigned int width;
X   struct fractal_info info;
X   FILE *t16_open();
X
X   if((fptarga = t16_open(readname, (int *)&width, (int *)&height, &cs, (U8 *)&info))==NULL)
X      return(-1);
X
X   rowcount = 0;
X   for (i=0; i<height; ++i)
X   {
X       t16_getline(fptarga, width, (U16 *)boxx);
X       if ((*outln)(boxx,width))
X       {
X      fclose(fptarga);
X      fptarga = NULL;
X      return(-1);
X       }
X       if (keypressed())
X       {
X      fclose(fptarga);
X      fptarga = NULL;
X      return(-1);
X       }
X   }
X   fclose(fptarga);
X   fptarga = NULL;
X   return(0);
X}
X/* Outline function for 16 bit data with 8 bit fudge */
Xoutlin16(BYTE *buffer,int linelen)
X{
X    extern int rowcount;
X    U16 *buf;
X    int i;
X    buf = (U16 *)buffer;
X    for(i=0;i<linelen;i++)
X       putcolor(i,rowcount,buf[i]>>8);
X    rowcount++;
X    return(0);
X}
SHAR_EOF
$TOUCH -am 1028230093 tgaview.c &&
chmod 0644 tgaview.c ||
echo "restore of tgaview.c failed"
set `wc -c tgaview.c`;Wc_c=$1
if test "$Wc_c" != "1504"; then
    echo original size 1504, current size $Wc_c
fi
# ============= tp3d.c ==============
echo "x - extracting tp3d.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > tp3d.c &&
X#include <stdio.h>
X#include "mpmath.h"
X#include "fractint.h"
X#include "prototyp.h"
X
X/* 3D Transparency Variables, MCP 5-30-91 */
Xextern double xxmin, xxmax, yymin, yymax, zzmin, zzmax, ttmin, ttmax;
Xextern int Transparent3D, SolidCore, NumFrames;
Xextern unsigned CoreRed, CoreGreen, CoreBlue;
Xextern int tpdepth, tptime, symmetry, AntiAliasing;
X
Xextern int xdots, ydots, colors, bitshift;
Xextern int row, col, inside, ShadowColors;
Xextern int TPlusFlag, MaxColorRes, NonInterlaced;
X
Xtypedef struct palett {
X   BYTE red;
X   BYTE green;
X   BYTE blue;
X} Palettetype;
X
Xextern Palettetype    dacbox[ 256 ];
X
X
Xint far NewTPFractal, far _MathType;
Xstatic double dx, dy, dz, dt;
Xstatic long ldx, ldy, ldz, ldt;
Xstatic long lxxmin, lxxmax, lyymin, lyymax, lzzmin, lzzmax, lttmin, lttmax;
X
Xint TranspSymmetry = 0;
X
X/* TARGA+ prototypes */
Xint MatchTPlusMode(unsigned xdots, unsigned ydots, unsigned MaxColorRes,
X           unsigned PixelZoom, unsigned NonInterlaced);
Xint CheckForTPlus(void);
X
X#ifndef XFRACT
Xvoid (*PutTC)(int col, int row, unsigned long color) = WriteTPlusBankedPixel;
Xunsigned long (*GetTC)(int col, int row) = ReadTPlusBankedPixel;
X#else
Xvoid (*PutTC)(int , int , unsigned long ) = WriteTPlusBankedPixel;
Xunsigned long (*GetTC)(int , int ) = ReadTPlusBankedPixel;
X#endif
X
X
Xchar far * far TCError[] =
X{
X   "Could not match this video resolution to a TARGA+ mode",
X   "True Color disk video isn't implement yet, maybe later . . .",
X};
X
Xchar far *TrueColorAutoDetect(void)
X{
X   if(CheckForTPlus())
X   {
X      if(TPlusFlag)
X      {
X         if(MaxColorRes == 8)
X         {
X            if(!MatchTPlusMode(xdots, ydots, 24, 0, NonInterlaced))
X               return(TCError[0]);
X         }
X         else if(!MatchTPlusMode(xdots, ydots, MaxColorRes, 0, NonInterlaced))
X            return(TCError[0]);
X
X         PutTC = WriteTPlusBankedPixel;
X         GetTC = ReadTPlusBankedPixel;
X         return(0);
X      }
X   }
X
X   /* Check for other TC adapters here, such as the XGA , and place it
X      in a true color mode with a resolution identical to the one selected
X      by the user. */
X
X
X   /* If we don't have a TC adapter or it is being used as the display
X      screen, then simulate one using disk video */
X   return(TCError[1]); /* return the 'not implemented' message */
X}
X
Xvoid TranspPerPixel(int MathType, union Arg far *xy, union Arg far *zt)
X{
X   if(NewTPFractal)
X   {
X      double Fudge = (double)(1L << bitshift);
X      _MathType = MathType;              /* Save this for later */
X
X      dx = (xxmax - xxmin) / xdots;
X      dy = (yymin - yymax) / ydots;  /* reverse direction of y-axis */
X      dz = (zzmax - zzmin) / xdots;
X      dt = (ttmax - ttmin) / NumFrames;
X
X      lxxmin = (long)(xxmin * Fudge);
X      lxxmax = (long)(xxmax * Fudge);
X      ldx    = (long)(dx    * Fudge);
X
X      lyymin = (long)(yymin * Fudge);
X      lyymax = (long)(yymax * Fudge);
X      ldy    = (long)(dy    * Fudge);
X
X      lzzmin = (long)(zzmin * Fudge);
X      lzzmax = (long)(zzmax * Fudge);
X      ldz    = (long)(dz    * Fudge);
X
X      lttmin = (long)(ttmin * Fudge);
X      lttmax = (long)(ttmax * Fudge);
X      ldt    = (long)(dt    * Fudge);
X
X      NewTPFractal = 0;
X   }
X
X   switch(MathType)
X   {
X      /* For calculation purposes, 'x' and 'z' are swapped */
X      case D_MATH:
X           xy->d.x = xxmin + (dx * col);
X           xy->d.y = yymax + (dy * row);
X           zt->d.x = zzmin + (dz * tpdepth);
X           zt->d.y = ttmin + (dt * tptime);
X           break;
X#ifndef XFRACT
X      case M_MATH:
X           xy->m.x = *d2MP(xxmin + (dx * col));
X           xy->m.y = *d2MP(yymax + (dy * row));
X           zt->m.x = *d2MP(zzmin + (dz * tpdepth));
X           zt->m.y = *d2MP(ttmin + (dt * tptime));
X           break;
X      case L_MATH:
X           xy->l.x = lxxmin + (ldx * col);
X           xy->l.y = lyymax + (ldy * row);
X           zt->l.x = lzzmin + (ldz * tpdepth);
X           zt->l.y = lttmin + (ldt * tptime);
X#endif
X   }
X}
X
X
Xint Transp3DFnct()
X{
X   unsigned x, y, z, savedinside;
X   int r;
X   unsigned long lcolor;
X
X   for(x = tpdepth;  x < xdots; x++, tpdepth++)
X   {
X      /* Here we go!  Calculate 2D slices to create a 3D composite */
X      savedinside = inside;
X      inside = 255;
X      r = calcfract();
X      inside = savedinside;
X
X      if(r < 0)
X         return(r);                 /* return if iterupted */
X
X      for(y = 0; y < ydots; y++)
X      {
X         unsigned long Red = 0L, Green = 0L, Blue = 0L;
X         unsigned long r = 0L, g = 0L, b = 0L;
X         unsigned color;
X
X         for(z = 0; z < xdots; z++)  /* Total the color guns */
X         {
X            color = (*getcolor)(z, y);
X            if(color == 255 && SolidCore)
X            {                           /* Display a solid core */
X               r = ((long)CoreRed)   * (xdots - z) / xdots;
X               g = ((long)CoreGreen) * (xdots - z) / xdots;
X               b = ((long)CoreBlue)  * (xdots - z) / xdots;
X               break;
X            }
X            else
X            {
X               Red   += (dacbox[color].red << 2);
X               Green += (dacbox[color].green << 2);
X               Blue  += (dacbox[color].blue << 2);
X            }
X         }
X
X         /* Calculate an average color */
X         if(z)
X         {
X            Red /= z;
X            Green /= z;
X            Blue /= z;
X         }
X
X         /* Overlay solid color */
X         Red   |= r;
X         Green |= g;
X         Blue  |= b;
X
X         lcolor = (Red << 16) + (Green << 8) + Blue;
X         PutTC(x, y, lcolor);
X         if(TranspSymmetry == ORIGIN)
X            PutTC(xdots - x - 1, ydots - y - 1, lcolor);
X         else if(TranspSymmetry == XAXIS)
X         {
X            PutTC(x, ydots - y - 1, lcolor);
X            PutTC(xdots - x - 1, y, lcolor);
X            PutTC(xdots - x - 1, ydots - y - 1, lcolor);
X            if(y > (ydots >> 1))
X               break;
X         }
X      }
X      if(x > (xdots >> 1))
X      {
X         if(TranspSymmetry == ORIGIN || TranspSymmetry == XAXIS)
X            break;
X      }
X   }
X   return(0);
X}
X
Xvoid ShadowPutColor(unsigned xdot, unsigned ydot, unsigned color)
X{
X   ShadowVideo(0);
X   if(ShadowColors)
X      putcolor(xdot >> AntiAliasing, ydot >> AntiAliasing, color);
X   else
X   {
X      unsigned r, g, b;
X      unsigned long lcolor;
X
X      r = (dacbox[color].red << 2);
X      g = (dacbox[color].green << 2);
X      b = (dacbox[color].blue << 2);
X      lcolor = ((long)r << 16) + (g << 8) + b;
X      PutTC(xdot >> AntiAliasing, ydot >> AntiAliasing, lcolor);
X   }
X   ShadowVideo(1);
X}
X
Xvoid AntiAliasPass(void)
X{
X   unsigned x, y, i, j, PixelSize, a;
X   unsigned xAct, yAct, xRef, yRef;
X
X   PixelSize = (1 << AntiAliasing);
X   xAct = (xdots >> AntiAliasing);
X   yAct = (ydots >> AntiAliasing);
X
X   for(yRef = y = 0; y < yAct; y++, yRef += PixelSize)
X   {
X      for(xRef = x = 0; x < xAct; x++, xRef += PixelSize)
X      {
X         unsigned total = 0;
X         unsigned long r = 0, g = 0, b = 0, lcolor;
X
X         for(i = 0; i < PixelSize; i++)
X         {
X            for(j = 0; j < PixelSize; j++)
X            {
X               unsigned color;
X
X               color = readdisk(xRef + i, yRef + j);
X               if(ShadowColors)
X                  total += color;
X               else
X               {
X                  r += (dacbox[color].red << 2);
X                  g += (dacbox[color].green << 2);
X                  b += (dacbox[color].blue << 2);
X               }
X            }
X         }
X
X         a = AntiAliasing * AntiAliasing;
X         ShadowVideo(0);
X         if(ShadowColors)
X            putcolor(x, y, total >> a);
X         else
X         {
X            r >>= a;
X            g >>= a;
X            b >>= a;
X            lcolor = ((long)r << 16) + (g << 8) + b;
X            PutTC(x, y, lcolor);
X         }
X         ShadowVideo(1);
X      }
X   }
X}
X
SHAR_EOF
$TOUCH -am 1028230093 tp3d.c &&
chmod 0644 tp3d.c ||
echo "restore of tp3d.c failed"
set `wc -c tp3d.c`;Wc_c=$1
if test "$Wc_c" != "7735"; then
    echo original size 7735, current size $Wc_c
fi
# ============= tplus.c ==============
echo "x - extracting tplus.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > tplus.c &&
X/* TPLUS.C, (C) 1991 The Yankee Programmer
X   All Rights Reserved.
X
X   This code may be distributed only when bundled with the Fractint
X   source code.
X
X   Mark C. Peterson
X   The Yankee Programmer
X   405-C Queen Street, Suite #181
X   Southington, CT 06489
X   [phone]
X
X*/
X
X#include <stdio.h>
X#ifndef XFRACT
X#include <conio.h>
X#include <string.h>
X#ifdef __TURBOC__
X#include <dos.h>
X#endif
X#include "port.h"
X#else
X#include "fractint.h"
X#endif
X#include "tplus.h"
X#include "prototyp.h"
X
Xstruct TPWrite far WriteOffsets = {
X      0,       1,    2,     3,      0x400,   0x401,      0x402,
X      0x403,   0x800,    0x801,     0x802,   0x803,   0xc00,      0xc01,
X      0xc02,   0xc03
X};
X
Xstruct TPRead far ReadOffsets = {
X      0,        2,     3,      0x400,   0x401,      0x402,
X      0x403,   0x800,    0x801,     0x802,   0x803,   0xc00,      0xc01,
X      0xc02,   0xc03
X};
X
Xstruct _BOARD far TPlus;
Xint TPlusErr = 0;
X
X#ifndef XFRACT
X
Xvoid WriteTPWord(unsigned Register, unsigned Number) {
X   OUTPORTB(TPlus.Write.INDIRECT, Register);
X   OUTPORTW(TPlus.Write.WBL, Number);
X}
X
Xvoid WriteTPByte(unsigned Register, unsigned Number) {
X   OUTPORTB(TPlus.Write.INDIRECT, Register);
X   OUTPORTB(TPlus.Write.WBL, Number);
X}
X
Xunsigned ReadTPWord(unsigned Register) {
X   OUTPORTB(TPlus.Write.INDIRECT, Register);
X   return(INPORTW(TPlus.Read.RBL));
X}
X
XBYTE ReadTPByte(unsigned Register) {
X   OUTPORTB(TPlus.Write.INDIRECT, Register);
X   return((BYTE)INPORTB(TPlus.Read.RBL));
X}
X
Xvoid DisableMemory(void) {
X   unsigned Mode1;
X
X   Mode1 = INPORTB(TPlus.Read.MODE1);
X   Mode1 &= 0xfe;
X   OUTPORTB(TPlus.Write.MODE1, Mode1);
X}
X
Xvoid EnableMemory(void) {
X   unsigned Mode1;
X
X   Mode1 = INPORTB(TPlus.Read.MODE1);
X   Mode1 |= 1;
X   OUTPORTB(TPlus.Write.MODE1, Mode1);
X}
X
Xstruct TPLUS_IO {
X   unsigned Cmd;
X   int Initx, Finalx, Inity, Finaly, Destx, Desty;
X   unsigned long Color;
X   unsigned RegsOffset, RegsSegment, RegListOffset, RegListSegment,
X        BoardNumber, StructSize;
X} far TPlusIO;
X
X#include <dos.h>
X
X/* TARGAP.SYS Commands */
X#define READALL    0
X#define WRITEALL   0
X#define NUMBOARDS  3
X#define FILLBLOCK  4
X#define GRABFIELD  4
X#define RESET       5
X#define GRABFRAME  5
X#define WAITFORVB  6
X#define SETBOARD   8
X#define IOBASE       9
X
X/* DOS IO Commands */
X#define DOS_READ   0x4402
X#define DOS_WRITE  0x4403
X
Xint hTPlus = -1;
Xunsigned NumTPlus = 0;
X
Xint TargapSys(int Command, unsigned DOS) {
X   struct TPLUS_IO far *IOPtr;
X   unsigned far *RegPtr;
X   union REGS r;
X   struct SREGS s;
X
X   if(hTPlus != -1) {
X      r.x.ax = DOS;
X      r.x.bx = hTPlus;
X      r.x.cx = sizeof(TPlusIO);
X      IOPtr = &TPlusIO;
X      RegPtr = TPlus.Reg;
X      r.x.dx = FP_OFF(IOPtr);
X      s.ds = FP_SEG(IOPtr);
X      TPlusIO.Cmd = Command;
X      TPlusIO.StructSize = sizeof(TPlus.Reg);
X      TPlusIO.RegsOffset = FP_OFF(RegPtr);
X      TPlusIO.RegsSegment = FP_SEG(RegPtr);
X      intdosx(&r, &r, &s);
X      return(!r.x.cflag);
X   }
X   return(0);
X}
X
Xint _SetBoard(int BoardNumber) {
X   TPlusIO.BoardNumber = BoardNumber;
X   return(TargapSys(SETBOARD, DOS_WRITE));
X}
X
X#include <stdio.h>
X
Xint TPlusLUT(BYTE far *LUTData, unsigned Index, unsigned Number,
X             unsigned DosFlag)
X{
X   struct TPLUS_IO far *IOPtr;
X   union REGS r;
X   struct SREGS s;
X
X   if(hTPlus != -1) {
X      r.x.ax = DosFlag;
X      r.x.bx = hTPlus;
X      r.x.cx = sizeof(TPlusIO);
X      IOPtr = &TPlusIO;
X      r.x.dx = FP_OFF(IOPtr);
X      s.ds = FP_SEG(IOPtr);
X      TPlusIO.Cmd = 9;
X      TPlusIO.StructSize = sizeof(TPlus.Reg);
X      TPlusIO.RegsOffset = FP_OFF(LUTData);
X      TPlusIO.RegsSegment = FP_SEG(LUTData);
X      TPlusIO.BoardNumber = Number;
X      TPlusIO.RegListOffset = Index;
X      intdosx(&r, &r, &s);
X      return(!r.x.cflag);
X   }
X   return(0);
X}
X
Xint SetVGA_LUT(void) {
X   char PathName[80];
X   FILE *Data;
X   BYTE LUTData[256 * 3];
X
X   findpath("tplus.dat", PathName);
X   if(PathName[0]) {
X      if((Data = fopen(PathName, "rb")) != 0) {
X     if(!fseek(Data, 16L << 8, SEEK_SET)) {
X        if(fread(LUTData, 1, sizeof(LUTData), Data) == sizeof(LUTData)) {
X           fclose(Data);
X           return(TPlusLUT(LUTData, 0, sizeof(LUTData), DOS_WRITE));
X        }
X     }
X      }
X   }
X   if(Data > 0)
X      fclose(Data);
X   return(0);
X}
X
Xint SetColorDepth(int Depth) {
X   if(TPlus.Reg[HIRES] && Depth == 4)
X      Depth = 2;
X   switch(Depth) {
X      case 1:
X     if(TPlus.Reg[XDOTS] > 512) {
X        TPlus.Reg[PERM] = 1;
X        TPlus.Reg[BYCAP] = 3;
X        TPlus.RowBytes = 10;
X     }
X     else {
X        TPlus.Reg[PERM] = 0;
X        TPlus.Reg[BYCAP] = 1;
X        TPlus.RowBytes = 9;
X     }
X     TPlus.Reg[BUFFPORTSRC] = 0;
X     TPlus.Reg[CM1] = 0;
X     TPlus.Reg[CM2] = 0;
X     TPlus.Reg[DEPTH] = 1;
X     TPlus.Reg[LIVE8] = 1;
X     TPlus.Reg[DISPMODE] = 0;
X     TPlus.Reg[LIVEPORTSRC] = 1;
X     TPlus.Reg[LUTBYPASS] = 0;
X     break;
X      case 2:
X     if(TPlus.Reg[XDOTS] > 512) {
X        TPlus.Reg[PERM] = 3;
X        TPlus.Reg[BYCAP] = 15;
X        TPlus.Reg[CM2] = 1;
X        TPlus.RowBytes = 11;
X     }
X     else {
X        TPlus.Reg[PERM] = 1;
X        TPlus.Reg[BYCAP] = 3;
X        TPlus.Reg[CM2] = 0;
X        TPlus.RowBytes = 10;
X     }
X     TPlus.Reg[BUFFPORTSRC] = 1;
X     TPlus.Reg[CM1] = 0;
X     TPlus.Reg[DEPTH] = 2;
X     TPlus.Reg[LIVE8] = 0;
X     TPlus.Reg[DISPMODE] = 0;
X     TPlus.Reg[LIVEPORTSRC] = 1;
X     TPlus.Reg[LUTBYPASS] = 1;
X     break;
X      case 3:
X      case 4:
X     TPlus.Reg[PERM] = (Depth == 3) ? 2 : 3;
X     TPlus.Reg[BYCAP] = 0xf;
X     TPlus.Reg[BUFFPORTSRC] = 3;
X     TPlus.Reg[CM1] = 1;
X     TPlus.Reg[CM2] = 1;
X     TPlus.Reg[DEPTH] = 4;
X     TPlus.Reg[LIVE8] = 0;
X     TPlus.Reg[DISPMODE] = 0;
X     TPlus.Reg[LIVEPORTSRC] = 1;
X     TPlus.Reg[LUTBYPASS] = 1;
X     TPlus.RowBytes = 11;
X     break;
X      default:
X     return(0);
X   }
X   TPlus.Plot = WriteTPlusBankedPixel;
X   TPlus.GetColor = ReadTPlusBankedPixel;
X   TPlus.Reg[LIVEMIXSRC] = 0;
X   TPlus.Reg[CM3] = 1;
X   TPlus.RowsPerBank = 16 - TPlus.RowBytes;
X   if(TargapSys(WRITEALL, DOS_WRITE)) {
X      if(Depth == 1)
X     SetVGA_LUT();
X      if(TPlus.ClearScreen)
X     ClearTPlusScreen();
X      TargapSys(READALL, DOS_READ);
X      return(Depth);
X   }
X   return(0);
X}
X
Xint SetBoard(int BoardNumber) {
X   unsigned ioBase, n;
X   unsigned long MemBase;
X
X   if(TPlus.ThisBoard != -1)
X      DisableMemory();
X   if(!_SetBoard(BoardNumber))
X      return(0);
X   if(!TargapSys(READALL, DOS_READ))
X      return(0);
X   TPlus.VerPan       = TPlus.Reg[VPAN];
X   TPlus.HorPan       = TPlus.Reg[HPAN];
X   TPlus.Top          = TPlus.Reg[TOP];
X   TPlus.Bottom       = TPlus.Reg[BOT];
X   TPlus.Bank64k      = 0xffff;         /* Force a bank switch */
X
X   MemBase      = TPlus.Reg[MEM_BASE];
X   MemBase += (TPlus.Reg[MEM_MAP] != 3) ? 8 : 0;
X   TPlus.Screen = (BYTE far *)(MemBase << 28);
X
X   if(!TargapSys(IOBASE, DOS_READ))
X      return(0);
X   ioBase = TPlusIO.BoardNumber;
X   TPlus.Read = ReadOffsets;
X   TPlus.Write = WriteOffsets;
X   for(n = 0; n < sizeof(TPlus.Read) / sizeof(unsigned); n++)
X      ((unsigned far *)&(TPlus.Read))[n] += ioBase;
X   for(n = 0; n < sizeof(TPlus.Write) / sizeof(unsigned); n++)
X      ((unsigned far *)&(TPlus.Write))[n] += ioBase;
X
X   EnableMemory();
X   return(1);
X}
X
Xint ResetBoard(int BoardNumber) {
X   int CurrBoard, Status = 0;
X
X   CurrBoard = TPlus.ThisBoard;
X   if(_SetBoard(BoardNumber))
X      Status = TargapSys(RESET, DOS_WRITE);
X   if(CurrBoard > 0)
X      _SetBoard(CurrBoard);
X   return(Status);
X}
X
X#include <fcntl.h>
X#include <io.h>
X
Xint CheckForTPlus(void) {
X   unsigned n;
X
X   if((hTPlus = open("TARGPLUS", O_RDWR | O_BINARY )) != -1) {
X      if(!TargapSys(NUMBOARDS, DOS_READ))
X     return(0);
X      NumTPlus = TPlusIO.BoardNumber;
X      TPlus.ThisBoard = -1;
X      TPlus.ClearScreen = 1;
X      for(n = 0; n < NumTPlus; n++)
X     if(!ResetBoard(n))
X        return(0);
X      if(SetBoard(0))
X     return(1);
X   }
X   return(0);
X}
X
Xint SetTPlusMode(int Mode, int NotIntFlag, int Depth, int Zoom) {
X   unsigned n;
X   char PathName[80];
X   FILE *Data;
X   unsigned NewRegs[128];
X
X   findpath("tplus.dat", PathName);
X   if(PathName[0]) {
X      if((Data = fopen(PathName, "rb")) != 0) {
X     if(!fseek(Data, (long)Mode << 8, SEEK_SET)) {
X        if(fread(NewRegs, 1, 256, Data) == 256) {
X           fclose(Data);
X           NewRegs[PE] = TPlus.Reg[PE];
X           NewRegs[OVLE] = TPlus.Reg[OVLE];
X           NewRegs[RGB] = TPlus.Reg[RGB];
X           NewRegs[SVIDEO] = TPlus.Reg[SVIDEO];
X           NewRegs[DAC567DATA] = TPlus.Reg[DAC567DATA];
X           NewRegs[VGASRC] = TPlus.Reg[VGASRC];
X           for(n = 0; n < 128; n++)
X          TPlus.Reg[n] = NewRegs[n];
X           if(TPlus.Reg[VTOP + 1] == 0xffff)
X          TPlus.Reg[NOT_INT] = 0;
X           else if(TPlus.Reg[VTOP] == 0xffff && !NotIntFlag) {
X          TPlusErr = 1;
X          return(0);
X           }
X           else
X          TPlus.Reg[NOT_INT] = NotIntFlag;
X           TPlus.xdots = TPlus.Reg[XDOTS];
X           TPlus.ydots = TPlus.Reg[YDOTS];
X           if(Zoom) {
X          TPlus.Reg[ZOOM] = Zoom;
X          TPlus.xdots >>= Zoom;
X          TPlus.ydots >>= Zoom;
X           }
X           return(SetColorDepth(Depth));
X        }
X     }
X      }
X   }
X   if(Data > 0)
X      fclose(Data);
X   return(0);
X}
X
Xint FillTPlusRegion(unsigned x, unsigned y, unsigned xdots, unsigned ydots,
X           unsigned long Color) {
X   int Status = 0;
X
X   TPlusIO.Initx = x;
X   TPlusIO.Inity = TPlus.Reg[YDOTS] - (y + ydots) - 2;
X   TPlusIO.Finalx = x + xdots - 1;
X   TPlusIO.Finaly = TPlus.Reg[YDOTS] - y - 1;
X   TPlusIO.Color = Color;
X   Status = TargapSys(FILLBLOCK, DOS_WRITE);
X   EnableMemory();
X   return(Status);
X}
X
Xvoid BlankScreen(unsigned long Color) {
X   unsigned BufferPort;
X
X   OUTPORTW(TPlus.Write.COLOR0, ((unsigned*)&Color)[0]);
X   OUTPORTB(TPlus.Write.COLOR2, ((unsigned*)&Color)[1]);
X   OUTPORTB(TPlus.Write.COLOR3, 0xff);
X   BufferPort = ReadTPByte(0xe9);
X   BufferPort |= 3;
X   WriteTPByte(0xe9, BufferPort);
X}
X
Xvoid UnBlankScreen(void) {
X   unsigned BufferPort;
X
X   BufferPort = ReadTPByte(0xe9);
X   BufferPort &= 0xfe;
X   WriteTPByte(0xe9, BufferPort);
X}
X
Xvoid EnableOverlayCapture(void) {
X   unsigned Mode2;
X
X   Mode2 = INPORTB(TPlus.Read.MODE2);
X   Mode2 |= (1 << 6);
X   Mode2 &= (0xff ^ (3 << 4));
X   Mode2 |= (1 << 5);
X   OUTPORTB(TPlus.Write.MODE2, Mode2);
X}
X
Xvoid DisableOverlayCapture(void) {
X   unsigned Mode2;
X
X   Mode2 = INPORTB(TPlus.Read.MODE2);
X   Mode2 &= (0xff ^ (7 << 4));
X   OUTPORTB(TPlus.Write.MODE2, Mode2);
X}
X
Xvoid ClearTPlusScreen(void) {
X   BlankScreen(0L);
X   EnableOverlayCapture();
X   TargapSys(WAITFORVB, DOS_READ);
X   TargapSys(WAITFORVB, DOS_READ);
X   TargapSys(WAITFORVB, DOS_READ);
X   DisableOverlayCapture();
X   UnBlankScreen();
X}
X
Xstatic struct {
X   unsigned xdots, ydots, Template, Zoom, Depth;
X} far ModeTable[] = {
X   512, 400, 0,  0, 4,
X   512, 476, 1,  0, 4,
X   512, 486, 2,  0, 4,
X   512, 576, 3,  0, 4,
X   640, 480, 4,  0, 2,
X   648, 486, 5,  0, 2,
X   720, 486, 6,  0, 2,
X   720, 576, 7,  0, 2,
X   756, 486, 8,  0, 2,
X   768, 576, 9,  0, 2,
X   800, 600, 10, 0, 2,
X   1024,768, 11, 0, 2,
X   640, 400, 13, 0, 2,
X   320, 200, 13, 1, 2,
X   512, 496, 14, 0, 4,
X   640, 496, 15, 0, 2,
X};
X
Xstatic unsigned TableSize = (sizeof(ModeTable) / sizeof(ModeTable[0]));
X
Xint MatchTPlusMode(unsigned xdots, unsigned ydots, unsigned MaxColorRes,
X           unsigned PixelZoom, unsigned NonInterlaced) {
X   unsigned n, Depth;
X
X   for(n = 0; n < TableSize; n++) {
X      if(ModeTable[n].xdots == xdots && ModeTable[n].ydots == ydots)
X     break;
X   }
X   if(n < TableSize) {
X      if(ModeTable[n].Zoom)
X     PixelZoom += ModeTable[n].Zoom;
X      if(PixelZoom > 4)
X     PixelZoom = 4;
X      switch(MaxColorRes) {
X     case 24:
X        Depth = 4;
X        break;
X     case 16:
X        Depth = 2;
X        break;
X     case 8:
X     default:
X        Depth = 1;
X        break;
X      }
X      if(ModeTable[n].Depth < Depth)
X     Depth = ModeTable[n].Depth;
X      return(SetTPlusMode(ModeTable[n].Template, NonInterlaced, Depth,
X         PixelZoom));
X   }
X   return(0);
X}
X
Xvoid TPlusZoom(int Zoom) {
X   unsigned Mode2;
X
X   Zoom &= 3;
X   Mode2 = INPORTB(TPlus.Read.MODE2);
X   Mode2 &= (0xff ^ (3 << 2));
X   Mode2 |= (Zoom << 2);
X   OUTPORTB(TPlus.Write.MODE2, Mode2);
X}
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 tplus.c &&
chmod 0644 tplus.c ||
echo "restore of tplus.c failed"
set `wc -c tplus.c`;Wc_c=$1
if test "$Wc_c" != "11727"; then
    echo original size 11727, current size $Wc_c
fi
# ============= zoom.c ==============
echo "x - extracting zoom.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > zoom.c &&
X/*
X    zoom.c - routines for zoombox manipulation and for panning
X
X*/
X
X#include <float.h>
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X#include "fractint.h"
X#include "prototyp.h"
X
X/* screen dimensions here are (1.0,1.0) corresponding to (xdots-1,ydots-1) */
Xextern double zbx,zby;           /* topleft of unrotated zoombox  */
Xextern double zwidth,zdepth,zskew; /* zoombox size & shape        */
Xextern int zrotate;           /* * 2.5 degree increments        */
Xextern int boxcount,boxx[],boxy[]; /* co-ords of each zoombox pixel */
Xextern int xdots,ydots,sxdots,sydots,sxoffs,syoffs;
Xextern double dxsize,dysize;       /* xdots-1, ydots-1            */
Xextern double xxmin,yymin,xxmax,yymax,xx3rd,yy3rd;
Xextern double sxmin,symin,sxmax,symax,sx3rd,sy3rd;
X/* top      left    corner of screen is (xxmin,yymax) */
X/* bottom left    corner of screen is (xx3rd,yy3rd) */
X/* bottom right corner of screen is (xxmax,yymin) */
Xextern double plotmx1,plotmx2,plotmy1,plotmy2;
X
Xextern int  calc_status;       /* status of calculations */
Xextern int  fractype;           /* fractal type */
Xextern char stdcalcmode;       /* '1', '2', 'g', 'b', or 't' */
Xextern int  num_worklist;       /* resume worklist for standard engine */
Xextern struct workliststuff worklist[MAXCALCWORK];
Xextern char dstack[4096];       /* common temp, used for get_line/put_line */
Xextern int  potflag;
Xextern int  pot16bit;
Xextern float finalaspectratio;
Xextern float  screenaspect;
X
Xstruct coords {
X    int x,y;
X    };
X
X#define PIXELROUND 0.00001
X
Xstatic void _fastcall drawlines(struct coords, struct coords, int, int);
Xstatic void _fastcall addbox(struct coords);
Xstatic void _fastcall zmo_calc(double, double, double *, double *);
Xstatic int  check_pan();
Xstatic void fix_worklist();
Xstatic void _fastcall move_row(int fromrow,int torow,int col);
X
Xvoid drawbox(int drawit)
X{   struct coords tl,bl,tr,br; /* dot addr of topleft, botleft, etc */
X    double tmpx,tmpy,dx,dy,rotcos,rotsin,ftemp1,ftemp2;
X    double fxwidth,fxskew,fydepth,fyskew,fxadj;
X
X    if (zwidth==0) { /* no box to draw */
X    if (boxcount!=0) { /* remove the old box from display */
X        clearbox();   /* asm routine */
X        boxcount = 0; }
X    reset_zoom_corners();
X    return; }
X
X    ftemp1 = PI*zrotate/72; /* convert to radians */
X    rotcos = cos(ftemp1);   /* sin & cos of rotation */
X    rotsin = sin(ftemp1);
X
X    /* do some calcs just once here to reduce fp work a bit */
X    fxwidth = sxmax-sx3rd;
X    fxskew  = sx3rd-sxmin;
X    fydepth = sy3rd-symax;
X    fyskew  = symin-sy3rd;
X    fxadj   = zwidth*zskew;
X
X    /* calc co-ords of topleft & botright corners of box */
X    tmpx = zwidth/-2+fxadj; /* from zoombox center as origin, on xdots scale */
X    tmpy = zdepth*finalaspectratio/2;
X    dx = (rotcos*tmpx - rotsin*tmpy) - tmpx; /* delta x to rotate topleft */
X    dy = tmpy - (rotsin*tmpx + rotcos*tmpy); /* delta y to rotate topleft */
X    /* calc co-ords of topleft */
X    ftemp1 = zbx + dx + fxadj;
X    ftemp2 = zby + dy/finalaspectratio;
X    tl.x   = ftemp1*(dxsize+PIXELROUND); /* screen co-ords */
X    tl.y   = ftemp2*(dysize+PIXELROUND);
X    xxmin  = sxmin + ftemp1*fxwidth + ftemp2*fxskew; /* real co-ords */
X    yymax  = symax + ftemp2*fydepth + ftemp1*fyskew;
X    /* calc co-ords of bottom right */
X    ftemp1 = zbx + zwidth - dx - fxadj;
X    ftemp2 = zby - dy/finalaspectratio + zdepth;
X    br.x   = ftemp1*(dxsize+PIXELROUND);
X    br.y   = ftemp2*(dysize+PIXELROUND);
X    xxmax  = sxmin + ftemp1*fxwidth + ftemp2*fxskew;
X    yymin  = symax + ftemp2*fydepth + ftemp1*fyskew;
X
X    /* do the same for botleft & topright */
X    tmpx = zwidth/-2 - fxadj;
X    tmpy = 0.0-tmpy;
X    dx = (rotcos*tmpx - rotsin*tmpy) - tmpx;
X    dy = tmpy - (rotsin*tmpx + rotcos*tmpy);
X    ftemp1 = zbx + dx - fxadj;
X    ftemp2 = zby + dy/finalaspectratio + zdepth;
X    bl.x   = ftemp1*(dxsize+PIXELROUND);
X    bl.y   = ftemp2*(dysize+PIXELROUND);
X    xx3rd  = sxmin + ftemp1*fxwidth + ftemp2*fxskew;
X    yy3rd  = symax + ftemp2*fydepth + ftemp1*fyskew;
X    ftemp1 = zbx + zwidth - dx + fxadj;
X    ftemp2 = zby - dy/finalaspectratio;
X    tr.x   = ftemp1*(dxsize+PIXELROUND);
X    tr.y   = ftemp2*(dysize+PIXELROUND);
X
X    if (boxcount!=0) { /* remove the old box from display */
X    clearbox();   /* asm routine */
X    boxcount = 0; }
X
X    if (drawit) { /* caller wants box drawn as well as co-ords calc'd */
X#ifndef XFRACT
X    /* build the list of zoom box pixels */
X    addbox(tl); addbox(tr);           /* corner pixels */
X    addbox(bl); addbox(br);
X    drawlines(tl,tr,bl.x-tl.x,bl.y-tl.y); /* top & bottom lines */
X    drawlines(tl,bl,tr.x-tl.x,tr.y-tl.y); /* left & right lines */
X#else
X        boxx[0] = tl.x + sxoffs;
X        boxy[0] = tl.y + syoffs;
X        boxx[1] = tr.x + sxoffs;
X        boxy[1] = tr.y + syoffs;
X        boxx[2] = br.x + sxoffs;
X        boxy[2] = br.y + syoffs;
X        boxx[3] = bl.x + sxoffs;
X        boxy[3] = bl.y + syoffs;
X        boxcount = 1;
X#endif
X    dispbox();                  /* asm routine to paint it */
X    }
X    }
X
Xstatic void _fastcall drawlines(struct coords fr, struct coords to,
X                int dx, int dy)
X{   int xincr,yincr,ctr;
X    int altctr,altdec,altinc;
X    struct coords tmpp,line1,line2;
X
X    if (abs(to.x-fr.x) > abs(to.y-fr.y)) { /* delta.x > delta.y */
X    if (fr.x>to.x) { /* swap so from.x is < to.x */
X        tmpp = fr; fr = to; to = tmpp; }
X    xincr = (to.x-fr.x)*4/sxdots+1; /* do every 1st, 2nd, 3rd, or 4th dot */
X    ctr = (to.x-fr.x-1)/xincr;
X    altdec = abs(to.y-fr.y)*xincr;
X    altinc = to.x-fr.x;
X    altctr = altinc/2;
X    yincr = (to.y>fr.y)?1:-1;
X    line2.x = (line1.x = fr.x) + dx;
X    line2.y = (line1.y = fr.y) + dy;
X    while (--ctr>=0) {
X        line1.x += xincr;
X        line2.x += xincr;
X        altctr -= altdec;
X        while (altctr<0) {
X        altctr    += altinc;
X        line1.y += yincr;
X        line2.y += yincr;
X        }
X        addbox(line1);
X        addbox(line2);
X        }
X    }
X
X    else { /* delta.y > delta.x */
X    if (fr.y>to.y) { /* swap so from.y is < to.y */
X        tmpp = fr; fr = to; to = tmpp; }
X    yincr = (to.y-fr.y)*4/sydots+1; /* do every 1st, 2nd, 3rd, or 4th dot */
X    ctr = (to.y-fr.y-1)/yincr;
X    altdec = abs(to.x-fr.x)*yincr;
X    altinc = to.y-fr.y;
X    altctr = altinc/2;
X    xincr = (to.x>fr.x) ? 1 : -1;
X    line2.x = (line1.x = fr.x) + dx;
X    line2.y = (line1.y = fr.y) + dy;
X    while (--ctr>=0) {
X        line1.y += yincr;
X        line2.y += yincr;
X        altctr  -= altdec;
X        while (altctr<0) {
X        altctr    += altinc;
X        line1.x += xincr;
X        line2.x += xincr;
X        }
X        addbox(line1);
X        addbox(line2);
X        }
X    }
X    }
X
Xstatic void _fastcall addbox(struct coords point)
X{
X    point.x += sxoffs;
X    point.y += syoffs;
X    if (point.x >= 0 && point.x < sxdots && point.y >= 0 && point.y < sydots) {
X    boxx[boxcount] = point.x;
X    boxy[boxcount] = point.y;
X    ++boxcount;
X    }
X    }
X
Xvoid moveboxf(double dx, double dy)
X{   int align,row,col;
X    align = check_pan();
X    if (dx!=0.0) {
X    if ((zbx += dx) + zwidth/2 < 0)  /* center must stay onscreen */
X        zbx = zwidth/-2;
X    if (zbx + zwidth/2 > 1)
X        zbx = 1.0 - zwidth/2;
X    if (align != 0
X      && ((col = zbx*(dxsize+PIXELROUND)) & (align-1)) != 0) {
X        if (dx > 0) col += align;
X        col -= col & (align-1); /* adjust col to pass alignment */
X        zbx = (double)col/dxsize; }
X    }
X    if (dy!=0.0) {
X    if ((zby += dy) + zdepth/2 < 0)
X        zby = zdepth/-2;
X    if (zby + zdepth/2 > 1)
X        zby = 1.0 - zdepth/2;
X    if (align != 0
X      && ((row = zby*(dysize+PIXELROUND)) & (align-1)) != 0) {
X        if (dy > 0) row += align;
X        row -= row & (align-1);
X        zby = (double)row/dysize; }
X    }
X    }
X
Xstatic void _fastcall chgboxf(double dwidth, double ddepth)
X{
X    if (zwidth+dwidth > 1)
X    dwidth = 1.0-zwidth;
X    if (zwidth+dwidth < 0.05)
X    dwidth = 0.05-zwidth;
X    zwidth += dwidth;
X    if (zdepth+ddepth > 1)
X    ddepth = 1.0-zdepth;
X    if (zdepth+ddepth < 0.05)
X    ddepth = 0.05-zdepth;
X    zdepth += ddepth;
X    moveboxf(dwidth/-2,ddepth/-2); /* keep it centered & check limits */
X    }
X
Xvoid resizebox(int steps)
X{
X    double deltax,deltay;
X    if (zdepth*screenaspect > zwidth) { /* box larger on y axis */
X    deltay = steps * 0.036 / screenaspect;
X    deltax = zwidth * deltay / zdepth;
X    }
X    else {                /* box larger on x axis */
X    deltax = steps * 0.036;
X    deltay = zdepth * deltax / zwidth;
X    }
X    chgboxf(deltax,deltay);
X    }
X
Xvoid chgboxi(int dw, int dd)
X{   /* change size by pixels */
X    chgboxf( (double)dw/dxsize, (double)dd/dysize );
X    }
X
X#ifdef C6
X#pragma optimize("e",off)  /* MSC 6.00A messes up next rtn with "e" on */
X#endif
X
Xvoid zoomout() /* for ctl-enter, calc corners for zooming out */
X{   double savxxmin,savyymax,ftemp;
X    /* (xxmin,yymax), etc, are already set to zoombox corners;
X       (sxmin,symax), etc, are still the screen's corners;
X       use the same logic as plot_orbit stuff to first calculate current screen
X       corners relative to the zoombox, as if the zoombox were a square with
X       upper left (0,0) and width/depth 1; ie calc the current screen corners
X       as if plotting them from the zoombox;
X       then extend these co-ords from current real screen corners to get
X       new actual corners
X       */
X    ftemp = (yymin-yy3rd)*(xx3rd-xxmin) - (xxmax-xx3rd)*(yy3rd-yymax);
X    plotmx1 = (xx3rd-xxmin) / ftemp; /* reuse the plotxxx vars is safe */
X    plotmx2 = (yy3rd-yymax) / ftemp;
X    plotmy1 = (yymin-yy3rd) / ftemp;
X    plotmy2 = (xxmax-xx3rd) / ftemp;
X    savxxmin = xxmin; savyymax = yymax;
X    zmo_calc(sxmin-savxxmin,symax-savyymax,&xxmin,&yymax); /* new xxmin/xxmax */
X    zmo_calc(sxmax-savxxmin,symin-savyymax,&xxmax,&yymin);
X    zmo_calc(sx3rd-savxxmin,sy3rd-savyymax,&xx3rd,&yy3rd);
X    }
X
X#ifdef C6
X#pragma optimize("e",on)  /* back to normal */
X#endif
X
Xstatic void _fastcall zmo_calc(double dx, double dy, double *newx, double *newy)
X{   double tempx,tempy;
X    /* calc cur screen corner relative to zoombox, when zoombox co-ords
X       are taken as (0,0) topleft thru (1,1) bottom right */
X    tempx = dy * plotmx1 - dx * plotmx2;
X    tempy = dx * plotmy1 - dy * plotmy2;
X    /* calc new corner by extending from current screen corners */
X    *newx = sxmin + tempx*(sxmax-sx3rd) + tempy*(sx3rd-sxmin);
X    *newy = symax + tempy*(sy3rd-symax) + tempx*(symin-sy3rd);
X    }
X
Xvoid aspectratio_crop(float oldaspect,float newaspect)
X{
X   double ftemp,xmargin,ymargin;
X   if (newaspect > oldaspect) { /* new ratio is taller, crop x */
X      ftemp = (1.0 - oldaspect / newaspect) / 2;
X      xmargin = (xxmax - xx3rd) * ftemp;
X      ymargin = (yymin - yy3rd) * ftemp;
X      xx3rd += xmargin;
X      yy3rd += ymargin;
X      }
X   else               { /* new ratio is wider, crop y */
X      ftemp = (1.0 - newaspect / oldaspect) / 2;
X      xmargin = (xx3rd - xxmin) * ftemp;
X      ymargin = (yy3rd - yymax) * ftemp;
X      xx3rd -= xmargin;
X      yy3rd -= ymargin;
X      }
X   xxmin += xmargin;
X   yymax += ymargin;
X   xxmax -= xmargin;
X   yymin -= ymargin;
X}
X
Xstatic int check_pan() /* return 0 if can't, alignment requirement if can */
X{   int i,j;
X    if (calc_status != 2 && calc_status != 4)
X    return(0); /* not resumable, not complete */
X    if ( curfractalspecific->calctype != StandardFractal
X      && curfractalspecific->calctype != calcmand
X      && curfractalspecific->calctype != calcmandfp
X      && curfractalspecific->calctype != lyapunov)
X    return(0); /* not a worklist-driven type */
X    if (zwidth != 1.0 || zdepth != 1.0 || zskew != 0.0 || zrotate != 0.0)
X    return(0); /* not a full size unrotated unskewed zoombox */
X    /* can pan if we get this far */
X    if (calc_status == 4)
X    return(1); /* image completed, align on any pixel */
X    if (potflag && pot16bit)
X    return(1); /* 1 pass forced so align on any pixel */
X    if (stdcalcmode == 'b')
X    return(1); /* btm, align on any pixel */
X    if (stdcalcmode == 't')
X    return(0); /* tesselate, can't do it */
X    if (stdcalcmode != 'g' || (curfractalspecific->flags&NOGUESS)) {
X    if (stdcalcmode == '2') /* align on even pixel for 2pass */
X       return(2);
X    return(1); /* assume 1pass */
X    }
X    /* solid guessing */
X    start_resume();
X    get_resume(sizeof(int),&num_worklist,sizeof(worklist),worklist,0);
X    /* don't do end_resume! we're just looking */
X    i = 9;
X    for (j=0; j<num_worklist; ++j) /* find lowest pass in any pending window */
X    if (worklist[j].pass < i)
X        i = worklist[j].pass;
X    j = ssg_blocksize(); /* worst-case alignment requirement */
X    while (--i >= 0)
X    j = j>>1; /* reduce requirement */
X    return(j);
X    }
X
Xstatic void _fastcall move_row(int fromrow,int torow,int col)
X/* move a row on the screen */
X{   int startcol,endcol,tocol;
X    memset(dstack,0,xdots); /* use dstack as a temp for the row; clear it */
X    if (fromrow >= 0 && fromrow < ydots) {
X    tocol = startcol = 0;
X    endcol = xdots-1;
X    if (col < 0) {
X        tocol -= col;
X        endcol += col; }
X    if (col > 0)
X        startcol += col;
X    get_line(fromrow,startcol,endcol,(BYTE *)&dstack[tocol]);
X    }
X    put_line(torow,0,xdots-1,(BYTE *)dstack);
X    }
X
Xint init_pan_or_recalc(int do_zoomout) /* decide to recalc, or to chg worklist & pan */
X{   int i,j,row,col,y,alignmask,listfull;
X    if (zwidth == 0.0)
X    return(0); /* no zoombox, leave calc_status as is */
X    /* got a zoombox */
X    if ((alignmask=check_pan()-1) < 0) {
X    calc_status = 0; /* can't pan, trigger recalc */
X    return(0); }
X    if (zbx == 0.0 && zby == 0.0) {
X    clearbox();
X    return(0); } /* box is full screen, leave calc_status as is */
X    col = zbx*(dxsize+PIXELROUND); /* calc dest col,row of topleft pixel */
X    row = zby*(dysize+PIXELROUND);
X    if (do_zoomout) { /* invert row and col */
X    row = 0-row;
X    col = 0-col; }
X    if ((row&alignmask) != 0 || (col&alignmask) != 0) {
X    calc_status = 0; /* not on useable pixel alignment, trigger recalc */
X    return(0); }
X    /* pan */
X    num_worklist = 0;
X    if (calc_status == 2) {
X       start_resume();
X       get_resume(sizeof(int),&num_worklist,sizeof(worklist),worklist,0);
X       } /* don't do end_resume! we might still change our mind */
X    /* adjust existing worklist entries */
X    for (i=0; i<num_worklist; ++i) {
X    worklist[i].yystart -= row;
X    worklist[i].yystop  -= row;
X    worklist[i].yybegin -= row;
X    worklist[i].xxstart -= col;
X    worklist[i].xxstop  -= col;
X    }
X    /* add worklist entries for the new edges */
X    listfull = i = 0;
X    j = ydots-1;
X    if (row < 0) {
X    listfull |= add_worklist(0,xdots-1,0,0-row-1,0,0,0);
X    i = 0 - row; }
X    if (row > 0) {
X    listfull |= add_worklist(0,xdots-1,ydots-row,ydots-1,ydots-row,0,0);
X    j = ydots - row - 1; }
X    if (col < 0)
X    listfull |= add_worklist(0,0-col-1,i,j,i,0,0);
X    if (col > 0)
X    listfull |= add_worklist(xdots-col,xdots-1,i,j,i,0,0);
X    if (listfull != 0) {
X    static char far msg[] = {"\
XTables full, can't pan current image.\n\
XCancel resumes old image, continue pans and calculates a new one."};
X    if (stopmsg(2,msg)) {
X        zwidth = 0; /* cancel the zoombox */
X        drawbox(1); }
X    else
X        calc_status = 0; /* trigger recalc */
X    return(0); }
X    /* now we're committed */
X    calc_status = 2;
X    clearbox();
X    if (row > 0) /* move image up */
X    for (y=0; y<ydots; ++y) move_row(y+row,y,col);
X    else     /* move image down */
X    for (y=ydots; --y>=0;)    move_row(y+row,y,col);
X    fix_worklist(); /* fixup any out of bounds worklist entries */
X    alloc_resume(sizeof(worklist)+10,1); /* post the new worklist */
X    put_resume(sizeof(int),&num_worklist,sizeof(worklist),worklist,0);
X    return(0);
X    }
X
Xstatic void _fastcall restart_window(int wknum)
X/* force a worklist entry to restart */
X{   int yfrom,yto,xfrom,xto;
X    if ((yfrom = worklist[wknum].yystart) < 0) yfrom = 0;
X    if ((xfrom = worklist[wknum].xxstart) < 0) xfrom = 0;
X    if ((yto = worklist[wknum].yystop) >= ydots) yto = ydots - 1;
X    if ((xto = worklist[wknum].xxstop) >= xdots) xto = xdots - 1;
X    memset(dstack,0,xdots); /* use dstack as a temp for the row; clear it */
X    while (yfrom <= yto)
X    put_line(yfrom++,xfrom,xto,(BYTE *)dstack);
X    worklist[wknum].sym = worklist[wknum].pass = 0;
X    worklist[wknum].yybegin = worklist[wknum].yystart;
X}
X
Xstatic void fix_worklist() /* fix out of bounds and symmetry related stuff */
X{   int i,j,k;
X    struct workliststuff *wk;
X    for (i=0; i<num_worklist; ++i) {
X    wk = &worklist[i];
X    if ( wk->yystart >= ydots || wk->yystop < 0
X      || wk->xxstart >= xdots || wk->xxstop < 0) { /* offscreen, delete */
X        for (j=i+1; j<num_worklist; ++j)
X        worklist[j-1] = worklist[j];
X        --num_worklist;
X        --i;
X        continue; }
X    if (wk->yystart < 0) /* partly off top edge */
X        if ((wk->sym&1) == 0) /* no sym, easy */
X        wk->yystart = 0;
X        else { /* xaxis symmetry */
X        if ((j = wk->yystop + wk->yystart) > 0
X          && num_worklist < MAXCALCWORK) { /* split the sym part */
X            worklist[num_worklist] = worklist[i];
X            worklist[num_worklist].yystart = 0;
X            worklist[num_worklist++].yystop = j;
X            wk->yystart = j+1; }
X        else
X            wk->yystart = 0;
X        restart_window(i); /* restart the no-longer sym part */
X        }
X    if (wk->yystop >= ydots) { /* partly off bottom edge */
X       j = ydots-1;
X       if ((wk->sym&1) != 0) { /* uses xaxis symmetry */
X          if ((k = wk->yystart + (wk->yystop - j)) < j)
X         if (num_worklist >= MAXCALCWORK) /* no room to split */
X            restart_window(i);
X         else { /* split it */
X            worklist[num_worklist] = worklist[i];
X            worklist[num_worklist].yystart = k;
X            worklist[num_worklist++].yystop = j;
X            j = k-1; }
X          wk->sym &= -1 - 1; }
X       wk->yystop = j; }
X    if (wk->xxstart < 0) /* partly off left edge */
X        if ((wk->sym&2) == 0) /* no sym, easy */
X        wk->xxstart = 0;
X        else { /* yaxis symmetry */
X        if ((j = wk->xxstop + wk->xxstart) > 0
X          && num_worklist < MAXCALCWORK) { /* split the sym part */
X            worklist[num_worklist] = worklist[i];
X            worklist[num_worklist].xxstart = 0;
X            worklist[num_worklist++].xxstop = j;
X            wk->xxstart = j+1; }
X        else
X            wk->xxstart = 0;
X        restart_window(i); /* restart the no-longer sym part */
X        }
X    if (wk->xxstop >= xdots) { /* partly off right edge */
X       j = xdots-1;
X       if ((wk->sym&2) != 0) { /* uses xaxis symmetry */
X          if ((k = wk->xxstart + (wk->xxstop - j)) < j)
X         if (num_worklist >= MAXCALCWORK) /* no room to split */
X            restart_window(i);
X         else { /* split it */
X            worklist[num_worklist] = worklist[i];
X            worklist[num_worklist].xxstart = k;
X            worklist[num_worklist++].xxstop = j;
X            j = k-1; }
X          wk->sym &= -1 - 2; }
X       wk->xxstop = j; }
X    if (wk->yybegin < wk->yystart) wk->yybegin = wk->yystart;
X    if (wk->yybegin > wk->yystop)  wk->yybegin = wk->yystop;
X    }
X    tidy_worklist(); /* combine where possible, re-sort */
X}
X
SHAR_EOF
$TOUCH -am 1028230093 zoom.c &&
chmod 0644 zoom.c ||
echo "restore of zoom.c failed"
set `wc -c zoom.c`;Wc_c=$1
if test "$Wc_c" != "18354"; then
    echo original size 18354, current size $Wc_c
fi
# ============= fractint.h ==============
echo "x - extracting fractint.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > fractint.h &&
X/* FRACTINT.H - common structures and values for the FRACTINT routines */
X
X#if defined(PUTTHEMHERE)        /* this MUST be defined ONLY in FRACTINT.C */
Xstruct videoinfo videoentry;
Xint helpmode;
X#endif
X
X#ifndef FRACTINT_H
X#define FRACTINT_H
X
X#if !defined(PUTTHEMHERE)
Xextern struct videoinfo videoentry;
Xextern int        helpmode;
X#endif
X
X#include <math.h>
X#include "port.h"
X
Xtypedef BYTE BOOLEAN;
X
X#ifndef C6
X#define _fastcall    /* _fastcall is a Microsoft C6.00 extension */
X#endif
X
X#ifndef XFRACT
Xtypedef int SEGTYPE;
Xtypedef unsigned USEGTYPE;
X#ifdef __TURBOC__
X#   define _bios_printer(a,b,c)   biosprint((a),(c),(b))
X#   define _bios_serialcom(a,b,c) bioscom((a),(c),(b))
X#else
X#ifndef __WATCOMC__
X#ifndef MK_FP
X#   define MK_FP(seg,off) (VOIDFARPTR )( (((long)(seg))<<16) | \
X                                          ((unsigned)(off)) )
X#endif
X#endif
X#endif
X#else
Xtypedef char * SEGTYPE;
Xtypedef char * USEGTYPE;
X#   define MK_FP(seg,off) (VOIDFARPTR )(seg+off)
X#endif
X
X
X#ifndef XFRACT
X#define clock_ticks() clock()
X#endif
X
X#ifdef XFRACT
X#define _fstrcpy(to,from) strcpy(to,from)
X#endif
X
X/* these are used to declare arrays for file names */
X#define FILE_MAX_PATH  80       /* max length of path+filename  */
X#define FILE_MAX_DIR   80       /* max length of directory name */
X#define FILE_MAX_DRIVE  3       /* max length of drive letter   */
X#define FILE_MAX_FNAME  9       /* max length of filename       */
X#define FILE_MAX_EXT    5       /* max length of extension      */
X
X#define MAXPARAMS 10        /* maximum number of parameters */
X#define MAXPIXELS 2048        /* Maximum pixel count across/down the screen */
X#define DEFAULTASPECT 0.75    /* Assumed overall screen dimensions, y/x     */
X
Xstruct videoinfo {        /* All we need to know about a Video Adapter */
X    char    name[26];    /* Adapter name (IBM EGA, etc)        */
X    char    comment[26];    /* Comments (UNTESTED, etc)        */
X    int    keynum;     /* key number used to invoked this mode */
X                /* 2-10 = F2-10, 11-40 = S,C,A{F1-F10}    */
X    int    videomodeax;    /* begin with INT 10H, AX=(this)    */
X    int    videomodebx;    /*        ...and BX=(this)    */
X    int    videomodecx;    /*        ...and CX=(this)    */
X    int    videomodedx;    /*        ...and DX=(this)    */
X                /* NOTE:  IF AX==BX==CX==0, SEE BELOW    */
X    int    dotmode;    /* video access method used by asm code */
X                /*    1 == BIOS 10H, AH=12,13 (SLOW)    */
X                /*    2 == access like EGA/VGA    */
X                /*    3 == access like MCGA        */
X                /*    4 == Tseng-like  SuperVGA*256    */
X                /*    5 == P'dise-like SuperVGA*256   */
X                /*    6 == Vega-like     SuperVGA*256    */
X                /*    7 == "Tweaked" IBM-VGA ...*256  */
X                /*    8 == "Tweaked" SuperVGA ...*256 */
X                /*    9 == Targa Format        */
X                /*    10 = Hercules            */
X                /*    11 = "disk video" (no screen)   */
X                /*    12 = 8514/A            */
X                /*    13 = CGA 320x200x4, 640x200x2    */
X                /*    14 = Tandy 1000         */
X                /*    15 = TRIDENT  SuperVGA*256    */
X                /*    16 = Chips&Tech SuperVGA*256    */
X    int    xdots;        /* number of dots across the screen    */
X    int    ydots;        /* number of dots down the screen    */
X    int    colors;     /* number of colors available        */
X    };
X
X
X#define INFO_ID     "Fractal"
X#define FRACTAL_INFO   struct fractal_info
X
X/*
X * Note: because non-MSDOS machines store structures differently, we have
X * to do special processing of the fractal_info structure in loadfile.c.
X * Make sure changes to the structure here get reflected there.
X */
X#ifndef XFRACT
X#define FRACTAL_INFO_SIZE sizeof(FRACTAL_INFO)
X#else
X/* This value should be the MSDOS size, not the Unix size. */
X#define FRACTAL_INFO_SIZE 502
X#endif
X
Xstruct fractal_info        /*  for saving data in GIF file     */
X{
X    char  info_id[8];        /* Unique identifier for info block */
X    short iterations;
X    short fractal_type;        /* 0=Mandelbrot 1=Julia 2= ... */
X    double xmin;
X    double xmax;
X    double ymin;
X    double ymax;
X    double creal;
X    double cimag;
X    short videomodeax;
X    short videomodebx;
X    short videomodecx;
X    short videomodedx;
X    short dotmode;
X    short xdots;
X    short ydots;
X    short colors;
X    short version;        /* used to be 'future[0]' */
X    float parm3;
X    float parm4;
X    float potential[3];
X    short rseed;
X    short rflag;
X    short biomorph;
X    short inside;
X    short logmap;
X    float invert[3];
X    short decomp[2];
X    short symmetry;
X            /* version 2 stuff */
X    short init3d[16];
X    short previewfactor;
X    short xtrans;
X    short ytrans;
X    short red_crop_left;
X    short red_crop_right;
X    short blue_crop_left;
X    short blue_crop_right;
X    short red_bright;
X    short blue_bright;
X    short xadjust;
X    short eyeseparation;
X    short glassestype;
X            /* version 3 stuff, release 13 */
X    short outside;
X            /* version 4 stuff, release 14 */
X    double x3rd;      /* 3rd corner */
X    double y3rd;
X    char stdcalcmode;      /* 1/2/g/b */
X    char useinitorbit;      /* init Mandelbrot orbit flag */
X    short calc_status;      /* resumable, finished, etc */
X    long tot_extend_len;  /* total length of extension blocks in .gif file */
X    short distest;
X    short floatflag;
X    short bailout;
X    long calctime;
X    BYTE trigndx[4];      /* which trig functions selected */
X    short finattract;
X    double initorbit[2];  /* init Mandelbrot orbit values */
X    short periodicity;      /* periodicity checking */
X            /* version 5 stuff, release 15 */
X    short pot16bit;      /* save 16 bit continuous potential info */
X    float faspectratio;   /* finalaspectratio, y/x */
X    short system;       /* 0 for dos, 1 for windows */
X    short release;      /* release number, with 2 decimals implied */
X    short flag3d;       /* stored only for now, for future use */
X    short transparent[2];
X    short ambient;
X    short haze;
X    short randomize;
X            /* version 6 stuff, release 15.x */
X    short rotate_lo;
X    short rotate_hi;
X    short distestwidth;
X            /* version 7 stuff, release 16 */
X    double dparm3;
X    double dparm4;
X            /* version 8 stuff, release 17 */
X    short fillcolor;
X            /* version 9 stuff, release 18 */
X    double mxmaxfp;
X    double mxminfp;
X    double mymaxfp;
X    double myminfp;
X    short zdots;
X    float originfp;
X    float depthfp;
X    float heightfp;
X    float widthfp;
X    float distfp;
X    float eyesfp;
X    short orbittype;
X    short juli3Dmode;
X    short maxfn;
X    short inversejulia;
X    double dparm5;
X    double dparm6;
X    double dparm7;
X    double dparm8;
X    double dparm9;
X    double dparm10;
X    short future[50];      /* for stuff we haven't thought of yet */
X};
X
X
X
X#define MAXVIDEOMODES 300    /* maximum entries in fractint.cfg      */
X#ifndef XFRACT
X#define MAXVIDEOTABLE 40        /* size of the resident video modes table */
X#else
X#define MAXVIDEOTABLE 2         /* size of the resident video modes table */
X#endif
X
X#define AUTOINVERT -123456.789
X
X#define N_ATTR 8            /* max number of attractors    */
X
Xextern    long     l_at_rad;    /* finite attractor radius  */
Xextern    double     f_at_rad;    /* finite attractor radius  */
X
X#define NUMIFS      64     /* number of ifs functions in ifs array */
X#define IFSPARM    7     /* number of ifs parameters */
X#define IFS3DPARM 13     /* number of ifs 3D parameters */
X
X#define ITEMNAMELEN 18     /* max length of names in .frm/.l/.ifs/.fc */
X
Xstruct moreparams
X{
X   int      type;                        /* index in fractalname of the fractal */
X   char     *param[MAXPARAMS-4];    /* name of the parameters */
X   double   paramvalue[MAXPARAMS-4];     /* default parameter values */
X};
X
Xstruct fractalspecificstuff
X{
X   char  *name;             /* name of the fractal */
X                    /* (leading "*" supresses name display) */
X   char  *param[4];            /* name of the parameters */
X   double paramvalue[4];         /* default parameter values */
X   int     helptext;            /* helpdefs.h HT_xxxx, -1 for none */
X   int     helpformula;            /* helpdefs.h HF_xxxx, -1 for none */
X   int     flags;             /* constraints, bits defined below */
X   float xmin;                /* default XMIN corner */
X   float xmax;                /* default XMAX corner */
X   float ymin;                /* default YMIN corner */
X   float ymax;                /* default YMAX corner */
X   int     isinteger;            /* 1 if integerfractal, 0 otherwise */
X   int     tojulia;            /* mandel-to-julia switch */
X   int     tomandel;            /* julia-to-mandel switch */
X   int     tofloat;            /* integer-to-floating switch */
X   int     symmetry;            /* applicable symmetry logic
X                       0 = no symmetry
X                      -1 = y-axis symmetry (If No Params)
X                       1 = y-axis symmetry
X                      -2 = x-axis symmetry (No Parms)
X                       2 = x-axis symmetry
X                      -3 = y-axis AND x-axis (No Parms)
X                       3 = y-axis AND x-axis symmetry
X                      -4 = polar symmetry (No Parms)
X                       4 = polar symmetry
X                       5 = PI (sin/cos) symmetry
X                       6 = NEWTON (power) symmetry
X                                */
X   int (*orbitcalc)();        /* function that calculates one orbit */
X   int (*per_pixel)();        /* once-per-pixel init */
X   int (*per_image)();        /* once-per-image setup */
X   int (*calctype)();        /* name of main fractal function */
X   int orbit_bailout;        /* usual bailout value for orbit calc */
X};
X
X/* defines for symmetry */
X#define  NOSYM        0
X#define  XAXIS_NOPARM  -1
X#define  XAXIS        1
X#define  YAXIS_NOPARM  -2
X#define  YAXIS        2
X#define  XYAXIS_NOPARM -3
X#define  XYAXIS     3
X#define  ORIGIN_NOPARM -4
X#define  ORIGIN     4
X#define  PI_SYM_NOPARM -5
X#define  PI_SYM     5
X#define  XAXIS_NOIMAG  -6
X#define  XAXIS_NOREAL    6
X#define  NOPLOT        99
X#define  SETUP_SYM    100
X
X/* defines for inside/outside */
X#define ITER        -1
X#define REAL        -2
X#define IMAG        -3
X#define MULT        -4
X#define SUM         -5
X#define ZMAG       -59
X#define BOF60      -60
X#define BOF61      -61
X#define EPSCROSS  -100
X#define STARTRAIL -101
X#define PERIOD    -102
X
X/* bitmask defines for fractalspecific flags */
X#define  NOZOOM     1    /* zoombox not allowed at all       */
X#define  NOGUESS    2    /* solid guessing not allowed       */
X#define  NOTRACE    4    /* boundary tracing not allowed       */
X#define  NOROTATE    8    /* zoombox rotate/stretch not allowed */
X#define  NORESUME      16    /* can't interrupt and resume         */
X#define  INFCALC       32    /* this type calculates forever       */
X#define  TRIG1           64    /* number of trig functions in formula*/
X#define  TRIG2          128
X#define  TRIG3          192
X#define  TRIG4          256
X#define  WINFRAC      512    /* supported in WinFrac           */
X#define  PARMS3D     1024    /* uses 3d parameters           */
X#define  OKJB        2048    /* works with Julibrot */
X#define  MORE        4096    /* more than 4 parms */
X
Xextern struct fractalspecificstuff far fractalspecific[];
Xextern struct fractalspecificstuff far *curfractalspecific;
X
X#define DEFAULTFRACTALTYPE    ".gif"
X#define ALTERNATEFRACTALTYPE    ".fra"
X
X#ifndef _CMPLX_DEFINED
X#define _CMPLX_DEFINED
X
Xstruct DHyperComplex {
X    double x,y;
X    double z,t;
X};
X
Xstruct LHyperComplex {
X    long x,y;
X    long z,t;
X};
X
Xstruct DComplex {
X    double x,y;
X};
X
Xstruct LComplex {
X    long x,y;
X};
X
Xtypedef struct  DComplex         _CMPLX;
Xtypedef struct  LComplex         _LCMPLX;
Xtypedef struct  DHyperComplex    _HCMPLX;
Xtypedef struct  LHyperComplex    _LHCMPLX;
X#endif
X
X#ifndef sqr
X#define sqr(x) ((x)*(x))
X#endif
X
X#ifndef lsqr
X#define lsqr(x) (multiply((x),(x),bitshift))
X#endif
X
X#define CMPLXmod(z)      (sqr((z).x)+sqr((z).y))
X#define CMPLXconj(z)    ((z).y =  -((z).y))
X#define LCMPLXmod(z)       (lsqr((z).x)+lsqr((z).y))
X#define LCMPLXconj(z)    ((z).y =  -((z).y))
X
Xtypedef  _LCMPLX LCMPLX;
X
X/* 3D stuff - formerly in 3d.h */
X#ifndef dot_product
X#define dot_product(v1,v2)  ((v1)[0]*(v2)[0]+(v1)[1]*(v2)[1]+(v1)[2]*(v2)[2])  /* TW 7-09-89 */
X#endif
X
X#define    CMAX    4   /* maximum column (4 x 4 matrix) */
X#define    RMAX    4   /* maximum row     (4 x 4 matrix) */
X#define    DIM       3   /* number of dimensions */
X
Xtypedef double MATRIX [RMAX] [CMAX];  /* matrix of doubles */
Xtypedef int   IMATRIX [RMAX] [CMAX];  /* matrix of ints    */
Xtypedef long  LMATRIX [RMAX] [CMAX];  /* matrix of longs   */
X
X/* A MATRIX is used to describe a transformation from one coordinate
Xsystem to another.  Multiple transformations may be concatenated by
Xmultiplying their transformation matrices. */
X
Xtypedef double VECTOR [DIM];  /* vector of doubles */
Xtypedef int   IVECTOR [DIM];  /* vector of ints    */
Xtypedef long  LVECTOR [DIM];  /* vector of longs   */
X
X/* A VECTOR is an array of three coordinates [x,y,z] representing magnitude
Xand direction. A fourth dimension is assumed to always have the value 1, but
Xis not in the data structure */
X
X
X#define PI 3.14159265358979323846
X
X#define SPHERE      init3d[0]        /* sphere? 1 = yes, 0 = no  */
X#define ILLUMINE  (FILLTYPE>4)    /* illumination model        */
X
X/* regular 3D */
X#define XROT      init3d[1]    /* rotate x-axis 60 degrees */
X#define YROT      init3d[2]    /* rotate y-axis 90 degrees */
X#define ZROT      init3d[3]    /* rotate x-axis  0 degrees */
X#define XSCALE      init3d[4]    /* scale x-axis, 90 percent */
X#define YSCALE      init3d[5]    /* scale y-axis, 90 percent */
X
X/* sphere 3D */
X#define PHI1      init3d[1]    /* longitude start, 180     */
X#define PHI2      init3d[2]    /* longitude end ,   0        */
X#define THETA1      init3d[3]        /* latitude start,-90 degrees */
X#define THETA2      init3d[4]        /* latitude stop,  90 degrees */
X#define RADIUS      init3d[5]    /* should be user input */
X
X/* common parameters */
X#define ROUGH      init3d[6]    /* scale z-axis, 30 percent */
X#define WATERLINE init3d[7]    /* water level            */
X#define FILLTYPE  init3d[8]    /* fill type            */
X#define ZVIEWER   init3d[9]    /* perspective view point   */
X#define XSHIFT      init3d[10]    /* x shift */
X#define YSHIFT      init3d[11]    /* y shift */
X#define XLIGHT      init3d[12]    /* x light vector coordinate */
X#define YLIGHT      init3d[13]    /* y light vector coordinate */
X#define ZLIGHT      init3d[14]    /* z light vector coordinate */
X#define LIGHTAVG  init3d[15]    /* number of points to average */
X
X#ifndef TRUE
X#define TRUE 1
X#define FALSE 0
X#endif
X
X/* Math definitions (normally in float.h) that are missing on some systems. */
X#ifndef FLT_MIN
X#define FLT_MIN 1.17549435e-38
X#endif
X#ifndef FLT_MAX
X#define FLT_MAX 3.40282347e+38
X#endif
X#ifndef DBL_EPSILON
X#define DBL_EPSILON 2.2204460492503131e-16
X#endif
X
X#ifndef XFRACT
X#define UPARR "\x18"
X#define DNARR "\x19"
X#define RTARR "\x1A"
X#define LTARR "\x1B"
X#else
X#define UPARR "K"
X#define DNARR "J"
X#define RTARR "L"
X#define LTARR "H"
X#endif
X
X#define JIIM  0
X#define ORBIT 1
X
Xstruct workliststuff    /* work list entry for std escape time engines */
X{
X    int xxstart;    /* screen window for this entry */
X    int xxstop;
X    int yystart;
X    int yystop;
X    int yybegin;    /* start row within window, for 2pass/ssg resume */
X    int sym;    /* if symmetry in window, prevents bad combines */
X    int pass;    /* for 2pass and solid guessing */
X};
X#define MAXCALCWORK 12
X
Xextern BYTE trigndx[];
Xextern void (*ltrig0)(void), (*ltrig1)(void), (*ltrig2)(void), (*ltrig3)(void);
Xextern void (*dtrig0)(void), (*dtrig1)(void), (*dtrig2)(void), (*dtrig3)(void);
X
Xstruct trig_funct_lst
X{
X    char *name;
X    void (*lfunct)(void);
X    void (*dfunct)(void);
X    void (*mfunct)(void);
X} ;
Xextern struct trig_funct_lst trigfn[];
X
X/* function prototypes */
X
Xextern    void   (_fastcall *plot)(int, int, int);
X
X/* for overlay return stack */
X
X#define ENTER_OVLY(ovlyid)\
X   extern int active_ovly;\
X   int prev_ovly;\
X   prev_ovly = active_ovly;\
X   active_ovly = ovlyid
X#define EXIT_OVLY active_ovly = prev_ovly
X
X#define BIG 100000.0
X
X#define OVLY_MISCOVL   1
X#define OVLY_CMDFILES  2
X#define OVLY_HELP      3
X#define OVLY_PROMPTS1  4
X#define OVLY_PROMPTS2  5
X#define OVLY_LOADFILE  6
X#define OVLY_ROTATE    7
X#define OVLY_PRINTER   8
X#define OVLY_LINE3D    9
X#define OVLY_ENCODER  10
X#define OVLY_CALCFRAC 11
X#define OVLY_INTRO    12
X#define OVLY_DECODER  13
X
X
X#define CTL(x) ((x)&0x1f)
X
X/* nonalpha tests if we have a control character */
X#define nonalpha(c) ((c)<32 || (c)>127)
X
X/* keys */
X#define   INSERT     1082
X#define   DELETE     1083
X#define   PAGE_UP     1073
X#define   PAGE_DOWN     1081
X#define   CTL_HOME     1119
X#define   CTL_END     1117
X#define   LEFT_ARROW     1075
X#define   RIGHT_ARROW     1077
X#define   UP_ARROW     1072
X#define   DOWN_ARROW     1080
X#define   LEFT_ARROW_2     1115
X#define   RIGHT_ARROW_2  1116
X#define   UP_ARROW_2     1141
X#define   DOWN_ARROW_2     1145
X#define   HOME         1071
X#define   END         1079
X#define   ENTER      13
X#define   ENTER_2     1013
X#define   CTL_ENTER      10
X#define   CTL_ENTER_2    1010
X#define   CTL_PAGE_UP    1132
X#define   CTL_PAGE_DOWN  1118
X#define   CTL_MINUS      1142
X#define   CTL_PLUS       1144
X#define   CTL_INSERT     1146
X#define   CTL_DEL        1147
X#define   F1         1059
X#define   F2         1060
X#define   F3         1061
X#define   F4         1062
X#define   F5         1063
X#define   F6         1064
X#define   F7         1065
X#define   F8         1066
X#define   F9         1067
X#define   F10         1068
X#define   TAB            9
X#define   ESC            27
X#define   SPACE          32
X#define   SF1            1084
X#define   SF2            1085
X#define   SF3            1086
X#define   SF4            1087
X#define   SF5            1088
X#define   SF6            1089
X#define   SF7            1090
X#define   SF8            1091
X#define   SF9            1092
X#define   SF10           1093
X/* text colors */
X#define BLACK       0
X#define BLUE       1
X#define GREEN       2
X#define CYAN       3
X#define RED       4
X#define MAGENTA    5
X#define BROWN       6 /* dirty yellow on cga */
X#define WHITE       7
X/* use values below this for foreground only, they don't work background */
X#define GRAY       8 /* don't use this much - is black on cga */
X#define L_BLUE       9
X#define L_GREEN   10
X#define L_CYAN      11
X#define L_RED      12
X#define L_MAGENTA 13
X#define YELLOW      14
X#define L_WHITE   15
X#define INVERSE 0x8000 /* when 640x200x2 text or mode 7, inverse */
X#define BRIGHT    0x4000 /* when mode 7, bright */
X/* and their use: */
Xextern BYTE txtcolor[];
X#define C_TITLE       txtcolor[0]+BRIGHT
X#define C_TITLE_DEV      txtcolor[1]
X#define C_HELP_HDG      txtcolor[2]+BRIGHT
X#define C_HELP_BODY      txtcolor[3]
X#define C_HELP_INSTR      txtcolor[4]
X#define C_HELP_LINK      txtcolor[5]+BRIGHT
X#define C_HELP_CURLINK      txtcolor[6]+INVERSE
X#define C_PROMPT_BKGRD      txtcolor[7]
X#define C_PROMPT_TEXT      txtcolor[8]
X#define C_PROMPT_LO      txtcolor[9]
X#define C_PROMPT_MED      txtcolor[10]
X#ifndef XFRACT
X#define C_PROMPT_HI      txtcolor[11]+BRIGHT
X#else
X#define C_PROMPT_HI      txtcolor[11]
X#endif
X#define C_PROMPT_INPUT      txtcolor[12]+INVERSE
X#define C_PROMPT_CHOOSE   txtcolor[13]+INVERSE
X#define C_CHOICE_CURRENT  txtcolor[14]+INVERSE
X#define C_CHOICE_SP_INSTR txtcolor[15]
X#define C_CHOICE_SP_KEYIN txtcolor[16]+BRIGHT
X#define C_GENERAL_HI      txtcolor[17]+BRIGHT
X#define C_GENERAL_MED      txtcolor[18]
X#define C_GENERAL_LO      txtcolor[19]
X#define C_GENERAL_INPUT   txtcolor[20]+INVERSE
X#define C_DVID_BKGRD      txtcolor[21]
X#define C_DVID_HI      txtcolor[22]+BRIGHT
X#define C_DVID_LO      txtcolor[23]
X#define C_STOP_ERR      txtcolor[24]+BRIGHT
X#define C_STOP_INFO      txtcolor[25]+BRIGHT
X#define C_TITLE_LOW      txtcolor[26]
X#define C_AUTHDIV1      txtcolor[27]+INVERSE
X#define C_AUTHDIV2      txtcolor[28]+INVERSE
X#define C_PRIMARY      txtcolor[29]
X#define C_CONTRIB      txtcolor[30]
X
X/* structure for xmmmoveextended parameter */
Xstruct XMM_Move
X  {
X    unsigned long   Length;
X    unsigned int    SourceHandle;
X    unsigned long   SourceOffset;
X    unsigned int    DestHandle;
X    unsigned long   DestOffset;
X  };
X
X/* structure passed to fullscreen_prompts */
Xstruct fullscreenvalues
X{
X   int type;   /* 'd' for double, 'f' for float, 's' for string,   */
X           /* 'D' for integer in double, '*' for comment */
X           /* 'i' for integer, 'y' for yes=1 no=0              */
X           /* 0x100+n for string of length n           */
X           /* 'l' for one of a list of strings                 */
X   union
X   {
X      double dval;    /* when type 'd' or 'f'  */
X      int    ival;    /* when type is 'i'      */
X      char   sval[16];    /* when type is 's'      */
X      char  *sbuf;    /* when type is 0x100+n  */
X      struct {        /* when type is 'l'      */
X     int  val;    /*   selected choice     */
X     int  vlen;    /*   char len per choice */
X     char **list;    /*   list of values     */
X     int  llen;    /*   number of values     */
X      } ch;
X   } uval;
X};
X#endif
SHAR_EOF
$TOUCH -am 1028230093 fractint.h &&
chmod 0644 fractint.h ||
echo "restore of fractint.h failed"
set `wc -c fractint.h`;Wc_c=$1
if test "$Wc_c" != "19765"; then
    echo original size 19765, current size $Wc_c
fi
# ============= fractype.h ==============
echo "x - extracting fractype.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > fractype.h &&
X#ifndef FRACTYPE_H
X#define FRACTYPE_H
X
X#define SIN        0
X#define COS        1
X#define SINH        2
X#define COSH        3
X#define EXP        4
X#define LOG        5
X#define SQR        6
X
X/* These MUST match the corresponding fractalspecific record in fractals.c */
X#define NOFRACTAL        -1
X#define MANDEL             0
X#define JULIA             1
X#define NEWTBASIN         2
X#define LAMBDA             3
X#define MANDELFP         4
X#define NEWTON             5
X#define JULIAFP          6
X#define PLASMA             7
X#define LAMBDASINE         8 /* obsolete */
X#define MANDELTRIGFP         8
X#define LAMBDACOS         9 /* obsolete */
X#define MANOWARFP         9
X#define LAMBDAEXP        10 /* obsolete */
X#define MANOWAR         10
X#define TEST            11
X#define SIERPINSKI        12
X#define BARNSLEYM1        13
X#define BARNSLEYJ1        14
X#define BARNSLEYM2        15
X#define BARNSLEYJ2        16
X#define MANDELSINE        17 /* obsolete */
X#define SQRTRIG         17
X#define MANDELCOS        18 /* obsolete */
X#define SQRTRIGFP        18
X#define MANDELEXP        19 /* obsolete */
X#define TRIGPLUSTRIG        19
X#define MANDELLAMBDA        20
X#define MARKSMANDEL        21
X#define MARKSJULIA        22
X#define UNITY            23
X#define MANDEL4         24
X#define JULIA4            25
X#define IFS            26
X#define IFS3D            27
X#define BARNSLEYM3        28
X#define BARNSLEYJ3        29
X#define DEMM            30 /* obsolete */
X#define TRIGSQR         30
X#define DEMJ            31 /* obsolete */
X#define TRIGSQRFP        31
X#define BIFURCATION        32
X#define MANDELSINH        33 /* obsolete */
X#define TRIGPLUSTRIGFP        33
X#define LAMBDASINH        34 /* obsolete */
X#define TRIGXTRIG        34
X#define MANDELCOSH        35 /* obsolete */
X#define TRIGXTRIGFP        35
X#define LAMBDACOSH        36 /* obsolete */
X#define SQR1OVERTRIG        36
X#define LMANDELSINE        37 /* obsolete */
X#define SQR1OVERTRIGFP        37
X#define LLAMBDASINE        38 /* obsolete */
X#define ZXTRIGPLUSZ        38
X#define LMANDELCOS        39 /* obsolete */
X#define ZXTRIGPLUSZFP        39
X#define LLAMBDACOS        40 /* obsolete */
X#define KAMFP            40
X#define LMANDELSINH        41 /* obsolete */
X#define KAM            41
X#define LLAMBDASINH        42 /* obsolete */
X#define KAM3DFP         42
X#define LMANDELCOSH        43 /* obsolete */
X#define KAM3D            43
X#define LLAMBDACOSH        44 /* obsolete */
X#define LAMBDATRIG        44
X#define LMANTRIGPLUSZSQRD    45
X#define LJULTRIGPLUSZSQRD    46
X#define FPMANTRIGPLUSZSQRD    47
X#define FPJULTRIGPLUSZSQRD    48
X#define LMANDELEXP        49 /* obsolete */
X#define LAMBDATRIGFP        49
X#define LLAMBDAEXP        50 /* obsolete */
X#define MANDELTRIG        50
X#define LMANDELZPOWER        51
X#define LJULIAZPOWER        52
X#define FPMANDELZPOWER        53
X#define FPJULIAZPOWER        54
X#define FPMANZTOZPLUSZPWR    55
X#define FPJULZTOZPLUSZPWR    56
X#define LMANTRIGPLUSEXP     57
X#define LJULTRIGPLUSEXP     58
X#define FPMANTRIGPLUSEXP    59
X#define FPJULTRIGPLUSEXP    60
X#define FPPOPCORN        61
X#define LPOPCORN        62
X#define FPLORENZ        63
X#define LLORENZ         64
X#define LLORENZ3D        65
X#define MPNEWTON        66
X#define MPNEWTBASIN        67
X#define COMPLEXNEWTON        68
X#define COMPLEXBASIN        69
X#define COMPLEXMARKSMAND    70
X#define COMPLEXMARKSJUL     71
X#define FORMULA         72
X#define FFORMULA        73
X#define SIERPINSKIFP        74
X#define LAMBDAFP        75
X#define BARNSLEYM1FP        76
X#define BARNSLEYJ1FP        77
X#define BARNSLEYM2FP        78
X#define BARNSLEYJ2FP        79
X#define BARNSLEYM3FP        80
X#define BARNSLEYJ3FP        81
X#define MANDELLAMBDAFP        82
X#define JULIBROT        83
X#define FPLORENZ3D        84
X#define LROSSLER        85
X#define FPROSSLER        86
X#define LHENON            87
X#define FPHENON         88
X#define FPPICKOVER        89
X#define FPGINGERBREAD        90
X#define DIFFUSION        91
X#define UNITYFP         92
X#define SPIDERFP        93
X#define SPIDER            94
X#define TETRATEFP        95
X#define MAGNET1M        96
X#define MAGNET1J        97
X#define MAGNET2M        98
X#define MAGNET2J        99
X#define LBIFURCATION           100
X#define LBIFLAMBDA           101
X#define BIFLAMBDA           102
X#define BIFADSINPI           103
X#define BIFEQSINPI           104
X#define FPPOPCORNJUL           105
X#define LPOPCORNJUL           106
X#define LSYSTEM            107
X#define MANOWARJFP           108
X#define MANOWARJ           109
X#define FNPLUSFNPIXFP           110
X#define FNPLUSFNPIXLONG        111
X#define MARKSMANDELPWRFP       112
X#define MARKSMANDELPWR           113
X#define TIMSERRORFP           114
X#define TIMSERROR           115
X#define LBIFEQSINPI           116
X#define LBIFADSINPI           117
X#define BIFSTEWART             118
X#define LBIFSTEWART            119
X#define FPHOPALONG             120
X#define FPCIRCLE               121
X#define FPMARTIN               122
X#define LYAPUNOV               123
X#define FPLORENZ3D1            124
X#define FPLORENZ3D3            125
X#define FPLORENZ3D4            126
X#define LLAMBDAFNFN            127
X#define FPLAMBDAFNFN           128
X#define LJULFNFN               129
X#define FPJULFNFN              130
X#define LMANLAMFNFN            131
X#define FPMANLAMFNFN           132
X#define LMANFNFN               133
X#define FPMANFNFN              134
X#define LBIFMAY                135
X#define BIFMAY                 136
X#define MPHALLEY               137
X#define HALLEY                 138
X#define DYNAMICFP              139
X#define QUATFP                 140
X#define QUATJULFP              141
X#define CELLULAR               142
X#define JULIBROTFP             143
X#define INVERSEJULIA           144
X#define INVERSEJULIAFP         145
X#define MANDELCLOUD            146
X#define PHOENIX                147
X#define PHOENIXFP              148
X#define MANDPHOENIX            149
X#define MANDPHOENIXFP          150
X#define HYPERCMPLXFP           151
X#define HYPERCMPLXJFP           152
X#define FROTH                  153
X#define FROTHFP                154
X#define MANDEL4FP              155
X#define JULIA4FP               156
X#define MARKSMANDELFP          157
X#define MARKSJULIAFP           158
X#define ICON                   159
X#define ICON3D                 160
X
X/* demonstration Mandelbrot and Julia fractals
X
X#define DEMOWALK            161
X#define DEMOMANDEL          162
X#define DEMOJULIA           163
X#define DEMOMANDELFP        164
X#define DEMOJULIAFP         165
X
X*/
X
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 fractype.h &&
chmod 0644 fractype.h ||
echo "restore of fractype.h failed"
set `wc -c fractype.h`;Wc_c=$1
if test "$Wc_c" != "5675"; then
    echo original size 5675, current size $Wc_c
fi
# ============= fmath.h ==============
echo "x - extracting fmath.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > fmath.h &&
X#ifndef FMATH_H
X#define FMATH_H
X
X/* FMath.h (C) 1989, Mark C. Peterson, CompuServe [70441,3353]
X     All rights reserved.
X
X   Code may be used in any program provided the author is credited
X     either during program execution or in the documentation.  Source
X     code may be distributed only in combination with public domain or
X     shareware source code.  Source code may be modified provided the
X     copyright notice and this message is left unchanged and all
X     modifications are clearly documented.
X
X     I would appreciate a copy of any work which incorporates this code,
X     however this is optional.
X
X     Mark C. Peterson
X     128 Hamden Ave., F
X     Waterbury, CT 06704
X     [phone]
X
X     Notes below document changes to Mark's original file:
X
X     Date       Change                                    Changer
X     ============================================================
X     07-16-89 - Added sqrt define per Mark's suggestion   TIW
X     07-26-89 - Added documentation and complex support   MCP
X*/
X
X/*****************
X * Documentation *
X *****************
X
X   #include "fmath.h"
X   float x, y, z;
X   int Pot, Fudge;
X
X                   23-bit accuracy (limit of type float)
X     Regular Implementation               Fast Math Implementation
X --------------------------------------------------------------------
X         z = x + y;                          fAdd(x, y, z);
X         z = x * y;                          fMul(x, y, z);
X         z = x * x;                          fSqr(x, z);
X         z = x / y;                          fDiv(x, y, z);
X         z = x * 2;                          fShift(x, 1, z);
X         z = x * 16;                         fShift(x, 4, z);
X         z = x / 32;                         fShift(x, -5, z);
X         z = x / (pow(2.0, (double)Pot));    fShift(x, -Pot, z);
X         z = (float)Pot * (1L << Fudge);     Fg2Float(Pot, Fudge, z);
X         Pot = (int)(z / (1L << Fudge));     Pot = Float2Fg(z, Fudge);
X
X                  Complex numbers using fComplex structures
X         z = x**2                            fSqrZ(&x, &z);      mod updated
X         z.mod = (z.x*z.x)+(z.y*z.y)         fModZ(&z);          mod updated
X         z = 1 / x                           fInvZ(&x, &z);      mod updated
X         z = x * y                           fMulZ(&x, &y, &z);  mod updated
X         z = x / y                           fDivZ(&x, &y, &z);  mod updated
X
X                            16-bit accuracy
X     Regular Implementation               Fast Math Implementation
X --------------------------------------------------------------------
X         z = x * y;                          fMul16(x, y, z);
X         z = x * x;                          fSqr16(x, z);
X
X                            14-bit accuracy
X     Regular Implementation               Fast Math Implementation
X --------------------------------------------------------------------
X         z = log(x);                         fLog14(x, z);
X         z = exp(x);                         fExp14(x, z);
X         z = pow(x, y);                      fPow14(x, y, z);
X
X                            12-bit accuracy
X     Regular Implementation               Fast Math Implementation
X --------------------------------------------------------------------
X         z = sin(x);                         fSin12(x, z);
X         z = cos(x);                         fCos12(x, z);
X         z = sinh(x);                        fSinh12(x, z);
X         z = cosh(x);                        fCosh12(x, z);
X
X                  Complex numbers using fComplex structures
X         z = sin(x)                          fSinZ(&x, &z);
X         z = cos(x)                          fCosZ(&x, &z);
X         z = tan(x)                          fTagZ(&x, &z);
X         z = sinh(x)                         fSinhZ(&x, &z);
X         z = cosh(x)                         fCoshZ(&x, &z);
X         z = tanh(x)                         fCoshZ(&x, &z);
X
XJust be sure to declare x, y, and z as type floats instead of type double.
X*/
X
Xlong
X#ifndef XFRACT
X   far RegFg2Float(long x, char FudgeFact),
X   far RegSftFloat(long x, char Shift),
X#else
X   far RegFg2Float(long x, int FudgeFact),
X   far RegSftFloat(long x, int Shift),
X#endif
X   far RegFloat2Fg(long x, int Fudge),
X   far RegAddFloat(long x, long y),
X   far RegDivFloat(long x, long y),
X   far RegMulFloat(long x, long y),
X   far RegSqrFloat(long x),
X   far RegSubFloat(long x, long y);
Xlong
X   far r16Mul(long x, long y),
X   far r16Sqr(long x);
Xint
X    far sin13(long x),
X    far cos13(long x),
X    far FastCosine(int x),
X    far FastSine(int x);
Xlong
X    far FastHypCosine(int x),
X    far FastHypSine(int x),
X   far sinh13(long x),
X   far cosh13(long x);
Xlong far LogFudged(unsigned long x, int Fudge);
Xlong far LogFloat14(unsigned long x);
Xunsigned long far ExpFudged(long x, int Fudge);
Xlong far ExpFloat14(long x);
X
X#define fAdd(x, y, z) (void)((*(long*)&z) = RegAddFloat(*(long*)&x, *(long*)&y))
X#define fMul(x, y, z) (void)((*(long*)&z) = RegMulFloat(*(long*)&x, *(long*)&y))
X#define fDiv(x, y, z) (void)((*(long*)&z) = RegDivFloat(*(long*)&x, *(long*)&y))
X#define fSub(x, y, z) (void)((*(long*)&z) = RegSubFloat(*(long*)&x, *(long*)&y))
X#define fMul16(x, y, z) (void)((*(long*)&z) = r16Mul(*(long*)&x, *(long*)&y))
X#define fSqr16(x, z) (void)((*(long*)&z) = r16Sqr(*(long*)&x))
X#define fSqr(x, z) (void)((*(long*)&z) = RegSqrFloat(*(long*)&x))
X#define fShift(x, Shift, z) (void)((*(long*)&z) = \
X   RegSftFloat(*(long*)&x, Shift))
X#define Fg2Float(x, f, z) (void)((*(long*)&z) = RegFg2Float(x, f))
X#define Float2Fg(x, f) RegFloat2Fg(*(long*)&x, f)
X#define fSin12(x, z) (void)((*(long*)&z) = \
X   RegFg2Float((long)sin13(Float2Fg(x, 13)), 13))
X#define fCos12(x, z) (void)((*(long*)&z) = \
X   RegFg2Float((long)cos13(Float2Fg(x, 13)), 13))
X#define fSinh12(x, z) (void)((*(long*)&z) = \
X   RegFg2Float(sinh13(Float2Fg(x, 13)), 13))
X#define fCosh12(x, z) (void)((*(long*)&z) = \
X   RegFg2Float(cosh13(Float2Fg(x, 13)), 13))
X#define fLog14(x, z) (void)((*(long*)&z) = \
X    RegFg2Float(LogFloat14(*(long*)&x), 16))
X#define fExp14(x, z) (void)((*(long*)&z) = ExpFloat14(*(long*)&x));
X#define fPow14(x, y, z) fLog14(x, z); fMul16(z, y, z); fExp14(z, z)
X#define fSqrt14(x, z) fLog14(x, z); fShift(z, -1, z); fExp14(z, z)
X
Xstruct fComplex {
X   float x, y, mod;
X};
X
Xvoid
X   fSqrZ(struct fComplex *x, struct fComplex *z),
X   fMod(struct fComplex *x),
X   fInvZ(struct fComplex *x, struct fComplex *z),
X   fMulZ(struct fComplex *x, struct fComplex *y, struct fComplex *z),
X   fDivZ(struct fComplex *x, struct fComplex *y, struct fComplex *z),
X   fSinZ(struct fComplex *x, struct fComplex *z),
X   fCosZ(struct fComplex *x, struct fComplex *z),
X   fTanZ(struct fComplex *x, struct fComplex *z),
X   fSinhZ(struct fComplex *x, struct fComplex *z),
X   fCoshZ(struct fComplex *x, struct fComplex *z),
X   fTanhZ(struct fComplex *x, struct fComplex *z);
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 fmath.h &&
chmod 0644 fmath.h ||
echo "restore of fmath.h failed"
set `wc -c fmath.h`;Wc_c=$1
if test "$Wc_c" != "6871"; then
    echo original size 6871, current size $Wc_c
fi
# ============= port.h ==============
echo "x - extracting port.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > port.h &&
X/**************************************
X**
X** PORT.H : Miscellaneous definitions for portability.    Please add
X** to this file for any new machines/compilers you may have.
X**
X** XFRACT file "SHARED.H" merged into PORT.H on 3/14/92 by --CWM--
X*/
X
X#ifndef PORT_H        /* If this is defined, this file has been    */
X#define PORT_H         /* included already in this module.        */
X
X#ifdef XFRACT        /* XFRACT forces unix configuration! --CWM-- */
X#ifdef MSDOS
X#undef MSDOS
X#endif
X#ifdef __MSDOS__
X#undef __MSDOS__
X#endif
X#ifndef unix
X#define unix
X#endif
X#endif
X
X#ifdef MSDOS        /* Microsoft C 5.1 for OS/2 and MSDOS */
X    typedef unsigned char  U8;
X    typedef signed char    S8;
X    typedef unsigned short U16;
X    typedef signed short   S16;
X    typedef unsigned long  U32;
X    typedef signed long    S32;
X    typedef unsigned char  BYTE;
X    typedef unsigned char  CHAR;
X    typedef void          *VOIDPTR;
X    typedef void far      *VOIDFARPTR;
X    typedef void const    *VOIDCONSTPTR;
X
X    #define CONST          const
X    #define PRINTER        "/dev/prn"
X    #define LOBYTEFIRST    1
X    #define SLASHC         '\\'
X    #define SLASH          "\\"
X    #define SLASHSLASH     "\\\\"
X    #define SLASHDOT       "\\."
X    #define DOTSLASH       ".\\"
X    #define DOTDOTSLASH    "..\\"
X    #define READMODE    "rb"    /* Correct DOS text-mode        */
X    #define WRITEMODE    "wb"    /* file open "feature".         */
X
X    #define write1(ptr,len,n,stream) fwrite(ptr,len,n,stream)
X    #define write2(ptr,len,n,stream) fwrite(ptr,len,n,stream)
X    #define rand15() rand()
X
X#else            /* may be Turbo-C */
X#ifdef __MSDOS__        /* TURBO-C */
X    typedef unsigned char  U8;
X    typedef signed char    S8;
X    typedef unsigned short U16;
X    typedef signed short   S16;
X    typedef unsigned long  U32;
X    typedef signed long    S32;
X    typedef unsigned char  BYTE;
X    typedef unsigned char  CHAR;
X    typedef void          *VOIDPTR;
X    typedef void far      *VOIDFARPTR;
X    typedef void const    *VOIDCONSTPTR;
X
X    #define CONST          const
X    #define PRINTER        "/dev/prn"
X    #define LOBYTEFIRST    1
X    #define SLASHC         '\\'
X    #define SLASH          "\\"
X    #define SLASHSLASH     "\\\\"
X    #define SLASHDOT       "\\."
X    #define DOTSLASH       ".\\"
X    #define DOTDOTSLASH    "..\\"
X    #define READMODE    "rb"    /* Correct DOS text-mode        */
X    #define WRITEMODE    "wb"    /* file open "feature".         */
X
X    #define write1(ptr,len,n,stream) fwrite(ptr,len,n,stream)
X    #define write2(ptr,len,n,stream) fwrite(ptr,len,n,stream)
X    #define rand15() rand()
X
X#else            /* Have to nest because #elif is not portable */
X#ifdef AMIGA        /* Lattice C 3.02 for Amiga */
X    typedef UBYTE          U8;
X    typedef BYTE           S8;
X    typedef UWORD          U16;
X    typedef WORD           S16;
X    typedef unsigned int   U32;
X    typedef int            S32;
X    typedef UBYTE          BYTE;
X    typedef UBYTE          CHAR;
X    typedef void          *VOIDPTR;
X    typedef void          *VOIDFARPTR;
X    typedef void          *VOIDCONSTPTR;
X
X    #define CONST
X    #define PRINTER        "PRT:"
X    #define LOBYTEFIRST    0
X    #define SLASHC         '/'
X    #define SLASH          "/"
X    #define SLASHSLASH     "//"
X    #define SLASHDOT       "/."
X    #define DOTSLASH       "./"
X    #define DOTDOTSLASH    "../"
X    #define READMODE    "rb"
X    #define WRITEMODE    "wb"
X
X    #define write1(ptr,len,n,stream) (fputc(*(ptr),stream),1)
X    #define write2(ptr,len,n,stream) (fputc((*(ptr))&255,stream),fputc((*(ptr))>>8,stream),1)
X    #define rand15() (rand()&0x7FFF)
X
X#else
X#ifdef unix            /* Unix machine */
X    typedef unsigned char  U8;
X    typedef char           S8;
X    typedef unsigned short U16;
X    typedef short          S16;
X    typedef unsigned long  U32;
X    typedef long           S32;
X    typedef unsigned char  BYTE;
X    typedef char           CHAR;
X#ifdef BADVOID
X    typedef char          *VOIDPTR;
X    typedef char          *VOIDFARPTR;
X    typedef char          *VOIDCONSTPTR;
X#else
X    typedef void          *VOIDPTR;
X    typedef void          *VOIDFARPTR;
X    typedef void          *VOIDCONSTPTR;
X#endif
X
X#    define CONST
X#    define PRINTER        "/dev/lp"
X#    define SLASHC         '/'
X#    define SLASH          "/"
X#    define SLASHSLASH     "//"
X#    define SLASHDOT       "/."
X#    define DOTSLASH       "./"
X#    define DOTDOTSLASH    "../"
X#    define READMODE    "r"
X#    define WRITEMODE    "w"
X
X#    define write1(ptr,len,n,stream) (fputc(*(ptr),stream),1)
X#    define write2(ptr,len,n,stream) (fputc((*(ptr))&255,stream),fputc((*(ptr))>>8,stream),1)
X#    define rand15() (rand()&0x7FFF)
X
X#    include "unix.h"
X
X
X#endif
X#endif
X#endif
X#endif
X
X#ifdef LOBYTEFIRST
X#define GET16(c,i)        (i) = *((U16*)(&(c)))
X#else
X#define GET16(c,i)              (i) = (*(unsigned char *)&(c))+\
X                ((*((unsigned char*)&(c)+1))<<8)
X#endif
X
X#endif    /* PORT_H */
SHAR_EOF
$TOUCH -am 1028230093 port.h &&
chmod 0644 port.h ||
echo "restore of port.h failed"
set `wc -c port.h`;Wc_c=$1
if test "$Wc_c" != "4549"; then
    echo original size 4549, current size $Wc_c
fi
# ============= helpcom.h ==============
echo "x - extracting helpcom.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > helpcom.h &&
X
X/*
X * helpcom.h
X *
X *
X * Common #defines, structures and code for HC.C and HELP.C
X *
X */
X
X#ifndef HELPCOM_H
X#define HELPCOM_H
X
X#include "port.h"
X
X/*
X * help file signature
X * If you get a syntax error, remove the LU from the end of the number.
X */
X
X#define HELP_SIG       (0xAFBC1823LU)
X
X
X/*
X * commands imbedded in the help text
X */
X
X#define CMD_LITERAL      1   /* next char taken literally */
X#define CMD_PARA      2   /* paragraph start code */
X#define CMD_LINK      3   /* hot-link start/end code */
X#define CMD_FF          4   /* force a form-feed */
X#define CMD_XONLINE      5   /* exclude from online help on/off */
X#define CMD_XDOC      6   /* exclude from printed document on/off */
X#define CMD_CENTER      7   /* center this line */
X#define CMD_SPACE      8   /* next byte is count of spaces */
X
X#define MAX_CMD       8
X
X
X/*
X * on-line help dimensions
X */
X
X#define SCREEN_WIDTH      (78)
X#define SCREEN_DEPTH      (22)
X#define SCREEN_INDENT      (1)
X
X
X/*
X * printed document dimensions
X */
X
X#define PAGE_WIDTH       (72)  /* width of printed text */
X#define PAGE_INDENT       (2)     /* indent all text by this much */
X#define TITLE_INDENT       (1)     /* indent titles by this much */
X
X#define PAGE_RDEPTH       (59)  /* the total depth (inc. heading) */
X#define PAGE_HEADING_DEPTH (3)     /* depth of the heading */
X#define PAGE_DEPTH       (PAGE_RDEPTH-PAGE_HEADING_DEPTH) /* depth of text */
X
X
X/*
X * Document page-break macros.    Goto to next page if this close (or closer)
X * to end of page when starting a CONTENT, TOPIC, or at a BLANK line.
X */
X
X#define CONTENT_BREAK (7)  /* start of a "DocContent" entry */
X#define TOPIC_BREAK   (4)  /* start of each topic under a DocContent entry */
X#define BLANK_BREAK   (2)  /* a blank line */
X
X
X/*
X * tokens returned by find_token_length
X */
X
X#define TOK_DONE    (0)   /* len == 0          */
X#define TOK_SPACE   (1)   /* a run of spaces      */
X#define TOK_LINK    (2)   /* an entire link      */
X#define TOK_PARA    (3)   /* a CMD_PARA       */
X#define TOK_NL        (4)   /* a new-line ('\n')    */
X#define TOK_FF        (5)   /* a form-feed (CMD_FF) */
X#define TOK_WORD    (6)   /* a word          */
X#define TOK_XONLINE (7)   /* a CMD_XONLINE      */
X#define TOK_XDOC    (8)   /* a CMD_XDOC       */
X#define TOK_CENTER  (9)   /* a CMD_CENTER      */
X
X
X/*
X * modes for find_token_length() and find_line_width()
X */
X
X#define ONLINE 1
X#define DOC    2
X
X
X/*
X * struct PD_INFO used by process_document()
X */
X
Xtypedef struct
X   {
X
X   /* used by process_document -- look but don't touch! */
X
X   int         pnum,
X         lnum;
X
X   /* PD_GET_TOPIC is allowed to change these */
X
X   char far *curr;
X   unsigned  len;
X
X   /* PD_GET_CONTENT is allowed to change these */
X
X   char far *id;
X   char far *title;
X   int         new_page;
X
X   /* general parameters */
X
X   char far *s;
X   int         i;
X
X
X   } PD_INFO;
X
X
X/*
X * Commands passed to (*get_info)() and (*output)() by process_document()
X */
X
Xenum  PD_COMMANDS
X   {
X
X/* commands sent to pd_output */
X
X   PD_HEADING,           /* call at the top of each page */
X   PD_FOOTING,        /* called at the end of each page */
X   PD_PRINT,        /* called to send text to the printer */
X   PD_PRINTN,        /* called to print a char n times */
X   PD_PRINT_SEC,    /* called to print the section title line */
X   PD_START_SECTION,    /* called at the start of each section */
X   PD_START_TOPIC,    /* called at the start of each topic */
X   PD_SET_SECTION_PAGE, /* set the current sections page number */
X   PD_SET_TOPIC_PAGE,    /* set the current topics page number */
X   PD_PERIODIC,     /* called just before curr is incremented to next token */
X
X/* commands sent to pd_get_info */
X
X   PD_GET_CONTENT,
X   PD_GET_TOPIC,
X   PD_RELEASE_TOPIC,
X   PD_GET_LINK_PAGE
X
X   } ;
X
X
Xtypedef int (*PD_FUNC)(int cmd, PD_INFO *pd, VOIDPTR info);
X
X
Xint _find_token_length(char far *curr, unsigned len, int *size, int *width);
Xint find_token_length(int mode, char far *curr, unsigned len, int *size, int *width);
Xint find_line_width(int mode, char far *curr, unsigned len);
Xint process_document(PD_FUNC get_info, PD_FUNC output, VOIDPTR info);
X
X
X/*
X * Code common to both HC.C and HELP.C (in Fractint).
X * #include INCLUDE_COMMON once for each program
X */
X
X
X#endif
X#ifdef INCLUDE_COMMON
X
X
X#ifndef XFRACT
X#define getint(ptr) (*(int far *)(ptr))
X#define setint(ptr,n) (*(int far *)(ptr)) = n
X#else
X/* Get an int from an unaligned pointer
X * This routine is needed because this program uses unaligned 2 byte
X * pointers all over the place.
X */
Xgetint(ptr)
Xchar *ptr;
X{
X    int s;
X    bcopy(ptr,&s,sizeof(int));
X    return s;
X}
X
X/* Set an int to an unaligned pointer */
Xvoid setint(ptr, n)
Xint n;
Xchar *ptr;
X{
X    bcopy(&n,ptr,sizeof(int));
X}
X#endif
X
X
Xstatic int is_hyphen(char far *ptr)   /* true if ptr points to a real hyphen */
X   {                   /* checkes for "--" and " -" */
X   if ( *ptr != '-' )
X      return (0);    /* that was easy! */
X
X   --ptr;
X
X   return ( *ptr!=' ' && *ptr!='-' );
X   }
X
X
Xint _find_token_length(register char far *curr, unsigned len, int *size, int *width)
X   {
X   register int _size  = 0;
X   register int _width = 0;
X   int tok;
X
X   if (len == 0)
X      tok = TOK_DONE;
X
X   else
X      {
X      switch ( *curr )
X     {
X     case ' ':    /* it's a run of spaces */
X        tok = TOK_SPACE;
X        while ( *curr == ' ' && _size < len )
X           {
X           ++curr;
X           ++_size;
X           ++_width;
X           }
X        break;
X
X     case CMD_SPACE:
X        tok = TOK_SPACE;
X        ++curr;
X        ++_size;
X        _width = *curr;
X        ++curr;
X        ++_size;
X        break;
X
X     case CMD_LINK:
X        tok = TOK_LINK;
X            _size += 1+3*sizeof(int); /* skip CMD_LINK + topic_num + topic_off + page_num */
X            curr += 1+3*sizeof(int);
X
X        while ( *curr != CMD_LINK )
X           {
X           if ( *curr == CMD_LITERAL )
X          {
X          ++curr;
X          ++_size;
X          }
X           ++curr;
X           ++_size;
X           ++_width;
X           assert(_size < len);
X           }
X
X        ++_size;   /* skip ending CMD_LINK */
X        break;
X
X     case CMD_PARA:
X        tok = TOK_PARA;
X        _size += 3;     /* skip CMD_PARA + indent + margin */
X        break;
X
X     case CMD_XONLINE:
X        tok = TOK_XONLINE;
X        ++_size;
X        break;
X
X     case CMD_XDOC:
X        tok = TOK_XDOC;
X        ++_size;
X        break;
X
X     case CMD_CENTER:
X        tok = TOK_CENTER;
X        ++_size;
X        break;
X
X     case '\n':
X        tok = TOK_NL;
X        ++_size;
X        break;
X
X     case CMD_FF:
X        tok = TOK_FF;
X        ++_size;
X        break;
X
X     default:   /* it must be a word */
X        tok = TOK_WORD;
X        while (1)
X           {
X           if ( _size >= len )
X          break;
X
X           else if ( *curr == CMD_LITERAL )
X          {
X          curr += 2;
X          _size += 2;
X          _width += 1;
X          }
X
X           else if ( *curr == '\0' )
X          {
X          assert(0);
X          }
X
X           else if ((unsigned)*curr <= MAX_CMD || *curr == ' ' ||
X            *curr == '\n')
X          break;
X
X           else if ( *curr == '-' )
X          {
X          ++curr;
X          ++_size;
X          ++_width;
X          if ( is_hyphen(curr-1) )
X             break;
X          }
X
X           else
X          {
X          ++curr;
X          ++_size;
X          ++_width;
X          }
X           }
X        break;
X     } /* switch */
X      }
X
X   if (size  != NULL)    *size  = _size;
X   if (width != NULL)    *width = _width;
X
X   return (tok);
X   }
X
X
Xint find_token_length(int mode, char far *curr, unsigned len, int *size, int *width)
X   {
X   int tok;
X   int t;
X   int _size;
X
X   tok = _find_token_length(curr, len, &t, width);
X
X   if ( (tok == TOK_XONLINE && mode == ONLINE) ||
X    (tok == TOK_XDOC    && mode == DOC)     )
X      {
X      _size = 0;
X
X      while (1)
X     {
X     curr  += t;
X     len   -= t;
X     _size += t;
X
X     tok = _find_token_length(curr, len, &t, NULL);
X
X     if ( (tok == TOK_XONLINE && mode == ONLINE) ||
X          (tok == TOK_XDOC      && mode == DOC)    ||
X          (tok == TOK_DONE)                )
X        break;
X     }
X
X      _size += t;
X      }
X   else
X      _size = t;
X
X   if (size != NULL )
X      *size = _size;
X
X   return (tok);
X   }
X
X
Xint find_line_width(int mode, char far *curr, unsigned len)
X   {
X   int size   = 0,
X       width  = 0,
X       lwidth = 0,
X       done   = 0,
X       tok;
X
X   do
X      {
X      tok = find_token_length(mode, curr, len, &size, &width);
X
X      switch(tok)
X     {
X     case TOK_DONE:
X     case TOK_PARA:
X     case TOK_NL:
X     case TOK_FF:
X        done = 1;
X        break;
X
X     case TOK_XONLINE:
X     case TOK_XDOC:
X     case TOK_CENTER:
X        curr += size;
X        len -= size;
X        break;
X
X     default:   /* TOK_SPACE, TOK_LINK or TOK_WORD */
X        lwidth += width;
X        curr += size;
X        len -= size;
X        break;
X     }
X      }
X   while ( !done );
X
X   return (lwidth);
X   }
X
X
X#define DO_PRINTN(ch,n)  ( pd.s = &(ch), pd.i = (n), output(PD_PRINTN, &pd, info) )
X#define DO_PRINT(str,n)  ( pd.s = (str), pd.i = (n), output(PD_PRINT, &pd, info) )
X
X
Xint process_document(PD_FUNC get_info, PD_FUNC output, VOIDPTR info)
X   {
X   int         skip_blanks;
X   int         tok;
X   int         size,
X         width;
X   int         col;
X   char      page_text[10];
X   PD_INFO   pd;
X   char      nl = '\n',
X         sp = ' ';
X   int         first_section,
X         first_topic;
X
X   pd.pnum = 1;
X   pd.lnum = 0;
X
X   col = 0;
X
X   output(PD_HEADING, &pd, info);
X
X   first_section = 1;
X
X   while ( get_info(PD_GET_CONTENT, &pd, info) )
X      {
X      if ( !output(PD_START_SECTION, &pd, info) )
X     return (0);
X
X      if ( pd.new_page && pd.lnum != 0 )
X     {
X     if ( !output(PD_FOOTING, &pd, info) )
X        return (0);
X     ++pd.pnum;
X     pd.lnum = 0;
X     if ( !output(PD_HEADING, &pd, info) )
X        return (0);
X     }
X
X      else
X     {
X     if ( pd.lnum+2 > PAGE_DEPTH-CONTENT_BREAK )
X        {
X        if ( !output(PD_FOOTING, &pd, info) )
X           return (0);
X        ++pd.pnum;
X        pd.lnum = 0;
X        if ( !output(PD_HEADING, &pd, info) )
X           return (0);
X        }
X     else if (pd.lnum > 0)
X        {
X        if ( !DO_PRINTN(nl, 2) )
X           return (0);
X        pd.lnum += 2;
X        }
X     }
X
X      if ( !output(PD_SET_SECTION_PAGE, &pd, info) )
X     return (0);
X
X      if ( !first_section )
X     {
X     if ( !output(PD_PRINT_SEC, &pd, info) )
X        return (0);
X     ++pd.lnum;
X     }
X
X      col = 0;
X
X      first_topic = 1;
X
X      while ( get_info(PD_GET_TOPIC, &pd, info) )
X     {
X     if ( !output(PD_START_TOPIC, &pd, info) )
X        return (0);
X
X     skip_blanks = 0;
X     col = 0;
X
X     if ( !first_section )     /* do not skip blanks for DocContents */
X        {
X        while (pd.len > 0)
X           {
X           tok = find_token_length(DOC, pd.curr, pd.len, &size, NULL);
X           if (tok != TOK_XDOC && tok != TOK_XONLINE &&
X           tok != TOK_NL   && tok != TOK_DONE )
X          break;
X           pd.curr += size;
X           pd.len  -= size;
X           }
X        if ( first_topic && pd.len != 0 )
X           {
X           if ( !DO_PRINTN(nl, 1) )
X          return (0);
X           ++pd.lnum;
X           }
X        }
X
X     if ( pd.lnum > PAGE_DEPTH-TOPIC_BREAK )
X        {
X        if ( !output(PD_FOOTING, &pd, info) )
X           return (0);
X        ++pd.pnum;
X        pd.lnum = 0;
X        if ( !output(PD_HEADING, &pd, info) )
X           return (0);
X        }
X     else if ( !first_topic )
X        {
X        if ( !DO_PRINTN(nl, 1) )
X           return (0);
X        pd.lnum++;
X        }
X
X     if ( !output(PD_SET_TOPIC_PAGE, &pd, info) )
X        return (0);
X
X     do
X        {
X        if ( !output(PD_PERIODIC, &pd, info) )
X           return (0);
X
X        tok = find_token_length(DOC, pd.curr, pd.len, &size, &width);
X
X        switch ( tok )
X           {
X           case TOK_PARA:
X          {
X          int        indent,
X                margin;
X          unsigned  holdlen = 0;
X          char far *holdcurr = 0;
X          int        in_link = 0;
X
X          ++pd.curr;
X
X          indent = *pd.curr++;
X          margin = *pd.curr++;
X
X          pd.len -= 3;
X
X          if ( !DO_PRINTN(sp, indent) )
X             return (0);
X
X          col = indent;
X
X          while (1)
X             {
X             if ( !output(PD_PERIODIC, &pd, info) )
X            return (0);
X
X             tok = find_token_length(DOC, pd.curr, pd.len, &size, &width);
X
X             if ( tok == TOK_NL || tok == TOK_FF )
X            break;
X
X             if ( tok == TOK_DONE )
X            {
X            if (in_link == 0)
X               {
X               col = 0;
X               ++pd.lnum;
X               if ( !DO_PRINTN(nl, 1) )
X                  return (0);
X               break;
X               }
X
X            else if (in_link == 1)
X               {
X               tok = TOK_SPACE;
X               width = 1;
X               size = 0;
X               ++in_link;
X               }
X
X            else if (in_link == 2)
X               {
X               tok = TOK_WORD;
X               width = strlen(page_text);
X               col += 8 - width;
X               size = 0;
X               pd.curr = page_text;
X               ++in_link;
X               }
X
X            else if (in_link == 3)
X               {
X               pd.curr = holdcurr;
X               pd.len = holdlen;
X               in_link = 0;
X               continue;
X               }
X            }
X
X             if ( tok == TOK_PARA )
X            {
X            col = 0;   /* fake a nl */
X            ++pd.lnum;
X            if ( !DO_PRINTN(nl, 1) )
X               return (0);
X            break;
X            }
X
X             if (tok == TOK_XONLINE || tok == TOK_XDOC )
X            {
X            pd.curr += size;
X            pd.len -= size;
X            continue;
X            }
X
X             if ( tok == TOK_LINK )
X            {
X            pd.s = pd.curr+1;
X            if ( get_info(PD_GET_LINK_PAGE, &pd, info) )
X               {
X               in_link = 1;
X               sprintf(page_text, "(p. %d)", pd.i);
X               }
X            else
X               in_link = 3;
X            holdcurr = pd.curr + size;
X            holdlen = pd.len - size;
X                        pd.len = size - 2 - 3*sizeof(int);
X                        pd.curr += 1 + 3*sizeof(int);
X            continue;
X            }
X
X             /* now tok is TOK_SPACE or TOK_WORD */
X
X             if (col+width > PAGE_WIDTH)
X            {       /* go to next line... */
X            if ( !DO_PRINTN(nl, 1) )
X               return (0);
X            if ( ++pd.lnum >= PAGE_DEPTH )
X               {
X               if ( !output(PD_FOOTING, &pd, info) )
X                  return (0);
X               ++pd.pnum;
X               pd.lnum = 0;
X               if ( !output(PD_HEADING, &pd, info) )
X                  return (0);
X               }
X
X            if ( tok == TOK_SPACE )
X               width = 0;    /* skip spaces at start of a line */
X
X            if ( !DO_PRINTN(sp, margin) )
X               return (0);
X            col = margin;
X            }
X
X             if (width > 0)
X            {
X            if (tok == TOK_SPACE)
X               {
X               if ( !DO_PRINTN(sp, width) )
X                  return (0);
X               }
X            else
X               {
X               if ( !DO_PRINT(pd.curr, (size==0) ? width : size) )
X                  return (0);
X               }
X            }
X
X             col += width;
X             pd.curr += size;
X             pd.len -= size;
X             }
X
X          skip_blanks = 0;
X          width = size = 0;
X          break;
X          }
X
X           case TOK_NL:
X          if (skip_blanks && col == 0)
X             break;
X
X          ++pd.lnum;
X
X          if ( pd.lnum >= PAGE_DEPTH || (col == 0 && pd.lnum >= PAGE_DEPTH-BLANK_BREAK) )
X             {
X             if ( col != 0 )    /* if last wasn't a blank line... */
X            {
X            if ( !DO_PRINTN(nl, 1) )
X               return (0);
X            }
X             if ( !output(PD_FOOTING, &pd, info) )
X            return (0);
X             ++pd.pnum;
X             pd.lnum = 0;
X             skip_blanks = 1;
X             if ( !output(PD_HEADING, &pd, info) )
X            return (0);
X             }
X          else
X             {
X             if ( !DO_PRINTN(nl, 1) )
X            return (0);
X             }
X
X          col = 0;
X          break;
X
X           case TOK_FF:
X          if (skip_blanks)
X             break;
X          if ( !output(PD_FOOTING, &pd, info) )
X             return (0);
X          col = 0;
X          pd.lnum = 0;
X          ++pd.pnum;
X          if ( !output(PD_HEADING, &pd, info) )
X             return (0);
X          break;
X
X           case TOK_CENTER:
X          width = (PAGE_WIDTH - find_line_width(DOC,pd.curr,pd.len)) / 2;
X          if ( !DO_PRINTN(sp, width) )
X             return (0);
X          break;
X
X           case TOK_LINK:
X          skip_blanks = 0;
X          if ( !DO_PRINT(pd.curr+1+3*sizeof(int),
X              size-3*sizeof(int)-2) )
X             return (0);
X          pd.s = pd.curr+1;
X          if ( get_info(PD_GET_LINK_PAGE, &pd, info) )
X             {
X             width += 9;
X             sprintf(page_text, " (p. %d)", pd.i);
X             if ( !DO_PRINT(page_text, strlen(page_text)) )
X            return (0);
X             }
X          break;
X
X           case TOK_WORD:
X          skip_blanks = 0;
X          if ( !DO_PRINT(pd.curr, size) )
X             return (0);
X          break;
X
X           case TOK_SPACE:
X          skip_blanks = 0;
X          if ( !DO_PRINTN(sp, width) )
X             return (0);
X          break;
X
X           case TOK_DONE:
X           case TOK_XONLINE:   /* skip */
X           case TOK_XDOC:       /* ignore */
X          break;
X
X           } /* switch */
X
X        pd.curr += size;
X        pd.len  -= size;
X        col     += width;
X        }
X     while (pd.len > 0);
X
X     get_info(PD_RELEASE_TOPIC, &pd, info);
X
X     first_topic = 0;
X     } /* while */
X
X      first_section = 0;
X      } /* while */
X
X   if ( !output(PD_FOOTING, &pd, info) )
X      return (0);
X
X   return (1);
X   }
X
X#undef DO_PRINT
X#undef DO_PRINTN
X
X
X#undef INCLUDE_COMMON
X#endif     /* #ifdef INCLUDE_COMMON */
SHAR_EOF
$TOUCH -am 1028230093 helpcom.h &&
chmod 0644 helpcom.h ||
echo "restore of helpcom.h failed"
set `wc -c helpcom.h`;Wc_c=$1
if test "$Wc_c" != "15703"; then
    echo original size 15703, current size $Wc_c
fi
# ============= helpdefs.h ==============
echo "x - extracting helpdefs.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > helpdefs.h &&
X
X/*
X * helpdefs.h
X *
X * Contains #defines for help.
X *
X * Generated by HC from: help.src
X *
X */
X
X
X/* current help file version */
X
X#define HELP_VERSION                     100
X
X
X/* labels */
X
X#define HELP_INDEX                         0        /* index */
X#define HELP3D                             1
X#define HELP3DFILL                         2
X#define HELP3DFRACT                        3
X#define HELP3DGLASSES                      4
X#define HELP3DLIGHT                        5
X#define HELP3DMODE                         6
X#define HELP3DOVLY                         7
X#define HELP3DPARMS                        8
X#define HELPCOLORMAP                       9
X#define HELPCOMMANDS                      10
X#define HELPCOORDS                        11
X#define HELPCYCLING                       12
X#define HELPFRACTALS                      13
X#define HELPLOADFILE                      14
X#define HELPMAIN                          15
X#define HELPMENU                          16
X#define HELPPARMFILE                      17
X#define HELPSAVEREST                      18
X#define HELPSTARFLD                       19
X#define HELPVIDSEL                        20
X#define HELPVIEW                          21
X#define HELPXHAIR                         22
X#define HELPXOPTS                         23
X#define HELPYOPTS                         24
X#define HELPZOOM                          25
X#define HELP_JIIM                         26
X#define HELP_ORBITS                       27
X#define HF_BARNSJ1                        28
X#define HF_BARNSJ2                        29
X#define HF_BARNSJ3                        30
X#define HF_BARNSM1                        31
X#define HF_BARNSM2                        32
X#define HF_BARNSM3                        33
X#define HF_BIFEQSINPI                     34
X#define HF_BIFLAMBDA                      35
X#define HF_BIFMAY                         36
X#define HF_BIFPLUSSINPI                   37
X#define HF_BIFSTEWART                     38
X#define HF_BIFURCATION                    39
X#define HF_CELLULAR                       40
X#define HF_CIRCLE                         41
X#define HF_CMPLXMARKSJUL                  42
X#define HF_CMPLXMARKSMAND                 43
X#define HF_COMPLEXNEWT                    44
X#define HF_DIFFUS                         45
X#define HF_DYNAM                          46
X#define HF_FNPLUSFN                       47
X#define HF_FNPLUSFNPIX                    48
X#define HF_FNTIMESFN                      49
X#define HF_FNXZPLUSZ                      50
X#define HF_FNZTIMESZ                      51
X#define HF_FROTH                          52
X#define HF_GINGER                         53
X#define HF_HALLEY                         54
X#define HF_HENON                          55
X#define HF_HOPALONG                       56
X#define HF_HYPERC                         57
X#define HF_HYPERCJ                        58
X#define HF_ICON                           59
X#define HF_INVERSE                        60
X#define HF_JULFNPLUSEXP                   61
X#define HF_JULFNPLUSZSQRD                 62
X#define HF_JULIA                          63
X#define HF_JULIA4                         64
X#define HF_JULIAFNFN                      65
X#define HF_JULZPOWER                      66
X#define HF_JULZZPWR                       67
X#define HF_KAM                            68
X#define HF_LAMBDA                         69
X#define HF_LAMBDAFN                       70
X#define HF_LAMBDAFNFN                     71
X#define HF_LORENZ                         72
X#define HF_LORENZ3D1                      73
X#define HF_LORENZ3D3                      74
X#define HF_LORENZ3D4                      75
X#define HF_MAGJ1                          76
X#define HF_MAGJ2                          77
X#define HF_MAGM1                          78
X#define HF_MAGM2                          79
X#define HF_MANDEL                         80
X#define HF_MANDEL4                        81
X#define HF_MANDELCLOUD                    82
X#define HF_MANDELFNFN                     83
X#define HF_MANDFN                         84
X#define HF_MANDFNPLUSEXP                  85
X#define HF_MANDFNPLUSZSQRD                86
X#define HF_MANDPHOENIX                    87
X#define HF_MANLAMFNFN                     88
X#define HF_MANOWAR                        89
X#define HF_MANOWARJ                       90
X#define HF_MANZPOWER                      91
X#define HF_MANZZPWR                       92
X#define HF_MARKSJULIA                     93
X#define HF_MARKSMAND                      94
X#define HF_MARKSMANDPWR                   95
X#define HF_MARTIN                         96
X#define HF_MLAMBDA                        97
X#define HF_NEWT                           98
X#define HF_NEWTBAS                        99
X#define HF_PHOENIX                       100
X#define HF_PICKOVER                      101
X#define HF_PLASMA                        102
X#define HF_POPCJUL                       103
X#define HF_POPCORN                       104
X#define HF_QUAT                          105
X#define HF_QUATJ                         106
X#define HF_ROSS                          107
X#define HF_SIER                          108
X#define HF_SPIDER                        109
X#define HF_SQRFN                         110
X#define HF_SQROVFN                       111
X#define HF_TEST                          112
X#define HF_TETRATE                       113
X#define HF_TIMSERR                       114
X#define HF_UNITY                         115
X#define HT_BARNS                         116
X#define HT_BIF                           117
X#define HT_CELLULAR                      118
X#define HT_CIRCLE                        119
X#define HT_DIFFUS                        120
X#define HT_DYNAM                         121
X#define HT_FNORFN                        122
X#define HT_FORMULA                       123
X#define HT_FROTH                         124
X#define HT_GINGER                        125
X#define HT_HALLEY                        126
X#define HT_HENON                         127
X#define HT_HYPERC                        128
X#define HT_ICON                          129
X#define HT_IFS                           130
X#define HT_INVERSE                       131
X#define HT_JULIA                         132
X#define HT_JULIBROT                      133
X#define HT_KAM                           134
X#define HT_LAMBDA                        135
X#define HT_LAMBDAFN                      136
X#define HT_LORENZ                        137
X#define HT_LSYS                          138
X#define HT_LYAPUNOV                      139
X#define HT_MAGNET                        140
X#define HT_MANDEL                        141
X#define HT_MANDELCLOUD                   142
X#define HT_MANDFN                        143
X#define HT_MANDJUL4                      144
X#define HT_MARKS                         145
X#define HT_MARTIN                        146
X#define HT_MLAMBDA                       147
X#define HT_NEWT                          148
X#define HT_NEWTBAS                       149
X#define HT_NEWTCMPLX                     150
X#define HT_PHOENIX                       151
X#define HT_PICK                          152
X#define HT_PICKMJ                        153
X#define HT_PLASMA                        154
X#define HT_POPCORN                       155
X#define HT_QUAT                          156
X#define HT_ROSS                          157
X#define HT_SCOTSKIN                      158
X#define HT_SIER                          159
X#define HT_TEST                          160
X#define HT_UNITY                         161
X#define INTRO_AUTHORS                    162
X#define INTRO_CREDITS                    163
X
X
SHAR_EOF
$TOUCH -am 1028230093 helpdefs.h &&
chmod 0644 helpdefs.h ||
echo "restore of helpdefs.h failed"
set `wc -c helpdefs.h`;Wc_c=$1
if test "$Wc_c" != "7593"; then
    echo original size 7593, current size $Wc_c
fi
# ============= mpmath.h ==============
echo "x - extracting mpmath.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > mpmath.h &&
X/*
X *  REMOVED FORMAL PARAMETERS FROM FUNCTION DEFINITIONS (1/4/92)
X */
X
X
X#ifndef MPMATH_H
X#define MPMATH_H
X
X#ifndef _CMPLX_DEFINED
X#define _CMPLX_DEFINED
X
Xstruct DHyperComplex {
X    double x,y;
X    double z,t;
X};
X
Xstruct LHyperComplex {
X    long x,y;
X    long z,t;
X};
X
Xstruct DComplex {
X    double x,y;
X};
X
Xstruct LComplex {
X    long x,y;
X};
X
Xtypedef struct  DComplex         _CMPLX;
Xtypedef struct  LComplex         _LCMPLX;
Xtypedef struct  DHyperComplex    _HCMPLX;
Xtypedef struct  LHyperComplex    _LHCMPLX;
X#endif
X
X#include <math.h>
X
X#ifdef XFRACT
X#define far
X#endif
X
X
X#ifndef XFRACT
Xstruct MP {
X   int Exp;
X        unsigned long Mant;
X};
X#else
Xstruct MP {
X   double val;
X};
X#endif
X
Xstruct MPC {
X        struct MP x, y;
X};
X
Xextern struct MP MPTrigTable[2][4][256], InvHalfPi, HalfPi, InvLn2, Ln2;
Xextern int MPaccuracy, MPOverflow;
Xextern int DivideOverflow;
X
X/* Mark Peterson's expanded floating point operators.  Automatically uses
X   either the 8086 or 80386 processor type specified in global 'cpu'. If
X   the operation results in an overflow (result < 2**(2**14), or division
X   by zero) the global 'MPoverflow' is set to one. */
X
Xextern int cpu;
X
X/* function pointer support added by Tim Wegner 12/07/89 */
Xextern int         (*pMPcmp)(struct MP , struct MP );
Xextern struct MP  *(*pMPmul)(struct MP , struct MP );
Xextern struct MP  *(*pMPdiv)(struct MP , struct MP );
Xextern struct MP  *(*pMPadd)(struct MP , struct MP );
Xextern struct MP  *(*pMPsub)(struct MP , struct MP );
Xextern struct MP  *(*pd2MP)(double )                ;
Xextern double     *(*pMP2d)(struct MP )             ;
X
X
X/*** Formula Declarations ***/
Xtypedef enum { D_MATH, M_MATH, L_MATH } MATH_TYPE;
Xextern MATH_TYPE MathType;
X
X#define fDiv(x, y, z) (void)((*(long*)&z) = RegDivFloat(*(long*)&x, *(long*)&y))
X#define fMul16(x, y, z) (void)((*(long*)&z) = r16Mul(*(long*)&x, *(long*)&y))
X#define fShift(x, Shift, z) (void)((*(long*)&z) = \
X   RegSftFloat(*(long*)&x, Shift))
X#define Fg2Float(x, f, z) (void)((*(long*)&z) = RegFg2Float(x, f))
X#define Float2Fg(x, f) RegFloat2Fg(*(long*)&x, f)
X#define fLog14(x, z) (void)((*(long*)&z) = \
X        RegFg2Float(LogFloat14(*(long*)&x), 16))
X#define fExp14(x, z) (void)((*(long*)&z) = ExpFloat14(*(long*)&x));
X#define fSqrt14(x, z) fLog14(x, z); fShift(z, -1, z); fExp14(z, z)
X
X/* the following are declared 4 dimensional as an experimnent */
X/* changeing declarations to _CMPLX and _LCMPLX restores the code */
X/* to 2D */
Xunion Arg {
X   _CMPLX     d;
X   struct MPC m;
X   _LCMPLX    l;
X/*
X   _DHCMPLX   dh;
X   _LHCMPLX   lh; */
X};
X
Xstruct ConstArg {
X   char *s;
X   int len;
X   union Arg a;
X};
X
Xextern union Arg *Arg1,*Arg2;
X
Xextern void lStkSin(void),lStkCos(void),lStkSinh(void),lStkCosh(void),lStkLog(void),lStkExp(void),lStkSqr(void);
Xextern void dStkSin(void),dStkCos(void),dStkSinh(void),dStkCosh(void),dStkLog(void),dStkExp(void),dStkSqr(void);
X
Xextern void (*ltrig0)(void);
Xextern void (*ltrig1)(void);
Xextern void (*ltrig2)(void);
Xextern void (*ltrig3)(void);
Xextern void (*dtrig0)(void);
Xextern void (*dtrig1)(void);
Xextern void (*dtrig2)(void);
Xextern void (*dtrig3)(void);
X
X/* -------------------------------------------------------------------- */
X/*   The following #defines allow the complex transcendental functions    */
X/*   in parser.c to be used here thus avoiding duplicated code.     */
X/* -------------------------------------------------------------------- */
X#ifndef XFRACT
X
X#define CMPLXmod(z)      (sqr((z).x)+sqr((z).y))
X#define CMPLXconj(z)    ((z).y =  -((z).y))
X#define LCMPLXmod(z)       (lsqr((z).x)+lsqr((z).y))
X#define LCMPLXconj(z)    ((z).y =  -((z).y))
X
X
X#define LCMPLXtrig0(arg,out) Arg1->l = (arg); ltrig0(); (out)=Arg1->l
X#define LCMPLXtrig1(arg,out) Arg1->l = (arg); ltrig1(); (out)=Arg1->l
X#define LCMPLXtrig2(arg,out) Arg1->l = (arg); ltrig2(); (out)=Arg1->l
X#define LCMPLXtrig3(arg,out) Arg1->l = (arg); ltrig3(); (out)=Arg1->l
X
X#endif /* XFRACT */
X
X#define  CMPLXtrig0(arg,out) Arg1->d = (arg); dtrig0(); (out)=Arg1->d
X#define  CMPLXtrig1(arg,out) Arg1->d = (arg); dtrig1(); (out)=Arg1->d
X#define  CMPLXtrig2(arg,out) Arg1->d = (arg); dtrig2(); (out)=Arg1->d
X#define  CMPLXtrig3(arg,out) Arg1->d = (arg); dtrig3(); (out)=Arg1->d
X
X#ifndef XFRACT
X
X#define LCMPLXsin(arg,out)   Arg1->l = (arg); lStkSin();  (out) = Arg1->l
X#define LCMPLXcos(arg,out)   Arg1->l = (arg); lStkCos();  (out) = Arg1->l
X#define LCMPLXsinh(arg,out)  Arg1->l = (arg); lStkSinh(); (out) = Arg1->l
X#define LCMPLXcosh(arg,out)  Arg1->l = (arg); lStkCosh(); (out) = Arg1->l
X#define LCMPLXlog(arg,out)   Arg1->l = (arg); lStkLog();  (out) = Arg1->l
X#define LCMPLXexp(arg,out)   Arg1->l = (arg); lStkExp();  (out) = Arg1->l
X/*
X#define LCMPLXsqr(arg,out)   Arg1->l = (arg); lStkSqr();  (out) = Arg1->l
X*/
X#define LCMPLXsqr(arg,out)   \
X   (out).x = lsqr((arg).x) - lsqr((arg).y);\
X   (out).y = multiply((arg).x, (arg).y, bitshiftless1)
X#define LCMPLXsqr_old(out)     \
X   (out).y = multiply(lold.x, lold.y, bitshiftless1);\
X   (out).x = ltempsqrx - ltempsqry\
X
X#define LCMPLXpwr(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
X     lStkPwr(); Arg1++; Arg2++; (out) = Arg2->l
X#define LCMPLXmult(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
X     lStkMul(); Arg1++; Arg2++; (out) = Arg2->l
X#define LCMPLXadd(arg1,arg2,out)    \
X    (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
X#define LCMPLXsub(arg1,arg2,out)    \
X    (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
X
X#define LCMPLXtimesreal(arg,real,out)    \
X    (out).x = multiply((arg).x,(real),bitshift);\
X    (out).y = multiply((arg).y,(real),bitshift)
X
X#define LCMPLXrecip(arg,out)    \
X{ long denom; denom = lsqr((arg).x) + lsqr((arg).y);\
Xif(denom==0L) overflow=1; else {(out).x = divide((arg).x,denom,bitshift);\
X(out).y = -divide((arg).y,denom,bitshift);}}
X#endif /* XFRACT */
X
X#define CMPLXsin(arg,out)    Arg1->d = (arg); dStkSin();  (out) = Arg1->d
X#define CMPLXcos(arg,out)    Arg1->d = (arg); dStkCos();  (out) = Arg1->d
X#define CMPLXsinh(arg,out)   Arg1->d = (arg); dStkSinh(); (out) = Arg1->d
X#define CMPLXcosh(arg,out)   Arg1->d = (arg); dStkCosh(); (out) = Arg1->d
X#define CMPLXlog(arg,out)    Arg1->d = (arg); dStkLog();  (out) = Arg1->d
X#define CMPLXexp(arg,out)    FPUcplxexp(&(arg), &(out))
X/*
X#define CMPLXsqr(arg,out)    Arg1->d = (arg); dStkSqr();  (out) = Arg1->d
X*/
X#define CMPLXsqr(arg,out)    \
X   (out).x = sqr((arg).x) - sqr((arg).y);\
X   (out).y = ((arg).x+(arg).x) * (arg).y
X#define CMPLXsqr_old(out)    \
X   (out).y = (old.x+old.x) * old.y;\
X   (out).x = tempsqrx - tempsqry
X
X#define CMPLXpwr(arg1,arg2,out)   (out)= ComplexPower((arg1), (arg2))
X#define CMPLXmult1(arg1,arg2,out)    Arg2->d = (arg1); Arg1->d = (arg2);\
X     dStkMul(); Arg1++; Arg2++; (out) = Arg2->d
X#define CMPLXmult(arg1,arg2,out)  \
X    {\
X       _CMPLX TmP;\
X       TmP.x = (arg1).x*(arg2).x - (arg1).y*(arg2).y;\
X       TmP.y = (arg1).x*(arg2).y + (arg1).y*(arg2).x;\
X       (out) = TmP;\
X     }
X#define CMPLXadd(arg1,arg2,out)    \
X    (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
X#define CMPLXsub(arg1,arg2,out)    \
X    (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
X#define CMPLXtimesreal(arg,real,out)   \
X    (out).x = (arg).x*(real);\
X    (out).y = (arg).y*(real)
X
X#define CMPLXrecip(arg,out)    \
X   { double denom; denom = sqr((arg).x) + sqr((arg).y);\
X     if(denom==0.0) {(out).x = 1.0e10;(out).y = 1.0e10;}else\
X    { (out).x =  (arg).x/denom;\
X     (out).y = -(arg).y/denom;}}
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 mpmath.h &&
chmod 0644 mpmath.h ||
echo "restore of mpmath.h failed"
set `wc -c mpmath.h`;Wc_c=$1
if test "$Wc_c" != "7413"; then
    echo original size 7413, current size $Wc_c
fi
# ============= targa.h ==============
echo "x - extracting targa.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > targa.h &&
X/* targa.h */
X
X
X#ifndef TARGA_H
X#define TARGA_H
X
X#ifndef XFRACT
X#include    <dos.h>
X#endif
X
X
Xextern unsigned int _dataseg_xx;
X
X/****************************************************************/
X
X#ifdef __TURBOC__
X#    define        PEEK(a,b,c,d)        movedata( b, a, _DS, c, d)
X#    define        POKE(a,b,c,d)        movedata( _DS, c, b, a, d )
X#    define        OUTPORTB    outportb
X#    define        INPORTB     inportb
X#    define        OUTPORTW    outport
X#    define        INPORTW     inport
X#else
X#    define        PEEK(a,b,c,d)        movedata( b, a, _dataseg_xx, c, d)
X#    define        POKE(a,b,c,d)        movedata( _dataseg_xx, c, b, a, d )
X#    define        OUTPORTB    outp
X#    define        INPORTB     inp
X#    define        OUTPORTW    outpw
X#    define        INPORTW     inpw
X#endif
X
X#define  FALSE    0
X#ifdef TRUE
X#undef TRUE
X#endif
X#define  TRUE    1
X
X/****************************************************************/
X
X#define TSEG            0xA000
X#define TIOBASE     0x220
X
X
X/****************************************************************/
X
X
X#define     TYPE_8        8
X#define     TYPE_16     16
X#define     TYPE_24     24
X#define     TYPE_32     32
X#define     TYPE_M8     -8
X
X/*
X * TARGA: 400 to 482 rows x 512 pixels/row X 16 bits/pixel
X */
X
X#define XMIN        0
X#define YMIN        0
X#define XMAX        512            /* maximum X value */
X#define YMAX        512            /* maximum Y value */
X#define XRES        512            /* X resolution */
X#define YRES        512            /* Y Resolution */
X#define YVISMAX     (2*targa.LinesPerField) /* Maximum visible Y coordinate */
X#define YVISMIN     0            /* Minimum visible Y coordiate */
X#define DEF_ROWS    400            /* Default number of rows */
X
X#define IOBASE        targa.iobase        /* io base location of graphics registers */
X#define MEMSEG        targa.memloc        /*  use the variable so we can use */
X#define SCNSEG        targa.memloc        /*  the one defined in TARGA */
X#define SRCBANK     (targa.memloc+0x0800)    /*  use high-bank as source bank */
X#define DESTBANK    targa.memloc        /*  use lo-bank as destination bank */
X
X/*    Output register definitions     */
X#define MODEREG     (IOBASE+0xC00)    /* Mode Register address */
X#define MASKREG     (IOBASE+0x800)    /* Mask Registers */
X#define UNDERREG    (IOBASE+0x800)    /* Underscan register */
X#define OVERREG     (IOBASE+0x802)    /* overscan register */
X#define DESTREG     (IOBASE+0x802)    /* Address of Page Select Lower Register */
X#define SRCREG        (IOBASE+0x803)    /* Address of Page Select Upper Register */
X#define VCRCON        (IOBASE+0x400)    /* Address of Contrast/VidSrc Register */
X#define BLNDREG     VCRCON
X#define SATHUE        (IOBASE+0x402)    /* Satuation/Hue Register address */
X#define DRREG        (IOBASE+0x401)    /* ADDRESS OF Controller Write Register */
X#define VERTPAN     (IOBASE+0x403)    /* Address of Vertical Pan Register */
X#define BORDER        (IOBASE)    /* Address of Page Select Lower Register */
X
X/*    Input register definitions  */
X#define VIDEOSTATUS    (IOBASE+0xC02)    /* Video Status Register */
X#define RASTERREG    (IOBASE+0xC00)    /* Raster counter register */
X
X/*    Default register values     */
X#define DEF_MODE 1            /* Default mode register value */
X                                                            /*    Memory selected, 512x512, 1x */
X                                                            /*    Display mode */
X#define DEF_MASK    0        /* default memory mask */
X#define DEF_SATURATION    0x4        /* default saturation value */
X#define DEF_HUE     0x10        /* default hue value */
X#define DEF_CONTRAST    0x10        /* default contrast value */
X#define DEF_VIDSRC    0        /* default video source value - Composite */
X#define DEF_VERTPAN    56        /* assumes 400-line output */
X#define DEF_BORDER    0        /* default border color */
X
X
X/*    MASK AND SHIFT VALUE FOR REGISTERS CONTAINING SUBFIELDS  */
X/*
X *        ******************************************************
X *                    MODE REGISTERS
X *        ******************************************************
X */
X#define MSK_MSEL    0xfffC        /* memory select bits */
X#define SHF_MSEL    0x0000
X#define MSEL        1
X
X#define MSK_IBIT    0xfffb        /* Interlace bit */
X#define SHF_IBIT    2
X
X#define MSK_RES     0xFFC7        /* disp. resolution and screen select bits */
X#define SHF_RES     3
X#define S0_512X512_0    0        /* 512x512 resolution screen */
X#define S1_512X512_1    1
X#define S2_512X256_0    2        /* 512x256 resolution screen 0 */
X#define S3_512X256_1    3        /* 512x256 resolution screen 1 */
X#define S4_256X256_0    4        /* 256x256 resolution screen 0 */
X#define S5_256X256_1    5        /*            ....        */
X#define S6_256X256_2    6
X#define S7_256X256_3    7
X
X#define MSK_REGWRITE    0xFFBF        /* mask for display register write */
X#define SHF_REGWRITE    6
X#define REGINDEX    0        /* to write an index value */
X#define REGVALUE    1        /* to write a value */
X
X#define MSK_BIT9    0xFF7F        /* maks for high-order bit of DR's */
X#define SHF_BIT9    7
X
X#define MSK_TAPBITS    0xFCFF        /* mask for setting the tap bits */
X#define SHF_TAPBITS    8
X
X#define MSK_ZOOM    0xF3FF        /* Mask for zoom factor */
X#define SHF_ZOOM    10
X
X#define MSK_DISPLAY    0xCFFF        /* Mask for display mode */
X#define SHF_DISPLAY    12
X#define MEMORY_MODE    0
X#define LIVE_FIXED    1
X#define OVERLAY_MODE    2
X#define LIVE_LIVE    3
X#define DEF_DISPLAY    0
X
X#define MSK_CAPTURE    0xBFFF        /* Mask for capture bit */
X#define SHF_CAPTURE    14
X
X#define MSK_GENLOCK    0x7FFF        /* MASK FOR GENLOCK */
X#define SHF_GENLOCK    15
X#define DEF_GENLOCK    0
X
X/*    Video status input register     */
X#define FIELDBIT    0x0001
X#define VIDEOLOSS    0x0002
X
X/*    VIDEO SOURCE/CONTROL REGISTER     */
X#define MSK_CONTRAST    0xFFC1
X#define SHF_CONTRAST    1
X#define MAX_CONTRAST    0x1f
X
X#define MSK_RGBORCV    0xBF
X#define SHF_RGBORCV    6
X#define RGB        1
X#define CV        0
X
X#define MSK_VCRORCAMERA 0x7F
X#define SHF_VCRORCAMERA 7
X#define VCR        1
X#define CAMERA        0
X
X/*    HUE/SATUATION REGISTER    */
X#define MSK_HUE     0xE0
X#define SHF_HUE     0
X#define MAX_HUE     0x1f
X
X#define MSK_SATURATION    0x1F
X#define SHF_SATURATION    5
X#define MAX_SATURATION    0x07
X
X
X/*
X *    *********************************************
X *            Display register settings
X *    *********************************************
X *
X *    Screen Positioning Registers:
X *        DR 0-3
X */
X#define LEFTBORDER    0
X#define DEF_LEFT    85
X#define MIN_LEFT    75
X#define MAX_LEFT    95
X#define RIGHTBORDER    1
X#define DEF_RIGHT    (DEF_LEFT+256)
X#define TOPBORDER    2
X#define DEF_TOP     40
X#define MIN_TOP     20
X#define BOTTOMBORDER    3
X#define DEF_BOTTOM    (DEFTOP+DEFROWS/2)
X#define MAX_BOTTOM    261
X
X/*    REgisters which track 0-3     */
X#define DR8        8
X#define PRESHIFT    DR8
X#define EQU_DR8     DR0
X#define DR9        9
X#define EQU_DR9     DR1
X#define DR10        10
X#define EQU_DR10    DR2
X#define DR11        11
X#define EQU_DR11    DR3
X
X/*    REQUIRED REGISTERS    */
X#define DR4        4
X#define DEF_DR4     352
X#define DR5        5
X#define DEF_DR5     1
X#define DR6        6
X#define DEF_DR6     0
X#define DR7        7
X#define DEF_DR7     511
X#define DR12        12
X#define DEF_DR12    20
X#define DR13        13
X#define DEF_DR13    22
X#define DR14        14
X#define DEF_DR14    0
X#define DR15        15
X#define DEF_DR15    511
X#define DR16        16
X#define DEF_DR16    0
X#define DR17        17
X#define DEF_DR17    0
X#define DR18        18
X#define DEF_DR18    0
X#define DR19        19
X#define DEF_DR19    4
X
X/* interlace mode register & parameters */
X#define DR20        20
X#define INTREG        0x14
X#define DEF_INT     0        /* default to interlace mode 0 */
X#define MSK_INTERLACE    0x0003
X
X/**************************************************************/
X
X
Xtypedef struct {
X            /*    Board Configuration */
X    int        memloc;     /* memory segment */
X    int        iobase;     /*  IOBASE segment */
X    int        BytesPerPixel;    /* number of words per pixel */
X    int        RowsPerBank;    /* number of row per 64K bank */
X    int        MaxBanks;    /*   maximum bank id */
X    int        AddressShift;    /*   number of bits to shift address */
X
X        /*    Control registers */
X    int        mode;        /*  mode register */
X    int        Mask;        /*  mask register */
X    int        PageMode;    /*  current page mode (screen res. and page) */
X    unsigned    PageLower;    /*  Lower Page Select register */
X    unsigned    PageUpper;    /*  upper Page select register */
X    int        VCRCon;     /*  VCRContract register */
X    int        SatHue;     /* Hue and Saturation register */
X    long        BorderColor;    /*  Border color register */
X    int        VertShift;    /*  Vertical Pan Register */
X    int        PanXOrig, PanYOrig;    /* x,y pan origin */
X
X        /* TARGA-SET PARAMETERS */
X    int    boardType;        /*  See TYPE_XX  IN THIS FILE */
X        /*  FOR DEFINITION OF Board Types */
X    int    xOffset;        /*  X-offset */
X    int    yOffset;        /*  Y-Offset */
X    int    LinesPerField;        /*  maximum visible row count */
X    int    InterlaceMode;        /*  desired interlace mode */
X    int    AlwaysGenLock;        /*  Genlock always on or not  */
X    int    Contrast;        /*  Desired Contrast */
X    int    Hue;            /*  Desired Hue */
X    int    Saturation;        /*  Desired Satuation */
X    int    RGBorCV;        /*  CV or RGB Input */
X    int    VCRorCamera;        /*  VCR or Camera */
X    int    ovrscnAvail, ovrscnOn;    /*  ovrscnAvail  1  if Overscan installed */
X                                                            /*  ovrscnOn  1 if overscan is stretching */
X        /*    Display Registers */
X    int    DisplayRegister[22];
X
X} TARStruct;
X
X
X/****************************************************************/
X/*  Data Definitions */
X
X#ifdef TARGA_DATA
X#        define    _x_
X#        define    eq( val )    =val
X#else
X#        define    _x_    extern
X#        define    eq( val )
X#endif
X
X_x_ int tseg        eq(    TSEG );
X_x_ int tiobase eq(    TIOBASE );
X
X_x_ TARStruct        targa;
X
X#undef    _x_
X#undef    eq
X
X#endif
X
SHAR_EOF
$TOUCH -am 1028230093 targa.h &&
chmod 0644 targa.h ||
echo "restore of targa.h failed"
set `wc -c targa.h`;Wc_c=$1
if test "$Wc_c" != "8664"; then
    echo original size 8664, current size $Wc_c
fi
# ============= targa_lc.h ==============
echo "x - extracting targa_lc.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > targa_lc.h &&
X#ifndef TARGA_LC_H
X#define TARGA_LC_H
X
X#define HEADERSIZE 18        /* Size, offsets, and masks for the */
X#define O_COMMENTLEN 0        /* TGA file header.  This is not a    */
X#define O_MAPTYPE 1            /* structure to avoid problems with    */
X#define O_FILETYPE 2        /* byte-packing and such.            */
X#define O_MAPORG 3
X#define O_MAPLEN 5
X#define O_MAPSIZE 7
X#define O_XORIGIN 8
X#define O_YORIGIN 10
X#define O_HSIZE 12
X#define O_VSIZE 14
X#define O_ESIZE 16
X#define O_FLAGS 17
X#define M_ORIGIN 0x20
X
X#define    T_NODATA 0
X#define T_RAWMAP 1
X#define T_RAWRGB 2
X#define T_RAWMON 3
X#define T_RLEMAP 9
X#define T_RLERGB 10
X#define T_RLEMON 11
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 targa_lc.h &&
chmod 0644 targa_lc.h ||
echo "restore of targa_lc.h failed"
set `wc -c targa_lc.h`;Wc_c=$1
if test "$Wc_c" != "618"; then
    echo original size 618, current size $Wc_c
fi
# ============= tplus.h ==============
echo "x - extracting tplus.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > tplus.h &&
X/* TPLUS.H, (C) 1991 The Yankee Programmer
X   All Rights Reserved
X
X   This code may be distributed only when bundled with the Fractint
X   source code.
X
X   Mark C. Peterson
X   The Yankee Programmer
X   405-C Queen Street, Suite #181
X   Southington, CT 06489
X   [phone]
X
X*/
X
X#ifndef TPLUS_H
X#define TPLUS_H
X
X#ifdef CTL
X#undef CTL
X#endif
X
X#ifdef __TURBOC__
X#define        OUTPORTB    outportb
X#define        INPORTB     inportb
X#define        OUTPORTW    outport
X#define        INPORTW     inport
X#else
X#define        OUTPORTB    outp
X#define        INPORTB     inp
X#define        OUTPORTW    outpw
X#define        INPORTW     inpw
X#endif
X
Xstruct TPWrite {
X   unsigned
X      COLOR0,  COLOR1,  COLOR2,  COLOR3,  VIDCON,  INDIRECT,   HUESAT,
X      OVSTRT,  MASKL,   MASKH,   LBNK,    HBNK,    MODE1,      MODE2,
X      WBL,     WBH;
X};
X
Xstruct TPRead {
X   unsigned
X      VIDSTAT,          CTL,     MASKL,   LBNK,    READAD,     MODE1,
X      OVSTRT,  USCAN,   MASKH,   OSCAN,   HBNK,    ROWCNT,     MODE2,
X      RBL,     RBH;
X};
X
X/* TPlus Register Data Offsets */
X#define     XDOTS       0
X#define     YDOTS       1
X#define     ASP_RATIO   2
X#define     DEPTH       4
X#define     PAGE        5
X#define     BOTBANK     7
X#define     TOPBANK     8
X#define     ZOOM        10
X#define     DISPMODE    11
X#define     DAC567DATA  15
X#define     VTOP        19
X#define     TOP         51
X#define     BOT         53
X#define     VPAN        55
X#define     NOT_INT     56
X#define     HIRES       61
X#define     PERM        64
X#define     BYCAP       68
X#define     PE          69
X#define     OVLE        70
X#define     HPAN        71
X#define     MEM_BASE    73
X#define     MEM_MAP     74
X#define     LIVEMIXSRC  91
X#define     RGB         93
X#define     SVIDEO      97
X#define     BUFFPORTSRC 98
X#define     CM1         101
X#define     CM2         102
X#define     LUTBYPASS   107
X#define     CM3         113
X#define     LIVEPORTSRC 115
X#define     LIVE8       116
X#define     VGASRC      123
X
Xstruct _BOARD {
X   int ThisBoard, ClearScreen;
X   BYTE far *Screen;
X   unsigned VerPan, HorPan, Top, Bottom;
X   unsigned xdots, ydots, Bank64k, RowBytes, RowsPerBank;
X   unsigned Reg[128];
X#ifndef XFRACT
X   void (*Plot)(int x, int y, unsigned long Color);
X   unsigned long (*GetColor)(int x, int y);
X#else
X   void (*Plot)();
X   unsigned long (*GetColor)();
X#endif
X
X   struct TPRead Read;
X   struct TPWrite Write;
X};
X
Xextern struct _BOARD far TPlus;
X
X#endif
SHAR_EOF
$TOUCH -am 1028230093 tplus.h &&
chmod 0644 tplus.h ||
echo "restore of tplus.h failed"
set `wc -c tplus.h`;Wc_c=$1
if test "$Wc_c" != "2388"; then
    echo original size 2388, current size $Wc_c
fi
# ============= prototyp.h ==============
echo "x - extracting prototyp.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > prototyp.h &&
X/* includes needed to define the prototypes */
X
X#include <stdio.h>
X#include "mpmath.h"
X#include "port.h"
X#include "fractint.h"
X#include "helpcom.h"
X
X/*  calcmand -- assembler file prototypes */
X
Xextern int cdecl calcmandasm();
X
X/*  calmanfp -- assembler file prototypes */
X
Xextern void cdecl calcmandfpasmstart();
Xextern int  cdecl calcmandfpasm();
X
X/*  fpu087 -- assembler file prototypes */
X
Xextern void cdecl FPUcplxmul(_CMPLX *, _CMPLX *, _CMPLX *);
Xextern void cdecl FPUcplxdiv(_CMPLX *, _CMPLX *, _CMPLX *);
Xextern void cdecl FPUsincos(double *, double *, double *);
Xextern void cdecl FPUsinhcosh(double *, double *, double *);
Xextern void cdecl FPUcplxlog(_CMPLX *, _CMPLX *);
Xextern void cdecl SinCos086(long , long *, long *);
Xextern void cdecl SinhCosh086(long , long *, long *);
Xextern long far cdecl r16Mul(long , long );
Xextern long far cdecl RegFloat2Fg(long , int );
Xextern long cdecl Exp086(long);
Xextern unsigned long far cdecl ExpFudged(long , int );
Xextern long far cdecl RegDivFloat(long , long );
Xextern long far cdecl LogFudged(unsigned long , int );
Xextern long far cdecl LogFloat14(unsigned long );
X#ifndef XFRACT
Xextern long far cdecl RegFg2Float(long, char);
Xextern long far cdecl RegSftFloat(long, char);
X#else
Xextern long far cdecl RegFg2Float(long , int );
Xextern long far cdecl RegSftFloat(long , int );
X#endif
X
X/*  fpu387 -- assembler file prototypes */
X
Xextern void cdecl FPUaptan387(double *, double *, double *);
Xextern void cdecl FPUcplxexp387(_CMPLX *, _CMPLX *);
X
X/*  fracsuba -- assembler file prototypes */
X
Xextern int cdecl  longbailout( void );
Xextern int FManOWarfpFractal( void );
Xextern int FJuliafpFractal( void );
Xextern int FBarnsley1FPFractal( void );
Xextern int FBarnsley2FPFractal( void );
Xextern int FLambdaFPFractal( void );
X
X/*  general -- assembler file prototypes */
X
Xextern  long   cdecl multiply(long, long, int);
Xextern  long   cdecl divide(long, long, int);
Xextern  int    cdecl getakey(void);
Xextern  void   cdecl buzzer(int);
Xextern  void   cdecl farmemfree(VOIDFARPTR );
Xextern  int    cdecl far_strlen( char far *);
Xextern  int    cdecl far_strnicmp(char far *, char far *,int);
Xextern  void   cdecl far_strcpy( char far *, char far *);
Xextern  int    cdecl far_strcmp( char far *, char far *);
Xextern  void   cdecl far_stricmp(char far *, char far *);
Xextern  void   cdecl far_strcat( char far *, char far *);
Xextern  void   cdecl far_memset( VOIDFARPTR , int      , int);
Xextern  void   cdecl far_memcpy( VOIDFARPTR , VOIDFARPTR , int);
Xextern  int    cdecl far_memcmp( VOIDFARPTR , VOIDFARPTR , int);
Xextern  void   cdecl far_memicmp(VOIDFARPTR , VOIDFARPTR , int);
Xextern  void   cdecl emmdeallocate(unsigned int);
Xextern  void   cdecl emmgetpage(unsigned int, unsigned int);
Xextern  void   cdecl emmclearpage(unsigned int, unsigned int);
Xextern  int    cdecl keypressed(void);
Xextern  long   cdecl readticker( void );
Xextern  void   cdecl emmdeallocate(unsigned int);
Xextern  void   cdecl xmmdeallocate(unsigned int);
Xextern  void   cdecl snd( int );
Xextern  void   cdecl nosnd( void );
Xextern  void   cdecl initasmvars( void );
X
X#ifndef __BORLANDC__
Xextern  void   cdecl enable( void );
Xextern  void   cdecl disable( void );
Xextern  void   cdecl delay( int );
X#endif
X
Xextern  int    cdecl farread(int, VOIDFARPTR, unsigned);
Xextern  int    cdecl farwrite(int, VOIDFARPTR, unsigned);
Xextern  long   cdecl normalize(char far *);
Xextern  unsigned int cdecl xmmmoveextended(struct XMM_Move *);
Xextern  void   cdecl erasesegment(int, int);
Xextern  int    cdecl IITCoPro( void );
Xextern  int    cdecl F4x4Check( void );
Xextern  int    cdecl F4x4Lock( void );
Xextern  void   cdecl F4x4Free( void );
Xextern  int    cdecl getakeynohelp( void );
Xextern  unsigned int cdecl cmpextra( unsigned int, char *, int );
Xextern  unsigned int cdecl fromextra( unsigned int, char *, int );
Xextern  unsigned int cdecl toextra( unsigned int, char *, int );
Xextern  void   cdecl load_mat(double (*)[4]);
Xextern  VOIDFARPTR cdecl farmemalloc(long);
Xextern  unsigned int *cdecl xmmquery(void);
Xextern  BYTE far *cdecl emmquery(void);
Xextern  unsigned int cdecl emmgetfree(void);
Xextern  unsigned int cdecl emmallocate(unsigned int);
Xextern  unsigned int cdecl emmallocate(unsigned int);
Xextern  unsigned int cdecl xmmallocate(unsigned int);
Xextern  void   mult_vec_iit(VECTOR);
X
X/*  lsysa -- assembler file prototypes */
X
Xextern void lsys_doplus(long);
Xextern void lsys_doplus_pow2(long);
Xextern void lsys_dominus(long);
Xextern void lsys_dominus_pow2(long);
Xextern void lsys_dopipe_pow2(long);
Xextern void lsys_dobang(long);
X
X#ifndef XFRACT
Xextern void lsys_doslash_386(long);
Xextern void lsys_dobslash_386(long);
Xextern void lsys_doat_386(long);
Xextern void lsys_dosizegf_386(long);
Xextern void lsys_dodrawg_386(long);
X#endif
X
X/*  mpmath_a -- assembler file prototypes */
X
Xextern struct MP * MPmul086(struct MP , struct MP );
Xextern struct MP * MPdiv086(struct MP , struct MP );
Xextern struct MP * MPadd086(struct MP , struct MP );
Xextern int         MPcmp086(struct MP , struct MP );
Xextern struct MP * d2MP086(double );
Xextern double    * MP2d086(struct MP );
Xextern struct MP * fg2MP086(long , int );
Xextern struct MP * MPmul386(struct MP , struct MP );
Xextern struct MP * MPdiv386(struct MP , struct MP );
Xextern struct MP * MPadd386(struct MP , struct MP );
Xextern int         MPcmp386(struct MP , struct MP );
Xextern struct MP * d2MP386(double );
Xextern double    * MP2d386(struct MP );
Xextern struct MP * fg2MP386(long , int );
Xextern double *    MP2d(struct MP );
Xextern int         MPcmp(struct MP , struct MP );
Xextern struct MP * MPmul(struct MP , struct MP );
Xextern struct MP * MPadd(struct MP , struct MP );
Xextern struct MP * MPdiv(struct MP , struct MP );
Xextern struct MP * d2MP(double );  /* Convert double to type MP */
Xextern struct MP * fg2MP(long , int ); /* Convert fudged to type MP */
X
X/*  newton -- assembler file prototypes */
X
Xextern int cdecl    NewtonFractal2( void );
Xextern void cdecl   invertz2(_CMPLX *);
X
X/*  tplus_a -- assembler file prototypes */
X
Xextern void WriteTPlusBankedPixel(int, int, unsigned long);
Xextern unsigned long ReadTPlusBankedPixel(int, int);
X
X/*  video -- assembler file prototypes */
X
Xextern void   cdecl adapter_detect(void);
Xextern void   cdecl clearbox(void);
Xextern void   cdecl dispbox(void);
Xextern void   cdecl setvideotext(void);
Xextern void   cdecl setnullvideo(void);
Xextern void   cdecl setfortext(void);
Xextern void   cdecl setforgraphics(void);
Xextern void   cdecl swapnormwrite(void);
Xextern void   cdecl setclear(void);
Xextern int    cdecl SetupShadowVideo(void);
Xextern int    cdecl ShadowVideo(int);
Xextern int    cdecl keycursor(int,int);
Xextern void   cdecl swapnormread(void);
Xextern void   cdecl setvideomode(int, int, int, int);
Xextern void   cdecl movewords(int,BYTE far*,BYTE far*);
Xextern void   cdecl movecursor(int, int);
Xextern void   cdecl get_line(int, int, int, BYTE *);
Xextern void   cdecl put_line(int, int, int, BYTE *);
Xextern void   cdecl setattr(int, int, int, int);
Xextern void   cdecl putstring(int,int,int,CHAR far *);
Xextern void   cdecl spindac(int, int);
Xextern void   cdecl find_special_colors(void);
Xextern char   cdecl get_a_char(void);
Xextern void   cdecl put_a_char(int);
Xextern void   cdecl scrollup(int, int);
Xextern void   cdecl home(void);
Xextern BYTE far *cdecl  findfont(int);
Xextern int _fastcall getcolor(int, int);
Xextern void _fastcall putcolor(int, int, int);
Xextern int  out_line(BYTE *, int);
Xextern void   (*swapsetup)(void);
X
X/*  3d -- C file prototypes */
X
Xextern void identity(MATRIX);
Xextern void mat_mul(MATRIX,MATRIX,MATRIX);
Xextern void scale(double ,double ,double ,MATRIX);
Xextern void xrot(double ,MATRIX);
Xextern void yrot(double ,MATRIX);
Xextern void zrot(double ,MATRIX);
Xextern void trans(double ,double ,double ,MATRIX);
Xextern int cross_product(VECTOR,VECTOR,VECTOR);
Xextern int normalize_vector(VECTOR);
Xextern int vmult(VECTOR,MATRIX,VECTOR);
Xextern void mult_vec_c(VECTOR);
Xextern int perspective(VECTOR);
Xextern int longvmultpersp(LVECTOR,LMATRIX,LVECTOR,LVECTOR,LVECTOR,int);
Xextern int longpersp(LVECTOR,LVECTOR,int );
Xextern int longvmult(LVECTOR,LMATRIX,LVECTOR,int );
X
X/*  calcfrac -- C file prototypes */
X
Xextern void calcfrac_overlay(void);
Xextern int calcfract(void);
Xextern int calcmand(void);
Xextern int calcmandfp(void);
Xextern int StandardFractal(void);
Xextern int test(void);
Xextern int plasma(void);
Xextern int diffusion(void);
Xextern int Bifurcation(void );
Xextern int BifurcLambda(void);
Xextern int BifurcSetTrigPi(void);
Xextern int LongBifurcSetTrigPi(void);
Xextern int BifurcAddTrigPi(void);
Xextern int LongBifurcAddTrigPi(void);
Xextern int BifurcMay(void);
Xextern int BifurcMaySetup(void);
Xextern int LongBifurcMay(void);
Xextern int BifurcLambdaTrig(void);
Xextern int LongBifurcLambdaTrig(void);
Xextern int BifurcVerhulstTrig(void);
Xextern int LongBifurcVerhulstTrig(void);
Xextern int BifurcStewartTrig(void);
Xextern int LongBifurcStewartTrig(void);
Xextern int popcorn(void);
Xextern int lyapunov(void);
Xextern int lya_setup(void);
Xextern int cellular(void);
Xextern int CellularSetup(void);
Xextern int calcfroth(void);
Xextern int froth_setup(void);
Xextern int demowalk(void);
X
X/*  cmdfiles -- C file prototypes */
X
Xextern void cmdfiles_overlay(void);
Xextern int cmdfiles(int ,char **);
Xextern int load_commands(FILE *);
Xextern void set_3d_defaults(void);
X
X/*  decoder -- C file prototypes */
X
Xextern short decoder(short );
X
X/*  diskvid -- C file prototypes */
X
Xextern int startdisk(void);
Xextern int pot_startdisk(void);
Xextern int targa_startdisk(FILE *,int );
Xextern void enddisk(void);
X#ifndef XFRACT
Xextern int readdisk(unsigned int, unsigned int );
Xextern void writedisk(unsigned int, unsigned int, unsigned int );
X#else
Xextern int readdisk(int, int );
Xextern void writedisk(int, int, int );
X#endif
Xextern void targa_writedisk(unsigned int ,unsigned int ,BYTE ,BYTE ,BYTE );
Xextern void dvid_status(int ,char *);
X
X/*  editpal -- C file prototypes */
X
Xextern void EditPalette(void );
Xextern VOIDPTR mem_alloc(unsigned size);
Xvoid putrow(int x, int y, int width, char *buff);
Xvoid getrow(int x, int y, int width, char *buff);
Xvoid mem_init(VOIDPTR block, unsigned size);
Xvoid hline(int x, int y, int width, int color);
Xint Cursor_WaitKey(void);
Xvoid Cursor_CheckBlink(void);
X#ifdef XFRACT
Xvoid Cursor_StartMouseTracking(void);
Xvoid Cursor_EndMouseTracking(void);
X#endif
Xvoid clip_putcolor(int x, int y, int color);
Xint clip_getcolor(int x, int y);
XBOOLEAN Cursor_Construct (void);
Xvoid    Cursor_Destroy   (void);
Xvoid    Cursor_SetPos    (int x, int y);
Xvoid    Cursor_Move        (int xoff, int yoff);
Xint       Cursor_GetX        (void);
Xint       Cursor_GetY        (void);
Xvoid    Cursor_Hide        (void);
Xvoid    Cursor_Show        (void);
X
X/*  encoder -- C file prototypes */
X
Xextern void encoder_overlay(void);
Xextern int savetodisk(char *);
Xextern int encoder(void);
X
X/*  f16 -- C file prototypes */
X
Xextern FILE *t16_open(char *,int *,int *,int *,U8 *);
Xextern int t16_getline(FILE *,int ,U16 *);
X
X/*  fracsubr -- C file prototypes */
X
Xextern void calcfracinit(void);
Xextern void adjust_corner(void);
X#ifndef XFRACT
Xextern int put_resume(int ,... );
Xextern int get_resume(int ,... );
X#else
Xextern int put_resume();
Xextern int get_resume();
X#endif
Xextern int alloc_resume(int ,int );
Xextern int start_resume(void);
Xextern void end_resume(void);
Xextern void sleepms(long );
Xextern void iplot_orbit(long ,long ,int );
Xextern void plot_orbit(double ,double ,int );
Xextern void scrub_orbit(void);
Xextern int add_worklist(int ,int ,int ,int ,int ,int ,int );
Xextern void tidy_worklist(void);
Xextern void get_julia_attractor(double ,double );
Xextern int ssg_blocksize(void);
Xextern void _fastcall symPIplot(int ,int ,int );
Xextern void _fastcall symPIplot2J(int ,int ,int );
Xextern void _fastcall symPIplot4J(int ,int ,int );
Xextern void _fastcall symplot2(int ,int ,int );
Xextern void _fastcall symplot2Y(int ,int ,int );
Xextern void _fastcall symplot2J(int ,int ,int );
Xextern void _fastcall symplot4(int ,int ,int );
Xextern void _fastcall symplot2basin(int ,int ,int );
Xextern void _fastcall symplot4basin(int ,int ,int );
Xextern void _fastcall noplot(int ,int ,int );
X
X/*  fractals -- C file prototypes */
X
Xextern void FloatPreCalcMagnet2(void);
Xextern void cpower(_CMPLX *,int ,_CMPLX *);
Xextern int lcpower(_LCMPLX *,int ,_LCMPLX *,int );
Xextern int complex_mult(_CMPLX ,_CMPLX ,_CMPLX *);
Xextern int complex_div(_CMPLX ,_CMPLX ,_CMPLX *);
Xextern int lcomplex_mult(_LCMPLX ,_LCMPLX ,_LCMPLX *,int );
Xextern int MPCNewtonFractal(void);
Xextern int Barnsley1Fractal(void);
Xextern int Barnsley1FPFractal(void);
Xextern int Barnsley2Fractal(void);
Xextern int Barnsley2FPFractal(void);
Xextern int JuliaFractal(void);
Xextern int JuliafpFractal(void);
Xextern int LambdaFPFractal(void);
Xextern int LambdaFractal(void);
Xextern int SierpinskiFractal(void);
Xextern int SierpinskiFPFractal(void);
Xextern int LambdaexponentFractal(void);
Xextern int LongLambdaexponentFractal(void);
Xextern int FloatTrigPlusExponentFractal(void);
Xextern int LongTrigPlusExponentFractal(void);
Xextern int MarksLambdaFractal(void);
Xextern int MarksLambdafpFractal(void);
Xextern int UnityFractal(void);
Xextern int UnityfpFractal(void);
Xextern int Mandel4Fractal(void);
Xextern int Mandel4fpFractal(void);
Xextern int floatZtozPluszpwrFractal(void);
Xextern int longZpowerFractal(void);
Xextern int longCmplxZpowerFractal(void);
Xextern int floatZpowerFractal(void);
Xextern int floatCmplxZpowerFractal(void);
Xextern int Barnsley3Fractal(void);
Xextern int Barnsley3FPFractal(void);
Xextern int TrigPlusZsquaredFractal(void);
Xextern int TrigPlusZsquaredfpFractal(void);
Xextern int Richard8fpFractal(void);
Xextern int Richard8Fractal(void);
Xextern int PopcornFractal(void);
Xextern int LPopcornFractal(void);
Xextern int MarksCplxMand(void );
Xextern int SpiderfpFractal(void );
Xextern int SpiderFractal(void );
Xextern int TetratefpFractal(void);
Xextern int ZXTrigPlusZFractal(void);
Xextern int ScottZXTrigPlusZFractal(void);
Xextern int SkinnerZXTrigSubZFractal(void);
Xextern int ZXTrigPlusZfpFractal(void);
Xextern int ScottZXTrigPlusZfpFractal(void);
Xextern int SkinnerZXTrigSubZfpFractal(void);
Xextern int Sqr1overTrigFractal(void);
Xextern int Sqr1overTrigfpFractal(void);
Xextern int TrigPlusTrigFractal(void);
Xextern int TrigPlusTrigfpFractal(void);
Xextern int ScottTrigPlusTrigFractal(void);
Xextern int ScottTrigPlusTrigfpFractal(void);
Xextern int SkinnerTrigSubTrigFractal(void);
Xextern int SkinnerTrigSubTrigfpFractal(void);
Xextern int TrigXTrigfpFractal(void);
Xextern int TrigXTrigFractal(void);
Xextern int TryFloatFractal(int (*)());
Xextern int TrigPlusSqrFractal(void);
Xextern int TrigPlusSqrfpFractal(void);
Xextern int ScottTrigPlusSqrFractal(void);
Xextern int ScottTrigPlusSqrfpFractal(void);
Xextern int SkinnerTrigSubSqrFractal(void);
Xextern int SkinnerTrigSubSqrfpFractal(void);
Xextern int TrigZsqrdfpFractal(void);
Xextern int TrigZsqrdFractal(void);
Xextern int SqrTrigFractal(void);
Xextern int SqrTrigfpFractal(void);
Xextern int Magnet1Fractal(void);
Xextern int Magnet2Fractal(void);
Xextern int LambdaTrigFractal(void);
Xextern int LambdaTrigfpFractal(void);
Xextern int LambdaTrigFractal1(void);
Xextern int LambdaTrigfpFractal1(void);
Xextern int LambdaTrigFractal2(void);
Xextern int LambdaTrigfpFractal2(void);
Xextern int ManOWarFractal(void);
Xextern int ManOWarfpFractal(void);
Xextern int MarksMandelPwrfpFractal(void);
Xextern int MarksMandelPwrFractal(void);
Xextern int TimsErrorfpFractal(void);
Xextern int TimsErrorFractal(void);
Xextern int CirclefpFractal(void);
Xextern int long_julia_per_pixel(void);
Xextern int long_richard8_per_pixel(void);
Xextern int long_mandel_per_pixel(void);
Xextern int julia_per_pixel(void);
Xextern int marks_mandelpwr_per_pixel(void);
Xextern int mandel_per_pixel(void);
Xextern int marksmandel_per_pixel(void);
Xextern int marksmandelfp_per_pixel();
Xextern int marks_mandelpwrfp_per_pixel(void);
Xextern int mandelfp_per_pixel(void);
Xextern int juliafp_per_pixel(void);
Xextern int MPCjulia_per_pixel(void);
Xextern int otherrichard8fp_per_pixel(void);
Xextern int othermandelfp_per_pixel(void);
Xextern int otherjuliafp_per_pixel(void);
Xextern int trigmandelfp_per_pixel(void);
Xextern int trigjuliafp_per_pixel(void);
Xextern int trigXtrigmandelfp_per_pixel(void);
Xextern int trigXtrigjuliafp_per_pixel(void);
Xextern int MarksCplxMandperp(void );
Xextern int MandelSetup(void);
Xextern int MandelfpSetup();
Xextern int JuliaSetup(void);
Xextern int NewtonSetup(void);
Xextern int StandaloneSetup(void);
Xextern int UnitySetup(void);
Xextern int JuliafpSetup(void);
Xextern int MandellongSetup(void);
Xextern int JulialongSetup(void);
Xextern int TrigPlusSqrlongSetup(void);
Xextern int TrigPlusSqrfpSetup(void);
Xextern int TrigPlusTriglongSetup(void);
Xextern int TrigPlusTrigfpSetup(void);
Xextern int FnPlusFnSym(void);
Xextern int ZXTrigPlusZSetup(void);
Xextern int LambdaTrigSetup(void);
Xextern int JuliafnPlusZsqrdSetup(void);
Xextern int SqrTrigSetup(void);
Xextern int FnXFnSetup(void);
Xextern int MandelTrigSetup(void);
Xextern int MarksJuliaSetup(void);
Xextern int MarksJuliafpSetup();
Xextern int SierpinskiSetup(void);
Xextern int SierpinskiFPSetup(void);
Xextern int StandardSetup(void);
Xextern int LambdaTrigOrTrigFractal(void);
Xextern int LambdaTrigOrTrigfpFractal(void);
Xextern int LambdaTrigOrTrigSetup(void);
Xextern int JuliaTrigOrTrigFractal(void);
Xextern int JuliaTrigOrTrigfpFractal(void);
Xextern int JuliaTrigOrTrigSetup(void);
Xextern int ManlamTrigOrTrigSetup(void);
Xextern int MandelTrigOrTrigSetup(void);
Xextern int HalleySetup(void);
Xextern int HalleyFractal(void);
Xextern int Halley_per_pixel(void);
Xextern int MPCHalleyFractal(void);
Xextern int MPCHalley_per_pixel(void);
Xextern int dynamfloat(double *,double *,double*);
Xextern int mandelcloudfloat(double *,double *,double*);
Xextern int dynam2dfloatsetup(void);
Xextern int dynam2dfloat(void);
Xextern int QuaternionFPFractal(void);
Xextern int quaternionfp_per_pixel(void);
Xextern int quaternionjulfp_per_pixel(void);
Xextern int LongPhoenixFractal(void);
Xextern int PhoenixFractal(void);
Xextern int PhoenixSetup(void);
Xextern int long_phoenix_per_pixel(void);
Xextern int phoenix_per_pixel(void);
Xextern int MandPhoenixSetup(void);
Xextern int long_mandphoenix_per_pixel(void);
Xextern int mandphoenix_per_pixel(void);
Xextern int HyperComplexFPFractal(void);
X
X/*  fractint -- C file prototypes */
X
Xextern void main(int ,char **);
Xextern int key_count(int );
Xextern int cmp_line(BYTE *,int );
Xextern void flip_image(int kbdchar);
Xextern int pot_line(BYTE *,int );
Xextern void reset_zoom_corners(void);
Xextern void clear_zoombox(void);
Xextern int sound_line(BYTE *,int );
X
X/*  gifview -- C file prototypes */
X
Xextern int get_byte(void);
Xextern int get_bytes(BYTE *,int );
Xextern int gifview(void);
X
X/*  help -- C file prototypes */
X
Xextern int _find_token_length(char far *,unsigned int ,int *,int *);
Xextern int find_token_length(int ,char far *,unsigned int ,int *,int *);
Xextern int find_line_width(int ,char far *,unsigned int );
Xextern int process_document(PD_FUNC ,PD_FUNC ,VOIDPTR );
Xextern void help_overlay(void );
Xextern int help(int );
Xextern int read_help_topic(int ,int ,int ,VOIDFARPTR );
Xextern int makedoc_msg_func(int ,int );
Xextern void print_document(char *,int (*)(int ,int ),int );
Xextern int init_help(void );
Xextern void end_help(void );
X
X/*  intro -- C file prototypes */
X
Xextern void intro_overlay(void );
Xextern void intro(void );
X
X/*  jb -- C file prototypes */
X
Xextern int JulibrotSetup(void );
Xextern int JulibrotfpSetup(void );
Xextern int jb_per_pixel(void );
Xextern int jbfp_per_pixel(void );
Xextern int zline(long ,long );
Xextern int zlinefp(double ,double );
Xextern int Std4dFractal(void );
Xextern int Std4dfpFractal(void );
X
X/*  line3d -- C file prototypes */
X
Xextern void line3d_overlay(void);
Xextern int line3d(BYTE *,unsigned int );
Xextern int _fastcall targa_color(int ,int ,int );
Xextern int targa_validate(char *);
X
X/*  loadfdos -- C file prototypes */
X
Xextern int get_video_mode(struct fractal_info *);
X
X/*  loadfile -- C file prototypes */
X
Xextern void loadfile_overlay(void);
Xextern int read_overlay(void);
Xextern void set_if_old_bif(void);
X
X/*  loadmap -- C file prototypes */
X
Xextern void SetTgaColors(void);
Xextern int ValidateLuts(char *);
Xextern int SetColorPaletteName(char *);
X
X/*  lorenz -- C file prototypes */
X
Xextern int orbit3dlongsetup(void);
Xextern int orbit3dfloatsetup(void);
Xextern int lorenz3dlongorbit(long *,long *,long *);
Xextern int lorenz3d1floatorbit(double *,double *,double *);
Xextern int lorenz3dfloatorbit(double *,double *,double *);
Xextern int lorenz3d3floatorbit(double *,double *,double *);
Xextern int lorenz3d4floatorbit(double *,double *,double *);
Xextern int henonfloatorbit(double *,double *,double *);
Xextern int henonlongorbit(long *,long *,long *);
Xextern int inverse_julia_orbit(double *,double *,double *);
Xextern int Minverse_julia_orbit(void);
Xextern int Linverse_julia_orbit(void);
Xextern int inverse_julia_per_image(void);
Xextern int rosslerfloatorbit(double *,double *,double *);
Xextern int pickoverfloatorbit(double *,double *,double *);
Xextern int gingerbreadfloatorbit(double *,double *,double *);
Xextern int rosslerlongorbit(long *,long *,long *);
Xextern int kamtorusfloatorbit(double *,double *,double *);
Xextern int kamtoruslongorbit(long *,long *,long *);
Xextern int hopalong2dfloatorbit(double *,double *,double *);
Xextern int martin2dfloatorbit(double *,double *,double *);
Xextern int orbit2dfloat(void);
Xextern int orbit2dlong(void);
Xextern int orbit3dlongcalc(void);
Xextern int orbit3dfloatcalc(void);
Xextern int funny_glasses_call(int (*)());
Xextern int ifs(void);
Xextern int ifs2d(void);
Xextern int orbit3dfloat(void);
Xextern int orbit3dlong(void);
Xextern int ifs3d(void);
Xextern int iconfloatorbit(double *, double *, double *);  /* dmf */
X
X/*  lsys -- C file prototypes */
X
Xextern int Lsystem(void);
Xextern int LLoad(void);
X
X/*  miscovl -- C file prototypes */
X
Xextern void miscovl_overlay(void);
Xextern void make_batch_file(void);
Xextern void shell_to_dos(void);
Xextern void showfreemem(void);
Xextern int edit_text_colors(void);
Xextern int select_video_mode(int );
X
X/*  miscres -- C file prototypes */
X
X#ifndef XFRACT
Xextern int timer(int ,int (*)(),... );
Xextern int matherr(struct exception *);
X#else
Xextern int timer();
X#endif
Xextern void restore_active_ovly(void);
Xextern void findpath(char *,char *);
Xextern void notdiskmsg(void);
Xextern int cvtcentermag(double *,double *,double *);
Xextern void updatesavename(char *);
Xextern int check_writefile(char *,char *);
Xextern int check_key(void);
Xextern void showtrig(char *);
Xextern int set_trig_array(int ,char *);
Xextern void set_trig_pointers(int );
Xextern int tab_display(void);
Xextern int endswithslash(char *);
Xextern int ifsload(void);
Xextern int find_file_item(char *,char *,FILE **);
Xextern int file_gets(char *,int ,FILE *);
Xextern void roundfloatd(double *);
X
X/*  mpmath_c -- C file prototypes */
X
Xextern struct MP *MPsub(struct MP ,struct MP );
Xextern struct MP *MPsub086(struct MP ,struct MP );
Xextern struct MP *MPsub386(struct MP ,struct MP );
Xextern struct MP *MPabs(struct MP );
Xextern struct MPC MPCsqr(struct MPC );
Xextern struct MP MPCmod(struct MPC );
Xextern struct MPC MPCmul(struct MPC ,struct MPC );
Xextern struct MPC MPCdiv(struct MPC ,struct MPC );
Xextern struct MPC MPCadd(struct MPC ,struct MPC );
Xextern struct MPC MPCsub(struct MPC ,struct MPC );
Xextern struct MPC MPCpow(struct MPC ,int );
Xextern int MPCcmp(struct MPC ,struct MPC );
Xextern _CMPLX MPC2cmplx(struct MPC );
Xextern struct MPC cmplx2MPC(_CMPLX );
Xextern void setMPfunctions(void );
Xextern _CMPLX ComplexPower(_CMPLX ,_CMPLX );
Xextern void SetupLogTable(void );
Xextern long far ExpFloat14(long );
Xextern int ComplexNewtonSetup(void );
Xextern int ComplexNewton(void );
Xextern int ComplexBasin(void );
Xextern int GausianNumber(int ,int );
X
X/*  msccos -- C file prototypes */
X
Xextern double _cos(double );
X
X/*  parser -- C file prototypes */
X
Xextern unsigned int SkipWhiteSpace(char *);
Xextern unsigned long NewRandNum(void );
Xextern void lRandom(void );
Xextern void dRandom(void );
Xextern void mRandom(void );
Xextern void SetRandFnct(void );
Xextern void RandomSeed(void );
Xextern void lStkSRand(void );
Xextern void mStkSRand(void );
Xextern void dStkSRand(void );
Xextern void dStkAbs(void );
Xextern void mStkAbs(void );
Xextern void lStkAbs(void );
Xextern void dStkSqr(void );
Xextern void mStkSqr(void );
Xextern void lStkSqr(void );
Xextern void dStkAdd(void );
Xextern void mStkAdd(void );
Xextern void lStkAdd(void );
Xextern void dStkSub(void );
Xextern void mStkSub(void );
Xextern void lStkSub(void );
Xextern void dStkConj(void );
Xextern void mStkConj(void );
Xextern void lStkConj(void );
Xextern void dStkZero(void );
Xextern void mStkZero(void );
Xextern void lStkZero(void );
Xextern void dStkReal(void );
Xextern void mStkReal(void );
Xextern void lStkReal(void );
Xextern void dStkImag(void );
Xextern void mStkImag(void );
Xextern void lStkImag(void );
Xextern void dStkNeg(void );
Xextern void mStkNeg(void );
Xextern void lStkNeg(void );
Xextern void dStkMul(void );
Xextern void mStkMul(void );
Xextern void lStkMul(void );
Xextern void dStkDiv(void );
Xextern void mStkDiv(void );
Xextern void lStkDiv(void );
Xextern void StkSto(void );
Xextern void StkLod(void );
Xextern void dStkMod(void );
Xextern void mStkMod(void );
Xextern void lStkMod(void );
Xextern void StkClr(void );
Xextern void dStkFlip(void );
Xextern void mStkFlip(void );
Xextern void lStkFlip(void );
Xextern void dStkSin(void );
Xextern void mStkSin(void );
Xextern void lStkSin(void );
Xextern void dStkTan(void );
Xextern void mStkTan(void );
Xextern void lStkTan(void );
Xextern void dStkTanh(void );
Xextern void mStkTanh(void );
Xextern void lStkTanh(void );
Xextern void dStkCoTan(void );
Xextern void mStkCoTan(void );
Xextern void lStkCoTan(void );
Xextern void dStkCoTanh(void );
Xextern void mStkCoTanh(void );
Xextern void lStkCoTanh(void );
Xextern void dStkRecip(void );
Xextern void mStkRecip(void );
Xextern void lStkRecip(void );
Xextern void StkIdent(void );
Xextern void dStkSinh(void );
Xextern void mStkSinh(void );
Xextern void lStkSinh(void );
Xextern void dStkCos(void );
Xextern void mStkCos(void );
Xextern void lStkCos(void );
Xextern void dStkCosXX(void );
Xextern void mStkCosXX(void );
Xextern void lStkCosXX(void );
Xextern void dStkCosh(void );
Xextern void mStkCosh(void );
Xextern void lStkCosh(void );
Xextern void dStkLT(void );
Xextern void mStkLT(void );
Xextern void lStkLT(void );
Xextern void dStkGT(void );
Xextern void mStkGT(void );
Xextern void lStkGT(void );
Xextern void dStkLTE(void );
Xextern void mStkLTE(void );
Xextern void lStkLTE(void );
Xextern void dStkGTE(void );
Xextern void mStkGTE(void );
Xextern void lStkGTE(void );
Xextern void dStkEQ(void );
Xextern void mStkEQ(void );
Xextern void lStkEQ(void );
Xextern void dStkNE(void );
Xextern void mStkNE(void );
Xextern void lStkNE(void );
Xextern void dStkOR(void );
Xextern void mStkOR(void );
Xextern void lStkOR(void );
Xextern void dStkAND(void );
Xextern void mStkAND(void );
Xextern void lStkAND(void );
Xextern void dStkLog(void );
Xextern void mStkLog(void );
Xextern void lStkLog(void );
Xextern void FPUcplxexp(_CMPLX *,_CMPLX *);
Xextern void dStkExp(void );
Xextern void mStkExp(void );
Xextern void lStkExp(void );
Xextern void dStkPwr(void );
Xextern void mStkPwr(void );
Xextern void lStkPwr(void );
Xextern void (*mtrig0)(void);
Xextern void (*mtrig1)(void);
Xextern void (*mtrig2)(void);
Xextern void (*mtrig3)(void);
Xextern void EndInit(void );
Xextern struct ConstArg far *isconst(char *,int );
Xextern void NotAFnct(void );
Xextern void FnctNotFound(void );
Xextern int whichfn(char *,int );
X#ifndef XFRACT
Xextern void (far *isfunct(char *,int ))(void );
X#else
Xextern void (far *isfunct(char *,int ))();
X#endif
Xextern void RecSortPrec(void );
Xextern int ParseStr(char *);
Xextern int Formula(void );
Xextern int form_per_pixel(void );
Xextern char *FindFormula(char *);
Xextern int RunForm(char *);
Xextern int fpFormulaSetup(void );
Xextern int intFormulaSetup(void );
Xextern void init_misc(void);
Xextern void free_workarea(void);
X
X/*  plot3d -- C file prototypes */
X
Xextern void _fastcall draw_line(int ,int ,int ,int ,int );
Xextern void _fastcall plot3dsuperimpose16b(int ,int ,int );
Xextern void _fastcall plot3dsuperimpose16(int ,int ,int );
Xextern void _fastcall plot3dsuperimpose256(int ,int ,int );
Xextern void _fastcall plotIFS3dsuperimpose256(int ,int ,int );
Xextern void _fastcall plot3dalternate(int ,int ,int );
Xextern void plot_setup(void);
X
X/*  printer -- C file prototypes */
X
Xextern void printer_overlay(void);
Xextern void Print_Screen(void);
X
X/*  prompts -- C file prototypes */
X
Xextern void prompts_overlay(void);
Xextern int fullscreen_prompt(char far*,int ,char far **,struct fullscreenvalues *,int ,int ,char far *);
Xextern int get_fracttype(void);
Xextern int get_fract_params(int );
Xextern int get_fract3d_params(void);
Xextern int get_3d_params(void);
Xextern int get_toggles(void);
Xextern int get_toggles2(void);
Xextern int get_view_params(void);
Xextern int get_starfield_params(void );
Xextern int get_commands(void);
Xextern void goodbye(void);
Xextern int getafilename(char *,char *,char *);
Xextern int splitpath(char *template,char *drive,char *dir,char *fname,char *ext);
Xextern int makepath(char *template,char *drive,char *dir,char *fname,char *ext);
Xextern char *extract_filename(char * fullfilename);
X
X/*  realdos -- C file prototypes */
X
Xextern int stopmsg(int ,CHAR far *);
Xextern int texttempmsg(char *);
Xextern int showtempmsg(char *);
Xextern void cleartempmsg(void);
Xextern void blankrows(int ,int ,int );
Xextern void helptitle(void);
Xextern int putstringcenter(int ,int ,int ,int ,char far *);
Xextern void stackscreen(void);
Xextern void unstackscreen(void);
Xextern void discardscreen(void);
Xextern int fullscreen_choice(int ,char far*,char far*,char far*,int ,char **,int *,int ,int ,int ,int ,void (*)(),char *,int (*)(),int (*)());
X#ifndef XFRACT /* Unix should have this in string.h */
Xextern int strncasecmp(char *,char *,int );
X#endif
Xextern int main_menu(int );
Xextern int input_field(int ,int ,char *,int ,int ,int ,int (*)(int));
Xextern int field_prompt(int ,char *,char *,char *,int ,int (*)(int));
Xextern int thinking(int ,char *);
Xextern void clear_screen(void );
Xextern int savegraphics(void);
Xextern void restoregraphics(void);
Xextern void discardgraphics(void);
Xextern int load_fractint_cfg(int );
Xextern void bad_fractint_cfg_msg(void);
Xextern void load_videotable(int );
Xextern int check_vidmode_key(int ,int );
Xextern int check_vidmode_keyname(char *);
Xextern void vidmode_keyname(int ,char *);
X
X/*  rotate -- C file prototypes */
X
Xextern void rotate_overlay(void);
Xextern void rotate(int );
Xextern void save_palette(void);
Xextern void load_palette(void );
X
X/*  slideshw -- C file prototypes */
X
Xextern int slideshw(void);
Xextern int startslideshow(void);
Xextern void stopslideshow(void);
Xextern void recordshw(int );
X
X/*  targa -- C file prototypes */
X
Xextern void WriteTGA(int ,int ,int );
Xextern int ReadTGA(int ,int );
Xextern void EndTGA(void );
Xextern void StartTGA(void);
Xextern void ReopenTGA(void);
X
X/*  testpt -- C file prototypes */
X
Xextern int teststart(void);
Xextern void testend(void);
Xextern int testpt(double ,double ,double ,double ,int ,int );
X
X/*  tgaview -- C file prototypes */
X
Xextern int tgaview(void);
Xextern int outlin16(BYTE*,int );
X
X/*  tp3d -- C file prototypes */
X
Xextern char far *TrueColorAutoDetect(void );
Xextern void TranspPerPixel(int ,union Arg far *,union Arg far *);
Xextern int Transp3DFnct(void);
Xextern void ShadowPutColor(unsigned int ,unsigned int ,unsigned int );
Xextern void AntiAliasPass(void );
X
X/*  tplus -- C file prototypes */
X
Xextern void WriteTPWord(unsigned int ,unsigned int );
Xextern void WriteTPByte(unsigned int ,unsigned int );
Xextern unsigned int ReadTPWord(unsigned int );
Xextern BYTE ReadTPByte(unsigned int );
Xextern void DisableMemory(void );
Xextern void EnableMemory(void );
Xextern int TargapSys(int ,unsigned int );
Xextern int _SetBoard(int );
Xextern int TPlusLUT(BYTE far *,unsigned int ,unsigned int ,unsigned int );
Xextern int SetVGA_LUT(void );
Xextern int SetColorDepth(int );
Xextern int SetBoard(int );
Xextern int ResetBoard(int );
Xextern int CheckForTPlus(void );
Xextern int SetTPlusMode(int ,int ,int ,int );
Xextern int FillTPlusRegion(unsigned int ,unsigned int ,unsigned int ,unsigned int ,unsigned long );
Xextern void BlankScreen(unsigned long );
Xextern void UnBlankScreen(void );
Xextern void EnableOverlayCapture(void );
Xextern void DisableOverlayCapture(void );
Xextern void ClearTPlusScreen(void );
Xextern int MatchTPlusMode(unsigned int ,unsigned int ,unsigned int ,unsigned int ,unsigned int );
Xextern void TPlusZoom(int );
X
X/*  yourvid -- C file prototypes */
X
Xextern int startvideo(void);
Xextern int endvideo(void);
Xextern void writevideo(int ,int ,int );
Xextern int readvideo(int ,int );
Xextern int readvideopalette(void);
Xextern int writevideopalette(void);
X#ifdef XFRACT
Xextern void readvideoline(int ,int, int, BYTE * );
Xextern void writevideoline(int ,int, int, BYTE * );
X#endif
X
X/*  zoom -- C file prototypes */
X
Xextern void drawbox(int );
Xextern void moveboxf(double ,double );
Xextern void resizebox(int );
Xextern void chgboxi(int ,int );
Xextern void zoomout(void);
Xextern void aspectratio_crop(float ,float );
Xextern int init_pan_or_recalc(int );
SHAR_EOF
$TOUCH -am 1028230093 prototyp.h &&
chmod 0644 prototyp.h ||
echo "restore of prototyp.h failed"
set `wc -c prototyp.h`;Wc_c=$1
if test "$Wc_c" != "33264"; then
    echo original size 33264, current size $Wc_c
fi
# ============= fractsrc.doc ==============
echo "x - extracting fractsrc.doc (Text)"
sed 's/^X//' << 'SHAR_EOF' > fractsrc.doc &&
XThe source code for Fractint is freely available.
X
XEnhancements to it are appreciated.  If you want to add something to
XFractint and join the Stone Soup Group, please do!  To submit changes,
Xsee "Contacting the Authors" in Fractint's online help.
X
X
XCopyright Information:
X======================
X
XSome parts of the source are from the public domain and are not
Xcopyrighted.
X
XSome parts of the source bear explicit copyright notices from the
Xauthor and are subject to the conditions listed there by the author.
X
XThe remainder of the source (not already public domain, no explicit
Xauthor's copyright notice) is Copyright 1990, 1991 by the Stone Soup Group
X(a loosely associated and ever-growing group of fanatic programmers).
X
XThe source code may be copied freely and may be used in other programs
Xunder the following conditions:
X  It may not be used in a commercial program which produces fractal images.
X  Please credit the author (in general, credit Fractint and the Stone Soup
X  Group) as the source of the code.
X
X
XDistribution of modified versions of Fractint:
X==============================================
X
XIf you enhance Fractint and want to distribute the results to others, the
Xpreferred approach is to join the Stone Soup Group - send us your
Xenhancements and get your name in lights in future versions of Fractint.
X
XWe prefer that a modified Fractint executable program not be distributed to
Xothers, but understand that you might want to give copies to friends.  This
Xis permitted, under the following conditions:
X  o The modified executable has a different name than "fractint.exe".
X  o The distribution includes a full unmodified copy of the corresponding
X    original version of fraint.exe.  (The easiest way is to copy fraint.exe
X    to yournew.exe, then "pkzip -a fraint.exe newfract.exe" to add your
X    version, and perhaps add a read.me file to describe it.)
X  o The heading displayed by the modified program clearly indicates that
X    it is a non-standard release.  E.g. you might change the heading to
X    say "Non-standard Fractint, Modified by John Doe".
X  o All author credits and distribution information in the online help
X    are unchanged (adding lines for your work is of course ok.)
X
XThe source code for a modified version of Fractint may not be distributed.
X(This is because we don't want any chance of confusion over which version
Xof a source file is the official release.)
X
X
XCompiling Fractint:
X===================
X
XFRASRC.EXE includes the complete source code for FRACTINT (.C and .ASM).
XRecognizing that not everyone HAS (or even wants) an assembler, much less
Xeither MASM 5.1 or Turbo-ASM, which are the only two assemblers that the
Xauthors are aware of that can handle these particular files, it also contains
Xa complete set of .OBJ files from the assembler code,
X
XThe distributed source will not compile to exactly match the Fractint
Xrelease - it compiles with a different version number and heading.
X
XThe Microsoft 6.00A C compiler and Microsoft 5.1 assembler are used for
XFractint releases, so that is the one combination of compiler/assembler
Xwhich is pretty much guaranteed to handle FRACTINT in all of its various
Xmutations.
X
XGiven that several of FRACTINT's co-authors now prefer (or only have!)
Xalternate combinations, we have re-arranged the code to (usually) handle
Xseveral popular alternatives.  In particular:
X
XMicrosoft C 6.00A and MASM 5.1:
X-------------------------------
XJust run MAKEFRAC.BAT, which invokes the Microsoft NMK utility using the
Xfiles FRACHELP.MAK, FRACTINT.MAK, and FRACTINT.LNK.  Note that the assembler
X.OBJ files have been included in the .ZIP file, so that you don't really
Xneed MASM unless you are going to modify one or more of them.  If you ARE
Xgoing to modify one of the assembler files, note that the distributed
Xversions rely on some nifty features added to version 5.1 (like the '.model
Xmedium,c' option) and will not assemble under older versions of MASM without
Xa LOT of work.
X
XNote that C 6.00 (the original release) had some problems.  We never used it
Xfor a Fractint release.  If you don't have the fixed version (6.00A) you
Xshould compile parser.c, loadfile.c, and calcfrac.c with no optimization,
Xusing the /qc option.  There might be other problems, those are the only
Xones we're aware of...
X
XWarning: FRACTINT.MAK uses C6.00A's most aggressive optimizations.  It is
Xassumed there is no aliasing.  See Microsoft's documentation on the /Oa
Xand /Oz options.
X
XMicrosoft C 5.1:
X----------------
XEdit MAKEFRAC.BAT: comment out the two "nmk ..." lines and uncomment
Xthe lines for C5.1.  Then run MAKEFRAC.
X
XQuick-C:
X--------
XFRACTINT is just too big for the interactive Quick-C (QC) environment.
XYou have to use the command-line variant of Quick-C (QCL).
X
XEdit MAKEFRAC.BAT: comment out the two "nmk ..." lines and uncomment
Xthe lines for QuickC.  Then run MAKEFRAC.
X
XWe're not sure all versions of QuickC work.  2.01 works as of
XFractint version 16.  Depending on how much memory you have available,
Xyou may have to manually compile some modules without the /O option.
X
XTurbo-C, Turbo-C++ and TASM
X---------------------------
XSorry, Turbo-C fans, but since version 14.0, FRACTINT requires TC++.
XThe lack of initialized FAR arrays and structures just did the older Turbo-C
Xproduct in.  The *good* news is that some of the FRACTINT authors now
Xuse Turbo-C++, so the odds of released FRACTINT distributions that do
Xnot compile with Turbo products are lower than they used to be.
X
XA TCFRACT.PRJ and TCHELP.PRJ file is included for Turbo-C users.  You should
Xrename these to FRACTINT.PRJ and HC.PRJ before compiling fractint.
X
XWith TC++ you'll have to do a manual step for the help system each time you
Xcreate a new fractint.exe - see notes in next section.
X
X
XBorland C++ 3.0 and 3.1 Users
X-----------------------------
XRename the BCFRACT.PRJ and BCHELP.PRJ files to FRACTINT.PRJ and HC.PRJ.
XThe project file will generate the FRACTINT.HLP file, but you will still
Xhave to run "hc /a" from the DOS command line to append the help
Xinformation.
X
X
X
XHelp System
X===========
X
XYou'll need to set up the help files to get any online help from a modified
Xversion of Fractint.
X
XFor MSC users the MAKEFRAC.BAT file contains the necessary steps, you don't
Xneed to do anything special.
X
XTC++ users should:
X  start by creating HC.EXE using the supplied HC.PRJ file
X  run "hc /c" to create the file FRACTINT.HLP
X  each time you create a new fractint.exe, afterward run "hc /a" to append
X    FRACTINT.HLP to the new FRACTINT.EXE
X
XYou don't need to understand the rest of this section unless you have a
Xproblem.
X
XThe source for Fractint's help is in the files HELP.SRC, HELP2.SRC, HELP3.SRC,
XHELP4.SRC, and HELP5.SRC.  The format of these files is described in HC.DOC.
X
XThe program HC.C ("help compiler") is used to convert the help text into
Xthe form Fractint uses at run time.
X
XRunning "hc /c" compiles HELPx.SRC.  It produces the file HELPDEFS.H for
Xuse when compiling Fractint, and the file FRACTINT.HLP.
XRunning "hc /a" appends the FRACTINT.HLP file to FRACTINT.EXE to make the
Xcompiled help info available at run time.
X
X
XOverlays
X========
X
XNote: generally you won't have to worry about this!
XOnly the addition of huge code (new overlays), or work which changes the
Xrelationship between major components of Fractint, are likely to affect
Xthe overlay structure.    However, if you make changes in a module which has a
Xcomment at the start saying it is an overlay, please follow the guidelines
Xfor use of ENTER_OVLY and EXIT_OVLY described after the next paragraph.
X
XFractint uses the Microsoft Link overlay feature, to reduce the runtime
Xmemory required (which would otherwise exceed what DOS can give it.)
XSome caution is required with overlays.  Those source modules which are
Xpart of an overlay have a comment to indicate this at the start.  See the
Xfractint.lnk file for the current overlay structure.
XSome notes about overlays:
X  o The obvious one: control should not switch to different overlays
X    frequently, else Fractint will become sluggish.  If the overlay structure
X    changes, a test from floppy disk with no disk caching is a good idea.
X  o The linker cannot detect indirect calls (e.g. thing=routinename;
X    (*thing)();) to an overlay.  Routines in overlays should not be called
X    indirectly, except from within the same overlay.
X  o The overlay manager logic (inserted by the linker) does handle calls
X    from within one overlay to another - the new overlay is brought in
X    from disk (displacing the old one in memory), when the subroutine
X    finishes the old overlay is brought back into memory.
X  o The overlay manager logic does not handle situations like the following:
X    overlayA calls residentB(), which calls overlayC().  OverlayC is loaded
X    and executed ok, eventually control returns to residentB ok, BUT the
X    return from there to overlayA does NOT reload overlayA!  Fractint has
X    constructs called ENTER_OVLY and EXIT_OVLY to circumvent this problem.
X
XGuidelines for routines in overlayed modules:
X  o If the routine is local, declare it "static" to ensure this and to
X    make analysis of relationships among overlays easier.
X  o If the routine is called from external code (resident, or in another
X    overlay), the first executable line in the routine must be:
X      ENTER_OVLY(OVLY_XXX); /* XXX is the module name */
X    Each "return" from the routine (incl. the implicit one at the end) must
X    be preceded by:
X      EXIT_OVLY;
X  o When creating a new overlay XXX, add a new OVLY_XXX value to Fractint:
X    Fractint.h has a define for each OVLY_XXX value.  Miscres.c has a
X    routine "restore_active_ovly" which needs a new line for OVLY_XXX.
X    The source module needs a dummy routine "xxx_overlay".
X
X
XWhere the Goodies are
X=====================
X
XIt has come to our attention that people who have no interest in fractals
Xat all have been wandering through the FRACTINT source code just to get at
Xsome of the neat tricks buried therein.  Here are a few hints as to where
Xto look:
X
XFRACTINT.C    - The main routine.  Nothing special here.
XFRACTINT.H    - General Include file.  Nothing special here, either.
XFRACTYPE.H    - Fractal type-specific Include file.
X
XPROMPTS.C    - The full-screen prompting code (using support routines
X          in VIDEO.ASM)
XCMDFILES.C    - Command line and sstools.ini parsing.
X
XFRACTALS.C,    - Most of the fractal-specific code.  If you want to know
X CALCFRAC.C,      how a fractal is calculated, look in here.  Specific
X FRACSUBR.C      speed-em-up support for special fractal types is in:
X FRACSUBA.ASM
XCALCMAND.ASM    - Mandelbrot/Julia set calculations.
XNEWTON.ASM    - Newton calculations
XLORENZ.C    - Attractor fractals and IFS
XJB.C        - "Julibrot" fractal type calculations
XTESTPT.C    - "Roll-your-own" fractal routine
XMPMATH_C.C,    - Mark Peterson's "fast-math" support routines.
X MPMATH_A.ASM,      (this stuff puts some of the routines supplied by your
X FPU387.ASM,      favorite "C" compiler to shame!)
X FPU087.ASM,      ...
X FMATH.H,      ...
X MPMATH.H      ...
XPARSER.C    - The "type=formula" formula parser routines
XLSYS.C        - L-Systems code
X
XVIDEO.ASM    - Assembler code containing all of the video routines
X          (setting up the video, reading/writing pixels, zoom-box
X          code, color-cycling, graphics-to-text "help" switch,
X          ... with help from the routines below for special adapters:
XLOADMAP.C    - Load .map files.
XTARGA.C,    - TARGA Video Routines
X TARGA.H,      ...
XFR8514A.ASM    - 8514/A Routines
XTPLUS.C     - Targa+ video routines
X TPLUS.H      ...
X TPLUS_A.ASM      ...
XHGCFRA.ASM    - Hercules Video Routines
XDISKVID.C    - "DISK'RAM" video routines
XYOURVID.C    - "Roll-your-own" video routines
X
XGENERAL.ASM    - General assembler code having nothing to do with fractals.
X          Lots of the tricky stuff is in here, and many of the "C"
X          routines that perform tricky functions rely on support
X          code buried in here.    In particular, this routine has the:
X            CPU, FPU Detectors
X            Keyboard routines
X            Mouse routines
X            Expanded memory routines
X            32-bit scaled integer multiply and divide routines
X
XENCODER.C    - GIF Encoder routine.
XGIFVIEW.C,    - GIF Decoder routines.
X DECODER.C,
X TGAVIEW.C,      (including a TARGA-format decoder currently used only for
X F16.C,       loading obsolete .tga format "Continuous Potential" files)
X TARGA_LC.H      ...
XLOADFILE.C    - Loads the Fractint parameter info from a GIF file.
X LOADFDOS.C      subroutines for DOS Fractint only
X
XLINE3D.C,    - 3D manipulation routines
X 3D.C
XPLOT3D        - 3D subroutines for LINE3D.C and LORENZ.C
X
XROTATE.C    - routines which "spin" the VGA video-DAC.
XEDITPAL.C    - palette-editing mode
X
XHELP.C        - HELP support
XINTRO.C     - title screen
X
XZOOM.C        - Zoombox manipulation.
X
XPRINTER.C,    - The Printer Routines
X PRINTERA.ASM      Data used by PRINTER.C
X
XMISCRES.C    - Miscellaneous resident subroutines; nothing special.
XMISCOVL.C    - Miscellaneous overlayed subroutines; includes <B>atch
X          command.
XREALDOS.C    - Some subroutines isolated from Windows development work;
X          nothing special in here.
X
XPORT.H        - Some portability stuff, nothing special here.
X
XHow things are set up
X=====================
XI've had to go through a lot of the code to figure out how things are set
Xup.  These are my rough notes, which I'm including in case they can help
Xsomeone else. -- Ken Shirriff
X
XThe control flow is very confusing.  Here are some details:
X
XEach fractal type has an entry in the fractalspecific table in fractalp.c.
XEntries that are not displayed are marked with an asterisk.  Each entry is
Xmarked as int or not int, and either has a pointer to another entry
X(tofloat) or NOFRACTAL.  If you select float and the type is int or vice
Xversa, you will end up with the tofloat type.  (e.g. If you select entry
XMANDEL, and select floating point, you will get entry MANDELFP).  There are
Xalso pointers tojulia and tomandel, which allow you to switch between mandel
Xand julia.  The four functions listed are curfractalspecific->orbitcalc,
Xcurfractalspecific->per_pixel, curfractalspecific->per_image, and
Xcurfractalspecific->calctype.
X
Xmain calls calcfracinit.
Xcalcfractint: this sets up curfractalspecific, which is the appropriate entry
X    from the fractalspecific table.  This routine does the int/float
X    conversion.
X
Xmain calls calcfract, which calls timer, which calls perform_worklist
Xperform_worklist calls curfractalspecific->per_image, which is eg.  MandelSetup
XMandelSetup: sets calctype to curfractalspecific->calctype, or for special
X    cases (eg. decomposition) to StandardFractal
X
Xperform_worklist calls solidguess (or whatever drawing system)
Xsolidguess calls *calctype for each pixel; calctype is eg. StandardFractal
X
XStandardFractal calls curfractalspecific->per_pixel once, and then loops over
X    each iteration calling curfractalspecific->orbitcalc.  These routines
X    are eg.  mandel_per_pixel and JuliaFractal.
X
X
X
XHere is the structure of the main routine:
X
Xmain()
X{
X    initialize things
Xrestorestart:
X    if loading, look after specifying image
Ximagestart:
X    while (adapter<0) {
X    process keys from short main menu
X    }
X
X    while (1) {
X    if (calc_status != 2 || showfile==0) {
X        initialize videoentry from videotable[adapter]
X        initialize size, color, etc. from videoentry
X        setvideomode()
X    }
X    if (showfile==0) {
X        load file
X    }
X    calcfracinit();
X    save corners, zoom data
X    if (showfile != 0) {
X        calcfract(); /* calculates the fractal until interrupted */
X    }
Xresumeloop:
X    if (no key pressed) {
X        set keypress = 13 to continue
X    } else if (key pressed) {
X        check input key
X    } else if (batch mode) {
X        look after batch key
X    }
X
X    process key from long menu
X    }
X}
X
X
XHow the video entries are managed:
X
Xget_video_mode(fractal_info): This routine is used to select a video mode
X    to match a picture we're loading.  It loads vidtbl and then  tries to
X    find a video mode that matches that in fractal_info.  Asks the user to
X    select one if there's no good match.  Figures out how to reduce the image
X    to fit the screen.
X
Xselect_video_mode(curmode): This is the main-menu routine for the user to
X    pick a video mode.  picks default video mode, lets user select mode
X    from menu, copies entry to videoentry, puts entry in videotable if not
X    there, calls update_fractint_cfg if key reassigned, returns key
X    corresponding to mode
X
Xcheck_vidmode_key(option, keypress): if keypress corresponds to a videomode in
X    videotable (for option 0) or vidtbl (for option 1) return the videomode
X    index, else -1.
X
Xcheck_vidmode_keyname: converts ascii key name into key number
X
Xadapter_detect: checks for type of video (ega, cga, etc) and set video_type,
Xmode7text, textsafe.
X
Xload_videotable: reads the entries in fractint.cfg into vidtbl
X    copies entries with an associated function key into videotable
X
Xload_fractint_cfg: reads video modes in fractint.cfg into vidtbl
X    (or copies from videotable) if fractint.cfg missing or bad
X
Xupdate_fractint_cfg: writes the entry in videoentry into the fractint.cfg file.
X
Xvidtbl: contains the video modes from fractint.cfg
Xvideotable: contains video modes with function keys; initialized in video.asm
Xvideo_type: contains type: hgc, egc, cga, mcga
X
X
XHere is how the floating point modes are set up.
Xparser.c uses the MathTypes:
XD_MATH: uses double precision routines, such as dStkMul, and FPUsincos
X    This is used if we have a fpu.
XM_MATH: uses MP type (mantissa, exponent).  These routines such as mStkAdd
X    call MPCadd, which call pMPadd, which calls MPadd086 or MPadd386.
X    The MP routines work on multiple precision, MPC works on complex pairs
X    of multiple precision.
XL_MATH: uses integer math.  Routines such as lStkAdd.
SHAR_EOF
$TOUCH -am 1028230093 fractsrc.doc &&
chmod 0644 fractsrc.doc ||
echo "restore of fractsrc.doc failed"
set `wc -c fractsrc.doc`;Wc_c=$1
if test "$Wc_c" != "17535"; then
    echo original size 17535, current size $Wc_c
fi
# ============= debugfla.doc ==============
echo "x - extracting debugfla.doc (Text)"
sed 's/^X//' << 'SHAR_EOF' > debugfla.doc &&
XThis list complete as of version 14.
XNone of these are necessarily supported in future.
X
XAdd one to any debug value to trigger writing benchmark values to
Xthe file "bench".  This gets stripped at startup; so all values
Xused for other purposes are even.
X
XExample:  "fractint debug=8088" forces Fractint to think you have an
X8088/8086 CPU and ignore all of the tricky 186/286/386-specific stuff.
X"Fractint 8089" does the same thing, but also turns on the benchmark
Xtimer.
X
X16    video.asm    pretend not a vga
X22    lorenz.c    force float for 3D perspective
X50    fractint.c    compare <r>estored files
X70    fractint.c    set fpu = 0
X72    fractint.c    don't use fast >= 287 fpu routines
X90    fractals.c    force "C" mandel & julia code (no calcmand or calmanfp)
X90    fractals.c    force generic code for fn+fn etc types
X90 parser.c    force "C" parser code even if FPU >= 387
X100    calcmand.asm    force use of 'code32bit' logic
X200    fractint.c    time encoder
X322   parserfp.c  disable optimizer (FPU >= 387 only)
X420    diskvid.c    don't use extended/expanded mem (force disk)
X420    realdos.c      same for screen save (force disk)
X420    editpal.c      same for screen save (force disk)
X420    jiim.c            same for screen save (force disk)
X422    diskvid.c    don't use expanded mem (force extended or disk)
X422    realdos.c      same for screen save (force extended or disk)
X450    fractint.c    abort in batch mode if savename exists
X470    calcfract.c    disable prevention of color 0 for BTM
X600    printer.c    paintjet, no form feed
X602    printer.c    paintjet, flip image
X7nn     miscovl.c    set <b> getprec() digits variable to nn
X870    fractint.c    set fpu to max 87
X1010    fractals.c    force fp for newton & newtbasin (no mpc math)
X1234    fractint.c    force larger integer arithmetic bitshift value
X2222    line3d.c    show amount of extra seg memory used
X2224    line3d.c    old just-the-dots logic, probably a temporary thing
X2870    fractint.c    set fpu to max 287 iit off
X2872    fractint.c    set fpu to max 287 iit on
X3000    general.asm    '~' goes to color play mode
X3002    realdos.c    don't show development in heading
X3870    fractint.c    set fpu to max 387 iit off
X3872    fractint.c    set fpu to max 387 iit on
X4000    miscres.c    turn on math error message (off otherwise)
X8088    general.asm    set cpu = 86, ie dont use 32 bit stuff
X8088    fractint.c    set cpu = 86, (case in general.asm is redundant?)
X9002-9100 fractint.c    reduce video_type to (debug-9000)/2 if init was higher
X10000    fractint.c    display cpu, fpu, and free memory at startup
X10000    fractint.c    ? (try extra hard for minimal startup memory?)
X
Xnonzero value, line3d.c, show "normal vector" errors instead of just fixing
Xnonzero value, prompts.c, show info if fullscreen_prompt2 array invalid
X
SHAR_EOF
$TOUCH -am 1028230093 debugfla.doc &&
chmod 0644 debugfla.doc ||
echo "restore of debugfla.doc failed"
set `wc -c debugfla.doc`;Wc_c=$1
if test "$Wc_c" != "2610"; then
    echo original size 2610, current size $Wc_c
fi
# ============= hc.doc ==============
echo "x - extracting hc.doc (Text)"
sed 's/^X//' << 'SHAR_EOF' > hc.doc &&
X
X... First version documentation is followed by additional notes
X... for features added in subsequent versions.
X
X
X           FRACTINT Help Compiler Source File Format
X
X
X
X0. Contents
X
X    1.0     Help compiler input/output.
X    1.1       The source input file.
X    1.2       The header (.H) output file.
X    1.3       The binary (.HLP) output file.
X    2.0     Source (.SRC) file format.
X    2.1       Comments.
X    2.2       Defining the output filenames.
X    2.3       Defining the help file version.
X    2.4.0     Help topics.
X    2.4.1    Starting a help topic.
X    2.4.2.0    The help text.
X    2.4.2.1      Special characters.
X    2.4.3    Starting another page.
X    2.5.0     Labels.
X    2.5.1    The help index label (HELP_INDEX).
X    2.5.2    Private labels.
X    2.6.0     Hot-links.
X    2.6.1    Special hot-links.
X    2.7       Tables.
X
X
X1.0 Help compiler input/output.
X
X    The Help Compiler converts a source file into two output files: a "C"
X  header file which is #included in FRACTINT and a binary file used at run-
X  time.
X
X
X1.1 The source input file.
X
X    The Help compiler takes as input a help source file (.SRC).  See x.x.x
X  for the .SRC file format.  HELP.SRC is FRACTINT's help file source.
X
X
X1.2 The header (.H) output file.
X
X    The header (.H) file contains a #define macro for each non-private label
X  (see 2.5.0) and for the help file version (see 2.3).    The .H file is
X  included in FRACTINT and the macros are used to set the current help mode.
X
X    The Help Compiler will only modify the .H file when a non-private label
X  (see 2.5.0) is added or deleted or when the help file version (see 2.3)
X  is changed.  This minimizes the times when FRACTINT will need to be re-
X  compiled.  However, when the Help Compiler does modify the .H file it is
X  necessary to re-compile FRACTINT.
X
X  In FRACTINT this file is named HELPDEFS.H
X
X1.3 The binary (.HLP) output file.
X
X    The .HLP file is the binary file where compiled help informnation is
X  stored.  See HC.C and HELP.C if you're interested in the file format.  In
X  FRACTINT the file is named FRACTINT.HLP.  This file may be appended to
X  FRACTINT.EXE for distribution, see the Help Compiler command-line help
X  (type "HC" at the DOS prompt) more info.
X
X
X2.0 Source (.SRC) file format.
X
X    The source file defines output files, help file version, topics, labels
X  and hypertext-style hot-links with commands and hot-links.  Commands start
X  with a tilde ('~') in the first column of a line and continue to the end
X  of the line.    Hot-links, defined within the text, are surrounded by curly-
X  braces ('{' and '}').  Comment lines, which may appear anywhere in the
X  file, start with a semicolon (';') in the first column and continue to
X  the end of the line.
X
X
X2.1 Comments.
X
X    Any line starting with a semicolon (;) is a comment.  The comment
X  continues to the end of the line and may appear anywhere in the file.
X  The semicolon must be in the first column of the line.
X
X
X2.2 Defining the output filenames.
X
X    The output filenames are defined in the source file by the following
X  commands:
X
X    ~HdrFile=H_FILE
X    ~HlpFile=HLP_FILE
X
X  H_FILE is the .H filename and HLP_FILE is the .HLP filename.    These
X  commands must appear before the first topic.
X
X
X2.3 Defining the help file version.
X
X    The help file version number is stored in a special #define in the .H
X  file (named HELP_VERSION) and stored in the .HLP file header.  If the
X  version number in HELP_VERSION does not match the version in the .HLP file
X  the file will not be used.  This is mainly to make sure FRACTINT doesn't
X  try to read a help file other than the one the .EXE is expecting.  To
X  define the help version:
X
X    ~Version=nnn
X
X  Where nnn is a positive decimal version number.  (Suggested format is 100
X  for version 1.00, 150 for version 1.50, etc.)  This command must appear
X  before the first help topic.    -1 will be used if the version is not defined
X  in the .SRC file.
X
X
X2.4.0 Help topics.
X
X    The help topics come after the HdrFile=, HlpFile= and Version= commands
X  and continue until end-of-file.
X
X
X2.4.1 Starting a help topic.
X
X  To start a new help topic use the following format:
X
X    ~Topic=TITLE
X
X  "~Topic=" is the command to start a topic and TITLE is the text to display
X  at the top of each page.  The title continues to the '\n' and may contain
X  up to 65 characters.
X
X    In the example:
X
X    ~Title=Command Keys available while in Display Mode
X
X  "Command Keys avail..." is the TITLE which would displayed at the top of
X  each page.
X
X
X2.4.2.0 The help text.
X
X    The help text for each topic can be several pages long. Each page is 22
X  rows by 78 columns.  The first and last rows should be blank for the best
X  appearance.
X
X
X2.4.2.1 Special characters.
X
X    To insert reserved characters (like ';', '~', '\' and '{') into the help
X  text precede the character with a backslash ('\').  To insert any character
X  (except null) into the text follow a backslash with a decimal (not hex
X  or octal) ASCII character code.  For example:
X
X    \~  - puts a tilde in the text.
X    \24 - places an up-arrow in the text.
X
X
X2.4.3 Starting another page.
X
X    To start a new page in the same topic put two tildes (~~) at the start
X  of a line.  No other text is allowed on the line.  Each page can be up to
X  22 lines long.  (The Help Compiler will warn you if any page gets longer
X  than 22 lines.)  For the best appearance the first and last lines should
X  be blank.
X
X
X2.5.0 Labels.
X
X    A label is a name which in used to refer to a help topic.  A label is
X  used in hot-links or in FRACTINT for context-sensitive help.    When help
X  goes to a label (when a hot-link is selected or context-sensitive help
X  is called from FRACTINT) it goes to the page of the topic where the label
X  was defined.
X
X    To define a label for a topic insert the following command into the
X  topic's text:
X
X    ~(NAME)
X
X  NAME is the name of the label.  The name follows "C"-style conventions
X  for variable names.  Case is significant.  The label should start at the
X  beginning of a line and have no text following it on the line.  The line
X  line will not appear in the help text.
X
X    For example, if this line:
X
X  ~(HELPPLASMA)
X
X  was placed in page three of a topic using it in a hot-link (see 2.6.0)
X  or as context-sensitive help would "go to" page three of that topic.  The
X  user would then be free to page up and down through the entire topic.
X
X    Each topic must have at least one label otherwise it could not be
X  referred to.
X
X
X2.5.1 The help index label (HELP_INDEX).
X
X    When the user wants to go to the "help index" (by pressing F1 while
X  in help) help will go to a special label named "HELP_INDEX".  Other than
X  the requirement that it be in every .SRC file you may treat it as any
X  other label.    It can be used in links or as context-sensitive help.
X
X
X2.5.2 Private labels.
X
X    A private label is a label which is local to the help file.  It can be
X  used in hot-links but cannot be used as context-sensitive help.  A private
X  label is a label with an "at sign" ('@') as the first character of its
X  name.  The "at sign" is part of the name.  In the example:
X
X    ~(@HELPPLASMA)
X
X  "@HELPPLASMA" is a private label.
X
X    Private labels are not included in the .H file so you may add or delete
X  private labels without re-compiling FRACTINT.  Each non-private label
X  takes up some memory (4 bytes) in FRACTINT so it's best to use private
X  labels whenever possible.  Use private labels except when you want to use
X  the label as context-sensitive help.
X
X
X2.6.0 Hot-links.
X
X    A hypertext-style hot-link to a label can appear anywhere in the help
X    text.  To define a hot-link use the following syntax:
X
X    {LABEL TEXT}
X
X  LABEL is the label to link to and TEXT is the text that will be highlighted.
X  Only the TEXT field will appear on the help screen.  No blanks are allowed
X  before the LABEL.  In the sample hot-link:
X
X    {HELPMAIN Command Keys in display mode}
X
X  "HELPMAIN" is the LABEL and "Command keys in display mode" is the
X  TEXT to will be hightlighted.
X
X
X2.6.1 Special hot-links.
X
X    In addition to normal hot-links to labels "special" links to custom
X  functions (built into HELP.C) are allowed.  These hot-links have a
X  negative number (-2..) in place of the LABEL.  No special hot-links are
X  currently supported in FRACTINT.
X
X
X2.7 Tables.
X
X    A table is a way of arranging a group of hot-links into evenly-spaced
X  columns.  The format for a table is:
X
X    ~Table=WIDTH COLS INDENT
X
X    << LINKS... >>
X
X    ~EndTable
X
X  WIDTH is the width of each item, COLS is the number of columns in the
X  table and INDENT is the number of spaces to indent the table.  LINKS is
X  a list of hot-links (see 2.6.0) which will be arranged.  Only blanks and
X  new-lines are allowed between the hot-links; other characters generate
X  an error.
X
X    In the example table:
X
X    ~Table=20 3 9
X    {@ONE One}
X    {@TWO Two}
X    {@THREE Three}
X    {@FOUR Four}
X    {@FIVE Five}
X    {SIX Six}
X    {SEVEN Seven}
X    {EIGHT Eight}
X    ~EndTable
X
X  20 is the WIDTH, 3 is COLS and INDENT is 9.  The following text would
X  be produced by the table:
X
X    One            Two         Three
X    Four            Five        Six
X    Seven            Eight
X
X  Each item would be a hot-link linking to its corresponding label (@ONE for
X  "One", etc.)  Any legal hot-link (to private or non-private labels) may be
X  used in a table.
X
X    The same effect could be produced by arranging the hot-links into
X  columns yourself but using a table is usually easier (especially if the
X  label names vary in length).
X
X
X
X... Second version additional documentation:
X
X          New features of the Help Compiler (HC)
X          ======================================
X
X
XExpanded command format
X=======================
X
X    Several commands may be "strung together" by separating them with commas.
X  For example:
X
X       ~Topic=Help on help, Label=HELPONHELP, Format-
X
X  To have a comma as part of a command (like in a topic) precede it with a
X  backslash.
X
X    Commands can be imbedded in the text with the following format:
X
X       ~(command)
X
X  The text before the tilde and immediately after the ending parend will be
X  part of the help text.
X
X
XNew commands
X============
X
X    Format[+/-]        L   turns formatting on/off.
X    Online[+/-]        L   enables/disables display of text in the online
X               help.
X    Doc[+/-]           L   enables/disables display of text in the printed
X               document.  (Currently ignored.)
X    FormatExclude=NUM  G/L Set the column number in which formatting is
X               automatically disabled.  (ie. all text after
X               column NUM is unformatted.)    If before any topics
X               sets global value, if in a topic sets only for
X               that topic.
X    FormatExclude=n    G/L Turn this feature off.  This is the default at the
X               start of the source file.  Global if before topic,
X               local otherwise
X    FormatExclude[+/-] G/L Temporarily enable/disable this feature.  Has no
X               effect if "FormatDisable=n" is in effect.
X    FormatExclude=     L   Resets FormatExclude to its global value.
X    Center[+/-]        L   Enable/Disable automatic centering of text.
X
X    All commands with a "L" are local in scope -- they effect only the current
X  topic.  All commands with a "G" are global in scope.  Commands with "G/L" are
X  global if used before any topics are defined and local otherwise.  At the
X  start of each topic the following local settings are in effect:
X
X       ~Online+,Doc+,FormatExclude=,Format+,Center-
X
X
XModified commands
X=================
X
X  Label=NAME        replaces the ~(...) command
X  FF            replaces the ~~ command
X
X
XHot-Links
X=========
X
X  Hot-links have been expanded to support "implicit" links.  These are links
X  which link to the topic whose title matches the highlighted text.  They have
X  no label field.  In the example:
X
X       Press <C> to goto {Color Cycling Mode}.
X
X  The link will link to the topic whose title is "Color Cycling Mode".  The
X  link must match the topics' title exactly except for case and leading or
X  trailing blanks.
X
X  Normal "explicit" hot-links to labels must now have an equal sign
X  immediately after the opening curly-brace.  For example:
X
X       {=HELPONHELP How do I use help?}
X
X
X  Links to the label named "HELPONHELP".  (The equal sign is not part of the
X  labels name.)
X
X
XParagraph formatting
X====================
X
X  The HC determines the end of a paragraph when it encounters:
X
X    o a blank line.
X    o a change of indentation after the second line of a paragraph.
X    o a line ending with a backslash ('\').
X    o If FormatExclude is enabled any line starting beyond the cut-off
X      value.
X
X  The HC only looks at the left margin of the text to determine paragraph
X  breaks.  If your not sure the HC can determine a paragraph boundry
X  append a backslash to the end of the last line of the paragraph.
X
X  The following examples illustrate when you need to use a backslash to make
X  HC format correctly:
X
X  1. Paragraph headings.
X
X    Heading
X    Text which follows the heading.  This text is supposed
X    to be a separate "paragraph" from the heading but the HC
X    doesn't know that!
X
X  This text would be formatted into a single paragraph.  (The word "Text"
X  would immediately follow "Heading".)  To make it format correctly append
X  a backslash to the end of "Heading".
X
X  2. Single-line bullets.
X
X    o Don't branch.
X    o Use string instructions, but don't go much out of your way
X      to do so.
X    o Keep memory accesses to a minimum by avoiding memory operands
X      and keeping instructions short.
X
X    Since the HC cannot tell that the first bullet is a separate paragraph
X  from the second bullet it would put both bullets into one paragraph.    Any
X  bullet of two lines or more (assuming the intentation for the second line
X  of the bullet is different from the first) is OK.  Always add a backslash
X  to the end of single-line bullets.
X
X    In general, if you cannot determine where a paragraph boundry is by
X  looking at the indentation of each line use a backslash to force a
X  paragraph break.
X
X
X
X
X... Third version additional documentation:
X
X  New Commands
X  ============
X
X  ~Comment, ~EndComment
X    Use to start/end multi-line comments.
X
X  ~CompressSpaces[+/-]
X    Turn on/off the automatic compression of spaces.  Used for data topics
X    and when reading normal topics with read_topic()
X
X  ~Data=label_name
X    Starts a topic which contains data.  Think of it as a macro for:
X
X      ~Topic=, Label=label_name, Format-, CompressSpaces-
X
X    Data labels cannot be part of the document or displayed as online help.
X
X  ~BinInc filename
X    Includes a file in binray format (no processing) into a data topic.
X    This command only works for data topics.  Example:
X    ~Data=TPLUS_DAT
X    ~BinInc tplus.dat
X
X  ~DocContents
X    Defines the documents table of contents.  Text is allowed.    Table of
X    content entries have the following format:
X
X      { id, indent, name, [topic, ...] [, FF] }
X
X    id       is it's identification (ie, 1.2.1)
X    indent is the indentation level, (ie. 2)
X    name   is the text to display to display (ie. Fractint Commands)
X       If name is in quotes it is also assumed to also be the
X       title of the first topic.
X    topic  list of 0 or more topics to print under this item.  Entries
X       in quotes are assumed to be the title of a topic, other
X       entries are assumed to be labels.
X    FF       If this keyword is present the entry will start on a new page in
X       the document.
X    It isn't as complex as it sounds; see "~DocContents" in HELP.SRC for
X    examples.
X
X
X  Quoted implicit hot-links
X  =========================
X
X    HC will ignore quotes areound implicit hot-links when searching for
X    the matching title.  This allows hot-links like:
X
X      {"Video adapter notes"}
X
X    intead of:
X
X      "{Video adapter notes}"
X
X    This is so that the hot-link page numbers don't end up inside the
X    quotes like: "Video adapter notes (p. 21)".  It also keeps quotes from
X    being separated from the text in the online-help.
X
X
X  Document printing
X  =================
X
X    The new /p command-line option compiles the .SRC file and prints the
X    document.  It does NOT write the .HLP file.
X
X    The old /p option (set swap path) has been changed to /r.
X
X
X   Printing the document
X   =====================
X
X   The function prototype (in HELP.C) to print the document is:
X
X    void print_document(char *outfname, int (*msg_func)(int,int),
X                int save_extraseg);
X
X   outfname is the file to "print" to (usually "FRACTINT.DOC"), msg_func
X   is a function which is called at the top of each page, and save_extraseg
X   is true if the data in the extraseg should be preserved.
X
X   See print_doc_msg_func() in HELP.C for an example of how to use msg_func.
X   If msg_func is NULL no msg_func is called.
X
X
X   Printing from help
X   ==================
X
X   There are hooks to print the document from a help topic by selecting a
X   "special" hot-link. I suggest a format like:
X
X    ~Topic=Generating FRACINT.DOC
X
X    Explain that selecting yes will print the document, etc...
X
X    {=-2  Yes, generate FRACTINT.DOC now. }
X    {=-1  No, do NOT generate FRACTINT.DOC. }
X
X   Selecting yes will generate the document and then return to the previous
X   topic.  Selecting no will simply return to the previous topic (like
X   backspace does.)
X
X
X
SHAR_EOF
$TOUCH -am 1028230093 hc.doc &&
chmod 0644 hc.doc ||
echo "restore of hc.doc failed"
set `wc -c hc.doc`;Wc_c=$1
if test "$Wc_c" != "17114"; then
    echo original size 17114, current size $Wc_c
fi
# ============= calcmand.c ==============
echo "x - extracting calcmand.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > calcmand.c &&
X/* calcmand.c
X * This file contains routines to replace calcmand.asm.
X *
X * This file Copyright 1991 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X */
X
X#include <fractint.h>
X
Xunsigned long savedmask;
Xlong linitx, linity;
X
Xcalcmandasm() {
X    printf("Warning: called calcmandasm\n");
X}
Xcode16bit() {}
Xcheckperiod() {}
Xcode32bit() {}
SHAR_EOF
$TOUCH -am 1028230093 calcmand.c &&
chmod 0644 calcmand.c ||
echo "restore of calcmand.c failed"
set `wc -c calcmand.c`;Wc_c=$1
if test "$Wc_c" != "381"; then
    echo original size 381, current size $Wc_c
fi
# ============= calmanfp.c ==============
echo "x - extracting calmanfp.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > calmanfp.c &&
X/* calmanfp.c
X * This file contains routines to replace calmanfp.asm.
X *
X * This file Copyright 1992 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X */
X
X#include "fractint.h"
X#include "fractype.h"
X
Xextern _CMPLX init, parm, new;
X
Xextern int color, oldcolor, realcolor, periodicitycheck, reset_periodicity,
X    fractype, kbdcount, dotmode, show_orbit, orbit_ptr, potflag, maxit,
X    inside, outside, fpu;
X
Xextern double closenuff, magnitude, rqlim;
X
Xstatic int tmp_word, inside_color, periodicity_color;
X
Xcalcmandfpasmstart() {
X    if (inside<0) {
X    inside_color = maxit;
X    } else {
X    inside_color = inside;
X    }
X
X    if (periodicitycheck < 0) {
X    periodicity_color = 7;
X    } else {
X    periodicity_color = inside_color;
X    }
X    oldcolor = 0;
X    return 0;
X}
X
X#define ABS(x) ((x)>0?(x):-(x))
X#define close 0.01
X
Xcalcmandfpasm() {
X    int cx;
X    int savedand;
X    double x,y,x2, y2, xy, Cx, Cy, savedx, savedy;
X    int savedincr;
X
X    if (periodicitycheck==0 || periodicitycheck == -59) {
X    oldcolor = 0;
X    } else if (reset_periodicity==0) {
X    oldcolor = maxit-250;
X    }
X
X    /* initparms */
X    savedx = 0;
X    savedy = 0;
X    savedand = 1;
X    savedincr = 1;
X    orbit_ptr = 0;
X    kbdcount--; /* Only check the keyboard sometimes */
X    if (kbdcount<0) {
X    int key;
X    kbdcount = 1000;
X    key = keypressed();
X    if (key) {
X        if (key=='o' || key=='O') {
X        getakey();
X        show_orbit = 1-show_orbit;
X        } else {
X        color = -1;
X        return -1;
X        }
X    }
X    }
X
X    cx = maxit;
X
X    if (fractype != JULIAFP && fractype != JULIA) {
X    /* Mandelbrot_87 */
X    cx--;
X    Cx = init.x;
X    Cy = init.y;
X    x = parm.x+Cx;
X    y = parm.y+Cy;
X    } else {
X    /* dojulia_87 */
X    Cx = parm.x;
X    Cy = parm.y;
X    x = init.x;
X    y = init.y;
X    }
X    x2 = x*x;
X    y2 = y*y;
X    xy = x*y;
X
X    /* top_of_cs_loop_87 */
X    do {
X    x = x2-y2+Cx;
X    y = 2*xy+Cy;
X    if (outside<=-2) {
X        new.x = x;
X        new.y = y;
X    }
X    /* no_save_new_xy_87 */
X    if (inside==-100) {
X        /* epsilon_cross */
X        if (ABS(x)<0.01) {
X        realcolor = maxit-cx;
X        if (realcolor==0) realcolor++;
X        kbdcount -= realcolor;
X        color = GREEN;
X        oldcolor = 0;
X        goto pop_stack;
X        } else if (ABS(y)<0.01) {
X        realcolor = maxit-cx;
X        if (realcolor==0) realcolor++;
X        kbdcount -= realcolor;
X        color = BROWN;
X        oldcolor = 0;
X        goto pop_stack;
X        }
X    }
X    /* end_epsilon_cross_87 */
X    if (cx<oldcolor) {
X        if (savedand==0) {
X        savedx = x;
X        savedy = y;
X        savedincr--;
X        if (savedincr==0) {
X            savedand = (savedand<<1) + 1;
X            savedincr = 4;
X        } else {
X            if (ABS(x-savedx)<closenuff && ABS(y-savedy)<closenuff) {
X            oldcolor = 65535;
X            realcolor = maxit;
X            kbdcount = kbdcount-(maxit-cx);
X            color = periodicity_color;
X            goto pop_stack;
X            }
X        }
X        }
X    }
X    /* no_periodicity_check_87 */
X    if (show_orbit != 0) {
X        plot_orbit(x,y,-1);
X    }
X    /* no_show_orbit_87 */
X    x2 = x*x;
X    y2 = y*y;
X    xy = x*y;
X    if (potflag != 0) {
X        magnitude = x2+y2;
X    }
X    if (x2+y2 > rqlim) {
X        goto over_bailout_87;
X    }
X
X    cx--;
X    } while (cx>0);
X
X    /* reached maxit */
X    oldcolor = 65535;
X    kbdcount -= maxit;
X    realcolor = maxit;
X    if (inside==-59) {
X    color = (x2+y2)*maxit/2+1;
X    } else {
X        color = inside_color;
X    }
X
Xpop_stack:
X
X    if (orbit_ptr) {
X    scrub_orbit();
X    }
X
X    return color;
X
Xover_bailout_87:
X    if (cx-10>=0) {
X    oldcolor = cx-10;
X    } else {
X    oldcolor = 0;
X    }
X    color = realcolor = maxit-cx;
X    if (realcolor==0) realcolor = 1;
X    kbdcount -= realcolor;
X    if (outside==-1) {
X    } else if (outside>-2) {
X    color = outside;
X    } else {
X    /* special_outside */
X    int ax;
X    if (outside==-2) {
X        color += new.x + 7;
X    } else if (outside==-3) {
X        color += new.y + 7;
X    } else if (outside==-4) {
X        if (new.y!=0) {
X        color *= new.x/new.y;
X        }
X    } else if (outside==-5) {
X        color +=  new.x + new.y;
X    }
X    /* check_color */
X    if (color<0 || color>maxit) {
X        color = 0;
X    }
X    }
X    goto pop_stack;
X
X}
SHAR_EOF
$TOUCH -am 1028230193 calmanfp.c &&
chmod 0644 calmanfp.c ||
echo "restore of calmanfp.c failed"
set `wc -c calmanfp.c`;Wc_c=$1
if test "$Wc_c" != "3910"; then
    echo original size 3910, current size $Wc_c
fi
# ============= diskvidu.c ==============
echo "x - extracting diskvidu.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > diskvidu.c &&
X/*
X   "Disk-Video" for Unix routines.
X
X   All the expanded memory caching stuff has been removed for the Unix
X   version.  We just keep the data in memory and write it out to a file
X   when we're done.  (Let virtual memory look after the details.)
X
X*/
X
X#include <stdio.h>
X#ifndef XFRACT
X#include <dos.h>
X#endif
X#include "fractint.h"
X
Xextern int sxdots, sydots, colors;
Xextern int dotmode;      /* video access method, 11 if really disk video */
Xextern int diskisactive;  /* set by fractint to disable re-init */
Xextern int debugflag;
Xextern int diskflag;
X
X#define BOXROW     6
X#define BOXCOL     11
X#define BOXWIDTH 57
X#define BOXDEPTH 12
X
X#define TIMETODISPLAY 10000
X
Xint disk16bit=0;       /* storing 16 bit values for continuous potential */
X
Xextern int Shadowing, AntiAliasing;
X
Xstatic int timetodisplay;
Xstatic FILE *fp = NULL;
Xstatic int disktarga;
X
Xstatic int headerlength;
Xstatic unsigned int rowsize = 0;   /* doubles as a disk video not ok flag */
Xstatic unsigned int colsize;       /* sydots, *2 when pot16bit */
X
Xstatic BYTE *dataPtr = NULL;
X
Xint startdisk(),pot_startdisk();
Xvoid enddisk();
Xint targa_startdisk(FILE *, int);
Xvoid targa_readdisk (unsigned int, unsigned int,
X             BYTE *, BYTE *, BYTE *);
Xvoid targa_writedisk(unsigned int, unsigned int,
X             BYTE, BYTE, BYTE);
Xvoid dvid_status(int,char *);
X
Xint made_dsktemp = 0;
X
Xint startdisk()
X{
X   if (!diskisactive)
X      return(0);
X   headerlength = disktarga = 0;
X   return (common_startdisk(sxdots,sydots,colors));
X   }
X
Xint pot_startdisk()
X{
X   int i;
X   if (dotmode == 11) /* ditch the original disk file */
X      enddisk();
X   else
X      showtempmsg("clearing 16bit pot work area");
X   headerlength = disktarga = 0;
X   i = common_startdisk(sxdots,sydots<<1,colors);
X   cleartempmsg();
X   disk16bit = 1;
X   return (i);
X   }
X
Xint targa_startdisk(FILE *targafp,int overhead)
X{
X   int i;
X   if (dotmode == 11) { /* ditch the original disk file, make just the targa */
X      enddisk();      /* close the 'screen' */
X      setnullvideo(); /* set readdot and writedot routines to do nothing */
X      }
X   headerlength = overhead;
X   fp = targafp;
X   disktarga = 1;
X   i = common_startdisk(sxdots*3,sydots,colors);
X   return (i);
X}
X
Xint _fastcall near common_startdisk(int newrowsize, int newcolsize, int colors)
X{
X   int i,success;
X   long memorysize;
X
X   if (diskflag)
X      enddisk();
X   if (dotmode == 11) { /* otherwise, real screen also in use, don't hit it */
X      char buf[20];
X      helptitle();
X      setattr(1,0,C_DVID_BKGRD,24*80);    /* init rest to background */
X      for (i = 0; i < BOXDEPTH; ++i)
X     setattr(BOXROW+i,BOXCOL,C_DVID_LO,BOXWIDTH);  /* init box */
X      putstring(BOXROW+2,BOXCOL+4,C_DVID_HI,"'Disk-Video' mode");
X      putstring(BOXROW+4,BOXCOL+4,C_DVID_LO,"Screen resolution: ");
X      sprintf(buf,"%d x %d",sxdots,sydots);
X      putstring(-1,-1,C_DVID_LO,buf);
X      if (disktarga)
X     putstring(-1,-1,C_DVID_LO,"  24 bit Targa");
X      else {
X     putstring(-1,-1,C_DVID_LO,"  Colors: ");
X     sprintf(buf,"%d",colors);
X     putstring(-1,-1,C_DVID_LO,buf);
X     }
X      putstring(BOXROW+8,BOXCOL+4,C_DVID_LO,"Status:");
X      dvid_status(0,"clearing the 'screen'");
X      }
X   timetodisplay = TIMETODISPLAY;  /* time-to-display-status counter */
X
X   memorysize = (long)(newcolsize) * newrowsize;
X   diskflag = 1;
X   rowsize = newrowsize;
X   colsize = newcolsize;
X
X   if (dataPtr != NULL) {
X       free(dataPtr);
X   }
X   dataPtr = (BYTE *)malloc(memorysize);
X
X  bzero(dataPtr,memorysize);
X
Xcommon_okend:
X   if (dotmode == 11)
X      dvid_status(0,"");
X   return(0);
X}
X
Xvoid enddisk()
X{
X   diskflag = rowsize = disk16bit = 0;
X   fp           = NULL;
X}
X
Xint readdisk(int col, int row)
X{
X   char buf[41];
X   if (--timetodisplay < 0) {  /* time to display status? */
X      if (dotmode == 11) {
X     sprintf(buf," reading line %4d",
X        (row >= sydots) ? row-sydots : row); /* adjust when potfile */
X     dvid_status(0,buf);
X     }
X      timetodisplay = TIMETODISPLAY;
X      }
X   if (row>=colsize || col>=rowsize) {
X       return 0;
X   }
X   return dataPtr[row*rowsize+col];
X}
X
Xint FromMemDisk(long offset, int size, void far *dest)
X{
X   far_memcpy(dest, (void far *) (dataPtr+offset), size);
X   return 1;
X}
X
Xvoid targa_readdisk(unsigned int col, unsigned int row,
X            BYTE *red, BYTE *green, BYTE *blue)
X{
X   col *= 3;
X   *blue  = readdisk(col,row);
X   *green = readdisk(++col,row);
X   *red   = readdisk(col+1,row);
X}
X
Xvoid writedisk(int col, int row, int color)
X{
X   char buf[41];
X   if (--timetodisplay < 0) {  /* time to display status? */
X      if (dotmode == 11) {
X     sprintf(buf," writing line %4d",
X        (row >= sydots) ? row-sydots : row); /* adjust when potfile */
X     dvid_status(0,buf);
X     }
X      timetodisplay = TIMETODISPLAY;
X      }
X   if (row>=colsize || col>=rowsize) {
X       return;
X   }
X   dataPtr[row*rowsize+col] = color;
X   if (Shadowing) {
X      unsigned Mask;
X      Mask = (1 << AntiAliasing) - 1;
X      if(!(col & Mask) && !(row & Mask))
X     ShadowPutColor(col, row, color);
X      }
X}
X
Xint ToMemDisk(long offset, int size, void far *src)
X{
X    far_memcpy((void far *) (dataPtr+offset), src, size);
X    return 1;
X}
X
Xvoid targa_writedisk(unsigned int col, unsigned int row,
X            BYTE red, BYTE green, BYTE blue)
X{
X   writedisk(col*=3,row,blue);
X   writedisk(++col, row,green);
X   writedisk(col+1, row,red);
X}
X
Xvoid dvid_status(int line,char *msg)
X{
X   char buf[41];
X   int attrib;
X   memset(buf,' ',40);
X   memcpy(buf,msg,strlen(msg));
X   buf[40] = 0;
X   attrib = C_DVID_HI;
X   if (line >= 100) {
X      line -= 100;
X      attrib = C_STOP_ERR;
X      }
X   putstring(BOXROW+8+line,BOXCOL+12,attrib,buf);
X   movecursor(25,80);
X}
SHAR_EOF
$TOUCH -am 1028230193 diskvidu.c &&
chmod 0644 diskvidu.c ||
echo "restore of diskvidu.c failed"
set `wc -c diskvidu.c`;Wc_c=$1
if test "$Wc_c" != "5594"; then
    echo original size 5594, current size $Wc_c
fi
# ============= fpu087.c ==============
echo "x - extracting fpu087.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fpu087.c &&
X/* Fpu087.c
X * This file contains routines to replace fpu087.asm.
X *
X * This file Copyright 1991 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X */
X
X#include <fractint.h>
X#include <mpmath.h>
X#include <math.h>
X
Xextern int DivideOverflow;
X
X/*
X *----------------------------------------------------------------------
X *
X * xxx086 --
X *
X *    Simulate integer math routines using floating point.
X *    This will of course slow things down, so this should all be
X *    changed at some point.
X *
X *----------------------------------------------------------------------
X */
X
Xvoid FPUaptan387(double *y, double *x, double *atan)
X{
X    *atan = atan2(*y,*x);
X}
X
Xvoid FPUcplxmul(_CMPLX *x, _CMPLX *y, _CMPLX *z)
X{
X    double tx;
X    tx = x->x * y->x - x->y * y->y;
X    z->y = x->x * y->y + x->y * y->x;
X    z->x = tx;
X}
X
Xvoid FPUcplxdiv(_CMPLX *x, _CMPLX *y, _CMPLX *z)
X{
X    double mod,tx,ty,yxmod,yymod;
X    mod = y->x * y->x + y->y * y->y;
X    if (mod==0) {
X    DivideOverflow++;
X    }
X    yxmod = y->x/mod;
X    yymod = - y->y/mod;
X    tx = x->x * yxmod - x->y * yymod;
X    z->y = x->x * yymod + x->y * yxmod;
X    z->x = tx;
X}
X
Xvoid FPUsincos(double *Angle, double *Sin, double *Cos)
X{
X    *Sin = sin(*Angle);
X    *Cos = cos(*Angle);
X}
X
Xvoid FPUsinhcosh(double *Angle, double *Sinh, double *Cosh)
X{
X    *Sinh = sinh(*Angle);
X    *Cosh = cosh(*Angle);
X}
X
Xvoid FPUcplxlog(_CMPLX *x, _CMPLX *z)
X{
X    double mod,zx,zy;
X    mod = sqrt(x->x*x->x + x->y*x->y);
X    zx = log(mod);
X    zy = atan2(x->y,x->x);
X
X    z->x = zx;
X    z->y = zy;
X}
X
Xvoid FPUcplxexp387(_CMPLX *x, _CMPLX *z)
X{
X    double pow,y;
X    y = x->y;
X    pow = exp(x->x);
X    z->x = pow*cos(y);
X    z->y = pow*sin(y);
X}
X
X/* Integer Routines */
Xvoid SinCos086(long x, long *sinx, long *cosx)
X{
X    double a;
X    a = x/(double)(1<<16);
X    *sinx = (long) (sin(a)*(double)(1<<16));
X    *cosx = (long) (cos(a)*(double)(1<<16));
X}
X
Xvoid SinhCosh086(long x, long *sinx, long *cosx)
X{
X    double a;
X    a = x/(double)(1<<16);
X    *sinx = (long) (sinh(a)*(double)(1<<16));
X    *cosx = (long) (cosh(a)*(double)(1<<16));
X}
X
Xlong Exp086(x)
Xlong x;
X{
X    return (long) (exp((double)x/(double)(1<<16))*(double)(1<<16));
X}
X
X#define em2float(l) (*(float *)&(l))
X#define float2em(f) (*(long *)&(f))
X
X/*
X * Input is a 16 bit offset number.  Output is shifted by Fudge.
X */
Xunsigned long ExpFudged(x, Fudge)
Xlong x;
Xint Fudge;
X{
X    return (long) (exp((double)x/(double)(1<<16))*(double)(1<<Fudge));
X}
X
X/* This multiplies two e/m numbers and returns an e/m number. */
Xlong r16Mul(x,y)
Xlong x,y;
X{
X    float f;
X    f = em2float(x)*em2float(y);
X    return float2em(f);
X}
X
X/* This takes an exp/mant number and returns a shift-16 number */
Xlong LogFloat14(x)
Xunsigned long x;
X{
X    return log((double)em2float(x))*(1<<16);
X}
X
X/* This divides two e/m numbers and returns an e/m number. */
Xlong RegDivFloat(x,y)
Xlong x,y;
X{
X    float f;
X    f = em2float(x)/em2float(y);
X    return float2em(f);
X}
X
X/*
X * This routine on the IBM converts shifted integer x,FudgeFact to
X * the 4 byte number: exp,mant,mant,mant
X * Instead of using exp/mant format, we'll just use floats.
X * Note: If sizeof(float) != sizeof(long), we're hosed.
X */
Xlong RegFg2Float(x,FudgeFact)
Xlong x;
Xint FudgeFact;
X{
X    float f;
X    long l;
X    f = x/(float)(1<<FudgeFact);
X    l = float2em(f);
X    return l;
X}
X
X/*
X * This converts em to shifted integer format.
X */
Xlong RegFloat2Fg(x,Fudge)
Xlong x;
Xint Fudge;
X{
X    return em2float(x)*(float)(1<<Fudge);
X}
X
Xlong RegSftFloat(x, Shift)
Xlong x;
Xint Shift;
X{
X    float f;
X    f = em2float(x);
X    if (Shift>0) {
X    f *= (1<<Shift);
X    } else {
X    f /= (1<<Shift);
X    }
X    return float2em(f);
X}
SHAR_EOF
$TOUCH -am 1028230193 fpu087.c &&
chmod 0644 fpu087.c ||
echo "restore of fpu087.c failed"
set `wc -c fpu087.c`;Wc_c=$1
if test "$Wc_c" != "3671"; then
    echo original size 3671, current size $Wc_c
fi
# ============= fracsuba.c ==============
echo "x - extracting fracsuba.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fracsuba.c &&
X#include "fractint.h"
X
Xextern long ltempsqrx,ltempsqry;
Xextern long lmagnitud, llimit, llimit2, lclosenuff, l16triglim;
Xextern int overflow, bitshift;
Xextern _LCMPLX lold, lnew;
X
Xlongbailout()
X{
X    ltempsqrx = lsqr(lnew.x); ltempsqry = lsqr(lnew.y);
X    lmagnitud = ltempsqrx + ltempsqry;
X    if (lmagnitud >= llimit || lmagnitud < 0 || labs(lnew.x) > llimit2
X    || labs(lnew.y) > llimit2 || overflow)
X        { overflow=0;
X        return(1); }
X    lold = lnew;
X    return(0);
X}
X
XFManOWarfpFractal() {}
XFJuliafpFractal() {}
XFBarnsley1FPFractal() {}
XFBarnsley2FPFractal() {}
XFLambdaFPFractal() {}
SHAR_EOF
$TOUCH -am 1028230193 fracsuba.c &&
chmod 0644 fracsuba.c ||
echo "restore of fracsuba.c failed"
set `wc -c fracsuba.c`;Wc_c=$1
if test "$Wc_c" != "589"; then
    echo original size 589, current size $Wc_c
fi
# ============= general.c ==============
echo "x - extracting general.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > general.c &&
X/* generalasm.c
X * This file contains routines to replace general.asm.
X *
X * This file Copyright 1991 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X */
X
X#include <string.h>
X#ifndef NOBSTRING
X/* If this gives you an error, read the README and modify the Makefile. */
X#include <bstring.h>
X#endif
X#include <stdio.h>
X#include <stdlib.h>
X#include <sys/types.h>
X#include <sys/time.h>
X#include "fractint.h"
X
Xint overflow = 0;
X
Xchar boxx[9216], boxy[4096];
Xchar boxvalues[2048];
Xchar tstack[4096];
X
Xextern int tabmode;
X
Xint DivideOverflow = 0;
Xint iit=0;
Xint cpu=0;        /* cpu type: 86, 186, 286, or 386 */
X#ifndef XFRACT
Xint fpu=0;        /* fpu type: 0, 87, 287, 387 */
X#else
Xint fpu=1;
X#endif
X
XSEGTYPE extraseg=0;        /* extra 64K segment (allocated by init) */
X/* ********************** Mouse Support Variables ************************** */
X
Xint lookatmouse=0;    /* see notes at mouseread routine */
Xint savebase=0;        /* base clock ticks */
Xint saveticks=0;    /* save after this many ticks */
Xint finishrow=0;    /* save when this row is finished */
X
Xint inside_help = 0;
X
Xextern int slides;    /* 1 for playback */
X
Xvoid toextra(tooffset, fromaddr, fromcount)
Xint tooffset;
Xchar *fromaddr;
Xint fromcount;
X{
X    bcopy(fromaddr,(char *)(extraseg+tooffset),fromcount);
X}
X
Xvoid fromextra(fromoffset, toaddr, tocount)
Xint fromoffset;
Xchar *toaddr;
Xint tocount;
X{
X    bcopy((char *)(extraseg+fromoffset),toaddr,tocount);
X}
X
Xint
Xcmpextra(cmpoffset,cmpaddr,cmpcount)
Xint cmpoffset;
Xchar *cmpaddr;
Xint cmpcount;
X{
X    return bcmp((char *)(extraseg+cmpoffset),cmpaddr,cmpcount);
X}
X
X/*
X; ****************** Function initasmvars() *****************************
X*/
Xvoid
Xinitasmvars()
X{
X    if (cpu!=0) return;
X    overflow = 0;
X    extraseg = malloc(0x18000);
X
X    /* set cpu type */
X    cpu = 1;
X
X    /* set fpu type */
X#ifndef XFRACT
X    fpu = 0;
X#else
X    fpu = 1;
X#endif
X
X}
X
Xvoid fpe_handler(int signum)
X{
X    overflow = 1;
X}
X
X/*
X;
X;       32-bit integer multiply routine with an 'n'-bit shift.
X;       Overflow condition returns 0x7fffh with overflow = 1;
X;
X;       long x, y, z, multiply();
X;       int n;
X;
X;       z = multiply(x,y,n)
X;
X*/
Xstatic float
Xtofloat(x,n)
Xlong x;
Xint n;
X{
X    return (float)x/(float)(1<<n);
X}
X/*
X * 32 bit integer multiply with n bit shift.
X * Note that we fake integer multiplication with floating point
X * multiplication.
X */
Xlong
Xmultiply(x, y, n)
Xlong x,y;
Xint n;
X{
X    register long l;
X    l = ((float)x)* ((float)y)/(float)(1<<n);
X    if (l==0x7fffffff) {
X    overflow = 1;
X    }
X    return l;
X}
X
X/*
X;
X;       32-bit integer divide routine with an 'n'-bit shift.
X;       Overflow condition returns 0x7fffh with overflow = 1;
X;
X;       z = divide(x,y,n);       z = x / y;
X*/
Xlong
Xdivide(x,y,n)
Xlong x,y;
Xint n;
X{
X    return (long) ( ((float)x)/ ((float)y)*(float)(1<<n));
X}
X
X/*
X; ****************** Function getakey() *****************************
X; **************** Function keypressed() ****************************
X
X;       'getakey()' gets a key from either a "normal" or an enhanced
X;       keyboard.   Returns either the vanilla ASCII code for regular
X;       keys, or 1000+(the scan code) for special keys (like F1, etc)
X;       Use of this routine permits the Control-Up/Down arrow keys on
X;       enhanced keyboards.
X;
X;       The concept for this routine was "borrowed" from the MSKermit
X;       SCANCHEK utility
X;
X;       'keypressed()' returns a zero if no keypress is outstanding,
X;       and the value that 'getakey()' will return if one is.  Note
X;       that you must still call 'getakey()' to flush the character.
X;       As a sidebar function, calls 'help()' if appropriate, or
X;       'tab_display()' if appropriate.
X;       Think of 'keypressed()' as a super-'kbhit()'.
X*/
Xint keybuffer = 0;
Xkeypressed() {
X    int ch;
X    ch = getkeynowait();
X    if (!ch) return 0;
X    keybuffer = ch;
X    if (ch==F1 && helpmode) {
X    keybuffer = 0;
X    inside_help = 1;
X    help(0);
X    inside_help = 0;
X    restore_active_ovly();
X    return 0;
X    } else if (ch==TAB && tabmode) {
X    keybuffer = 0;
X    tab_display();
X    restore_active_ovly();
X    return 0;
X    }
X    return ch;
X}
X
X/* Wait for a key.
X * This should be used instead of:
X * while (!keypressed()) {}
X * If timeout=1, waitkeypressed will time out after .5 sec.
X */
Xwaitkeypressed(timeout)
Xint timeout;
X{
X    int status;
X    while (!keybuffer) {
X    keybuffer = getkeyint(1);
X    if (timeout) break;
X    }
X    return keypressed();
X}
X
X/*
X * This routine returns a key, ignoring F1
X */
Xgetakeynohelp() {
X    int ch;
X    while (1) {
X    ch = getakey();
X    if (ch != F1) break;
X    }
X    return ch;
X}
X/*
X * This routine returns a keypress
X */
Xgetakey()
X{
X    int ch;
X
X    do {
X    ch = getkeyint(1);
X    } while (ch==0);
X    return ch;
X}
X
X/*
X * This routine returns the current key, or 0.
X */
Xgetkeynowait() {
X    return getkeyint(0);
X}
X
X/*
X * This is the low level key handling routine.
X * If block is set, we want to block before returning, since we are waiting
X * for a key press.
X * We also have to handle the slide file, etc.
X */
X
Xgetkeyint(block)
Xint block;
X{
X    int ch;
X    int curkey;
X    if (keybuffer) {
X    ch = keybuffer;
X    keybuffer = 0;
X    return ch;
X    }
X    curkey = xgetkey(0);
X    if (slides==1 && curkey == ESC) {
X    stopslideshow();
X    return 0;
X    }
X
X    if (curkey==0 && slides==1) {
X    curkey = slideshw();
X    }
X
X    if (curkey==0 && block) {
X    curkey = xgetkey(1);
X    if (slides==1 && curkey == ESC) {
X        stopslideshow();
X        return 0;
X    }
X    }
X
X    if (curkey && slides==2) {
X    recordshw(curkey);
X    }
X
X    return curkey;
X}
X
X/*
X; ****************** Function buzzer(int buzzertype) *******************
X;
X;       Sound a tone based on the value of the parameter
X;
X;       0 = normal completion of task
X;       1 = interrupted task
X;       2 = error contition
X
X;       "buzzer()" codes:  strings of two-word pairs
X;               (frequency in cycles/sec, delay in milliseconds)
X;               frequency == 0 means no sound
X;               delay     == 0 means end-of-tune
X*/
Xvoid
Xbuzzer(buzzertype)
Xint buzzertype;
X{
X    printf("\007");
X    fflush(stdout);
X    if (buzzertype==0) {
X    redrawscreen();
X    }
X}
X
X/*
X; ***************** Function delay(int delaytime) ************************
X;
X;       performs a delay loop for 'delaytime' milliseconds
X*/
Xvoid
Xdelay(delaytime)
Xint delaytime;
X{
X    static struct timeval delay;
X    delay.tv_sec = delaytime/1000;
X    delay.tv_usec = (delaytime%1000)*1000;
X    (void) select(0, (int *) 0, (int *) 0, (int *) 0, &delay);
X}
X
X/*
X; ************** Function tone(int frequency,int delaytime) **************
X;
X;       buzzes the speaker with this frequency for this amount of time
X*/
Xvoid
Xtone(frequency, delaytime)
Xint frequency, delaytime;
X{
X}
X
X/*
X; ************** Function snd(int hertz) and nosnd() **************
X;
X;       turn the speaker on with this frequency (snd) or off (nosnd)
X;
X; *****************************************************************
X*/
Xvoid
Xsnd(hertz)
Xint hertz;
X{
X}
X
Xvoid
Xnosnd()
X{}
X
X/*
X; long readticker() returns current bios ticker value
X*/
Xlong
Xreadticker()
X{
X    return clock_ticks();
X}
X
X/*
X; ************************* Far Segment RAM Support **************************
X;
X;
X;       farptr = (char far *)farmemalloc(long bytestoalloc);
X;       (void)farmemfree(farptr);
X*/
X
XVOIDPTR
Xfarmemalloc(len)
Xlong len;
X{
X    return (VOIDPTR )malloc((unsigned)len);
X}
X
Xvoid
Xfarmemfree(addr)
XVOIDPTR addr;
X{
X    free((char *)addr);
X}
X
Xerasesegment(segaddress,segvalue)
X{
X}
X
X
Xint
Xfarread(handle, buf, len)
Xint handle;
XVOIDPTR buf;
Xunsigned len;
X{
X    return read(handle, buf, len);
X}
X
Xint
Xfarwrite(handle, buf, len)
Xint handle;
XVOIDPTR buf;
Xunsigned len;
X{
X    return write(handle,buf,len);
X}
X
X
Xlong
Xnormalize(ptr)
Xchar *ptr;
X{
X    return (long) ptr;
X}
X
X/*
X; *************** Far string/memory functions *********
X*/
Xint
Xfar_strlen (a)
Xchar *a;
X{
X    return strlen(a);
X}
X
X
Xint
Xfar_strcpy (a,b)
Xchar *a,*b;
X{
X    return (int)strcpy(a,b);
X}
X
Xint
Xfar_strcmp (a,b)
Xchar *a, *b;
X{
X    return strcmp(a,b);
X}
X
Xint
Xfar_stricmp(a,b)
Xchar *a,*b;
X{
X    return stricmp(a,b);
X}
X
Xint
Xfar_strnicmp(a,b,n)
Xchar *a,*b;
Xint n;
X{
X    return strnicmp(a,b,n);
X}
X
Xint
Xfar_strcat (a,b)
Xchar *a,*b;
X{
X    return (int)strcat(a,b);
X}
X
Xint
Xfar_memset ( a,c,len)
XVOIDPTR a;
Xint c;
Xint len;
X{
X    return (int)memset(a,c,len);
X}
X
Xint
Xfar_memcpy ( a,b,len)
XVOIDFARPTR a,b;
Xint len;
X{
X    memcpy(a,b,len);
X    return (int)a;
X}
X
Xint
Xfar_memcmp (a,b,len)
XVOIDFARPTR a,b;
Xint len;
X{
X    return memcmp(a,b,len);
X}
X
Xint
Xfar_memicmp(a,b,len)
XVOIDFARPTR a,b;
Xint len;
X{
X    return memicmp(a,b,len);
X}
X
X/*
X * Extended memory support
X */
X
XBYTE *
Xemmquery()
X{
X}
X
Xunsigned int
Xemmgetfree()
X{}
X
Xunsigned int
Xemmallocate(len)
Xunsigned int len;
X{}
X
Xvoid
Xemmdeallocate(len)
Xunsigned int len;
X{}
X
Xvoid
Xemmgetpage(a,b)
Xunsigned int a, b;
X{}
X
Xvoid
Xemmclearpage(a,b)
Xunsigned int a, b;
X{}
X
X
Xunsigned int *
Xxmmquery()
X{}
X
Xunsigned int
Xxmmallocate(a)
Xunsigned int a;
X{}
X
Xvoid
Xxmmdeallocate(a)
Xunsigned int a;
X{}
X
Xvoid
Xxmmmoveextended(a)
Xint a;
X{}
X
X/*
X * IIT coprocessor routines.
X */
X
Xload_mat(matrix)
Xdouble matrix[16];
X{}
X
Xvoid
Xmult_vec_iit(vector)
Xdouble vector[3];
X{}
X
Xint
XIITCoPro() {
X    return 0;
X}
X
Xint F4x4Check()
X{
X}
X
Xvoid F4x4Free() {}
X
Xint F4x4Lock() {}
X
X
X/* --------------------------------------------------------------------
X * The following routines are used for encoding/decoding gif images.
X * If we aren't on a PC, things are rough for decoding the fractal info
X * structure in the GIF file.  These routines look after converting the
X * MS_DOS format data into a form we can use.
X * If dir==0, we convert to MSDOS form.  Otherwise we convert from MSDOS.
X */
X
Xstatic getChar(), getInt(), getLong(), getFloat(), getDouble();
X
Xdecode_fractal_info(info,dir)
X    struct fractal_info *info;
X    int dir;
X{
X    unsigned char *buf;
X    unsigned char *bufPtr;
X    int i;
X
X    if (dir==1) {
X    buf = (unsigned char *)malloc(FRACTAL_INFO_SIZE);
X    bufPtr = buf;
X    bcopy((char *)info,(char *)buf,FRACTAL_INFO_SIZE);
X    }  else {
X    buf = (unsigned char *)malloc(sizeof(struct fractal_info));
X    bufPtr = buf;
X    bcopy((char *)info,(char *)buf,sizeof(struct fractal_info));
X    }
X
X    if (dir==1) {
X    strncpy(info->info_id,bufPtr,8);
X    } else {
X    strncpy(bufPtr,info->info_id,8);
X    }
X    bufPtr += 8;
X    getInt(&info->iterations,&bufPtr,dir);
X    getInt(&info->fractal_type,&bufPtr,dir);
X    getDouble(&info->xmin,&bufPtr,dir);
X    getDouble(&info->xmax,&bufPtr,dir);
X    getDouble(&info->ymin,&bufPtr,dir);
X    getDouble(&info->ymax,&bufPtr,dir);
X    getDouble(&info->creal,&bufPtr,dir);
X    getDouble(&info->cimag,&bufPtr,dir);
X    getInt(&info->videomodeax,&bufPtr,dir);
X    getInt(&info->videomodebx,&bufPtr,dir);
X    getInt(&info->videomodecx,&bufPtr,dir);
X    getInt(&info->videomodedx,&bufPtr,dir);
X    getInt(&info->dotmode,&bufPtr,dir);
X    getInt(&info->xdots,&bufPtr,dir);
X    getInt(&info->ydots,&bufPtr,dir);
X    getInt(&info->colors,&bufPtr,dir);
X    getInt(&info->version,&bufPtr,dir);
X    getFloat(&info->parm3,&bufPtr,dir);
X    getFloat(&info->parm4,&bufPtr,dir);
X    getFloat(&info->potential[0],&bufPtr,dir);
X    getFloat(&info->potential[1],&bufPtr,dir);
X    getFloat(&info->potential[2],&bufPtr,dir);
X    getInt(&info->rseed,&bufPtr,dir);
X    getInt(&info->rflag,&bufPtr,dir);
X    getInt(&info->biomorph,&bufPtr,dir);
X    getInt(&info->inside,&bufPtr,dir);
X    getInt(&info->logmap,&bufPtr,dir);
X    getFloat(&info->invert[0],&bufPtr,dir);
X    getFloat(&info->invert[1],&bufPtr,dir);
X    getFloat(&info->invert[2],&bufPtr,dir);
X    getInt(&info->decomp[0],&bufPtr,dir);
X    getInt(&info->decomp[1],&bufPtr,dir);
X    getInt(&info->symmetry,&bufPtr,dir);
X    for (i=0;i<16;i++) {
X    getInt(&info->init3d[i],&bufPtr,dir);
X    }
X    getInt(&info->previewfactor,&bufPtr,dir);
X    getInt(&info->xtrans,&bufPtr,dir);
X    getInt(&info->ytrans,&bufPtr,dir);
X    getInt(&info->red_crop_left,&bufPtr,dir);
X    getInt(&info->red_crop_right,&bufPtr,dir);
X    getInt(&info->blue_crop_left,&bufPtr,dir);
X    getInt(&info->blue_crop_right,&bufPtr,dir);
X    getInt(&info->red_bright,&bufPtr,dir);
X    getInt(&info->blue_bright,&bufPtr,dir);
X    getInt(&info->xadjust,&bufPtr,dir);
X    getInt(&info->eyeseparation,&bufPtr,dir);
X    getInt(&info->glassestype,&bufPtr,dir);
X    getInt(&info->outside,&bufPtr,dir);
X    getDouble(&info->x3rd,&bufPtr,dir);
X    getDouble(&info->y3rd,&bufPtr,dir);
X    getChar(&info->stdcalcmode,&bufPtr,dir);
X    getChar(&info->useinitorbit,&bufPtr,dir);
X    getInt(&info->calc_status,&bufPtr,dir);
X    getLong(&info->tot_extend_len,&bufPtr,dir);
X    getInt(&info->distest,&bufPtr,dir);
X    getInt(&info->floatflag,&bufPtr,dir);
X    getInt(&info->bailout,&bufPtr,dir);
X    getLong(&info->calctime,&bufPtr,dir);
X    for (i=0;i<4;i++) {
X    getChar(&info->trigndx[i],&bufPtr,dir);
X    }
X    getInt(&info->finattract,&bufPtr,dir);
X    getDouble(&info->initorbit[0],&bufPtr,dir);
X    getDouble(&info->initorbit[1],&bufPtr,dir);
X    getInt(&info->periodicity,&bufPtr,dir);
X    getInt(&info->pot16bit,&bufPtr,dir);
X    getFloat(&info->faspectratio,&bufPtr,dir);
X    getInt(&info->system,&bufPtr,dir);
X    getInt(&info->release,&bufPtr,dir);
X    getInt(&info->flag3d,&bufPtr,dir);
X    getInt(&info->transparent[0],&bufPtr,dir);
X    getInt(&info->transparent[1],&bufPtr,dir);
X    getInt(&info->ambient,&bufPtr,dir);
X    getInt(&info->haze,&bufPtr,dir);
X    getInt(&info->randomize,&bufPtr,dir);
X    getInt(&info->rotate_lo,&bufPtr,dir);
X    getInt(&info->rotate_hi,&bufPtr,dir);
X    getInt(&info->distestwidth,&bufPtr,dir);
X    getDouble(&info->dparm3,&bufPtr,dir);
X    getDouble(&info->dparm4,&bufPtr,dir);
X    getInt(&info->fillcolor,&bufPtr,dir);
X    getDouble(&info->mxmaxfp,&bufPtr,dir);
X    getDouble(&info->mxminfp,&bufPtr,dir);
X    getDouble(&info->mymaxfp,&bufPtr,dir);
X    getDouble(&info->myminfp,&bufPtr,dir);
X    getInt(&info->zdots,&bufPtr,dir);
X    getFloat(&info->originfp,&bufPtr,dir);
X    getFloat(&info->depthfp,&bufPtr,dir);
X    getFloat(&info->heightfp,&bufPtr,dir);
X    getFloat(&info->widthfp,&bufPtr,dir);
X    getFloat(&info->distfp,&bufPtr,dir);
X    getFloat(&info->eyesfp,&bufPtr,dir);
X    getInt(&info->orbittype,&bufPtr,dir);
X    getInt(&info->juli3Dmode,&bufPtr,dir);
X    getInt(&info->maxfn,&bufPtr,dir);
X    getInt(&info->inversejulia,&bufPtr,dir);
X    getDouble(&info->dparm5,&bufPtr,dir);
X    getDouble(&info->dparm6,&bufPtr,dir);
X    getDouble(&info->dparm7,&bufPtr,dir);
X    getDouble(&info->dparm8,&bufPtr,dir);
X    getDouble(&info->dparm9,&bufPtr,dir);
X    getDouble(&info->dparm10,&bufPtr,dir);
X    for (i=0;i<50;i++) {
X    getInt(&info->future[i],&bufPtr,dir);
X    }
X    if (bufPtr-buf != FRACTAL_INFO_SIZE) {
X    printf("Warning: loadfile miscount on fractal_info structure.\n");
X    printf("Components add up to %d bytes, but FRACTAL_INFO_SIZE = %d\n",
X        bufPtr-buf, FRACTAL_INFO_SIZE);
X    }
X    if (dir==0) {
X    bcopy((char *)buf,(char *)info,FRACTAL_INFO_SIZE);
X    }
X
X    free(buf);
X}
X
X/*
X * This routine gets a char out of the buffer.
X * It updates the buffer pointer accordingly.
X */
Xstatic getChar(dst,src,dir)
X    unsigned char *dst;
X    unsigned char **src;
X    int dir;
X{
X    if (dir==1) {
X    *dst = **src;
X    } else {
X    **src = *dst;
X    }
X    (*src)++;
X}
X
X/*
X * This routine gets an int out of the buffer.
X * It updates the buffer pointer accordingly.
X */
Xstatic getInt(dst,src,dir)
X    short *dst;
X    unsigned char **src;
X    int dir;
X{
X    if (dir==1) {
X    *dst = (*src)[0] + ((((char *)(*src))[1])<<8);
X    } else {
X    (*src)[0] = (*dst)&0xff;
X    (*src)[1] = ((*dst)&0xff00)>>8;
X    }
X    (*src) += 2; /* sizeof(int) in MS_DOS */
X}
X
X/*
X * This routine gets a long out of the buffer.
X * It updates the buffer pointer accordingly.
X */
Xstatic getLong(dst,src,dir)
X    long *dst;
X    unsigned char **src;
X    int dir;
X{
X    if (dir==1) {
X    *dst = ((unsigned long)((*src)[0])) +
X        (((unsigned long)((*src)[1]))<<8) +
X        (((unsigned long)((*src)[2]))<<16) +
X        (((long)(((char *)(*src))[3]))<<24);
X    } else {
X    (*src)[0] = (*dst)&0xff;
X    (*src)[1] = ((*dst)&0xff00)>>8;
X    (*src)[2] = ((*dst)&0xff0000)>>8;
X    (*src)[3] = ((*dst)&0xff000000)>>8;
X    }
X    (*src) += 4; /* sizeof(long) in MS_DOS */
X}
X
X#define P4 16.
X#define P7 128.
X#define P8 256.
X#define P12 4096.
X#define P15 32768.
X#define P20 1048576.
X#define P23 8388608.
X#define P28 268435456.
X#define P36 68719476736.
X#define P44 17592186044416.
X#define P52 4503599627370496.
X
X
X/*
X * This routine gets a double out of the buffer, or puts a double into the
X * buffer;
X * It updates the buffer pointer accordingly.
X */
Xstatic getDouble(dst,src,dir)
X    double *dst;
X    unsigned char **src;
X    int dir;
X{
X    int e;
X    double f;
X    int i;
X    if (dir==1) {
X    for (i=0;i<8;i++) {
X        if ((*src)[i] != 0) break;
X    }
X    if (i==8) {
X        *dst = 0;
X    } else {
X        e = (((*src)[7]&0x7f)<<4) + (((*src)[6]&0xf0)>>4) - 1023;
X        f = 1 + ((*src)[6]&0x0f)/P4 + (*src)[5]/P12 + (*src)[4]/P20 +
X        (*src)[3]/P28 + (*src)[2]/P36 + (*src)[1]/P44 + (*src)[0]/P52;
X        f *= pow(2.,(double)e);
X        if ((*src)[7]&0x80) {
X        f = -f;
X        }
X        *dst = f;
X    }
X    } else {
X    if (*dst==0) {
X        bzero((char *)(*src),8);
X    } else {
X        int s=0;
X        f = *dst;
X        if (f<0) {
X        s = 0x80;
X        f = -f;
X        }
X        e = log(f)/log(2.);
X        f = f/pow(2.,(double)e) - 1;
X        if (f<0) {
X        e--;
X        f = (f+1)*2-1;
X        } else if (f>=1) {
X        e++;
X        f = (f+1)/2-1;
X        }
X        e += 1023;
X        (*src)[7] = s | ((e&0x7f0)>>4);
X        f *= P4;
X        (*src)[6] = ((e&0x0f)<<4) | (((int)f)&0x0f);
X        f = (f-(int)f)*P8;
X        (*src)[5] = (((int)f)&0xff);
X        f = (f-(int)f)*P8;
X        (*src)[4] = (((int)f)&0xff);
X        f = (f-(int)f)*P8;
X        (*src)[3] = (((int)f)&0xff);
X        f = (f-(int)f)*P8;
X        (*src)[2] = (((int)f)&0xff);
X        f = (f-(int)f)*P8;
X        (*src)[1] = (((int)f)&0xff);
X        f = (f-(int)f)*P8;
X        (*src)[0] = (((int)f)&0xff);
X    }
X    }
X    *src += 8; /* sizeof(double) in MSDOS */
X}
X
X/*
X * This routine gets a float out of the buffer.
X * It updates the buffer pointer accordingly.
X */
Xstatic getFloat(dst,src,dir)
X    float *dst;
X    unsigned char **src;
X    int dir;
X{
X    int e;
X    double f;
X    int i;
X    if (dir==1) {
X    for (i=0;i<4;i++) {
X        if ((*src)[i] != 0) break;
X    }
X    if (i==4) {
X        *dst = 0;
X    } else {
X        e = (((*src)[3]&0x7f)<<1)| (((*src)[2]&0x80)>>7) - 127;
X        f = 1 + ((*src)[2]&0x7f)/P7 + (*src)[1]/P15 + (*src)[0]/P23;
X        f *= pow(2.,(double)e);
X        if ((*src)[3]&0x80) {
X        f = -f;
X        }
X        *dst = f;
X    }
X    } else {
X    if (*dst==0) {
X        bzero((char *)(*src),4);
X    } else {
X        int s=0;
X        f = *dst;
X        if (f<0) {
X        s = 0x80;
X        f = -f;
X        }
X        e = log(f)/log(2.);
X        f = f/pow(2.,(double)e) - 1;
X        if (f<0) {
X        e--;
X        f = (f+1)*2-1;
X        } else if (f>=1) {
X        e++;
X        f = (f+1)/2-1;
X        }
X        e += 127;
X        (*src)[3] = s | ((e&0xf7)>>1);
X        f *= P7;
X        (*src)[2] = ((e&0x01)<<7) | (((int)f)&0x7f);
X        f = (f-(int)f)*P8;
X        (*src)[1] = (((int)f)&0xff);
X        f = (f-(int)f)*P8;
X        (*src)[0] = (((int)f)&0xff);
X    }
X    }
X    *src += 4; /* sizeof(float) in MSDOS */
X}
X
X/*
X * Fix up the ranges data.
X */
Xfix_ranges(ranges,num,dir)
X    int *ranges, num;
X    int dir;
X{
X    unsigned char *buf;
X    unsigned char *bufPtr;
X    int i;
X
X    if (dir==1) {
X    buf = (unsigned char *)malloc(num*2);
X    bufPtr = buf;
X    bcopy((char *)ranges, (char *)buf, num*2);
X    } else {
X    buf = (unsigned char *)malloc(num*sizeof(int));
X    bufPtr = buf;
X    bcopy((char *)ranges, (char *)buf, num*sizeof(int));
X    }
X    for (i=0;i<num;i++) {
X    getInt(&ranges[i],bufPtr,dir);
X    }
X    free((char *)buf);
X}
SHAR_EOF
$TOUCH -am 1028230193 general.c &&
chmod 0644 general.c ||
echo "restore of general.c failed"
set `wc -c general.c`;Wc_c=$1
if test "$Wc_c" != "19394"; then
    echo original size 19394, current size $Wc_c
fi
# ============= printera.c ==============
echo "x - extracting printera.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > printera.c &&
X/*
X *  printera.c
X *
X *
X *  Paintjet tables for printer.c, in here so that we can link them
X *  as part of the printer.c overlay and not waste far space.
X *
X *  The tables were copied from Lee Crocker's PGIF program, with
X *  the 8 undithered colors moved to the first 8 table slots.
X *
X *  This file contains various lookup tables used by PJGIF.  Patterns contains
X *  unsigned values representing each of the 330 HP PaintJet colors.  Each color
X *  at 90 DPI is composed of four dots in 8 colors.  Each hex digit of these
X *  unsigned values represents one of the four dots.  Although the PaintJet will
X *  produce these patterns automatically in 90 DPI mode, it is much faster to do
X *  it in software with the PaintJet in 8-color 180 DPI mode.
X *
X *  920501 Hans Wolfgang Schulze converted from printera.asm for xfractint.
X *       ([e-mail])
X */
X
X#include "port.h"
X
Xunsigned int far pj_patterns [] = {
X      0x7777,0x0000,0x1111,0x2222,0x3333,0x4444,0x5555,0x6666,
X             0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,
X      0x0110,0x0120,0x0130,0x0140,0x0150,0x0160,0x0170,0x0220,
X      0x0230,0x0240,0x0250,0x0260,0x0270,0x0330,0x0340,0x0350,
X      0x0360,0x0370,0x0440,0x0450,0x0460,0x0470,0x0550,0x0560,
X      0x0570,0x0660,0x0670,0x0770,0x0111,0x0112,0x0113,0x0114,
X      0x0115,0x0116,0x0117,0x2012,0x0123,0x0124,0x0125,0x0126,
X      0x0127,0x3013,0x0134,0x0135,0x0136,0x0137,0x4014,0x0145,
X      0x0146,0x0147,0x5015,0x0156,0x0157,0x6016,0x0167,0x7017,
X      0x0222,0x0223,0x0224,0x0225,0x0226,0x0227,0x3023,0x0234,
X      0x0235,0x0236,0x0237,0x4024,0x0245,0x0246,0x0247,0x5025,
X      0x0256,0x0257,0x6026,0x0267,0x7027,0x0333,0x0334,0x0335,
X      0x0336,0x0337,0x4034,0x0345,0x0346,0x0347,0x5035,0x0356,
X      0x0357,0x6036,0x0367,0x7037,0x0444,0x0445,0x0446,0x0447,
X      0x5045,0x0456,0x0457,0x6046,0x0467,0x7047,0x0555,0x0556,
X      0x0557,0x6056,0x0567,0x7057,0x0666,0x0667,0x7067,0x0777,
X             0x1112,0x1113,0x1114,0x1115,0x1116,0x1117,0x2112,
X      0x1123,0x2114,0x2115,0x2116,0x2117,0x3113,0x3114,0x3115,
X      0x3116,0x3117,0x4114,0x4115,0x4116,0x4117,0x5115,0x5116,
X      0x5117,0x6116,0x6117,0x7117,0x1222,0x1223,0x1224,0x1225,
X      0x1226,0x1227,0x3123,0x1234,0x1235,0x1236,0x1237,0x4124,
X      0x1245,0x1246,0x1247,0x5125,0x1256,0x1257,0x6126,0x1267,
X      0x7127,0x1333,0x1334,0x1335,0x1336,0x1337,0x4134,0x1345,
X      0x1346,0x1347,0x5135,0x1356,0x1357,0x6136,0x1367,0x7137,
X      0x1444,0x1445,0x1446,0x1447,0x5145,0x1456,0x1457,0x6146,
X      0x1467,0x7147,0x1555,0x1556,0x1557,0x6156,0x1567,0x7157,
X      0x1666,0x1667,0x7167,0x1777,       0x2223,0x2224,0x2225,
X      0x2226,0x2227,0x3223,0x3224,0x3225,0x3226,0x3227,0x4224,
X      0x4225,0x4226,0x4227,0x5225,0x5226,0x5227,0x6226,0x6227,
X      0x7227,0x2333,0x2334,0x2335,0x2336,0x2337,0x4234,0x2345,
X      0x2346,0x2347,0x5235,0x2356,0x2357,0x6236,0x2367,0x7237,
X      0x2444,0x2445,0x2446,0x2447,0x5245,0x2456,0x2457,0x6246,
X      0x2467,0x7247,0x2555,0x2556,0x2557,0x6256,0x2567,0x7257,
X      0x2666,0x2667,0x7267,0x2777,       0x3334,0x3335,0x3336,
X      0x3337,0x4334,0x4335,0x4336,0x4337,0x5335,0x5336,0x5337,
X      0x6336,0x6337,0x7337,0x3444,0x3445,0x3446,0x3447,0x5345,
X      0x3456,0x3457,0x6346,0x3467,0x7347,0x3555,0x3556,0x3557,
X      0x6356,0x3567,0x7357,0x3666,0x3667,0x7367,0x3777,
X      0x4445,0x4446,0x4447,0x5445,0x5446,0x5447,0x6446,0x6447,
X      0x7447,0x4555,0x4556,0x4557,0x6456,0x4567,0x7457,0x4666,
X      0x4667,0x7467,0x4777,       0x5556,0x5557,0x6556,0x6557,
X      0x7557,0x5666,0x5667,0x7567,0x5777,       0x6667,0x7667,
X      0x6777};
X
X/*
X * The 3 tables below contain the red, green, and blue values (on a scale of
X *  0..255) of each of the 330 PaintJet colors.  These values are based on data
X *  generously provided by HP customer service.
X *       11 <- changed black's value from this, seemed wrong
X *         135 <- changed red's value from this
X *           11 <- changed blue's value from this
X */
Xunsigned char far pj_reds[] = {
X        229,  2,145,  7,227,  9,136, 5,
X             17, 10, 17, 10, 16, 10, 16, 29, 16, 32, 15, 30, 15, 31,  9,
X     15, 10, 15,  9, 13, 37, 15, 32, 16, 36, 10, 15,  9, 13, 30, 15,
X     31,  8, 13, 38, 62, 26, 68, 26, 63, 26, 68, 16, 35, 16, 33, 16,
X     33, 77, 26, 69, 29, 77, 16, 31, 16, 31, 64, 27, 71, 16, 36, 81,
X      9, 15, 10, 15,  8, 13, 37, 15, 31, 15, 33, 10, 15,  9, 13, 29,
X     15, 28,  8, 12, 28, 98, 28, 79, 32, 94, 16, 34, 17, 35, 73, 30,
X     82, 17, 43,101, 11, 15, 10, 13, 29, 15, 27,  9, 13, 25, 65, 27,
X     71, 16, 35, 88,  7, 12, 39,110,     54,146, 53,136, 58,144, 29,
X     57, 28, 53, 29, 56,159, 54,144, 61,160, 27, 51, 28, 52,135, 55,
X    144, 30, 60,159, 14, 23, 15, 22, 14, 21, 64, 30, 58, 32, 64, 15,
X     22, 15, 21, 54, 31, 56, 14, 22, 64,185, 59,160, 69,185, 29, 57,
X     31, 60,145, 63,162, 33, 71,186, 15, 22, 16, 21, 50, 30, 52, 15,
X     21, 54,134, 58,145, 30, 60,161, 15, 22, 69,187,     13,  9, 14,
X      6, 11, 31, 14, 27, 12, 27, 10, 14,  9, 12, 24,  9, 23,  6,  9,
X     22, 76, 23, 61, 25, 74, 15, 29, 14, 28, 55, 23, 62, 12, 30, 73,
X         11, 15, 10, 12, 25, 14, 23,  8, 11, 20, 50, 22, 53, 13, 26, 61,
X          5,  8, 21, 71,     71,189, 87,227, 30, 63, 32, 69,164, 76,190,
X         37, 89,227, 15, 22, 14, 20, 54, 31, 57, 14, 21, 63,147, 67,163,
X         33, 72,191, 13, 24, 94,228,     15, 10, 13, 26, 14, 23, 10, 13,
X         20, 50, 23, 50, 15, 26, 52,  8, 11, 23, 65,     60,147, 32, 67,
X        166, 14, 24, 77,194,      8, 32, 97};
X
X/*
X *                   11 <- changed black's value from this, seemed wrong
X *                           65 <- changed green from this
X */
X
Xunsigned char far pj_greens[] = {
X        224,  2, 20, 72,211, 10, 11, 55,
X             12, 15, 19, 11, 11, 14, 17, 14, 18, 22, 12, 13, 16, 19, 24,
X         29, 16, 17, 23, 27, 41, 17, 22, 29, 39, 11, 10, 14, 14, 11, 14,
X         17, 21, 25, 40, 16, 21, 28, 14, 16, 19, 25, 28, 37, 18, 20, 26,
X         33, 48, 20, 26, 33, 46, 13, 12, 16, 18, 14, 18, 22, 24, 30, 42,
X         40, 49, 25, 27, 39, 50, 69, 27, 33, 48, 66, 17, 17, 24, 27, 19,
X         28, 35, 38, 48, 68,100, 32, 46, 65, 98, 18, 22, 29, 36, 27, 39,
X         54, 49, 71,105, 11, 10, 14, 12, 10, 14, 13, 20, 20, 25, 11, 15,
X         18, 22, 29, 49, 36, 46, 69,111,     23, 31, 16, 19, 22, 28, 30,
X         37, 20, 22, 28, 34, 54, 22, 29, 36, 53, 14, 15, 17, 19, 17, 19,
X         26, 25, 32, 46, 43, 50, 27, 28, 41, 49, 68, 29, 37, 51, 68, 19,
X         19, 25, 28, 22, 30, 36, 40, 47, 66,104, 35, 51, 68,105, 20, 24,
X         31, 37, 30, 38, 56, 50, 69,103, 13, 12, 15, 14, 13, 15, 16, 21,
X         21, 26, 14, 16, 22, 23, 28, 44, 35, 42, 62,102,     78, 40, 44,
X         65, 78, 98, 43, 53, 76, 99, 26, 27, 36, 40, 29, 43, 50, 63, 75,
X         99,136, 49, 69, 98,142, 28, 32, 42, 51, 39, 52, 73, 77,103,145,
X         17, 17, 21, 21, 18, 22, 24, 34, 37, 43, 19, 23, 30, 40, 48, 69,
X         62, 76,101,147,     72,113,145,218, 33, 42, 52, 71, 61, 77,116,
X        105,148,221, 18, 17, 21, 23, 21, 26, 30, 37, 43, 64, 30, 35, 48,
X         50, 69,115, 77, 99,149,224,     10, 13, 11, 10, 12, 11, 17, 16,
X         15,  9, 11, 12, 17, 17, 22, 26, 27, 36, 61,     14, 18, 21, 26,
X         48, 34, 41, 68,115,     69, 99,149};
X
X/*                    15 <- changed black's value from this, seemed wrong
X *                           56 <- changed green from this
X *                                          163 <- changed cyan from this
X */
Xunsigned char far pj_blues[] = {
X        216,  2, 34, 48, 33, 73, 64,168,
X             18, 19, 18, 20, 19, 22, 21, 22, 24, 22, 26, 24, 27, 24, 27,
X         24, 29, 27, 31, 29, 22, 27, 25, 30, 28, 31, 29, 33, 33, 28, 32,
X         32, 41, 40, 46, 28, 32, 28, 34, 30, 36, 31, 35, 32, 38, 34, 41,
X         35, 27, 35, 31, 39, 34, 40, 37, 44, 40, 34, 42, 37, 49, 47, 45,
X         40, 36, 43, 40, 47, 43, 33, 40, 36, 45, 41, 44, 41, 49, 46, 40,
X         49, 45, 58, 56, 58, 30, 38, 34, 44, 40, 42, 39, 49, 46, 38, 49,
X         46, 59, 62, 67, 49, 46, 55, 52, 44, 55, 52, 64, 64, 66, 43, 55,
X         53, 66, 70, 78, 87, 91,101,115,     39, 34, 42, 37, 43, 36, 45,
X         38, 47, 42, 49, 43, 34, 41, 36, 44, 38, 49, 45, 52, 46, 40, 47,
X         42, 56, 51, 45, 49, 45, 52, 48, 56, 50, 40, 47, 44, 52, 47, 54,
X         51, 59, 55, 47, 58, 50, 66, 60, 56, 34, 44, 38, 48, 42, 52, 47,
X         56, 50, 42, 51, 46, 64, 59, 57, 60, 56, 64, 61, 52, 61, 57, 72,
X         67, 64, 48, 58, 53, 69, 65, 65, 87, 83, 87, 94,     53, 59, 55,
X         64, 60, 46, 53, 49, 59, 54, 60, 56, 65, 62, 53, 62, 58, 76, 71,
X         68, 41, 50, 45, 56, 51, 58, 53, 63, 59, 49, 60, 56, 74, 71, 71,
X         66, 63, 73, 70, 60, 69, 67, 84, 81, 79, 55, 67, 64, 84, 81, 83,
X        104,104,106,116,     32, 40, 53, 48, 54, 50, 61, 57, 46, 59, 56,
X         76, 75, 80, 64, 59, 70, 67, 57, 69, 65, 83, 81, 85, 54, 68, 66,
X         86, 88, 96,110,114,125,137,     71, 81, 78, 68, 77, 76, 93, 92,
X         90, 65, 77, 75, 92, 93, 96,117,119,126,138,     78, 79, 98,102,
X        110,124,131,143,157,    173,185,200};
SHAR_EOF
$TOUCH -am 1028230193 printera.c &&
chmod 0644 printera.c ||
echo "restore of printera.c failed"
set `wc -c printera.c`;Wc_c=$1
if test "$Wc_c" != "8947"; then
    echo original size 8947, current size $Wc_c
fi
# ============= tplus_a.c ==============
echo "x - extracting tplus_a.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > tplus_a.c &&
X/* tplus_a.c
X * This file contains routines to replace tplus_a.asm.
X *
X * This file Copyright 1992 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X */
X
X#include <fractint.h>
X
XWriteTPlusBankedPixel() {}
XReadTPlusBankedPixel() {}
XMatchTPlusMode() {}
SHAR_EOF
$TOUCH -am 1028230193 tplus_a.c &&
chmod 0644 tplus_a.c ||
echo "restore of tplus_a.c failed"
set `wc -c tplus_a.c`;Wc_c=$1
if test "$Wc_c" != "295"; then
    echo original size 295, current size $Wc_c
fi
# ============= video.c ==============
echo "x - extracting video.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > video.c &&
X#include <curses.h>
X#include <string.h>
X#include "fractint.h"
X#include "prototyp.h"
X
X/*
X * This file contains Unix versions of the routines in video.asm
X * Copyright 1992 Ken Shirriff
X */
X
Xextern int colors,rotate_lo,rotate_hi;
Xextern int boxx[],boxy[],boxcount;
X
Xextern unsigned char *xgetfont();
X
XWINDOW *curwin;
X
Xextern int boxcount;
Xextern int dotmode;
Xextern int sxdots,sydots,sxoffs,syoffs;
Xint daclearn = 0;
Xint dacnorm = 0;
Xint daccount = 0;
Xint ShadowColors;
Xint goodmode    =    0;    /* if non-zero, OK to read/write pixels */
Xvoid (*dotwrite)(int, int, int);
X                /* write-a-dot routine */
Xint (*dotread)(int, int);     /* read-a-dot routine */
Xvoid (*linewrite)();        /* write-a-line routine */
Xvoid (*lineread)();        /* read-a-line routine */
Xint andcolor    =    0;      /* "and" value used for color selection */
Xint diskflag    =    0;    /* disk video active flag */
X
Xint videoflag    =    0;    /* special "your-own-video" flag */
X
Xvoid (*swapsetup)(void)    =NULL;    /* setfortext/graphics setup routine */
Xint color_dark    =    0;    /* darkest color in palette */
Xint color_bright    =0;    /* brightest color in palette */
Xint color_medium    =0;    /* nearest to medbright grey in palette
X                   Zoom-Box values (2K x 2K screens max) */
Xint boxcolor    =    0;    /* Zoom-Box color */
Xint reallyega    =    0;    /* 1 if its an EGA posing as a VGA */
Xint gotrealdac    =    0;    /* 1 if loaddac has a dacbox */
Xint rowcount    =    0;    /* row-counter for decoder and out_line */
Xint video_type    =    0;    /* actual video adapter type:
X                    0  = type not yet determined
X                    1  = Hercules
X                    2  = CGA (assumed if nothing else)
X                    3  = EGA
X                    4  = MCGA
X                    5  = VGA
X                    6  = VESA (not yet checked)
X                   11  = 8514/A (not yet checked)
X                   12  = TIGA    (not yet checked)
X                   13  = TARGA    (not yet checked)
X                   100 = x monochrome
X                   101 = x 256 colors
X                   */
Xint svga_type    =    0;    /*  (forced) SVGA type
X                    1 = ahead "A" type
X                    2 = ATI
X                    3 = C&T
X                    4 = Everex
X                    5 = Genoa
X                    6 = Ncr
X                    7 = Oak-Tech
X                    8 = Paradise
X                    9 = Trident
X                   10 = Tseng 3000
X                   11 = Tseng 4000
X                   12 = Video-7
X                   13 = ahead "B" type
X                   14 = "null" type (for testing only) */
Xint mode7text    =    0;    /* nonzero for egamono and hgc */
Xint textaddr    =    0xb800;    /* b800 for mode 3, b000 for mode 7 */
Xint textsafe    =    0;    /* 0 = default, runup chgs to 1
X                  1 = yes
X                  2 = no, use 640x200
X                  3 = bios, yes plus use int 10h-1Ch
X                  4 = save, save entire image */
Xint text_type    =    1;    /* current mode's type of text:
X                    0  = real text, mode 3 (or 7)
X                    1  = 640x200x2, mode 6
X                    2  = some other mode, graphics */
Xint textrow     =    0;    /* for putstring(-1,...) */
Xint textcol     =    0;    /* for putstring(..,-1,...) */
Xint textrbase    =    0;    /* textrow is relative to this */
Xint textcbase    =    0;    /* textcol is relative to this */
Xextern unsigned char dacbox[];
Xint vesa_detect =    1;    /* set to 0 to disable VESA-detection */
X
X/*
X
X;        |--Adapter/Mode-Name------|-------Comments-----------|
X
X;        |------INT 10H------|Dot-|--Resolution---|
X;        |key|--AX---BX---CX---DX|Mode|--X-|--Y-|Color|
X*/
X
Xstruct videoinfo videotable[MAXVIDEOTABLE] = {
X    {"xfractint mode           ","                         ",
X     999, 0,     0,   0,   0,    19, 640, 480,  256},
X    {"unused  mode             ","                         ",
X     0, 0,     0,   0,   0,    0, 0, 0,  0},
X       };
X
Xvoid setforgraphics();
X
Xvoid
Xnullwrite(a,b,c)
Xint a,b,c;
X{}
X
Xint
Xnullread(a,b)
Xint a,b;
X{
X    return 0;
X}
X
Xvoid setnullvideo()
X{
X    dotwrite = nullwrite;
X    dotread = nullread;
X}
X
Xvoid normalineread();
Xvoid normaline();
X
X/*
X; ********************** Function setvideotext() ************************
X
X;       Sets video to text mode, using setvideomode to do the work.
X*/
Xvoid
Xsetvideotext() {
X    dotmode = 0;
X    setvideomode(3,0,0,0);
X}
X
X/*
X; **************** Function setvideomode(ax, bx, cx, dx) ****************
X;       This function sets the (alphanumeric or graphic) video mode
X;       of the monitor.   Called with the proper values of AX thru DX.
X;       No returned values, as there is no particular standard to
X;       adhere to in this case.
X
X;       (SPECIAL "TWEAKED" VGA VALUES:  if AX==BX==CX==0, assume we have a
X;       genuine VGA or register compatable adapter and program the registers
X;       directly using the coded value in DX)
X
X; Unix: We ignore ax,bx,cx,dx.  dotmode is the "mode" field in the video
X; table.  We use mode 19 for the X window.
X*/
Xvoid
Xsetvideomode(ax,bx,cx,dx)
Xint ax,bx,cx,dx;
X{
X    if (diskflag) {
X    enddisk();
X    }
X    if (videoflag) {
X    endvideo();
X    videoflag = 0;
X    }
X    goodmode = 1;
X    switch (dotmode) {
X    case 0: /* text */
X        clear();
X        /*
X        touchwin(curwin);
X        */
X        wrefresh(curwin);
X        break;
X    case 11:
X        startdisk();
X        dotwrite = writedisk;
X        dotread = readdisk;
X        lineread = normalineread;
X        linewrite = normaline;
X        break;
X    case 19: /* X window */
X        wclear(curwin); /* ???? */
X        putstring(0, 0, 0,
X            "Press operation key, or <Esc> to return to Main Menu");
X        wrefresh(curwin);
X        dotwrite = writevideo;
X        dotread = readvideo;
X        lineread = readvideoline;
X        linewrite = writevideoline;
X        videoflag = 1;
X        startvideo();
X        setforgraphics();
X        break;
X    default:
X        printf("Bad mode %d\n", dotmode);
X        exit(-1);
X    }
X    if (dotmode !=0) {
X    loaddac();
X    andcolor = colors-1;
X    boxcount =0;
X    }
X}
X
Xloaddac()
X{
X    readvideopalette();
X}
X
X
X/*
X; **************** Function getcolor(xdot, ydot) *******************
X
X;       Return the color on the screen at the (xdot,ydot) point
X*/
Xint
Xgetcolor(xdot,ydot)
Xint xdot,ydot;
X{
X    int x1,y1;
X    x1 = xdot+sxoffs;
X    y1 = ydot+syoffs;
X    if (x1<0 || y1<0 || x1>=sxdots || y1>=sydots) return 0;
X    return dotread(x1,y1);
X}
X
X/*
X; ************** Function putcolor(xdot, ydot, color) *******************
X
X;       write the color on the screen at the (xdot,ydot) point
X*/
Xvoid
Xputcolor(xdot,ydot,color)
Xint xdot,ydot,color;
X{
X    dotwrite(xdot+sxoffs,ydot+syoffs,color&andcolor);
X}
X
X/*
X; **************** Function movecursor(row, col)  **********************
X
X;       Move the cursor (called before printfs)
X*/
Xvoid
Xmovecursor(row,col)
Xint row, col;
X{
X    if (row==-1) {
X    row = textrow;
X    } else {
X    textrow = row;
X    }
X    if (col==-1) {
X    col = textcol;
X    } else {
X    textcol = col;
X    }
X    wmove(curwin,row,col);
X}
X
X/*
X; **************** Function keycursor(row, col)  **********************
X
X;       Subroutine to wait cx ticks, or till keystroke pending
X*/
Xkeycursor(row,col)
X{
X    int ch;
X    movecursor(row,col);
X    wrefresh(curwin);
X    waitkeypressed(0);
X    return getakey();
X}
X
X/*
X; PUTSTR.asm puts a string directly to video display memory. Called from C by:
X;    putstring(row, col, attr, string) where
X;         row, col = row and column to start printing.
X;         attr = color attribute.
X;         string = far pointer to the null terminated string to print.
X;    Written for the A86 assembler (which has much less 'red tape' than MASM)
X;    by Bob Montgomery, Orlando, Fla.             7-11-88
X;    Adapted for MASM 5.1 by Tim Wegner          12-11-89
X;    Furthur mucked up to handle graphics
X;       video modes by Bert Tyler                 1-07-90
X;    Reworked for:  row,col update/inherit;
X;       620x200x2 inverse video;  far ptr to string;
X;       fix to avoid scrolling when last posn chgd;
X;       divider removed;  newline ctl chars;  PB  9-25-90
X*/
Xvoid
Xputstring(row, col, attr, msg)
Xint row,col, attr;
XCHAR far *msg;
X{
X    int so=0;
X
X    if (row!=-1) textrow = row;
X    if (col!=-1) textcol = col;
X
X    if (attr & INVERSE || attr & BRIGHT) {
X    wstandout(curwin);
X    so = 1;
X    }
X    wmove(curwin,textrow+textrbase, textcol+textcbase);
X    while (1) {
X    if (*msg=='\0') break;
X    if (*msg=='\n') {
X        textcol = 0;
X        textrow++;
X        wmove(curwin,textrow+textrbase, textcol+textcbase);
X    } else {
X        char *ptr;
X        ptr = strchr(msg,'\n');
X        if (ptr==NULL) {
X        waddstr(curwin,msg);
X        break;
X        } else {
X        waddch(curwin,*msg);
X        }
X    }
X    msg++;
X    }
X    if (so) {
X    wstandend(curwin);
X    }
X
X    wrefresh(curwin);
X    fflush(stdout);
X    getyx(curwin,textrow,textcol);
X    textrow -= textrbase;
X    textcol -= textcbase;
X}
X
X/*
X; setattr(row, col, attr, count) where
X;         row, col = row and column to start printing.
X;         attr = color attribute.
X;         count = number of characters to set
X;         This routine works only in real color text mode.
X*/
Xvoid
Xsetattr(row, col, attr, count)
Xint row, col, attr, count;
X{
X    movecursor(row,col);
X}
X
X/*
X; **************** Function home()  ********************************
X
X;       Home the cursor (called before printfs)
X*/
Xvoid
Xhome()
X{
X    wmove(curwin,0,0);
X    textrow = 0;
X    textcol = 0;
X}
X
X
X/*
X; ************* Function scrollup(toprow, botrow) ******************
X
X;       Scroll the screen up (from toprow to botrow)
X*/
Xvoid
Xscrollup(top, bot)
Xint top,bot;
X{
X    wmove(curwin,top,0);
X    wdeleteln(curwin);
X    wmove(curwin,bot,0);
X    winsertln(curwin);
X    wrefresh(curwin);
X}
X
X/*
X; *************** Function spindac(direction, rstep) ********************
X
X;       Rotate the MCGA/VGA DAC in the (plus or minus) "direction"
X;       in "rstep" increments - or, if "direction" is 0, just replace it.
X*/
Xvoid
Xspindac(dir, inc)
Xint dir, inc;
X{
X    int i,top;
X    unsigned char tmp[3];
X    unsigned char *dacbot;
X    int len;
X    if (colors<16) return;
X    if (dir != 0 && rotate_lo<colors && rotate_lo<rotate_hi) {
X    top = rotate_hi>colors ? colors-1:rotate_hi;
X    dacbot = dacbox+3*rotate_lo;
X    len = (top-rotate_lo)*3*sizeof(unsigned char);
X    if (dir>0) {
X        for (i=0;i<inc;i++) {
X        bcopy(dacbot,tmp,3*sizeof(unsigned char));
X        bcopy(dacbot+3*sizeof(unsigned char),dacbot,len);
X        bcopy(tmp,dacbot+len,3*sizeof(unsigned char));
X        }
X    } else {
X        for (i=0;i<inc;i++) {
X        bcopy(dacbot+len,tmp,3*sizeof(unsigned char));
X        bcopy(dacbot,dacbot+3*sizeof(unsigned char),len);
X        bcopy(tmp,dacbot,3*sizeof(unsigned char));
X        }
X    }
X    }
X    writevideopalette();
X    delay(colors-daccount-1);
X}
X
X/*
X; ---- Help (Video) Support
X; ********* Functions setfortext() and setforgraphics() ************
X
X;       setfortext() resets the video for text mode and saves graphics data
X;       setforgraphics() restores the graphics mode and data
X;       setclear() clears the screen after setfortext()
X*/
Xvoid
Xsetfortext()
X{
X}
X
Xvoid
Xsetclear()
X{
X    wclear(curwin);
X    wrefresh(curwin);
X}
X
Xvoid
Xsetforgraphics()
X{
X    startvideo();
X    spindac(0,1);
X}
X
Xunsigned char *fontTab = NULL;
X
X/*
X; ************** Function findfont(n) ******************************
X
X;       findfont(0) returns far pointer to 8x8 font table if it can
X;                   find it, NULL otherwise;
X;                   nonzero parameter reserved for future use
X*/
XBYTE *
Xfindfont(fontparm)
Xint fontparm;
X{
X    if (fontTab==NULL) {
X    fontTab = xgetfont();
X    }
X    return (BYTE *)fontTab;
X}
X
X/*
X; ******************** Zoombox functions **************************
X*/
X
X/*
X * The IBM method is that boxx[],boxy[] is a set of locations, and boxvalues
X * is the values in these locations.
X * Instead of using this box save/restore technique, we'll put the corners
X * in boxx[0],boxy[0],1,2,3 and then use xor.
X */
X
Xvoid
Xdispbox()
X{
X    if (boxcount) {
X    setlinemode(1);
X    drawline(boxx[0],boxy[0],boxx[1],boxy[1]);
X    drawline(boxx[1],boxy[1],boxx[2],boxy[2]);
X    drawline(boxx[2],boxy[2],boxx[3],boxy[3]);
X    drawline(boxx[3],boxy[3],boxx[0],boxy[0]);
X    setlinemode(0);
X    xsync();
X    }
X}
X
Xvoid
Xclearbox()
X{
X    dispbox();
X}
X
Xint
XCheckForTPlus()
X{
X    return 0;
X}
X
X/*
X; Passing this routine 0 turns off shadow, nonzero turns it on.
X*/
Xint
XShadowVideo(on)
Xint on;
X{
X    return 0;
X}
X
Xint
XSetupShadowVideo()
X{
X    return 0;
X}
X
X/*
X; adapter_detect:
X;       This routine performs a few quick checks on the type of
X;       video adapter installed.
X;       It sets variables video_type and textsafe,
X;       and fills in a few bank-switching routines.
X*/
Xint done_detect = 0;
Xvoid
Xadapter_detect()
X{
X    if (done_detect) return;
X    done_detect = 1;
X    textsafe = 2;
X    if (colors==2) {
X    video_type = 100;
X    } else {
X    video_type = 101;
X    }
X}
X
X/*
X; **************** internal Read/Write-a-line routines *********************
X;
X;       These routines are called by out_line(), put_line() and get_line().
X*/
X
Xvoid
Xnormaline(y,x,lastx,pixels)
Xint x,y,lastx;
XBYTE *pixels;
X{
X    int i,width;
X    width = lastx-x+1;
X    for (i=0;i<width;i++) {
X    dotwrite(x+i,y,pixels[i]);
X    }
X}
X
Xvoid
Xnormalineread(y,x,lastx,pixels)
Xint x,y,lastx;
XBYTE *pixels;
X{
X    int i,width;
X    width = lastx-x+1;
X    for (i=0;i<width;i++) {
X    pixels[i] = dotread(x+i,y);
X    }
X}
X
X/*
X; *************** Function find_special_colors ********************
X
X;       Find the darkest and brightest colors in palette, and a medium
X;       color which is reasonably bright and reasonably grey.
X*/
Xvoid
Xfind_special_colors()
X{
X    int maxb = 0;
X    int minb = 99999;
X    int med = 0;
X    int maxgun, mingun;
X    int brt;
X    int i;
X
X    color_dark = 0;
X    color_medium = 7;
X    color_bright = 15;
X
X    if (colors==2) {
X    color_medium = 1;
X    color_bright = 1;
X    return;
X    }
X
X    if (!gotrealdac) return;
X
X    for (i=0;i<colors;i++) {
X    brt = dacbox[i*3+0]+dacbox[i*3+1]+dacbox[i*3+2];
X    if (brt>maxb) {
X        maxb = brt;
X        color_bright = i;
X    }
X    if (brt<minb) {
X        minb = brt;
X        color_dark = i;
X    }
X    if (brt<150 && brt>80) {
X        maxgun = mingun = dacbox[i*3+0];
X        if (dacbox[i*3+1]>dacbox[i*3+0]) {
X        maxgun = dacbox[i*3+1];
X        } else {
X        mingun = dacbox[i*3+1];
X        }
X        if(dacbox[i*3+2]>maxgun) maxgun = dacbox[i*3+2];
X        if(dacbox[i*3+2]<mingun) mingun = dacbox[i*3+2];
X        if (brt-(maxgun-mingun)/2>med) {
X        color_medium = i;
X        med = brt-(maxgun-mingun)/2;
X        }
X    }
X    }
X}
X
X/*
X; *************** Functions get_a_char, put_a_char ********************
X
X;       Get and put character and attribute at cursor
X;       Hi nybble=character, low nybble attribute. Text mode only
X*/
Xchar
Xget_a_char()
X{
X}
X
Xvoid
Xput_a_char(ch)
Xint ch;
X{
X}
X
X/*
X; ***Function get_line(int row,int startcol,int stopcol, unsigned char *pixels)
X
X;       This routine is a 'line' analog of 'getcolor()', and gets a segment
X;       of a line from the screen and stores it in pixels[] at one byte per
X;       pixel
X;       Called by the GIF decoder
X*/
X
Xvoid
Xget_line(row, startcol, stopcol, pixels)
Xint row,startcol,stopcol;
XBYTE *pixels;
X{
X    if (startcol+sxoffs>=sxdots||row+syoffs>=sydots) return;
X    lineread(row+syoffs,startcol+sxoffs,stopcol+sxoffs,pixels);
X}
X
X/*
X; ***Function put_line(int row,int startcol,int stopcol, unsigned char *pixels)
X
X;       This routine is a 'line' analog of 'putcolor()', and puts a segment
X;       of a line from the screen and stores it in pixels[] at one byte per
X;       pixel
X;       Called by the GIF decoder
X*/
X
Xvoid
Xput_line(row, startcol, stopcol, pixels)
Xint row, startcol, stopcol;
XBYTE *pixels;
X{
X    if (startcol+sxoffs>=sxdots||row+syoffs>sydots) return;
X    linewrite(row+syoffs,startcol+sxoffs,stopcol+sxoffs,pixels);
X}
X
X/*
X; ***************Function out_line(pixels,linelen) *********************
X
X;       This routine is a 'line' analog of 'putcolor()', and sends an
X;       entire line of pixels to the screen (0 <= xdot < xdots) at a clip
X;       Called by the GIF decoder
X*/
Xint
Xout_line(pixels, linelen)
XBYTE *pixels;
Xint linelen;
X{
X    if (rowcount+syoffs>=sydots) return 0;
X    linewrite(rowcount+syoffs,sxoffs,linelen+sxoffs-1,pixels);
X    rowcount++;
X    return 0;
X}
X
X/*
X; far move routine for savegraphics/restoregraphics
X*/
Xvoid
Xmovewords(len, fromptr, toptr)
Xint len;
XBYTE *fromptr, *toptr;
X{
X    bcopy(fromptr, toptr, len);
X}
X
Xvoid swapnormread() {}
Xvoid swapnormwrite() {}
X
X/*
X * Implement stack and unstack window functions by using multiple curses
X * windows.
X */
Xsavecurses(ptr)
XWINDOW **ptr;
X{
X    ptr[0] = curwin;
X    curwin = newwin(0,0,0,0);
X    touchwin(curwin);
X    wrefresh(curwin);
X}
X
Xrestorecurses(ptr)
XWINDOW **ptr;
X{
X    delwin(curwin);
X    curwin = ptr[0];
X    touchwin(curwin);
X    wrefresh(curwin);
X}
X
SHAR_EOF
$TOUCH -am 1028230193 video.c &&
chmod 0644 video.c ||
echo "restore of video.c failed"
set `wc -c video.c`;Wc_c=$1
if test "$Wc_c" != "15972"; then
    echo original size 15972, current size $Wc_c
fi
# ============= unix.c ==============
echo "x - extracting unix.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > unix.c &&
X/* Unix.c
X * This file contains compatibility routines.
X *
X * This file Copyright 1991 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <sys/time.h>
X#include <sys/types.h>
X#include <sys/file.h>
X#include <sys/stat.h>
X#include <string.h>
X#include <ctype.h>
X#include "port.h"
X
Xint iocount;
X
X/*
X *----------------------------------------------------------------------
X *
X * clock_ticks --
X *
X *      Return time in CLK_TCK ticks.
X *
X * Results:
X *      Time.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xlong
Xclock_ticks()
X{
X    struct timeval tim;
X    gettimeofday(&tim,NULL);
X    return tim.tv_sec*CLK_TCK + tim.tv_usec*CLK_TCK/1000000;
X}
X
X/* stub */
Xintdos() {}
X
X/*
X *----------------------------------------------------------------------
X *
X * kbhit --
X *
X *      Get a key.
X *
X * Results:
X *      1 if key, 0 otherwise.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xint
Xkbhit()
X{
X    return 0;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * stackavail --
X *
X *      Returns amout of stack available.
X *
X * Results:
X *      Available stack.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xlong
Xstackavail()
X{
X    return 8192;
X}
X
X#ifndef HAVESTRI
X/*
X *----------------------------------------------------------------------
X *
X * stricmp --
X *
X *      Compare strings, ignoring case.
X *
X * Results:
X *      -1,0,1.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xstricmp(s1, s2)
X    register char *s1, *s2;        /* Strings to compare. */
X{
X    int c1, c2;
X
X    while (1) {
X    c1 = *s1++;
X    c2 = *s2++;
X    if (isupper(c1)) c1 = tolower(c1);
X    if (isupper(c2)) c2 = tolower(c2);
X    if (c1 != c2) {
X        return c1 - c2;
X    }
X    if (c1 == 0) {
X        return 0;
X    }
X    }
X}
X/*
X *----------------------------------------------------------------------
X *
X * strnicmp --
X *
X *      Compare strings, ignoring case.  Maximum length is specified.
X *
X * Results:
X *      -1,0,1.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xint
Xstrnicmp(s1, s2, numChars)
X    register char *s1, *s2;        /* Strings to compare. */
X    register int numChars;        /* Max number of chars to compare. */
X{
X    register char c1, c2;
X
X    for ( ; numChars > 0; --numChars) {
X    c1 = *s1++;
X    c2 = *s2++;
X    if (isupper(c1)) c1 = tolower(c1);
X    if (isupper(c2)) c2 = tolower(c2);
X    if (c1 != c2) {
X        return c1 - c2;
X    }
X    if (c1 == '\0') {
X        return 0;
X    }
X    }
X    return 0;
X}
X#endif
X
X/*
X *----------------------------------------------------------------------
X *
X * strlwr --
X *
X *      Convert string to lower case.
X *
X * Results:
X *      The string.
X *
X * Side effects:
X *      Modifies the string.
X *
X *----------------------------------------------------------------------
X */
Xchar *
Xstrlwr(s)
X    char *s;
X{
X    register char *sptr=s;
X    while (*sptr != '\0') {
X    if (isupper(*sptr)) {
X        *sptr = tolower(*sptr);
X    }
X    sptr++;
X    }
X    return s;
X}
X/*
X *----------------------------------------------------------------------
X *
X * strupr --
X *
X *      Convert string to upper case.
X *
X * Results:
X *      The string.
X *
X * Side effects:
X *      Modifies the string.
X *
X *----------------------------------------------------------------------
X */
Xchar *
Xstrupr(s)
X    char *s;
X{
X    register char *sptr=s;
X    while (*sptr != '\0') {
X    if (islower(*sptr)) {
X        *sptr = toupper(*sptr);
X    }
X    sptr++;
X    }
X    return s;
X}
X/*
X *----------------------------------------------------------------------
X *
X * memicmp --
X *
X *      Compare memory (like memcmp), but ignoring case.
X *
X * Results:
X *      -1,0,1.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xint
Xmemicmp(s1, s2, n)
X        register char *s1, *s2;
X        register n;
X{
X        register char c1,c2;
X        while (--n >= 0)
X        c1 = *s1++;
X        if (isupper(c1)) c1 = tolower(c1);
X        c2 = *s2++;
X        if (isupper(c2)) c2 = tolower(c2);
X                if (c1 != c2)
X                        return (c1 - c2);
X        return (0);
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * findpath --
X *
X *      Find where a file is.
X *    We return filename if it is an absolute path.
X *    Otherwise we first try FRACTDIR/filename, SRCDIR/filename,
X *      and then ./filename.
X *
X * Results:
X *      Returns full pathname in fullpathname.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xfindpath(filename, fullpathname)
Xchar *filename, *fullpathname;
X{
X    int fd;
X    char *fractdir;
X
X    if (filename[0]=='/') {
X    strcpy(fullpathname,filename);
X    return;
X    }
X    fractdir = getenv("FRACTDIR");
X    if (fractdir != NULL) {
X    strcpy(fullpathname,fractdir);
X    strcat(fullpathname,"/");
X    strcat(fullpathname,filename);
X    fd = open(fullpathname,O_RDONLY);
X    if (fd != -1) {
X        close(fd);
X        return;
X    }
X    }
X    strcpy(fullpathname,SRCDIR);
X    strcat(fullpathname,"/");
X    strcat(fullpathname,filename);
X    fd = open(fullpathname,O_RDONLY);
X    if (fd != -1) {
X    close(fd);
X    return;
X    }
X    strcpy(fullpathname,"./");
X    strcat(fullpathname,filename);
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * filelength --
X *
X *      Find length of a file.
X *
X * Results:
X *      Length.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xint filelength(fd)
Xint fd;
X{
X    struct stat buf;
X    fstat(fd,&buf);
X    return buf.st_size;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * splitpath --
X *
X *      This is the splitpath code from prompts.c
X *
X * Results:
X *      Returns drive, dir, base, and extension.
X *
X * Side effects:
X *      None.
X *
X *----------------------------------------------------------------------
X */
Xsplitpath(char *template,char *drive,char *dir,char *fname,char *ext)
X{
X   int length;
X   int len;
X   int offset;
X   char *tmp;
X
X   if(drive)
X      drive[0] = 0;
X   if(dir)
X      dir[0]   = 0;
X   if(fname)
X      fname[0] = 0;
X   if(ext)
X      ext[0]   = 0;
X
X   if((length = strlen(template)) == 0)
X      return(0);
X   offset = 0;
X
X   /* get drive */
X   if(length >= 2)
X      if(template[1] == ':')
X      {
X     if(drive)
X     {
X        drive[0] = template[offset++];
X        drive[1] = template[offset++];
X        drive[2] = 0;
X     }
X     else
X     {
X        offset++;
X        offset++;
X     }
X      }
X
X   /* get dir */
X   if(offset < length)
X   {
X      tmp = strrchr(template,SLASHC);
X      if(tmp)
X      {
X     tmp++;  /* first character after slash */
X     len = tmp - &template[offset];
X     if(len >=0 && len < 80 && dir)
X        strncpy(dir,&template[offset],len);
X     if(len < 80 && dir)
X        dir[len] = 0;
X     offset += len;
X      }
X   }
X   else
X      return(0);
X
X   /* get fname */
X   if(offset < length)
X   {
X      tmp = strrchr(template,'.');
X      if(tmp < strrchr(template,SLASHC) || tmp < strrchr(template,':'))
X     tmp = 0; /* in this case the '.' must be a directory */
X      if(tmp)
X      {
X     tmp++; /* first character past "." */
X     len = tmp - &template[offset];
X     if((len > 0) && (offset+len < length) && fname)
X     {
X        strncpy(fname,&template[offset],len);
X        fname[len] = 0;
X     }
X     offset += len;
X     if((offset < length) && ext)
X        strcpy(ext,&template[offset]);
X      }
X      else if((offset < length) && fname)
X     strcpy(fname,&template[offset]);
X   }
X   return(0);
X}
X
X_splitpath(char *template,char *drive,char *dir,char *fname,char *ext)
X{
X    return splitpath(template,drive,dir,fname,ext);
X}
X
X/* SGI lacks ftime.  This ftime simulation routine is from Frank Chen */
X#ifdef FTIME
Xvoid ftime(tp)
Xstruct timeb    *tp;
X{
X        struct timeval  timep;
X        struct timezone timezp;
X
X        if ( gettimeofday(&timep,&timezp) != 0) {
X                perror("error in gettimeofday");
X                exit(0);
X        }
X        tp->time = timep.tv_sec;
X        tp->millitm = timep.tv_usec/1000;
X        tp->timezone = timezp.tz_minuteswest;
X        tp->dstflag = timezp.tz_dsttime;
X}
X#endif
SHAR_EOF
$TOUCH -am 1028230193 unix.c &&
chmod 0644 unix.c ||
echo "restore of unix.c failed"
set `wc -c unix.c`;Wc_c=$1
if test "$Wc_c" != "8340"; then
    echo original size 8340, current size $Wc_c
fi
# ============= unixscr.c ==============
echo "x - extracting unixscr.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > unixscr.c &&
X/* Unixscr.c
X * This file contains routines for the Unix port of fractint.
X * It uses the current window for text and creates an X window for graphics.
X *
X * This file Copyright 1991 Ken Shirriff.  It may be used according to the
X * fractint license conditions, blah blah blah.
X *
X * Some of the X stuff is based on xloadimage by Jim Frost.
X * The FindWindowRoot routine is from ssetroot by Tom LaStrange.
X * Other root window stuff is based on xmartin, by Ed Kubaitis.
X * Some of the colormap stuff is from Mike Yang ([e-mail]).
X * Some of the zoombox code is from Bill Broadley.
X * David Sanderson straightened out a bunch of include file problems.
X */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <curses.h>
X#include <X11/Xlib.h>
X#include <X11/keysym.h>
X#include <X11/Xatom.h>
X#include <signal.h>
X#include <sys/types.h>
X#ifdef _AIX
X#include <sys/select.h>
X#endif
X#include <sys/time.h>
X#include <sys/ioctl.h>
X#ifdef FPUERR
X#include <floatingpoint.h>
X#endif
X#ifdef __hpux
X#include <sys/file.h>
X#endif
X#include <fcntl.h>
X#include "fractint.h"
X#include "prototyp.h"
X#include "helpdefs.h"
X#ifdef linux
X#define FNDELAY O_NDELAY
X#endif
X
X/* Check if there is a character waiting for us.  */
X#define input_pending() (ioctl(0,FIONREAD,&iocount),(int)iocount)
X
X/* external variables (set in the FRACTINT.CFG file, but findable here */
X
Xextern    int    dotmode;        /* video access method (= 19)       */
Xextern    int    sxdots, sydots;     /* total # of dots on the screen   */
Xextern    int    sxoffs, syoffs;     /* offset of drawing area          */
Xextern    int    colors;         /* maximum colors available       */
Xextern    int    initmode;
Xextern    int    adapter;
Xextern    int    gotrealdac;
Xextern    int    inside_help;
Xextern  float    finalaspectratio;
Xextern  float    screenaspect;
Xextern    int    lookatmouse;
X
Xextern struct videoinfo videotable[];
X
X/* the video-palette array (named after the VGA adapter's video-DAC) */
X
Xextern unsigned char dacbox[256][3];
X
Xextern void drawbox();
X
Xextern int text_type;
Xextern int helpmode;
Xextern int rotate_hi;
X
Xextern void fpe_handler();
X
Xextern WINDOW *curwin;
X
Xstatic int onroot = 0;
Xstatic int fullscreen = 0;
Xstatic int sharecolor = 0;
Xstatic int privatecolor = 0;
Xstatic int fixcolors = 0;
Xstatic int sync = 0; /* Run X events synchronously (debugging) */
Xint slowdisplay = 0; /* We have a slow display, so don't print too much */
Xstatic int simple_input = 0; /* Use simple input (debugging) */
Xstatic char *Xdisplay = "";
Xstatic char *Xgeometry = NULL;
X
Xstatic int unixDisk = 0; /* Flag if we use the disk video mode */
X
Xstatic int old_fcntl;
X
Xstatic int doesBacking;
X
X/*
X * The pixtab stuff is so we can map from fractint pixel values 0-n to
X * the actual color table entries which may be anything.
X */
Xstatic int usepixtab = 0;
Xstatic unsigned long pixtab[256];
Xstatic int ipixtab[256];
X
Xstatic int fastmode = 0; /* Don't draw pixels 1 at a time */
Xstatic int alarmon = 0; /* 1 if the refresh alarm is on */
Xstatic int doredraw = 0; /* 1 if we have a redraw waiting */
X
X/* Static routines */
Xstatic Window FindRootWindow(void);
Xstatic Window pr_dwmroot(Display *dpy, Window pwin);
Xstatic int errhand(Display *dp, XErrorEvent *xe);
Xstatic int getachar(void);
Xstatic int handleesc(void);
Xstatic int translatekey(int ch);
Xstatic int xcmapstuff(void);
Xstatic int xhandleevents(void);
Xstatic void RemoveRootPixmap(void);
Xstatic void doneXwindow(void);
Xstatic void initdacbox(void);
Xstatic void setredrawscreen(void);
Xstatic void clearXwindow(void);
X#ifdef FPUERR
Xstatic void continue_hdl(int sig, int code, struct sigcontext *scp,
X    char *addr);
X#endif
X
Xstatic int mousefkey[4][4] /* [button][dir] */ = {
X    {RIGHT_ARROW,LEFT_ARROW,DOWN_ARROW,UP_ARROW},
X    {0,0,PAGE_DOWN,PAGE_UP},
X    {CTL_PLUS,CTL_MINUS,CTL_DEL,CTL_INSERT},
X    {CTL_END,CTL_HOME,CTL_PAGE_DOWN,CTL_PAGE_UP}
X};
X
X/*
X *----------------------------------------------------------------------
X *
X * unixarg --
X *
X *    See if we want to do something with the argument.
X *
X * Results:
X *    Returns 1 if we parsed the argument.
X *
X * Side effects:
X *    Increments i if we use more than 1 argument.
X *
X *----------------------------------------------------------------------
X */
Xint
Xunixarg(argc,argv,i)
Xint argc;
Xchar **argv;
Xint *i;
X{
X    if (strcmp(argv[*i],"-display")==0 && (*i)+1<argc) {
X    Xdisplay = argv[(*i)+1];
X    (*i)++;
X    return 1;
X    } else if (strcmp(argv[*i],"-fullscreen")==0) {
X    fullscreen = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-disk")==0) {
X    unixDisk = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-onroot")==0) {
X    onroot = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-share")==0) {
X    sharecolor = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-fast")==0) {
X    fastmode = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-simple")==0) {
X    simple_input = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-slowdisplay")==0) {
X    slowdisplay = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-sync")==0) {
X    sync = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-private")==0) {
X    privatecolor = 1;
X    return 1;
X    } else if (strcmp(argv[*i],"-fixcolors")==0 && *i+1<argc) {
X    fixcolors = atoi(argv[(*i)+1]);
X    (*i)++;
X    return 1;
X    } else if (strcmp(argv[*i],"-geometry")==0 && *i+1<argc) {
X    Xgeometry = argv[(*i)+1];
X    (*i)++;
X    return 1;
X    } else {
X    return 0;
X    }
X}
X/*
X *----------------------------------------------------------------------
X *
X * UnixInit --
X *
X *    Initialize the windows and stuff.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Initializes windows.
X *
X *----------------------------------------------------------------------
X */
Xvoid
XUnixInit()
X{
X    /*
X     * Check a bunch of important conditions
X     */
X    if (sizeof(short) != 2) {
X    fprintf(stderr,"Error: need short to be 2 bytes\n");
X    exit(-1);
X    }
X    if (sizeof(long) < sizeof(FLOAT4)) {
X    fprintf(stderr,"Error: need sizeof(long)>=sizeof(FLOAT4)\n");
X    exit(-1);
X    }
X
X    initscr();
X    curwin = stdscr;
X    cbreak();
X    noecho();
X
X    if (standout()) {
X    text_type = 1;
X    standend();
X    } else {
X    text_type = 1;
X    }
X
X    signal(SIGINT,goodbye);
X    signal(SIGFPE, fpe_handler);
X    /*
X    signal(SIGTSTP,goodbye);
X    */
X#ifdef FPUERR
X    signal(SIGABRT,SIG_IGN);
X    /*
X        setup the IEEE-handler to forget all common ( invalid,
X        divide by zero, overflow ) signals. Here we test, if
X        such ieee trapping is supported.
X    */
X    if (ieee_handler("set","common",continue_hdl) != 0 )
X        printf("ieee trapping not supported here \n");
X#endif
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * UnixDone --
X *
X *    Cleanup windows and stuff.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Cleans up.
X *
X *----------------------------------------------------------------------
X */
X
Xvoid
XUnixDone()
X{
X    if (!unixDisk) {
X    doneXwindow();
X    }
X    if (!simple_input) {
X    fcntl(0,F_SETFL,old_fcntl);
X    }
X    mvcur(0,COLS-1, LINES-1,0);
X    nocbreak();
X    echo();
X    endwin();
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * errhand --
X *
X *    Called on an X server error.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Prints the error message.
X *
X *----------------------------------------------------------------------
X */
Xstatic int errhand(dp,xe)
XDisplay *dp;
XXErrorEvent *xe;
X{
X        char buf[200];
X        fflush(stdout);
X        printf("X Error: %d %d %d %d\n",xe->type,xe->error_code,
X        xe->request_code, xe->minor_code);
X        XGetErrorText(dp,xe->error_code,buf,200);
X        printf("%s\n",buf);
X}
X
X#ifdef FPUERR
X/*
X *----------------------------------------------------------------------
X *
X * continue_hdl --
X *
X *    Handle an IEEE fpu error.
X *    This routine courtesy of Ulrich Hermes
X *    <[e-mail]>
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Clears flag.
X *
X *----------------------------------------------------------------------
X */
Xstatic void
Xcontinue_hdl(sig,code,scp,addr)
Xint sig, code;
X
Xstruct sigcontext *scp;
Xchar *addr;
X
X{
X    int i;
X    char out[20];
X    /*        if you want to get all messages enable this statement.    */
X    /*  printf("ieee exception code %x occurred at pc %X\n",code,scp->sc_pc); */
X    /*    clear all excaption flags                      */
X    i = ieee_flags("clear","exception","all",out);
X}
X#endif
X
X#define DEFX 640
X#define DEFY 480
X#define DEFXY "640x480+0+0"
X
Xstatic Display *Xdp = NULL;
Xstatic Window Xw;
Xstatic GC Xgc = NULL;
Xstatic Visual *Xvi;
Xstatic Screen *Xsc;
Xstatic Colormap    Xcmap;
Xstatic int Xdepth;
Xstatic XImage *Ximage =NULL;
Xstatic char *Xdata;
Xstatic int Xdscreen;
Xstatic Pixmap    Xpixmap = 0;
Xstatic int Xwinwidth=DEFX,Xwinheight=DEFY;
Xstatic Window Xroot;
Xstatic int xlastcolor = -1;
Xstatic int xlastfcn = GXcopy;
Xstatic BYTE *pixbuf = NULL;
X
X/*
X *----------------------------------------------------------------------
X *
X * initUnixWindow --
X *
X *    Make the X window.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Makes window.
X *
X *----------------------------------------------------------------------
X */
X
Xvoid
XinitUnixWindow()
X{
X    XSetWindowAttributes Xwatt;
X    XGCValues Xgcvals;
X    int Xwinx=0,Xwiny=0;
X    int i;
X
X    if (Xdp != NULL) {
X       /* We are already initialized */
X       return;
X    }
X
X    if (!simple_input) {
X    old_fcntl = fcntl(0,F_GETFL);
X    fcntl(0,F_SETFL,FNDELAY);
X    }
X
X    /*
X    initmode = 0;
X    */
X    adapter = 0;
X
X    /* We have to do some X stuff even for disk video, to parse the geometry
X     * string */
X
X    if (unixDisk) {
X    int offx, offy;
X    fastmode = 0;
X    gotrealdac=1;
X    colors = 256;
X    for (i=0;i<colors;i++) {
X        pixtab[i] = i;
X        ipixtab[i] = i;
X    }
X    if (fixcolors>0) {
X        colors = fixcolors;
X    }
X    if (Xgeometry) {
X        XParseGeometry(Xgeometry, &offx, &offy, (unsigned int *)&Xwinwidth,
X            (unsigned int *)&Xwinheight);
X    }
X    sxdots = Xwinwidth;
X    sydots = Xwinheight;
X    } else {
X    Xdp = XOpenDisplay(Xdisplay);
X    if (Xdp==NULL) {
X        fprintf(stderr,"Could not open display %s\n",Xdisplay);
X        fprintf(stderr,"Note: xfractint can run without X in -disk mode\n");
X        UnixDone();
X        exit(-1);
X    }
X    Xdscreen = XDefaultScreen(Xdp);
X    if (Xgeometry && !onroot) {
X        XGeometry(Xdp, Xdscreen, Xgeometry, DEFXY, 0, 1, 1, 0, 0,
X            &Xwinx, &Xwiny, &Xwinwidth, &Xwinheight);
X    }
X    if (sync) {
X        XSynchronize(Xdp,True);
X    }
X    XSetErrorHandler(errhand);
X    Xsc = ScreenOfDisplay(Xdp,Xdscreen);
X    Xvi = XDefaultVisualOfScreen(Xsc);
X    Xdepth = DefaultDepth(Xdp,Xdscreen);
X    colors = 1<<Xdepth;
X    if (colors>256) colors = 256;
X    if (fixcolors>0) {
X        colors = fixcolors;
X    }
X    switch (Xvi->class) {
X        case DirectColor:
X        case PseudoColor:
X        case GrayScale:
X        gotrealdac=1;
X        break;
X        case TrueColor:
X        case StaticColor:
X        case StaticGray:
X        default:
X        gotrealdac=0;
X        break;
X    }
X
X    if (fullscreen || onroot) {
X        Xwinwidth = DisplayWidth(Xdp,Xdscreen);
X        Xwinheight = DisplayHeight(Xdp,Xdscreen);
X    }
X    sxdots = Xwinwidth;
X    sydots = Xwinheight;
X
X    Xwatt.background_pixel = BlackPixelOfScreen(Xsc);
X    Xwatt.bit_gravity = StaticGravity;
X    doesBacking = DoesBackingStore(Xsc);
X    if (doesBacking) {
X        Xwatt.backing_store = Always;
X    } else {
X        Xwatt.backing_store = NotUseful;
X    }
X    if (onroot) {
X        Xroot = FindRootWindow();
X        RemoveRootPixmap();
X        /*
X        XSetWindowBackground(Xdp,Xroot);
X        */
X        Xgc = XCreateGC(Xdp,Xroot,0,&Xgcvals);
X        Xpixmap = XCreatePixmap(Xdp,Xroot,Xwinwidth,Xwinheight,Xdepth);
X        Xw = Xroot;
X        XFillRectangle(Xdp,Xpixmap,Xgc,0,0,Xwinwidth,Xwinheight);
X        XSetWindowBackgroundPixmap(Xdp,Xroot,Xpixmap);
X    } else {
X        Xroot = DefaultRootWindow(Xdp);
X        Xw = XCreateWindow(Xdp, Xroot, Xwinx, Xwiny, Xwinwidth,
X            Xwinheight, 0, Xdepth, InputOutput, CopyFromParent,
X            CWBackPixel|CWBitGravity|CWBackingStore, &Xwatt);
X        XStoreName(Xdp,Xw,"xfractint");
X        Xgc = XCreateGC(Xdp,Xw,0,&Xgcvals);
X    }
X    colors = xcmapstuff();
X    if (rotate_hi==255) rotate_hi = colors-1;
X    if (!onroot) {
X        XSetBackground(Xdp,Xgc,pixtab[0]);
X        XSetForeground(Xdp,Xgc,pixtab[1]);
X        Xwatt.background_pixel = pixtab[0];
X        XChangeWindowAttributes(Xdp,Xw,CWBackPixel,&Xwatt);
X        XMapWindow(Xdp,Xw);
X    }
X    if (onroot) {
X        XSelectInput(Xdp,Xw,KeyPressMask|KeyReleaseMask|ExposureMask);
X    } else {
X        XSelectInput(Xdp,Xw,KeyPressMask|KeyReleaseMask|ExposureMask|
X            ButtonPressMask|ButtonReleaseMask|PointerMotionMask);
X    }
X
X    resizeWindow();
X    xsync();
X    }
X
X    initdacbox();
X
X    videotable[0].xdots = sxdots;
X    videotable[0].ydots = sydots;
X    videotable[0].colors = colors;
X    videotable[0].dotmode = (unixDisk) ? 11 : 19;
X}
X/*
X *----------------------------------------------------------------------
X *
X * doneXwindow --
X *
X *    Clean up the X stuff.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Frees window, etc.
X *
X *----------------------------------------------------------------------
X */
Xstatic void
XdoneXwindow()
X{
X    if (Xdp==NULL) {
X    return;
X    }
X    if (Xgc) {
X    XFreeGC(Xdp,Xgc);
X    }
X    if (Xpixmap) {
X    XFreePixmap(Xdp,Xpixmap);
X    Xpixmap = (Pixmap)NULL;
X    }
X    XFlush(Xdp);
X    /*
X    XCloseDisplay(Xdp);
X    */
X    Xdp = NULL;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * clearXwindow --
X *
X *    Clears X window.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Clears window.
X *
X *----------------------------------------------------------------------
X */
Xstatic void
XclearXwindow()
X{
X    char *ptr;
X    int i,len;
X    if (pixtab[0] != 0) {
X    /*
X     * Initialize image to pixtab[0].
X     */
X    if (colors==2) {
X        for (i=0;i<Ximage->bytes_per_line;i++) {
X        Ximage->data[i] = 0xff;
X        }
X    } else {
X        for (i=0;i<Ximage->bytes_per_line;i++) {
X        Ximage->data[i] = pixtab[0];
X        }
X    }
X    for (i=1;i<Ximage->height;i++) {
X        bcopy(Ximage->data,Ximage->data+i*Ximage->bytes_per_line,
X        Ximage->bytes_per_line);
X    }
X    } else {
X    /*
X     * Initialize image to 0's.
X     */
X    bzero(Ximage->data,Ximage->bytes_per_line*Ximage->height);
X    }
X    xlastcolor = -1;
X    XSetForeground(Xdp, Xgc, pixtab[0]);
X    if (onroot) {
X    XFillRectangle(Xdp,Xpixmap,Xgc,0,0,Xwinwidth,Xwinheight);
X    }
X    XFillRectangle(Xdp,Xw,Xgc,0,0,Xwinwidth,Xwinheight);
X    xsync();
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * initdacbox --
X *
X * Put something nice in the dac.
X *
X * The conditions are:
X *    Colors 1 and 2 should be bright so ifs fractals show up.
X *    Color 15 should be bright for lsystem.
X *    Color 1 should be bright for bifurcation.
X *    Colors 1,2,3 should be distinct for periodicity.
X *    The color map should look good for mandelbrot.
X *    The color map should be good if only 128 colors are used.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Loads the dac.
X *
X *----------------------------------------------------------------------
X */
Xstatic void
Xinitdacbox()
X{
X    int i;
X    if (colors==2) {
X    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
X    dacbox[1][0] = dacbox[1][1] = dacbox[1][2] = 63;
X    } else {
X    for (i=0;i<256;i++) {
X            dacbox[i][0] = (i>>5)*8+7;
X            dacbox[i][1] = (((i+16)&28)>>2)*8+7;
X            dacbox[i][2] = (((i+2)&3))*16+15;
X    }
X    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
X    dacbox[1][0] = dacbox[1][1] = dacbox[1][2] = 63;
X    dacbox[2][0] = 47; dacbox[2][1] = dacbox[2][2] = 63;
X    }
X    writevideopalette();
X}
X
X
Xint startvideo()
X{
X    clearXwindow();
X    return(0);
X}
X
Xint endvideo()
X{
X    return(0);                /* set flag: video ended */
X
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * resizeWindow --
X *
X *    Look after resizing the window if necessary.
X *
X * Results:
X *    Returns 1 for resize, 0 for no resize.
X *
X * Side effects:
X *    May reallocate data structures.
X *
X *----------------------------------------------------------------------
X */
Xint
XresizeWindow()
X{
X    static int oldx = -1, oldy = -1;
X    int junki;
X    unsigned int junkui;
X    Window *junkw;
X    unsigned int width, height;
X    int Xmwidth;
X    Status status;
X
X    if (unixDisk) return 0;
X
X    XGetGeometry(Xdp,Xw,&junkw,&junki, &junki, &width, &height,
X        &junkui, &junkui);
X
X    if (oldx != width || oldy != height) {
X    sxdots = width;
X    sydots = height;
X    videotable[0].xdots = sxdots;
X    videotable[0].ydots = sydots;
X    oldx = sxdots;
X    oldy = sydots;
X    Xwinwidth = sxdots;
X    Xwinheight = sydots;
X    screenaspect = sydots/(float)sxdots;
X    finalaspectratio = screenaspect;
X    Xmwidth = (Xdepth > 1)? sxdots: (1 + sxdots/8);
X    if (pixbuf != NULL) {
X        free(pixbuf);
X    }
X    pixbuf = (BYTE *) malloc(Xwinwidth *sizeof(BYTE));
X    if (Ximage != NULL) {
X        free(Ximage->data);
X        XDestroyImage(Ximage);
X    }
X    Ximage = XCreateImage(Xdp,Xvi,Xdepth, ZPixmap, 0, NULL, sxdots,
X        sydots,8, Xmwidth);
X    if (Ximage == NULL) {
X        printf("XCreateImage failed\n");
X        UnixDone();
X        exit(-1);
X    }
X    Ximage->data = malloc(Ximage->bytes_per_line * Ximage->height);
X    if (Ximage->data==NULL) {
X        fprintf(stderr,"Malloc failed: %d\n", Ximage->bytes_per_line *
X            Ximage->height);
X        exit(-1);
X    }
X    clearXwindow();
X    return 1;
X    } else {
X    return 0;
X    }
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * xcmapstuff --
X *
X *    Set up the colormap appropriately
X *
X * Results:
X *    Number of colors.
X *
X * Side effects:
X *    Sets colormap.
X *
X *----------------------------------------------------------------------
X */
Xstatic int
Xxcmapstuff()
X{
X    int ncells,i,powr;
X
X    if (onroot) {
X    privatecolor = 0;
X    }
X    for (i=0;i<colors;i++) {
X    pixtab[i] = i;
X    ipixtab[i] = 999;
X    }
X    if (!gotrealdac) {
X    } else if (sharecolor) {
X    gotrealdac = 0;
X    } else if (privatecolor) {
X    Xcmap = XCreateColormap(Xdp,Xw,Xvi,AllocAll);
X    XSetWindowColormap(Xdp,Xw,Xcmap);
X    } else {
X    Xcmap = DefaultColormap(Xdp,Xdscreen);
X    for (powr=Xdepth;powr>=1;powr--) {
X        ncells = 1<<powr;
X        if (ncells>colors) continue;
X        if (XAllocColorCells(Xdp,Xcmap,False,NULL,0,pixtab,
X            (unsigned int)ncells)) {
X        colors = ncells;
X        printf("%d colors\n",colors);
X        usepixtab = 1;
X        break;
X        }
X    }
X    if (!usepixtab) {
X        printf("Couldn't allocate any colors\n");
X        gotrealdac = 0;
X    }
X    }
X    for (i=0;i<colors;i++) {
X    ipixtab[pixtab[i]] = i;
X    }
X    /* We must make sure if any color uses position 0, that it is 0.
X     * This is so we can clear the image with bzero.
X     * So, suppose fractint 0 = cmap 42, cmap 0 = fractint 55.
X     * Then want fractint 0 = cmap 0, cmap 42 = fractint 55.
X     * I.e. pixtab[55] = 42, ipixtab[42] = 55.
X     */
X    if (ipixtab[0] == 999) {
X    ipixtab[0] = 0;
X    } else if (ipixtab[0] != 0) {
X    int other;
X    other = ipixtab[0];
X    pixtab[other] = pixtab[0];
X    ipixtab[pixtab[other]] = other;
X    pixtab[0] = 0;
X    ipixtab[0] = 0;
X    }
X
X    if (!gotrealdac && colors==2 && BlackPixelOfScreen(Xsc)!=0) {
X    pixtab[0] = ipixtab[0] = 1;
X    pixtab[1] = ipixtab[1] = 0;
X    usepixtab = 1;
X    }
X
X    return colors;
X}
X/*
X *----------------------------------------------------------------------
X *
X * writevideoline --
X *
X *    Write a line of pixels to the screen.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Draws pixels.
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xwritevideoline(y,x,lastx,pixels)
Xint x,y,lastx;
XBYTE *pixels;
X{
X    int width;
X    int i;
X    BYTE *pixline;
X
X#if 1
X    if (x==lastx) {
X    writevideo(x,y,pixels[0]);
X    return;
X    }
X    width = lastx-x+1;
X    if (usepixtab) {
X    for (i=0;i<width;i++) {
X        pixbuf[i] = pixtab[pixels[i]];
X    }
X    pixline = pixbuf;
X    } else {
X    pixline = pixels;
X    }
X    for (i=0;i<width;i++) {
X    XPutPixel(Ximage,x+i,y,pixline[i]);
X    }
X    if (fastmode==1 && helpmode != HELPXHAIR) {
X    if (!alarmon) {
X        schedulealarm(0);
X    }
X    } else {
X    XPutImage(Xdp,Xw,Xgc,Ximage,x,y,x,y,width,1);
X    if (onroot) {
X        XPutImage(Xdp,Xpixmap,Xgc,Ximage,x,y,x,y,width,1);
X    }
X    }
X#else
X    width = lastx-x+1;
X    for (i=0;i<width;i++) {
X    writevideo(x+i,y,pixels[i]);
X    }
X#endif
X}
X/*
X *----------------------------------------------------------------------
X *
X * readvideoline --
X *
X *    Reads a line of pixels from the screen.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Gets pixels
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xreadvideoline(y,x,lastx,pixels)
Xint x,y,lastx;
XBYTE *pixels;
X{
X    int i,width;
X    width = lastx-x+1;
X    for (i=0;i<width;i++) {
X    pixels[i] = readvideo(x+i,y);
X    }
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * writevideo --
X *
X *    Write a point to the screen
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Draws point.
X *
X *----------------------------------------------------------------------
X */
Xvoid writevideo(int x, int y, int color)
X{
X#if DEBUG /* Debugging checks */
X    if (color>=colors || color < 0) {
X    printf("Color %d too big %d\n", color, colors);
X    }
X    if (x>=sxdots || x<0 || y>=sydots || y<0) {
X    printf("Bad coord %d %d\n", x,y);
X    }
X#endif
X    if (xlastcolor != color) {
X    XSetForeground(Xdp,Xgc,pixtab[color]);
X    xlastcolor = color;
X    }
X    XPutPixel(Ximage,x,y,pixtab[color]);
X    if (fastmode==1 && helpmode != HELPXHAIR) {
X    if (!alarmon) {
X        schedulealarm(0);
X    }
X    } else {
X    XDrawPoint(Xdp,Xw,Xgc,x,y);
X    if (onroot) {
X        XDrawPoint(Xdp,Xpixmap,Xgc,x,y);
X    }
X    }
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * readvideo --
X *
X *    Read a point from the screen
X *
X * Results:
X *    Value of point.
X *
X * Side effects:
X *    None.
X *
X *----------------------------------------------------------------------
X */
Xint readvideo(int x, int y)
X{
X    return ipixtab[XGetPixel(Ximage,x,y)];
X}
X
XXColor cols[256];
X
X/*
X *----------------------------------------------------------------------
X *
X * readvideopalette --
X *    Reads the current video palette into dacbox.
X *
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Fills in dacbox.
X *
X *----------------------------------------------------------------------
X */
Xint readvideopalette()
X{
X
X    int i;
X    if (gotrealdac==0) return -1;
X    for (i=0;i<256;i++) {
X    dacbox[i][0] = cols[i].red/1024;
X    dacbox[i][1] = cols[i].green/1024;
X    dacbox[i][2] = cols[i].blue/1024;
X    }
X    return 0;
X
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * writevideopalette --
X *    Writes dacbox into the video palette.
X *
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Changes the displayed colors.
X *
X *----------------------------------------------------------------------
X */
Xint writevideopalette()
X{
X    int i;
X
X    if (!gotrealdac) return -1;
X    for(i=0;i<256;i++) {
X    cols[i].pixel = pixtab[i];
X    cols[i].flags = DoRed | DoGreen | DoBlue;
X    cols[i].red = dacbox[i][0]*1024;
X    cols[i].green = dacbox[i][1]*1024;
X    cols[i].blue = dacbox[i][2]*1024;
X    }
X    if (!unixDisk) {
X    XStoreColors(Xdp,Xcmap,cols,colors);
X    XFlush(Xdp);
X    }
X    return 0;
X
X}
X/*
X *----------------------------------------------------------------------
X *
X * setlinemode --
X *
X *    Set line mode to 0=draw or 1=xor.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Sets mode.
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xsetlinemode(mode)
Xint mode;
X{
X    if (unixDisk) return;
X    xlastcolor = -1;
X    if (mode==0) {
X    XSetFunction(Xdp, Xgc, GXcopy);
X    xlastfcn = GXcopy;
X    } else {
X    XSetForeground(Xdp, Xgc, colors-1);
X    xlastcolor = -1;
X    XSetFunction(Xdp, Xgc, GXxor);
X    xlastfcn = GXxor;
X    }
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * drawline --
X *
X *    Draw a line.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Modifies window.
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xdrawline(x1,y1,x2,y2)
Xint x1,y1,x2,y2;
X{
X    if (!unixDisk) {
X    XDrawLine(Xdp,Xw,Xgc,x1,y1,x2,y2);
X    }
X}
X/*
X *----------------------------------------------------------------------
X *
X * xsync --
X *
X *    Sync the x server
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Modifies window.
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xxsync()
X{
X    if (!unixDisk) {
X    XSync(Xdp,False);
X    }
X}
X/*
X *----------------------------------------------------------------------
X *
X * getachar --
X *
X *    Gets a character.
X *
X * Results:
X *    Key.
X *
X * Side effects:
X *    Reads key.
X *
X *----------------------------------------------------------------------
X */
Xstatic int
Xgetachar()
X{
X    if (simple_input) {
X    return getchar();
X    } else {
X    char ch;
X    int status;
X    status = read(0,&ch,1);
X    if (status<0) {
X        return -1;
X    } else {
X        return ch;
X    }
X    }
X}
X
Xstatic int xbufkey = 0;        /* Buffered X key */
X/*
X *----------------------------------------------------------------------
X *
X * xgetkey --
X *
X *    Get a key from the keyboard or the X server.
X *    Blocks if block = 1.
X *
X * Results:
X *    Key, or 0 if no key and not blocking.
X *    Times out after .5 second.
X *
X * Side effects:
X *    Processes X events.
X *
X *----------------------------------------------------------------------
X */
Xint
Xxgetkey(block)
Xint block;
X{
X    static int skipcount = 0;
X    int ch,ch2;
X    fd_set reads;
X    int status;
X    static struct timeval tout;
X    tout.tv_sec = 0;
X    tout.tv_usec = 500000;
X    while (1) {
X    if (input_pending()) {
X        ch = getachar();
X        if (ch == ESC) {
X        return handleesc();
X        } else {
X        return translatekey(ch);
X        }
X    }
X
X    /* Don't check X events every time, since that is expensive */
X    skipcount++;
X    if (block==0 && skipcount<25) break;
X    skipcount = 0;
X
X    if (!unixDisk) {
X        xhandleevents();
X    }
X    if (xbufkey) {
X        ch = xbufkey;
X        xbufkey = 0;
X        skipcount = 9999; /* If we got a key, check right away next time */
X        return translatekey(ch);
X    }
X    if (!block) break;
X    FD_ZERO(&reads);
X    FD_SET(0,&reads);
X    if (unixDisk) {
X        status = select(1,&reads,NULL,NULL,&tout);
X    } else {
X        FD_SET(ConnectionNumber(Xdp),&reads);
X        status = select(ConnectionNumber(Xdp)+1,&reads,NULL,NULL,&tout);
X    }
X    if (status<=0) {
X        return 0;
X    }
X    }
X    return 0;
X}
X/*
X *----------------------------------------------------------------------
X *
X * translatekey --
X *
X *    Translate an input key into MSDOS format.  The purpose of this
X *    routine is to do the mappings like U -> PAGE_UP.
X *
X * Results:
X *    New character;
X *
X * Side effects:
X *    None.
X *
X *----------------------------------------------------------------------
X */
Xstatic int
Xtranslatekey(ch)
Xint ch;
X{
X    if (ch>='a' && ch<='z') {
X    return ch;
X    } else {
X    switch (ch) {
X        case 'I':
X        return INSERT;
X        case 'D':
X        return DELETE;
X        case 'U':
X        return PAGE_UP;
X        case 'N':
X        return PAGE_DOWN;
X        case CTL('O'):
X        return CTL_HOME;
X        case CTL('E'):
X        return CTL_END;
X        case 'H':
X        return LEFT_ARROW;
X        case 'L':
X        return RIGHT_ARROW;
X        case 'K':
X        return UP_ARROW;
X        case 'J':
X        return DOWN_ARROW;
X        case 1115:
X        return LEFT_ARROW_2;
X        case 1116:
X        return RIGHT_ARROW_2;
X        case 1141:
X        return UP_ARROW_2;
X        case 1145:
X        return DOWN_ARROW_2;
X        case 'O':
X        return HOME;
X        case 'E':
X        return END;
X        case '\n':
X        return ENTER;
X        case CTL('T'):
X        return CTL_ENTER;
X        case -2:
X        return CTL_ENTER_2;
X        case CTL('U'):
X        return CTL_PAGE_UP;
X        case CTL('N'):
X        return CTL_PAGE_DOWN;
X        case '{':
X        return CTL_MINUS;
X        case '}':
X        return CTL_PLUS;
X        /* we need ^I for tab */
X#if 0
X        case CTL('I'):
X        return CTL_INSERT;
X#endif
X        case CTL('D'):
X        return CTL_DEL;
X        case '!':
X        return F1;
X        case '@':
X        return F2;
X        case '#':
X        return F3;
X        case '$':
X        return F4;
X        case '%':
X        return F5;
X        case '^':
X        return F6;
X        case '&':
X        return F7;
X        case '*':
X        return F8;
X        case '(':
X        return F9;
X        case ')':
X        return F10;
X        default:
X        return ch;
X    }
X    }
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * handleesc --
X *
X *    Handle an escape key.  This may be an escape key sequence
X *    indicating a function key was pressed.
X *
X * Results:
X *    Key.
X *
X * Side effects:
X *    Reads keys.
X *
X *----------------------------------------------------------------------
X */
Xstatic int
Xhandleesc()
X{
X    int ch1,ch2,ch3;
X    if (simple_input) {
X    return ESC;
X    }
X#ifdef __hpux
X    /* HP escape key sequences. */
X    ch1 = getachar();
X    if (ch1==-1) {
X    delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X    ch1 = getachar();
X    }
X    if (ch1==-1) {
X    return ESC;
X    }
X    switch (ch1) {
X    case 'A':
X        return UP_ARROW;
X    case 'B':
X        return DOWN_ARROW;
X    case 'D':
X        return LEFT_ARROW;
X    case 'C':
X        return RIGHT_ARROW;
X    case 'd':
X        return HOME;
X    }
X    if (ch1 != '[') return ESC;
X    ch1 = getachar();
X    if (ch1==-1) {
X    delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X    ch1 = getachar();
X    }
X    if (ch1==-1 || !isdigit(ch1)) return ESC;
X    ch2 = getachar();
X    if (ch2==-1) {
X    delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X    ch2 = getachar();
X    }
X    if (ch2==-1) return ESC;
X    if (isdigit(ch2)) {
X    ch3 = getachar();
X    if (ch3==-1) {
X        delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X        ch3 = getachar();
X    }
X    if (ch3 != '~') return ESC;
X    ch2 = (ch2-'0')*10+ch3-'0';
X    } else if (ch3 != '~') {
X    return ESC;
X    } else {
X    ch2 = ch2-'0';
X    }
X    switch (ch2) {
X    case 5:
X        return PAGE_UP;
X    case 6:
X        return PAGE_DOWN;
X    case 29:
X        return F1; /* help */
X    case 11:
X        return F1;
X    case 12:
X        return F2;
X    case 13:
X        return F3;
X    case 14:
X        return F4;
X    case 15:
X        return F5;
X    case 17:
X        return F6;
X    case 18:
X        return F7;
X    case 19:
X        return F8;
X    default:
X        return ESC;
X    }
X#else
X    /* SUN escape key sequences */
X    ch1 = getachar();
X    if (ch1==-1) {
X    delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X    ch1 = getachar();
X    }
X    if (ch1 != '[') {        /* See if we have esc [ */
X    return ESC;
X    }
X    ch1 = getachar();
X    if (ch1==-1) {
X    delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X    ch1 = getachar();
X    }
X    if (ch1==-1) {
X    return ESC;
X    }
X    switch (ch1) {
X    case 'A':        /* esc [ A */
X        return UP_ARROW;
X    case 'B':        /* esc [ B */
X        return DOWN_ARROW;
X    case 'C':        /* esc [ C */
X        return RIGHT_ARROW;
X    case 'D':        /* esc [ D */
X        return LEFT_ARROW;
X    default:
X        break;
X    }
X    ch2 = getachar();
X    if (ch2==-1) {
X    delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X    ch2 = getachar();
X    }
X    if (ch2 == '~') {        /* esc [ ch1 ~ */
X    switch (ch1) {
X        case '2':        /* esc [ 2 ~ */
X        return INSERT;
X        case '3':        /* esc [ 3 ~ */
X        return DELETE;
X        case '5':        /* esc [ 5 ~ */
X        return PAGE_UP;
X        case '6':        /* esc [ 6 ~ */
X        return PAGE_DOWN;
X        default:
X        return ESC;
X    }
X    } else if (ch2==-1) {
X    return ESC;
X    } else {
X    ch3 = getachar();
X    if (ch3==-1) {
X        delay(250); /* Wait 1/4 sec to see if a control sequence follows */
X        ch3 = getachar();
X    }
X    if (ch3 != '~') {    /* esc [ ch1 ch2 ~ */
X        return ESC;
X    }
X    if (ch1=='1') {
X        switch (ch2) {
X        case '1':    /* esc [ 1 1 ~ */
X            return F1;
X        case '2':    /* esc [ 1 2 ~ */
X            return F2;
X        case '3':    /* esc [ 1 3 ~ */
X            return F3;
X        case '4':    /* esc [ 1 4 ~ */
X            return F4;
X        case '5':    /* esc [ 1 5 ~ */
X            return F5;
X        case '6':    /* esc [ 1 6 ~ */
X            return F6;
X        case '7':    /* esc [ 1 7 ~ */
X            return F7;
X        case '8':    /* esc [ 1 8 ~ */
X            return F8;
X        case '9':    /* esc [ 1 9 ~ */
X            return F9;
X        default:
X            return ESC;
X        }
X    } else if (ch1=='2') {
X        switch (ch2) {
X        case '0':    /* esc [ 2 0 ~ */
X            return F10;
X        case '8':    /* esc [ 2 8 ~ */
X            return F1;  /* HELP */
X        default:
X            return ESC;
X        }
X    } else {
X        return ESC;
X    }
X    }
X#endif
X}
X
X
Xextern double zwidth, zdepth, zrotate, zskew, zbx, zby, dxsize,dysize;
Xextern int zoomoff;
X
Xextern int editpal_cursor;
Xextern void Cursor_SetPos();
X
Xint XZoomWaiting = 0;
X
X#define SENS 1
X#define ABS(x) ((x)>0?(x):-(x))
X#define MIN(x,y) ((x)<(y)?(x):(y))
X#define SIGN(x) ((x)>0?1:-1)
X
X/*
X *----------------------------------------------------------------------
X *
X * xhandleevents --
X *
X *    Handles X events.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Does event action.
X *
X *----------------------------------------------------------------------
X */
Xstatic int
Xxhandleevents()
X{
X    XEvent xevent;
X    static ctl_mode = 0;
X    static shift_mode = 0;
X    int bandx0,bandy0,bandx1,bandy1;
X    static int bnum=0;
X    static int lastx,lasty;
X    static int dx,dy;
X
X    if (doredraw) {
X    redrawscreen();
X    }
X
X    while (XPending(Xdp) && !xbufkey) {
X    XNextEvent(Xdp,&xevent);
X    switch (((XAnyEvent *)&xevent)->type) {
X        case KeyRelease:
X        {
X        char buffer[1];
X        KeySym keysym;
X        (void) XLookupString(&xevent,buffer,1,&keysym,NULL);
X        switch (keysym) {
X            case XK_Control_L:
X            case XK_Control_R:
X            ctl_mode = 0;
X            break;
X            case XK_Shift_L:
X            case XK_Shift_R:
X            shift_mode = 0;
X            break;
X        }
X        }
X        break;
X        case KeyPress:
X        {
X        int charcount;
X        char buffer[1];
X        KeySym keysym;
X        int compose;
X        charcount = XLookupString(&xevent,buffer,1,&keysym,NULL);
X        switch (keysym) {
X            case XK_Control_L:
X            case XK_Control_R:
X            ctl_mode = 1;
X            return;
X            case XK_Shift_L:
X            case XK_Shift_R:
X            shift_mode = 1;
X            break;
X            case XK_Home:
X            case XK_R7:
X            xbufkey = ctl_mode ? CTL_HOME : HOME;
X            return;
X            case XK_Left:
X            case XK_R10:
X            xbufkey = ctl_mode ? LEFT_ARROW_2 : LEFT_ARROW;
X            return;
X            case XK_Right:
X            case XK_R12:
X            xbufkey = ctl_mode ? RIGHT_ARROW_2 : RIGHT_ARROW;
X            return;
X            case XK_Down:
X            case XK_R14:
X            xbufkey = ctl_mode ? DOWN_ARROW_2 : DOWN_ARROW;
X            return;
X            case XK_Up:
X            case XK_R8:
X            xbufkey = ctl_mode ? UP_ARROW_2 : UP_ARROW;
X            return;
X            case XK_Insert:
X            xbufkey = ctl_mode ? CTL_INSERT : INSERT;
X            return;
X            case XK_Delete:
X            xbufkey = ctl_mode ? CTL_DEL : DELETE;
X            return;
X            case XK_End:
X            case XK_R13:
X            xbufkey = ctl_mode ? CTL_END : END;
X            return;
X            case XK_Help:
X            xbufkey = F1;
X            return;
X            case XK_Prior:
X            case XK_R9:
X            xbufkey = ctl_mode ? CTL_PAGE_UP : PAGE_UP;
X             return;
X            case XK_Next:
X            case XK_R15:
X            xbufkey = ctl_mode ? CTL_PAGE_DOWN : PAGE_DOWN;
X             return;
X            case XK_F1:
X            case XK_L1:
X            xbufkey = shift_mode ? SF1: F1;
X            return;
X            case XK_F2:
X            case XK_L2:
X            xbufkey = shift_mode ? SF2: F2;
X            return;
X            case XK_F3:
X            case XK_L3:
X            xbufkey = shift_mode ? SF3: F3;
X            return;
X            case XK_F4:
X            case XK_L4:
X            xbufkey = shift_mode ? SF4: F4;
X            return;
X            case XK_F5:
X            case XK_L5:
X            xbufkey = shift_mode ? SF5: F5;
X            return;
X            case XK_F6:
X            case XK_L6:
X            xbufkey = shift_mode ? SF6: F6;
X            return;
X            case XK_F7:
X            case XK_L7:
X            xbufkey = shift_mode ? SF7: F7;
X            return;
X            case XK_F8:
X            case XK_L8:
X            xbufkey = shift_mode ? SF8: F8;
X            return;
X            case XK_F9:
X            case XK_L9:
X            xbufkey = shift_mode ? SF9: F9;
X            return;
X            case XK_F10:
X            case XK_L10:
X            xbufkey = shift_mode ? SF10: F10;
X            return;
X            case '+':
X             xbufkey = ctl_mode ? CTL_PLUS : '+';
X             return;
X            case '-':
X             xbufkey = ctl_mode ? CTL_MINUS : '-';
X             return;
X             break;
X            case XK_Return:
X            case XK_KP_Enter:
X             xbufkey = ctl_mode ? CTL('T') : '\n';
X             return;
X        }
X        if (charcount==1) {
X            xbufkey = buffer[0];
X            if (xbufkey=='\003') {
X            goodbye();
X            }
X        }
X        }
X        break;
X        case MotionNotify:
X        {
X        if (editpal_cursor && !inside_help) {
X            while ( XCheckWindowEvent(Xdp,Xw,PointerMotionMask,
X            &xevent)) {}
X
X            if (xevent.xmotion.state&Button2Mask ||
X                (xevent.xmotion.state&Button1Mask &&
X                xevent.xmotion.state&Button3Mask)) {
X            bnum = 3;
X            } else if (xevent.xmotion.state&Button1Mask) {
X            bnum = 1;
X            } else if (xevent.xmotion.state&Button3Mask) {
X            bnum = 2;
X            } else {
X            bnum = 0;
X            }
X
X#define MSCALE 1
X
X            if (lookatmouse==3 && bnum != 0) {
X            dx += (xevent.xmotion.x-lastx)/MSCALE;
X            dy += (xevent.xmotion.y-lasty)/MSCALE;
X            lastx = xevent.xmotion.x;
X            lasty = xevent.xmotion.y;
X            } else {
X            Cursor_SetPos(xevent.xmotion.x, xevent.xmotion.y);
X            xbufkey = ENTER;
X            }
X
X        }
X        }
X        break;
X        case ButtonPress:
X        {
X        int done = 0;
X        int banding = 0;
X        if (lookatmouse==3 || zoomoff == 0) {
X            lastx = xevent.xbutton.x;
X            lasty = xevent.xbutton.y;
X            break;
X        }
X        bandx1 = bandx0 = xevent.xbutton.x;
X        bandy1 = bandy0 = xevent.xbutton.y;
X        while (!done) {
X            XNextEvent(Xdp,&xevent);
X            switch (xevent.type) {
X            case MotionNotify:
X            while ( XCheckWindowEvent(Xdp,Xw,PointerMotionMask,
X                &xevent)) {}
X            if (banding) {
X                XDrawRectangle(Xdp,Xw,Xgc,MIN(bandx0,bandx1),
X                MIN(bandy0,bandy1), ABS(bandx1-bandx0),
X                ABS(bandy1-bandy0));
X            }
X            bandx1 = xevent.xmotion.x;
X            bandy1 = xevent.xmotion.y;
X            if (ABS(bandx1-bandx0)*finalaspectratio >
X                ABS(bandy1-bandy0)) {
X                bandy1 = SIGN(bandy1-bandy0)*ABS(bandx1-bandx0)*
X                finalaspectratio + bandy0;
X            } else {
X                bandx1 = SIGN(bandx1-bandx0)*ABS(bandy1-bandy0)/
X                finalaspectratio + bandx0;
X            }
X            if (!banding) {
X                /* Don't start rubber-banding until the mouse
X                   gets moved.  Otherwise a click messes up the
X                   window */
X                if (ABS(bandx1-bandx0)>10 ||
X                    ABS(bandy1-bandy0)>10) {
X                banding = 1;
X                XSetForeground(Xdp, Xgc, colors-1);
X                XSetFunction(Xdp, Xgc, GXxor);
X                }
X            }
X            if (banding) {
X                XDrawRectangle(Xdp,Xw,Xgc,MIN(bandx0,bandx1),
X                MIN(bandy0,bandy1), ABS(bandx1-bandx0),
X                ABS(bandy1-bandy0));
X            }
X            XFlush(Xdp);
X            break;
X            case ButtonRelease:
X            done = 1;
X            break;
X            }
X        }
X        if (!banding) {
X            break;
X        }
X        XDrawRectangle(Xdp,Xw,Xgc,MIN(bandx0,bandx1),
X            MIN(bandy0,bandy1), ABS(bandx1-bandx0),
X            ABS(bandy1-bandy0));
X        if (bandx1==bandx0) {
X            bandx1 = bandx0+1;
X        }
X        if (bandy1==bandy0) {
X            bandy1 = bandy0+1;
X        }
X        zrotate = 0;
X        zskew = 0;
X        zbx = (MIN(bandx0,bandx1)-sxoffs)/dxsize;
X        zby = (MIN(bandy0,bandy1)-syoffs)/dysize;
X        zwidth = ABS(bandx1-bandx0)/dxsize;
X        zdepth = zwidth;
X        if (!inside_help) {
X            xbufkey = ENTER;
X        }
X        if (xlastcolor != -1) {
X            XSetForeground(Xdp, Xgc, xlastcolor);
X        }
X        XSetFunction(Xdp, Xgc, xlastfcn);
X        XZoomWaiting = 1;
X        drawbox(0);
X        }
X        break;
X        case Expose:
X        if (!doesBacking) {
X        int x,y,w,h;
X        x = xevent.xexpose.x;
X        y = xevent.xexpose.y;
X        w = xevent.xexpose.width;
X        h = xevent.xexpose.height;
X        if (x+w>sxdots) {
X            w = sxdots-x;
X        }
X        if (y+h>sydots) {
X            h = sydots-y;
X        }
X        if (x<sxdots && y<sydots && w>0 && h>0) {
X
X            XPutImage(Xdp,Xw,Xgc,Ximage,xevent.xexpose.x,
X                xevent.xexpose.y, xevent.xexpose.x,
X                xevent.xexpose.y, xevent.xexpose.width,
X                xevent.xexpose.height);
X        }
X        }
X        break;
X    }
X    }
X
X    if (!xbufkey && editpal_cursor && !inside_help && lookatmouse == 3 &&
X        (dx != 0 || dy != 0)) {
X    if (ABS(dx)>ABS(dy)) {
X        if (dx>0) {
X        xbufkey = mousefkey[bnum][0]; /* right */
X        dx--;
X        } else if (dx<0) {
X        xbufkey = mousefkey[bnum][1]; /* left */
X        dx++;
X        }
X    } else {
X        if (dy>0) {
X        xbufkey = mousefkey[bnum][2]; /* down */
X        dy--;
X        } else if (dy<0) {
X        xbufkey = mousefkey[bnum][3]; /* up */
X        dy++;
X        }
X    }
X    }
X
X}
X
X#define w_root Xroot
X#define dpy Xdp
X#define scr Xdscreen
X/*
X *----------------------------------------------------------------------
X *
X * pr_dwmroot --
X *
X *    Search for a dec window manager root window.
X *
X * Results:
X *    Returns the root window.
X *
X * Side effects:
X *    None.
X *
X *----------------------------------------------------------------------
X */
Xstatic Window
Xpr_dwmroot(dpy, pwin)
XDisplay *dpy;
XWindow  pwin;
X{
X   /* search for DEC Window Manager root */
X   XWindowAttributes pxwa,cxwa;
X   Window  root,parent,*child;
X   unsigned int     i,nchild;
X
X    if (!XGetWindowAttributes(dpy,pwin,&pxwa)) {
X    printf("Search for root: XGetWindowAttributes failed\n");
X    return RootWindow(dpy, scr);
X    }
X    if (XQueryTree(dpy,pwin,&root,&parent,&child,&nchild)) {
X    for (i = 0; i < nchild; i++) {
X        if (!XGetWindowAttributes(dpy,child[i],&cxwa)) {
X        printf("Search for root: XGetWindowAttributes failed\n");
X        return RootWindow(dpy, scr);
X        }
X        if (pxwa.width == cxwa.width && pxwa.height == cxwa.height) {
X        return(pr_dwmroot(dpy, child[i]));
X        }
X    }
X    return(pwin);
X    } else {
X    printf("xfractint: failed to find root window\n");
X    return RootWindow(dpy, scr);
X    }
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * FindRootWindow --
X *
X *    Find the root or virtual root window.
X *
X * Results:
X *    Returns the root window.
X *
X * Side effects:
X *    None.
X *
X *----------------------------------------------------------------------
X */
Xstatic Window
XFindRootWindow()
X{
X   int i;
X   w_root = RootWindow(dpy,scr);
X   w_root = pr_dwmroot(dpy, w_root); /* search for DEC wm root */
X
X{  /* search for swm/tvtwm root (from ssetroot by Tom LaStrange) */
X   Atom __SWM_VROOT = None;
X   Window rootReturn, parentReturn, *children;
X   unsigned int numChildren;
X
X   __SWM_VROOT = XInternAtom(dpy, "__SWM_VROOT", False);
X   XQueryTree(dpy, w_root, &rootReturn, &parentReturn, &children, &numChildren);
X   for (i = 0; i < numChildren; i++) {
X      Atom actual_type;
X      int actual_format;
X      unsigned long nitems, bytesafter;
X      Window *newRoot = NULL;
X
X      if (XGetWindowProperty (dpy, children[i], __SWM_VROOT,(long)0,(long)1,
X         False, XA_WINDOW, &actual_type, &actual_format, &nitems, &bytesafter,
X         (unsigned char **) &newRoot) == Success && newRoot) {
X         w_root = *newRoot; break;
X         }
X      }
X   }
X   return w_root;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * RemoveRootPixmap --
X *
X *    Clean up old pixmap on the root window.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Pixmap is cleaned up.
X *
X *----------------------------------------------------------------------
X */
Xstatic void
XRemoveRootPixmap()
X{
X    Atom prop,type;
X    int format;
X    unsigned long nitems,after;
X    Pixmap *pm;
X
X    prop = XInternAtom(Xdp,"_XSETROOT_ID",False);
X    if (XGetWindowProperty(Xdp,Xroot,prop,(long)0,(long)1,1,AnyPropertyType,
X        &type, &format, &nitems, &after, (unsigned char **)&pm) ==
X        Success && nitems == 1) {
X    if (type==XA_PIXMAP && format==32 && after==0) {
X        XKillClient(Xdp,(XID)*pm);
X        XFree((char *)pm);
X    }
X    }
X}
Xstatic unsigned char *fontPtr = NULL;
X/*
X *----------------------------------------------------------------------
X *
X * xgetfont --
X *
X *    Get an 8x8 font.
X *
X * Results:
X *    Returns a pointer to the bits.
X *
X * Side effects:
X *    None.
X *
X *----------------------------------------------------------------------
X */
Xunsigned char *
Xxgetfont()
X{
X    XFontStruct *font_info;
X    Pixmap font_pixmap;
X    XImage *font_image;
X    char str[8];
X    int i,j,k,l;
X    int width;
X    fontPtr = (unsigned char *)malloc(128*8);
X    bzero(fontPtr,128*8);
X    XSetBackground(Xdp,Xgc,0);
X    xlastcolor = -1;
X    XSetForeground(Xdp,Xgc,1);
X#define FONT "-*-*-medium-r-*-*-9-*-*-*-*-*-iso8859-*"
X    font_info = XLoadQueryFont(Xdp,FONT);
X    if (font_info==NULL) {
X    printf("No %s\n", FONT);
X    }
X    if (font_info==NULL || font_info->max_bounds.width>8 ||
X        font_info->max_bounds.width != font_info->min_bounds.width) {
X    printf("Bad font: %s\n", FONT);
X    sleep(2);
X    font_info = XLoadQueryFont(Xdp,"6x12");
X    }
X    if (font_info==NULL) return NULL;
X    width = font_info->max_bounds.width;
X    if (font_info->max_bounds.width>8 ||
X        font_info->max_bounds.width != font_info->min_bounds.width) {
X    printf("Bad font\n");
X    return NULL;
X    }
X    font_pixmap = XCreatePixmap(Xdp,Xw,64,8,Xdepth);
X
X    for (i=0;i<128;i+=8) {
X    for (j=0;j<8;j++) {
X        str[j] = i+j;
X    }
X    XDrawImageString(Xdp,font_pixmap,Xgc,0,8,str,8);
X    font_image = XGetImage(Xdp,font_pixmap,0,0,64,8,AllPlanes,XYPixmap);
X    for (j=0;j<8;j++) {
X        for (k=0;k<8;k++) {
X        for (l=0;l<width;l++) {
X            if (XGetPixel(font_image,j*width+l,k)) {
X            fontPtr[(i+j)*8+k] = (fontPtr[(i+j)*8+k]<<1)|1;
X            } else {
X            fontPtr[(i+j)*8+k] = (fontPtr[(i+j)*8+k]<<1);
X            }
X        }
X        }
X    }
X    XDestroyImage(font_image);
X    }
X    return fontPtr;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * shell_to_dos --
X *
X *    Exit to a unix shell.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Goes to shell
X *
X *----------------------------------------------------------------------
X */
X#define SHELL "/bin/csh"
Xvoid
Xshell_to_dos()
X{
X    int (*sigint)();
X    char *shell;
X    char *argv[2];
X    int pid, donepid;
X
X    sigint = (int(*)())signal(SIGINT, SIG_IGN);
X    shell = getenv("SHELL");
X    if (shell==NULL) {
X    shell = SHELL;
X    }
X    argv[0] = shell;
X    argv[1] = NULL;
X
X    /* Clean up the window */
X
X    if (!simple_input) {
X    fcntl(0,F_SETFL,old_fcntl);
X    }
X    mvcur(0,COLS-1, LINES-1,0);
X    nocbreak();
X    echo();
X    endwin();
X
X    /* Fork the shell */
X
X    pid = fork();
X    if (pid < 0) {
X    perror("fork to shell");
X    }
X    if (pid==0) {
X    execvp(shell, argv);
X    perror("fork to shell");
X    exit(1);
X    }
X
X    /* Wait for the shell to finish */
X
X    while (1) {
X    donepid = wait(0);
X    if (donepid<0 || donepid==pid) break;
X    }
X
X    /* Go back to curses mode */
X
X    initscr();
X    curwin = stdscr;
X    cbreak();
X    noecho();
X    if (!simple_input) {
X    old_fcntl = fcntl(0,F_GETFL);
X    fcntl(0,F_SETFL,FNDELAY);
X    }
X
X    (void) signal(SIGINT, sigint);
X    putchar('\n');
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * schedulealarm --
X *
X *    Start the refresh alarm
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Starts the alarm.
X *
X *----------------------------------------------------------------------
X */
X#define DRAW_INTERVAL 6
Xvoid
Xschedulealarm(soon)
Xint soon;
X{
X    if (!fastmode) return;
X    signal(SIGALRM, setredrawscreen);
X    if (soon) {
X    alarm(1);
X    } else {
X    alarm(DRAW_INTERVAL);
X    }
X    alarmon = 1;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * setredrawscreen --
X *
X *    Set the screen refresh flag
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Sets the flag.
X *
X *----------------------------------------------------------------------
X */
Xstatic void
Xsetredrawscreen()
X{
X    doredraw = 1;
X}
X
X/*
X *----------------------------------------------------------------------
X *
X * redrawscreen --
X *
X *    Refresh the screen.
X *
X * Results:
X *    None.
X *
X * Side effects:
X *    Redraws the screen.
X *
X *----------------------------------------------------------------------
X */
Xvoid
Xredrawscreen()
X{
X    if (alarmon) {
X    XPutImage(Xdp,Xw,Xgc,Ximage,0,0,0,0,sxdots,sydots);
X    if (onroot) {
X        XPutImage(Xdp,Xpixmap,Xgc,Ximage,0,0,0,0,sxdots,sydots);
X    }
X    alarmon = 0;
X    }
X    doredraw = 0;
X}
X
SHAR_EOF
$TOUCH -am 1028230193 unixscr.c &&
chmod 0644 unixscr.c ||
echo "restore of unixscr.c failed"
set `wc -c unixscr.c`;Wc_c=$1
if test "$Wc_c" != "46415"; then
    echo original size 46415, current size $Wc_c
fi
# ============= unix.h ==============
echo "x - extracting unix.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > unix.h &&
X/* UNIX.H - unix port declarations */
X
X
X#ifndef _UNIX_H
X#define _UNIX_H
X
X#define far
X#define cdecl
X#define huge
X#define near
X#ifndef RAND_MAX
X#define RAND_MAX 0x7fffffff
X#endif
X#define O_BINARY 0
X#ifdef CLK_TCK
X#undef CLK_TCK
X#endif
X#define CLK_TCK 1000
Xtypedef float FLOAT4;
Xtypedef short INT2;
Xtypedef unsigned short UINT2;
Xtypedef int INT4;
Xtypedef unsigned int UINT4;
X#define max(a,b) ((a)>(b)?(a):(b))
X#define min(a,b) ((a)<(b)?(a):(b))
X#define remove(x) unlink(x)
X#define _MAX_FNAME 20
X#define _MAX_EXT 4
X#define chsize(fd,len) ftruncate(fd,len)
X
X#define inp(x) 0
X#define outp(x,y)
X
X#ifndef labs
X#define labs(x) ((x)>0?(x):-(x))
X#endif
X
X/* We get a problem with connect, since it is used by X */
X#define connect connect1
X/* dysize may conflict with time.h */
X#define dysize dysize1
X/* inline is a reserved word */
X#define inline inline1
X
X/* Some stdio.h's don't have this */
X#ifndef SEEK_SET
X#define SEEK_SET 0
X#endif
X#ifndef SEEK_CUR
X#define SEEK_CUR 1
X#endif
X#ifndef SEEK_END
X#define SEEK_END 2
X#endif
X
Xextern int iocount;
X
Xchar *strlwr(char *s);
Xchar *strupr(char *s);
X
X
X/* bcopy is probably faster than memmove, memcpy */
X#define memcpy(dst,src,n) bcopy(src,dst,n)
X#define memmove(dst,src,n) bcopy(src,dst,n)
X
X/*
X * These defines are so movedata, etc. will work properly, without worrying
X * about the silly segment stuff.
X */
X#define movedata(s_seg,s_off,d_seg,d_off,len) bcopy(s_off,d_off,len)
Xstruct SREGS {
X    int ds;
X};
X#define FP_SEG(x) 0
X#define FP_OFF(x) ((char *)(x))
X#define segread(x)
X
X/*
X * SGI and 386BSD don't have timeb
X */
X#ifdef __386BSD__
X#define FTIME
X#endif
X
X#ifdef SYSVSGI
X#define FTIME
Xstruct timeb
X{
X        time_t  time;
X        unsigned short millitm;
X        int   timezone;
X        int   dstflag;
X};
X#else
X#ifdef FTIME
X#include <sys/timeb.h>
X#endif
X#endif
X
X/* External functions in unixscr.c */
X
Xint unixarg(int argc, char **argv, int *i);
X    /* Parses xfractint-specific command line arguments */
Xvoid UnixInit(void);
X    /* initializes curses text window and the signal handlers. */
Xvoid initUnixWindow(void);
X    /* initializes the graphics window, colormap, etc. */
Xvoid UnixDone(void);
X    /* cleans up X window and curses. */
Xint startvideo(void);
X    /* clears the graphics window */
Xint endvideo(void);
X    /* just a stub. */
Xint readvideo(int x, int y);
X    /* reads a pixel from the screen. */
Xvoid readvideoline(int y, int x, int lastx, BYTE *pixels);
X    /* reads a line of pixels from the screen. */
Xvoid writevideo(int x, int y, int color);
X    /* writes a pixel to the screen. */
Xvoid writevideoline(int y, int x, int lastx, BYTE *pixels);
X    /* writes a line of pixels to the screen. */
Xint readvideopalette(void);
X    /* reads the current colormap into dacbox. */
Xint writevideopalette(void);
X    /* writes the current colormap from dacbox. */
Xint resizeWindow(void);
X    /* Checks if the window has been resized, and handles the resize.  */
Xint xgetkey(int block);
X    /* Checks if a key has been pressed. */
Xunsigned char * xgetfont(void);
X    /* Returns bitmap of an 8x8 font. */
Xvoid drawline(int x1, int y1, int x2, int y2);
X    /* Draws a line from (x1,y1) to (x2,y2). */
Xvoid setlinemode(int mode);
X    /* Sets line mode to draw or xor. */
Xvoid shell_to_dos(void);
X    /* Calls a Unix subshell. */
Xvoid xsync(void);
X    /* Forces all window events to be processed. */
Xvoid redrawscreen(void);
X    /* Used with schedulealarm.  Xfractint has a delayed write mode,
X     * where the screen is updated only every few seconds.
X     */
Xvoid schedulealarm(int soon);
X    /* Schedules the next delayed update. */
X
X#endif
SHAR_EOF
$TOUCH -am 1028230193 unix.h &&
chmod 0644 unix.h ||
echo "restore of unix.h failed"
set `wc -c unix.h`;Wc_c=$1
if test "$Wc_c" != "3507"; then
    echo original size 3507, current size $Wc_c
fi
# ============= Makefile ==============
echo "x - extracting Makefile (Text)"
sed 's/^X//' << 'SHAR_EOF' > Makefile &&
X#
X# Makefile for xfractint
X#
X
X# SRCDIR should be a path to the directory that will hold fractint.hlp
X# You will have to copy fractint.hlp to SRCDIR and make it world readable.
X# SRCDIR should also hold the .par, .frm, etc. files
XSRCDIR = /usr/local/bin/X11/fractint
X# BINDIR is where you put your X11 binaries
XBINDIR = /usr/local/bin/X11
X# MANDIR is where you put your chapter 1 man pages
XMANDIR = /user/local/man/man1
X
X#SRCDIR = /users/shirriff/fractfiles
X#BINDIR = /users/shirriff/fractfiles
X#MANDIR = /users/shirriff/fractfiles
X
XNOBSTRING =
XHAVESTRI =
XDEBUG =
X
X# For Ultrix, uncomment the NOBSTRING line.
X# For SunOS, uncomment the NOBSTRING and HAVESTRI lines, so bstring.h will
X# not be included, and the library stricmp will be used.
X# For HPUX, uncomment the NOBSTRING line, change the DEFINES line, the CFLAGS
X# line, the CC line, and the LIBS line.
X# For AIX or OSF/1, change the DEFINES and LIB lines.
X# For Apollo, uncomment the NOBSTRING line.  You must also remove the
X#     source references to unistd.h, malloc.h, and alloc.h.
X# For 386BSD, uncomment the NOBSTRING line.  Depending on your system, you
X#     may have to change the "#elif !defined(__386BSD__)" at the top of
X#     prompts2.c to "#else".
X#
X# HPUX fixes thanks to David Allport, Bill Broadley, and R. Lloyd.
X# AIX fixes thanks to David Sanderson & Elliot Jaffe.
X# OSF/1 fixes thanks to Ronald Record.
X# 386BSD fixes thanks to Paul Richards and Andreas Gustafsson.
X# Apollo fixes thanks to Carl Heidrich
X# Linux fixes thanks to Darcy Boese
X# Makefile dependency fixes thanks to Paul Roberts.
X
X#DEBUG adds some sanity checking but will slow xfractint down
X#DEBUG = -DEBUG
X#NOBSTRING = -DNOBSTRING
X#HAVESTRI = -DHAVESTRI
X# If your compiler doesn't handle void *, define -DBADVOID
X# If you get SIGFPE errors define -DFPUERR
X# For HPUX, add -DSYS5
X# and maybe add -DSYSV -D_CLASSIC_ANSI_TYPES
X# For AIX, add -DNOBSTRING and -DDIRENT
X# AIX may also need -D_POSIX_SOURCE -D_ALL_SOURCE -D_NONSTD_TYPES
X# For Dec Alpha, add -DFTIME -DNOBSTRING -DDIRENT
X# For SGI, you may have to add -DSYSVSGI
XDEFINES = -DXFRACT $(NOBSTRING) $(HAVESTRI) $(DEBUG)
X
X#Maybe -D_CONST will fix problems with constant type in include files?
X#For HPUX, use CFLAGS = -I. $(DEFINES) -I/usr/include/X11R4 +O3 +Obb1000
X#For SGI, add -cckr to CFLAGS
X#For 386BSD, add -I/usr/X386/include to CFLAGS
X#For Apollo add -I/usr/include/X11 to CFLAGS
X#Some systems need -static on the CFLAGS.
X#For Linux, add -DLINUX to CFLAGS
X
X#CFLAGS = -I. -D_CONST $(DEFINES)
XCFLAGS = -I. $(DEFINES)
X
X# Gcc is usually the only compiler that works for this
X# For HPUX, use CC = cc -Aa -D_HPUX_SOURCE
X# For AIX, maybe use CC = xlc, but other AIX users found cc works, xlc doesn't.
X# For Apollo use CC = cc -A cpu,mathlib_sr10  -A systype,bsd4.3
XCC = gcc
XCC = cc
X
X# For HPUX, use LIBS = -L /usr/lib/X11R4 -lX11 -lm -lcurses -ltermcap
X# For AIX or OSF/1, add -lbsd
X# For 386BSD, add -L/usr/X386/lib to LIBS
X# For Apollo, change -lX11 to -L/usr/X11/libX11
XLIBS = -lX11 -lm -lcurses -ltermcap
X
XOLDSRC = 3d.c calcfrac.c cmdfiles.c decoder.c editpal.c encoder.c f16.c \
Xfracsubr.c fractalp.c fractals.c fractint.c gifview.c hc.c hcmplx.c \
Xhelp.c intro.c \
Xjb.c jiim.c line3d.c loadfdos.c loadfile.c loadmap.c lorenz.c lsys.c \
Xmiscfrac.c miscovl.c miscres.c mpmath_c.c parser.c parserfp.c plot3d.c \
Xprinter.c prompts1.c prompts2.c realdos.c rotate.c slideshw.c targa.c \
Xtestpt.c tgaview.c tp3d.c tplus.c zoom.c fractint.h fractype.h fmath.h port.h \
Xhelpcom.h helpdefs.h mpmath.h targa.h targa_lc.h tplus.h prototyp.h \
Xfractsrc.doc debugfla.doc hc.doc
X
XNEWSRC = calcmand.c calmanfp.c diskvidu.c fpu087.c fracsuba.c general.c \
Xprintera.c tplus_a.c video.c unix.c unixscr.c unix.h \
XMakefile versions
X
XHELPFILES = help.src help2.src help3.src help4.src help5.src
X
XSRCFILES = $(OLDSRC) $(NEWSRC) $(HELPFILES)
X
XPARFILES = cellular.par fractint.par icons.par phoenix.par
X
XFRMFILES = fractint.frm
X
XIFSFILES = fractint.ifs
X
XLFILES = fractint.l penrose.l tiling.l
X
XMAPFILES = \
Xaltern.map blues.map chroma.map default.map firestrm.map froth3.map \
Xfroth316.map froth6.map froth616.map gamma1.map gamma2.map glasses1.map \
Xglasses2.map goodega.map green.map grey.map grid.map headache.map \
Xlandscap.map lyapunov.map neon.map paintjet.map royal.map topo.map \
Xvolcano.map
X
XOLDRUN = $(PARFILES) $(FRMFILES) $(IFSFILES) $(LFILES) \
X$(MAPFILES) demo.key
X
XNEWRUN = fractint0.doc README xfractint.man
X
XNEWFILES = $(NEWSRC) $(NEWRUN)
X
XRUNFILES = $(OLDRUN) $(NEWRUN)
X
XFILES = $(SRCFILES) $(RUNFILES)
X
XOBJS = \
X3d.o calcfrac.o calcmand.o calmanfp.o cmdfiles.o decoder.o diskvidu.o \
Xeditpal.o encoder.o f16.o fpu087.o fracsuba.o fracsubr.o fractalp.o \
Xfractals.o fractint.o general.o gifview.o hcmplx.o help.o intro.o jb.o jiim.o \
Xline3d.o loadfdos.o loadfile.o loadmap.o lorenz.o lsys.o miscfrac.o miscovl.o \
Xmiscres.o mpmath_c.o parser.o parserfp.o plot3d.o  printer.o printera.o \
Xprompts1.o prompts2.o realdos.o rotate.o slideshw.o targa.o testpt.o \
Xtgaview.o tp3d.o tplus.o tplus_a.o unix.o unixscr.o video.o zoom.o
X
XHOBJS = hc.o unix.o
X
XHELP = help.src help2.src help3.src help4.src help5.src
X
X#Need to prevent lex from doing fractint.l -> fractint.c
X.SUFFIXES:
X.SUFFIXES: .o .c .s .h
X
Xxfractint: fractint.hlp $(OBJS)
X    $(CC) -o xfractint $(CFLAGS) $(OBJS) $(LIBS)
X    strip xfractint
X
Xtar:    $(FILES)
X    tar cfh xfractint.tar $(FILES)
X
Xtidy:
X    rm -f $(OBJS) $(HOBJS)
X
Xclean:
X    rm -f $(OBJS) $(HOBJS) fractint.doc fractint.hlp hc xfractint helpdefs.h
X
Xinstall: xfractint fractint.hlp
X    cp xfractint $(BINDIR)/xfractint
X    strip $(BINDIR)/xfractint
X    chmod a+x $(BINDIR)/xfractint
X    cp fractint.hlp $(PARFILES) $(FRMFILES) $(IFSFILES) $(LFILES) $(MAPFILES) $(SRCDIR)
X    (cd $(SRCDIR); chmod a+r fractint.hlp $(PARFILES) $(FRMFILES) $(IFSFILES) $(LFILES) $(MAPFILES) )
X    cp xfractint.man $(MANDIR)/xfractint.1
X    chmod a+r $(MANDIR)/xfractint.1
X
Xfractint.hlp: hc $(HELP)
X    ./hc /c
X
Xmakedoc: doc
X
Xfractint.doc: doc
X
Xdoc: hc $(HELP)
X    ./hc /p
X
Xhc:    $(HOBJS)
X    $(CC) -o hc $(CFLAGS) $(HOBJS)
X
Xunix.o:    unix.c
X    $(CC) $(CFLAGS) -DSRCDIR=\"$(SRCDIR)\" -c unix.c
X
Xfractint.o: fractint.c
X    $(CC) $(CFLAGS) -DSRCDIR=\"$(SRCDIR)\" -c fractint.c
X
Xhelp.o: help.c
X    $(CC) $(CFLAGS) -DSRCDIR=\"$(SRCDIR)\" -c help.c
X
Xsharsrc:    $(SRCFILES)
X    shar -s [e-mail] $(SRCFILES) > xfsrc.shar
X
Xsharrun:    $(RUNFILES)
X    shar -s [e-mail] $(RUNFILES) > xfrun.shar
X
Xshar:    $(FILES)
X    shar -s [e-mail] $(FILES) > xfractint.shar
X
Xsharc:    $(FILES)
X    shar -s [e-mail] $(FILES) > xfractint.shar; compress xfractint.shar
X
Xshartw: $(OLDSRC) $(HELPFILES)
X    shar -s [e-mail] $(OLDSRC) $(HELPFILES)> source.tw;compress \
X    source.tw
X
Xcheckout:
X    co -l -r4.5 -q -f $(FILES)
X
Xcheckin: $(OLDRUN) $(OLDSRC)
X    ci -u -f -r5.2 -m"xfractint 2.1 pre sync" $(FILES)
X
Xunlock: $(FILES)
X    co -u -f $(FILES)
X
Xoutdate: $(FILES)
X    rcs -o3.5 $(FILES)
X
Xmerge: $(SRCFILES) $(HELPFILES)
X    for i in $(SRCFILES) ; do \
X        rcsmerge -r3.1 -r3.1.1.1 $$i; \
X    done
X
Xtags: $(SRCFILES)
X    ctags $(SRCFILES)
X
Xdiff:
X    echo "use make -i"; \
X    for i in $(FILES) ; do \
X        (diff -c $$i v18 > diffs/$$i; true;); \
X        true; \
X    done
X
Xcopy: $(FILES)
X    mv $(FILES) backup
X
X
X# DO NOT DELETE THIS LINE -- make depend depends on it.
X
X3d.o: 3d.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xcalcfrac.o: calcfrac.c fractint.h port.h fractype.h mpmath.h targa_lc.h \
X            prototyp.h helpcom.h
X
Xcalcmand.o: calcmand.c fractint.h port.h
X
Xcalmanfp.o: calmanfp.c fractint.h port.h fractype.h
X
Xcmdfiles.o: cmdfiles.c fractint.h port.h fractype.h prototyp.h mpmath.h \
X            helpcom.h
X
Xdecoder.o: decoder.c prototyp.h mpmath.h port.h fractint.h helpcom.h
X
Xdiskvidu.o: diskvidu.c fractint.h port.h
X
Xeditpal.o: editpal.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xencoder.o: encoder.c fractint.h port.h fractype.h prototyp.h mpmath.h helpcom.h
X
Xf16.o: f16.c targa_lc.h prototyp.h mpmath.h port.h fractint.h helpcom.h
X
Xfpu087.o: fpu087.c fractint.h port.h mpmath.h
X
Xfracsuba.o: fracsuba.c fractint.h port.h
X
Xfracsubr.o: fracsubr.c fractint.h port.h fractype.h mpmath.h prototyp.h \
X            helpcom.h
X
Xfractalp.o: fractalp.c fractint.h port.h mpmath.h helpdefs.h fractype.h \
X            prototyp.h helpcom.h
X
Xfractals.o: fractals.c fractint.h port.h mpmath.h helpdefs.h fractype.h \
X            prototyp.h helpcom.h
X
Xfractint.o: fractint.c prototyp.h mpmath.h port.h fractint.h helpcom.h \
X            fractype.h helpdefs.h
X
Xgeneral.o: general.c fractint.h port.h
X
Xgifview.o: gifview.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xhc.o: hc.c helpcom.h port.h
X
Xhelp.o: help.c fractint.h port.h helpcom.h helpdefs.h prototyp.h mpmath.h
X
Xintro.o: intro.c fractint.h port.h helpdefs.h prototyp.h mpmath.h helpcom.h
X
Xjb.o: jb.c fractint.h port.h mpmath.h helpdefs.h prototyp.h helpcom.h
X
Xjiim.o: jiim.c helpdefs.h fractint.h port.h fractype.h prototyp.h mpmath.h \
X        helpcom.h
X
Xline3d.o: line3d.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xloadfdos.o: loadfdos.c fractint.h port.h helpdefs.h prototyp.h mpmath.h \
X            helpcom.h
X
Xloadfile.o: loadfile.c fractint.h port.h fractype.h targa_lc.h prototyp.h \
X            mpmath.h helpcom.h
X
Xloadmap.o: loadmap.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xlorenz.o: lorenz.c mpmath.h fractint.h port.h fractype.h prototyp.h helpcom.h
X
Xlsys.o: lsys.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xmiscovl.o: miscovl.c fractint.h port.h fractype.h helpdefs.h prototyp.h \
X            mpmath.h helpcom.h
X
Xmiscres.o: miscres.c fractint.h port.h fractype.h helpdefs.h prototyp.h \
X            mpmath.h helpcom.h
X
Xmpmath_c.o: mpmath_c.c mpmath.h prototyp.h port.h fractint.h helpcom.h
X
Xparser.o: parser.c mpmath.h prototyp.h port.h fractint.h helpcom.h
X
Xplot3d.o: plot3d.c fractint.h port.h fractype.h prototyp.h mpmath.h helpcom.h
X
Xprinter.o: printer.c fractint.h port.h fractype.h prototyp.h mpmath.h helpcom.h
X
Xprintera.o: printera.c port.h
X
Xprompts1.o: prompts1.c fractint.h port.h fractype.h helpdefs.h prototyp.h \
X            mpmath.h helpcom.h
X
Xprompts2.o: prompts2.c fractint.h port.h fractype.h helpdefs.h prototyp.h \
X            mpmath.h helpcom.h
X
Xrealdos.o: realdos.c fractint.h port.h fractype.h helpdefs.h prototyp.h \
X            mpmath.h helpcom.h
X
Xrotate.o: rotate.c fractint.h port.h helpdefs.h prototyp.h mpmath.h helpcom.h
X
Xslideshw.o: slideshw.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xtarga.o: targa.c targa.h fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xtgaview.o: tgaview.c fractint.h port.h targa_lc.h prototyp.h mpmath.h helpcom.h
X
Xtp3d.o: tp3d.c mpmath.h fractint.h port.h prototyp.h helpcom.h
X
Xtplus.o: tplus.c port.h tplus.h prototyp.h mpmath.h fractint.h helpcom.h
X
Xtplus_a.o: tplus_a.c fractint.h port.h
X
Xunix.o: unix.c port.h
X
Xunixscr.o: unixscr.c fractint.h port.h prototyp.h mpmath.h helpcom.h helpdefs.h
X
Xvideo.o: video.c fractint.h port.h prototyp.h mpmath.h helpcom.h
X
Xzoom.o: zoom.c fractint.h port.h prototyp.h mpmath.h helpcom.h
SHAR_EOF
$TOUCH -am 1028230193 Makefile &&
chmod 0644 Makefile ||
echo "restore of Makefile failed"
set `wc -c Makefile`;Wc_c=$1
if test "$Wc_c" != "10830"; then
    echo original size 10830, current size $Wc_c
fi
# ============= versions ==============
echo "x - extracting versions (Text)"
sed 's/^X//' << 'SHAR_EOF' > versions &&
XREVISION INFORMATION:
X
XVersion 0.01: (Jan 3, 1992)
X    Initial version.  Some fractals work.
XVersion 0.03: (Jan 4, 1992)
X    Most fractals work.
X    Handles colors better.
XVersion 0.04:
X    Has working zoom box, lsys.
XVersion 0.05:
X    Routines to get a pixel and write a line of pixels implemented.
X    Has working diffusion, region guessing.
X    GIF save works.
X    MP math routines work(?).
X    Boundary trace works.
XVersion 0.06:
X    Log colormaps work
X    X cursor keys work.
XVersion 0.07: (Jan 9, 1992)
X    File input screens work.
X    Sun cursor keys work in text window.
X    Fixed rand().
X    Plasma works.
X    Ifs fractals work.
X    Man page included.
XVersion 0.08:
X    Compilation problems with SunOS fixed (I hope).
X    Got root window drawing working, colormap sharing, private colormap.
X    Got printer support working.
X    Palette editing works.
X    Control-cursor works.
X    GIF read works.
X    3d display works.
XVersion 1.00: (Feb 6, 1992)
X    Updated to fractint 17.00.
XVersion 1.01: (May 16, 1992)
X    GIF89a read and write works.
X    hc problems fixed: many thanks to Roberto Flor and Thomas Winder.
X    Mouse support for zoom boxes and palette editor.
X    New feature: use periodicity as an inside method.
X    Corner selection works.
X    Default color map changed so bifurcation, ifs, lsystem show up better.
X    Fixed bug with bifurcation pixel row.
X    Fixed bug with manzpower: incorrect if real=2, imag != 0
X    Fixed problem with ^D's killing shell when exiting xfractint.
X    No longer prints to column 80, which messed up some displays.
XVersion 1.02: (May 17, 1992)
X    Fixed problem with help on Suns.
XVersion 1.03: (June 11, 1992)
X    Fixed problem with loading gifs on Suns.
X    Fixed problems with @ and tab keys.
X    Added shell to dos.
X    Added floating point Mandelbrot computation.
X    Added -fast flag for faster X-windows drawing.
X    Added HPUX flags to Makefile.
X    Added window resizing.
X    Changed default colormap again.
X    Got disk video working.
X    Added -slowdisplay flag to prevent xfractint from hanging on slow displays.
X    Added compressed PostScript output.
X    Added dithered GIF reads.
XVersion 1.04: (July 9, 1992)
X    Merged with fractint 17.25.
X    Added quaternions.
X    Added dynamic systems.
X    Added cellular automata.
X    Added floating point julibrot.
X    Added gamma to palette editor.
X    Added command string specification during execution.
X    Always set floating point flag and removed unused MP floating point code.
X    Improved ifs editing.
X    Fixed problem with potential and < 256 colors.
X    Fixed complexnewton and newtbasin.
X    Fixed a bug in helpcom.h with formatting of links.
X    Allow 256 entry map files, even with < 256 colors.
X    Added integer restriction to parameter entry.
XVersion 1.05 (July 13, 1992)
X    Fixed problems with include files and type declarations.
X    Sped up negative powers.
XVersion 1.06 (Sept 24, 1992)
X    Merged with latest fractint (17.27).
X    Added attractor basin phase plotting for Julia sets.
X    Improved finite attractor code to find more attractors.
X    Added (untested) make install option.
X    Added mandelcloud type.
XVersion 1.07: (Nov 1, 1992)
X    Merged with latest fractint (17.29).
X    Added many more .map, .par files, thanks to Dan Goldwater.
X    Fixed segfault in postscript printing.
X    Fixed disk video size selection.
X    Fixed color printing.
XVersion 1.08: (Nov 2, 1992)
X    Fixed some definitions.
XVersion 1.09:
X    Got batch mode working.
X    Added support for xfractint library directory (setenv FRACTDIR).
X    Merged with fractint17.31
X    Has device-resolution postscript.
X    Makefile improvements.
X    Added still more .map, .par, etc. files, thanks to Dan Goldwater.
X    Fixed a hc.c wordsize problem (thanks to David Gibson).
XVersion 2.00: (June 5, 1993)
X    Merged with fractint 18.00.
XVersion 2.01: (June 11, 1993)
X    Fixed gamma conflict.
XVersion 2.02: (July 28, 1993)
X    Fixed Makefile for Linux (thanks to Darcy Boese)
X    Synced with fractint 18.1
X    Made changes so xfractint will work on 64-bit Alphas.
XVersion 2.03 (Oct 9, 1993)
X    Synced with fractint 18.2
XVersion 2.04 (Oct 28, 1993)
X    CD-ROM release.  Contains cursor fix for JIIM.
SHAR_EOF
$TOUCH -am 1028230193 versions &&
chmod 0644 versions ||
echo "restore of versions failed"
set `wc -c versions`;Wc_c=$1
if test "$Wc_c" != "4195"; then
    echo original size 4195, current size $Wc_c
fi
# ============= help.src ==============
echo "x - extracting help.src (Text)"
sed 's/^X//' << 'SHAR_EOF' > help.src &&
X;
X; HELP.SRC
X;
X;
X~HdrFile=HELPDEFS.H
X~HlpFile=FRACTINT.HLP
X~Version=100
X~FormatExclude=8
X;
X;
X;
X~Topic=Main Help Index, Label=HELPMENU
X~Label=HELP_INDEX
X
X~Format-
X   { Using Help }                { Fractals and the PC }
X   { Introduction }                { Distribution of Fractint }
X   { Conditions on Use }            { Contacting the Authors }
X   { Getting Started }                { The Stone Soup Story }
X   { New Features in Version 18.2 }        { A Word About the Authors }
X                      { Other Fractal Products }
X   { Display Mode Commands }            { Fractint on Unix }
X   { Color Cycling Commands }            { Using Fractint With a Mouse }
X   { Palette Editing Commands }         { Video Adapter Notes }
X                      { GIF Save File Format }
X   { Summary of Fractal Types }
X                      { Common Problems }
X   { Doodads\, Bells\, and Whistles }
X   { "3D" Images }                          { Bibliography }
X   { Palette Maps }                { Other Programs }
X                      { Revision History }
X   { Startup Parameters\, Parameter Files }  { Version13 to 14 Conversion }
X   { Batch Mode }
X   { "Disk-Video" Modes }                   { Printing Fractint Documentation }
X~Format+
X;
X;
X;
X~DocContents
X{     , 0, "New Features in Version 18.2", FF}
X
X{     , 0, "Introduction", "Conditions on Use", FF}
X
X{1.   , 0, Fractint Commands, FF}
X{1.1  , 1, "Getting Started"}
X{1.2  , 1, "Plotting Commands"}
X{1.3  , 1, "Zoom box Commands"}
X{1.4  , 1, "Color Cycling Commands"}
X{1.5  , 1, "Palette Editing Commands"}
X{1.6  , 1, "Image Save/Restore Commands"}
X{1.7  , 1, "Print Command"}
X{1.8  , 1, "Parameter Save/Restore Commands"}
X{1.9  , 1, "\"3D\" Commands"}
X{1.10 , 1, "Interrupting and Resuming"}
X{1.11 , 1, "Orbits Window"}
X{1.12 , 1, "View Window"}
X{1.13 , 1, "Video Mode Function Keys"}
X{1.14 , 1, "Hints"}
X{1.15 , 1, "Fractint on Unix"}
X
X{2.   , 0, "Fractal Types", FF}
X{2.1  , 1, "The Mandelbrot Set"}
X{2.2  , 1, "Julia Sets"}
X{2.3  , 1, "Julia Toggle Spacebar Commands"}
X{2.4  , 1, "Inverse Julias"}
X{2.5  , 1, "Newton domains of attraction"}
X{2.6  , 1, "Newton"}
X{2.7  , 1, "Complex Newton"}
X{2.8  , 1, "Lambda Sets"}
X{2.9  , 1, "Mandellambda Sets"}
X{2.10 , 1, "Circle"}
X{2.11 , 1, "Plasma Clouds"}
X{2.12 , 1, "Lambdafn"}
X{2.13 , 1, "Mandelfn"}
X{2.14 , 1, "Barnsley Mandelbrot/Julia Sets"}
X{2.15 , 1, "Barnsley IFS Fractals"}
X{2.16 , 1, "Sierpinski Gasket"}
X{2.17 , 1, "Quartic Mandelbrot/Julia"}
X{2.18 , 1, "Distance Estimator"}
X{2.19 , 1, "Pickover Mandelbrot/Julia Types"}
X{2.20 , 1, "Pickover Popcorn"}
X{2.21 , 1, "Peterson Variations"}
X{2.22 , 1, "Unity"}
X{2.23 , 1, "Scott Taylor / Lee Skinner Variations"}
X{2.24 , 1, "Kam Torus"}
X{2.25 , 1, "Bifurcation"}
X{2.26 , 1, "Orbit Fractals"}
X{2.27 , 1, "Lorenz Attractors"}
X{2.28 , 1, "Rossler Attractors"}
X{2.29 , 1, "Henon Attractors"}
X{2.30 , 1, "Pickover Attractors"}
X{2.31 , 1, "Gingerbreadman"}
X{2.32 , 1, "Martin Attractors"}
X{2.33 , 1, "Icon"}
X{2.34 , 1, "Test"}
X{2.35 , 1, "Formula"}
X{2.36 , 1, "Julibrots"}
X{2.37 , 1, "Diffusion Limited Aggregation"}
X{2.38 , 1, "Magnetic Fractals"}
X{2.39 , 1, "L-Systems"}
X{2.40 , 1, "Lyapunov Fractals"}
X{2.41 , 1, "fn||fn Fractals"}
X{2.42 , 1, "Halley"}
X{2.43 , 1, "Dynamic System"}
X{2.44 , 1, "Mandelcloud"}
X{2.45 , 1, "Quaternion"}
X{2.46 , 1, "HyperComplex"}
X{2.47 , 1, "Cellular Automata"}
X{2.48 , 1, "Phoenix"}
X{2.49 , 1, "Frothy Basins"}
X
X{3.   , 0, Doodads\, Bells\, and Whistles, FF}
X{3.1  , 1, "Drawing Method"}
X{3.2  , 1, "Palette Maps"}
X{3.3  , 1, "Autokey Mode"}
X{3.4  , 1, "Distance Estimator Method"}
X{3.5  , 1, "Inversion"}
X{3.6  , 1, "Decomposition"}
X{3.7  , 1, "Logarithmic Palettes and Color Ranges"}
X{3.8  , 1, "Biomorphs"}
X{3.9  , 1, "Continuous Potential"}
X{3.10 , 1, "Starfields"}
X
X{4.   , 0, "\"3D\" Images", "3D Overview", FF}
X{4.1  , 1, "3D Mode Selection"}
X{4.2  , 1, "Select Fill Type Screen"}
X{4.3  , 1, "Stereo 3D Viewing"}
X{4.4  , 1, "Rectangular Coordinate Transformation"}
X{4.5  , 1, "3D Color Parameters"}
X{4.6  , 1, "Light Source Parameters"}
X{4.7  , 1, "Spherical Projection"}
X{4.8  , 1, "3D Overlay Mode"}
X{4.9  , 1, "Special Note for CGA or Hercules Users"}
X{4.10 , 1, "Making Terrains"}
X{4.11 , 1, "Making 3D Slides"}
X{4.12 , 1, "Interfacing with Ray Tracing Programs"}
X
X{5.   , 0, Command Line Parameters\, Parameter Files\, Batch Mode, "Introduction to Parameters", FF}
X{5.1  , 1, "Using the DOS Command Line"}
X{5.2  , 1, "Setting Defaults (SSTOOLS.INI File)"}
X{5.3  , 1, "Parameter Files and the <@> Command"}
X{5.4  , 1, "General Parameter Syntax"}
X{5.5  , 1, "Startup Parameters"}
X{5.6  , 1, "Calculation Mode Parameters"}
X{5.7  , 1, "Fractal Type Parameters"}
X{5.8  , 1, "Image Calculation Parameters"}
X{5.9  , 1, "Color Parameters"}
X{5.10 , 1, "Doodad Parameters"}
X{5.11 , 1, "File Parameters"}
X{5.12 , 1, "Video Parameters"}
X{5.13 , 1, "Sound Parameters"}
X{5.14 , 1, "Printer Parameters"}
X{5.15 , 1, "PostScript Parameters"}
X{5.16 , 1, "PaintJet Parameters"}
X{5.17 , 1, "Plotter Parameters"}
X{5.18 , 1, "3D Parameters"}
X{5.19 , 1, "Batch Mode"}
X
X{6.   , 0, Hardware Support, FF}
X{6.1  , 1, Notes on Video Modes\, \"Standard\" and Otherwise,
X            "Video Adapter Notes", "EGA", "Tweaked VGA", "Super-VGA",
X            "8514/A", "XGA", "Targa", "Targa+"}
X{6.2  , 1, "\"Disk-Video\" Modes"}
X{6.3  , 1, "Customized Video Modes\, FRACTINT.CFG"}
X
X{7.   , 0, "Common Problems", FF}
X
X{8.   , 0, "Fractals and the PC", FF}
X{8.1  , 1, A Little History}
X{8.1.1, 2, "Before Mandelbrot"}
X{8.1.2, 2, "Who Is This Guy\, Anyway?"}
X{8.2  , 1, A Little Code}
X{8.2.1, 2, "Periodicity Logic"}
X{8.2.2, 2, "Limitations of Integer Math (And How We Cope)"}
X{8.2.3, 2, "The Fractint \"Fractal Engine\" Architecture"}
X
X{Appendix A, 0, Mathematics of the Fractal Types,
X           "Summary of Fractal Types",
X           "Inside=bof60|bof61|zmag|period",
X           "Inside=epscross|startrail",
X           "Finite Attractors",
X           "Trig Identities", FF}
X
X{Appendix B, 0, Stone Soup With Pixels: The Authors,
X           "The Stone Soup Story",
X           "A Word About the Authors",
X           "Distribution of Fractint",
X           "Contacting the Authors", FF}
X
X{Appendix C, 0, "GIF Save File Format", FF}
X
X{Appendix D, 0, Other Fractal Products, FF}
X
X{Appendix E, 0, "Bibliography", FF}
X
X{Appendix F, 0, "Other Programs", FF}
X
X{Appendix G, 0, Revision History,
X           "Version 17",
X           "Version 16",
X           "Version 15",
X           "Versions 12 through 14",
X           "Versions  1 through 11",
X           FF}
X
X{Appendix H, 0, Version13 to Version 14 Type Mapping, "Version13 to 14 Conversion", FF}
X;
X; End of DoContents
X;
X;
X;
X~Topic=Using Help
X; This topic is online only.
X
XUse the following keys in help mode:
X
X   F1           Go to the main help index.
X
X   PgDn/PgUp       Go to the next/previous page.
X
X   Backspace       Go to the previous topic.
X
X   Escape       Exit help mode.
X
X   Enter       Select (go to) highlighted hot-link.
X
X   Tab/Shift-Tab   Move to the next/previous hot-link.
X
X   \24 \25 \27 \26       Move to a hot-link.
X
X   Home/End       Move to the first/last hot-link.
X;
X;
X;
X~Topic=Printing Fractint Documentation
X
XYou can generate a text file containing full Fractint documentation by
Xselecting the "Generate FRACTINT.DOC now" hot-link below and pressing
XEnter, or by using the DOS command "fractint makedoc=filename" ("filename"
Xis the name of the file to be written; it defaults to FRACTINT.DOC.)
X
XAll information in the documentation file is also available in the online
Xhelp, so extracting it is a matter of preference - you can print the
Xfile (e.g.  DOS command "print fractint.doc" or "copy fractint.doc prn")
Xor read it with a text editor.    It contains over 100 pages of information,
Xhas a table of contents, and is cross-referenced by page number.
X
X  {=-101 Exit without generating FRACTINT.DOC}
X
X  {=-100 Generate FRACTINT.DOC now}
X
XFractint's great (and unique as far as we know) online help and integrated
Xdocumentation file software was written by Ethan Nagel.
X;
X;
X;
X~Topic=New Features in Version 18.2
XVersions 18.1 and 18.2 are bug-fix releases for version 18.0.  Changes from
X18.1 to 18.2 include:
X
X The <b> command now causes filenames only to be written in PAR files.
X
X Fractint will now search directories in the PATH for files not found in the
X requested the requested directory or the current directory. If you place
X .MAP, .FRM, etc. in directories in your PATH, then Fractint will find them.
X
X Fixed bug that caused fractals using PI symmetry to fail at high resolution.
X
X Fractals interrupted with <3> or <r> can now resume.
X
X The palette editor's <u> (undo) now works.
X
X The <s> command in orbit/Julia window mode is no longer case sensitive.
X
X Added warnings that the POV-Ray output is obsolete (but has been left in).
X Use POV-Ray's height field facility instead or create and convert RAW files.
X
X Fixed several IFS bugs.
X
XChanges from 18.0 to 18.1 include:
X
X Overlay tuning - the Mandelbrot/Julia Set fractals are now back up
X to 17.x speeds
X
X Disk Video modes now work correctly with VESA video adapters (they
X used to use the same array for different purposes, confusing each other)
X
X 1024x768x256 and 2048x2048x256 disk video modes work again
X
X Parameter-file processing no longer crashes Fractint if it attempts to
X run a formula requiring access to a non-existent FRM file
X
X IFS arrays no longer overrun their array space
X
X type=cellular fixes
X
X "autologmap=2" now correctly picks up the minimum color
X
X The use of disk-video mode with random-access fractal types is now
X legal (it generates a warning message but lets you proceed if you
X really want to)
X
X The Lsystems "spinning-wheel" now spins slower (removing needless overhead)
X
X Changes to contributors' addresses in the Help screens
X
X(The remainder of this "new features" section is from version 18.0)
X
XNew fractal types:
X
X 19 new fractal types, including:
X
X New fractal types - 'lambda(fn||fn)', 'julia(fn||fn)', 'manlam(fn||fn)',
X 'mandel(fn||fn)', 'halley', 'phoenix', 'mandphoenix', 'cellular',
X generalized bifurcation, and 'bifmay' - from Jonathan Osuch.
X
X New Mandelcloud, Quaternion, Dynamic System, Cellular Automata fractal
X types from Ken Shirriff.
X
X New HyperComplex fractal types from Timothy Wegner
X
X New ICON type from Dan Farmer, including a PAR file of examples.
X
X New Frothy Basin fractal types (and PAR entries) by Wesley Loewer
X
X MIIM (Modified Inverse Iteration Method) implementation of Inverse Julia
X from Michael Snyder.
X
X New Inverse Julia fractal type from Juan Buhler.
X
X New floating-point versions of Markslambda, Marksmandel, Mandel4,
X and Julia4 types (chosen automatically if the floating-point option
X is enabled).
X
XNew options/features:
X
X New assembler-based parser logic from Chuck Ebbert - significantly
X faster than the C-based code it replaces!
X
X New assembler-based Lyapunov logic from Nicholas Wilt and Wes Loewer.
X Roughly six times faster than the old version!
X
X New Orbits-on-a-window / Julia-in-a-window options:\
X  1) The old Overlay option is now '#' (Shift-3).\
X  2) During generation, 'O' brings up orbits (as before) - after\
X     generation, 'O' brings up new orbits Windows mode.\
X  3) Control-O brings up new orbits Windows mode at any time.\
X  4) Spacebar toggles between Inverse Julia mode and the Julia set and\
X     back to the Mandelbrot set.\
X These new "in-a-window" modes are really neat!  See {Orbits Window}
X and {Julia Toggle Spacebar Commands} for details.
X
X New multi-image GIF support in the <B> command.  You can now generate
X 65535x65535x256 fractal images using Fractint (if you have the disk
X space, of course).  This option builds special PAR entries and a
X MAKEMIG.BAT file that you later use to invoke Fractint multiple times
X to generate individual sections of the image and (in a final step)
X stitch them all together.  If your other software can't handle
X Multiple-image GIFs, a SIMPLGIF program is also supplied that converts
X MIGS into simgle-image GIFs.  Press F1 at the <B> prompts screen for
X details.
X
X Fractint's decoder now handles Multi-Image Gifs.
X
X New SuperVGA/VESA Autodetect logic from the latest version of
X VGAKIT.  Sure hope we didn't break anything.
X
X New register-compatible 8514/A code from Jonathan Osuch.  By default,
X Fractint now looks first for the presence of an 8514/A register-compatible
X adapter and then (and only if it doesn't find one) the presence of the
X 8514/A API (IE, HDILOAD is no longer necessary for register-compatible
X "8514/a" adapters).  Fractint can be forced to use the 8514/A API by using
X a new command-line option, "afi=yes".  Jonathan also added ATI's
X "8514/a-style" 800x600x256 and 1280x1024x16 modes.
X
X New XGA-detection logic for ISA-based XGA-2 systems.
X
X The palette editor now has a "freestyle" editing option.  See
X {Palette Editing Commands} for details.
X
X
X Fractint is now more "batch file" friendly.  When running Fractint from
X a batch file, pressing any key will cause Fractint to exit with an
X errorlevel = 2.  Any error that interrupts an image save to disk will
X cause an exit with errorlevel = 2.  Any error that prevents an
X image from being generated will cause an exit with errorlevel = 1.
X
X New Control-X, Control-Y, and Control-Z options flip a fractal image
X along the X-axis, Y-axis, and Origin, respectively.
X
X New area calculation mode in TAB screen from Ken Shirriff
X (for accuracy use inside=0).
X
X The TAB screen now indicates when the Integer Math algorithms are in use.
X
X The palette must now be explicitly changed, it will not reset to the default
X unexpectedly when doing things like switching video modes.
X
X The Julibrot type has been generalized.
X Julibrot fractals can now be generated from PAR files.
X
X Added <b> command support for viewwindows.
X
X Added room for two additional PAR comments in the <B> command
X
X New coloring method for IFS shows which parts of fractal came from
X which transform.
X
X Added attractor basin phase plotting for Julia sets from Ken Shirriff.
X
X Improved finite attractor code to find more attractors from Ken Shirriff.
X
X New zero function, to be used in PAR files to replace old integer tan, tanh
X
X Debugflag=10000 now reports video chipset in use as well as CPU/FPU
X type and available memory
X
X Added 6 additional parameters for params= for those fractal types that
X need them.
X
X New 'matherr()' logic lets Fractint get more aggressive when these errors
X happen.
X
X New autologmap option (log=+-2) from Robin Bussell that ensures that
X all palette values are used by searching the screen border for the lowest
X value and then setting log= to +- that color.
X
X Two new diffusion options - falling and square cavity.
X
X Three new Editpal commands: '!', '@' and '#' commands (that's
X <shift-1>, <shift-2>, and <shift-3>) to swap R<->G, G<->B, R<->B.
X
X Parameter files now use a slightly shorter maximum line length, making
X them a bit more readable when stuffed into messages on Compuserve.
X
X Plasma now has 16-bit .POT output for use with Ray tracers. The "old"
X algorithm has been modified so that the plasma effect is independent
X of resolution.
X
X Slight modification to the Raytrace code to make it compatible with
X Rayshade 4.0 patch level 6.
X
X Improved boundary-tracing logic from Wesley Loewer.
X
X Command-line parameters can now be entered on-the-fly using the <g> key
X thanks to Ken Shirriff.
X
X Dithered gif images can now be loaded onto a b/w display.
X Thanks to Ken Shirriff.
X
X Pictures can now be output as compressed PostScript.
X Thanks to Ken Shirriff.
X
X Periodicity is a new inside coloring option.
X Thanks to Ken Shirriff.
X
X Fixes: symmetry values for the SQR functions, bailout for the floating-pt
X versions of 'lambdafn' and 'mandelfn' fractals from Jonathan Osuch.
X
X "Flip", "conj" operators are now selectable in the parser
X
X New DXF Raytracing option from Dennis Bragg.
X
X Improved boundary-tracing logic from Wesley Loewer.
X
X New MSC7-style overlay structure is used if MAKEFRAC.BAT specifies MSC7.
X (with new FRACTINT.DEF and FRACTINT.LNK files for MSC7 users).  Several
X modules have been re-organized to take advantage of this new overlay
X capability if compiled under MSC7.
X
X Fractint now looks first any embedded help inside FRACTINT.EXE, and then
X for an external FRACTINT.HLP file before giving up. Previous releases
X required that the help text be embedded inside FRACTINT.EXE.
X
XBug fixes:
X
X Corrected formulas displayed for Marksmandel, Cmplxmarksmandel, and
X  associated julia types.
X
X BTM and precision fixes.
X
X Symmetry logic changed for various "outside=" options
X
X Symmetry value for EXP function in lambdafn and lambda(fn||fn) fixed.
X
X Fixed bug where math errors prevented save in batch mode.
X
X The <3> and <r> commands no longer destroy image -- user can back out
X with ESC and image is still there.
X
X Fixed display of correct number of Julibrot parameters, and Julibrot
X relaxes and doesn't constantly force ALTERN.MAP.
X
X Fixed tesseral type for condition when border is all one color but center
X contains image.
X
X Fixed integer mandel and julia when used with parameters > +1.99 and < -1.99
X
X Eliminated recalculation when generating a julia type from a mandelbrot
X type when the 'z' screen is viewed for the first time.
X
X Minor logic change to prevent double-clutching into and out of graphics
X mode when pressing, say, the 'x' key from a menu screen.
X
X Changed non-US phone number for the Houston Public (Software) Library
X
X The "Y" screen is now "Extended Options" instead of "Extended Doodads"
X
X ...and probably a lot more bux-fixes that we've since forgotten that
X we've implemented.
X
X~Topic=Introduction
X
XFRACTINT plots and manipulates images of "objects" -- actually, sets of
Xmathematical points -- that have fractal dimension.
XSee {"Fractals and the PC"} for some
Xhistorical and mathematical background on fractal geometry, a discipline
Xnamed and popularized by mathematician Benoit Mandelbrot. For now, these
Xsets of points have three important properties:
X
X1) They are generated by relatively simple calculations repeated over and
Xover, feeding the results of each step back into the next -- something
Xcomputers can do very rapidly.
X
X2) They are, quite literally, infinitely complex: they reveal more and
Xmore detail without limit as you plot smaller and smaller areas. Fractint
Xlets you "zoom in" by positioning a small box and hitting <Enter> to
Xredraw the boxed area at full-screen size; its maximum linear
X"magnification" is over a trillionfold.
X
X3) They can be astonishingly beautiful, especially using PC color
Xdisplays' ability to assign colors to selected points, and (with VGA
Xdisplays or EGA in 640x350x16 mode) to "animate" the images by quickly
Xshifting those color assignments.
X~OnlineFF
X
XFor a demonstration of some of Fractint's features, run the demonstration
Xfile included with this release (DEMO.BAT) by typing "demo" at the DOS
Xprompt. You can stop the demonstration at any time by pressing <Esc>.
X
XThe name FRACTINT was chosen because the program generates many of its
Ximages using INTeger math, rather than the floating point calculations
Xused by most such programs. That means that you don't need a math co-
Xprocessor chip (aka floating point unit or FPU), although for a few
Xfractal types where floating point math is faster, the program recognizes
Xand automatically uses an 80x87 chip if it's present. It's even faster on
Xsystems using Intel's 80386 and 80486 microprocessors, where the integer
Xmath can be executed in their native 32-bit mode.
X
XFractint works with many adapters and graphics modes from CGA to the
X1024x768, 256-color XGA mode. Even "larger" images, up to 2048x2048x256,
Xcan be plotted to expanded memory, extended memory, or disk: this bypasses
Xthe screen and allows you to create images with higher resolution than
Xyour current display can handle, and to run in "background" under multi-
Xtasking control programs such as DESQview and Windows 3.
X~OnlineFF
X
XFractint is an experiment in collaboration. Many volunteers have joined
XBert Tyler, the program's first author, in improving successive versions.
XThrough electronic mail messages, first on CompuServe's PICS forum and now
Xon GRAPHDEV, new versions are hacked out and debugged a little at a time.
XFractint was born fast, and none of us has seen any other fractal plotter
Xclose to the present version for speed, versatility, and all-around
Xwonderfulness. (If you have, tell us so we can steal somebody else's ideas
Xinstead of each other's.)
XSee {The Stone Soup Story} and {A Word About the Authors} for information
Xabout the authors, and see {Contacting the Authors} for how to contribute
Xyour own ideas and code.
X;
X;
X;
X~Topic=Conditions on Use
X
XFractint is freeware. The copyright is retained by the Stone Soup Group.
X
XFractint may be freely copied and distributed in unmodified form but may
Xnot be sold. (A nominal distribution fee may be charged for media and
Xhandling by freeware and shareware distributors.) Fractint may be used
Xpersonally or in a business - if you can do your job better by using
XFractint, or using images from it, that's great! It may not be given away
Xwith commercial products without explicit permission from the Stone Soup
XGroup.
X
XThere is no warranty of Fractint's suitability for any purpose, nor any
Xacceptance of liability, express or implied.
X
X **********************************************************************\
X * Contribution policy: Don't want money. Got money. Want admiration. *\
X **********************************************************************
X~OnlineFF
X
XSource code for Fractint is also freely available - see
X{Distribution of Fractint}.
XSee the FRACTSRC.DOC file included with the source for conditions on use.
X(In most cases we just want credit.)
X;
X;
X;
X~Topic=Getting Started
X
XTo start the program, enter FRACTINT at the DOS prompt. The program
Xdisplays an initial "credits" screen. If Fractint doesn't start properly,
Xplease see {Common Problems}.
X
XHitting <Enter> gets you from the initial screen to the main menu. You can
Xselect options from the menu by moving the highlight with the cursor arrow
Xkeys
X~Doc-
X(\24 \25 \27 \26)
X~Doc+
Xand pressing <Enter>, or you can enter commands directly.
X
XAs soon as you select a video mode, Fractint begins drawing an image - the
X"full" Mandelbrot set if you haven't selected another fractal type.
X
XFor a quick start, after starting Fractint try one of the following:\
X  If you have MCGA, VGA, or better:  <F3>\
X  If you have EGA:             <F9>\
X  If you have CGA:             <F5>\
X  Otherwise, monochrome:         <F6>
X
XAfter the initial Mandelbrot image has been displayed, try zooming
Xinto it (see {Zoom Box Commands}) and color cycling (see
X{Color Cycling Commands}).
XOnce you're comfortable with these basics, start exploring other
Xfunctions from the main menu.
X
XHelp is available from the menu and at most other points in Fractint by
Xpressing the <F1> key.
X
XAT ANY TIME, you can hit
X~Doc-
Xone of the keys described in {Display Mode Commands}
X~Doc+,Online-
Xa command key
X~Online+
Xto select a function. You do not need to wait for a calculation
Xto finish, nor do you have to return to the main menu.
X
XWhen entering commands, note that for the "typewriter" keys, upper and
Xlower case are equivalent, e.g. <B> and <b> have the same result.
X
XMany commands and parameters can be passed to FRACTINT as command-line
Xarguments or read from a configuration file;
X~Doc-
Xsee {Startup Parameters\, Parameter Files} for details.
X~Doc+,Online-
Xsee "Command Line Parameters, Parameter Files, Batch Mode" for details.
X~Online+
X;
X;
X;
X~Topic=Display Mode Commands
X;
X; This topic is online only
X
X~Format-
X   { Summary of Commands }
X   { Plotting Commands}
X   { Zoom Box Commands }
X   { Image Save/Restore Commands }
X   { Print Command }
X   { Parameter Save/Restore Commands }
X   { Interrupting and Resuming }
X   { Orbits Window }
X   { View Window }
X   { \"3D\" Commands }
X   { Video Mode Function Keys }
X   { Hints }
X;
X;
X;
X~Topic=Summary of Commands, Label=HELPMAIN
X; This topic is online only
X~Doc-
X
XHit any of these keys at the menu or while drawing or viewing a fractal.
XCommands marked with an '*' are also available at the credits screen.
X
X~Format-
X{Plotting Commands}
X * Delete,F2,F3,.. Select a Video Mode and draw (or redraw) current fractal
X * F1           HELP! (Enter help mode)
X   Esc or m       Go to main menu
X   \\            Redraw previous screen (you can 'back out' recursively)
X   Tab           Display information about the current fractal image
X * t           Select a new fractal type and parameters
X * x           Set a number of options and doodads
X * y           Set extended options and doodads
X * z           Set fractal type-specific parameters
X   c or + or -       Enter Color-Cycling Mode (see {=HELPCYCLING Color Cycling Commands})
X   e           Enter Palette-Editing Mode (see {=HELPXHAIR Palette Editing Commands})
X   Spacebar       Mandelbrot/Julia Set toggle.
X   Enter       Continue an interrupted calculation (e.g. after a save)
X * f           toggle the floating-point algorithm option ON or OFF
X * i           Set parameters for 3D fractal types
X * Insert       Restart the program (at the credits screen)
X   a           Convert the current image into a fractal 'starfield'
X   o           toggles 'orbits' option on and off during image generation
X * d           Shell to DOS (type 'exit' at the DOS prompt to return)
X   Ctrl-X       Flip the current image along the screen's X-axis
X   Ctrl-Y       Flip the current image along the screen's Y-axis
X   Ctrl-Z       Flip the current image along the screen's Origin
X
X{Image Save/Restore Commands}
X   s           Save the current screen image to disk
X * r           Restore a saved (or .GIF) image ('3' or 'o' for 3-D)
X
X{Orbits Window}
X   o           Turns on Orbits Window mode after image generation
X   ctrl-o       Turns on Orbits Window mode
X
X{View Window}
X * v           Set view window parameters (reduction, aspect ratio)
X
X{Print Command}
X   p           Print the screen (command-line options set printer type)
X~OnlineFF
X{Parameter Save/Restore Commands}
X   b           Save commands describing the current image in a file
X           (writes an entry to be used with @ command)
X * @           Run a set of commands (in command line format) from a file
X   g           Give a startup parameter: {Summary of all Parameters}
X
X{\"3D\" Commands}
X * 3           3D transform a saved (or .GIF) image
X   # (shift-3)       same as 3, but overlay the current image
X
X{Zoom Box Commands}
X   PageUp       When no Zoom Box is active, bring one up
X           When active already, shrink it
X   PageDown       Expand the Zoom Box
X           Expanding past the screen size cancels the Zoom Box
X   \24 \25 \27 \26       Pan (Move) the Zoom Box
X   Ctrl- \24 \25 \27 \26   Fast-Pan the Zoom Box (may require an enhanced keyboard)
X   Enter       Redraw the Screen or area inside the Zoom Box
X   Ctrl-Enter       'Zoom-out' - expands the image so that your current
X           image is positioned inside the current zoom-box location.
X   Ctrl-Pad+/Pad-  Rotate the Zoom Box
X   Ctrl-PgUp/PgDn  Change Zoom Box vertical size (change its aspect ratio)
X   Ctrl-Home/End   Change Zoom Box shape
X   Ctrl-Ins/Del    Change Zoom Box color
X
X{Interrupting and Resuming}
X
X{Video Mode Function Keys}
X~Doc+
X;
X;
X;
X~Topic=Plotting Commands
X
XFunction keys & various combinations are used to select a video mode and
Xredraw the screen.  For a quick start try one of the following:\
X  If you have MCGA, VGA, or better:  <F3>\
X  If you have EGA:             <F9>\
X  If you have CGA:             <F5>\
X  Otherwise, monochrome:         <F6>\
X
X<F1>\
XDisplay a help screen. The function keys available in help mode are
Xdisplayed at the bottom of the help screen.
X
X<M> or <Esc>\
XReturn from a displayed image to the main menu.
X
X<Esc>\
XFrom the main menu, <Esc> is used to exit from Fractint.
X
X<Delete>\
XSame as choosing "select video mode" from the main menu.
XGoes to the "select video mode" screen.  See {Video Mode Function Keys}.
X
X<\\> (previously <Home>)\
XRedraw the previous image. The program tracks 25 sets of previous
Xcoordinates and fractal types, but does not remember other options which
Xwere different for those past images.
X
X<Tab>\
XDisplay the current fractal type, parameters, video mode, screen or (if
Xdisplayed) zoom-box coordinates, maximum iteration count, and other
Xinformation useful in keeping track of where you are.  The Tab function is
Xnon-destructive - if you press it while in the midst of generating an
Ximage, you will continue generating it when you return.  The Tab function
Xtells you if your image is still being generated or has finished - a handy
Xfeature for those overnight, 1024x768 resolution fractal images.  If the
Ximage is incomplete, it also tells you whether it can be interrupted and
Xresumed.  (Any function other than <Tab> and <F1> counts as an
X"interrupt".)
X
XThe Tab screen also includes a pixel-counting function, which will count
Xthe number of pixels colored in the inside color.  This gives an estimate
Xof the area of the fractal.  Note that the inside color must be different
Xfrom the outside color(s) for this to work; inside=0 is a good choice.
X
X<T>\
XSelect a fractal type. Move the cursor to your choice (or type the first
Xfew letters of its name) and hit <Enter>. Next you will be prompted for
Xany parameters used by the selected type - hit <Enter> for the defaults.
XSee {Fractal Types} for a list of supported types.
X
X<X>\
XSelect a number of eXtended options. Brings up a full-screen menu of
Xoptions, any of which you can change at will.  These options are:\
X  "passes=" - see {Drawing Method}\
X  Floating point toggle - see <F> key description below\
X  "maxiter=" - see {Image Calculation Parameters}\
X  "inside=" and "outside=" - see {Color Parameters}\
X  "savename=" filename - see {File Parameters}\
X  "overwrite=" option - see {File Parameters}\
X  "sound=" option - see {Sound Parameters}\
X  "logmap=" - see {Logarithmic Palettes and Color Ranges}\
X  "biomorph=" - see {Biomorphs}\
X  "decomp=" - see {Decomposition}\
X  "fillcolor=" - see {Drawing Method}\
X
X<F>\
XToggles the use of floating-point algorithms
X(see {"Limitations of Integer Math (And How We Cope)"}).
XWhether floating point is in
Xuse is shown on the <Tab> status screen.  The floating point option can
Xalso be turned on and off using the "X" options screen.
XIf you have a non-Intel floating point chip which supports the full 387
Xinstruction set, see the "FPU=" command in {Startup Parameters}
Xto get the most out of your chip.
X
X<Y>\
XMore options which we couldn't fit under the <X> command:\
X  "finattract=" - see {Finite Attractors}\
X  "potential=" parameters - see {Continuous Potential}\
X  "invert=" parameters - see {Inversion}\
X  "distest=" parameters - see {Distance Estimator Method}\
X  "cyclerange=" - see {Color Cycling Commands}\
X
X<Z>\
XModify the parameters specific to the currently selected fractal type.
XThis command lets you modify the parameters which are requested when you
Xselect a new fractal type with the <T> command, without having to repeat
Xthat selection. You can enter "e" or "p" in column one of the input fields
Xto get the numbers e and pi (2.71828... and 3.14159...).\
XFrom the fractal parameters screen, you can press <F6> to bring up a
Xsub parameter screen for the coordinates of the image's corners.
X; With the IFS fractal type, <Z> brings up the IFS editor (see
X; {=HT_IFS Barnsley IFS Fractals}).
X
X<+> or <->\
XSwitch to color-cycling mode and begin cycling the palette
Xby shifting each color to the next "contour."  See {Color Cycling Commands}.\
X<C>\
XSwitch to color-cycling mode but do not start cycling.
XThe normally black "overscan" border of the screen changes to white.
XSee {Color Cycling Commands}.
X
X<E>\
XEnter Palette-Editing Mode.  See {Palette Editing Commands}.
X
X<Spacebar>\
XToggle between Mandelbrot set images and their corresponding Julia-set
Ximages. Read the notes in {=HT_JULIA Fractal Types, Julia Sets}
Xbefore trying this option if you want to see anything interesting.
X
X<J>\
XToggle between Julia escape time fractal and the Inverse Julia orbit
Xfractal. See {=HT_INVERSE Inverse Julias}
X
X<Enter>\
XEnter is used to resume calculation after a pause. It is only
Xnecessary to do this when there is a message on the screen waiting to be
Xacknowledged, such as the message shown after you save an image to disk.
X
X<I>\
XModify 3D transformation parameters used with 3D fractal types such as
X"Lorenz3D" and 3D "IFS" definitions, including the selection of
X{=HELP3DGLASSES "funny glasses"} red/blue 3D.
X
X<A>\
XConvert the current image into a fractal 'starfield'.  See {Starfields}.
X
X<O> (the letter, not the number)\
XIf pressed while an image is being generated, toggles the display of
Xintermediate results -- the "orbits" Fractint uses as it calculates values
Xfor each point. Slows the display a bit, but shows you how clever the
Xprogram is behind the scenes. (See "A Little Code" in
X{"Fractals and the PC"}.)
X
X<D>\
XShell to DOS. Return to Fractint by entering "exit" at a DOS prompt.
X~OnlineFF
X<Insert>\
XRestart at the "credits" screen and reset most variables to their initial
Xstate.    Variables which are not reset are: savename, lightname, video,
Xstartup filename.
X;
X;
X;
X~Topic=Zoom Box Commands, Label=HELPZOOM
X
XZoom Box functions can be invoked while an image is being generated or when
Xit has been completely drawn.  Zooming is supported for most fractal types,
Xbut not all.
X
XThe general approach to using the zoom box is:    Frame an area using
Xthe keys described below,
Xthen <Enter> to expand what's in the frame to fill the
Xwhole screen (zoom in); or <Ctrl><Enter> to shrink the current image into
Xthe framed area (zoom out). With a mouse, double-click the left button to
Xzoom in, double click the right button to zoom out.
X
X<Page Up>, <Page Down>\
XUse <Page Up> to initially bring up the zoom box. It starts at full screen
Xsize. Subsequent use of these keys makes the zoom box smaller or larger.
XUsing <Page Down> to enlarge the zoom box when it is already at maximum
Xsize removes the zoom box from the display. Moving the mouse away from you
Xor toward you while holding the left button down performs the same
Xfunctions as these keys.
X
XUsing the cursor "arrow" keys
X~Doc-
X(\24 \25 \27 \26)
X~Doc+
Xor moving
Xthe mouse without holding any buttons down, moves the zoom box.
X
XHolding <Ctrl> while pressing cursor "arrow" keys moves the box 5 times
Xfaster.  (This only works with enhanced keyboards.)
X
XPanning: If you move a fullsize zoombox and don't change anything else
Xbefore performing the zoom, Fractint just moves what's already on the
Xscreen and then fills in the new edges, to reduce drawing time. This
Xfeature applies to most fractal types but not all.  A side effect is that
Xwhile an image is incomplete, a full size zoom box moves in steps larger
Xthan one pixel.  Fractint keeps the box on multiple pixel boundaries, to
Xmake panning possible.    As a multi-pass (e.g. solid guessing) image
Xapproaches completion, the zoom box can move in smaller increments.
X
XIn addition to resizing the zoom box and moving it around, you can do some
Xrather warped things with it.  If you're a new Fractint user, we recommend
Xskipping the rest of the zoom box functions for now and coming back to
Xthem when you're comfortable with the basic zoom box functions.
X
X<Ctrl><Keypad->, <Ctrl><Keypad+>\
XHolding <Ctrl> and pressing the numeric keypad's + or - keys rotates the
Xzoom box. Moving the mouse left or right while holding the right button
Xdown performs the same function.
X
X<Ctrl><Page Up>, <Ctrl><Page Down>\
XThese commands change the zoom box's "aspect ratio", stretching or
Xshrinking it vertically. Moving the mouse away from you or toward you
Xwhile holding both buttons (or the middle button on a 3-button mouse) down
Xperforms the same function. There are no commands to directly stretch or
Xshrink the zoom box horizontally - the same effect can be achieved by
Xcombining vertical stretching and resizing.
X
X<Ctrl><Home>, <Ctrl><End>\
XThese commands "skew" the zoom box, moving the top and bottom edges in
Xopposite directions. Moving the mouse left or right while holding both
Xbuttons (or the middle button on a 3-button mouse) down performs the same
Xfunction. There are no commands to directly skew the left and right edges
X- the same effect can be achieved by using these functions combined with
Xrotation.
X
X<Ctrl><Insert>, <Ctrl><Delete>\
XThese commands change the zoom box color. This is useful when you're
Xhaving trouble seeing the zoom box against the colors around it. Moving
Xthe mouse away from you or toward you while holding the right button down
Xperforms the same function.
X
XYou may find it difficult to figure out what combination of size, position
Xrotation, stretch, and skew to use to get a particular result.    (We do.)\
XA good way to get a feel for all these functions is to play with the
XGingerbreadman fractal type. Gingerbreadman's shape makes it easy to
Xsee what you're doing to him. A warning though: Gingerbreadman will run
Xforever, he's never quite done! So, pre-empt with your next zoom when he's
Xbaked enough.
X
XIf you accidentally change your zoom box shape or rotate and
Xforget which way is up, just use <PageDown> to make it bigger until it
Xdisappears, then <PageUp> to get a fresh one.  With a
Xmouse, after removing the old zoom box from the display release and
Xre-press the left button for a fresh one.
X
XIf your screen does not have a 4:3 "aspect ratio" (i.e. if the visible
Xdisplay area on it is not 1.333 times as wide as it is high), rotating and
Xzooming will have some odd effects - angles will change, including the
Xzoom box's shape itself, circles (if you are so lucky as to see any with a
Xnon-standard aspect ratio) become non-circular, and so on. The vast
Xmajority of PC screens *do* have a 4:3 aspect ratio.
X
XZooming is not implemented for the plasma and diffusion fractal types, nor
Xfor overlayed and 3D images. A few fractal types support zooming but
Xdo not support rotation and skewing - nothing happens when you try it.
X;
X;
X;
X~Topic=Image Save/Restore Commands, Label=HELPSAVEREST
X
X<S> saves the current image to disk. All parameters required to recreate
Xthe image are saved with it. Progress is marked by colored lines moving
Xdown the screen's edges.
X
XThe default filename for the first image saved after starting Fractint is
XFRACT001.GIF;  subsequent saves in the same session are automatically
Xincremented 002, 003... Use the "savename=" parameter or <X> options
Xscreen to change the name. By default, files left over from previous
Xsessions are not overwritten - the first unused FRACTnnn name is used.
XUse the "overwrite=yes" parameter or <X> options screen) to overwrite
Xexisting files.
X
XA save operation can be interrupted by pressing any key. If you interrupt,
Xyou'll be asked whether to keep or discard the partial file.
X
X<R> restores an image previously saved with <S>, or an ordinary GIF file.
XAfter pressing <R> you are shown the file names in the current directory
Xwhich match the current file mask. To select a file to restore, move the
Xcursor to it (or type the first few letters of its name) and press
X<Enter>.
X
XDirectories are shown in the file list with a "\\" at the end of the name.
XWhen you select a directory, the contents of that directory are shown. Or,
Xyou can type the name of a different directory (and optionally a different
Xdrive) and press <Enter> for a new display. You can also type a mask such
Xas "*.XYZ" and press <Enter> to display files whose name ends with the
Xmatching suffix (XYZ).
X
XYou can use <F6> to switch directories to the default fractint directory
Xor to your own directory which is specified through the DOS environment
Xvariable "FRACTDIR".
X
XOnce you have selected a file to restore, a summary description of the
Xfile is shown, with a video mode selection list. Usually you can just
Xpress <Enter> to go past this screen and load the image. Other choices
Xavailable at this point are:\
X  Cursor keys: select a different video mode\
X  <Tab>: display more information about the fractal\
X  <F1>: for help about the "err" column in displayed video modes\
XIf you restore a file into a video mode which does not have the same pixel
Xdimensions as the file, Fractint will make some adjustments:  The view
Xwindow parameters (see <V> command) will automatically be set to an
Xappropriate size, and if the image is larger than the screen dimensions,
Xit will be reduced by using only every Nth pixel during the restore.
X;
X;
X;
X~Topic=Print Command
X
X<P>\
X
XPrint the current fractal image on your (Laserjet, Paintjet, Epson-
Xcompatible, PostScript, or HP-GL) printer.
X
XSee {"Setting Defaults (SSTOOLS.INI File)"} and {"Printer Parameters"}
Xfor how to let Fractint know about your printer setup.
X
X{"Disk-Video" Modes} can be used to
Xgenerate images for printing at higher resolutions than your screen
Xsupports.
X;
X;
X;
X~Topic=Parameter Save/Restore Commands, Label=HELPPARMFILE
X
XParameter files can be used to save/restore all options and settings
Xrequired to recreate particular images.  The parameters required to
Xdescribe an image require very little disk space, especially compared with
Xsaving the image itself.
X
X<@>
X
XThe <@> command loads a set of parameters describing an image.
X(Actually, it can also be used to set non-image parameters such as SOUND,
Xbut at this point we're interested in images. Other uses of parameter
Xfiles are discussed in {"Parameter Files and the <@> Command"}.)
X
XWhen you hit <@>, Fractint displays the names of the entries in the
Xcurrently selected parameter file.  The default parameter file,
XFRACTINT.PAR, is included with the Fractint release and contains
Xparameters for some sample images.
X
XAfter pressing <@>, highlight an entry and press <Enter> to load it, or
Xpress <F6> to change to another parameter file.
X
XNote that parameter file entries specify all calculation related
Xparameters, but do not specify things like the video mode - the image will
Xbe plotted in your currently selected mode.
X
X<B>
X
XThe <B> command saves the parameters required to describe the currently
Xdisplayed image, which can subsequently be used with the <@> command to
Xrecreate it.
X
XAfter you press <B>, Fractint prompts for:
X
X  Parameter file:  The name of the file to store the parameters in.  You
X  should use some name like "myimages" instead of fractint.par, so that
X  your images are kept separate from the ones released with new versions
X  of Fractint. You can use the PARMFILE= command in SSTOOLS.INI
X  to set the default parameter file name to "myimages" or whatever.
X  (See {"Setting Defaults (SSTOOLS.INI File)"} and "parmfile=" in
X  {"File Parameters"}.)
X
X  Name:  The name you want to assign to the entry, to be displayed when
X  the <@> command is used.
X
X  Main comment:  A comment to be shown beside the entry in the <@> command
X  display.
X
X  Second, Third, and Fourth comment:  Additional comments to store in the
X  file with the entry. These comments go in the file only, and are not
X  displayed by the <@> command.
X
X  Record colors?:  Whether color information should be included in the
X  entry. Usually the default value displayed by Fractint is what you want.
X  Allowed values are:\
X  "no" - Don't record colors. This is the default if the image is using
X     your video adapter's default colors.
X  "@mapfilename" - When these parameters are used, load colors from the
X     named color map file. This is the default if you are currently using
X     colors from a color map file.
X  "yes" - Record the colors in detail. This is the default when you've
X     changed the display colors by using the palette editor or by color
X     cycling. The only reason that this isn't what Fractint always does
X     for the <B> command is that color information can be bulky - up to
X     nearly 1K of disk space. That may not
X     sound like much, but can add up when you consider the thousands of
X     wonderful images you may find you just *have* to record...
X     Smooth-shaded ranges of colors are compressed, so if that's used a
X     lot in an image the color information won't be as bulky.
X
X  # of colors:    This only matters if "Record colors?" is set to "yes".  It
X  specifies the number of colors to record. Recording less colors will
X  take less space. Usually the default value displayed by Fractint is what
X  you want. You might want to increase it in some cases, e.g. if you are
X  using a 256 color mode with maxiter 150, and have used the palette
X  editor to set all 256 possible colors for use with color cycling, then
X  you'll want to set the "# of colors" to 256.
X
X  At the bottom of the input screen are inputs for Fractint's "pieces"
X  divide-and-conquer feature. You can create multiple PAR entries that
X  break an image up into pieces so that you can generate the image pieces
X  one by one. There are two reasons for doing this. The first is in case the
X  fractal is very slow, and you want to generate parts of the image at the
X  same time on several computers. The second is that you might want to make
X  an image greater than 2048 x 2048. The parameters for this feature are:
X     X Multiples - How many divisions of final image in the x direction\
X     Y Multiples - How many divisions of final image in the y direction\
X     Video mode  - Fractint video mode for each piece (e.g. "F3")\
X
X  The last item defaults to the current video mode. If either X Multiples or
X  Y Multiples are greater than 1, then multiple numbered PAR entries for the
X  pieces are added to the PAR file, and a MAKEMIG.BAT file is created that
X  builds all of the component pieces and then stitches them together into
X  a "multi-image" GIF.  The current limitations of the "divide and conquer"
X  algorithm are 36 or fewer X and Y multiples (so you are limited to "only"
X  36x36=1296 component images), and a final resolution limit in both the
X  X and Y directions of 65,535 (a limitation of "only" four billion pixels
X  or so).
X
X  The final image generated by MAKEMIG is a "multi-image" GIF file called
X  FRACTMIG.GIF.  In case you have other software that can't handle
X  multi-image GIF files, MAKEMIG includes a final (but commented out) call
X  to SIMPLGIF, a companion program that reads a GIF file that may contain
X  little tricks like multiple images and creates a simple GIF from it.
X  Fair warning: SIMPLGIF needs room to build a composite image while it
X  works, and it does that using a temporary disk file equal to the size
X  of the final image - and a 64Kx64K GIF image requires a 4GB temporary
X  disk file!
X
X<G>
X
XThe <G> command lets you give a startup parameter interactively.
X;
X;
X;
X~Topic=<X> Options Screen, Label=HELPXOPTS
X; This topic is online context-sensitive only.
X
X   Passes - see {Drawing Method}\
X   Fillcolor - see {Drawing Method}\
X   Floating Point Algorithm - see notes below\
X   Maximum Iterations - see {Image Calculation Parameters}\
X   Inside and Outside colors - see {Color Parameters}\
X   Savename and File Overwrite - see {File Parameters}\
X   Sound option - see {Sound Parameters}\
X   Log Palette - see {Logarithmic Palettes and Color Ranges}\
X   Biomorph Color - see {Biomorphs}\
X   Decomp Option - see {Decomposition}\
X
XYou can toggle the use of floating-point algorithms on this screen (see
X{"Limitations of Integer Math (And How We Cope)"}).  Whether floating
Xpoint is in use is shown on the <Tab> status screen.  If you have a
Xnon-Intel floating point chip which supports the full 387 instruction set,
Xsee the "FPU=" command in {Startup Parameters} to get the most out of your
Xchip.
X;
X;
X~Topic=<Y> Options Screen, Label=HELPYOPTS
X; This topic is online context-sensitive only.
X
X   Finite attractor - see{ Finite Attractors }\
X
X   Potential parameters - see{ Continuous Potential }\
X
X   Distance Estimator parameters - see{ Distance Estimator Method }\
X
X   Inversion parameters - see{ Inversion }\
X
X   Color cycling range - see{ Color Cycling Commands }\
X;
X;
X~Topic=Image Coordinates Screen, Label=HELPCOORDS
X; This topic is online context-sensitive only.
X
XYou can directly enter corner coordinates on this screen instead of
Xusing the zoom box to move around.  You can also use <F4> to reset
Xthe coordinates to the defaults for the current fractal type.
X
XThere are two formats for the display: corners or center-mag.  You can
Xtoggle between the two by using <F7>.
X
XIn corners mode, corner coordinate values are entered directly.  Usually
Xonly the top-left and bottom-right corners need be specified - the
Xbottom left corner can be entered as zeros to default to an ordinary
Xunrotated rectangular area.  For rotated or skewed images, the bottom
Xleft corner must also be specified.
X
XCenter-mag mode can only be used with unrotated unstretched images.
XIn this mode the image area is described by entering the coordinates for
Xthe center of the rectangle, and its magnification factor.
X;
X;
X;
X~Topic=Interrupting and Resuming
X
XFractint command keys can be loosely grouped as:
X
X o Keys which suspend calculation of the current image (if one is being
X   calculated) and automatically resume after the function.  <Tab>
X   (display status information) and <F1> (display help), are the only
X   keys in this group.
X
X o Keys which automatically trigger calculation of a new image.
X   Examples:  selecting a video mode (e.g. <F3>);  selecting a fractal
X   type using <T>;  using the <X> screen to change an option such as
X   maximum iterations.
X
X o Keys which do something, then wait for you to indicate what to do
X   next.  Examples:  <M> to go to main menu;  <C> to enter color cycling
X   mode;  <PageUp> to bring up a zoom box.  After using a command in this
X   group, calculation automatically resumes when you return from the
X   function (e.g. <Esc> from color cycling, <PageDn> to clear zoom box).
X   There are a few fractal types which cannot resume calculation, they
X   are noted below.  Note that after saving an image with <S>, you must
X   press <Enter> to clear the "saved" message from the screen and resume.
X
XAn image which is <S>aved before it completes can later be <R>estored and
Xcontinued. The calculation is automatically resumed when you restore such
Xan image.
X
XWhen a slow fractal type resumes after an interruption in the third
Xcategory above, there may be a lag while nothing visible happens.  This is
Xbecause most cases of resume restart at the beginning of a screen line.
XIf unsure, you can check whether calculation has resumed with the <Tab>
Xkey.
X
XThe following fractal types cannot (currently) be resumed: plasma, 3d
Xtransformations, julibrot, and 3d orbital types like lorenz3d.    To check
Xwhether resuming an image is possible, use the <Tab> key while it is
Xcalculating.  It is resumable unless there is a note under the fractal
Xtype saying it is not.
X
XThe {Batch Mode} section discusses how to resume in batch mode.
X
XTo <R>estore and resume a "formula", "lsystem", or "ifs" type fractal your
X"formulafile", "lfile", or "ifsfile" must contain the required name.
X;
X;
X;
X~Topic=Orbits Window, Label=HELP_ORBITS
XThe <O> key turns on the Orbit mode.  In this mode a cursor appears
Xover the fractal. A window appears showing the orbit used in the
Xcalculation of the color at the point where the cursor is. Move the
Xcursor around the fractal using the arrow keys or the mouse and watch
Xthe orbits change. Try entering the Orbits mode with View Windows (<V>)
Xturned on. The following keys take effect in Orbits mode.\
X<c>         Circle toggle - makes little circles with radii inversely\
X            proportional to the iteration. Press <c> again to toggle\
X            back to point-by-point display of orbits.\
X<l>         Line toggle - connects orbits with lines (can use with <c>)\
X<n>         Numbers toggle - shows coordinates of the cursor on the\
X            screen. Press <n> again to turn off numbers.\
X<p>         Enter pixel coordinates directly\
X<h>         Hide fractal toggle. Works only if View Windows is turned on\
X            and set for a small window (such as the default size.) Hides the\
X            fractal, allowing the orbit to take up the whole screen. Press\
X            <h> again to uncover the fractal.\
X<s>         Saves the fractal, cursor, orbits, and numbers as they appear\
X            on the screen.\
X<<> or <,>  Zoom orbits image smaller\
X<>> or <.>  Zoom orbits image larger\
X<z>         Restore default zoom.\
X;
X;
X;
X~Topic=View Window, Label=HELPVIEW
X
XThe <V> command is used to set the view window parameters described below.
XThese parameters can be used to:\
X o Define a small window on the screen which is to contain the generated
X   images. Using a small window speeds up calculation time (there are
X   fewer pixels to generate). You can use a small window to explore
X   quickly, then turn the view window off to recalculate the image at
X   full screen size.
X o Generate an image with a different "aspect ratio"; e.g. in a square
X   window or in a tall skinny rectangle.
X o View saved GIF images which have pixel dimensions different from any
X   mode supported by your hardware. This use of view windows occurs
X   automatically when you restore such an image.
X
X"Preview display"\
XSet this to "yes" to turn on view window, "no" for full screen display.
XWhile this is "no", the only view parameter which has any affect is "final
Xmedia aspect ratio". When a view window is being used, all other Fractint
Xfunctions continue to operate normally - you can zoom, color-cycle, and
Xall the rest.
X
X"Reduction factor"\
XWhen an explicit size is not given, this determines the view window size,
Xas a factor of the screen size.  E.g. a reduction factor of 2 makes the
Xwindow 1/2 as big as the screen in both dimensions.
X
X"Final media aspect ratio"\
XThis is the height of the final image you want, divided by the width. The
Xdefault is 0.75 because standard PC monitors have a height:width ratio of
X3:4. E.g. set this to 2.0 for an image twice as high as it is wide. The
Xeffect of this parameter is visible only when "preview display" is
Xenabled.
X
X"Crop starting coordinates"\
XThis parameter affects what happens when you change the aspect ratio. If
Xset to "no", then when you change aspect ratio, the prior image will be
Xsqueezed or stretched to fit into the new shape. If set to "yes", the
Xprior image is "cropped" to avoid squeezing or stretching.
X
X"Explicit size"\
XSetting these to non-zero values over-rides the "reduction factor" with
Xexplicit sizes in pixels. If only the "x pixels" size is specified, the "y
Xpixels" size is calculated automatically based on x and the aspect ratio.
X
XMore about final aspect ratio:    If you want to produce a high quality
Xhard-copy image which is say 8" high by 5" down, based on a vertical
X"slice" of an existing image, you could use a procedure like the
Xfollowing. You'll need some method of converting a GIF image to your final
Xmedia (slide or whatever) - Fractint can only do the whole job with a
XPostScript printer, it does not preserve aspect ratio with other printers.
X o restore the existing image\
X o set view parameters: preview to yes, reduction to anything (say 2),
X   aspect ratio to 1.6, and crop to yes
X o zoom, rotate, whatever, till you get the desired final image\
X o set preview display back to no\
X o trigger final calculation in some high res disk video mode, using the
X   appropriate video mode function key
X o print directly to a PostScript printer, or save the result as a GIF
X   file and use external utilities to convert to hard copy.
X;
X;
X;
X~Topic=\"3D\" Commands
X
XSee {\"3D\" Images} for details of these commands.
X
X<3>\
XRestore a saved image as a 3D "landscape", translating its color
Xinformation into "height". You will be prompted for all KINDS of options.
X
X<#>\
XRestore in 3D and overlay the result on the current screen.
X;
X;
X;
X~Topic=Video Mode Function Keys, Label=HELPVIDSEL
X
XFractint supports *so* many video modes that we've given up trying to
Xreserve a keyboard combination for each of them.
X
XAny supported video mode can be selected by going to the "Select Video Mode"
Xscreen (from main menu or by using <Delete>), then using the cursor up and down
Xarrow keys and/or <PageUp> and <PageDown> keys to highlight the desired mode,
Xthen pressing <Enter>.
X
XUp to 39 modes can be assigned to the keys F2-F10, SF1-SF10 <Shift>+<Fn>),
XCF1-CF10 (<Ctrl>+<Fn>), and AF1-AF10 (<Alt>+<Fn>).  The modes assigned to
Xfunction keys can be invoked directly by pressing the assigned key, without
Xgoing to the video mode selection screen.
X
X30 key combinations can be reassigned:    <F1> to <F10> combined with any of
X<Shift>, <Ctrl>, or <Alt>.
XThe video modes assigned to <F2> through <F10> can not be
Xchanged - these are assigned to the most common video modes, which might
Xbe used in demonstration files or batches.
X
XTo reassign a function key to a mode you often use, go to the "select
Xvideo mode" screen, highlight the video
Xmode, press the keypad (gray) <+> key, then press the desired
Xfunction key or key combination.  The new key assignment will be remembered
Xfor future runs.
X
XTo unassign a key (so that it doesn't invoke any video
Xmode), highlight the mode currently selected by the key and press the
Xkeypad (gray) <-> key.
X
XA note about the "select video modes" screen:
Xthe video modes which are displayed with a 'B' suffix in the number
Xof colors are modes which have no custom programming - they use the BIOS
Xand are S-L-O-W ones.
X
XSee {"Video Adapter Notes"} for comments about particular adapters.
X
XSee {"Disk-Video" Modes} for a description of these non-display modes.
X
XSee {"Customized Video Modes\, FRACTINT.CFG"} for information about
Xadding your own video modes.
X;
X;
X;
X~Topic=Hints
X
XRemember, you do NOT have to wait for the program to finish a full screen
Xdisplay before entering a command. If you see an interesting spot you want
Xto zoom in on while the screen is half-done, don't wait -- do it! If you
Xthink after seeing the first few lines that another video mode would look
Xbetter, go ahead -- Fractint will shift modes and start the redraw at
Xonce. When it finishes a display, it beeps and waits for your next
Xcommand.
X
XIn general, the most interesting areas are the "border" areas where the
Xcolors are changing rapidly. Zoom in on them for the best results. The
Xfirst Mandelbrot-set (default) fractal image has a large, solid-colored
Xinterior that is the slowest to display; there's nothing to be seen by
Xzooming there.
X
XPlotting time is directly proportional to the number of pixels in a
Xscreen, and hence increases with the resolution of the video mode.
XYou may want to start in a low-resolution mode for quick progress while
Xzooming in, and switch to a higher-resolution mode
Xwhen things get interesting. Or use the
Xsolid guessing mode and pre-empt with
Xa zoom before it finishes. Plotting time also varies with the maximum
Xiteration setting, the fractal type, and your choice of drawing mode.
XSolid-guessing (the default) is fastest, but it can be wrong:
Xperfectionists will want to use dual-pass mode (its first-pass preview is
Xhandy if you might zoom pre-emptively) or single-pass mode.
X
XWhen you start systematically exploring, you can save time (and hey, every
Xlittle bit helps -- these "objects" are INFINITE, remember!) by <S>aving
Xyour last screen in a session to a file, and then going straight to it the
Xnext time by using the command FRACTINT FRACTxxx (the .GIF extension is
Xassumed), or by starting Fractint normally and then using the <R> command
Xto reload the saved file. Or you could hit <B> to create a parameter file
Xentry with the "recipe" for a given image, and next time use the <@>
Xcommand to re-plot it.
X;
X;
X;
X~Topic=Fractint on Unix
X
XFractint has been ported to Unix to run under X Windows.  This version is
Xcalled "Xfractint".  Xfractint may be obtained by anonymous ftp to
Xsprite.Berkeley.EDU, in the file xfractnnn.shar.Z.
X
XXfractint is still under development and is not as reliable as the IBM PC
Xversion.
X
XContact Ken Shirriff ([e-mail]) for information on Xfractint.
X
XXfractint is a straight port of the IBM PC version.  Thus, it uses the
XIBM user interface.  If you do not have function keys, or Xfractint does
Xnot accept them from your keyboard, use the following key mappings:
X
X     IBM             Unix\
X     F1 to F10       Shift-1 to Shift-0\
X     INSERT          I\
X     DELETE          D\
X     PAGE_UP         U\
X     PAGE_DOWN       N\
X     LEFT_ARROW      H\
X     RIGHT_ARROW     L\
X     UP_ARROW        K\
X     DOWN_ARROW      J\
X     HOME            O\
X     END             E\
X     CTL_PLUS        \}\
X     CTL_MINUS       \{
X
XXfractint takes the following options:
X
X-onroot\
XPuts the image on the root window.
X
X-fast\
XUses a faster drawing technique.
X
X-disk\
XUses disk video.
X
X-geometry WxH[\{+-X}\{+-Y}]\
XChanges the geometry of the image window.
X
X-display displayname\
XSpecifies the X11 display to use.
X
X-private\
XAllocates the entire colormap (i.e. more colors).
X
X-share\
XShares the current colormap.
X
X-fixcolors n\
XUses only n colors.
X
X-slowdisplay\
XPrevents xfractint from hanging on the title page with slow displays.
X
X-simple\
XUses simpler keyboard handling, which makes debugging easier.
X
XCommon problems:
X
XIf you get the message "Couldn't find fractint.hlp", you can\
Xa) Do "setenv FRACTDIR /foo", replacing /foo with the directory containing
Xfractint.hlp.\
Xb) Run xfractint from the directory containing fractint.hlp, or\
Xc) Copy fractint.hlp to /usr/local/bin/X11/fractint
X
XIf you get the message "Invalid help signature", the problem is due to
Xbyteorder.  You are probably using a Sun help file on a Dec machine or
Xvice versa.
X
XIf xfractint doesn't accept input, try typing into both the graphics window
Xand the text window.  On some systems, only one of these works.
X
XIf you are using Openwindows and can't get xfractint to accept input, add
Xto your .Xdefaults file:\
XOpenWindows.FocusLenience:      True
X
XIf you cannot view the GIFs that xfractint creates, the problem is that
Xxfractint creates GIF89a format and your viewer probably only handles
XGIF87a format.  Run "xfractint gif87a=y" to produce GIF87a format.
X
XBecause many shifted characters are used to simulate IBM keys, you can't
Xenter capitalized filenames.
X;
X;
X;
X~Topic=Color Cycling Commands, Label=@ColorCycling
X
X~Doc-
XSee {=HELPCYCLING Color Cycling Command Summary} for a summary of commands.
X
X~Doc+
XColor-cycling mode is entered with the 'c', '+', or '-' keys from an image,
Xor with the 'c' key from Palette-Editing mode.
X
XThe color-cycling commands are available ONLY for VGA adapters and EGA
Xadapters in 640x350x16 mode.  You can also enter color-cycling while
Xusing a disk-video mode, to load or save a palette - other functions are
Xnot supported in disk-video.
X
XNote that the colors available on an EGA adapter (16 colors at a
Xtime out of a palette of 64) are limited compared to those of VGA, super-
XVGA, and MCGA (16 or 256 colors at a time out of a palette of 262,144). So
Xcolor-cycling in general looks a LOT better in the latter modes. Also,
Xbecause of the EGA palette restrictions, some commands are not available
Xwith EGA adapters.
X
XColor cycling applies to the color numbers selected by the "cyclerange="
Xcommand line parameter (also changeable via the <Y> options screen and via
Xthe palette editor).  By default, color numbers 1 to 255 inclusive are
Xcycled.  On some images you might want to set "inside=0" (<X> options or
Xcommand line parameter) to exclude the "lake" from color cycling.
X
XWhen you are in color-cycling mode, you will either see the screen colors
Xcycling, or will see a white "overscan" border when paused, as a reminder
Xthat you are still in this mode.  The keyboard commands available once
Xyou've entered color-cycling. are described below.
X
X<F1>\
XBring up a HELP screen with commands specific to color cycling mode.
X
X<Esc>\
XLeave color-cycling mode.
X
X<+> or <->\
XBegin cycling the palette by shifting each color to the next "contour."
X<+> cycles the colors in one direction, <-> in the other.
X
X'<' or '>'\
XForce a color-cycling pause, disable random colorizing, and single-step
Xthrough a one color-cycle.  For "fine-tuning" your image colors.
X
XCursor up/down\
XIncrease/decrease the cycling speed. High speeds may cause a harmless
Xflicker at the top of the screen.
X
X<F2> through <F10>\
XSwitches from simple rotation to color selection using randomly generated
Xcolor bands of short (F2) to long (F10) duration.
X
X<1> through <9>\
XCauses the screen to be updated every 'n' color cycles (the default is 1).
XHandy for slower computers.
X
X<Enter>\
XRandomly selects a function key (F2 through F10) and then updates ALL the
Xscreen colors prior to displaying them for instant, random colors.  Hit
Xthis over and over again (we do).
X
X<Spacebar>\
XPause cycling with white overscan area. Cycling restarts with any command
Xkey (including another spacebar).
X
X<Shift><F1>-<F10>\
XPause cycling and reset the palette to a preset two color "straight"
Xassignment, such as a spread from black to white. (Not for EGA)
X
X<Ctrl><F1>-<F10>\
XPause & set a 2-color cyclical assignment, e.g. red->yellow->red (not EGA).
X
X<Alt><F1>-<F10>\
XPause & set a 3-color cyclical assignment, e.g. green->white->blue (not EGA).
X
X<R>, <G>, <B>\
XPause and increase the red, green, or blue component of all colors by a
Xsmall amount (not for EGA). Note the case distinction of this vs:
X
X<r>, <g>, <b>\
XPause and decrease the red, green, or blue component of all colors by a
Xsmall amount (not for EGA).
X
X<D> or <A>\
XPause and load an external color map from the files DEFAULT.MAP or
XALTERN.MAP, supplied with the program.
X
X<L>\
XPause and load an external color map (.MAP file).  Several .MAP files are
Xsupplied with Fractint.  See {Palette Maps}.
X
X<S>\
XPause, prompt for a filename, and save the current palette to the named
Xfile (.MAP assumed).  See {Palette Maps}.
X;
X;
X;
X~Topic=Color Cycling Command Summary, Label=HELPCYCLING
X; This topic is online only
X
X~Format-
X  See {Color Cycling Commands} for full documentation.
X
X  F1           HELP! (Enter help mode and display this screen)
X  Esc           Exit from color-cycling mode
X  + or -       (re)-set the direction of the color-cycling
X~Doc-
X  \27 \26           (re)-set the direction of the color-cycling (just like +/-)
X  \24 \25           SpeedUp/SlowDown the color cycling process
X~Doc+,Online-
X  Right/Left Arrow (re)-set the direction of the color-cycling (just like +/-)
X  Up/Down Arrow    SpeedUp/SlowDown the color cycling process
X~Online+
X  F2 thru F10       Select Short--Medium--Long (randomly-generated) color bands
X  1  thru 9       Cycle through 'nn' colors between screen updates (default=1)
X  Enter        Randomly (re)-select all new colors    [TRY THIS ONE!]
X  Spacebar       Pause until another key is hit
X  < or >       Pause and single-step through one color-cycle
X* SF1 thru AF10    Pause and reset the Palette to one of 30 fixed sequences
X  d or a       pause and load the palette from DEFAULT.MAP or ALTERN.MAP
X  l           load palette from a map file
X  s           save palette to a map file
X* r or g or b or   force a pause and Lower (lower case) or Raise (upper case)
X* R or G or B       the Red, Green, or Blue component of the fractal image
X;
X;
X;
X~Topic=Palette Editing Commands
X
X~Doc-
XSee {=HELPXHAIR Palette Editing Command Summary} for a summary of commands.
X
X~Doc+
XPalette-editing mode provides a number of tools for modifying the colors
Xin an image.  It can be used only with MCGA or higher adapters, and only
Xwith 16 or 256 color video modes.
XMany thanks to Ethan Nagel for creating the palette editor.
X
XUse the <E> key to enter palette-editing mode from a displayed image or
Xfrom the main menu.
X
XWhen this mode is entered, an empty palette frame is displayed. You can
Xuse the cursor keys to position the frame outline, and <Pageup> and
X<Pagedn> to change its size.  (The upper and lower limits on the size
Xdepend on the current video mode.)  When the frame is positioned where you
Xwant it, hit Enter to display the current palette in the frame.
X
XNote that the palette frame shows R(ed) G(reen) and B(lue) values for two
Xcolor registers at the top.  The active color register has a solid frame,
Xthe inactive register's frame is dotted.  Within the active register, the
Xactive color component is framed.
X
XUsing the commands described below, you can assign particular colors to
Xthe registers and manipulate them.  Note that at any given time there are
Xtwo colors "X"d - these are pre-empted by the editor to display the
Xpalette frame. They can be edited but the results won't be visible. You
Xcan change which two colors are borrowed ("X"d out) by using the <v>
Xcommand.
X
XOnce the palette frame is displayed and filled in, the following commands
Xare available:
X
X<F1>\
XBring up a HELP screen with commands specific to palette-editing mode.
X
X<Esc>\
XLeave palette-editing mode
X
X<H>\
XHide the palette frame to see full image; the cross-hair remains visible
Xand all functions remain enabled; hit <H> again to restore the palette
Xdisplay.
X
XCursor keys\
XMove the cross-hair cursor around. In 'auto' mode (the default) the color
Xunder the center of the cross-hair is automatically assigned to the active
Xcolor register. Control-Cursor keys move the cross-hair faster. A mouse
Xcan also be used to move around.
X
X<R> <G> <B>\
XSelect the Red, Green, or Blue component of the active color register for
Xsubsequent commands
X
X<Insert> <Delete>\
XSelect previous or next color component in active register
X
X<+> <->\
XIncrease or decrease the active color component value by 1  Numeric keypad
X(gray) + and - keys do the same.
X
X<Pageup> <Pagedn>\
XIncrease or decrease the active color component value by 5; Moving the
Xmouse up/down with left button held is the same
X
X<0> <1> <2> <3> <4> <5>\
XSet the active color component's value to 0 10 20 ... 60
X
X<Space>\
XSelect the other color register as the active one.  In the default 'auto'
Xmode this results in the now-inactive register being set to remember the
Xcolor under the cursor, and the now-active register changing from whatever
Xit had previously remembered to now follow the color.
X
X<,> <.>\
XRotate the palette one step.  By default colors 1 through 255 inclusive
Xare rotated.  This range can be over-ridden with the "cyclerange"
Xparameter, the <Y> options screen, or the <O> command described below.
X
X"<" ">"\
XRotate the palette continuously (until next keystroke)
X
X<O>\
XSet the color cycling range to the range of colors currently defined by
Xthe color registers.
X
X<C>\
XEnter Color-Cycling Mode.  When you invoke color-cycling from here, it
Xwill subsequently return to palette-editing when you <Esc> from it.
XSee {Color Cycling Commands}.
X
X<=>\
XCreate a smoothly shaded range of colors between the colors selected by
Xthe two color registers.
X
X<M>\
XSpecify a gamma value for the shading created by <=>.
X
X<D>\
XDuplicate the inactive color register's values to the active color
Xregister.
X
X<T>\
XStripe-shade - create a smoothly shaded range of colors between the two
Xcolor registers, setting only every Nth register.  After hitting <T>, hit
Xa numeric key from 2 to 9 to specify N.  For example, if you press <T>
X<3>, smooth shading is done between the two color registers, affecting
Xonly every 3rd color between them.  The other colors between them remain
Xunchanged.
X
X<W>\
XConvert current palette to gray-scale.    (If the <X> or <Y> exclude ranges
Xdescribed later are in force, only the active range of colors is converted
Xto gray-scale.)
X
X<Shift-F2> ... <Shift-F9>\
XStore the current palette in a temporary save area associated with the
Xfunction key.  The temporary save palettes are useful for quickly
Xcomparing different palettes or the effect of some changes - see next
Xcommand.  The temporary palettes are only remembered until you exit from
Xpalette-editing mode.
X
X<F2> ... <F9>\
XRestore the palette from a temporary save area.  If you haven't previously
Xsaved a palette for the function key, you'll get a simple grey scale.
X
X<L>\
XPause and load an external color map (.MAP file).  See {Palette Maps}.
X
X<S>\
XPause, prompt for a filename, and save the current palette to the named
Xfile (.MAP assumed).  See {Palette Maps}.
X
X<I>\
XInvert frame colors.  With some colors the palette is easier to see when
Xthe frame colors are interchanged.
X~OnlineFF
X<\\>\
XMove or resize the palette frame.  The frame outline is drawn - it can
Xthen be repositioned and sized with the cursor keys, <Pageup> and
X<Pagedn>, just as was done when first entering palette-editing mode.  Hit
XEnter when done moving/sizing.
X
X<V>\
XUse the colors currently selected by the two color registers for the
Xpalette editor's frame.  When palette editing mode is entered, the last
Xtwo colors are "X"d out for use by the palette editor; this command can be
Xused to replace the default with two other color numbers.
X
X<A>\
XToggle 'auto' mode on or off.  When on (the default), the active color
Xregister follows the cursor; when off, <Enter> must be pressed to set the
Xactive register to the color under the cursor.
X
X<Enter>\
XOnly useful when 'auto' is off, as described above; double clicking the
Xleft mouse button is the same as Enter.
X
X<X>\
XToggle 'exclude' mode on or off - when toggled on, only those image pixels
Xwhich match the active color are displayed.
X
X<Y>\
XToggle 'exclude' range on or off - similar to <X>, but all pixels matching
Xcolors in the range of the two color registers are displayed.
X
X<N>\
XMake a negative color palette - will convert only current color if in 'x'
Xmode or range between editors in 'y' mode or entire palette if in "normal"
Xmode.
X
X<!>\
X<@>\
X<#>\
XSwap R<->G, G<->B, and R<->B columns. These keys are shifted 1, 2, and 3,
Xwhich you may find easier to remember.
X
X<U>\
XUndoes the last palette editor command.  Will undo all the way to the
Xbeginning of the current session.
X~OnlineFF
X<E>
XRedoes the undone palette editor commands.
X
X<F>\
XToggles "Freestyle mode" on and off (Freestyle mode changes a range of
Xpalette values smoothly from a center value outward).
XWith your cursor inside the palette box, press the <F> key to enter
XFreestyle mode.  A default range of colors will be selected for you
Xcentered at the cursor (the ends of the color range are noted by putting
Xdashed lines around the corresponding palette values). While in Freestyle
Xmode:
X
X Moving the mouse changes the location of the range of colors that are
X affected.
X
X Control-Insert/Delete or the shifted-right-mouse-button changes the
X size of the affected palette range.
X
X The normal color editing keys (R,G,B,1-6, etc) set the central color
X of the affected palette range.
X~OnlineFF
X Pressing ENTER or double-clicking the left mouse button makes the
X palette changes permanent (if you don't perform this step, any
X palette changes disappear when you press the <F> key again to exit
X freestyle mode).
X;
X;
X;
X~Topic=Palette Editing Command Summary, Label=HELPXHAIR
X; This topic is online only.
X
X~Format-
X  See {Palette Editing Commands} for full documentation.
X
X  F1           HELP! (Enter help mode and display this screen)
X  Esc           Exit from palette editing mode
X  h           Hide/unhide the palette frame
X  Cursor keys       Move the cross-hair cursor around. Control-Cursor keys
X           move faster. A mouse can also be used to move around.
X  r or g or b       Select the the Red, Green, or Blue component of the
X           active color register for subsequent commands
X  Insert or Delete Select previous or next color component in active register
X  + or -       Increase or decrease the active color component by 1
X  Pageup or Pagedn Increase or decrease the active color component by 5;
X           Moving the mouse up/down with left button held is the same
X  0 1 2 3 4 5 6    Set active color component to 0 10 20 ... 60
X  Space        Select the other color register as the active one
X  , or .       Rotate the palette one step
X  < or >       Rotate the palette continuously (until next keystroke)
X  c           Enter Color-Cycling Mode (see {=HELPCYCLING Color Cycling Commands})
X  =           Create a smoothly shaded range of colors
X  m           Set the gamma value for '='.
X~FF
X  d           Duplicate the inactive color register in active color
X  t           Stripe-shade; after hitting 't', hit a number from 2 to 9
X           which is used as stripe width
X  Shift-F2,F3,..F9 Store the current palette in a temporary save area
X           associated with the function key
X  F2,F3,...,F9       Restore the palette from a temporary save area
X  w           Convert palette (or current exclude range) to gray-scale
X  \\            Move or resize the palette frame
X  i           Invert frame colors, useful with dark colors
X  a           Toggle 'auto' mode on or off - when on, the active color
X           register follows the cursor; when off, Enter must be hit
X           to set the register to the color under the cursor
X  Enter        Only useful when 'auto' is off, as described above; double
X           clicking the left mouse button is the same as Enter
X  x           Toggle 'exclude' mode on or off
X  y           Toggle 'exclude' range on or off
X  o           Set the 'cyclerange' (range affected by color cycling
X           commands) to the range of the two registers
X  n           Make a negative color palette
X  u           Undoes the last command
X  e           Redoes the last undone command
X~FF
X  !           Swap red and green columns
X  @           Swap green and blue columns
X  #           Swap red and blue columns
X  f                Enter Palette-Editing Mode.  See {Palette Editing Commands}
X                   for details.
X;
X;
X; Fractal Types:
X~Include help2.src
X;
X; Doodads, 3D:
X~Include help3.src
X;
X; Parameters, Video Adapters & Modes:
X~Include help4.src
X;
X; The rest:
X~Include help5.src
X;
X;
SHAR_EOF
$TOUCH -am 1028230193 help.src &&
chmod 0644 help.src ||
echo "restore of help.src failed"
set `wc -c help.src`;Wc_c=$1
if test "$Wc_c" != "76566"; then
    echo original size 76566, current size $Wc_c
fi
# ============= help2.src ==============
echo "x - extracting help2.src (Text)"
sed 's/^X//' << 'SHAR_EOF' > help2.src &&
X~Topic=Summary of Fractal Types, Label=HELPFRACTALS
X~Format-
X~Doc-
XFor detailed descriptions, select a hot-link below, see {Fractal Types},
Xor use <F2> from the fractal type selection screen.
X~Doc+,Online-
XSUMMARY OF FRACTAL TYPES
X~Online+
X~CompressSpaces-
X;
X; Note that prompts.c pulls formulas out of the following for <Z> screen,
X; using the HF_xxx labels.  It assumes a rigid formatting structure for
X; the formulas:
X;    4 leading blanks (which get stripped on <Z> screen)
X;    lines no wider than 76 characters (not counting initial 4 spaces)
X;    formula ends at any of:
X;    blank line
X;    line which begins in column 1
X;    format ctl char (~xxx, {xxx}, \x)
X;
X
X{=HT_BARNS barnsleyj1}
X~Label=HF_BARNSJ1
X      z(0) = pixel;
X      z(n+1) = (z-1)*c if real(z) >= 0, else
X      z(n+1) = (z+1)*c
X    Two parameters: real and imaginary parts of c
X{=HT_BARNS barnsleyj2}
X~Label=HF_BARNSJ2
X      z(0) = pixel;
X      if real(z(n)) * imag(c) + real(c) * imag(z((n)) >= 0
X     z(n+1) = (z(n)-1)*c
X      else
X     z(n+1) = (z(n)+1)*c
X    Two parameters: real and imaginary parts of c
X{=HT_BARNS barnsleyj3}
X~Label=HF_BARNSJ3
X      z(0) = pixel;
X      if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
X     + i * (2*real(z((n)) * imag(z((n))) else
X      z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
X         + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
X    Two parameters: real and imaginary parts of c.
X~OnlineFF
X{=HT_BARNS barnsleym1}
X~Label=HF_BARNSM1
X      z(0) = c = pixel;
X      if real(z) >= 0 then
X    z(n+1) = (z-1)*c
X      else
X    z(n+1) = (z+1)*c.
X    Parameters are perturbations of z(0)
X{=HT_BARNS barnsleym2}
X~Label=HF_BARNSM2
X      z(0) = c = pixel;
X      if real(z)*imag(c) + real(c)*imag(z) >= 0
X    z(n+1) = (z-1)*c
X      else
X    z(n+1) = (z+1)*c
X    Parameters are perturbations of z(0)
X{=HT_BARNS barnsleym3}
X~Label=HF_BARNSM3
X      z(0) = c = pixel;
X      if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
X     + i * (2*real(z((n)) * imag(z((n))) else
X      z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
X     + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
X    Parameters are perturbations of z(0)
X~OnlineFF
X
X{=HT_BIF bifurcation}
X~Label=HF_BIFURCATION
X    Pictorial representation of a population growth model.
X      Let P = new population, p = oldpopulation, r = growth rate
X      The model is: P = p + r*fn(p)*(1-fn(p)).
X    Three parameters: Filter Cycles, Seed Population, and Function.
X{=HT_BIF bif+sinpi}
X~Label=HF_BIFPLUSSINPI
X    Bifurcation variation: model is: P = p + r*fn(PI*p).
X    Three parameters: Filter Cycles, Seed Population, and Function.
X{=HT_BIF bif=sinpi}
X~Label=HF_BIFEQSINPI
X    Bifurcation variation: model is: P = r*fn(PI*p).
X    Three parameters: Filter Cycles, Seed Population, and Function.
X{=HT_BIF biflambda}
X~Label=HF_BIFLAMBDA
X    Bifurcation variation: model is: P = r*fn(p)*(1-fn(p)).
X    Three parameters: Filter Cycles, Seed Population, and Function.
X{=HT_BIF bifstewart}
X~Label=HF_BIFSTEWART
X    Bifurcation variation: model is: P = (r*fn(p)*fn(p)) - 1.
X    Three parameters: Filter Cycles, Seed Population, and Function.
X{=HT_BIF bifmay}
X~Label=HF_BIFMAY
X    Bifurcation variation: model is: P = r*p / ((1+p)^beta).
X    Three parameters: Filter Cycles, Seed Population, and Beta.
X~OnlineFF
X
X{=HT_CELLULAR cellular}
X~Label=HF_CELLULAR
X    One-dimensional cellular automata or line automata.  The type of CA
X    is given by kr, where k is the number of different states of the
X    automata and r is the radius of the neighborhood.  The next generation
X    is determined by the sum of the neighborhood and the specified rule.
X    Four parameters: Initial String, Rule, Type, and Starting Row Number.
X    For Type = 21, 31, 41, 51, 61, 22, 32, 42, 23, 33, 24, 25, 26, 27
X        Rule =  4,  7, 10, 13, 16,  6, 11, 16,  8, 15, 10, 12, 14, 16 digits
X
X{=HT_CIRCLE circle}
X~Label=HF_CIRCLE
X    Circle pattern by John Connett
X      x + iy = pixel
X      z = a*(x^2 + y^2)
X      c = integer part of z
X      color = c modulo(number of colors)
X
X{=HT_MARKS cmplxmarksjul}
X~Label=HF_CMPLXMARKSJUL
X    A generalization of the marksjulia fractal.
X      z(0) = pixel;
X      z(n+1) = (c^exp)*z(n)^2 + c.
X    Four parameters: real and imaginary parts of c and exp.
X~OnlineFF
X
X{=HT_MARKS cmplxmarksmand}
X~Label=HF_CMPLXMARKSMAND
X    A generalization of the marksmandel fractal.
X      z(0) = c = pixel;
X      z(n+1) = (c^exp)*z(n)^2 + c.
X    Four parameters: real and imaginary parts of
X    perturbation of z(0) and exp.
X
X{=HT_NEWTCMPLX complexnewton\, complexbasin}
X~Label=HF_COMPLEXNEWT
X    Newton fractal types extended to complex degrees. Complexnewton
X    colors pixels according to the number of iterations required to
X    escape to a root. Complexbasin colors pixels according to which
X    root captures the orbit. The equation is based on the newton
X    formula for solving the equation z^p = r
X      z(0) = pixel;
X      z(n+1) = ((p - 1) * z(n)^p + r)/(p * z(n)^(p - 1)).
X    Four parameters: real & imaginary parts of degree p and root r
X
X{=HT_DIFFUS diffusion}
X~Label=HF_DIFFUS
X    Diffusion Limited Aggregation.  Randomly moving points
X    accumulate.  Two parameters: border width (default 10), type
X~OnlineFF
X
X{=HT_DYNAM dynamic}
X~Label=HF_DYNAM
X    Time-discrete dynamic system.
X      x(0) = y(0) = start position.
X      y(n+1) = y(n) + f( x(n) )
X      x(n+1) = x(n) - f( y(n) )
X      f(k) = sin(k + a*fn1(b*k))
X    For implicit Euler approximation: x(n+1) = x(n) - f( y(n+1) )
X    Five parameters: start position step, dt, a, b, and the function fn1.
X
X{=HT_SCOTSKIN fn+fn(pix)}
X~Label=HF_FNPLUSFNPIX
X      c = z(0) = pixel;
X      z(n+1) = fn1(z) + p*fn2(c)
X    Six parameters: real and imaginary parts of the perturbation
X    of z(0) and factor p, and the functions fn1, and fn2.
X
X{=HT_SCOTSKIN fn(z*z)}
X~Label=HF_FNZTIMESZ
X      z(0) = pixel;
X      z(n+1) = fn(z(n)*z(n))
X    One parameter: the function fn.
X~OnlineFF
X
X{=HT_SCOTSKIN fn*fn}
X~Label=HF_FNTIMESFN
X      z(0) = pixel; z(n+1) = fn1(n)*fn2(n)
X    Two parameters: the functions fn1 and fn2.
X
X{=HT_SCOTSKIN fn*z+z}
X~Label=HF_FNXZPLUSZ
X      z(0) = pixel; z(n+1) = p1*fn(z(n))*z(n) + p2*z(n)
X    Five parameters: the real and imaginary components of
X    p1 and p2, and the function fn.
X
X{=HT_SCOTSKIN fn+fn}
X~Label=HF_FNPLUSFN
X      z(0) = pixel;
X      z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
X    Six parameters: The real and imaginary components of
X    p1 and p2, and the functions fn1 and fn2.
X
X{=HT_FORMULA formula}
X    Formula interpreter - write your own formulas as text files!
X~OnlineFF
X
X{=HT_FROTH frothybasin}
X~Label=HF_FROTH
X    Pixel color is determined by which attractor captures the orbit.  The
X    shade of color is determined by the number of iterations required to
X    capture the orbit.
X      z(0) = pixel;  z(n+1) = z(n)^2 - c*conj(z(n))
X      where c = 1 + ai,  and  a = 1.02871376822...
X
X{=HT_GINGER gingerbread}
X~Label=HF_GINGER
X    Orbit in two dimensions defined by:
X      x(n+1) = 1 - y(n) + |x(n)|
X      y(n+1) = x(n)
X    Two parameters: initial values of x(0) and y(0).
X
X{=HT_HALLEY halley}
X~Label=HF_HALLEY
X      Halley map for the function: F = z(z^a - 1) = 0
X      z(0) = pixel;
X      z(n+1) = z(n) - R * F / [F' - (F" * F / 2 * F')]
X      bailout when: abs(mod(z(n+1)) - mod(z(n)) < epsilon
X    Three parameters: order of z (a), relaxation coefficient (R),
X                      small number for bailout (epsilon).
X~OnlineFF
X{=HT_HENON henon}
X~Label=HF_HENON
X    Orbit in two dimensions defined by:
X      x(n+1) = 1 + y(n) - a*x(n)*x(n)
X      y(n+1) = b*x(n)
X    Two parameters: a and b
X
X{=HT_MARTIN hopalong}
X~Label=HF_HOPALONG
X    Hopalong attractor by Barry Martin - orbit in two dimensions.
X      z(0) = y(0) = 0;
X      x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))
X      y(n+1) = a - x(n)
X    Parameters are a, b, and c.
X
X{=HT_HYPERC hypercomplex}
X~Label=HF_HYPERC
X    HyperComplex Mandelbrot set.
X      h(0)   = (0,0,0,0)
X      h(n+1) = fn(h(n)) + C.
X      where "fn" is sin, cos, log, sqr etc.
X    Two parameters: cj, ck
X    C = (xpixel,ypixel,cj,ck)
X~OnlineFF
X
X{=HT_HYPERC hypercomplexj}
X~Label=HF_HYPERCJ
X    HyperComplex Julia set.
X      h(0)   = (xpixel,ypixel,zj,zk)
X      h(n+1) = fn(h(n)) + C.
X      where "fn" is sin, cos, log, sqr etc.
X    Six parameters: c1, ci, cj, ck
X    C = (c1,ci,cj,ck)
X
X{=HT_ICON icon, icon3d}
X~Label=HF_ICON
X    Orbit in three dimensions defined by:
X      p = lambda + alpha * magnitude + beta * (x(n)*zreal - y(n)*zimag)
X      x(n+1) = p * x(n) + gamma * zreal - omega * y(n)
X      y(n+1) = p * y(n) - gamma * zimag + omega * x(n)
X      (3D version uses magnitude for z)
X      Parameters:  Lambda, Alpha, Beta, Gamma, Omega, and Degree
X
X{=HT_IFS IFS}
X    Barnsley IFS (Iterated Function System) fractals. Apply
X    contractive affine mappings.
X~OnlineFF
X
X{=HT_PICKMJ julfn+exp}
X~Label=HF_JULFNPLUSEXP
X    A generalized Clifford Pickover fractal.
X      z(0) = pixel;
X      z(n+1) = fn(z(n)) + e^z(n) + c.
X    Three parameters: real & imaginary parts of c, and fn
X
X{=HT_PICKMJ julfn+zsqrd}
X~Label=HF_JULFNPLUSZSQRD
X      z(0) = pixel;
X      z(n+1) = fn(z(n)) + z(n)^2 + c
X    Three parameters: real & imaginary parts of c, and fn
X
X{=HT_JULIA julia}
X~Label=HF_JULIA
X    Classic Julia set fractal.
X      z(0) = pixel; z(n+1) = z(n)^2 + c.
X    Two parameters: real and imaginary parts of c.
X~OnlineFF
X
X{=HT_INVERSE julia_inverse}
X~Label=HF_INVERSE
X    Inverse Julia function - "orbit" traces Julia set in two dimensions.
X      z(0) = a point on the Julia Set boundary; z(n+1) = +- sqrt(z(n) - c)
X    Parameters: Real and Imaginary parts of c
X           Maximum Hits per Pixel (similar to max iters)
X           Breadth First, Depth First or Random Walk Tree Traversal
X           Left or Right First Branching (in Depth First mode only)
X        Try each traversal method, keeping everything else the same.
X        Notice the differences in the way the image evolves.  Start with
X        a fairly low Maximum Hit limit, then increase it.  The hit limit
X        cannot be higher than the maximum colors in your video mode.
X
X{=HT_FNORFN julia(fn||fn)}
X~Label=HF_JULIAFNFN
X      z(0) = pixel;
X      if modulus(z(n)) < shift value, then
X         z(n+1) = fn1(z(n)) + c,
X      else
X         z(n+1) = fn2(z(n)) + c.
X    Five parameters: real, imaginary portions of c, shift value,
X                     fn1 and fn2.
X~OnlineFF
X
X{=HT_MANDJUL4 julia4}
X~Label=HF_JULIA4
X    Fourth-power Julia set fractals, a special case
X    of julzpower kept for speed.
X      z(0) = pixel;
X      z(n+1) = z(n)^4 + c.
X    Two parameters: real and imaginary parts of c.
X
X{=HT_JULIBROT julibrot}
X    'Julibrot' 4-dimensional fractals.
X
X{=HT_PICKMJ julzpower}
X~Label=HF_JULZPOWER
X      z(0) = pixel;
X      z(n+1) = z(n)^m + c.
X    Three parameters: real & imaginary parts of c, exponent m
X
X{=HT_PICKMJ julzzpwr}
X~Label=HF_JULZZPWR
X      z(0) = pixel;
X      z(n+1) = z(n)^z(n) + z(n)^m + c.
X    Three parameters: real & imaginary parts of c, exponent m
X~OnlineFF
X
X{=HT_KAM kamtorus, kamtorus3d}
X~Label=HF_KAM
X    Series of orbits superimposed.
X    3d version has 'orbit' the z dimension.
X      x(0) = y(0) = orbit/3;
X      x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)
X      y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)
X    After each orbit, 'orbit' is incremented by a step size.
X    Parameters: a, step size, stop value for 'orbit', and
X    points per orbit.
X
X{=HT_LAMBDA lambda}
X~Label=HF_LAMBDA
X    Classic Lambda fractal. 'Julia' variant of Mandellambda.
X      z(0) = pixel;
X      z(n+1) = lambda*z(n)*(1 - z(n)).
X    Two parameters: real and imaginary parts of lambda.
X
X{=HT_LAMBDAFN lambdafn}
X~Label=HF_LAMBDAFN
X      z(0) = pixel;
X      z(n+1) = lambda * fn(z(n)).
X    Three parameters: real, imag portions of lambda, and fn
X~OnlineFF
X
X{=HT_FNORFN lambda(fn||fn)}
X~Label=HF_LAMBDAFNFN
X      z(0) = pixel;
X      if modulus(z(n)) < shift value, then
X         z(n+1) = lambda * fn1(z(n)),
X      else
X         z(n+1) = lambda * fn2(z(n)).
X    Five parameters: real, imaginary portions of lambda, shift value,
X                     fn1 and fn2.
X
X{=HT_LORENZ lorenz, lorenz3d}
X~Label=HF_LORENZ
X    Lorenz two lobe attractor - orbit in three dimensions.
X    In 2d the x and y components are projected to form the image.
X      z(0) = y(0) = z(0) = 1;
X      x(n+1) = x(n) + (-a*x(n)*dt) + (     a*y(n)*dt)
X      y(n+1) = y(n) + ( b*x(n)*dt) - (       y(n)*dt) - (z(n)*x(n)*dt)
X      z(n+1) = z(n) + (-c*z(n)*dt) + (x(n)*y(n)*dt)
X    Parameters are dt, a, b, and c.
X~OnlineFF
X
X{=HT_LORENZ lorenz3d1}
X~Label=HF_LORENZ3D1
X    Lorenz one lobe attractor - orbit in three dimensions.
X    The original formulas were developed by Rick Miranda and Emily Stone.
X      z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
X      x(n+1) = x(n) + (-a*dt-dt)*x(n) + (a*dt-b*dt)*y(n)
X         + (dt-a*dt)*norm + y(n)*dt*z(n)
X      y(n+1) = y(n) + (b*dt-a*dt)*x(n) - (a*dt+dt)*y(n)
X         + (b*dt+a*dt)*norm - x(n)*dt*z(n) - norm*z(n)*dt
X      z(n+1) = z(n) +(y(n)*dt/2) - c*dt*z(n)
X    Parameters are dt, a, b, and c.
X~OnlineFF
X
X{=HT_LORENZ lorenz3d3}
X~Label=HF_LORENZ3D3
X    Lorenz three lobe attractor - orbit in three dimensions.
X    The original formulas were developed by Rick Miranda and Emily Stone.
X      z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
X      x(n+1) = x(n) +(-(a*dt+dt)*x(n) + (a*dt-b*dt+z(n)*dt)*y(n))/3
X          + ((dt-a*dt)*(x(n)^2-y(n)^2)
X          + 2*(b*dt+a*dt-z(n)*dt)*x(n)*y(n))/(3*norm)
X      y(n+1) = y(n) +((b*dt-a*dt-z(n)*dt)*x(n) - (a*dt+dt)*y(n))/3
X          + (2*(a*dt-dt)*x(n)*y(n)
X          + (b*dt+a*dt-z(n)*dt)*(x(n)^2-y(n)^2))/(3*norm)
X      z(n+1) = z(n) +(3*x(n)*dt*x(n)*y(n)-y(n)*dt*y(n)^2)/2 - c*dt*z(n)
X    Parameters are dt, a, b, and c.
X~OnlineFF
X{=HT_LORENZ lorenz3d4}
X~Label=HF_LORENZ3D4
X    Lorenz four lobe attractor - orbit in three dimensions.
X    The original formulas were developed by Rick Miranda and Emily Stone.
X      z(0) = y(0) = z(0) = 1;
X      x(n+1) = x(n) +(-a*dt*x(n)^3
X         + (2*a*dt+b*dt-z(n)*dt)*x(n)^2*y(n) + (a*dt-2*dt)*x(n)*y(n)^2
X         + (z(n)*dt-b*dt)*y(n)^3) / (2 * (x(n)^2+y(n)^2))
X      y(n+1) = y(n) +((b*dt-z(n)*dt)*x(n)^3 + (a*dt-2*dt)*x(n)^2*y(n)
X         + (-2*a*dt-b*dt+z(n)*dt)*x(n)*y(n)^2
X         - a*dt*y(n)^3) / (2 * (x(n)^2+y(n)^2))
X      z(n+1) = z(n) +(2*x(n)*dt*x(n)^2*y(n) - 2*x(n)*dt*y(n)^3 - c*dt*z(n))
X    Parameters are dt, a, b, and c.
X
X{=HT_LSYS lsystem}
X    Using a turtle-graphics control language and starting with
X    an initial axiom string, carries out string substitutions the
X    specified number of times (the order), and plots the resulting.
X
X{=HT_LYAPUNOV lyapunov}
X    Derived from the Bifurcation fractal, the Lyapunov plots the Lyapunov
X    Exponent for a population model where the Growth parameter varies between
X    two values in a periodic manner.
X~OnlineFF
X
X{=HT_MAGNET magnet1j}
X~Label=HF_MAGJ1
X      z(0) = pixel;
X        [  z(n)^2 + (c-1)  ] 2
X      z(n+1) =    | ---------------- |
X        [  2*z(n) + (c-2)  ]
X    Parameters: the real and imaginary parts of c
X
X{=HT_MAGNET magnet1m}
X~Label=HF_MAGM1
X      z(0) = 0; c = pixel;
X        [  z(n)^2 + (c-1)  ] 2
X      z(n+1) =    | ---------------- |
X        [  2*z(n) + (c-2)  ]
X    Parameters: the real & imaginary parts of perturbation of z(0)
X
X{=HT_MAGNET magnet2j}
X~Label=HF_MAGJ2
X      z(0) = pixel;
X        [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)           ] 2
X      z(n+1) =    |  -------------------------------------------- |
X        [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]
X    Parameters: the real and imaginary parts of c
X~OnlineFF
X{=HT_MAGNET magnet2m}
X~Label=HF_MAGM2
X      z(0) = 0; c = pixel;
X        [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)           ] 2
X      z(n+1) =    |  -------------------------------------------- |
X        [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]
X    Parameters: the real and imaginary parts of perturbation of z(0)
X
X{=HT_MANDEL mandel}
X~Label=HF_MANDEL
X    Classic Mandelbrot set fractal.
X      z(0) = c = pixel;
X      z(n+1) = z(n)^2 + c.
X    Two parameters: real & imaginary perturbations of z(0)
X
X{=HT_FNORFN mandel(fn||fn)}
X~Label=HF_MANDELFNFN
X      c = pixel;
X      z(0) = p1
X      if modulus(z(n)) < shift value, then
X         z(n+1) = fn1(z(n)) + c,
X      else
X         z(n+1) = fn2(z(n)) + c.
X    Five parameters: real, imaginary portions of p1, shift value,
X                     fn1 and fn2.
X~OnlineFF
X
X{=HT_MANDELCLOUD mandelcloud}
X~Label=HF_MANDELCLOUD
X    Displays orbits of Mandelbrot set:
X      z(0) = c = pixel;
X      z(n+1) = z(n)^2 + c.
X    One parameter: number of intervals
X
X{=HT_MANDJUL4 mandel4}
X~Label=HF_MANDEL4
X    Special case of mandelzpower kept for speed.
X      z(0) = c = pixel;
X      z(n+1) = z(n)^4 + c.
X    Parameters: real & imaginary perturbations of z(0)
X
X{=HT_MANDFN mandelfn}
X~Label=HF_MANDFN
X      z(0) = c = pixel;
X      z(n+1) = c*fn(z(n)).
X    Parameters: real & imaginary perturbations of z(0), and fn
X~OnlineFF
X
X{=HT_FNORFN manlam(fn||fn)}
X~Label=HF_MANLAMFNFN
X      c = pixel;
X      z(0) = p1
X      if modulus(z(n)) < shift value, then
X         z(n+1) = fn1(z(n)) * c, else
X         z(n+1) = fn2(z(n)) * c.
X    Five parameters: real, imaginary parts of p1, shift value, fn1, fn2.
X
X{=HT_MARTIN Martin}
X~Label=HF_MARTIN
X    Attractor fractal by Barry Martin - orbit in two dimensions.
X      z(0) = y(0) = 0;
X      x(n+1) = y(n) - sin(x(n))
X      y(n+1) = a - x(n)
X    Parameter is a (try a value near pi)
X
X{=HT_MLAMBDA mandellambda}
X~Label=HF_MLAMBDA
X      z(0) = .5; lambda = pixel;
X      z(n+1) = lambda*z(n)*(1 - z(n)).
X    Parameters: real & imaginary perturbations of z(0)
X~OnlineFF
X
X{=HT_PHOENIX mandphoenix}
X~Label=HF_MANDPHOENIX
X      z(0) = p1, y(0) = 0;
X      For degree of Z = 0:
X        z(n+1) = z(n)^2 + pixel.x + (pixel.y)y(n), y(n+1) = z(n)
X      For degree of Z >= 2:
X        z(n+1) = z(n)^degree + pz(n)^(degree-1) + qy(n), y(n+1) = z(n)
X      For degree of Z <= -3:
X        z(n+1) = z(n)^|degree| + pz(n)^(|degree|-2) + qy(n), y(n+1) = z(n)
X    Three parameters: real part of z(0), imaginary part of z(0), and the
X      degree of Z.
X
X{=HT_PICKMJ manfn+exp}
X~Label=HF_MANDFNPLUSEXP
X    'Mandelbrot-Equivalent' for the julfn+exp fractal.
X      z(0) = c = pixel;
X      z(n+1) = fn(z(n)) + e^z(n) + C.
X    Parameters: real & imaginary perturbations of z(0), and fn
X~OnlineFF
X
X{=HT_PICKMJ manfn+zsqrd}
X~Label=HF_MANDFNPLUSZSQRD
X    'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.
X      z(0) = c = pixel;
X      z(n+1) = fn(z(n)) + z(n)^2 + c.
X    Parameters: real & imaginary perturbations of z(0), and fn
X
X{=HT_SCOTSKIN manowar}
X~Label=HF_MANOWAR
X      c = z1(0) = z(0) = pixel;
X      z(n+1) = z(n)^2 + z1(n) + c;
X      z1(n+1) = z(n);
X    Parameters: real & imaginary perturbations of z(0)
X
X{=HT_SCOTSKIN manowar}
X~Label=HF_MANOWARJ
X      z1(0) = z(0) = pixel;
X      z(n+1) = z(n)^2 + z1(n) + c;
X      z1(n+1) = z(n);
X    Parameters: real & imaginary perturbations of c
X~OnlineFF
X
X{=HT_PICKMJ manzpower}
X~Label=HF_MANZPOWER
X    'Mandelbrot-Equivalent' for julzpower.
X      z(0) = c = pixel;
X      z(n+1) = z(n)^exp + c; try exp = e = 2.71828...
X    Parameters: real & imaginary perturbations of z(0), real &
X    imaginary parts of exponent exp.
X
X{=HT_PICKMJ manzzpwr}
X~Label=HF_MANZZPWR
X    'Mandelbrot-Equivalent' for the julzzpwr fractal.
X      z(0) = c = pixel
X      z(n+1) = z(n)^z(n) + z(n)^exp + C.
X    Parameters: real & imaginary perturbations of z(0), and exponent
X
X{=HT_MARKS marksjulia}
X~Label=HF_MARKSJULIA
X    A variant of the julia-lambda fractal.
X      z(0) = pixel;
X      z(n+1) = (c^exp)*z(n)^2 + c.
X    Parameters: real & imaginary parts of c, and exponent
X~OnlineFF
X
X{=HT_MARKS marksmandel}
X~Label=HF_MARKSMAND
X    A variant of the mandel-lambda fractal.
X      z(0) = c = pixel;
X      z(n+1) = (c^exp)*z(n)^2 + c.
X    Parameters: real & imaginary perturbations of z(0), and exponent
X
X{=HT_MARKS marksmandelpwr}
X~Label=HF_MARKSMANDPWR
X    The marksmandelpwr formula type generalized (it previously
X    had fn=sqr hard coded).
X      z(0) = pixel, c = z(0) ^ (z(0) - 1):
X      z(n+1) = c * fn(z(n)) + pixel,
X    Parameters: real and imaginary perturbations of z(0), and fn
X
X{=HT_NEWTBAS newtbasin}
X~Label=HF_NEWTBAS
X    Based on the Newton formula for finding the roots of z^p - 1.
X    Pixels are colored according to which root captures the orbit.
X      z(0) = pixel;
X      z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
X    Two parameters: the polynomial degree p, and a flag to turn
X    on color stripes to show alternate iterations.
X~OnlineFF
X
X{=HT_NEWT newton}
X~Label=HF_NEWT
X    Based on the Newton formula for finding the roots of z^p - 1.
X    Pixels are colored according to the iteration when the orbit
X    is captured by a root.
X      z(0) = pixel;
X      z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
X    One parameter: the polynomial degree p.
X
X{=HT_PHOENIX phoenix}
X~Label=HF_PHOENIX
X      z(0) = pixel, y(0) = 0;
X      For degree of Z = 0: z(n+1) = z(n)^2 + p + qy(n), y(n+1) = z(n)
X      For degree of Z >= 2:
X        z(n+1) = z(n)^degree + pz(n)^(degree-1) + qy(n), y(n+1) = z(n)
X      For degree of Z <= -3:
X        z(n+1) = z(n)^|degree| + pz(n)^(|degree|-2) + qy(n), y(n+1) = z(n)
X    Three parameters: real p, real q, and the degree of Z.
X~OnlineFF
X{=HT_PICK pickover}
X~Label=HF_PICKOVER
X    Orbit in three dimensions defined by:
X      x(n+1) = sin(a*y(n)) - z(n)*cos(b*x(n))
X      y(n+1) = z(n)*sin(c*x(n)) - cos(d*y(n))
X      z(n+1) = sin(x(n))
X    Parameters: a, b, c, and d.
X
X{=HT_PLASMA plasma}
X~Label=HF_PLASMA
X    Random, cloud-like formations.  Requires 4 or more colors.
X    A recursive algorithm repeatedly subdivides the screen and
X    colors pixels according to an average of surrounding pixels
X    and a random color, less random as the grid size decreases.
X    Four parameters: 'graininess' (.5 to 50, default = 2), old/new
X    algorithm, seed value used, 16-bit out output selection.
X
X{=HT_POPCORN popcorn}
X~Label=HF_POPCORN
X    The orbits in two dimensions defined by:
X      x(0) = xpixel, y(0) = ypixel;
X      x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
X      y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
X    are plotted for each screen pixel and superimposed.
X    One parameter: step size h.
X~OnlineFF
X
X{=HT_POPCORN popcornjul}
X~Label=HF_POPCJUL
X    Conventional Julia using the popcorn formula:
X      x(0) = xpixel, y(0) = ypixel;
X      x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
X      y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
X    One parameter: step size h.
X
X{=HT_QUAT quatjul}
X~Label=HF_QUATJ
X    Quaternion Julia set.
X      q(0)   = (xpixel,ypixel,zj,zk)
X      q(n+1) = q(n)*q(n) + c.
X    Four parameters: c, ci, cj, ck
X    c = (c1,ci,cj,ck)
X
X{=HT_QUAT quat}
X~Label=HF_QUAT
X    Quaternion Mandelbrot set.
X      q(0)   = (0,0,0,0)
X      q(n+1) = q(n)*q(n) + c.
X    Two parameters: cj,ck
X    c = (xpixel,ypixel,cj,ck)
X~OnlineFF
X
X{=HT_ROSS rossler3D}
X~Label=HF_ROSS
X    Orbit in three dimensions defined by:
X      x(0) = y(0) = z(0) = 1;
X      x(n+1) = x(n) - y(n)*dt -   z(n)*dt
X      y(n+1) = y(n) + x(n)*dt + a*y(n)*dt
X      z(n+1) = z(n) + b*dt + x(n)*z(n)*dt - c*z(n)*dt
X    Parameters are dt, a, b, and c.
X
X{=HT_SIER sierpinski}
X~Label=HF_SIER
X    Sierpinski gasket - Julia set producing a 'Swiss cheese triangle'
X      z(n+1) = (2*x,2*y-1) if y > .5;
X      else (2*x-1,2*y) if x > .5;
X      else (2*x,2*y)
X    No parameters.
X
X{=HT_SCOTSKIN spider}
X~Label=HF_SPIDER
X      c(0) = z(0) = pixel;
X      z(n+1) = z(n)^2 + c(n);
X      c(n+1) = c(n)/2 + z(n+1)
X    Parameters: real & imaginary perturbation of z(0)
X~OnlineFF
X
X{=HT_SCOTSKIN sqr(1/fn)}
X~Label=HF_SQROVFN
X      z(0) = pixel;
X      z(n+1) = (1/fn(z(n))^2
X    One parameter: the function fn.
X
X{=HT_SCOTSKIN sqr(fn)}
X~Label=HF_SQRFN
X      z(0) = pixel;
X      z(n+1) = fn(z(n))^2
X    One parameter: the function fn.
X
X{=HT_TEST test}
X~Label=HF_TEST
X    'test' point letting us (and you!) easily add fractal types via
X    the c module testpt.c.  Default set up is a mandelbrot fractal.
X    Four parameters: user hooks (not used by default testpt.c).
X
X{=HT_SCOTSKIN tetrate}
X~Label=HF_TETRATE
X      z(0) = c = pixel;
X      z(n+1) = c^z(n)
X    Parameters: real & imaginary perturbation of z(0)
X~OnlineFF
X
X{=HT_MARKS tim's_error}
X~Label=HF_TIMSERR
X    A serendipitous coding error in marksmandelpwr brings to life
X    an ancient pterodactyl!  (Try setting fn to sqr.)
X      z(0) = pixel, c = z(0) ^ (z(0) - 1):
X      tmp = fn(z(n))
X      real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c);
X      imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c);
X      z(n+1) = tmp + pixel;
X    Parameters: real & imaginary perturbations of z(0) and function fn
X
X{=HT_UNITY unity}
X~Label=HF_UNITY
X      z(0) = pixel;
X      x = real(z(n)), y = imag(z(n))
X      One = x^2 + y^2;
X      y = (2 - One) * x;
X      x = (2 - One) * y;
X      z(n+1) = x + i*y
X    No parameters.
X~CompressSpaces+
X;
X;
X;
X~Topic=Fractal Types
X
XA list of the fractal types and their mathematics can be found in the
X{Summary of Fractal Types}.  Some notes about how Fractint calculates
Xthem are in "A Little Code" in {"Fractals and the PC"}.
X
XFractint starts by default with the Mandelbrot set. You can change that by
Xusing the command-line argument "TYPE=" followed by one of the
Xfractal type names, or by using the <T> command and
Xselecting the type - if parameters are needed, you will be prompted for
Xthem.
X
XIn the text that follows, due to the limitations of the ASCII character
Xset, "a*b" means "a times b", and "a^b" means "a to the power b".
X
X~Doc-
XPress <PageDown> for type selection list.
X~FF
XSelect a fractal type:
X
X~Table=40 2 0
X{ The Mandelbrot Set }
X{ Julia Sets }
X{ Inverse Julias }
X{ Newton domains of attraction }
X{ Newton }
X{ Complex Newton }
X{ Lambda Sets }
X{ Mandellambda Sets }
X{ Plasma Clouds }
X{ Lambdafn }
X{ Mandelfn }
X{ Barnsley Mandelbrot/Julia Sets }
X{ Barnsley IFS Fractals }
X{ Sierpinski Gasket }
X{ Quartic Mandelbrot/Julia }
X{ Distance Estimator }
X{ Pickover Mandelbrot/Julia Types }
X{ Pickover Popcorn }
X{ Dynamic System }
X{ Quaternion }
X{ Peterson Variations }
X{ Unity }
X{ Circle }
X{ Scott Taylor / Lee Skinner Variations }
X{ Kam Torus }
X{ Bifurcation }
X{ Orbit Fractals }
X{ Lorenz Attractors }
X{ Rossler Attractors }
X{ Henon Attractors }
X{ Pickover Attractors }
X{ Martin Attractors }
X{ Gingerbreadman }
X{ Test }
X{ Formula }
X{ Julibrots }
X{ Diffusion Limited Aggregation }
X{ Magnetic Fractals }
X{ L-Systems }
X{ Lyapunov Fractals }
X{ fn||fn Fractals }
X{ Halley }
X{ Cellular Automata }
X{ Phoenix }
X{ Frothy Basins }
X{ Icon }
X{ Hypercomplex }
X~EndTable
X~Doc+
X;
X;
X~Topic=The Mandelbrot Set, Label=HT_MANDEL
X(type=mandel)
X
XThis set is the classic: the only one implemented in many plotting
Xprograms, and the source of most of the printed fractal images published
Xin recent years. Like most of the other types in Fractint, it is simply a
Xgraph: the x (horizontal) and y (vertical) coordinate axes represent
Xranges of two independent quantities, with various colors used to
Xsymbolize levels of a third quantity which depends on the first two. So
Xfar, so good: basic analytic geometry.
X
XNow things get a bit hairier. The x axis is ordinary, vanilla real
Xnumbers. The y axis is an imaginary number, i.e. a real number times i,
Xwhere i is the square root of -1. Every point on the plane -- in this
Xcase, your PC's display screen -- represents a complex number of the form:
X
X    x-coordinate + i * y-coordinate
X
XIf your math training stopped before you got to imaginary and complex
Xnumbers, this is not the place to catch up. Suffice it to say that they
Xare just as "real" as the numbers you count fingers with (they're used
Xevery day by electrical engineers) and they can undergo the same kinds of
Xalgebraic operations.
X
XOK, now pick any complex number -- any point on the complex plane -- and
Xcall it C, a constant. Pick another, this time one which can vary, and
Xcall it Z. Starting with Z=0 (i.e., at the origin, where the real and
Ximaginary axes cross), calculate the value of the expression
X
X    Z^2 + C
X
XTake the result, make it the new value of the variable Z, and calculate
Xagain. Take that result, make it Z, and do it again, and so on: in
Xmathematical terms, iterate the function Z(n+1) = Z(n)^2 + C. For certain
Xvalues of C, the result "levels off" after a while. For all others, it
Xgrows without limit. The Mandelbrot set you see at the start -- the solid-
Xcolored lake (blue by default), the blue circles sprouting from it, and
Xindeed every point of that color -- is the set of all points C for which
Xthe value of Z is less than 2 after 150 iterations (150 is the default setting,
Xchangeable via the <X> options screen or "maxiter=" parameter).
XAll the surrounding "contours" of other colors represent points for which Z
Xexceeds 2 after 149 iterations (the contour closest to the M-set itself),
X148 iterations, (the next one out), and so on.
X
XWe actually don't test for Z exceeding 2 - we test Z squared against 4
Xinstead because it is easier.  This value (FOUR usually) is known as the
X"bailout" value for the calculation, because we stop iterating for the
Xpoint when it is reached.  The bailout value can be changed on the <Z>
Xoptions screen but the default is usually best.
X
XSome features of interest:
X
X1. Use the <X> options screen to increase the maximum number of iterations.
XNotice that the boundary of the M-set becomes more and more convoluted (the
Xtechnical terms are "wiggly," "squiggly," and "utterly bizarre") as the Z-
Xvalues for points that were still within the set after 150 iterations turn
Xout to exceed 2 after 200, 500, or 1200. In fact, it can be proven that
Xthe true boundary is infinitely long: detail without limit.
X
X2. Although there appear to be isolated "islands" of blue, zoom in -- that
Xis, plot for a smaller range of coordinates to show more detail -- and
Xyou'll see that there are fine "causeways" of blue connecting them to the
Xmain set. As you zoomed, smaller islands became visible; the same is true
Xfor them. In fact, there are no isolated points in the M-set: it is
X"connected" in a strict mathematical sense.
X
X3. The upper and lower halves of the first image are symmetric (a fact
Xthat Fractint makes use of here and in some other fractal types to speed
Xplotting). But notice that the same general features -- lobed discs,
Xspirals, starbursts -- tend to repeat themselves (although never exactly)
Xat smaller and smaller scales, so that it can be impossible to judge by
Xeye the scale of a given image.
X
X4. In a sense, the contour colors are window-dressing: mathematically, it
Xis the properties of the M-set itself that are interesting, and no
Xinformation about it would be lost if all points outside the set were
Xassigned the same color. If you're a serious, no-nonsense type, you may
Xwant to cycle the colors just once to see the kind of silliness that other
Xpeople enjoy, and then never do it again. Go ahead. Just once, now. We
Xtrust you.
X;
X;
X~Topic=Julia Sets, Label=HT_JULIA
X(type=julia)
X
XThese sets were named for mathematician Gaston Julia, and can be generated
Xby a simple change in the iteration process described for the
X{=HT_MANDEL Mandelbrot Set}.  Start with a
Xspecified value of C, "C-real + i * C-imaginary"; use as the initial value
Xof Z "x-coordinate + i * y-coordinate"; and repeat the same iteration,
XZ(n+1) = Z(n)^2 + C.
X
XThere is a Julia set corresponding to every point on the complex plane --
Xan infinite number of Julia sets. But the most visually interesting tend
Xto be found for the same C values where the M-set image is busiest, i.e.
Xpoints just outside the boundary. Go too far inside, and the corresponding
XJulia set is a circle; go too far outside, and it breaks up into scattered
Xpoints. In fact, all Julia sets for C within the M-set share the
X"connected" property of the M-set, and all those for C outside lack it.
X
XFractint's spacebar toggle lets you "flip" between any view of the M-set
Xand the Julia set for the point C at the center of that screen. You can
Xthen toggle back, or zoom your way into the Julia set for a while and then
Xreturn to the M-set. So if the infinite complexity of the M-set palls,
Xremember: each of its infinite points opens up a whole new Julia set.
X
XHistorically, the Julia sets came first: it was while looking at the M-set
Xas an "index" of all the Julia sets' origins that Mandelbrot noticed its
Xproperties.
X
XThe relationship between the {=HT_MANDEL Mandelbrot} set and Julia set can
Xhold between
Xother sets as well.  Many of Fractint's types are "Mandelbrot/Julia" pairs
X(sometimes called "M-sets" or "J-sets". All these are generated by
Xequations that are of the form z(k+1) = f(z(k),c), where the function
Xorbit is the sequence z(0), z(1), ..., and the variable c is a complex
Xparameter of the equation. The value c is fixed for "Julia" sets and is
Xequal to the first two parameters entered with the "params=Creal/Cimag"
Xcommand. The initial orbit value z(0) is the complex number corresponding
Xto the screen pixel. For Mandelbrot sets, the parameter c is the complex
Xnumber corresponding to the screen pixel. The value z(0) is c plus a
Xperturbation equal to the values of the first two parameters.  See
Xthe discussion of {=HT_MLAMBDA Mandellambda Sets}.
XThis approach may or may not be the
X"standard" way to create "Mandelbrot" sets out of "Julia" sets.
X
XSome equations have additional parameters.  These values are entered as the
Xthird for fourth params= value for both Julia and Mandelbrot sets. The
Xvariables x and y refer to the real and imaginary parts of z; similarly,
Xcx and cy are the real and imaginary parts of the parameter c and fx(z)
Xand fy(z) are the real and imaginary parts of f(z). The variable c is
Xsometimes called lambda for historical reasons.
X
XNOTE: if you use the "PARAMS=" argument to warp the M-set by starting with
Xan initial value of Z other than 0, the M-set/J-sets correspondence breaks
Xdown and the spacebar toggle no longer works.
X;
X;
X~Topic=Julia Toggle Spacebar Commands, Label=HELP_JIIM
XThe spacebar toggle has been enhanced for the classic Mandelbrot and Julia
Xtypes. When viewing the Mandelbrot, the spacebar turns on a window mode that
Xdisplays the Inverse Julia corresponding to the cursor position in a window.
XPressing the spacebar then causes the regular Julia escape time fractal
Xcorresponding to the cursor position to be generated. The following keys
Xtake effect in Inverse Julia mode.
X
X<Space>     Generate the escape-time Julia Set corresponding to the cursor\
X            position. Only works if fractal is a "Mandelbrot" type.\
X<n>         Numbers toggle - shows coordinates of the cursor on the\
X            screen. Press <n> again to turn off numbers.\
X<p>         Enter new pixel coordinates directly\
X<h>         Hide fractal toggle. Works only if View Windows is turned on\
X            and set for a small window (such as the default size.) Hides \
X            the fractal, allowing the orbit to take up the whole screen. \
X            Press <h> again to uncover the fractal.\
X<s>         Saves the fractal, cursor, orbits, and numbers.\
X<<> or <,>  Zoom inverse julia image smaller.\
X<>> or <.>  Zoom inverse julia image larger.\
X<z>         Restore default zoom.\
X
XThe Julia Inverse window is only implemented for the classic Mandelbrot
X(type=mandel). For other "Mandelbrot" types <space> turns on the cursor
Xwithout the Julia window, and allows you to select coordinates of the
Xmatching Julia set in a way similar to the use of the zoom box with the
XMandelbrot/Julia toggle in previous Fractint versions.
X;
X;
X~Topic=Inverse Julias, Label=HT_INVERSE
X(type=julia_inverse)
X
XPick a function, such as the familiar Z(n) = Z(n-1) squared plus C
X(the defining function of the Mandelbrot Set).  If you pick a point Z(0)
Xat random from the complex plane, and repeatedly apply the function to it,
Xyou get a sequence of new points called an orbit, which usually either
Xzips out toward infinity or zooms in toward one or more "attractor" points
Xnear the middle of the plane.  The set of all points that are "attracted"
Xto infinity is called the "Basin of Attraction" of infinity.  Each of the
Xother attractors also has its own Basin of Attraction.  Why is it called
Xa Basin?  Imagine a lake, and all the water in it "draining" into the
Xattractor.  The boundary between these basins is called the Julia Set of
Xthe function.
X
XThe boundary between the basins of attraction is sort of like a
Xrepeller; all orbits move away from it, toward one of the attractors.
XBut if we define a new function as the inverse of the old one, as for
Xinstance Z(n) = sqrt(Z(n-1) minus C), then the old attractors become
Xrepellers, and the former boundary itself becomes the attractor!  Now,
Xstarting from any point, all orbits are drawn irresistibly to the Julia
XSet!  In fact, once an orbit reaches the boundary, it will continue to
Xhop about until it traces the entire Julia Set!  This method for drawing
XJulia Sets is called the Inverse Iteration Method, or IIM for short.
X
XUnfortunately, some parts of each Julia Set boundary are far more
Xattractive to inverse orbits than others are, so that as an orbit
Xtraces out the set, it keeps coming back to these attractive parts
Xagain and again, only occasionally visiting the less attractive parts.
XThus it may take an infinite length of time to draw the entire set.
XTo hasten the process, we can keep track of how many times each pixel
Xon our computer screen is visited by an orbit, and whenever an orbit
Xreaches a pixel that has already been visited more than a certain number
Xof times, we can consider that orbit finished and move on to another one.
XThis "hit limit" thus becomes similar to the iteration limit used in the
Xtraditional escape-time fractal algorithm.  This is called the Modified
XInverse Iteration Method, or MIIM, and is much faster than the IIM.
X
XNow, the inverse of Mandelbrot's classic function is a square root, and
Xthe square root actually has two solutions; one positive, one negative.
XTherefore at each step of each orbit of the inverse function there is
Xa decision; whether to use the positive or the negative square root.
XEach one gives rise to a new point on the Julia Set, so each is a good
Xchoice.  This series of choices defines a binary decision tree, each
Xpoint on the Julia Set giving rise to two potential child points.
XThere are many interesting ways to traverse a binary tree, among them
XBreadth first, Depth first (left or negative first), Depth first (right
Xor positive first), and completely at random.  It turns out that most
Xtraversal methods lead to the same or similar pictures, but that how the
Ximage evolves as the orbits trace it out differs wildly depending on the
Xtraversal method chosen.  As far as I know, this fact is an original
Xdiscovery, and this version of FRACTINT is its first publication.
X
XPick a Julia constant such as Z(0) = (-.74543, .11301), the popular
XSeahorse Julia, and try drawing it first Breadth first, then Depth first
X(right first), Depth first (left first), and finally with Random Walk.
X
XCaveats: the video memory is used in the algorithm, to keep track of
Xhow many times each pixel has been visited (by changing it's color).
XTherefore the algorithm will not work well if you zoom in far enough that
Xpart of the Julia Set is off the screen.
X
XBugs:   Not working with Disk Video.
X        Not resumeable.
X
XThe <J> key toggles between the Inverse Julia orbit and the
Xcorresponding Julia escape time fractal.
X;
X;
X~Topic=Newton domains of attraction, Label=HT_NEWTBAS
X(type=newtbasin)
X
XThe Newton formula is an algorithm used to find the roots of polynomial
Xequations by successive "guesses" that converge on the correct value as
Xyou feed the results of each approximation back into the formula. It works
Xvery well -- unless you are unlucky enough to pick a value that is on a
Xline BETWEEN two actual roots. In that case, the sequence explodes into
Xchaos, with results that diverge more and more wildly as you continue the
Xiteration.
X
XThis fractal type shows the results for the polynomial Z^n - 1, which has
Xn roots in the complex plane. Use the <T>ype command and enter "newtbasin"
Xin response to the prompt. You will be asked for a parameter, the "order"
Xof the equation (an integer from 3 through 10 -- 3 for x^3-1, 7 for x^7-1,
Xetc.). A second parameter is a flag to turn on alternating shades showing
Xchanges in the number of iterations needed to attract an orbit. Some
Xpeople like stripes and some don't, as always, Fractint gives you a
Xchoice!
X
XThe coloring of the plot shows the "basins of attraction" for each root of
Xthe polynomial -- i.e., an initial guess within any area of a given color
Xwould lead you to one of the roots. As you can see, things get a bit weird
Xalong certain radial lines or "spokes," those being the lines between
Xactual roots. By "weird," we mean infinitely complex in the good old
Xfractal sense. Zoom in and see for yourself.
X
XThis fractal type is symmetric about the origin, with the number of
X"spokes" depending on the order you select. It uses floating-point math if
Xyou have an FPU, or a somewhat slower integer algorithm if you don't have
Xone.
X~Doc-
X
XSee also: {Newton}
X~Doc+
X;
X;
X~Topic=Newton, Label=HT_NEWT
X(type=newton)
X
XThe generating formula here is identical to that for {=HT_NEWTBAS newtbasin},
Xbut the
Xcoloring scheme is different. Pixels are colored not according to the root
Xthat would be "converged on" if you started using Newton's formula from
Xthat point, but according to the iteration when the value is close to a
Xroot.  For example, if the calculations for a particular pixel converge to
Xthe 7th root on the 23rd iteration, NEWTBASIN will color that pixel using
Xcolor #7, but NEWTON will color it using color #23.
X
XIf you have a 256-color mode, use it: the effects can be much livelier
Xthan those you get with type=newtbasin, and color cycling becomes, like,
Xdownright cosmic. If your "corners" choice is symmetrical, Fractint
Xexploits the symmetry for faster display.
X
XThe applicable "params=" values are the same as newtbasin. Try "params=4."
XOther values are 3 through 10. 8 has twice the symmetry and is faster. As
Xwith newtbasin, an FPU helps.
X;
X;
X~Topic=Complex Newton, Label=HT_NEWTCMPLX
X(type=complexnewton/complexbasin)
X
XWell, hey, "Z^n - 1" is so boring when you can use "Z^a - b" where "a" and
X"b" are complex numbers!  The new "complexnewton" and "complexbasin"
Xfractal types are just the old {=HT_NEWT "newton"} and
X{=HT_NEWTBAS "newtbasin"} fractal types with
Xthis little added twist.  When you select these fractal types, you are
Xprompted for four values (the real and imaginary portions of "a" and "b").
XIf "a" has a complex portion, the fractal has a discontinuity along the
Xnegative axis - relax, we finally figured out that it's *supposed* to be
Xthere!
X;
X;
X~Topic=Lambda Sets, Label=HT_LAMBDA
X(type=lambda)
X
XThis type calculates the Julia set of the formula lambda*Z*(1-Z). That is,
Xthe value Z[0] is initialized with the value corresponding to each pixel
Xposition, and the formula iterated. The pixel is colored according to the
Xiteration when the sum of the squares of the real and imaginary parts
Xexceeds 4.
X
XTwo parameters, the real and imaginary parts of lambda, are required. Try
X0 and 1 to see the classical fractal "dragon". Then try 0.2 and 1 for a
Xlot more detail to zoom in on.
X
XIt turns out that all quadratic Julia-type sets can be calculated using
Xjust the formula z^2+c (the "classic" Julia"), so that this type is
Xredundant, but we include it for reason of it's prominence in the history
Xof fractals.
X;
X;
X~Topic=Mandellambda Sets, Label=HT_MLAMBDA
X(type=mandellambda)
X
XThis type is the "Mandelbrot equivalent" of the {=HT_LAMBDA lambda} set.
XA comment is
Xin order here. Almost all the Fractint "Mandelbrot" sets are created from
Xorbits generated using formulas like z(n+1) = f(z(n),C), with z(0) and C
Xinitialized to the complex value corresponding to the current pixel. Our
Xreasoning was that "Mandelbrots" are maps of the corresponding "Julias".
XUsing this scheme each pixel of a "Mandelbrot" is colored the same as the
XJulia set corresponding to that pixel. However, Kevin Allen informs us
Xthat the MANDELLAMBDA set appears in the literature with z(0) initialized
Xto a critical point (a point where the derivative of the formula is zero),
Xwhich in this case happens to be the point (.5,0). Since Kevin knows more
Xabout Dr. Mandelbrot than we do, and Dr. Mandelbrot knows more about
Xfractals than we do, we defer! Starting with version 14 Fractint
Xcalculates MANDELAMBDA Dr. Mandelbrot's way instead of our way. But ALL
XTHE OTHER "Mandelbrot" sets in Fractint are still calculated OUR way!
X(Fortunately for us, for the classic Mandelbrot Set these two methods are
Xthe same!)
X
XWell now, folks, apart from questions of faithfulness to fractals named in
Xthe literature (which we DO take seriously!), if a formula makes a
Xbeautiful fractal, it is not wrong. In fact some of the best fractals in
XFractint are the results of mistakes! Nevertheless, thanks to Kevin for
Xkeeping us accurate!
X
X(See description of "initorbit=" command in {Image Calculation Parameters}
Xfor a way to experiment with different orbit intializations).
X;
X;
X~Topic=Circle, Label=HT_CIRCLE
X(type=circle)
X
XThis fractal types is from A. K. Dewdney's "Computer Recreations" column
Xin "Scientific American". It is attributed to John Connett of the
XUniversity of Minnesota.
X
X(Don't tell anyone, but this fractal type is not really a fractal!)
X
XFascinating Moire patterns can be formed by calculating x^2 + y^2 for
Xeach pixel in a piece of the complex plane. After multiplication by a
Xmagnification factor (the parameter), the number is truncated to an integer
Xand mapped to a color via color = value modulo (number of colors). That is,
Xthe integer is divided by the number of colors, and the remainder is the
Xcolor index value used.  The resulting image is not a fractal because all
Xdetail is lost after zooming in too far. Try it with different resolution
Xvideo modes - the results may surprise you!
X;
X;
X~Topic=Plasma Clouds, Label=HT_PLASMA
X(type=plasma)
X
XPlasma clouds ARE real live fractals, even though we didn't know it at
Xfirst. They are generated by a recursive algorithm that randomly picks
Xcolors of the corner of a rectangle, and then continues recursively
Xquartering previous rectangles. Random colors are averaged with those of
Xthe outer rectangles so that small neighborhoods do not show much change,
Xfor a smoothed-out, cloud-like effect. The more colors your video mode
Xsupports, the better.  The result, believe it or not, is a fractal
Xlandscape viewed as a contour map, with colors indicating constant
Xelevation.  To see this, save and view with the <3> command
X(see {\"3D\" Images})
Xand your "cloud" will be converted to a mountain!
X
XYou've GOT to try {=@ColorCycling color cycling} on these (hit "+" or "-").
XIf you
Xhaven't been hypnotized by the drawing process, the writhing colors will
Xdo it for sure. We have now implemented subliminal messages to exploit the
Xuser's vulnerable state; their content varies with your bank balance,
Xpolitics, gender, accessibility to a Fractint programmer, and so on. A
Xfree copy of Microsoft C to the first person who spots them.
X
XThis type accepts four parameters.
X
XThe first determines how abruptly the colors change. A value of .5 yields
Xbland clouds, while 50 yields very grainy ones. The default value is 2.
X
XThe second determines whether to use the original algorithm (0) or a
Xmodified one (1). The new one gives the same type of images but draws
Xthe dots in a different order. It will let you see
Xwhat the final image will look like much sooner than the old one.
X
XThe third determines whether to use a new seed for generating the
Xnext plasma cloud (0) or to use the previous seed (1).
X
XThe fourth parameter turns on 16-bit .POT output which provides much
Xsmoother height gradations. This is especially useful for creating
Xmountain landscapes when using the plasma output with a ray tracer
Xsuch as POV-Ray.
X
XWith parameter three set to 1, the next plasma cloud generated will be
Xidentical to the previous but at whatever new resolution is desired.
X
XZooming is ignored, as each plasma-cloud screen is generated randomly.
X
XThe random number seed used for each plasma image is displayed on the
X<tab> information screen, and can be entered with the command line
Xparameter "rseed=" to recreate a particular image.
X
XThe algorithm is based on the Pascal program distributed by Bret Mulvey as
XPLASMA.ARC. We have ported it to C and integrated it with Fractint's
Xgraphics and animation facilities. This implementation does not use
Xfloating-point math. The algorithm was modified starting with version 18
Xso that the plasma effect is independent of screen resolution.
X
XSaved plasma-cloud screens are EXCELLENT starting images for fractal
X"landscapes" created with the {\"3D\" commands}.
X;
X;
X~Topic=Lambdafn, Label=HT_LAMBDAFN
X(type=lambdafn)
X
XFunction=[sin|cos|sinh|cosh|exp|log|sqr|...]) is specified with this type.
XPrior to version 14, these types were lambdasine, lambdacos, lambdasinh,
Xlambdacos, and lambdaexp.  Where we say "lambdasine" or some such below,
Xthe good reader knows we mean "lambdafn with function=sin".)
X
XThese types calculate the Julia set of the formula lambda*fn(Z), for
Xvarious values of the function "fn", where lambda and Z are both complex.
XTwo values, the real and imaginary parts of lambda, should be given in the
X"params=" option.  For the feathery, nested spirals of LambdaSines and the
Xfrost-on-glass patterns of LambdaCosines, make the real part = 1, and try
Xvalues for the imaginary part ranging from 0.1 to 0.4 (hint: values near
X0.4 have the best patterns). In these ranges the Julia set "explodes". For
Xthe tongues and blobs of LambdaExponents, try a real part of 0.379 and an
Ximaginary part of 0.479.
X
XA coprocessor used to be almost mandatory: each LambdaSine/Cosine
Xiteration calculates a hyperbolic sine, hyperbolic cosine, a sine, and a
Xcosine (the LambdaExponent iteration "only" requires an exponent, sine,
Xand cosine operation)!    However, Fractint now computes these
Xtranscendental functions with fast integer math. In a few cases the fast
Xmath is less accurate, so we have kept the old slow floating point code.
XTo use the old code, invoke with the float=yes option, and, if you DON'T
Xhave a coprocessor, go on a LONG vacation!
X;
X;
X~Topic=Halley, Label=HT_HALLEY
X(type=halley)
X
XThe Halley map is an algorithm used to find the roots of polynomial
Xequations by successive "guesses" that converge on the correct value as
Xyou feed the results of each approximation back into the formula. It works
Xvery well -- unless you are unlucky enough to pick a value that is on a
Xline BETWEEN two actual roots. In that case, the sequence explodes into
Xchaos, with results that diverge more and more wildly as you continue the
Xiteration.
X
XThis fractal type shows the results for the polynomial Z(Z^a - 1), which
Xhas a+1 roots in the complex plane. Use the <T>ype command and enter
X"halley" in response to the prompt. You will be asked for a parameter, the
X"order" of the equation (an integer from 2 through 10 -- 2 for Z(Z^2 - 1),
X7 for Z(Z^7 - 1), etc.). A second parameter is the relaxation coefficient,
Xand is used to control the convergence stability. A number greater than
Xone increases the chaotic behavior and a number less than one decreases the
Xchaotic behavior. The third parameter is the value used to determine when
Xthe formula has converged. The test for convergence is
X||Z(n+1)|^2 - |Z(n)|^2| < epsilon. This convergence test produces the
Xwhisker-like projections which generally point to a root.
X;
X;
X~Topic=Phoenix, Label=HT_PHOENIX
X(type=phoenix, mandphoenix)
X
XThe phoenix type defaults to the original phoenix curve discovered by
XShigehiro Ushiki, "Phoenix", IEEE Transactions on Circuits and Systems,
XVol. 35, No. 7, July 1988, pp. 788-789.  These images do not have the
XX and Y axis swapped as is normal for this type.
X
XThe mandphoenix type is the corresponding Mandelbrot set image of the
Xphoenix type.  The spacebar toggles between the two as long as the
Xmandphoenix type has an initial Z(0) of (0,0).  The mandphoenix is not
Xan effective index to the phoenix type, so explore the wild blue yonder.
X
XTo reproduce the Mandelbrot set image of the phoenix type as shown in
XStevens' book, "Fractal Programming in C", set initorbit=0/0 on the
Xcommand line or with the <g> key.  The colors need to be rotated one
Xposition because Stevens uses the values from the previous calculation
Xinstead of the current calculation to determine when to bailout.
X;
X;
X~Topic=fn||fn Fractals, Label=HT_FNORFN
X(type=lambda(fn||fn), manlam(fn||fn), julia(fn||fn), mandel(fn||fn))
X
XTwo functions=[sin|cos|sinh|cosh|exp|log|sqr|...]) are specified with
Xthese types.  The two functions are alternately used in the calculation
Xbased on a comparison between the modulus of the current Z and the
Xshift value.  The first function is used if the modulus of Z is less
Xthan the shift value and the second function is used otherwise.
X
XThe lambda(fn||fn) type calculates the Julia set of the formula
Xlambda*fn(Z), for various values of the function "fn", where lambda
Xand Z are both complex.  Two values, the real and imaginary parts of
Xlambda, should be given in the "params=" option.  The third value is
Xthe shift value.  The space bar will generate the corresponding
X"psuedo Mandelbrot" set, manlam(fn||fn).
X
XThe manlam(fn||fn) type calculates the "psuedo Mandelbrot" set of the
Xformula fn(Z)*C, for various values of the function "fn", where C
Xand Z are both complex.  Two values, the real and imaginary parts of
XZ(0), should be given in the "params=" option.  The third value is
Xthe shift value.  The space bar will generate the corresponding
Xjulia set, lamda(fn||fn).
X
XThe julia(fn||fn) type calculates the Julia set of the formula
Xfn(Z)+C, for various values of the function "fn", where C
Xand Z are both complex.  Two values, the real and imaginary parts of
XC, should be given in the "params=" option.  The third value is
Xthe shift value.  The space bar will generate the corresponding
Xmandelbrot set, mandel(fn||fn).
X
XThe mandel(fn||fn) type calculates the Mandelbrot set of the formula
Xfn(Z)+C, for various values of the function "fn", where C
Xand Z are both complex.  Two values, the real and imaginary parts of
XZ(0), should be given in the "params=" option.  The third value is
Xthe shift value.  The space bar will generate the corresponding
Xjulia set, julia(fn||fn).
X;
X;
X~Topic=Mandelfn, Label=HT_MANDFN
X(type=mandelfn)
X
XFunction=[sin|cos|sinh|cosh|exp|log|sqr|...]) is specified with this type.
XPrior to version 14, these types were mandelsine, mandelcos, mandelsinh,
Xmandelcos, and mandelexp. Same comment about our lapses into the old
Xterminology as above!
X
XThese are "pseudo-Mandelbrot" mappings for the {=HT_LAMBDAFN LambdaFn}
XJulia functions.
XThey map to their corresponding Julia sets via the spacebar command in
Xexactly the same fashion as the original M/J sets.  In general, they are
Xinteresting mainly because of that property (the function=exp set in
Xparticular is rather boring). Generate the appropriate "Mandelfn" set,
Xzoom on a likely spot where the colors are changing rapidly, and hit the
Xspacebar key to plot the Julia set for that particular point.
X
XTry "FRACTINT TYPE=MANDELFN CORNERS=4.68/4.76/-.03/.03 FUNCTION=COS" for a
Xgraphic demonstration that we're not taking Mandelbrot's name in vain
Xhere. We didn't even know these little buggers were here until Mark
XPeterson found this a few hours before the version incorporating Mandelfns
Xwas released.
X
XNote: If you created images using the lambda or mandel "fn" types prior to
Xversion 14, and you wish to update the fractal information in the "*.fra"
Xfile, simply read the files and save again. You can do this in batch mode
Xvia a command line such as:
X
X     "fractint oldfile.fra savename=newfile.gif batch=yes"
X
XFor example, this procedure can convert a version 13 "type=lambdasine"
Ximage to a version 14 "type=lambdafn function=sin" GIF89a image.  We do
Xnot promise to keep this "backward compatibility" past version 14 - if you
Xwant to keep the fractal information in your *.fra files accurate, we
Xrecommend conversion.  See {GIF Save File Format}.
X;
X;
X~Topic=Barnsley Mandelbrot/Julia Sets, Label=HT_BARNS
X(type=barnsleym1/.../j3)
X
XMichael Barnsley has written a fascinating college-level text, "Fractals
XEverywhere," on fractal geometry and its graphic applications. (See
X{Bibliography}.) In it, he applies the principle of the M and J
Xsets to more general functions of two complex variables.
X
XWe have incorporated three of Barnsley's examples in Fractint. Their
Xappearance suggests polarized-light microphotographs of minerals, with
Xpatterns that are less organic and more crystalline than those of the M/J
Xsets. Each example has both a "Mandelbrot" and a "Julia" type. Toggle
Xbetween them using the spacebar.
X
XThe parameters have the same meaning as they do for the "regular"
XMandelbrot and Julia. For types M1, M2, and M3, they are used to "warp"
Xthe image by setting the initial value of Z. For the types J1 through J3,
Xthey are the values of C in the generating formulas.
X
XBe sure to try the <O>rbit function while plotting these types.
X;
X;
X~Topic=Barnsley IFS Fractals, Label=HT_IFS
X(type=ifs)
X
XOne of the most remarkable spin-offs of fractal geometry is the ability to
X"encode" realistic images in very small sets of numbers -- parameters for
Xa set of functions that map a region of two-dimensional space onto itself.
XIn principle (and increasingly in practice), a scene of any level of
Xcomplexity and detail can be stored as a handful of numbers, achieving
Xamazing "compression" ratios... how about a super-VGA image of a forest,
Xmore than 300,000 pixels at eight bits apiece, from a 1-KB "seed" file?
X
XAgain, Michael Barnsley and his co-workers at the Georgia Institute of
XTechnology are to be thanked for pushing the development of these iterated
Xfunction systems (IFS).
X
XWhen you select this fractal type, Fractint scans the current IFS file
X(default is FRACTINT.IFS, a set of definitions supplied with Fractint) for
XIFS definitions, then prompts you for the IFS name you wish to run. Fern
Xand 3dfern are good ones to start with. You can press <F6> at the
Xselection screen if you want to select a different .IFS file you've
Xwritten.
X
XNote that some Barnsley IFS values generate images quite a bit smaller
Xthan the initial (default) screen. Just bring up the zoom box, center it
Xon the small image, and hit <Enter> to get a full-screen image.
X
XTo change the number of dots Fractint generates for an IFS image before
Xstopping, you can change the "maximum iterations" parameter on the <X>
Xoptions screen.
X
XFractint supports two types of IFS images: 2D and 3D. In order to fully
Xappreciate 3D IFS images, since your monitor is presumably 2D, we have
Xadded rotation, translation, and perspective capabilities. These share
Xvalues with the same variables used in Fractint's other 3D facilities; for
Xtheir meaning see {"Rectangular Coordinate Transformation"}.
XYou can enter these values from the command line using:
X
Xrotation=xrot/yrot/zrot       (try 30/30/30)\
Xshift=xshift/yshift          (shifts BEFORE applying perspective!)\
Xperspective=viewerposition    (try 200)\
X
XAlternatively, entering <I> from main screen will allow you to modify
Xthese values. The defaults are the same as for regular 3D, and are not
Xalways optimum for 3D IFS. With the 3dfern IFS type, try
Xrotation=30/30/30. Note that applying shift when using perspective changes
Xthe picture -- your "point of view" is moved.
X
XA truly wild variation of 3D may be seen by entering "2" for the stereo
Xmode (see {"Stereo 3D Viewing"}),
Xputting on red/blue "funny glasses", and watching the fern develop
Xwith full depth perception right there before your eyes!
X
XThis feature USED to be dedicated to Bruce Goren, as a bribe to get him to
Xsend us MORE knockout stereo slides of 3D ferns, now that we have made it
Xso easy! Bruce, what have you done for us *LATELY* ?? (Just kidding,
Xreally!)
X
XEach line in an IFS definition (look at FRACTINT.IFS with your editor for
Xexamples) contains the parameters for one of the generating functions,
Xe.g. in FERN:
X~Format-
X   a    b     c    d    e    f      p
X ___________________________________
X   0     0    0  .16    0    0     .01
X .85   .04 -.04  .85    0  1.6     .85
X .2   -.26  .23  .22    0  1.6     .07
X-.15   .28  .26  .24    0  .44     .07
X
XThe values on each line define a matrix, vector, and probability:
X    matrix   vector  prob
X    |a b|     |e|     p
X    |c d|     |f|
X~Format+
X
XThe "p" values are the probabilities assigned to each function (how often
Xit is used), which add up to one. Fractint supports up to 32 functions,
Xalthough usually three or four are enough.
X
X3D IFS definitions are a bit different.  The name is followed by (3D) in
Xthe definition file, and each line of the definition contains 13 numbers:
Xa b c d e f g h i j k l p, defining:
X    matrix   vector  prob\
X    |a b c|   |j|     p\
X    |d e f|   |k|\
X    |g h i|   |l|\
X
X;You can experiment with changes to IFS definitions interactively by using
X;Fractint's <Z> command.  After selecting an IFS definition, hit <Z> to
X;bring up the IFS editor. This editor displays the current IFS values, lets
X;you modify them, and lets you save your modified values as a text file
X;which you can then merge into an XXX.IFS file for future use with
X;Fractint.
X;
XThe program FDESIGN can be used to design IFS fractals - see
X{=@FDESIGN FDESIGN}.
X
XYou can save the points in your IFS fractal in the file ORBITS.RAW which is
Xoverwritten each time a fractal is generated. The program Acrospin can
Xread this file and will let you view the fractal from any angle using
Xthe cursor keys. See {=@ACROSPIN Acrospin}.
X;
X;
X~Topic=Sierpinski Gasket, Label=HT_SIER
X(type=sierpinski)
X
XAnother pre-Mandelbrot classic, this one found by W. Sierpinski around
XWorld War I. It is generated by dividing a triangle into four congruent
Xsmaller triangles, doing the same to each of them, and so on, yea, even
Xunto infinity. (Notice how hard we try to avoid reiterating "iterating"?)
X
XIf you think of the interior triangles as "holes", they occupy more and
Xmore of the total area, while the "solid" portion becomes as hopelessly
Xfragile as that gasket you HAD to remove without damaging it -- you
Xremember, that Sunday afternoon when all the parts stores were closed?
XThere's a three-dimensional equivalent using nested tetrahedrons instead
Xof triangles, but it generates too much pyramid power to be safely
Xunleashed yet.
X
XThere are no parameters for this type. We were able to implement it with
Xinteger math routines, so it runs fairly quickly even without an FPU.
X;
X;
X~Topic=Quartic Mandelbrot/Julia, Label=HT_MANDJUL4
X(type=mandel4/julia4)
X
XThese fractal types are the moral equivalent of the original M and J sets,
Xexcept that they use the formula Z(n+1) = Z(n)^4 + C, which adds
Xadditional pseudo-symmetries to the plots. The "Mandel4" set maps to the
X"Julia4" set via -- surprise! -- the spacebar toggle. The M4 set is kind
Xof boring at first (the area between the "inside" and the "outside" of the
Xset is pretty thin, and it tends to take a few zooms to get to any
Xinteresting sections), but it looks nice once you get there. The Julia
Xsets look nice right from the start.
X
XOther powers, like Z(n)^3 or Z(n)^7, work in exactly the same fashion. We
Xused this one only because we're lazy, and Z(n)^4 = (Z(n)^2)^2.
X;
X;
X~Topic=Distance Estimator
X(distest=nnn/nnn)
X
XThis used to be type=demm and type=demj.  These types have not died, but
Xare only hiding!  They are equivalent to the mandel and julia types with
Xthe "distest=" option selected with a predetermined value.
X
XThe {Distance Estimator Method}
Xcan be used to produce higher quality images of M and J sets,
Xespecially suitable for printing in black and white.
X
XIf you have some *.fra files made with the old types demm/demj, you may
Xwant to convert them to the new form.  See the {=HT_MANDFN Mandelfn}
Xsection for directions to carry out the conversion.
X;
X;
X~Topic=Pickover Mandelbrot/Julia Types, Label=HT_PICKMJ
X(type=manfn+zsqrd/julfn+zsqrd, manzpowr/julzpowr, manzzpwr/julzzpwr,
Xmanfn+exp/julfn+exp - formerly included man/julsinzsqrd and
Xman/julsinexp which have now been generalized)
X
XThese types have been explored by Clifford A. Pickover, of the IBM Thomas
XJ. Watson Research center. As implemented in Fractint, they are regular
XMandelbrot/Julia set pairs that may be plotted with or without the
X{=@Biomorphs "biomorph"} option Pickover used to create organic-looking
Xbeasties (see
Xbelow). These types are produced with formulas built from the functions
Xz^z, z^n, sin(z), and e^z for complex z. Types with "power" or "pwr" in
Xtheir name have an exponent value as a third parameter. For example,
Xtype=manzpower params=0/0/2 is our old friend the classical Mandelbrot,
Xand type=manzpower params=0/0/4 is the Quartic Mandelbrot. Other values of
Xthe exponent give still other fractals.  Since these WERE the original
X"biomorph" types, we should give an example.  Try:
X
X    FRACTINT type=manfn+zsqrd biomorph=0 corners=-8/8/-6/6 function=sin
X
Xto see a big biomorph digesting little biomorphs!
X;
X;
X~Topic=Pickover Popcorn, Label=HT_POPCORN
X(type=popcorn/popcornjul)
X
XHere is another Pickover idea. This one computes and plots the orbits of
Xthe dynamic system defined by:
X
X     x(n+1) = x(n) - h*sin(y(n)+tan(3*y(n))\
X     y(n+1) = y(n) - h*sin(x(n)+tan(3*x(n))\
X
Xwith the initializers x(0) and y(0) equal to ALL the complex values within
Xthe "corners" values, and h=.01.  ALL these orbits are superimposed,
Xresulting in "popcorn" effect.  You may want to use a maxiter value less
Xthan normal - Pickover recommends a value of 50.  As a bonus,
Xtype=popcornjul shows the Julia set generated by these same equations with
Xthe usual escape-time coloring. Turn on orbit viewing with the "O"
Xcommand, and as you watch the orbit pattern you may get some insight as to
Xwhere the popcorn comes from. Although you can zoom and rotate popcorn,
Xthe results may not be what you'd expect, due to the superimposing of
Xorbits and arbitrary use of color. Just for fun we added type popcornjul,
Xwhich is the plain old Julia set calculated from the same formula.
X;
X;
X~Topic=Dynamic System, Label=HT_DYNAM
X(type=dynamic, dynamic2)
X
XThese fractals are based on a cyclic system of differential equations:
X     x'(t) = -f(y(t))\
X     y'(t) = f(x(t))\
XThese equations are approximated by using a small time step dt, forming
Xa time-discrete dynamic system:
X     x(n+1) = x(n) - dt*f(y(n))\
X     y(n+1) = y(n) + dt*f(x(n))\
XThe initial values x(0) and y(0) are set to various points in the plane,
Xthe dynamic system is iterated, and the resulting orbit points are plotted.
X
XIn fractint, the function f is restricted to:
X      f(k) = sin(k + a*fn1(b*k))
XThe parameters are the spacing of the initial points, the time step dt,
Xand the parameters (a,b,fn1) that affect the function f.
XNormally the orbit points are plotted individually, but for a negative
Xspacing the points are connected.
X
XThis fractal is similar to the {=HT_POPCORN Pickover Popcorn}.
X~OnlineFF
XA variant is the implicit Euler approximation:
X     y(n+1) = y(n) + dt*f(x(n))\
X     x(n+1) = x(n) - dt*f(y(n+1))\
XThis variant results in complex orbits.  The implicit Euler approximation
Xis selected by entering dt<0.
X
XThere are two options that have unusual effects on these fractals.  The
XOrbit Delay value controls how many initial points are computed before
Xthe orbits are displayed on the screen.  This allows the orbit to settle
Xdown.  The outside=summ option causes each pixel to increment color every
Xtime an orbit touches it; the resulting display is a 2-d histogram.
X
XThese fractals are discussed in Chapter 14 of Pickover's "Computers,
XPattern, Chaos, and Beauty".
X;
X;
X~Topic=Mandelcloud, Label=HT_MANDELCLOUD
X(type=mandelcloud)
X
XThis fractal computes the Mandelbrot function, but displays it differently.
XIt starts with regularly spaced initial pixels and displays the resulting
Xorbits.  This idea is somewhat similar to the {=HT_DYNAM Dynamic System}.
X
XThere are two options that have unusual effects on this fractal.  The
XOrbit Delay value controls how many initial points are computed before
Xthe orbits are displayed on the screen.  This allows the orbit to settle
Xdown.  The outside=summ option causes each pixel to increment color every
Xtime an orbit touches it; the resulting display is a 2-d histogram.
X
XThis fractal was invented by Noel Giffin.
X
X;
X;
X~Topic=Peterson Variations, Label=HT_MARKS
X(type=marksmandel, marksjulia, cmplxmarksmand, cmplxmarksjul, marksmandelpwr,
Xtim's_error)
X
XThese fractal types are contributions of Mark Peterson. MarksMandel and
XMarksJulia are two families of fractal types that are linked in the same
Xmanner as the classic Mandelbrot/Julia sets: each MarksMandel set can be
Xconsidered as a mapping into the MarksJulia sets, and is linked with the
Xspacebar toggle. The basic equation for these sets is:
X      Z(n+1) = ((lambda^exp) * Z(n)^2) + lambda
Xwhere Z(0) = 0.0 and lambda is (x + iy) for MarksMandel. For MarksJulia,
XZ(0) = (x + iy) and lambda is a constant (taken from the MarksMandel
Xspacebar toggle, if that method is used). The exponent is a positive
Xinteger or a complex number. We call these "families" because each value
Xof the exponent yields a different MarksMandel set, which turns out to be
Xa kinda-polygon with (exponent+1) sides. The exponent value is the third
Xparameter, after the "initialization warping" values. Typically one would
Xuse null warping values, and specify the exponent with something like
X"PARAMS=0/0/4", which creates an unwarped, pentagonal MarksMandel set.
X
XIn the process of coding MarksMandelPwr formula type, Tim Wegner
Xcreated the type "tim's_error" after making an interesting coding mistake.
X;
X;
X~Topic=Unity, Label=HT_UNITY
X(type=unity)
X
XThis Peterson variation began with curiosity about other "Newton-style"
Xapproximation processes. A simple one,
X
X   One = (x * x) + (y * y); y = (2 - One) * x;     x = (2 - One) * y;
X
Xproduces the fractal called Unity.
X
XOne of its interesting features is the "ghost lines." The iteration loop
Xbails out when it reaches the number 1 to within the resolution of a
Xscreen pixel. When you zoom a section of the image, the bailout criterion
Xis adjusted, causing some lines to become thinner and others thicker.
X
XOnly one line in Unity that forms a perfect circle: the one at a radius of
X1 from the origin. This line is actually infinitely thin. Zooming on it
Xreveals only a thinner line, up (down?) to the limit of accuracy for the
Xalgorithm. The same thing happens with other lines in the fractal, such as
Xthose around |x| = |y| = (1/2)^(1/2) = .7071
X
XTry some other tortuous approximations using the {=HT_TEST TEST stub} and
Xlet us know what you come up with!
X;
X;
X~Topic=Scott Taylor / Lee Skinner Variations, Label=HT_SCOTSKIN
X(type=fn(z*z), fn*fn, fn*z+z, fn+fn, sqr(1/fn), sqr(fn), spider,
Xtetrate, manowar)
X
XTwo of Fractint's faithful users went bonkers when we introduced the
X"formula" type, and came up with all kinds of variations on escape-time
Xfractals using trig functions.    We decided to put them in as regular
Xtypes, but there were just too many! So we defined the types with variable
Xfunctions and let you, the, overwhelmed user, specify what the functions
Xshould be! Thus Scott Taylor's "z = sin(z) + z^2" formula type is now the
X"fn+fn" regular type, and EITHER function can be one of sin, cos, tan, cotan,
Xsinh, cosh, tanh, cotanh, exp, log, sqr, recip, ident, conj, flip, or cosxx.
XPlus we give you 4 parameters to set, the complex
Xcoefficients of the two functions!  Thus the innocent-looking "fn+fn" type
Xis really 256 different types in disguise, not counting the damage
Xdone by the parameters!
X
X Some functions that require further explanation:
X
X conj()   - returns the complex conjugate of the argument. That is, changes
X            sign of the imaginary component of argument: (x,y) becomes (x,-y)
X ident()  - identity function. Leaves the value of the argument unchanged,
X            acting like a "z" term in a formula.
X~OnlineFF
X flip()   - Swap the real and imaginary components of the complex number.
X            e.g. (4,5) would become (5,4)
X
XLee informs us that you should not judge fractals by their "outer"
Xappearance. For example, the images produced by z = sin(z) + z^2 and z =
Xsin(z) - z^2 look very similar, but are different when you zoom in.
X;
X;
X~Topic=Kam Torus, Label=HT_KAM
X(type=kamtorus, kamtorus3d)
X
XThis type is created by superimposing orbits generated by a set of
Xequations, with a variable incremented each time.
X
X     x(0) = y(0) = orbit/3;\
X     x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)\
X     y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)\
X
XAfter each orbit, 'orbit' is incremented by a step size. The parameters
Xare angle "a", step size for incrementing 'orbit', stop value for 'orbit',
Xand points per orbit. Try this with a stop value of 5 with sound=x for
Xsome weird fractal music (ok, ok, fractal noise)! You will also see the
XKAM Torus head into some chaotic territory that Scott Taylor wanted to
Xhide from you by setting the defaults the way he did, but now we have
Xrevealed all!
X
XThe 3D variant is created by treating 'orbit' as the z coordinate.
X
XWith both variants, you can adjust the "maxiter" value (<X> options
Xscreen or parameter maxiter=) to change the number of orbits plotted.
X;
X;
X~Topic=Bifurcation, Label=HT_BIF
X(type=bifxxx)
X
XThe wonder of fractal geometry is that such complex forms can arise from
Xsuch simple generating processes. A parallel surprise has emerged in the
Xstudy of dynamical systems: that simple, deterministic equations can yield
Xchaotic behavior, in which the system never settles down to a steady state
Xor even a periodic loop. Often such systems behave normally up to a
Xcertain level of some controlling parameter, then go through a transition
Xin which there are two possible solutions, then four, and finally a
Xchaotic array of possibilities.
X
XThis emerged many years ago in biological models of population growth.
XConsider a (highly over-simplified) model in which the rate of growth is
Xpartly a function of the size of the current population:
X
XNew Population =  Growth Rate * Old Population * (1 - Old Population)
X
Xwhere population is normalized to be between 0 and 1. At growth rates less
Xthan 200 percent, this model is stable: for any starting value, after
Xseveral generations the population settles down to a stable level. But for
Xrates over 200 percent, the equation's curve splits or "bifurcates" into
Xtwo discrete solutions, then four, and soon becomes chaotic.
X
XType=bifurcation illustrates this model. (Although it's now considered a
Xpoor one for real populations, it helped get people thinking about chaotic
Xsystems.) The horizontal axis represents growth rates, from 190 percent
X(far left) to 400 percent; the vertical axis normalized population values,
Xfrom 0 to 4/3. Notice that within the chaotic region, there are narrow
Xbands where there is a small, odd number of stable values. It turns out
Xthat the geometry of this branching is fractal; zoom in where changing
Xpixel colors look suspicious, and see for yourself.
X
XThree parameters apply to bifurcations: Filter Cycles, Seed Population,
Xand Function or Beta.
X
XFilter Cycles (default 1000) is the number of iterations to be done before
Xplotting maxiter population values. This gives the iteration time to settle
Xinto the characteristic patterns that constitute the bifurcation diagram,
Xand results in a clean-looking plot.  However, using lower values produces
Xinteresting results too. Set Filter Cycles to 1 for an unfiltered map.
X
XSeed Population (default 0.66) is the initial population value from which
Xall others are calculated. For filtered maps the final image is independent
Xof Seed Population value in the valid range (0.0 < Seed Population < 1.0).
X~OnlineFF
XSeed Population becomes effective in unfiltered maps - try setting Filter
XCycles to 1 (unfiltered) and Seed Population to 0.001 ("PARAMS=1/.001" on
Xthe command line). This results in a map overlaid with nice curves. Each
XSeed Population value results in a different set of curves.
X
XFunction (default "ident") is the function applied to the old population
Xbefore the new population is determined. The "ident" function calculates
Xthe same bifurcation fractal that was generated before these formulae
Xwere generalized.
X
XBeta is used in the bifmay bifurcations and is the power to which the
Xdenominator is raised.
X
XNote that fractint normally uses periodicity checking to speed up
Xbifurcation computation.  However, in some cases a better quality image
Xwill be obtained if you turn off periodicity checking with "periodicity=no";
Xfor instance, if you use a high number of iterations and a smooth
Xcolormap.
X
XMany formulae can be used to produce bifurcations.  Mitchel Feigenbaum
Xstudied lots of bifurcations in the mid-70's, using a HP-65 calculator
X(IBM PCs, Fractals, and Fractint, were all Sci-Fi then !). He studied
Xwhere bifurcations occurred, for the formula r*p*(1-p), the one described
Xabove.    He found that the ratios of lengths of adjacent areas of
Xbifurcation were four and a bit.  These ratios vary, but, as the growth
Xrate increases, they tend to a limit of 4.669+.  This helped him guess
Xwhere bifurcation points would be, and saved lots of time.
X
XWhen he studied bifurcations of r*sin(PI*p) he found a similar pattern,
Xwhich is not surprising in itself.  However, 4.669+ popped out, again.
XDifferent formulae, same number ?  Now, THAT's surprising !  He tried many
Xother formulae and ALWAYS got 4.669+ - Hot Damn !!!  So hot, in fact, that
Xhe phoned home and told his Mom it would make him Famous ! He also went on
Xto tell other scientists.  The rest is History...
X
X(It has been conjectured that if Feigenbaum had a copy of Fractint, and
Xused it to study bifurcations, he may never have found his Number, as it
Xonly became obvious from long perusal of hand-written lists of values,
Xwithout the distraction of wild color-cycling effects !).
X~OnlineFF
XWe now know that this number is as universal as PI or E. It appears in
Xsituations ranging from fluid-flow turbulence, electronic oscillators,
Xchemical reactions, and even the Mandelbrot Set - yup, fraid so:
X"budding" of the Mandelbrot Set along the negative real axis occurs at
Xintervals determined by Feigenbaum's Number, 4.669201660910.....
X
XFractint does not make direct use of the Feigenbaum Number (YET !).
XHowever, it does now reflect the fact that there is a whole sub-species of
XBifurcation-type fractals.  Those implemented to date, and the related
Xformulae, (writing P for pop[n+1] and p for pop[n]) are :
X
X  bifurcation  P =  p + r*fn(p)*(1-fn(p))  Verhulst Bifurcations.\
X  biflambda    P =      r*fn(p)*(1-fn(p))  Real equivalent of Lambda Sets.\
X  bif+sinpi    P =  p + r*fn(PI*p)         Population scenario based on...\
X  bif=sinpi    P =      r*fn(PI*p)         ...Feigenbaum's second formula.\
X  bifstewart   P =      r*fn(p)*fn(p) - 1  Stewart Map.\
X  bifmay       P =      r*p / ((1+p)^b)    May Map.\
X
XIt took a while for bifurcations to appear here, despite them being over a
Xcentury old, and intimately related to chaotic systems. However, they are
Xnow truly alive and well in Fractint!
X;
X;
X~Topic=Orbit Fractals
X
XOrbit Fractals are generated by plotting an orbit path in two or three
Xdimensional space.
X
XSee {Lorenz Attractors}, {Rossler Attractors},
X{Henon Attractors}, {Pickover Attractors}, {Gingerbreadman},
Xand {Martin Attractors}.
X
XThe orbit trajectory for these types can be saved in the file ORBITS.RAW
Xby invoking
XFractint with the "orbitsave=yes" command-line option.  This file will
Xbe overwritten each time you generate a new fractal, so rename it if you
Xwant to save it.  A nifty program called Acrospin can read these files and
Xrapidly rotate them in 3-D - see {=@ACROSPIN Acrospin}.
X;
X;
X~Topic=Lorenz Attractors, Label=HT_LORENZ
X(type=lorenz/lorenz3d)
X
XThe "Lorenz Attractor" is a "simple" set of three deterministic equations
Xdeveloped by Edward Lorenz while studying the non- repeatability of
Xweather patterns.  The weather forecaster's basic problem is that even
Xvery tiny changes in initial patterns ("the beating of a butterfly's
Xwings" - the official term is "sensitive dependence on initial
Xconditions") eventually reduces the best weather forecast to rubble.
X
XThe lorenz attractor is the plot of the orbit of a dynamic system
Xconsisting of three first order non-linear differential equations. The
Xsolution to the differential equation is vector-valued function of one
Xvariable.  If you think of the variable as time, the solution traces an
Xorbit.    The orbit is made up of two spirals at an angle to each other in
Xthree dimensions. We change the orbit color as time goes on to add a
Xlittle dazzle to the image.  The equations are:
X
X        dx/dt = -a*x + a*y\
X        dy/dt =  b*x - y   -z*x\
X        dz/dt = -c*z + x*y\
X
XWe solve these differential equations approximately using a method known
Xas the first order taylor series.  Calculus teachers everywhere will kill
Xus for saying this, but you treat the notation for the derivative dx/dt as
Xthough it really is a fraction, with "dx" the small change in x that
Xhappens when the time changes "dt".  So multiply through the above
Xequations by dt, and you will have the change in the orbit for a small
Xtime step. We add these changes to the old vector to get the new vector
Xafter one step. This gives us:
X
X         xnew = x + (-a*x*dt) + (a*y*dt)\
X         ynew = y + (b*x*dt) - (y*dt) - (z*x*dt)\
X         znew = z + (-c*z*dt) + (x*y*dt)\
X
X         (default values: dt = .02, a = 5, b = 15, c = 1)
X
XWe connect the successive points with a line, project the resulting 3D
Xorbit onto the screen, and voila! The Lorenz Attractor!
X
XWe have added two versions of the Lorenz Attractor.  "Type=lorenz" is the
XLorenz attractor as seen in everyday 2D.  "Type=lorenz3d" is the same set
Xof equations with the added twist that the results are run through our
Xperspective 3D routines, so that you get to view it from different angles
X(you can modify your perspective "on the fly" by using the <I> command.)
XIf you set the "stereo" option to "2", and have red/blue funny glasses on,
Xyou will see the attractor orbit with depth perception.
X
XHint: the default perspective values (x = 60, y = 30, z = 0) aren't the
Xbest ones to use for fun Lorenz Attractor viewing.  Experiment a bit -
Xstart with rotation values of 0/0/0 and then change to 20/0/0 and 40/0/0
Xto see the attractor from different angles.- and while you're at it, use a
Xnon-zero perspective point Try 100 and see what happens when you get
X*inside* the Lorenz orbits.  Here comes one - Duck!  While you are at it,
Xturn on the sound with the "X". This way you'll at least hear it coming!
X
XDifferent Lorenz attractors can be created using different parameters.
XFour parameters are used. The first is the time-step (dt). The default
Xvalue is .02. A smaller value makes the plotting go slower; a larger value
Xis faster but rougher. A line is drawn to connect successive orbit values.
XThe 2nd, third, and fourth parameters are coefficients used in the
Xdifferential equation (a, b, and c). The default values are 5, 15, and 1.
XTry changing these a little at a time to see the result.
X;
X;
X~Topic=Rossler Attractors, Label=HT_ROSS
X(type=rossler3D)
X
XThis fractal is named after the German Otto Rossler, a non-practicing
Xmedical doctor who approached chaos with a bemusedly philosophical
Xattitude.  He would see strange attractors as philosophical objects. His
Xfractal namesake looks like a band of ribbon with a fold in it. All we can
Xsay is we used the same calculus-teacher-defeating trick of multiplying
Xthe equations by "dt" to solve the differential equation and generate the
Xorbit.    This time we will skip straight to the orbit generator - if you
Xfollowed what we did above with type {=HT_LORENZ Lorenz} you can easily
Xreverse engineer the differential equations.
X
X         xnew = x - y*dt -     z*dt\
X         ynew = y + x*dt + a*y*dt\
X         znew = z + b*dt + x*z*dt - c*z*dt\
X
XDefault parameters are dt = .04, a = .2, b = .2, c = 5.7
X;
X;
X~Topic=Henon Attractors, Label=HT_HENON
X(type=henon)
X
XMichel Henon was an astronomer at Nice observatory in southern France. He
Xcame to the subject of fractals via investigations of the orbits of
Xastronomical objects.  The strange attractor most often linked with
XHenon's name comes not from a differential equation, but from the world of
Xdiscrete mathematics - difference equations. The Henon map is an example
Xof a very simple dynamic system that exhibits strange behavior. The orbit
Xtraces out a characteristic banana shape, but on close inspection, the
Xshape is made up of thicker and thinner parts.    Upon magnification, the
Xthicker bands resolve to still other thick and thin components.  And so it
Xgoes forever! The equations that generate this strange pattern perform the
Xmathematical equivalent of repeated stretching and folding, over and over
Xagain.
X
X         xnew =  1 + y - a*x*x\
X         ynew =  b*x\
X
XThe default parameters are a=1.4 and b=.3.
X;
X;
X~Topic=Pickover Attractors, Label=HT_PICK
X(type=pickover)
X
XClifford A. Pickover of the IBM Thomas J. Watson Research center is such a
Xcreative source for fractals that we attach his name to this one only with
Xgreat trepidation.  Probably tomorrow he'll come up with another one and
Xwe'll be back to square one trying to figure out a name!
X
XThis one is the three dimensional orbit defined by:
X
X         xnew = sin(a*y) - z*cos(b*x)\
X         ynew = z*sin(c*x) - cos(d*y)\
X         znew = sin(x)\
X
XDefault parameters are: a = 2.24, b = .43, c = -.65, d = -2.43
X;
X;
X~Topic=Gingerbreadman, Label=HT_GINGER
X(type=gingerbreadman)
X
XThis simple fractal is a charming example stolen from "Science of Fractal
XImages", p. 149.
X
X         xnew = 1 - y + |x|\
X         ynew = x
X
XThe initial x and y values are set by parameters, defaults x=-.1, y = 0.
X;
X;
X~Topic=Martin Attractors, Label=HT_MARTIN
X(type=hopalong/martin)
X
XThese fractal types are from A. K. Dewdney's "Computer Recreations" column
Xin "Scientific American". They are attributed to Barry Martin of Aston
XUniversity in Birmingham, England.
X
XHopalong is an "orbit" type fractal like lorenz. The image is obtained by
Xiterating this formula after setting z(0) = y(0) = 0:\
X      x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))\
X      y(n+1) = a - x(n)\
XParameters are a, b, and c. The function "sign()"  returns 1 if the argument
Xis positive, -1 if argument is negative.
X
XThis fractal continues to develop in surprising ways after many iterations.
X
XAnother Martin fractal is simpler. The iterated formula is:\
X      x(n+1) = y(n) - sin(x(n))\
X      y(n+1) = a - x(n)\
XThe parameter is "a". Try values near the number pi.
X;
X;
X;
X~Topic=Icon, Label=HT_ICON
X(type=icon/icon3d)
X
X  This fractal type was inspired by the book "Symmetry in Chaos"
X  by Michael Field and Martin Golubitsky (ISBN 0-19-853689-5, Oxford Press)
X
X  To quote from the book's jacket,
X
X    "Field and Golubitsky describe how a chaotic process eventually can
X    lead to symmetric patterns (in a river, for instance, photographs of
X    the turbulent movement of eddies, taken over time, often reveal
X    patterns on the average."
X
X  The Icon type implemented here maps the classic population logistic
X  map of bifurcation fractals onto the complex plane in Dn symmetry.
X
X  The initial points plotted are the more chaotic initial orbits, but
X  as you wait, delicate webs will begin to form as the orbits settle
X  into a more periodic pattern.  Since pixels are colored by the number
X  of times they are hit, the more periodic paths will become clarified
X  with time.  These fractals run continuously.
X
XThere are 6 parameters:  Lambda, Alpha, Beta, Gamma, Omega, and Degree
X    Omega  0 = Dn, or dihedral (rotation + reflectional) symmetry
X          !0 = Zn, or cyclic (rotational) symmetry
X    Degree = n, or Degree of symmetry
X;
X;
X;
X~Topic=Quaternion, Label=HT_QUAT
X(type=quat,quatjul)
X
XThese fractals are based on quaternions.  Quaternions are an extension of
Xcomplex numbers, with 4 parts instead of 2.  That is, a quaternion Q
Xequals a+ib+jc+kd, where a,b,c,d are reals.  Quaternions have rules for
Xaddition and multiplication.  The normal Mandelbrot and Julia formulas
Xcan be generalized to use quaternions instead of complex numbers.
X
XThere is one complication.  Complex numbers have 2 parts, so they can
Xbe displayed on a plane.  Quaternions have 4 parts, so they require 4
Xdimensions to view.  That is, the quaternion Mandelbrot set is actually a
X4-dimensional object.  Each quaternion C generates a 4-dimensional Julia set.
X
XOne method of displaying the 4-dimensional object is to take a 3-dimensional
Xslice and render the resulting object in 3-dimensional perspective.
XFractint isn't that sophisticated, so it merely displays a 2-dimensional
Xslice of the resulting object. (Note: Now Fractint is that sophisticated!
XSee the Julibrot type!)
X
XIn fractint, for the Julia set, you can specify the four parameters
Xof the quaternion constant: c=(c1,ci,cj,ck), but the 2-dimensional slice
Xof the z-plane Julia set is fixed to (xpixel,ypixel,0,0).
X
XFor the Mandelbrot set, you can specify the position of the c-plane slice:
X(xpixel,ypixel,cj,ck).
X
XThese fractals are discussed in Chapter 10 of Pickover's "Computers,
XPattern, Chaos, and Beauty".
X;
X;
X~Topic=HyperComplex, Label=HT_HYPERC
X(type=hypercomplex,hypercomplexj)
X
XThese fractals are based on hypercomplex numbers, which like quaternions
Xare a four dimensional generalization of complex numbers. It is not
Xpossible to fully generalize the complex numbers to four dimensions without
Xsacrificing some of the algebraic properties shared by real and complex
Xnumbers. Quaternions violate the commutative law of multiplication, which
Xsays z1*z2 = z2*z1. Hypercomplex numbers fail the rule that says all non-zero
Xelements have multiplicative inverses - that is, if z is not 0, there
Xshould be a number 1/z such that (1/z)*(z) = 1. This law holds most of the
Xtime but not all the time for hypercomplex numbers.
X
XHowever hypercomplex numbers have a wonderful property for fractal purposes.
XEvery function defined for complex numbers has a simple generalization
Xto hypercomplex numbers. Fractint's implementation takes advantage of this
Xby using "fn" variables - the iteration formula is\
X    h(n+1) = fn(h(n)) + C.\
Xwhere "fn" is the hypercomplex generalization of sin, cos, log, sqr etc.
X~OnlineFF
XYou can see 3D versions of these fractals using fractal type Julibrot.
XHypercomplex numbers were brought to our attention by Clyde Davenport,
Xauthor of "A Hypercomplex Calculus with Applications to Relativity",
XISBN 0-9623837-0-8.
X;
X;
X
X~Topic=Cellular Automata, Label=HT_CELLULAR
X(type=cellular)
X
XThese fractals are generated by 1-dimensional cellular automata.  Consider
Xa 1-dimensional line of cells, where each cell can have the value 0 or 1.
XIn each time step, the new value of a cell is computed from the old value
Xof the cell and the values of its neighbors.  On the screen, each horizontal
Xrow shows the value of the cells at any one time.  The time axis proceeds
Xdown the screen, with each row computed from the row above.
X
XDifferent classes of cellular automata can be described by how many different
Xstates a cell can have (k), and how many neighbors on each side are examined
X(r).  Fractint implements the binary nearest neighbor cellular automata
X(k=2,r=1), the binary next-nearest neighbor cellular automata (k=2,r=2),
Xand the ternary nearest neighbor cellular automata (k=3,r=1) and several
Xothers.
X
XThe rules used here determine the next state of a given cell by using the
Xsum of the states in the cell's neighborhood.  The sum of the cells in the
Xneighborhood are mapped by rule to the new value of the cell.  For the
Xbinary nearest neighbor cellular automata, only the closest neighbor on
Xeach side is used.  This results in a 4 digit rule controlling the
Xgeneration of each new line:  if each of the cells in the neighborhood is
X1, the maximum sum is 1+1+1 = 3 and the sum can range from 0 to 3, or 4
Xvalues.  This results in a 4 digit rule.  For instance, in the rule 1010,
Xstarting from the right we have 0->0, 1->1, 2->0, 3->1.  If the cell's
Xneighborhood sums to 2, the new cell value would be 0.
X
XFor the next-nearest cellular automata (kr = 22), each pixel is determined
Xfrom the pixel value and the two neighbors on each side.  This results in
Xa 6 digit rule.
X
XFor the ternary nearest neighbor cellular automata (kr = 31), each cell
Xcan have the value 0, 1, or 2.  A single neighbor on each side is examined,
Xresulting in a 7 digit rule.
X
X  kr  #'s in rule  example rule     | kr  #'s in rule  example rule\
X  21      4        1010             | 42     16        2300331230331001\
X  31      7        1211001          | 23      8        10011001\
X  41     10        3311100320       | 33     15        021110101210010\
X  51     13        2114220444030    | 24     10        0101001110\
X  61     16        3452355321541340 | 25     12        110101011001\
X  22      6        011010           | 26     14        00001100000110\
X  32     11        21212002010      | 27     16        0010000000000110\
X
XThe starting row of cells can be set to a pattern of up to 16 digits or to a
Xrandom pattern.  The borders are set to zeros if a pattern is entered or are
Xset randomly if the starting row is set randomly.
X
XA zero rule will randomly generate the rule to use.
X
XHitting the space bar toggles between continuously generating the cellular
Xautomata and stopping at the end of the current screen.
X
XRecommended reading:
X"Computer Software in Science and Mathematics", Stephen Wolfram, Scientific
XAmerican, September, 1984.
X"Abstract Mathematical Art", Kenneth E. Perry, BYTE, December, 1986.
X"The Armchair Universe", A. K. Dewdney, W. H. Freeman and Company, 1988.
X"Complex Patterns Generated by Next Nearest Neighbors Cellular Automata",
XWentian Li, Computers & Graphics, Volume 13, Number 4.
X;
X;
X~Topic=Test, Label=HT_TEST
X(type=test)
X
XThis is a stub that we (and you!) use for trying out new fractal types.
X"Type=test" fractals make use of Fractint's structure and features for
Xwhatever code is in the routine 'testpt()' (located in the small source
Xfile TESTPT.C) to determine the color of a particular pixel.
X
XIf you have a favorite fractal type that you believe would fit nicely into
XFractint, just rewrite the C function in TESTPT.C (or use the prototype
Xfunction there, which is a simple M-set implementation) with an algorithm
Xthat computes a color based on a point in the complex plane.
X
XAfter you get it working, send your code to one of the authors and we
Xmight just add it to the next release of Fractint, with full credit to
Xyou. Our criteria are: 1) an interesting image and 2) a formula
Xsignificantly different from types already supported. (Bribery may also
Xwork. THIS author is completely honest, but I don't trust those other
Xguys.) Be sure to include an explanation of your algorithm and the
Xparameters supported, preferably formatted as you see here to simplify
Xfolding it into the documentation.
X;
X;
X~Topic=Formula, Label=HT_FORMULA
X(type=formula)
X
XThis is a "roll-your-own" fractal interpreter - you don't even need a
Xcompiler!
X
XTo run a "type=formula" fractal, you first need a text file containing
Xformulas (there's a sample file - FRACTINT.FRM - included with this
Xdistribution).    When you select the "formula" fractal type, Fractint scans
Xthe current formula file (default is FRACTINT.FRM) for formulas, then
Xprompts you for the formula name you wish to run.  After prompting for any
Xparameters, the formula is parsed for syntax errors and then the fractal
Xis generated. If you want to use a different formula file, press <F6> when
Xyou are prompted to select a formula name.
X
XThere are two command-line options that work with type=formula
X("formulafile=" and "formulaname="), useful when you are using this
Xfractal type in batch mode.
X
XThe following documentation is supplied by Mark Peterson, who wrote the
Xformula interpreter:
X
XFormula fractals allow you to create your own fractal formulas.  The
Xgeneral format is:
X
X   Mandelbrot(XAXIS) \{ z = Pixel:  z = sqr(z) + pixel, |z| <= 4 \}\
X      |     |       |            |           |\
X     Name     Symmetry      Initial      Iteration      Bailout\
X              Condition              Criteria\
X
XInitial conditions are set, then the iterations performed until the
Xbailout criteria is true or 'z' turns into a periodic loop.
XAll variables are created automatically by their usage and treated as
Xcomplex.  If you declare 'v = 2' then the variable 'v' is treated as a
Xcomplex with an imaginary value of zero.
X
X~Format-
X      Predefined Variables (x, y)
X      --------------------------------------------
X      z         used for periodicity checking
X      p1         parameters 1 and 2
X      p2         parameters 3 and 4
X      pixel      screen coordinates
X          LastSqr        Modulus from the last sqr() function
X          rand           Complex random number
X
X          Precedence
X          --------------------------------------------
X          1              sin(), cos(), sinh(), cosh(), cosxx(),
X                         tan(), cotan(), tanh(), cotanh(),
X                         sqr, log(), exp(), abs(), conj(), real(),
X                         imag(), flip(), fn1(), fn2(), fn3(), fn4(),
X                         srand()
X          2              - (negation), ^ (power)
X          3              * (multiplication), / (division)
X          4              + (addition), - (subtraction)
X          5              = (assignment)
X          6              < (less than), <= (less than or equal to)
X                         > (greater than), >= (greater than or equal to)
X                         == (equal to), != (not equal to)
X          7              && (logical AND), || (logical OR)
X~Format+
X
XPrecedence may be overridden by use of parenthesis.  Note the modulus
Xsquared operator |z| is also parenthetic and always sets the imaginary
Xcomponent to zero.  This means 'c * |z - 4|' first subtracts 4 from z,
Xcalculates the modulus squared then multiplies times 'c'.  Nested modulus
Xsquared operators require overriding parenthesis:\
X      c * |z + (|pixel|)|\
X
XThe functions fn1(...) to fn4(...) are variable functions - when used,
Xthe user is prompted at run time (on the <Z> screen) to specify one of
Xsin, cos, sinh, cosh, exp, log, sqr, etc. for each required variable function.
X
XThe formulas are performed using either integer or floating point
Xmathematics depending on the <F> floating point toggle.  If you do not
Xhave an FPU then type MPC math is performed in lieu of traditional
Xfloating point.
X
XThe 'rand' predefined variable is changed with each iteration to a new
Xrandom number with the real and imaginary components containing a value
Xbetween zero and 1. Use the srand() function to initialize the random
Xnumbers to a consistent random number sequence.  If a formula does not
Xcontain the srand() function, then the formula compiler will use the system
Xtime to initialize the sequence.  This could cause a different fractal to be
Xgenerated each time the formula is used depending on how the formula is
Xwritten.
X
XRemember that when using integer math there is a limited dynamic range, so
Xwhat you think may be a fractal could really be just a limitation of the
Xinteger math range.  God may work with integers, but His dynamic range is
Xmany orders of magnitude greater than our puny 32 bit mathematics!  Always
Xverify with the floating point <F> toggle.
X;
X;
X~Topic=Frothy Basins, Label=HT_FROTH
X(type=frothybasin)
X
XFrothy Basins, or Riddled Basins, were discovered by James C. Alexander of
Xthe University of Maryland.  The discussion below is derived from a two page
Xarticle entitled "Basins of Froth" in Science News, November 14, 1992 and
Xfrom correspondence with others, including Dr. Alexander.
X
XThe equations that generate this fractal are not very different from those
Xthat generate many other orbit fractals.
X
X~Format-
X      z(0) = pixel;
X      z(n+1) = z(n)^2 - c*conj(z(n))
X      where c = 1 + ai,  and  a = 1.02871376822...
X~Format+
X
XOne of the things that makes this fractal so interesting is the shape of
Xthe dynamical system's attractors.  It is not at all uncommon for a
Xdynamical system to have non-point attractors.  Shapes such as circles are
Xvery common.  Strange attractors are attractors which are themselves
Xfractal.  What is unusual about this system, however, is that the
Xattractors intersect.  This is the first case in which such a phenomenon
Xhas been observed.  The three attractors for this system are made up of
Xline segments which overlap to form an equilateral triangle.  This
Xattractor triangle can be seen by pressing the 'o' key while the fractal
Xis being generated to turn on the "show orbits" option.
X
XAn interesting variation on this fractal can be generated by applying the
Xabove mapping twice per each iteration.  The result is that each of the
Xthree attractors is split into two parts, giving the system six
Xattractors.
X
XThese are also called "Riddled Basins" because each basin is riddled with
Xholes.  Which attractor a point is eventually pulled into is extremely
Xsensitive to its initial position.  A very slight change in any direction
Xmay cause it to end up on a different attractor.  As a result, the basins
Xare thoroughly intermingled. The effect appears to be a frothy mixture that
Xhas been subjected to lots of stirring and folding.
X
XPixel color is determined by which attractor captures the orbit.  The shade
Xof color is determined by the number of iterations required to capture the
Xorbit.  In Fractint, the actual shade of color used depends on how many
Xcolors are available in the video mode being used.
X
XIf 256 colors are available, the default coloring scheme is determined by
Xthe number of iterations that were required to capture the orbit.  An
Xalternative coloring scheme can be used where the shade is determined by
Xthe iterations required divided by the maximum iterations.  This method is
Xespecially useful on deeply zoomed images.
X
XIf only 16 colors are available, then only the alternative coloring
Xscheme is used.  If fewer than 16 colors are available, then Fractint
Xjust colors the basins without any shading.
X;
X;
X~Topic=Julibrots, Label=HT_JULIBROT
X(type=julibrot)
X
XThe Julibrot fractal type uses a general-purpose renderer for visualizing
Xthree dimensional solid fractals. Originally Mark Peterson developed
Xthis rendering mechanism to view a 3-D sections of a 4-D structure he
Xcalled a "Julibrot".  This structure, also called "layered Julia set" in
Xthe fractal literature, hinges on the relationship between the Mandelbrot
Xand Julia sets. Each Julia set is created using a fixed value c in the
Xiterated formula z^2 + c. The Julibrot is created by layering Julia sets
Xin the x-y plane and continuously varying c, creating new Julia sets as z is
Xincremented. The solid shape thus created is rendered by shading the surface
Xusing a brightness inversely proportional to the virtual viewer's eye.
X
XStarting with Fractint version 18, the Julibrot engine can be used
Xwith other Julia formulas besides the classic z^2 + c. The first field on
Xthe Julibrot parameter screen lets you select which orbit formula to use.
X
XYou can also use the Julibrot renderer to visualize 3D cross sections of
Xtrue four dimensional Quaternion and Hypercomplex fractals.
X
XThe Julibrot Parameter Screens
X
XOrbit Algorithm - select the orbit algorithm to use. The available
X   possibilities include 2-D Julia and both mandelbrot and Julia variants
X   of the 4-D Quaternion and Hypercomplex fractals.
X
XOrbit parameters - the next screen lets you fill in any parameters
X   belonging to the orbit algorithm. This list of parameters is not
X   necessarily the same as the list normally presented for the orbit
X   algorithm, because some of these parameters are used in the Julibrot
X   layering process.
X
X   From/To Parameters
X   These parameters allow you to specify the "Mandelbrot" values used to
X   generate the layered Julias. The parameter c in the Julia formulas will
X   be incremented in steps ranging from the "from" x and y values to the
X   "to" x and y values. If the orbit formula is one of the "true" four
X   dimensional fractal types quat, quatj, hypercomplex, or hypercomplexj,
X   then these numbers are used with the 3rd and 4th dimensional values.
X
X   The "from/to" variables are different for the different kinds of orbit
X   algorithm.
X
X      2D Julia sets - complex number formula z' = f(z) + c\
X         The "from/to" parameters change the values of c.\
X      4D Julia sets - Quaternion or Hypercomplex formula z' = f(z) + c\
X         The four dimensions of c are set by the orbit parameters.\
X         The first two dimensions of z are determined by the corners values.\
X         The third and fourth dimensions of z are the "to/from" variables.\
X      4D Mandelbrot sets - Quaternion or Hypercomplex formula z' = f(z) + c\
X         The first two dimensions of c are determined by the corners values.\
X         The third and fourth dimensions of c are the "to/from" variables.\
X
XDistance between the eyes - set this to 2.5 if you want a red/blue
X   anaglyph image, 0 for a normal greyscale image.
X
XNumber of z pixels - this sets how many layers are rendered in the screen
X   z-axis. Use a higher value with higher resolution video modes.
X
XThe remainder of the parameters are needed to construct the red/blue
Xpicture so that the fractal appears with the desired depth and proper 'z'
Xlocation.  With the origin set to 8 inches beyond the screen plane and the
Xdepth of the fractal at 8 inches the default fractal will appear to start
Xat 4 inches beyond the screen and extend to 12 inches if your eyeballs are
X2.5 inches apart and located at a distance of 24 inches from the screen.
XThe screen dimensions provide the reference frame.
X
X;
X;
X~Topic=Diffusion Limited Aggregation, Label=HT_DIFFUS
X(type=diffusion)
X
XThis type begins with a single point in the center of the screen.
XSubsequent points move around randomly until coming into contact with the
Xfirst point, at which time their locations are fixed and they are colored
Xrandomly.  This process repeats until the fractals reaches the edge of the
Xscreen.  Use the show orbits function to see the points' random motion.
X
XOne unfortunate problem is that on a large screen, this process will tend
Xto take eons.  To speed things up, the points are restricted to a box
Xaround the initial point.  The first and only parameter to diffusion
Xcontains the size of the border between the fractal and the edge of the
Xbox.  If you make this number small, the fractal will look more solid and
Xwill be generated more quickly.
X
XDiffusion was inspired by a Scientific American article a couple of years
Xback which includes actual pictures of real physical phenomena that behave
Xlike this.
X
XThanks to Adrian Mariano for providing the diffusion code and
Xdocumentation. Juan J. Buhler added the additional options.
X;
X;
X~Topic=Lyapunov Fractals, Label=HT_LYAPUNOV
X(type=lyapunov)
X
XThe Bifurcation fractal illustrates what happens in a simple population
Xmodel as the growth rate increases.  The Lyapunov fractal expands that model
Xinto two dimensions by letting the growth rate vary in a periodic fashion
Xbetween two values.  Each pair of growth rates is run through a logistic
Xpopulation model and a value called the Lyapunov Exponent is calculated for
Xeach pair and is plotted. The Lyapunov Exponent is calculated by adding up
Xlog | r - 2*r*x| over many cycles of the population model and dividing by the
Xnumber of cycles. Negative Lyapunov exponents indicate a stable, periodic
Xbehavior and are plotted in color. Positive Lyapunov exponents indicate
Xchaos (or a diverging model) and are colored black.
X
XOrder parameter.
XEach possible periodic sequence yields a two dimensional space to explore.
XThe Order parameter selects a sequence.  The default value 0 represents the
Xsequence ab which alternates between the two values of the growth parameter.
XOn the screen, the a values run vertically and the b values run
Xhorizontally. Here is how to calculate the space parameter for any desired
Xsequence.  Take your sequence of a's and b's and arrange it so that it starts
Xwith at least 2 a's and ends with a b. It may be necessary to rotate the
Xsequence or swap a's and b's. Strike the first a and the last b off the list
Xand replace each remaining a with a 1 and each remaining b with a zero.
XInterpret this as a binary number and convert it into decimal.
X
XAn Example.
XI like sonnets.  A sonnet is a poem with fourteen lines that has the
Xfollowing rhyming sequence: abba abba abab cc.  Ignoring the rhyming couplet
Xat the end, let's calculate the Order parameter for this pattern.
X
X  abbaabbaabab         doesn't start with at least 2 a's \
X  aabbaabababb         rotate it \
X  1001101010           drop the first and last, replace with 0's and 1's \
X  512+64+32+8+2 = 618
X
XAn Order parameter of 618 gives the Lyapunov equivalent of a sonnet.  "How do
XI make thee? Let me count the ways..."
X
XPopulation Seed.
XWhen two parts of a Lyapunov overlap, which spike overlaps which is strongly
Xdependent on the initial value of the population model.  Any changes from
Xusing a different starting value between 0 and 1 may be subtle. The values 0
Xand 1 are interpreted in a special manner. A Seed of 1 will choose a random
Xnumber between 0 and 1 at the start of each pixel. A Seed of 0 will suppress
Xresetting the seed value between pixels unless the population model diverges
Xin which case a random seed will be used on the next pixel.
X
XFilter Cycles.
XLike the Bifurcation model, the Lyapunov allow you to set the number of
Xcycles that will be run to allow the model to approach equilibrium before
Xthe lyapunov exponent calculation is begun. The default value of 0 uses one
Xhalf of the iterations before beginning the calculation of the exponent.
X
XReference.
XA.K. Dewdney, Mathematical Recreations, Scientific American, Sept. 1991
X;
X;
X~Topic=Magnetic Fractals, Label=HT_MAGNET
X(type=magnet1m/.../magnet2j)
X
XThese fractals use formulae derived from the study of hierarchical
Xlattices, in the context of magnetic renormalisation transformations.
XThis kinda stuff is useful in an area of theoretical physics that deals
Xwith magnetic phase-transitions (predicting at which temperatures a given
Xsubstance will be magnetic, or non-magnetic).  In an attempt to clarify
Xthe results obtained for Real temperatures (the kind that you and I can
Xfeel), the study moved into the realm of Complex Numbers, aiming to spot
XReal phase-transitions by finding the intersections of lines representing
XComplex phase-transitions with the Real Axis.  The first people to try
Xthis were two physicists called Yang and Lee, who found the situation a
Xbit more complex than first expected, as the phase boundaries for Complex
Xtemperatures are (surprise!) fractals.
X
XAnd that's all the technical (?) background you're getting here!  For more
Xdetails (are you SERIOUS ?!) read "The Beauty of Fractals".  When you
Xunderstand it all, you might like to rewrite this section, before you
Xstart your new job as a professor of theoretical physics...
X
XIn Fractint terms, the important bits of the above are "Fractals",
X"Complex Numbers", "Formulae", and "The Beauty of Fractals".  Lifting the
XFormulae straight out of the Book and iterating them over the Complex
Xplane (just like the Mandelbrot set) produces Fractals.
X
XThe formulae are a bit more complicated than the Z^2+C used for the
XMandelbrot Set, that's all.  They are :
X
X~Format-
X          [          ] 2
X          |  Z^2 + (C-1)  |
X    MAGNET1 : | ------------- |
X          |  2*Z + (C-2)  |
X          [          ]
X
X          [                        ] 2
X          |     Z^3 + 3*(C-1)*Z + (C-1)*(C-2)        |
X    MAGNET2 : | --------------------------------------- |
X          |  3*(Z^2) + 3*(C-2)*Z + (C-1)*(C-2) + 1  |
X          [                        ]
X~Format+
X
XThese aren't quite as horrific as they look (oh yeah ?!) as they only
Xinvolve two variables (Z and C), but cubing things, doing division, and
Xeventually squaring the result (all in Complex Numbers) don't exactly
Xspell S-p-e-e-d !  These are NOT the fastest fractals in Fractint !
X
XAs you might expect, for both formulae there is a single related
XMandelbrot-type set (magnet1m, magnet2m) and an infinite number of related
XJulia-type sets (magnet1j, magnet2j), with the usual toggle between the
Xcorresponding Ms and Js via the spacebar.
X
XIf you fancy delving into the Julia-types by hand, you will be prompted
Xfor the Real and Imaginary parts of the parameter denoted by C.  The
Xresult is symmetrical about the Real axis (and therefore the initial image
Xgets drawn in half the usual time) if you specify a value of Zero for the
XImaginary part of C.
X
XFractint Historical Note:  Another complication (besides the formulae) in
Ximplementing these fractal types was that they all have a finite attractor
X(1.0 + 0.0i), as well as the usual one (Infinity).  This fact spurred the
Xdevelopment of Finite Attractor logic in Fractint.  Without this code you
Xcan still generate these fractals, but you usually end up with a pretty
Xboring image that is mostly deep blue "lake", courtesy of Fractint's
Xstandard {Periodicity Logic}.
XSee {Finite Attractors} for more
Xinformation on this aspect of Fractint internals.
X
X(Thanks to Kevin Allen for Magnetic type documentation above).
X;
X;
X~Topic=L-Systems, Label=HT_LSYS
X(type=lsystem)
X
XThese fractals are constructed from line segments using rules specified in
Xdrawing commands.  Starting with an initial string, the axiom,
Xtransformation rules are applied a specified number of times, to produce
Xthe final command string which is used to draw the image.
X
XLike the type=formula fractals, this type requires a separate data file.
XA sample file, FRACTINT.L, is included with this distribution.    When you
Xselect type lsystem, the current lsystem file is read and you are asked
Xfor the lsystem name you wish to run. Press <F6> at this point if you wish
Xto use a different lsystem file. After selecting an lsystem, you are asked
Xfor one parameter - the "order", or number of times to execute all the
Xtransformation rules.  It is wise to start with small orders, because the
Xsize of the substituted command string grows exponentially and it is very
Xeasy to exceed your resolution.  (Higher orders take longer to generate
Xtoo.)  The command line options "lname=" and "lfile=" can be used to over-
Xride the default file name and lsystem name.
X
XEach L-System entry in the file contains a specification of the angle, the
Xaxiom, and the transformation rules.  Each item must appear on its own
Xline and each line must be less than 160 characters long.
X
XThe statement "angle n" sets the angle to 360/n degrees; n must be an
Xinteger greater than two and less than fifty.
X
X"Axiom string" defines the axiom.
X
XTransformation rules are specified as "a=string" and convert the single
Xcharacter 'a' into "string."  If more than one rule is specified for a
Xsingle character all of the strings will be added together.  This allows
Xspecifying transformations longer than the 160 character limit.
XTransformation rules may operate on any characters except space, tab or
X'}'.
X
XAny information after a ; (semi-colon) on a line is treated as a comment.
X
XHere is a sample lsystem:
X
X~Format-
XDragon \{      ; Name of lsystem, \{ indicates start
X  Angle 8     ; Specify the angle increment to 45 degrees
X  Axiom FX     ; Starting character string
X  F=         ; First rule:    Delete 'F'
X  y=+FX--FY+     ; Change 'y' into  "+fx--fy+"
X  x=-FX++FY-     ; Similar transformation on 'x'
X}         ; final } indicates end
X
XThe standard drawing commands are:
X    F Draw forward
X    G Move forward (without drawing)
X    + Increase angle
X    - Decrease angle
X    | Try to turn 180 degrees. (If angle is odd, the turn
X      will be the largest possible turn less than 180 degrees.)
X~Format+
X
XThese commands increment angle by the user specified angle value. They
Xshould be used when possible because they are fast. If greater flexibility
Xis needed, use the following commands which keep a completely separate
Xangle pointer which is specified in degrees.
X
X~Format-
X    D    Draw forward
X    M    Move forward
X    \nn Increase angle nn degrees
X    /nn Decrease angle nn degrees
X
XColor control:
X    Cnn Select color nn
X    <nn Increment color by nn
X    >nn decrement color by nn
X
XAdvanced commands:
X    !      Reverse directions (Switch meanings of +, - and \, /)
X    @nnn  Multiply line segment size by nnn
X      nnn may be a plain number, or may be preceded by
X          I for inverse, or Q for square root.
X          (e.g.  @IQ2 divides size by the square root of 2)
X    [      Push.  Stores current angle and position on a stack
X    ]      Pop.    Return to location of last push
X~Format+
X
XOther characters are perfectly legal in command strings.  They are ignored
Xfor drawing purposes, but can be used to achieve complex translations.
X;
X;
X;
SHAR_EOF
$TOUCH -am 1028230193 help2.src &&
chmod 0644 help2.src ||
echo "restore of help2.src failed"
set `wc -c help2.src`;Wc_c=$1
if test "$Wc_c" != "116316"; then
    echo original size 116316, current size $Wc_c
fi
# ============= help3.src ==============
echo "x - extracting help3.src (Text)"
sed 's/^X//' << 'SHAR_EOF' > help3.src &&
X~Topic=Doodads\, Bells\, and Whistles
X
X~Format-
X   { Drawing Method }
X   { Autokey Mode }
X   { Distance Estimator Method }
X   { Inversion }
X   { Decomposition }
X   { Logarithmic Palettes and Color Ranges }
X   { Biomorphs }
X   { Continuous Potential }
X   { Starfields }
X~Format+
X;
X;
X;
X~Topic=Drawing Method
X
XThe "passes option" (<X> options screen or "passes=" parameter)
Xselects single-pass, dual-pass, or solid-guessing
X(default) mode.  This option applies to most fractal types.
X
XSingle-pass mode ("1") draws the screen pixel by pixel.
X
XDual-pass ("2") generates a "coarse" screen first as a preview
Xusing 2x2-pixel boxes, and then generates the rest of the dots with a
Xsecond pass.
X
XSolid-guessing ("g") is the default.  It performs from two to four
Xvisible passes -
Xmore in higher resolution video modes. Its first visible pass is
Xactually two passes - one pixel per 4x4, 8x8, or 16x16 pixel box
Xis generated, and the guessing logic is
Xapplied to fill in the blocks at the next level (2x2, 4x4, or 8x8).
XSubsequent passes fill in the display at the next finer resolution,
Xskipping blocks which are surrounded by the same color. Solid-guessing can
Xguess wrong, but it sure guesses quickly!
X
XBoundary Tracing ("b"), which only
Xworks with fractal types (such as the Mandelbrot set, but not the Newton
Xtype) that do not contain "islands" of colors, finds a color "boundary",
Xtraces it around the screen, and then "blits" in the color over the
Xenclosed area.
X
XTesseral ("t") is a sort of "super-solid-guessing" option that successively
Xdivides the image into subsections.  It's actually slower than the
Xsolid-guessing algorithm, but it looks neat, so we left it in.\
X
XThe "fillcolor=" option in the <X> screen or on the command line sets a
Xfixed color to be used by the Boundary Tracing and Tesseral calculations
Xfor filling in defined regions. The effect of this is to show off the
Xboundaries of the areas delimited by these two methods.
X;
X;
X~Topic=Autokey Mode
X
XThe autokey feature allows you to set up beautiful self-running demo
X"loops". You can set up hypnotic sequences to attract people to a booth,
Xto generate sequences for special effects, to teach how Fractal exploring
Xis done, etc.
X
XA sample autokey file (DEMO.KEY) and a batch to run it (DEMO.BAT) are
Xincluded with Fractint. Type "demo" at the DOS prompt to run it.
X
XAutokey record mode is enabled with the command line parameter
X"AUTOKEY=RECORD". Keystrokes are saved in an intelligible text format in a
Xfile called AUTO.KEY. You can change the file name with the "AUTOKEYNAME="
Xparameter.
X
XPlayback is enabled with the parameter "AUTOKEY=PLAY". Playback can be
Xterminated by pressing the <Esc> key.
X
XAfter using record mode to capture an autokey file, you'll probably want
Xto touch it up using your editor before playing it back.
X
XSeparate lines are not necessary but you'll probably find it
Xeasier to understand an autokey file if you put each command on a separate
Xline. Autokey files can contain the following:
X
X  Quoted strings. Fractint reads whatever is between the quotes just as if
X  you had typed it. For example,
X      "t" "ifs"
X  issues the "t" (type) command and then enters the letters i", "f", and
X  "s" to select the ifs type.
X
X  Symbols for function keys used to select a video mode. Examples:\
X      F3  -- Function key 3\
X      SF3 --<Shift> and <F3> together\
X
X  Special keys: ENTER ESC F1 PAGEUP PAGEDOWN HOME END LEFT RIGHT UP DOWN
X  INSERT DELETE TAB
X
X  WAIT <nnn.n> -- wait nnn.n seconds before continuing
X
X  CALCWAIT -- pause until the current fractal calculation or file save or
X  restore is finished. This command makes demo files more robust since
X  calculation times depend on the  speed of the machine running the demo -
X  a "WAIT 10" command may allow enough time to complete a fractal on one
X  machine, but not on another. The record mode does not generate this
X  command - it should be added by hand to the autokey file whenever there
X  is a process that should be allowed to run to completion.
X
X  GOTO target -- The autokey file continues to be read from the label
X  "target". The label can be any word that does not duplicate a key word.
X  It must be present somewhere in the autokey file with a colon after it.
X  Example:\
X      MESSAGE 2 This is executed once\
X      start:\
X      MESSAGE 2 This is executed repeatedly\
X      GOTO start\
X  GOTO is mainly useful for writing continuous loop demonstrations. It can
X  also be useful when debugging an autokey file, to skip sections of it.
X
X  ; -- A semi-colon indicates that the rest of the line containing it is a
X  comment.
X
X  MESSAGE nn <Your message here> -- Places a message on the top of the
X  screen for nn seconds
X
XMaking Fractint demos can be tricky. Here are some suggestions which may
Xhelp:
X
X  Start Fractint with "fractint autokeyname=mydemo.key autokey=record".
X  Use a unique name each time you run so that you don't overwrite prior
X  files.
X
X  When in record mode, avoid using the cursor keys to select filenames,
X  fractal types, formula names, etc. Instead, try to type in names. This
X  will ensure that the exact item you want gets chosen during playback
X  even if the list is different then.
X
X  Beware of video mode assumptions. It is safest to build a separate demo
X  for different resolution monitors.
X
X  When in the record mode, try to type names quickly, then pause. If you
X  pause partway through a name Fractint will break up the string in the
X  .KEY file. E.g. if you paused in the middle of typing fract001, you
X  might get:\
X      "fract"\
X      WAIT 2.2\
X      "001"\
X  No harm done, but messy to clean up. Fractint ignores pauses
X  less than about 1/2 second.
X
X  DO pause when you want the viewer to see what is happening during
X  playback.
X
X  When done recording, clean up your mydemo.key file. Insert a CALCWAIT
X  after each keystroke which triggers something that takes a variable
X  amount of time (calculating a fractal, restoring a file, saving a file).
X
X  Add comments with ";" to the file so you know what is going on in
X  future.
X
X  It is a good idea to use INSERT before a GOTO which restarts the demo.
X  The <insert> key resets Fractint as if you exited the program and
X  restarted it.
X
XWarning: an autokey file built for this version of Fractint will probably
Xrequire some retouching before it works with future releases of Fractint.
XWe have no intention of making sure that the same sequence of keystrokes
Xwill have exactly the same effect from one version of Fractint to the
Xnext. That would require pretty much freezing Fractint development, and we
Xjust love to keep enhancing it!
X;
X;
X;
X~Topic=Distance Estimator Method
X
XThis is Phil Wilson's implementation of an alternate method for the M and
XJ sets, based on work by mathematician John Milnor and described in "The
XScience of Fractal Images", p. 198.  While it can take full advantage of
Xyour color palette, one of the best uses is in preparing monochrome images
Xfor a printer.    Using the 1600x1200x2 disk-video mode and an HP LaserJet,
Xwe have produced pictures of quality equivalent to the black and white
Xillustrations of the M-set in "The Beauty of Fractals."
X
XThe distance estimator method widens very thin "strands" which are part of
Xthe "inside" of the set.  Instead of hiding invisibly between pixels,
Xthese strands are made one pixel wide.
X
XThough this option is available with any escape time fractal type, the
Xformula used is specific to the mandel and julia types - for most other
Xtypes it doesn't do a great job.
X
XTo turn on the distance estimator method with any escape time  fractal
Xtype, set the "Distance Estimator" value on the <Y> options screen (or use
Xthe "distest=" command line parameter).
X
XSetting the distance estimator option to a negative value -nnn enables
Xedge-tracing mode.  The edge of the set is display as color number nnn.
XThis option works best when the "inside" and "outside" color values are
Xalso set to some other value(s).
X
XIn a 2 color (monochrome) mode, setting to any positive value results in
Xthe inside of the set being expanded to include edge points, and the
Xoutside points being displayed in the other color.
X
XIn color modes, setting to value 1 causes the edge points to be displayed
Xusing the inside color and the outside points to be displayed in their
Xusual colors.  Setting to a value greater than one causes the outside
Xpoints to be displayed as contours, colored according to their distance
Xfrom the inside of the set.  Use a higher value for narrower color bands,
Xa lower value for wider ones.  1000 is a good value to start with.
X
XThe second distance estimator parameter ("width factor") sets the distance
Xfrom the inside of the set which is to be considered as part of the
Xinside.  This value is expressed as a percentage of a pixel width, the
Xdefault is 71.
X
XYou should use 1 or 2 pass mode with the distance estimator method, to
Xavoid missing some of the thin strands made visible by it.  For the
Xhighest quality, "maxiter" should also be set to a high value, say 1000 or
Xso.  You'll probably also want "inside" set to zero, to get a black
Xinterior.
X
XEnabling the distance estimator method automatically toggles to floating
Xpoint mode. When you reset distest back to zero, remember to also turn off
Xfloating point mode if you want it off.
X
XUnfortunately, images using the distance estimator method can take many
Xhours to calculate even on a fast machine with a coprocessor, especially
Xif a high "maxiter" value is used.  One way of dealing with this is to
Xleave it turned off while you find and frame an image.    Then hit <B> to
Xsave the current image information in a parameter file
X(see {Parameter Save/Restore Commands}).  Use an editor to change the parameter
Xfile entry, adding "distest=1", "video=something" to select a high-
Xresolution monochrome disk-video mode, "maxiter=1000", and "inside=0". Run
Xthe parameter file entry with the <@> command when you won't be needing
Xyour machine for a while (over the weekend?)
X;
X;
X;
X~Topic=Inversion
X
XMany years ago there was a brief craze for "anamorphic art": images
Xpainted and viewed with the use of a cylindrical mirror, so that  they
Xlooked weirdly distorted on the canvas but correct in the distorted
Xreflection. (This byway of art history may be a useful defense when your
Xfriends and family give you odd looks for staring at fractal images color-
Xcycling on a CRT.)
X
XThe Inversion option performs a related transformation on most of the
Xfractal types. You define the center point and radius of a circle;
XFractint maps each point inside the circle to a corresponding point
Xoutside, and vice-versa. This is known to mathematicians as inverting (or
Xif you want to get precise, "everting") the plane, and is something they
Xcan contemplate without getting a headache. John Milnor (also mentioned
Xin connection with the {Distance Estimator Method}), made his name in the
X1950s with a method for everting a seven-dimensional sphere, so we have a
Xlot of catching up to do.
X
XFor example, if a point inside the circle is 1/3 of the way from the
Xcenter to the radius, it is mapped to a point along the same radial line,
Xbut at a distance of (3 * radius) from the origin. An outside point at 4
Xtimes the radius is mapped inside at 1/4 the radius.
X
XThe inversion parameters on the <Y> options screen allow entry of the
Xradius and center coordinates of the inversion circle. A default choice of
X-1 sets the radius at 1/6 the smaller dimension of the image currently on
Xthe screen.  The default values for Xcenter and Ycenter use the
Xcoordinates currently mapped to the center of the screen.
X
XTry this one out with a {=HT_NEWT Newton} plot, so its radial "spokes"
Xwill give you
Xsomething to hang on to. Plot a Newton-method image, then set the
Xinversion radius to 1, with default center coordinates. The center
X"explodes" to the periphery.
X
XInverting through a circle not centered on the origin produces bizarre
Xeffects that we're not even going to try to describe. Aren't computers
Xwonderful?
X;
X;
X;
X~Topic=Decomposition
X
XYou'll remember that most fractal types are calculated by iterating a
Xsimple function of a complex number, producing another complex number,
Xuntil either the number exceeds some pre-defined "bailout" value, or the
Xiteration limit is reached. The pixel corresponding to the starting point
Xis then colored based on the result of that calculation.
X
XThe decomposition option ("decomp=", on the <X> screen) toggles to another
Xcoloring protocol.  Here the points are colored according to which
Xquadrant of the complex plane (negative real/positive imaginary, positive
Xreal/positive imaginary, etc.) the final value is in. If you use 4 as the
Xparameter, points ending up in each quadrant are given their own color; if
X2 (binary decomposition), points in alternating quadrants are given 2
Xalternating colors.
X
XThe result is a kind of warped checkerboard coloring, even in areas that
Xwould ordinarily be part of a single contour. Remember, for the M-set all
Xpoints whose final values exceed 2 (by any amount) after, say, 80
Xiterations are normally the same color; under decomposition, Fractint runs
X[bailout-value] iterations and then colors according to where the actual
Xfinal value falls on the complex plane.
X
XWhen using decomposition, a higher bailout value will give a more accurate
Xplot, at some expense in speed.  You might want to set the bailout value
X(in the parameters prompt following selection of a new fractal type;
Xpresent for most but not all types) to a higher value than the default.  A
Xvalue of about 50 is a good compromise for M/J sets.
X;
X;
X;
X~Topic=Logarithmic Palettes and Color Ranges
X
XBy default, Fractint maps iterations to colors 1:1. I.e. if the
Xcalculation for a fractal "escapes" (exceeds the bailout value) after N
Xiterations, the pixel is colored as color number N. If N is greater than
Xthe number of colors available, it wraps around. So, if you are using a
X16-color video mode, and you are using the default maximum iteration count
Xof 150, your image will run through the 16-color palette 150/16 = 9.375
Xtimes.
X
XWhen you use Logarithmic palettes, the entire range of iteration values is
Xcompressed to map to one span of the color range.  This results in
Xspectacularly different images if you are using a high iteration limit
Xnear the current iteration maximum of 32000 and are zooming in on an area
Xnear a "lakelet".
X
XWhen using a compressed palette in a 256 color mode, we suggest changing
Xyour colors from the usual defaults.  The last few colors in the default
XIBM VGA color map are black.  This results in points nearest the "lake"
Xsmearing into a single dark band, with little contrast from the blue (by
Xdefault) lake.
X
XFractint has a number of types of compressed palette, selected by the "Log
XPalette" line on the <X> screen, or by the "logmap=" command line
Xparameter:
X
X  logmap=1: for standard logarithmic palette.
X
X  logmap=-1: "old" logarithmic palette. This variant was the only one used
X  before Fractint 14.0. It differs from logmap=1 in that some colors are
X  not used - logmap=1 "spreads" low color numbers which are unused by
X  logmap=-1's pure logarithmic mapping so that all colors are assigned.
X
X  logmap=N (>1): Same as logmap=1, but starting from iteration count N.
X  Pixels with iteration counts less than N are mapped to color 1. This is
X  useful when zooming in an area near the lake where no points in the
X  image have low iteration counts - it makes use of the low colors which
X  would otherwise be unused.
X
X  logmap=-N (<-1): Similar to logmap=N, but uses a square root
X  distribution of the colors instead of a logarithmic one.
X
X  logmap=2 or -2: Auto calculates the logmap value for maximum effect.
X
XAnother way to change the 1:1 mapping of iteration counts to colors is to
Xuse the "RANGES=" parameter.  It has the format:\
X   RANGES=aa/bb/cc/dd/...
X
XIteration counts up to and including the first value are mapped to color
Xnumber 0, up to and including the second value to color number 1, and so
Xon. The values must be in ascending order.
X
XA negative value can be specified for "striping". The negative value
Xspecifies a stripe width, the value following it specifies the limit of
Xthe striped range.  Two alternating colors are used within the striped
Xrange.
X
XExample:\
X   RANGES=0/10/30/-5/65/79/32000\
XThis example maps iteration counts to colors as follows:
X
X~Format-
X    color    iterations
X    -------------------
X      0      unused (formula always iterates at least once)
X      1       1 to 10
X      2      11 to 30
X      3      31 to 35, 41 to 45, 51 to 55, and 61 to 65
X      4      36 to 40, 46 to 50, and 56 to 60
X      5      66 to 79
X      6      80 and greater
X~Format+
XNote that the maximum value in a RANGES parameter is 32767.
X;
X;
X;
X~Topic=Biomorphs, Label=@Biomorphs
X
XRelated to {Decomposition} are the "biomorphs" invented by Clifford
XPickover, and discussed by A. K. Dewdney in the July 1989 "Scientific
XAmerican", page 110.  These are so-named because this coloring scheme
Xmakes many fractals look like one-celled animals.  The idea is simple.
XThe escape-time algorithm terminates an iterating formula when the size of
Xthe orbit value exceeds a predetermined bailout value. Normally the pixel
Xcorresponding to that orbit is colored according to the iteration when
Xbailout happened. To create biomorphs, this is modified so that if EITHER
Xthe real OR the imaginary component is LESS than the bailout, then the
Xpixel is set to the "biomorph" color. The effect is a bit better with
Xhigher bailout values: the bailout is automatically set to 100 when this
Xoption is in effect. You can try other values with the "bailout=" option.
X
XThe biomorph option is turned on via the "biomorph=nnn" command-line
Xoption (where "nnn" is the color to use on the affected pixels).  When
Xtoggling to Julia sets, the default corners are three times bigger than
Xnormal to allow seeing the biomorph appendages. Does not work with all
Xtypes - in particular it fails with any of the mandelsine family. However,
Xif you are stuck with monochrome graphics, try it - works great in two-
Xcolor modes. Try it with the marksmandel and marksjulia types.
X;
X;
X;
X~Topic=Continuous Potential
X
XNote: This option can only be used with 256 color modes.
X
XFractint's images are usually calculated by the "level set" method,
Xproducing bands of color corresponding to regions where the calculation
Xgives the same value. When "3D" transformed (see {\"3D\" Images}),
Xmost images other than plasma
Xclouds are like terraced landscapes: most of the surface is either
Xhorizontal or vertical.
X
XTo get the best results with the "illuminated" 3D fill options 5 and 6,
Xthere is an alternative approach that yields continuous changes in colors.
X
XContinuous potential is approximated by calculating
X
X     potential =  log(modulus)/2^iterations
X
Xwhere "modulus" is the orbit value (magnitude of the complex number) when
Xthe modulus bailout was exceeded, at the "iterations" iteration.  Clear as
Xmud, right?
X
XFortunately, you don't have to understand all the details. However, there
XARE a few points to understand. First, Fractint's criterion for halting a
Xfractal calculation, the "modulus bailout value", is generally set to 4.
XContinuous potential is inaccurate at such a low value.
X
XThe bad news is that the integer math which makes the "mandel" and "julia"
Xtypes so fast imposes a hard-wired maximum value of 127. You can still
Xmake interesting images from those types, though, so don't avoid them. You
Xwill see "ridges" in the "hillsides." Some folks like the effect.
X
XThe good news is that the other fractal types, particularly the (generally
Xslower) floating point algorithms, have no such limitation.  The even
Xbetter news is that there is a floating-point algorithm for the "mandel"
Xand "julia" types.  To force the use of a floating-point algorithm, use
XFractint with the "FLOAT=YES" command-line toggle.  Only a few fractal
Xtypes like plasma clouds, the Barnsley IFS type, and "test" are unaffected
Xby this toggle.
X
XThe parameters for continuous potential are:\
X    potential=maxcolor[/slope[/modulus[/16bit]]]\
XThese parameters are present on the <Y> options screen.
X
X"Maxcolor" is the color corresponding to zero potential, which plots as
Xthe TOP of the mountain. Generally this should be set to one less than the
Xnumber of colors, i.e. usually 255. Remember that the last few colors of
Xthe default IBM VGA palette are BLACK, so you won't see what you are
Xreally getting unless you change to a different palette.
X
X"Slope" affects how rapidly the colors change -- the slope of the
X"mountains" created in 3D. If this is too low, the palette will not cover
Xall the potential values and large areas will be black. If it is too high,
Xthe range of colors in the picture will be much less than those available.
XThere is no easy way to predict in advance what this value should be.
X
X"Modulus" is the bailout value used to determine when an orbit has
X"escaped". Larger values give more accurate and smoother potential. A
Xvalue of 500 gives excellent results. As noted, this value must be <128
Xfor the integer fractal types (if you select a higher number, they will
Xuse 127).
X
X"16bit":  If you transform a continuous potential image to 3D, the
Xillumination modes 5 and 6 will work fine, but the colors will look a bit
Xgranular. This is because even with 256 colors, the continuous potential
Xis being truncated to integers. The "16bit" option can be used to add an
Xextra 8 bits of goodness to each stored pixel, for a much smoother result
Xwhen transforming to 3D.
X
XFractint's visible behavior is unchanged when 16bit is enabled, except
Xthat solid guessing and boundary tracing are not used. But when you save
Xan image generated with 16bit continuous potential:\
X o The saved file is a fair bit larger.\
X o Fractint names the file with a .POT extension instead of .GIF, if you
X   didn't specify an extension in "savename".
X o The image can be used as input to a subsequent <3> command to get the
X   promised smoother effect.
X o If you happen to view the saved image with a GIF viewer other than
X   Fractint, you'll find that it is twice as wide as it is supposed to
X   be. (Guess where the extra goodness was stored!) Though these files
X   are structurally legal GIF files the double-width business made us
X   think they should perhaps not be called GIF - hence the .POT filename
X   extension.
X
XA 16bit (.POT) file can be converted to an ordinary 8 bit GIF by
X<R>estoring it, changing "16bit" to "no" on the <Y> options screen, and
X<S>aving.
X
XYou might find with 16bit continuous potential that there's a long delay
Xat the start of an image, and disk activity during calculation. Fractint
Xuses its disk-video cache area to store the extra 8 bits per pixel - if
Xthere isn't sufficient memory available, the cache will page to disk.
X
XThe following commands can be used to recreate the image that Mark
XPeterson first prototyped for us, and named "MtMand":
X
X    TYPE=mandel\
X    CORNERS=-0.19920/-0.11/1.0/1.06707\
X    INSIDE=255\
X    MAXITER=255\
X    POTENTIAL=255/2000/1000/16bit\
X    PASSES=1\
X    FLOAT=yes\
X
XNote that prior to version 15.0, Fractint:\
X o Produced "16 bit TGA potfiles" This format is no longer generated, but
X   you can still (for a release or two) use <R> and <3> with those files.
X o Assumed "inside=maxit" for continuous potential. It now uses the
X   current "inside=" value - to recreate prior results you must be
X   explicit about this parameter.
X;
X;
X;
X~Topic=Starfields, Label=HELPSTARFLD
X
XOnce you have generated your favorite fractal image, you can convert it
Xinto a fractal starfield with the 'a' transformation (for 'astronomy'? -
Xonce again, all of the good letters were gone already).  Stars are
Xgenerated on a pixel-by-pixel basis - the odds that a particular pixel
Xwill coalesce into a star are based (partially) on the color index of that
Xpixel.
X
X(The following was supplied by Mark Peterson, the starfield author).
X
XIf the screen were entirely black and the 'Star Density per Pixel' were
Xset to 30 then a starfield transformation would create an evenly
Xdistributed starfield with an average of one star for every 30 pixels.
X
XIf you're on a 320x200 screen then you have 64000 pixels and would end up
Xwith about 2100 stars.    By introducing the variable of 'Clumpiness' we can
Xcreate more stars in areas that have higher color values.  At 100%
XClumpiness a color value of 255 will change the average of finding a star
Xat that location to 50:50.  A lower clumpiness values will lower the
Xamount of probability weighting.  To create a spiral galaxy draw your
Xfavorite spiral fractal (IFS, Julia, or Mandelbrot) and perform a
Xstarfield transformation.  For general starfields I'd recommend
Xtransforming a plasma fractal.
X
XReal starfields have many more dim stars than bright ones because very few
Xstars are close enough to appear bright.  To achieve this effect the
Xprogram will create a bell curve based on the value of ratio of Dim stars
Xto bright stars.  After calculating the bell curve the curve is folded in
Xhalf and the peak used to represent the number of dim stars.
X
XStarfields can only be shown in 256 colors.  Fractint will automatically
Xtry to load ALTERN.MAP and abort if the map file cannot be found.
X;
X;
X;
X~Topic=Palette Maps, Label=HELPCOLORMAP
X
XIf you have a VGA, MCGA, Super-VGA, 8514/A, XGA, TARGA, or TARGA+ video
Xadapter, you can save and restore color palettes for use
Xwith any image.  To load a palette onto an existing image, use
Xthe <L> command in color-cycling or palette-editing mode.  To save a
Xpalette, use the <S> command in those modes.  To change the default
Xpalette for an entire run, use the command line "map=" parameter.
X
XThe default filetype for color-map files is ".MAP".
X
XThese color-maps are ASCII text
Xfiles set up as a series of RGB triplet values (one triplet per
Xline, encoded as the red, green, and blue [RGB] components of the color).
X
XNote that .MAP file color values are in GIF format - values go from 0 (low) to
X255 (high), so for a VGA adapter they get divided by 4 before being
Xstuffed into the VGA's Video-DAC registers (so '6' and '7' end up
Xreferring to the same color value).
X~OnlineFF
X
X~Format-
XFractint is distributed with some sample .MAP files:
X   ALTERN.MAP     the famous "Peterson-Vigneau Pseudo-Grey Scale"
X   BLUES.MAP     for rainy days, by Daniel Egnor
X   CHROMA.MAP     general purpose, chromatic
X   DEFAULT.MAP     the VGA start-up values
X   FIRESTRM.MAP  general purpose, muted fire colors
X   GAMMA1.MAP and GAMMA2.MAP  Lee Crocker's response to ALTERN.MAP
X   GLASSES1.MAP  used with 3d glasses modes
X   GLASSES2.MAP  used with 3d glasses modes
X   GOODEGA.MAP     for EGA users
X   GREEN.MAP     shaded green
X   GREY.MAP     another grey variant
X   GRID.MAP     for stereo surface grid images
X   HEADACHE.MAP  major stripes, by D. Egnor (try cycling and hitting <2>)
X   LANDSCAP.MAP  Guruka Singh Khalsa's favorite map for plasma "landscapes"
X   NEON.MAP     a flashy map, by Daniel Egnor
X   PAINTJET.MAP  high resolution mode PaintJet colors
X   ROYAL.MAP     the royal purple, by Daniel Egnor
X   TOPO.MAP     Monte Davis's contribution to full color terrain
X   VOLCANO.MAP     an explosion of lava, by Daniel Egnor
X~Format+
X;
X;
X;
X~Topic=\"3D\" Images, Label=HELP3D
X; Empty in docs, just to have the hotlink defined at chapter level.
X~Format-,Doc-
X
X   { 3D Overview }
X   { 3D Mode Selection }
X   { Select Fill Type Screen }
X   { Stereo 3D Viewing }
X   { Rectangular Coordinate Transformation }
X   { 3D Color Parameters }
X   { Light Source Parameters }
X   { Spherical Projection }
X   { 3D Overlay Mode }
X   { Special Note for CGA or Hercules Users }
X   { Making Terrains }
X   { Making 3D Slides }
X   { Interfacing with Ray Tracing Programs }
X~Format+,Doc+
X;
X;
X;
X~Topic=3D Overview
X
XFractint can restore images in "3D". Important: we use quotation marks
Xbecause it does not CREATE images of 3D fractal objects (there are such,
Xbut we're not there yet.) Instead, it restores .GIF images as a 3D
XPROJECTION or STEREO IMAGE PAIR.  The iteration values you've come to know
Xand love, the ones that determine pixel colors, are translated into
X"height" so that your saved screen becomes a landscape viewed in
Xperspective. You can even wrap the landscape onto a sphere for realistic-
Xlooking planets and moons that never existed outside your PC!
X
XWe suggest starting with a saved plasma-cloud screen. Hit <3> in main
Xcommand mode to begin the process. Next, select the file to be
Xtransformed, and the video mode. (Usually you want the same video mode the
Xfile was generated in; other choices may or may not work.)
X
XAfter hitting <3>, you'll be bombarded with a long series of options.
XNot to worry: all
Xof them have defaults chosen to yield an acceptable starting image, so the
Xfirst time out just pump your way through with the <Enter> key. When you
Xenter a different value for any option, that becomes the default value the
Xnext time you hit <3>, so you can change one option at a time until you
Xget what you want. Generally <ESC> will take you back to the previous
Xscreen.
X
XOnce you're familiar with the effects of the 3D option values you have a
Xvariety of options on how to specify them. You can specify them all on the
Xcommand line (there ARE a lot of them so they may not all fit within the
XDOS command line limits), with an SSTOOLS.INI file, or with a parameter
Xfile.
X
XHere's an example for you power FRACTINTers, the command
X
X      FRACTINT MYFILE SAVENAME=MY3D 3D=YES BATCH=YES
X
Xwould make Fractint load MYFILE.GIF, re-plot it as a 3D landscape (taking
Xall of the defaults), save the result as MY3D.GIF, and exit to DOS. By the
Xtime you've come back with that cup of coffee, you'll have a new world to
Xview, if not conquer.
X
XNote that the image created by 3D transformation is treated as if it were
Xa plasma cloud - We have NO idea how to retain the ability to zoom and pan
Xaround a 3D image that has been twisted, stretched, perspective-ized, and
Xwater-leveled. Actually, we do, but it involves the kind of hardware that
XIndustrial Light & Magic, Pixar et al. use for feature films. So if you'd
Xlike to send us a check equivalent to George Lucas' net from the "Star
XWars" series...
X;
X;
X;
X~Topic=3D Mode Selection, Label=HELP3DMODE
X
XAfter hitting <3> and getting past the filename prompt and video mode
Xselection, you're presented with a "3d Mode Selection" screen.  If you
Xwish to change the default for any of the following parameters,
Xuse the cursor keys to move through the menu. When you're
Xsatisfied press <Enter>.
X
XPreview Mode:
X   Preview mode provides a rapid look at your transformed image using by
X   skipping a lot of rows and filling the image in. Good for quickly
X   discovering the best parameters. Let's face it, the Fractint authors
X   most famous for "blazingly fast" code *DIDN'T* write the 3D routines!
X   [Pieter: "But they *are* picking away it and making some progress in
X   each release."]
X
XShow Box:
X   If you have selected Preview Mode you have another option to worry
X   about. This is the option to show the image box in scaled and rotated
X   coordinates x, y, and z. The box only appears in rectangular
X   transformations and shows how the final image will be oriented. If you
X   select light source in the next screen, it will also show you the
X   light source vector so you can tell where the light is coming from in
X   relation to your image. Sorry no head or tail on the vector yet.
X
X~OnlineFF
XCoarseness:
X   This sets how many divisions the image will be divided into in the y
X   direction, if you select preview mode, ray tracing output, or grid fill
X   in the "Select Fill Type" screen.
X
XSpherical Projection:
X   The next question asks if you want a sphere projection. This will take
X   your image and map it onto a plane if you answer "no" or a sphere if
X   you answer "yes" as described above. Try it and you'll see what we
X   mean.  See {Spherical Projection}.
X
XStereo:
X
X   Stereo sound in Fractint? Well, not yet. Fractint now allows you to
X   create 3D images for use with red/blue glasses like 3D comics you may
X   have seen, or images like Captain EO.
X
X   Option 0 is normal old 3D you can look at with just your eyes.
X
X   Options 1 and 2 require the special red/blue-green glasses.    They are
X   meant to be viewed right on the screen or on a color print off of the
X   screen. The image can be made to hover entirely or partially in front
X   of the screen. Great fun!  These two options give a gray scale image
X   when viewed.
X
X   Option 1 gives 64 shades of gray but with half the spatial resolution
X   you have selected. It works by writing the red and blue images on
X   adjacent pixels, which is why it eats half your resolution. In
X   general, we recommend you use this only with resolutions above
X   640x350. Use this mode for continuous potential landscapes where you
X   *NEED* all those shades.
X
X   Option "2" gives you full spatial resolution but with only 16 shades
X   of gray. If the red and blue images overlap, the colors are mixed.
X   Good for wire-frame images (we call them surface grids), lorenz3d and
X   3D IFS. Works fine in 16 color modes.
X
X   Option 3 is for creating stereo pair images for view later with more
X   specialized equipment. It allows full color images to be presented in
X   glorious stereo. The left image presented on the screen first. You may
X   photograph it or save it. Then the second image is presented, you may
X   do the same as the first image. You can then take the two images and
X   convert them to a stereo image pair as outlined by Bruce Goren (see
X   below).
X
X   Also see {Stereo 3D Viewing}.
X
X~OnlineFF
XRay Tracing Output:
X
X   Fractint can create files of its 3d transformations which are
X   compatible with many ray tracing programs. Currently four are supported
X   directly: DKB (now obsolete), VIVID, MTV, and RAYSHADE. In addition a "RAW"
X   output is supported which can be relatively easily transformed to be
X   usable by many other products.
X   One other option is supported: ACROSPIN.  This is not a ray tracer,
X   but the same Fractint options apply - see {=@ACROSPIN Acrospin}.
X
X   Option values:\
X      0  disables the creation of ray tracing output\
X      1  DKB format (obsolete-see below)\
X      2  VIVID format\
X      3  generic format (must be massaged externally)\
X      4  MTV format\
X      5  RAYSHADE format\
X      6  ACROSPIN format\
X   Users of POV-Ray can use the DKB output and convert to POV-Ray with the
X   DKB2POV utility that comes with POV-Ray. A better (faster) approach is to
X   create a RAW output file and convert to POV-Ray with RAW2POV.  A still
X   better approach is to use POV-Ray's height field feature to directly
X   read the fractal .GIF or .POT file and do the 3D transformation inside
X   POV-Ray.
X
X   All ray tracing files consist of triangles which follow the surface
X   created by Fractint during the 3d transform. Triangles which lie below
X   the "water line" are not created in order to avoid causing unnecessary
X   work for the poor ray tracers which are already overworked.
X   A simple plane can be substituted by the user at the
X   waterline if needed.
X
X   The size (and therefore the number) of triangles created is determined
X   by the "coarse" parameter setting. While generating the ray tracing
X   file, you will view the image from above and watch it partitioned into
X   triangles.
X
X   The color of each triangle is the average of the color of its verticies
X   in the original image, unless BRIEF is selected.
X
X   If BRIEF is selected, a default color is assigned at the begining of the
X   file and is used for all triangles.
X
X   Also see {Interfacing with Ray Tracing Programs}.
X
XBrief output:
X
X   This is a ray tracing sub-option.
X   When it is set to yes, Fractint creates a considerably
X   smaller and somewhat faster file. In this mode, all triangles
X   use the default color specified at the begining of the file.
X   This color should be edited to supply the color of your choice.
X
XTarga Output:
X
X   If you want any of the 3d transforms you select to be saved as a
X   Targa-24 file or overlayed onto one, select yes for this option.
X   The overlay option in the final screen determines whether you will
X   create a new file or overlay an existing one.
X
XMAP File name:
X
X   Imediately after selecting the previous options, you will be given the
X   chance to select an alternate color MAP file. The default is to
X   use the current MAP. If you want another MAP used, then enter your
X   selection at this point.
X
XOutput File Name:
X
X   This is a ray tracing sub-option, used to specify the name of the
X   file to be written.    The default name is FRACT001.RAY.  The name is
X   incremented by one each time a file is written.
X   If you have not set "overwrite=yes" then
X   the file name will also be automatically incremented to avoid
X   over-writing previous files.
X
X~Online-
XWhen you are satisfied with your selections press enter to go
Xto the next parameter screen.
X~Online+
X;
X;
X;
X~Topic=Select Fill Type Screen, Label=HELP3DFILL
X
XThis option exists because in the course of the 3D projection, portions
Xof the original image may be stretched to fit the new surface. Points of
Xan image that formerly were right next to each other, now may have a space
Xbetween them. This option generally determines what to do with the space
Xbetween the mapped dots. It is not used if you have selected a value for
XRAY other than 0.
X
XFor an illustration, pick the second option "just draw the points", which
Xjust maps points to corresponding points. Generally this will leave empty
Xspace between many of the points. Therefore you can choose various
Xalgorithms that "fill in" the space between the points in various ways.
X
XLater, try the first option "make a surface grid." This option will make a
Xgrid of the surface which is as many divisions in the original "y"
Xdirection as was set in "coarse" in the first screen. It is very fast, and
Xcan give you a good idea what the final relationship of parts of your
Xpicture will look like.
X
XLater, try the second option "connect the dots (wire frame)", then "surface
Xfills" - "colors interpolated" and "colors not interpolated", the general
Xfavorites of the authors. Solid fill, while it reveals the pseudo-geology
Xunder your pseudo-landscape, inevitably takes longer.
X
XLater, try the light source fill types. These two algorithms allow you to
Xposition the "sun" over your "landscape." Each pixel is colored according
Xto the angle the surface makes with an imaginary light source. You will be
Xasked to enter the three coordinates of the vector pointing toward the
Xlight in a following parameter screen - see {Light Source Parameters}.
X
X"Light source before transformation" uses the illumination direction without
Xtransforming it. The light source is fixed relative to your computer screen.
XIf you generate a sequence of images with progressive rotation, the effect is
Xas if you and the light source are fixed and the object is rotating. Therefore
Xas the object rotates features of the object move in and out of the light.
XThis fill option was incorrect prior to version 16.1, and has been changed.
X
X"Light source after transformation" applies the same transformation to both
Xthe light direction and the object. Since both the light direction and the
Xobject are transformed, if you generate a sequence of images with the rotation
Xprogressively changed, the effect is as if the image and the light source
Xare fixed in relation to each other and you orbit around the image. The
Xillumination of features on the object is constant, but you see the object
Xfrom different angles. This fill option was correct in earlier Fractint
Xversions and has not been changed.
X
XFor ease of discussion we will refer to the following fill types by these
Xnumbers:
X    1 - surface grid\
X    2 - (default) - no fill at all - just draw the dots\
X    3 - wire frame - joins points with lines\
X    4 - surface fill - (colors interpolated)\
X    5 - surface fill - (interpolation turned off)\
X    6 - solid fill - draws lines from the "ground" up to the point\
X    7 - surface fill with light model - calculated before 3D transforms\
X    8 - surface fill with light model - calculated after 3D transforms\
X
XTypes 4, 7, and 8 interpolate colors when filling, making a very smooth
Xfill if the palette is continuous. This may not be desirable if the
Xpalette is not continuous. Type 5 is the same as type 4 with interpolation
Xturned off. You might want to use fill type 5, for example, to project
Xa .GIF photograph onto a sphere. With type 4, you might see the filled-in
Xpoints, since chances are the palette is not continuous; type 5 fills
Xthose same points in with the colors of adjacent pixels. However, for most
Xfractal images, fill type 4 works better.
X
XThis screen is not available if you have selected a ray tracing option.
X;
X;
X;
X~Topic=Stereo 3D Viewing, Label=HELP3DGLASSES
X
XThe "Funny Glasses" (stereo 3D) parameter screen is presented only if
Xyou select a non-zero stereo option in the prior 3D parameters.
X(See {3D Mode Selection}.)
XWe suggest you definitely use defaults at first on this screen.
X
XWhen you look at an image with both eyes, each eye sees the image in
Xslightly different perspective because they see it from different places.
X
XThe first selection you must make is ocular separation, the distance the
Xbetween the viewers eyes. This is measured as a % of screen and is an
Ximportant factor in setting the position of the final stereo image in
Xfront of or behind the CRT Screen.
X
XThe second selection is convergence, also as a % of screen. This tends to
Xmove the image forward and back to set where it floats. More positive
Xvalues move the image towards the viewer. The value of this parameter
Xneeds to be set in conjunction with the setting of ocular separation and
Xthe perspective distance. It directly adjusts the overall separation of
Xthe two stereo images. Beginning anaglyphers love to create images
Xfloating mystically in front of the screen, but grizzled old 3D veterans
Xlook upon such antics with disdain, and believe the image should be safely
Xinside the monitor where it belongs!
X
XLeft and Right Red and Blue image crop (% of screen also) help keep the
Xvisible part of the right image the same as the visible part of the left
Xby cropping them. If there is too much in the field of either eye that the
Xother doesn't see, the stereo effect can be ruined.
X
XRed and Blue brightness factor. The generally available red/blue-green
Xglasses, made for viewing on ink on paper and not the light from a CRT,
Xlet in more red light in the blue-green lens than we would like. This
Xleaves a ghost of the red image on the blue-green image (definitely not
Xdesired in stereo images). We have countered this by adjusting the
Xintensity of the red and blue values on the CRT. In general you should not
Xhave to adjust this.
X
XThe final entry is Map file name (present only if stereo=1 or stereo=2
Xwas selected).
XIf you have a special map file you want
Xto use for Stereo 3D this is the place to enter its name. Generally
Xglasses1.map is for type 1 (alternating pixels), and glasses2.map is for
Xtype 2 (superimposed pixels). Grid.map is great for wire-frame images
Xusing 16 color modes.
X
XThis screen is not available if you have selected a ray tracing option.
X;
X;
X;
X~Topic=3D Fractal Parameters, Label=HELP3DFRACT
X; This topic is online only.
X
XThe parameters on this screen are a subset of the zillions of options
Xavailable for Fractint's 3D image transformations.
XThis screen's parameters are those which also affect 3D fractal types like
Xlorenz3d and kamtorus3d.
XSince they are documented elsewhere, we won't repeat ourselves:
X
XFor a description of rotation, perspective, and shift parameters, please
Xsee {Rectangular Coordinate Transformation}.  Ignore the paragraphs about
X"scaling" and "water level" - those parts apply only to 3D Transforms.
X
XFor a description of the stereo option, please see the "stereo" subheading
Xin {3D Mode Selection}.
X;
X;
X;
X~Topic=Rectangular Coordinate Transformation, Label=HELP3DPARMS
X
XThe first entries are rotation values around the X, Y, and Z axes. Think
Xof your starting image as a flat map: the X value tilts the bottom of your
Xmonitor towards you by X degrees, the Y value pulls the left side of the
Xmonitor towards you, and the Z value spins it counter-clockwise. Note that
Xthese are NOT independent rotations: the image is rotated first along the
XX-axis, then along the Y-axis, and finally along the Z-axis. Those are
XYOUR axes, not those of your (by now hopelessly skewed) monitor. All
Xrotations actually occur through the center of the original image. Rotation
Xparameters are not used when a ray tracing option has been selected.
X
XThen there are three scaling factors in percent. Initially, leave the X
Xand Y axes alone and play with Z, now the vertical axis, which translates
Xinto surface "roughness."  High values of Z make spiky, on-beyond-Alpine
Xmountains and improbably deep valleys; low values make gentle, rolling
Xterrain. Negative roughness is legal: if you're doing an M-set image and
Xwant Mandelbrot Lake to be below the ground, instead of eerily floating
Xabove, try a roughness of about -30%.
X
XNext we need a water level -- really a minimum-color value that performs
Xthe function "if (color < waterlevel) color = waterlevel". So it plots all
Xcolors "below" the one you choose at the level of that color, with the
Xeffect of filling in "valleys" and converting them to "lakes."
X
XNow we enter a perspective distance, which you can think of as the
X"distance" from your eye to the image. A zero value (the default) means no
Xperspective calculations, which allows use of a faster algorithm.
XPerspective distance is not available if you have selected a ray tracing
Xoption.
X
XFor non-zero values, picture a box with the original X-Y plane of your
Xflat fractal on the bottom, and your 3D fractal inside. A perspective
Xvalue of 100% places your eye right at the edge of the box and yields
Xfairly severe distortion, like a close view through a wide-angle lens.
X200% puts your eye as far from the front of the box as the back is behind.
X300% puts your eye twice as far from the front of the box as the back is,
Xetc. Try about 150% for reasonable results. Much larger values put you far
Xaway for even less distortion, while values smaller than 100% put you
X"inside" the box. Try larger values first, and work your way in.
X
XNext, you are prompted for two types of X and Y shifts (now back in the
Xplane of your screen) that let you move the final image around if you'd
Xlike to re-center it. The first set, x and y shift with perspective, move
Xthe image and the effect changes the perspective you see. The second set,
X"x and y adjust without perspective", move the image but do not change
Xperspective.  They are used just for positioning the final image on the
Xscreen. Shifting of any type is not available if you have selected a ray
Xtracing option.
X~Doc-
X
X{3D Color Parameters} are also requested on the same input screen.\
X
XIf you are doing a {Spherical Projection}, special parameters for
Xit are requested at the start of this screen.
X~Doc+
X;
X;
X;
X~Topic=3D Color Parameters
X
XYou are asked for a range of "transparent" colors, if any. This
Xoption is most useful when using the {3D Overlay Mode}.  Enter the
Xcolor range (minimum and maximum value) for which you do not want to
Xoverwrite whatever may already be on the screen. The default is no
Xtransparency (overwrite everything).
X
XNow, for the final option. This one will smooth the transition between
Xcolors by randomizing them and reduce the banding that occurs with some
Xmaps. Select the value of randomize to between 0 (for no effect) and 7 (to
Xrandomize your colors almost beyond use). 3 is a good starting point.
X
XThat's all for this screen. Press enter for these parameters and the
Xnext and final screen will appear (honestly!).
X;
X;
X;
X~Topic=Light Source Parameters, Label=HELP3DLIGHT
X
XThis one deals with all the aspects of light source and Targa files.
X
XYou must choose the direction of the light from the light source. This will
Xbe scaled in the x, y, and z directions the same as the image. For
Xexample, 1,1,3 positions the light to come from the lower right front of
Xthe screen in relation to the untransformed image. It is important to
Xremember that these coordinates are scaled the same as your image. Thus,
X"1,1,1" positions the light to come from a direction of equal distances to
Xthe right, below and in front of each pixel on the original image.
XHowever, if the x,y,z scale is set to 90,90,30 the result will be from
Xequal distances to the right and below each pixel but from only 1/3 the
Xdistance in front of the screen i.e.. it will be low in the sky, say,
Xafternoon or morning.
X
XThen you are asked for a smoothing factor. Unless you used
X{Continuous Potential} when generating the starting image, the
Xillumination when using light source fills may appear "sparkly", like a
Xsandy beach in bright sun. A smoothing factor of 2 or 3 will allow you to
Xsee the large-scale shapes better.
X
XSmoothing is primarily useful when doing light source fill types with plasma
Xclouds. If your fractal is not a plasma cloud and has features with
Xsharply defined boundaries (e.g. Mandelbrot Lake), smoothing may cause
Xthe colors to run. This is a feature, not a bug. (A copyrighted response
Xof [your favorite commercial software company here], used by permission.)
X
XThe ambient option sets the minimum light value a surface has if it has no
Xdirect lighting at all. All light values are scaled from this value to
Xwhite. This effectively adjusts the depth of the shadows and sets the
Xoverall contrast of the image.
X
XIf you selected the full color option, you have a few more choices.
XThe next is the haze factor. Set this to make distant objects more hazy.
XClose up objects will have little effect, distant objects will have most.
X0 disables the function. 100 is the maximum effect, the farthest objects
Xwill be lost in the mist. Currently, this does not really use distance
Xfrom the viewer, we cheat and use the y value of the original image. So
Xthe effect really only works if the y-rotation (set earlier) is between
X+/- 30.
X
XNext, you can chose the name under which to save your Targa file. If you
Xhave a RAM disk handy, you might want to create the file on it, for speed.
XSo include its  full path name in this option. If you have not set
X"overwrite=yes" then the file name will be incremented to avoid over-writing
Xprevious files. If you are going to overlay an existing Targa file, enter
Xits name here.
X
XNext, you may select the background color for the Targa file. The default
Xbackground on the Targa file is sky blue. Enter the Red, Green, and Blue
Xcomponent for the background color you wish.
X
XFinally, absolutely the last option (this time we mean it): you can now
Xchoose to overlay an existing Targa-24, type 2, non mapped, top-to-bottom
Xfile, such as created by Fractint or PVRay. The Targa file specified above
Xwill be overlayed with new info just as a GIF is overlayed on screen. Note:
Xit is not necessary to use the "O" overlay command to overlay Targa files.
XThe Targa_Overlay option must be set to yes, however.
X
X
XYou'll probably want to adjust the final colors for monochrome fill types
Xusing light source via {=@ColorCycling color cycling}.
XTry one of the more continuous
Xpalettes (<F8> through <F10>), or load the GRAY palette with the
X<A>lternate-map command.
X
X~Online-
XNow, lie down for a while in a quiet room with a damp washcloth on your
Xforehead. Feeling better? Good -- because it's time to go back almost to
Xthe top of the 3D options and just say yes to:
X~Online+
X;
X;
X;
X~Topic=Spherical Projection
X
XPicture a globe lying on its side, "north" pole to the right. (It's our
Xplanet, and we'll position it the way we like.) You will be mapping the X
Xand Y axes of the starting image to latitude and longitude on the globe,
Xso that what was a horizontal row of pixels follows a line of longitude.
XThe defaults exactly cover the hemisphere facing you, from longitude 180
Xdegrees (top) to 0 degrees (bottom) and latitude -90 (left) to latitude 90
X(right). By changing them you can map the image to a piece of the
Xhemisphere or wrap it clear around the globe.
X
XThe next entry is for a radius factor that controls the over-all size of
Xthe globe. All the rest of the entries are the same as in the landscape
Xprojection. You may want less surface roughness for a plausible look,
Xunless you prefer small worlds with big topography, a la "The Little
XPrince."
X
XWARNING: When the "construction" process begins at the edge of the globe
X(default) or behind it, it's plotting points that will be hidden by
Xsubsequent points as the process sweeps around the sphere toward you. Our
Xnifty hidden-point algorithms "know" this, and the first few dozen lines
Xmay be invisible unless a high mountain happens to poke over the horizon.
XIf you start a spherical projection and the screen stays black, wait for a
Xwhile (a longer while for higher resolution or fill type 6) to see if
Xpoints start to appear. Would we lie to you? If you're still waiting hours
Xlater, first check that the power's still on, then consider a faster
Xsystem.
X;
X;
X;
X~Topic=3D Overlay Mode, Label=HELP3DOVLY
X
XWhile the <3> command (see {\"3D\" Images})
Xcreates its image on a blank screen, the <#> (or <shift-3> on some
Xkeyboards) command
Xdraws a second image over an existing displayed image. This image can be
Xany restored image from a <R> command or the result of a just executed <3>
Xcommand. So you can do a landscape, then press <#> and choose spherical
Xprojection to re-plot that image or another as a moon in the sky above the
Xlandscape. <#> can be repeated as many times as you like.
X
XIt's worth noting that not all that many years ago, one of us watched
XBenoit Mandelbrot and fractal-graphics wizard Dick Voss creating just such
Xa moon-over-landscape image at IBM's research center in Yorktown Heights,
XNY. The system was a large and impressive mainframe with floating-point
Xfacilities bigger than the average minicomputer, running LBLGRAPH -- what
XMandelbrot calls "an independent-minded and often very ill-mannered heap
Xof graphics programs that originated in work by Alex Hurwitz and Jack
XWright of IBM Los Angeles."
X
XWe'd like to salute LBLGRAPH, its successors, and their creators, because
Xit was their graphic output (like "Planetrise over Labelgraph Hill," plate
XC9 in Mandelbrot's "Fractal Geometry of Nature") that helped turn fractal
Xgeometry from a mathematical curiosity into a phenomenon. We'd also like
Xto point out that it wasn't as fast, flexible or pretty as Fractint on a
X386/16 PC with S-VGA graphics. Now, a lot of the difference has to do with
Xthe incredible progress of micro-processor power since then, so a lot of
Xthe credit should go to Intel rather than to our highly tuned code. OK,
Xtwist our arms -- it IS awfully good code.
X;
X;
X;
X~Topic=Special Note for CGA or Hercules Users
X
XIf you are one of those unfortunates with a CGA or Hercules 2-color
Xmonochrome graphics, it is now possible for you to make 3D projection
Ximages.
X
XTry the following unfortunately circuitous approach. Invoke Fractint,
Xmaking sure you have set askvideo=yes. Use a disk-video mode to create a
X256 color fractal. You might want to edit the fractint.cfg file to make a
Xdisk-video mode with the same pixel dimensions as your normal video. Using
Xthe "3" command, enter the file name of the saved 256 color file, then
Xselect your 2 or 4
Xcolor mode, and answer the other 3D prompts. You will then see a 3D
Xprojection of the fractal. Another example of Stone Soup responsiveness to
Xour fan mail!
X;
X;
X;
X~Topic=Making Terrains
X
XIf you enjoy using Fractint for making landscapes, we have several new
Xfeatures for you to work with. When doing 3d transformations banding tends
Xto occur because all pixels of a given height end up the same color. Now,
Xcolors can be randomized to make the transitions between different colors
Xat different altitudes smoother. Use the new "RANDOMIZE= " variable to
Xaccomplish this. If your light source images all look like lunar
Xlandscapes since they are all monochrome and have very dark shadows, we
Xnow allow you to set the ambient light for adjusting the contrast of the
Xfinal image. Use the "Ambient= " variable. In addition to being able to
Xcreate scenes with light sources in monochrome, you can now do it in full
Xcolor as well. Setting fullcolor=1 will generate a Targa-24 file with a
Xfull color image which will be a combination of the original colors of the
Xsource image (or map file if you select map=something) and the amount of
Xlight which reflects off a given point on the surface. Since there can be
X256 different colors in the original image and 256 levels of light, you
Xcan now generate an image with *lots* of colors. To convert it to a GIF if
Xyou can't view Targa files directly, you can use PICLAB (see
X{Other Programs}), and the following commands:
X
X    SET PALETTE 256\
X    SET CREZ 8\
X    TLOAD yourfile.tga\
X    MAKEPAL\
X    MAP\
X    GSAVE yourfile.gif\
X    EXIT\
XUsing the full color option allows you to also set a haze factor with the
X"haze= " variable to make more distant objects more hazy.
X
XAs a default, full color files also have the background set to sky blue.
XWarning, the files which are created with the full color option are very
Xlarge, 3 bytes per pixel. So be sure to use a disk with enough space.
XThe file is created using Fractint's disk-video caching, but is always
Xcreated on real disk (expanded or extended memory is not used.) Try the
Xfollowing settings of the new variables in sequence to get a feel for the
Xeffect of each one:\
X    ;use this with any filltype\
X    map=topo\
X    randomize=3; adjusting this smooths color transitions\
X
X    ;now add this using filltype 5 or 6\
X    ambient=20; adjusting this changes the contrast\
X    filltype=6\
X    smoothing=2; makes the light not quite as granular as the terrain\
X
X    ;now add the following, and this is where it gets slow\
X    fullcolor=1; use PICLAB to reduce resulting lightfile to a GIF\
X
X    ;and finally this\
X    haze=20; sets the amount of haze for distant objects\
X
XWhen full color is being used, the image you see on the screen will
Xrepresent the amount of light being reflected, not the colors in the final
Ximage. Don't be disturbed if the colors look weird, they are an artifact
Xof the process being used. The image being created in the lightfile won't
Xlook like the screen.
X
XHowever, if you are worried, hit ESC several times and when Fractint gets
Xto the end of the current line it will abort. Your partial image will be
Xthere as LIGHT001.TGA or with whatever file name you selected with the
Xlightname option. Convert it as described above and adjust any parameters
Xyou are not happy with. Its a little awkward, but we haven't figured
Xout a better way yet.
X;
X;
X;
X~Topic=Making 3D Slides
X
XBruce Goren, CIS's resident stereoscopic maven, contributed these tips on
Xwhat to do with your 3D images (Bruce inspired and prodded us so much we
Xautomated much of what follows, allowing both this and actual on screen
Xstereo viewing, but we included it here for reference and a brief
Xtutorial.)
X
X"I use a Targa 32 video card and TOPAS graphic software, moving the
Xviewport or imaginary camera left and right to create two separate views
Xof the stationary object in x,y,z, space. The distance between the two
Xviews, known as the inter-ocular distance, toe-in or convergence angle, is
Xcritical. It makes the difference between good 3-D and headache-generating
Xbad 3-D.
X
X"For a 3D fractal landscape, I created and photographed the left and right
Xeye views as if flying by in an imaginary airplane and mounted the film
Xchips for stereo viewing. To make my image, first I generated a plasma
Xcloud based on a color map I calculated to resemble a geological survey
Xmap (available on CIS as TARGA.MAP). In the 3D reconstruction, I used a
Xperspective value of 150 and shifted the camera -15 and +15 on the X-axis
Xfor the left and right views. All other values were left to the defaults.
X
X"The images are captured on a Matrix 3000 film recorder -- basically a box
Xwith a high-resolution (1400 lines) black and white TV and a 35mm camera
X(Konica FS-1) looking at the TV screen through a filter wheel. The Matrix
X3000 can be calibrated for 8 different film types, but so far I have only
Xused Kodak Ektachrome 64 daylight for slides and a few print films. I
Xglass mount the film chips myself.
X
X"Each frame is exposed three times, once through each of the red, blue,
Xand green filters to create a color image from computer video without the
Xscan-lines which normally result from photographing television screens.
XThe aspect ratio of the resulting images led me to mount the chips using
Xthe 7-sprocket Busch-European Emde masks. The best source of Stereo
Xmounting and viewing supplies I know of is an outfit called Reel 3-D
XEnterprises, Inc. at P.O. Box 2368, Culver City, CA 90231, tel. 213-837-
X2368. "My platform is an IBM PC/AT crystal-swapped up to 9 MHz. The math
Xco-processor runs on a separate 8-MHz accessory sub-board.  The system
Xcurrently has 6.5 MB of RAM."
X;
X;
X;
X~Topic=Interfacing with Ray Tracing Programs
X
X(Also see "Ray Tracing Output", "Brief", and "Output File Name"
Xin {"3D Mode Selection"}.)
X
XFractint allows you to save your 3d transforms in files which may be
Xfed to a ray tracer (or to "Acrospin").
XHowever, they are not ready to be traced by
Xthemselves. For one thing, no light source is included. They are
Xactually meant to be included within other ray tracing files.
X
XSince the intent is to produce an object which may be included in a larger
Xray tracing scene, it is expected that all rotations, shifts, and final
Xscaling will be done by the ray tracer. Thus, in creating the images, no
Xfacilities for rotations or shifting is provided. Scaling is provided to
Xachieve the correct aspect ratio.
X
XWARNING! The files created using the RAY option can be huge. Setting
XCOARSE to 40 will result in over 2000 triangles. Each triangle can utilize
Xfrom 50 to 200 bytes each to describe, so your ray tracing files can
Xrapidly approach or exceed 1Meg. Make sure you have enough disk space before
Xyou start.
X
XEach file starts with a comment identifying the version of Fractint
Xby which it was created. The file ends with a comment giving the number
Xof triangles in the file.
X
XThe files consist of long strips of adjacent triangles. Triangles are
Xclockwise or counter clockwise depending on the target ray tracer.
XCurrently, MTV and Rayshade are the only ones which use counter clockwise
Xtriangles. The size of the triangles is set by the COARSE setting in the
Xmain 3d menu. Color information about each individual triangle is included
Xfor all files unless in the brief mode.
X
XTo keep the poor ray tracer from working too hard, if WATERLINE is set
Xto a non zero value, no triangle which lies entirely at or below the
Xcurrent setting of WATERLINE is written to the ray tracing file.  These
Xmay be replaced by a simple plane in the syntax of the ray tracer you are
Xusing.
X
XFractint's coordinate system has the origin of the x-y plane at the upper
Xleft hand corner of the screen, with positive x to the right and positive
Xy down. The ray tracing files have the origin of the x-y plane moved to
Xthe center of the screen with positive x to the right and positive y up.
XIncreasing values of the color index are out of the screen and in the +z
Xdirection. The color index 0 will be found in the xy plane at z=-1.
X
XWhen x- y- and zscale are set to 100, the surface created by the
Xtriangles will fall within a box of +/- 1.0 in all 3 directions. Changing
Xscale will change the size and/or aspect ratio of the enclosed object.
X
XWe will only describe the structure of the RAW format here. If you want
Xto understand any of the ray tracing file formats besides RAW, please
Xsee your favorite ray tracer docs.
X
XThe RAW format simply consists of a series of clockwise triangles. If
XBRIEF=yes, Each line is a vertex with coordinates x, y, and z. Each
Xtriangle is separated by a couple of CR's from the next. If BRIEF=no, the
Xfirst line in each triangle description if the r,g,b value of the triangle.
X
XSetting BRIEF=yes produces shorter files with the color of each triangle
Xremoved - all triangles will be the same color. These files are
Xotherwise identical to normal files but will run faster than the non BRIEF
Xfiles.    Also, with BRIEF=yes, you may be able to get files with more
Xtriangles to run than with BRIEF=no.
X
XThe DKB format is now obsolete. POV-Ray users should use the RAW output
Xand convert to POV-Ray using the POV Group's RAW2POV utility. POV-Ray
Xusers can also do all 3D transformations within POV-Ray using height fields.
X;
X;
X;
X
X
SHAR_EOF
$TOUCH -am 1028230193 help3.src &&
chmod 0644 help3.src ||
echo "restore of help3.src failed"
set `wc -c help3.src`;Wc_c=$1
if test "$Wc_c" != "64400"; then
    echo original size 64400, current size $Wc_c
fi
# ============= help4.src ==============
echo "x - extracting help4.src (Text)"
sed 's/^X//' << 'SHAR_EOF' > help4.src &&
X~Topic=Startup Parameters\, Parameter Files
X; This topic is online only.
X
X~Format-
X    { Summary of all Parameters }
X    { Introduction to Parameters }
X    { Using the DOS Command Line }
X    { Setting Defaults (SSTOOLS.INI File) }
X    { Parameter Files and the <@> Command }
X    { General Parameter Syntax }
X    { Startup Parameters }
X    { Calculation Mode Parameters }
X    { Fractal Type Parameters }
X    { Image Calculation Parameters }
X    { Color Parameters }
X    { Doodad Parameters }
X    { File Parameters }
X    { Sound Parameters }
X    { Video Parameters }
X    { Printer Parameters }
X    { 3D Parameters }
X;
X;
X~Topic=Summary of all Parameters, Label=HELPCOMMANDS
X; This topic is online only.
X~Format-
X
X{Startup Parameters}
X  @filename[/setname]       Process commands from a file
X  [filename=]filename       Start with this saved file (one saved by FRACTINT
X               or a generic GIF file [treated as a plasma cloud])
X               ('filename=' is required except on command line)
X  batch=yes           Batch mode run (display image, save-to-disk, exit)
X  autokey=play|record       Playback or record keystrokes
X  autokeyname=filename       File for autokey mode, default AUTO.KEY
X  fpu=387|iit|noiit       Assume 387 or IIT fpu is present or absent
X  makedoc=filename       Create Fractint documentation file
X
X{Calculation Mode Parameters}
X  passes=1|2|g|b|t       Select Single-Pass, Dual-Pass, Solid-Guessing,
X               Boundary-Tracing, or the Tesseral drawing
X               algorithms
X  fillcolor=normal|<nnn>   Sets a block fill color for use with Boundary
X                     Tracing and Tesseral options
X  float=yes           For most functions changes from integer math to fp
X  symmetry=xxxx        Force symmetry to None, Xaxis, Yaxis, XYaxis,
X               Origin, or Pi symmetry.  Useful for debugging.
X~FF
X
X{Fractal Type Parameters}
X  type=fractaltype       Perform this Fractal Type (Default = mandel)
X               See {Fractal Types} for a full list
X  params=xxx[/xxx[/...       Begin with these extra Parameter values
X               (Examples:  params=4   params=-0.480/0.626)
X  function=fn1/.../fn4       Allows specification of transcendental functions
X               with types using variable functions. Values are
X               sin, cos, tan, cotan, sinh, cosh, tanh, cotanh,
X               exp, log, sqr, recip (1/z), ident (identity),
X               conj, flip, zero, and cosxx (cos with bug)
X  formulaname=name       Formula name for 'type=formula' fractals
X  lname=name           Lsystem name for 'type=lsystem' fractals
X  ifs=name           IFS name for 'type=ifs' fractals
X  3dmode=monocular|left|right|red-blue  Sets the 3D mode used with Julibrot
X  julibrot3d=nn[/nn[/nn[/nn[/nn[/nn]]]]]")  Sets Julibrot 3D parameters zdots,
X                           origin, depth, height, width, and distance
X  julibroteyes=nn          Distance between the virtual eyes for Julibrot
X  julibrotfromto=nn/nn[/nn/nn] "From-to" parameters used for Julibrot
X  miim=[depth|breadth|walk]/[left|right]/[xxx/yyy[/zzz]] Params for MIIM
X                           julias.  xxx/yyy = julia constant, zzz = max hits.
X                           Eg. miim=depth/left/-.74543/.11301/3
X~FF
X{Image Calculation Parameters}
X  corners=xmin/xmax/ymin/ymax[/x3rd/y3rd]
X               Begin with these Coordinates
X               (Example: corners=-0.739/-0.736/0.288/0.291)
X  center-mag=[Xctr/Yctr/Mag] An alternative method of entering corners.
X               With no parameters causes <B> command to output
X               'center-mag=' instead of corners.
X  maxiter=nnn           Maximum number of iterations (default = 150)
X  bailout=nnnn           Use this as the iteration bailout value (instead
X               of the default (4.0 for most fractal types)
X  initorbit=nnn/nnn       Sets the value used to initialize Mandelbrot orbits
X               to the given complex number (real and imag parts)
X  orbitdelay=nn           Slows up the display of orbits (by nn/10000 sec)
X  initorbit=pixel       Sets the value used to initialize Mandelbrot orbits
X               to the complex number corresponding to the screen
X               pixel. This is the default for most types.
X  periodicity=[no|show|nnn] Controls periodicity checking. 'no' turns checking
X               off; entering a number nnn controls the tightness
X               of checking (default 1, higher is more stringent)
X               'show' or a neg value colors 'caught' points white.
X  rseed=nnnnn           Random number seed, for reproducable Plasma Clouds
X  showdot=nn           Colors the current dot being calculated color nn.
X~FF
X{Color Parameters}
X  inside=nnn|maxiter|zmag|bof60|bof61|epscr|star|per
X               Fractal interior color (inside=0 for black)
X  outside=nnn|iter|real|imag|mult|summ  Fractal exterior color options
X  map=filename           Use 'filename' as the default color map (vga/targa)
X  colors=@filename|colorspec Sets current image color map from file or spec,
X               vga or higher only
X  cyclerange=nnn/nnn       Range of colors to cycle (default 1/255)
X  cyclelimit=nnn       Color-cycler speed-limit (1 to 256, default = 55)
X  textcolors=aa/bb/cc/...  Set text screen colors
X  textcolors=mono       Set text screen colors to simple black and white
X  shortmap=yes           Uses the compact .map file format
X
X{Doodad Parameters}
X  logmap=yes|old|nn       Yes maps logarithm of iteration to color. Old uses
X               pre vsn 14 logic. >1 compresses, <-1 for quadratic.
X  ranges=nn/nn/nn/...       Ranges of iteration values to map to colors
X  distest=nnn/nnn       Distance Estimator Method
X  decomp=nn           'Decomposition' toggle, value 2 to 256.
X  biomorph=nnn           Biomorph Coloring
X  potential=nn[/nn[/nn[/16bit]]]  Continuous Potential
X  invert=nn/nn/nn       Turns on inversion - turns images 'inside out'
X~FF
X  finattract=yes       Look for finite attractor in julia types
X  exitnoask=yes           bypasses the final "are you sure?" exit screen
X
X{Sound Parameters}
X  sound=off|x|y|z          Nobody ever plays with fractals at work, do they?
X                           x|y|z can be used to add sound to attractor
X                           fractals, the orbits command, and reading GIFs.
X  hertz=nnn                Base frequency for attractor sound effects
X
X{File Parameters}
X  savename=filename       Save files using this name (instead of FRACT001)
X  overwrite=no|yes       Don't over-write existing files
X  savetime=nnn           Autosave image every nnn minutes of calculation
X  gif87a=yes           Save GIF files in the older GIF87a format (with
X               no FRACTINT extension blocks)
X  dither=yes           Dither color GIFs read into a b/w display.
X  parmfile=filename       File for <@> and <b> commands, default FRACTINT.PAR
X  formulafile=filename       File for type=formula, default FRACTINT.FRM
X  lfile=filename       File for type=lsystem, default FRACTINT.L
X  ifsfile=filename       File for type=ifs, default FRACTINT.IFS
X  orbitsave=yes        Causes IFS and orbit fractals orbit points to be
X               saved in the file ORBITS.RAW
X~FF
X
X{Video Parameters}
X  video=xxx           Begin with this video mode (Example: Video=F2)
X  askvideo=no           Skip the prompt for video mode when restoring files
X  adapter=hgc|cga|ega|egamono|mcga|vga
X                           Assume this (standard) video adapter is present
X  adapter=ATI|Everex|Trident|NCR|Video7|Genoa|Paradise|Chipstech|
X                           Tseng3000|Tseng4000|AheadA|AheadB|Oaktech
X                           Assume the named SuperVGA Chip set is present and
X                           enable its non-standard SuperVGA modes.
X  afi=yes                  Disables the register-compatible 8514/A logic
X                           and forces the use of the 8514/A API (HDILOAD)
X  textsafe=yes|no|bios|save  For use when images are not restored correctly on
X               return from a text display
X  exitmode=nn           Sets the bios-supported videomode to use upon exit
X               (if not mode 3) - nn is the mode in hexadecimal
X  viewwindows=xx[/xx[/yes|no[/nn[/nn]]]]
X               Set the reduction factor, final media aspect ratio,
X               crop starting coordinates (y/n), explicit x size,
X               and explicit y size
X~FF
X
X{Printer Parameters}
X  printer=type[/res[/lpt#[/-1]]]
X               Set the printer type, dots/inch, and port#
X               types: IBM, EPSON, CO (Star Micronix),
X                  HP (LaserJet), PA (Paintjet),
X                  PS (PostScript portrait), PSL (landscape)
X               port# 1-3 LPTn, 11-14 COMn, 21-22 direct parallel,
X                 31-32 direct serial
X  linefeed=crlf|lf|cr       Control characters to emit at end of each line
X  title=yes           Print a title with the output
X  printfile=filename       Print to specified file
X  epsf=1|2|3|...       Forces print to file; default filename fract001.eps,
X               forces PostScript mode
X  translate=yes|nnn       PostScript only; yes prints negative image;
X               >0 reduces image colors; <0 color reduce+negative
X  halftone=frq/angl/styl   PostScript: defines halftone screen
X  halftone=r/g/b       PaintJet: contrast adjustment
X  comport=port/baud/opts   COM port initialization. Port=1,2,3,etc.
X               baud=115,150,300,600,1200,2400,4800,9600
X               options 7,8 | 1,2 | e,n,o (any order)
X               Example: comport=1/9600/n71
X~FF
X  colorps=yes|no           Enable or Disable the color postscript extensions
X  rleps=yes|no             Enable or Disable the postscript rle encoding
X
X{3D Parameters}
X  3d=yes|overlay       Resets 3D to defaults, starts 3D mode. If overlay
X               specified, does not clear existing graphics screen
X  preview=yes           Turns on 3D 'preview' default mode
X  showbox=yes           Turns on 3D 'showbox' default mode
X  sphere=yes           Turns on 3D sphere mode
X  coarse=nnn           Sets Preview 'coarseness' default value
X  stereo=nnn           Sets Stereo (R/B 3D) option:  0 = none,
X               1 = alternate, 2 = superimpose, 3 = photo
X  ray=nnn           selects raytrace output file format
X  brief=yes           selects brief or verbose file for DKB output
X
X  interocular=nnn       Sets 3D Interocular distance default value
X  converge=nnn           Sets 3D Convergence default value
X  crop=nnn/nnn/nnn/nnn       Sets 3D red-left, red-right, blue-left,
X               and blue-right cropping default valuess
X  bright=nnn/nnn       Sets 3D red and blue brightness defaults,
X
X  longitude=nn/nn       Longitude minumim and maximum
X  latitude=nn/nn       Latitude minimum and maximum
X  radius=nn           Radius scale factor
X  rotation=nn[/nn[/nn]]    Rotation abount x,y, and z axes
X  scalexyz=nn/nn/nn       X, Y, and Z scale factors
X  roughness=nn           Same as Z scale factor
X  waterline=nn           Colors this number and below will be 'inside' color
X  filltype=nn           3D filltype
X  perspective=nn       Perspective viewer distance (100 is at the edge)
X  xyshift=nn/nn        Shift image in x & y directions (alters viewpoint)
X  lightsource=nn/nn/nn       The coordinates of the light source vector
X  smoothing=nn           Smooths rough images in light source mode
X  transparent=mm/nn       Sets colors 'mm' to 'nn as transparent
X  xyadjust=nnn/nnn       Sets 3D X and Y adjustment defaults,
X  randomize=nnn        smoothes 3d color transitions between elevations
X  fullcolor=yes        allows creation of full color .TGA image with
X               light source fill types
X  ambient=nnn           sets depth of shadows and contrast when using
X               light source fill types
X  haze=nnn           sets haze for distant objects if fullcolor=1
X  lightname=filename       fullcolor output file name, default FRACT001.TGA
X;
X;
X~Topic=Introduction to Parameters
X
XFractint accepts command-line parameters that allow you to start it with a
Xparticular video mode, fractal type, starting coordinates, and just about
Xevery other parameter and option.
X
XThese parameters can also be specified in a SSTOOLS.INI file, to set them
Xevery time you run Fractint.
X
XThey can also be specified as named groups in a .PAR (parameter) file
Xwhich you can then call up while running Fractint by using the <@>
Xcommand.
X
XIn all three cases (DOS command line, SSTOOLS.INI, and parameter file) the
Xparameters use the same syntax, usually a series of keyword=value commands
Xlike SOUND=OFF.  Each parameter is described in detail in subsequent
Xsections.
X;
X;
X~Topic=Using the DOS Command Line
X
XYou can specify parameters when you start Fractint from DOS by using a
Xcommand like:
X
X    FRACTINT SOUND=OFF FILENAME=MYIMAGE.GIF
X
XThe individual parameters are separated by one or more spaces (an
Xparameter itself may not include spaces). Upper or lower case may be
Xused, and parameters can be in any order.
X
XSince DOS commands are limited to 128 characters, Fractint has a special
Xcommand you can use when you have a lot of startup parameters (or have a
Xset of parameters you use frequently):
X
X    FRACTINT @MYFILE
X
XWhen @filename is specified on the command line, Fractint reads parameters
Xfrom the specified file as if they were keyed on the command line.  You
Xcan create the file with a text editor, putting one "keyword=value"
Xparameter on each line.
X;
X;
X~Topic=Setting Defaults (SSTOOLS.INI File)
XEvery time Fractint runs, it searches the current directory, and then the
Xdirectories in your DOS PATH, for a file named SSTOOLS.INI.  If it finds
Xthis file, it begins by reading parameters from it.  This file is useful
Xfor setting parameters you always want, such as those defining your
Xprinter setup.
X
XSSTOOLS.INI is divided into sections belonging to particular programs.
XEach section begins with a label in brackets. Fractint looks for the label
X[fractint], and ignores any lines it finds in the file belonging to any
Xother label. If an SSTOOLS.INI file looks like this:
X
X  [fractint]\
X  sound=off     ; (for home use only)\
X  printer=hp     ; my printer is a LaserJet\
X  inside=0     ; using "traditional" black\
X  [startrek]\
X  warp=9.5     ; Captain, I dinna think the engines can take it!\
X
XFractint will use only the second, third, and fourth lines of the file.
X(Why use a convention like that when Fractint is the only program you know
Xof that uses an SSTOOLS.INI file?  Because there are other programs (such
Xas Lee Crocker's PICLAB) that now use the same file, and there may one day
Xbe other, sister programs to Fractint using that file.)
X;
X;
X~Topic=Parameter Files and the <@> Command
X
XYou can change parameters on-the-fly while running Fractint by using the
X<@> command and a parameter file. Parameter files contain named groups of
Xparameters, looking something like this:
X
X  quickdraw \{        ; a set of parameters named quickdraw\
X     maxiter=150\
X     float=no\
X     }\
X  slowdraw \{        ; another set of parameters\
X     maxiter=2000\
X     float=yes\
X     }\
X
XIf you use the <@> command and select a parameter file containing the
Xabove example, Fractint will show two choices: quickdraw and slowdraw. You
Xmove the cursor to highlight one of the choices and press <Enter> to set
Xthe parameters specified in the file by that choice.
X
XThe default parameter file name is FRACTINT.PAR. A different file can be
Xselected with the "parmfile=" option, or by using <@> and then hitting
X<F6>.
X
XYou can create parameter files with a text editor, or for some uses, by
Xusing the <B> command. Parameter files can be used in a number of ways,
Xsome examples:
X
X  o To save the parameters for a favorite image. Fractint can do this for
X    you with the <B> command.
X
X  o To save favorite sets of 3D transformation parameters. Fractint can do
X    this for you with the <B> command.
X
X  o To set up different sets of parameters you use occasionally. For
X    instance, if you have two printers, you might want to set up a group
X    of parameters describing each.
X
X  o To save image parameters for later use in batch mode - see
X    {Batch Mode}.
X
XSee {"Parameter Save/Restore Commands"} for details about the <@> and
X<B> commands.
X;
X;
X~Topic=General Parameter Syntax
X
XParameters must be separated by one or more spaces.
X
XUpper and lower case can be used in keywords and values.
X
XAnything on a line following a ; (semi-colon) is ignored, i.e. is a
Xcomment.
X
XIn parameter files and SSTOOLS.INI:\
X  o Individual parameters can be entered on separate lines.\
X  o Long values can be split onto multiple lines by ending a line with a \\
X    (backslash) - leading spaces on the following line are ignored, the
X    information on the next line from the first non-blank character onward
X    is appended to the prior line.
X
XSome terminology:\
X  KEYWORD=nnn           enter a number in place of "nnn"\
X  KEYWORD=[filename]       you supply filename\
X  KEYWORD=yes|no|whatever  choose one of "yes", "no", or "whatever"\
X  KEYWORD=1st[/2nd[/3rd]]  the slash-separated parameters "2nd" and
X               "3rd" are optional
X;
X;
X~Topic=Startup Parameters
X
X@FILENAME\
XCauses Fractint to read "filename" for parameters. When it finishes, it
Xresumes reading its own command line -- i.e., "FRACTINT MAXITER=250
X@MYFILE PASSES=1" is legal. This option is only valid on the DOS command
Xline, as Fractint is not clever enough to deal with multiple indirection.
X
X@FILENAME/GROUPNAME\
XLike @FILENAME, but reads a named group of parameters from a parameter
Xfile.  See {"Parameter Files and the <@> Command"}.
X
XFILENAME=[name]\
XCauses Fractint to read the named file, which must either have been saved
Xfrom an earlier Fractint session or be a generic GIF file, and use that as
Xthe starting point, bypassing the initial information screens. The
Xfiletype is optional and defaults to .GIF. Non-Fractint GIF files are
Xrestored as fractal type "plasma".\
XOn the DOS command line you may omit FILENAME= and just give the file name.
X
XBATCH=yes\
XSee {Batch Mode}.
X
XAUTOKEY=play|record\
XSpecifying "play" runs Fractint in playback mode - keystrokes are read
Xfrom the autokey file (see next parameter) and interpreted as if they're
Xbeing entered from the keyboard.\
XSpecifying "record" runs in recording mode - all keystrokes are recorded
Xin the autokey file.\
XSee also {Autokey Mode}.
X
XAUTOKEYNAME=[filename]\
XSpecifies the file name to be used in autokey mode. The default file name
Xis AUTO.KEY.
X
XFPU=387|IIT|NOIIT\
XThis parameter is useful if you have an unusual coprocessor chip. If you
Xhave a 80287 replacement chip with full 80387 functionality use "FPU=387"
Xto inform Fractint to take advantage of those extra 387 instructions.
XIf you have the IIT fpu, but don't have IIT's 'f4x4int.com' TSR loaded,
Xuse "FPU=IIT" to force Fractint to use that chip's matrix multiplication
Xroutine automatically to speed up 3-D transformations (if you have an IIT
Xfpu and have that TSR loaded, Fractint will auto-detect the presence of
Xthe fpu and TSR and use its extra capabilities automatically).
XSince all IIT chips support 80387 instructions, enabling the IIT code also
Xenables Fractint's use of all 387 instructions.
XSetting "FPU=NOIIT" disables Fractint's IIT Auto-detect capability.
XWarning: multi-tasking operating systems such as Windows and DesQView
Xdon't automatically save the IIT chip extra registers, so running two
Xprograms at once that both use the IIT's matrix multiply feature but
Xdon't use the handshaking provided by that 'f4x4int.com' program,
Xerrors will result.
X
XMAKEDOC[=filename]\
XCreate Fractint documentation file (for printing or viewing with a text
Xeditor) and then return to DOS.  Filename defaults to FRACTINT.DOC.
XThere's also a function in Fractint's online help which can be used to
Xproduce the documentation file -
X~Doc-
Xsee {Printing Fractint Documentation}.
X~Doc+,Online-
Xuse "Printing Fractint Documentation" from the main help index.
X~Online+
X;
X;
X~Topic=Calculation Mode Parameters
X
XPASSES=1|2|guess|btm|tesseral\
XSelects single-pass, dual-pass, solid-Guessing mode, Boundary Tracing,
Xor the Tesseral algorithm.  See {Drawing Method}.
X
XFILLCOLOR=normal|<nnn>\
XSets a color to be used for block fill by Boundary Tracing and Tesseral
Xalgorithms.  See {Drawing Method}.
X
XFLOAT=yes\
XMost fractal types have both a fast integer math and a floating point
Xversion. The faster, but possibly less accurate, integer version is the
Xdefault. If you have a new 80486 or other fast machine with a math
Xcoprocessor, or if you are using the continuous potential option (which
Xlooks best with high bailout values not possible with our integer math
Ximplementation), you may prefer to use floating point. Just add
X"float=yes" to the command line to do so.
XAlso see {"Limitations of Integer Math (And How We Cope)"}.
X
XSYMMETRY=xxx\
XForces symmetry to None, Xaxis, Yaxis, XYaxis, Origin, or Pi symmetry.
XUseful for debugging.
X;
X;
X~Topic=Fractal Type Parameters
X
XTYPE=[name]\
XSelects the fractal type to calculate. The default is type "mandel".
X
XPARAMS=n/n/n/n...\
XSet optional (required, for some fractal types) values used in the
Xcalculations. These numbers typically represent the real and imaginary
Xportions of some startup value, and are described in detail as needed in
X{Fractal Types}.\
X(Example: FRACTINT TYPE=julia PARAMS=-0.48/0.626 would wait at the opening
Xscreen for you to select a video mode, but then proceed straight to the
XJulia set for the stated x (real) and y (imaginary) coordinates.)
X
XFUNCTION=[fn1[/fn2[/fn3[/fn4]]]]\
XAllows setting variable functions found in some fractal type formulae.
XPossible values are sin, cos, tan, cotan, sinh, cosh, tanh, cotanh, exp,
Xlog, sqr, recip (i.e. 1/z), ident (i.e. identity), and cosxx (cos with
Xa pre version 16 bug).
X
XFORMULANAME=[formulaname]\
XSpecifies the default formula name for type=formula fractals.  (I.e. the
Xname of a formula defined in the FORMULAFILE.) Required if you want to
Xgenerate one of these fractal types in batch mode, as this is the only way
Xto specify a formula name in that case.
X
XLNAME=[lsystemname]\
XSpecifies the default L-System name. (I.e. the name of an entry in the
XLFILE.) Required if you want to generate one of these fractal types in
Xbatch mode, as this is the only way to specify an L-System name in that
Xcase.
X
XIFS=[ifsname]\
XSpecifies the default IFS name. (I.e. the name of an entry in the
XIFSFILE.) Required if you want to generate one of these fractal types in
Xbatch mode, as this is the only way to specify an IFS name in that case.
X;
X;
X~Topic=Image Calculation Parameters
XMAXITER=nnn\
XReset the iteration maximum (the number of iterations at which the program
Xgives up and says 'OK, this point seems to be part of the set in question
Xand should be colored [insidecolor]') from the default 150. Values range
Xfrom 10 to 32000 (super-high iteration limits like 30000 are useful when
Xusing logarithmic palettes).  See {The Mandelbrot Set} for a description
Xof the iteration method of calculating fractals.\
X"maxiter=" can also be used to adjust the number of orbits plotted for
X3D "attractor" fractal types such as lorenz3d and kamtorus.
X
XCORNERS=xmin/xmax/ymin/ymax[/x3rd/y3rd]\
XExample: corners=-0.739/-0.736/0.288/0.291\
XBegin with these coordinates as the range of x and y coordinates, rather
Xthan the default values of (for type=mandel) -2.0/2.0/-1.5/1.5. When you
Xspecify four values (the usual case), this defines a rectangle: x-
Xcoordinates are mapped to the screen, left to right, from xmin to xmax, y-
Xcoordinates are mapped to the screen, bottom to top, from ymin to ymax.
XSix parameters can be used to describe any rotated or stretched
Xparallelogram:    (xmin,ymax) are the coordinates used for the top-left
Xcorner of the screen, (xmax,ymin) for the bottom-right corner, and
X(x3rd,y3rd) for the bottom-left.
X
XCENTER-MAG=[Xctr/Yctr/Mag]\
XThis is an alternative way to enter corners as a center point and a
Xmagnification that is popular with some fractal programs and publications.
XEntering just "CENTER-MAG=" tells Fractint whether to use this form rather
Xthan corners when saving parameters with  the <B> command. The <TAB>
Xstatus display shows the "corners" in both forms.  Note that an aspect
Xratio of 1.3333 is assumed; if you have altered the zoom box proportions
Xor rotated the zoom box, this form can no longer be used.
X
XBAILOUT=nnn\
XOver-rides the default bailout criterion for escape-time fractals. Can
Xalso be set from the parameters screen after selecting a fractal type.
XSee description of bailout in {The Mandelbrot Set}.
X
XRESET\
XCauses Fractint to reset all calculation related parameters to their
Xdefault values. Non-calculation parameters such as "printer=", "sound=",
Xand "savename=" are not affected. RESET should be specified at the start
Xof each parameter file entry (used with the <@> command) which defines an
Ximage, so that the entry need not describe every possible parameter - when
Xinvoked, all parameters not specifically set by the entry will have
Xpredictable values (the defaults).
X
XINITORBIT=pixel\
XINITORBIT=nnn/nnn\
XAllows control over the value used to begin each Mandelbrot-type orbit.
X"initorbit=pixel" is the default for most types; this command initializes
Xthe orbit to the complex number corresponding to the screen pixel. The
Xcommand "initorbit=nnn/nnn" uses the entered value as the initializer. See
Xthe discussion of the {Mandellambda Sets} for more on this topic.
X
XORBITDELAY=<nn>\
XSlows up the display of orbits using the <o> command
Xfor folks with hot new computers. Units are in 1/10000 seconds per
Xorbit point.  ORBITDELAY=10 therefore allows you to see each pixel's
Xorbit point for about one millisecond. For best display of orbits,
Xtry passes=1 and a moderate resolution such as 320x200.  Note that
Xthe first time you press the 'o' key with the 'orbitdelay' function
Xactive, your computer will pause for a half-second or so to calibrate
Xa high-resolution timer.
X
XPERIODICITY=no|show|nnn\
XControls periodicity checking (see {Periodicity Logic}).
X"no" turns it off, "show" lets
Xyou see which pixels were painted as "inside" due to being caught
Xby periodicity.  Specifying a number causes a more conservative
Xperiodicity test (each increase of 1 divides test tolerance by 2).
XEntering a negative number lets you turn on "show" with that number. Type
Xlambdafn function=exp needs periodicity turned off to be accurate -- there
Xmay be other cases.
X
XRSEED=nnnn\
XThe initial random-number "seed" for plasma clouds is taken from your PC's
Xinternal clock-timer. This argument forces a value (which you can see in
Xthe <Tab> display), and allows you to reproduce plasma clouds. A detailed
Xdiscussion of why a TRULY random number may be impossible to define, let
Xalone generate, will have to wait for "FRACTINT: The 3-MB Doc File."
X
XSHOWDOT=<nn>\
XColors the pixel being calculated color <nn>. Useful for very slow
Xfractals for showing you the calculation status.
X;
X;
X~Topic=Color Parameters
XINSIDE=nnn|bof60|bof61|zmag|attractor|epscross|startrail|period\
XSet the color of the interior: for
Xexample, "inside=0" makes the M-set "lake" a stylish basic black. A setting of
X-1 makes inside=maxiter. Three more options reveal hidden structure inside the
Xlake.  Inside=bof60 and inside=bof61, are named after the figures on pages 60
Xand 61 of "Beauty of Fractals".  See {Inside=bof60|bof61|zmag|period}
Xfor a brilliant explanation of what these do!
X
XInside=zmag is a method of coloring based on the magnitude of Z after the
Xmaximum iterations have been reached.  The affect along the edges of the
XMandelbrot is like thin-metal welded sculpture.
X
XInside=epscross colors pixels green or yellow according to whether their
Xorbits swing close to the Y-axis or X-axis, respectively. Inside=starcross
Xhas a coloring scheme based on clusters of points in the orbits. Best with
Xoutside=<nnn>. For more information, see {Inside=epscross|startrail}.
X
XInside=period colors pixels according to the period of their eventual orbit.
X
XNote that the "Look for finite attractor" option on the <Y> options screen
Xwill override the selected inside option if an attractor is found - see
X{Finite Attractors}.
X
XOUTSIDE=nnn|iter|real|imag|summ|mult\
XThe classic method of coloring outside
Xthe fractal is to color according to how many iterations were required before
XZ reached the bailout value, usually 4. This is the method used when
XOUTSIDE=iter.
X
XHowever, when Z reaches bailout the real and imaginary components can be at
Xvery diferent values.  OUTSIDE=real and OUTSIDE=imag color using the iteration
Xvalue plus the real or imaginary values.  OUTSIDE=summ uses the sum of all
Xthese values.  These options can give a startling 3d quality to otherwise flat
Ximages and can change some boring images to wonderful ones. OUTSIDE=mult
Xcolors by multiplying the iteration by real divided by imaginary. There was no
Xmathematical reason for this, it just seemed like a good idea.
X
XOutside=nnn sets the color of the exterior to some number of your choosing:
Xfor example, "OUTSIDE=1" makes all points not INSIDE the fractal set to color
X1 (blue). Note that defining an OUTSIDE color forces any image to be a
Xtwo-color one: either a point is INSIDE the set, or it's OUTSIDE it.
X
XMAP=[filename]\
XReads in a replacement color map from [filename]. This map replaces the
Xdefault color map of your video adapter. Requires a VGA or higher adapter.
XThe difference
Xbetween this argument and an alternate map read in via <L> in color-
Xcommand mode is that this one applies to the entire run.
XSee {Palette Maps}.
X
XCOLORS=@filename|colorspecification\
XSets colors for the current image, like the <L> function in color cycling
Xand palette editing modes. Unlike the MAP= parameter, colors set with
XCOLORS= do not replace the default - when you next select a new video
Xmode, colors will revert to their defaults.\
XCOLORS=@filename tells Fractint to use a color map file named "filename".
XSee {Palette Maps}.\
XCOLORS=colorspecification specifies the colors directly. The value of
X"colorspecification" is rather long (768 characters for 256 color modes),
Xand its syntax is not documented here. This form of the COLORS= command is
Xnot intended for manual use - it exists for use by the <B> command when
Xsaving the description of a nice image.
X
XCYCLERANGE=nnn/nnn\
XSets the range of color numbers to be animated during color cycling.  The
Xdefault is 1/255, i.e. just color number 0 (usually black) is not cycled.
X
XCYCLELIMIT=nnn\
XSets the speed of color cycling. Technically, the number of DAC registers
Xupdated during a single vertical refresh cycle. Legal values are 1 - 256,
Xdefault is 55.
X
XTEXTCOLORS=mono\
XSet text screen colors to simple black and white.
X
XTEXTCOLORS=aa/bb/cc/...\
XSet text screen colors. Omit any value to use the default (e.g.
Xtextcolors=////50 to set just the 5th value). Each value is a 2 digit
Xhexadecimal value; 1st digit is background color (from 0 to 7), 2nd digit
Xis foreground color (from 0 to F).\
X~Format-
XColor values are:
X    0 black    8 gray
X    1 blue    9 light blue
X    2 green    A light green
X    3 cyan    B light cyan
X    4 red    C light red
X    5 magenta    D light magenta
X    6 brown    E yellow
X    7 white    F bright white
X31 colors can be specified, their meanings are as follows:
X~OnlineFF
X  heading:
X    1  Fractint version info
X    2  heading line development info (not used in released version)
X  help:
X    3  sub-heading
X    4  main text
X    5  instructions at bottom of screen
X    6  hotlink field
X    7  highlighted (current) hotlink
X  menu, selection boxes, parameter input boxes:
X    8  background around box and instructions at bottom
X    9  emphasized text outside box
X   10  low intensity information in box
X   11  medium intensity information in box
X   12  high intensity information in box (e.g. heading)
X   13  current keyin field
X   14  current keyin field when it is limited to one of n values
X   15  current choice in multiple choice list
X   16  speed key prompt in multiple choice list
X   17  speed key keyin in multiple choice list
X  general (tab key display, IFS parameters, "thinking" display):
X   18  high intensity information
X   19  medium intensity information
X   20  low intensity information
X   21  current keyin field
X  disk video:
X   22  background around box
X   23  high intensity information
X   24  low intensity information
X  diagnostic messages:
X   25  error
X   26  information
X  credits screen:
X   27  bottom lines
X   28  high intensity divider line
X   29  low intensity divider line
X   30  primary authors
X   31  contributing authors
XThe default is
X   textcolors=1F/1A/2E/70/28/71/31/78/70/17/
X          1F/1E/2F/3F/5F/07/0D/71/70/78/0F/
X          70/0E/0F/4F/20/17/20/28/0F/07
X(In a real command file, all values must be on one line.)
X~Format+
X;
X;
X~Topic=Doodad Parameters
X
XLOGMAP=yes|old|n\
XSelects a compressed relationship between escape-time iterations and
Xpalette colors.  See {"Logarithmic Palettes and Color Ranges"} for details.
X
XRANGES=nn/nn/nn/...\
XSpecifies ranges of escape-time iteration counts to be mapped to each
Xcolor number.  See {"Logarithmic Palettes and Color Ranges"} for details.
X
XDISTEST=nnn/nnn\
XA nonzero value in the first parameter enables the distance estimator
Xmethod. The second parameter specifies the "width factor", defaults to 71.
XSee {"Distance Estimator Method"} for details.
X
XDECOMP=2|4|8|16|32|64|128|256\
XInvokes the corresponding decomposition coloring scheme.
XSee {Decomposition} for details.
X
XBIOMORPH=nnn\
XTurn on biomorph option; set affected pixels to color nnn.
XSee {Biomorphs} for details.
X
XPOTENTIAL=maxcolor[/slope[/modulus[/16bit]]]\
XEnables the "continuous potential" coloring mode for all fractal types
Xexcept plasma clouds, attractor types such as lorenz, and IFS. The four
Xarguments define the maximum color value, the slope of the potential
Xcurve, the modulus "bailout" value, and whether 16 bit values are to be
Xcalculated.  Example: "POTENTIAL=240/2000/40/16bit". The Mandelbrot and
XJulia types ignore the modulus bailout value and use their own hardwired
Xvalue of 4.0 instead.  See {Continuous Potential} for details.
X
XINVERT=nn/nn/nn\
XTurns on inversion. The parameters are radius of inversion, x-coordinate
Xof center, and y-coordinate of center. -1 as the first parameter sets the
Xradius to 1/6 the smaller screen dimension; no x/y parameters defaults to
Xcenter of screen. The values are displayed with the <Tab> command.
XSee {Inversion} for details.
X
XFINATTRACT=no|yes\
XAnother option to show coloring inside some Julia "lakes" to show escape
Xtime to finite attractors. Works with lambda, magnet types, and possibly
Xothers.  See {Finite Attractors} for more information.
X
XEXITNOASK=yes\
XThis option forces Fractint to bypass the final "are you sure?" exit
Xscreen when the ESCAPE key is pressed from the main image-generation
Xscreen.  Added at the request of Ward Christensen.  It's his funeral <grin>.
X;
X;
X~Topic=File Parameters
X
XSAVENAME=[name]\
XSet the filename to use when you <S>ave a screen. The default filename is
XFRACT001. The .GIF extension is optional (Example: SAVENAME=myfile)
X
XOVERWRITE=no|yes\
XSets the savename overwrite flag (default is 'no'). If 'yes', saved files
Xwill over-write existing files from previous sessions; otherwise the
Xautomatic incrementing of FRACTnnn.GIF will find the first unused
Xfilename.
X
XSAVETIME=nnn\
XTells Fractint to automatically do a save every nnn minutes while a
Xcalculation is in progress.  This is mainly useful with long batches - see
X{Batch Mode}.
X
XGIF87a=YES\
XBackward-compatibility switch to force creation of GIF files in the GIF87a
Xformat. As of version 14, Fractint defaults to the new GIF89a format which
Xpermits storage of fractal information within the format. GIF87a=YES is
Xonly needed if you wish to view Fractint images with a GIF decoder that
Xcannot accept the newer format.  See {GIF Save File Format}.
X
XDITHER=YES\
XDither a color file into two colors for display on a b/w display.  This give
Xa poor-quality display of gray levels.  Note that if you have a 2-color
Xdisplay, you can create a 256-color gif with disk video and then read it
Xback in dithered.
X
XPARMFILE=[parmfilename]\
XSpecifies the default parameter file to be used by the <@> and <B>
Xcommands.  If not specified, the default is FRACTINT.PAR.
X
XFORMULAFILE=[formulafilename]\
XSpecifies the formula file for type=formula fractals (default is
XFRACTINT.FRM).    Handy if you want to generate one of these fractal types
Xin batch mode.
X
XLFILE=[lsystemfile]\
XSpecifies the default L-System file for type=lsystem fractals (if not
XFRACTINT.L).
X
XIFSFILE=[ifsfilename]\
XSpecifies the default file for type=ifs fractals (default is
XFRACTINT.IFS).
X
XFILENAME=[.suffix]\
XSets the default file extension used for the <r> command.
XWhen this parameter is omitted, the
Xdefault file mask shows .GIF and .POT files.  You might want to specify
Xthis parameter and the SAVENAME= parameter in your SSTOOLS.INI file if you
Xkeep your fractal images separate from other .GIF files by using a
Xdifferent suffix for them.
X
XORBITSAVE=yes\
XCauses the file ORBITS.RAW to be opened and the points generated by orbit
Xfractals or IFS fractals to be saved in a raw format. This file can be read
Xby the Acrospin program which can rotate and scale the image rapidly in
Xresponse to cursor-key commands. The filename ORBITS.RAW is fixed and will
Xbe overwritten each time a new fractal is generated with this option.\
X(see {Barnsley IFS Fractals} {Orbit Fractals} {=@ACROSPIN Acrospin});
X;
X~Topic=Video Parameters
X
XVIDEO=xxx\
XSet the initial video mode (and bypass the informational screens). Handy
Xfor batch runs. (Example: VIDEO=F4 for IBM 16-color VGA.)
XYou can obtain the current VIDEO= values (key assignments) from the
X"select video mode" screens inside Fractint. If you want to do a batch run
Xwith a video mode which isn't currently assigned to a key, you'll have to
Xmodify the key assignments - see {"Video Mode Function Keys"}.
X
XASKVIDEO=yes|no\
XIf "no," this eliminates the prompt asking you if a file to be restored is
XOK for your current video hardware.\
XWARNING: every version of Fractint so far has had a bigger, better, but
Xshuffled-around video table. Since calling for a mode your hardware
Xdoesn't support can leave your system in limbo, be careful about leaving
Xthe above two parameters in a command file to be used with future versions
Xof Fractint, particularly for the super-VGA modes.
X
XADAPTER=hgc|cga|ega|egamono|mcga|vga|ATI|Everex|Trident|NCR|Video7|Genoa|
X        Paradise|Chipstech|Tseng3000|Tseng4000|AheadA|AheadB|Oaktech\
XBypasses Fractint's internal video autodetect logic and assumes that the
Xspecified kind of adapter is present. Use this parameter only if you
Xencounter video problems without it.  Specifying adapter=vga with an SVGA
Xadapter will make its extended modes unusable with Fractint.  All of the
Xoptions after the "VGA" option specify specific SuperVGA chipsets which
Xare capable of video resolutions higher than that of a "vanilla" VGA adapter.
XNote that Fractint cares about the Chipset your adapter uses internally,
Xnot the name of the company that sold it to you.
X
XVESADETECT=yes|no\
XSpecify no to bypass VESA video detection logic. Try this if you encounter
Xvideo problems with a VESA compliant video adapter or driver.
X
XAFI=yes|8514|no\
XNormally, when you attempt to use an 8514/A-specific video mode, Fractint
Xfirst attempts to detect the presence of an 8514/A register-compatible
Xadapter.  If it fails to find one, it then attempts to detect the presence
Xof an 8514/A-compatible API (IE, IBM's HDILOAD or its equivalent).
XFractint then uses either its register-compatible or its API-compatible
Xvideo logic based on the results of those tests.  If you have an
X"8514/A-compatible" video adapter that passes Fractint's
Xregister-compatible detection logic but doesn't work correctly with
XFractint's register-compatible video logic, setting "afi=yes" will
Xforce Fractint to bypass the register-compatible code and look only for
Xthe API interface.
X
XTEXTSAFE=yes|no|bios|save\
XWhen you switch from a graphics image to text mode (e.g. when you use <F1>
Xwhile a fractal is on display), Fractint remembers the graphics image, and
Xrestores it when you return from the text mode.
XThis should be no big deal - there are a number of well-defined ways
XFractint could do this which *should* work on any video adapter.  They
Xdon't - every fast approach we've tried runs into a bug on one video
Xadapter or another.  So, we've implemented a fast way which works on most
Xadapters in most modes as the default, and added this parameter for use
Xwhen the default approach doesn't work.\
XIf you experience the following problems, please fool around with this
Xparameter to try to fix the problem:\
X  o Garbled image, or lines or dashes on image, when returning to image
X    after going to menu, <tab> display, or help.\
X  o Blank screen when starting Fractint.\
XThe problems most often occur in higher resolution modes. We have not
Xencountered them at all in modes under 320x200x256 - for those modes
XFractint always uses a fast image save/restore approach.\
XTextsafe options:\
X  yes: This is the default. When switching to/from graphics, Fractint
X    saves just that part of video memory which EGA/VGA adapters are
X    supposed to modify during the mode changes.
X  no: This forces use of monochrome 640x200x2 mode for text displays (when
X    there is a high resolution graphics image to be saved.) This choice is
X    fast but uses chunky and colorless characters. If it turns out to be
X    the best choice for you, you might want to also specify
X    "textcolors=mono" for a more consistent appearance in text screens.
X  bios: This saves memory in the same way as textsafe=yes, but uses the
X    adapter's BIOS routines to save/restore the graphics state.  This
X    approach is fast and ought to work on all adapters. Sadly, we've found
X    that very few adapters implement this function perfectly.
X  save: This is the last choice to try. It should work on all adapters in
X    all modes but it is slow. It tells Fractint to save/restore the entire
X    image. Expanded or extended memory is used for the save if you have
X    enough available; otherwise a temporary disk file is used. The speed
X    of textsafe=save will be acceptable on some machines but not others.
X    The speed depends on:\
X      o Cpu and video adapter speed.\
X      o Whether enough expanded or extended memory is available.\
X      o Video mode of image being remembered. A few special modes are
X    *very* slow compared to the rest. The slow ones are: 2 and 4 color
X    modes with resolution higher than 640x480; custom modes for ATI
X    EGA Wonder, Paradise EGA-480, STB, Compaq portable 386, AT&T 6300,
X    and roll-your-own video modes implemented with customized
X    "yourvid.c" code.
XIf you want to tune Fractint to use different "textsafe" options for
Xdifferent video modes, see {"Customized Video Modes\, FRACTINT.CFG"}.
X(E.g. you might
Xwant to use the slower textsafe=save approach just for a few high-
Xresolution modes which have problems with textsafe=yes.)
X
XEXITMODE=nn\
XSets the bios-supported videomode to use upon exit to the specified value.
Xnn is in hexadecimal.  The default is 3, which resets to 80x25 color text
Xmode on exit. With Hercules Graphics Cards, and with monochrome EGA
Xsystems, the exit mode is always 7 and is unaffected by this parameter.
X
XTPLUS=yes|no\
XFor TARGA+ adapters. Setting this to 'no' pretends a TARGA+ is NOT
Xinstalled.
X
XNONINTERLACED=yes|no\
XFor TARGA+ adapters. Setting this to 'yes' will configure the adapter to a
Xnon-interlaced mode whenever possible.    It should only be used with a
Xmultisynch monitor. The default is no, i.e. interlaced.
X
XMAXCOLORRES=8|16|24\
XFor TARGA+ adapters. This determines the number of bits to use for color
Xresolution.  8 bit color is equivalent to VGA color resolution. The 16 and
X24 bit color resolutions are true color video modes which are not yet
Xsupported by Fractint but are hopefully coming soon.
X
XPIXELZOOM=0|1|2|3\
XFor TARGA+ adapters. Lowers the video mode resolution by powers of 2. For
Xexample, the 320x200 video resolution on the TARGA+ is actually the
X640x400 video mode with a pixel zoom of 1.  Using the 640x400 video mode
Xwith a zoom of 3 would lower the resolution by 8, which is 2 raised to the
X3rd power, for a full screen resolution of 80x50 pixels.
X
XVIEWWINDOWS=xx[/xx[/yes|no[/nn[/nn]]]]
XSet the reduction factor, final media aspect ratio, crop starting
Xcoordinates (y/n), explicit x size, and explicit y size, see {"View Window"}.
X;
X;
X~Topic=Sound Parameters
X
XSOUND=off|x|y|z\
XWe're all MUCH too busy to waste time with Fractint at work, and no doubt
Xyou are too, so "sound=off" is included only for use at home, to avoid
Xwaking the kids or your Significant Other, late at night. (By the way,
Xdidn't you tell yourself "just one more zoom on LambdaSine" an hour ago?)
XSuggestions for a "boss" hot-key will be cheerfully ignored, as this
Xsucker is getting big enough without including a spreadsheet screen too.
XThe "sound=x/y/x" options are for the "attractor" fractals, like the
XLorenz fractals - they play with the sound on your PC speaker as they are
Xgenerating an image, based on the X or Y or Z co-ordinate they are
Xdisplaying at the moment.  At the moment, "sound=x" (or y or z) really
Xdoesn't work very well when using an integer algorithm - try it with the
Xfloating-point toggle set, instead.
X
XThe scope of the sound command has been extended. You can now hear the
Xsound of fractal orbits--just turn on sound from the command line or the
X<X> menu, fire up a fractal, and try the <O>rbits command. Use the
Xorbitdelay=<nnn> command (also on the <X> menu) to dramatically alter
Xthe effect, which ranges from an unearthly scream to a series of discrete
Xtones. Not recommended when people you have to live with are nearby!
XRemember, we don't promise that it will sound beautiful!
X
XYou can also "hear" any image that Fractint can decode; turn on sound
Xbefore using <R> to read in a GIF file. We have no idea if this feature
Xis useful. It was inspired by the comments of an on-line friend who is
Xblind. We solicit feedback and suggestions from anyone who finds these
Xsound features interesting or useful. The orbitdelay command also affects
Xthe sound of decoding images.
X
XHERTZ=nnn\
XAdjusts the sound produced by the "sound=x/y/z" option.  Legal values are
X200 through 10000.
X;
X;
X~Topic=Printer Parameters
X
X~Doc-
XGeneral printer parameters are described below.\
XAdditional parameters for specific types of printers are described in:\
X     {PostScript Parameters}\
X     {PaintJet Parameters}\
X     {Plotter Parameters}\
X
X~Doc+
XPRINTER=type[/resolution[/port#]]\
XDefines your printer setup. The SSTOOLS.INI file is a REAL handy place to
Xput this option, so that it's available whenever you have that sudden,
Xirresistible urge for hard copy.
X~Format-
XPrinter types:
X  IB  IBM-compatible (default)
X  EP  Epson-compatible
X  HP  LaserJet
X  CO  Star Micronics Color printer, supposedly Epson-color-compatible
X  PA  Paintjet
X  PS  PostScript
X  PSL Postscript, landscape mode
X  PL  Plotter using HP-GL
XResolution:
X  In dots per inch.
X  Epson/IBM: 60, 120, 240
X  LaserJet: 75, 150, 300
X  PaintJet: 90, 180
X  PostScript: 10 through 600, or special value 0 to print full page to
X  within about .4" of the edges (in portrait mode, width is full page and
X  height is adjusted to 3:4 aspect ratio)
X  Plotter: 1 to 10 for 1/Nth of page (e.g. 2 for 1/2 page)
XPort:
X  1, 2, 3 for LPT1-3 via BIOS
X  11, 12, 13, 14 for COM1-4 via BIOS
X  21, 22 for LPT1 or LPT2 using direct port access (faster when it works)
X  31, 32 for COM1 or COM2 using direct port access
X~Format+
X
XCOMPORT=port/baud/options\
XSerial printer port initialization.\
XPort=1,2,3,etc.\
XBaud=115,150,300,600,1200,2400,4800,9600\
XOptions: 7,8 | 1,2 | e,n,o (any order).\
XExample: comport=1/9600/n81 for COM1 set to 9600, no parity, 8 bits per
Xcharacter, 1 stop bit.
X
XLINEFEED=crlf|lf|cr\
XSpecifies the control characters to emit at end of each line:  carriage
Xreturn and linefeed, just linefeed, or just carriage return.  The default
Xis crlf.
X
XTITLE=yes\
XIf specified, title information is added to printouts.
X
XPRINTFILE=filename\
XCauses output data for the printer to be written to the named file on disk
Xinstead of to a printer port. The filename is incremented by 1 each time
Xan image is printed - e.g. if the name is FRAC01.PRN, the second print
Xoperation writes to FRAC02.PRN, etc. Existing files are not overwritten -
Xif the file exists, the filename is incremented to a new name.
X;
X;
X~Topic=PostScript Parameters
X
XEPSF=1|2|3\
XForces print-to-file and PostScript. If PRINTFILE is not specified, the
Xdefault filename is FRACT001.EPS. The number determines how 'well-behaved'
Xa .EPS file is. 1 means by-the-book. 2 allows some EPS 'no-nos' like
Xsettransfer and setscreen - BUT includes code that should make the code
Xstill work without affecting the rest of the non-EPS document. 3 is a
Xfree-for-all.
X
XCOLORPS=YES|NO - Enable or disable the color extensions.
X
XRLEPS=YES|NO\
XEnable or disable run length encoding of the PostScript file.  Run length
Xencoding will make the PostScript file much smaller, but it may take longer
Xto print.  The run length encoding code is based on pnmtops, which is
Xcopyright (C) 1989 by Jef Poskanzer, and carries the following notice:
X"Permission to use, copy, modify, and distribute this software and its
Xdocumentation for any purpose and without fee is hereby granted, provided
Xthat the above copyright notice appear in all copies and that both that
Xcopyright notice and this permission notice appear in supporting
Xdocumentation.  This software is provided "as is" without express or
Ximplied warranty."
X
XTRANSLATE=yes|-n|n\
XTranslate=yes prints the negative image of the fractal.
XTranslate=n reduces the image to that many colors. A negative value causes
Xa color reduction as well as a negative image.
X
XHALFTONE=frq/ang/sty[/f/a/s/f/a/s/f/a/s]\
XTells the PostScript printer how to define its halftone screen. The first
Xvalue, frequency, defines the number of halftone lines per inch. The
Xsecond chooses the angle (in degrees) that the screen lies at. The third
Xoption chooses the halftone 'spot' style. Good default frequencies are
Xbetween 60 and 80; Good default angles are 45 and 0; the default style is
X0. If the halftone= option is not specified, Fractint will print using the
Xprinter's default halftone screen, which should have been already set to
Xdo a fine job on the printer.
X
XThese are the only three used when colorps=no. When color PS printing is
Xbeing used, the other nine options specify the red, green, then blue
Xscreens. A negative number in any of these places will cause it to use
Xthe previous (or default) value for that parameter. NOTE: Especially when
Xusing color, the built-in screens in the printer's ROM may be the best
Xchoice for printing.
X~OnlineFF
XThe default values are as follows: halftone=45/45/1/45/75/1/45/15/1/45/0/1
Xand these will be used if Fractint's halftone is chosen over the printer's
Xbuilt-in screen.
X~Format-
X
XCurrent halftone styles:
X    0 Dot
X    1 Dot (Smoother)
X    2 Dot (Inverted)
X    3 Ring (Black)
X    4 Ring (White)
X    5 Triangle (Right)
X    6 Triangle (Isosceles)
X    7 Grid
X    8 Diamond
X    9 Line
X   10 Microwaves
X   11 Ellipse
X   12 Rounded Box
X   13 Custom
X   14 Star
X   15 Random
X   16 Line (slightly different)
X~Format+
X~OnlineFF
X
XA note on device-resolution black and white printing\
X----------------------------------------------------\
X
XThis mode of printing can now be done much more quickly, and takes a
Xlot less file space. Just set EPSF=0 PRINTER=PSx/nnn COLORPS=NO
XRLEPS=YES TRANSLATE=m, where x is P or L for portrait/landscape, nnn is
Xyour printer's resolution, m is 2 or -2 for positive or negative
Xprinting respectively. This combination of parameters will print
Xexactly one printer pixel per each image pixel and it will keep the
Xproportions of the picture, if both your screen and printer have
Xsquare pixels (or the same pixel-aspect). Choose a proper (read large)
Xwindow size to fill as much of the paper as possible for the most
Xspectacular results.  2048 by 2048 is barely enough to fill the width
Xof a letter size page with 300 dpi printer resolution.  For higher
Xresolution printers, you will wish fractint supported larger window
Xsizes (hint, hint...). Bug reports and/or suggestions should be
Xforwarded to Yavuz Onder (post to sci.fractals, no e-mail yet).
X~OnlineFF
X
XA word from the author (Scott Taylor)\
X-------------------------------------\
X
XColor PostScript printing is new to me. I don't even have a color printer to
Xtest it on. (Don't want money. Want a Color PostScript printer!) The initial
Xtests seem to have worked. I am still testing and don't know whether or not
Xsome sort of gamma correction will be needed. I'll have to wait and see about
Xthat one.
X;
X;
X~Topic=PaintJet Parameters
XNote that the pixels printed by the PaintJet are square.
XThus, a printout of an image
Xcreated in a video mode with a 4:3 pixel ratio (such as 640x480 or
X800x600) will come out matching the screen; other modes (such as 320x200)
Xwill come out stretched.
X
XBlack and white images, or images using the 8 high resolution PaintJet
Xcolors, come out very nicely.  Some images using the full spectrum of
XPaintJet colors are very nice, some are disappointing.
X
XWhen 180 dots per inch is selected (in PRINTER= command), high resolution
X8 color printing is done.  When 90 dpi is selected, low resolution
Xprinting using the full 330 dithered color palette is done.  In both
Xcases, Fractint starts by finding the nearest color supported by the
XPaintJet for each color in your image.    The translation is then
Xdisplayed (unless the current display mode is disk video).  This display
X*should* be a fairly good match to what will be printed
X- it won't be perfect most of the time but should give some idea
Xof how the output will look.  At this point you can <Enter> to go ahead
Xand print, <Esc> to cancel, or <k> to cancel and keep the
Xadjusted colors.
X
XNote that you can use the color map PAINTJET.MAP to create images which
Xuse the 8 high resolution colors available on the PaintJet.  Also, two
Xhigh-resolution disk video modes are available for creating full page
Ximages.
X
XIf you find that the preview image seems very wrong (doesn't match what
Xactually gets printed) or think that Fractint could be doing a better job
Xof picking PaintJet colors to match your image's colors, you can try
Xplaying with the following parameter.  Fair warning: this is a very
Xtricky business and you may find it a very frustrating business trying to
Xget it right.
X
XHALFTONE=r/g/b\
X(The parameter name is not appropriate - we appropriated a PostScript
Xparameter for double duty here.)\
XThis separately sets the "gamma" adjustment for each of the red, green,
Xand blue color components.  Think of "gamma" as being
Xlike the contrast adjustment on your screen.  Higher gamma values for all
Xthree components results in colors with more contrast being produced
Xon the printer.  Since each color component can have its gamma separately
Xadjusted, you can change the resulting color mix subtly (or drastically!)\
XEach gamma value entered has one implied decimal digit.\
XThe default is "halftone=21/19/16", for red 2.1, green 1.9, and blue 1.6.
X(A note from Pieter Branderhorst: I wrote this stuff to come out reasonably
Xon my monitor/printer.    I'm a bit suspicious of the guns on my monitor;
Xif the colors seem ridiculously wrong on your system you might start by
Xtrying halftone=17/17/17.)
X;
X;
X~Topic=Plotter Parameters
X
XPlotters which understand HP-GL commands are supported. To use a plotter,
Xdraw a SMALL image (32x20 or 64x40) using the <v>iew screen options.  Put
Xa red pen in the first holder in the plotter, green in the second, blue in
Xthe third.  Now press <P> to start plotting.  Now get a cup of coffee...
Xor two... or three.  It'll take a while to plot.  Experiment with
Xdifferent resolutions, plot areas, plotstyles, and even change pens to
Xcreate weird-colored images.
X
XPLOTSTYLE=0|1|2\
X0: 3 parallel lines (red/green/blue) are drawn for each pixel, arranged
X  like "///".  Each bar is scaled according to the intensity of the
X  corresponding color in the pixel.  Using different pen colors (e.g.
X  blue, green, violet) can come out nicely.  The trick is to not tell
X  anyone what color the bars are supposed to represent and they will
X  accept these plotted colors because they do look nice...
X1: Same as 0, but the lines are also twisted.  This removes some of the
X  'order' of the image which is a nice effect.  It also leaves more
X  whitespace making the image much lighter, but colors such as yellow are
X  actually visible.
X2: Color lines are at the same angle and overlap each other.  This type
X  has the most whitespace.  Quality improves as you increase the number of
X  pixels squeezed into the same size on the plotter.
X;
X;
X~Topic=3D Parameters
X
XTo stay out of trouble, specify all the 3D parameters, even if you want to
Xuse what you think are the default values. It takes a little practice to
Xlearn what the default values really are. The best way to create a set of
Xparameters is to use the <B> command on an image you like and then use an
Xeditor to modify the resulting parameter file.
X
X3D=Yes\
X3D=Overlay\
XResets all 3d parameters to default values. If FILENAME= is given, forces
Xa restore to be performed in 3D mode (handy when used with 'batch=yes' for
Xbatch-mode 3D images). If specified, 3D=Yes should come before any other
X3d parameters on the command line or in a parameter file entry. The form
X3D=Overlay is identical except that the previous graphics screen is not
Xcleared, as with the <#> (<shift-3> on some keyboards) overlay command.
XUseful for building parameter files that use the 3D overlay feature.\
X
XThe options below override the 3D defaults:
X~Format-
XPREVIEW=yes           Turns on 3D 'preview' default mode
XSHOWBOX=yes           Turns on 3D 'showbox' default mode
XCOARSE=nn           Sets Preview 'coarseness' default value
XSPHERE=yes           Turns on spherical projection mode
XSTEREO=n           Selects the type of stereo image creation
XRAY=nnn            selects raytrace output file format
XBRIEF=yes           selects brief or verbose file for DKB output
X
XINTEROCULAR=nn           Sets the interocular distance for stereo
XCONVERGE=nn           Determines the overall image separation
XCROP=nn/nn/nn/nn       Trims the edges off stereo pairs
XBRIGHT=nn/nn           Compensates funny glasses filter parameters
XLONGITUDE=nn/nn        Longitude minimum and maximum
XLATITUDE=nn/nn           Latitude minimum and maximum
XRADIUS=nn           Radius scale factor
XROTATION=nn[/nn[/nn]]       Rotation about x,y, and z axes
XSCALEZYZ=nn/nn/nn       X,y,and z scale factors
XROUGHNESS=nn           Same as z scale factor
XWATERLINE=nn           Colors nn and below will be "inside" color
XFILLTYPE=nn           3D filltype
XPERSPECTIVE=nn           Perspective distance
XXYSHIFT=nn/nn           Shift image in x and y directions with
X                perspective
XLIGHTSOURCE=nn/nn/nn       Coordinates for light-source vector
XSMOOTHING=nn           Smooths images in light-source fill modes
XTRANSPARENT=min/max       Defines a range of colors to be treated as
X                "transparent" when <#>Overlaying 3D images.
XXYADJUST=nn/nn           This shifts the image in the x/y dir without
X                perspective
X~Format+
X
XBelow are new commands as of version 14 that support Marc Reinig's terrain
Xfeatures.
X
XRANDOMIZE=nnn (0 - 100)\
XThis feature randomly varies the color of a pixel to near by colors.
XUseful to minimize map banding in 3d transformations. Usable with all
XFILLTYPES. 0 disables, max values is 7. Try 3 - 5.
X
XAMBIENT=nnn (0 - 100)\
XSet the depth of the shadows when using full color and light source
Xfilltypes. "0" disables the function, higher values lower the contrast.
X
XFULLCOLOR=yes\
XValid with any light source FILLTYPE. Allows you to create a Targa-24 file
Xwhich uses the color of the image being transformed or the map you select
Xand shades it as you would see it in real life. Well, its better than B&W.
XA good map file to use is topo
X
XHAZE=nnn (0 - 100)\
XGives more realistic terrains by setting the amount of haze for distant
Xobjects when using full color in light source FILLTYPES. Works only in the
X"y" direction currently, so don't use it with much y rotation. Try
X"rotation=85/0/0". 0 disables.
X
XLIGHTNAME=<filename>\
XThe name of the Targa-24 file to be created when using full color with
Xlight source. Default is light001.tga. If overwrite=no (the default), the
Xfile name will be incremented until an unused filename is found.
XBackground in this file will be sky blue.
X;
X;
X;
X~Topic=Batch Mode
X
XIt IS possible, believe it or not, to become so jaded with the screen
Xdrawing process, so familiar with the types and options, that you just
Xwant to hit a key and do something else until the final images are safe on
Xdisk.  To do this, start Fractint with the BATCH=yes parameter.  To set up
Xa batch run with the parameters required for a particular image you might:
X  o Find an interesting area.  Note the parameters from the <Tab> display.
X    Then use an editor to write a batch file.
X  o Find an interesting area.  Set all the options you'll want in the
X    batch run.    Use the <B> command to store the parameters in a file.
X    Then use an editor to add the additional required batch mode
X    parameters (such as VIDEO=) to the generated parameter file entry.
X    Then run the batch using "fractint @myname.par/myentry" (if you told
X    the <B> command to use file "myname" and to name the entry "myentry").
X
XAnother approach to batch mode calculations, using "FILENAME=" and resume,
Xis described later.
X
XWhen modifying a parameter file entry generated by the <B> command, the
Xonly parameters you must add for a batch mode run are "BATCH=yes", and
X"VIDEO=xxx" to select a video mode.  You might want to also add
X"SAVENAME=[name]" to name the result as something other than the default
XFRACT001.GIF.  Or, you might find it easier to leave the generated
Xparameter file unchanged and add these parameters by using a command like:
X   fractint @myname.par/myentry batch=y video=AF3 savename=mygif
X
X"BATCH=yes" tells Fractint to run in batch mode -- that is, Fractint draws
Xthe image using whatever other parameters you specified, then acts as if
Xyou had hit <S> to save the image, then exits to DOS.
X
X"FILENAME=" can be used with "BATCH=yes" to resume calculation of an
Xincomplete image.  For instance, you might interactively find an image you
Xlike; then select some slow options (a high resolution disk video mode,
Xdistance estimator method, high maxiter, or whatever);    start the
Xcalculation;  then interrupt immediately with a <S>ave.  Rename the save
Xfile (fract001.gif if it is the first in the session and you didn't name
Xit with the <X> options or "savename=") to xxx.gif. Later you can run
XFractint in batch mode to finish the job:\
X    fractint batch=yes filename=xxx savename=xxx
X
X"SAVETIME=nnn" is useful with long batch calculations, to store a
Xcheckpoint every nnn minutes.  If you start a many hour calculation with
Xsay "savetime=60", and a power failure occurs during the calculation,
Xyou'll have lost at most an hour of work on the image.  You can resume
Xcalculation from the save file as above.  Automatic saves triggered by
XSAVETIME do not increment the save file name. The same file is overwritten
Xby each auto save until the image completes.  But note that Fractint does
Xnot directly over-write save files.  Instead, each save operation writes a
Xtemporary file FRACTINT.TMP, then deletes the prior save file, then
Xrenames FRACTINT.TMP to be the new save file.  This protects against power
Xfailures which occur during a save operation - if such a power failure
Xoccurs, the prior save file is intact and there's a harmless incomplete
XFRACTINT.TMP on your disk.
X
XIf you want to spread a many-hour image over multiple bits of free machine
Xtime you could use a command like:\
X    fractint batch=yes filename=xxx savename=xxx savetime=60 video=F3\
XWhile this batch is running, hit <S> (almost any key actually) to tell
Xfractint to save what it has done so far and give your machine back.  A status
Xcode of 2 is returned by fractint to the batch file.  Kick off the batch
Xagain when you have another time slice for it.
X
XWhile running a batch file, pressing any key will cause Fractint to exit
Xwith an errorlevel = 2.  Any error that interrupts an image save to disk
Xwill cause an exit with errorlevel = 2.  Any error that prevents an image
Xfrom being generated will cause an exit with errorlevel = 1.
X
XThe SAVETIME= parameter, and batch resumes of partial calculations, only
Xwork with fractal types which can be resumed.  See
X{"Interrupting and Resuming"} for information about non-resumable types.
X;
X;
X;
X~Topic=Video Adapter Notes
X
XTrue to the spirit of public-domain programming, Fractint makes only a
Xlimited attempt to verify that your video adapter can run in the mode you
Xspecify, or even that an adapter is present, before writing to it.
XSo if you use the "video=" command line parameter, check it before using
Xa new version of Fractint -
Xthe old key combo may now call an ultraviolet holographic mode.
X~Doc-
X
XComments about some particular video adapters:\
X    { EGA }      { Tweaked VGA }   { Super-VGA }\
X    { 8514/A }      { XGA }\
X    { Targa }      { Targa+ }\
X
XAlso see {Customized Video Modes\, FRACTINT.CFG}.
X~Doc+
X;
X;
X~Topic=EGA
X~Format-,Online-
XEGA
X~Format+,Online+
X
XFractint assumes that every EGA adapter has a full 256K of memory
X(and can therefore display 640 x 350 x 16 colors), but does nothing to
Xverify that fact before slinging pixels.
X;
X;
X~Topic=Tweaked VGA
X~Format-,Online-
X"TWEAKED" VGA MODES
X~Format+,Online+
X
XThe IBM VGA adapter is a highly programmable device, and can be set up to
Xdisplay many video-mode combinations beyond those "officially" supported
Xby the IBM BIOS. E.g. 320x400x256 and 360x480x256 (the latter is one of
Xour favorites).
XThese video modes are perfectly legal, but temporarily
Xreprogram the adapter (IBM or fully register-compatible) in a non-standard
Xmanner that the BIOS does not recognize.
X
XFractint also contains code that sets up the IBM (or any truly register-
Xcompatible) VGA adapter for several extended modes such as 704x528,
X736x552, 768x576, and 800x600. It does this by programming the VGA
Xcontroller to use the fastest dot-clock on the IBM adapter (28.322 MHz),
Xthrowing more pixels, and reducing the refresh rate to make up for it.
X
XThese modes push many monitors beyond their rated specs, in terms of both
Xresolution and refresh rate. Signs that your monitor is having problems
Xwith a particular "tweaked" mode include:
X o vertical or horizontal overscan (displaying dots beyond the edges of
X   your visible CRT area)
X o flickering (caused by a too-slow refresh rate)\
X o vertical roll or total garbage on the screen (your monitor simply
X   can't keep up, or is attempting to "force" the image into a pre-set
X   mode that doesn't fit).
X
XWe have successfully tested the modes up to 768x576 on an IBM PS/2 Model
X80 connected to IBM 8513, IBM 8514, NEC Multisync II, and Zenith 1490
Xmonitors (all of which exhibit some overscan and flicker at the highest
Xrates), and have tested 800x600 mode on the NEC Multisync II (although it
Xtook some twiddling of the vertical-size control).
X;
X;
X~Topic=Super-VGA
X~Format-,Online-
XSUPER-EGA AND SUPER-VGA MODES
X~Format+,Online+
X
XSince version 12.0, we've used both John Bridges' SuperVGA Autodetecting
Xlogic *and* VESA adapter detection, so that many brand-specific SuperVGA
Xmodes have been combined into single video mode selection entries.
XThere is now exactly one entry for SuperVGA 640x480x256 mode, for instance.
X
XIf Fractint's automatic SuperVGA/VESA detection logic guesses wrong,
Xand you know which SuperVGA chipset your video adapter uses, you can use
Xthe "adapter=" command-line option to force Fractint to assume the presence
Xof a specific SuperVGA Chipset - see {Video Parameters} for details.
X;
X;
X~Topic=8514/A
X~Format-,Online-
X8514/A MODES
X~Format+,Online+
X
XThe IBM 8514/A modes (640x480 and 1024x768) default to using the hardware
Xregisters.  If an error occurs when trying to open the adapter, an attempt
Xwill be made to use IBM's software interface, and requires the preloading
Xof IBM's HDILOAD TSR utility.
X
XThe Adex 1280x1024 modes were written for and tested on an Adex
XCorporation 8514/A using a Brooktree DAC.  The ATI GU 800x600x256 and
X1280x1024x16 modes require a ROM bios version of 1.3 or higher for 800x600
Xand 1.4 or higher for 1280x1024.
X
XThere are two sets of 8514/A modes: full sets (640x480, 800x600, 1024x768,
X1280x1024) which cover the entire screen and do NOT have a border color
X(so that you cannot tell when you are "paused" in a color-cycling mode),
Xand partial sets (632x474, 792x594, 1016x762, 1272x1018) with small border
Xareas which do turn white when you are paused in color-cycling mode. Also,
Xwhile these modes are declared to be 256-color, if you do not have your
X8514/A adapter loaded with its full complement of memory you will actually
Xbe in 16-color mode. The hardware register 16-color modes have not been
Xtested.
X
XIf your 8514/A adapter is not truly register compatible and Fractint does
Xnot detect this, use of the adapter interface can be forced by using afi=y
Xor afi=8514 in your SSTOOLS.INI file.
X
XFinally, because IBM's adapter interface does not handle drawing single
Xpixels very well (we have to draw a 1x1 pixel "box"), generating the zoom
Xbox when using the interface is excruciatingly slow. Still, it works!
X;
X;
X~Topic=XGA
X~Format-,Online-
XXGA MODES
X~Format+,Online+
X
XThe XGA adapter is supported using the VESA/SuperVGA Autodetect modes -
Xthe XGA looks like just another SuperVGA adapter to Fractint.
XThe supported XGA modes are 640x480x256, 1024x768x16, 1024x768x256,
X800x600x16, and 800x600x256.  Note that the 1024x768x256 mode requires
Xa full 1MB of adapter memory, the 1024x768 modes require a high-rez
Xmonitor, and the 800x600 modes require a multisynching monitor such
Xas the NEC 2A.
X;
X;
X~Topic=Targa
X~Format-,Online-
XTARGA MODES
X~Format+,Online+
X
XTARGA support for Fractint is provided courtesy of Joe McLain and has been
Xenhanced with the help of Bruce Goren and Richard Biddle.  To use a TARGA
Xboard with Fractint, you must define two DOS environment variables,
X"TARGA" and "TARGASET".  The definition of these variables is standardized
Xby Truevision; if you have a TARGA board you probably already have added
X"SET" statements for these variables to your AUTOEXEC.BAT file.
XBe aware that there are a LOT of possible TARGA configurations, and a LOT
Xof opportunities for a TARGA board and a VGA or EGA board to interfere
Xwith each other, and we may not have all of them smoothed away yet.  Also,
Xthe TARGA boards have an entirely different color-map scheme than the VGA
Xcards, and at the moment they cannot be run through the color-cycling
Xmenu. The "MAP=" argument (see {Color Parameters}),
Xhowever, works with both TARGA and
XVGA boards and enables you to redefine the default color maps with either
Xboard.
X;
X;
X~Topic=Targa+
X~Format-,Online-
XTARGA+ MODES
X~Format+,Online+
X
XTo use the special modes supported for TARGA+ adapters, the TARGAP.SYS
Xdevice driver has to be loaded, and the TPLUS.DAT file (included with
XFractint) must be in the same directory as Fractint.  The video modes with
Xnames containing "True Color Autodetect" can be used with the Targa+.  You
Xmight want to use the command line parameters "tplus=", "noninterlaced=",
X"maxcolorres=", and "pixelzoom=" (see {Video Parameters})
Xin your SSTOOLS.INI file to modify Fractint's use of the adapter.
X;
X;
X~Topic="Disk-Video" Modes
X
XThese "video modes" do not involve a video adapter at all. They use (in
Xorder or preference) your expanded memory, your extended memory, or your
Xdisk drive (as file FRACTINT.$$$) to store the fractal image. These modes
Xare useful for creating images beyond the capacity of your video adapter
Xright up to the current internal limit of 2048 x 2048 x 256,
Xe.g. for subsequent printing.
XThey're also useful for
Xbackground processing under multi-tasking DOS managers - create an image
Xin a disk-video mode, save it, then restore it in a real video mode.
X
XWhile you are using a disk-video mode, your screen will display text
Xinformation indicating whether memory or your disk drive is being used,
Xand what portion of the "screen" is being read from or written to.  A
X"Cache size" figure is also displayed. 64K is the maximum cache size.  If
Xyou see a number less than this, it means that you don't have a lot of
Xmemory free, and that performance will be less than optimum.  With a very
Xlow cache size such as 4 or 6k, performance gets considerably worse in
Xcases using solid guessing, boundary tracing, plasma, or anything else
Xwhich paints the screen non-linearly.  If you have this problem, all we
Xcan suggest is having fewer TSR utilities loaded before starting Fractint,
Xor changing in your config.sys file, such as reducing a very high BUFFERS
Xvalue.
X
XThe zoom box is disabled during disk-video modes (you couldn't see where
Xit is anyway).    So is the orbit display feature.
X
X{=@ColorCycling Color Cycling} can be used during disk-video modes,
Xbut only to load or save a color palette.
X
XWhen using real disk for your disk-video, Fractint will not generate some
X"attractor" types (e.g. lorenz) nor "IFS" images.  These would kill your
Xdisk drive.  Boundary tracing is allowed - it may give your drive a bit of
Xa workout, but is generally tolerable.
X
XWhen using a real disk, and you are not directing the file to a RAM disk,
Xand you aren't using a disk caching program on your machine, specifying
XBUFFERS=10 (or more) in your config.sys file is best for performance.
XBUFFERS=10,2 or even BUFFERS=10,4 is also good.  It is also best to keep
Xyour disk relatively "compressed" (or "defragmented") if you have a
Xutility to do this.
X
XIn order to use extended memory, you must have HIMEM.SYS or an equivalent
Xthat supports the XMS 2.0 standard or higher.  Also, you can't have a
XVDISK installed in extended memory.  Himem.sys is distributed with
XMicrosoft Windows 286/386 and 3.0.  If you have problems using the
Xextended memory, try rebooting with just himem.sys loaded and see if that
Xclears up the problem.
X
XIf you are running background disk-video fractals under Windows 3, and you
Xdon't have a lot of real memory (over 2Mb), you might find it best to
Xforce Fractint to use real disk for disk-video modes.  (Force this by
Xusing a .pif file with extended memory and expanded memory set to zero.)
XTry this if your disk goes crazy when generating background images, which
Xare supposedly using extended or expanded memory.  This problem can occur
Xbecause, to multi-task, sometimes Windows must page an application's
Xexpanded or extended memory to disk, in big chunks. Fractint's own cached
Xdisk access may be faster in such cases.
X;
X;
X;
X~Topic=Customized Video Modes\, FRACTINT.CFG
X
XIf you have a favorite adapter/video mode that you would like to add to
XFractint... if you want some new sizes of disk-video modes... if you want
Xto remove table entries that do not apply to your system... if you want to
Xspecify different "textsafe=" options for different video modes... relief
Xis here, and without even learning "C"!
X
XYou can do these things by modifying the FRACTINT.CFG file with your text
Xeditor. Saving a backup copy of FRACTINT.CFG first is of course highly
Xrecommended!
X
XFractint uses a video adapter table for most of what it needs to know
Xabout any particular adapter/mode combination. The table is loaded from
XFRACTINT.CFG each time Fractint is run. It can contain information for
Xup to 300 adapter/mode combinations. The table entries, and the function
Xkeys they are tied to, are displayed in the "select video mode" screen.
X
XThis table makes adding support for various third-party video cards and
Xtheir modes much easier, at least for the ones that pretend to be
Xstandard with extra dots and/or colors. There is even a special
X"roll-your-own" video mode (mode 19) enabling those of you with "C"
Xcompilers and a copy of the Fractint source to generate video modes
Xsupporting whatever adapter you may have.
X
XThe table as currently distributed begins with nine standard and several
Xnon-standard IBM video modes that have been exercised successfully with a
XPS/2 model 80. These entries, coupled with the descriptive comments in the
Xtable definition and the information supplied (or that should have been
Xsupplied!) with your video adapter, should be all you need to add your own
Xentries.
X
XAfter the IBM and quasi-pseudo-demi-IBM modes, the table contains an ever-
Xincreasing number of entries for other adapters. Almost all of these
Xentries have been added because someone like you sent us spec sheets, or
Xmodified Fractint to support them and then informed us about it.
X
XLines in FRACTINT.CFG which begin with a semi-colon are treated as comments.
XThe rest of the lines must have eleven fields separated by commas.
XThe fields are defined as:
X
X~Format-
X1. Key assignment. F2 to F10, SF1 to SF10, CF1 to CF10, or AF1 to AF10.
X   Blank if no key is assigned to the mode.
X2. The name of the adapter/video mode (25 chars max, no leading blanks).
X   The adapter is set up for that mode via INT 10H, with:
X3. AX = this,
X4. BX = this,
X5. CX = this, and
X6. DX = this (hey, having all these registers wasn't OUR idea!)
X7. An encoded value describing how to write to your video memory in that
X   mode. Currently available codes are:
X  1) Use the BIOS (INT 10H, AH=12/13, AL=color) (last resort - SLOW!)
X  2) Pretend it's a (perhaps super-res) EGA/VGA
X  3) Pretend it's an MCGA
X  4) SuperVGA 256-Color mode using the Tseng Labs chipset
X  5) SuperVGA 256-Color mode using the Paradise chipset
X  6) SuperVGA 256-Color mode using the Video-7 chipset
X  7) Non-Standard IBM VGA 360 x 480 x 256-Color mode
X  8) SuperVGA 1024x768x16 mode for the Everex chipset
X  9) TARGA video modes
X 10) HERCULES video mode
X 11) Non-Video, i.e. "disk-video"
X 12) 8514/A video modes
X 13) CGA 320x200x4-color and 640x200x2-color modes
X 14) Reserved for Tandy 1000 video modes
X 15) SuperVGA 256-Color mode using the Trident chipset
X 16) SuperVGA 256-Color mode using the Chips & Tech chipset
X 17) SuperVGA 256-Color mode using the ATI VGA Wonder chipset
X 18) SuperVGA 256-Color mode using the EVEREX chipset
X 19) Roll-your-own video mode (as you've defined it in YOURVID.C)
X 20) SuperVGA 1024x768x16 mode for the ATI VGA Wonder chipset
X 21) SuperVGA 1024x768x16 mode for the Tseng Labs chipset
X 22) SuperVGA 1024x768x16 mode for the Trident chipset
X 23) SuperVGA 1024x768x16 mode for the Video 7 chipset
X 24) SuperVGA 1024x768x16 mode for the Paradise chipset
X 25) SuperVGA 1024x768x16 mode for the Chips & Tech chipset
X 26) SuperVGA 1024x768x16 mode for the Everex Chipset
X 27) SuperVGA Auto-Detect mode (we poke around looking for your adapter)
X 28) VESA modes
X 29) True Color Auto-Detect (currently only Targa+ supported)
XAdd 100, 200, 300, or 400 to this code to specify an over-ride "textsafe="
X option to be used with the mode.  100=yes, 200=no, 300=bios, 400=save.
X E.g. 428 for a VESA mode with textsafe=save forced.
X8. The number of pixels across the screen (X - 160 to 2048)
X9. The number of pixels down the screen (Y - 160 to 2048)
X10. The number of available colors (2, 4, 16, or 256)
X11. A comment describing the mode (25 chars max, leading blanks are OK)
X~Format+
X
XNOTE that the AX, BX, CX, and DX fields use hexadecimal notation (fifteen
X==> 'f', sixteen ==> '10'), because that's the way most adapter
Xdocumentation describes it. The other fields use standard decimal
Xnotation.
X
XIf you look closely at the default entries, you will notice that the IBM
XVGA entries labeled "tweaked" and "non standard" have entries in the table
Xwith AX = BX = CX = 0, and DX = some other number. Those are special flags
Xthat we used to tell the program to custom-program the VGA adapter, and
Xare NOT undocumented BIOS calls. Maybe they should be, but they aren't.
X
XIf you have a fancy adapter and a new video mode that works on it, and it
Xis not currently supported, PLEASE GET THAT INFORMATION TO US!    We will
Xadd the video mode to the list on our next release, and give you credit
Xfor it. Which brings up another point: If you can confirm that a
Xparticular video adapter/mode works (or that it doesn't), and the program
Xsays it is UNTESTED, please get that information to us also.  Thanks in
Xadvance!
X;
X;
X;
SHAR_EOF
$TOUCH -am 1028230193 help4.src &&
chmod 0644 help4.src ||
echo "restore of help4.src failed"
set `wc -c help4.src`;Wc_c=$1
if test "$Wc_c" != "79101"; then
    echo original size 79101, current size $Wc_c
fi
# ============= help5.src ==============
echo "x - extracting help5.src (Text)"
sed 's/^X//' << 'SHAR_EOF' > help5.src &&
X~Topic=Common Problems
X
XOf course, Fractint would never stoop to having a "common" problem.  These
Xnotes describe some, ahem, "special situations" which come up occasionally
Xand which even we haven't the gall to label as "features".
X
XHang during startup:\
X  There might be a problem with Fractint's video detection logic and your
X  particular video adapter. Try running with "fractint adapter=xxx" where
X  xxx is cga, ega, egamono, mcga, or vga.  If "adapter=vga" works, and you
X  really have a SuperVGA adapter capable of higher video modes, there are
X  other "adapter=" options for a number of SuperVGA chipsets - please see
X  the full selection in {Video Parameters} for details.  If this solves the
X  problem, create an SSTOOLS.INI file with the "adapter=xxx" command in it
X  so that the fix will apply to every run.\
X  Another possible cause:  If you install the latest Fractint in say
X  directory "newfrac", then run it from another directory with the command
X  "\\newfrac\\fractint", *and* you have an older version of fractint.exe
X  somewhere in your DOS PATH, a silent hang is all you'll get.  See the
X  notes under the "Cannot find FRACTINT.EXE message" problem for the reason.\
X  Another possibility: try one of the "textsafe" parameter choices
X  described in {Video Parameters}.
X
XScrambled image when returning from a text mode display:\
X  If an image which has been partly or completely generated gets partly
X  destroyed when you return to it from the menu, help, or the information
X  display, please try the various "textsafe" parameter options - see
X  {Video Parameters} for details.  If this cures the problem, create
X  an SSTOOLS.INI file with the "textsafe=xxx" command so that the fix will
X  apply to every run.
X
X"Holes" in an image while it is being drawn:\
X  Little squares colored in your "inside" color, in a pattern of every
X  second square of that size, in solid guessing mode, both across and down
X  (i.e., 1 out of 4), are
X  a symptom of an image which should be calculated with more conservative
X  periodicity checking than the default.  See the Periodicity parameter
X  under {Image Calculation Parameters}.
X
XBlack bar at top of screen during color cycling on 8086/8088 machines:\
X  (This might happen intermittently, not every run.)\
X  "fractint cyclelimit=10" might cure the problem.  If so, increase
X  the cyclelimit value (try increasing by 5 or 10 each time) until the
X  problem reappears, then back off one step and add that cyclelimit value
X  to your SSTOOLS.INI file.
X
XOther video problems:
X
X  If you are using a VESA driver with your video adapter, the first thing
X  to try is the "vesadetect=no" parameter. If that fixes the problem, add
X  it to your SSTOOLS.INI file to make the fix permanent.
X
X  It may help to explicitly specify your type of adapter - see the
X  "adapter=" parameter in {Video Parameters}.
X
X  We've had one case where a video driver for Windows does not work
X  properly with Fractint.  If running under Windows, DesqView, or some
X  other layered environment, try running Fractint directly from DOS to see
X  if that avoids the problem.\
X  We've also had one case of a problem co-existing with "386 to the Max".
X
X  We've had one report of an EGA adapter which got scrambled images in
X  all modes until "textsafe=no" was used (see {Video Parameters}).
X
X  Also, see {Video Adapter Notes} for information
X  about enhanced video modes - Fractint makes only limited attempts to
X  verify that a video mode you request is actually supported by your
X  adapter.
X~OnlineFF
X
XOther Hangs and Strange Behavior:\
X  We've had some problems (hangs and solid beeps) on an FPU equipped
X  machine when running under Windows 3's enhanced mode.  The only ways
X  around the problem we can find are to either run the Fractint image
X  involved outside Windows, or to use the DOS command "SET NO87=nofpu"
X  before running Fractint.  (This SET command makes Fractint ignore your
X  fpu, so things might be a lot slower as a result.)
X
XInsufficient memory:\
X  Fractint requires a fair bit of memory to run.  Most machines with at
X  least 640k (ok sticklers, make that "PC-compatible machines") will have
X  no problem.  Machines with 512k and machines with many TSR utilities
X  and/or a LAN interface may have problems.  Some Fractint features
X  allocate memory when required during a run.  If you get a message about
X  insufficient memory, or suspect that some problem is due to a memory
X  shortage, you could try commenting out some TSR utilities in your
X  AUTOEXEC.BAT file, some non-critical drivers in your CONFIG.SYS file, or
X  reducing the BUFFERS parameter in your CONFIG.SYS.
X~OnlineFF
X
X"Cannot find FRACTINT.EXE" message:\
X  Fractint is an overlayed program - some parts of it are brought from
X  disk into memory only when used.  The overlay manager needs to know
X  where to find the program.  It must be named FRACTINT.EXE (which it is
X  unless somebody renamed it), and you should either be in the directory
X  containing it when you start Fractint, or that directory should be in
X  your DOS PATH.
X
X"File FRACTINT.CFG is missing or invalid" message:\
X  You should either start Fractint while you are in the directory
X  containing it, or should have that directory in your DOS PATH variable.
X  If that isn't the problem, maybe you have a FRACTINT.CFG file from an
X  older release of Fractint lying around? If so, best rename or delete it.
X  If that isn't the problem either, then the FRACTINT.CFG included in the
X  FRAINT.EXE release file has probably been changed or deleted. Best
X  reinstall Fractint to get a fresh copy.
X~OnlineFF
X
XSome other program doesn't like GIF files created by Fractint:\
X  Fractint generates nice clean GIF89A spec files, honest! But telling
X  this to the other program isn't likely to change its mind. Instead, try
X  an option which might get around the problem: run Fractint with the
X  command line option "gif87a=yes" and then save an image. Fractint will
X  store the image in the older GIF87A format, without any fractal
X  parameters in it (so you won't be able to load the image back into
X  Fractint and zoom into it - the fractal type, coordinates, etc. are not
X  stored in this older format), and without an "aspect ratio" in the GIF
X  header (we've seen one utility which doesn't like that field.)
X
XDisk video mode performance:\
X  This won't be blindingly fast at the best of times, but there are things
X  which can slow it down and can be tuned.  See {"Disk-Video" Modes}
X  for details.
X;
X;
X;
X~Topic=Fractals and the PC
X;
X; empty for document, present just so we can reference the subject
X
X~Format-,Doc-
X
X    A Little History:
X       { Before Mandelbrot }
X       { Who Is This Guy, Anyway? }
X
X    A Little Code:
X       { Periodicity Logic }
X       { Limitations of Integer Math (And How We Cope) }
X       { The Fractint "Fractal Engine" Architecture }
X
X    A Little Math:
X       { Summary of Fractal Types }
X       { Inside=bof60|bof61|zmag|period }
X       { Inside=epscross|startrail }
X       { Finite Attractors }
X       { Trig Identities }
X~Format+,Doc+
X;
X;
X~Topic=Before Mandelbrot
X
XLike new forms of life, new branches of mathematics and science don't
Xappear from nowhere. The ideas of fractal geometry can be traced to the
Xlate nineteenth century, when mathematicians created shapes -- sets of
Xpoints -- that seemed to have no counterpart in nature.  By a wonderful
Xirony, the "abstract" mathematics descended from that work has now turned
Xout to be MORE appropriate than any other for describing many natural
Xshapes and processes.
X
XPerhaps we shouldn't be surprised.  The Greek geometers worked out the
Xmathematics of the conic sections for its formal beauty; it was two
Xthousand years before Copernicus and Brahe, Kepler and Newton overcame the
Xpreconception that all heavenly motions must be circular, and found the
Xellipse, parabola, and hyperbola in the paths of planets, comets, and
Xprojectiles.
X
XIn the 17th century Newton and Leibniz created calculus, with its
Xtechniques for "differentiating" or finding the derivative of functions --
Xin geometric terms, finding the tangent of a curve at any given point.
XTrue, some functions were discontinuous, with no tangent at a gap or an
Xisolated point. Some had singularities: abrupt changes in direction at
Xwhich the idea of a tangent becomes meaningless. But these were seen as
Xexceptional, and attention was focused on the "well-behaved" functions
Xthat worked well in modeling nature.
X
XBeginning in the early 1870s, though, a 50-year crisis transformed
Xmathematical thinking. Weierstrass described a function that was
Xcontinuous but nondifferentiable -- no tangent could be described at any
Xpoint. Cantor showed how a simple, repeated procedure could turn a line
Xinto a dust of scattered points, and Peano generated a convoluted curve
Xthat eventually touches every point on a plane. These shapes seemed to
Xfall "between" the usual categories of one-dimensional lines, two-
Xdimensional planes and three-dimensional volumes. Most still saw them as
X"pathological" cases, but here and there they began to find applications.
X
XIn other areas of mathematics, too, strange shapes began to crop up.
XPoincare attempted to analyze the stability of the solar system in the
X1880s and found that the many-body dynamical problem resisted traditional
Xmethods. Instead, he developed a qualitative approach, a "state space" in
Xwhich each point represented a different planetary orbit, and studied what
Xwe would now call the topology -- the "connectedness" -- of whole families
Xof orbits. This approach revealed that while many initial motions quickly
Xsettled into the familiar curves, there were also strange, "chaotic"
Xorbits that never became periodic and predictable.
X
XOther investigators trying to understand fluctuating, "noisy" phenomena --
Xthe flooding of the Nile, price series in economics, the jiggling of
Xmolecules in Brownian motion in fluids -- found that traditional models
Xcould not match the data. They had to introduce apparently arbitrary
Xscaling features, with spikes in the data becoming rarer as they grew
Xlarger, but never disappearing entirely.
X
XFor many years these developments seemed unrelated, but there were
Xtantalizing hints of a common thread. Like the pure mathematicians' curves
Xand the chaotic orbital motions, the graphs of irregular time series often
Xhad the property of self-similarity: a magnified small section looked very
Xsimilar to a large one over a wide range of scales.
X;
X;
X~Topic=Who Is This Guy\, Anyway?
X
XWhile many pure and applied mathematicians advanced these trends, it is
XBenoit Mandelbrot above all who saw what they had in common and pulled the
Xthreads together into the new discipline.
X
XHe was born in Warsaw in 1924, and moved to France in 1935. In a time when
XFrench mathematical training was strongly analytic, he visualized problems
Xwhenever possible, so that he could attack them in geometric terms.  He
Xattended the Ecole Polytechnique, then Caltech, where he encountered the
Xtangled motions of fluid turbulence.
X
XIn 1958 he joined IBM, where he began a mathematical analysis of
Xelectronic "noise" -- and began to perceive a structure in it, a hierarchy
Xof fluctuations of all sizes, that could not be explained by existing
Xstatistical methods. Through the years that followed, one seemingly
Xunrelated problem after another was drawn into the growing body of ideas
Xhe would come to call fractal geometry.
X
XAs computers gained more graphic capabilities, the skills of his mind's
Xeye were reinforced by visualization on display screens and plotters.
XAgain and again, fractal models produced results -- series of flood
Xheights, or cotton prices -- that experts said looked like "the real
Xthing."
X
XVisualization was extended to the physical world as well. In a provocative
Xessay titled "How Long Is the Coast of Britain?" Mandelbrot noted that the
Xanswer depends on the scale at which one measures: it grows longer and
Xlonger as one takes into account every bay and inlet, every stone, every
Xgrain of sand. And he codified the "self-similarity" characteristic of
Xmany fractal shapes -- the reappearance of geometrically similar features
Xat all scales.
X
XFirst in isolated papers and lectures, then in two editions of his seminal
Xbook, he argued that many of science's traditional mathematical models are
Xill-suited to natural forms and processes: in fact, that many of the
X"pathological" shapes mathematicians had discovered generations before are
Xuseful approximations of tree bark and lung tissue, clouds and galaxies.
X
XMandelbrot was named an IBM Fellow in 1974, and continues to work at the
XIBM Watson Research Center. He has also been a visiting professor and
Xguest lecturer at many universities.
X;
X;
X~Topic=Periodicity Logic
X
XThe "Mandelbrot Lake" in the center of the M-set images is the traditional
Xbane of plotting programs. It sucks up the most computer time because it
Xalways reaches the iteration limit -- and yet the most interesting areas
Xare invariably right at the edge the lake.
X(See {The Mandelbrot Set} for a description of the iteration process.)
X
XThanks to Mark Peterson for pointing out (well, he more like beat us over
Xthe head until we paid attention) that the iteration values in the middle
Xof Mandelbrot Lake tend to decay to periodic loops (i.e., Z(n+m) == Z(n),
Xa fact that is pointed out on pages 58-61 of "The Beauty of Fractals"). An
Xintelligent program (like the one he wrote) would check for this
Xperiodicity once in a while, recognize that iterations caught in a loop
Xare going to max out, and bail out early.
X
XFor speed purposes, the current version of the program turns this checking
Xalgorithm on only if the last pixel generated was in the lake.    (The
Xchecking itself takes a small amount of time, and the pixels on the very
Xedge of the lake tend to decay to periodic loops very slowly, so this
Xcompromise turned out to be the fastest generic answer).
X
XTry a full M-set plot with a 1000-iteration maximum with any other
Xprogram, and then try it on this one for a pretty dramatic proof of the
Xvalue of periodicity checking.
X
XYou can get a visual display of the periodicity effects if you press
X<O>rbits while plotting. This toggles display of the intermediate
Xiterations during the generation process.  It also gives you an idea of
Xhow much work your poor little PC is going through for you!  If you use
Xthis toggle, it's best to disable solid-guessing first using <1> or <2>
Xbecause in its second pass, solid-guessing bypasses many of the pixel
Xcalculations precisely where the orbits are most interesting.
X
XMark was also responsible for pointing out that 16-bit integer math was
Xgood enough for the first few levels of M/J images, where the round-off
Xerrors stay well within the area covered by a single pixel. Fractint now
Xuses 16-bit math where applicable, which makes a big difference on non-32-
Xbit PCs.
X;
X;
X~Topic=Limitations of Integer Math (And How We Cope)
X
XBy default, Fractint uses 16-bit and/or 32-bit integer math to generate
Xnearly all its fractal types. The advantage of integer math is speed: this
Xis by far the fastest such plotter that we have ever seen on any PC. The
Xdisadvantage is an accuracy limit. Integer math represents numbers like
X1.00 as 32-bit integers of the form [1.00 * (2^29)] (approximately
Xa range of 500,000,000) for the Mandelbrot and Julia sets. Other integer
Xfractal types use a bitshift of 24 rather than 29, so 1.0 is stored
Xinternally as [1.00 * (2^*24)]. This yields accuracy of better than 8
Xsignificant digits, and works fine... until the initial values of the
Xcalculations on consecutive pixels differ only in the ninth decimal place.
X
XAt that point, if Fractint has a floating-point algorithm handy for that
Xparticular fractal type (and virtually all of the fractal types have one
Xthese days), it will silently switch over to the floating-point algorithm
Xand keep right on going.  Fair warning - if you don't have an FPU, the
Xeffect is that of a rocket sled hitting a wall of jello, and even if you
Xdo, the slowdown is noticeable.
X
XIf it has no floating-point algorithm, Fractint does the best it can: it
Xswitches to its minimal drawing mode, with adjacent pixels having initial
Xvalues differing by 1 (really 0.000000002).  Attempts to zoom further may
Xresult in moving the image around a bit, but won't actually zoom.  If you
Xare stuck with an integer algorithm, you can reach minimal mode with your
Xfifth consecutive "maximum zoom", each of which covers about 0.25% of the
Xprevious screen. By then your full-screen image is an area less than
X1/(10^13)th [\~0.0000000000001] the area of the initial screen.  (If your
Ximage is rotated or stretched very slightly, you can run into the wall of
Xjello as early as the fourth consecutive maximum zoom.    Rotating or
Xstretching by larger amounts has less impact on how soon you run into it.)
X
XThink of it this way: at minimal drawing mode, your VGA display would have
Xto have a surface area of over one million square miles just to be able to
Xdisplay the entire M-set using the integer algorithms.    Using the
Xfloating-point algorithms, your display would have to be big enough to fit
Xthe entire solar system out to the orbit of Saturn inside it.  So there's
Xa considerable saving on hardware, electricity and desk space involved
Xhere.  Also, you don't have to take out asteroid insurance.
X
X32 bit integers also limit the largest number which can be stored.  This
Xdoesn't matter much since numbers outside the supported range (which is
Xbetween -4 and +4) produce a boring single color. If you try to zoom-out
Xto reduce the entire Mandelbrot set to a speck, or to squeeze
Xit to a pancake, you'll find you can't do so in integer math mode.
X;
X;
X~Topic=The Fractint "Fractal Engine" Architecture
X
XSeveral of the authors would never ADMIT this, but Fractint has evolved a
Xpowerful and flexible architecture that makes adding new fractals very
Xeasy. (They would never admit this because they pride themselves on being
Xthe sort that mindlessly but happily hacks away at code and "sees if it
Xworks and doesn't hang the machine".)
X
XMany fractal calculations work by taking a rectangle in the complex plane,
Xand, point by point, calculating a color corresponding to that point.
XFurthermore, the color calculation is often done by iterating a function
Xover and over until some bailout condition is met.
X(See {The Mandelbrot Set} for a description of the iteration process.)
X
XIn implementing such a scheme, there are three fractal-specific
Xcalculations that take place within a framework that is pretty much the
Xsame for them all.  Rather than copy the same code over and over, we
Xcreated a standard fractal engine that calls three functions that may be
Xbolted in temporarily to the engine.  The "bolting in" process uses the C
Xlanguage mechanism of variable function pointers.
X
XThese three functions are:
X
X   1) a setup function that is run once per image, to do any required
X   initialization of variables,
X
X   2) a once-per-pixel function that does whatever initialization has to
X   be done to calculate a color for one pixel, and
X
X   3) a once-per-orbit-iteration function, which is the fundamental
X   fractal algorithm that is repeatedly iterated in the fractal
X   calculation.
X
XThe common framework that calls these functions can contain all sorts of
Xspeedups, tricks, and options that the fractal implementor need not worry
Xabout.    All that is necessary is to write the three functions in the
Xcorrect way, and BINGO! - all options automatically apply. What makes it
Xeven easier is that usually one can re-use functions 1) and 2) written for
Xother fractals, and therefore only need to write function 3).
X
XThen it occurred to us that there might be more than one sort of fractal
Xengine, so we even allowed THAT to be bolted in. And we created a data
Xstructure for each fractal that includes pointers to these four functions,
Xvarious prompts, a default region of the complex plane, and various
Xmiscellaneous bits of information that allow toggling between Julia and
XMandelbrot or toggling between the various kinds of math used in
Ximplementation.
X
XThat sounds pretty flexible, but there is one drawback - you have to be a
XC programmer and have a C compiler to make use of it! So we took it a step
Xfurther, and designed a built-in high level compiler, so that you can
Xenter the formulas for the various functions in a formula file in a
Xstraightforward algebra-like language, and Fractint will compile them and
Xbolt them in for you!
X
XThere is a terrible down side to this flexibility.  Fractint users
Xeverywhere are going berserk. Fractal-inventing creativity is running
Xrampant. Proposals for new fractal types are clogging the mail and the
Xtelephones.
X
XAll we can say is that non-productivity software has never been so potent,
Xand we're sorry, it's our fault!
X
XFractint was compiled using Microsoft C 6.00A and Microsoft Assembler 5.1,
Xusing the "Medium" model. Note that the assembler code uses the "C" model
Xoption added to version 5.1, and must be assembled with the /MX or /ML
Xswitch to link with the "C" code. Because it has become too large to
Xdistribute comfortably as a single compressed file, and because many
Xdownloaders have no intention of ever modifying it, Fractint is now
Xdistributed as two files: one containing FRACTINT.EXE, auxiliary files and
Xthis document, and another containing complete source code (including a
X.MAK file and MAKEFRAC.BAT).  See {Distribution of Fractint}.
X;
X;
X;
X~Topic=Inside=bof60|bof61|zmag|period
X~Format-,Online-
X
XINSIDE=BOF60|BOF61|ZMAG|PERIOD
X~Format+,Online+
X
XHere is an *ATTEMPTED* explanation of what the inside=bof60 and
Xinside=bof61 options do. This explanation is hereby dedicated to Adrian
XMariano, who badgered it out of us! For the *REAL* explanation, see
X"Beauty of Fractals", page 62.
X
XLet p(z) be the function that is repeatedly iterated to generate a fractal
Xusing the escape-time algorithm.  For example, p(z) = z^2+c in the case of
Xa Julia set. Then let pk(z) be the result of iterating the function p for
Xk iterations. (The "k" should be shown as a superscript.) We could also
Xuse the notation pkc(z) when the function p has a parameter c, as it does
Xin our example.  Now hold your breath and get your thinking cap on. Define
Xa(c) = inf\{|pck(0)|:k=1,2,3,...}. In English - a(c) is the greatest lower
Xbound of the images of zero of as many iterations as you like. Put another
Xway, a(c) is the closest to the origin any point in the orbit starting
Xwith 0 gets. Then the index (c) is the value of k (the iteration) when
Xthat closest point was achieved.  Since there may be more than one,
Xindex(c) is the least such. Got it?  Good, because the "Beauty of
XFractals" explanation of this, is, ahhhh, *TERSE* ! Now for the punch
Xline. Inside=bof60 colors the lake alternating shades according to the
Xlevel sets of a(c).  Each band represents solid areas of the fractal where
Xthe closest value of the orbit to the origin is the same.  Inside=bof61
Xshow domains where index(c) is constant.  That is, areas where the
Xiteration when the orbit swooped closest to the origin has the same value.
XWell, folks, that's the best we can do! Improved explanations will be
Xaccepted for the next edition!
X
Xinside=zmag is similar. This option colors inside pixels according to
Xthe magnitude of the orbit point when maxiter was reached, using the formula
Xcolor = (x^2 + y^2) * maxiter/2 + 1.
X
Xinside=period colors pixels according to the length of their eventual cycle.
XFor example, points that approach a fixed point have color=1.  Points that
Xapproach a 2-cycle have color=2.  Points that do not approach a cycle during
Xthe iterations performed have color=maxit.  This option works best with a
Xfairly large number of iterations.
X;
X;
X;
X~Topic=Inside=epscross|startrail
X~Format-,Online-
X
XINSIDE=EPSCROSS|STARTRAIL
X~Format+,Online+
X
XKenneth Hooper has written a paper entitled "A Note On Some Internal
XStructures Of The Mandelbrot Set" published in "Computers and Graphics", Vol
X15, No.2, pp. 295-297.    In that article he describes Clifford Pickover's
X"epsilon cross" method which creates some mysterious plant-like tendrils in
Xthe Mandelbrot set. The algorithm is this. In the escape-time calculation of a
Xfractal, if the orbit comes within .01 of the Y-axis, the orbit is terminated
Xand the pixel is colored green. Similarly, the pixel is colored yellow if it
Xapproaches the X-axis. Strictly speaking, this is not an "inside" option
Xbecause a point destined to escape could be caught by this bailout criterion.
X
XHooper has another coloring scheme called "star trails" that involves
Xdetecting clusters of points being traversed by the orbit. A table of tangents
Xof each orbit point is built, and the pixel colored according to how many
Xorbit points are near the first one before the orbit flies out of the cluster.
XThis option looks fine with maxiter=16, which greatly speeds the calculation.
X
XBoth of these options should be tried with the outside color fixed
X(outside=<nnn>) so that the "lake" structure revealed by the algorithms can be
Xmore clearly seen. Epsilon Cross is fun to watch with boundary tracing turned
Xon - even though the result is incorrect it is interesting! Shucks - what
Xdoes "incorrect" mean in chaos theory anyway?!
X;
X;
X;
X~Topic=Finite Attractors
X~Format-,Online-
X
XFINITE ATTRACTORS
X~Format+,Online+
X
XMany of Fractint's fractals involve the iteration of functions of complex
Xnumbers until some "bailout" value is exceeded, then coloring the
Xassociated pixel according to the number of iterations performed.  This
Xprocess identifies which values tend to infinity when iterated, and gives
Xus a rough measure of how "quickly" they get there.
X
XIn dynamical terms, we say that "Infinity is an Attractor", as many
Xinitial values get "attracted" to it when iterated.  The set of all points
Xthat are attracted to infinity is termed The Basin of Attraction of
XInfinity.  The coloring algorithm used divides this Basin of Attraction
Xinto many distinct sets, each a single band of one color, representing all
Xthe points that are "attracted" to Infinity at the same "rate".  These
Xsets (bands of color) are termed "Level Sets" - all points in such a set
Xare at the same "Level" away from the attractor, in terms of numbers of
Xiterations required to exceed the bailout value.
X
XThus, Fractint produces colored images of the Level Sets of the Basin of
XAttraction of Infinity, for all fractals that iterate functions of Complex
Xnumbers, at least.  Now we have a sound mathematical definition of what
XFractint's "bailout" processing generates, and we have formally introduced
Xthe terms Attractor, Basin of Attraction, and Level Set, so you should
Xhave little trouble following the rest of this section!
X
XFor certain Julia-type fractals, Fractint can also display the Level Sets
Xof Basins of Attraction of Finite Attractors.  This capability is a by-
Xproduct of the implementation of the MAGNETic fractal types, which always
Xhave at least one Finite Attractor.
X
XThis option can be invoked by setting the "Look for finite attractor"
Xoption on the <Y> options screen, or by giving the "finattract=yes"
Xcommand-line option.
X
XMost Julia-types that have a "lake" (normally colored blue by default)
Xhave a Finite Attractor within this lake, and the lake turns out to be,
Xquite appropriately, the Basin of Attraction of this Attractor.
X
XThe "finattract=yes" option (command-line or <Y> options screen)
Xinstructs Fractint to seek out and identify a possible Finite Attractor
Xand, if found, to display the Level Sets of its Basin of Attraction, in
Xaddition to those of the Basin of Attraction of Infinity.  In many cases
Xthis results in a "lake" with colored "waves" in it;  in other cases there
Xmay be little change in the lake's appearance.
X
XFor a quick demonstration, select a fractal type of LAMBDA, with a
Xparameter of 0.5 + 0.5i.  You will obtain an image with a large blue lake.
XNow set "Look for finite attractor" to 1 with the "Y" menu.
XThe image will be re-drawn
Xwith a much more colorful lake.  A Finite Attractor lives in the center of
Xone of the resulting "ripple" patterns in the lake - turn the <O>rbits
Xdisplay on to see where it is - the orbits of all initial points that are
Xin the lake converge there.
X
XFractint tests for the presence of a Finite Attractor by iterating a
XCritical Value of the fractal's function.  If the iteration doesn't bail
Xout before exceeding twice the iteration limit, it is almost certain that
Xwe have a Finite Attractor - we assume that we have.
X
XNext we define a small circle around it and, after each iteration, as well
Xas testing for the usual bailout value being exceeded, we test to see if
Xwe've hit the circle. If so, we bail out and color our pixels according to
Xthe number of iterations performed.  Result - a nicely colored-in lake
Xthat displays the Level Sets of the Basin of Attraction of the Finite
XAttractor.  Sometimes !
X
XFirst exception: This does not work for the lakes of Mandel-types.  Every
Xpoint in a Mandel-type is, in effect, a single point plucked from one of
Xits related Julia-types.  A Mandel-type's lake has an infinite number of
Xpoints, and thus an infinite number of related Julia-type sets, and
Xconsequently an infinite number of finite attractors too.  It *MAY* be
Xpossible to color in such a lake, by determining the attractor for EVERY
Xpixel, but this would probably treble (at least) the number of iterations
Xneeded to draw the image.  Due to this overhead, Finite Attractor logic
Xhas not been implemented for Mandel-types.
X
XSecondly, certain Julia-types with lakes may not respond to this
Xtreatment, depending on the parameter value used.  E.g., the Lambda Set
Xfor 0.5 + 0.5i responds well; the Lambda Set for 0.0 + 1.0i does not - its
Xlake stays blue.  Attractors that consist of single points, or a cycle of
Xa finite number of points are ok.  Others are not.  If you're into fractal
Xtechnospeke, the implemented approach fails if the Julia-type is a
XParabolic case, or has Siegel Disks, or has Herman Rings.
X
XHowever, all the difficult cases have one thing in common - they all have
Xa parameter value that falls exactly on the edge of the related Mandel-
Xtype's lake.  You can avoid them by intelligent use of the Mandel-Julia
XSpace-Bar toggle:  Pick a view of the related Mandel-type where the center
Xof the screen is inside the lake, but not too close to its edge, then use
Xthe space-bar toggle.  You should obtain a usable Julia-type with a lake,
Xif you follow this guideline.
X
XThirdly, the initial implementation only works for Julia-types that use
Xthe "Standard" fractal engine in Fractint.  Fractals with their own
Xspecial algorithms are not affected by Finite Attractor logic, as yet.
X
XFinally, the finite attractor code will not work if it fails to detect
Xa finite attractor.  If the number of iterations is set too low, the finite
Xattractor may be missed.
X
XDespite these restrictions, the Finite Attractor logic can produce
Xinteresting results.  Just bear in mind that it is principally a bonus
Xoff-shoot from the development of the MAGNETic fractal types, and is not
Xspecifically tuned for optimal performance for other Julia types.
X
X(Thanks to Kevin Allen for the above).
X
XThere is a second type of finite attractor coloring, which is selected
Xby setting "Look for Finite Attractor" to a negative value.  This colors
Xpoints by the phase of the convergence to the finite attractor,
Xinstead of by the speed of convergence.
X
XFor example, consider the Julia set for -0.1 + 0.7i, which is the three-lobed
X"rabbit" set.  The Finite Attractor is an orbit of length three; call these
Xvalues a, b, and c.  Then, the Julia set iteration can converge to one of
Xthree sequences: a,b,c,a,b,c,..., or b,c,a,b,c,..., or c,a,b,c,a,b,...
XThe Finite Attractor phase option colors the interior of the Julia set with
Xthree colors, depending on which of the three sequences the orbit converges
Xto.  Internally, the code determines one point of the orbit, say "a", and
Xthe length of the orbit cycle, say 3.  It then iterates until the sequence
Xconverges to a, and then uses the iteration number modulo 3 to determine the
Xcolor.
X
X;
X;
X~Topic=Trig Identities
X~Online-
X
XTRIG IDENTITIES
X~Online+
X
XThe following trig identities are invaluable for coding fractals that use
Xcomplex-valued transcendental functions.
X
X~Format-
X   e^(x+iy) = (e^x)cos(y) + i(e^x)sin(y)
X
X   sin(x+iy)  = sin(x)cosh(y) + icos(x)sinh(y)
X   cos(x+iy)  = cos(x)cosh(y) - isin(x)sinh(y)
X   sinh(x+iy) = sinh(x)cos(y) + icosh(x)sin(y)
X   cosh(x+iy) = cosh(x)cos(y) + isinh(x)sin(y)
X
X   cosxx(x+iy) = cos(x)cosh(y) + isin(x)sinh(y)
X     (cosxx is present in Fractint to provide compatibility with a bug
X     which was in its cos calculation before version 16)
X
X   ln(x+iy) = (1/2)ln(x*x + y*y) + i(arctan(y/x) + 2kPi)
X                    (k = 0, +-1, +-2, +-....)
X
X             sin(2x)           sinh(2y)
X   tan(x+iy) = ------------------  + i------------------
X           cos(2x) + cosh(2y)     cos(2x) + cosh(2y)
X~OnlineFF
X
X            sinh(2x)            sin(2y)
X   tanh(x+iy) = ------------------ + i------------------
X        cosh(2x) + cos(2y)    cosh(2x) + cos(2y)
X
X         sin(2x) - i*sinh(2y)
X   cotan(x+iy) = --------------------
X          cosh(2y) - cos(2x)
X
X          sinh(2x) - i*sin(2y)
X   cotanh(x+iy) = --------------------
X           cosh(2x) - cos(2y)
X
X   z^z = e^(log(z)*z)
X
X   log(x+iy) = 1/2(log(x*x + y*y) + i(arc_tan(y/x))
X
X   e^(x+iy) = (cosh(x) + sinh(x)) * (cos(y) + isin(y))
X        = e^x * (cos(y) + isin(y))
X        = (e^x * cos(y)) + i(e^x * sin(y))
X~Format+
X;
X;
X;
X~Topic=GIF Save File Format
X
XSince version 5.0, Fractint has had the <S>ave-to-disk command, which
Xstores screen images in the extremely compact, flexible .GIF (Graphics
XInterchange Format) widely supported on Compuserve. Version 7.0 added the
X<R>estore-from-disk capability.
X
XUntil version 14, Fractint saved images as .FRA files, which were a
Xnon-standard extension of the then-current GIF87a specification.  The
Xreason was that GIF87a did not offer a place to store the extra
Xinformation needed by Fractint to implement the
X<R> feature -- i.e., the parameters that let you keep zooming, etc.
Xas if the restored file had just been created in this session.
XThe .FRA format worked with all of the popular GIF decoders that we
Xtested, but these were not true GIF files. For one thing,
Xinformation after the GIF terminator (which is where we put the extra info)
Xhas the potential to confuse the
Xonline GIF viewers used on Compuserve. For another, it is the opinion of
Xsome GIF developers that the addition of this extra information violates
Xthe GIF87a spec. That's why we used the default filetype .FRA instead.
X
XSince version 14, Fractint has used a genuine .GIF format, using the
XGIF89a spec - an upwardly compatible extension of GIF87a, released by
XCompuserve on August 1 1990.
XThis new spec allows the
Xplacement of application data within "extension blocks".
XIn version 14 we changed our default savename extension from .FRA
Xto .GIF.
X
XThere is one significant advantage to the new GIF89a format compared to
Xthe old GIF87a-based .FRA format for Fractint purposes:  the new .GIF
Xfiles may be uploaded to the Compuserve graphics forums (such as
XFractint's home forum, GRAPHDEV) with fractal information intact.  Therefore
Xanyone downloading a Fractint image from Compuserve will also be
Xdownloading all the information needed to regenerate the image.
X
XFractint can still read .FRA files generated by
Xearlier versions.  If for some reason you wish to save files in the older
XGIF87a format, for example because your favorite GIF decoder has not yet
Xbeen upgraded to GIF89a, use the command-line parameter "GIF87a=yes".
XThen any saved files will use the original GIF87a format without any
Xapplication-specific information.
X
XAn easy way to convert an older .FRA file into true .GIF format suitable
Xfor uploading is something like this at the DOS prompt:\
X    FRACTINT MYFILE.FRA SAVENAME=MYFILE.GIF BATCH=YES\
XFractint will load MYFILE.FRA, save it in true .GIF format as MYFILE.GIF,
Xand return to DOS.
X
XGIF and "Graphics Interchange Format" are trademarks of Compuserve
XIncorporated, an H&R Block Company.
X;
X;
X;
X~Topic=Using Fractint With a Mouse
X; This topic is online only.
X
X~FormatExclude-
XLeft Button:   Brings up and sizes the Zoom Box.   While holding down the
X           left button, push the mouse forward to shrink the Zoom Box,
X           and pull it back to expand it.
X           Double-clicking the left button performs the Zoom.
X
XRight Button:  While holding the right button held down, move the mouse
X           from side to side to 'rotate' the Zoom Box.  Move the mouse
X           forward or back to change the Zoom Box color.
X           Double-clicking the right button performs a 'Zoom-Out'.
X
XBoth Buttons:  (or the middle button, if you have three of them) While
X           holding down both buttons, move the mouse up and down to
X           stretch/shrink the height of the Zoom Box, or side to side
X           to 'squish' the Zoom Box into a non-rectangular shape.
X
XZoom and Pan using the mouse typically consists of pushing in the left
Xbutton, sizing the zoom box, letting go of the button, panning to the
Xgeneral area, then double-clicking the left button to perform the Zoom.
X;
X;
X;
X~Topic=Selecting a video mode when loading a file, Label=HELPLOADFILE
X; This topic is only online, context-sensitive.
X~Format-
X
XThe most suitable video modes for the file are listed first.
X
XThe 'err' column in the video mode information indicates:
X  blank  mode seems perfect for this image
X  v     image smaller than screen, will be loaded in a <v>iew window
X  c     mode has more colors than image needs
X  *     a major problem, one or more of the following is also shown:
X   C     mode has too few colors
X   R     image larger than screen, Fractint will reduce the image, possibly
X     into a <v>iew window, and maybe with aspect ratio a bit wrong
X   A     mode has the wrong shape of pixels for this image
X;
X;
X;
X~Topic=Distribution of Fractint
X~Format-,Online-
X
XDISTRIBUTION OF FRACTINT
X~Format+,Online+
X
XNew versions of FRACTINT are uploaded to the CompuServe network, and make
Xtheir way to other systems from that point.  FRACTINT is available as
Xtwo self-extracting archive files - FRAINT.EXE (executable & documentation)
Xand FRASRC.EXE (source code).
X
XThe latest version can always be found on CompuServe in the "Fractal Sources"
Xlibrary of the GRAPHDEV forum.  If you're not a Compuserve subscriber, but
Xwish to get more information about Compuserve and its graphics forums,
Xfeel free to call their 800 number (800-848-8199) and ask for operator
Xnumber 229.
X
XIf you don't have access to Compuserve, many other sites tend to carry
Xthese files shortly after their initial release (although sometimes
Xusing different naming conventions).  For instance...
X
XIf you speak Internet and FTP, SIMTEL20 and its various mirror sites
Xtend to carry new versions of Fractint shortly after they are released.
Xlook in the PD:<MSDOS.GRAPHICS> directory for files named FRA*.*.  Then
Xagain, if you don't speak Internet and FTP...
X~OnlineFF
X
XYour favorite local BBS probably carries these files as well (although
Xperhaps not the latest versions) using naming conventions like FRA*.ZIP.
XOne BBS that *does* carry the latest version is the "Ideal Studies BBS"
X(508)757-1806, 1200/2400/9600HST.  Peter Longo is the SYSOP and a true
Xfractal fanatic.  There is a very short registration, and thereafter the
Xentire board is open to callers on the first call.  Then again, if you
Xdon't even have a modem...
X
XMany Shareware/Freeware library services will ship you diskettes containing
Xthe latest versions of Fractint for a nominal fee that basically covers
Xtheir cost of packaging and a small profit that we don't mind them making.
XOne in particular is the Public (Software) Library, PO Box 35705,
XHouston, TX 77235-5705, USA.  Their phone number is 800-242-4775 (outside
Xthe US, dial 713-524-6394).  Ask for item #9112 for five 5.25" disks, #9113
Xfor three 3.5" disks.  Cost is $6.99 plus $4 S&H in the U.S./Canada, $11
XS&H overseas.
X
XIn Europe, the latest versions are available from another Fractint enthusiast,
XJon Horner - Editor of FRAC'Cetera, a disk-based fractal/chaos resource.
XDisk prices for UK/Europe are: 5.25" HD BP4.50/5.00  : 3.5" HD BP (British
XPounds) 5.00/5.50.  Prices include p&p (airmail to Europe).  Contact:
XJon Horner, FRAC'Cetera, Le Mont Ardaine, Rue des Ardaines, St. Peters,
XGuernsey GY7 9EU, CI, UK.  Phone [phone].  CIS 100112,1700
X
XThe X Windows port of Fractint maintained by Ken Shirriff is available
Xvia FTP from sprite.berkeley.edu.
X
X;
X;
X~Topic=Contacting the Authors
X~Format-,Online-
X
XCONTACTING THE AUTHORS
X~Format+,Online+
X
XCommunication between the programmers for development of the next version of
XFractint takes place in GRAPHDEV (Graphics Developers) Section 4 (Fractal
XSources) of CompuServe (CIS).
X
XAccess to the GRAPHDEV forum is open to any and all interested
Xin computer generated fractals.
XNew members are always welcome!
XStop on by if you have any questions or
Xjust want to take a peek at what's getting tossed into the soup.
XAlso, you'll find many GIF image files generated by fellow Fractint fans
Xand many fractal programs as well in the GRAPHDEV forum's data library 5.
X
XIf you're not a Compuserve subscriber, but wish to get more information
Xabout Compuserve and its graphics forums, feel free to call their 800
Xnumber (800-848-8199) and ask for operator number 229.
X
X~Format-
XBert Tyler        [73477,433] on CIS
X                        [e-mail] on Internet
X
XTimothy Wegner        [71320,675] on CIS
X                        [e-mail] on Internet
X~Format+
X;
X;
X~Topic=The Stone Soup Story
X~Format-,Online-
XTHE STONE SOUP STORY
X~Format+,Online+
X
XOnce upon a time, somewhere in Eastern Europe, there was a great famine.
XPeople jealously hoarded whatever food they could find, hiding it even
Xfrom their friends and neighbors. One day a peddler drove his wagon into a
Xvillage, sold a few of his wares, and began asking questions as if he
Xplanned to stay for the night.
X
X[No!  No!  It was three Russian Soldiers! - Lee Crocker]\
X[Wait!    I heard it was a Wandering Confessor! - Doug Quinn]\
X[Well *my* kids have a book that uses Russian Soldiers! - Bert]\
X[Look, who's writing this documentation, anyway? - Monte]\
X[Ah, but who gets it *last* and gets to upload it? - Bert]\
X
X"There's not a bite to eat in the whole province," he was told. "Better
Xkeep moving on."
X
X"Oh, I have everything I need," he said. "In fact, I was thinking of
Xmaking some stone soup to share with all of you." He pulled an iron
Xcauldron from his wagon, filled it with water, and built a fire under it.
XThen, with great ceremony, he drew an ordinary-looking stone from a velvet
Xbag and dropped it into the water.
X
XBy now, hearing the rumor of food, most of the villagers had come to the
Xsquare or watched from their windows. As the peddler sniffed the "broth"
Xand licked his lips in anticipation, hunger began to overcome their
Xskepticism.
X
X"Ahh," the peddler said to himself rather loudly, "I do like a tasty stone
Xsoup. Of course, stone soup with CABBAGE -- that's hard to beat."
X
XSoon a villager approached hesitantly, holding a cabbage he'd retrieved
Xfrom its hiding place, and added it to the pot. "Capital!" cried the
Xpeddler. "You know, I once had stone soup with cabbage and a bit of salt
Xbeef as well, and it was fit for a king."
X
XThe village butcher managed to find some salt beef...and so it went,
Xthrough potatoes, onions, carrots, mushrooms, and so on, until there was
Xindeed a delicious meal for all. The villagers offered the peddler a great
Xdeal of money for the magic stone, but he refused to sell and traveled on
Xthe next day. And from that time on, long after the famine had ended, they
Xreminisced about the finest soup they'd ever had.
X
X                ***
X
XThat's the way Fractint has grown, with quite a bit of magic, although
Xwithout the element of deception. (You don't have to deceive programmers
Xto make them think that hours of painstaking, often frustrating work is
Xfun... they do it to themselves.)
X
XIt wouldn't have happened, of course, without Benoit Mandelbrot and the
Xexplosion of interest in fractal graphics that has grown from his work at
XIBM. Or without the example of other Mandelplotters for the PC. Or without
Xthose wizards who first realized you could perform Mandelbrot calculations
Xusing integer math (it wasn't us - we just recognize good algorithms when
Xwe steal--uhh--see them).  Or those graphics experts who hang around the
XCompuserve PICS forum and keep adding video modes to the program.  Or...
X~Doc-
X(continued in {A Word About the Authors})
X~Doc+
X;
X;
X~Topic=A Word About the Authors
X~Format-,Online-
X
XA WORD ABOUT THE AUTHORS
X~Format+,Online+
X
XFractint is the result of a synergy between the main authors, many
Xcontributors, and published sources.  All four of the main authors have
Xhad a hand in many aspects of the code.  However, each author has certain
Xareas of greater contribution and creativity.  Since there is not room in
Xthe credits screen for the contributions of the main authors, we list these
Xhere to facilitate those who would like to communicate with us on
Xparticular subjects.
X
XBert Tyler is the original author.  He wrote the "blindingly fast" 386-
Xspecific 32 bit integer math code and the original video mode logic. Bert
Xmade Stone Soup possible, and provides a sense of direction when we need
Xit. His forte is writing fast 80x86 assembler, his knowledge of a variety
Xof video hardware, and his skill at hacking up the code we send him!
X
XBert has a BA in mathematics from Cornell University.  He has been in
Xprogramming since he got a job at the computer center in his sophomore
Xyear at college - in other words, he hasn't done an honest day's work in
Xhis life.  He has been known to pass himself off as a PC expert, a UNIX
Xexpert, a statistician, and even a financial modeling expert.  He is
Xcurrently masquerading as an independent PC consultant, supporting the PC-
Xto-Mainframe communications environment at NIH.  If you sent mail from the
XInternet to an NIH staffer on his 3+Mail system, it was probably Bert's
Xcode that mangled it during the Internet-to-3+Mail conversion.    He also
Xclaims to support the MS-Kermit environment at NIH. Fractint is Bert's
Xfirst effort at building a graphics program.
X
XTim Wegner contributed the original implementation of palette animation,
Xand is responsible for most of the 3D mechanisms.  He provided the main
Xoutlines of the "StandardFractal" engine and data structures, and is
Xaccused by his cohorts of being "obsessed with options".  Tim is quite
Xproud of having originally integrated the 256 color super VGA modes in
XFractint, especially since he knows almost nothing about it!
X
XTim has BA and MA degrees in mathematics from Carleton College and the
XUniversity of California Berkeley.  He worked for 7 years overseas as a
Xvolunteer, doing things like working with Egyptian villagers building
Xwater systems. Since returning to the US in 1982, he has written shuttle
Xnavigation software, a software support environment prototype, and
Xsupported strategic information planning, all at NASA's Johnson Space
XCenter.
X
XMark Peterson invented the periodicity detection logic, several original
Xfractal types, transcendental function libraries, alternate math
Ximplementations, the formula compiler, and the "Julibrot" intrinsic 3D
Xfractals - in other words, most of the truly original ideas in Fractint!
X
XMark's knowledge of higher mathematics and programming was achieved almost
Xentirely through self-study.  Mark has written several magazine articles on
Xcomputer programming and is coauthor of a book on Fractint called Fractal
XCreations.  Mark is also a free-lance computer consultant specializing in high
Xperformance applications.
X
XPieter Branderhorst is a late-comer to the group who likes to distract the
Xother authors with enhancements impacting at least half of the source at
Xonce.  His contributions include super solid guessing, image rotation,
Xresume, fast disk caching, and the new user interface.    More than any of
Xthe authors, he has personally touched and massaged the entire source.
X
XPieter left high school to work with computers, back when huge machines
Xhad 64k of core.  He's been happily computing since, mostly programming
Xand designing software from comms firmware to database and o/s, and
Xanything between, and large scale online transaction processing
Xapplications.  He has worked as a free-lance computer consultant (whatever
Xthat means) since 1983.
X;
X;
X~Topic=Other Fractal Products
X
X(Forgive us, but we just *have* to begin this section with a plug for
X*our* fractal products...)
X
XFractint's primary authors have written several books about fractals,
XFractint, and Winfract (the Windows version of Fractint).
X
XThe book about Fractint is The Waite Group's Fractal Creations (Copyright
X(C) 1991 Waite Group Press, ISBN # 1-878739-05-0).  The original book was
Xbased on Fractint version 15 - the second edition (which should hit
Xyour favorite local bookstore sometime in the fall of 1993) is based
Xon version 18.  The book about Winfract is The Waite Group's Fractals
Xfor Windows (Copyright (C) 1992 Waite Group Press, ISBN # 1-878739-25-5).
X
X~Format-
XFractal Creations and Fractals for Windows include:
X o A guided tour of Fractint/Winfract.
X o A detailed manual and reference section of commands.
X o A tutorial on fractals.
X o A reference containing tips, explanations, and examples of parameters
X   for all the Fractals generated by Fractint/Winfract.
X o Secrets on how the programs work internally.
X o 3-D red/blue glasses.
X o A fold-out color poster of the most spectacular fractals.
X o A disk containing either Fractint or Winfract and demonstration files.
X o (Fractals for Windows and the second edition of Fractal Creations only)
X   A complete copy of the source code with a chapter explaining how the
X   program works.
X~Format+
X
XIf you enjoy Fractint, you're sure to enjoy Fractal Creations. The book
Xincludes Fractint and is an excellent companion to the program.  If you
Xuse the Windows environment, be sure to pick up a copy of Fractals for
XWindows as well.
X;
X;
X~OnlineFF
X
XA great fractals newsletter is "Amygdala" published by Rollo Silver.
XYou'll find equal parts fractal algorithms, humor, reviews, and ideas.
XWrite to:
X   Amygdala\
X   Box 219\
X   San Cristobal, NM 87564\
X   USA\
X   Email:[e-mail]\
X   Phone: [phone]\
X
X
XAnother great fractals newsletter (this one based in the UK) is
X"FRAC'Cetera", a disk-based fractal/chaos resource published by
XJon Horner.  Contact:
X
X   Jon Horner\
X   FRAC'Cetera\
X   Le Mont Ardaine\
X   Rue des Ardaines\
X   ST Peters\
X   Guernsey GY7 9EU, CI, UK\
X   Email: [e-mail]\
X   PH: (44) 0481 63689\
X
X;
X;
X~Topic=Bibliography
X
XBARNSLEY, Michael: "Fractals Everywhere," Academic Press, 1988.
X
XDEWDNEY, A. K., "Computer Recreations" columns in "Scientific American" --
X   8/85, 7/87, 11/87, 12/88, 7/89.
X
XFEDER, Jens: "Fractals," Plenum, 1988.\
X   Quite technical, with good coverage of applications in fluid
X   percolation, game theory, and other areas.
X
XGLEICK, James: "Chaos: Making a New Science," Viking Press, 1987.\
X   The best non-technical account of the revolution in our understanding
X   of dynamical systems and its connections with fractal geometry.
X
XMANDELBROT, Benoit: "The Fractal Geometry of Nature," W. H. Freeman & Co.,
X   1982.\
X   An even more revised and expanded version of the 1977 work. A rich and
X   sometimes confusing stew of formal and informal mathematics, the
X   prehistory of fractal geometry, and everything else. Best taken in
X   small doses.
X~OnlineFF
X
XMANDELBROT, Benoit: "Fractals: Form, Chance, and Dimension," W. H. Freeman
X   & Co., 1977.\
X   A much revised translation of "Les objets fractals: forme, hasard, et
X   dimension," Flammarion, 1975.
X
XPEITGEN, Heinz-Otto & RICHTER, Peter: "The Beauty of Fractals," Springer-
X   Verlag, 1986.\
X   THE coffee-table book of fractal images, knowledgeable on computer
X   graphics as well as the mathematics they portray.
X
XPEITGEN, Heinz-Otto & SAUPE, Ditmar: "The Science of Fractal Images,"
X   Springer-Verlag, 1988.\
X   A fantastic work, with a few nice pictures, but mostly filled with
X   *equations*!!!
X
XPICKOVER, Clifford: "Computers, Pattern, Chaos, and Beauty," St. Martin's
X   Press, 1990.\
X
XSCHROEDER, Manfred: "Fractals, Chaos, Power Laws," W. H. Freeman
X   & Co., 1991.\
X
XWEGNER, Timothy & PETERSON, Mark: "Fractal Creations," Waite Group Press,
X   1991 (second edition, by Wegner and Tyler, due in the fall of 1993).\
X   If we tell you how *wonderful* this book is you might think we were
X   bragging, so let's just call it:  THE definitive companion to Fractint!
X
XWEGNER, Timothy & PETERSON, Mark & TYLER, Bert, & Branderhorst, Pieter:
X   "Fractals for Windows," Waite Group Press, 1992.\
X   This book is to Winfract (the Windows version of Fractint) what
X   "Fractals for Windows" is to Fractint.
X;
X;
X~Topic=Other Programs
X
XWINFRACT. Bert Tyler has ported Fractint to run under Windows 3!  The same
Xunderlying code is used, with a Windows user interface.  Winfract has
Xalmost all the functionality of Fractint - the biggest difference is the
Xabsence of a zillion weird video modes.  Fractint for DOS will continue to
Xbe the definitive version.  Winfract is available from CompuServe in
XGRAPHDEV Lib 4, as WINFRA.ZIP (executable) and WINSRC.ZIP (source).
X
X
XPICLAB, by Lee Crocker - a freeware image manipulation utility available
Xfrom Compuserve in PICS Lib 10, as PICLAB.EXE.    PICLAB can do very
Xsophisticated resizing and color manipulation of GIF and TGA files.  It
Xcan be used to reduce 24 bit TGA files generated with the Fractint
X"lightname" option to GIF files.
X
X~OnlineFF
X
X~Label=@FDESIGN
XFDESIGN, by Doug Nelson (CIS ID 70431,3374) - a freeware IFS fractal
Xgenerator available from Compuserve in GRAPHDEV Lib 4, and probably on your
Xlocal BBS.  This program requires a VGA adapter and a Microsoft-compatible
Xmouse, and a floating point coprocessor is highly recommended.    It
Xgenerates IFS fractals in a *much* more intuitive fashion than Fractint.
XIt can also (beginning with version 3.0) save its IFS formulas in
XFractint-style .IFS files.
X
X~Label=@ACROSPIN
XACROSPIN, by David Parker - An inexpensive commercial program that reads
Xan object definition file and creates images that can be rapidly rotated
Xin three dimensions. The Fractint "orbitsave=yes" option creates files that
Xthis program can read for orbit-type fractals and IFS fractals. Contact:
X   David Parker             801-966-2580\
X   P O Box 26871            800-227-6248\
X   Salt Lake City, UT  84126-0871
X;
X;
X~Topic=Revision History
X
X  Please select one of:
X
X      {Version 17}
X
X      {Version 16}
X
X      {Version 15}
X
X      {Versions 12 through 14}
X
X      {Versions  1 through 11}
X;
X~Topic=Version 17
X
XVersion 17.2, 3/92
X
X - Fixed a bug which caused Fractint to hang when a Continuous Potential\
X   Bailout value was set (using the 'Y') screen and then the 'Z' screen\
X   was activated.\
X - fixed a bug which caused "batch=yes" runs to abort whenever any\
X   key was pressed.\
X - bug-fixes in the Stereo3D/Targa logic from Marc Reinig.\
X - Fractint now works correctly again on FPU-less 8088s when\
X   zoomed deeply into the Mandelbrot/Julia sets\
X - The current image is no longer marked as "not resumable" on a\
X   Shell-To-Dos ("D") command.\
X - fixed a bug which prevented the "help" functions from working\
X   properly during fractal-type selection for some fractal types.\
X
XVersion 17.1, 3/92
X
X - fixed a bug which caused PCs with no FPU to lock up when they attempted\
X   to use some fractal types.\
X - fixed a color-cycling bug which caused the palette to single-step \
X   when you pressed ESCAPE to exit color-cycling.\
X - fixed the action of the '<' and '>' keys during color-cycling.\
X
XVersion 17.0, 2/92
X
X- New fractal types (but of course!):
X
XLyapunov Fractals from Roy Murphy (see {Lyapunov Fractals} for details)
X
X'BifStewart' (Stewart Map bifurcation) fractal type and new bifurcation
Xparameters (filter cycles, seed population) from Kevin Allen.
X
XLorenz3d1, Lorenz3d2, and Lorenz3d3 fractal types from Scott Taylor.
XNote that a bug in the Lorenz3d1 fractal prevents zooming-out from
Xworking with it at the moment.
X
XMartin, Circle, and Hopalong (culled from Dewdney's Scientific American
XArticle)
X
XLots of new entries in fractint.par.
X
XNew ".L" files (TILING.L, PENROSE.L)
X
XNew 'rand()' function added to the 'type=formula' parser
X
X- New fractal generation options:
X
XNew 'Tesseral' calculation algorithm (use the 'X' option list to
Xselect it) from  Chris Lusby Taylor.
X
XNew 'Fillcolor=' option shows off Boundary Tracing and Tesseral structure
X
Xinside=epscross and inside=startrail options taken from a paper by
XKenneth Hooper, with credit also to Clifford Pickover
X
XNew Color Postscript Printer support from Scott Taylor.
X
XSound= command now works with <O>rbits and <R>ead commands.
X
XNew 'orbitdelay' option in X-screen and command-line interface
X
XNew "showdot=nn" command-line option that displays the pixel currently
Xbeing worked on using the specified color value (useful for those lloooonngg
Ximages being calculated using solid guessing - "where is it now?").
X
XNew 'exitnoask=yes' commandline/SSTOOLS.INI option to avoid the final
X"are you sure?" screen
X
XNew plasma-cloud options.  The interface at the moment (documented here and
X  here only because it might change later) lets you:\
X  - use an alternate drawing algorithm that gives you an earlier preview\
X    of the finished image.
X  - re-generate your favorite plasma cloud (say, at a higher resolution)
X    by forcing a re-select of the random seed.\
X
XNew 'N' (negative palette) option from Scott Taylor - the documentation at
Xthis point is:    Pressing 'N' while in the palette editor will invert
Xeach color. It will convert only the current color if it is in 'x' mode,
Xa range if in 'y' mode, and every color if not in either the 'x' or 'y' mode.
X
X- Speedups:
X
XNew, faster floating-point Mandelbrot/Julia set code from Wesley Loewer,
XFrank Fussenegger and Chris Lusby Taylor (in separate contributions).
X
XFaster non-386 integer Mandelbrot code from Chris Lusby Taylor, Mike Gelvin
Xand Bill Townsend (in separate contributions)
X
XNew integer Lsystems logic from Nicholas Wilt
X
XFinite-Attractor fixups and Lambda/mandellambda speedups from Kevin Allen.
X
XGIF Decoder speedups from Mike Gelvin
X
X- Bug-fixes and other enhancements:
X
XFractint now works with 8088-based AMSTRAD computers.
X
XThe video logic is improved so that (we think) fewer video boards will need
X"textsafe=save" for correct operation.
X
XFixed a bug in the VESA interface which effectively messed up adapters
Xwith unusual VESA-style access, such as STB's S3 chipset.
X
XFixed a color-cycling bug that would at times restore the wrong colors
Xto your image if you exited out of color-cycling, displayed a 'help'
Xscreen, and then returned to the image.
X
XFixed the XGA video logic so that its 256-color modes use the same
Xdefault 256 colors as the VGA adapter's 320x200x256 mode.
X
XFixed the 3D bug that caused bright spots on surfaces
Xto show as black blotches of color 0 when using a light source.
X
XFixed an image-generation bug that sometimes caused image regeneration
Xto restart even if not required if the image had been zoomed in
Xto the point that floating-point had been automatically activated.
X
XAdded autodetection and 640x480x256 support for the Compaq Advanced VGA
XSystems board - I wonder if it works?
X
XAdded VGA register-compatible 320x240x256 video mode.
X
XFixed the "logmap=yes" option to (again) take effect for continuous potential
Ximages.  This was broken in version 15.x.
X
XThe colors for the floating-point algorithm of the Julia fractal
Xnow match the colors for the integer algorithm.
X
XIf the GIF Encoder (the "Save" command) runs out of disk space, it now
Xtells you about it.
X
XIf you select both the boundary-tracing algorithm and either "inside=0"
Xor "outside=0", the algorithm will now give you an error message instead
Xof silently failing.
X
XUpdated 3D logic from Marc Reinig.
X
XMinor changes to permit IFS3D fractal types to be handled properly
Xusing the "B" command.
X
XMinor changes to the "Obtaining the latest Source" section to refer
Xto BBS access (Peter Longo's) and mailed diskettes (the Public (Software)
XLibrary).
X
X~Topic=Version 16
X
XVersion 16.12, 8/91
X
X  Fix to cure some video problems reported with Amstrad
X     8088/8086-based PCs.
X
XVersion 16.11, 7/91
X
X  SuperVGA Autodetect fixed for older Tseng 3000 adapters.\
X
X  New "adapter=" options to force the selection of specific SuperVGA
X     adapter types.  See {Video Parameters} for details.\
X
X  Integer/Floating-Point math toggle is changed only temporarily
X     if floating-point math is forced due to deep zooming.\
X
X  Fractint now survives being modified by McAfee's "SCAN /AV" option.\
X
X  Bug Fixes for Acrospin interface, 3D "Light Source Before
X     Transformation" fill type, and GIF decoder.\
X
X  New options in the <Z> parameters screen allow you to directly
X     enter image coordinates.\
X
X  New "inside=zmag" and "outside=real|imag|mult|summ" options.\
X
X  The GIF Decoder now survives reading GIF files with a local color map.\
X  Improved IIT Math Coprocessor support.\
X
X  New color-cycling single-step options, '<' and '>'.\
X
XVersion 16.0, 6/91
X
X  Integrated online help / fractint.doc system from Ethan Nagel.
X    To create a printable fractint.doc file see {Startup Parameters}.
X
X  Over 350 screens of online help! Try pressing <F1> just about anywhere!\
X
X  New "autokey" feature.  Type "demo" to run the included demo.bat and
X    demo.key files for a great demonstration of Fractint.
X    See {Autokey Mode} for details.
X
X  New <@> command executes a saved set of commands.  The <b> command has
X    changed to write the current image's parameters as a named set of
X    commands in a structured file.  Saved sets of commands can subsequently
X    be executed with the <@> command.
X    See {Parameter Save/Restore Commands}.
X    A default "fractint.par" file is included with the release.
X
X  New <z> command allows changing fractal type-specific parameters without
X    going back through the <t> (fractal type selection) screen.
X
X  Ray tracer interface from Marc Reinig, generates 3d transform output for a
X    number of ray tracers; see {"Interfacing with Ray Tracing Programs"}
X
X  Selection of video modes and structure of "fractint.cfg" have changed. If
X    you have a customized fractint.cfg file, you'll have to rebuild it based
X    on this release's version. You can customize the assignment of your
X    favorite video modes to function keys; see {Video Mode Function Keys}.
X    <delete> is a new command key which goes directly to video mode selection.
X
X  New "cyclerange" option (command line and <y> options screen) from Hugh
X    Steele. Limits color cycling to a specified range of colors.
X
X  Improved {Distance Estimator Method} algorithm from Phil Wilson.\
X
X  New "ranges=" option from Norman Hills.
X    See {Logarithmic Palettes and Color Ranges} for details.
X
X  type=formula definitions can use "variable functions" to select
X    sin, cos, sinh, cosh, exp, log, etc at run time;
X    new built-ins tan, tanh, cotan, cotanh, and flip
X    are available with type=formula; see Type {Formula}
X
X  New <w> command in palette editing mode to convert image to greyscale\
X
X  All "fn" fractal types (e.g. fn*fn) can now use new functions tan, tanh,
X    cotan, cotanh, recip, and ident; bug in prior cos function fixed, new
X    function cosxx (conjugate of cos) is the old erroneous cos calculation
X
X  New L-Systems from Herb Savage\
X  New IFS types from Alex Matulich\
X  Many new formulas in fractint.frm, including a large group from
X    JM Richard-Collard
X  Generalized type manzpwr with complex exponent per Lee Skinner's request\
X  Initial orbit parameter added to Gingerbreadman fractal type\
X
X  New color maps (neon, royal, volcano, blues, headache) from Daniel Egnor\
X
X  IFS type has changed to use a single file containing named entries
X    (instead of a separate xxx.ifs file per type); the <z> command brings up
X    IFS editor (used to be <i> command).  See {=HT_IFS Barnsley IFS Fractals}.
X
X  Much improved support for PaintJet printers; see {PaintJet Parameters}\
X
X  From Scott Taylor:\
X    Support for plotters using HP-GL; see {Plotter Parameters}\
X    Lots of new PostScript halftones; see {PostScript Parameters}\
X    "printer=PS[L]/0/..." for full page PostScript; see {PostScript Parameters}\
X    Option to drive printer ports directly (faster); see {Printer Parameters}\
X    Option to change printer end of line control chars; see {Printer Parameters}
X
X  Support for XGA video adapter\
X  Support for Targa+ video adapter\
X  16 color VGA mode enhancements:\
X    Now use the first 16 colors of .map files to be more predictable\
X    Palette editor now works with these modes\
X    Color cycling now works properly with these modes
X  Targa video adapter fixes; Fractint now uses (and requires) the "targa"
X    and "targaset" environment variables for Targa systems
X  "vesadetect=no" parameter to bypass use of VESA video driver; try
X    this if you encounter video problems with a VESA driver
X  Upgraded video adapter detect and handling from John Bridges; autodetect
X    added for NCR, Trident 8900, Tseng 4000, Genoa (this code
X    is from a beta release of VGAKIT, we're not sure it all works yet)
X
X  Zoom box is included in saved/printed images (but, is not recognized as
X    anything special when such an image is restored)
X
X  The colors numbers reserved by the palette editor are now selectable with
X    the new <v> palette editing mode command
X
X  Option to use IIT floating point chip's special matrix arithmetic for
X    faster 3D transforms; see "fpu=" in {Startup Parameters}
X
X  Disk video cache increased to 64k; disk video does less seeking when
X    running to real disk
X  Faster floating point code for 287 and higher fpus, for types mandel,
X    julia, barnsleyj1/m1/j2/m2, lambda, manowar, from Chuck Ebbert
X
X  "filename=.xxx" can be used to set default <r> function file mask\
X
X  Selection of type formula or lsys now goes directly to entry selection
X    (file selection step is now skipped); to change to a different file, use
X    <F6> from the entry selection screen
X
X  Three new values have been added to the textcolors= parameter; if you use
X    this parameter you should update it by inserting values for the new 6th,
X    7th, 9th, and 13th positions; see "textcolors=" in {Color Parameters}
X
X  The formula type's imag() function has changed to return the result as
X    a real number
X
X  Fractal type-specific parameters (entered after selecting a new fractal
X    type with <T>) now restart at their default values each time you select
X    a new fractal type
X
X  Floating point input fields can now be entered in scientific notation (e.g.
X    11.234e-20). Entering the letters "e" and "p" in the first column causes
X    the numbers e=2.71828... and pi=3.14159... to be entered.
X
X  New option "orbitsave=yes" to create files for Acrospin for
X    some types (see {Barnsley IFS Fractals}, {Orbit Fractals},
X    {=@ACROSPIN Acrospin})
X
X  Bug fixes:\
X    Problem with Hercules adapter auto-detection repaired.\
X    Problems with VESA video adapters repaired (we're not sure we've got them
X      all yet...)\
X    3D transforms fixed to work at high resolutions (> 1000 dots).\
X    3D parameters no longer clobbered when restoring non-3D images.\
X    L-Systems fixed to not crash when order too high for available memory.\
X    PostScript EPS file fixes.\
X    Bad leftmost pixels with floating point at 2048 dot resolution fixed.\
X    3D transforms fixed to use current <x> screen float/integer setting.\
X    Restore of images using inversion fixed.\
X    Error in "cos" function (used with "fn" type fractals) fixed; prior
X      incorrect function still available as "cosxx" for compatibility
X
X  Old 3D=nn/nn/nn/... form of 3D transform parameters no longer supported\
X
X  Fractint source code now Microsoft C6.00A compatible.
X;
X;
X~Topic=Version 15
X
XVersion 15.11, 3/91, companion to Fractal Creations, not for general
Xrelease
X
X  Autokey feature, IIT fpu support, and some bug fixes publicly released in
X  version 16.
X
X
XVersion 15 and 15.1, 12/90
X
X  New user interface! Enjoy! Some key assignments have changed and some have
X    been removed.
X  New palette editing from Ethan Nagel.\
X  Reduced memory requirements - Fractint now uses overlays and will run on a
X    512K machine.
X  New <v>iew command: use to get small window for fast preview, or to setup
X    an image which will eventually be rendered on hard copy with different
X    aspect ratio
X  L-System fractal type from Adrian Mariano\
X  Postscript printer support from Scott Taylor\
X  Better Tandy video support and faster CGA video from Joseph A Albrecht\
X  16 bit continuous potential files have changed considerably;    see the
X    Continuous Potential section for details.  Continuous potential is now
X    resumable.
X  Mandelbrot calculation is faster again (thanks to Mike Gelvin) - double
X    speed in 8086 32 bit case
X  Compressed log palette and sqrt palette from Chuck Ebbert\
X  Calculation automatically resumes whenever current image is resumable and
X    is not paused for a visible reason.
X  Auto increment of savename changed to be more predictable\
X  New video modes:\
X    trident 1024x768x256 mode\
X    320x480x256 tweak mode (good for reduced 640x480 viewing)\
X    changed NEC GB-1, hopefully it works now\
X  Integer mandelbrot and julia now work with periodicitycheck\
X  Initial zoombox color auto-picked for better contrast (usually)\
X  New adapter=cga|ega|mcga|vga for systems having trouble with auto-detect\
X  New textsafe=no|yes for systems having trouble with garbled text mode\
X  <r> and <3> commands now present list of video modes to pick from; <r> can
X    reduce a non-standard or unviewable image size.
X  Diffusion fractal type is now resumable after interrupt/save\
X  Exitmode=n parameter, sets video mode to n when exiting from fractint\
X  When savetime is used with 1 and 2 pass and solid guessing, saves are
X    deferred till the beginning of a new row, so that no calculation time is
X    lost.
X  3d photographer's mode now allows the first image to be saved to disk\
X  textcolors=mono|12/34/56/... -- allows setting user interface colors\
X  Code (again!) compilable under TC++ (we think!)\
X  .TIW files (from v9.3) are no longer supported as input to 3D
X    transformations
X  bug fixes:\
X    multiple restores (msc 6.0, fixed in 14.0r)\
X    repeating 3d loads problem; slow 3d loads of images with float=yes\
X    map= is now a real substitute for default colors\
X    starfield and julibrot no longer cause permanent color map replacement\
X    starfield parameters bug fix - if you couldn't get the starfield
X    parameters to do anything interesting before, try again with this\
X    release\
X    Newton and newtbasin orbit display fixed
X
X Version 15.1:
X
X  Fixed startup and text screen problems on systems with VESA compliant
X    video adapters.
X  New textsafe=save|bios options.\
X  Fixes for EGA with monochrome monitor, and for Hercules Graphics Card.
X    Both should now be auto-detected and operate correctly in text modes.
X    Options adapter=egamono and adapter=hgc added.
X  Fixed color L-Systems to not use color 0 (black).\
X  PostScript printing fix.
X;
X~Topic=Versions 12 through 14
X
XVersion 14, 8/90
X
X  LAST MINUTE NEWS FLASH!\
X    Compuserve announces the GIF89a on August 1, 1990, and Fractint supports
X    it on August 2! GIF files can now contain fractal information!  Fractint
X    now saves its files in the new GIF89a format by default, and uses .GIF
X    rather than .FRA as a default filetype.  Note that Fractint still
X    *looks* for a .FRA file on file restores if it can't find a .GIF file,
X    and can be coerced into using the old GIF87a format with the new
X    'gif87a=yes' command-line option.
X
X  Pieter Branderhorst mounted a major campaign to get his name in lights:\
X  Mouse interface:  Diagonals, faster movement, improved feel. Mouse button
X    assignments have changed - see the online help.
X  Zoom box enhancements:  The zoom box can be rotated, stretched, skewed,
X    and panned partially offscreen.  See "More Zoom Box Commands".
X  FINALLY!! You asked for it and we (eventually, by talking Pieter into it
X    [actually he grabbed it]) did it!  Images can be saved before
X    completion, for a subsequent restore and continue.    See "Interrupting
X    and Resuming" and "Batch Mode".
X  Off-center symmetry:    Fractint now takes advantage of x or y axis symmetry
X    anywhere on the screen to reduce drawing time.
X  Panning:  If you move an image up, down, left, or right, and don't change
X    anything else, only the new edges are calculated.
X  Disk-video caching - it is now possible, reasonable even, to do most
X    things with disk video, including solid guessing, 3d, and plasma.
X  Logarithmic palette changed to use all colors.  It now matches regular
X    palette except near the "lake".  "logmap=old" gets the old way.
X  New "savetime=nnn" parameter to save checkpoints during long calculations.\
X  Calculation time is shown in <Tab> display.
X
X  Kevin C Allen    Finite Attractor, Bifurcation Engine, Magnetic fractals...\
X  Made Bifurcation/Verhulst into a generalized Fractal Engine (like
X    StandardFractal, but for Bifurcation types), and implemented periodicity
X    checking for Bifurcation types to speed them up.
X  Added Integer version of Verhulst Bifurcation (lots faster now). Integer
X    is the default.  The Floating-Point toggle works, too.
X  Added NEW Fractal types BIFLAMBDA, BIF+SINPI, and BIF=SINPI. These are
X    Bifurcation types that make use of the new Engine. Floating-
X    point/Integer toggle is available for BIFLAMBDA. The SINPI types are
X    Floating-Point only, at this time.
X  Corrected the generation of the MandelLambda Set.  Sorry, but it's always
X    been wrong (up to v 12, at least).    Ask Mandelbrot !
X  Added NEW Fractal types MAGNET1M, MAGNET1J, MAGNET2M, MAGNET2J from "The
X    Beauty of Fractals".  Floating-Point only, so far, but what do you
X    expect with THESE formulae ?!
X  Added new symmetry types XAXIS NOIMAG and XAXIS NOREAL, required by the
X    new MAGNETic Fractal types.
X  Added Finite Attractor Bailout (FAB) logic to detect when iterations are
X    approaching a known finite attractor. This is required by the new
X    MAGNETic Fractal types.
X  Added Finite Attractor Detection (FAD) logic which can be used by *SOME*
X    Julia types prior to generating an image, to test for finite attractors,
X    and find their values, for use by FAB logic. Can be used by the new
X    MAGNETic Fractal Types, Lambda Sets, and some other Julia types too.
X
X  Mike Burkey sent us new tweaked video modes:\
X    VGA     - 400x600x256   376x564x256   400x564x256\
X    ATI VGA - 832x612x256
X  New HP Paintjet support from Chris Martin\
X  New "FUNCTION=" command to allow substition of different transcendental
X    functions for variables in types (allows one type with four of these
X    variables to represent 7*7*7*7 different types!
X  ALL KINDS of new fractal types, some using "FUNCTION=": fn(z*z), fn*fn,
X    fn*z+z, fn+fn, sqr(1/fn), sqr(fn), spider, tetrate, and Manowar. Most of
X    these are generalizations of formula fractal types contributed by Scott
X    Taylor and Lee Skinner.
X  Distance Estimator logic can now be applied to many fractal types using
X    distest= option. The types "demm" and "demj" have been replaced by
X    "type=mandel distest=nnn" and "type=julia distest=nnn"
X  Added extended memory support for diskvideo thanks to Paul Varner\
X  Added support for "center and magnification" format for corners.\
X  Color 0 is no longer generated except when specifically requested with
X    inside= or outside=.
X  Formula name is now included in <Tab> display and in <S>aved images.\
X  Bug fixes - formula type and diskvideo, batch file outside=-1 problem.\
X  Now you can produce your favorite fractal terrains in full color instead
X    of boring old monochrome! Use the fullcolor option in 3d! Along with a
X    few new 3D options.
X  New "INITORBIT=" command to allow alternate Mandelbrot set orbit
X    initialization.
X
X
XVersion 13.0, 5/90
X
X  F1 was made the help key.\
X    Use F1 for help\
X    Use F9 for EGA 320x200x16 video mode\
X    Use CF4 for EGA 640x200x16 mode (if anybody uses that mode)\
X  Super-Solid-guessing (three or more passes) from Pieter Branderhorst
X    (replaces the old solid-guessing mode)
X  Boundary Tracing option from David Guenther ("fractint passes=btm", or use
X    the new 'x' options screen)
X  "outside=nnn" option sets all points not "inside" the fractal to color
X    "nnn" (and generates a two-color image).
X  'x' option from the main menu brings up a full-screen menu of many popular
X    options and toggle switches
X  "Speed Key" feature for fractal type selection (either use the cursor keys
X    for point-and-shoot, or just start typing the name of your favorite
X    fractal type)
X  "Attractor" fractals (Henon, Rossler, Pickover, Gingerbread)\
X  Diffusion fractal type by Adrian Mariano\
X  "type=formula" formulas from Scott Taylor and Lee H. Skinner.\
X  "sound=" options for attractor fractals.  Sound=x  plays speaker tones
X    according to the 'x' attractor value  Sound=y  plays speaker tones
X    according to the 'y' attractor value.  Sound=z  plays speaker tones
X    according to the 'z' attractor value  (These options are best invoked
X    with the floating-point algorithm flag set.)
X  "hertz=" option for adjusting the "sound=x/y/z" output.\
X  Printer support for color printers (printer=color) from Kurt Sowa\
X  Trident 4000 and Oak Technologies SuperVGA support from John Bridges\
X  Improved 8514/A support (the zoom-box keeps up with the cursor keys now!)\
X  Tandy 1000 640x200x16 mode from Brian Corbino (which does not, as yet,
X    work with the F1(help) and TAB functions)
X  The Julibrot fractal type and the Starmap option now automatically verify
X    that they have been selected with a 256-color palette, and search for,
X    and use, the appropriate GLASSESn.MAP or ALTERN.MAP palette map when
X    invoked.  *You* were supposed to be doing that manually all along, but
X    *you* probably never read the docs, huh?
X  Bug Fixes:\
X    TAB key now works after R(estore) commands\
X    PS/2 Model 30 (MCGA) adapters should be able to select 320x200x256 mode
X      again (we think)\
X    Everex video adapters should work with the Autodetect modes again (we
X      think)
X
X
XVersion 12.0, 3/90
X
X  New SuperVGA Autodetecting and VESA Video modes (you tell us the
X    resolution you want, and we'll figure out how to do it)
X  New Full-Screen Entry for most prompting\
X  New Fractal formula interpreter ('type=formula') - roll your own fractals
X    without using a "C" compiler!
X  New 'Julibrot' fractal type\
X  Added floating point option to all remaining fractal types.\
X  Real (funny glasses) 3D - Now with "real-time" lorenz3D!!\
X  Non-Destructive <TAB> - Check out what your fractal parameters are without
X    stopping the generation of a fractal image
X  New Cross-Hair mode for changing individual palette colors (VGA only)\
X  Zooming beyond the limits of Integer algorithms (with automatic switchover
X    to a floating-point algorithm when you zoom in "too far")
X  New 'inside=bof60', 'inside=bof61' ("Beauty of Fractals, Page nn") options\
X  New starmap ('a' - for astrology? astronomy?) transformation option\
X  Restrictions on the options available when using Expanded Memory
X    "Disk/RAM" video mode have been removed
X  And a lot of other nice little clean-up features that we've already
X    forgotten that we've added...
X  Added capability to create 3D projection images (just barely) for people
X    with 2 or 4 color video boards.
X;
X~Topic=Versions  1 through 11
X
XVersion 11.0, 1/90
X
X  More fractal types\
X    mandelsinh/lambdasinh     mandelcosh/lambdacosh\
X    mansinzsqrd/julsinzsqrd     mansinexp/julsinexp\
X    manzzprw/julzzpwr         manzpower/julzpower\
X    lorenz (from Rob Beyer)     lorenz3d\
X    complexnewton         complexbasin\
X    dynamic             popcorn\
X  Most fractal types given an integer and a floating point algorithm.
X    "Float=yes" option now determines whether integer or floating-point
X    algorithms are used for most fractal types.  "F" command toggles the use
X    of floating-point algorithms, flagged in the <Tab> status display
X  8/16/32/../256-Way decomposition option (from Richard Finegold)\
X  "Biomorph=", "bailout=", "symmetry="  and "askvideo=" options\
X  "T(ransform)" option in the IFS editor lets you select 3D options (used
X    with the Lorenz3D fractal type)
X  The "T(ype)" command uses a new "Point-and-Shoot" method of selecting
X    fractal types rather than prompting you for a type name
X  Bug fixes to continuous-potential algorithm on integer fractals, GIF
X    encoder, and IFS editor
X
X
XVersion 10.0, 11/89
X
X  Barnsley IFS type (Rob Beyer)\
X  Barnsley IFS3D type\
X  MandelSine/Cos/Exp type\
X  MandelLambda/MarksLambda/Unity type\
X  BarnsleyM1/J1/M2/J2/M3/J3 type\
X  Mandel4/Julia4 type\
X  Sierpinski gasket type\
X  Demm/Demj and bifurcation types (Phil Wilson), "test" is "mandel" again\
X  <I>nversion command for most fractal types\
X  <Q>uaternary decomposition toggle and "DECOMP=" argument\
X  <E>ditor for Barnsley IFS parameters\
X  Command-line options for 3D parameters\
X  Spherical 3D calculations 5x faster\
X  3D now clips properly to screen edges and works at extreme perspective\
X  "RSEED=" argument for reproducible plasma clouds\
X  Faster plasma clouds (by 40% on a 386)\
X  Sensitivity to "continuous potential" algorithm for all types except
X    plasma and IFS
X  Palette-map <S>ave and Restore (<M>) commands\
X  <L>ogarithmic and <N>ormal palette-mapping commands and arguments\
X  Maxiter increased to 32,000 to support log palette maps\
X  .MAP and .IFS files can now reside anywhere along the DOS path\
X  Direct-video support for Hercules adapters (Dean Souleles)\
X  Tandy 1000 160x200x16 mode (Tom Price)\
X  320x400x256 register-compatible-VGA "tweaked" mode\
X  ATI VGA Wonder 1024x768x16 direct-video mode (Mark Peterson)\
X  1024x768x16 direct-video mode for all supported chipsets\
X  Tseng 640x400x256 mode\
X  "Roll-your-own" video mode 19\
X  New video-table "hot-keys" eliminate need for enhanced keyboard to access
X    later entries
X
X
XVersion 9.3, 8/89
X
X  <P>rint command and "PRINTER=" argument (Matt Saucier)\
X  8514/A video modes (Kyle Powell)\
X  SSTOOLS.INI sensitivity and '@THISFILE' argument\
X  Continuous-potential algorithm for Mandelbrot/Julia sets\
X  Light source 3D option for all fractal types\
X  "Distance estimator" M/J method (Phil Wilson) implemented as "test" type\
X  LambdaCosine and LambdaExponent types\
X  Color cycling mode for 640x350x16 EGA adapters\
X  Plasma clouds for 16-color and 4-color video modes\
X  Improved TARGA support (Joe McLain)\
X  CGA modes now use direct-video read/writes\
X  Tandy 1000 320x200x16 and 640x200x4 modes (Tom Price)\
X  TRIDENT chip-set super-VGA video modes (Lew Ramsey)\
X  Direct-access video modes for TRIDENT, Chips & Technologies, and ATI VGA
X    WONDER adapters (John Bridges). and, unlike version 9.1, they WORK in
X    version 9.3!)
X  "zoom-out" (<Ctrl><Enter>) command\
X  <D>os command for shelling out\
X  2/4/16-color Disk/RAM video mode capability and 2-color video modes
X    supporting full-page printer graphics
X  "INSIDE=-1" option (treated dynamically as "INSIDE=maxiter")\
X  Improved <H>elp and sound routines (even a "SOUND=off" argument)\
X  Turbo-C and TASM compatibility (really!  Would we lie to you?)
X
X
XVersion 8.1, 6/89
X
X  <3>D restore-from-disk and 3D <O>verlay commands, "3D=" argument\
X  Fast Newton algorithm including inversion option (Lee Crocker)\
X  16-bit Mandelbrot/Julia logic for 386-class speed with non-386 PCs on
X    "large" images (Mark Peterson)
X  Restore now loads .GIF files (as plasma clouds)\
X  TARGA video modes and color-map file options (Joe McLain)\
X  30 new color-cycling palette options (<Shft><F1> to <Alt><F10>)\
X  "Disk-video, RAM-video, EMS-video" modes\
X  Lambda sets now use integer math (with 80386 speedups)\
X  "WARN=yes" argument to prevent over-writing old .GIF files
X
X
XVersion 7.0, 4/89
X
X  Restore from disk (from prior save-to-disk using v. 7.0 or later)\
X  New types: Newton, Lambda, Mandelfp, Juliafp, Plasma, Lambdasine\
X  Many new color-cycling options (for VGA adapters only)\
X  New periodicity logic (Mark Peterson)\
X  Initial displays recognize (and use) symmetry\
X  Solid-guessing option (now the default)\
X  Context-sensitive <H>elp\
X  Customizable video mode configuration file (FRACTINT.CFG)\
X  "Batch mode" option\
X  Improved super-VGA support (with direct video read/writes)\
X  Non-standard 360 x 480 x 256 color mode on a STANDARD IBM VGA!
X
X
XVersion 6.0, 2/89
X
X  32-bit integer math emulated for non-386 processors; FRACT386 renamed
X    FRACTINT
X  More video modes
X
X
XVersion 5.1, 1/89
X
X  Save to disk\
X  New! Improved! (and Incompatible!) optional arguments format\
X  "Correct" initial image aspect ratio\
X  More video modes
X
X
XVersion 4.0, 12/88
X
X  Mouse support (Mike Kaufman)\
X  Dynamic iteration limits\
X  Color cycling\
X  Dual-pass mode\
X  More video modes, including "tweaked" modes for IBM VGA and register-
X    compatible adapters
X
X
XVersion 3.1, 11/88
X
X  Julia sets
X
X
XVersion 2.1, 10/23/88 (the "debut" on CIS)
X
X  Video table\
X  CPU type detector
X
X
XVersion 2.0, 10/10/88
X
X  Zoom and pan
X
X
XVersion 1.0, 9/88
X
X  The original, blindingly fast, 386-specific 32-bit integer algorithm
X;
X;
X;
X~Topic=Version13 to 14 Conversion
X
XA number of types in Fractint version 13 and earlier were generalized in
Xversion 14. We added a "backward compatibility" hook that (hopefully)
Xautomatically translates these to the new form when the old files are
Xread. Files may be converted via:
X
X   FRACTINT OLDFILE.FRA SAVENAME=NEWFILE.GIF BATCH=YES
X
XIn a few cases the biomorph flag was incorrectly set in older files.  In
Xthat case, add "biomorph=no" to the command line.
X
XThis procedure can also be used to convert any *.fra file to the new
XGIF89a spec, which now allows storage of fractal information.
X
X
X~Format-
XTYPES CHANGED FROM VERSION 13 -
X
X
XV13 NAME        V14 NAME + PARAMETERS
X--------        --------------------------------------
X
XLOGMAP=YES        LOGMAP=OLD   for identical Logmap type
X
XDEMJ            JULIA DISTEST=nnn
X
XDEMM            MANDEL DISTEST=nnn
X
X            Note: DISTEST also available on many other types
X
XMANSINEXP        MANFN+EXP FUNCTION=SIN
X
X            Note: New functions for this type are
X                  cos sinh cosh exp log sqr
X
XJULSINEXP        JULFN+EXP FUNCTION=SIN
X
X            Note: New functions for this type are
X                  cos sinh cosh exp log sqr
X
XMANSINZSQRD        MANFN+ZSQRD FUNCTION=SQR/SIN
X
X            Note: New functions for this type are
X                  cos sinh cosh exp log sqr
X
XJULSINZSQRD        JULFN+ZSQRD FUNCTION=SQR/SIN
X
X            Note: New functions for this type are
X                  cos sinh cosh exp log sqr
X
XLAMBDACOS        LAMBDAFN FUNCTION=COS
X
XLAMBDACOSH        LAMBDAFN FUNCTION=COSH
X
XLAMBDAEXP        LAMBDAFN FUNCTION=EXP
X
XLAMBDASINE        LAMBDAFN FUNCTION=SIN
X
XLAMBDASINH        LAMBDAFN FUNCTION=SINH
X
X            Note: New functions for this type are
X                  log sqr
X
XMANDELCOS        MANDELFN FUNCTION=COS
X
XMANDELCOSH        MANDELFN FUNCTION=COSH
X
XMANDELEXP        MANDELFN FUNCTION=EXP
X
XMANDELSINE        MANDELFN FUNCTION=SIN
X
XMANDELSINH        MANDELFN FUNCTION=SINH
X
X            Note: New functions for this type are
X                  log sqr
X
XMANDELLAMBDA        MANDELLAMBDA INITORBIT=PIXEL
X
XPOPCORN SYMMETRY=NONE    POPCORNJUL
X
X-------------------------------------------------------------
X
XFormulas from FRACTINT.FRM in version 13
X
XMANDELGLASS        MANDELLAMBDA INITORBIT=.5/0
X
XINVMANDEL        V13 divide bug may cause some image differences.
X
XNEWTON4         V13 divide bug may cause some image differences.
X
XSPIDER            V13 divide bug may cause some image differences.
X
XMANDELSINE        MANDELFN FUNCTION=SIN BAILOUT=50
X
XMANDELCOSINE        MANDELFN FUNCTION=COS BAILOUT=50
X
XMANDELHYPSINE        MANDELFN FUNCTION=SINH BAILOUT=50
X
XMANDELHYPCOSINE     MANDELFN FUNCTION=COSH BAILOUT=50
X
XSCOTTSIN PARAMS=nnn    FN+FN FUNCTION=SIN/SQR BAILOUT=nnn+3
X
XSCOTTSINH PARAMS=nnn    FN+FN FUNCTION=SINH/SQR BAILOUT=nnn+3
X
XSCOTTCOS PARAMS=nnn    FN+FN FUNCTION=COS/SQR BAILOUT=nnn+3
X
XSCOTTCOSH PARAMS=nnn    FN+FN FUNCTION=COSH/SQR BAILOUT=nnn+3
X
XSCOTTLPC PARAMS=nnn    FN+FN FUNCTION=LOG/COS BAILOUT=nnn+3
X
XSCOTTLPS PARAMS=nnn    FN+FN FUNCTION=LOG/SIN BAILOUT=nnn+3
X            Note: New functions for this type are
X            sin/sin sin/cos sin/sinh sin/cosh sin/exp
X            cos/cos cos/sinh cos/cosh cos/exp
X            sinh/sinh sinh/cosh sinh/exp sinh/log
X            cosh/cosh cosh/exp cosh/log
X            exp/exp exp/log exp/sqr log/log log/sqr sqr/sqr
X
XSCOTTSZSA PARAMS=nnn    FN(Z*Z) FUNCTION=SIN BAILOUT=nnn+3
X
XSCOTTCZSA PARAMS=nnn    FN(Z*Z) FUNCTION=COS BAILOUT=nnn+3
X
X            Note: New functions for this type are
X            sinh cosh exp log sqr
X
XSCOTTZSZZ PARAMS=nnn    FN*Z+Z FUNCTION=SIN BAILOUT=nnn+3
X
XSCOTTZCZZ PARAMS=nnn    FN*Z+Z FUNCTION=COS BAILOUT=nnn+3
X
X            Note: New functions for this type are
X            sinh cosh exp log sqr
X
XSCOTTSZSB PARAMS=nnn    FN*FN FUNCTION=SIN/SIN BAILOUT=nnn+3
X
XSCOTTCZSB PARAMS=nnn    FN*FN FUNCTION=COS/COS BAILOUT=nnn+3
X
XSCOTTLTS PARAMS=nnn    FN*FN FUNCTION=LOG/SIN BAILOUT=nnn+3
X
XSCOTTLTC PARAMS=nnn    FN*FN FUNCTION=LOG/COS BAILOUT=nnn+3
X
X            Note: New functions for this type are
X            sin/cos sin/sinh sin/cosh sin/exp sin/sqr
X            cos/sinh cos/cosh cos/exp cos/sqr
X            sinh/sinh sinh/cosh sinh/exp sinh/log sinh/sqr
X            cosh/cosh cosh/exp cosh/log cosh/sqr
X            exp/exp exp/log exp/sqr log/log log/sqr sqr/sqr
X
XSCOTTSIC PARAMS=nnn    SQR(1/FN) FUNCTION=COS BAILOUT=nnn+3
X
XSCOTTSIS PARAMS=nnn    SQR(1/FN) FUNCTION=SIN BAILOUT=nnn+3
X
XTETRATE PARAMS=nnn    TETRATE BAILOUT=nnn+3
X
X            Note: New function type sqr(1/fn) with
X                  sin cos sinh cosh exp log sqr
X
X            Note: New function type sqr(fn) with
X                  sin cos sinh cosh exp log sqr
X~Format+
X;
X;
X~Data=INTRO_AUTHORS
X;
X; FRACTINT intro screen primary authors
X;
X Primary Authors
X Bert Tyler          CompuServe (CIS) ID: [73477,433]
X Timothy Wegner       CIS ID: [71320,675]   Internet: [e-mail]
X Mark Peterson          CIS ID: [70441,3353]
X Pieter Branderhorst  CIS ID: [72611,2257]
X Contributing Authors
X
X
X; room for 14 authors at a time here
X
X
X
X
X
X
X
X
X
X
X
X
X SPACEBAR toggles scrolling off/on
X   Copyright (C) 1990-93 The Stone Soup Group.  Fractint may be freely copied
X   and distributed but may not be sold.  See help for more information.
X;
X;
X;
X~Data=INTRO_CREDITS
X;
X; FRACTINT intro screen contributing authors.
X;
X          ...
X Michael Abrash   360x480x256, 320x400x256 VGA video modes
X Joseph Albrecht  Tandy video, CGA video speedup
X Kevin Allen      [e-mail] Finite attractor, bifurcation engine
X Steve Bennett      restore-from-disk logic
X Rob Beyer      [71021,2074] Barnsley IFS, Lorenz fractals
X Francois Blais      [70700,446] Lyapunov Fractals, LYAPUNOV.MAP
X Dennis Bragg     [75300,2456] DXF Raytracing output option
X Juan J. Buhler   [e-mail] Diffusion options, inverse Julia type
X Mike Burkey      376x564x256, 400x564x256, and 832x612x256 VGA video modes
X Robin Bussell      Palette-editor "freestyle" option
X John Bridges      [75300,2137] superVGA support, 360x480x256 mode
X Brian Corbino      [71611,702] Tandy 1000 640x200x16 video mode
X Lee Crocker      [73407,2030] Fast Newton, Inversion, Decomposition..
X Monte Davis      [71450,3542] Documentation
X Chuck Ebbert      [76306,1226] cmprsd & sqrt logmap, fpu speedups
X Dan Farmer      [70703,1632] orbits enhancements
X Richard Finegold [76701,153] 8/16/../256-Way Decomposition option
X Frank Fussenegger Mandelbrot speedups
X Mike Gelvin      [73337,520] Mandelbrot speedups
X Lawrence Gozum   [73437,2372] Tseng 640x400x256 Video Mode
X David Guenther   [70531,3525] Boundary Tracing algorithm
X Norman Hills      [71621,1352] Ranges option
X Richard Hughes   [70461,3272] "inside=", "outside=" coloring options
X Mike Kaufman      [[e-mail]] mouse support, other features
X Wesley Loewer    fast fp Mandel/Julia/Lyapunov, boundary trace, frothybasin
X Adrian Mariano   [[e-mail]] Diffusion & L-Systems
X Charles Marslett [75300,1636] VESA video and IIT math chip support
X Joe McLain      [75066,1257] TARGA Support, color-map files
X Bob Montgomery   [73357,3140] (Author of VPIC) Fast text I/O routines
X Bret Mulvey      plasma clouds
X Roy Murphy      [76376,721] Lyapunov Fractals
X Ethan Nagel      [70022,2552] Palette editor, integrated help/doc system
X Jonathan Osuch   [73277,1432] IIT detect, register-compatible 8514/A code
X Marc Reinig      [72410,77] Lots of 3D options
X Kyle Powell      [76704,12] 8514/A Support
X Matt Saucier      [72371,3101] Printer Support
X Herb Savage      [75260,217] 'inside=bof60', 'inside=bof61' options
X Ken Shirriff     [e-mail] Quaternions, CA, Xfract port
X Lee Skinner      [75450,3631] Tetrate fractal types and more
X Dean Souleles      [75115,1671] Hercules Support
X Kurt Sowa      [73467,2013] Color Printer Support
X Hugh Steele      cyclerange feature
X John Swenson      [75300,2136] Postscript printer features
X Chris Taylor      Floating&Fixed-point algorithm speedups, Tesseral Option
X Scott Taylor      [72401,410] PostScript, Kam Torus, many fn types.
X Bill Townsend      Mandelbrot Speedups
X Paul Varner      [73237,441] Extended Memory support for Disk Video
X Dave Warker      Integer Mandelbrot Fractals concept
X Aaron Williams   Register-compatible 8514/A code
X Phil Wilson      [76247,3145] Distance Estimator, Bifurcation fractals
X Nicholas Wilt      Lsystem speedups
X Richard Wilton   Tweaked VGA Video modes
X          ...
X; Byte Magazine      Tweaked VGA Modes
X; MS-Kermit      Keyboard Routines
X; PC Magazine      Sound Routines
X; PC Tech Journal  CPU, FPU Detectors
X;
X;
SHAR_EOF
$TOUCH -am 1028230193 help5.src &&
chmod 0644 help5.src ||
echo "restore of help5.src failed"
set `wc -c help5.src`;Wc_c=$1
if test "$Wc_c" != "93177"; then
    echo original size 93177, current size $Wc_c
fi
exit 0