home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / plotting / gnuplot3.lzh / gnuplot / term / apollo.trm < prev    next >
Encoding:
Text File  |  1991-06-03  |  16.6 KB  |  534 lines
  1. /* GNUPLOT - apollo.trm */
  2. /*
  3.     Apollo terminal driver for GNUplot.
  4.  
  5.     Open a pad for the graphics, and use GPR routines.  For additional
  6.     speed, we do the graphics to a separate bitmap, and the blt the
  7.     entire bitmap to the display.  When the user specifies an output
  8.     file name, however, we draw directly to the screen, so the graphics
  9.     are written to the file correctly.  Thus, the user can save the
  10.     graphics in a file, to be viewed later.  If we try the bitmap
  11.     trick, it looks funny.
  12.  
  13.     Ray Lischner (uunet!mntgfx!lisch)
  14.     4 October 1989    file created for GNUplot 1.1
  15.     26 March 1990    updated for GNUplot 2.0
  16. */
  17.  
  18. #include <apollo/base.h>
  19. #include <apollo/error.h>
  20. #include <apollo/pad.h>
  21. #include <apollo/gpr.h>
  22.  
  23. /* default tick sizes for small windows */
  24. #define APOLLO_VTIC     6
  25. #define APOLLO_HTIC     6    
  26.  
  27. /* issue an error message, using additional text "s" */
  28. #define apollo_error(s)    error_$print_name(status, (s), strlen(s))
  29.  
  30. /* if "status" indicates an error, then issue an error message */
  31. #define apollo_check(s)    if (status.all != status_$ok) apollo_error(s)
  32.  
  33. static ios_$id_t stream = -1;           /* the stream for the pad */
  34. static gpr_$bitmap_desc_t screen_desc;  /* the screen's bitmap */
  35. static gpr_$bitmap_desc_t bitmap_desc;  /* the graphics bitmap */
  36. static gpr_$attribute_desc_t attr;      /* attribute block for saved bitmap */
  37. static short draw_width;                /* default GPR draw width */
  38. static name_$long_pname_t font_name;    /* font path name */
  39. static int APOLLO_XMAX, APOLLO_YMAX;    /* window size */
  40. static boolean use_bitmap;              /* use a separate bitmap? */
  41.  
  42. /* return whether stdout is a DM pad */
  43. apollo_isa_pad()
  44. {
  45.     status_$t status;
  46.     pad_$isa(1, &status);
  47.     return (status.all == status_$ok);
  48. }
  49.  
  50. /*
  51.     Find out what the default font is for the pad, and save the
  52.     character height and width information.
  53.  
  54.     Note that we must save the font file name because we need
  55.     to reload the font file everytime the window changes size.
  56. */
  57. static void apollo_font_info(struct termentry* tbl, char* fname)
  58. {
  59.     short fwidth, fheight, flen;
  60.     status_$t status;
  61.  
  62.     /* get the font size & update the termentry table */
  63.     pad_$inq_font(stream, &fwidth, &fheight, fname, name_$long_pnamlen_max,
  64.           &flen, &status);
  65.     apollo_check("inq_font");
  66.     fname[flen] = '\0';
  67.  
  68.     tbl->v_char = fheight;
  69.     tbl->h_char = fwidth;
  70. }
  71.  
  72. /*
  73.     Initialize all the GPR stuff.  To save time, we draw into a separate
  74.     bitmap, and then blt it onto the screen all at once.  This results
  75.     in 5-10 times speed-up in the graphics, with only a little
  76.     complication.  Most of the complication is right here, making sure
  77.     we allocate the right bitmaps, etc., in the right order.  The rest
  78.     is in APOLLO_text(), where we actually BLT the bitmap onto the screen.
  79.     Everything else is the same.
  80.  
  81.     The bitmaps have the same size as the window.  If the window changes
  82.     size, then the bitmaps retain the same size, so the user sees part
  83.     of the plot or a lot of space around the plot.  Drawing a new plot,
  84.     or replotting the previous one causes APOLLO_graphics() to see if
  85.     the window has changed size, in which case the GPR is terminated,
  86.     and this routine is called again.  Thus, make sure any changes
  87.     preserve this ability.  Anything that should only be done once
  88.     to the pad should be handled by APOLLO_init().
  89.  
  90.     By the way, we save the current draw width, to be used later
  91.     for drawing extra wide lines.  This way we don't need to know
  92.     anything about the current output device characteristics;
  93.     we can just draw the default width, or twice the default width, etc.
  94. */
  95. static void apollo_gpr_init(struct termentry* tbl, pad_$window_desc_t* window)
  96. {
  97.     gpr_$offset_t size;
  98.     short fontid;
  99.     status_$t status;
  100.  
  101.     size.x_size = APOLLO_XMAX = tbl->xmax = window->width;
  102.     size.y_size = APOLLO_YMAX = tbl->ymax = window->height;
  103.  
  104.     /* now initialize GPR */
  105.     gpr_$init(gpr_$frame, stream, size, 1, &screen_desc, &status);
  106.     apollo_check("gpr_$init");
  107.  
  108.     if (use_bitmap)
  109.     {
  110.     /* allocate the bitmap and its attribute block */
  111.     gpr_$allocate_attribute_block(&attr, &status);
  112.     apollo_check("allocate_attribute_block");
  113.  
  114.     gpr_$allocate_bitmap(size, 1, attr, &bitmap_desc, &status);
  115.     apollo_check("allocate_bitmap");
  116.  
  117.     gpr_$set_bitmap(bitmap_desc, &status);
  118.     apollo_check("set_bitmap");
  119.     }
  120.  
  121.     /* set the font file */
  122.     gpr_$load_font_file(font_name, strlen(font_name), &fontid, &status);
  123.     apollo_check(font_name);
  124.  
  125.     gpr_$set_text_font(fontid, &status);
  126.     apollo_check("set_text_font");
  127.  
  128.     gpr_$inq_draw_width(&draw_width, &status);
  129.     apollo_check("inq_draw_width");
  130. }
  131.  
  132. /*
  133.     Determine the tick sizes to be used for labelling borders.
  134.     By default, we use 1/50 of the window size, which looks nice to me.
  135.     If this makes the ticks too small, however, we use a minimum
  136.     size, to make sure they are visible.  The minimum size was also
  137.     determined experimentally.
  138.  
  139.     Feel free to changes the sizes to something you feel looks better.
  140.  
  141.     This routine must be called after apollo_gpr_init(), because we
  142.     need to know the window size, as stored in the termentry table.
  143. */
  144. static void apollo_tic_sizes(struct termentry* tbl)
  145. {
  146.     /* base the tick size on the window size */
  147.     tbl->v_tic = tbl->ymax / 50;
  148.     if (tbl->v_tic < APOLLO_VTIC)
  149.     tbl->v_tic = APOLLO_VTIC;
  150.     tbl->h_tic = tbl->xmax / 50;
  151.     if (tbl->v_tic < APOLLO_HTIC)
  152.     tbl->v_tic = APOLLO_HTIC;
  153. }
  154.  
  155. /*
  156.     Terminate the GPR.  This is called whenever the window size
  157.     changes, and we need to reinitialize the GPR.  I assume that
  158.     calling gpr_$terminate() also deallocates the bitmaps and
  159.     attribute blocks because deallocating the screen's bitmap
  160.     causes terminate() to think GPR has already been terminated.
  161.  
  162.     Since this can be called many times, make sure nothing
  163.     drastic is done here, like closing the stream to the pad.
  164.     The only actions should be those that will be reinitialized
  165.     by apollo_gpr_init().
  166. */
  167. static void apollo_gpr_terminate()
  168. {
  169.     status_$t status;
  170.  
  171.     gpr_$terminate(false, &status);
  172.     apollo_check("terminate");
  173. }
  174.  
  175. /*
  176.     Initialize the graphics.  This is called once, so we do things
  177.     here that should be done exactly once, such as opening the window.
  178.     I like to give windows names, so it is obvious what the window's
  179.     contents are, but this causes a transcript to be kept in a file
  180.     whose name is the window's name.  This might be nice in some
  181.     circumstances, but to me it is a nuisance, so the file is
  182.     deleted immediately.  The name is unlikely to appear normally,
  183.     so there should be little interference with users' normal files.
  184.     If the user has explicitly set the output file, however, then
  185.     we use that name, and do not delete the file.  Thus, the
  186.     user can get a metafile of the plot.  We can tell if the
  187.     output file has been set because outstr is "STDOUT".  Otherwise,
  188.     outstr is the filename, in single quotes.  We need to strip
  189.     the quotes to make the file name.
  190.  
  191.     The DM defaults are used for window sizes and positions.  If
  192.     the user doesn't like it, he or she can change is and issue
  193.     a replot command (assuming a plot has already been generated).
  194.  
  195.     Note, also, that we must call pad_$set_scale() or else
  196.     pad_$inq_windows() returns scaled values, which is not what
  197.     we want.  Setting the scale to one (1) turns off the scaling,
  198.     so we get real pixel sizes.
  199.  
  200.     Finally, we get the name and size of the default font.  The
  201.     name is kept, as explained earlier.  Then we can initialize
  202.     the GPR stuff.
  203.  
  204.     Note that there is a way that APOLLO_init() gets called more
  205.     than once.  If the user issues the "set terminal apollo" command
  206.     more than once, then this is called, so we need to make sure
  207.     that we do not keep creating windows.
  208.  
  209.     An alternative strategy would be to interpret multiple "set term
  210.     apollo"s to mean create multiple windows.  The user could only
  211.     access the most recent window because GNUplot has no concept of
  212.     multiple terminals.  The user would, in fact, have no way of
  213.     removing old windows because they are still active.  We could try
  214.     catching keyboard events to see if the user presses EXIT, but I do
  215.     not want to start getting into that mess.  If the user really
  216.     wants this kind of functionality, then he or she can run gnuplot
  217.     multiple times.  I think that is a lot cleaner, don't you?
  218. */
  219. APOLLO_init()
  220. {
  221.     /* only initialize once */
  222.     if (stream == -1)
  223.     {
  224.     extern char outstr[];
  225.     struct termentry* tbl;
  226.     pad_$window_desc_t window;
  227.     name_$long_name_t wname;
  228.     short wnum;            /* junk needed by pad_$inq_windows() */
  229.     boolean unlink_wname;
  230.     status_$t status;
  231.  
  232.     tbl = &term_tbl[term];
  233.  
  234.     /* make the window name unique, with "gnuplot" in the label */
  235.     if (strcmp(outstr, "STDOUT") == 0)
  236.     {
  237.         sprintf(wname, "gnuplot-%d", getpid());
  238.         unlink_wname = true;
  239.     }
  240.     else
  241.     {
  242.         /* strip the single quotes around the file name */
  243.         strcpy(wname, outstr + 1);
  244.         wname[strlen(wname) - 1] = '\0';
  245.         unlink_wname = false;
  246.     }
  247.  
  248.     use_bitmap = unlink_wname;
  249.  
  250.     /* use the default window position and size */
  251.     window.top = window.left = window.width = window.height = 0;
  252.     pad_$create_window(wname, strlen(wname), pad_$transcript, 1, window,
  253.                &stream, &status);
  254.     apollo_check("create_window");
  255.  
  256.     /* if this is not the user's name, then delete the file */
  257.     if (unlink_wname)
  258.         unlink(wname);
  259.  
  260.     /* remove all scaling, to revert to pixel units, not char. units */
  261.     pad_$set_scale(stream, 1, 1, &status);
  262.     apollo_check("set_scale");
  263.  
  264.     /* get rid of the window when the program exits */
  265.     pad_$set_auto_close(stream, 1, true, &status);
  266.     apollo_check("set_auto_close");
  267.  
  268.     /* now determine the window size & update the termentry table */
  269.     pad_$inq_windows(stream, &window, 1, &wnum, &status);
  270.     apollo_check("inq_windows");
  271.  
  272.     /* the order of the next three calls is important */
  273.     apollo_font_info(tbl, font_name);
  274.     apollo_gpr_init(tbl, &window);
  275.     apollo_tic_sizes(tbl);
  276.     }
  277. }
  278.  
  279. /*
  280.     Prepare for graphics output.  Since this is what the user wants to
  281.     do when preparing a new plot, this is a meaningful time to see if
  282.     the window has changed size.  Thus, we avoid mucking about with
  283.     asynchronous traps, and we avoid the bigger problem of dealing
  284.     with a half-finished plot when the window changes size.
  285.  
  286.     Simply put, get the current window size, and if it has changed,
  287.     then get rid of the old bitmaps, etc., and allocate new ones at
  288.     the new size.  We also need to update the termentry table.
  289.     If the window stays the same size, then just clear it.
  290. */
  291. static void apollo_redo_window(pad_$window_desc_t* window)
  292. {
  293.     struct termentry* tbl = &term_tbl[term];
  294.     status_$t status;
  295.  
  296.     /* the order of the following calls is important */
  297.     apollo_gpr_terminate();
  298.     apollo_gpr_init(tbl, window);
  299.     apollo_tic_sizes(tbl);
  300. }
  301.  
  302. APOLLO_graphics()
  303. {
  304.     pad_$window_desc_t window;
  305.     short wnum;
  306.     status_$t status;
  307.  
  308.     pad_$inq_windows(stream, &window, 1, &wnum, &status);
  309.     apollo_check("inq_windows");
  310.  
  311.     if (window.width != APOLLO_XMAX || window.height != APOLLO_YMAX)
  312.     apollo_redo_window(&window);
  313.     else
  314.     {
  315.     gpr_$clear(0, &status);
  316.     apollo_check("clear");
  317.     }
  318. }
  319.  
  320. /* set a line type:
  321.    -2 heavy, solid    (border)
  322.    -1 heavy, dotted    (axis)
  323.    0  solid        (normal)
  324.    1  dots        (other curves)
  325.    2  short dash
  326.    3  long dash
  327.    4  dash dot
  328.  
  329.    Apparently, GPUplot draws a lot of short line segments, and each
  330.    one starts a new pattern.  This makes the patterns somewhat useless,
  331.    but one can still tell the difference between solid, dotted, and
  332.    dashed lines.  The utility of fancier styles is limited, however.
  333.  
  334.    On a color workstation, we should use different colors, but I
  335.    don't have one.
  336. */
  337.  
  338. /*
  339.     To draw different line styles on an Apollo, we use two different
  340.     parameters.  One is a line thickness, which is just an integral
  341.     multiple of the default line thickness.  The second is a 16-bit
  342.     pattern that is repeated.  We could use fancier patterns, since
  343.     GPR supports up to 64-bits, but, as I explained earlier, this
  344.     really does not buy us anything.
  345.  
  346.     I used patterns that do not start with all bits on because
  347.     GNUplot seems to use lots of short line segments to draw
  348.     a curve, and this might make a very curvey plot seem like
  349.     a solid line, regardless of pattern.  I don't want to start
  350.     with too many zeros, however, or else the curve might not
  351.     appear at all!  All the patterns, therefore, start with one
  352.     bit on.  The rest of the bits determine the true pattern.
  353.  
  354.     By examining graphics.c, we see that linetype -2 is used exclusively
  355.     for the border, -1 for the axes, and the non-negative integers for
  356.     the curves.  We use heavy lines for the border and axes, and normal
  357.     width lines for the curves.
  358.  
  359.     Since C arrays start at zero, make sure all the offsets are correct,
  360.     so that it is easy to access the array with -2...n linetypes.
  361. */
  362.  
  363. typedef struct {
  364.     short width;
  365.     short pattern;
  366. } APOLLO_LINE;
  367.  
  368. static APOLLO_LINE apollo_lines[] = {
  369.     { 2, ~0 },        /* heavy, solid */
  370.     { 2, 0x6666 },    /* heavy, dotted */
  371.     { 1, ~0 },        /* normal */
  372.     { 1, 0xAAAA },    /* dotted */
  373.     { 1, 0xC3C3 },    /* short dash */
  374.     { 1, 0xE01F },    /* long dash */
  375.     { 1, 0x87F8 },    /* dash dot */
  376.     { 1, 0x6666 },    /* big dots */
  377. };
  378.  
  379. #define BITS_PER_LINETYPE    16
  380.  
  381. /* apollo_line(-2) is the border style, etc. */
  382. #define apollo_line(x)        apollo_lines[(x)+2]
  383. #define apollo_pattern(x)    &apollo_line(x).pattern
  384. #define apollo_width(x)        apollo_line(x).width
  385.  
  386. #define APOLLO_MIN_LINE        (-2)
  387. #define APOLLO_MAX_LINE        (sizeof(apollo_lines)/sizeof(*apollo_lines)-2)
  388.  
  389. /* set the line style */
  390. APOLLO_linetype(ltype)
  391. int ltype;
  392. {
  393.     status_$t status;
  394.  
  395.     if (ltype < APOLLO_MIN_LINE)
  396.     ltype = APOLLO_MIN_LINE;
  397.     if (ltype >= APOLLO_MAX_LINE)
  398.     ltype %= APOLLO_MAX_LINE;
  399.  
  400.     gpr_$set_line_pattern(1, apollo_pattern(ltype), BITS_PER_LINETYPE, &status);
  401.     apollo_check("set_line_pattern");
  402.  
  403.     gpr_$set_draw_width(draw_width * apollo_width(ltype), &status);
  404.     apollo_check("set_draw_width");
  405. }
  406.  
  407. /* issue an error message that includes an (x, y) coordinate */
  408. static void apollo_xy_error(char* s, int x, int y, status_$t status)
  409. {
  410.     char buffer[128];
  411.  
  412.     sprintf(buffer, "%s(%d, %d)", s, x, y);
  413.     apollo_error(buffer);
  414. }
  415.  
  416. #define apollo_xy_check(s)    \
  417.     if (status.all != status_$ok) apollo_xy_error((s), x, y, status)
  418.  
  419. /*
  420.     Note that GNUplot and GPR have reversed ideas of where the Y origin is.
  421.     This means subtracting the Y coordinate from Y max.
  422. */
  423. #define plot_to_gpr(y)        (APOLLO_YMAX - (y))
  424.  
  425. /* move to a new position */
  426. APOLLO_move(unsigned int x, unsigned int y)
  427. {
  428.     status_$t status;
  429.  
  430.     gpr_$move((gpr_$coordinate_t) x, plot_to_gpr(y), &status);
  431.     apollo_xy_check("move");
  432. }
  433.  
  434. /* draw a line to a new position */
  435. APOLLO_vector(unsigned int x, unsigned int y)
  436. {
  437.     status_$t status;
  438.  
  439.     gpr_$line((gpr_$coordinate_t) x, plot_to_gpr(y), &status);
  440.     apollo_xy_check("line");
  441. }
  442.  
  443. /*
  444.     On terminals, this switches to text mode.  The real meaning,
  445.     however, is that the graphics are finished.  This means we can
  446.     now display the saved bitmap.
  447. */
  448. APOLLO_text()
  449. {
  450.     if (use_bitmap)
  451.     {
  452.     static gpr_$position_t pos;        /* always zero */
  453.     gpr_$window_t window;
  454.     status_$t status;
  455.  
  456.     /* bitblt the entire bitmap to the entire window */
  457.     window.window_base.x_coord = 0;
  458.     window.window_base.y_coord = 0;
  459.     window.window_size.x_size = APOLLO_XMAX;
  460.     window.window_size.y_size = APOLLO_YMAX;
  461.  
  462.     gpr_$set_bitmap(screen_desc, &status);
  463.     apollo_check("set_bitmap(screen_desc)");
  464.  
  465.     gpr_$pixel_blt(bitmap_desc, window, pos, &status);
  466.     apollo_check("bitblt");
  467.  
  468.     gpr_$set_bitmap(bitmap_desc, &status);
  469.     apollo_check("set_bitmap(bitmap_desc)");
  470.     }
  471. }
  472.  
  473. APOLLO_text_angle(ang)
  474. int ang;
  475. {
  476.     status_$t status;
  477.  
  478.     gpr_$set_text_path(ang ? gpr_$up : gpr_$right, &status);
  479.     apollo_check("set_text_path");
  480.     return TRUE;
  481. }
  482.  
  483. static enum JUSTIFY apollo_text_mode;
  484.  
  485. APOLLO_justify_text(mode)
  486. enum JUSTIFY mode;
  487. {
  488.     apollo_text_mode = mode;
  489.     return TRUE;
  490. }
  491.  
  492. /*
  493.     Write "str" right justified on row "row".  A row is assumed to
  494.     have whatever height the current text has.  Make sure the
  495.     text does not cover the tick marks.
  496. */
  497. APOLLO_put_text(x, y, str)
  498. unsigned int x, y;
  499. char str[];
  500. {
  501.     gpr_$offset_t size;
  502.     status_$t status;
  503.  
  504.     gpr_$inq_text_extent(str, strlen(str), &size, &status);
  505.     apollo_check("inq_text_extent");
  506.  
  507.     y -= size.y_size / 2;    /* center around "y" */
  508.     switch (apollo_text_mode)
  509.     {
  510.     case LEFT:
  511.     break;
  512.     case CENTRE:
  513.     x -= size.x_size / 2;
  514.     break;
  515.     case RIGHT:
  516.     x -= size.x_size;
  517.     break;
  518.     }
  519.     APOLLO_move(x, y);
  520.  
  521.     gpr_$text(str, strlen(str), &status);
  522.     apollo_check("put_text");
  523. }
  524.  
  525. /* reset the graphics state and terminate */
  526. APOLLO_reset()
  527. {
  528.     if (stream != -1)
  529.     {
  530.     apollo_gpr_terminate();
  531.     stream = -1;
  532.     }
  533. }
  534.