home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / MAGAZINE / MISC / CNEWS009.ZIP / H_GRAPH2.ARC / H_GRAPH2.NUM < prev    next >
Encoding:
Text File  |  1988-07-14  |  17.1 KB  |  545 lines
  1.  10  #include <stdio.h>
  2.  20  #include <conio.h>
  3.  30  #include <dos.h>
  4.  40  #include <h_graph2.h>
  5.  50  #include <mouse.h>
  6.  60  
  7.  70  int m_init(buttons)
  8.  80  int *buttons;
  9.  90  {
  10.  100     union REGS reg;
  11.  110     reg.x.ax=0;
  12.  120     int86(0x33,®,®);
  13.  130     *buttons=reg.x.bx;
  14.  140     return(reg.x.ax);
  15.  150  }
  16.  160  
  17.  170  void m_cursor(on)
  18.  180  int on;
  19.  190  {
  20.  200     union REGS reg;
  21.  210     reg.x.ax=((on)?1:2);
  22.  220     int86(0x33,®,®);
  23.  230  }
  24.  240  
  25.  250  int m_status(hpos,vpos)
  26.  260  int *hpos,*vpos;
  27.  270  {
  28.  280     union REGS regs;
  29.  290     regs.x.ax=3 ;
  30.  300     int86(0x33,®s,®s);
  31.  310     *hpos=regs.x.cx;
  32.  320     *vpos=regs.x.dx;
  33.  330     return regs.x.bx;
  34.  340  }
  35.  350  
  36.  360  void  m_move(hpos,vpos)
  37.  370  int   hpos,vpos;
  38.  380  {
  39.  390     union REGS regs;
  40.  400     regs.x.ax=4;
  41.  410     regs.x.cx=hpos;
  42.  420     regs.x.dx=vpos;
  43.  430     int86(0x33,®s,®s);
  44.  440  }
  45.  450  
  46.  460  void  m_limit(hmin,vmin,hmax,vmax)
  47.  470  int   hmin,hmax,vmin,vmax;
  48.  480  {
  49.  490     union REGS regs;
  50.  500     regs.x.ax=7;
  51.  510     regs.x.cx=hmin;
  52.  520     regs.x.dx=hmax;
  53.  530     int86(0x33,®s,®s);
  54.  540     regs.x.ax=8;
  55.  550     regs.x.cx=vmin;
  56.  560     regs.x.dx=vmax;
  57.  570     int86(0x33,®s,®s);
  58.  580  }
  59.  590  
  60.  600  void m_shape(seg,offset)
  61.  610  int seg,*offset;
  62.  620  {
  63.  630     union REGS regs;
  64.  640     struct SREGS sregs;
  65.  650     regs.x.ax=9;
  66.  660     regs.x.bx=*(offset+32);     /* horiz HOTSPOT in cursor mask */
  67.  670     regs.x.cx=*(offset+33);     /* vert HOTSPOT in cursor mask */
  68.  680     regs.x.dx=offset;           /* first 16 ints are the AND mask */
  69.  690     sregs.es=seg;               /* next 16 ints are the XOR mask */
  70.  700     int86x(0x33,®s,®s,&sregs);
  71.  710  }
  72.  720  
  73.  730  
  74.  740  int h_isherc()
  75.  750  {
  76.  760     union REGS reg;
  77.  770     char save_byte;
  78.  780     extern char far *h_p;
  79.  790     reg.h.ah=15;
  80.  800     int86(16,®,®);
  81.  810     if(reg.h.al!=7) return(-1);
  82.  820     save_byte=*(h_p+65535);
  83.  830     h_p=H_MEMLOC;
  84.  840     *(h_p+65535)=170;
  85.  850     if(*(h_p+65535)!=170) return(1);
  86.  860     *(h_p+65535)=85;
  87.  870     if(*(h_p+65535)!=85) return(1);
  88.  880     *(h_p+65535)=save_byte;
  89.  890     return(0);
  90.  900  }
  91.  910  
  92.  920  int h_init(mode)
  93.  930  int mode;
  94.  940  {
  95.  950     extern int h_vpage,h_apage,h_xpos,h_ypos;
  96.  960     extern int h_pmode,h_vmode,h_color,h_start;
  97.  970     extern int h_xmax,h_xmin,h_ymax,h_ymin;
  98.  980     extern char far *h_p;
  99.  990     static char text[]={97,80,82,15,25,6,25,25,2,13,11,12,0,0,0,0};
  100.  1000     static char graph[]={53,45,46,7,91,2,87,87,2,3,0,0,0,0,0,0};
  101.  1010     char *ptr;
  102.  1020     unsigned i;
  103.  1030     union REGS reg;
  104.  1040     outp(MODEPORT,((h_vmode==99)?2:0));
  105.  1050     ptr=((mode==99)?graph:text);
  106.  1060     reg.h.ah=0;
  107.  1070     reg.h.al=((mode==99)?6:7);
  108.  1080     int86(0x10,®,®);
  109.  1090     outp(MODEPORT,((mode==99)?2:0));
  110.  1100     for(i=0;i<16;i++)
  111.  1110     {
  112.  1120        outp(ADDRPORT,i);
  113.  1130        outp(DATAPORT,*(ptr+i));
  114.  1140     }
  115.  1150     h_vpage=h_apage=h_xmin=h_ymin=h_ypos=h_xpos=h_pmode=h_start=0;
  116.  1160     h_vmode=((mode==99)?99:7);
  117.  1170     h_xmax=719;
  118.  1180     h_ymax=347;
  119.  1190     if(mode==99)
  120.  1200     {
  121.  1210        h_mempse(h_p,0,65535);
  122.  1220     }
  123.  1230     h_color=1;
  124.  1240     outp(MODEPORT,((mode==99)?10:8));
  125.  1250     return(h_vmode);
  126.  1260  }
  127.  1270  
  128.  1280  
  129.  1290  int h_setvpage(page)
  130.  1300  int page;
  131.  1310  {
  132.  1320     extern int h_vpage;
  133.  1330     extern int h_vmode;
  134.  1340     int old_page;
  135.  1350     if(h_vmode==99)
  136.  1360     {
  137.  1370        outp(MODEPORT,10+((page==1)?128:0));
  138.  1380     }
  139.  1390     old_page=h_vpage;
  140.  1400     h_vpage=page;
  141.  1410     return(old_page);
  142.  1420  }
  143.  1430  
  144.  1440  
  145.  1450  void h_onoff(on)
  146.  1460  int on;
  147.  1470  {
  148.  1480     extern int h_vmode;
  149.  1490     extern int h_vpage;
  150.  1500     outp(MODEPORT,((on)?8:0)+((h_vpage==1)?128:0)+((h_vmode==99)?2:0));
  151.  1510  }
  152.  1520  
  153.  1530  void h_drawc(letter,alf_ptr)
  154.  1540  char letter;
  155.  1550  char *alf_ptr;
  156.  1560  {
  157.  1570     extern int h_xpos;
  158.  1580     extern int h_ypos;
  159.  1590     extern int h_xmin;
  160.  1600     extern int h_ymin;
  161.  1610     extern int h_xmax;
  162.  1620     extern int h_ymax;
  163.  1630     extern int h_pmode;
  164.  1640     extern int h_color;
  165.  1650     extern char far *h_p;
  166.  1660     int delta_x,delta_y,height,width,start,stop;
  167.  1670     int i,offset,byte_loc,x1,y1,start_loc,stop_loc,edge_loc;
  168.  1680     char andmask1,andmask2,this_byte,last_bit;
  169.  1690     delta_y=(int)(*alf_ptr);
  170.  1700     delta_x=(int)(*(alf_ptr+1));
  171.  1710     if(delta_y & 128) delta_y=(delta_y & ~128)*-1;
  172.  1720     if(delta_x & 128) delta_x=(delta_x & ~128)*-1;
  173.  1730     height=(int)*(alf_ptr+2);
  174.  1740     width=(int)*(alf_ptr+3);
  175.  1750     start=(int)*(alf_ptr+4);
  176.  1760     stop=(int)*(alf_ptr+5);
  177.  1770     if(h_xpos+width<h_xmin || h_xpos>=h_xmax || h_ypos+height<h_ymin || h_ypos>h_ymax)
  178.  1780     {
  179.  1790        h_xpos+=(int)delta_x;
  180.  1800        h_ypos+=(int)delta_y;
  181.  1810        return;
  182.  1820     }
  183.  1830     else
  184.  1840     {
  185.  1850        offset=h_xpos & 7;
  186.  1860        andmask1=(char)(255<<(8-offset));
  187.  1870        andmask2=255>>(offset+((width==8)?0:1));
  188.  1880        if(h_xpos>=h_xmin && h_xpos+width<=h_xmax);
  189.  1890        else
  190.  1900        {
  191.  1910           if(h_xpos<=h_xmax-width)
  192.  1920           {
  193.  1930              start_loc=((h_xpos+16)>>3)-2;
  194.  1940              edge_loc=h_xmin>>3;
  195.  1950              if(start_loc==edge_loc)
  196.  1960              {
  197.  1970                 andmask1|=(char)(255<<(8-(h_xmin & 7)));
  198.  1980              }
  199.  1990              else
  200.  2000              {
  201.  2010                 andmask1=255;
  202.  2020                 andmask2|=(char)(255<<(8-(h_xmin & 7)));
  203.  2030              }
  204.  2040           }
  205.  2050           else
  206.  2060           {
  207.  2070              stop_loc=(h_xpos+8)>>3;
  208.  2080              edge_loc=h_xmax>>3;
  209.  2090              if(stop_loc==edge_loc)
  210.  2100              {
  211.  2110                 andmask2|=255>>(h_xmax & 7);
  212.  2120              }
  213.  2130              else
  214.  2140              {
  215.  2150                 andmask2=255;
  216.  2160                 andmask1|=255>>(h_xmax & 7);
  217.  2170              }
  218.  2180           }
  219.  2190        }
  220.  2200     }
  221.  2210     h_p=H_MEMLOC;
  222.  2220     x1=h_xpos;
  223.  2230     switch(h_pmode)
  224.  2240     {
  225.  2250        case H_PSET:
  226.  2260           for(i=0;i<height;i++)
  227.  2270           {
  228.  2280              this_byte=*(alf_ptr+6+((int)(letter)*14)+i);
  229.  2290              last_bit=0;
  230.  2300              y1=h_ypos+i;
  231.  2310              if(y1>=h_ymin && y1<h_ymax)
  232.  2320              {
  233.  2330                 byte_loc=H_FORMULA;
  234.  2340                 *(h_p+byte_loc)=(*(h_p+byte_loc) & andmask1) | (char)((this_byte>>offset));
  235.  2350                 if(width==9)
  236.  2360                 {
  237.  2370                    if(letter>start && letter<stop)
  238.  2380                    {
  239.  2390                       last_bit=this_byte & 1;
  240.  2400                    }
  241.  2410                    *(h_p+ ++byte_loc)=(*(h_p+byte_loc) & andmask2) | ((char)(this_byte<<(8-offset))) | ((char)(last_bit<<(7-offset)));
  242.  2420                 }
  243.  2430                 else
  244.  2440                 {
  245.  2450                    *(h_p+ ++byte_loc)=(*(h_p+byte_loc) & andmask2) | ((char)(this_byte<<(8-offset)));
  246.  2460                 }
  247.  2470              }
  248.  2480           }
  249.  2490           break;
  250.  2500        case H_OR:
  251.  2510           for(i=0;i<height;i++)
  252.  2520           {
  253.  2530              this_byte=*(alf_ptr+6+((int)(letter)*14)+i);
  254.  2540              last_bit=0;
  255.  2550              y1=h_ypos+i;
  256.  2560              if(y1>=h_ymin && y1<h_ymax)
  257.  2570              {
  258.  2580                 byte_loc=H_FORMULA;
  259.  2590                 *(h_p+byte_loc)=*(h_p+byte_loc) | (char)((this_byte>>offset));
  260.  2600                 if(width==9)
  261.  2610                 {
  262.  2620                    if(letter>start && letter<stop)
  263.  2630                    {
  264.  2640                       last_bit=this_byte & 1;
  265.  2650                    }
  266.  2660                    *(h_p+ ++byte_loc)=*(h_p+byte_loc) | ((char)(this_byte<<(8-offset))) | ((char)(last_bit<<(7-offset)));
  267.  2670                 }
  268.  2680                 else
  269.  2690                 {
  270.  2700                    *(h_p+ ++byte_loc)=*(h_p+byte_loc) | ((char)(this_byte<<(8-offset)));
  271.  2710                 }
  272.  2720              }
  273.  2730           }
  274.  2740           break;
  275.  2750        case H_XOR:
  276.  2760           for(i=0;i<height;i++)
  277.  2770           {
  278.  2780              this_byte=*(alf_ptr+6+((int)(letter)*14)+i);
  279.  2790              last_bit=0;
  280.  2800              y1=h_ypos+i;
  281.  2810              if(y1>=h_ymin && y1<h_ymax)
  282.  2820              {
  283.  2830                 byte_loc=H_FORMULA;
  284.  2840                 *(h_p+byte_loc)=*(h_p+byte_loc) ^ (char)((this_byte>>offset));
  285.  2850                 if(width==9)
  286.  2860                 {
  287.  2870                    if(letter>start && letter<stop)
  288.  2880                    {
  289.  2890                       last_bit=this_byte & 1;
  290.  2900                    }
  291.  2910                    *(h_p+ ++byte_loc)=*(h_p+byte_loc) ^ ((char)(this_byte<<(8-offset))) | ((char)(last_bit<<(7-offset)));
  292.  2920                 }
  293.  2930                 else
  294.  2940                 {
  295.  2950                    *(h_p+ ++byte_loc)=*(h_p+byte_loc) ^ ((char)(this_byte<<(8-offset)));
  296.  2960                 }
  297.  2970              }
  298.  2980           }
  299.  2990           break;
  300.  3000     }
  301.  3010     h_xpos+=(int)delta_x;
  302.  3020     h_ypos+=(int)delta_y;
  303.  3030  }
  304.  3040  
  305.  3050  int h_loadfont(fname,alphaptr)
  306.  3060  char *fname;
  307.  3070  char *alphaptr;
  308.  3080  {
  309.  3090     FILE *fptr;
  310.  3100     char *alpha;
  311.  3110     fptr=fopen(fname,"rb");
  312.  3120     if(fptr==0) return(-1);
  313.  3130     fread(alphaptr,1,3590,fptr);
  314.  3140     fclose(fptr);
  315.  3150     return(0);
  316.  3160  }
  317.  3170  
  318.  3180  void h_boxfill(x2,y2,tile)
  319.  3190  int x2,y2;
  320.  3200  char *tile;
  321.  3210  {
  322.  3220     extern int h_xmin,h_xmax,h_ymin,h_ymax,h_pmode,h_xpos,h_ypos;
  323.  3230     extern char far *h_p;
  324.  3240     int i,x1,y1,byte_loc,whole_bytes;
  325.  3250     char save_byte,andmask1,andmask2,temp_byte;
  326.  3260     h_p=H_MEMLOC;
  327.  3270     if(h_xpos>h_xmax || h_ypos>h_ymax || x2<h_xmin || y2<h_ymin) return;
  328.  3280     x1=((h_xpos>h_xmin)?h_xpos:h_xmin);
  329.  3290     x2=((x2<h_xmax)?x2++:h_xmax);
  330.  3300     y1=((h_ypos>h_ymin)?h_ypos:h_ymin);
  331.  3310     y2=((y2<h_ymax)?y2:h_ymax);
  332.  3320     andmask1=(char)(255<<(8-(x1 & 7)));
  333.  3330     andmask2=(char)(255>>((x2 & 7)+1));
  334.  3340     whole_bytes=((x2>>3)-(x1>>3))-1;
  335.  3350     switch(h_pmode)
  336.  3360     {
  337.  3370        case H_PSET:
  338.  3380           for(;y1<=y2;y1++)
  339.  3390           {
  340.  3400              save_byte=*(tile+(y1 & 7));
  341.  3410              byte_loc=H_FORMULA;
  342.  3420              if(whole_bytes>=0)
  343.  3430              {
  344.  3440                 *(h_p+byte_loc)=(*(h_p+byte_loc) & andmask1) | (save_byte & (~andmask1));
  345.  3450                 if(whole_bytes)
  346.  3460                 {
  347.  3470                    h_mempse((h_p+byte_loc+1),save_byte,whole_bytes);
  348.  3480                    byte_loc+=whole_bytes;
  349.  3490                 }
  350.  3500                 *(h_p+ ++byte_loc)=(*(h_p+byte_loc) & andmask2) | (save_byte & (~andmask2));
  351.  3510              }
  352.  3520              else
  353.  3530              {
  354.  3540                 *(h_p+byte_loc)=(*(h_p+byte_loc) & (andmask1 ^ andmask2)) | (save_byte & ~andmask1 & ~andmask2);
  355.  3550              }
  356.  3560           }
  357.  3570           break;
  358.  3580        case H_OR:
  359.  3590           for(;y1<=y2;y1++)
  360.  3600           {
  361.  3610              save_byte=*(tile+(y1 & 7));
  362.  3620              byte_loc=H_FORMULA;
  363.  3630              if(whole_bytes>=0)
  364.  3640              {
  365.  3650                 *(h_p+byte_loc)|=save_byte & (~andmask1);
  366.  3660                 if(whole_bytes)
  367.  3670                 {
  368.  3680                    h_memor(h_p+byte_loc+1,save_byte,whole_bytes);
  369.  3690                    byte_loc+=whole_bytes;
  370.  3700                 }
  371.  3710                 *(h_p+ ++byte_loc)|=save_byte & (~andmask2);
  372.  3720              }
  373.  3730              else
  374.  3740              {
  375.  3750                 *(h_p+byte_loc)|=save_byte & ~andmask1 & ~andmask2;
  376.  3760              }
  377.  3770           }
  378.  3780           break;
  379.  3790        case H_AND:
  380.  3800           for(;y1<=y2;y1++)
  381.  3810           {
  382.  3820              save_byte=*(tile+(y1 & 7));
  383.  3830              byte_loc=H_FORMULA;
  384.  3840              if(whole_bytes>=0)
  385.  3850              {
  386.  3860                 temp_byte=andmask1 | (save_byte & (~andmask1));
  387.  3870                 *(h_p+byte_loc)&=temp_byte;
  388.  3880                 if(whole_bytes)
  389.  3890                 {
  390.  3900                    h_memand(h_p+byte_loc+1,save_byte,whole_bytes);
  391.  3910                    byte_loc+=whole_bytes;
  392.  3920                 }
  393.  3930                 temp_byte=andmask2 | (save_byte & (~andmask2));
  394.  3940                 *(h_p+ ++byte_loc)&=temp_byte;
  395.  3950              }
  396.  3960              else
  397.  3970              {
  398.  3980                 *(h_p+byte_loc)&=save_byte & ~andmask1 & ~andmask2;
  399.  3990              }
  400.  4000           }
  401.  4010           break;
  402.  4020        case H_XOR:
  403.  4030           for(;y1<=y2;y1++)
  404.  4040           {
  405.  4050              save_byte=*(tile+(y1 & 7));
  406.  4060              byte_loc=H_FORMULA;
  407.  4070              if(whole_bytes>=0)
  408.  4080              {
  409.  4090                 *(h_p+byte_loc)^=save_byte & (~andmask1);
  410.  4100                 if(whole_bytes)
  411.  4110                 {
  412.  4120                    h_memxor(h_p+byte_loc+1,save_byte,whole_bytes);
  413.  4130                    byte_loc+=whole_bytes;
  414.  4140                 }
  415.  4150                 *(h_p+ ++byte_loc)^=save_byte & (~andmask2);
  416.  4160              }
  417.  4170              else
  418.  4180              {
  419.  4190                 *(h_p+byte_loc)^=save_byte & ~andmask1 & ~andmask2;
  420.  4200              }
  421.  4210           }
  422.  4220           break;
  423.  4230     }
  424.  4240  }
  425.  4250  
  426.  4260  int h_moveto(x1,y1)
  427.  4270  int x1,y1;
  428.  4280  {
  429.  4290     extern int h_xmin,h_xmax,h_ymin,h_ymax,h_xpos,h_ypos;
  430.  4300     h_xpos=x1;
  431.  4310     h_ypos=y1;
  432.  4320     if(x1<=h_xmax && x1>=h_xmin && y1>=h_ymin && y1<=h_ymax) return 0;
  433.  4330     else return 1;
  434.  4340  }
  435.  4350  
  436.  4360  void h_box(x2,y2,tile)
  437.  4370  int x2,y2;
  438.  4380  char *tile;
  439.  4390  {
  440.  4400     int x1,y1;
  441.  4410     extern int h_xpos,h_ypos;
  442.  4420     x1=h_xpos;
  443.  4430     y1=h_ypos;
  444.  4440     h_moveto(x1,y1);
  445.  4450     h_boxfill(x2,y1,tile);
  446.  4460     h_moveto(x2,y1);
  447.  4470     h_boxfill(x2,y2,tile);
  448.  4480     h_moveto(x1,y2);
  449.  4490     h_boxfill(x2,y2,tile);
  450.  4500     h_moveto(x1,y1);
  451.  4510     h_boxfill(x1,y2,tile);
  452.  4520  }
  453.  4530  
  454.  4540  int h_setpmode(newpmode)
  455.  4550  int newpmode;
  456.  4560  {
  457.  4570     int savemode;
  458.  4580     extern int h_pmode;
  459.  4590     savemode=h_pmode;
  460.  4600     h_pmode=newpmode;
  461.  4610     return savemode;
  462.  4620  }
  463.  4630  
  464.  4640  void h_clrw(tile)
  465.  4650  char *tile;
  466.  4660  {
  467.  4670     int savex,savey,savepmode;
  468.  4680     extern int h_xpos,h_ypos,h_pmode;
  469.  4690     savepmode=h_pmode;
  470.  4700     savex=h_xpos;
  471.  4710     savey=h_ypos;
  472.  4720     h_moveto(0,0);
  473.  4730     h_setpmode(H_PSET);
  474.  4740     h_boxfill(719,347,tile);
  475.  4750     h_setpmode(savepmode);
  476.  4760     h_moveto(savex,savey);
  477.  4770  }
  478.  4780  
  479.  4790  void h_explode(tile)
  480.  4800  char *tile;
  481.  4810  {
  482.  4820     double i;
  483.  4830     int halfx,halfy,totalx,totaly;
  484.  4840     extern int h_xmin,h_xmax,h_ymin,h_ymax;
  485.  4850     halfx=h_xmin+((h_xmax-h_xmin)>>1);
  486.  4860     halfy=h_ymin+((h_ymax-h_ymin)>>1);
  487.  4870     totalx=h_xmax-h_xmin;
  488.  4880     totaly=h_ymax-h_ymin;
  489.  4890     for(i=.01;i<1.01;i+=.025)
  490.  4900     {
  491.  4910         h_moveto((int)(halfx-(totalx*i)/2),(int)(halfy-(totaly*i)/2));
  492.  4920         h_boxfill((int)(halfx+(totalx*i)/2),(int)(halfy+(totaly*i)/2),tile);
  493.  4930     }
  494.  4940     h_clrw(tile);
  495.  4950  }
  496.  4960  
  497.  4970  void h_draws(string,alphabet)
  498.  4980  char *string;
  499.  4990  char *alphabet;
  500.  5000  {
  501.  5010     int length,i;
  502.  5020     length=strlen(string);
  503.  5030     for(i=0;i<length;i++)
  504.  5040     {
  505.  5050        h_drawc(*(string+i),alphabet);
  506.  5060     }
  507.  5070  }
  508.  5080  
  509.  5090  void h_patterns()
  510.  5100  {
  511.  5110     extern char lgrey[],dgrey[],fore[],back[],nlines[],nstripes[],nrhatch[];
  512.  5120     extern char nlhatch[],wlines[],wstripes[],wrhatch[],wlhatch[];
  513.  5130     h_boxfill(179,115,fore);
  514.  5140     h_moveto(180,0);
  515.  5150     h_boxfill(359,115,lgrey);
  516.  5160     h_moveto(360,0);
  517.  5170     h_boxfill(539,115,nlines);
  518.  5180     h_moveto(540,0);
  519.  5190     h_boxfill(719,115,nstripes);
  520.  5200     h_moveto(0,116);
  521.  5210     h_boxfill(179,231,nrhatch);
  522.  5220     h_moveto(180,116);
  523.  5230     h_boxfill(359,231,nlhatch);
  524.  5240     h_moveto(360,116);
  525.  5250     h_boxfill(539,231,wlines);
  526.  5260     h_moveto(540,116);
  527.  5270     h_boxfill(719,231,wstripes);
  528.  5280     h_moveto(0,232);
  529.  5290     h_boxfill(179,347,wrhatch);
  530.  5300     h_moveto(180,232);
  531.  5310     h_boxfill(359,347,wlhatch);
  532.  5320     h_moveto(360,232);
  533.  5330     h_boxfill(539,347,dgrey);
  534.  5340     h_moveto(540,232);
  535.  5350     h_boxfill(719,347,wrhatch);
  536.  5360     h_setpmode(H_OR);
  537.  5370     h_boxfill(719,347,wlhatch);
  538.  5380     h_setpmode(H_PSET);
  539.  5390  }
  540.  5400  20
  541.  5410  
  542.  5420  
  543.  5430  
  544.  5440  
  545.