#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#define _LIBG_EXTENSION
#include <libg.h>

#define ONES    (~0UL)

#define xtbinit(a,b,c,d)        binit(a,b, "anim")

typedef unsigned char uchar;

#define INPUTSCALE      10000   /* inherited from fdevelop */
int     inputscale      = INPUTSCALE;

#define NZOOM   20
Rectangle zoomr[NZOOM]; /* for zooming in and out */
int     nzoom = 0;      /* current one */

Rectangle origscreen;

FILE    *inf;

/* options for various commands */

#define Tcenter 10
#define Tljust  20
#define Trjust  30
#define Tabove  40
#define Tbelow  50
#define Tsmall  1
#define Tmedium 2
#define Tbig    3
#define Tbigbig 4

#define Lsolid  10
#define Lfat    20
#define Lfatfat 30
#define Ldotted 40
#define Ldashed 50
#define Lline   1
#define Larrow1 2
#define Larrow2 3
#define Larrow3 4

#define Bnofill 1
#define Bfill   2

#define Cnofill 1
#define Cfill   2


#define eq(s,t) (strcmp((char *) s, (char *) t) == 0)
#define muldiv(a,b,c)   (((a) * (b)) / (c))     /* ought to be inline */

/* holds data for all input objects */

unsigned memsize;               /* bytes */
uchar   *inbuf;                 /* input collected here */
uchar   *input;                 /* leave a null at front */
uchar   *nextinp;               /* next free slot in input */
int     nobj    = 0;            /* number of objects in input */
int     overflow = 0;           /* 1 => too much input */

long    slot[2000];             /* slots */
int     slotnum;

uchar   *savechar(int);
uchar   *draw_obj(uchar *, int, int);
uchar   *step_obj(uchar *, int, int);
uchar   *prev_obj(uchar *);
uchar   *next_obj(uchar *);
uchar   *refresh(uchar *);
int     zoomin(void);
Rectangle square(Rectangle);

Point   fetchpt(int, uchar *);
Point   scalept(int, Point);

void    putstring(char *);

int     reshaped        = 0;    /* set to 1 in ereshaped */
/* this ought to include Expose events in X... */

Mouse   mouse;
int     buttondown(void);
Cursor  skull, deadmouse;

char    kbdline [100];
int     do_kbd(void);

#define MAXVIEW 20
char    *viewname[MAXVIEW];
Rectangle viewpt[MAXVIEW];
int     curview = 0;
int     nview   = 0;
#define INSET   4       /* picture inset from frame */

#define AW      8       /* arrowhead width and height */
#define AH      10

#define MARGINPCT       5
int     margin  = MARGINPCT;    /* percent margin around edges */

#define MAXCLICK        20
char    *clickname[MAXCLICK];           /* click names */
int     clickval[MAXCLICK];             /* 1 => click on this */
int     clicking = 0;                   /* number of active clicks */
int     nclick  = 0;

int     boxops[] ={     'n', Bnofill, 'f', Bfill, 0 };
int     circops[] ={    'n', Cnofill, 'f', Cfill, 0 };
int     textops[] ={    'c', Tcenter, 'l', Tljust, 'r', Trjust,
                       's', Tsmall, 'm', Tmedium, 'b', Tbig, 'B', Tbigbig, 0 };
int     lineops[] ={    's', Lsolid, 'f', Lfat, 'F', Lfatfat, 'o', Ldotted, 'a', Ldashed,
                       '-', Lline, '>', Larrow1, '<', Larrow2, 'x', Larrow3, 0 };

enum    { Fwd = 1, Back = 0 };

enum    { F_XOR = DxorS, F_CLR = Zero, F_STORE = S, F_OR = DorS };

int     delay           = 1;    /* how long to delay between things */
int     singstep        = 0;    /* single step if 1, cycle if 2 */
int     dir             = Fwd;          /* 1 = fwd, 0 = backward */
int     fatness         = 0;            /* n => draw with 2n+1 lines */
int     xormode         = F_XOR;        /* otherwise OR/CLR */

enum Menuitems {
       Again = 0,              /* Menu items -- must be 0, other in order */
       Faster,
       Slower,
       Step,
       Forward,
       Fatter,
       Thinner,
       Zoomin,
       Zoomout,
       Xor,
       Newfile,
       Quit,
       Backward ,
       Proceed,
       Hit,
       Cycle,
};

