Annotation of OpenXM_contrib/gnuplot/term.c, Revision 1.1.1.1
1.1 maekawa 1: #ifndef lint
2: static char *RCSid = "$Id: term.c,v 1.104 1998/06/18 14:55:19 ddenholm Exp $";
3: #endif
4:
5: /* GNUPLOT - term.c */
6:
7: /*[
8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
9: *
10: * Permission to use, copy, and distribute this software and its
11: * documentation for any purpose with or without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and
13: * that both that copyright notice and this permission notice appear
14: * in supporting documentation.
15: *
16: * Permission to modify the software is granted, but not the right to
17: * distribute the complete modified source code. Modifications are to
18: * be distributed as patches to the released version. Permission to
19: * distribute binaries produced by compiling modified sources is granted,
20: * provided you
21: * 1. distribute the corresponding source modifications from the
22: * released version in the form of a patch file along with the binaries,
23: * 2. add special version identification to distinguish your version
24: * in addition to the base release version number,
25: * 3. provide your name and address as the primary contact for the
26: * support of your modified version, and
27: * 4. retain our contact information in regard to use of the base
28: * software.
29: * Permission to distribute the released version of the source code along
30: * with corresponding source modifications in the form of a patch file is
31: * granted with same provisions 2 through 4 for binary distributions.
32: *
33: * This software is provided "as is" without express or implied warranty
34: * to the extent permitted by applicable law.
35: ]*/
36:
37:
38: /* This module is responsible for looking after the terminal
39: * drivers at the lowest level. Only this module (should)
40: * know about all the various rules about interpreting
41: * the terminal capabilities exported by the terminal
42: * drivers in the table.
43: *
44: * Note that, as far as this module is concerned, a
45: * terminal session lasts only until _either_ terminal
46: * or output file changes. Before either is changed,
47: * the terminal is shut down.
48: *
49: * Entry points : (see also term/README)
50: *
51: * term_set_output() : called when set output invoked
52: *
53: * term_init() : optional. Prepare the terminal for first
54: * use. It protects itself against subsequent calls.
55: *
56: * term_start_plot() : called at start of graph output. Calls term_init
57: * if necessary
58: *
59: * term_apply_lp_properties() : apply linewidth settings
60: *
61: * term_end_plot() : called at the end of a plot
62: *
63: * term_reset() : called during int_error handling, to shut
64: * terminal down cleanly
65: *
66: * term_start_multiplot() : called by set multiplot
67: *
68: * term_end_multiplot() : called by set nomultiplot
69: *
70: * term_check_multiplot_okay() : called just before an interactive
71: * prompt is issued while in multiplot mode,
72: * to allow terminal to suspend if necessary,
73: * Raises an error if interactive multiplot
74: * is not supported.
75: */
76:
77: #include "plot.h"
78: #include "bitmap.h"
79: #include "setshow.h"
80: #include "driver.h"
81:
82: #ifdef _Windows
83: FILE *open_printer __PROTO((void)); /* in wprinter.c */
84: void close_printer __PROTO((FILE * outfile));
85: # ifdef __MSC__
86: # include <malloc.h>
87: # else
88: # include <alloc.h>
89: # endif /* MSC */
90: #endif /* _Windows */
91:
92:
93: /* true if terminal has been initialized */
94: static TBOOLEAN term_initialised;
95:
96: /* true if terminal is in graphics mode */
97: static TBOOLEAN term_graphics = FALSE;
98:
99: /* we have suspended the driver, in multiplot mode */
100: static TBOOLEAN term_suspended = FALSE;
101:
102: /* true if? */
103: static TBOOLEAN opened_binary = FALSE;
104:
105: /* true if require terminal to be initialized */
106: static TBOOLEAN term_force_init = FALSE;
107:
108: extern FILE *gpoutfile;
109: extern char *outstr;
110: extern float xsize, ysize;
111:
112: /* internal pointsize for do_point */
113: static double term_pointsize;
114:
115: static void term_suspend __PROTO((void));
116: static void term_close_output __PROTO((void));
117: static void null_linewidth __PROTO((double));
118:
119: void do_point __PROTO((unsigned int x, unsigned int y, int number));
120: void do_pointsize __PROTO((double size));
121: void line_and_point __PROTO((unsigned int x, unsigned int y, int number));
122: void do_arrow __PROTO((unsigned int sx, unsigned int sy, unsigned int ex, unsigned int ey, int head));
123:
124:
125: #ifdef __ZTC__
126: char *ztc_init();
127: /* #undef TGIF */
128: #endif
129:
130: #ifdef VMS
131: char *vms_init();
132: void vms_reset();
133: void term_mode_tek();
134: void term_mode_native();
135: void term_pasthru();
136: void term_nopasthru();
137: void fflush_binary();
138: # define FOPEN_BINARY(file) fopen(file, "wb", "rfm=fix", "bls=512", "mrs=512")
139: #else /* !VMS */
140: # define FOPEN_BINARY(file) fopen(file, "wb")
141: #endif /* !VMS */
142:
143:
144: /* This is needed because the unixplot library only writes to stdout. */
145: #if defined(UNIXPLOT) || defined(GNUGRAPH)
146: static FILE save_stdout;
147: #endif
148: static int unixplot = 0;
149:
150: #if defined(MTOS) || defined(ATARI)
151: int aesid = -1;
152: #endif
153:
154: #define NICE_LINE 0
155: #define POINT_TYPES 6
156:
157: #ifndef DEFAULTTERM
158: # define DEFAULTTERM NULL
159: #endif
160:
161: /* interface to the rest of gnuplot - the rules are getting
162: * too complex for the rest of gnuplot to be allowed in
163: */
164:
165: #if defined(PIPES)
166: static TBOOLEAN pipe_open = FALSE;
167: #endif /* PIPES */
168:
169: static void term_close_output()
170: {
171: FPRINTF((stderr, "term_close_output\n"));
172:
173: opened_binary = FALSE;
174:
175: if (!outstr) /* ie using stdout */
176: return;
177:
178: #if defined(PIPES)
179: if (pipe_open) {
180: (void) pclose(gpoutfile);
181: pipe_open = FALSE;
182: } else
183: #endif /* PIPES */
184: #ifdef _Windows
185: if (stricmp(outstr, "PRN") == 0)
186: close_printer(gpoutfile);
187: else
188: #endif
189: (void) fclose(gpoutfile);
190:
191: gpoutfile = stdout; /* Don't dup... */
192: free(outstr);
193: outstr = NULL;
194: }
195:
196: #ifdef OS2
197: # define POPEN_MODE ("wb")
198: #else
199: # define POPEN_MODE ("w")
200: #endif
201:
202: /* assigns dest to outstr, so it must be allocated or NULL
203: * and it must not be outstr itself !
204: */
205: void term_set_output(dest)
206: char *dest;
207: {
208: FILE *f;
209:
210: FPRINTF((stderr, "term_set_output\n"));
211: assert(dest == NULL || dest != outstr);
212:
213: if (multiplot) {
214: fputs("In multiplotmode you can't change the output\n", stderr);
215: return;
216: }
217: if (term && term_initialised) {
218: (*term->reset) ();
219: term_initialised = FALSE;
220: }
221: if (dest == NULL) { /* stdout */
222: UP_redirect(4);
223: term_close_output();
224: } else {
225:
226: #if defined(PIPES)
227: if (*dest == '|') {
228: if ((f = popen(dest + 1, POPEN_MODE)) == (FILE *) NULL)
229: os_error("cannot create pipe; output not changed", c_token);
230: else
231: pipe_open = TRUE;
232: } else
233: #endif /* PIPES */
234:
235: #ifdef _Windows
236: if (outstr && stricmp(outstr, "PRN") == 0) {
237: /* we can't call open_printer() while printer is open, so */
238: close_printer(gpoutfile); /* close printer immediately if open */
239: gpoutfile = stdout; /* and reset output to stdout */
240: free(outstr);
241: outstr = NULL;
242: }
243: if (stricmp(dest, "PRN") == 0) {
244: if ((f = open_printer()) == (FILE *) NULL)
245: os_error("cannot open printer temporary file; output may have changed", c_token);
246: } else
247: #endif
248:
249: {
250: if (term && (term->flags & TERM_BINARY)) {
251: f = FOPEN_BINARY(dest);
252: } else
253: f = fopen(dest, "w");
254:
255: if (f == (FILE *) NULL)
256: os_error("cannot open file; output not changed", c_token);
257: }
258: term_close_output();
259: gpoutfile = f;
260: outstr = dest;
261: opened_binary = (term && (term->flags & TERM_BINARY));
262: UP_redirect(1);
263: }
264: }
265:
266: void term_init()
267: {
268: FPRINTF((stderr, "term_init()\n"));
269:
270: if (!term)
271: int_error("No terminal defined", NO_CARET);
272:
273: /* check if we have opened the output file in the wrong mode
274: * (text/binary), if set term comes after set output
275: * This was originally done in change_term, but that
276: * resulted in output files being truncated
277: */
278:
279: if (outstr &&
280: (((term->flags & TERM_BINARY) && !opened_binary) ||
281: ((!(term->flags & TERM_BINARY) && opened_binary)))) {
282: /* this is nasty - we cannot just term_set_output(outstr)
283: * since term_set_output will first free outstr and we
284: * end up with an invalid pointer. I think I would
285: * prefer to defer opening output file until first plot.
286: */
287: char *temp = gp_alloc(strlen(outstr) + 1, "temp file string");
288: if (temp) {
289: FPRINTF((stderr, "term_init : reopening \"%s\" as %s\n",
290: outstr, term->flags & TERM_BINARY ? "binary" : "text"));
291: strcpy(temp, outstr);
292: term_set_output(temp); /* will free outstr */
293: } else
294: fputs("Cannot reopen output file in binary", stderr);
295: /* and carry on, hoping for the best ! */
296: }
297: #ifdef OS2
298: else if (!outstr && !interactive && (term->flags & TERM_BINARY)) {
299: /* binary (eg gif) to stdout in a non-interactive session */
300: fflush(stdout); // _fsetmode requires an empty buffer
301:
302: _fsetmode(stdout, "b");
303: }
304: #endif
305:
306:
307: if (!term_initialised || term_force_init) {
308: FPRINTF((stderr, "- calling term->init()\n"));
309: (*term->init) ();
310: term_initialised = TRUE;
311: }
312: }
313:
314:
315: void term_start_plot()
316: {
317: FPRINTF((stderr, "term_start_plot()\n"));
318:
319: if (!term_initialised)
320: term_init();
321:
322: if (!term_graphics) {
323: FPRINTF((stderr, "- calling term->graphics()\n"));
324: (*term->graphics) ();
325: term_graphics = TRUE;
326: } else if (multiplot && term_suspended) {
327: if (term->resume) {
328: FPRINTF((stderr, "- calling term->resume()\n"));
329: (*term->resume) ();
330: }
331: term_suspended = FALSE;
332: }
333: }
334:
335: void term_end_plot()
336: {
337: FPRINTF((stderr, "term_end_plot()\n"));
338:
339: if (!term_initialised)
340: return;
341:
342: if (!multiplot) {
343: FPRINTF((stderr, "- calling term->text()\n"));
344: (*term->text) ();
345: term_graphics = FALSE;
346: }
347: #ifdef VMS
348: if (opened_binary)
349: fflush_binary();
350: else
351: #endif /* VMS */
352:
353: (void) fflush(gpoutfile);
354: }
355:
356: void term_start_multiplot()
357: {
358: FPRINTF((stderr, "term_start_multiplot()\n"));
359: if (multiplot)
360: term_end_multiplot();
361:
362: multiplot = TRUE;
363: term_start_plot();
364: }
365:
366: void term_end_multiplot()
367: {
368: FPRINTF((stderr, "term_end_multiplot()\n"));
369: if (!multiplot)
370: return;
371:
372: if (term_suspended) {
373: if (term->resume)
374: (*term->resume) ();
375: term_suspended = FALSE;
376: }
377: multiplot = FALSE;
378:
379: term_end_plot();
380: }
381:
382:
383:
384: static void term_suspend()
385: {
386: FPRINTF((stderr, "term_suspend()\n"));
387: if (term_initialised && !term_suspended && term->suspend) {
388: FPRINTF((stderr, "- calling term->suspend()\n"));
389: (*term->suspend) ();
390: term_suspended = TRUE;
391: }
392: }
393:
394: void term_reset()
395: {
396: FPRINTF((stderr, "term_reset()\n"));
397:
398: if (!term_initialised)
399: return;
400:
401: if (term_suspended) {
402: if (term->resume) {
403: FPRINTF((stderr, "- calling term->resume()\n"));
404: (*term->resume) ();
405: }
406: term_suspended = FALSE;
407: }
408: if (term_graphics) {
409: (*term->text) ();
410: term_graphics = FALSE;
411: }
412: if (term_initialised) {
413: (*term->reset) ();
414: term_initialised = FALSE;
415: }
416: }
417:
418: void term_apply_lp_properties(lp)
419: struct lp_style_type *lp;
420: {
421: /* This function passes all the line and point properties to the
422: * terminal driver and issues the corresponding commands.
423: *
424: * Alas, sometimes it might be necessary to give some help to
425: * this function by explicitly issuing additional '(*term)(...)'
426: * commands.
427: */
428:
429: if (lp->pointflag) {
430: /* change points, too
431: * Currently, there is no 'pointtype' function. For points
432: * there is a special function also dealing with (x,y) co-
433: * ordinates.
434: */
435: (*term->pointsize) (lp->p_size);
436: }
437: /* _first_ set the line width, _then_ set the line type !
438:
439: * The linetype might depend on the linewidth in some terminals.
440: */
441: (*term->linewidth) (lp->l_width);
442: (*term->linetype) (lp->l_type);
443: }
444:
445:
446:
447: void term_check_multiplot_okay(f_interactive)
448: TBOOLEAN f_interactive;
449: {
450: FPRINTF((stderr, "term_multiplot_okay(%d)\n", f_interactive));
451:
452: if (!term_initialised)
453: return; /* they've not started yet */
454:
455: /* make sure that it is safe to issue an interactive prompt
456: * it is safe if
457: * it is not an interactive read, or
458: * the terminal supports interactive multiplot, or
459: * we are not writing to stdout and terminal doesn't
460: * refuse multiplot outright
461: */
462: if (!f_interactive || (term->flags & TERM_CAN_MULTIPLOT) ||
463: ((gpoutfile != stdout) && !(term->flags & TERM_CANNOT_MULTIPLOT))
464: ) {
465: /* it's okay to use multiplot here, but suspend first */
466: term_suspend();
467: return;
468: }
469: /* uh oh : they're not allowed to be in multiplot here */
470:
471: term_end_multiplot();
472:
473: /* at this point we know that it is interactive and that the
474: * terminal can either only do multiplot when writing to
475: * to a file, or it does not do multiplot at all
476: */
477:
478: if (term->flags & TERM_CANNOT_MULTIPLOT)
479: int_error("This terminal does not support multiplot", NO_CARET);
480: else
481: int_error("Must set output to a file or put all multiplot commands on one input line", NO_CARET);
482: }
483:
484: void do_point(x, y, number)
485: unsigned int x, y;
486: int number;
487: {
488: register int htic, vtic;
489: register struct termentry *t = term;
490:
491: if (number < 0) { /* do dot */
492: (*t->move) (x, y);
493: (*t->vector) (x, y);
494: return;
495: }
496: number %= POINT_TYPES;
497: /* should be in term_tbl[] in later version */
498: htic = (term_pointsize * t->h_tic / 2);
499: vtic = (term_pointsize * t->v_tic / 2);
500:
501: switch (number) {
502: case 0: /* do diamond */
503: (*t->move) (x - htic, y);
504: (*t->vector) (x, y - vtic);
505: (*t->vector) (x + htic, y);
506: (*t->vector) (x, y + vtic);
507: (*t->vector) (x - htic, y);
508: (*t->move) (x, y);
509: (*t->vector) (x, y);
510: break;
511: case 1: /* do plus */
512: (*t->move) (x - htic, y);
513: (*t->vector) (x - htic, y);
514: (*t->vector) (x + htic, y);
515: (*t->move) (x, y - vtic);
516: (*t->vector) (x, y - vtic);
517: (*t->vector) (x, y + vtic);
518: break;
519: case 2: /* do box */
520: (*t->move) (x - htic, y - vtic);
521: (*t->vector) (x - htic, y - vtic);
522: (*t->vector) (x + htic, y - vtic);
523: (*t->vector) (x + htic, y + vtic);
524: (*t->vector) (x - htic, y + vtic);
525: (*t->vector) (x - htic, y - vtic);
526: (*t->move) (x, y);
527: (*t->vector) (x, y);
528: break;
529: case 3: /* do X */
530: (*t->move) (x - htic, y - vtic);
531: (*t->vector) (x - htic, y - vtic);
532: (*t->vector) (x + htic, y + vtic);
533: (*t->move) (x - htic, y + vtic);
534: (*t->vector) (x - htic, y + vtic);
535: (*t->vector) (x + htic, y - vtic);
536: break;
537: case 4: /* do triangle */
538: (*t->move) (x, y + (4 * vtic / 3));
539: (*t->vector) (x - (4 * htic / 3), y - (2 * vtic / 3));
540: (*t->vector) (x + (4 * htic / 3), y - (2 * vtic / 3));
541: (*t->vector) (x, y + (4 * vtic / 3));
542: (*t->move) (x, y);
543: (*t->vector) (x, y);
544: break;
545: case 5: /* do star */
546: (*t->move) (x - htic, y);
547: (*t->vector) (x - htic, y);
548: (*t->vector) (x + htic, y);
549: (*t->move) (x, y - vtic);
550: (*t->vector) (x, y - vtic);
551: (*t->vector) (x, y + vtic);
552: (*t->move) (x - htic, y - vtic);
553: (*t->vector) (x - htic, y - vtic);
554: (*t->vector) (x + htic, y + vtic);
555: (*t->move) (x - htic, y + vtic);
556: (*t->vector) (x - htic, y + vtic);
557: (*t->vector) (x + htic, y - vtic);
558: break;
559: }
560: }
561:
562: void do_pointsize(size)
563: double size;
564: {
565: term_pointsize = (size >= 0 ? size : 1);
566: }
567:
568:
569: /*
570: * general point routine
571: */
572: void line_and_point(x, y, number)
573: unsigned int x, y;
574: int number;
575: {
576: /* temporary(?) kludge to allow terminals with bad linetypes
577: to make nice marks */
578:
579: (*term->linetype) (NICE_LINE);
580: do_point(x, y, number);
581: }
582:
583: /*
584: * general arrow routine
585: *
586: * I set the angle between the arrowhead and the line 15 degree.
587: * The length of arrowhead varies depending on the line length
588: * within the the range [0.3*(the-tic-length), 2*(the-tic-length)].
589: * No head is printed if the arrow length is zero.
590: *
591: * Yasu-hiro Yamazaki(hiro@rainbow.physics.utoronto.ca)
592: * Jul 1, 1993
593: */
594:
595: #define COS15 (0.96593) /* cos of 15 degree */
596: #define SIN15 (0.25882) /* sin of 15 degree */
597:
598: #define HEAD_LONG_LIMIT (2.0) /* long limit of arrowhead length */
599: #define HEAD_SHORT_LIMIT (0.3) /* short limit of arrowhead length */
600: /* their units are the "tic" length */
601:
602: #define HEAD_COEFF (0.3) /* default value of head/line length ratio */
603:
604: void do_arrow(sx, sy, ex, ey, head)
605: unsigned int sx, sy; /* start point */
606: unsigned int ex, ey; /* end point (point of arrowhead) */
607: TBOOLEAN head;
608: {
609: register struct termentry *t = term;
610: float len_tic = ((double) (t->h_tic + t->v_tic)) / 2.0;
611: /* average of tic sizes */
612: /* (dx,dy) : vector from end to start */
613: double dx = (double) sx - (double) ex;
614: double dy = (double) sy - (double) ey;
615: double len_arrow = sqrt(dx * dx + dy * dy);
616:
617: /* draw the line for the arrow. That's easy. */
618: (*t->move) (sx, sy);
619: (*t->vector) (ex, ey);
620:
621: /* no head for arrows whih length = 0
622: * or, to be more specific, length < DBL_EPSILON,
623: * because len_arrow will almost always be != 0
624: */
625: if (head && fabs(len_arrow) >= DBL_EPSILON) {
626: /* now calc the head_coeff */
627: double coeff_shortest = len_tic * HEAD_SHORT_LIMIT / len_arrow;
628: double coeff_longest = len_tic * HEAD_LONG_LIMIT / len_arrow;
629: double head_coeff = GPMAX(coeff_shortest,
630: GPMIN(HEAD_COEFF, coeff_longest));
631: /* now draw the arrow head. */
632: /* we put the arrowhead marks at 15 degrees to line */
633: int x, y; /* one endpoint */
634:
635: x = (int) (ex + (COS15 * dx - SIN15 * dy) * head_coeff);
636: y = (int) (ey + (SIN15 * dx + COS15 * dy) * head_coeff);
637: (*t->move) (x, y);
638: (*t->vector) (ex, ey);
639:
640: x = (int) (ex + (COS15 * dx + SIN15 * dy) * head_coeff);
641: y = (int) (ey + (-SIN15 * dx + COS15 * dy) * head_coeff);
642: (*t->vector) (x, y);
643: }
644: }
645:
646: #if 0 /* oiginal routine */
647: #define ROOT2 (1.41421) /* sqrt of 2 */
648:
649: void org_do_arrow(sx, sy, ex, ey, head)
650: int sx, sy; /* start point */
651: int ex, ey; /* end point (point of arrowhead) */
652: TBOOLEAN head;
653: {
654: register struct termentry *t = term;
655: int len = (t->h_tic + t->v_tic) / 2; /* arrowhead size = avg of tic sizes */
656:
657: /* draw the line for the arrow. That's easy. */
658: (*t->move) (sx, sy);
659: (*t->vector) (ex, ey);
660:
661: if (head) {
662: /* now draw the arrow head. */
663: /* we put the arrowhead marks at 45 degrees to line */
664: if (sx == ex) {
665: /* vertical line, special case */
666: int delta = ((float) len / ROOT2 + 0.5);
667: if (sy < ey)
668: delta = -delta; /* up arrow goes the other way */
669: (*t->move) (ex - delta, ey + delta);
670: (*t->vector) (ex, ey);
671: (*t->vector) (ex + delta, ey + delta);
672: } else {
673: int dx = sx - ex;
674: int dy = sy - ey;
675: double coeff = len / sqrt(2.0 * ((double) dx * (double) dx
676: + (double) dy * (double) dy));
677: int x, y; /* one endpoint */
678:
679: x = (int) (ex + (dx + dy) * coeff);
680: y = (int) (ey + (dy - dx) * coeff);
681: (*t->move) (x, y);
682: (*t->vector) (ex, ey);
683:
684: x = (int) (ex + (dx - dy) * coeff);
685: y = (int) (ey + (dy + dx) * coeff);
686: (*t->vector) (x, y);
687: }
688: }
689: }
690:
691: #endif /* original routine */
692:
693:
694: #define TERM_PROTO
695: #define TERM_BODY
696: #define TERM_PUBLIC static
697:
698: #include "term.h"
699:
700: #undef TERM_PROTO
701: #undef TERM_BODY
702: #undef TERM_PUBLIC
703:
704:
705: /* Dummy functions for unavailable features */
706: /* return success if they asked for default - this simplifies code
707: * where param is passed as a param. Client can first pass it here,
708: * and only if it fails do they have to see what was trying to be done
709: */
710:
711: /* change angle of text. 0 is horizontal left to right.
712: * 1 is vertical bottom to top (90 deg rotate)
713: */
714: int null_text_angle(ang)
715: int ang;
716: {
717: return (ang == 0);
718: }
719:
720: /* change justification of text.
721: * modes are LEFT (flush left), CENTRE (centred), RIGHT (flush right)
722: */
723: int null_justify_text(just)
724: enum JUSTIFY just;
725: {
726: return (just == LEFT);
727: }
728:
729:
730: /* Change scale of plot.
731: * Parameters are x,y scaling factors for this plot.
732: * Some terminals (eg latex) need to do scaling themselves.
733: */
734: int null_scale(x, y)
735: double x;
736: double y;
737: {
738: return FALSE; /* can't be done */
739: }
740:
741: int do_scale(x, y)
742: double x;
743: double y;
744: {
745: return TRUE; /* can be done */
746: }
747:
748: void options_null()
749: {
750: term_options[0] = '\0'; /* we have no options */
751: }
752:
753: void UNKNOWN_null()
754: {
755: }
756:
757: void MOVE_null(x, y)
758: unsigned int x, y;
759: {
760: }
761:
762: void LINETYPE_null(t)
763: int t;
764: {
765: }
766:
767: void PUTTEXT_null(x, y, s)
768: unsigned int x, y;
769: char *s;
770: {
771: }
772:
773:
774: int set_font_null(s)
775: char *s;
776: {
777: return FALSE;
778: }
779:
780: static void null_linewidth(s)
781: double s;
782: {
783: }
784:
785:
786: /* cast to get rid of useless warnings about UNKNOWN_null */
787: typedef void (*void_fp) __PROTO((void));
788:
789:
790: /* setup the magic macros to compile in the right parts of the
791: * terminal drivers included by term.h
792: */
793:
794: #define TERM_TABLE
795: #define TERM_TABLE_START(x) ,{
796: #define TERM_TABLE_END(x) }
797:
798:
799: /*
800: * term_tbl[] contains an entry for each terminal. "unknown" must be the
801: * first, since term is initialized to 0.
802: */
803: struct termentry term_tbl[] =
804: {
805: {"unknown", "Unknown terminal type - not a plotting device",
806: 100, 100, 1, 1,
807: 1, 1, options_null, UNKNOWN_null, UNKNOWN_null,
808: UNKNOWN_null, null_scale, UNKNOWN_null, MOVE_null, MOVE_null,
809: LINETYPE_null, PUTTEXT_null}
810: ,
811: {"table", "Dump ASCII table of X Y [Z] values to output",
812: 100, 100, 1, 1,
813: 1, 1, options_null, UNKNOWN_null, UNKNOWN_null,
814: UNKNOWN_null, null_scale, UNKNOWN_null, MOVE_null, MOVE_null,
815: LINETYPE_null, PUTTEXT_null}
816: #include "term.h"
817:
818: };
819:
820: #define TERMCOUNT (sizeof(term_tbl)/sizeof(struct termentry))
821:
822: void list_terms()
823: {
824: register int i;
825: char line_buffer[BUFSIZ];
826:
827: StartOutput();
828: sprintf(line_buffer,"\nAvailable terminal types:\n");
829: OutLine(line_buffer);
830:
831: for (i = 0; i < TERMCOUNT; i++) {
832: sprintf(line_buffer," %15s %s\n",
833: term_tbl[i].name, term_tbl[i].description);
834: OutLine(line_buffer);
835: }
836:
837: EndOutput();
838: }
839:
840:
841: /* set_term: get terminal number from name on command line
842: * will change 'term' variable if successful
843: */
844: struct termentry *
845: set_term(c_token_arg)
846: int c_token_arg;
847: {
848: register struct termentry *t = NULL;
849: char *input_name;
850:
851: if (!token[c_token_arg].is_token)
852: int_error("terminal name expected", c_token_arg);
853: input_name = input_line + token[c_token_arg].start_index;
854: t = change_term(input_name, token[c_token_arg].length);
855: if (!t)
856: int_error("unknown or ambiguous terminal type; type just 'set terminal' for a list",
857: c_token_arg);
858:
859: /* otherwise the type was changed */
860:
861: return (t);
862: }
863:
864: /* change_term: get terminal number from name and set terminal type
865: *
866: * returns NULL for unknown or ambiguous, otherwise is terminal
867: * driver pointer
868: */
869: struct termentry *
870: change_term(name, length)
871: char *name;
872: int length;
873: {
874: int i;
875: struct termentry *t = NULL;
876:
877: for (i = 0; i < TERMCOUNT; i++) {
878: if (!strncmp(name, term_tbl[i].name, length)) {
879: if (t)
880: return (NULL); /* ambiguous */
881: t = term_tbl + i;
882: }
883: }
884:
885: if (!t) /* unknown */
886: return (NULL);
887:
888: /* Success: set terminal type now */
889:
890: term = t;
891: term_initialised = FALSE;
892: name = term->name;
893:
894: if (term->scale != null_scale)
895: fputs("Warning : scale interface is not null_scale - may not work with multiplot\n", stderr);
896:
897: /* check that optional fields are initialised to something */
898: if (term->text_angle == 0)
899: term->text_angle = null_text_angle;
900: if (term->justify_text == 0)
901: term->justify_text = null_justify_text;
902: if (term->point == 0)
903: term->point = do_point;
904: if (term->arrow == 0)
905: term->arrow = do_arrow;
906: if (term->set_font == 0)
907: term->set_font = set_font_null;
908: if (term->pointsize == 0)
909: term->pointsize = do_pointsize;
910: if (term->linewidth == 0)
911: term->linewidth = null_linewidth;
912:
913: /* Special handling for unixplot term type */
914: if (!strncmp("unixplot", name, 8)) {
915: UP_redirect(2); /* Redirect actual stdout for unixplots */
916: } else if (unixplot) {
917: UP_redirect(3); /* Put stdout back together again. */
918: }
919: if (interactive)
920: fprintf(stderr, "Terminal type set to '%s'\n", name);
921:
922: return (t);
923: }
924:
925: /*
926: * Routine to detect what terminal is being used (or do anything else
927: * that would be nice). One anticipated (or allowed for) side effect
928: * is that the global ``term'' may be set.
929: * The environment variable GNUTERM is checked first; if that does
930: * not exist, then the terminal hardware is checked, if possible,
931: * and finally, we can check $TERM for some kinds of terminals.
932: * A default can be set with -DDEFAULTTERM=myterm in the Makefile
933: * or #define DEFAULTTERM myterm in term.h
934: */
935: /* thanks to osupyr!alden (Dave Alden) for the original GNUTERM code */
936: void init_terminal()
937: {
938: char *term_name = DEFAULTTERM;
939: #if (defined(__TURBOC__) && defined(MSDOS) && !defined(_Windows)) || defined(NEXT) || defined(SUN) || defined(X11)
940: char *env_term = NULL; /* from TERM environment var */
941: #endif
942: #ifdef X11
943: char *display = NULL;
944: #endif
945: char *gnuterm = NULL;
946:
947: /* GNUTERM environment variable is primary */
948: gnuterm = getenv("GNUTERM");
949: if (gnuterm != (char *) NULL) {
950: term_name = gnuterm;
951: } else {
952:
953: #ifdef __ZTC__
954: term_name = ztc_init();
955: #endif
956:
957: #ifdef VMS
958: term_name = vms_init();
959: #endif /* VMS */
960:
961: #ifdef NEXT
962: env_term = getenv("TERM");
963: if (term_name == (char *) NULL
964: && env_term != (char *) NULL && strcmp(term, "next") == 0)
965: term_name = "next";
966: #endif /* NeXT */
967:
968: #ifdef SUN
969: env_term = getenv("TERM"); /* try $TERM */
970: if (term_name == (char *) NULL
971: && env_term != (char *) NULL && strcmp(env_term, "sun") == 0)
972: term_name = "sun";
973: #endif /* SUN */
974:
975: #ifdef _Windows
976: term_name = "win";
977: #endif /* _Windows */
978:
979: #ifdef GPR
980: /* find out whether stdout is a DM pad. See term/gpr.trm */
981: if (gpr_isa_pad())
982: term_name = "gpr";
983: #else
984: # ifdef APOLLO
985: /* find out whether stdout is a DM pad. See term/apollo.trm */
986: if (apollo_isa_pad())
987: term_name = "apollo";
988: # endif /* APOLLO */
989: #endif /* GPR */
990:
991: #ifdef X11
992: env_term = getenv("TERM"); /* try $TERM */
993: if (term_name == (char *) NULL
994: && env_term != (char *) NULL && strcmp(env_term, "xterm") == 0)
995: term_name = "x11";
996: display = getenv("DISPLAY");
997: if (term_name == (char *) NULL && display != (char *) NULL)
998: term_name = "x11";
999: if (X11_Display)
1000: term_name = "x11";
1001: #endif /* x11 */
1002:
1003: #ifdef AMIGA
1004: term_name = "amiga";
1005: #endif
1006:
1007: #if defined(ATARI) || defined(MTOS)
1008: term_name = "atari";
1009: #endif
1010:
1011: #ifdef UNIXPC
1012: if (iswind() == 0) {
1013: term_name = "unixpc";
1014: }
1015: #endif /* unixpc */
1016:
1017: #ifdef CGI
1018: if (getenv("CGIDISP") || getenv("CGIPRNT"))
1019: term_name = "cgi";
1020: #endif /*CGI */
1021:
1022: #ifdef DJGPP
1023: term_name = "svga";
1024: #endif
1025:
1026: #ifdef GRASS
1027: term_name = "grass";
1028: #endif
1029:
1030: #ifdef OS2
1031: /* if (_osmode==OS2_MODE) term_name = "pm" ; else term_name = "emxvga"; */
1032: # ifdef X11
1033: /* This catch is hopefully ok ... */
1034: env_term = getenv("WINDOWID");
1035: display = getenv("DISPLAY");
1036: if ((env_term != (char *) NULL) && (display != (char *) NULL))
1037: term_name = "x11";
1038: else
1039: # endif /* X11 */
1040: term_name = "pm";
1041: #endif /*OS2 */
1042:
1043: /* set linux terminal only if LINUX_setup was successfull, if we are on X11
1044: LINUX_setup has failed, also if we are logged in by network */
1045: #ifdef LINUXVGA
1046: if (LINUX_graphics_allowed)
1047: term_name = "linux";
1048: #endif /* LINUXVGA */
1049: }
1050:
1051: /* We have a name, try to set term type */
1052: if (term_name != NULL && *term_name != '\0') {
1053: if (change_term(term_name, (int) strlen(term_name)))
1054: return;
1055: fprintf(stderr, "Unknown or ambiguous terminal name '%s'\n", term_name);
1056: }
1057: change_term("unknown", 7);
1058: }
1059:
1060:
1061: #ifdef __ZTC__
1062: char *ztc_init()
1063: {
1064: int g_mode;
1065: char *term_name = NULL;
1066:
1067: g_mode = fg_init();
1068:
1069: switch (g_mode) {
1070: case FG_NULL:
1071: fputs("Graphics card not detected or not supported.\n", stderr);
1072: exit(1);
1073: case FG_HERCFULL:
1074: term_name = "hercules";
1075: break;
1076: case FG_EGAMONO:
1077: term_name = "egamono";
1078: break;
1079: case FG_EGAECD:
1080: term_name = "egalib";
1081: break;
1082: case FG_VGA11:
1083: term_name = "vgamono";
1084: break;
1085: case FG_VGA12:
1086: term_name = "vgalib";
1087: break;
1088: case FG_VESA6A:
1089: term_name = "svgalib";
1090: break;
1091: case FG_VESA5:
1092: term_name = "ssvgalib";
1093: break;
1094: }
1095: fg_term();
1096: return (term_name);
1097: }
1098: #endif /* __ZTC__ */
1099:
1100:
1101: /*
1102: This is always defined so we don't have to have command.c know if it
1103: is there or not.
1104: */
1105: #if !(defined(UNIXPLOT) || defined(GNUGRAPH))
1106: void UP_redirect(caller)
1107: int caller;
1108: {
1109: caller = caller; /* to stop Turbo C complaining
1110: * about caller not being used */
1111: }
1112:
1113: #else /* UNIXPLOT || GNUGRAPH */
1114: void UP_redirect(caller)
1115: int caller;
1116: /*
1117: Unixplot can't really write to gpoutfile--it wants to write to stdout.
1118: This is normally ok, but the original design of gnuplot gives us
1119: little choice. Originally users of unixplot had to anticipate
1120: their needs and redirect all I/O to a file... Not very gnuplot-like.
1121:
1122: caller: 1 - called from SET OUTPUT "FOO.OUT"
1123: 2 - called from SET TERM UNIXPLOT
1124: 3 - called from SET TERM other
1125: 4 - called from SET OUTPUT
1126: */
1127: {
1128: switch (caller) {
1129: case 1:
1130: /* Don't save, just replace stdout w/gpoutfile (save was already done). */
1131: if (unixplot)
1132: *(stdout) = *(gpoutfile); /* Copy FILE structure */
1133: break;
1134: case 2:
1135: if (!unixplot) {
1136: fflush(stdout);
1137: save_stdout = *(stdout);
1138: *(stdout) = *(gpoutfile); /* Copy FILE structure */
1139: unixplot = 1;
1140: }
1141: break;
1142: case 3:
1143: /* New terminal in use--put stdout back to original. */
1144: /* closepl(); *//* This is called by the term. */
1145: fflush(stdout);
1146: *(stdout) = save_stdout; /* Copy FILE structure */
1147: unixplot = 0;
1148: break;
1149: case 4:
1150: /* User really wants to go to normal output... */
1151: if (unixplot) {
1152: fflush(stdout);
1153: *(stdout) = save_stdout; /* Copy FILE structure */
1154: }
1155: break;
1156: }
1157: }
1158: #endif /* UNIXPLOT || GNUGRAPH */
1159:
1160:
1161: /* test terminal by drawing border and text */
1162: /* called from command test */
1163: void test_term()
1164: {
1165: register struct termentry *t = term;
1166: char *str;
1167: int x, y, xl, yl, i;
1168: unsigned int xmax_t, ymax_t;
1169: char label[MAX_ID_LEN];
1170: int key_entry_height;
1171: int p_width;
1172:
1173: term_start_plot();
1174: screen_ok = FALSE;
1175: xmax_t = (unsigned int) (t->xmax * xsize);
1176: ymax_t = (unsigned int) (t->ymax * ysize);
1177:
1178: p_width = pointsize * (t->h_tic);
1179: key_entry_height = pointsize * (t->v_tic) * 1.25;
1180: if (key_entry_height < (t->v_char))
1181: key_entry_height = (t->v_char);
1182:
1183: /* border linetype */
1184: (*t->linetype) (-2);
1185: (*t->move) (0, 0);
1186: (*t->vector) (xmax_t - 1, 0);
1187: (*t->vector) (xmax_t - 1, ymax_t - 1);
1188: (*t->vector) (0, ymax_t - 1);
1189: (*t->vector) (0, 0);
1190: (void) (*t->justify_text) (LEFT);
1191: (*t->put_text) (t->h_char * 5, ymax_t - t->v_char * 3, "Terminal Test");
1192: /* axis linetype */
1193: (*t->linetype) (-1);
1194: (*t->move) (xmax_t / 2, 0);
1195: (*t->vector) (xmax_t / 2, ymax_t - 1);
1196: (*t->move) (0, ymax_t / 2);
1197: (*t->vector) (xmax_t - 1, ymax_t / 2);
1198: /* test width and height of characters */
1199: (*t->linetype) (-2);
1200: (*t->move) (xmax_t / 2 - t->h_char * 10, ymax_t / 2 + t->v_char / 2);
1201: (*t->vector) (xmax_t / 2 + t->h_char * 10, ymax_t / 2 + t->v_char / 2);
1202: (*t->vector) (xmax_t / 2 + t->h_char * 10, ymax_t / 2 - t->v_char / 2);
1203: (*t->vector) (xmax_t / 2 - t->h_char * 10, ymax_t / 2 - t->v_char / 2);
1204: (*t->vector) (xmax_t / 2 - t->h_char * 10, ymax_t / 2 + t->v_char / 2);
1205: (*t->put_text) (xmax_t / 2 - t->h_char * 10, ymax_t / 2,
1206: "12345678901234567890");
1207: /* test justification */
1208: (void) (*t->justify_text) (LEFT);
1209: (*t->put_text) (xmax_t / 2, ymax_t / 2 + t->v_char * 6, "left justified");
1210: str = "centre+d text";
1211: if ((*t->justify_text) (CENTRE))
1212: (*t->put_text) (xmax_t / 2,
1213: ymax_t / 2 + t->v_char * 5, str);
1214: else
1215: (*t->put_text) (xmax_t / 2 - strlen(str) * t->h_char / 2,
1216: ymax_t / 2 + t->v_char * 5, str);
1217: str = "right justified";
1218: if ((*t->justify_text) (RIGHT))
1219: (*t->put_text) (xmax_t / 2,
1220: ymax_t / 2 + t->v_char * 4, str);
1221: else
1222: (*t->put_text) (xmax_t / 2 - strlen(str) * t->h_char,
1223: ymax_t / 2 + t->v_char * 4, str);
1224: /* test text angle */
1225: str = "rotated ce+ntred text";
1226: if ((*t->text_angle) (1)) {
1227: if ((*t->justify_text) (CENTRE))
1228: (*t->put_text) (t->v_char,
1229: ymax_t / 2, str);
1230: else
1231: (*t->put_text) (t->v_char,
1232: ymax_t / 2 - strlen(str) * t->h_char / 2, str);
1233: } else {
1234: (void) (*t->justify_text) (LEFT);
1235: (*t->put_text) (t->h_char * 2, ymax_t / 2 - t->v_char * 2, "Can't rotate text");
1236: }
1237: (void) (*t->justify_text) (LEFT);
1238: (void) (*t->text_angle) (0);
1239: /* test tic size */
1240: (*t->move) ((unsigned int) (xmax_t / 2 + t->h_tic * (1 + ticscale)), (unsigned) 0);
1241: (*t->vector) ((unsigned int) (xmax_t / 2 + t->h_tic * (1 + ticscale)), (unsigned int)
1242: (ticscale * t->v_tic));
1243: (*t->move) ((unsigned int) (xmax_t / 2), (unsigned int) (t->v_tic * (1 + ticscale)));
1244: (*t->vector) ((unsigned int) (xmax_t / 2 + ticscale * t->h_tic), (unsigned int) (t->v_tic * (1
1245: + ticscale)));
1246: (*t->put_text) ((unsigned int) (xmax_t / 2 - 10 * t->h_char), (unsigned int) (t->v_tic * 2 +
1247: t->v_char / 2),
1248: "test tics");
1249:
1250: /* test line and point types */
1251: x = xmax_t - t->h_char * 6 - p_width;
1252: y = ymax_t - key_entry_height;
1253: (*t->pointsize) (pointsize);
1254: for (i = -2; y > key_entry_height; i++) {
1255: (*t->linetype) (i);
1256: /* (void) sprintf(label,"%d",i); Jorgen Lippert
1257: lippert@risoe.dk */
1258: (void) sprintf(label, "%d", i + 1);
1259: if ((*t->justify_text) (RIGHT))
1260: (*t->put_text) (x, y, label);
1261: else
1262: (*t->put_text) (x - strlen(label) * t->h_char, y, label);
1263: (*t->move) (x + t->h_char, y);
1264: (*t->vector) (x + t->h_char * 4, y);
1265: if (i >= -1)
1266: (*t->point) (x + t->h_char * 5 + p_width / 2, y, i);
1267: y -= key_entry_height;
1268: }
1269: /* test some arrows */
1270: (*t->linewidth) (1.0);
1271: (*t->linetype) (0);
1272: x = xmax_t / 4;
1273: y = ymax_t / 4;
1274: xl = t->h_tic * 5;
1275: yl = t->v_tic * 5;
1276: (*t->arrow) (x, y, x + xl, y, TRUE);
1277: (*t->arrow) (x, y, x + xl / 2, y + yl, TRUE);
1278: (*t->arrow) (x, y, x, y + yl, TRUE);
1279: (*t->arrow) (x, y, x - xl / 2, y + yl, FALSE);
1280: (*t->arrow) (x, y, x - xl, y, TRUE);
1281: (*t->arrow) (x, y, x - xl, y - yl, TRUE);
1282: (*t->arrow) (x, y, x, y - yl, TRUE);
1283: (*t->arrow) (x, y, x + xl, y - yl, TRUE);
1284:
1285: term_end_plot();
1286: }
1287:
1288: #if 0
1289: # if defined(MSDOS)||defined(g)||defined(MTOS)||defined(OS2)||defined(_Windows)||defined(DOS386)
1290: /* output for some terminal types must be binary to stop non Unix computers
1291: changing \n to \r\n.
1292: If the output is not STDOUT, the following code reopens gpoutfile
1293: with binary mode. */
1294: void reopen_binary()
1295: {
1296: if (outstr) {
1297: (void) fclose(gpoutfile);
1298: # ifdef _Windows
1299: if (!stricmp(outstr, "PRN")) {
1300: /* use temp file for windows */
1301: (void) strcpy(filename, win_prntmp);
1302: }
1303: # endif
1304: if ((gpoutfile = fopen(filename, "wb")) == (FILE *) NULL) {
1305: if ((gpoutfile = fopen(filename, "w")) == (FILE *) NULL) {
1306: os_error("cannot reopen file with binary type; output unknown",
1307: NO_CARET);
1308: } else {
1309: os_error("cannot reopen file with binary type; output reset to ascii",
1310: NO_CARET);
1311: }
1312: }
1313: # if defined(__TURBOC__) && defined(MSDOS)
1314: # ifndef _Windows
1315: if (!stricmp(outstr, "PRN")) {
1316: /* Put the printer into binary mode. */
1317: union REGS regs;
1318: regs.h.ah = 0x44; /* ioctl */
1319: regs.h.al = 0; /* get device info */
1320: regs.x.bx = fileno(gpoutfile);
1321: intdos(®s, ®s);
1322: regs.h.dl |= 0x20; /* binary (no ^Z intervention) */
1323: regs.h.dh = 0;
1324: regs.h.ah = 0x44; /* ioctl */
1325: regs.h.al = 1; /* set device info */
1326: intdos(®s, ®s);
1327: }
1328: # endif /* !_Windows */
1329: # endif /* TURBOC && MSDOS */
1330: }
1331: }
1332:
1333: # endif /* MSDOS || g || MTOS || ... */
1334: #endif /* 0 */
1335:
1336: #ifdef VMS
1337: /* these are needed to modify terminal characteristics */
1338: # ifndef VWS_XMAX
1339: /* avoid duplicate warning; VWS includes these */
1340: # include <descrip.h>
1341: # include <ssdef.h>
1342: # endif /* !VWS_MAX */
1343: # include <iodef.h>
1344: # include <ttdef.h>
1345: # include <tt2def.h>
1346: # include <dcdef.h>
1347: # include <stat.h>
1348: # include <fab.h>
1349: /* If you use WATCOM C or a very strict ANSI compiler, you may have to
1350: * delete or comment out the following 3 lines: */
1351: # ifndef TT2$M_DECCRT3 /* VT300 not defined as of VAXC v2.4 */
1352: # define TT2$M_DECCRT3 0X80000000
1353: # endif
1354: static unsigned short chan;
1355: static int old_char_buf[3], cur_char_buf[3];
1356: $DESCRIPTOR(sysoutput_desc, "SYS$OUTPUT");
1357:
1358: char *vms_init()
1359: /*
1360: * Look first for decw$display (decterms do regis)
1361: * Determine if we have a regis terminal
1362: * and save terminal characteristics
1363: */
1364: {
1365: /* Save terminal characteristics in old_char_buf and
1366: initialise cur_char_buf to current settings. */
1367: int i;
1368: if (getenv("DECW$DISPLAY"))
1369: return ("x11");
1370: atexit(vms_reset);
1371: sys$assign(&sysoutput_desc, &chan, 0, 0);
1372: sys$qiow(0, chan, IO$_SENSEMODE, 0, 0, 0, old_char_buf, 12, 0, 0, 0, 0);
1373: for (i = 0; i < 3; ++i)
1374: cur_char_buf[i] = old_char_buf[i];
1375: sys$dassgn(chan);
1376:
1377: /* Test if terminal is regis */
1378: if ((cur_char_buf[2] & TT2$M_REGIS) == TT2$M_REGIS)
1379: return ("regis");
1380: return (NULL);
1381: }
1382:
1383: void vms_reset()
1384: /* set terminal to original state */
1385: {
1386: int i;
1387: sys$assign(&sysoutput_desc, &chan, 0, 0);
1388: sys$qiow(0, chan, IO$_SETMODE, 0, 0, 0, old_char_buf, 12, 0, 0, 0, 0);
1389: for (i = 0; i < 3; ++i)
1390: cur_char_buf[i] = old_char_buf[i];
1391: sys$dassgn(chan);
1392: }
1393:
1394: void term_mode_tek()
1395: /* set terminal mode to tektronix */
1396: {
1397: long status;
1398: if (gpoutfile != stdout)
1399: return; /* don't modify if not stdout */
1400: sys$assign(&sysoutput_desc, &chan, 0, 0);
1401: cur_char_buf[0] = 0x004A0000 | DC$_TERM | (TT$_TEK401X << 8);
1402: cur_char_buf[1] = (cur_char_buf[1] & 0x00FFFFFF) | 0x18000000;
1403:
1404: cur_char_buf[1] &= ~TT$M_CRFILL;
1405: cur_char_buf[1] &= ~TT$M_ESCAPE;
1406: cur_char_buf[1] &= ~TT$M_HALFDUP;
1407: cur_char_buf[1] &= ~TT$M_LFFILL;
1408: cur_char_buf[1] &= ~TT$M_MECHFORM;
1409: cur_char_buf[1] &= ~TT$M_NOBRDCST;
1410: cur_char_buf[1] &= ~TT$M_NOECHO;
1411: cur_char_buf[1] &= ~TT$M_READSYNC;
1412: cur_char_buf[1] &= ~TT$M_REMOTE;
1413: cur_char_buf[1] |= TT$M_LOWER;
1414: cur_char_buf[1] |= TT$M_TTSYNC;
1415: cur_char_buf[1] |= TT$M_WRAP;
1416: cur_char_buf[1] &= ~TT$M_EIGHTBIT;
1417: cur_char_buf[1] &= ~TT$M_MECHTAB;
1418: cur_char_buf[1] &= ~TT$M_SCOPE;
1419: cur_char_buf[1] |= TT$M_HOSTSYNC;
1420:
1421: cur_char_buf[2] &= ~TT2$M_APP_KEYPAD;
1422: cur_char_buf[2] &= ~TT2$M_BLOCK;
1423: cur_char_buf[2] &= ~TT2$M_DECCRT3;
1424: cur_char_buf[2] &= ~TT2$M_LOCALECHO;
1425: cur_char_buf[2] &= ~TT2$M_PASTHRU;
1426: cur_char_buf[2] &= ~TT2$M_REGIS;
1427: cur_char_buf[2] &= ~TT2$M_SIXEL;
1428: cur_char_buf[2] |= TT2$M_BRDCSTMBX;
1429: cur_char_buf[2] |= TT2$M_EDITING;
1430: cur_char_buf[2] |= TT2$M_INSERT;
1431: cur_char_buf[2] |= TT2$M_PRINTER;
1432: cur_char_buf[2] &= ~TT2$M_ANSICRT;
1433: cur_char_buf[2] &= ~TT2$M_AVO;
1434: cur_char_buf[2] &= ~TT2$M_DECCRT;
1435: cur_char_buf[2] &= ~TT2$M_DECCRT2;
1436: cur_char_buf[2] &= ~TT2$M_DRCS;
1437: cur_char_buf[2] &= ~TT2$M_EDIT;
1438: cur_char_buf[2] |= TT2$M_FALLBACK;
1439:
1440: status = sys$qiow(0, chan, IO$_SETMODE, 0, 0, 0, cur_char_buf, 12, 0, 0, 0, 0);
1441: if (status == SS$_BADPARAM) {
1442: /* terminal fallback utility not installed on system */
1443: cur_char_buf[2] &= ~TT2$M_FALLBACK;
1444: sys$qiow(0, chan, IO$_SETMODE, 0, 0, 0, cur_char_buf, 12, 0, 0, 0, 0);
1445: } else {
1446: if (status != SS$_NORMAL)
1447: lib$signal(status, 0, 0);
1448: }
1449: sys$dassgn(chan);
1450: }
1451:
1452: void term_mode_native()
1453: /* set terminal mode back to native */
1454: {
1455: int i;
1456: if (gpoutfile != stdout)
1457: return; /* don't modify if not stdout */
1458: sys$assign(&sysoutput_desc, &chan, 0, 0);
1459: sys$qiow(0, chan, IO$_SETMODE, 0, 0, 0, old_char_buf, 12, 0, 0, 0, 0);
1460: for (i = 0; i < 3; ++i)
1461: cur_char_buf[i] = old_char_buf[i];
1462: sys$dassgn(chan);
1463: }
1464:
1465: void term_pasthru()
1466: /* set terminal mode pasthru */
1467: {
1468: if (gpoutfile != stdout)
1469: return; /* don't modify if not stdout */
1470: sys$assign(&sysoutput_desc, &chan, 0, 0);
1471: cur_char_buf[2] |= TT2$M_PASTHRU;
1472: sys$qiow(0, chan, IO$_SETMODE, 0, 0, 0, cur_char_buf, 12, 0, 0, 0, 0);
1473: sys$dassgn(chan);
1474: }
1475:
1476: void term_nopasthru()
1477: /* set terminal mode nopasthru */
1478: {
1479: if (gpoutfile != stdout)
1480: return; /* don't modify if not stdout */
1481: sys$assign(&sysoutput_desc, &chan, 0, 0);
1482: cur_char_buf[2] &= ~TT2$M_PASTHRU;
1483: sys$qiow(0, chan, IO$_SETMODE, 0, 0, 0, cur_char_buf, 12, 0, 0, 0, 0);
1484: sys$dassgn(chan);
1485: }
1486:
1487: void fflush_binary()
1488: {
1489: typedef short int INT16; /* signed 16-bit integers */
1490: register INT16 k; /* loop index */
1491: if (gpoutfile != stdout) {
1492: /* Stupid VMS fflush() raises error and loses last data block
1493: unless it is full for a fixed-length record binary file.
1494: Pad it here with NULL characters. */
1495: for (k = (INT16) ((*gpoutfile)->_cnt); k > 0; --k)
1496: putc('\0', gpoutfile);
1497: fflush(gpoutfile);
1498: }
1499: }
1500: #endif /* VMS */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to term.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot