home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / fermiVogle.tar.Z / fermiVogle.tar / devel / drivers / unixplot.c < prev    next >
C/C++ Source or Header  |  1996-02-07  |  4KB  |  297 lines
  1. /*
  2. **    VOGLE Driver for UNIX "plot" format output
  3. */
  4.  
  5. #include <stdio.h>
  6. #include "vogle.h"
  7.  
  8. #define SPACE_SIZE    1024
  9. #define    POINT(x, y)    (0x10000 * (y) + (x))
  10. #define MAXCOLOR    7
  11.  
  12. extern FILE    *_voutfile();
  13.  
  14. static int    uplot_first_time = 1, drawn = 0,
  15.         curcol = 0,            /* black */
  16.         uplotlstx = -1, uplotlsty = -1;    /* last (x, y) drawn */
  17.  
  18. #undef MAP_TO_LINESTYLES    /* This works, but doesn't look great on text */
  19.  
  20. /*
  21.  * Line style map for our standard colours
  22.  */
  23. static char    *colormap[MAXCOLOR + 1] = {
  24.     "solid",
  25.     "dotted",
  26.     "shortdashed",
  27.     "longdashed",
  28.     "dotdashed",
  29.     "solid",
  30.     "solid",
  31.     "solid"
  32. };
  33.  
  34. static FILE    *fp;
  35.  
  36. static int noop(void);
  37. static void putpt(int x, int y, FILE *fp);
  38. static int uplot_init(void);
  39. static void uplot_exit(void);
  40. static void uplot_draw(int x, int y);
  41. static int uplot_font(char *font);
  42. static void uplot_clear(void);
  43. static void uplot_color(int col);
  44. static void uplot_char(char c);
  45. static void uplot_string(char *s);
  46. static void uplot_fill(int n, int x[], int y[]);
  47.  
  48. /*
  49.  * noop
  50.  *
  51.  *    do nothing but return -1
  52.  */
  53. static int
  54. noop(void)
  55. {
  56.     return(-1);
  57. }
  58.  
  59. /*
  60.  * putpt
  61.  *
  62.  *    Put a point out to the file.  Two two-byte values, little-endian.
  63.  *    NOTE:  This assumes 8-bit chars and 16-bit shorts.
  64.  */
  65. static void
  66. putpt(int x, int y, FILE *fp)
  67. {
  68.     short sx, sy;
  69.  
  70.     sx = (short) x;
  71.     sy = (short) y;
  72.  
  73.     putc((sx & 0xff), fp);
  74.     putc(((sx >> 8) & 0xff), fp);
  75.     putc((sy & 0xff), fp);
  76.     putc(((sy >> 8) & 0xff), fp);
  77. }
  78.  
  79. /*
  80.  * uplot_init
  81.  *
  82.  *    Set up the unixplot environment. Returns 1 on success.
  83.  */
  84. static int
  85. uplot_init(void)
  86. {
  87.     fp = _voutfile();
  88.  
  89.     if (!uplot_first_time)
  90.         return(1);
  91.  
  92.     putc('s', fp);
  93.     putpt(0, 0, fp);
  94.     putpt(SPACE_SIZE, SPACE_SIZE, fp);
  95.  
  96.     vdevice.sizeSx = vdevice.sizeSy = SPACE_SIZE; 
  97.     vdevice.sizeX = vdevice.sizeY = SPACE_SIZE; 
  98.  
  99.     vdevice.depth = 1;
  100.  
  101.     return(1);
  102. }
  103.  
  104.  
  105. /*
  106.  * uplot_exit
  107.  *
  108.  *    Flush remaining data and close the output file if neccessary.
  109.  */
  110. static void
  111. uplot_exit(void)
  112. {
  113.     fflush(fp);
  114.     if (fp != stdout)
  115.     {
  116.         fclose(fp);
  117.     }
  118. }
  119.  
  120. /*
  121.  * uplot_draw
  122.  *
  123.  *    draw to an x, y point.
  124.  */
  125. static void
  126. uplot_draw(int x, int y)
  127. {
  128.     if (uplotlstx != vdevice.cpVx || uplotlsty != vdevice.cpVy)
  129.     {
  130.         putc('m', fp);
  131.         putpt(vdevice.cpVx, vdevice.cpVy, fp);
  132.     }
  133.  
  134.     putc('n', fp);
  135.     putpt(x, y, fp);
  136.     uplotlstx = x;
  137.     uplotlsty = y;
  138.     drawn = 1;
  139. }
  140.  
  141. /*
  142.  * uplot_font
  143.  *
  144.  *    There's not much we can do for this.  We can't even know
  145.  *    the width or height!
  146.  */
  147. static int
  148. uplot_font(char *font)
  149. {
  150.     if (strcmp(font, "large") == 0 || strcmp(font, "small") == 0)
  151.     {
  152.         vdevice.hwidth = 1.0;
  153.         vdevice.hheight = 1.0;
  154.         return(1);
  155.     }
  156.     else
  157.     {
  158.         return(0);
  159.     }
  160. }
  161.  
  162. /*
  163.  * uplot_clear
  164.  *
  165.  *    Erase the plot
  166.  */
  167. static
  168. uplot_clear(void)
  169. {
  170.     if (drawn)
  171.     {
  172.         putc('e', fp);
  173.     }
  174.  
  175.     drawn = 0;
  176. }
  177.  
  178. /*
  179.  * uplot_color
  180.  *
  181.  *    Change the linestyle of the lines
  182.  */
  183. static void
  184. uplot_color(int col)
  185. {
  186.     if (col > MAXCOLOR)
  187.         return;
  188.  
  189.     curcol = col;
  190.  
  191. #ifdef MAP_TO_LINESTYLES
  192.     fprintf(fp, "f%s\n", colormap[curcol]);
  193. #endif
  194. }
  195.     
  196. /*
  197.  * uplot_char
  198.  *
  199.  *    Output a character
  200.  */
  201. static void
  202. uplot_char(char c)
  203. {
  204.     if (uplotlstx != vdevice.cpVx || uplotlsty != vdevice.cpVy)
  205.     {
  206.         putc('m', fp);
  207.         putpt(vdevice.cpVx, vdevice.cpVy, fp);
  208.     }
  209.  
  210.     fprintf(fp, "t%c\n", c);
  211.  
  212.     drawn = 1;
  213.     uplotlstx = uplotlsty = -1;
  214. }
  215.  
  216. /*
  217.  * uplot_string
  218.  *
  219.  *    output a string one char at a time.
  220.  */
  221. static void
  222. uplot_string(char *s)
  223. {
  224.     if (uplotlstx != vdevice.cpVx || uplotlsty != vdevice.cpVy)
  225.     {
  226.         putc('m', fp);
  227.         putpt(vdevice.cpVx, vdevice.cpVy, fp);
  228.     }
  229.  
  230.     fprintf(fp, "t%s\n", s);
  231.  
  232.     drawn = 1;
  233.     uplotlstx = uplotlsty = -1;
  234. }
  235.  
  236. /*
  237.  * uplot_fill
  238.  *
  239.  *    Should do a fill, but we can't so just draw the polygon
  240.  */
  241. static void
  242. uplot_fill(int n, int x[], int y[])
  243. {
  244.     int     i;
  245.  
  246.     putc('m', fp);
  247.     putpt(x[0], y[0], fp);
  248.  
  249.     for (i = 1; i < n; i++)
  250.     {
  251.         putc('n', fp);
  252.         putpt(x[i], y[i], fp);
  253.     }
  254.     putc('n', fp);
  255.     putpt(x[0], y[0], fp);
  256.  
  257.     vdevice.cpVx = x[n - 1];
  258.     vdevice.cpVy = y[n - 1];
  259.  
  260.     uplotlstx = uplotlsty = -1;
  261. }
  262.  
  263. static DevEntry uplotdev = {
  264.     "unixplot",
  265.     "large",
  266.     "small",
  267.     noop,
  268.     uplot_char,
  269.     noop,
  270.     uplot_clear,
  271.     uplot_color,
  272.     uplot_draw,
  273.     uplot_exit,
  274.     uplot_fill,
  275.     uplot_font,
  276.     noop,
  277.     noop,
  278.     uplot_init,
  279.     noop,
  280.     noop,
  281.     noop,
  282.     uplot_string,
  283.     noop,
  284.     noop
  285. };
  286.  
  287. /*
  288.  * _unixplot_devcpy
  289.  *
  290.  *    copy the unixplot device into vdevice.dev.
  291.  */
  292. void
  293. _unixplot_devcpy(void)
  294. {
  295.     vdevice.dev = uplotdev;
  296. }
  297.