Annotation of OpenXM_contrib/gnuplot/term/gpr.trm, Revision 1.1.1.2
1.1 maekawa 1: /*
1.1.1.2 ! maekawa 2: * $Id: gpr.trm,v 1.6 1998/12/14 18:39:32 lhecking Exp $
1.1 maekawa 3: *
4: */
5:
6: /* GNUPLOT - gpr.trm */
7:
8: /*[
9: * Copyright 1990 - 1993, 1998
10: *
11: * Permission to use, copy, and distribute this software and its
12: * documentation for any purpose with or without fee is hereby granted,
13: * provided that the above copyright notice appear in all copies and
14: * that both that copyright notice and this permission notice appear
15: * in supporting documentation.
16: *
17: * Permission to modify the software is granted, but not the right to
18: * distribute the complete modified source code. Modifications are to
19: * be distributed as patches to the released version. Permission to
20: * distribute binaries produced by compiling modified sources is granted,
21: * provided you
22: * 1. distribute the corresponding source modifications from the
23: * released version in the form of a patch file along with the binaries,
24: * 2. add special version identification to distinguish your version
25: * in addition to the base release version number,
26: * 3. provide your name and address as the primary contact for the
27: * support of your modified version, and
28: * 4. retain our contact information in regard to use of the base
29: * software.
30: * Permission to distribute the released version of the source code along
31: * with corresponding source modifications in the form of a patch file is
32: * granted with same provisions 2 through 4 for binary distributions.
33: *
34: * This software is provided "as is" without express or implied warranty
35: * to the extent permitted by applicable law.
36: ]*/
37:
38: /*
39: * This file is included by ../term.c.
40: *
41: * This terminal driver supports:
42: * APOLLO's GPR windowing system
43: *
44: * AUTHORS
45: * Michael Aramini
46: * Roque D Oliveira , oliveria@caen.engin.umich.edu
47: *
48: * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
49: *
50: */
51:
52: /*
53: * adapted to the new terminal layout by Stefan Bodewig (Dec. 1995)
54: */
55:
56: #include "driver.h"
57:
58: #ifdef TERM_REGISTER
59: register_term(gpr)
60: #endif
61:
62: #ifdef TERM_PROTO
63: TERM_PUBLIC void GPR_init __PROTO((void));
64: TERM_PUBLIC void GPR_graphics __PROTO((void));
65: TERM_PUBLIC void GPR_text __PROTO((void));
66: TERM_PUBLIC void GPR_linetype __PROTO((int linetype));
67: TERM_PUBLIC void GPR_move __PROTO((unsigned int x, unsigned int y));
68: TERM_PUBLIC void GPR_vector __PROTO((unsigned int x, unsigned int y));
69: TERM_PUBLIC void GPR_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
70: TERM_PUBLIC int GPR_text_angle __PROTO((int ang));
71: TERM_PUBLIC int GPR_justify_text __PROTO((enum JUSTIFY mode));
72: TERM_PUBLIC void GPR_reset __PROTO((void));
73: /* landscape window */
74: /*
75: #define GPR_XMAX 720
76: #define GPR_YMAX 450
77: */
78: /* portrait window */
79: #define GPR_XMAX 585
80: #define GPR_YMAX 735
81: #define GPR_VCHAR 19
82: #define GPR_HCHAR 10
83: #define GPR_VTIC (GPR_YMAX/80)
84: #define GPR_HTIC (GPR_XMAX/80)
85: #endif /* TERM_PROTO */
86:
87: #ifndef TERM_PROTO_ONLY
88: #ifdef TERM_BODY
89: void GPRold_linetype __PROTO((int linetype));
90: static void check __PROTO((char *messagex));
91: int gpr_isa_pad __PROTO((void));
92: #include <apollo/base.h>
93: #include <apollo/error.h>
94: #include <apollo/gpr.h>
95: #include <apollo/pad.h>
96:
97: #define GPR_XLAST (GPR_XMAX - 1)
98: #define GPR_YLAST (GPR_YMAX - 1)
99:
100:
101: gpr_$direction_t gpr_path = gpr_$right;
102: /* text angle, 0=horizontal, 1=vertical */
103: int gpr_ang = 0;
104: /* text is flush left */
105: enum JUSTIFY gpr_justify = LEFT;
106:
107: static status_$t status;
108: /* set it to 1 when debugging program */
109: unsigned int Debug = 0;
110:
111:
112: static void check(messagex)
113: char *messagex;
114: {
115: if (status.all = status_$ok) {
116: error_$print(status);
117: printf("Error occurred while %s.\n", messagex);
118: }
119: }
120:
121: /* return whether stdout is a DM pad . Called by term.c */
122: int gpr_isa_pad()
123: {
124: pad_$isa(1, &status);
125: return (status.all == status_$ok);
126: }
127:
128:
129: TERM_PUBLIC void GPR_init()
130: {
131: gpr_$offset_t dm_bitmap_size;
132: gpr_$bitmap_desc_t dm_bitmap_desc;
133: pad_$window_desc_t window;
134: short font_id;
135: stream_$id_t stream_id;
136: static gpr_$rgb_plane_t hi_plane;
137: static gpr_$disp_char_t display_characteristics;
138: static float screen_size_r_width, screen_size_r_height;
139: static short int disp_len = sizeof(gpr_$disp_char_t);
140: static short int disp_len_returned;
141:
142:
143: /* open a pad to do graphics in */
144: window.top = 0;
145: window.left = 0;
146: /* 10 accounts for width of window border */
147: window.width = GPR_XMAX + 10;
148: /* 35 accounts for height of window border */
149: window.height = GPR_YMAX + 35;
150: pad_$create_window("", (short) 0, pad_$transcript, (short) 1, window, &stream_id, &status);
151: check("pad_$create_window");
152:
153: /* pad_$set_full_window(stream_id,(short) 1,&window, &status); */
154: /* pad_$set_border (stream_id,(short) 1, true, &status); */
155: pad_$set_scale(stream_id, (short) 1, (short) 1, &status);
156: pad_$set_auto_close(stream_id, (short) 1, true, &status);
157:
158: gpr_$inq_disp_characteristics(gpr_$direct, stream_id, disp_len, &display_characteristics, &disp_len_returned, &status);
159: check("in gpr_$inq_display_characteristics");
160: /*x_window_size in pixels */
161: screen_size_r_width = (float) display_characteristics.x_window_size;
162: /*y_window_size in pixels */
163: screen_size_r_height = (float) display_characteristics.y_window_size;
164: hi_plane = display_characteristics.n_planes - 1;
165: if (Debug)
166: printf("width=%f height=%f \n", screen_size_r_width, screen_size_r_height);
167:
168: dm_bitmap_size.x_size = 1280;
169: dm_bitmap_size.y_size = 1024;
170: gpr_$init(gpr_$direct, stream_id, dm_bitmap_size, hi_plane, &dm_bitmap_desc, &status);
171: check("in gpr_$init");
172: /*
173: gpr_$set_obscured_opt(gpr_$pop_if_obs, &status);
174: check("in gpr_$set_obscured_opt");
175: */
176: gpr_$set_auto_refresh(true, &status);
177: check("in gpr_$set_auto_refresh");
178:
179: /* load a font and make it current */
180: gpr_$load_font_file("f7x13", 5, &font_id, &status);
181: check("in gpr_$load_font_file");
182: gpr_$set_text_font(font_id, &status);
183: check("in gpr_$set_text_font");
184:
185: /* set up color values */
186: gpr_$set_draw_value((gpr_$pixel_value_t) 7, &status); /* white */
187: check("in gpr_set_draw_value");
188: gpr_$set_text_background_value((gpr_$pixel_value_t) (-1), &status); /* trans */
189: check("in gpr_$set_text_background_value");
190: gpr_$set_text_value((gpr_$pixel_value_t) 7, &status); /* white */
191: check("in gpr_$set_text_value");
192: }
193:
194:
195: TERM_PUBLIC void GPR_graphics()
196: {
197: gpr_$coordinate_t locx, locy, marker_size;
198:
199: (void) gpr_$acquire_display(&status);
200: check("in gpr_$acquire display");
201: gpr_$clear((gpr_$pixel_value_t) 0, &status); /* black */
202: check("in gpr_$clear");
203:
204: if (Debug) {
205: marker_size = (short) 10;
206:
207: locx = (short) 5;
208: locy = (short) 5;
209: gpr_$set_draw_value((gpr_$pixel_value_t) 2, &status); /* white */
210: gpr_$move((locx - marker_size / 2), locy, &status);
211: gpr_$line((locx + marker_size / 2), locy, &status);
212: gpr_$move(locx, (locy + marker_size / 2), &status);
213: gpr_$line(locx, (locy - marker_size / 2), &status);
214:
215: locx = (short) (GPR_XMAX - 1 - 5);
216: locy = (short) 5;
217: gpr_$set_draw_value((gpr_$pixel_value_t) 3, &status); /* white */
218: gpr_$move((locx - marker_size / 2), locy, &status);
219: gpr_$line((locx + marker_size / 2), locy, &status);
220: gpr_$move(locx, (locy + marker_size / 2), &status);
221: gpr_$line(locx, (locy - marker_size / 2), &status);
222:
223: locx = (short) 5;
224: locy = (short) (GPR_YMAX - 1 - 5);
225: gpr_$set_draw_value((gpr_$pixel_value_t) 4, &status); /* white */
226: gpr_$move((locx - marker_size / 2), locy, &status);
227: gpr_$line((locx + marker_size / 2), locy, &status);
228: gpr_$move(locx, (locy + marker_size / 2), &status);
229: gpr_$line(locx, (locy - marker_size / 2), &status);
230:
231: locx = (short) (GPR_XMAX - 1 - 5);
232: locy = (short) (GPR_YMAX - 1 - 5);
233: gpr_$set_draw_value((gpr_$pixel_value_t) 5, &status); /* white */
234: gpr_$move((locx - marker_size / 2), locy, &status);
235: gpr_$line((locx + marker_size / 2), locy, &status);
236: gpr_$move(locx, (locy + marker_size / 2), &status);
237: gpr_$line(locx, (locy - marker_size / 2), &status);
238:
239: gpr_$set_draw_value((gpr_$pixel_value_t) 7, &status); /* white */
240: check("in gpr_$set_draw_value");
241: } /* end if(Debug) */
242: }
243:
244:
245: TERM_PUBLIC void GPR_text()
246: {
247: gpr_$release_display(&status);
248: check("gpr_$release_display");
249: }
250:
251:
252: void GPRold_linetype(linetype)
253: int linetype;
254: {
255: static gpr_$line_pattern_t patterns[2 + 5] =
256: {
257: {0xFFFF}, /* solid 1111111111111111 */
258: {0x3FFF}, /* very long dashed 0011111111111111 */
259: {0xFFFF}, /* solid 1111111111111111 */
260: {0x5555}, /* dotted 0101010101010101 */
261: {0x3333}, /* short dashed 0011001100110011 */
262: {0xB5AD}, /* dot short-dashed 1011010110101101 */
263: {0x3FFF} /* very long dashed 0011111111111111 */
264: };
265: if (linetype >= 5)
266: linetype %= 5;
267: gpr_$set_line_pattern((short) 1, patterns[linetype + 2], (short) 16, &status);
268: check("in gpr_$set_line_pattern");
269: }
270:
271: TERM_PUBLIC void GPR_linetype(linetype)
272: int linetype;
273: {
274: static gpr_$line_pattern_t patterns[2 + 7] =
275: {
276: {0xFFFF}, /* solid 1111111111111111 */
277: {0x1111}, /* long-spaced dotted 0001000100010001 */
278: {0xFFFF}, /* solid 1111111111111111 */
279: {0x5555}, /* dotted 0101010101010101 */
280: {0x3333}, /* short dashed 0011001100110011 */
281: {0x7777}, /* medium dashed 0111011101110111 */
282: {0x3F3F}, /* long dashed 0011111100111111 */
283: {0x0F0F}, /* long-spaced dashed 0000111100001111 */
284: {0x5F5F} /* dot dashed 0101111101011111 */
285: };
286: if (linetype >= 7)
287: linetype %= 7;
288: gpr_$set_line_pattern((short) 1, patterns[linetype + 2], (short) 16, &status);
289: check("in gpr_$set_line_pattern");
290:
291: /*
292: gpr_$set_draw_value((gpr_$pixel_value_t)(linetype + 1), &status);
293: check("in gpr_$set_draw_value");
294: */
295: }
296:
297:
298: TERM_PUBLIC void GPR_move(x, y)
299: unsigned int x, y;
300: {
301: gpr_$move((short) x, (short) (GPR_YMAX - 1 - y), &status);
302: check("in gpr_$move");
303: }
304:
305:
306: TERM_PUBLIC void GPR_vector(x, y)
307: unsigned int x, y;
308: {
309: gpr_$line((short) x, (short) (GPR_YMAX - 1 - y), &status);
310: check("in gpr_$line");
311: }
312:
313:
314: TERM_PUBLIC void GPR_put_text(x, y, str)
315: unsigned int x, y; /* reference point of string */
316: char str[]; /* the text */
317: {
318: gpr_$coordinate_t xgpr, ygpr;
319: gpr_$offset_t str_size_in_pixels;
320: short int str_len;
321:
322: gpr_$coordinate_t locx, locy, marker_size;
323:
324: if (Debug) {
325: locx = (short) x;
326: locy = (short) (GPR_YMAX - 1 - y);
327: marker_size = (short) 20;
328: gpr_$set_draw_value((gpr_$pixel_value_t) 1, &status); /* white */
329: gpr_$move((locx - marker_size / 2), locy, &status);
330: gpr_$line((locx + marker_size / 2), locy, &status);
331: gpr_$move(locx, (locy + marker_size / 2), &status);
332: gpr_$line(locx, (locy - marker_size / 2), &status);
333: gpr_$set_draw_value((gpr_$pixel_value_t) 7, &status); /* white */
334: }
335: xgpr = (short) x;
336: ygpr = (short) (GPR_YMAX - 1 - y);
337: gpr_$set_text_path(gpr_path, &status);
338: check("gpr_$set_text_path");
339:
340: str_len = (short) strlen(str);
341: /* Calculate how much space (in pixels) the string requires */
342: gpr_$inq_text_extent(str, str_len, &str_size_in_pixels, &status);
343: check("in gpr_$inq_text_extent");
344:
345: switch (gpr_justify) {
346: case LEFT:
347: {
348: switch (gpr_path) {
349: case gpr_$up: /* vertical */
350: {
351: if (Debug)
352: printf("LEFT and up , str=%s\n", str);
353: break;
354: }
355: case gpr_$right: /* horizontal */
356: {
357: ygpr = ygpr + str_size_in_pixels.y_size / 2;
358: if (Debug)
359: printf("LEFT and right, str=%s \n", str);
360: break;
361: }
362: }
363: break;
364: }
365:
366: case CENTRE:
367: {
368: switch (gpr_path) {
369: case gpr_$up: /* vertical */
370: {
371: xgpr = xgpr + str_size_in_pixels.x_size / 2;
372: ygpr = ygpr + str_size_in_pixels.y_size / 2;
373: if (Debug)
374: printf("CENTRE and up, str=%s \n", str);
375: break;
376: }
377: case gpr_$right: /* horizontal */
378: {
379: xgpr = xgpr - str_size_in_pixels.x_size / 2;
380: ygpr = ygpr + str_size_in_pixels.y_size / 2;
381: if (Debug)
382: printf("CENTRE and right, str=%s \n", str);
383: break;
384: }
385: }
386: break;
387: }
388: case RIGHT:
389: {
390: switch (gpr_path) {
391: case gpr_$up: /* vertical */
392: {
393: ygpr = ygpr + str_size_in_pixels.y_size;
394: if (Debug)
395: printf("RIGHT and up, str=%s \n", str);
396: break;
397: }
398: case gpr_$right: /* horizontal */
399: {
400: xgpr = xgpr - str_size_in_pixels.x_size;
401: ygpr = ygpr + str_size_in_pixels.y_size / 2;
402: if (Debug)
403: printf("RIGHT and right, str=%s \n", str);
404: break;
405: }
406: }
407: break;
408: }
409: }
410:
411: gpr_$move(xgpr, ygpr, &status);
412: check("in gpr_$move");
413: gpr_$text(str, str_len, &status);
414: check("in gpr_$text");
415: }
416:
417: TERM_PUBLIC int GPR_text_angle(ang)
418: int ang;
419: {
420: if (gpr_ang != ang) {
421: gpr_ang = ang;
422: gpr_path = (gpr_ang == 1 ? gpr_$up : gpr_$right);
423: }
424: return (TRUE);
425: }
426:
427: TERM_PUBLIC int GPR_justify_text(mode)
428: enum JUSTIFY mode;
429: {
430: gpr_justify = mode;
431: return (TRUE);
432: }
433:
434: TERM_PUBLIC void GPR_reset()
435: {
436: gpr_$terminate(false, &status);
437: check("in gpr_$terminate");
438: }
439:
440: #endif /* TERM_BODY */
441:
442: #ifdef TERM_TABLE
443:
444: TERM_TABLE_START(gpr_driver)
445: "gpr", "Apollo Graphics Primitive Resource, fixed-size window",
446: GPR_XMAX, GPR_YMAX, GPR_VCHAR, GPR_HCHAR,
447: GPR_VTIC, GPR_HTIC, options_null, GPR_init, GPR_reset,
448: GPR_text, null_scale, GPR_graphics, GPR_move, GPR_vector,
449: GPR_linetype, GPR_put_text, GPR_text_angle,
450: GPR_justify_text, line_and_point, do_arrow, set_font_null
451: TERM_TABLE_END(gpr_driver)
452:
453: #undef LAST_TERM
454: #define LAST_TERM gpr_driver
455:
456: #endif /* TERM_TABLE */
457: #endif /* TERM_PROTO_ONLY */
458:
459: #ifdef TERM_HELP
460: START_HELP(gpr)
461: "1 gpr",
462: "?commands set terminal gpr",
463: "?set terminal gpr",
464: "?set term gpr",
465: "?terminal gpr",
466: "?term gpr",
467: "?gpr",
468: " The `gpr` terminal driver supports the Apollo Graphics Primitive Resource",
469: " for a fixed-size window. It has no options.",
470: "",
471: " If a variable window size is desired, use the `apollo` terminal instead."
472: END_HELP(gpr)
473: #endif /* TERM_HELP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gpr.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term