char    *m3[]   = { "again", "faster", "slower", "1 step", "backward",
                   "fatter", "thinner", "zoom in", "zoom out",
                   "or mode", "new file", "Quit?", 0 };
char    *stepmenu[]     = { "1 step", "cycle", "run" };
char    *dirmenu[]      = { "forward", "backward" };
char    *modemenu[]     = { "or mode", "xor mode" };

char    *m3gen(int);
char    *m2gen(int);

Menu    mbut3   = { (char **) 0, m3gen, 0 };
Menu    mbut2   = { (char **) 0, m2gen, 0 };

int     last_hit;
int     last_but;
int     Etimer;

extern  int     do_rcv(FILE *);
extern  int     skipline(FILE *);
extern  int     skipbl(FILE *);
extern  int     badfile(FILE *);
extern  int     savect(int);
extern  int     saveint(int);
extern  int     savelong(long);
extern  int     savepair(int, int);
extern  int     sendopt(int[], char *);
extern  int     erase(uchar *);
extern  int     fatline(Point, Point, int, int);
extern  int     fatcircle(Point, int, int, int);
extern  int     arrow(Point, Point, int, int, int);

extern  FILE    *show(FILE *);
extern  int     clear(void);
extern  int     view_setup(int);
extern  int     init_params(void);
extern  int     checkmouse(void);
extern  int     domouse(void);


main(int argc, char *argv[])
{
       FILE *fp = stdin;

       xtbinit(0, 0, &argc, argv);
       einit(Emouse|Ekeyboard);
       Etimer = etimer(0, 75);
       setbuf(stderr, NULL);

       origscreen = screen.r;
       memsize = 1000000;
       while (argc > 1 && argv[1][0] == '-') {
               switch (argv[1][1]) {
               case 'm':
                       memsize = atoi(&argv[1][2]);
                       break;
               }
               argv++;
               argc--;
       }
       if (inbuf == NULL && (inbuf = (uchar *) malloc(memsize)) == NULL) {
               fprintf(stderr, "can't allocate %u bytes", memsize);
               exit(1);
       }
       if ((fp = fopen(argv[1], "r")) == NULL) {
               fprintf(stderr, "can't open file %s\n", argv[1]);
               exit(1);
       }

       while ((fp = show(fp)) != 0)
               ;
}

FILE *show(FILE *fp)
{
       uchar *ip;
       int i, n, c;
       Event tev;

       init_params();
       input = inbuf+1;        /* leave a null at front */
       nextinp = inbuf+1;      /* next free slot in input */

       clear();
       cursorswitch(&deadmouse);
       do_rcv(fp);
       cursorswitch(0);

       dir = Fwd;
       ip = nextinp;   /* pointing at the end */
 again:
       for (; ip; ) {
               checkmouse();   /* waits for a menu selection */
               n = domouse();
               if (n == Quit)
                       return 0;
               if (n == Hit)
                       continue;       /* wait for another mouse hit */
               if (n == Forward) {     /* change from fwd to back -- fiddle ip */
                       ip = next_obj(ip);
                       continue;
               }
               if (n == Backward) {
                       ip = prev_obj(ip);
                       continue;
               }
               if (n == Newfile) {
                       char buf[100];
                       /* fprintf(stderr, "filename? "); */
                       putstring("filename? ");
                       if (do_kbd() == 0)
                               continue;
                       fclose(fp);
                       /* open up the new file, return its fp.  ick */
                       if ((fp = fopen(kbdline, "r")) != NULL)
                               return fp;
                       sprintf(buf, "can't open %s", kbdline);
                       fprintf(stderr, "%s\n", buf);
                       putstring(buf);
                       continue;
               }
               if (n == Again) {
                       if (reshaped) {
                               view_setup(nview);
                               reshaped = 0;
                       }
                       clear();
                       dir = Fwd;
                       ip = input;
               }
               if (n == Zoomin || n == Zoomout) {
                       clear();
                       dir = Fwd;
                       ip = refresh(ip);
                       continue;
               }
               if (singstep == 1) {
                       ip = step_obj(ip, xormode, dir);
               } else {                /* free running */
                  cycle:
                       while (ip) {
                               ip = step_obj(ip, xormode, dir);
                               if (buttondown()) {     /* someone has touched the mouse */
                                       singstep = 0;
                                       break;          /* back round main loop */
                               }
                               for(i = delay-1; i>0; i--)
                                       eread(Etimer, &tev);
                       }
                       if (singstep == 2) {
                               clear();
                               dir = Fwd;
                               ip = input;
                               goto cycle;
                       }

               }
       }
       if (ip == 0)
               ip = dir == Fwd ? nextinp : input;
       goto again;
}

