home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / EXAMPLES / DEMOGRAB.C < prev    next >
C/C++ Source or Header  |  1991-03-09  |  17KB  |  784 lines
  1. /*
  2.     demograb.c
  3.  
  4.     C-scape 3.2    Example Program
  5.     Copyright (c) 1990 by Oakland Group, Inc.
  6.     ALL RIGHTS RESERVED.
  7.     
  8.     This program demonstrates how graphics images can be drawn
  9.     on top of C-scape screens and then saved into the window for mobility.
  10.  
  11.     This program relies on the compiler supplied graphics library
  12.     to draw the graphic images.
  13.  
  14.     The following graphics libraries are supported:
  15.     
  16.     Note:    If you are running on a CGA then you must run 
  17.             the DOS utility GRAPTABL.COM before running 
  18.             this program.  GRAPTABL.COM loads the extended 
  19.             ASCII character    set for use in graphics mode.
  20.  
  21.     Note:    The Microsoft 5.1 graphics library does not support the
  22.             Hercules card.  The Microsoft 6.0 library does, but first
  23.             you have to install a TSR utility for it to work.
  24.  
  25.     Revision History:
  26.     -----------------
  27.      1/31/90 jmd    added environment variable support
  28.      4/01/90 jmd    ansi-fied
  29.      4/22/90 pmcm    added check on fexit before updating graph
  30.      6/06/90 jmd    changed main to return an int
  31.      9/14/90 bkd    changed to use exit(0) instead of return(0).
  32.     10/19/90 pmcm    included ostdlib.h for exit(), added return(1)
  33.     10/31/90 jmd    added call to DoSexit
  34.     11/02/90 ted    added m6, tc++ support.
  35.     12/01/90 ted    added (int) casts in fg_color & bardata[i] assignments.
  36.     12/01/90 ted    prototyped main, except if Turbo C++.
  37.     12/01/90 ted    removed unused 'box' variable in MS dgraf_Init.
  38.     12/04/90 ted    restored "" includes for C-scape headers (not <> includes).
  39.     12/08/90 pmcm    removed reference in note section re: defining M5
  40. */
  41.  
  42. #include <stdio.h>
  43.  
  44. #include "cscape.h"
  45. #include "olimits.h"    /* we need this for prompting user of MAXINT */
  46. #include "ostdlib.h"
  47. #include "pcmode.h"
  48. #include "pmwinobj.h"    /* for pmwin stuff */
  49. #include "scancode.h"
  50.  
  51.  
  52. /*** Conditionally include compiler-supplied graphics library header ***/
  53.  
  54. /*-----------------------------    Microsoft C specific ---------------------*/
  55.  
  56. #ifdef M6
  57. #include <graph.h>
  58. #endif
  59.  
  60. /*----------------------------- Borland Turbo C specific -----------------*/
  61.  
  62. #ifdef __TURBOC__
  63. #include <graphics.h>
  64.  
  65. /*     
  66.     Borland Users!
  67.     BGI_PATH is directory in which initgraph looks for the 
  68.     Borland .BGI files.  You may have to change this path 
  69.     depending on how you have installed your Turbo C compiler.
  70.     Consult the Turbo C manual under initgraph for more information.
  71.     Note that the backslashes in the path name must quoted
  72.     with a preceding backslash.
  73.  
  74.     You can also define the environment variable BGIPATH
  75.     which overrides this #define:
  76.     
  77.     set BGIPATH=\tc\bgi
  78. */
  79.  
  80. #define BGI_PATH     "\\TC\\"
  81.  
  82. #endif
  83.  
  84. /*----------------------------- End of Compiler specific section -------------*/
  85.  
  86.  
  87.  
  88. /*** data structure to hold information about the demo ***/
  89.  
  90. typedef struct {
  91.     int        hgt;                /* display height in pixels */
  92.     int        wid;                /* display width in pixels     */
  93.     int        ncolors;            /* number of available colors */
  94.  
  95.     byte     reg;                /* colors used by menus and popups */
  96.     byte     sel;
  97.  
  98. } dgraf_struct;
  99.  
  100.  
  101. /*** Macros and definitions ***/
  102.  
  103. #define nrand(n)        (rand() % (n))
  104. #define QUIT            999
  105.  
  106. /*** Function prototypes ***/
  107.  
  108. /* Turbo C++ complains if main is prototyped */
  109. #ifndef TCP
  110. int main(void);
  111. #endif
  112.  
  113. sed_type     makesed(int *bardata);
  114. boolean     spc_UpdateGraph(sed_type sed, int scancode);
  115. void         UpdateGraph(win_type win);
  116.  
  117. /* graphics routines */
  118.  
  119. int     dgraf_Init(dgraf_struct *dgrafp);
  120. void     dgraf_Line(opbox *opboxp, int color);
  121. void     dgraf_Rectangle(opbox *opboxp, int color);
  122. void     dgraf_FillRectangle(opbox *opboxp, int color);
  123. void     dgraf_Clear(void);
  124.  
  125. #define BAR_COUNT     5
  126.  
  127. /* global data */
  128.  
  129. sed_type mainsed = NULL;
  130. win_type graphwin = NULL;
  131.  
  132. int         bardata[BAR_COUNT];
  133.  
  134. int         fg_color, bg_color;
  135. /*-----------------------------    MAIN -----------------------------------------*/
  136.  
  137. int main(void)
  138. {
  139.     dgraf_struct dgraf;
  140.     int         i, x;
  141.     ocbox        cbox;
  142.     pmap_type    pmap;
  143.  
  144.  
  145.     /*  
  146.         Initialize the C-scape device interface:
  147.         def_ModeGraphics selects best available graphics mode
  148.     */
  149.  
  150.     if (!disp_Init(def_ModeGraphics, FNULL)) {
  151.         printf("\nDEMOGRAB: -- No graphics hardware found;");
  152.         printf("\n          -- Or, insufficient memory to initialize the OWL ...");
  153.         printf("\n             (This program requires a large memory mode)\n");
  154.         exit(1);
  155.         return(1);
  156.     }
  157.  
  158.     /* map colors for 2 color video modes */
  159.     if (disp_GetColors() <= 2L) {
  160.         disp_MapMono(TRUE);
  161.         fg_color = 1;
  162.         bg_color = 0;
  163.     }
  164.     else {
  165.         fg_color = (int) disp_GetColors() - 1;
  166.         bg_color = 3;
  167.     }
  168.  
  169.     /* Initialize Graphics Library */
  170.     if ((x = dgraf_Init(&dgraf)) != 0) {
  171.         disp_Close();
  172.  
  173. #ifdef __TURBOC__            /* Turbo C */
  174.     switch(x) {
  175.     case -2:
  176.         printf("\nDEMOGRAB: Turbo C initgraph cannot detect graphics card.\n");
  177.         break;
  178.     case -3:
  179.         printf("\nDEMOGRAB: Turbo C initgraph cannot find BGI driver file.\n");
  180.         break;
  181.     case -4:
  182.         printf("\nDEMOGRAB: Turbo C initgraph does not support this video hardware.\n");
  183.         break;
  184.     case -5:
  185.         printf("\nDEMOGRAB: Turbo C initgraph insufficient memory to load driver.\n");
  186.         break;
  187.     default:    
  188.         printf("\nDEMOGRAB: Turbo C initgraph error %d.\n", x);
  189.         break;
  190.     }
  191. #else
  192.         printf("\nDEMOGRAB: Microsoft C _setvideomode does not support this video hardware.\n");
  193. #endif
  194.  
  195.         exit(1);
  196.         return(1);
  197.     }
  198.  
  199.     /* Turn on the mouse */
  200.     hard_InitMouse();
  201.  
  202.     /* Turn on sedwin mouse */
  203.     sedwin_ClassInit();
  204.  
  205.     /* Turn on pmap window mouse */
  206.     pmwin_MouseInit();
  207.  
  208.     /* initialize bar data */
  209.     for (i = 0; i < BAR_COUNT; i++) {
  210.         bardata[i] = (int) (((float) rand() / (float) RAND_MAX) * (float) 100) + 1;
  211.     }
  212.  
  213.     /* create the main sed */
  214.     mainsed = makesed(bardata);
  215.  
  216.     /* create the graphwin:
  217.      *     the graphwin is a pmwin (pixel map window) to which we draw the
  218.      *  graphic.  We then affix the graphic to the window by calling
  219.      *  win_Grab(win)
  220.      */
  221.  
  222.     /* first define the size of the windows in a ocbox structure: */
  223.     cbox.toprow   = 10;
  224.     cbox.leftcol  = 30;
  225.     cbox.botrow   = 20;
  226.     cbox.rightcol = 70;
  227.  
  228.     /* 
  229.         now create the window with win_Open.  We pass win_Open
  230.            the class function for the type of window we wish to create,
  231.            in this case pmwin_Class, and a pointer to the ocbox structure
  232.            defining its initial size and position.
  233.     */    
  234.  
  235.     graphwin = win_Open(pmwin_Class, &cbox);
  236.  
  237.     win_SetAttr(graphwin, 0x3f);
  238.     win_SetBorder(graphwin, bd_1);
  239.     win_SetShadow(graphwin, 1);
  240.  
  241.     bord_SetFeature(graphwin, BD_MOVE);
  242.  
  243.     /* create a pmap, clear it, and connect it to the pmwin */
  244.        pmap = pmap_Open(win_GetPixWidth(graphwin), win_GetPixHeight(graphwin));
  245.     pmap_Clear(pmap, 0);
  246.     pmwin_SetPmap(graphwin, pmap);
  247.  
  248.     win_Employ(graphwin);
  249.     UpdateGraph(graphwin);
  250.  
  251.     /* activate the main sed */
  252.     sed_Go(mainsed);
  253.  
  254.     win_Close(graphwin);
  255.  
  256.     /* the pmap must be closed specifically, it is not automatically
  257.      * closed by win_Close
  258.      */
  259.     pmap_Close(pmap);            
  260.  
  261.     sed_Close(mainsed);
  262.  
  263.     /* close down device interface */
  264.     disp_Close();
  265.  
  266.     exit(0);
  267.     return(0);
  268. }
  269.  
  270. sed_type makesed(int *bardata)
  271. /*
  272.     Create a sed for entering bar data.
  273.  
  274.     bardata is array of BAR_COUNT integers.  As the values in bardata
  275.     are changed the graph in graphwin is updated.
  276. */
  277. {
  278.     menu_type    menu;
  279.     sed_type    sed;
  280.     int         i;
  281.  
  282.     static char intmax_prompt[80];
  283.  
  284.     sprintf(intmax_prompt,  " Enter a number 0 to %-d ",  INT_MAX);
  285.  
  286.     menu = menu_Open();
  287.  
  288.     for (i = 0; i < BAR_COUNT; i++) {
  289.         menu_Printf(menu, "@p[%d,3]Bar data %2d: @fd[#####]", i, i,
  290.               &bardata[i], &pint_funcs, intmax_prompt);
  291.     }
  292.  
  293.     menu_Printf(menu, "\n\n @p[3]@f[ All Done ]", NULL, &menu_funcs);
  294.  
  295.     menu_Flush(menu);
  296.  
  297.     sed = sed_Open(menu);
  298.     sed_SetColors(sed, 0x1e, 0x17, 0x40);
  299.  
  300.     sed_SetBorder(sed, bd_prompt);
  301.     sed_SetBorderFeature(sed, BD_MOVE);
  302.  
  303.     sed_SetBorderColor(sed, 0x1b);
  304.     sed_SetBorderTitle(sed, "demograb");
  305.     sed_SetPosition(sed, 1, 1);
  306.     sed_SetHeight(sed, 10);
  307.     sed_SetWidth(sed, 39);
  308.     sed_SetShadow(sed, 1);
  309.     sed_SetShadowAttr(sed, 0x08);
  310.  
  311.     sed_SetMouse(sed, sedmou_Track);
  312.     sed_SetSpecial(sed, spc_UpdateGraph);
  313.  
  314.     sed_Repaint(sed);
  315.  
  316.     return(sed);
  317. }
  318.  
  319. boolean spc_UpdateGraph(sed_type sed, int scancode)
  320. /*
  321.     Updates the graph when a field is changed.
  322.     Assumes graph windows is stored in global variable, 'graphwin'.
  323. */
  324. {
  325.     static int savedata[BAR_COUNT];
  326.     boolean mustRebuild = FALSE;
  327.     int i;
  328.     
  329.     /* If we changed fields, update the graph */
  330.     switch (scancode) {
  331.     case ESC:
  332.     case ENTER:
  333.     case UP:
  334.     case DOWN:    
  335.     case PGUP:
  336.     case PGDN:
  337.         /* we are going to change fields,
  338.          *     call field fexit to test if field is valid.
  339.          *      if valid, test if we need to update the graph
  340.          */
  341.  
  342.         if (sed_DoFieldFexit(sed, sed_GetFieldNo(sed))) {
  343.             /*     
  344.              *    Move field record into variable.
  345.              *    Call the sexit function.
  346.              *    The    sexit writes the string of digits in the field
  347.              *    record to the native field variable.
  348.              */
  349.             sed_DoFieldSexit(sed, sed_GetFieldNo(sed));
  350.     
  351.             for (i = 0; i < BAR_COUNT; i++) {
  352.                 if (bardata[i] != savedata[i])  {
  353.                     savedata[i] = bardata[i];
  354.                     mustRebuild = TRUE;
  355.                 }
  356.             }            
  357.             if (mustRebuild) {
  358.                 UpdateGraph(graphwin);
  359.             }
  360.         }
  361.     
  362.         break;
  363.     }
  364.  
  365.     return(FALSE);
  366. }
  367.  
  368. void UpdateGraph(win_type win)
  369. /*
  370.     Repaint the graph to the display directly
  371.     then copy the graphics from the display to the graph window's
  372.     pmap with win_Grab().
  373. */
  374. {
  375.     opcoord winx, winy;
  376.     odim     hight, width;
  377.     opbox    pbox;
  378.     int        i, maxbar, ymargin, xmargin, barwidth;
  379.     double     scale;
  380.  
  381.     /* get location and size of window (in pixels) */
  382.     winx = win_GetXmin(win);
  383.     winy = win_GetYmin(win);
  384.  
  385.     hight = win_GetPixHeight(win);
  386.     width = win_GetPixWidth(win);
  387.  
  388.     ymargin = hight / 10;
  389.     xmargin = width / 10;
  390.  
  391.     barwidth = (width - xmargin * 2) / (BAR_COUNT);
  392.  
  393.     /* temporarily turn off mouse cursor,
  394.      * so that we don't draw over it.
  395.      * note: disp_Cache must be followed by a call to disp_Flush.
  396.      */
  397.     disp_Cache();
  398.  
  399.     /* first, clear the region */
  400.     pbox.xmin = winx;
  401.     pbox.xmax = winx + width;
  402.     pbox.ymin = winy;
  403.     pbox.ymax = winy + hight;
  404.     dgraf_FillRectangle(&pbox, bg_color);
  405.  
  406.     /* draw y axis */
  407.     pbox.xmin = pbox.xmax = winx + xmargin; 
  408.     pbox.ymin = winy + ymargin;
  409.     pbox.ymax = winy + hight - ymargin;
  410.     dgraf_Line(&pbox, fg_color);
  411.  
  412.     /* draw x axis */
  413.     /*  pbox.xmin and pbox.ymax stay the same */
  414.     pbox.xmax = winx + width - xmargin;
  415.     pbox.ymin = pbox.ymax;
  416.     dgraf_Line(&pbox, fg_color);
  417.     
  418.     /* find the largest bar (for auto scale) */
  419.     maxbar = bardata[0];
  420.     for (i = 1; i < BAR_COUNT; i++) {
  421.         if (bardata[i] > maxbar) {
  422.             maxbar = bardata[i];
  423.         }
  424.     }
  425.     scale = (.8 * hight) / (float) (maxbar ? maxbar : 1);
  426.         /* draw bars */
  427.     for (i = 0; i < BAR_COUNT; i++) {
  428.     
  429.         pbox.xmin = winx + xmargin + (barwidth * i) + barwidth / 4;
  430.         pbox.xmax = pbox.xmin + (barwidth * 3) / 4;
  431.         pbox.ymax = winy + hight - ymargin - 1;
  432.         pbox.ymin = pbox.ymax - (int) ((double) bardata[i] * scale);
  433.         dgraf_FillRectangle(&pbox, fg_color);
  434.     }
  435.     
  436.     /* turn mouse cursor back on, 
  437.      * note: disp_Flush must be preceeded by a call to disp_Cache.
  438.      */
  439.     disp_Flush();
  440.  
  441.     /* now copy the picture in to the pmwin */
  442.     win_Grab(win);
  443. }  
  444.     
  445.                                       
  446. /*---------------------------------------------------------------------------*/
  447.  
  448. /*     
  449.     Portable graphics routines:
  450.     The following routines are defined for the various graphics libraries
  451.     supported.
  452. */
  453.  
  454. /*-----------------------------    Microsoft C specific ---------------------*/
  455.  
  456. #ifdef M6            /* Microsoft */
  457.  
  458. int dgraf_Init(dgraf_struct *dgrafp)
  459. /*
  460.     Microsoft version.
  461.  
  462.     Initialize the graphics library.
  463.     Initialize demo data.
  464.  
  465.     Returns 
  466.             0     if successful 
  467.             -1  if the video hardware is unsupported by MS.
  468.  
  469. */
  470.  
  471. {
  472.     struct    videoconfig config;        /* Microsoft defined structure */
  473.     short     mode;
  474.  
  475.     switch(pc_GetMode()) {
  476.  
  477.        case 0x13:
  478.         mode = _MRES256COLOR;
  479.         break;
  480.  
  481.        case 0x12:
  482.         mode = _VRES16COLOR;
  483.         break;
  484.  
  485.        case 0x11:
  486.         mode = _VRES2COLOR;
  487.         break;
  488.  
  489.        case 0x10:
  490.         mode = _ERESCOLOR;
  491.         break;
  492.  
  493.        case 0x0f:
  494.         mode = _ERESNOCOLOR;
  495.         break;
  496.  
  497.        case 0x0e:
  498.         mode = _HRES16COLOR;
  499.         break;
  500.  
  501.        case 0x0d:
  502.         mode = _MRES16COLOR;
  503.         break;
  504.  
  505.        case 0x06:
  506.         mode = _HRESBW;
  507.         break;
  508.  
  509.        case 0x05:
  510.     case 0x04:
  511.         mode = _MRESNOCOLOR;
  512.         break;
  513.  
  514.     case 0x10A:
  515.     case 0x10B:
  516.         /* 
  517.         The    Hercules graphics card is not supported by Microsoft 5.1.  _HERCMONO
  518.         is in their graphic.h but does not work with _setvideomode, below.
  519.         */
  520.         mode = _HERCMONO;
  521.         break;
  522.  
  523.     case 0x140:
  524.         /* Compaq Plasma 40 not supported by Microsoft, fall through ... */
  525.  
  526.     default:
  527.         return(-1);
  528.     }
  529.                              
  530.     /* initialize Microsoft video mode */
  531.     if ((_setvideomode(mode)) == 0) {
  532.         return(-1);    /* unsupported hardware configuration */
  533.     }
  534.  
  535.     /* initialize config structure */
  536.     _getvideoconfig(&config);
  537.  
  538.     dgraf_Clear();
  539.  
  540.     /* set up dgraf data */
  541.  
  542.     dgrafp->hgt = config.numypixels;
  543.     dgrafp->wid = config.numxpixels;
  544.     dgrafp->ncolors = config.numcolors;
  545.  
  546.     /* Set up the menu colors */
  547.     if (disp_GetColors() > 2L) {
  548.         dgrafp->reg  = 0x34;
  549.         dgrafp->sel = 0x43;
  550.     }
  551.     else {
  552.         dgrafp->reg  = 0x10;
  553.         dgrafp->sel = 0x01;
  554.     }
  555.  
  556.     return(0);
  557. }
  558.  
  559. void dgraf_Line(opbox *opboxp, int color)
  560. /*
  561.     Draw a line from
  562.     (opboxp->xmin, opboxp->ymax) to (opboxp->xmax, opboxp->ymax)
  563.     with color color.
  564.  
  565.     Microsoft version.
  566. */
  567. {
  568.     _setcolor(color);
  569.     _moveto(opboxp->xmin, opboxp->ymin);
  570.     _lineto(opboxp->xmax, opboxp->ymax);
  571. }
  572.  
  573. void dgraf_Rectangle(opbox *opboxp, int color)
  574. /*
  575.     Draw a rectangle with corners
  576.     (opboxp->xmin, opboxp->ymax) (opboxp->xmax, opboxp->ymax)
  577.     with color color.
  578.  
  579.     Microsoft version.
  580. */
  581. {
  582.     _setcolor(color);
  583.     _rectangle(_GBORDER, opboxp->xmin, opboxp->ymin, opboxp->xmax, opboxp->ymax);
  584. }
  585.  
  586. void dgraf_FillRectangle(opbox *opboxp, int color)
  587. /*
  588.     Draw a filled rectangle with corners
  589.     (opboxp->xmin, opboxp->ymax) (opboxp->xmax, opboxp->ymax)
  590.     with color color.
  591.  
  592.     Microsoft version.
  593. */
  594. {
  595.     _setcolor(color);
  596.     _rectangle(_GFILLINTERIOR, opboxp->xmin, opboxp->ymin, opboxp->xmax, opboxp->ymax);
  597. }
  598.  
  599. void dgraf_Clear()
  600. /*
  601.     Clear the display.
  602.  
  603.     Microsoft version.
  604. */
  605. {
  606.     _clearscreen(_GVIEWPORT);
  607. }
  608.  
  609. #endif
  610.  
  611. /*----------------------------- Borland Turbo C specific -----------------*/
  612.  
  613.  
  614. #ifdef __TURBOC__            /* Turbo C */
  615.  
  616. int dgraf_Init(dgraf_struct *dgrafp)
  617. /*
  618.     Turbo C version.
  619.  
  620.     Initialize the graphics library.
  621.     Initialize demo data.
  622.  
  623.     Returns 
  624.             0 if successful.
  625.  
  626.             turbo initgraph error code if not successful:
  627.                 -2 cannot detect graphics card
  628.                 -3 cannot find driver file
  629.                 -4 invalid driver (unsupported video mode)
  630.                 -5 insufficient memory to load driver
  631.                 
  632. */
  633. {
  634.     int        mode, driver;
  635.     char   *bgipath;    
  636.  
  637.     switch(pc_GetMode()) {
  638.  
  639.        case 0x12:
  640.         driver = VGA;
  641.         mode = VGAHI;
  642.         break;
  643.  
  644.        case 0x11:
  645.         driver = MCGA;
  646.         mode = MCGAHI;
  647.         break;
  648.  
  649.        case 0x10:
  650.         driver = EGA;
  651.         mode = EGAHI;
  652.         break;
  653.  
  654.        case 0x0f:
  655.         driver = EGAMONO;
  656.         mode = EGAMONOHI;
  657.         break;
  658.  
  659.        case 0x0e:
  660.         driver = EGA;
  661.         mode = EGALO;
  662.         break;
  663.  
  664.        case 0x06:
  665.         driver = CGA;
  666.         mode = CGAHI;
  667.         break;
  668.  
  669.        case 0x05:
  670.     case 0x04:
  671.         driver = CGA;
  672.         mode = CGAC1;
  673.         break;
  674.  
  675.     case 0x10A:
  676.     case 0x10B:
  677.         driver = HERCMONO;
  678.         mode = HERCMONOHI;
  679.         break;
  680.  
  681.     case 0x140:    /* Compaq plasma mode 40 */
  682.         driver = ATT400;
  683.         mode = ATT400HI;
  684.         break;
  685.  
  686.        case 0x13:    /* 320x200  (pc_Mode13) 256 color VGA/MCGA, fall through... */
  687.  
  688.        case 0x0d:    /* 320x200  (pc_ModeD)  16 color EGA, fall through...       */
  689.  
  690.     default:
  691.                 /* Not supported by TC -- return code for invalid driver    */
  692.         return(-4);
  693.     }
  694.  
  695.     /* test for environment variable */
  696.     if ((bgipath = getenv("BGIPATH")) == NULL) {
  697.         bgipath = BGI_PATH;
  698.     }
  699.  
  700.     initgraph(&driver, &mode, bgipath);
  701.  
  702.     if (driver < 0) {
  703.         /* initgraph failed */
  704.         return(driver);
  705.     }
  706.  
  707.     dgraf_Clear();
  708.  
  709.     /* set up dgraf data */
  710.  
  711.     dgrafp->hgt = getmaxy();
  712.     dgrafp->wid = getmaxx();
  713.     dgrafp->ncolors = getmaxcolor() + 1;
  714.  
  715.     /* Set up the menu colors */
  716.     if (disp_GetColors() > 2L) {
  717.         dgrafp->reg  = 0x34;
  718.         dgrafp->sel = 0x43;
  719.     }
  720.     else {
  721.         dgrafp->reg  = 0x10;
  722.         dgrafp->sel = 0x01;
  723.     }
  724.  
  725.     return(0);
  726. }
  727.  
  728. void dgraf_Line(opbox *opboxp, int color)
  729. /*
  730.     Draw a line from
  731.     (opboxp->xmin, opboxp->ymax) to (opboxp->xmax, opboxp->ymax)
  732.     with color color.
  733.  
  734.     Turbo C version.
  735. */
  736. {
  737.     setcolor(color);
  738. /*    setlinestyle(SOLID_LINE, 0, THICK_WIDTH);    */
  739.  
  740.     line(opboxp->xmin, opboxp->ymin, 
  741.          opboxp->xmax, opboxp->ymax);
  742. }
  743.  
  744. void dgraf_Rectangle(opbox *opboxp, int color)
  745. /*
  746.     Draw a rectangle with corners
  747.     (opboxp->xmin, opboxp->ymax) (opboxp->xmax, opboxp->ymax)
  748.     with color color.
  749.  
  750.     Turbo C version.
  751. */
  752. {
  753.     setcolor(color);
  754.     rectangle(opboxp->xmin, opboxp->ymin,
  755.               opboxp->xmax, opboxp->ymax);
  756. }
  757.  
  758. void dgraf_FillRectangle(opbox *opboxp, int color)
  759. /*
  760.     Draw a filled rectangle with corners
  761.     (opboxp->xmin, opboxp->ymax) (opboxp->xmax, opboxp->ymax)
  762.     with color color.
  763.  
  764.     Turbo C version.
  765. */
  766. {
  767.     setfillstyle(SOLID_FILL, color);
  768.     bar(opboxp->xmin, opboxp->ymin, 
  769.         opboxp->xmax, opboxp->ymax);
  770. }
  771.  
  772. void dgraf_Clear()
  773. /*
  774.     Clear the display.
  775.  
  776.     Turbo C version.
  777. */
  778. {
  779.     clearviewport();
  780. }
  781.  
  782. #endif
  783.  
  784.