[BACK]Return to tek.trm CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / gnuplot / term

Annotation of OpenXM_contrib/gnuplot/term/tek.trm, Revision 1.1.1.2

1.1       maekawa     1: /*
1.1.1.2 ! maekawa     2:  * $Id: tek.trm,v 1.8 1998/12/14 18:41:23 lhecking Exp $
1.1       maekawa     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>