uchar *refresh(uchar *cp)       /* redraw the screen up to cp */
{
       uchar *ip;

       for (ip = input; ip != 0 && ip < cp; )
               ip = step_obj(ip, xormode, Fwd);
       return ip;
}

init_params(void)
{
       int i;

       for (i = 0; i < MAXCLICK; i++)
               if (clickname[i]) {
                       free(clickname[i]);
                       clickname[i] = 0;
                       clickval[i] = 0;
               }
       for (i = 0; i < MAXVIEW; i++)
               if (viewname[i]) {
                       free(viewname[i]);
                       viewname[i] = 0;
               }
       nview = nclick = curview = nobj = overflow = slotnum = 0;
       screen.r = inset(screen.r, INSET);
       zoomr[0] = screen.r = square(screen.r);
       nzoom = 0;
}

Rectangle shrink(Rectangle r, int pct)  /* shrink rectangle by 2*pct */
{
       int dx = (r.max.x-r.min.x) * pct / 100;
       int dy = (r.max.y-r.min.y) * pct / 100;
       r.min = add(r.min, Pt(dx,dy));
       r.max = sub(r.max, Pt(dx,dy));
       return r;
}

Rectangle square(Rectangle r)   /* return largest square within r */
{
       double ar;

       ar = (double) Dy(r)/Dx(r);      /* y/x aspect ratio */
       if (ar < 0.9 || ar > 1.1)       /* leave it alone */
               return r;
       if (ar <= 1)    /* x is longer than y */
               r.max.x = r.min.x + Dy(r);
       else            /* y is longer */
               r.max.y = r.min.y + Dx(r);
       return r;
}

view_setup(int n)
{
       int i, j, v, dx, dy, r, c;
       Rectangle sr;

       sr = square(screen.r);
       switch (n) {
       case 1: r = 1; c = 1; break;
       case 2: r = 2; c = 1; break;
       case 3: case 4: r = 2; c = 2; break;
       case 5: case 6: r = 3; c = 2; break;
       case 7: case 8: case 9: r = 3; c = 3; break;
       default: r = (n+2)/3; c = 3; break; /* finking out */
       }
       dx = Dx(sr) / c;
       dy = Dy(sr) / r;
       v = 0;
       for (i = 0; i < r && v < n; i++)
               for (j = 0; j < c && v < n; j++) {
                       viewpt[v] = sr;
                       viewpt[v].min.x = sr.min.x + j * dx;
                       viewpt[v].max.x = sr.min.x + (j+1) * dx;
                       viewpt[v].min.y = sr.min.y + i * dy;
                       viewpt[v].max.y = sr.min.y + (i+1) * dy;
                       v++;
               }
       for (i = 0; i < n; i++) {
               viewpt[i] = shrink(viewpt[i], margin);
       }
       zoomr[nzoom] = screen.r;
}

void ereshaped(Rectangle r)
{
       reshaped = 1;
       origscreen = r;
       screen.r = inset(r, INSET);
       zoomr[0] = screen.r = square(screen.r);
       nzoom = 0;
}

drawrect(Rectangle r, int mode)
{
       segment(&screen, r.min, Pt(r.min.x,r.max.y), ONES, mode);
       segment(&screen, r.min, Pt(r.max.x,r.min.y), ONES, mode);
       segment(&screen, r.max, Pt(r.min.x,r.max.y), ONES, mode);
       segment(&screen, r.max, Pt(r.max.x,r.min.y), ONES, mode);
}

