![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jek.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / tek|
Return to jek.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / tek |
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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.