home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / VOGLE.ZIP / VOGLE / DRIVERS / HPDXY.C < prev    next >
C/C++ Source or Header  |  2000-02-11  |  7KB  |  467 lines
  1. #define VOGLE 1
  2.  
  3. /*
  4.  *    DXY & HPGL Driver for vogle/vogl.
  5.  */
  6. #include <stdio.h>
  7. #ifdef VOGLE
  8. #include "vogle.h"
  9. #else
  10. #include "vogl.h"
  11. #endif
  12.  
  13. extern FILE    *_voutfile();
  14.  
  15. static int    plotlstx, plotlsty;    /* position of last draw */
  16.  
  17. static FILE    *fp;
  18.  
  19. #define    P_RESET        0
  20. #define    P_MOVE        1
  21. #define    P_DRAW        2
  22. #define    P_TXTSIZE    3
  23. #define    P_BEGTXT    4
  24. #define    P_ENDTXT    5
  25. #define    P_PEN        6
  26.  
  27. /*
  28.  * basic commands for hpgl
  29.  */
  30. /* 
  31.  * Changed to the delimiters to commas and removed spaces (for older plotter).
  32.  * (mike@penguin.gatech.edu) 
  33.  */
  34. static char    *hpgl[] = {
  35.     "DF;\n",
  36.     "PU%d,%d;\n",
  37.     "PD%d,%d;\n",
  38.     "SI%.4f,%.4f;\n",
  39.     "LB",
  40.     "\003\n",
  41.     "SP%d;\n"
  42. };
  43.  
  44. /*
  45.  * basic commands for dxy
  46.  */
  47. static char    *dxy[] = {
  48.     "",
  49.     "M %d,%d\n",
  50.     "D %d,%d\n",
  51.     "S %d\n",
  52.     "P",
  53.     "\n",
  54.     "J %d\n"
  55. };
  56.  
  57. static char    **plotcmds;
  58.  
  59. /*
  60.  * noop
  61.  *
  62.  *      do nothing but return-1
  63.  */
  64. static int
  65. noop()
  66. {
  67.     return(-1);
  68. }
  69. /*
  70.  * HPGL_common_init()
  71.  *
  72.  * Performs the common parts of HPGL initialization.
  73.  */
  74. static int
  75. HPGL_common_init(minx, maxx, miny, maxy)
  76.     int    minx, maxx, miny, maxy;
  77. {
  78.     vdevice.depth = 4;
  79.  
  80.     fp = _voutfile();
  81.  
  82.     /*
  83.      * The next line is for serial lines if you need to set modes
  84.      */
  85.     fprintf(fp, "\033.(;\033.I81;;17;\033.N;19:IN;");
  86.  
  87.     /*
  88.      * Cause scaling to be 0 to maxX maxY.
  89.      */
  90.     fprintf(fp, "IP%d,%d,%d,%d;", minx, miny, maxx, maxy);
  91.     fprintf(fp, "SC0,%d,0,%d;", vdevice.sizeX, vdevice.sizeY);
  92.  
  93.     plotcmds = hpgl;
  94.     plotlstx = -1111111;
  95.     plotlsty = -1111111;
  96.  
  97.     return(1);
  98. }
  99.  
  100. /*
  101.  * HPGL_init
  102.  *
  103.  *    set up hp plotter. Returns 1 on success.
  104.  */
  105.  
  106. static int
  107. HPGL_A4_init()
  108. {
  109.     /*
  110.      * A4 paper
  111.      */
  112.     vdevice.sizeX = vdevice.sizeY = 7320;
  113.  
  114.     vdevice.sizeSx = 10200;
  115.     vdevice.sizeSy = 7320;
  116.  
  117.     /* 
  118.      * Changed to 7000 (from 7721) as noted by Michael J. Gourlay 
  119.      * (mike@penguin.gatech.edu) 
  120.      */
  121.     return(HPGL_common_init(-7000, 7000, -7000, 7000));
  122. }
  123.  
  124. static int
  125. HPGL_A3_init()
  126. {
  127.     /*
  128.      * A3 paper
  129.      */
  130.     vdevice.sizeX = vdevice.sizeY = 10560;
  131.  
  132.     vdevice.sizeSx = 14720; 
  133.     vdevice.sizeSy = 10560; 
  134.  
  135.     return(HPGL_common_init(-10000, 10000, -10000, 10000));
  136. }
  137.  
  138. static int
  139. HPGL_A2_init()
  140. {
  141.     /*
  142.      * A2 paper
  143.      */
  144.     vdevice.sizeX = vdevice.sizeY = 13440;
  145.  
  146.     vdevice.sizeSx = 18734;
  147.     vdevice.sizeSy = 13440;
  148.  
  149.     return(HPGL_common_init(-13000, 13000, -13000, 13000));
  150. }
  151.  
  152. static int
  153. HPGL_A1_init()
  154. {
  155.     /*
  156.      * A1 paper
  157.      */
  158.     vdevice.sizeX = vdevice.sizeY = 21360;
  159.  
  160.     vdevice.sizeSx = 29774;
  161.     vdevice.sizeSy = 21360;
  162.  
  163.     return(HPGL_common_init(-21000, 21000, -21000, 21000));
  164. }
  165.  
  166.  
  167. /*
  168.  * DXY_init
  169.  *
  170.  *    set up dxy plotter. Returns 1 on success.
  171.  */
  172. static int
  173. DXY_init()
  174. {
  175.     fp = _voutfile();
  176.  
  177.     vdevice.sizeX = vdevice.sizeY = 1920; 
  178.  
  179.     vdevice.sizeSx = 2668; 
  180.     vdevice.sizeSy = 1920; 
  181.  
  182.     plotcmds = dxy;
  183.     plotlstx = -1;
  184.     plotlsty = -1;
  185.  
  186.     fprintf(fp, plotcmds[P_RESET]);
  187.  
  188.     return(1);
  189. }
  190.  
  191. /*
  192.  * PLOT_draw
  193.  *
  194.  *    print the commands to draw a line from the current graphics position
  195.  * to (x, y).
  196.  */
  197. static int
  198. PLOT_draw(x, y)
  199.     int    x, y;
  200. {
  201.     if (plotlstx != vdevice.cpVx || plotlsty != vdevice.cpVy)
  202.         fprintf(fp, plotcmds[P_MOVE], vdevice.cpVx, vdevice.cpVy);
  203.  
  204.     fprintf(fp, plotcmds[P_DRAW], x, y);
  205.     plotlstx = x;
  206.     plotlsty = y;
  207.  
  208.     return(0);
  209. }
  210.  
  211. /*
  212.  * PLOT_exit
  213.  *
  214.  *    exit from vogle printing the command to put away the pen and flush
  215.  * the buffer.
  216.  */
  217. static int
  218. PLOT_exit()
  219. {
  220.     fprintf(fp, plotcmds[P_PEN], 0);
  221.     fprintf(fp, "\033.)");
  222.     fflush(fp);
  223.  
  224.     if (fp != stdout)
  225.         fclose(fp);
  226.  
  227.     return(0);
  228. }
  229.  
  230. /*
  231.  * PLOT_color
  232.  *
  233.  *    change the current pen number.
  234.  */
  235. static int
  236. PLOT_color(i)
  237.     int    i;
  238. { 
  239.     fprintf(fp, plotcmds[P_PEN], i);
  240.  
  241.     return(0);
  242. }
  243.  
  244. /*
  245.  * HPGL_font
  246.  *
  247.  *    load in large or small
  248.  */
  249. static int
  250. HPGL_font(font)
  251.     char    *font;
  252. {
  253.     if (strcmp(font, "small") == 0) {
  254.         vdevice.hwidth = 97.01;    /* Size in plotter resolution units */
  255.         vdevice.hheight = vdevice.hwidth * 2.0;
  256.         fprintf(fp, plotcmds[P_TXTSIZE], 0.16, 0.32);
  257.     } else if (strcmp(font, "large") == 0) {
  258.         vdevice.hwidth = 145.5;
  259.         vdevice.hheight = vdevice.hwidth * 2.0;
  260.         fprintf(fp, plotcmds[P_TXTSIZE], 0.24, 0.48);
  261.     } else 
  262.         return(0);
  263.  
  264.     return(1);
  265. }
  266.  
  267. /*
  268.  * DXY_font
  269.  *
  270.  *    load in large or small.
  271.  */
  272. static int
  273. DXY_font(font)
  274.     char    *font;
  275. {
  276.     if (strcmp(font, "small") == 0) {
  277.         vdevice.hwidth = 24.25;
  278.         vdevice.hheight = vdevice.hwidth * 2.0;
  279.         fprintf(fp, plotcmds[P_TXTSIZE], 3);
  280.     } else if (strcmp(font, "large") == 0) {
  281.         vdevice.hwidth = 36.375;
  282.         vdevice.hheight = vdevice.hwidth * 2.0;
  283.         fprintf(fp, plotcmds[P_TXTSIZE], 5);
  284.     } else 
  285.         return(0);
  286.  
  287.     return(1);
  288. }
  289.  
  290. /*
  291.  * PLOT_char
  292.  *
  293.  *    draw a character.
  294.  */
  295. static int
  296. PLOT_char(c)
  297.     char    c;
  298. {
  299.     if (plotlstx != vdevice.cpVx || plotlsty != vdevice.cpVy)
  300.         fprintf(fp, plotcmds[P_MOVE], vdevice.cpVx, vdevice.cpVy);
  301.  
  302.     fprintf(fp, plotcmds[P_BEGTXT]);
  303.  
  304.     fprintf(fp, "%c", c);
  305.  
  306.     fprintf(fp, plotcmds[P_ENDTXT]);
  307.  
  308.     plotlstx = plotlsty = -1111111;
  309.  
  310.     return(0);
  311. }
  312.  
  313. /*
  314.  * PLOT_string
  315.  *
  316.  *    output a string.
  317.  */
  318. static int
  319. PLOT_string(s)
  320.     char    *s;
  321. {
  322.     if (plotlstx != vdevice.cpVx || plotlsty != vdevice.cpVy)
  323.         fprintf(fp, plotcmds[P_MOVE], vdevice.cpVx, vdevice.cpVy);
  324.  
  325.     fprintf(fp, plotcmds[P_BEGTXT]);
  326.  
  327.     fputs(s, fp);
  328.  
  329.     fprintf(fp, plotcmds[P_ENDTXT]);
  330.  
  331.     plotlstx = plotlsty = -1111111;
  332.  
  333.     return(0);
  334. }
  335.  
  336. /*
  337.  * PLOT_fill
  338.  *
  339.  *      "fill" a polygon
  340.  */
  341. static int
  342. PLOT_fill(n, x, y)
  343.     int     n, x[], y[];
  344. {
  345.     int     i;
  346.  
  347.     if (plotlstx != x[0] || plotlsty != y[0])
  348.         fprintf(fp, plotcmds[P_MOVE], x[0], y[0]);
  349.  
  350.     for (i = 1; i < n; i++)
  351.         fprintf(fp, plotcmds[P_DRAW], x[i], y[i]);
  352.  
  353.     fprintf(fp, plotcmds[P_DRAW], x[0], y[0]);
  354.  
  355.     plotlstx = vdevice.cpVx = x[n - 1];
  356.     plotlsty = vdevice.cpVy = y[n - 1];
  357.  
  358.     return(0);
  359. }
  360.  
  361. static DevEntry hpgldev = {
  362.     "hpgl",
  363.     "large",
  364.     "small",
  365.     noop,
  366.     PLOT_char,
  367.     noop,
  368.     noop,
  369.     PLOT_color,
  370.     PLOT_draw,
  371.     PLOT_exit,
  372.     PLOT_fill,
  373.     HPGL_font,
  374.     noop,
  375.     noop,
  376.     HPGL_A2_init,
  377.     noop,
  378.     noop,
  379. #ifndef VOGLE
  380.     noop,
  381. #endif
  382.     noop,
  383.     PLOT_string,
  384.     noop,
  385.     noop
  386. };
  387.  
  388. /*
  389.  * _HPGL_devcpy
  390.  *
  391.  *    copy the HPGL device into vdevice.dev.
  392.  */
  393. void
  394. _HPGL_A2_devcpy()
  395. {
  396. /* if you don't have structure assignment ...
  397.     char    *dev, *tdev, *edev;
  398.  
  399.     dev = (char *)&hpgldev;
  400.     tdev = (char *)&vdevice.dev;
  401.     edev = dev + sizeof(Device);
  402.  
  403.     while (dev != edev)
  404.         *tdev++ = *dev++;
  405. */
  406.     vdevice.dev = hpgldev;
  407. }
  408.  
  409. void
  410. _HPGL_A3_devcpy()
  411. {
  412.     vdevice.dev = hpgldev;
  413.     vdevice.dev.Vinit = HPGL_A3_init;
  414. }
  415.  
  416. void
  417. _HPGL_A4_devcpy()
  418. {
  419.     vdevice.dev = hpgldev;
  420.     vdevice.dev.Vinit = HPGL_A4_init;
  421. }
  422.  
  423. void
  424. _HPGL_A1_devcpy()
  425. {
  426.     vdevice.dev = hpgldev;
  427.     vdevice.dev.Vinit = HPGL_A1_init;
  428. }
  429.  
  430. static DevEntry dxydev = {
  431.     "dxy",
  432.     "large",
  433.     "small",
  434.     noop,
  435.     PLOT_char,
  436.     noop,
  437.     noop,
  438.     PLOT_color,
  439.     PLOT_draw,
  440.     PLOT_exit,
  441.     PLOT_fill,
  442.     DXY_font,
  443.     noop,
  444.     noop,
  445.     DXY_init,
  446.     noop,
  447.     noop,
  448. #ifndef VOGLE
  449.     noop,
  450. #endif
  451.     noop,
  452.     PLOT_string,
  453.     noop,
  454.     noop
  455. };
  456.  
  457. /*
  458.  * _DXY_devcpy
  459.  *
  460.  *    copy the DXY device into vdevice.dev.
  461.  */
  462. void
  463. _DXY_devcpy()
  464. {
  465.     vdevice.dev = dxydev;
  466. }
  467.