domouse(void)
{
       int i, n;
       Rectangle r;

       if (last_but == 1)
               return Proceed;
       if (last_but == 3) {
               switch (last_hit) {
               case Again:
                       return Again;
               case Faster:
                       if (delay > 1)
                               delay /= 2;
                       return Hit;
               case Slower:
                       delay *= 2;
                       return Hit;
               case Step:
                       singstep = (singstep+1) % 3;
                       return Hit;
               case Forward:
                       dir = 1 - dir;
                       if (xormode == F_OR)
                               xormode = F_CLR;
                       else if (xormode == F_CLR)
                               xormode = F_OR;
                       return dir == Fwd ? Forward : Backward;
               case Fatter:
                       fatness++;
                       return Hit;
               case Thinner:
                       if (fatness > 0)
                               fatness--;
                       return Hit;
               case Zoomin:
                       return zoomin();
               case Zoomout:
                       if (nzoom > 0)
                               nzoom--;
                       return Zoomout;
               case Xor:
                       if (xormode == F_OR || xormode == F_CLR)
                               xormode = F_XOR;
                       else if (dir == Fwd)
                               xormode = F_OR;
                       else
                               xormode = F_CLR;
                       return Hit;
               case Newfile:
                       return Newfile;
               case Quit:
                       return Quit;
               default:
                       return Hit;
               }
       } else if (last_but == 2) {
               Rectangle r;
               if (last_hit == -1)
                       return Hit;
               else if (last_hit < nview) {
                       r = getrect(2, &mouse);         /* really ought to be 2,3 */
                       if (r.min.x == 0 && r.max.x == 0)       /* bailed out */
                               return Hit;
                       if (Dx(r) < 10 || Dy(r) < 10)   /* too small */
                               return Hit;
                       if (eqpt(r.min, r.max))
                               r = inset(origscreen, INSET);
                       drawrect(inset(viewpt[last_hit], -(INSET+fatness)), F_CLR);
                       drawrect(r, F_OR);
                       viewpt[last_hit] = r = inset(r, INSET+fatness);
                       return Hit;
               } else {        /* a click */
                       if (clickval[last_hit-nview]) { /* was on, so turn off */
                               clickval[last_hit-nview] = 0;
                               clicking--;
                       } else {
                               clickval[last_hit-nview] = 1;
                               clicking++;
                       }
                       return Hit;
               }
       }
}

int zoomin(void)
{
       Rectangle r;

       r = getrect(3, &mouse);
       /* fprintf(stderr, "into zoomin %d, r %d %d %d %d\n", */
       /*       nzoom, r.min.x, r.min.y, r.max.x, r.max.y); */
       if (r.min.x == 0)       /* no selection */
               return Hit;
       if (Dx(r) < 10 || Dy(r) < 10) { /* very small */
               if (Dx(zoomr[nzoom+1]) < 10)    /* no previous one */
                       return Hit;
               r = zoomr[nzoom+1];     /* use previous one */
       } else {        /* preserve aspect ratio if near square */
               double ar = (double) Dy(r) / Dx(r);
               if (ar > 0.9 && ar < 1.1)       /* force ratio */
                       r = square(r);
       }
       /* either new one or zoom back in */
       if (nzoom < NZOOM-1) {
               nzoom++;
               zoomr[nzoom] = r;
       }
       return Zoomin;
}


