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