home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / MISC / NETWORK / TEL23SRC.ZIP / TEK / VGTEK.C < prev   
Encoding:
C/C++ Source or Header  |  1991-06-24  |  32.5 KB  |  1,446 lines
  1. /*
  2. vgtek.c by Aaron Contorer 1987 for NCSA
  3. bugfixes by Tim Krauskopf 1988
  4.  
  5. Takes Tektronix codes as input; sends output to real graphics devices.
  6.  
  7. CHANGES TO MAKE:
  8. Create a function to make sure a window is attached to a real window.
  9. Calling program will call this whenever switching between active windows.
  10. Pass virtual window number to RG driver so it can call back.
  11. */
  12.  
  13. #define FALSE 0
  14. #define TRUE 1
  15. #define MAXVG 20     /* maximum number of VG windows */
  16.                     /* temporary states */
  17. #define HIY 0        /* waiting for various pieces of coordinates */
  18. #define EXTRA 1
  19. #define LOY 2
  20. #define HIX 3
  21. #define LOX 4
  22. #define DONE 5        /* not waiting for coordinates */
  23. #define ENTERVEC 6    /* entering vector mode */
  24. #define CANCEL 7    /* done but don't draw a line */
  25. #define RS 8        /* RS - incremental plot mode */
  26. #define ESCOUT 9    /* when you receive an escape char after a draw command */
  27. #define CMD0 50        /* got esc, need 1st cmd letter */
  28. #define SOMEL 51    /* got esc L, need 2nd letter */
  29. #define IGNORE 52    /* ignore next char */
  30. #define SOMEM 53    /* got esc M, need 2nd letter */
  31. #define IGNORE2 54
  32. #define INTEGER 60    /* waiting for 1st integer part */
  33. #define INTEGER1 61    /* waiting for 2nd integer part */
  34. #define INTEGER2 62    /* waiting for 3rd (last) integer part */
  35. #define COLORINT 70
  36. #define GTSIZE0 75
  37. #define GTSIZE1 76
  38. #define SOMET 80
  39. #define JUNKARRAY 81
  40. #define STARTDISC 82
  41. #define DISCARDING 83
  42.                     /* output modes */
  43. #define ALPHA 0
  44. #define DRAW 1
  45. #define MARK 3
  46. #define TEMPDRAW 101
  47. #define TEMPMOVE 102
  48. #define TEMPMARK 103
  49.                     /* stroked fonts */
  50. #define CHARWIDE 51        /* total horz. size */
  51. #define CHARTALL 76        /* total vert. size */
  52. #define CHARH 10        /* horz. unit size */
  53. #define CHARV 13        /* vert. unit size */
  54.                     /* RG coordinate space dimensions */
  55. #define RGXSIZE 4096
  56. #define RGYSIZE 4096
  57.  
  58. #include <stdlib.h>
  59. #include <stdio.h>
  60. #include <fcntl.h>
  61. #include <string.h>
  62. #ifdef MEMORY_DEBUG
  63. #include "memdebug.h"
  64. #endif
  65. #include "externs.h"
  66. #include "vgtek.h"
  67. #include "vgfont.h"
  68. #include "tekstor.h"
  69.  
  70. #ifdef MSC
  71. #define mousecl    mousecml
  72. #endif
  73.  
  74. static void clipvec(int vw, int xa, int ya, int xb, int yb);
  75. static int fontnum(int vw, int n);
  76. static void storexy(int vw, int x, int y);
  77. static int joinup(int hi, int lo, int e);
  78. static void newcoord(int vw);
  79. static void linefeed(int vw);
  80. static int drawc(int vw, char c);
  81. static int clipt(double p, double q, double *t0, double *t1);
  82.  
  83. #ifdef QAK
  84. void setgin();                /* routine to kick into GIN mode */
  85. void resetgin();            /* routine to get out of GIN mode */
  86. int donothing();
  87. #endif
  88. extern unsigned char s[550];
  89. extern struct config def;
  90. extern int ftpok, rcpok, temptek, viewmode;
  91. extern int ginon;           /* whether we are in GIN mode or not */
  92. extern int mighty;            /* whether there is a mouse or not hooked up to the system */
  93.  
  94. struct VGWINTYPE 
  95. {
  96.     int RGdevice, RGnum;
  97.     char mode,modesave;                 /* current output mode */
  98.     char loy,hiy,lox,hix,ex,ey;         /* current graphics coordinates */
  99.     char nloy,nhiy,nlox,nhix,nex,ney;     /* new coordinates */
  100.     int curx,cury;                        /* current composite coordinates */
  101.     int winbot,wintop,winleft,winright,wintall,winwide; /* position of window in virtual space */
  102.     int textcol;                        /* text starts in 0 or 2048 */
  103.     int intin;                            /* integer parameter being input */
  104.     int pencolor;                        /* current pen color */
  105.     int fontnum,charx,chary;             /* char size */
  106.     int count;                             /* for temporary use in special state loops */
  107. };
  108.  
  109. static struct VGWINTYPE VGwin[MAXVG];         /* virtual window descriptors */
  110. static char state[MAXVG],savstate[MAXVG];    /* save state in a parallel array for speed */
  111. static STOREP VGstore[MAXVG];                 /* the store where data for this window is kept */
  112. static char storing[MAXVG];                 /* are we currently saving data from this window */
  113. static int drawing[MAXVG];                     /* redrawing or not? */
  114.  
  115. #define NUMSIZES 6                             /* number of char sizes */
  116. static int charxset[NUMSIZES] = {56,51,34,31,112,168};
  117. static int charyset[NUMSIZES] = {88,82,53,48,176,264};
  118.  
  119. void showmouse(void)
  120. {
  121.     int m1=1,m2=0,m3=0,m4=0;        /* mouse variables to show the mouse cursor */
  122.  
  123.     if(mighty) {
  124.         vprint(console->vs, "Mouse Shown\r\n");
  125.         mousecl(&m1,&m2,&m3,&m4);    /* call mouse routine to show mouse cursor */
  126.     }
  127. }                                    /* end showmouse() */
  128.  
  129. void hidemouse(void)
  130. {
  131.     int m1=2,m2=0,m3=0,m4=0;        /* mouse variables to hide the mouse cursor */
  132.  
  133.     if(mighty) {
  134.         vprint(console->vs, "Mouse hidden\r\n");
  135.         mousecl(&m1,&m2,&m3,&m4);    /* call mouse routine to hide mouse cursor */
  136.     }
  137. }                                    /* end hidemouse() */
  138.  
  139. /**************************************************************************/
  140. /*  dispgr
  141. *   display graphics menu screen
  142. */
  143. void dispgr(void)
  144. {
  145.     int c,i,j,k,l;
  146.  
  147.     c=n_color(current->colors[0]);
  148.     n_clear();
  149.     n_cur(0,0);
  150.     n_puts("ALT-G                           Graphics menu");
  151.     n_puts("<            Press the appropriate function key or ESC to resume        >\n");
  152.     strcpy(s,"   F1 - Write postscript to a file called: ");
  153.     strcat(s,def.psfile);
  154.     n_puts(s);
  155.     n_puts(  "   F2 - Change postscript output file name\n");
  156.     strcpy(s,"   F3 - Write HPGL code to a file called: ");
  157.     strcat(s,def.hpfile);
  158.     n_puts(s);
  159.     n_puts(  "   F4 - Change HPGL output file name\n");
  160.     strcpy(s,"   F5 - Write Tektronix 4014 codes to a file called: ");
  161.     strcat(s,def.tekfile);
  162.     n_puts(s);
  163.     n_puts(  "   F6 - Change Tektronix output file name\n");
  164.     VGwhatzoom(temptek,&i,&j,&k,&l);
  165.     sprintf(s,"        View region is currently: %d,%d,%d,%d",i,j,k,l);
  166.     n_puts(s);
  167.     n_puts("   F7 - Set a new view region (Zoom, Pan)");
  168.     n_puts("   RETURN - draw picture on screen in current zoom factor\n");
  169.     n_puts("   Enter choice:");
  170.     viewmode=8;
  171.     n_color(c);
  172. }
  173.  
  174. /*******************************************************************/
  175. /*
  176. *    Set font for window 'vw' to size 'n'.
  177. *    Sizes are 0..3 in Tek 4014 standard.
  178. *    Sizes 4 & 5 are used internally for Tek 4105 emulation.
  179. */
  180. static int fontnum(vw,n)
  181. int vw,n;
  182.  
  183. {
  184.     if(n<0||n>=NUMSIZES)
  185.             return(-1);
  186.     VGwin[vw].fontnum=n;
  187.     VGwin[vw].charx=charxset[n];
  188.     VGwin[vw].chary=charyset[n];
  189.     return(0);
  190. }
  191.  
  192. static void storexy(vw,x,y)
  193. int vw,x,y;
  194.                 
  195. /* set graphics x and y position */
  196. {
  197.     VGwin[vw].curx=x;
  198.     VGwin[vw].cury=y;
  199. }
  200.  
  201. static int joinup(hi,lo,e)
  202. int hi,lo,e;
  203.  
  204. /* returns the number represented by the 3 pieces */
  205. {
  206.     return (((hi/*&31*/)<<7)|((lo/*&31*/)<<2)|(e/*&3*/));    /* end joinup() */
  207. }
  208.  
  209. static void newcoord(vw)
  210. int vw;
  211.  
  212. /*
  213.     Replace x,y with nx,ny
  214. */
  215. {
  216.     VGwin[vw].hiy=VGwin[vw].nhiy;
  217.     VGwin[vw].hix=VGwin[vw].nhix;
  218.     VGwin[vw].loy=VGwin[vw].nloy;
  219.     VGwin[vw].lox=VGwin[vw].nlox;
  220.     VGwin[vw].ey=VGwin[vw].ney;
  221.     VGwin[vw].ex=VGwin[vw].nex;
  222.     VGwin[vw].curx=joinup(VGwin[vw].nhix,VGwin[vw].nlox,VGwin[vw].nex);
  223.     VGwin[vw].cury=joinup(VGwin[vw].nhiy,VGwin[vw].nloy,VGwin[vw].ney);
  224. }
  225.  
  226. static void linefeed(int vw)
  227.  
  228. /* 
  229.     Perform a linefeed & cr(CHARTALL units) in specified window.
  230. */
  231. {
  232.  
  233. /*    int y=joinup(VGwin[vw].hiy,VGwin[vw].loy,VGwin[vw].ey);*/
  234.  
  235.     int y=VGwin[vw].cury;
  236.     int x;
  237.     if(y>VGwin[vw].chary) 
  238.         y -=VGwin[vw].chary;
  239.     else {
  240.         y= 3119-VGwin[vw].chary;
  241.         VGwin[vw].textcol=2048-VGwin[vw].textcol;
  242.       }
  243.     x=VGwin[vw].textcol;
  244.     storexy(vw,x,y);
  245. }
  246.     
  247. #ifdef DEBUG
  248. static int drawc(vw,c)
  249. int vw;
  250. char c;                 /* character to draw */
  251. {
  252.     putchar(c);
  253. }
  254.  
  255. #else
  256. static drawc(vw,c)
  257. int vw;
  258. char c;             /* character to draw */
  259. /*
  260.     Draw a stroked character at the current cursor location.
  261.     Uses simple 8-directional moving, 8-directional drawing.
  262. */
  263. {
  264.     int x,y,savex,savey,strokex,strokey;
  265.     int n;            /* number of times to perform command */
  266.     char *pstroke;    /* pointer into stroke data */
  267.     int hmag,vmag;
  268.  
  269.     if(c==10) {
  270.         linefeed(vw);
  271.         return(0);
  272.       }
  273.     if(c==7) {
  274.         (*RG[VGwin[vw].RGdevice].bell)(VGwin[vw].RGnum);
  275.         unstore(VGstore[vw]);
  276.         return(0);
  277.       }
  278.     savey=y=VGwin[vw].cury;
  279.     savex=x=VGwin[vw].curx;
  280.     if(c==8) {
  281.         if(savex<=VGwin[vw].textcol)
  282.             return(0);
  283.         savex-=VGwin[vw].charx;
  284.         if(savex<VGwin[vw].textcol) 
  285.             savex=VGwin[vw].textcol;
  286.         VGwin[vw].cury=savey;
  287.         VGwin[vw].curx=savex;
  288.         return(0);
  289.       }
  290.     hmag=VGwin[vw].charx / 10;
  291.     vmag=VGwin[vw].chary / 10;
  292.     if(3119-savey<VGwin[vw].chary) {
  293.         savey=y=3119-VGwin[vw].chary;
  294.       }
  295.     if(c<32||c>126) 
  296.         return(0);
  297.     c-=32;
  298.     pstroke=VGfont[c];
  299.     while(*pstroke) {
  300.         strokex=x;
  301.         strokey=y;
  302.         n=(*(pstroke++)-48);    /* run length */
  303.         c=*(pstroke++);            /* direction code */
  304.         switch(c) {             /* horizontal movement: positive=right */
  305.             case 'e': 
  306.             case 'd': 
  307.             case 'c': 
  308.             case 'y': 
  309.             case 'h': 
  310.             case 'n':
  311.                 x+=n*hmag;
  312.                 break;
  313.  
  314.             case 'q': 
  315.             case 'a': 
  316.             case 'z': 
  317.             case 'r': 
  318.             case 'f': 
  319.             case 'v':
  320.                 x-=n*hmag;
  321.           }
  322.  
  323.         switch(c) {         /* vertical movement: positive=up */
  324.             case 'q': 
  325.             case 'w': 
  326.             case 'e': 
  327.             case 'r': 
  328.             case 't': 
  329.             case 'y':
  330.                 y+=n*vmag;
  331.                 break;
  332.  
  333.             case 'z': 
  334.             case 'x': 
  335.             case 'c': 
  336.             case 'v': 
  337.             case 'b': 
  338.             case 'n':
  339.                 y-=n*vmag;
  340.           }
  341.  
  342.         switch(c) {         /* draw or move */
  343.             case 'r': 
  344.             case 't': 
  345.             case 'y': 
  346.             case 'f': 
  347.             case 'h':
  348.             case 'v': 
  349.             case 'b': 
  350.             case 'n':
  351.                 clipvec(vw,strokex,strokey,x,y);
  352.                 break;
  353.           }
  354.     
  355.       }                     /* end while not at end of string */
  356.  
  357. /* Update cursor location to next char position */
  358.     if(savex+2*VGwin[vw].chary<=4096)savex+=VGwin[vw].charx;
  359.     else {
  360.         savey-=VGwin[vw].chary;
  361.         if(savey<0) {
  362.             savey= 3119-VGwin[vw].chary; 
  363.             VGwin[vw].textcol=2048 - VGwin[vw].textcol;
  364.           }
  365.         savex=VGwin[vw].textcol;
  366.       }
  367.     VGwin[vw].cury=savey;
  368.     VGwin[vw].curx=savex;         /* end drawc() */
  369. }
  370.  
  371. #endif
  372.  
  373. static int clipt(p, q, t0, t1)
  374. double p,
  375. q,
  376. *t0,
  377. *t1;            /* To be called only by clipvec() */
  378. {
  379.     double r;
  380.     int accept=(int)TRUE;
  381.  
  382.     if(p<0.0) {
  383.         r=q/p;
  384.         if(r>*t1) 
  385.             accept=(int)FALSE;
  386.         else 
  387.             if(r>*t0) 
  388.                 *t0=r;
  389.       }
  390.     else 
  391.         if(p>0.0) {
  392.             r=q/p;
  393.             if(r<*t0) 
  394.                 accept=FALSE;
  395.             else 
  396.                 if(r<*t1) 
  397.                     *t1=r;
  398.           }
  399.         else 
  400.             if(q<0.0) 
  401.                 accept=FALSE;
  402.         return(accept);
  403. }
  404.  
  405. #ifdef DEBUG
  406. static void clipvec(vw,xa,ya,xb,yb)
  407. int vw;
  408. int xa,ya,xb,yb;
  409. {
  410.     printf("%d,%d to %d,%d\n",xa,ya,xb,yb);
  411. }
  412.  
  413. #else
  414. static void clipvec(vw,xa,ya,xb,yb)
  415. int vw;
  416. int xa,ya,xb,yb;
  417. /*
  418.     Draw a vector in vw's window from x0,y0 to x1,y1.
  419.     Zoom the vector to the current visible window,
  420.     and clip it before drawing it.
  421.     Uses Liang-Barsky algorithm from ACM Transactions on Graphics,
  422.         Vol. 3, No. 1, January 1984, p. 7.
  423. */
  424. {
  425.     int t,b,l,r;
  426.     double x0,y0,x1,y1,t0,t1,deltay,deltax;
  427.     struct VGWINTYPE *vp;
  428.     vp=&VGwin[vw];
  429.  
  430.     t=vp->wintop;
  431.     b=vp->winbot;
  432.     l=vp->winleft;
  433.     r=vp->winright;
  434.  
  435. /* totally visible */
  436.     if(xa<=r&&xb<=r&&xa>=l&&xb>=l&&ya<=t&&yb<=t&&ya>=b&&yb>=b) {
  437.         if (ginon) hidemouse();  /* hide mouse cursor */
  438.         (*RG[vp->RGdevice].drawline)(vp->RGnum,
  439.         (int)((long)(xa - l) * RGXSIZE / vp->winwide),
  440.         (int)((long)(ya- b) * RGYSIZE / vp->wintall),
  441.         (int)((long)(xb - l) * RGXSIZE / vp->winwide),
  442.         (int)((long)(yb- b) * RGYSIZE / vp->wintall));
  443.         if (ginon) showmouse();     /* show mouse cursor */
  444.         return;
  445.       }
  446. /* trivially invisible */
  447.     if((xa>r&&xb>r)||(xa<l&&xb<l)||(ya<b&&yb<b)||(ya>t&&yb>t)) 
  448.         return;
  449. /* the clipping algorithm */
  450.     x0=(double)xa;
  451.     y0=(double)ya;
  452.     x1=(double)xb;
  453.     y1=(double)yb;
  454.     t0=0.0;
  455.     t1=1.0;
  456.     deltax=x1-x0;
  457.  
  458.     if(clipt(-deltax,x0-l,&t0,&t1)) {
  459.         if(clipt(deltax,r-x0,&t0,&t1)) {
  460.             deltay=y1-y0;
  461.             if(clipt(-deltay,y0-b,&t0,&t1)) {
  462.                 if(clipt(deltay,t-y0,&t0,&t1)) {
  463.                     if(t1<1.0) {
  464.                         x1=x0+t1*deltax;
  465.                         y1=y0+t1*deltay;
  466.                       }
  467.                     if(t0>0.0) {
  468.                         x0+=t0*deltax;
  469.                         y0+=t0*deltay;
  470.                       }
  471. /* draw the line, it is at least partially visible */
  472.                     (*RG[vp->RGdevice].drawline)(vp->RGnum,
  473.                         (int)((long)((int)x0-l)*RGXSIZE/vp->winwide),
  474.                         (int)((long)((int)y0-b)*RGYSIZE/vp->wintall),
  475.                         (int)((long)((int)x1-l)*RGXSIZE/vp->winwide),
  476.                         (int)((long)((int)y1-b)*RGYSIZE/vp->wintall));
  477.                   } 
  478.               } 
  479.           } 
  480.       }             /* end if */
  481. }                     /* end clipvec() */
  482. #endif
  483.  
  484. /*******************************************************
  485. ********************************************************
  486. All routines given below may be called by the user
  487. program.  No routines given above may be called from
  488. the user program.
  489. ********************************************************
  490. *******************************************************/
  491.  
  492. void VGinit(void)
  493. /*
  494.     Initialize the whole VG environment.  Should be called ONCE
  495.     at program startup before using the VG routines.
  496. */
  497. {
  498.     int i;
  499.     for(i=0; i<MAXVG; i++)
  500.         VGwin[i].RGdevice=-1; /* no device */
  501. #ifndef DEBUG
  502.     for(i=0; i<MAXRG; i++) 
  503.         (*RG[i].init)();
  504. #endif
  505. }
  506.  
  507. void VGuncover(int vw)
  508. /*
  509.     Make sure window is completely visible, rather than partly or
  510.     completely invisible.
  511.     This function is to be called whenever a window is made active,
  512.     to ensure that the user can see it.
  513. */
  514. {
  515. #ifndef DEBUG
  516.     (*RG[VGwin[vw].RGdevice].uncover)(VGwin[vw].RGnum);
  517. #endif
  518. }
  519.  
  520. int VGdevice(vw,dev)
  521. int vw,dev;
  522. /*
  523.     Detach window from its current device and attach it to the
  524.     specified device.  Returns negative number if unable to do so.
  525.     Sample application:  switching an image from #9 to Hercules.
  526.     Must redraw after calling this.
  527. */
  528. {
  529.     int newwin;
  530.     newwin=(*RG[dev].newwin)();
  531.     if(newwin<0) 
  532.         return((int)newwin);         /* unable to open new window */
  533.     (*RG[VGwin[vw].RGdevice].close)(VGwin[vw].RGnum);
  534.     VGwin[vw].RGdevice=dev;
  535.     VGwin[vw].RGnum=newwin;
  536.     VGwin[vw].pencolor=1;
  537.     fontnum(vw,1);
  538.     return(0);
  539. }
  540.  
  541. int VGnewwin(device)
  542. int device;                     /* number of RG device to use */
  543. /*
  544.     Create a new VG window and return its number.
  545.     New window will be attached to specified real device.
  546.     Returns -1 if unable to create a new VG window.
  547. */
  548. {
  549.     int vw=0;
  550.     while(vw<MAXVG&&VGwin[vw].RGdevice!=-1)
  551.         vw++;
  552.     if(vw==MAXVG) {
  553.         return(-1);
  554.       }
  555.     VGstore[vw]=newstore();
  556.     if(VGstore[vw]==NULL) {
  557.         return(-1);                /* no memory */
  558.       }
  559.     VGwin[vw].RGdevice=device;
  560.     VGwin[vw].RGnum=(*RG[device].newwin)();
  561.     if(VGwin[vw].RGnum< 0) {    /* no windows available on device */
  562.         freestore(VGstore[vw]);
  563.         return(-1);
  564.       }
  565.     VGwin[vw].mode=ALPHA;
  566.     state[vw]=DONE;
  567.     storing[vw]=TRUE;
  568.     VGwin[vw].textcol=0;
  569.     drawing[vw]=1;
  570.     fontnum(vw,0);
  571.     (*RG[device].pencolor)(VGwin[vw].RGnum,1);
  572.     storexy(vw,0,3071);
  573.     VGzoom(vw,0,0,4095,3119);
  574.     return(vw);
  575. }
  576.  
  577. void VGclrstor(vw)
  578. int vw;
  579. /* 
  580.     Clear the store associated with window vw.  
  581.     All contents are lost.
  582.     User program can call this whenever desired.
  583.     Automatically called after receipt of Tek page command.
  584. */
  585. {
  586.     freestore(VGstore[vw]);
  587.     VGstore[vw]=newstore();/* Don't have to check for errors; there was definitelyenough memory. */
  588. }
  589.  
  590. /*
  591.     Successively call the function pointed to by 'func' for each
  592.     character stored from window vw.  Each character will
  593.     be passed in integer form as the only parameter.  A value of -1
  594.     will be passed on the last call to indicate the end of the data.
  595. */
  596. void VGdumpstore(vw,func)
  597. int vw;
  598. void (*func)(int data);
  599. {
  600.     int data;
  601.     STOREP st=VGstore[vw];
  602.  
  603.     topstore(st);
  604.     while((data=nextitem(st))!=-1)(*func)(data);
  605.     (*func)(-1);
  606. }
  607.  
  608. void VGdraw(vw,c)
  609. int vw;
  610. char c;             /* the latest input char */
  611. /*
  612.     This is the main Tek emulator process.  Pass it the window and
  613.     the latest input character, and it will take care of the rest.
  614.     Calls RG functions as well as local zoom and character drawing
  615.     functions.
  616. */
  617. {
  618.     char cmd;
  619.     char value;
  620.     char goagain; /* true means go thru the function a second time */
  621.     struct VGWINTYPE *vp;
  622.     vp=&VGwin[vw];
  623.  
  624. /*** MAIN LOOP ***/
  625.      do {
  626.         cmd=(char) ((c>>5) & 0x03);
  627.         value=(char) (c&0x1f);
  628.         goagain=FALSE;
  629.         switch(state[vw]) {
  630.             case HIY:             /* beginning of a vector */
  631.                 vp->nhiy=vp->hiy;
  632.                 vp->nhix=vp->hix;
  633.                 vp->nloy=vp->loy;
  634.                 vp->nlox=vp->lox;
  635.                 vp->ney =vp->ey;
  636.                 vp->nex =vp->ex;
  637.                 switch(cmd) {
  638.                     case 0:
  639.                         if(value==27) {        /* escape sequence */
  640.                             state[vw]=ESCOUT;
  641.                             savstate[vw]=HIY;
  642.                           }
  643.                         else 
  644.                             if(value<27)     /* ignore */
  645.                                 break;
  646.                             else {
  647.                                 state[vw]=CANCEL;
  648.                                 goagain=TRUE;
  649.                               }
  650.                         break;
  651.  
  652.                     case 1:                 /* hiy */
  653.                         vp->nhiy=value;
  654.                         state[vw]=EXTRA;
  655.                         break;
  656.  
  657.                     case 2:                 /* lox */
  658.                         vp->nlox=value;
  659.                         state[vw]=DONE;
  660.                         break;
  661.  
  662.                     case 3:                 /* extra or loy */
  663.                         vp->nloy=value;
  664.                         state[vw]=LOY;
  665.                         break;
  666.                     }
  667.                 break;        
  668.     
  669.             case ESCOUT:
  670.                 if(value!=13&&value!=10&&value!=27&&value!='~') {    /* skip all EOL-type characters */
  671.                     state[vw]=savstate[vw];
  672.                     goagain=TRUE;
  673.                   }
  674.                 break;
  675.  
  676.             case EXTRA:                        /* got hiy; expecting extra or loy */
  677.                 switch(cmd) {
  678.                     case 0:
  679.                         if(value==27) {        /* escape sequence */
  680.                             state[vw]=ESCOUT;
  681.                             savstate[vw]=EXTRA;
  682.                           }
  683.                         else 
  684.                             if(value<27)    /* ignore */
  685.                                 break;
  686.                             else {
  687.                                 state[vw]=DONE;
  688.                                 goagain=TRUE;
  689.                               }
  690.                             break;
  691.  
  692.                     case 1:                 /* hix */
  693.                         vp->nhix=value;
  694.                         state[vw]=LOX;
  695.                         break;
  696.  
  697.                     case 2:                 /* lox */
  698.                         vp->nlox=value;
  699.                         state[vw]=DONE;
  700.                         break;
  701.  
  702.                     case 3:                 /* extra or loy */
  703.                         vp->nloy=value;
  704.                         state[vw]=LOY;
  705.                         break;
  706.                     }
  707.                 break;
  708.     
  709.             case LOY:                         /* got extra or loy; next may be loy or something else */
  710.                 switch(cmd) {
  711.                     case 0:
  712.                         if(value==27) {        /* escape sequence */
  713.                             state[vw]=ESCOUT;
  714.                             savstate[vw]=LOY;
  715.                           }
  716.                         else 
  717.                             if(value<27)     /* ignore */
  718.                                 break;
  719.                             else {
  720.                                 state[vw]=DONE;
  721.                                 goagain=TRUE;
  722.                               }
  723.                         break;
  724.  
  725.                     case 1:                 /* hix */
  726.                         vp->nhix=value;
  727.                         state[vw]=LOX;
  728.                         break;
  729.  
  730.                     case 2:                 /* lox */
  731.                         vp->nlox=value;
  732.                         state[vw]=DONE;
  733.                         break;
  734.  
  735.                     case 3:                 /* this is loy; previous loy was really extra */
  736.                         vp->ney=(char) ((vp->nloy>>2)&3);
  737.                         vp->nex=(char) ((vp->nlox) & 3);
  738.                         vp->nloy=value;
  739.                         state[vw]=HIX;
  740.                         break;
  741.  
  742.                   }
  743.                 break;
  744.     
  745.             case HIX:                         /* hix or lox */
  746.                 switch(cmd) {
  747.                     case 0:
  748.                         if(value==27) {        /* escape sequence */
  749.                             state[vw]=ESCOUT;
  750.                             savstate[vw]=HIX;
  751.                           }
  752.                         else 
  753.                             if(value<27)    /* ignore */
  754.                                 break;
  755.                             else {
  756.                                 state[vw]=DONE;
  757.                                 goagain=TRUE;
  758.                               }
  759.                         break;
  760.  
  761.                     case 1:                 /* hix */
  762.                         vp->nhix=value;
  763.                         state[vw]=LOX;
  764.                         break;
  765.  
  766.                     case 2:                     /* lox */
  767.                         vp->nlox=value;
  768.                         state[vw]=DONE;
  769.                         break;
  770.                   }
  771.                  break;
  772.     
  773.             case LOX:                         /* must be lox */
  774.                 switch(cmd) {
  775.                     case 0:
  776.                         if(value==27) {        /* escape sequence */
  777.                             state[vw]=ESCOUT;
  778.                             savstate[vw]=LOX;
  779.                           }
  780.                         else 
  781.                             if(value< 27)     /* ignore */
  782.                                 break;
  783.                             else {
  784.                                 state[vw]=DONE;
  785.                                 goagain=TRUE;
  786.                               }
  787.                         break;
  788.  
  789.                     case 2:
  790.                         vp->nlox=value;
  791.                         state[vw]=DONE;
  792.                         break;
  793.  
  794.                   }
  795.                 break;
  796.     
  797.             case ENTERVEC:
  798.                 if(c==7)
  799.                     vp->mode=DRAW;
  800.                 if(c<27)
  801.                     break;
  802.                 state[vw]=HIY;
  803.                 vp->mode=TEMPMOVE;
  804.                 vp->modesave=DRAW;
  805.                 goagain=TRUE;
  806.                 break;
  807.  
  808.             case RS:
  809.                 switch(c) {
  810.                     case ' ':                /* pen up */
  811.                         vp->modesave=vp->mode;
  812.                         vp->mode=TEMPMOVE;
  813.                         break;
  814.  
  815.                     case 'P':                /* pen down */
  816.                         vp->mode=DRAW;
  817.                         break;
  818.  
  819.                     case 'D':                /* move up */
  820.                         vp->cury++;
  821.                         break;
  822.  
  823.                     case 'E':
  824.                         vp->cury++;
  825.                         vp->curx++;
  826.                         break;
  827.  
  828.                     case 'A':
  829.                         vp->curx++;
  830.                         break;
  831.  
  832.                     case 'I':
  833.                         vp->curx++;
  834.                         vp->cury--;
  835.                         break;
  836.  
  837.                     case 'H':
  838.                         vp->cury--;
  839.                         break;
  840.  
  841.                     case 'J':
  842.                         vp->curx--;
  843.                         vp->cury--;
  844.                         break;
  845.  
  846.                     case 'B':
  847.                         vp->curx--;
  848.                         break;
  849.  
  850.                     case 'F':
  851.                         vp->cury++;
  852.                         vp->curx--;
  853.                         break;
  854.  
  855.                     case 27:
  856.                         savstate[vw]=RS;
  857.                         state[vw]=ESCOUT;
  858.                         break;
  859.  
  860.                     default:        /*storexy(vw,vp->curx,vp->cury);*/
  861.                         state[vw]=CANCEL;
  862.                         goagain=TRUE;
  863.                         break;
  864.                   }
  865.                 if(vp->mode==DRAW)
  866.                     clipvec(vw,vp->curx,vp->cury,vp->curx,vp->cury);
  867. #ifdef DEBUG
  868.                 printf("RS: %d,%d\n",vp->curx,vp->cury);
  869. #endif
  870.                 break;
  871.  
  872.             case CMD0:                             /* get 1st letter of cmd */
  873.                 switch(c) {
  874.                     case 29:                    /* GS, start draw */
  875.                         state[vw]=DONE;
  876.                         goagain=TRUE;
  877.                         break;
  878.  
  879.                     case '8':
  880.                         fontnum(vw,0);
  881.                         state[vw]=DONE;
  882.                         break;
  883.  
  884.                     case '9':
  885.                         fontnum(vw,1);
  886.                         state[vw]=DONE;
  887.                         break;
  888.  
  889.                     case ':':
  890.                         fontnum(vw,2);
  891.                         state[vw]=DONE;
  892.                         break;
  893.  
  894.                     case ';':
  895.                         fontnum(vw,3);
  896.                         state[vw]=DONE;
  897.                         break;
  898.  
  899.                     case 12: /* form feed=clrscr */
  900.                         VGpage(vw);
  901.                         VGclrstor(vw);                
  902.                         break;
  903.  
  904.                     case 'L':
  905.                         state[vw]=SOMEL;
  906.                         break;
  907.  
  908.                     case 'K':
  909.                         state[vw]=IGNORE;
  910.                         break;
  911.  
  912.                     case 'M':
  913.                         state[vw]=SOMEM;
  914.                         break;
  915.  
  916.                     case 'T':
  917.                         state[vw]=SOMET;
  918.                         break;
  919.  
  920.                     case 26:
  921.                         setgin();            /* set the gin stuff up */
  922.                         unstore(VGstore[vw]);
  923.                         unstore(VGstore[vw]);
  924.                         break;
  925.  
  926.                     case 10:
  927.                     case 13:
  928.                     case 27:
  929.                     case '~':
  930.                         savstate[vw]=DONE;
  931.                         state[vw]=ESCOUT;
  932.                         break;        /* completely ignore these after ESC */
  933.  
  934.                     default:
  935.                         state[vw]=DONE;
  936.                   }                 /* end switch */
  937.                 break;
  938.     
  939.             case SOMET:                /* Got ESC T; now handle 3rd char. */
  940.                 switch(c) {
  941.                     case 'G':         /* set surface color map */
  942.                         state[vw]=INTEGER;
  943.                         savstate[vw]=JUNKARRAY;
  944.                         break;
  945.  
  946.                     case 'F':         /* set dialog area color map */
  947.                         state[vw]=JUNKARRAY;
  948.                         break;
  949.  
  950.                     default:
  951.                         state[vw]=DONE;
  952.                   }            
  953.                 break;
  954.  
  955.             case JUNKARRAY:            /* This character is the beginning of an integer arrayto be discarded.  Get array size. */
  956.                 savstate[vw]=STARTDISC;
  957.                 state[vw]=INTEGER;
  958.                 break;
  959.  
  960.             case STARTDISC:            /* Begin discarding integers. */
  961.                 vp->count=vp->intin + 1;
  962.                 goagain=TRUE;
  963.                 state[vw]=DISCARDING;
  964.                 break;
  965.  
  966.             case DISCARDING:        /* We are in the process of discarding an integer array. */
  967.                 goagain=TRUE;
  968.                 if(!(--(vp->count))) 
  969.                     state[vw]=DONE;
  970.                 else
  971.                     if(vp->count==1) {
  972.                         state[vw]=INTEGER;
  973.                         savstate[vw]=DONE;
  974.                       }
  975.                      else {
  976.                         state[vw]=INTEGER;
  977.                         savstate[vw]=DISCARDING;
  978.                       }
  979.                 break;
  980.  
  981.             case INTEGER:
  982.                 if(c & 0x40) {
  983.                     vp->intin=c & 0x3f;
  984.                     state[vw]=INTEGER1;
  985.                   } 
  986.                 else {
  987.                     vp->intin=c&0x0f;
  988.                     if(!(c & 0x10))
  989.                         vp->intin*=-1;
  990.                     state[vw]=savstate[vw];
  991.                   }
  992.                 break;
  993.  
  994.             case INTEGER1:
  995.                 if(c & 0x40) {
  996.                     vp->intin=(vp->intin<<6)|(c&0x3f);
  997.                     state[vw]=INTEGER2;
  998.                   } 
  999.                 else {
  1000.                     vp->intin=(vp->intin<<4)|(c&0x0f);
  1001.                     if(!(c & 0x10)) 
  1002.                         vp->intin*=-1;
  1003.                     state[vw]=savstate[vw];
  1004.                   }
  1005.                 break;
  1006.  
  1007.             case INTEGER2:
  1008.                 vp->intin=(vp->intin<<4)|(c&0x0f);
  1009.                 if(!(c&0x10)) 
  1010.                     vp->intin*=-1;
  1011.                 state[vw]=savstate[vw];
  1012.                 break;
  1013.  
  1014.             case IGNORE:         /* ignore next char; it's not supported */
  1015.                 state[vw]=DONE;
  1016.                 break;
  1017.     
  1018.             case IGNORE2:         /* ignore next 2 chars */
  1019.                 state[vw]=IGNORE;
  1020.                 break;
  1021.  
  1022.             case SOMEL:         /* now process 2nd letter */
  1023.                 switch(c) {
  1024.                     case 'F':     /* move */
  1025.                         vp->modesave=vp->mode;
  1026.                         vp->mode=TEMPMOVE;
  1027.                         state[vw]=HIY;
  1028.                         break;
  1029.  
  1030.                     case 'G':     /* draw */
  1031.                         vp->modesave=vp->mode;
  1032.                         vp->mode=TEMPDRAW;
  1033.                         state[vw]=HIY;
  1034.                         break;
  1035.  
  1036.                     case 'H':     /* marker */
  1037.                         vp->modesave=vp->mode;
  1038.                         vp->mode=TEMPMARK;
  1039.                         state[vw]=HIY;
  1040.                         break;
  1041.     
  1042.                     default:
  1043.                         state[vw]=DONE;
  1044.                   }             /* end switch */
  1045.                 break;
  1046.     
  1047.             case SOMEM:
  1048.                 switch(c) {
  1049.                     case 'C':     /* set graphtext size */
  1050.                         savstate[vw]=GTSIZE0;
  1051.                         state[vw]=INTEGER;
  1052.                         break;
  1053.  
  1054.                     case 'L':     /* set line index */
  1055.                         savstate[vw]=COLORINT;
  1056.                         state[vw]=INTEGER;
  1057.                         break;
  1058.  
  1059.                     default:
  1060.                         state[vw]=DONE;
  1061.                   }             /* end switch */
  1062.                 break;
  1063.     
  1064.             case COLORINT:         /* set line index; have integer */
  1065.                 vp->pencolor=vp->intin;
  1066.                 (*RG[vp->RGdevice].pencolor)
  1067.                 (vp->RGnum,vp->intin);
  1068.                 state[vw]=CANCEL;
  1069.                 goagain=TRUE;     /* we ignored current char; now process it */
  1070.                 break;
  1071.  
  1072.             case GTSIZE0:        /* discard the first integer; get the 2nd */
  1073.                 state[vw]=INTEGER; /* get the important middle integer */
  1074.                 savstate[vw]=GTSIZE1;
  1075.                 goagain=TRUE;
  1076.                 break;
  1077.  
  1078.             case GTSIZE1:        /* integer is the height */
  1079.                 if(vp->intin<88)
  1080.                     fontnum(vw,0);
  1081.                 else 
  1082.                     if(vp->intin<149) 
  1083.                         fontnum(vw,4);
  1084.                     else 
  1085.                         fontnum(vw,5);
  1086.                 state[vw]=INTEGER;             /* discard last integer */
  1087.                 savstate[vw]=DONE;
  1088.                 goagain=TRUE;
  1089.                 break;
  1090.  
  1091.  
  1092.             case DONE:             /* ready for anything */
  1093.                 switch(c) {
  1094.                     case 31:
  1095.                         vp->mode=ALPHA; 
  1096.                         state[vw]=CANCEL;
  1097.                         break;
  1098.  
  1099.                     case 30:
  1100.                         state[vw]=RS;
  1101.                         break;
  1102.  
  1103.                     case 28:
  1104.                         if(cmd) {
  1105.                             vp->mode=MARK;
  1106.                             state[vw]=HIY;
  1107.                           }
  1108.                         break;
  1109.  
  1110.                     case 29:
  1111.                         state[vw]=ENTERVEC;
  1112.                         break;
  1113.  
  1114.                     case 27:
  1115.                         state[vw]=CMD0;
  1116.                         break;
  1117.                 
  1118.                     default:
  1119.                         if(vp->mode==ALPHA) { 
  1120.                             drawc(vw,c);
  1121.                             state[vw]=CANCEL;
  1122.                           }
  1123.                         else 
  1124.                             if(vp->mode==DRAW && cmd) {
  1125.                                 state[vw]=HIY;
  1126.                                 goagain=TRUE;
  1127.                               }
  1128.                             else 
  1129.                                 if(vp->mode==MARK && cmd) {
  1130.                                     state[vw]=HIY;
  1131.                                     goagain=TRUE;
  1132.                                   }
  1133.                                 else 
  1134.                                     if(vp->mode==DRAW &&(c==13||c==10)) {    /* break drawing mode on CRLF */
  1135.                                         vp->mode=ALPHA; 
  1136.                                         state[vw]=CANCEL;
  1137.                                       }
  1138.                                     else
  1139.                                         state[vw]=CANCEL;    /* do nothing */                
  1140.                   }             /* end switch(c) */
  1141.           }                     /* end switch(state) */
  1142.         if(state[vw]==DONE) {
  1143.             if(vp->mode==TEMPMOVE) {
  1144.                 vp->mode=vp->modesave;
  1145.                 newcoord(vw);
  1146.               }
  1147.             else 
  1148.                 if(vp->mode==DRAW||vp->mode==TEMPDRAW) {
  1149.                     clipvec(vw,vp->curx,vp->cury,
  1150.                     joinup(vp->nhix,vp->nlox,vp->nex),
  1151.                     joinup(vp->nhiy,vp->nloy,vp->ney));
  1152.                     if(vp->mode==TEMPDRAW) 
  1153.                         vp->mode=vp->modesave;
  1154.                     newcoord(vw);
  1155.                   }
  1156.                 else 
  1157.                     if(vp->mode==MARK||vp->mode==TEMPMARK)        /* draw marker */
  1158.                         newcoord(vw);
  1159.           }                     /* end if done */
  1160.         if(state[vw]==CANCEL) 
  1161.             state[vw]=DONE;
  1162.       } while(goagain);
  1163. /*** END OF MAIN LOOP ***/
  1164. } /* end VGdraw() */
  1165.  
  1166. void VGpage(vw)
  1167. int vw;
  1168. /*  Clear screen and have a few other effects:
  1169.     - Return graphics to home position(0,3071)
  1170.     - Switch to alpha mode
  1171.     This is a standard Tek command; don't look at me.
  1172. */
  1173. {
  1174. #ifndef DEBUG
  1175.     (*RG[VGwin[vw].RGdevice].clrscr)(VGwin[vw].RGnum);
  1176.     (*RG[VGwin[vw].RGdevice].pencolor)(VGwin[vw].RGnum,1);
  1177. #endif
  1178.     VGwin[vw].mode=ALPHA;
  1179.     state[vw]=DONE;
  1180.     VGwin[vw].textcol=0;
  1181.     fontnum(vw,0);
  1182.     storexy(vw,0,3071);
  1183. } /* end page */
  1184.  
  1185. int VGpred(vw,dest)
  1186. int vw,dest;
  1187. /*
  1188.     Redraw window 'vw' in pieces to window 'dest'.
  1189.     Must call this function repeatedly to draw whole image.
  1190.     Only draws part of the image at a time, to yield CPU power.
  1191.     Returns 0 if needs to be called more, or 1 if the image
  1192.     is complete.  Another call would result in the redraw beginning again.
  1193.     User should clear screen before beginning redraw.
  1194. */
  1195. {
  1196.     int data;
  1197.     STOREP st=VGstore[vw];
  1198.     int count=0;
  1199.  
  1200.     if(drawing[vw]) {                    /* wasn't redrawing */
  1201.         topstore(st);
  1202.         drawing[vw]=0;                    /* redraw incomplete */
  1203.       }
  1204.     while( ++count < (int)PREDCOUNT && ((data=(int)nextitem(st)) != -1) ) 
  1205.         VGdraw(dest,(char)data);
  1206.     if(data==-1)
  1207.         drawing[vw]=1;                     /* redraw complete */
  1208.     return((int)drawing[vw]);
  1209. }
  1210.  
  1211. void VGstopred(vw,dest)
  1212. int vw, dest;
  1213. /*
  1214.     Abort VGpred redrawing of specified window.
  1215.     Must call this routine if you decide not to complete the redraw.
  1216. */
  1217. {
  1218.     drawing[vw]=1;
  1219.     dest=dest;
  1220. }
  1221.  
  1222. void VGredraw(vw,dest)
  1223. int vw,dest;
  1224. /*
  1225.     Redraw the contents of window 'vw' to window 'dest'.
  1226.     Does not yield CPU until done.
  1227.     User should clear the screen before calling this, to avoid 
  1228.     a messy display.
  1229. */
  1230. {
  1231.     int data;
  1232.     STOREP st=VGstore[vw];
  1233.  
  1234.     topstore(st);
  1235.     while((data=(int)nextitem(st))!=-1) {
  1236.         VGdraw(dest,(char)data);
  1237.       }
  1238. }
  1239.  
  1240. void VGzoom(int vw,int x0,int y0,int x1,int y1)
  1241. /*
  1242.     Set new borders for zoom/pan region.
  1243.     x0,y0 is lower left; x1,y1 is upper right.
  1244.     User should redraw after calling this.
  1245. */
  1246. {
  1247.     VGwin[vw].winbot=y0;
  1248.     VGwin[vw].winleft=x0;
  1249.     VGwin[vw].wintop=y1;
  1250.     VGwin[vw].winright=x1;
  1251.     VGwin[vw].wintall=y1-y0+1;
  1252.     VGwin[vw].winwide=x1-x0+1;
  1253.     VGgiveinfo(vw);
  1254. }
  1255.  
  1256. void VGwhatzoom(vw,px0,py0,px1,py1)
  1257.     int vw,*px0,*py0,*px1,*py1;
  1258. {
  1259.     *py0=VGwin[vw].winbot;
  1260.     *px0=VGwin[vw].winleft;
  1261.     *py1=VGwin[vw].wintop;
  1262.     *px1=VGwin[vw].winright;
  1263. }
  1264.  
  1265. void VGzcpy(int src,int dest)
  1266. /*
  1267.     Set zoom/pan borders for window 'dest' equal to those for window 'src'.
  1268.     User should redraw window 'dest' after calling this.
  1269. */
  1270. {
  1271.     VGzoom(dest,VGwin[src].winleft, VGwin[src].winbot,
  1272.     VGwin[src].winright, VGwin[src].wintop);
  1273. }
  1274.  
  1275. void VGclose(int vw)
  1276. /*
  1277.     Close virtual window.
  1278.     Release its real graphics device and its store.
  1279. */
  1280. {
  1281.     (*RG[VGwin[vw].RGdevice].close)(VGwin[vw].RGnum);
  1282.     freestore(VGstore[vw]);
  1283.     VGwin[vw].RGdevice=-1;
  1284. }
  1285.  
  1286. int VGwrite(vw,data,count)
  1287. int vw, count;
  1288. char *data;
  1289. /*
  1290.     Draw the data pointed to by 'data' of length 'count'
  1291.     on window vw, and add it to the store for that window.
  1292.     This is THE way for user program to pass Tektronix data.
  1293. */
  1294. {
  1295.     char *c=data;
  1296.     char *end=&(data[count]);
  1297.  
  1298.     if(VGwin[vw].RGdevice==-1 || vw>=MAXVG || vw<0)
  1299.         return(-1);        /* window not open */
  1300.     if(storing[vw]) {
  1301.         while(c!=end) {
  1302.             if(*c==24)                /* ASC CAN character */
  1303.                 return((int)(c-data+1));
  1304.             addstore(VGstore[vw], *c);
  1305.             VGdraw(vw,*c++);
  1306.           }
  1307.       } 
  1308.     else {
  1309.         while(c!=end) {
  1310.             if(*c==24)
  1311.                 return((int)(c-data+1));
  1312.             else
  1313.                 VGdraw(vw,*c++);
  1314.           }
  1315.       }
  1316.     return(count);
  1317. }
  1318.  
  1319. void VGgiveinfo(vw)
  1320. int vw;
  1321. /*
  1322.     Send interesting information about the virtual window down to
  1323.     its RG, so that the RG can make VG calls and display zoom values
  1324. */
  1325. {
  1326.     (*RG[VGwin[vw].RGdevice].info)(VGwin[vw].RGnum,vw,VGwin[vw].winbot,VGwin[vw].winleft,VGwin[vw].wintop,VGwin[vw].winright);
  1327. }
  1328.  
  1329. char *
  1330. VGrgname(rgdev)
  1331. int rgdev;
  1332. /*
  1333.     Return a pointer to a human-readable string
  1334.     which describes the specified real device
  1335. */
  1336.  
  1337. {
  1338.     return(*RG[rgdev].devname)();
  1339. }
  1340.  
  1341. void VGgmode(rgdev)
  1342. int rgdev;
  1343. /* Put the specified real device into graphics mode */
  1344. {
  1345. #ifndef DEBUG
  1346.     (*RG[rgdev].gmode)();
  1347. #endif
  1348. }
  1349.  
  1350. void VGtmode(rgdev)
  1351. int rgdev;
  1352. /* Put the specified real device into text mode */
  1353.  
  1354. {
  1355.     (*RG[rgdev].tmode)();
  1356. }
  1357.  
  1358. void VGgindata(vw,x,y,c,a)
  1359. int vw,x,y;
  1360. char c, *a;
  1361. /*
  1362.     Translate data for output as GIN report.
  1363.  
  1364.     User indicates VW number and x,y coordinates of the GIN cursor.
  1365.     Coordinate space is 0-4095, 0-4095 with 0,0 at the bottom left of
  1366.     the real window and 4095,4095 at the upper right of the real window.
  1367.     'c' is the character to be returned as the keypress.
  1368.     'a' is a pointer to an array of 5 characters.  The 5 chars must
  1369.     be transmitted by the user to the remote host as the GIN report.
  1370. */
  1371. {
  1372.     unsigned long x1,y1,x2,y2;
  1373.  
  1374.     x2=x;
  1375.     y2=y;
  1376. #ifdef CGW
  1377.     printf("x=%d y=%d\n",x,y);
  1378.     printf("x2=%d y2=%d\n",x2,y2);
  1379. #endif
  1380.     vw-=1;
  1381. #ifdef CGW
  1382.     printf("winwide=%d wintall=%d ",VGwin[vw].winwide,VGwin[vw].wintall);
  1383.     printf("winleft=%d  winbot=%d\n",VGwin[vw].winleft,VGwin[vw].winbot);
  1384. #endif
  1385. #ifdef OLDWAY
  1386.     x2=(((x1*RGXSIZE)/VGwin[vw].winwide)+VGwin[vw].winleft)>>2;
  1387.     y2=(((y1*RGYSIZE)/VGwin[vw].wintall)+VGwin[vw].winbot)>>2;
  1388. #else
  1389.     x1=(x2 * (unsigned long)VGwin[vw].winwide) / 640;
  1390.     y1=(y2 * (unsigned long)VGwin[vw].wintall) / 350;
  1391. #ifdef CGW
  1392.     printf("1 x2=%d  y2=%d\n",(int) x1,(int) y1);
  1393. #endif
  1394.     x1+=VGwin[vw].winleft;
  1395.     y1+=VGwin[vw].winbot;
  1396. #ifdef CGW
  1397.     printf("2 x2=%d  y2=%d\n",(int) x1,(int) y1);
  1398. #endif
  1399.     x1=x1>>2;
  1400.     y1=y1>>2;
  1401. #ifdef CGW
  1402.     printf("3 x2=%d  y2=%d\n",(int) x1,(int) y1);
  1403. #endif
  1404. #endif
  1405.  
  1406.     a[0]=c;
  1407.     a[1]=(char)(0x20 + (x1 >> 5));
  1408.     a[2]=(char)(0x20 | (x1 & 0x001F));
  1409.     a[3]=(char)(0x20 + (y1 >> 5));
  1410.     a[4]=(char)(0x20 | (y1 & 0x001F));
  1411.  
  1412.     printf("a== %c %x %x %x %x\n",a[0],a[1],a[2],a[3],a[4]);
  1413.  
  1414. }
  1415.  
  1416.  
  1417. /**********************************************************************
  1418. *
  1419. * setgin()
  1420. *    shows the GIN cursor on the screen
  1421. */
  1422.  
  1423. void setgin()
  1424. {
  1425.     int m1=0,m2=0,m3=0,m4=0;        /* mouse variables to show the mouse cursor */
  1426.  
  1427.     vprint(console->vs,"GIN set\r\n");
  1428.     if(mighty)
  1429.         mousecl(&m1,&m2,&m3,&m4);    /* call mouse routine to show mouse cursor */
  1430.     showmouse();
  1431.     ginon=1;
  1432. }                                    /* end setgin() */
  1433.  
  1434. /**********************************************************************
  1435. *
  1436. * resetgin()
  1437. *    removes the GIN cursor on the screen
  1438. */
  1439.  
  1440. void resetgin()
  1441. {
  1442.     hidemouse();
  1443.     vprint(console->vs, "GIN reset\r\n");
  1444.     ginon=0;
  1445. }                                    /* end resetgin() */
  1446.