do_rcv(FILE *fp)
{
       int c, n, b, m, i, v, x1, x2, y1, y2;
       char opts[100];
       char text[100];
       char *p;
       uchar *ip, *oip;

   while ((b = c = getc(fp)) != EOF) {
       switch (c) {
       case ' ':
       case '\t':
       case '\n':
               break;
       case '#':               /* comments */
               skipline(fp);
               break;
       case 'b':               /* blank.  ignore for now */
               skipline(fp);
               break;

       case 'd':       /* definition of some sort */
               switch (c = skipbl(fp)) {
               case 'v':       /* view */
               case 'c':       /* click */
                       if (fscanf(fp, "%d %s", &i, text) != 2)
                               return badfile(fp);
                       if (c == 'c') {
                               clickname[i] = malloc(strlen(text)+1);
                               strcpy(clickname[i], text);
                               nclick++;
                       } else {        /* c == 'v' */
                               viewname[i] = malloc(strlen(text)+1);
                               strcpy(viewname[i], text);
                               nview++;
                       }
                       skipline(fp);   /* might be a title there */
                       break;
               case 'p':       /* only pragma is 'e' for end */
                       skipline(fp);
                       view_setup(nview);
                       break;
               default:
                       return badfile(fp);
               }
               break;

       case 'c':               /* click */
               if (fscanf(fp, "%d", &i) != 1)
                       return badfile(fp);
               oip = savechar(c);
               savechar(i);
               savect(nextinp-oip);
               skipline(fp);
               break;
       case 'e':               /* erase */
               if (fscanf(fp, "%d", &i) != 1)
                       return badfile(fp);
               oip = savechar(c);
               savelong(slot[i]);
               savect(nextinp-oip);
               skipline(fp);
               break;

       case 'g':               /* geom:  draw line, box, circle, ... */
               if (fscanf(fp, "%d", &slotnum) != 1)
                       return badfile(fp);
               switch (c = skipbl(fp)) {
               case 'l':
               case 'b':
                       if (fscanf(fp, "%d %s %d %d %d %d", &v, opts, &x1, &y1, &x2, &y2) != 6)
                               return badfile(fp);
                       slot[slotnum] = nextinp-input;
                       oip = savechar(c);
                       savechar(v);
                       savechar(sendopt(c=='b' ? boxops : lineops, opts));     /* options */
                       savepair(x1, y1);
                       savepair(x2, y2);
                       savect(nextinp-oip);
                       break;

               case 'c':       /* circle */
                       if (fscanf(fp, "%d %s %d %d %d", &v, opts, &x1, &y1, &x2) != 5)
                               return badfile(fp);;
                       slot[slotnum] = nextinp-input;
                       oip = savechar('o');    /* 'o' is for circle */
                       savechar(v);
                       savechar(sendopt(circops, opts));
                       savepair(x1, y1);
                       saveint(x2);
                       savect(nextinp-oip);
                       break;

               case 't':       /* text */
                       if (fscanf(fp, "%d %s %d %d", &v, opts, &x1, &y1) != 4)
                               return badfile(fp);
                       slot[slotnum] = nextinp-input;
                       oip = savechar('t');
                       savechar(v);
                       savechar(sendopt(textops, opts));
                       savepair(x1, y1);
                       getc(fp);       /* skip 1 separator; no quotes */
                       for (p = text; (c = getc(fp)) != '\n'; )
                               *p++ = c;
                       *p = 0;
                       ungetc('\n', fp);
                       /* slow... */
                       p = (char *) nextinp + 1;
                       if (eq(text, "bullet"))
                               strcpy(p, "*");
                       else if (eq(text, "dot"))
                               strcpy(p, ".");
                       else if (eq(text, "circle"))
                               strcpy(p, "o");
                       else if (eq(text, "times"))
                               strcpy(p, "x");
                       else
                               strcpy(p, text);
                       *nextinp = n = strlen(p);       /* insert count before string */
                       nextinp += n + 2;               /* +2 = count before + \0 on end */
                       savect(nextinp-oip);
                       break;

               default:
                       return badfile(fp);
               }
               break;

       }
       if (b == 'c' || b == 'e' || b == 'g')   /* graphical objs */
               draw_obj(oip, F_XOR, Fwd);
       *nextinp = 0;
   }
}

badfile(FILE *fp)
{
       fprintf(stderr, "input file is not in .i format");
       while (getc(fp) != EOF)
               ;
       fclose(fp);
}

sendopt(int optvals[], char *opts)
{
       int i, n;

       n = 0;
       for (i = 0; optvals[i] && opts; i += 2)
               if (*opts == optvals[i]) {
                       n += optvals[i+1];
                       opts++;
               }
       return n;
}

clear(void)     /* screen */
{
       Rectangle r;

       screen.r = origscreen;
       r = inset(screen.r, INSET);
       bitblt(&screen, r.min, &screen, r, 0);
}


uchar *savechar(int c)
{
       *nextinp++ = c;
       return nextinp-1;
}

savect(int n)
{
       if (n > 255) {
               fprintf(stderr, "text string too long");
               n = 255;
       }
       *nextinp++ = n;
}

saveint(int n)
{
       *nextinp++ = n >> 8;
       *nextinp++ = n & 0377;
}

savelong(long n)
{
       *nextinp++ = n >> 24;
       *nextinp++ = n >> 16;
       *nextinp++ = n >> 8;
       *nextinp++ = n;
}

savepair(int x, int y)
{
       saveint(x);
       saveint(y);
}

getpoint(uchar *ip)
{
       return *ip << 8 | *(ip+1);
}

long getlong(uchar *ip)
{
       return *ip << 24 | *(ip+1) << 16 | *(ip+2) << 8 | *(ip+3);
}

Point scalept(int v, Point p)
{
       p.x = muldiv(p.x, Dx(viewpt[v]), inputscale);
       p.y = Dy(viewpt[v]) - muldiv(p.y, Dy(viewpt[v]), inputscale);
       return p;
}

scalex(int v, int x)
{
       int i;
       int nx = muldiv(x, Dx(viewpt[v]), inputscale);

       for (i = 1; i <= nzoom; i++)
               nx = nx * ((double)Dx(screen.r) / Dx(zoomr[i]));
       return nx;
}

