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