home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c129 / 1.ddi / WORLDDR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-20  |  36.1 KB  |  1,454 lines
  1.  
  2. #include <math.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <graph.h>
  6. #include <dos.h>
  7. #include <bios.h>
  8. #include <stdlib.h>
  9. #include "asyncxx.h"
  10. #include "hpplot.h"
  11.  
  12. typedef  struct{ int x,y;}  xyrec;
  13. typedef  struct{ int x,y,edge;}  xyerec;
  14.  
  15. struct WorldRect{
  16.    float left, bottom, right, top;
  17. };
  18.  
  19.  
  20. struct point2D{
  21.   int x,y;
  22. };
  23.  
  24. struct viewporttype{
  25.    int  left, bottom,right, top;
  26. };
  27. struct viewporttype vp;
  28. int  mx;
  29. int  my;
  30. int  vx;
  31. int  vy;
  32. int  vh;
  33. int  vl;
  34. float tx;
  35. float ty;
  36. float wx;
  37. float wy;
  38. float wh;
  39. float wl;
  40. int vxAbs;
  41. int vyAbs;
  42. int curfont;
  43. int curdir;
  44. int cursize;
  45. char CRTGraphOnF=1;
  46. char PlotterOnF=0;
  47. char ClipOnF = 1;
  48. int HORIZDIR = 0;
  49. int VERTDIR = 1;
  50. int textsize = 1;
  51. int textDir = 0;
  52. char far *CharTable= (char far *) 0xF8007a6e;  /* start of video rom */
  53. char ESC = '\x1b';
  54. int HVBitMask[8] = {1,2,4,8,16,32,64,128};
  55. int FSCompare();
  56.  
  57.  
  58. unsigned int BitMask[8]  = {0x80,0x40,0x20,0x10,8,4,2,1};
  59. char  ToshResArray[4][2] = {";","\x1d",";",";"};
  60. char  EMXResArray[4][2] = {"K", "L", "Y", "Z"};
  61. char  ELQResArray[5][2] = {"\x20", "\x21", "\x26", "\x27", "\x28"};
  62. char HPLResStringsY[4][4]  = {"75","100","150","300"};
  63. char HPJetResStringsY[2][5]  = {"640","1280"};
  64. xyerec FillStack[2000];
  65. int  fspntr;
  66.  
  67. enum justify{
  68.           LEFT_TEXT   = 0,
  69.           CENTER_TEXT = 1,
  70.           RIGHT_TEXT  = 2,
  71.           BOTTOM_TEXT = 0,
  72.           TOP_TEXT    = 2
  73. };
  74.  
  75. char fillmask[10][8]     = {{ 0,0,0,0,0,0,0,0},                 /* empty  */
  76.                             {255,255,255,255,255,255,255,255},  /* solid  */
  77.                            {0,255,0,255,0,255,0,255},          /* horiz  */
  78.                            {17,34,68,136, 17,34,68,136},       /* ////   */
  79.                            {15,30,60,120,240,225,195,135},     /* dbl // */
  80.                            {135,195,225,240,120,60,30,15},     /* dbl \\ */
  81.                            {136,68,34,17,136,68,34,17},        /* \\\\   */
  82.                            {129,66,36,24,24,36,66, 129},       /* hatch  */
  83.                            {195,102,60,24,60,102,195,129},     /* hvy hat */
  84.                            {136,136,136,136,136,136,136,136}}; /* vertic */
  85.  
  86. short linemask[5]      =   {0xFFFF, 0x5555, 0x6666, 0xBDBD,0xFF00};
  87.  
  88.  
  89.  
  90. int Round( float x )
  91. {
  92.   int _round;
  93.  
  94.   _round = floor( x+0.49999);
  95.   return( _round );
  96. }
  97.  
  98.  
  99. float Float( int i )
  100. {
  101.   float ans;
  102.   ans = ((float) i);
  103.   return( ans );
  104. }
  105.  
  106. int AdjustCRTColor( int c )
  107. {
  108.   int color;
  109.   struct videoconfig v;
  110.   if (CRTGraphOnF){
  111.         _getvideoconfig(&v);
  112.         if (v.numcolors==0)
  113.                 if (c>=1) color=1; else color=0;
  114.         else
  115.                 if (c > v.numcolors-1 )
  116.                         color = v.numcolors-1;
  117.                 else
  118.                         color = c;
  119.  
  120.    }
  121.    return( color );
  122. }
  123.  
  124. void GetMaxCoords( int *x, int *y )
  125. {
  126.    struct videoconfig vc;
  127.  
  128.         if (CRTGraphOnF) {
  129.                 _getvideoconfig( &vc);
  130.                 *x = vc.numxpixels-1;
  131.                 *y = vc.numypixels-1;
  132.         }
  133.         else {
  134.                 *x = 639;
  135.                 *y = 485;
  136.         }
  137.  
  138. }
  139.  
  140. short Short(float x){
  141.   short _Short;
  142.         _Short = ((int) x);
  143.         return( _Short );
  144. }
  145.  
  146. void _moverel( int x1, int y1 )
  147. {
  148.   struct xycoord position;
  149.  
  150.         position = _getcurrentposition();
  151.         _moveto( position.xcoord+x1, position.ycoord+y1 );
  152. }
  153.  
  154. void _linerel( int x1, int y1 )
  155. {
  156.   struct xycoord position;
  157.  
  158.         position = _getcurrentposition();
  159.         _lineto( position.xcoord+x1, position.ycoord+y1 );
  160.  
  161. }
  162.  
  163. void linetoXX( float x, float y )
  164. {
  165.         if (CRTGraphOnF) {
  166.                 _lineto( Round(x), vh-Round(y));
  167.         }
  168.         if (PlotterOnF){
  169.                 Plineto( vxAbs+x, vyAbs+y );
  170.         }
  171. }
  172.  
  173.  
  174. void linerelXX( float x, float y )
  175. {
  176.         if (CRTGraphOnF) {
  177.                 _linerel( Round(x), -Round(y));
  178.         }
  179.         if (PlotterOnF){
  180.                 Plinerel( x, y );
  181.         }
  182. }
  183.  
  184.  
  185. void movetoXX( float x, float y )
  186. {
  187.         if (CRTGraphOnF) {
  188.                 _moveto( Round(x), vh-Round(y));
  189.         }
  190.         if (PlotterOnF){
  191.                 Pmoveto( vxAbs+x, vyAbs+y );
  192.         }
  193. }
  194.  
  195. void moverelXX( float x, float y )
  196. {
  197.         if (CRTGraphOnF) {
  198.                 _moverel( Round(x), -Round(y));
  199.         }
  200.         if (PlotterOnF){
  201.                 Pmoverel( x, y );
  202.         }
  203. }
  204.  
  205. float ClampReal( float r, float l, float h ){
  206.  float ClampResult;
  207.    if (r<l) ClampResult=l;
  208.    else
  209.      if (r>h) ClampResult=h;
  210.      else ClampResult = r;
  211.    return( ClampResult );
  212.  
  213. }
  214.  
  215. float ConvertX1( float xx1)
  216. {  float temp;
  217.    float _ConvertX1;
  218.  
  219.     temp = (xx1-wx)*tx+vx;
  220.     _ConvertX1 = ClampReal(temp,-1000.0,1000.0);
  221.   return(_ConvertX1);
  222. }
  223.  
  224.  
  225. float ConvertY1(float yy1 )
  226. { float temp;
  227.   float _ConvertY1;
  228.  
  229.   temp = (yy1-wy)*ty+vy;
  230.   _ConvertY1 = ClampReal(temp,-1000.0,1000.0);
  231.   return(_ConvertY1 );
  232. }
  233.  
  234.  
  235. float ConvertX2(float xx1 )
  236. {
  237.   float _ConvertX2;
  238.   float temp;
  239.  
  240.   temp = xx1* tx;
  241.   _ConvertX2 = ClampReal( temp, -1000.0,1000.0);
  242.   return( _ConvertX2 );
  243. }
  244.  
  245.  
  246. float ConvertY2( float yy1)
  247. {
  248.   float temp;
  249.   float _ConvertY2;
  250.  
  251.   temp = yy1*ty;
  252.   _ConvertY2 = ClampReal(temp,-1000.0,1000.0);
  253.   return(_ConvertY2 );
  254. }
  255.  
  256. void MoveWorldAbs( float xx1, float yy1)
  257.  
  258. {
  259.   movetoXX(ConvertX1(xx1), ConvertY1(yy1));
  260. }
  261.  
  262.  
  263. void MoveWorldRel( float xx1,float yy1 )
  264. {
  265.   moverelXX(ConvertX2(xx1), ConvertY2(yy1));
  266. }
  267.  
  268. void LineWorldAbs( float xx1,float  yy1)
  269. {
  270.   linetoXX( ConvertX1(xx1), ConvertY1(yy1));
  271. }
  272.  
  273. void LineWorldRel( float xx1,float  yy1 )
  274. {
  275.   linerelXX(ConvertX2(xx1), ConvertY2(yy1));
  276. }
  277.  
  278.  
  279. void GetViewportOrigin( int *left, int *top )
  280. {
  281.    *left = vp.left;
  282.    *top  = vp.top;
  283.  
  284. }
  285.  
  286.  
  287. void settextjustify(int dirx, int diry)
  288. {
  289.            HORIZDIR = dirx;
  290.            VERTDIR =  diry;
  291.  
  292. }
  293.  
  294.  
  295. void SelectColor( int c )
  296. {
  297.    int color ;
  298.  
  299.         if (CRTGraphOnF) {
  300.                 color = AdjustCRTColor(c);
  301.                 _setcolor( color );
  302.         }
  303.         if (PlotterOnF){
  304.                 SelectPen(c);
  305.         }
  306. }
  307.  
  308.  
  309. char CheckBit(unsigned int i, unsigned int bit)
  310. {
  311.   char checkBitResult;
  312.  
  313.         if ((i & BitMask[bit]) == BitMask[bit])
  314.                 checkBitResult = 1;
  315.         else
  316.                 checkBitResult = 0;
  317.         return(checkBitResult);
  318. }
  319.  
  320. void outgraphstring(char *s)
  321. {  int LengthS,sc,i,j,k,l,x,y;
  322.    int size9,size8,size4,jsize, isize;
  323.    unsigned int c;
  324.    struct xycoord position;
  325.  
  326.         LengthS = strlen(s);
  327.         c = _getcolor();
  328.         position = _getcurrentposition();
  329.         x = position.xcoord;
  330.         y = position.ycoord;
  331.         size8 = textsize*8;
  332.         size9 = textsize*9;
  333.         size4 = textsize*4;
  334.         switch (HORIZDIR) {
  335.                 case  0:
  336.                         break;
  337.                 case  1: if (textDir==0)
  338.                                 x = x - size9*(LengthS /2);
  339.                         else
  340.                                 x = x-size4;
  341.                         break;
  342.                 case 2: if (textDir==0)
  343.                                 x = x - size9*LengthS;
  344.                         else
  345.                                 x = x-size8;
  346.                         break;
  347.         }
  348.         switch (VERTDIR) {
  349.                 case 0: break;
  350.                 case 1: if (textDir==0)
  351.                                 y = y + size4;
  352.                         else
  353.                                 y =y+size9*(LengthS / 2);
  354.                         break;
  355.                 case 2: if (textDir==0)
  356.                                 y = y + size8;
  357.                         else
  358.                                 y =y+size9*LengthS;
  359.                         break;
  360.         }
  361.         for ( sc = 0; sc <= LengthS-1; sc++){
  362.                 for (i = 0; i <= 7; i++){
  363.                         isize = i*textsize;
  364.                         for (j = 0; j <= 7; j++){
  365.                                 jsize = j*textsize;
  366.                                 if (CheckBit(CharTable[s[sc]*8+i],j))
  367.                                 for (k = 0; k<= textsize - 1; k++)
  368.                                         for (l =0; l<= textsize - 1; l++)
  369.                                                 if (textDir == 0){
  370.                                                         _setpixel(x+(jsize)+k,y-(size8-1)+(isize)+l);
  371.                                                 }
  372.                                                 else  {
  373.                                                         _setpixel(x+(size8-1)+(isize)+l,y-(jsize)+k);
  374.                                                 }
  375.                         }
  376.                 }
  377.         if (textDir == 0)
  378.                 x = x + size9;
  379.         else
  380.                 y = y - size9;
  381.  
  382.   }
  383. }
  384.  
  385. void settextjustifyXX( unsigned int h, unsigned int v )
  386. {
  387.         if (CRTGraphOnF) {
  388.                 settextjustify( h,v );
  389.         }
  390.         if (PlotterOnF){
  391.                 Psettextjustify(h,v);
  392.         }
  393.  
  394. }
  395.  
  396. void settextstyle( int font, int dir, int size )
  397. {
  398.      textDir = dir;
  399.      textsize = size;
  400. }
  401. void gettextstyleXX(int *font, int *dir, int *size )
  402. {
  403.   *font = curfont;
  404.   *dir = curdir;
  405.   *size = cursize;
  406. }
  407.  
  408. void settextstyleXX(unsigned int font, unsigned int dir, unsigned int size )
  409. {
  410.        curfont = font;
  411.        curdir = dir;
  412.        cursize = size;
  413.  
  414.         if (CRTGraphOnF) {
  415.                   settextstyle( font, dir, size );
  416.         }
  417.         if (PlotterOnF){
  418.                 Psettextstyle( font, dir, size );
  419.         }
  420.  
  421. }
  422.  
  423. void ClipOn()
  424. {
  425.         ClipOnF = 1;
  426.  
  427. }
  428.  
  429. void ClipOff()
  430. {
  431.         ClipOnF = 0;
  432.  
  433. }
  434.  
  435. void PlotterOn()
  436. {
  437.         PlotterOnF = 1;
  438.  
  439. }
  440.  
  441. void PlotterOff()
  442. {
  443.         PlotterOnF = 0;
  444.  
  445. }
  446.  
  447.  
  448. void CRTGraphOn()
  449. {
  450.         CRTGraphOnF = 1;
  451. }
  452.  
  453. void CRTGraphOff()
  454. {
  455.         CRTGraphOnF = 0;
  456. }
  457.  
  458. void setlinestyleXX( int ls, int pat,
  459.                      int thick )
  460. {
  461.         if (CRTGraphOnF)
  462.                 _setlinestyle( linemask[ls] );
  463.         if (PlotterOnF)
  464.                 Psetlinestyle( ls,pat );
  465.  
  466. }
  467.  
  468. void setfillstyleXX( int pat,
  469.                      int c )
  470. {
  471.  
  472.         SelectColor(c);
  473.         if (CRTGraphOnF)
  474.                  _setfillmask( fillmask[pat]);
  475.         if (PlotterOnF)
  476.                 Psetfillstyle( pat,c );
  477.  
  478. }
  479.  
  480. int getcolorXX()
  481. {       int color;
  482.  
  483.         if (PlotterOnF)
  484.                 color = Pgetcolor();
  485.         if (CRTGraphOnF)
  486.                 color = _getcolor();
  487.         return( color );
  488. }
  489.  
  490. void barXX(float x1,float y1, float x2, float y2 )
  491. {
  492.        
  493.    int xx1,yy1,xx2,yy2;
  494.  
  495.         
  496.         if (CRTGraphOnF) {
  497.            xx1 = Round(x1);
  498.            yy1 = vh-Round(y1);
  499.            xx2 = Round(x2);
  500.            yy2 = vh-Round(y2);
  501.  
  502.            if  (xx2>= 0) {
  503.                   _rectangle( _GBORDER, xx1,yy1,xx2,yy2);
  504.                   if (yy1 != yy2)
  505.                         _rectangle( _GFILLINTERIOR, xx1,yy1,xx2,yy2);
  506.            }
  507.  
  508.         }
  509.         if (PlotterOnF){
  510.                 Pbar( vxAbs+x1,vyAbs+y1,vxAbs+x2,vyAbs+y2);
  511.                 Prectangle( vxAbs+x1,vyAbs+y1,vxAbs+x2,vyAbs+y2);
  512.         }
  513. }
  514.  
  515. void rectangleXX(float x1,float y1, float x2, float y2 )
  516. {
  517.         if (CRTGraphOnF) {
  518.                 _rectangle( _GBORDER, Round(x1),Round(y1),Round(x2),Round(y2));
  519.         }
  520.         if (PlotterOnF){
  521.                 Prectangle( vxAbs+x1,vyAbs+y1,vxAbs+x2,vyAbs+y2);
  522.         }
  523.  
  524. }
  525.  
  526. void pieXX(float x,float y,float stangle,float endangle,
  527.            float radius,float AspectRatio)
  528. {
  529.   int x1,x2,y1,y2,x3,y3,x4,y4;
  530.   float twopi360;
  531.  
  532.   if (PlotterOnF)  {AspectRatio = 1.0;}
  533.   twopi360 = 6.2831854/360.0;
  534.  
  535.   x3 = Round(x + (radius*cos(twopi360*stangle)));
  536.   y3 = Round(y + (AspectRatio*radius*sin(stangle*twopi360)));
  537.   x4 = Round(x + (radius*cos(twopi360*endangle)));
  538.   y4 = Round(y + (AspectRatio*radius*sin(endangle*twopi360)));
  539.   x1 = Round(x- (radius));
  540.   x2 = Round(x+ (radius));
  541.   y1 = Round(y+AspectRatio*radius);
  542.   y2 = Round(y-AspectRatio*radius);
  543.   if (CRTGraphOnF){
  544.     _pie(_GFILLINTERIOR, x1,vh-y1,x2,vh-y2,x3,vh-y3,x4,vh-y4);
  545.   }
  546.   if (PlotterOnF)
  547.     PShadeWedge(vxAbs + x, vyAbs +y, radius, Round(stangle),
  548.                 Round(endangle-stangle));
  549.  
  550. }
  551.  
  552. void outtextXX( char *s )
  553. {
  554.         if (CRTGraphOnF) {
  555.                 outgraphstring(s);
  556.         }
  557.         if (PlotterOnF){
  558.                 Pouttext(s);
  559.         }
  560.  
  561. }
  562.  
  563. void outtextPie( int x, int y, char *s)
  564. {
  565.    movetoXX(x,y);
  566.    outtextXX(s);
  567. }
  568. void SetWorldRect( struct WorldRect *r,
  569.                    float a,float b,float c,float d  )
  570.  
  571. {
  572.       (*r).left = a;
  573.       (*r).bottom = b;
  574.       (*r).right = c;
  575.       (*r).top = d;
  576.  
  577. }
  578. void SetGraphViewport(int xx1,int yy1,int xx2,int yy2)
  579.  
  580. {  int maxX, maxY,pux1,puy1, puy2,pux2;
  581.    float x1,x2,y1,y2;
  582.  
  583.         if (CRTGraphOnF){
  584.                 _setviewport( xx1,yy1,xx2,yy2);
  585.                 if (ClipOnF)
  586.                         _setcliprgn( xx1,yy1,xx2,yy2);
  587.         }
  588.         if (PlotterOnF) {
  589.                 GetMaxCoords( &maxX,&maxY );
  590.                 GetPlotterViewport( &pux1, &puy1, &pux2, &puy2 );
  591.                 if (ClipOnF){
  592.                         x1 = ( pux1 + (pux2-pux1)* (Float(xx1)/Float(maxX)));
  593.                         y1 = ( puy2 - (puy2-puy1)* (Float(yy1)/Float(maxY)));
  594.                         x2 = ( pux1 + (pux2-pux1)* (Float(xx2)/Float(maxX)));
  595.                         y2 = ( puy2 - (puy2-puy1)* (Float(yy2)/Float(maxY)));
  596.                         SetClippingWindow( Round(x1),Round(y1),Round(x2),Round(y2));
  597.                 }
  598.         }
  599.  vp.right = xx2;
  600.   vp.top = yy1;
  601.   vp.left = xx1;
  602.   vp.bottom = yy2;
  603.  
  604.   vx = 0;
  605.   vy = 0;
  606.   vh = yy2 - yy1;
  607.   vl = xx2 - xx1;
  608.   vxAbs = xx1;
  609.   vyAbs = maxY-yy2;
  610. }
  611.  
  612.  
  613. void OneTimeInit(int mode)
  614. {
  615.    int gdriver;
  616.    int gmode;
  617.    int x;
  618.    int y;
  619.  
  620.    vx = 0;
  621.    vy = 0;
  622.    vl = 720;
  623.    vh = 348;
  624.  
  625.  
  626.         if (CRTGraphOnF){
  627.          switch  (mode){
  628.                 case 1: _setvideomode(_MRES4COLOR);
  629.                 break;
  630.                 case 2: _setvideomode(_MRESNOCOLOR);
  631.                 break;
  632.                 case 3: _setvideomode(_HRESBW);
  633.                 break;
  634.                 case 4: _setvideomode(_MRES16COLOR);
  635.                 break;
  636.                 case 5: _setvideomode(_HRES16COLOR);
  637.                 break;
  638.                 case 6: _setvideomode(_ERESCOLOR);
  639.                 break;
  640.                 case 7: _setvideomode(_VRES2COLOR);
  641.                 break;
  642.                 case 8: _setvideomode(_VRES16COLOR);
  643.                 break;
  644.                 case 9: _setvideomode(_MRES256COLOR);
  645.                 break;
  646.                 case 10: _setvideomode(_DEFAULTMODE);
  647.                 break;
  648.                 case 11: _setvideomode(_ERESNOCOLOR);
  649.                 break;
  650.                 case 12: _setvideomode(8);
  651.                 break;
  652.               default:   _setvideomode(6);
  653.                 break;
  654.          }
  655.          GetMaxCoords(&x, &y);
  656.          SetGraphViewport(0,0,x,y);
  657.         }
  658.         if (PlotterOnF){
  659.                 SetPlotterViewport(1000,500,10000, 7500);
  660.                 GetMaxCoords( &x, &y );
  661.                 SetGraphViewport(0,0,x,y);
  662.                 ScalePlotterViewport( 0,0,x,y );
  663.                 PenUp();
  664.         }
  665.         settextjustifyXX( LEFT_TEXT, CENTER_TEXT );
  666.         settextstyleXX( 0, HORIZDIR, 1 );
  667.  
  668. }
  669.  
  670.  
  671. void SetWorldCoordinates(float l, float b,float  r, float t)
  672. {
  673.         wx = l;
  674.         wy = b;
  675.         wh = t - b;
  676.         wl = r - l;
  677.         tx = vl/wl;
  678.         ty = vh/wh;
  679. }
  680.  
  681.  
  682. void PolyLineWorldAbs( float *x, float *y, int numdat )
  683. {
  684.   int i;
  685.   MoveWorldAbs( x[0], y[0] );
  686.   for (i=1; i< numdat; i++ )
  687.         LineWorldAbs( x[i], y[i] );
  688. }
  689.  
  690. void polyminmax( int *PolyVector,int numdat,
  691.                  int *xmin, int *ymin,int *xmax, int *ymax ){
  692.  
  693.    int i;
  694.  
  695.    *xmin = PolyVector[0];
  696.    *xmax = PolyVector[0];
  697.    *ymin = PolyVector[1];
  698.    *ymax = PolyVector[1];
  699.  
  700.    for ( i = 1; i <= numdat - 1; ++i ) {
  701.       if ( (PolyVector[i*2]) < (*xmin) ) {
  702.          (*xmin) = (PolyVector[i*2]);
  703.       }
  704.       if ( (PolyVector[i*2]) > (*xmax) ) {
  705.          (*xmax) = (PolyVector[i*2]);
  706.       }
  707.       if ( (PolyVector[i*2+1]) < (*ymin) ) {
  708.          (*ymin) = (PolyVector[i*2+1]);
  709.       }
  710.       if ( (PolyVector[i*2+1]) > (*ymax) ) {
  711.          (*ymax) = (PolyVector[i*2+1]);
  712.       }
  713.  
  714.  
  715.   }
  716.  
  717. }
  718.  
  719.  
  720. void FSQuickSort(int l, int r)
  721. {
  722.   qsort((void *) FillStack,(size_t) fspntr,sizeof(FillStack[0]),FSCompare );
  723. }
  724.  
  725.  
  726. int FSCompare(xyerec *e1, xyerec *e2)
  727. {
  728.   xyerec temp1, temp2;
  729.   temp1 = *e1; temp2 = *e2;
  730.   if ((temp1.y > temp2.y) ||
  731.       ((temp1.y == temp2.y) && (temp1.x > temp2.x))) return(1);
  732.   if ((temp1.y == temp2.y) && (temp1.x == temp2.x)) return(0);
  733.   else return(-1);
  734. }
  735.  
  736.  
  737. void MemPlot(int xx,int yy,int ee)
  738. {
  739.   FillStack[fspntr].x = xx;
  740.   FillStack[fspntr].y = yy;
  741.   FillStack[fspntr].edge = ee;
  742.   fspntr += 1;
  743.  
  744. }
  745.  
  746.  
  747. int Sign(int i)
  748. { int result;
  749.   if (i > 0)
  750.     result = 1;
  751.   else
  752.     if (i < 0)
  753.       result = -1;
  754.     else
  755.        result = 0;
  756.   return(result);
  757. }
  758.  
  759. void MemDraw(int x1, int y1,int x2, int y2,int edge ,int ep)
  760. {
  761.   int dx,dy,dxabs, dyabs, i, px, py, sdx, sdy, x,y;
  762.  
  763. /* Bresenham's algorithm for line drawing */
  764. /* Based upon the line-drawing algorithm
  765.    in Graphics Programming in C by Roger T. Stevens  */
  766.  
  767.   dx = (x2 - x1);
  768.   dy = (y2 - y1);
  769.   dxabs= abs(dx);
  770.   dyabs = abs(dy);
  771.   sdx = Sign(dx);
  772.   sdy = Sign(dy);
  773.   MemPlot(x1,y1,edge);
  774.   x = 0; y = 0;
  775.   px = x1; py = y1;
  776.   if (dxabs >= dyabs)
  777.   {
  778.     for (i = 1; i <= dxabs-1; ++i)
  779.     {
  780.       y +=dyabs;
  781.       if (y >= dxabs)
  782.       {
  783.         y -= dxabs;
  784.         py += sdy;
  785.       }
  786.       px += sdx;
  787.       MemPlot(px,py,edge);
  788.     }
  789.   }
  790.   else
  791.   {
  792.     for (i = 1; i <= dyabs-1; i++)
  793.     {
  794.       x +=  dxabs;
  795.       if (x >= dyabs)
  796.       {
  797.         x -= dyabs;
  798.         px +=  sdx;
  799.       };
  800.       py +=  sdy;
  801.       MemPlot(px,py,edge);
  802.     }
  803.   }
  804.   /* plot endpoint only if ep flag set true */
  805.   if (ep==1) MemPlot(x2,y2,edge);
  806. }
  807.  
  808.  
  809. void TLine(int x1, int y1,int x2, int y2)
  810. { _moveto(x1,y1);
  811.   _lineto(x2,y2);
  812. }
  813.  
  814. void QCPolyFill(xyrec *xy, int n, int fillcolor, int outlinecolor)
  815. {
  816.   int minY,maxY,i,j;
  817.   int plotit,ep;
  818.   int EdgeTable[20];
  819.  
  820.   /* Zero out edge table */
  821.   memset(EdgeTable,0,sizeof(EdgeTable));
  822.   fspntr = 0;
  823.  
  824.   /* Check and make sure we are dealing  with a closed polygon */
  825.   if ((xy[0].x != xy[n-1].x) || (xy[0].y != xy[n-1].y))
  826.   {
  827.     xy[n] = xy[0];
  828.     n += 1;
  829.   }
  830.   /* Create pixel list of polygon outline */
  831.   /* Plot endpoint if line meets at in interior vertex */
  832.   for (i = 1; i <= n-1; i++)
  833.   {
  834.     if (i == (n-1))
  835.       ep = (Sign(xy[i-1].y - xy[i].y) != Sign(xy[0].y - xy[(1)].y));
  836.     else
  837.       ep = (Sign(xy[i-1].y - xy[i].y) != Sign(xy[i].y - xy[(i+1)].y));
  838.     if (xy[i-1].y != xy[i].y)
  839.     MemDraw(xy[i-1].x,xy[i-1].y,xy[i].x,xy[i].y,i,ep);
  840.   }
  841.  
  842.   /* Sort pixel list of polygon outline */
  843.   FSQuickSort(0,fspntr-1);
  844.   plotit = 1;
  845.  
  846.   /* set to fill color */
  847.   _setcolor(fillcolor);
  848.  
  849.   /* Initialze edge table for first edge */
  850.   EdgeTable[FillStack[0].edge] = 1;
  851.   for (i = 0; i <=fspntr-1; i++)
  852.   {
  853.     /* check and make sure points are on the same scan line */
  854.     if  (FillStack[i].y == FillStack[i+1].y)
  855.     {
  856.     /* check and make sure edges are different */
  857.       if (FillStack[i].edge != FillStack[i+1].edge)
  858.       {
  859.     /* check and make sure edge has not be encountered before */
  860.         if (EdgeTable[FillStack[i+1].edge] != 1)
  861.         {
  862.     /* if polygon interior (plotit=1)  draw line between edges */
  863.           if (plotit == 1)
  864.           {
  865.             TLine(FillStack[i].x, FillStack[i].y,
  866.                FillStack[i+1].x, FillStack[i].y);
  867.             plotit = 0;  /* set plotit false */
  868.           }
  869.           else
  870.             plotit = 1;  /*set plot it true */
  871.         }
  872.         /* Enter edge into edge table */
  873.         EdgeTable[FillStack[i+1].edge] = 1;
  874.       }
  875.     }
  876.     else
  877.     {
  878.       /* y values different means scan line transition */
  879.       /* reset plotit to 1, and EdgeTable */
  880.       plotit = 1;
  881.       memset(EdgeTable,0,sizeof(EdgeTable));
  882.       EdgeTable[FillStack[i+1].edge] = 1;
  883.     }
  884.   }
  885.  
  886.   /* set to outline color */
  887.   _setcolor(outlinecolor);
  888.  
  889.   /* draw outline of polygon */
  890.   for (i = 1; i <= n-1; i++)
  891.   {
  892.     TLine(xy[i-1].x,xy[i-1].y,xy[i].x,xy[i].y);
  893.   }
  894. }
  895.  
  896.  
  897.  
  898. void PolyFillWorldAbs( float *x, float *y, int fillstyle,
  899.                        int fillcolor, int numdat )
  900. {
  901.  
  902.  xyrec *PolyVector;
  903.  int i,outline;
  904.  
  905.   PolyVector = (xyrec *) calloc(numdat,sizeof(xyrec));
  906.  
  907.   MoveWorldAbs( x[0], y[0] );
  908.   for (i=0; i< numdat; i++ ){
  909.       PolyVector[i].x = Round(ConvertX1(x[i]));
  910.       PolyVector[i].y = Round(ConvertY1(y[i]));
  911.   }
  912.   outline = getcolorXX();
  913.   QCPolyFill(PolyVector,  numdat,  fillcolor,  outline);
  914.   free (PolyVector);
  915. }
  916.  
  917.  
  918.  
  919. void PolyLineWorldRel( float *x, float *y, int numdat )
  920. {
  921.   int i;
  922.   MoveWorldRel( x[0], y[0] );
  923.   for (i=1; i< numdat; i++ )
  924.         LineWorldRel( x[i], y[i] );
  925. }
  926.  
  927.  
  928. void BarWorld( float x1,float y1,float h,float w,
  929.                int gc, int gh)
  930. { struct WorldRect r;
  931.   int color;
  932.  
  933.     setfillstyleXX( gh,gc );
  934.     r.left = ConvertX1(x1);
  935.     r.bottom = ConvertY1(y1);
  936.     r.right = ConvertX1(x1+w);
  937.     r.top = ConvertY1(y1+h);
  938.     barXX(r.left, r.top, r.right, r.bottom );
  939. }
  940.  
  941. void EraseWorldRect( struct WorldRect *wr )
  942. { struct viewporttype r;
  943.  
  944.   if (CRTGraphOnF){
  945.         _clearscreen( _GVIEWPORT );
  946.   }
  947. }
  948.  
  949. void ClearViewportXX()
  950. {
  951.         if (CRTGraphOnF)
  952.              _clearscreen( _GVIEWPORT );
  953.  
  954. }
  955.  
  956. void closegraphics()
  957. {
  958.         _setvideomode( _DEFAULTMODE);
  959. }
  960.  
  961.  
  962.  
  963. /*  Screen Dumping Routines  */
  964. int prnerr(int i)
  965. { int prnreturn;
  966.   int error;
  967.  
  968. /*
  969. if ( ((i & 0x20) == 0x20) || ((i & 0x08) ==0x08) || ((i & 0x01 ) ==0x01) )
  970. */
  971.  if ((41 & i ) != 0 )
  972.    prnreturn = 1;
  973.  else prnreturn = 0;
  974.  return(prnreturn);
  975. }
  976.  
  977. void POC(int p, char  c , int *err)
  978. {
  979.    if (p > 1) p = 0;
  980.     *err = _bios_printer(_PRINTER_WRITE,p,c);
  981.  
  982.  
  983. }
  984.  
  985.  
  986.  
  987. int GetPrnPixel(int x,int y, int orient)
  988. {
  989. int result,getmaxx,getmaxy,xval, yy;
  990.   GetMaxCoords(&getmaxx,&getmaxy);
  991.   if (orient == 1){
  992.     xval = getmaxx - y;
  993.     if (xval >= 0 )
  994.       result = _getpixel(xval,x);
  995.     else
  996.       result = 0;
  997.   }
  998.   else
  999.      result = _getpixel(x,y);
  1000.   return(result);
  1001. }
  1002.  
  1003. int GetPrnMaxX(int orient)
  1004. {
  1005. int result, getmaxx,getmaxy;
  1006.  
  1007.   GetMaxCoords(&getmaxx, &getmaxy);
  1008.   if (orient == 1)
  1009.     result = getmaxy;
  1010.   else
  1011.     result = getmaxx;
  1012.   return(result);
  1013. }
  1014.  
  1015. int GetPrnMaxY(int orient)
  1016. {
  1017. int result, getmaxx,getmaxy;
  1018.  
  1019.   GetMaxCoords(&getmaxx, &getmaxy);
  1020.   if (orient == 1)
  1021.     result = getmaxx;
  1022.   else
  1023.     result = getmaxy;
  1024.   return(result);
  1025. }
  1026.  
  1027.  
  1028. void OutputPrinterChar(int PrnPort, char ch,int *error)
  1029. { int i,l;
  1030.   switch (PrnPort) {
  1031.         case 0: POC(PrnPort,ch,error);break;
  1032.         case 1: POC(PrnPort,ch,error);break;
  1033.         case 2: send_com(ch,error);break;
  1034.         default:  POC(PrnPort,ch,error); break;
  1035.   }
  1036. }
  1037.  
  1038. void OutputPrinterString(int PrnPort, char *s,int  *error)
  1039. { int i,l;
  1040.   char ss[255];
  1041.   strcpy( ss,s);
  1042.   l = strlen(ss);
  1043.   for (i=0; i< l; i++) {
  1044.         OutputPrinterChar(PrnPort,ss[i],error);
  1045.   }
  1046. }
  1047.  
  1048. char GetHorizByte(int x,int y, float xm, float ym, int rv, int orient)
  1049. {
  1050.   int i,j, result;
  1051.   char p;
  1052.   char GetHorizByteResult;
  1053.   int ycalc;
  1054.   float xinc, xminc;
  1055.   result = 0;
  1056.   ycalc = floor(y/ym);
  1057.   xinc = 1/xm;
  1058.   xminc = x * xinc;
  1059.   for ( i = 0; i <= 7; i++)  {
  1060.     p = GetPrnPixel( floor(xminc), ycalc, orient) >0;
  1061.         if (rv==1)  p = (char) !(p);
  1062.         if (p)  result = (result | (HVBitMask[7-i]));
  1063.     xminc += xinc;
  1064.   }
  1065.   GetHorizByteResult =( (char) result);
  1066.   return( GetHorizByteResult);
  1067. }
  1068.  
  1069. char GetVertByte(int x,int y,int numPix,float xm,float ym,int rv, int orient)
  1070. {
  1071.   int n,total,i,j,e,b,l;
  1072.   char  result;
  1073.   char  p;
  1074.   char GetVertByteResult;
  1075.   int  xcalc;
  1076.   float yminc,yinc;
  1077.  
  1078.   e = y + numPix - 1;
  1079.   b = 0;
  1080.   l = 0;
  1081.   n = numPix-1;
  1082.   xcalc = floor(x/xm);
  1083.   yinc = 1/ym;
  1084.   yminc = y*yinc;
  1085.   for (i = y; i <= e; i++){
  1086.     p = (GetPrnPixel( xcalc, floor(yminc), orient) >0);
  1087.         if (rv==1)  p= (char) !(p);
  1088.         if (p)  b = (b | (HVBitMask[n-l]));
  1089.         l += 1;
  1090.     yminc += yinc;
  1091.   }
  1092.   GetVertByteResult = ( (char) b);
  1093.   return(GetVertByteResult);
  1094. }
  1095.  
  1096.  
  1097. void ToshibaPScreenDump(int PrnPort,int res,float xm,float ym,
  1098.                         int rv,int orient, int ff, int *error)
  1099. {
  1100.  
  1101.    int maxX, maxY, x,ycount,y,l;
  1102.    char ch,tch;
  1103.    char numCol[80];
  1104.  
  1105.    *error = 0;
  1106.    if (res>1)  res = 0;
  1107.    OutputPrinterChar( PrnPort, ESC ,error);
  1108.    OutputPrinterChar( PrnPort, 'L' ,error);
  1109.    OutputPrinterChar( PrnPort, '0' ,error);
  1110.    OutputPrinterChar( PrnPort, '7' ,error);
  1111.  
  1112.     y = 0;
  1113.     maxX = floor((GetPrnMaxX(orient) + 1) *xm);
  1114.     maxY = floor((GetPrnMaxY(orient) + 1) *ym);
  1115.  
  1116.     itoa(maxX,numCol,10);
  1117.  
  1118.     if (!(prnerr(*error))) {
  1119.         while (y < maxY){
  1120.                 OutputPrinterChar( PrnPort, ESC, error);
  1121.                 OutputPrinterString( PrnPort, ToshResArray[res], error);
  1122.                 if (strlen( numCol)<4 )
  1123.                         OutputPrinterChar( PrnPort, '0', error);
  1124.                 OutputPrinterString( PrnPort, numCol, error);
  1125.                 if (!(prnerr(*error))) {
  1126.                         for ( x = 0; x <= maxX-1; x++) {
  1127.                                 for (l = 0; l <= 3; l++) {
  1128.                                         ch = GetVertByte(x,y+l*6,6,xm,ym,rv,orient);
  1129.                                         OutputPrinterChar(PrnPort,ch,error);
  1130.                                 }
  1131.                         }
  1132.                         if (!(prnerr(*error))) {
  1133.                                 OutputPrinterChar(PrnPort, '\x0d',error);
  1134.                                 OutputPrinterChar(PrnPort, '\x0a',error);
  1135.                                 y +=  24;
  1136.                         }
  1137.                 }
  1138.  
  1139.         }
  1140.         if (!(prnerr(*error))){
  1141.                 tch = '\x1a';
  1142.                 OutputPrinterChar( PrnPort, ESC ,error);
  1143.                 OutputPrinterChar( PrnPort, tch ,error);
  1144.                 OutputPrinterChar( PrnPort, 'I' ,error);
  1145.                 if (ff== 0) OutputPrinterChar(PrnPort,12,error);
  1146.         }
  1147.   }
  1148. }
  1149.  
  1150. void EpsonMXScreenDump(int PrnPort,int res,float xm,float ym,
  1151.                        int rv,int orient, int ff, int *error)
  1152. {
  1153.  
  1154.    int ilow,ihigh,maxX, maxY, x,ycount;
  1155.    int y;
  1156.    char ch;
  1157.    char low,high;
  1158.    char outString[80];
  1159.  
  1160.   *error = 0;
  1161.   if (res>3) res = 0;
  1162.  
  1163.   y = 0;
  1164.   maxX = floor((GetPrnMaxX(orient) + 1) *xm);
  1165.   maxY = floor((GetPrnMaxY(orient) + 1) *ym);
  1166.  
  1167.   ilow = maxX % 256;
  1168.   low = ((char)ilow);
  1169.   ihigh = (maxX / 256 );
  1170.   high  = ((char)ihigh);
  1171.  
  1172.  
  1173.  
  1174.   OutputPrinterChar( PrnPort, ESC, error );
  1175.   OutputPrinterChar( PrnPort, 'A', error );
  1176.   OutputPrinterChar( PrnPort, '\x08', error );
  1177.   OutputPrinterChar( PrnPort, ESC, error );
  1178.   OutputPrinterChar( PrnPort, '\x32', error );
  1179.  
  1180.   if (!(prnerr(*error))) {
  1181.         while (y < maxY){
  1182.                 OutputPrinterChar(PrnPort,ESC,error);
  1183.                 OutputPrinterString(PrnPort, EMXResArray[res],error);
  1184.                 OutputPrinterChar(PrnPort,low,error);
  1185.                 OutputPrinterChar(PrnPort,high,error);
  1186.  
  1187.                 if (!(prnerr(*error))) {
  1188.                         for (x = 0;  x <= maxX-1; x++) {
  1189.                         ch = GetVertByte(x,y,8,xm,ym,rv, orient);
  1190.                         OutputPrinterChar(PrnPort,ch,error);
  1191.                 }
  1192.                 if (!(prnerr(*error))){
  1193.                         OutputPrinterChar(PrnPort, '\x0d',error);
  1194.                         OutputPrinterChar(PrnPort, '\x0a',error);
  1195.                         y +=  8;
  1196.                 }
  1197.       }
  1198.   }
  1199.     if (!(prnerr(*error))){
  1200.         OutputPrinterChar(PrnPort, '\x0d',error);
  1201.         OutputPrinterChar(PrnPort, '\x0a',error);
  1202.         OutputPrinterChar(PrnPort, ESC,error );
  1203.         OutputPrinterChar(PrnPort, 'A',error);
  1204.         OutputPrinterChar(PrnPort, '\x0c',error);
  1205.         OutputPrinterChar(PrnPort, ESC,error );
  1206.         OutputPrinterChar(PrnPort, '\x32',error );
  1207.         if (ff== 0)  OutputPrinterChar(PrnPort,12,error);
  1208.     }
  1209.   }
  1210. }
  1211.  
  1212.  
  1213. void EpsonFXScreenDump(int PrnPort,int res,float xm,float ym,
  1214.                        int rv,int orient, int ff, int *error)
  1215. {
  1216.  
  1217.    int ilow,ihigh,maxX, maxY, x,ycount;
  1218.    int y;
  1219.    char ch;
  1220.    char low,high;
  1221.    char outString[80];
  1222.  
  1223.   *error = 0;
  1224.   if (res>3) res = 0;
  1225.  
  1226.   y = 0;
  1227.   maxX = floor((GetPrnMaxX(orient) + 1) *xm);
  1228.   maxY = floor((GetPrnMaxY(orient) + 1) *ym);
  1229.  
  1230.   ilow = maxX % 256;
  1231.   low = ((char)ilow);
  1232.   ihigh = (maxX / 256 );
  1233.   high  = ((char)ihigh);
  1234.  
  1235.  
  1236.  
  1237.   OutputPrinterChar( PrnPort, ESC, error );
  1238.   OutputPrinterChar( PrnPort, 'A', error );
  1239.   OutputPrinterChar( PrnPort, '\x08', error );
  1240.  
  1241.   if (!(prnerr(*error))) {
  1242.         while (y < maxY){
  1243.                 OutputPrinterChar(PrnPort,ESC,error);
  1244.                 OutputPrinterString(PrnPort, EMXResArray[res],error);
  1245.                 OutputPrinterChar(PrnPort,low,error);
  1246.                 OutputPrinterChar(PrnPort,high,error);
  1247.  
  1248.                 if (!(prnerr(*error))) {
  1249.                         for (x = 0;  x <= maxX-1; x++) {
  1250.                         ch = GetVertByte(x,y,8,xm,ym,rv, orient);
  1251.                         OutputPrinterChar(PrnPort,ch,error);
  1252.                 }
  1253.                 if (!(prnerr(*error))){
  1254.                         OutputPrinterChar(PrnPort, '\x0d',error);
  1255.                         OutputPrinterChar(PrnPort, '\x0a',error);
  1256.                         y +=  8;
  1257.                 }
  1258.       }
  1259.   }
  1260.     if (!(prnerr(*error))){
  1261.         OutputPrinterChar(PrnPort, '\x0d',error);
  1262.         OutputPrinterChar(PrnPort, '\x0a',error);
  1263.         OutputPrinterChar(PrnPort, ESC,error );
  1264.         OutputPrinterChar(PrnPort, 'A',error);
  1265.         OutputPrinterChar(PrnPort, '\x0c',error);
  1266.         if (ff== 0)  OutputPrinterChar(PrnPort,12,error);
  1267.     }
  1268.   }
  1269. }
  1270.  
  1271. void EpsonLQScreenDump(int PrnPort,int  res,float  xm,float  ym,
  1272.                        int rv,int orient, int ff,int *error)
  1273. {
  1274.  
  1275.   int maxX, maxY, x,ycount,y,l;
  1276.   char ch;
  1277.   char high,low;
  1278.   int ilow;
  1279.   int ihigh;
  1280.   char numCol[10];
  1281.   char endGraph[10];
  1282.   char lineSpace[10];
  1283.   char graphInit[10];
  1284.  
  1285.   *error = 0;
  1286.   if (res>8)  res = 0;
  1287.   if (res<4)  EpsonMXScreenDump(PrnPort, res, xm, ym, rv,orient,ff, error);
  1288.   else  {
  1289.         res -= 4;
  1290.         y = 0;
  1291.         maxX = floor((GetPrnMaxX(orient) + 1) *xm);
  1292.         maxY = floor((GetPrnMaxY(orient) + 1) *ym);
  1293.         ilow = maxX % 256;
  1294.         low = ((char)ilow);
  1295.         ihigh = (maxX / 256 );
  1296.         high  = ((char)ihigh);
  1297.  
  1298.         OutputPrinterChar(PrnPort,ESC,error);
  1299.         OutputPrinterChar(PrnPort,'A',error);
  1300.         OutputPrinterChar(PrnPort,'\x08',error);
  1301.         if (!(prnerr(*error))){
  1302.                 while (y < maxY){
  1303.                         OutputPrinterChar(PrnPort,ESC,error);
  1304.                         OutputPrinterChar(PrnPort,'*',error);
  1305.                         OutputPrinterString(PrnPort,ELQResArray[res],error);
  1306.                         OutputPrinterChar(PrnPort,low,error);
  1307.                         OutputPrinterChar(PrnPort,high,error);
  1308.                         if (!(prnerr(*error))){
  1309.                                 for (x = 0; x <= maxX-1; x++){
  1310.                                         for (l = 0; l <= 2; l++) {
  1311.                                         ch = GetVertByte(x,y+l*8,8,xm,ym,rv,orient);
  1312.                                         OutputPrinterChar(PrnPort,ch,error);
  1313.                                         }
  1314.                                 }
  1315.                         }
  1316.                         if (!(prnerr(*error))){
  1317.                                 OutputPrinterChar(PrnPort, '\x0d',error);
  1318.                                 OutputPrinterChar(PrnPort, '\x0a',error);
  1319.                                 y += 24;
  1320.                         }
  1321.  
  1322.                 } /*  end while */
  1323.         }   /* end if */
  1324.                 if(!(prnerr(*error))){
  1325.                         OutputPrinterChar(PrnPort,ESC,error);
  1326.                         OutputPrinterChar(PrnPort,'@',error);
  1327.                 }   /* end if */
  1328.                 if ((ff== 0)&& (!(prnerr(*error))))
  1329.                         OutputPrinterChar(PrnPort,12,error);
  1330.         } /* end else */
  1331. }  /* end epsonlq */
  1332.  
  1333.  
  1334.  
  1335. void HPLaserPlusScreenDump(int PrnPort,int res,float  xm,float  ym,
  1336.                            int rv,int orient, int ff,int *error)
  1337. {
  1338.  
  1339.    int  maxX, maxY, x,ycount,y,l;
  1340.    char outString[80];
  1341.    char lch[5],ch;
  1342.  
  1343.   *error = 0;
  1344.   if (res>3)  res = 0;
  1345.   OutputPrinterChar(PrnPort,ESC,error);
  1346.   OutputPrinterChar(PrnPort,'*',error);
  1347.   OutputPrinterChar(PrnPort,'t',error);
  1348.   OutputPrinterString(PrnPort,HPLResStringsY[res],error);
  1349.   OutputPrinterChar(PrnPort,'R',error);
  1350.  
  1351.   OutputPrinterChar(PrnPort,ESC,error);
  1352.   OutputPrinterChar(PrnPort,'*',error);
  1353.   OutputPrinterChar(PrnPort,'r',error);
  1354.   OutputPrinterChar(PrnPort,'0',error);
  1355.   OutputPrinterChar(PrnPort,'A',error);
  1356.  
  1357.   maxX = floor((GetPrnMaxX(orient) + 1) *xm);
  1358.   maxY = floor((GetPrnMaxY(orient) + 1) *ym);
  1359.   l = maxX / 8;
  1360.   itoa( l,lch,10);
  1361.  
  1362.   for (y = 0; y < maxY; y++){
  1363.         OutputPrinterChar(PrnPort,ESC,error);
  1364.         OutputPrinterChar(PrnPort,'*',error);
  1365.         OutputPrinterChar(PrnPort,'b',error);
  1366.         OutputPrinterString(PrnPort,lch,error);
  1367.         OutputPrinterChar(PrnPort,'W',error);
  1368.  
  1369.         for ( x = 0; x <= ((maxX-1) / 8); x++) {
  1370.                 ch = GetHorizByte(x*8,y,xm,ym,rv, orient);
  1371.                 OutputPrinterChar(PrnPort,ch, error);
  1372.         }
  1373.   }
  1374.   OutputPrinterChar(PrnPort,ESC,error);
  1375.   OutputPrinterChar(PrnPort,'*',error);
  1376.   OutputPrinterChar(PrnPort,'r',error);
  1377.   OutputPrinterChar(PrnPort,'B',error);
  1378.   if (ff== 0)  OutputPrinterChar(PrnPort,12,error);
  1379. }
  1380.  
  1381.  
  1382. void HPThinkJetScreenDump(int PrnPort,int res,float  xm,float  ym,
  1383.                            int rv,int orient, int ff,int *error)
  1384. {
  1385.  
  1386.    int  maxX, maxY, x,ycount,y,l;
  1387.    char outString[80];
  1388.    char lch[5],ch;
  1389.  
  1390.   *error = 0;
  1391.   if (res>1)  res = 0;
  1392.   OutputPrinterChar(PrnPort,ESC,error);
  1393.   OutputPrinterChar(PrnPort,'*',error);
  1394.   OutputPrinterChar(PrnPort,'r',error);
  1395.   OutputPrinterString(PrnPort,HPJetResStringsY[res],error);
  1396.   OutputPrinterChar(PrnPort,'S',error);
  1397.  
  1398.   OutputPrinterChar(PrnPort,ESC,error);
  1399.   OutputPrinterChar(PrnPort,'*',error);
  1400.   OutputPrinterChar(PrnPort,'r',error);
  1401.   OutputPrinterChar(PrnPort,'A',error);
  1402.  
  1403.   maxX = floor((GetPrnMaxX(orient) + 1) *xm);
  1404.   maxY = floor((GetPrnMaxY(orient) + 1) *ym);
  1405.   l = maxX / 8;
  1406.   itoa( l,lch,10);
  1407.  
  1408.   for (y = 0; y < maxY; y++){
  1409.         OutputPrinterChar(PrnPort,ESC,error);
  1410.         OutputPrinterChar(PrnPort,'*',error);
  1411.         OutputPrinterChar(PrnPort,'b',error);
  1412.         OutputPrinterString(PrnPort,lch,error);
  1413.         OutputPrinterChar(PrnPort,'W',error);
  1414.  
  1415.         for ( x = 0; x <= ((maxX-1) / 8); x++) {
  1416.                 ch = GetHorizByte(x*8,y,xm,ym,rv,orient);
  1417.                 OutputPrinterChar(PrnPort,ch, error);
  1418.         }
  1419.   }
  1420.   OutputPrinterChar(PrnPort,ESC,error);
  1421.   OutputPrinterChar(PrnPort,'*',error);
  1422.   OutputPrinterChar(PrnPort,'r',error);
  1423.   OutputPrinterChar(PrnPort,'B',error);
  1424.   if (ff== 0)  OutputPrinterChar(PrnPort,12,error);
  1425. }
  1426.  
  1427.  
  1428. void ScreenDump(int printer,int PrnPort,int  res,float xm,float ym,
  1429.                 int rv,int orient, int ff,int *error)
  1430. {
  1431.   int maxX, maxY;
  1432.   if (CRTGraphOnF){
  1433.   GetMaxCoords( &maxX, &maxY );
  1434.   _setviewport(0,0,maxX, maxY);
  1435.   switch ( printer) {
  1436.        case 0: EpsonMXScreenDump(PrnPort, res, xm, ym, rv,  orient, ff, error);break;
  1437.        case 1: EpsonLQScreenDump(PrnPort, res, xm, ym, rv,  orient, ff, error);break;
  1438.        case 2: ToshibaPScreenDump(PrnPort, res, xm, ym, rv, orient, ff, error);break;
  1439.        case 3: HPLaserPlusScreenDump(PrnPort, res, xm, ym, rv, orient, ff, error);break;
  1440.        case 4: HPThinkJetScreenDump(PrnPort, res, xm, ym, rv,  orient,ff, error);break;
  1441.        case 5: EpsonFXScreenDump(PrnPort, res, xm, ym, rv, orient,ff, error);break;
  1442.  
  1443.     default:  EpsonMXScreenDump(PrnPort, res, xm, ym, rv,  orient, ff, error);break;
  1444.  }
  1445.       _setviewport(vp.left,vp.top,vp.right,vp.bottom);
  1446.  }
  1447.  if (!(prnerr(*error) == 0)) *error = 0;
  1448. }
  1449.  
  1450. /*   2/20/90   Improved performance of printer drivers by removing
  1451.            redundant multiplies and divides in the GetVertByte
  1452.            and GetHorizByte function.
  1453. */
  1454.