Point fetchpt(int v, uchar *ip)
{
       Point pt;
       int i;

       pt.x = *ip << 8 | *(ip+1);
       pt.y = *(ip+2) << 8 | *(ip+3);
       pt = scalept(v, pt);
       pt = add(pt, viewpt[v].min);
       for (i = 1; i <= nzoom; i++) {
               pt.x = (pt.x-zoomr[i].min.x) * (double) Dx(zoomr[0]) / Dx(zoomr[i]);
               pt.y = (pt.y-zoomr[i].min.y) * (double) Dy(zoomr[0]) / Dy(zoomr[i]);
       }
       /* pt.x += screen.r.min.x;
       /* pt.y += screen.r.min.y;
       */
       return pt;
}

/*
 Encoding:  type, view#, opts, coords, chars, etc., # = length of group
       bvoxxyyxxyy#
       lvoxxyyxxyy#
       ovoxxyyrr#
       tvoxxyynccc0#
       ennnn#
       cn#

*/

uchar *prev_obj(uchar *ip)
{
       if (ip <= input)
               return 0;
       return ip - ip[-1] - 1;
}

uchar *next_obj(uchar *ip)
{
       if (ip < input || ip >= nextinp)
               return 0;
       switch (*ip) {
       case 0:
               return 0;
       case 'b':
       case 'l':
               return ip + 12;
       case 'o':
               return ip + 10;
       case 't':
               return ip + ip[7] + 10;
       case 'c':
               return ip + 3;
       case 'e':
               return ip + 6;
       default:
               return 0;
       }
}

uchar *step_obj(uchar *ip, int mode, int dir)   /* draw objs until one that changes something */
{
       int c;
       uchar *oip;

       if (clicking) {
               for (;;) {
                       oip = ip;
                       ip = draw_obj(ip, mode, dir);
                       if (ip == 0 || (oip && *oip == 'c' && clickval[oip[1]]))
                               return ip;
               }

       } else {        /* stepping */
               while (ip) {
                       c = *ip;
                       ip = draw_obj(ip, mode, dir);
                       if (c == 'b' || c == 'l' || c == 't' || c == 'e' || c == 'o')
                               return ip;
               }
               return ip;
       }
}

uchar *draw_obj(uchar *ip, int mode, int dir)   /* draw obj from coords at ip */
{
       int c, r, thick, n, shift, head;
       Point p0, p1, p2;

       if (ip < input || ip >= nextinp)
               return 0;
       switch (c = *ip++) {
       case 'b':
               p0 = fetchpt(*ip, ip+2);
               p1 = fetchpt(*ip, ip+6);
               if (ip[1] == Bfill) {
                       if (p0.y < p1.y)
                               /* rectf(&screen, Rpt(p0, p1), mode); */
                               bitblt(&screen, p0, &screen, Rpt(p0, p1), mode);
                       else
                               /* rectf(&screen, Rect(p0.x,p1.y,p1.x,p0.y), mode); */
                               bitblt(&screen, p0, &screen, Rect(p0.x,p1.y,p1.x,p0.y), mode);
               } else {
                       segment(&screen, p0, Pt(p0.x,p1.y), ONES, mode);
                       segment(&screen, Pt(p0.x,p1.y), p1, ONES, mode);
                       segment(&screen, p1, Pt(p1.x,p0.y), ONES, mode);
                       segment(&screen, Pt(p1.x,p0.y), p0, ONES, mode);
               }
               if (dir == Fwd)
                       ip += 1+9+1;
               else
                       ip -= (*(ip-2) + 2);
               break;
       case 'l':
               p0 = fetchpt(*ip, ip+2);
               p1 = fetchpt(*ip, ip+6);
               thick = ip[1]/10;       /* ought to be a macro! */
               if (thick == Ldotted/10 || thick == Ldashed/10)
                       thick = 1;
               thick = 2 * thick - 1;  /* 1,3,5 */
               fatline(p0, p1, mode, thick);
               head = ip[1]%10;        /* ditto */
               if (head == Larrow1 || head == Larrow3)
                       arrow(p0, p1, AW, AH, mode);
               if (head == Larrow2 || head == Larrow3)
                       arrow(p1, p0, AW, AH, mode);
               if (dir == Fwd)
                       ip += 1+9+1;
               else
                       ip -= (*(ip-2) + 2);
               break;
       case 'o':
               p0 = fetchpt(*ip, ip+2);
               r = scalex(*ip, getpoint(ip+6));
               /* fprintf(stderr, "draw circle %d at %d,%d\n", r, p0.x, p0.y); */
               if (ip[1] == Cnofill)
                       fatcircle(p0, r, mode, 1);
               else
                       disc(&screen, p0, r + fatness, ONES, mode);
               if (dir == Fwd)
                       ip += 1+7+1;
               else
                       ip -= (*(ip-2) + 2);
               break;
       case 't':
               p0 = fetchpt(*ip, ip+2);
               /* fprintf(stderr, "draw text %s at %d,%d\n", ip+7, p0.x, p0.y); */
               n = ip[6];
               shift = (ip[1]/10) * 10;        /* ought to be a macro! */
               if (shift == Tljust)
                       shift = 0;
               else if (shift == Tcenter)
                       shift = (9 * n) / 2;    /* 9 = char width */
               else
                       shift = 9 * n;
               string(&screen, sub(p0, Pt(shift,6)), font, (char *) ip+7, mode);
               if (dir == Fwd)
                       ip += 1+5 + *(ip+6)+2 + 1;
               else
                       ip -= (*(ip-2) + 2);
               break;
       case 'e':
               erase(ip-1);
               if (dir == Fwd)
                       ip += 5;
               else
                       ip -= (*(ip-2) + 2);
               break;
       case 'c':
               if (dir == Fwd)
                       ip += 2;
               else
                       ip -= (*(ip-2) + 2);
               break;
       default:
               ip = 0;
               break;
       }
       return ip;
}

