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