home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / COMM / MISC / SRC26_2.ZIP / SRC / GLIO98.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-27  |  10.0 KB  |  445 lines
  1. /*
  2.     GLIO98.C:
  3.     Module of graphic handler (with G-LIO)
  4.     by Atsuhiro Kojima  Jun 12 1989
  5.  * 89/09/25
  6.  *      ---- V2.4.0 distribution ----
  7. */
  8.  
  9. #ifdef     PC98
  10. #include "option.h"
  11. #ifdef UOP_GRAPHICS
  12. #include    <stdio.h>
  13. #include    <dos.h>
  14. #include    "glio98.h"
  15.  
  16. /*
  17.     Define constants.
  18. */
  19. #define Private     static
  20. #define Public
  21.  
  22. #define LioWorkSize (0x1210+0x10)
  23. #define LioParamSize 0x30    /* this is grater than largest parameter size */
  24. #define EntryBase   0xf990
  25. #define IntInterval 0xc5
  26. #define IntInit     0xa0
  27. #define IntScreen   0xa1
  28. #define IntView     0xa2
  29. #define IntColor1   0xa3
  30. #define IntColor2   0xa4
  31. #define IntCls        0xa5
  32. #define IntPset     0xa6
  33. #define IntLine     0xa7
  34. #define IntCircle   0xa8
  35. #define IntPut2     0xad
  36.  
  37. /*
  38.     Define types.
  39. */
  40. typedef struct    {        /* parameters for gscreen. */
  41.     unsigned char   mode;
  42.     unsigned char   sw;
  43.     unsigned char   activ;
  44.     unsigned char   disp;
  45. }   ParaScreen;
  46.  
  47. typedef struct    {        /* parameters for gview. */
  48.     int         sx;
  49.     int         sy;
  50.     int         ex;
  51.     int         ey;
  52.     unsigned char   fill;
  53.     unsigned char   bord;
  54. }   ParaView;
  55.  
  56. typedef struct    {        /* parameters for gcolor1. */
  57.     unsigned char   dummy;
  58.     unsigned char   back;
  59.     unsigned char   bord;
  60.     unsigned char   fore;
  61.     unsigned char   mode;
  62. }   ParaColor1;
  63.  
  64. typedef struct    {        /* parameters for gpset. */
  65.     int         x;
  66.     int         y;
  67.     unsigned char   pal;
  68. }   ParaPset;
  69.  
  70. typedef struct    {        /* parameters for gline. */
  71.     int         sx;
  72.     int         sy;
  73.     int         ex;
  74.     int         ey;
  75.     unsigned char   pal;
  76.     unsigned char   draw;
  77.     unsigned char   sw;
  78.     unsigned char   fill;
  79.     unsigned char   style;
  80.     unsigned char   len;
  81.     unsigned int    patOff;
  82.     unsigned int    patSeg;
  83. }   ParaLine;
  84.  
  85. typedef struct    {        /* parameters for gcircle. */
  86.     int         cx;
  87.     int         cy;
  88.     int         rx;
  89.     int         ry;
  90.     unsigned char   pal;
  91.     unsigned char   arc;
  92.     int         sx;
  93.     int         sy;
  94.     int         ex;
  95.     int         ey;
  96.     unsigned char   fill;
  97.     unsigned int    patOff;
  98.     unsigned int    patSeg;
  99. }   ParaCircle;
  100.  
  101. typedef struct    {        /* parameters for gput2. */
  102.     int         x;
  103.     int         y;
  104.     unsigned        jis;
  105.     unsigned char   draw;
  106.     unsigned char   sw;
  107.     unsigned char   fore;
  108.     unsigned char   back;
  109. }   ParaPut2;
  110.  
  111. /*
  112.     Define private symbols.
  113. */
  114. Private char        orgWork[LioWorkSize];   /* work area for lio. */
  115. Private char*        lioWork= orgWork;    /* work area (paragraph alignment)*/
  116. Private char        paramWork[LioParamSize]; /* parameter area for LIO */
  117. Private char*        lioParam = paramWork; /* parameter area pointer    */
  118. Private unsigned    lioBase;        /* base segment of work area */
  119. Private char        iret[]= {0xcf};    /* iret. */
  120.  
  121. /*
  122.     Define procedures.
  123. */
  124. Private void    normWork()
  125. /*
  126.     normalize the base segment of work area for G-Lio.
  127.     (G-Lio requires work area which begins from offset 0x0000.)
  128. */
  129. {
  130.     struct  SREGS   segRegs;
  131.     unsigned        parag;
  132.  
  133.     segread(&segRegs);
  134.     lioBase= ((unsigned)orgWork >> 4) + segRegs.ds;
  135.     parag=   ((unsigned)orgWork & 0x000f);
  136.  
  137.     if (parag)
  138.     {
  139.     lioBase++;
  140.     lioWork= &orgWork[0x10-parag];
  141.     lioParam = ¶mWork[0x10-parag];
  142.     }
  143. }
  144.  
  145.  
  146. Private void    setVector()
  147. /*
  148.     set interrupt vectors for G-LIO.
  149. */
  150. {
  151.     static short         nEntry= 0;
  152.     int         i;
  153.     unsigned        ds;
  154.     union   REGS    inRegs;
  155.     union   REGS    outRegs;
  156.     struct  SREGS   segRegs;
  157.     static struct  {
  158.         unsigned char    entry;
  159.         unsigned char    dummy;
  160.         unsigned int    offset;
  161.         }        vecEntry;
  162.  
  163.     segread(&segRegs);
  164.     ds= segRegs.ds;
  165. /*    movedata(EntryBase, 0, ds, &nEntry, 1); */
  166.     moveMemory(&nEntry, ds, 0, EntryBase, 1);
  167.  
  168.     for (i=0; i< nEntry; i++)
  169.     {
  170. /*    movedata(EntryBase, i*4+4, ds, &vecEntry, sizeof(vecEntry)); */
  171.     moveMemory(&vecEntry, ds, i*4+4, EntryBase, sizeof(vecEntry)/2);
  172.     inRegs.h.ah= 0x25;    /* set vector for lio services. */
  173.     inRegs.h.al= vecEntry.entry;
  174.     inRegs.x.dx= vecEntry.offset;
  175.     segread(&segRegs);
  176.     segRegs.ds= EntryBase;
  177.     
  178.     intdosx(&inRegs, &outRegs, &segRegs);
  179.     }
  180.  
  181.     inRegs.h.ah= 0x25;    /* set vector for lio interruption (do nothing). */
  182.     inRegs.h.al= IntInterval;
  183.     inRegs.x.dx= (unsigned)iret;
  184.     segread(&segRegs);
  185.  
  186.     intdosx(&inRegs, &outRegs, &segRegs);
  187. }
  188.  
  189.  
  190. Public    int ginit()
  191. /*
  192.     ginit() will initialize graphic environment.
  193.     (set work area & vectors).
  194. */
  195. {
  196.     union   REGS    inRegs,
  197.             outRegs;
  198.     struct  SREGS   segRegs;
  199.  
  200.     normWork();
  201.     setVector();
  202.  
  203.     segread(&segRegs);
  204.     segRegs.ds= lioBase;
  205.     int86x(IntInit, &inRegs, &outRegs, &segRegs);
  206. }
  207.  
  208. Public    int gscreen(mode, sw, activ, disp)
  209. /*
  210.     gscreen() will set the screen.
  211. */
  212. int mode;   /* graphic mode. */
  213. int sw;     /* graphic switch. */
  214. int activ;  /* active page. */
  215. int disp;   /* display page. */
  216. {
  217.     union   REGS    inRegs,
  218.             outRegs;
  219.     struct  SREGS   segRegs;
  220.     ParaScreen*     params= (ParaScreen*)lioWork;
  221.  
  222.     inRegs.x.bx= 0;
  223.     segread(&segRegs);
  224.     segRegs.ds= lioBase;
  225.  
  226.     params->mode=   mode;
  227.     params->sw=     sw;
  228.     params->activ=  activ;
  229.     params->disp=   disp;
  230.  
  231.     int86x(IntScreen, &inRegs, &outRegs, &segRegs);
  232. }
  233.  
  234.  
  235. Public    int gview(sx, sy, ex, ey, fill, bord)
  236. /*
  237.     gview() will set viewport.
  238. */
  239. int        sx, sy; /* starting point of the viewport. */
  240. int        ex, ey; /* ending point of the viewport. */
  241. int        fill;    /* fill color. */
  242. int        bord;    /* border color. */
  243. {
  244.     union   REGS    inRegs,
  245.             outRegs;
  246.     struct  SREGS   segRegs;
  247.     ParaView*        params= (ParaView*)lioWork; 
  248.  
  249.     inRegs.x.bx= 0;
  250.     segread(&segRegs);
  251.     segRegs.ds= lioBase;
  252.  
  253.     params->sx=     sx;
  254.     params->sy=     sy;
  255.     params->ex=     ex;
  256.     params->ey=     ey;
  257.     params->fill=   fill;
  258.     params->bord=   bord;
  259.  
  260.     int86x(IntView, &inRegs, &outRegs, &segRegs);
  261. }
  262.  
  263.  
  264. Public    int gcolor1(back, bord, fore, mode)
  265. /*
  266.     gcolor1() will set color code.
  267. */
  268. int back;   /* background color. */
  269. int bord;   /* border color. */
  270. int fore;   /* foreground color. */
  271. int mode;   /* color mode. */
  272. {
  273.     union   REGS    inRegs,
  274.             outRegs;
  275.     struct  SREGS   segRegs;
  276.     ParaColor1*     params= (ParaColor1*)lioWork;
  277.  
  278.     inRegs.x.bx= 0;
  279.     segread(&segRegs);
  280.     segRegs.ds= lioBase;
  281.  
  282.     params->back=   back;
  283.     params->bord=   bord;
  284.     params->fore=   fore;
  285.     params->mode=   mode;
  286.  
  287.     int86x(IntColor1, &inRegs, &outRegs, &segRegs);
  288. }
  289.  
  290.  
  291. Public    int gcls()
  292. /*
  293.     gcls() will clear screen.
  294. */
  295. {
  296.     union   REGS    inRegs,
  297.             outRegs;
  298.     struct  SREGS   segRegs;
  299.  
  300.     segread(&segRegs);
  301.     segRegs.ds= lioBase;
  302.  
  303.     int86x(IntCls, &inRegs, &outRegs, &segRegs);
  304. }
  305.  
  306.  
  307. Public    int gpset(x, y, pal, mode)
  308. /*
  309.     gpset will plot a point.
  310. */
  311. int x,y;    /* point. */
  312. int pal;    /* color. */
  313. int mode;   /* action mode. */
  314. {
  315.     union   REGS    inRegs,
  316.             outRegs;
  317.     struct  SREGS   segRegs;
  318.     ParaPset*        params= (ParaPset*)lioWork; 
  319.  
  320.     inRegs.h.ah= mode;
  321.     inRegs.x.bx= 0;
  322.     segread(&segRegs);
  323.     segRegs.ds= lioBase;
  324.  
  325.     params->x=        x;
  326.     params->y=        y;
  327.     params->pal=    pal;
  328.  
  329.     int86x(IntPset, &inRegs, &outRegs, &segRegs);
  330. }
  331.  
  332.  
  333. Public    int gline(sx, sy, ex, ey, pal, draw, sw, fill, style, len, pat)
  334. /*
  335.     gline() will draw line (or rectangle).
  336. */
  337. int sx, sy;    /* starting point of line. */
  338. int ex, ey;    /* ending point of line. */
  339. int pal;    /* palette code of line. */
  340. int draw;    /* draw flag. */
  341. int sw;     /* draw switch. */
  342. int fill;    /* palette code for filling. */
  343. int style;    /* line style. */
  344. int len;    /* length of line pattern. */
  345. int*    pat;    /* pointer to line pattern. */
  346. {
  347.     union   REGS    inRegs,
  348.             outRegs;
  349.     struct  SREGS   segRegs;
  350.     ParaLine*        params= (ParaLine*)lioWork;
  351.  
  352.     inRegs.x.bx= 0;
  353.     segread(&segRegs);
  354.     segRegs.ds= lioBase;
  355.  
  356.     params->sx=     sx;
  357.     params->sy=     sy;
  358.     params->ex=     ex;
  359.     params->ey=     ey;
  360.     params->pal=    pal;
  361.     params->draw=   draw;
  362.     params->sw=     sw;
  363.     params->fill=   fill;
  364.     params->style=  style;
  365.     params->len=    len;
  366.     params->patOff= (unsigned)pat;
  367.     params->patSeg= segRegs.ds;
  368.  
  369.     int86x(IntLine, &inRegs, &outRegs, &segRegs);
  370. }
  371.  
  372. Public    int gcircle(cx, cy, rx, ry, pal, arc, sx, sy, ex, ey, fill, pat)
  373. /*
  374.     gcircle() will draw circle (or ellipse).
  375. */
  376. int    cx, cy; /* center point. */
  377. int    rx, ry; /* radius. */
  378. int    pal;    /* color of line. */
  379. int    arc;    /* arc flag. */
  380. int    sx, sy; /* starting point. */
  381. int    ex, ey; /* ending point. */
  382. int    fill;    /* fill color. */
  383. int*    pat;    /* fill pattern. */
  384. {
  385.     union   REGS    inRegs,
  386.             outRegs;
  387.     struct  SREGS   segRegs;
  388.     ParaCircle*     params= (ParaCircle*)lioWork;
  389.  
  390.     inRegs.x.bx= 0;
  391.     segread(&segRegs);
  392.     segRegs.ds= lioBase;
  393.  
  394.     params->cx=     cx;
  395.     params->cy=     cy;
  396.     params->rx=     rx;
  397.     params->ry=     ry;
  398.     params->pal=    pal;
  399.     params->arc=    arc;
  400.     params->sx=     sx;
  401.     params->sy=     sy;
  402.     params->ex=     ex;
  403.     params->ey=     ey;
  404.     params->fill=   fill;
  405.     params->patOff= (unsigned)pat;
  406.     params->patSeg= segRegs.ds;
  407.  
  408.     int86x(IntCircle, &inRegs, &outRegs, &segRegs);
  409. }
  410.  
  411.  
  412. Public    int gput2(x, y, jis, draw, sw, fore, back)
  413. /*
  414.     gput2() will put a character on the graphic screen.
  415. */
  416. int        x, y;   /* point. */
  417. unsigned    jis;    /* jis code. */
  418. int        draw;   /* draw flag. */
  419. int        sw;     /* graphic switch. */
  420. int        fore;   /* foreground color. */
  421. int        back;   /* background color. */
  422. {
  423.     union   REGS    inRegs,
  424.             outRegs;
  425.     struct  SREGS   segRegs;
  426.     ParaPut2*        params= (ParaPut2*)lioWork; 
  427.  
  428.     inRegs.x.bx= 0;
  429.     segread(&segRegs);
  430.     segRegs.ds= lioBase;
  431.  
  432.     params->x=        x;
  433.     params->y=        y;
  434.     params->jis=    jis;
  435.     params->draw=   draw;
  436.     params->sw=     sw;
  437.     params->fore=   fore;
  438.     params->back=   back;
  439.  
  440.     int86x(IntPut2, &inRegs, &outRegs, &segRegs);
  441. }
  442.  
  443. #endif /* UOP_GRAPHICS */
  444. #endif /* PC98 */
  445.