erase(uchar *ip)
{
       long target = getlong(ip+1);    /* target label index */
       int mode = F_XOR;

       if (xormode == F_OR || xormode == F_CLR)
               mode = dir == Fwd ? F_CLR : F_OR;
       draw_obj(input+target, mode, Fwd);
}

#define abs(x) ((x) >= 0 ? (x) : -(x))

fatline(Point p0, Point p1, int mode, int thick)
{
       int i, fat, beg, nl;

       fat = thick * (2 * fatness + 1);
       beg = fat / 2;
       if (abs(p1.x-p0.x) >= abs(p1.y-p0.y)) { /* horizontal */
               for (nl = 0, i = -beg; nl < fat; nl++, i++)
                       segment(&screen, add(p0, Pt(0,i)), add(p1, Pt(0,i)), ONES, mode);
       } else {
               for (nl = 0, i = -beg; nl < fat; nl++, i++)
                       segment(&screen, add(p0, Pt(i,0)), add(p1, Pt(i,0)), ONES, mode);
       }
}

fatcircle(Point p0, int r, int mode, int thick)
{
       int i, fat, beg, nl;

       fat = thick * (2 * fatness + 1);
       beg = fat / 2;
       for (nl = 0, i = -beg; nl < fat; nl++, i++)
               circle(&screen, p0, r+i, ONES, mode);
}

arrow(Point p1, Point p2, int w, int h, int c)
       /* draw arrow of height,width (h,w) at p2 of segment p1,p2 */
{
       Point d;
       int norm, qx, qy, lx, ly;

       d = sub(p2, p1);
       norm = sqrt((long)d.x*d.x + (long)d.y*d.y);
       if (norm == 0)  /* shouldn't happen, but ... */
               return;
       qx = p2.x - muldiv(h, d.x, norm);
       qy = p2.y - muldiv(h, d.y, norm);
       lx = muldiv(w/2, -d.y, norm);
       ly = muldiv(w/2, d.x, norm);
       /* segment(&screen, p1, p2, c); */
       segment(&screen, Pt(qx+lx, qy+ly), p2, ONES, c);
       segment(&screen, Pt(qx-lx, qy-ly), p2, ONES, c);
}

skipbl(FILE *fp)
{
       int c;

       while ((c = getc(fp)) == ' ' || c == '\t')
               ;
       return c;
}

skipline(FILE *fp)
{
       int c;

       while ((c = getc(fp)) != '\n')
               ;
       ungetc('\n', fp);
}

char *m3gen(int n)
{
       static char buf[50];

       if (n < 0 || n > Quit)
               return 0;
       else if (n == Faster) {
               sprintf(buf, "faster %d", delay);
               return buf;
       } else if (n == Slower) {
               sprintf(buf, "slower %d", delay);
               return buf;
       } else if (n == Step) {
               return stepmenu[singstep];
       } else if (n == Forward) {
               return dirmenu[dir];
       } else if (n == Fatter) {
               sprintf(buf, "fatter %d", fatness+1);
               return buf;
       } else if (n == Thinner) {
               sprintf(buf, "thinner %d", fatness+1);
               return buf;
       } else if (n == Xor) {
               return xormode == F_XOR ? modemenu[0] : modemenu[1];
       } else
               return m3[n];
}

