Return to charproc.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm

Annotation of researchv9/X11/src/X.V11R1/clients/xterm/charproc.c, revision 1.1

1.1     ! root        1: 
        !             2: /*
        !             3:  *     $Source: /orpheus/u1/X11/clients/xterm/RCS/charproc.c,v $
        !             4:  *     $Header: charproc.c,v 1.36 87/09/09 16:40:30 swick Exp $
        !             5:  */
        !             6: 
        !             7: 
        !             8: #include <X11/copyright.h>
        !             9: 
        !            10: /*
        !            11:  * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
        !            12:  *
        !            13:  *                         All Rights Reserved
        !            14:  *
        !            15:  * Permission to use, copy, modify, and distribute this software and its
        !            16:  * documentation for any purpose and without fee is hereby granted,
        !            17:  * provided that the above copyright notice appear in all copies and that
        !            18:  * both that copyright notice and this permission notice appear in
        !            19:  * supporting documentation, and that the name of Digital Equipment
        !            20:  * Corporation not be used in advertising or publicity pertaining to
        !            21:  * distribution of the software without specific, written prior permission.
        !            22:  *
        !            23:  *
        !            24:  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
        !            25:  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
        !            26:  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
        !            27:  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
        !            28:  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
        !            29:  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
        !            30:  * SOFTWARE.
        !            31:  */
        !            32: 
        !            33: 
        !            34: /* charproc.c */
        !            35: 
        !            36: #include <stdio.h>
        !            37: #include <sgtty.h>
        !            38: #include <ctype.h>
        !            39: #include <errno.h>
        !            40: #include <setjmp.h>
        !            41: #include <sys/ioctl.h>
        !            42: #include <sys/time.h>
        !            43: #include <X11/Xlib.h>
        !            44: #include <X11/Xutil.h>
        !            45: #include <X11/Intrinsic.h>
        !            46: #include <X11/Xatom.h>
        !            47: #include "ptyx.h"
        !            48: #include "VTparse.h"
        !            49: #include "data.h"
        !            50: #include "error.h"
        !            51: #ifdef MODEMENU
        !            52: #include "menu.h"
        !            53: #endif MODEMENU
        !            54: 
        !            55: extern void exit(), bcopy();
        !            56: 
        !            57: #define        DEFAULT         -1
        !            58: #define        TEXT_BUF_SIZE   256
        !            59: #define TRACKTIMESEC   4L
        !            60: #define TRACKTIMEUSEC  0L
        !            61: 
        !            62: #define        doinput()               (bcnt-- > 0 ? *bptr++ : in_put())
        !            63: 
        !            64: #ifndef lint
        !            65: static char rcs_id[] = "$Header: charproc.c,v 1.36 87/09/09 16:40:30 swick Exp $";
        !            66: #endif lint
        !            67: 
        !            68: static long arg;
        !            69: static int nparam;
        !            70: static ANSI reply;
        !            71: static int param[NPARAM];
        !            72: 
        !            73: static unsigned long ctotal;
        !            74: static unsigned long ntotal;
        !            75: static jmp_buf vtjmpbuf;
        !            76: 
        !            77: extern XrmNameList nameList;
        !            78: extern XrmClassList classList;
        !            79: 
        !            80: extern int groundtable[];
        !            81: extern int csitable[];
        !            82: extern int dectable[];
        !            83: extern int eigtable[];
        !            84: extern int esctable[];
        !            85: extern int iestable[];
        !            86: extern int igntable[];
        !            87: extern int scrtable[];
        !            88: extern int scstable[];
        !            89: 
        !            90: 
        !            91: /* event handlers */
        !            92: extern XtEventReturnCode HandleKeyPressed();
        !            93: extern XtEventReturnCode EventDoNothing();
        !            94: extern XtEventReturnCode HandleEnterWindow();
        !            95: extern XtEventReturnCode HandleLeaveWindow();
        !            96: extern XtEventReturnCode HandleFocusChange();
        !            97: extern XtEventReturnCode VTButtonPressed();
        !            98: extern XtEventReturnCode VTMouseMoved();
        !            99: extern XtEventReturnCode VTButtonReleased();
        !           100: 
        !           101: 
        !           102: VTparse()
        !           103: {
        !           104:        register TScreen *screen = &term.screen;
        !           105:        register int *parsestate = groundtable;
        !           106:        register int c;
        !           107:        register char *cp;
        !           108:        register int row, col, top, bot, scstype;
        !           109:        extern int bitset(), bitclr(), finput(), TrackMouse();
        !           110: 
        !           111:        if(setjmp(vtjmpbuf))
        !           112:                parsestate = groundtable;
        !           113:        for( ; ; )
        !           114:                switch(parsestate[c = doinput()]) {
        !           115:                 case CASE_GROUND_STATE:
        !           116:                        /* exit ignore mode */
        !           117:                        parsestate = groundtable;
        !           118:                        break;
        !           119: 
        !           120:                 case CASE_IGNORE_STATE:
        !           121:                        /* Ies: ignore anything else */
        !           122:                        parsestate = igntable;
        !           123:                        break;
        !           124: 
        !           125:                 case CASE_IGNORE_ESC:
        !           126:                        /* Ign: escape */
        !           127:                        parsestate = iestable;
        !           128:                        break;
        !           129: 
        !           130:                 case CASE_IGNORE:
        !           131:                        /* Ignore character */
        !           132:                        break;
        !           133: 
        !           134:                 case CASE_BELL:
        !           135:                        /* bell */
        !           136:                        Bell();
        !           137:                        break;
        !           138: 
        !           139:                 case CASE_BS:
        !           140:                        /* backspace */
        !           141:                        CursorBack(screen, 1);
        !           142:                        break;
        !           143: 
        !           144:                 case CASE_CR:
        !           145:                        /* carriage return */
        !           146:                        CarriageReturn(screen);
        !           147:                        break;
        !           148: 
        !           149:                 case CASE_ESC:
        !           150:                        /* escape */
        !           151:                        parsestate = esctable;
        !           152:                        break;
        !           153: 
        !           154:                 case CASE_VMOT:
        !           155:                        /*
        !           156:                         * form feed, line feed, vertical tab
        !           157:                         */
        !           158:                        Index(screen, 1);
        !           159:                        if (term.flags & LINEFEED)
        !           160:                                CarriageReturn(screen);
        !           161:                        if(screen->display->qlen > 0 ||
        !           162:                         (ioctl(screen->display->fd, FIONREAD, (char *) &arg), arg) > 0)
        !           163:                                xevents();
        !           164:                        break;
        !           165: 
        !           166:                 case CASE_TAB:
        !           167:                        /* tab */
        !           168:                        screen->cur_col = TabNext(term.tabs, screen->cur_col);
        !           169:                        if (screen->cur_col > screen->max_col)
        !           170:                                screen->cur_col = screen->max_col;
        !           171:                        break;
        !           172: 
        !           173:                 case CASE_SI:
        !           174:                        screen->curgl = 0;
        !           175:                        break;
        !           176: 
        !           177:                 case CASE_SO:
        !           178:                        screen->curgl = 1;
        !           179:                        break;
        !           180: 
        !           181:                 case CASE_SCR_STATE:
        !           182:                        /* enter scr state */
        !           183:                        parsestate = scrtable;
        !           184:                        break;
        !           185: 
        !           186:                 case CASE_SCS0_STATE:
        !           187:                        /* enter scs state 0 */
        !           188:                        scstype = 0;
        !           189:                        parsestate = scstable;
        !           190:                        break;
        !           191: 
        !           192:                 case CASE_SCS1_STATE:
        !           193:                        /* enter scs state 1 */
        !           194:                        scstype = 1;
        !           195:                        parsestate = scstable;
        !           196:                        break;
        !           197: 
        !           198:                 case CASE_SCS2_STATE:
        !           199:                        /* enter scs state 2 */
        !           200:                        scstype = 2;
        !           201:                        parsestate = scstable;
        !           202:                        break;
        !           203: 
        !           204:                 case CASE_SCS3_STATE:
        !           205:                        /* enter scs state 3 */
        !           206:                        scstype = 3;
        !           207:                        parsestate = scstable;
        !           208:                        break;
        !           209: 
        !           210:                 case CASE_ESC_IGNORE:
        !           211:                        /* unknown escape sequence */
        !           212:                        parsestate = eigtable;
        !           213:                        break;
        !           214: 
        !           215:                 case CASE_ESC_DIGIT:
        !           216:                        /* digit in csi or dec mode */
        !           217:                        if((row = param[nparam - 1]) == DEFAULT)
        !           218:                                row = 0;
        !           219:                        param[nparam - 1] = 10 * row + (c - '0');
        !           220:                        break;
        !           221: 
        !           222:                 case CASE_ESC_SEMI:
        !           223:                        /* semicolon in csi or dec mode */
        !           224:                        param[nparam++] = DEFAULT;
        !           225:                        break;
        !           226: 
        !           227:                 case CASE_DEC_STATE:
        !           228:                        /* enter dec mode */
        !           229:                        parsestate = dectable;
        !           230:                        break;
        !           231: 
        !           232:                 case CASE_ICH:
        !           233:                        /* ICH */
        !           234:                        if((c = param[0]) < 1)
        !           235:                                c = 1;
        !           236:                        InsertChar(screen, c);
        !           237:                        parsestate = groundtable;
        !           238:                        break;
        !           239: 
        !           240:                 case CASE_CUU:
        !           241:                        /* CUU */
        !           242:                        if((c = param[0]) < 1)
        !           243:                                c = 1;
        !           244:                        CursorUp(screen, c);
        !           245:                        parsestate = groundtable;
        !           246:                        break;
        !           247: 
        !           248:                 case CASE_CUD:
        !           249:                        /* CUD */
        !           250:                        if((c = param[0]) < 1)
        !           251:                                c = 1;
        !           252:                        CursorDown(screen, c);
        !           253:                        parsestate = groundtable;
        !           254:                        break;
        !           255: 
        !           256:                 case CASE_CUF:
        !           257:                        /* CUF */
        !           258:                        if((c = param[0]) < 1)
        !           259:                                c = 1;
        !           260:                        CursorForward(screen, c);
        !           261:                        parsestate = groundtable;
        !           262:                        break;
        !           263: 
        !           264:                 case CASE_CUB:
        !           265:                        /* CUB */
        !           266:                        if((c = param[0]) < 1)
        !           267:                                c = 1;
        !           268:                        CursorBack(screen, c);
        !           269:                        parsestate = groundtable;
        !           270:                        break;
        !           271: 
        !           272:                 case CASE_CUP:
        !           273:                        /* CUP | HVP */
        !           274:                        if((row = param[0]) < 1)
        !           275:                                row = 1;
        !           276:                        if(nparam < 2 || (col = param[1]) < 1)
        !           277:                                col = 1;
        !           278:                        CursorSet(screen, row-1, col-1, term.flags);
        !           279:                        parsestate = groundtable;
        !           280:                        break;
        !           281: 
        !           282:                 case CASE_ED:
        !           283:                        /* ED */
        !           284:                        switch (param[0]) {
        !           285:                         case DEFAULT:
        !           286:                         case 0:
        !           287:                                ClearBelow(screen);
        !           288:                                break;
        !           289: 
        !           290:                         case 1:
        !           291:                                ClearAbove(screen);
        !           292:                                break;
        !           293: 
        !           294:                         case 2:
        !           295:                                ClearScreen(screen);
        !           296:                                break;
        !           297:                        }
        !           298:                        parsestate = groundtable;
        !           299:                        break;
        !           300: 
        !           301:                 case CASE_EL:
        !           302:                        /* EL */
        !           303:                        switch (param[0]) {
        !           304:                         case DEFAULT:
        !           305:                         case 0:
        !           306:                                ClearRight(screen);
        !           307:                                break;
        !           308:                         case 1:
        !           309:                                ClearLeft(screen);
        !           310:                                break;
        !           311:                         case 2:
        !           312:                                ClearLine(screen);
        !           313:                                break;
        !           314:                        }
        !           315:                        parsestate = groundtable;
        !           316:                        break;
        !           317: 
        !           318:                 case CASE_IL:
        !           319:                        /* IL */
        !           320:                        if((c = param[0]) < 1)
        !           321:                                c = 1;
        !           322:                        InsertLine(screen, c);
        !           323:                        parsestate = groundtable;
        !           324:                        break;
        !           325: 
        !           326:                 case CASE_DL:
        !           327:                        /* DL */
        !           328:                        if((c = param[0]) < 1)
        !           329:                                c = 1;
        !           330:                        DeleteLine(screen, c);
        !           331:                        parsestate = groundtable;
        !           332:                        break;
        !           333: 
        !           334:                 case CASE_DCH:
        !           335:                        /* DCH */
        !           336:                        if((c = param[0]) < 1)
        !           337:                                c = 1;
        !           338:                        DeleteChar(screen, c);
        !           339:                        parsestate = groundtable;
        !           340:                        break;
        !           341: 
        !           342:                 case CASE_TRACK_MOUSE:
        !           343:                        /* Track mouse as long as in window and between
        !           344:                           specified rows */
        !           345:                        TrackMouse(param[0], param[2]-1, param[1]-1,
        !           346:                         param[3]-1, param[4]-2);
        !           347:                        break;
        !           348: 
        !           349:                 case CASE_DA1:
        !           350:                        /* DA1 */
        !           351:                        if (param[0] <= 0) {    /* less than means DEFAULT */
        !           352:                                reply.a_type   = CSI;
        !           353:                                reply.a_pintro = '?';
        !           354:                                reply.a_nparam = 2;
        !           355:                                reply.a_param[0] = 1;           /* VT102 */
        !           356:                                reply.a_param[1] = 2;           /* VT102 */
        !           357:                                reply.a_inters = 0;
        !           358:                                reply.a_final  = 'c';
        !           359:                                unparseseq(&reply, screen->respond);
        !           360:                        }
        !           361:                        parsestate = groundtable;
        !           362:                        break;
        !           363: 
        !           364:                 case CASE_TBC:
        !           365:                        /* TBC */
        !           366:                        if ((c = param[0]) <= 0) /* less than means default */
        !           367:                                TabClear(term.tabs, screen->cur_col);
        !           368:                        else if (c == 3)
        !           369:                                TabZonk(term.tabs);
        !           370:                        parsestate = groundtable;
        !           371:                        break;
        !           372: 
        !           373:                 case CASE_SET:
        !           374:                        /* SET */
        !           375:                        modes(&term, bitset);
        !           376:                        parsestate = groundtable;
        !           377:                        break;
        !           378: 
        !           379:                 case CASE_RST:
        !           380:                        /* RST */
        !           381:                        modes(&term, bitclr);
        !           382:                        parsestate = groundtable;
        !           383:                        break;
        !           384: 
        !           385:                 case CASE_SGR:
        !           386:                        /* SGR */
        !           387:                        for (c=0; c<nparam; ++c) {
        !           388:                                switch (param[c]) {
        !           389:                                 case DEFAULT:
        !           390:                                 case 0:
        !           391:                                        term.flags &= ~(INVERSE|BOLD|UNDERLINE);
        !           392:                                        break;
        !           393:                                 case 1:
        !           394:                                 case 5:        /* Blink, really.       */
        !           395:                                        term.flags |= BOLD;
        !           396:                                        break;
        !           397:                                 case 4:        /* Underscore           */
        !           398:                                        term.flags |= UNDERLINE;
        !           399:                                        break;
        !           400:                                 case 7:
        !           401:                                        term.flags |= INVERSE;
        !           402:                                }
        !           403:                        }
        !           404:                        parsestate = groundtable;
        !           405:                        break;
        !           406: 
        !           407:                 case CASE_CPR:
        !           408:                        /* CPR */
        !           409:                        if ((c = param[0]) == 5) {
        !           410:                                reply.a_type = CSI;
        !           411:                                reply.a_pintro = 0;
        !           412:                                reply.a_nparam = 1;
        !           413:                                reply.a_param[0] = 0;
        !           414:                                reply.a_inters = 0;
        !           415:                                reply.a_final  = 'n';
        !           416:                                unparseseq(&reply, screen->respond);
        !           417:                        } else if (c == 6) {
        !           418:                                reply.a_type = CSI;
        !           419:                                reply.a_pintro = 0;
        !           420:                                reply.a_nparam = 2;
        !           421:                                reply.a_param[0] = screen->cur_row+1;
        !           422:                                reply.a_param[1] = screen->cur_col+1;
        !           423:                                reply.a_inters = 0;
        !           424:                                reply.a_final  = 'R';
        !           425:                                unparseseq(&reply, screen->respond);
        !           426:                        }
        !           427:                        parsestate = groundtable;
        !           428:                        break;
        !           429: 
        !           430:                 case CASE_DECSTBM:
        !           431:                        /* DECSTBM */
        !           432:                        if((top = param[0]) < 1)
        !           433:                                top = 1;
        !           434:                        if(nparam < 2 || (bot = param[1]) == DEFAULT
        !           435:                           || bot > screen->max_row + 1
        !           436:                           || bot == 0)
        !           437:                                bot = screen->max_row+1;
        !           438:                        if (bot > top) {
        !           439:                                if(screen->scroll_amt)
        !           440:                                        FlushScroll(screen);
        !           441:                                screen->top_marg = top-1;
        !           442:                                screen->bot_marg = bot-1;
        !           443:                                CursorSet(screen, 0, 0, term.flags);
        !           444:                        }
        !           445:                        parsestate = groundtable;
        !           446:                        break;
        !           447: 
        !           448:                 case CASE_DECREQTPARM:
        !           449:                        /* DECREQTPARM */
        !           450:                        if ((c = param[0]) == DEFAULT)
        !           451:                                c = 0;
        !           452:                        if (c == 0 || c == 1) {
        !           453:                                reply.a_type = CSI;
        !           454:                                reply.a_pintro = 0;
        !           455:                                reply.a_nparam = 7;
        !           456:                                reply.a_param[0] = c + 2;
        !           457:                                reply.a_param[1] = 1;   /* no parity */
        !           458:                                reply.a_param[2] = 1;   /* eight bits */
        !           459:                                reply.a_param[3] = 112; /* transmit 9600 baud */
        !           460:                                reply.a_param[4] = 112; /* receive 9600 baud */
        !           461:                                reply.a_param[5] = 1;   /* clock multiplier ? */
        !           462:                                reply.a_param[6] = 0;   /* STP flags ? */
        !           463:                                reply.a_inters = 0;
        !           464:                                reply.a_final  = 'x';
        !           465:                                unparseseq(&reply, screen->respond);
        !           466:                        }
        !           467:                        parsestate = groundtable;
        !           468:                        break;
        !           469: 
        !           470:                 case CASE_DECSET:
        !           471:                        /* DECSET */
        !           472:                        dpmodes(&term, bitset);
        !           473:                        parsestate = groundtable;
        !           474:                        if(screen->TekEmu)
        !           475:                                return;
        !           476:                        break;
        !           477: 
        !           478:                 case CASE_DECRST:
        !           479:                        /* DECRST */
        !           480:                        dpmodes(&term, bitclr);
        !           481:                        parsestate = groundtable;
        !           482:                        break;
        !           483: 
        !           484:                 case CASE_DECALN:
        !           485:                        /* DECALN */
        !           486:                        if(screen->cursor_state)
        !           487:                                HideCursor();
        !           488:                        for(row = screen->max_row ; row >= 0 ; row--) {
        !           489:                                bzero(screen->buf[2 * row + 1],
        !           490:                                 col = screen->max_col + 1);
        !           491:                                for(cp = screen->buf[2 * row] ; col > 0 ; col--)
        !           492:                                        *cp++ = 'E';
        !           493:                        }
        !           494:                        ScrnRefresh(screen, 0, 0, screen->max_row + 1,
        !           495:                         screen->max_col + 1);
        !           496:                        parsestate = groundtable;
        !           497:                        break;
        !           498: 
        !           499:                 case CASE_GSETS:
        !           500:                        screen->gsets[scstype] = c;
        !           501:                        parsestate = groundtable;
        !           502:                        break;
        !           503: 
        !           504:                 case CASE_DECSC:
        !           505:                        /* DECSC */
        !           506:                        CursorSave(&term, &screen->sc);
        !           507:                        parsestate = groundtable;
        !           508:                        break;
        !           509: 
        !           510:                 case CASE_DECRC:
        !           511:                        /* DECRC */
        !           512:                        CursorRestore(&term, &screen->sc);
        !           513:                        parsestate = groundtable;
        !           514:                        break;
        !           515: 
        !           516:                 case CASE_DECKPAM:
        !           517:                        /* DECKPAM */
        !           518:                        term.keyboard.flags |= KYPD_APL;
        !           519:                        parsestate = groundtable;
        !           520:                        break;
        !           521: 
        !           522:                 case CASE_DECKPNM:
        !           523:                        /* DECKPNM */
        !           524:                        term.keyboard.flags &= ~KYPD_APL;
        !           525:                        parsestate = groundtable;
        !           526:                        break;
        !           527: 
        !           528:                 case CASE_IND:
        !           529:                        /* IND */
        !           530:                        Index(screen, 1);
        !           531:                        if(screen->display->qlen > 0 ||
        !           532:                         (ioctl(screen->display->fd, FIONREAD, (char *)&arg), arg) > 0)
        !           533:                                xevents();
        !           534:                        parsestate = groundtable;
        !           535:                        break;
        !           536: 
        !           537:                 case CASE_NEL:
        !           538:                        /* NEL */
        !           539:                        Index(screen, 1);
        !           540:                        CarriageReturn(screen);
        !           541:                        if(screen->display->qlen > 0 ||
        !           542:                         (ioctl(screen->display->fd, FIONREAD, (char *)&arg), arg) > 0)
        !           543:                                xevents();
        !           544:                        parsestate = groundtable;
        !           545:                        break;
        !           546: 
        !           547:                 case CASE_HTS:
        !           548:                        /* HTS */
        !           549:                        TabSet(term.tabs, screen->cur_col);
        !           550:                        parsestate = groundtable;
        !           551:                        break;
        !           552: 
        !           553:                 case CASE_RI:
        !           554:                        /* RI */
        !           555:                        RevIndex(screen, 1);
        !           556:                        parsestate = groundtable;
        !           557:                        break;
        !           558: 
        !           559:                 case CASE_SS2:
        !           560:                        /* SS2 */
        !           561:                        screen->curss = 2;
        !           562:                        parsestate = groundtable;
        !           563:                        break;
        !           564: 
        !           565:                 case CASE_SS3:
        !           566:                        /* SS3 */
        !           567:                        screen->curss = 3;
        !           568:                        parsestate = groundtable;
        !           569:                        break;
        !           570: 
        !           571:                 case CASE_CSI_STATE:
        !           572:                        /* enter csi state */
        !           573:                        nparam = 1;
        !           574:                        param[0] = DEFAULT;
        !           575:                        parsestate = csitable;
        !           576:                        break;
        !           577: 
        !           578:                 case CASE_OSC:
        !           579:                        /* do osc escapes */
        !           580:                        do_osc(finput);
        !           581:                        parsestate = groundtable;
        !           582:                        break;
        !           583: 
        !           584:                 case CASE_RIS:
        !           585:                        /* RIS */
        !           586:                        VTReset(TRUE);
        !           587:                        parsestate = groundtable;
        !           588:                        break;
        !           589: 
        !           590:                 case CASE_LS2:
        !           591:                        /* LS2 */
        !           592:                        screen->curgl = 2;
        !           593:                        parsestate = groundtable;
        !           594:                        break;
        !           595: 
        !           596:                 case CASE_LS3:
        !           597:                        /* LS3 */
        !           598:                        screen->curgl = 3;
        !           599:                        parsestate = groundtable;
        !           600:                        break;
        !           601: 
        !           602:                 case CASE_LS3R:
        !           603:                        /* LS3R */
        !           604:                        screen->curgr = 3;
        !           605:                        parsestate = groundtable;
        !           606:                        break;
        !           607: 
        !           608:                 case CASE_LS2R:
        !           609:                        /* LS2R */
        !           610:                        screen->curgr = 2;
        !           611:                        parsestate = groundtable;
        !           612:                        break;
        !           613: 
        !           614:                 case CASE_LS1R:
        !           615:                        /* LS1R */
        !           616:                        screen->curgr = 1;
        !           617:                        parsestate = groundtable;
        !           618:                        break;
        !           619: 
        !           620:                 case CASE_XTERM_SAVE:
        !           621:                        savemodes(&term);
        !           622:                        parsestate = groundtable;
        !           623:                        break;
        !           624: 
        !           625:                 case CASE_XTERM_RESTORE:
        !           626:                        restoremodes(&term);
        !           627:                        parsestate = groundtable;
        !           628:                        break;
        !           629: 
        !           630:                 case CASE_PRINT:
        !           631:                        /* printable characters */
        !           632:                        top = bcnt > TEXT_BUF_SIZE ? TEXT_BUF_SIZE : bcnt;
        !           633:                        cp = bptr;
        !           634:                        *--bptr = c;
        !           635:                        while(top > 0 && isprint(*cp)) {
        !           636:                                top--;
        !           637:                                bcnt--;
        !           638:                                cp++;
        !           639:                        }
        !           640:                        if(screen->curss) {
        !           641:                                dotext(screen, term.flags,
        !           642:                                 screen->gsets[screen->curss], bptr, bptr + 1);
        !           643:                                screen->curss = 0;
        !           644:                                bptr++;
        !           645:                        }
        !           646:                        if(bptr < cp)
        !           647:                                dotext(screen, term.flags,
        !           648:                                 screen->gsets[screen->curgl], bptr, cp);
        !           649:                        bptr = cp;
        !           650:                        break;
        !           651:                }
        !           652: }
        !           653: 
        !           654: finput()
        !           655: {
        !           656:        return(doinput());
        !           657: }
        !           658: 
        !           659: static int select_mask;
        !           660: static int write_mask;
        !           661: 
        !           662: static char v_buffer[4096];
        !           663: static char *v_bufstr;
        !           664: static char *v_bufptr;
        !           665: static char *v_bufend;
        !           666: #define        ptymask()       (v_bufptr > v_bufstr ? pty_mask : 0)
        !           667: 
        !           668: v_write(f, d, l)
        !           669: int f;
        !           670: char *d;
        !           671: int l;
        !           672: {
        !           673:        int r;
        !           674:        int c = l;
        !           675: 
        !           676:        if (!v_bufstr) {
        !           677:                v_bufstr = v_buffer;
        !           678:                v_bufptr = v_buffer;
        !           679:                v_bufend = &v_buffer[4096];
        !           680:        }
        !           681: 
        !           682: 
        !           683:        if ((1 << f) != pty_mask)
        !           684:                return(write(f, d, l));
        !           685: 
        !           686:        if (v_bufptr > v_bufstr) {
        !           687:                if (l) {
        !           688:                        if (v_bufend > v_bufptr + l) {
        !           689:                                bcopy(d, v_bufptr, l);
        !           690:                                v_bufptr += l;
        !           691:                        } else {
        !           692:                                if (v_bufstr != v_buffer) {
        !           693:                                        bcopy(v_bufstr, v_buffer,
        !           694:                                              v_bufptr - v_bufstr);
        !           695:                                        v_bufptr -= v_bufstr - v_buffer;
        !           696:                                        v_bufstr = v_buffer;
        !           697:                                }
        !           698:                                if (v_bufend > v_bufptr + l) {
        !           699:                                        bcopy(d, v_bufptr, l);
        !           700:                                        v_bufptr += l;
        !           701:                                } else if (v_bufptr < v_bufend) {
        !           702:                                        fprintf(stderr, "Out of buffer space\n");
        !           703:                                        c = v_bufend - v_bufptr;
        !           704:                                        bcopy(d, v_bufptr, c);
        !           705:                                        v_bufptr = v_bufend;
        !           706:                                } else {
        !           707:                                        fprintf(stderr, "Out of buffer space\n");
        !           708:                                        c = 0;
        !           709:                                }
        !           710:                        }
        !           711:                }
        !           712:                if (v_bufptr > v_bufstr) {
        !           713:                        if ((r = write(f, v_bufstr, v_bufptr - v_bufstr)) <= 0)
        !           714:                                return(r);
        !           715:                        if ((v_bufstr += r) >= v_bufptr)
        !           716:                                v_bufstr = v_bufptr = v_buffer;
        !           717:                }
        !           718:        } else if (l) {
        !           719:                if ((r = write(f, d, l)) < 0) {
        !           720:                        if (errno == EWOULDBLOCK)
        !           721:                                r = 0;
        !           722:                        else if (errno == EINTR)
        !           723:                                r = 0;
        !           724:                        else
        !           725:                                return(r);
        !           726:                }
        !           727:                if (l - r) {
        !           728:                        if (l - r > v_bufend - v_buffer) {
        !           729:                                fprintf(stderr, "Truncating to %d\n",
        !           730:                                                v_bufend - v_buffer);
        !           731:                                l = (v_bufend - v_buffer) + r;
        !           732:                        }
        !           733:                        bcopy(d + r, v_buffer, l - r);
        !           734:                        v_bufstr = v_buffer;
        !           735:                        v_bufptr = v_buffer + (l - r);
        !           736:                }
        !           737:        }
        !           738:        return(c);
        !           739: }
        !           740: 
        !           741: in_put()
        !           742: {
        !           743:        register TScreen *screen = &term.screen;
        !           744:        register char *cp;
        !           745:        register int i;
        !           746:        static struct timeval trackTimeOut;
        !           747: 
        !           748:        select_mask = pty_mask; /* force initial read */
        !           749:        for( ; ; ) {
        !           750:                if((select_mask & pty_mask) && (eventMode == NORMAL)) {
        !           751:                        if(screen->logging)
        !           752:                                FlushLog(screen);
        !           753:                        if((bcnt = read(screen->respond, bptr = buffer,
        !           754:                         BUF_SIZE)) < 0) {
        !           755:                                if(errno == EIO && am_slave)
        !           756:                                        exit(0);
        !           757:                                else if(errno != EWOULDBLOCK)
        !           758:                                        Panic(
        !           759:                                 "input: read returned unexpected error (%d)\n",
        !           760:                                         errno);
        !           761:                        } else if(bcnt == 0)
        !           762:                                Panic("input: read returned zero\n", 0);
        !           763:                        else {
        !           764:                                /* strip parity bit */
        !           765:                                for(i = bcnt, cp = bptr ; i > 0 ; i--)
        !           766:                                        *cp++ &= CHAR;
        !           767:                                if(screen->scrollWindow && screen->scrollinput &&
        !           768:                                 screen->topline < 0)
        !           769:                                        /* Scroll to bottom */
        !           770:                                        WindowScroll(screen, 0);
        !           771:                                break;
        !           772:                        }
        !           773:                }
        !           774:                if(screen->scroll_amt)
        !           775:                        FlushScroll(screen);
        !           776:                if(screen->cursor_set && (screen->cursor_col != screen->cur_col
        !           777:                 || screen->cursor_row != screen->cur_row)) {
        !           778:                        if(screen->cursor_state)
        !           779:                                HideCursor();
        !           780:                        ShowCursor();
        !           781:                } else if(screen->cursor_set != screen->cursor_state) {
        !           782:                        if(screen->cursor_set)
        !           783:                                ShowCursor();
        !           784:                        else
        !           785:                                HideCursor();
        !           786:                }
        !           787:                
        !           788:        if (waitingForTrackInfo) {
        !           789:                        trackTimeOut.tv_sec = TRACKTIMESEC;
        !           790:                        trackTimeOut.tv_usec = TRACKTIMEUSEC;
        !           791:                        select_mask = pty_mask;
        !           792:                        if ((i = select(max_plus1, &select_mask, (int *)NULL, (int *)NULL,
        !           793:                         &trackTimeOut)) < 0) {
        !           794:                                if (errno != EINTR)
        !           795:                                        SysError(ERROR_SELECT);
        !           796:                                continue;
        !           797:                        } else if (i == 0) {
        !           798:                                /* emacs just isn't replying, go on */
        !           799:                                waitingForTrackInfo = 0;
        !           800:                                Bell();
        !           801:                                select_mask = Select_mask;
        !           802:                        }
        !           803:                } else if (QLength(screen->display))
        !           804:                        select_mask = X_mask;
        !           805:                else {
        !           806:                        write_mask = ptymask();
        !           807:                        XFlush(screen->display);
        !           808:                        select_mask = Select_mask;
        !           809:                        if (eventMode != NORMAL)
        !           810:                                select_mask = X_mask;
        !           811:                        if(select(max_plus1, &select_mask, &write_mask, 
        !           812:                                (int *)NULL, (struct timeval *) NULL) < 0){
        !           813:                                if (errno != EINTR)
        !           814:                                        SysError(ERROR_SELECT);
        !           815:                                continue;
        !           816:                        } 
        !           817:                }
        !           818:                if (write_mask & ptymask())
        !           819:                        v_write(screen->respond, 0, 0); /* flush buffer */
        !           820:                if(select_mask & X_mask) {
        !           821:                        if (bcnt <= 0) {
        !           822:                                bcnt = 0;
        !           823:                                bptr = buffer;
        !           824:                        }
        !           825:                        xevents();
        !           826:                        if (bcnt > 0)
        !           827:                                break;
        !           828:                }
        !           829:        }
        !           830:        bcnt--;
        !           831:        return(*bptr++);
        !           832: }
        !           833: 
        !           834: /*
        !           835:  * process a string of characters according to the character set indicated
        !           836:  * by charset.  worry about end of line conditions (wraparound if selected).
        !           837:  */
        !           838: dotext(screen, flags, charset, buf, ptr)
        !           839: register TScreen       *screen;
        !           840: unsigned       flags;
        !           841: char           charset;
        !           842: char   *buf;
        !           843: char   *ptr;
        !           844: {
        !           845:        register char   *s;
        !           846:        register int    len;
        !           847:        register int    n;
        !           848:        register int    next_col;
        !           849: 
        !           850:        switch (charset) {
        !           851:        case 'A':       /* United Kingdom set                   */
        !           852:                for (s=buf; s<ptr; ++s)
        !           853:                        if (*s == '#')
        !           854:                                *s = '\036';    /* UK pound sign*/
        !           855:                break;
        !           856: 
        !           857:        case 'B':       /* ASCII set                            */
        !           858:                break;
        !           859: 
        !           860:        case '0':       /* special graphics (line drawing)      */
        !           861:                for (s=buf; s<ptr; ++s)
        !           862:                        if (*s>=0x5f && *s<=0x7e)
        !           863:                                *s = *s == 0x5f ? 0x7f : *s - 0x5f;
        !           864:                break;
        !           865: 
        !           866:        default:        /* any character sets we don't recognize*/
        !           867:                return;
        !           868:        }
        !           869: 
        !           870:        len = ptr - buf; 
        !           871:        ptr = buf;
        !           872:        while (len > 0) {
        !           873:                n = screen->max_col-screen->cur_col+1;
        !           874:                if (n <= 1) {
        !           875:                        if (screen->do_wrap && (flags&WRAPAROUND)) {
        !           876:                                Index(screen, 1);
        !           877:                                screen->cur_col = 0;
        !           878:                                screen->do_wrap = 0;
        !           879:                                n = screen->max_col+1;
        !           880:                        } else
        !           881:                                n = 1;
        !           882:                }
        !           883:                if (len < n)
        !           884:                        n = len;
        !           885:                next_col = screen->cur_col + n;
        !           886:                WriteText(screen, ptr, n, flags);
        !           887:                /*
        !           888:                 * the call to WriteText updates screen->cur_col.
        !           889:                 * If screen->cur_col != next_col, we must have
        !           890:                 * hit the right margin, so set the do_wrap flag.
        !           891:                 */
        !           892:                screen->do_wrap = (screen->cur_col < next_col);
        !           893:                len -= n;
        !           894:                ptr += n;
        !           895:        }
        !           896: }
        !           897:  
        !           898: /*
        !           899:  * write a string str of length len onto the screen at
        !           900:  * the current cursor position.  update cursor position.
        !           901:  */
        !           902: WriteText(screen, str, len, flags)
        !           903: register TScreen       *screen;
        !           904: register char  *str;
        !           905: register int   len;
        !           906: unsigned       flags;
        !           907: {
        !           908:        register int cx, cy;
        !           909:        register unsigned fgs = flags;
        !           910:        GC      currentGC;
        !           911:  
        !           912:    if(screen->cur_row - screen->topline <= screen->max_row) {
        !           913:        /*
        !           914:        if(screen->cur_row == screen->cursor_row && screen->cur_col <=
        !           915:         screen->cursor_col && screen->cursor_col <= screen->cur_col + len - 1)
        !           916:                screen->cursor_state = OFF;
        !           917:         */
        !           918:        if(screen->cursor_state)
        !           919:                HideCursor();
        !           920: 
        !           921:        /*
        !           922:         *      make sure that the correct GC is current
        !           923:         */
        !           924: 
        !           925:        if (fgs & BOLD)
        !           926:                if (fgs & INVERSE)
        !           927:                        currentGC = screen->reverseboldGC;
        !           928:                else    currentGC = screen->normalboldGC;
        !           929:        else  /* not bold */
        !           930:                if (fgs & INVERSE)
        !           931:                        currentGC = screen->reverseGC;
        !           932:                else    currentGC = screen->normalGC;
        !           933: 
        !           934:        if (fgs & INSERT)
        !           935:                InsertChar(screen, len);
        !           936:       if (!(AddToRefresh(screen))) {
        !           937:                if(screen->scroll_amt)
        !           938:                        FlushScroll(screen);
        !           939:        cx = CursorX(screen, screen->cur_col);
        !           940:        cy = CursorY(screen, screen->cur_row)+screen->fnt_norm->max_bounds.ascent;
        !           941:        XDrawImageString(screen->display, TextWindow(screen), currentGC,
        !           942:                        cx, cy, str, len);
        !           943: 
        !           944:        if((fgs & BOLD) && screen->enbolden) 
        !           945:                if (currentGC == screen->normalGC || screen->reverseGC)
        !           946:                        XDrawString(screen->display, TextWindow(screen),
        !           947:                                currentGC,cx + 1, cy, str, len);
        !           948: 
        !           949:        if(fgs & UNDERLINE) 
        !           950:                XDrawLine(screen->display, TextWindow(screen), currentGC,
        !           951:                        cx, cy+1,
        !           952:                        cx + len * FontWidth(screen), cy+1);
        !           953:        /*
        !           954:         * the following statements compile data to compute the average 
        !           955:         * number of characters written on each call to XText.  The data
        !           956:         * may be examined via the use of a "hidden" escape sequence.
        !           957:         */
        !           958:        ctotal += len;
        !           959:        ++ntotal;
        !           960:       }
        !           961:     }
        !           962:        ScreenWrite(screen, str, flags, len);
        !           963:        CursorForward(screen, len);
        !           964: }
        !           965:  
        !           966: /*
        !           967:  * process ANSI modes set, reset
        !           968:  */
        !           969: modes(term, func)
        !           970: Terminal       *term;
        !           971: int            (*func)();
        !           972: {
        !           973:        register int    i;
        !           974: 
        !           975:        for (i=0; i<nparam; ++i) {
        !           976:                switch (param[i]) {
        !           977:                case 4:                 /* IRM                          */
        !           978:                        (*func)(&term->flags, INSERT);
        !           979:                        break;
        !           980: 
        !           981:                case 20:                /* LNM                          */
        !           982:                        (*func)(&term->flags, LINEFEED);
        !           983:                        break;
        !           984:                }
        !           985:        }
        !           986: }
        !           987: 
        !           988: /*
        !           989:  * process DEC private modes set, reset
        !           990:  */
        !           991: dpmodes(term, func)
        !           992: Terminal       *term;
        !           993: int            (*func)();
        !           994: {
        !           995:        register TScreen        *screen = &term->screen;
        !           996:        register int    i, j;
        !           997:        extern int bitset();
        !           998: 
        !           999:        for (i=0; i<nparam; ++i) {
        !          1000:                switch (param[i]) {
        !          1001:                case 1:                 /* DECCKM                       */
        !          1002:                        (*func)(&term->keyboard.flags, CURSOR_APL);
        !          1003:                        break;
        !          1004:                case 3:                 /* DECCOLM                      */
        !          1005:                        if(screen->c132) {
        !          1006:                                ClearScreen(screen);
        !          1007:                                CursorSet(screen, 0, 0, term->flags);
        !          1008:                                if((j = func == bitset ? 132 : 80) !=
        !          1009:                                 ((term->flags & IN132COLUMNS) ? 132 : 80) ||
        !          1010:                                 j != screen->max_col + 1) {
        !          1011:                                        XResizeWindow(
        !          1012:                                            screen->display,
        !          1013:                                            TextWindow(screen),
        !          1014:                                            (unsigned) FontWidth(screen) * j
        !          1015:                                                + 2*screen->border
        !          1016:                                                + screen->scrollbar,
        !          1017:                                            (unsigned) FontHeight(screen)
        !          1018:                                                * (screen->max_row + 1)
        !          1019:                                                + 2 * screen->border);
        !          1020:                                        XSync(screen->display, FALSE);
        !          1021:                                        if(QLength(screen->display) > 0)
        !          1022:                                                xevents();
        !          1023:                                }
        !          1024:                                (*func)(&term->flags, IN132COLUMNS);
        !          1025:                        }
        !          1026:                        break;
        !          1027:                case 4:                 /* DECSCLM (slow scroll)        */
        !          1028:                        if (func == bitset) {
        !          1029:                                screen->jumpscroll = 0;
        !          1030:                                if (screen->scroll_amt)
        !          1031:                                        FlushScroll(screen);
        !          1032:                        } else
        !          1033:                                screen->jumpscroll = 1;
        !          1034:                        (*func)(&term->flags, SMOOTHSCROLL);
        !          1035:                        break;
        !          1036:                case 5:                 /* DECSCNM                      */
        !          1037:                        j = term->flags;
        !          1038:                        (*func)(&term->flags, REVERSE_VIDEO);
        !          1039:                        if ((term->flags ^ j) & REVERSE_VIDEO)
        !          1040:                                ReverseVideo(term);
        !          1041:                        break;
        !          1042: 
        !          1043:                case 6:                 /* DECOM                        */
        !          1044:                        (*func)(&term->flags, ORIGIN);
        !          1045:                        CursorSet(screen, 0, 0, term->flags);
        !          1046:                        break;
        !          1047: 
        !          1048:                case 7:                 /* DECAWM                       */
        !          1049:                        (*func)(&term->flags, WRAPAROUND);
        !          1050:                        break;
        !          1051:                case 8:                 /* DECARM                       */
        !          1052:                        j = term->flags;
        !          1053:                        (*func)(&term->flags, AUTOREPEAT);
        !          1054:                        if ((term->flags ^ j) & AUTOREPEAT)
        !          1055:                                if(term->flags & AUTOREPEAT)
        !          1056:                                        XAutoRepeatOn(screen->display);
        !          1057:                                else
        !          1058:                                        XAutoRepeatOff(screen->display);
        !          1059:                        break;
        !          1060:                case 9:                 /* MIT bogus sequence           */
        !          1061:                        if(func == bitset)
        !          1062:                                screen->send_mouse_pos = 1;
        !          1063:                        else
        !          1064:                                screen->send_mouse_pos = 0;
        !          1065:                        break;
        !          1066:                case 38:                /* DECTEK                       */
        !          1067:                        if(func == bitset & !(screen->inhibit & I_TEK)) {
        !          1068:                                if(screen->logging) {
        !          1069:                                        FlushLog(screen);
        !          1070:                                        screen->logstart = Tbuffer;
        !          1071:                                }
        !          1072:                                screen->TekEmu = TRUE;
        !          1073:                        }
        !          1074:                        break;
        !          1075:                case 40:                /* 132 column mode              */
        !          1076:                        (*func)(&screen->c132, 1);
        !          1077:                        break;
        !          1078:                case 41:                /* curses hack                  */
        !          1079:                        (*func)(&screen->curses, 1);
        !          1080:                        break;
        !          1081:                case 44:                /* margin bell                  */
        !          1082:                        (*func)(&screen->marginbell, 1);
        !          1083:                        if(!screen->marginbell)
        !          1084:                                screen->bellarmed = -1;
        !          1085:                        break;
        !          1086:                case 45:                /* reverse wraparound   */
        !          1087:                        (*func)(&term->flags, REVERSEWRAP);
        !          1088:                        break;
        !          1089:                case 46:                /* logging              */
        !          1090:                        if(func == bitset)
        !          1091:                                StartLog(screen);
        !          1092:                        else
        !          1093:                                CloseLog(screen);
        !          1094:                        break;
        !          1095:                case 47:                /* alternate buffer             */
        !          1096:                        if(func == bitset)
        !          1097:                                ToAlternate(screen);
        !          1098:                        else
        !          1099:                                FromAlternate(screen);
        !          1100:                        break;
        !          1101:                case 1000:              /* xtem bogus sequence          */
        !          1102:                        if(func == bitset)
        !          1103:                                screen->send_mouse_pos = 2;
        !          1104:                        else
        !          1105:                                screen->send_mouse_pos = 0;
        !          1106:                        break;
        !          1107:                case 1001:              /* xtem sequence w/hilite tracking */
        !          1108:                        if(func == bitset)
        !          1109:                                screen->send_mouse_pos = 3;
        !          1110:                        else
        !          1111:                                screen->send_mouse_pos = 0;
        !          1112:                        break;
        !          1113:                }
        !          1114:        }
        !          1115: }
        !          1116: 
        !          1117: /*
        !          1118:  * process xterm private modes save
        !          1119:  */
        !          1120: savemodes(term)
        !          1121: Terminal *term;
        !          1122: {
        !          1123:        register TScreen        *screen = &term->screen;
        !          1124:        register int i;
        !          1125: 
        !          1126:        for (i = 0; i < nparam; i++) {
        !          1127:                switch (param[i]) {
        !          1128:                case 1:                 /* DECCKM                       */
        !          1129:                        screen->save_modes[0] = term->keyboard.flags &
        !          1130:                         CURSOR_APL;
        !          1131:                        break;
        !          1132:                case 3:                 /* DECCOLM                      */
        !          1133:                        if(screen->c132)
        !          1134:                                screen->save_modes[1] = term->flags &
        !          1135:                                 IN132COLUMNS;
        !          1136:                        break;
        !          1137:                case 4:                 /* DECSCLM (slow scroll)        */
        !          1138:                        screen->save_modes[2] = term->flags & SMOOTHSCROLL;
        !          1139:                        break;
        !          1140:                case 5:                 /* DECSCNM                      */
        !          1141:                        screen->save_modes[3] = term->flags & REVERSE_VIDEO;
        !          1142:                        break;
        !          1143:                case 6:                 /* DECOM                        */
        !          1144:                        screen->save_modes[4] = term->flags & ORIGIN;
        !          1145:                        break;
        !          1146: 
        !          1147:                case 7:                 /* DECAWM                       */
        !          1148:                        screen->save_modes[5] = term->flags & WRAPAROUND;
        !          1149:                        break;
        !          1150:                case 8:                 /* DECARM                       */
        !          1151:                        screen->save_modes[6] = term->flags & AUTOREPEAT;
        !          1152:                        break;
        !          1153:                case 9:                 /* mouse bogus sequence */
        !          1154:                        screen->save_modes[7] = screen->send_mouse_pos;
        !          1155:                        break;
        !          1156:                case 40:                /* 132 column mode              */
        !          1157:                        screen->save_modes[8] = screen->c132;
        !          1158:                        break;
        !          1159:                case 41:                /* curses hack                  */
        !          1160:                        screen->save_modes[9] = screen->curses;
        !          1161:                        break;
        !          1162:                case 44:                /* margin bell                  */
        !          1163:                        screen->save_modes[12] = screen->marginbell;
        !          1164:                        break;
        !          1165:                case 45:                /* reverse wraparound   */
        !          1166:                        screen->save_modes[13] = term->flags & REVERSEWRAP;
        !          1167:                        break;
        !          1168:                case 46:                /* logging              */
        !          1169:                        screen->save_modes[14] = screen->logging;
        !          1170:                        break;
        !          1171:                case 47:                /* alternate buffer             */
        !          1172:                        screen->save_modes[15] = screen->alternate;
        !          1173:                        break;
        !          1174:                case 1000:              /* mouse bogus sequence         */
        !          1175:                case 1001:
        !          1176:                        screen->save_modes[7] = screen->send_mouse_pos;
        !          1177:                        break;
        !          1178:                }
        !          1179:        }
        !          1180: }
        !          1181: 
        !          1182: /*
        !          1183:  * process xterm private modes restore
        !          1184:  */
        !          1185: restoremodes(term)
        !          1186: Terminal *term;
        !          1187: {
        !          1188:        register TScreen        *screen = &term->screen;
        !          1189:        register int i, j;
        !          1190: 
        !          1191:        for (i = 0; i < nparam; i++) {
        !          1192:                switch (param[i]) {
        !          1193:                case 1:                 /* DECCKM                       */
        !          1194:                        term->keyboard.flags &= ~CURSOR_APL;
        !          1195:                        term->keyboard.flags |= screen->save_modes[0] &
        !          1196:                         CURSOR_APL;
        !          1197:                        break;
        !          1198:                case 3:                 /* DECCOLM                      */
        !          1199:                        if(screen->c132) {
        !          1200:                                ClearScreen(screen);
        !          1201:                                CursorSet(screen, 0, 0, term->flags);
        !          1202:                                if((j = (screen->save_modes[1] & IN132COLUMNS)
        !          1203:                                 ? 132 : 80) != ((term->flags & IN132COLUMNS)
        !          1204:                                 ? 132 : 80) || j != screen->max_col + 1) {
        !          1205:                                        XResizeWindow(
        !          1206:                                            screen->display,
        !          1207:                                            TextWindow(screen),
        !          1208:                                            (unsigned) FontWidth(screen) * j 
        !          1209:                                                + 2*screen->border
        !          1210:                                                + screen->scrollbar,
        !          1211:                                            (unsigned) FontHeight(screen)
        !          1212:                                                * (screen->max_row + 1)
        !          1213:                                                + 2*screen->border);
        !          1214:                                        XSync(screen->display, FALSE);  /* synchronize */
        !          1215:                                        if(QLength(screen->display) > 0)
        !          1216:                                                xevents();
        !          1217:                                }
        !          1218:                                term->flags &= ~IN132COLUMNS;
        !          1219:                                term->flags |= screen->save_modes[1] &
        !          1220:                                 IN132COLUMNS;
        !          1221:                        }
        !          1222:                        break;
        !          1223:                case 4:                 /* DECSCLM (slow scroll)        */
        !          1224:                        if (screen->save_modes[2] & SMOOTHSCROLL) {
        !          1225:                                screen->jumpscroll = 0;
        !          1226:                                if (screen->scroll_amt)
        !          1227:                                        FlushScroll(screen);
        !          1228:                        } else
        !          1229:                                screen->jumpscroll = 1;
        !          1230:                        term->flags &= ~SMOOTHSCROLL;
        !          1231:                        term->flags |= screen->save_modes[2] & SMOOTHSCROLL;
        !          1232:                        break;
        !          1233:                case 5:                 /* DECSCNM                      */
        !          1234:                        if((screen->save_modes[3] ^ term->flags) &
        !          1235:                         REVERSE_VIDEO) {
        !          1236:                                term->flags &= ~REVERSE_VIDEO;
        !          1237:                                term->flags |= screen->save_modes[3] &
        !          1238:                                 REVERSE_VIDEO;
        !          1239:                                ReverseVideo(term);
        !          1240:                        }
        !          1241:                        break;
        !          1242:                case 6:                 /* DECOM                        */
        !          1243:                        term->flags &= ~ORIGIN;
        !          1244:                        term->flags |= screen->save_modes[4] & ORIGIN;
        !          1245:                        CursorSet(screen, 0, 0, term->flags);
        !          1246:                        break;
        !          1247: 
        !          1248:                case 7:                 /* DECAWM                       */
        !          1249:                        term->flags &= ~WRAPAROUND;
        !          1250:                        term->flags |= screen->save_modes[5] & WRAPAROUND;
        !          1251:                        break;
        !          1252:                case 8:                 /* DECARM                       */
        !          1253:                        if((screen->save_modes[6] ^ term->flags) & AUTOREPEAT) {
        !          1254:                                term->flags &= ~REVERSE_VIDEO;
        !          1255:                                term->flags |= screen->save_modes[6] &
        !          1256:                                 REVERSE_VIDEO;
        !          1257:                                if(term->flags & AUTOREPEAT)
        !          1258:                                        XAutoRepeatOn(screen->display);
        !          1259:                                else
        !          1260:                                        XAutoRepeatOff(screen->display);
        !          1261:                        }
        !          1262:                        break;
        !          1263:                case 9:                 /* MIT bogus sequence           */
        !          1264:                        screen->send_mouse_pos = screen->save_modes[7];
        !          1265:                        break;
        !          1266:                case 40:                /* 132 column mode              */
        !          1267:                        screen->c132 = screen->save_modes[8];
        !          1268:                        break;
        !          1269:                case 41:                /* curses hack                  */
        !          1270:                        screen->curses = screen->save_modes[9];
        !          1271:                        break;
        !          1272:                case 44:                /* margin bell                  */
        !          1273:                        if(!(screen->marginbell = screen->save_modes[12]))
        !          1274:                                screen->bellarmed = -1;
        !          1275:                        break;
        !          1276:                case 45:                /* reverse wraparound   */
        !          1277:                        term->flags &= ~REVERSEWRAP;
        !          1278:                        term->flags |= screen->save_modes[13] & REVERSEWRAP;
        !          1279:                        break;
        !          1280:                case 46:                /* logging              */
        !          1281:                        if(screen->save_modes[14])
        !          1282:                                StartLog(screen);
        !          1283:                        else
        !          1284:                                CloseLog(screen);
        !          1285:                        break;
        !          1286:                case 47:                /* alternate buffer             */
        !          1287:                        if(screen->save_modes[15])
        !          1288:                                ToAlternate(screen);
        !          1289:                        else
        !          1290:                                FromAlternate(screen);
        !          1291:                        break;
        !          1292:                case 1000:              /* mouse bogus sequence         */
        !          1293:                case 1001:
        !          1294:                        screen->send_mouse_pos = screen->save_modes[7];
        !          1295:                        break;
        !          1296:                }
        !          1297:        }
        !          1298: }
        !          1299: 
        !          1300: /*
        !          1301:  * set a bit in a word given a pointer to the word and a mask.
        !          1302:  */
        !          1303: bitset(p, mask)
        !          1304: int    *p;
        !          1305: {
        !          1306:        *p |= mask;
        !          1307: }
        !          1308: 
        !          1309: /*
        !          1310:  * clear a bit in a word given a pointer to the word and a mask.
        !          1311:  */
        !          1312: bitclr(p, mask)
        !          1313: int    *p;
        !          1314: {
        !          1315:        *p &= ~mask;
        !          1316: }
        !          1317: 
        !          1318: unparseseq(ap, fd)
        !          1319: register ANSI  *ap;
        !          1320: {
        !          1321:        register int    c;
        !          1322:        register int    i;
        !          1323:        register int    inters;
        !          1324: 
        !          1325:        c = ap->a_type;
        !          1326:        if (c>=0x80 && c<=0x9F) {
        !          1327:                unparseputc(ESC, fd);
        !          1328:                c -= 0x40;
        !          1329:        }
        !          1330:        unparseputc(c, fd);
        !          1331:        c = ap->a_type;
        !          1332:        if (c==ESC || c==DCS || c==CSI || c==OSC || c==PM || c==APC) {
        !          1333:                if (ap->a_pintro != 0)
        !          1334:                        unparseputc((char) ap->a_pintro, fd);
        !          1335:                for (i=0; i<ap->a_nparam; ++i) {
        !          1336:                        if (i != 0)
        !          1337:                                unparseputc(';', fd);
        !          1338:                        unparseputn((unsigned int) ap->a_param[i], fd);
        !          1339:                }
        !          1340:                inters = ap->a_inters;
        !          1341:                for (i=3; i>=0; --i) {
        !          1342:                        c = (inters >> (8*i)) & 0xff;
        !          1343:                        if (c != 0)
        !          1344:                                unparseputc(c, fd);
        !          1345:                }
        !          1346:                unparseputc((char) ap->a_final, fd);
        !          1347:        }
        !          1348: }
        !          1349: 
        !          1350: unparseputn(n, fd)
        !          1351: unsigned int   n;
        !          1352: int fd;
        !          1353: {
        !          1354:        unsigned int    q;
        !          1355: 
        !          1356:        q = n/10;
        !          1357:        if (q != 0)
        !          1358:                unparseputn(q, fd);
        !          1359:        unparseputc((char) ('0' + (n%10)), fd);
        !          1360: }
        !          1361: 
        !          1362: unparseputc(c, fd)
        !          1363: char c;
        !          1364: int fd;
        !          1365: {
        !          1366:        char    buf[2];
        !          1367:        register i = 1;
        !          1368:        extern Terminal term;
        !          1369: 
        !          1370:        if((buf[0] = c) == '\r' && (term.flags & LINEFEED)) {
        !          1371:                buf[1] = '\n';
        !          1372:                i++;
        !          1373:        }
        !          1374:        if (write(fd, buf, i) != i)
        !          1375:                Panic("unparseputc: error writing character\n", 0);
        !          1376: }
        !          1377: 
        !          1378: ToAlternate(screen)
        !          1379: register TScreen *screen;
        !          1380: {
        !          1381:        extern ScrnBuf Allocate();
        !          1382: 
        !          1383:        if(screen->alternate)
        !          1384:                return;
        !          1385:        if(!screen->altbuf)
        !          1386:                screen->altbuf = Allocate(screen->max_row + 1, screen->max_col
        !          1387:                 + 1);
        !          1388:        SwitchBufs(screen);
        !          1389:        screen->alternate = TRUE;
        !          1390: }
        !          1391: 
        !          1392: FromAlternate(screen)
        !          1393: register TScreen *screen;
        !          1394: {
        !          1395:        if(!screen->alternate)
        !          1396:                return;
        !          1397:        screen->alternate = FALSE;
        !          1398:        SwitchBufs(screen);
        !          1399: }
        !          1400: 
        !          1401: SwitchBufs(screen)
        !          1402: register TScreen *screen;
        !          1403: {
        !          1404:        register int rows, top;
        !          1405:        char *save [2 * MAX_ROWS];
        !          1406: 
        !          1407:        if(screen->cursor_state)
        !          1408:                HideCursor();
        !          1409:        rows = screen->max_row + 1;
        !          1410:        bcopy((char *)screen->buf, (char *)save, 2 * sizeof(char *) * rows);
        !          1411:        bcopy((char *)screen->altbuf, (char *)screen->buf, 2 * sizeof(char *) *
        !          1412:         rows);
        !          1413:        bcopy((char *)save, (char *)screen->altbuf, 2 * sizeof(char *) * rows);
        !          1414: 
        !          1415:        if((top = -screen->topline) <= screen->max_row) {
        !          1416:                if(screen->scroll_amt)
        !          1417:                        FlushScroll(screen);
        !          1418:                if(top == 0)
        !          1419:                        XClearWindow(screen->display, TextWindow(screen));
        !          1420:                else
        !          1421:                        XClearArea(
        !          1422:                            screen->display,
        !          1423:                            TextWindow(screen),
        !          1424:                            (int) screen->border + screen->scrollbar,
        !          1425:                            (int) top * FontHeight(screen) + screen->border,
        !          1426:                            (unsigned) Width(screen),
        !          1427:                            (unsigned) (screen->max_row - top + 1)
        !          1428:                                * FontHeight(screen),
        !          1429:                            FALSE);
        !          1430:        }
        !          1431:        ScrnRefresh(screen, 0, 0, rows, screen->max_col + 1);
        !          1432: }
        !          1433: 
        !          1434: VTRun()
        !          1435: {
        !          1436:        register TScreen *screen = &term.screen;
        !          1437:        register int i;
        !          1438:        
        !          1439:        if(!VWindow(screen) && !VTInit()) {
        !          1440:                if(TWindow(screen)) {
        !          1441:                        screen->TekEmu = TRUE;
        !          1442:                        return;
        !          1443:                }
        !          1444:                Exit(ERROR_VINIT);
        !          1445:        }
        !          1446:        screen->cursor_state = OFF;
        !          1447:        screen->cursor_set = ON;
        !          1448:        XMapWindow(screen->display, VWindow(screen));
        !          1449:        if(screen->select)
        !          1450:                VTSelect();
        !          1451:        if (L_flag > 0) {
        !          1452:                XWarpPointer (screen->display, None, VWindow(screen),
        !          1453:                            0, 0, 0, 0,
        !          1454:                            FullWidth(screen) >> 1, FullHeight(screen) >>1);
        !          1455:                L_flag = -1;
        !          1456:        }
        !          1457:        bcnt = 0;
        !          1458:        bptr = buffer;
        !          1459:        while(Tpushb > Tpushback) {
        !          1460:                *bptr++ = *--Tpushb;
        !          1461:                bcnt++;
        !          1462:        }
        !          1463:        bcnt += (i = Tbcnt);
        !          1464:        for( ; i > 0 ; i--)
        !          1465:                *bptr++ = *Tbptr++;
        !          1466:        bptr = buffer;
        !          1467:        if(!setjmp(VTend))
        !          1468:                VTparse();
        !          1469:        HideCursor();
        !          1470:        screen->cursor_set = OFF;
        !          1471:        VTUnselect();
        !          1472: }
        !          1473: 
        !          1474: /*ARGSUSED*/
        !          1475: XtEventReturnCode VTExpose(event, eventdata)
        !          1476: register XExposeEvent *event;
        !          1477: caddr_t eventdata;
        !          1478: {
        !          1479:        register TScreen *screen = &term.screen;
        !          1480: 
        !          1481: #ifdef DEBUG
        !          1482:        if(debug)
        !          1483:                fputs("Expose\n", stderr);
        !          1484: #endif DEBUG
        !          1485:        if (event->type == Expose) {
        !          1486:                HandleExposure (screen, (XExposeEvent *)event);
        !          1487:                return(XteventHandled);
        !          1488:        }
        !          1489:        if (screen->incopy <= 0) {
        !          1490:                screen->incopy = 1;
        !          1491:                if (screen->scrolls > 0)
        !          1492:                        screen->scrolls--;
        !          1493:        }
        !          1494:        if (event->type == GraphicsExpose)
        !          1495:          if (HandleExposure (screen, (XExposeEvent *)event))
        !          1496:                screen->cursor_state = OFF;
        !          1497:        if ((event->type == NoExpose) || event->count == 0) {
        !          1498:                if (screen->incopy <= 0 && screen->scrolls > 0)
        !          1499:                        screen->scrolls--;
        !          1500:                if (screen->scrolls)
        !          1501:                        screen->incopy = -1;
        !          1502:                else
        !          1503:                        screen->incopy = 0;
        !          1504:        }
        !          1505:        return (XteventHandled);
        !          1506: }
        !          1507: 
        !          1508: 
        !          1509: 
        !          1510: /*ARGSUSED*/
        !          1511: XtEventReturnCode VTConfigure(event, eventdata)
        !          1512: XConfigureEvent *event;
        !          1513: caddr_t eventdata;
        !          1514: {
        !          1515:        register TScreen *screen = &term.screen;
        !          1516: 
        !          1517:        if (event->type ==ConfigureNotify ) {
        !          1518:                ScreenResize (screen, event->width, event->height, &term.flags);
        !          1519:                return(XteventHandled);
        !          1520:        }       
        !          1521:        if (event->type != UnmapNotify) return(XteventNotHandled);
        !          1522: #ifdef DEBUG
        !          1523:        if(debug)
        !          1524:                fputs("UnmapWindow VT\n", stderr);
        !          1525: #endif DEBUG
        !          1526:        if(screen->Tshow) {
        !          1527:                screen->Tshow = FALSE;
        !          1528:                XUnmapWindow(screen->display,  screen->fullTwin.window );
        !          1529:                SyncUnmap( screen->fullTwin.window, TWINDOWEVENTS );
        !          1530:        }
        !          1531:        reselectwindow(screen);
        !          1532:        return (XteventHandled);
        !          1533: }
        !          1534: 
        !          1535: 
        !          1536: 
        !          1537: VTInit()
        !          1538: {
        !          1539:        unsigned int width, height;
        !          1540:        register TScreen *screen = &term.screen;
        !          1541:        register int i, j;
        !          1542:        XPoint  *vp;
        !          1543:        static short failed;
        !          1544:        int x, y, root_x, root_y, xpos, ypos, pr;
        !          1545:        Window win, root;
        !          1546:        extern char *malloc();
        !          1547:        XGCValues               xgcv;
        !          1548:        GCMask                  mask;
        !          1549:        XSizeHints              sizehints;
        !          1550:        XWMHints                wmhints;
        !          1551:        extern int              VTgcFontMask;
        !          1552: 
        !          1553:        if(failed)
        !          1554:                return(FALSE);
        !          1555:        
        !          1556:        TabReset (term.tabs);
        !          1557: 
        !          1558:        screen->fnt_norm = screen->fnt_bold = NULL;
        !          1559:        
        !          1560:        /* do the XFont calls */
        !          1561: 
        !          1562:        if ((screen->fnt_norm = XLoadQueryFont(screen->display, f_n)) == NULL) {
        !          1563:            fprintf(stderr, "%s: Could not open font %s; using server default\n", 
        !          1564:                    xterm_name, f_n);
        !          1565:            screen->fnt_norm =
        !          1566:                  XQueryFont(screen->display,
        !          1567:                             DefaultGC(screen->display,
        !          1568:                                       DefaultScreen(screen->display)
        !          1569:                                       )->gid
        !          1570:                             );
        !          1571:            VTgcFontMask = 0;
        !          1572:        }
        !          1573: 
        !          1574:        if (!f_b || !VTgcFontMask
        !          1575:            || !(screen->fnt_bold = XLoadQueryFont(screen->display, f_b))) {
        !          1576:                screen->fnt_bold = screen->fnt_norm;
        !          1577:                screen->enbolden = TRUE;  /*no bold font */
        !          1578:        }
        !          1579: 
        !          1580:        /* find the max width and higth of the font */
        !          1581: 
        !          1582:        screen->fullVwin.f_width = screen->fnt_norm->max_bounds.width;
        !          1583:        screen->fullVwin.f_height = screen->fnt_norm->max_bounds.ascent +
        !          1584:                                    screen->fnt_norm->max_bounds.descent;
        !          1585: 
        !          1586:        /* making cursor -- won't work yet */
        !          1587: 
        !          1588:        if (XStrCmp(curs_shape, "arrow") == 0) {
        !          1589:                screen->curs = make_arrow(screen->mousecolor,
        !          1590:                        screen->background);
        !          1591:        } else {
        !          1592:                screen->curs = make_xterm(screen->mousecolor,
        !          1593:                        screen->background);
        !          1594:        }
        !          1595: 
        !          1596:        i = 2 * screen->border + screen->scrollbar;
        !          1597:        j = 2 * screen->border;
        !          1598: 
        !          1599: 
        !          1600:        /* set defaults */
        !          1601:        xpos = 1; ypos = 1; width = 80; height = 24;
        !          1602: 
        !          1603:        pr = XParseGeometry(geo_metry, &xpos, &ypos, &width, &height);
        !          1604: 
        !          1605:        screen->max_col = width;
        !          1606:        screen->max_row = height;
        !          1607:        width = width * screen->fullVwin.f_width + i;
        !          1608:        height = height * screen->fullVwin.f_height + j;
        !          1609: 
        !          1610:        if ((pr & XValue) && (XNegative&pr)) 
        !          1611:          xpos += DisplayWidth(screen->display, DefaultScreen(screen->display)) 
        !          1612:                        - width;
        !          1613:        if ((pr & YValue) && (YNegative&pr))
        !          1614:          ypos += DisplayHeight(screen->display, DefaultScreen(screen->display)) 
        !          1615:                        - height;
        !          1616: 
        !          1617:        /* set up size hints for window manager */
        !          1618:        sizehints.min_width = 2 * screen->border + screen->scrollbar;
        !          1619:        sizehints.min_height = 2 * screen->border;
        !          1620:        sizehints.width_inc = FontWidth(screen);
        !          1621:        sizehints.height_inc = FontHeight(screen);
        !          1622:        sizehints.flags = PMinSize|PResizeInc;
        !          1623:        sizehints.x = xpos;
        !          1624:        sizehints.y = ypos;
        !          1625:        if ((XValue&pr) && (YValue&pr)) 
        !          1626:          sizehints.flags |= USPosition;
        !          1627:        else sizehints.flags |= PPosition;
        !          1628:        sizehints.width = width;
        !          1629:        sizehints.height = height;
        !          1630:        if ((WidthValue&pr) && (HeightValue&pr)) 
        !          1631:          sizehints.flags |= USSize;
        !          1632:        else sizehints.flags |= PSize;
        !          1633: 
        !          1634:         screen->fullVwin.fullwidth = width;
        !          1635:         screen->fullVwin.fullheight = height;
        !          1636:         screen->fullVwin.width = width - i;
        !          1637:         screen->fullVwin.height = height - j;
        !          1638: 
        !          1639:        
        !          1640:        if((screen->fullVwin.window = XtCreateWindow(
        !          1641:            screen->display,
        !          1642:            DefaultRootWindow(screen->display), 
        !          1643:            xpos, ypos,
        !          1644:            width, height,
        !          1645:            screen->borderwidth, screen->bordercolor,
        !          1646:            screen->background, NorthWestGravity)) == NULL) {
        !          1647:                fprintf(stderr, "%s: Can't create VT window\n");
        !          1648:                return(FALSE);
        !          1649:        }
        !          1650:        /* crock to make configure notifies get through */
        !          1651:        XtMakeMaster(screen->display, screen->fullVwin.window);
        !          1652: 
        !          1653:        /* set size hints */
        !          1654:        XSetNormalHints(screen->display, VWindow(screen), &sizehints);
        !          1655:        /* do the GC stuff */
        !          1656: 
        !          1657:        mask = VTgcFontMask | GCForeground | GCBackground 
        !          1658:                | GCGraphicsExposures | GCFunction;
        !          1659: 
        !          1660:        xgcv.graphics_exposures = TRUE; /* default */
        !          1661:        xgcv.function = GXcopy;
        !          1662:        xgcv.font = screen->fnt_norm->fid;
        !          1663:        xgcv.foreground = screen->foreground;
        !          1664:        xgcv.background = screen->background;
        !          1665: 
        !          1666:        screen->normalGC = XtGetGC(
        !          1667:            screen->display,
        !          1668:            (XContext)NULL, 
        !          1669:            DefaultRootWindow(screen->display),
        !          1670:            mask,
        !          1671:            &xgcv);
        !          1672: 
        !          1673:        if (screen->enbolden) { /* there is no bold font */
        !          1674:                xgcv.font = screen->fnt_norm->fid;
        !          1675:                screen->normalboldGC = screen->normalGC;
        !          1676:        } else {
        !          1677:                xgcv.font = screen->fnt_bold->fid;
        !          1678:                screen->normalboldGC = XtGetGC(
        !          1679:                    screen->display,
        !          1680:                    (XContext)NULL,
        !          1681:                    DefaultRootWindow(screen->display),
        !          1682:                    mask,
        !          1683:                    &xgcv);
        !          1684:        }
        !          1685: 
        !          1686:        xgcv.font = screen->fnt_norm->fid;
        !          1687:        xgcv.foreground = screen->background;
        !          1688:        xgcv.background = screen->foreground;
        !          1689: 
        !          1690:        screen->reverseGC = XtGetGC(
        !          1691:            screen->display,
        !          1692:            (XContext)NULL,
        !          1693:            DefaultRootWindow(screen->display),
        !          1694:            mask,
        !          1695:            &xgcv);
        !          1696: 
        !          1697:        if (screen->enbolden) /* there is no bold font */
        !          1698:                xgcv.font = screen->fnt_norm->fid;
        !          1699:        else
        !          1700:                xgcv.font = screen->fnt_bold->fid;
        !          1701: 
        !          1702:        screen->reverseboldGC = XtGetGC(
        !          1703:            screen->display,
        !          1704:            (XContext)NULL,
        !          1705:            DefaultRootWindow(screen->display),
        !          1706:            mask,
        !          1707:            &xgcv);
        !          1708: 
        !          1709:        /* we also need a set of caret (called a cursor here) gc's */
        !          1710: 
        !          1711:        xgcv.font = screen->fnt_norm->fid;
        !          1712: 
        !          1713:        if (screen->cursorcolor != screen->foreground) {
        !          1714:                xgcv.foreground = screen->cursorcolor;
        !          1715:                xgcv.background = screen->foreground;
        !          1716:        } else {
        !          1717:                xgcv.foreground = screen->foreground;
        !          1718:                xgcv.background = screen->background;
        !          1719:        }
        !          1720: 
        !          1721:        screen->cursorGC = XtGetGC(
        !          1722:            screen->display,
        !          1723:            (XContext)NULL,
        !          1724:            DefaultRootWindow(screen->display),
        !          1725:            mask,
        !          1726:            &xgcv);
        !          1727: 
        !          1728:        if (screen->cursorcolor != screen->background) {
        !          1729:                xgcv.foreground = screen->cursorcolor;
        !          1730:                xgcv.background = screen->background;
        !          1731:        } else {
        !          1732:                xgcv.foreground = screen->background;
        !          1733:                xgcv.background = screen->foreground;
        !          1734:        }
        !          1735: 
        !          1736:        screen->reversecursorGC = XtGetGC(
        !          1737:            screen->display,
        !          1738:            (XContext)NULL,
        !          1739:            DefaultRootWindow(screen->display),
        !          1740:            mask,
        !          1741:            &xgcv);
        !          1742: 
        !          1743: 
        !          1744:        /* setup toolkit stuff */
        !          1745: 
        !          1746:        XtSetNameAndClass(screen->display, screen->fullVwin.window, 
        !          1747:          nameList, classList);
        !          1748:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1749:         (XtEventHandler) HandleEnterWindow, EnterWindowMask, (caddr_t)NULL);
        !          1750:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1751:         (XtEventHandler) HandleLeaveWindow, LeaveWindowMask, (caddr_t)NULL);
        !          1752:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1753:         (XtEventHandler) HandleFocusChange, FocusChangeMask, (caddr_t)NULL);
        !          1754:        XtSetEventHandler(screen->display, VWindow(screen),
        !          1755:         (XtEventHandler) VTButtonPressed, ButtonPressMask, (caddr_t)NULL);
        !          1756:        XtSetEventHandler(screen->display, VWindow(screen),
        !          1757:         (XtEventHandler) VTButtonReleased, ButtonReleaseMask, (caddr_t)NULL);
        !          1758:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1759:         (XtEventHandler) VTMouseMoved, ButtonMotionMask, (caddr_t)NULL);
        !          1760:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1761:         (XtEventHandler) VTExpose, ExposureMask, (caddr_t)NULL);
        !          1762:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1763:         (XtEventHandler) VTConfigure, StructureNotifyMask, (caddr_t)NULL);
        !          1764:        XtSetEventHandler(screen->display, VWindow(screen), 
        !          1765:         (XtEventHandler) HandleKeyPressed, KeyPressMask, (caddr_t)NULL);
        !          1766: 
        !          1767:        /*
        !          1768:         * XCreateTerm flushes all events, which might include an EnterWindow
        !          1769:         * or LeaveWindow.  So if the cursor is not where it is supposed to
        !          1770:         * be, we set select to the appropriate thing.
        !          1771:         */
        !          1772:        if(TWindow(screen) && XQueryPointer(
        !          1773:            screen->display,
        !          1774:            DefaultRootWindow(screen->display), 
        !          1775:            &root, &win,
        !          1776:            &root_x, &root_y,
        !          1777:            &x, &y,
        !          1778:            &mask)) {
        !          1779:                if(win == TWindow(screen))
        !          1780:                        screen->select |= INWINDOW;
        !          1781:                else
        !          1782:                        screen->select &= ~INWINDOW;
        !          1783:        }
        !          1784: 
        !          1785:        /* Reset variables used by ANSI emulation. */
        !          1786: 
        !          1787:        screen->gsets[0] = 'B';                 /* ASCII_G              */
        !          1788:        screen->gsets[1] = 'B';
        !          1789:        screen->gsets[2] = 'B';                 /* DEC supplemental.    */
        !          1790:        screen->gsets[3] = 'B';
        !          1791:        screen->curgl = 0;                      /* G0 => GL.            */
        !          1792:        screen->curgr = 2;                      /* G2 => GR.            */
        !          1793:        screen->curss = 0;                      /* No single shift.     */
        !          1794: 
        !          1795:        wmhints.flags = StateHint | InputHint;
        !          1796:        wmhints.input = True;
        !          1797:        if (iconstartup) wmhints.initial_state = IconicState;
        !          1798:        else wmhints.initial_state = NormalState;
        !          1799:         if(icon_geom) {
        !          1800:           wmhints.icon_x = 1; wmhints.icon_y = 1; width = 1; height = 1;
        !          1801:           pr = XParseGeometry(
        !          1802:               icon_geom,
        !          1803:               &wmhints.icon_x, &wmhints.icon_y, 
        !          1804:               &width, &height);
        !          1805:            if((pr & XValue) && (pr & XNegative))
        !          1806:               wmhints.icon_x += 
        !          1807:                 DisplayWidth(screen->display,DefaultScreen(screen->display)) 
        !          1808:                  - width - 2 * screen->borderwidth;
        !          1809:            if((pr & YValue) && (pr & YNegative))
        !          1810:               wmhints.icon_y += 
        !          1811:                 DisplayHeight(screen->display,DefaultScreen(screen->display))
        !          1812:                  - height - 2 * screen->borderwidth;
        !          1813:           if ((XValue&pr) && (YValue&pr)) 
        !          1814:            wmhints.flags |= IconPositionHint;
        !          1815:         }
        !          1816:        XSetWMHints(screen->display, VWindow(screen), &wmhints);
        !          1817: 
        !          1818:        XDefineCursor(screen->display, VWindow(screen), screen->curs );
        !          1819:        XStoreName (screen->display, VWindow(screen), screen->titlename);
        !          1820:        XChangeProperty(
        !          1821:            screen->display, VWindow(screen),
        !          1822:            XA_WM_ICON_NAME, XA_STRING,
        !          1823:            8, PropModeReplace,
        !          1824:            (unsigned char *)screen->iconname, screen->iconnamelen);
        !          1825: 
        !          1826:         screen->cur_col = screen->cur_row = 0;
        !          1827:        screen->max_col = Width(screen)  / screen->fullVwin.f_width - 1;
        !          1828:        screen->top_marg = 0;
        !          1829:        screen->bot_marg = screen->max_row = Height(screen) /
        !          1830:                                screen->fullVwin.f_height - 1;
        !          1831: 
        !          1832:        screen->sc.row = screen->sc.col = screen->sc.flags = NULL;
        !          1833: 
        !          1834:        /* allocate memory for screen buffer */
        !          1835:        screen->buf = screen->allbuf = (ScrnBuf) Allocate (screen->max_row + 1,
        !          1836:                                          screen->max_col +1);
        !          1837: 
        !          1838:        screen->do_wrap = NULL;
        !          1839:        screen->scrolls = screen->incopy = 0;
        !          1840: /*     free((char *)fInfo);    */
        !          1841:        vp = &VTbox[1];
        !          1842:        (vp++)->x = FontWidth(screen) - 1;
        !          1843:        (vp++)->y = FontHeight(screen) - 1;
        !          1844:        (vp++)->x = -(FontWidth(screen) - 1);
        !          1845:        vp->y = -(FontHeight(screen) - 1);
        !          1846:        screen->box = VTbox;
        !          1847: 
        !          1848:        screen->savelines = save_lines;
        !          1849:        screen->savedlines = 0;
        !          1850:        if(screen->scrollbar) {
        !          1851:                screen->scrollbar = 0;
        !          1852:                ScrollBarOn(screen, TRUE);
        !          1853:        }
        !          1854:        return(TRUE);
        !          1855: }
        !          1856: 
        !          1857: /*
        !          1858:  * Shows cursor at new cursor position in screen.
        !          1859:  */
        !          1860: ShowCursor()
        !          1861: {
        !          1862:        register TScreen *screen = &term.screen;
        !          1863:        register int x, y, flags, y1, x1;
        !          1864:        char c;
        !          1865:        GC      currentGC;
        !          1866: 
        !          1867:        if (eventMode != NORMAL) return;
        !          1868: 
        !          1869:        if (screen->cur_row - screen->topline > screen->max_row)
        !          1870:                return;
        !          1871:        c = screen->buf[y = 2 * (screen->cursor_row = screen->cur_row)]
        !          1872:         [x = screen->cursor_col = screen->cur_col];
        !          1873:        flags = screen->buf[y + 1][x];
        !          1874:        if (c == 0)
        !          1875:                c = ' ';
        !          1876: 
        !          1877:        if(screen->select) {
        !          1878: 
        !          1879:                if(flags & INVERSE) { /* is reverse video */
        !          1880:                        if (flags & BOLD) {
        !          1881:                                currentGC = screen->normalboldGC;
        !          1882:                        } else {
        !          1883:                                currentGC = screen->normalGC;
        !          1884:                        }
        !          1885: 
        !          1886:                } else { /* normal video */
        !          1887:                        if (flags & BOLD) {
        !          1888:                                currentGC = screen->reverseboldGC;
        !          1889:                        } else {
        !          1890:                                currentGC = screen->reverseGC;
        !          1891:                        }
        !          1892:                }
        !          1893:        } else { /* not selected */
        !          1894:                if(flags & INVERSE) { /* is reverse video */
        !          1895:                        currentGC = screen->reverseGC;
        !          1896:                } else { /* normal video */
        !          1897:                        currentGC = screen->normalGC;
        !          1898:                }
        !          1899:            
        !          1900:        }
        !          1901: 
        !          1902: 
        !          1903:        x = CursorX (screen, screen->cur_col);
        !          1904:        y = CursorY(screen, screen->cur_row) + 
        !          1905:          screen->fnt_norm->max_bounds.ascent;
        !          1906:        XDrawImageString(screen->display, TextWindow(screen), currentGC,
        !          1907:                x, y, &c, 1);
        !          1908: 
        !          1909:        if((flags & BOLD) && screen->enbolden) /* no bold font */
        !          1910:                XDrawString(screen->display, TextWindow(screen), currentGC,
        !          1911:                        x + 1, y, &c, 1);
        !          1912:        if(flags & UNDERLINE) 
        !          1913:                XDrawLine(screen->display, TextWindow(screen), currentGC,
        !          1914:                        x, y+1, x + FontWidth(screen), y+1);
        !          1915:        if(screen->select) {
        !          1916:               y1 = y - screen->fnt_norm->max_bounds.ascent;
        !          1917:               x1 = x + screen->fnt_norm->max_bounds.lbearing;
        !          1918:                XDrawLine(screen->display, TextWindow(screen), currentGC,
        !          1919:                         x1, y1, x1, y1 + FontHeight(screen)-1);
        !          1920:        } else {
        !          1921:                screen->box->x = x + screen->fnt_norm->max_bounds.lbearing;
        !          1922:                screen->box->y = y - screen->fnt_norm->max_bounds.ascent;
        !          1923:                XDrawLines(screen->display, TextWindow(screen), currentGC,
        !          1924:                        screen->box, NBOX, CoordModePrevious);
        !          1925:        }
        !          1926:        screen->cursor_state = ON;
        !          1927: }
        !          1928: 
        !          1929: /*
        !          1930:  * hide cursor at previous cursor position in screen.
        !          1931:  */
        !          1932: HideCursor()
        !          1933: {
        !          1934:        register TScreen *screen = &term.screen;
        !          1935:        GC      currentGC;
        !          1936:        register int x, y, flags;
        !          1937:        char c;
        !          1938: 
        !          1939:        if(screen->cursor_row - screen->topline > screen->max_row)
        !          1940:                return;
        !          1941:        c = screen->buf[y = 2 * screen->cursor_row][x = screen->cursor_col];
        !          1942:        flags = screen->buf[y + 1][x];
        !          1943: 
        !          1944:        if(flags & INVERSE) {
        !          1945:                if(flags & BOLD) {
        !          1946:                        currentGC = screen->reverseboldGC;
        !          1947:                } else {
        !          1948:                        currentGC = screen->reverseGC;
        !          1949:                }
        !          1950:        } else {
        !          1951:                if(flags & BOLD) {
        !          1952:                        currentGC = screen->normalboldGC;
        !          1953:                } else {
        !          1954:                        currentGC = screen->normalGC;
        !          1955:                }
        !          1956:        }
        !          1957: 
        !          1958:        if (c == 0)
        !          1959:                c = ' ';
        !          1960:        x = CursorX (screen, screen->cursor_col);
        !          1961:        y = (((screen->cursor_row - screen->topline) * FontHeight(screen))) +
        !          1962:         screen->border;
        !          1963:        y = y+screen->fnt_norm->max_bounds.ascent;
        !          1964:        XDrawImageString(screen->display, TextWindow(screen), currentGC,
        !          1965:                x, y, &c, 1);
        !          1966:        if((flags & BOLD) && screen->enbolden)
        !          1967:                XDrawString(screen->display, TextWindow(screen), currentGC,
        !          1968:                        x + 1, y, &c, 1);
        !          1969:        if(flags & UNDERLINE) 
        !          1970:                XDrawLine(screen->display, TextWindow(screen), currentGC,
        !          1971:                        x, y+1, x + FontWidth(screen), y+1);
        !          1972:        screen->cursor_state = OFF;
        !          1973: }
        !          1974: 
        !          1975: VTSelect()
        !          1976: {
        !          1977:        register TScreen *screen = &term.screen;
        !          1978: 
        !          1979:        XSetWindowBorder(screen->display, TextWindow(screen), screen->bordercolor);
        !          1980: }
        !          1981: 
        !          1982: VTUnselect()
        !          1983: {
        !          1984:        register TScreen *screen = &term.screen;
        !          1985: 
        !          1986:        XSetWindowBorderPixmap(screen->display, TextWindow(screen), 
        !          1987:          screen->graybordertile);
        !          1988: }
        !          1989: 
        !          1990: VTReset(full)
        !          1991: int full;
        !          1992: {
        !          1993:        register TScreen *screen = &term.screen;
        !          1994: 
        !          1995:        /* reset scrolling region */
        !          1996:        screen->top_marg = 0;
        !          1997:        screen->bot_marg = screen->max_row;
        !          1998:        term.flags &= ~ORIGIN;
        !          1999:        if(full) {
        !          2000:                TabReset (term.tabs);
        !          2001:                term.keyboard.flags = NULL;
        !          2002:                screen->gsets[0] = 'B';
        !          2003:                screen->gsets[1] = 'B';
        !          2004:                screen->gsets[2] = 'B';
        !          2005:                screen->gsets[3] = 'B';
        !          2006:                screen->curgl = 0;
        !          2007:                screen->curgr = 2;
        !          2008:                screen->curss = 0;
        !          2009:                ClearScreen(screen);
        !          2010:                screen->cursor_state = OFF;
        !          2011:                if(!(term.flags & AUTOREPEAT))
        !          2012:                        XAutoRepeatOn(screen->display);
        !          2013:                if (term.flags & REVERSE_VIDEO)
        !          2014:                        ReverseVideo(&term);
        !          2015: 
        !          2016:                term.flags = term.initflags;
        !          2017:                if(screen->c132 && (term.flags & IN132COLUMNS)) {
        !          2018:                        XResizeWindow(
        !          2019:                            screen->display,
        !          2020:                            TextWindow(screen),
        !          2021:                            (unsigned) 80*FontWidth(screen)
        !          2022:                                + 2 * screen->border + screen->scrollbar,
        !          2023:                            (unsigned) FontHeight(screen)
        !          2024:                                * (screen->max_row + 1) + 2 * screen->border);
        !          2025:                        XSync(screen->display, FALSE);  /* synchronize */
        !          2026:                        if(QLength(screen->display) > 0)
        !          2027:                                xevents();
        !          2028:                }
        !          2029:                CursorSet(screen, 0, 0, term.flags);
        !          2030:        }
        !          2031:        longjmp(vtjmpbuf, 1);   /* force ground state in parser */
        !          2032: }
        !          2033: 
        !          2034: 
        !          2035: #ifdef MODEMENU
        !          2036: #define        MMENU_SCROLL            0
        !          2037: #define        MMENU_VIDEO             (MMENU_SCROLL+1)
        !          2038: #define        MMENU_WRAP              (MMENU_VIDEO+1)
        !          2039: #define        MMENU_REVERSEWRAP       (MMENU_WRAP+1)
        !          2040: #define        MMENU_NLM               (MMENU_REVERSEWRAP+1)
        !          2041: #define        MMENU_CURSOR            (MMENU_NLM+1)
        !          2042: #define        MMENU_PAD               (MMENU_CURSOR+1)
        !          2043: #define        MMENU_REPEAT            (MMENU_PAD+1)
        !          2044: #define        MMENU_SCROLLBAR         (MMENU_REPEAT+1)
        !          2045: #define        MMENU_SCROLLKEY         (MMENU_SCROLLBAR+1)
        !          2046: #define        MMENU_SCROLLINPUT       (MMENU_SCROLLKEY+1)
        !          2047: #define        MMENU_C132              (MMENU_SCROLLINPUT+1)
        !          2048: #define        MMENU_CURSES            (MMENU_C132+1)
        !          2049: #define        MMENU_MARGBELL          (MMENU_CURSES+1)
        !          2050: #define        MMENU_TEKWIN            (MMENU_MARGBELL+1)
        !          2051: #define        MMENU_ALTERN            (MMENU_TEKWIN+1)
        !          2052: #define        MMENU_LINE              (MMENU_ALTERN+1)
        !          2053: #define        MMENU_RESET             (MMENU_LINE+1)
        !          2054: #define        MMENU_FULLRESET         (MMENU_RESET+1)
        !          2055: #define        MMENU_TEKMODE           (MMENU_FULLRESET+1)
        !          2056: #define        MMENU_HIDEVT            (MMENU_TEKMODE+1)
        !          2057: 
        !          2058: static char *vtext[] = {
        !          2059:        "Jump Scroll",
        !          2060:        "Reverse Video",
        !          2061:        "Auto Wraparound",
        !          2062:        "Reverse Wraparound",
        !          2063:        "Auto Linefeed",
        !          2064:        "Application Cursors",
        !          2065:        "Application Pad",
        !          2066:        "Auto Repeat",
        !          2067:        "Scrollbar",
        !          2068:        "Scroll to bottom on key",
        !          2069:        "Scroll to bottom on input",
        !          2070:        "80 <-> 132 Columns",
        !          2071:        "Curses Emulation",
        !          2072:        "Margin Bell",
        !          2073:        "Tek Window Showing",
        !          2074:        "Alternate Screen",
        !          2075:        "-",
        !          2076:        "Soft Reset",
        !          2077:        "Full Reset",
        !          2078:        "Select Tek Mode",
        !          2079:        "Hide VT Window",
        !          2080:        0,
        !          2081: };
        !          2082: 
        !          2083: 
        !          2084: static int menutermflags;
        !          2085: static int menukbdflags;
        !          2086: static int t132;
        !          2087: static int taltern;
        !          2088: static int tcurses;
        !          2089: static int tmarginbell;
        !          2090: static int tscrollbar;
        !          2091: static int tscrollkey;
        !          2092: static int tscrollinput;
        !          2093: static int tshow;
        !          2094: 
        !          2095: Menu *setupmenu(menu)
        !          2096: register Menu **menu;
        !          2097: {
        !          2098:        register TScreen *screen = &term.screen;
        !          2099:        register char **cp;
        !          2100:        register int flags = term.flags;
        !          2101:        register int kflags = term.keyboard.flags;
        !          2102: 
        !          2103:        if (*menu == NULL) {
        !          2104:                if ((*menu = NewMenu("Modes", re_verse)) == NULL)
        !          2105:                        return(NULL);
        !          2106:                for(cp = vtext ; *cp ; cp++)
        !          2107:                        AddMenuItem(*menu, *cp);
        !          2108:                if(!(flags & SMOOTHSCROLL))
        !          2109:                        CheckItem(*menu, MMENU_SCROLL);
        !          2110:                if(flags & REVERSE_VIDEO)
        !          2111:                        CheckItem(*menu, MMENU_VIDEO);
        !          2112:                if(flags & WRAPAROUND)
        !          2113:                        CheckItem(*menu, MMENU_WRAP);
        !          2114:                if(flags & REVERSEWRAP)
        !          2115:                        CheckItem(*menu, MMENU_REVERSEWRAP);
        !          2116:                if(flags & LINEFEED)
        !          2117:                        CheckItem(*menu, MMENU_NLM);
        !          2118:                if(kflags & CURSOR_APL)
        !          2119:                        CheckItem(*menu, MMENU_CURSOR);
        !          2120:                if(kflags & KYPD_APL)
        !          2121:                        CheckItem(*menu, MMENU_PAD);
        !          2122:                if(flags & AUTOREPEAT)
        !          2123:                        CheckItem(*menu, MMENU_REPEAT);
        !          2124:                if(tscrollbar = (screen->scrollbar > 0)) {
        !          2125:                        CheckItem(*menu, MMENU_SCROLLBAR);
        !          2126:                        if(tscrollkey = screen->scrollkey)
        !          2127:                                CheckItem(*menu, MMENU_SCROLLKEY);
        !          2128:                        if(tscrollinput = screen->scrollinput)
        !          2129:                                CheckItem(*menu, MMENU_SCROLLINPUT);
        !          2130:                } else {
        !          2131:                        tscrollkey = FALSE;
        !          2132:                        DisableItem(*menu, MMENU_SCROLLKEY);
        !          2133:                        tscrollinput = FALSE;
        !          2134:                        DisableItem(*menu, MMENU_SCROLLINPUT);
        !          2135:                }
        !          2136:                if(t132 = screen->c132)
        !          2137:                        CheckItem(*menu, MMENU_C132);
        !          2138:                if(tcurses = screen->curses)
        !          2139:                        CheckItem(*menu, MMENU_CURSES);
        !          2140:                if(tmarginbell = screen->marginbell)
        !          2141:                        CheckItem(*menu, MMENU_MARGBELL);
        !          2142:                if(tshow = screen->Tshow)
        !          2143:                        CheckItem(*menu, MMENU_TEKWIN);
        !          2144:                else
        !          2145:                        DisableItem(*menu, MMENU_HIDEVT);
        !          2146:                DisableItem(*menu, MMENU_ALTERN);
        !          2147:                if(taltern = screen->alternate) {
        !          2148:                        CheckItem(*menu, MMENU_ALTERN);
        !          2149:                }
        !          2150:                DisableItem(*menu, MMENU_LINE);
        !          2151:                if(screen->inhibit & I_TEK) {
        !          2152:                        DisableItem(*menu, MMENU_TEKWIN);
        !          2153:                        DisableItem(*menu, MMENU_TEKMODE);
        !          2154:                }
        !          2155:                menutermflags = flags;
        !          2156:                menukbdflags = kflags;
        !          2157:                return(*menu);
        !          2158:        }
        !          2159:        menutermflags ^= flags;
        !          2160:        menukbdflags ^= kflags;
        !          2161:        if (menutermflags & SMOOTHSCROLL)
        !          2162:                SetItemCheck(*menu, MMENU_SCROLL, !(flags & SMOOTHSCROLL));
        !          2163:        if (menutermflags & REVERSE_VIDEO)
        !          2164:                SetItemCheck(*menu, MMENU_VIDEO, flags & REVERSE_VIDEO);
        !          2165:        if (menutermflags & WRAPAROUND)
        !          2166:                SetItemCheck(*menu, MMENU_WRAP, flags & WRAPAROUND);
        !          2167:        if (menutermflags & REVERSEWRAP)
        !          2168:                SetItemCheck(*menu, MMENU_REVERSEWRAP, flags & REVERSEWRAP);
        !          2169:        if (menutermflags & LINEFEED)
        !          2170:                SetItemCheck(*menu, MMENU_NLM, flags & LINEFEED);
        !          2171:        if (menukbdflags & CURSOR_APL)
        !          2172:                SetItemCheck(*menu, MMENU_CURSOR, kflags & CURSOR_APL);
        !          2173:        if (menukbdflags & KYPD_APL)
        !          2174:                SetItemCheck(*menu, MMENU_PAD, kflags & KYPD_APL);
        !          2175:         if (menutermflags & AUTOREPEAT)
        !          2176:                 SetItemCheck(*menu, MMENU_REPEAT, flags & AUTOREPEAT);
        !          2177:        if(tscrollbar != (screen->scrollbar > 0)) {
        !          2178:                SetItemCheck(*menu, MMENU_SCROLLBAR, (tscrollbar =
        !          2179:                 (screen->scrollbar > 0)));
        !          2180:                SetItemDisable(*menu, MMENU_SCROLLKEY, !tscrollbar);
        !          2181:                SetItemCheck(*menu, MMENU_SCROLLKEY,
        !          2182:                 tscrollkey = (tscrollbar && screen->scrollkey));
        !          2183:                SetItemDisable(*menu, MMENU_SCROLLINPUT, !tscrollbar);
        !          2184:                SetItemCheck(*menu, MMENU_SCROLLINPUT,
        !          2185:                 tscrollinput = (tscrollbar && screen->scrollinput));
        !          2186:        } else if (tscrollbar) {
        !          2187:                if (tscrollkey != screen->scrollkey)
        !          2188:                        SetItemCheck(*menu, MMENU_SCROLLKEY,
        !          2189:                         tscrollkey = screen->scrollkey);
        !          2190:                if (tscrollinput != screen->scrollinput)
        !          2191:                        SetItemCheck(*menu, MMENU_SCROLLINPUT,
        !          2192:                         tscrollinput = screen->scrollinput);
        !          2193:        }
        !          2194:        if(t132 != screen->c132)
        !          2195:                SetItemCheck(*menu, MMENU_C132, (t132 = screen->c132));
        !          2196:        if(tcurses != screen->curses)
        !          2197:                SetItemCheck(*menu, MMENU_CURSES, (tcurses = screen->curses));
        !          2198:        if(tmarginbell != screen->marginbell)
        !          2199:                SetItemCheck(*menu, MMENU_MARGBELL, (tmarginbell =
        !          2200:                screen->marginbell));
        !          2201:        if(tshow != screen->Tshow) {
        !          2202:                SetItemCheck(*menu, MMENU_TEKWIN, (tshow = screen->Tshow));
        !          2203:                SetItemDisable(*menu, MMENU_HIDEVT, !tshow);
        !          2204:        }
        !          2205:        if(taltern != screen->alternate) {
        !          2206:                SetItemCheck(*menu, MMENU_ALTERN, (taltern =
        !          2207:                 screen->alternate));
        !          2208:        }
        !          2209:        menutermflags = flags;
        !          2210:        menukbdflags = kflags;
        !          2211:        return(*menu);
        !          2212: }
        !          2213: 
        !          2214: domenufunc(item)
        !          2215: int item;
        !          2216: {
        !          2217:        register TScreen *screen = &term.screen;
        !          2218: 
        !          2219:        switch (item) {
        !          2220:        case MMENU_SCROLL:
        !          2221:                term.flags ^= SMOOTHSCROLL;
        !          2222:                if (term.flags & SMOOTHSCROLL) {
        !          2223:                        screen->jumpscroll = FALSE;
        !          2224:                        if (screen->scroll_amt)
        !          2225:                                FlushScroll(screen);
        !          2226:                } else
        !          2227:                        screen->jumpscroll = TRUE;
        !          2228:                break;
        !          2229: 
        !          2230:        case MMENU_VIDEO:
        !          2231:                term.flags ^= REVERSE_VIDEO;
        !          2232:                ReverseVideo(&term);
        !          2233:                break;
        !          2234: 
        !          2235:        case MMENU_WRAP:
        !          2236:                term.flags ^= WRAPAROUND;
        !          2237:                break;
        !          2238: 
        !          2239:        case MMENU_REVERSEWRAP:
        !          2240:                term.flags ^= REVERSEWRAP;
        !          2241:                break;
        !          2242: 
        !          2243:        case MMENU_NLM:
        !          2244:                term.flags ^= LINEFEED;
        !          2245:                break;
        !          2246: 
        !          2247:        case MMENU_CURSOR:
        !          2248:                term.keyboard.flags ^= CURSOR_APL;
        !          2249:                break;
        !          2250: 
        !          2251:        case MMENU_PAD:
        !          2252:                term.keyboard.flags ^= KYPD_APL;
        !          2253:                break;
        !          2254: 
        !          2255:        case MMENU_REPEAT:
        !          2256:                term.flags ^= AUTOREPEAT;
        !          2257:                if (term.flags & AUTOREPEAT)
        !          2258:                        XAutoRepeatOn(screen->display);
        !          2259:                else
        !          2260:                        XAutoRepeatOff(screen->display);
        !          2261:                break;
        !          2262: 
        !          2263:        case MMENU_SCROLLBAR:
        !          2264:                if(screen->scrollbar)
        !          2265:                        ScrollBarOff(screen);
        !          2266:                else
        !          2267:                        ScrollBarOn(screen, FALSE);
        !          2268:                break;
        !          2269: 
        !          2270:        case MMENU_SCROLLKEY:
        !          2271:                screen->scrollkey = !screen->scrollkey;
        !          2272:                break;
        !          2273: 
        !          2274:        case MMENU_SCROLLINPUT:
        !          2275:                screen->scrollinput = !screen->scrollinput;
        !          2276:                break;
        !          2277: 
        !          2278:                
        !          2279:        case MMENU_C132:
        !          2280:                screen->c132 = !screen->c132;
        !          2281:                break;
        !          2282: 
        !          2283:        case MMENU_MARGBELL:
        !          2284:                if(!(screen->marginbell = !screen->marginbell))
        !          2285:                        screen->bellarmed = -1;
        !          2286:                break;
        !          2287: 
        !          2288:        case MMENU_CURSES:
        !          2289:                screen->curses = !screen->curses;
        !          2290:                break;
        !          2291: 
        !          2292:        case MMENU_FULLRESET:
        !          2293:                VTReset(TRUE);
        !          2294:                break;
        !          2295: 
        !          2296:        case MMENU_RESET:
        !          2297:                VTReset(FALSE);
        !          2298:                break;
        !          2299: 
        !          2300:        case MMENU_HIDEVT:
        !          2301:                XUnmapWindow(screen->display, VWindow(screen));
        !          2302:                reselectwindow(screen);
        !          2303:                SyncUnmap(VWindow(screen), WINDOWEVENTS);
        !          2304:                        /* drop through */
        !          2305:        case MMENU_TEKMODE:
        !          2306:                if(!screen->TekEmu) {
        !          2307:                        if(screen->logging) {
        !          2308:                                FlushLog(screen);
        !          2309:                                screen->logstart = Tbuffer;
        !          2310:                        }
        !          2311:                        screen->TekEmu = TRUE;
        !          2312:                        longjmp(VTend, 1);
        !          2313:                } else
        !          2314:                        XRaiseWindow(screen->display, TWindow(screen));
        !          2315:                break;
        !          2316: 
        !          2317:        case MMENU_TEKWIN:
        !          2318:                if(screen->Tshow = !screen->Tshow) {
        !          2319:                        if(TWindow(screen) || TekInit()) {
        !          2320:                                XMapWindow(screen->display, TWindow(screen));
        !          2321:                                screen->Tshow = TRUE;
        !          2322:                        }
        !          2323:                } else {
        !          2324:                        screen->Tshow = FALSE;
        !          2325:                        XUnmapWindow(screen->display, TWindow(screen));
        !          2326:                        SyncUnmap(TWindow(screen), TWINDOWEVENTS);
        !          2327:                        if(screen->TekEmu) {
        !          2328:                                if(screen->logging) {
        !          2329:                                        FlushLog(screen);
        !          2330:                                        screen->logstart = buffer;
        !          2331:                                }
        !          2332:                                longjmp(Tekend, 1);
        !          2333:                        }
        !          2334:                }
        !          2335:                reselectwindow(screen);
        !          2336:                break;
        !          2337:        }
        !          2338: }
        !          2339: #endif MODEMENU
        !          2340: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.