Annotation of researchv9/jtools/src/tek/jek.c, revision 1.1

1.1     ! root        1: #include "jerq.h"
        !             2: #include <signal.h>
        !             3: 
        !             4: #define        CURSOR  '\001'
        !             5: 
        !             6: #define NUL '\000'
        !             7: #define SOH '\001'
        !             8: #define STX '\002'
        !             9: #define ETX '\003'
        !            10: #define EOT '\004'
        !            11: #define ENQ '\005'
        !            12: #define ACK '\006'
        !            13: #define BEL '\007'
        !            14: #define BS  '\010'
        !            15: #define HT  '\011'
        !            16: #define NL  '\012'
        !            17: #define VT  '\013'
        !            18: #define FF  '\014'
        !            19: #define CR  '\015'
        !            20: #define SO  '\016'
        !            21: #define SI  '\017'
        !            22: #define DLE '\020'
        !            23: #define DC1 '\021'
        !            24: #define DC2 '\022'
        !            25: #define DC3 '\023'
        !            26: #define DC4 '\024'
        !            27: #define NAK '\025'
        !            28: #define SYN '\026'
        !            29: #define ETB '\027'
        !            30: #define CAN '\030'
        !            31: #define EM  '\031'
        !            32: #define SUB '\032'
        !            33: #define ESC '\033'
        !            34: #define FS  '\034'
        !            35: #define GS  '\035'
        !            36: #define RS  '\036'
        !            37: #define US  '\037'
        !            38: #define DEL '\177'
        !            39: 
        !            40: #define NORMAL         0
        !            41: #define DEFOCUSED      1
        !            42: #define WRITETHRU      2
        !            43: 
        !            44: #define OUTMODED       -1
        !            45: #define DISALLOWED     0
        !            46: #define ALLOWED                1
        !            47: #define FLASHED                2
        !            48: #define PENDING                3
        !            49: #define DIMMED         4
        !            50: #define REMOTE         6
        !            51: #define LOCAL          7
        !            52: #define ALPHA          8
        !            53: #define GIN            9
        !            54: #define GRAPH          10
        !            55: #define POINT          11
        !            56: #define SPECIALPOINT   12
        !            57: #define INCREMENTAL    13
        !            58: #define RESET          14
        !            59: #define EXIT           15
        !            60: 
        !            61: #define SAVEC          64
        !            62: #define SAVEL          32
        !            63: #define SAVEP          128
        !            64: 
        !            65: #define TEKXMAX                4096
        !            66: #define TEKYMAX                3120
        !            67: 
        !            68: #define MAGICSIZE      16
        !            69: 
        !            70: /* There is no checking on buffer overrun in magic mode, since there is no
        !            71:    way to recover if it happens. */
        !            72: 
        !            73: char magicbase[MAGICSIZE],*magicbot=magicbase,*magictop=magicbase;
        !            74: 
        !            75: short menu2_bits[] = {
        !            76:         0x1FF8, 0x1008, 0x1008, 0x1008,
        !            77:         0x1FF8, 0x1FF8, 0x1FF8, 0x1C38,
        !            78:         0x1188, 0x13C8, 0x1188, 0x1DB8,
        !            79:         0x1188, 0x1008, 0x1008, 0x1FF8,
        !            80: };
        !            81: Cursor menu2;
        !            82: 
        !            83: short sunset_bits[] = {
        !            84:         0x5006, 0xA819, 0x00A0, 0x04A0,
        !            85:         0x049F, 0x12A4, 0x0808, 0x03E0,
        !            86:         0x2412, 0x0808, 0x0808, 0x3FFF,
        !            87:         0x3C1F, 0x7E7E, 0x783E, 0xFCFC,
        !            88: };
        !            89: Cursor sunset;
        !            90: 
        !            91: short none_bits[] = {
        !            92:        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        !            93: };
        !            94: Cursor none;
        !            95: 
        !            96: short grey_bits[] = {
        !            97:        0x1111, 0x4444, 0x1111, 0x4444, 0x1111, 0x4444, 0x1111, 0x4444,
        !            98:        0x1111, 0x4444, 0x1111, 0x4444, 0x1111, 0x4444, 0x1111, 0x4444,
        !            99: };
        !           100: Texture grey;
        !           101: 
        !           102: short hdots_bits[] = {
        !           103:         0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
        !           104:         0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
        !           105:         0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
        !           106:         0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
        !           107: };
        !           108: Texture hdots;
        !           109: 
        !           110: short vdots_bits[] = {
        !           111:         0xFFFF, 0x0000, 0xFFFF, 0x0000,
        !           112:         0xFFFF, 0x0000, 0xFFFF, 0x0000,
        !           113:         0xFFFF, 0x0000, 0xFFFF, 0x0000,
        !           114:         0xFFFF, 0x0000, 0xFFFF, 0x0000,
        !           115: };
        !           116: Texture vdots;
        !           117: 
        !           118: char style_dotted[] = { 2, 2, 0};
        !           119: char style_dot_dash[] = {7, 2, 2, 1, 2, 2, 0};
        !           120: char style_short_dash[] = {4, 4, 0};
        !           121: char style_long_dash[] = {8, 8, 0};
        !           122: char *styles[] = {
        !           123:                        0,                      /*       = 0 ==> solid          */
        !           124:                        style_dotted,           /*       = 1 ==> dotted         */
        !           125:                        style_dot_dash,         /*       = 2 ==> dot-dash       */
        !           126:                        style_short_dash,       /*       = 3 ==> short-dash     */
        !           127:                        style_long_dash,        /*       = 4 ==> long-dash      */
        !           128: };
        !           129: 
        !           130: extern Font defont;
        !           131: 
        !           132: int width[]={56,51,34,31,56,51,34,31},height[]={88,82,53,48,88,82,53,48};
        !           133: Font *font[8];
        !           134: 
        !           135: /* Map for size 16 x 16 */
        !           136: 
        !           137: unsigned char dither[16][16] = {
        !           138: 127, 223,  95, 247, 119, 215,  87, 253, 125, 221,  93, 245, 117, 213,  85, 255, 
        !           139: 128,  32, 160,   8, 136,  40, 168,   2, 130,  34, 162,  10, 138,  42, 170,   0, 
        !           140:  64, 224,  96, 200,  72, 232, 104, 194,  66, 226,  98, 202,  74, 234, 106, 192, 
        !           141: 176,  16, 144,  56, 184,  24, 152,  50, 178,  18, 146,  58, 186,  26, 154,  48, 
        !           142: 112, 208,  80, 248, 120, 216,  88, 242, 114, 210,  82, 250, 122, 218,  90, 240, 
        !           143: 140,  44, 172,   4, 132,  36, 164,  14, 142,  46, 174,   6, 134,  38, 166,  12, 
        !           144:  76, 236, 108, 196,  68, 228, 100, 206,  78, 238, 110, 198,  70, 230, 102, 204, 
        !           145: 188,  28, 156,  52, 180,  20, 148,  62, 190,  30, 158,  54, 182,  22, 150,  60, 
        !           146: 124, 220,  92, 244, 116, 212,  84, 254, 126, 222,  94, 246, 118, 214,  86, 252, 
        !           147: 131,  35, 163,  11, 139,  43, 171,   1, 129,  33, 161,   9, 137,  41, 169,   3, 
        !           148:  67, 227,  99, 203,  75, 235, 107, 193,  65, 225,  97, 201,  73, 233, 105, 195, 
        !           149: 179,  19, 147,  59, 187,  27, 155,  49, 177,  17, 145,  57, 185,  25, 153,  51, 
        !           150: 115, 211,  83, 251, 123, 219,  91, 241, 113, 209,  81, 249, 121, 217,  89, 243, 
        !           151: 143,  47, 175,   7, 135,  39, 167,  13, 141,  45, 173,   5, 133,  37, 165,  15, 
        !           152:  79, 239, 111, 199,  71, 231, 103, 205,  77, 237, 109, 197,  69, 229, 101, 207, 
        !           153: 191,  31, 159,  55, 183,  23, 151,  61, 189,  29, 157,  53, 181,  21, 149,  63, 
        !           154: };
        !           155: 
        !           156: int dispmode, kbdmode, tekmargin, currfont, penstate, flash_state, flashmode,
        !           157:     dim_state, zaxis, drawallowed, bypass, intensity, aplmode, dithermode,
        !           158:     lastmouse, smear, F_DRAW, lockfont;
        !           159: char *linestyle;
        !           160: Point tekcursor,tekhairs,jerqcursor,jerqhairs;
        !           161: Point jerqorigin,jerqsize;
        !           162: Rectangle jerqrect;
        !           163: 
        !           164: int DELimpliesLOY = 0, LFeffect = 0, CReffect = 0,
        !           165:     GINcount = 5, DIMallowed = ALLOWED;
        !           166: 
        !           167: char *switchtext[]=
        !           168:        {"local","page","reset","font","flash","random",
        !           169:         "focus","shift","exit",NULL};
        !           170: Menu switchmenu={switchtext};
        !           171: 
        !           172: char *fonttext[]=
        !           173:        {"lock  ","apl   "," jumbo"," big  "," small"," tiny ",NULL};
        !           174: Menu fontmenu={fonttext};
        !           175: 
        !           176: int waitforchar() 
        !           177: {
        !           178: 
        !           179:        int perm,xoff;
        !           180:        int c,delay;
        !           181: 
        !           182:        perm = RCV|KBD|MOUSE;
        !           183:        xoff = 0;
        !           184: /*     flash_state = ALLOWED;*/
        !           185:        flash_state = DISALLOWED;
        !           186:        if (dispmode == ALPHA)
        !           187:                dim_state = DIMallowed;
        !           188:        else
        !           189:                dim_state = DISALLOWED;
        !           190:        for(;;) {
        !           191: /* 
        !           192:  *             if (got&ALARM) {
        !           193:  *                     if (flash_state == ALLOWED) {
        !           194:  *                             flash_state = flash();
        !           195:  *                             alarm(6);
        !           196:  *                     } else if (flash_state == FLASHED) {
        !           197:  *                             unflash();
        !           198:  *                             flash_state = DISALLOWED;
        !           199:  *                             alarm(60);
        !           200:  *                     } else if (dim_state == ALLOWED) {
        !           201:  *                             dim_state = PENDING;
        !           202:  *                             alarm(60);
        !           203:  *                             delay = 90;
        !           204:  *                     } else if ((dim_state == PENDING) && (--delay == 0)) {
        !           205:  *                             dim_state = dim();
        !           206:  *                             alarm(60);
        !           207:  *             }
        !           208:  */
        !           209:                wait(perm);
        !           210:                if (P->state&RESHAPED) {
        !           211:                        c = reshape();
        !           212:                        if (c == OUTMODED)
        !           213:                                break;
        !           214:                }
        !           215:                if (button123()) {
        !           216:                        if button3()
        !           217:                                continue;
        !           218:                        else if ((c = dobuttons()) != ALLOWED)
        !           219:                                break;
        !           220:                }
        !           221:                if (P->state&KBD) {
        !           222:                        c = kbdchar();
        !           223: /*
        !           224:  *                     if (c == 0xB2) {
        !           225:  *                             addmagic(ESC);
        !           226:  *                             addmagic(FF);
        !           227:  *                     } else
        !           228:  */
        !           229:                        if (dispmode == GIN) {
        !           230:                                if (kbdmode == REMOTE) {
        !           231:                                        /*sendchar(c);*/
        !           232:                                        reportcursor(c, tekhairs);
        !           233:                                        dispmode = ALPHA;
        !           234:                                        c = OUTMODED;
        !           235:                                        break;
        !           236:                                } /* else
        !           237:                                        throw character away; */
        !           238:                        } else {
        !           239:                                if (kbdmode == LOCAL)
        !           240:                                        break;
        !           241:                                if (c == DC3) {
        !           242:                                        perm &= ~RCV;
        !           243:                                        xoff = 1;
        !           244:                                } else {
        !           245:                                        if (xoff) {
        !           246:                                                xoff = 0;
        !           247:                                                perm |= RCV;
        !           248:                                                if (c != DC1)
        !           249:                                                        sendchar(c);
        !           250:                                        } else
        !           251:                                                sendchar(c);
        !           252:                                }
        !           253:                        }
        !           254:                }
        !           255:                if ((c = magicchar()) != -1)
        !           256:                        break;
        !           257:                if ((perm&RCV) && P->state&RCV) {
        !           258:                        c = rcvchar();
        !           259:                        if (kbdmode != LOCAL)
        !           260:                                break;
        !           261:                }
        !           262:        }
        !           263: /*     if (flash_state == FLASHED)
        !           264:  *             unflash();
        !           265:  */
        !           266:        if (dim_state == DIMMED)
        !           267:                undim();
        !           268:        return c;
        !           269: }
        !           270: 
        !           271: int dim() {
        !           272:        texture(&display,jerqrect,&grey,F_XOR);
        !           273:        return DIMMED;
        !           274: }
        !           275: 
        !           276: undim() {
        !           277:        texture(&display,jerqrect,&grey,F_XOR);
        !           278: }
        !           279: 
        !           280: int magicchar() {
        !           281:        if (magicbot < magictop)
        !           282:                return *magicbot++;
        !           283:        magicbot = magictop = magicbase;
        !           284:        return -1;
        !           285: }
        !           286: 
        !           287: addmagic(c)
        !           288: char c;
        !           289: {
        !           290:        *magictop++ = c;
        !           291: }
        !           292: 
        !           293: clearmagic()
        !           294: {
        !           295:        magicbot = magictop = magicbase;
        !           296: }
        !           297: 
        !           298: Point jerqtotek(p)
        !           299: Point p;
        !           300: {
        !           301:        Point q;
        !           302: 
        !           303:        q.x = muldiv(p.x - jerqorigin.x,TEKXMAX,jerqsize.x);
        !           304:        q.y = TEKYMAX - muldiv(p.y - jerqorigin.y,TEKYMAX,jerqsize.y);
        !           305:        if (q.x < 0)
        !           306:                q.x = 0;
        !           307:        if (q.x >= TEKXMAX)
        !           308:                q.x = TEKXMAX-1;
        !           309:        if (q.y < 0)
        !           310:                q.y = 0;
        !           311:        if (q.y >= TEKYMAX)
        !           312:                q.y = TEKYMAX-1;
        !           313:        return q;
        !           314: }
        !           315: 
        !           316: static int *xtab, *ytab;
        !           317: 
        !           318: maketable()
        !           319: {
        !           320:        int x, y, *p;
        !           321:        for (x=0, p=xtab; x<TEKXMAX; x++)
        !           322:                *p++ = jerqorigin.x + muldiv(x,jerqsize.x,TEKXMAX);
        !           323:        for (y=0, p=ytab; y<TEKYMAX; y++)
        !           324:                *p++ = jerqorigin.y + muldiv(TEKYMAX-y,jerqsize.y,TEKYMAX);
        !           325: }
        !           326: 
        !           327: Point tektojerq(p)
        !           328: Point p;
        !           329: {
        !           330:        Point q;
        !           331: 
        !           332:        q.x = xtab[p.x];
        !           333:        q.y = ytab[p.y];
        !           334:        return q;
        !           335: }
        !           336: 
        !           337: reportcursor(c, p)
        !           338: Point p;
        !           339: {
        !           340:        static char buf[]={' ',' ',' ',' ',' ',CR,EOT};
        !           341: 
        !           342:        buf[0] = c;
        !           343:        buf[1] = 040 | (p.x>>7);
        !           344:        buf[2] = 040 | ((p.x>>2)&037);
        !           345:        buf[3] = 040 | (p.y>>7);
        !           346:        buf[4] = 040 | ((p.y>>2)&037);
        !           347:        if (c)
        !           348:                sendnchars(GINcount+1,buf);
        !           349:        else
        !           350:                sendnchars(GINcount,buf+1);
        !           351: }
        !           352: 
        !           353: int reshape() {
        !           354:        int omode;
        !           355:        P->state &= ~RESHAPED;
        !           356:        jerqorigin = add(display.rect.origin,Pt(5,7));
        !           357:        jerqsize = sub(sub(display.rect.corner,Pt(5,7)), jerqorigin);
        !           358:        jerqrect = inset(display.rect,3);
        !           359:        maketable();
        !           360:        jerqcursor = tektojerq(tekcursor);
        !           361:        jerqhairs = tektojerq(tekhairs);
        !           362:        omode = dispmode;
        !           363:        clearscreen();
        !           364:        if (omode == GIN)
        !           365:                hairs(jerqhairs);
        !           366:        addmagic(ESC);
        !           367:        addmagic(FF);
        !           368:        return OUTMODED;
        !           369: }
        !           370: 
        !           371: hairs(p)
        !           372: Point p;
        !           373: {
        !           374:        texture(&display,Rect(0,p.y,Drect.corner.x,p.y+1),&hdots,F_XOR);
        !           375:        texture(&display,Rect(p.x,0,p.x+1,Drect.corner.y),&vdots,F_XOR);
        !           376: }
        !           377: 
        !           378: dofontmenu() {
        !           379:        Cursor *old;
        !           380:        int which, oldfont;
        !           381:        static char *whichmagic = "89:;";
        !           382:        if (lockfont) {
        !           383:                switchtext[3] = "font";
        !           384:                lockfont = 0;
        !           385:                return;
        !           386:        }
        !           387:        old = cursswitch(&menu2);
        !           388:        while (!button123())
        !           389:                wait(MOUSE);
        !           390:        if (button13()) {
        !           391:                cursswitch(old);
        !           392:                return;
        !           393:        }
        !           394:        if (aplmode)
        !           395:                fonttext[1] = "ascii ";
        !           396:        else
        !           397:                fonttext[1] = "apl   ";
        !           398:        oldfont = currfont - aplmode + 2;
        !           399:        fonttext[oldfont][0] = '>';
        !           400:        cursswitch((Texture *)0);
        !           401:        switch(which = menuhit(&fontmenu,2)) {
        !           402:                case 0:
        !           403:                        lockfont = 1;
        !           404:                        switchtext[3] = "unlock font";
        !           405:                        break;
        !           406:                case 2:
        !           407:                case 3:
        !           408:                case 4:
        !           409:                case 5:
        !           410:                        addmagic(ESC);
        !           411:                        addmagic(whichmagic[which-2]);
        !           412:                        break;
        !           413:                case 1:
        !           414:                        addmagic(ESC);
        !           415:                        if (aplmode)
        !           416:                                addmagic(SI);
        !           417:                        else
        !           418:                                addmagic(SO);
        !           419:                        break;
        !           420:        }
        !           421:        fonttext[oldfont][0] = ' ';
        !           422:        cursswitch(old);
        !           423: }
        !           424: 
        !           425: int dobuttons() {
        !           426: /* returns ALLOWED if waitforchar should continue; else char to return */
        !           427:        Cursor *old;
        !           428:        Point p;
        !           429:        if (button1() && (dispmode == GIN) &&(flash_state == DISALLOWED)) {
        !           430:                old = cursswitch(&none);
        !           431:                while (button1()) {
        !           432:                        p = mouse.xy;
        !           433:                        if ((!eqpt(p,jerqhairs)) && ptinrect(p,jerqrect)) {
        !           434:                                hairs(jerqhairs);
        !           435:                                jerqhairs = p;
        !           436:                                tekhairs = jerqtotek(jerqhairs);
        !           437:                                hairs(jerqhairs);
        !           438:                        }
        !           439:                        wait(MOUSE);
        !           440:                }
        !           441:                cursswitch(old);
        !           442:                return ALLOWED;
        !           443:        }
        !           444:        if (button2()) {
        !           445:                if (dim_state == DIMMED) {
        !           446:                        switchtext[7] = "shift";
        !           447:                        switchtext[8] = "exit";
        !           448:                        switchtext[9] = NULL;
        !           449:                } else {
        !           450:                        switchtext[7] = "exit";
        !           451:                        switchtext[8] = NULL;
        !           452:                }
        !           453:                switch(menuhit(&switchmenu,2)) {
        !           454:                        case 0:
        !           455:                                if (kbdmode == REMOTE) {
        !           456:                                        switchtext[0] = "line";
        !           457:                                        kbdmode = LOCAL;
        !           458:                                } else {
        !           459:                                        switchtext[0] = "local";
        !           460:                                        kbdmode = REMOTE;
        !           461:                                }
        !           462:                                return ALLOWED;
        !           463:                        case 1:
        !           464:                                addmagic(ESC);
        !           465:                                addmagic(FF);
        !           466:                                return ALLOWED;
        !           467:                        case 2:
        !           468:                                dispmode = RESET;
        !           469:                                return OUTMODED;
        !           470:                        case 3:
        !           471:                                dofontmenu();
        !           472:                                return ALLOWED;
        !           473:                        case 4:
        !           474:                                if (flashmode) {
        !           475:                                        switchtext[4] = "flash";
        !           476:                                        flashmode = 0;
        !           477:                                } else {
        !           478:                                        switchtext[4] = "no flash";
        !           479:                                        flashmode = 1;
        !           480:                                }
        !           481:                                return ALLOWED;
        !           482:                        case 5: 
        !           483:                                if (dithermode) {
        !           484:                                        switchtext[5] = "dither";
        !           485:                                        dithermode = 0;
        !           486:                                } else {
        !           487:                                        switchtext[5] = "random";
        !           488:                                        dithermode = 1;
        !           489:                                }
        !           490:                                return ALLOWED;
        !           491:                        case 6: if (smear) {
        !           492:                                        switchtext[6] = "smear";
        !           493:                                        smear = 0;
        !           494:                                } else {
        !           495:                                        switchtext[6] = "focus";
        !           496:                                        smear = 1;
        !           497:                                }
        !           498:                                return ALLOWED;
        !           499:                        case 7:
        !           500:                                if (dim_state == DIMMED)
        !           501:                                        return DISALLOWED;
        !           502:                                /* else fall through */
        !           503:                        case 8:
        !           504:                                old = cursswitch(&sunset);
        !           505:                                while (!button123())
        !           506:                                        wait(MOUSE);
        !           507:                                while (button3())
        !           508:                                        wait(MOUSE);
        !           509:                                cursswitch(old);
        !           510:                                if (button12()) {
        !           511:                                        while (button123())
        !           512:                                                wait(MOUSE);
        !           513:                                        return ALLOWED;
        !           514:                                }
        !           515:                                dispmode = EXIT;
        !           516:                                return OUTMODED;
        !           517:                }
        !           518:        }
        !           519:        return ALLOWED;
        !           520: }
        !           521: 
        !           522: statemachine()
        !           523: {
        !           524:        for(dispmode = RESET; dispmode != EXIT; ) {
        !           525:                switch(dispmode) {
        !           526:                        case RESET:
        !           527:                                resetmode();
        !           528:                                break;
        !           529:                        case ALPHA:
        !           530:                                alphamode();
        !           531:                                break;
        !           532:                        case GIN:
        !           533:                                ginmode();
        !           534:                                break;
        !           535:                        case GRAPH:
        !           536:                        case POINT:
        !           537:                                graphmode();
        !           538:                                break;
        !           539:                        case SPECIALPOINT:
        !           540:                                specialpointmode();
        !           541:                                break;
        !           542:                        case INCREMENTAL:
        !           543:                                incrementalmode();
        !           544:                                break;
        !           545:                }
        !           546:        }
        !           547: }
        !           548: 
        !           549: resetmode() {
        !           550:        intensity = 100;
        !           551:        if (!lockfont) {
        !           552:                currfont = 0;
        !           553:                aplmode = 0;
        !           554:                defont = *font[currfont];
        !           555: #ifdef X11
        !           556:                XSetFont(dpy, gc, defont.fid);
        !           557: #endif X11
        !           558:        }
        !           559:        homecursor();
        !           560:        dispmode = ALPHA;
        !           561:        zaxis = NORMAL;
        !           562:        linestyle = styles[0];
        !           563: /*     flash_state = ALLOWED; */
        !           564:        /*flashmode = 0;*/
        !           565: }
        !           566: 
        !           567: int controlchar(c)
        !           568: int c;
        !           569: {
        !           570:        if (c == OUTMODED)
        !           571:                return;
        !           572:        switch(c) {
        !           573:                case BEL:
        !           574:                        ringbell();
        !           575:                        bypass = 0;
        !           576:                        return 0;
        !           577:                case BS:
        !           578:                case HT:
        !           579:                case VT:
        !           580:                        bypass = 0;
        !           581:                        if (dispmode == ALPHA)
        !           582:                                return c;
        !           583:                        return 0;
        !           584:                case CR:
        !           585:                        if (dispmode == ALPHA) {
        !           586:                                if (CReffect)
        !           587:                                        addmagic(NL);
        !           588:                                return c;
        !           589:                        }
        !           590:                        dispmode = ALPHA;
        !           591:                        bypass = 0;
        !           592:                        addmagic(c);
        !           593:                        if (CReffect)
        !           594:                                addmagic(NL);
        !           595:                        return OUTMODED;
        !           596:                case FS:
        !           597:                        if ((dispmode == ALPHA) || (dispmode == GRAPH)) {
        !           598:                                dispmode = POINT;
        !           599:                                return OUTMODED;
        !           600:                        }
        !           601:                        return 0;
        !           602:                case GS:
        !           603:                        if ((dispmode == ALPHA) || (dispmode == GRAPH)) {
        !           604:                                dispmode = GRAPH;
        !           605:                                drawallowed = 0;
        !           606:                                return OUTMODED;
        !           607:                        }
        !           608:                        return 0;
        !           609:                case NL:
        !           610:                        if (LFeffect)
        !           611:                                addmagic(CR);
        !           612:                        if (dispmode == ALPHA)
        !           613:                                return c;
        !           614:                        return 0;
        !           615:                case RS:
        !           616:                        if (dispmode != GIN) {
        !           617:                                dispmode = INCREMENTAL;
        !           618:                                penstate = 0;
        !           619:                                return OUTMODED;
        !           620:                        }
        !           621:                        return 0;
        !           622:                case US:
        !           623:                        if (dispmode == ALPHA)
        !           624:                                return 0;
        !           625:                        dispmode = ALPHA;
        !           626:                        bypass = 0;
        !           627:                        return OUTMODED;
        !           628:                case ESC:
        !           629:                        return escmode();
        !           630:                default:
        !           631:                        if (c < 040)
        !           632:                                return 0;
        !           633:                        return c;
        !           634:        }
        !           635: }
        !           636: 
        !           637: int escmode() {
        !           638:        int c,ignore;
        !           639: 
        !           640:        do {
        !           641:                c = waitforchar();
        !           642:                ignore = 0;
        !           643:                switch(c) {
        !           644:                case CAN:
        !           645:                        bypass = 1;
        !           646:                        return 0;
        !           647:                case OUTMODED:
        !           648:                case CR:
        !           649:                        ignore = 1;
        !           650:                        break;
        !           651:                case ENQ:
        !           652:                        bypass = 1;
        !           653:                        if (dispmode != GIN) {
        !           654:                                /*sendchar(status());*/
        !           655:                                reportcursor(status(), tekcursor);
        !           656:                                return 0;
        !           657:                        } 
        !           658:                        reportcursor(0, tekhairs);
        !           659:                        dispmode = ALPHA;
        !           660:                        return OUTMODED;
        !           661:                case ETB:
        !           662:                        /* Hard copy */
        !           663:                        bypass = 0;
        !           664:                        return 0;
        !           665:                case FF:
        !           666:                        clearscreen();
        !           667:                        homecursor();
        !           668:                        bypass = 0;
        !           669:                        dispmode = ALPHA;
        !           670:                        return OUTMODED;
        !           671:                case FS:
        !           672:                        if ((dispmode == INCREMENTAL) || ( dispmode == GIN))
        !           673:                                return 0;
        !           674:                        dispmode = SPECIALPOINT;
        !           675:                        return OUTMODED;
        !           676:                case SI:
        !           677:                        
        !           678:                        if (aplmode && !lockfont) {
        !           679:                                currfont -= aplmode;
        !           680:                                aplmode = 0;
        !           681:                                goto outfont;
        !           682:                        }
        !           683:                        return 0;
        !           684:                case SO:
        !           685:                        if (!aplmode && !lockfont) {
        !           686:                                aplmode = 4;
        !           687:                                currfont += aplmode;
        !           688:                                goto outfont;
        !           689:                        }
        !           690:                        return 0;
        !           691:                case SUB:
        !           692:                        dispmode = GIN;
        !           693:                        bypass = 1;
        !           694:                        return OUTMODED;
        !           695:                case '8':
        !           696:                        if (!lockfont) {
        !           697:                                currfont = 0 + aplmode;
        !           698:                                goto outfont;
        !           699:                        }
        !           700:                        return 0;
        !           701:                case '9':
        !           702:                        if (!lockfont) {
        !           703:                                currfont = 1 + aplmode;
        !           704:                                goto outfont;
        !           705:                        }
        !           706:                        return 0;
        !           707:                case ':':
        !           708:                        if (!lockfont) {
        !           709:                                currfont = 2 + aplmode;
        !           710:                                goto outfont;
        !           711:                        }
        !           712:                        return 0;
        !           713:                case ';':
        !           714:                        if (!lockfont) {
        !           715:                                currfont = 3 + aplmode;
        !           716: outfont:
        !           717:                                defont = *font[currfont];
        !           718: #ifdef X11
        !           719:                                XSetFont(dpy, gc, defont.fid);
        !           720: #endif X11
        !           721:                        }
        !           722:                        return 0;
        !           723:                default:
        !           724:                        if ((c=='?') && (DELimpliesLOY))
        !           725:                                return DEL;
        !           726:                        if ((c<'`')||(c>'w'))
        !           727:                                break;
        !           728:                        c -= '`';
        !           729:                        if (((c + 1) & 7) >= 6)
        !           730:                                break;
        !           731:                        zaxis = c / 8;
        !           732:                                /* zaxis = 0 ==> Normal
        !           733:                                 *       = 1 ==> Defocused
        !           734:                                 *       = 2 ==> Write-through
        !           735:                                 */
        !           736:                        if ((c + 1) & 7)
        !           737:                                linestyle = styles[c & 7];
        !           738:                                /*       = 0 ==> solid
        !           739:                                 *       = 1 ==> dotted
        !           740:                                 *       = 2 ==> dot-dash
        !           741:                                 *       = 3 ==> short-dash
        !           742:                                 *       = 4 ==> long-dash
        !           743:                                 */
        !           744:                        return 0;
        !           745:                }
        !           746:        } while (ignore);
        !           747:        return 0;
        !           748: }
        !           749: 
        !           750: ginmode() {
        !           751:        int c;
        !           752:        hairs(jerqhairs);
        !           753:        c = waitforchar();
        !           754:        hairs(jerqhairs);
        !           755:        c = controlchar(c);
        !           756: }
        !           757: 
        !           758: specialpointmode() {
        !           759:        int c;
        !           760:        static char intents[] = {
        !           761:         14, 16, 17, 19, 20, 22, 23, 25, 28, 31, 34, 38, 41, 44, 47, 50,
        !           762: /*     SP , ! , " , # , $ , % , & , ' , ( , ) , * , + , , , - , . , / ,        */
        !           763:         56, 62, 69, 75, 81, 88, 94,100, 56, 62, 69, 75, 81, 88, 94,100,
        !           764: /*      0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , : , ; , < , = , > , ? ,        */
        !           765:          0,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  3,  3,  3,  3,
        !           766: /*      @ , A , B , C , D , E , F , G , H , I , J , K , L , M , N , O ,        */
        !           767:          4,  4,  4,  5,  5,  5,  6,  6,  7,  8,  9, 10, 11, 12, 12, 13,
        !           768: /*      P , Q , R , S , T , U , V , W , X , Y , Z , [ , \ , ] , ^ , _ ,        */
        !           769:         14, 16, 17, 19, 20, 22, 23, 25, 28, 31, 34, 38, 41, 44, 47, 50,
        !           770: /*      ` , a , b , c , d , e , f , g , h , i , j , k , l , m , n , o ,        */
        !           771:         56, 62, 69, 75, 81, 88, 94,100, 56, 62, 69, 75, 81, 88, 94,100,
        !           772: /*      p , q , r , s , t , u , v , w , x , y , z , { , | , } , ~ ,DEL,        */
        !           773:        };
        !           774: 
        !           775:        if (((c = waitforchar()) < 040) || (c >= '~')) {
        !           776:                c = controlchar(c);
        !           777:                return;
        !           778:        }
        !           779:        intensity = intents[c-' '];
        !           780:        intensity = muldiv(intensity, 200-intensity, 100);
        !           781:        graphmode();
        !           782: }
        !           783: 
        !           784: intent(p)
        !           785: Point p;
        !           786: {
        !           787:        int i,j,cnt=0;
        !           788:        for (i=0;i<=smear;i++)
        !           789:                for (j=0;j<=smear;j++)
        !           790:                        if (dithermode) {
        !           791:                                if ( (16*16*intensity) > 
        !           792:                                     (100*dither[(p.y+i)%16][(p.x+j)%16]) )
        !           793:                                        cnt++;
        !           794:                        } else {
        !           795:                                if (intensity > (rand()%100))
        !           796:                                        cnt++;
        !           797:                        }
        !           798:        return cnt;
        !           799: }
        !           800: 
        !           801: graphmode() {
        !           802:        register b,c;
        !           803:        static Point ojcurs;
        !           804:        static hix, hiy, lox, loy, extra;
        !           805:        register int numdots;
        !           806: 
        !           807:        if ((c = waitforchar()) < 040) {
        !           808:                c = controlchar(c);
        !           809:                return;
        !           810:        }
        !           811:        if ((c & 0140) == 040) {        /* new hiy */
        !           812:                hiy = c & 037;
        !           813:                do
        !           814:                        if (((c = waitforchar()) < 040) &&
        !           815:                            ((c = controlchar(c)) == OUTMODED))
        !           816:                                return;
        !           817:                while (c == 0);
        !           818:        }
        !           819:        if ((c & 0140) == 0140) {       /* new loy */
        !           820:                b = c & 037;
        !           821:                do
        !           822:                        if (((c = waitforchar()) < 040) &&
        !           823:                            ((c = controlchar(c)) == OUTMODED))
        !           824:                                return;
        !           825:                while (c == 0);
        !           826:                if ((c & 0140) == 0140) {       /* no, it was extra */
        !           827:                        extra = b;
        !           828:                        loy = c & 037;
        !           829:                        do
        !           830:                                if (((c = waitforchar()) < 040) &&
        !           831:                                    ((c = controlchar(c)) == OUTMODED))
        !           832:                                        return;
        !           833:                        while (c == 0);
        !           834:                }
        !           835:                else
        !           836:                        loy = b;
        !           837:        }
        !           838:        if ((c & 0140) == 040) {        /* new hix */
        !           839:                hix = c & 037;
        !           840:                do
        !           841:                        if (((c = waitforchar()) < 040) &&
        !           842:                            ((c = controlchar(c)) == OUTMODED))
        !           843:                                return;
        !           844:                while (c == 0);
        !           845:        }
        !           846:        lox = c & 037;          /* this should be lox */
        !           847:        if (extra & 020)
        !           848:                tekmargin = TEKXMAX/2;
        !           849:        tekcursor.x = (hix<<7) | (lox<<2) | (extra & 03);
        !           850:        tekcursor.y = (hiy<<7) | (loy<<2) | ((extra & 014)>>2);
        !           851:        jerqcursor = tektojerq(tekcursor);
        !           852:        if (dispmode == GRAPH) {
        !           853:                if (drawallowed) {
        !           854:                        if (zaxis != WRITETHRU) {
        !           855:                                dsegment(&display,ojcurs,jerqcursor,
        !           856:                                         F_DRAW, linestyle);
        !           857:                                point(&display,jerqcursor,F_DRAW);
        !           858:                        }
        !           859:                        saveline(ojcurs,jerqcursor,linestyle);
        !           860:                }
        !           861:        } else {
        !           862:                if ((numdots = intent(tekcursor)) >= 4)
        !           863:                        point(&display,sub(jerqcursor,Pt(0,1)),F_DRAW);
        !           864:                if (numdots >= 3)
        !           865:                        point(&display,sub(jerqcursor,Pt(1,0)),F_DRAW);
        !           866:                if (numdots >= 2)
        !           867:                        point(&display,sub(jerqcursor,Pt(1,1)),F_DRAW);
        !           868:                if (numdots >= 1)
        !           869:                        point(&display,jerqcursor,F_DRAW);
        !           870:                savepoint(jerqcursor);
        !           871:        }
        !           872:        ojcurs = jerqcursor;
        !           873:        drawallowed = 1;
        !           874: }
        !           875: 
        !           876: incrementalmode() {
        !           877:        int c;
        !           878:        register int numdots;
        !           879: 
        !           880:        if ((c = waitforchar()) == OUTMODED)
        !           881:                return;
        !           882:        if ((c < 040) && ((c = controlchar(c)) <= 0))
        !           883:                        return;
        !           884:        if (c&040)
        !           885:                penstate = 0;
        !           886:        if (c&020)
        !           887:                penstate = 1;
        !           888:        if (c&04)
        !           889:                tekcursor.y++;
        !           890:        if (c&010)
        !           891:                tekcursor.y--;
        !           892:        if (c&01)
        !           893:                tekcursor.x++;
        !           894:        if (c&02)
        !           895:                tekcursor.x--;
        !           896:        jerqcursor = tektojerq(tekcursor);
        !           897:        if (penstate == 0)
        !           898:                return;
        !           899:        if ((numdots = intent(tekcursor)) >= 4)
        !           900:                point(&display,sub(jerqcursor,Pt(0,1)),F_DRAW);
        !           901:        if (numdots >= 3)
        !           902:                point(&display,sub(jerqcursor,Pt(1,0)),F_DRAW);
        !           903:        if (numdots >= 2)
        !           904:                point(&display,sub(jerqcursor,Pt(1,1)),F_DRAW);
        !           905:        if (numdots >= 1)
        !           906:                point(&display,jerqcursor,F_DRAW);
        !           907:        savepoint(jerqcursor);
        !           908: }
        !           909: 
        !           910: alphamode() {
        !           911:        int c;
        !           912: 
        !           913:        c = waitforchar();
        !           914:        if (c == OUTMODED)
        !           915:                return;
        !           916:        if ((c < 040) && ((c = controlchar(c)) <= 0))
        !           917:                        return;
        !           918:        if (bypass)
        !           919:                return;
        !           920:        switch(c) {
        !           921:                case DEL:
        !           922:                        /* ignore */
        !           923:                        return;
        !           924:                case BS:
        !           925:                        if ((tekcursor.x -= width[currfont]) < tekmargin)
        !           926:                                tekcursor.x = TEKXMAX - width[currfont];
        !           927:                        break;
        !           928:                case NL:
        !           929:                        tekcursor.y -= height[currfont];
        !           930:                        break;
        !           931:                case CR:
        !           932:                        tekcursor.x = tekmargin;
        !           933:                        break;
        !           934:                case HT:
        !           935:                        tekcursor.x += width[currfont];
        !           936:                        break;
        !           937:                case VT:
        !           938:                        if ((tekcursor.y += height[currfont]) >= TEKYMAX)
        !           939:                                tekcursor.y = 0;
        !           940:                        break;
        !           941:                case ' ':
        !           942:                        tekcursor.x += width[currfont];
        !           943:                        break;
        !           944:                default:
        !           945:                        if (c <= ' ')
        !           946:                                return;
        !           947:                        if (zaxis != WRITETHRU)
        !           948:                                drawchar(currfont,c,jerqcursor,F_DRAW);
        !           949:                        savechar(currfont,c,jerqcursor);
        !           950:                        tekcursor.x += width[currfont];
        !           951:                        break;
        !           952:        }
        !           953:        if (tekcursor.x >= TEKXMAX) {
        !           954:                tekcursor.x = tekmargin;
        !           955:                tekcursor.y -= height[currfont];
        !           956:        }
        !           957:        if (tekcursor.y < 0) {
        !           958:                tekcursor.y = TEKYMAX - height[currfont];
        !           959:                tekcursor.x -= tekmargin;
        !           960:                tekmargin = (TEKXMAX/2) - tekmargin;
        !           961:                if ((tekcursor.x += tekmargin) > TEKXMAX)
        !           962:                        tekcursor.x -= tekmargin;
        !           963:        }
        !           964:        jerqcursor = tektojerq(tekcursor);
        !           965: }
        !           966: 
        !           967: drawchar(f,c,p,m)
        !           968: int f,m;
        !           969: Point p;
        !           970: char c;
        !           971: {
        !           972:        static char s[2];
        !           973: 
        !           974:        s[0] = c;
        !           975:        string(font[f], s , &display,
        !           976: #ifdef X11
        !           977:                Pt(p.x,p.y-font[f]->max_bounds.ascent), m);
        !           978: #endif X11
        !           979: #ifdef SUNTOOLS
        !           980:                Pt(p.x,p.y+(*font[f])->pf_char[0].pc_home.y), m);
        !           981: #endif SUNTOOLS
        !           982: 
        !           983: }
        !           984: 
        !           985: clearscreen(){
        !           986:        savereset();
        !           987:        flash_state = DISALLOWED;
        !           988:        dim_state = DISALLOWED;
        !           989:        rectf(&display,Drect,F_CLR);
        !           990:        homecursor();
        !           991: }
        !           992: 
        !           993: homecursor(){
        !           994:        bypass = 0;
        !           995:        tekcursor.x = 0;
        !           996:        tekcursor.y = TEKYMAX - height[currfont];
        !           997:        jerqcursor = tektojerq(tekcursor);
        !           998:        tekmargin = 0;
        !           999: }
        !          1000: 
        !          1001: int status(){
        !          1002:        int s;
        !          1003:        s = 33;
        !          1004:        if (dispmode == GRAPH)
        !          1005:                s |= 8;
        !          1006:        if (dispmode == ALPHA)
        !          1007:                s |= 4;
        !          1008:        if (tekmargin)
        !          1009:                s |= 2;
        !          1010:        return s;
        !          1011: }
        !          1012: 
        !          1013: errorabort(s)
        !          1014: char *s; {
        !          1015:        sendnchars(strlen(s),s);
        !          1016:        sleep(5);
        !          1017:        exit();
        !          1018: }
        !          1019: 
        !          1020: main(argc,argv)
        !          1021: int argc;
        !          1022: char *argv[];
        !          1023: {
        !          1024:        char *s;
        !          1025:        Font savedefont;
        !          1026:        extern int childid;
        !          1027:        static Font sfonts[8];
        !          1028: 
        !          1029:        kbdmode = REMOTE;
        !          1030:        startshell();
        !          1031:        initdisplay(argc, argv);
        !          1032:        initcursors();
        !          1033:        savedefont = defont;
        !          1034: #ifdef X11
        !          1035:        font[0] = XLoadQueryFont(dpy, "9x15");
        !          1036:        font[1] = &savedefont;
        !          1037:        font[2] = XLoadQueryFont(dpy, "6x12");
        !          1038:        font[3] = XLoadQueryFont(dpy, "6x10");
        !          1039: #endif X11
        !          1040: #ifdef SUNTOOLS
        !          1041:        sfonts[0] = pf_open("/usr/lib/fonts/tekfonts/tekfont0");
        !          1042:        sfonts[1] = pf_open("/usr/lib/fonts/tekfonts/tekfont1");
        !          1043:        sfonts[2] = pf_open("/usr/lib/fonts/tekfonts/tekfont2");
        !          1044:        sfonts[3] = pf_open("/usr/lib/fonts/tekfonts/tekfont3");
        !          1045:        font[0] = &sfonts[0];
        !          1046:        font[1] = &sfonts[1];
        !          1047:        font[2] = &sfonts[2];
        !          1048:        font[3] = &sfonts[3];
        !          1049: #endif SUNTOOLS
        !          1050:        font[4] = font[0];
        !          1051:        font[5] = font[1];
        !          1052:        font[6] = font[2];
        !          1053:        font[7] = font[3];
        !          1054:        xtab = (int *)alloc(TEKXMAX*sizeof(int));
        !          1055:        ytab = (int *)alloc(TEKYMAX*sizeof(int));
        !          1056:        dithermode = 1;
        !          1057:        smear = 1;
        !          1058:        lockfont = 0;
        !          1059:        tekhairs.x = TEKXMAX/2;
        !          1060:        tekhairs.y = TEKYMAX/2;
        !          1061:        while (--argc)
        !          1062:                if ((s = argv[argc]) && (*s) && (*s++ == '-'))
        !          1063:                        while (*s)
        !          1064:                                switch(*s++) {
        !          1065:                                        case 'd':
        !          1066:                                                DELimpliesLOY = 1;
        !          1067:                                                break;
        !          1068:                                        case 'l':
        !          1069:                                                LFeffect = 1;
        !          1070:                                                CReffect = 0;
        !          1071:                                                break;
        !          1072:                                        case 'c':
        !          1073:                                                CReffect = 1;
        !          1074:                                                LFeffect = 0;
        !          1075:                                                break;
        !          1076:                                        case 'g':
        !          1077:                                                GINcount = 4;
        !          1078:                                                break;
        !          1079:                                        case 'e':
        !          1080:                                                GINcount = 6;
        !          1081:                                                break;
        !          1082:                                        case 'u':
        !          1083:                                                DIMallowed = DISALLOWED;
        !          1084:                                                break;
        !          1085:                                }
        !          1086:        DIMallowed = DISALLOWED;
        !          1087:        F_DRAW = F_OR;
        !          1088:        statemachine();
        !          1089:        sendchar(NL);
        !          1090:        kill(childid, SIGHUP);
        !          1091: }
        !          1092: 
        !          1093: initcursors()
        !          1094: {
        !          1095:        menu2 = ToCursor(menu2_bits, menu2_bits, 7, 7);
        !          1096:        sunset = ToCursor(sunset_bits, sunset_bits, 7, 7);
        !          1097:        none = ToCursor(none_bits, none_bits, 7, 7);
        !          1098:        vdots = ToTexture(vdots_bits);
        !          1099:        hdots = ToTexture(hdots_bits);
        !          1100:        grey = ToTexture(grey_bits);
        !          1101: }

unix.superglobalmegacorp.com

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