char *m2gen(int n)
{
       static char buf[50];

       if (n < 0 || n >= nview+nclick)
               return 0;
       else if (n < nview) {
               sprintf(buf, "view %s", viewname[n]);
               return buf;
       } else {
               sprintf(buf, "click %s%s",
                       clickname[n-nview], clickval[n-nview] ? "*" : "");
               return buf;
       }
}


#define button3(b)      ((b) & 4)
#define button2(b)      ((b) & 2)
#define button1(b)      ((b) & 1)
#define button23(b)     ((b) & 6)
#define button123(b)    ((b) & 7)

int buttondown(void)    /* report state of buttons, if any */
{
       if (!ecanmouse())       /* no event pending */
               return 0;
       mouse = emouse();       /* something, but it could be motion */
       return mouse.buttons & 7;
}

int waitdown(void)      /* wait until some button is down */
{
       while (!(mouse.buttons & 7))
               mouse = emouse();
       return mouse.buttons & 7;
}

int waitup(void)
{
       while (mouse.buttons & 7)
               mouse = emouse();
       return mouse.buttons & 7;
}

checkmouse(void)        /* return button touched if any */
{
       int c, b;
       char *p = NULL;
       extern int confirm(int);

       b = waitdown();
       last_but = 0;
       last_hit = -1;
       c = 0;
       if (button3(b)) {
               last_hit = menuhit(3, &mouse, &mbut3);
               last_but = 3;
       } else if (button2(b)) {
               last_hit = menuhit(2, &mouse, &mbut2);
               last_but = 2;
       } else {                /* button1() */
               last_but = 1;
       }
       waitup();
       if (last_but == 3 && last_hit >= 0) {
               p = m3[last_hit];
               c = p[strlen(p) - 1];
       }
       if (c == '?' && !confirm(last_but))
               last_hit = -1;
       return last_but;
}

confirm(int but)        /* ask for confirmation if menu item ends with '?' */
{
       int c;
       static int but_cvt[8] = { 0, 1, 2, 0, 3, 0, 0, 0 };

       cursorswitch(&skull);
       c = waitdown();
       waitup();
       cursorswitch(0);
       return but == but_cvt[c];
}

Cursor deadmouse = {
       { 0, 0},        /* offset */
       { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x0C, 0x00, 0x82, 0x04, 0x41,
         0xFF, 0xE1, 0x5F, 0xF1, 0x3F, 0xFE, 0x17, 0xF0,
         0x03, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
       { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x0C, 0x00, 0x82, 0x04, 0x41,
         0xFF, 0xE1, 0x5F, 0xF1, 0x3F, 0xFE, 0x17, 0xF0,
         0x03, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
};

Cursor skull ={
       { 0, 0 },
       { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03,
         0xE7, 0xE7, 0x3F, 0xFC, 0x0F, 0xF0, 0x0D, 0xB0,
         0x07, 0xE0, 0x06, 0x60, 0x37, 0xEC, 0xE4, 0x27,
         0xC3, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
       { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03,
         0xE7, 0xE7, 0x3F, 0xFC, 0x0F, 0xF0, 0x0D, 0xB0,
         0x07, 0xE0, 0x06, 0x60, 0x37, 0xEC, 0xE4, 0x27,
         0xC3, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
};


do_kbd(void)    /* read a line from keyboard */
{
       char *p;

       for (p = kbdline; (*p = ekbd()) != '\n' && *p != '\r'; p++) {
               /* fprintf(stderr, "%c", *p); */
               if (*p == '\b')
                       p -= 2;
               if (p < kbdline)
                       p = kbdline;
               p[1] = 0;
               putstring(kbdline);

       }
       *p = 0;
       /* fprintf(stderr, "\n"); */
       /* fprintf(stderr, "\nfilename is [%s]\n", kbdline); */
       return strlen(kbdline);
}

void putstring(char *buf)
{
       Point p;
       static int jmax = 0, l;

       p = add(screen.r.min, Pt(20,20));
       bitblt(&screen, p, &screen, Rect(p.x, p.y, p.x+jmax, p.y+font->height), F_CLR);
       string(&screen, p, font, buf, F_OR);
       if ((l = strwidth(font, buf)) > jmax)
               jmax = l;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.