Annotation of OpenXM_contrib/gnuplot/term/tek.trm, Revision 1.1.1.1
1.1 maekawa 1: /*
2: * $Id: tek.trm,v 1.20 1998/04/14 00:18:07 drd Exp $
3: *
4: */
5:
6: /* GNUPLOT - tek.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: * tek40xx, bitgraph, kermit_color_tek40xx, kermit_mono_tek40xx, selanar
43: * ln03plus
44: *
45: * AUTHORS
46: * Colin Kelley, Thomas Williams, Russell Lang
47: *
48: * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
49: *
50: */
51:
52: /*
53: * Modified June 1995 Ian MacPhedran to support newterm format
54: */
55: #define TEK
56: #define CTEK
57: #define VTTEK
58: #define KERMIT
59: #define SELANAR
60: #define BITGRAPH
61:
62: #include "driver.h"
63:
64: #ifdef TERM_REGISTER
65: register_term(tek40)
66: #ifdef VTTEK
67: register_term(vttek)
68: #endif
69: #ifdef KERMIT
70: register_term(kc_tek40)
71: register_term(km_tek40)
72: #endif
73: #ifdef SELANAR
74: register_term(selanar)
75: #endif
76: #ifdef BITGRAPH
77: register_term(bitgraph)
78: #endif
79: #endif /* TERM_REGISTER */
80:
81: #ifdef TERM_PROTO
82: TERM_PUBLIC void TEK40init __PROTO((void));
83: TERM_PUBLIC void TEK40graphics __PROTO((void));
84: TERM_PUBLIC void TEK40text __PROTO((void));
85: TERM_PUBLIC void TEK40linetype __PROTO((int linetype));
86: TERM_PUBLIC void TEK40move __PROTO((unsigned int x, unsigned int y));
87: TERM_PUBLIC void TEK40vector __PROTO((unsigned int x, unsigned int y));
88: TERM_PUBLIC void TEK40put_text __PROTO((unsigned int x, unsigned int y, char str[]));
89: TERM_PUBLIC void TEK40reset __PROTO((void));
90: TERM_PUBLIC void BG_text __PROTO((void));
91: TERM_PUBLIC void BG_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
92: TERM_PUBLIC void KTEK40graphics __PROTO((void));
93: TERM_PUBLIC void KTEK40Ctext __PROTO((void));
94: TERM_PUBLIC void KTEK40Clinetype __PROTO((int linetype));
95: TERM_PUBLIC void KTEK40Mlinetype __PROTO((int linetype));
96: TERM_PUBLIC void KTEK40reset __PROTO((void));
97: TERM_PUBLIC void SEL_init __PROTO((void));
98: TERM_PUBLIC void SEL_graphics __PROTO((void));
99: TERM_PUBLIC void SEL_text __PROTO((void));
100: TERM_PUBLIC void SEL_reset __PROTO((void));
101: TERM_PUBLIC void VTTEK40init __PROTO((void));
102: TERM_PUBLIC void VTTEK40reset __PROTO((void));
103: TERM_PUBLIC void VTTEK40linetype __PROTO((int linetype));
104: TERM_PUBLIC void VTTEK40put_text __PROTO((unsigned int x, unsigned int y, char str[]));
105: TERM_PUBLIC void CTEK_linetype __PROTO((int linetype));
106: TERM_PUBLIC void CTEK_move __PROTO((unsigned int x, unsigned int y));
107: TERM_PUBLIC void CTEK_vector __PROTO((unsigned int x, unsigned int y));
108:
109: #endif /* TERM_PROTO */
110:
111: #ifndef TERM_PROTO_ONLY
112: #ifdef TERM_BODY
113:
114: #ifdef TEK
115:
116: #define TEK40XMAX 1024
117: #define TEK40YMAX 780
118:
119: #define TEK40XLAST (TEK40XMAX - 1)
120: #define TEK40YLAST (TEK40YMAX - 1)
121:
122: #define TEK40VCHAR 25
123: #define TEK40HCHAR 14
124: #define TEK40VTIC 11
125: #define TEK40HTIC 11
126:
127: #define HX 0x20 /* bit pattern to OR over 5-bit data */
128: #define HY 0x20
129: #define LX 0x40
130: #define LY 0x60
131:
132: #define LOWER5 31
133: #define UPPER5 (31<<5)
134:
135:
136: TERM_PUBLIC void TEK40init()
137: {
138: }
139:
140:
141: TERM_PUBLIC void TEK40graphics()
142: {
143: #ifdef VMS
144: term_pasthru();
145: #endif /* VMS */
146: fputs("\033\014", gpoutfile);
147: /* 1
148: 1. clear screen
149: */
150: (void) fflush(gpoutfile);
151: sleep(1);
152: /* sleep 1 second to allow screen time to clear on real
153: tektronix terminals */
154: }
155:
156: TERM_PUBLIC void TEK40text()
157: {
158: #ifdef VMS
159: (void) fflush(gpoutfile); /* finish the graphics */
160: #endif
161: TEK40move(0, 12);
162: fputs("\037", gpoutfile);
163: /* 1
164: 1. into alphanumerics
165: */
166: #ifdef VMS
167: term_nopasthru();
168: #endif /* VMS */
169: }
170:
171:
172: TERM_PUBLIC void TEK40linetype(linetype)
173: int linetype;
174: {
175: }
176:
177: TERM_PUBLIC void TEK40move(x, y)
178: unsigned int x, y;
179: {
180: (void) putc('\035', gpoutfile); /* into graphics */
181: TEK40vector(x, y);
182: }
183:
184:
185: TERM_PUBLIC void TEK40vector(x, y)
186: unsigned int x, y;
187: {
188: (void) putc((HY | (y & UPPER5) >> 5), gpoutfile);
189: (void) putc((LY | (y & LOWER5)), gpoutfile);
190: (void) putc((HX | (x & UPPER5) >> 5), gpoutfile);
191: (void) putc((LX | (x & LOWER5)), gpoutfile);
192: }
193:
194:
195: TERM_PUBLIC void TEK40put_text(x, y, str)
196: unsigned int x, y;
197: char str[];
198: {
199: TEK40move(x, y - 11);
200: fprintf(gpoutfile, "\037%s\n", str);
201: }
202:
203:
204: TERM_PUBLIC void TEK40reset()
205: {
206: }
207:
208: #endif /* TEK */
209:
210:
211:
212: /* thanks to dukecdu!evs (Ed Simpson) for the BBN BitGraph driver */
213:
214: #ifdef BITGRAPH
215:
216: #define BG_XMAX 768 /* width of plot area */
217: #define BG_YMAX 768 /* height of plot area */
218: #define BG_SCREEN_HEIGHT 1024 /* full screen height */
219:
220: #define BG_XLAST (BG_XMAX - 1)
221: #define BG_YLAST (BG_YMAX - 1)
222:
223: #define BG_VCHAR 16
224: #define BG_HCHAR 9
225: #define BG_VTIC 8
226: #define BG_HTIC 8
227:
228:
229: #define BG_init TEK40init
230:
231: #define BG_graphics TEK40graphics
232:
233:
234: #define BG_linetype TEK40linetype
235:
236: #define BG_move TEK40move
237:
238: #define BG_vector TEK40vector
239:
240:
241: TERM_PUBLIC void BG_text()
242: {
243: #ifdef VMS
244: (void) fflush(gpoutfile); /* finish the graphics */
245: #endif
246: BG_move(0, BG_SCREEN_HEIGHT - 2 * BG_VCHAR);
247: fputs("\037", gpoutfile);
248: /* 1
249: 1. into alphanumerics
250: */
251: }
252:
253:
254: TERM_PUBLIC void BG_put_text(x, y, str)
255: unsigned int x, y;
256: char str[];
257: {
258: BG_move(x, y - 11);
259: fprintf(gpoutfile, "\037%s\n", str);
260: }
261:
262:
263: #define BG_reset TEK40reset
264:
265: #endif /* BITGRAPH */
266:
267:
268: /* Color and Monochrome specials for the MS-DOS Kermit Tektronix Emulator
269: by Russell Lang, eln272v@monu1.cc.monash.oz */
270:
271: #ifdef KERMIT
272:
273: #define KTEK40HCHAR 13
274:
275: TERM_PUBLIC void KTEK40graphics()
276: {
277: #ifdef VMS
278: term_mode_tek();
279: term_pasthru();
280: #endif /* VMS */
281: fputs("\033\014", gpoutfile);
282: /* 1
283: 1. clear screen
284: */
285: /* kermit tektronix emulation doesn't need to wait */
286: }
287:
288: TERM_PUBLIC void KTEK40Ctext()
289: {
290: TEK40text();
291: KTEK40Clinetype(0); /* change to green */
292: #ifdef VMS
293: term_nopasthru();
294: #endif /* VMS */
295: }
296:
297: /* special color linetypes for MS-DOS Kermit v2.31 tektronix emulator */
298: /* 0 = normal, 1 = bright
299: foreground color (30-37) = 30 + colors
300: where colors are 1=red, 2=green, 4=blue */
301: static char *kermit_color[15] =
302: {"\033[0;37m", "\033[1;30m",
303: "\033[0;32m", "\033[0;36m", "\033[0;31m", "\033[0;35m",
304: "\033[1;34m", "\033[1;33m", "\033[1;31m", "\033[1;37m",
305: "\033[1;35m", "\033[1;32m", "\033[1;36m", "\033[0;34m",
306: "\033[0;33m"};
307:
308: TERM_PUBLIC void KTEK40Clinetype(linetype)
309: int linetype;
310: {
311: if (linetype >= 13)
312: linetype %= 13;
313: fprintf(gpoutfile, "%s", kermit_color[linetype + 2]);
314: }
315:
316:
317: /* linetypes for MS-DOS Kermit v2.30 tektronix emulator */
318: /* `=solid, a=fine dots, b=short dashes, c=dash dot,
319: d=long dash dot, e=dash dot dot */
320: static char *kerm_linetype = "`a`abcde";
321:
322: TERM_PUBLIC void KTEK40Mlinetype(linetype)
323: int linetype;
324: {
325: if (linetype >= 6)
326: linetype %= 6;
327: fprintf(gpoutfile, "\033%c", kerm_linetype[linetype + 2]);
328: }
329:
330: TERM_PUBLIC void KTEK40reset()
331: {
332: fputs("\030\n", gpoutfile); /* turn off Tek emulation */
333: #ifdef VMS
334: term_mode_native();
335: #endif /* VMS */
336: }
337:
338: #endif /* KERMIT */
339:
340:
341: /* thanks to sask!macphed (Geoff Coleman and Ian Macphedran) for the
342: Selanar driver */
343:
344: #ifdef SELANAR
345:
346: TERM_PUBLIC void SEL_init()
347: {
348: fputs("\033\062", gpoutfile);
349: /* 1
350: 1. set to ansi mode
351: */
352: }
353:
354:
355: TERM_PUBLIC void SEL_graphics()
356: {
357: fputs("\033[H\033[J\033\061\033\014", gpoutfile);
358: /* 1 2 3
359: 1. clear ANSI screen
360: 2. set to TEK mode
361: 3. clear screen
362: */
363: #ifdef VMS
364: term_pasthru();
365: #endif /* VMS */
366: }
367:
368:
369: TERM_PUBLIC void SEL_text()
370: {
371: #ifdef VMS
372: (void) fflush(gpoutfile); /* finish the graphics */
373: #endif
374: TEK40move(0, 12);
375: fputs("\033\062", gpoutfile);
376: /* 1
377: 1. into ANSI mode
378: */
379: #ifdef VMS
380: term_nopasthru();
381: #endif /* VMS */
382: }
383:
384: TERM_PUBLIC void SEL_reset()
385: {
386: fputs("\033\061\033\012\033\062\033[H\033[J", gpoutfile);
387: /* 1 2 3 4
388: 1 set tek mode
389: 2 clear screen
390: 3 set ansi mode
391: 4 clear screen
392: */
393: }
394:
395: #endif /* SELANAR */
396:
397: #ifdef VTTEK
398:
399: TERM_PUBLIC void VTTEK40init()
400: {
401: fputs("\033[?38h", gpoutfile);
402: fflush(gpoutfile);
403: sleep(1);
404: /* sleep 1 second to allow screen time to clear on some terminals */
405: #ifdef VMS
406: term_mode_tek();
407: #endif /* VMS */
408: }
409:
410: TERM_PUBLIC void VTTEK40reset()
411: {
412: fputs("\033[?38l", gpoutfile);
413: fflush(gpoutfile);
414: sleep(1);
415: /* sleep 1 second to allow screen time to clear on some terminals */
416: #ifdef VMS
417: term_mode_native();
418: #endif /* VMS */
419: }
420:
421: /* linetypes for VT-type terminals in tektronix emulator mode */
422: /* `=solid, a=fine dots, b=short dashes, c=dash dot,
423: d=long dash dot, h=bold solid, i=bold fine dots, j=bold short dashes,
424: k=bold dash dot, l=bold long dash dot */
425: static char *vt_linetype = "`a`abcdhijkl";
426: static int last_vt_linetype = 0;
427: TERM_PUBLIC void VTTEK40linetype(linetype)
428: int linetype;
429: {
430: if (linetype >= 10)
431: linetype %= 10;
432: fprintf(gpoutfile, "\033%c", vt_linetype[linetype + 2]);
433: last_vt_linetype = linetype;
434: }
435:
436: TERM_PUBLIC void VTTEK40put_text(x, y, str)
437: unsigned int x, y;
438: char str[];
439: {
440: int linetype;
441: linetype = last_vt_linetype;
442: VTTEK40linetype(0);
443: TEK40put_text(x, y, str);
444: VTTEK40linetype(linetype);
445: }
446:
447: #endif /* VTTEK */
448:
449: #ifdef LN03P
450:
451: TERM_PUBLIC void LN03Pinit()
452: {
453: fputs("\033[?38h", gpoutfile);
454: }
455:
456: TERM_PUBLIC void LN03Preset()
457: {
458: fputs("\033[?38l", gpoutfile);
459: }
460:
461: #endif /* LN03P */
462:
463:
464:
465: /* tek40xx (monochrome) with linetype support by Jay I. Choe */
466: #ifdef CTEK
467:
468: /*#define ABS(A) (((A)>=0)? (A):-(A))*/
469: #define SIGN(A) (((A) >= 0)? 1:-1)
470:
471: static void CT_solid_vector __PROTO((int x, int y));
472: static void CT_draw_vpoint __PROTO((int x, int y, int last));
473: static void CT_pattern_vector __PROTO((int x1, int y1));
474:
475: /* CT_lines are line types defined as bit pattern */
476: static unsigned long CT_lines[] =
477: {0xffffffff, /* solid line */
478: 0x000fffff, /* long dash */
479: 0x00ff00ff, /* short dash */
480: 0x00f00fff, /* dash-dot */
481: 0x00f07fff, /* long dash - dot */
482: 0x07070707,
483: 0x07ff07ff,
484: 0x070707ff};
485:
486: /* current line pattern */
487: static unsigned long *CT_pattern = &CT_lines[0];
488:
489: /* we need to keep track of tek cursor location */
490: static int CT_last_linetype = 0, CT_last_x, CT_last_y;
491:
492: TERM_PUBLIC void CTEK_linetype(linetype)
493: int linetype;
494: {
495: if (linetype < 0)
496: linetype = 0;
497: linetype %= (sizeof(CT_lines) / sizeof(unsigned long));
498: CT_pattern = &CT_lines[linetype];
499: CT_last_linetype = linetype;
500: }
501:
502: TERM_PUBLIC void CTEK_move(x, y)
503: unsigned int x;
504: unsigned int y;
505: {
506: TEK40move(x, y);
507: CT_last_x = x;
508: CT_last_y = y;
509: }
510:
511: static void CT_solid_vector(x, y)
512: int x;
513: int y;
514: {
515: TEK40vector(x, y);
516: CT_last_x = x;
517: CT_last_y = y;
518: }
519:
520: /*
521: simulate pixel draw using tek vector draw.
522: delays actual line drawing until maximum line segment is determined
523: (or first/last point is defined)
524: */
525: static int CT_penon = 0; /* is Pen on? */
526:
527: static void CT_draw_vpoint(x, y, last)
528: int x;
529: int y;
530: int last;
531: {
532: static int xx0, yy0, xx1, yy1;
533:
534: if ((*CT_pattern) & 1) {
535: if (CT_penon) { /* This point is a continuation of current line */
536: xx1 = x;
537: yy1 = y;
538: } else { /* beginning of new line */
539: xx0 = xx1 = x;
540: yy0 = yy1 = y;
541: CT_penon = 1;
542: }
543: *CT_pattern = ((*CT_pattern) >> 1) | 0x80000000; /* rotate the pattern */
544: if (last) { /* draw the line anyway if this is the last point */
545: TEK40move(xx0, yy0);
546: TEK40vector(xx1, yy1);
547: CT_penon = 0;
548: }
549: } else { /* do not draw this pixel */
550: if (CT_penon) { /* last line segment ended at the previous pixel. */
551: /* draw the line */
552: TEK40move(xx0, yy0);
553: TEK40vector(xx1, yy1);
554: CT_penon = 0;
555: }
556: *CT_pattern = (*CT_pattern) >> 1; /* rotate the current pattern */
557: }
558: }
559:
560: /*
561: draw vector line with pattern
562: */
563:
564: static void CT_pattern_vector(x1, y1)
565: int x1;
566: int y1;
567: {
568: int op; /* order parameter */
569: int x0 = CT_last_x;
570: int y0 = CT_last_y;
571: int dx = x1 - x0;
572: int dy = y1 - y0;
573: int ax = ABS(dx) << 1;
574: int ay = ABS(dy) << 1;
575: int sx = SIGN(dx);
576: int sy = SIGN(dy);
577:
578: if (ax >= ay) {
579: for (op = ay - (ax >> 1); x0 != x1; x0 += sx, op += ay) {
580: CT_draw_vpoint(x0, y0, 0);
581: if (op > 0 || (op == 0 && sx == 1)) {
582: op -= ax;
583: y0 += sy;
584: }
585: }
586: } else { /* ax < ay */
587: for (op = ax - (ay >> 1); y0 != y1; y0 += sy, op += ax) {
588: CT_draw_vpoint(x0, y0, 0);
589: if (op > 0 || (op == 0 && sy == 1)) {
590: op -= ay;
591: x0 += sx;
592: }
593: }
594: }
595: CT_draw_vpoint(x0, y0, 1); /* last point */
596: CT_last_x = x1;
597: CT_last_y = y1;
598: }
599:
600: TERM_PUBLIC void CTEK_vector(x, y)
601: unsigned int x;
602: unsigned int y;
603: {
604: if (CT_last_linetype <= 0)
605: CT_solid_vector(x, y);
606: else
607: CT_pattern_vector(x, y);
608: }
609:
610: #endif /* CTEK */
611: #endif /* TERM_BODY */
612:
613: #ifdef TERM_TABLE
614:
615: TERM_TABLE_START(tek40_driver)
616: #ifndef CTEK
617: "tek40xx", "Tektronix 4010 and others; most TEK emulators",
618: TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
619: TEK40VTIC, TEK40HTIC, options_null, TEK40init, TEK40reset,
620: TEK40text, null_scale, TEK40graphics, TEK40move, TEK40vector,
621: TEK40linetype, TEK40put_text, null_text_angle,
622: null_justify_text, line_and_point, do_arrow, set_font_null
623: #else
624: "tek40xx", "Tektronix 4010 and others; most TEK emulators",
625: TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
626: TEK40VTIC, TEK40HTIC, options_null, TEK40init, TEK40reset,
627: TEK40text, null_scale, TEK40graphics, CTEK_move, CTEK_vector,
628: CTEK_linetype, TEK40put_text, null_text_angle,
629: null_justify_text, line_and_point, do_arrow, set_font_null
630: #endif /* CTEK */
631: TERM_TABLE_END(tek40_driver)
632:
633: #undef LAST_TERM
634: #define LAST_TERM tek40_driver
635:
636: #ifdef VTTEK
637: TERM_TABLE_START(vttek_driver)
638: "vttek", "VT-like tek40xx terminal emulator",
639: TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
640: TEK40VTIC, TEK40HTIC, options_null, VTTEK40init, VTTEK40reset,
641: TEK40text, null_scale, TEK40graphics, TEK40move, TEK40vector,
642: VTTEK40linetype, VTTEK40put_text, null_text_angle,
643: null_justify_text, line_and_point, do_arrow, set_font_null
644: TERM_TABLE_END(vttek_driver)
645:
646: #undef LAST_TERM
647: #define LAST_TERM vttek_driver
648:
649: #endif /* VTTEK */
650:
651: #ifdef KERMIT
652: TERM_TABLE_START(kc_tek40_driver)
653: "kc_tek40xx", "MS-DOS Kermit Tek4010 terminal emulator - color",
654: TEK40XMAX, TEK40YMAX, TEK40VCHAR, KTEK40HCHAR,
655: TEK40VTIC, TEK40HTIC, options_null, TEK40init, KTEK40reset,
656: KTEK40Ctext, null_scale, KTEK40graphics, TEK40move, TEK40vector,
657: KTEK40Clinetype, TEK40put_text, null_text_angle,
658: null_justify_text, do_point, do_arrow, set_font_null
659: TERM_TABLE_END(kc_tek40_driver)
660:
661: #undef LAST_TERM
662: #define LAST_TERM kc_tek40_driver
663:
664: TERM_TABLE_START(km_tek40_driver)
665: "km_tek40xx", "MS-DOS Kermit Tek4010 terminal emulator - monochrome",
666: TEK40XMAX, TEK40YMAX, TEK40VCHAR, KTEK40HCHAR,
667: TEK40VTIC, TEK40HTIC, options_null, TEK40init, KTEK40reset,
668: TEK40text, null_scale, KTEK40graphics, TEK40move, TEK40vector,
669: KTEK40Mlinetype, TEK40put_text, null_text_angle,
670: null_justify_text, line_and_point, do_arrow, set_font_null
671: TERM_TABLE_END(km_tek40_driver)
672:
673: #undef LAST_TERM
674: #define LAST_TERM km_tek40_driver
675:
676: #endif /* KERMIT */
677:
678: #ifdef SELANAR
679: TERM_TABLE_START(selanar_driver)
680: "selanar", "Selanar",
681: TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
682: TEK40VTIC, TEK40HTIC, options_null, SEL_init, SEL_reset,
683: SEL_text, null_scale, SEL_graphics, TEK40move, TEK40vector,
684: TEK40linetype, TEK40put_text, null_text_angle,
685: null_justify_text, line_and_point, do_arrow, set_font_null
686: TERM_TABLE_END(selanar_driver)
687:
688: #undef LAST_TERM
689: #define LAST_TERM selanar_driver
690:
691: #endif /* SELANAR */
692:
693: #ifdef BITGRAPH
694: TERM_TABLE_START(bitgraph_driver)
695: "bitgraph", "BBN Bitgraph Terminal",
696: BG_XMAX, BG_YMAX, BG_VCHAR, BG_HCHAR,
697: BG_VTIC, BG_HTIC, options_null, BG_init, BG_reset,
698: BG_text, null_scale, BG_graphics, BG_move, BG_vector,
699: BG_linetype, BG_put_text, null_text_angle,
700: null_justify_text, line_and_point, do_arrow, set_font_null
701: TERM_TABLE_END(bitgraph_driver)
702:
703: #undef LAST_TERM
704: #define LAST_TERM bitgraph_driver
705:
706: #endif /* BITGRAPH */
707:
708: #endif /* TERM_TABLE */
709:
710: #endif /* TERM_PROTO_ONLY */
711:
712: #ifdef TERM_HELP
713: START_HELP(tek40)
714: "1 tek40",
715: "?commands set terminal tek40xx",
716: "?set terminal tek40xx",
717: "?set term tek40xx",
718: "?terminal tek40xx",
719: "?terminal tek40xx",
720: "?tek40",
721: "?commands set terminal vttek",
722: "?set terminal vttek",
723: "?set term vttek",
724: "?terminal vttek",
725: "?term vttek",
726: "?vttek",
727: "?commands set terminal kc-tek40xx",
728: "?set terminal kc-tek40xx",
729: "?set term kc-tek40xx",
730: "?terminal kc-tek40xx",
731: "?term kc-tek40xx",
732: "?kc-tek40xx",
733: "?commands set terminal km-tek40xx",
734: "?set terminal km-tek40xx",
735: "?set term km-tek40xx",
736: "?terminal km-tek40xx",
737: "?term km-tek40xx",
738: "?km-tek40xx",
739: "?commands set terminal selanar",
740: "?set terminal selanar",
741: "?set term selanar",
742: "?terminal selanar",
743: "?term selanar",
744: "?selanar",
745: "?commands set terminal bitgraph",
746: "?set terminal bitgraph",
747: "?set term bitgraph",
748: "?terminal bitgraph",
749: "?term bitgraph",
750: "?bitgraph",
751: " This family of terminal drivers supports a variety of VT-like terminals.",
752: " `tek40xx` supports Tektronix 4010 and others as well as most TEK emulators;",
753: " `vttek` supports VT-like tek40xx terminal emulators; `kc-tek40xx` supports",
754: " MS-DOS Kermit Tek4010 terminal emulators in color: `km-tek40xx` supports them",
755: " in monochrome; `selanar` supports Selanar graphics; and `bitgraph` supports",
756: " BBN Bitgraph terminals. None have any options."
757: END_HELP(tek40)
758: #endif /* TERM_HELP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tek.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term