![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Tekproc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm|
Return to Tekproc.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xterm |
1.1 root 1: /*
2: * $Source: /orpheus/u1/X11/clients/xterm/RCS/Tekproc.c,v $
3: * $Header: Tekproc.c,v 1.5 87/09/10 17:19:46 swick Exp $
4: */
5:
6:
7: #include <X11/copyright.h>
8:
9: /*
10: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
11: *
12: * All Rights Reserved
13: *
14: * Permission to use, copy, modify, and distribute this software and its
15: * documentation for any purpose and without fee is hereby granted,
16: * provided that the above copyright notice appear in all copies and that
17: * both that copyright notice and this permission notice appear in
18: * supporting documentation, and that the name of Digital Equipment
19: * Corporation not be used in advertising or publicity pertaining to
20: * distribution of the software without specific, written prior permission.
21: *
22: *
23: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
24: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
25: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
26: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
27: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
28: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
29: * SOFTWARE.
30: */
31:
32: /* Tekproc.c */
33:
34: #include <X11/Xlib.h>
35: #include <X11/Intrinsic.h>
36: #include <X11/Xatom.h>
37: #include <X11/Xutil.h>
38: #include "ptyx.h"
39: #include "Tekparse.h"
40: #include <stdio.h>
41: #include <sgtty.h>
42: #include <ctype.h>
43: #include <errno.h>
44: #include <setjmp.h>
1.1.1.2 ! root 45: #include <time.h>
1.1 root 46: #include <pwd.h>
47: #include <strings.h>
48: #include "data.h"
49: #include "error.h"
50: #ifdef MODEMENU
51: #include "menu.h"
52: #endif MODEMENU
53:
54: extern void exit();
55: extern long time();
56:
57: /* ||| Temp stuff till I make this work again */
58: char *fore_color;
59: char *back_color;
60: char *curs_color;
61:
62: #define TekColormap DefaultColormap( screen->display, \
63: DefaultScreen(screen->display) )
64:
65: /* Tek defines */
66:
67: #define BEL 07
68: #define CANCEL 030
69: #define DOTDASHEDLINE 2
70: #define DOTTEDLINE 1
71: #define EAST 01
72: #define ETX 03
73: #define LARGEFONT 0
74: #define LARGEFONTNAME "9x15"
75: #define LINEMASK 07
76: #define LONGDASHEDLINE 4
77: #define MARGIN1 0
78: #define MARGIN2 1
79: #define MAX_PTS 150
80: #define MAX_VTX 300
81: #define NAK 025
82: #define NORTH 04
83: #define PENDOWN 1
84: #define PENUP 0
85: #define SHORTDASHEDLINE 3
86: #define SMALLFONT 3
87: #define SMALLFONTNAME "5x7"
88: #define SOLIDLINE 0
89: #define SOUTH 010
90: #define TEKBOTTOMPAD 23
91: #define TEKDEFHEIGHT 565
92: #define TEKDEFWIDTH 750
93: #define TEKHEIGHT 3072
94: #define TEKHOME ((TekChar[screen->page.fontsize].nlines - 1)\
95: * TekChar[screen->page.fontsize].vsize)
96: #define TEKMINHEIGHT 452
97: #define TEKMINWIDTH 600
98: #define TEKPAD 57
99: #define TEKTOPPAD 34
100: #define TEKWIDTH 4096
101: #define TEXT_BUF_SIZE 256
102: #define THREEFONT 2
103: #define THREEFONTNAME "8x13"
104: #define TWOFONT 1
105: #define TWOFONTNAME "fixed"
106: #define WEST 02
107:
108: #define TekMove(x,y) screen->cur_X = x; screen->cur_Y = y
109: #define input() Tinput()
110: #define unput(c) *Tpushback++ = c
111:
112: #ifndef lint
113: static char rcs_id[] = "$Header: Tekproc.c,v 1.5 87/09/10 17:19:46 swick Exp $";
114: #endif lint
115:
116: static XPoint *T_box[TEKNUMFONTS] = {
117: T_boxlarge,
118: T_box2,
119: T_box3,
120: T_boxsmall,
121: };
122: static struct Tek_Char {
123: int hsize; /* in Tek units */
124: int vsize; /* in Tek units */
125: int charsperline;
126: int nlines;
127: } TekChar[TEKNUMFONTS] = {
128: {56, 88, 74, 35}, /* large */
129: {51, 82, 81, 38}, /* #2 */
130: {34, 53, 121, 58}, /* #3 */
131: {31, 48, 133, 64}, /* small */
132: };
133:
134: static int *curstate;
135: static Cursor GINcursor;
136: static XSegment *line_pt;
137: static int nplot;
138: static TekLink Tek0;
139: static jmp_buf Tekjump;
140: static TekLink *TekRecord;
141: static XSegment *Tline;
142: static int *Tparsestate;
143:
144: extern int Talptable[];
145: extern int Tbestable[];
146: extern int Tbyptable[];
147: extern int Tesctable[];
148: extern int Tipltable[];
149: extern int Tplttable[];
150: extern int Tpttable[];
151: extern int Tspttable[];
152:
153: /* event handlers */
154: extern HandleKeyPressed();
155: extern EventDoNothing();
156: extern HandleEnterWindow();
157: extern HandleLeaveWindow();
158: extern HandleFocusChange();
159: extern TekButtonPressed();
160:
161:
162: Tekparse()
163: {
164: register TScreen *screen = &term.screen;
165: register int c, x, y;
166: char ch;
167: int arg;
168: int Tinput();
169:
170: for( ; ; )
171: switch(Tparsestate[c = input()]) {
172: case CASE_REPORT:
173: /* report address */
174: if(screen->TekGIN) {
175: TekGINoff();
176: TekEnqMouse(0);
177: } else {
178: c = 064; /* has hard copy unit */
179: if(screen->margin == MARGIN2)
180: c |= 02;
181: TekEnq(c, screen->cur_X, screen->cur_Y);
182: }
183: TekRecord->ptr[-1] = NAK; /* remove from recording */
184: Tparsestate = curstate;
185: break;
186:
187: case CASE_VT_MODE:
188: /* special return to vt102 mode */
189: Tparsestate = curstate;
190: TekRecord->ptr[-1] = NAK; /* remove from recording */
191: if(screen->logging) {
192: FlushLog(screen);
193: screen->logstart = buffer;
194: }
195: return;
196:
197: case CASE_SPT_STATE:
198: /* Enter Special Point Plot mode */
199: if(screen->TekGIN)
200: TekGINoff();
201: Tparsestate = curstate = Tspttable;
202: break;
203:
204: case CASE_GIN:
205: /* Do Tek GIN mode */
206: screen->TekGIN = &TekRecord->ptr[-1];
207: /* Set cross-hair cursor raster array */
208: if(GINcursor = make_tcross(
209: screen->mousecolor,
210: screen->background))
211: XDefineCursor(
212: screen->display,
213: TWindow(screen),
214: GINcursor);
215: Tparsestate = Tbyptable; /* Bypass mode */
216: break;
217:
218: case CASE_BEL:
219: /* BEL */
220: if(screen->TekGIN)
221: TekGINoff();
222: if(!TekRefresh)
223: Bell();
224: Tparsestate = curstate; /* clear bypass condition */
225: break;
226:
227: case CASE_BS:
228: /* BS */
229: if(screen->TekGIN)
230: TekGINoff();
231: Tparsestate = curstate; /* clear bypass condition */
232: TCursorBack();
233: break;
234:
235: case CASE_PT_STATE:
236: /* Enter Tek Point Plot mode */
237: if(screen->TekGIN)
238: TekGINoff();
239: Tparsestate = curstate = Tpttable;
240: break;
241:
242: case CASE_PLT_STATE:
243: /* Enter Tek Plot mode */
244: if(screen->TekGIN)
245: TekGINoff();
246: Tparsestate = curstate = Tplttable;
247: if((c = input()) == BEL)
248: screen->pen = PENDOWN;
249: else {
250: unput(c);
251: screen->pen = PENUP;
252: }
253: break;
254:
255: case CASE_TAB:
256: /* HT */
257: if(screen->TekGIN)
258: TekGINoff();
259: Tparsestate = curstate; /* clear bypass condition */
260: TCursorForward();
261: break;
262:
263: case CASE_IPL_STATE:
264: /* Enter Tek Incremental Plot mode */
265: if(screen->TekGIN)
266: TekGINoff();
267: Tparsestate = curstate = Tipltable;
268: break;
269:
270: case CASE_ALP_STATE:
271: /* Enter Tek Alpha mode from any other mode */
272: if(screen->TekGIN)
273: TekGINoff();
274: /* if in one of graphics states, move alpha cursor */
275: if(nplot > 0) /* flush line Tbuffer */
276: TekFlush();
277: Tparsestate = curstate = Talptable;
278: break;
279:
280: case CASE_UP:
281: /* cursor up */
282: if(screen->TekGIN)
283: TekGINoff();
284: Tparsestate = curstate; /* clear bypass condition */
285: TCursorUp();
286: break;
287:
288: case CASE_COPY:
289: /* make copy */
290: if(screen->TekGIN)
291: TekGINoff();
292: TekCopy();
293: TekRecord->ptr[-1] = NAK; /* remove from recording */
294: Tparsestate = curstate; /* clear bypass condition */
295: break;
296:
297: case CASE_PAGE:
298: /* Page Function */
299: if(screen->TekGIN)
300: TekGINoff();
301: TekPage(); /* clear bypass condition */
302: break;
303:
304: case CASE_BES_STATE:
305: /* Byp: an escape char */
306: Tparsestate = Tbestable;
307: break;
308:
309: case CASE_BYP_STATE:
310: /* set bypass condition */
311: Tparsestate = Tbyptable;
312: break;
313:
314: case CASE_IGNORE:
315: /* Esc: totally ignore CR, ESC, LF, ~ */
316: break;
317:
318: case CASE_ASCII:
319: /* Select ASCII char set */
320: /* ignore for now */
321: Tparsestate = curstate;
322: break;
323:
324: case CASE_APL:
325: /* Select APL char set */
326: /* ignore for now */
327: Tparsestate = curstate;
328: break;
329:
330: case CASE_CHAR_SIZE:
331: /* character size selector */
332: screen->cur.fontsize = c & 03;
333: Tparsestate = curstate;
334: break;
335:
336: case CASE_BEAM_VEC:
337: /* beam and vector selector */
338: /* only line types */
339: if((c &= LINEMASK) != screen->cur.linetype) {
340: if(nplot > 0)
341: TekFlush();
342: screen->cur.linetype = c;
343: }
344: Tparsestate = curstate;
345: break;
346:
347: case CASE_CURSTATE:
348: Tparsestate = curstate;
349: break;
350:
351: case CASE_PENUP:
352: /* Ipl: penup */
353: screen->pen = PENUP;
354: break;
355:
356: case CASE_PENDOWN:
357: /* Ipl: pendown */
358: screen->pen = PENDOWN;
359: break;
360:
361: case CASE_IPL_POINT:
362: /* Ipl: point */
363: x = screen->cur_X;
364: y = screen->cur_Y;
365: if(c & NORTH)
366: y++;
367: else if(c & SOUTH)
368: y--;
369: if(c & EAST)
370: x++;
371: else if(c & WEST)
372: x--;
373: if(screen->pen == PENDOWN)
374: TekDraw(x, y);
375: else
376: TekMove(x, y);
377: break;
378:
379: case CASE_PLT_VEC:
380: /* Plt: vector */
381: unput(c);
382: if(getpoint()) {
383: if(screen->pen == PENDOWN)
384: TekDraw(screen->cur.x, screen->cur.y);
385: else
386: TekMove(screen->cur.x, screen->cur.y);
387: screen->pen = PENDOWN;
388: }
389: break;
390:
391: case CASE_PT_POINT:
392: /* Pt: point */
393: unput(c);
394: if(getpoint()) {
395: TekMove(screen->cur.x, screen->cur.y);
396: TekDraw(screen->cur.x, screen->cur.y);
397: }
398: break;
399:
400: case CASE_SPT_POINT:
401: /* Spt: point */
402: /* ignore intensity character in c */
403: if(getpoint()) {
404: TekMove(screen->cur.x, screen->cur.y);
405: TekDraw(screen->cur.x, screen->cur.y);
406: }
407: break;
408:
409: case CASE_CR:
410: /* CR */
411: if(screen->TekGIN)
412: TekGINoff();
413: if(nplot > 0) /* flush line Tbuffer */
414: TekFlush();
415: screen->cur_X = screen->margin == MARGIN1 ? 0 :
416: TEKWIDTH / 2;
417: Tparsestate = curstate = Talptable;
418: break;
419:
420: case CASE_ESC_STATE:
421: /* ESC */
422: Tparsestate = Tesctable;
423: break;
424:
425: case CASE_LF:
426: /* LF */
427: if(screen->TekGIN)
428: TekGINoff();
429: TCursorDown();
430: if(!TekRefresh && (screen->display->qlen > 0 ||
431: (ioctl(screen->display->fd, FIONREAD, (char *)&arg), arg) > 0))
432: xevents();
433: break;
434:
435: case CASE_SP:
436: /* SP */
437: TCursorForward();
438: break;
439:
440: case CASE_PRINT:
441: /* printable character */
442: ch = c;
443: c = screen->cur.fontsize;
444:
445: XDrawString(
446: screen->display,
447: TWindow(screen),
448: screen->TnormalGC,
449: (int)(screen->cur_X * TekScale(screen)) + screen->border,
450: (int)((TEKHEIGHT + TEKTOPPAD - screen->cur_Y) * TekScale(screen)) + screen->border - screen->tobaseline[c],
451: &ch,
452: 1);
453: TCursorForward();
454: break;
455: case CASE_OSC:
456: /* do osc escape */
457: do_osc(Tinput);
458: Tparsestate = curstate;
459: break;
460: }
461: }
462:
463: static int rcnt;
464: static char *rptr;
465: static int Tselect_mask;
466:
467: Tinput()
468: {
469: register TScreen *screen = &term.screen;
470: register char *cp;
471: register int i;
472: register TekLink *tek;
473: extern char *malloc();
474:
475: if(Tpushback > Tpushb)
476: return(*--Tpushback);
477: if(TekRefresh) {
478: if(rcnt-- > 0)
479: return(*rptr++);
480: if(tek = TekRefresh->next) {
481: TekRefresh = tek;
482: rcnt = tek->count - 1;
483: rptr = tek->data;
484: return(*rptr++);
485: }
486: TekRefresh = (TekLink *)0;
487: longjmp(Tekjump, 1);
488: }
489: again:
490: if(Tbcnt-- <= 0) {
491: if(nplot > 0) /* flush line Tbuffer */
492: TekFlush();
493: Tselect_mask = pty_mask; /* force a read */
494: for( ; ; ) {
495: if(Tselect_mask & pty_mask) {
496: if(screen->logging)
497: FlushLog(screen);
498: if((Tbcnt = read(screen->respond,
499: Tbptr = Tbuffer, BUF_SIZE)) < 0) {
500: if(errno == EIO && am_slave)
501: exit(0);
1.1.1.2 ! root 502: else
1.1 root 503: Panic(
504: "Tinput:read returned unexpected error (%d)\n",
505: errno);
506: } else if(Tbcnt == 0)
507: Panic("input: read returned zero\n", 0);
508: else {
509: /* strip parity bit */
510: for(i = Tbcnt, cp = Tbptr ; i > 0 ; i--)
511: *cp++ &= CHAR;
512: break;
513: }
514: }
515: if (Ttoggled && curstate == Talptable) {
516: TCursorToggle(TOGGLE);
517: Ttoggled = FALSE;
518: }
519: if(QLength(screen->display))
520: Tselect_mask = X_mask;
521: else {
522: XFlush(screen->display);
523: Tselect_mask = Select_mask;
524: if((i = select(max_plus1, &Tselect_mask,
1.1.1.2 ! root 525: (int *)NULL, 0x6fffffff)) < 0){
1.1 root 526: if (errno != EINTR)
527: SysError(ERROR_TSELECT);
528: continue;
529: }
530: }
531: if(Tselect_mask & X_mask) {
532: xevents();
533: if(Tbcnt > 0)
534: goto again;
535: }
536: }
537: Tbcnt--;
538: if (!Ttoggled && curstate == Talptable) {
539: TCursorToggle(TOGGLE);
540: Ttoggled = TRUE;
541: }
542: }
543: if((tek = TekRecord)->count >= TEK_LINK_BLOCK_SIZE) {
544: if((TekRecord = tek->next = (TekLink *)malloc(sizeof(TekLink)))
545: == (TekLink *)0)
546: Panic("Tinput: malloc error (%d)\n", errno);
547: tek = tek->next;
548: tek->next = (TekLink *)0;
549: tek->count = 0;
550: tek->ptr = tek->data;
551: }
552: tek->count++;
553: return(*tek->ptr++ = *Tbptr++);
554: }
555:
556: TekExpose(rep)
557: register XExposeEvent *rep;
558: {
559: register TScreen *screen = &term.screen;
560: register int border = 2 * screen->border;
561: register double d;
562:
563: if(rep) {
564: if (rep->width != (TWidth(screen) + border) || rep->height !=
565: (THeight(screen) + border)) {
566: XClearWindow(screen->display, TWindow(screen));
567: TWidth(screen) = rep->width - border;
568: THeight(screen) = rep->height - border;
569: TekScale(screen) = (double)TWidth(screen) /
570: (TEKWIDTH + TEKPAD);
571: if((d = (double)THeight(screen) / (TEKHEIGHT +
572: TEKTOPPAD + TEKBOTTOMPAD)) < TekScale(screen))
573: TekScale(screen) = d;
574: TFullWidth(screen) = rep->width;
575: TFullHeight(screen) = rep->height;
576:
577: } else if(TFullHeight(screen) != rep->height)
578: TFullHeight(screen) = rep->height;
579: else if(!Ttoggled)
580: TCursorToggle(CLEAR);
581: }
582: Ttoggled = TRUE;
583: Tpushback = Tpushb;
584: screen->cur_X = 0;
585: screen->cur_Y = TEKHOME;
586: screen->cur = screen->page;
587: screen->margin = MARGIN1;
588: if(screen->TekGIN) {
589: screen->TekGIN = NULL;
590: TekGINoff();
591: }
592: TekRefresh = &Tek0;
593: rptr = TekRefresh->data;
594: rcnt = TekRefresh->count;
595: Tparsestate = curstate = Talptable;
596: if(!screen->waitrefresh)
597: dorefresh();
598: }
599:
600: dorefresh()
601: {
602: register TScreen *screen = &term.screen;
603: register Cursor cur;
604:
605: XDefineCursor(screen->display, TWindow(screen),
606: cur = make_wait(screen->mousecolor, screen->background));
607: XFlush(screen->display);
608: if(!setjmp(Tekjump))
609: Tekparse();
610: XDefineCursor(screen->display, TWindow(screen),
611: (screen->TekGIN && GINcursor) ? GINcursor : screen->arrow);
612: XFreeCursor(screen->display, cur);
613: }
614:
615: TekPage()
616: {
617: register TScreen *screen = &term.screen;
618: register TekLink *tek, *tek2;
619:
620: XClearWindow(screen->display, TWindow(screen));
621: screen->cur_X = 0;
622: screen->cur_Y = TEKHOME;
623: screen->margin = MARGIN1;
624: screen->page = screen->cur;
625: if(screen->TekGIN)
626: TekGINoff();
627: tek = TekRecord = &Tek0;
628: tek->count = 0;
629: tek->ptr = tek->data;
630: if(tek = tek->next)
631: do {
632: tek2 = tek->next;
633: free((char *)tek);
634: } while(tek = tek2);
635: TekRecord->next = (TekLink *)0;
636: TekRefresh = (TekLink *)0;
637: Ttoggled = TRUE;
638: Tparsestate = curstate = Talptable; /* Tek Alpha mode */
639: }
640:
641: #define EXTRABITS 017
642: #define FIVEBITS 037
643: #define HIBITS (FIVEBITS << SHIFTHI)
644: #define LOBITS (FIVEBITS << SHIFTLO)
645: #define SHIFTHI 7
646: #define SHIFTLO 2
647: #define TWOBITS 03
648:
649: getpoint()
650: {
651: register int c, x, y, e, lo_y = 0;
652: register TScreen *screen = &term.screen;
653:
654: x = screen->cur.x;
655: y = screen->cur.y;
656: for( ; ; ) {
657: if((c = input()) < ' ') { /* control character */
658: unput(c);
659: return(0);
660: }
661: if(c < '@') { /* Hi X or Hi Y */
662: if(lo_y) { /* seen a Lo Y, so this must be Hi X */
663: x &= ~HIBITS;
664: x |= (c & FIVEBITS) << SHIFTHI;
665: continue;
666: }
667: /* else Hi Y */
668: y &= ~HIBITS;
669: y |= (c & FIVEBITS) << SHIFTHI;
670: continue;
671: }
672: if(c < '`') { /* Lo X */
673: x &= ~LOBITS;
674: x |= (c & FIVEBITS) << SHIFTLO;
675: screen->cur.x = x;
676: screen->cur.y = y;
677: return(1); /* OK */
678: }
679: /* else Lo Y */
680: if(lo_y) { /* seen a Lo Y, so other must be extra bits */
681: e = (y >> SHIFTLO) & EXTRABITS;
682: x &= ~TWOBITS;
683: x |= e & TWOBITS;
684: y &= ~TWOBITS;
685: y |= (e >> SHIFTLO) & TWOBITS;
686: }
687: y &= ~LOBITS;
688: y |= (c & FIVEBITS) << SHIFTLO;
689: lo_y++;
690: }
691: }
692:
693: TCursorBack()
694: {
695: register TScreen *screen = &term.screen;
696: register struct Tek_Char *t;
697: register int x, l;
698:
699: x = ( screen->cur_X -=
700: (t = &TekChar[screen->cur.fontsize])->hsize
701: );
702:
703: if(screen->margin == MARGIN1 && x < 0 || screen->margin == MARGIN2
704: && x < TEKWIDTH / 2) {
705: if((l = (screen->cur_Y + (t->vsize - 1)) / t->vsize + 1) >=
706: t->nlines) {
707: screen->margin = !screen->margin;
708: l = 0;
709: }
710: screen->cur_Y = l * t->vsize;
711: screen->cur_X = (t->charsperline - 1) * t->hsize;
712: }
713: }
714:
715: TCursorForward()
716: {
717: register TScreen *screen = &term.screen;
718: register struct Tek_Char *t;
719: register int l;
720:
721: if( ( screen->cur_X +=
722: ( t = &TekChar[screen->cur.fontsize])->hsize
723: ) > TEKWIDTH
724: ) {
725: if((l = screen->cur_Y / t->vsize - 1) < 0) {
726: screen->margin = !screen->margin;
727: l = t->nlines - 1;
728: }
729: screen->cur_Y = l * t->vsize;
730: screen->cur_X = screen->margin == MARGIN1 ? 0 : TEKWIDTH / 2;
731: }
732: }
733:
734: TCursorUp()
735: {
736: register TScreen *screen = &term.screen;
737: register struct Tek_Char *t;
738: register int l;
739:
740: t = &TekChar[screen->cur.fontsize];
741:
742: if((l = (screen->cur_Y + (t->vsize - 1)) / t->vsize + 1) >= t->nlines) {
743: l = 0;
744: if((screen->margin = !screen->margin) != MARGIN1) {
745: if(screen->cur_X < TEKWIDTH / 2)
746: screen->cur_X += TEKWIDTH / 2;
747: } else if(screen->cur_X >= TEKWIDTH / 2)
748: screen->cur_X -= TEKWIDTH / 2;
749: }
750: screen->cur_Y = l * t->vsize;
751: }
752:
753: TCursorDown()
754: {
755: register TScreen *screen = &term.screen;
756: register struct Tek_Char *t;
757: register int l;
758:
759: t = &TekChar[screen->cur.fontsize];
760:
761: if((l = screen->cur_Y / t->vsize - 1) < 0) {
762: l = t->nlines - 1;
763: if((screen->margin = !screen->margin) != MARGIN1) {
764: if(screen->cur_X < TEKWIDTH / 2)
765: screen->cur_X += TEKWIDTH / 2;
766: } else if(screen->cur_X >= TEKWIDTH / 2)
767: screen->cur_X -= TEKWIDTH / 2;
768: }
769: screen->cur_Y = l * t->vsize;
770: }
771:
772: TekDraw (x, y)
773: int x, y;
774: {
775: register TScreen *screen = &term.screen;
776:
777: if(nplot == 0 || T_lastx != screen->cur_X || T_lasty != screen->cur_Y) {
778: /*
779: * We flush on each unconnected line segment if the line
780: * type is not solid. This solves a bug in X when drawing
781: * points while the line type is not solid.
782: */
783: if(nplot > 0 && screen->cur.linetype != SOLIDLINE)
784: TekFlush();
785: }
786: AddToDraw(screen->cur_X, screen->cur_Y, x, y);
787: T_lastx = screen->cur_X = x;
788: T_lasty = screen->cur_Y = y;
789: }
790:
791: AddToDraw(x1, y1, x2, y2)
792: int x1, y1, x2, y2;
793: {
794: register TScreen *screen = &term.screen;
795: register XSegment *lp;
796:
797: if(nplot >= MAX_PTS) {
798: TekFlush();
799: }
800: lp = line_pt++;
801: lp->x1 = x1 = x1 * TekScale(screen) + screen->border;
802: lp->y1 = y1 = (TEKHEIGHT + TEKTOPPAD - y1) * TekScale(screen) +
803: screen->border;
804: lp->x2 = x2 = x2 * TekScale(screen) + screen->border;
805: lp->y2 = y2 = (TEKHEIGHT + TEKTOPPAD - y2) * TekScale(screen) +
806: screen->border;
807: nplot++;
808: }
809:
810: TekFlush ()
811: {
812: register TScreen *screen = &term.screen;
813:
814: XDrawSegments(screen->display, TWindow(screen),
815: ((screen->cur.linetype == SOLIDLINE)? screen->TnormalGC :
816: screen->linepat[screen->cur.linetype - 1]),
817: Tline, nplot);
818: nplot = 0;
819: line_pt = Tline;
820: }
821:
822: TekGINoff()
823: {
824: register TScreen *screen = &term.screen;
825:
826: XDefineCursor(screen->display, TWindow(screen), screen->arrow);
827: if(GINcursor)
828: XFreeCursor(screen->display, GINcursor);
829: if(screen->TekGIN) {
830: *screen->TekGIN = CANCEL; /* modify recording */
831: screen->TekGIN = NULL;
832: }
833: }
834:
835: TekEnqMouse(c)
836: int c;
837: {
838: register TScreen *screen = &term.screen;
839: int mousex, mousey, winx, winy;
840: unsigned int mask; /* XQueryPointer */
841: Window root, subw;
842:
843: XQueryPointer(
844: screen->display, TWindow(screen),
845: &root, &subw,
846: &mousex, &mousey,
847: &winx, &winy,
848: &mask);
849: if((mousex = (mousex - screen->border) / TekScale(screen)) < 0)
850: mousex = 0;
851: else if(mousex >= TEKWIDTH)
852: mousex = TEKWIDTH - 1;
853: if((mousey = TEKHEIGHT + TEKTOPPAD - (mousey - screen->border) /
854: TekScale(screen)) < 0)
855: mousey = 0;
856: else if(mousey >= TEKHEIGHT)
857: mousey = TEKHEIGHT - 1;
858: TekEnq(c, mousex, mousey);
859: }
860:
861: TekEnq (status, x, y)
862: int status;
863: register int x, y;
864: {
865: register TScreen *screen = &term.screen;
866: int pty = screen->respond;
867: char cplot [5];
868:
869: /* Translate x and y to Tektronix code */
870: cplot[1] = 040 | ((x >> SHIFTHI) & FIVEBITS);
871: cplot[2] = 040 | ((x >> SHIFTLO) & FIVEBITS);
872: cplot[3] = 040 | ((y >> SHIFTHI) & FIVEBITS);
873: cplot[4] = 040 | ((y >> SHIFTLO) & FIVEBITS);
874: if(cplot[0] = status)
875: write (pty, cplot, 5);
876: else
877: write (pty, &cplot[1], 4);
878: }
879:
880: TekRun()
881: {
882: register TScreen *screen = &term.screen;
883: register int i;
884:
885: if(!TWindow(screen) && !TekInit()) {
886: if(VWindow(screen)) {
887: screen->TekEmu = FALSE;
888: return;
889: }
890: Exit(ERROR_TINIT);
891: }
892: if(!screen->Tshow) {
893: screen->Tshow = TRUE;
894: XMapRaised(screen->display, TWindow(screen));
895: } else
896: XRaiseWindow(screen->display, TWindow(screen));
897: if(screen->select)
898: TekSelect();
899: if (L_flag > 0) {
900: XWarpPointer (screen->display, None, TWindow(screen),
901: 0, 0, 0, 0,
902: TFullWidth(screen) >> 1, TFullHeight(screen) >> 1);
903: L_flag = -1;
904: }
905: Tpushback = Tpushb;
906: Tbptr = Tbuffer;
907: for(i = Tbcnt = bcnt ; i > 0 ; i--)
908: *Tbptr++ = *bptr++;
909: Tbptr = Tbuffer;
910: Ttoggled = TRUE;
911: if(!setjmp(Tekend))
912: Tekparse();
913: if(!Ttoggled) {
914: TCursorToggle(TOGGLE);
915: Ttoggled = TRUE;
916: }
917: screen->TekEmu = FALSE;
918: TekUnselect();
919: }
920:
921: #define DOTTED_LENGTH 2
922: #define DOT_DASHED_LENGTH 4
923: #define SHORT_DASHED_LENGTH 2
924: #define LONG_DASHED_LENGTH 2
925:
926: static int dash_length[TEKNUMLINES] = {
927: DOTTED_LENGTH,
928: DOT_DASHED_LENGTH,
929: SHORT_DASHED_LENGTH,
930: LONG_DASHED_LENGTH,
931: };
932:
933: static unsigned char dotted[DOTTED_LENGTH] = {3, 1};
934: static unsigned char dot_dashed[DOT_DASHED_LENGTH] = {3, 4, 3, 1};
935: static unsigned char short_dashed[SHORT_DASHED_LENGTH] = {4, 4};
936: static unsigned char long_dashed[LONG_DASHED_LENGTH] = {4, 7};
937:
938: static unsigned char *dashes[TEKNUMLINES] = {
939: dotted,
940: dot_dashed,
941: short_dashed,
942: long_dashed,
943: };
944:
945:
946:
947: /*ARGSUSED*/
948: XtEventReturnCode TekExposeWindow(event, eventdata)
949: register XEvent *event;
950: caddr_t eventdata;
951: {
952: register TScreen *screen = &term.screen;
953: #ifdef DEBUG
954: if(debug)
955: fputs("ExposeWindow Tek\n", stderr);
956: #endif DEBUG
957: if(!screen->Tshow) {
958: screen->Tshow = TRUE;
959: reselectwindow(screen);
960: }
961: TekExpose((XExposeEvent *) event);
962:
963: return (XteventHandled);
964: }
965:
966: /*ARGSUSED*/
967: XtEventReturnCode TekUnmapWindow(event, eventdata)
968: XEvent *event;
969: caddr_t eventdata;
970: {
971: register TScreen *screen = &term.screen;
972:
973: if (event->type != UnmapNotify) return(XteventNotHandled);
974:
975: #ifdef DEBUG
976: if(debug)
977: fputs("UnmapWindow Tek\n", stderr);
978: #endif DEBUG
979: screen->Tshow = FALSE;
980: /* if(screen->show) {
981: screen->show = FALSE;
982: XUnmapWindow(screen->display, screen->fullVwin.window );
983: SyncUnmap( screen->fullVwin.window, WINDOWEVENTS );
984: }
985: */
986: reselectwindow(screen);
987: return (XteventHandled);
988: }
989:
990:
991: TekInit()
992: {
993: register TScreen *screen = &term.screen;
994: register int i;
995: register TekLink *tek;
996: register double d;
997: register int border = 2 * screen->border;
998: XColor cdef;
999: int pixels[2];
1000: static short Tfailed;
1001: int x, y, rootx, rooty, pr;
1002: Window win, root;
1003: unsigned int mask; /* XQueryPointer */
1004: XGCValues gcv;
1005: int winX, winY, width, height;
1006: XSizeHints sizehints;
1007: XSetWindowAttributes attr;
1008: char Tdefault[32];
1009: extern char *malloc();
1010:
1011: if(Tfailed)
1012: return(0);
1013: if (!(screen->Tfont[SMALLFONT] = XLoadQueryFont(screen->display, SMALLFONTNAME))) {
1014: fprintf(stderr, "%s: Could not get font %s; using server default\n",
1015: xterm_name, SMALLFONTNAME);
1016: screen->Tfont[SMALLFONT] =
1017: XQueryFont(screen->display,
1018: DefaultGC(screen->display,
1019: DefaultScreen(screen->display)
1020: )->gid
1021: );
1022: TEKgcFontMask = 0;
1023: }
1024: if((Tbuffer = (char *)malloc(BUF_SIZE)) == NULL ||
1025: (Tpushb = (char *)malloc(10)) == NULL ||
1026: (Tline = (XSegment *)malloc(MAX_VTX * sizeof(XSegment))) == NULL) {
1027: fprintf(stderr, "%s: Not enough core for Tek mode\n",
1028: xterm_name);
1029: goto mallocfailed;
1030: }
1031:
1032: screen->xorplane = 1;
1033: screen->Tbackground = XtDefaultBGPixel;
1034: screen->Tforeground = XtDefaultFGPixel;
1035: screen->Tcursorcolor = XtDefaultFGPixel;
1036:
1037: if (DisplayCells(screen->display, DefaultScreen(screen->display)) > 2
1038: && (fore_color || back_color || curs_color)) {
1039: if (curs_color &&
1040: XParseColor(screen->display, TekColormap, curs_color, &cdef)) {
1041: if(XAllocColorCells(
1042: screen->display,
1043: TekColormap,
1044: 0,
1045: &screen->xorplane, 1,
1046: pixels, 2)) {
1047: screen->cellsused = TRUE;
1048: screen->colorcells[2] = cdef;
1049: screen->Tbackground = pixels[0];
1050: screen->Tforeground = pixels[1];
1051:
1052: screen->Tcursorcolor = screen->Tbackground |
1053: screen->xorplane;
1054: screen->Tcolor |= C_CURSOR;
1055: screen->planeused = TRUE;
1056: }
1057: } else if (XAllocColorCells(
1058: screen->display,
1059: TekColormap, 0,
1060: &screen->xorplane, 1, &screen->Tbackground, 1)) {
1061: screen->Tforeground = screen->Tbackground |
1062: screen->xorplane;
1063: screen->Tcursorcolor = screen->Tforeground;
1064: screen->planeused = TRUE;
1065: }
1066: if (screen->Tbackground != XtDefaultBGPixel) {
1067: if (back_color == NULL ||
1068: !XParseColor(screen->display,
1069: TekColormap,
1070: back_color, &cdef)) {
1071: cdef.pixel = XtDefaultBGPixel;
1072: XQueryColor(screen->display, TekColormap, &cdef);
1073: screen->Tcolor |= C_BACKGROUND;
1074: }
1075: cdef.pixel = screen->Tbackground;
1076: XStoreColor(screen->display, TekColormap, &cdef);
1077: if(screen->cellsused) {
1078: screen->colorcells[0] = cdef;
1079: cdef.pixel = screen->Tforeground |
1080: screen->xorplane;
1081: XStoreColor(screen->display, TekColormap,&cdef);
1082: }
1083: if (fore_color == NULL ||
1084: !XParseColor(screen->display,
1085: TekColormap,
1086: fore_color, &cdef)) {
1087: cdef.pixel = XtDefaultFGPixel;
1088: XQueryColor(screen->display, TekColormap, &cdef);
1089: screen->Tcolor |= C_FOREGROUND;
1090: }
1091: cdef.pixel = screen->Tforeground;
1092: XStoreColor(screen->display, TekColormap, &cdef);
1093: if(screen->cellsused) {
1094: screen->colorcells[1] = cdef;
1095: cdef.pixel = screen->Tcursorcolor;
1096: XStoreColor(screen->display, TekColormap, &cdef);
1097: }
1098: }
1099: }
1100:
1101: if (T_geometry == NULL) {
1102: sprintf(Tdefault, "=%dx%d",
1103: TEKDEFWIDTH + border, TEKDEFHEIGHT + border);
1104: T_geometry = Tdefault;
1105: }
1106:
1107: winX = 1;
1108: winY = 1;
1109: width = TEKDEFWIDTH + border;
1110: height = TEKDEFHEIGHT + border;
1111:
1112: pr = XParseGeometry(T_geometry, &winX, &winY, &width, &height);
1113: if ((pr & XValue) && (XNegative&pr))
1114: winX += DisplayWidth(screen->display, DefaultScreen(screen->display)) - width;
1115: if ((pr & YValue) && (YNegative&pr))
1116: winY += DisplayHeight(screen->display, DefaultScreen(screen->display)) - height;
1117:
1118: /* set up size hints */
1119: sizehints.min_width = TEKMINWIDTH + border;
1120: sizehints.min_height = TEKMINHEIGHT + border;
1121: sizehints.width_inc = 1;
1122: sizehints.height_inc = 1;
1123: sizehints.flags = PMinSize|PResizeInc;
1124: if ((XValue&pr) && (YValue&pr))
1125: sizehints.flags |= USPosition;
1126: else sizehints.flags |= PPosition;
1127: sizehints.width = width;
1128: sizehints.height = height;
1129: if ((WidthValue&pr) && (HeightValue&pr))
1130: sizehints.flags |= USSize;
1131: else sizehints.flags |= PSize;
1132:
1133: attr.border_pixmap = screen->graybordertile;
1134: attr.win_gravity = NorthWestGravity;
1135: attr.background_pixel = screen->Tbackground;
1136: if((TWindow(screen) = XCreateWindow(
1137: screen->display,
1138: DefaultRootWindow(screen->display),
1139: winX, winY, width, height, screen->borderwidth,
1140: DefaultDepth(screen->display, DefaultScreen(screen->display)),
1141: CopyFromParent, CopyFromParent,
1142: CWBorderPixmap|CWBackPixel|CWWinGravity, &attr)) == NULL) {
1143: fprintf(stderr, "%s: Can't create Tek window\n", xterm_name);
1144: free((char *)Tline);
1145: mallocfailed:
1146: if(Tpushb)
1147: free((char *)Tpushb);
1148: if(Tbuffer)
1149: free((char *)Tbuffer);
1150: XFreeFont(screen->display, screen->Tfont[SMALLFONT]);
1151: fontfailed:
1152: Tfailed = TRUE;
1153: return(FALSE);
1154: }
1155: /* crock to make configure notifies get through */
1156: XtMakeMaster(screen->display, TWindow(screen));
1157:
1158: XSetNormalHints (screen->display, TWindow(screen), &sizehints);
1159:
1160: XtSetEventHandler(screen->display, TWindow(screen),
1161: (XtEventHandler) HandleEnterWindow, EnterWindowMask, (caddr_t)NULL);
1162: XtSetEventHandler(screen->display, TWindow(screen),
1163: (XtEventHandler) HandleLeaveWindow, LeaveWindowMask, (caddr_t)NULL);
1164: XtSetEventHandler(screen->display, TWindow(screen),
1165: (XtEventHandler) HandleFocusChange, FocusChangeMask, (caddr_t)NULL);
1166: XtSetEventHandler(screen->display, TWindow(screen),
1167: (XtEventHandler) TekButtonPressed, ButtonPressMask, (caddr_t)NULL);
1168: XtSetEventHandler(screen->display, TWindow(screen),
1169: (XtEventHandler) EventDoNothing, ButtonReleaseMask, (caddr_t)NULL);
1170: XtSetEventHandler(screen->display, TWindow(screen),
1171: (XtEventHandler) TekExposeWindow, ExposureMask, (caddr_t)NULL);
1172: XtSetEventHandler(screen->display, TWindow(screen),
1173: (XtEventHandler) TekUnmapWindow, StructureNotifyMask, (caddr_t)NULL);
1174: XtSetEventHandler(screen->display, TWindow(screen),
1175: (XtEventHandler) HandleKeyPressed, KeyPressMask, (caddr_t)NULL);
1176:
1177: screen->Tbox = T_box;
1178:
1179: TFullWidth(screen) = width;
1180: TFullHeight(screen) = height;
1181: TWidth(screen) = width - border;
1182: THeight(screen) = height - border;
1183: TekScale(screen) = (double)TWidth(screen)
1184: / (TEKWIDTH + TEKPAD);
1185: if((d = (double)THeight(screen) / (TEKHEIGHT + TEKTOPPAD +
1186: TEKBOTTOMPAD)) < TekScale(screen))
1187: TekScale(screen) = d;
1188:
1189:
1190: screen->tobaseline[SMALLFONT] = screen->Tfont[SMALLFONT]->ascent;
1191:
1192: if (!(screen->Tfont[THREEFONT] = XLoadQueryFont(screen->display, THREEFONTNAME)))
1193: screen->Tfont[THREEFONT] = screen->Tfont[SMALLFONT];
1194: screen->tobaseline[THREEFONT] = screen->Tfont[THREEFONT]->ascent;
1195:
1196: if (!(screen->Tfont[TWOFONT] = XLoadQueryFont(screen->display, TWOFONTNAME)))
1197: screen->Tfont[TWOFONT] = screen->Tfont[THREEFONT];
1198: screen->tobaseline[TWOFONT] = screen->Tfont[TWOFONT]->ascent;
1199:
1200: if (!(screen->Tfont[LARGEFONT] = XLoadQueryFont(screen->display, LARGEFONTNAME)))
1201: screen->Tfont[LARGEFONT] = screen->Tfont[TWOFONT];
1202: screen->tobaseline[LARGEFONT] = screen->Tfont[LARGEFONT]->ascent;
1203:
1204: gcv.graphics_exposures = TRUE; /* default */
1205: gcv.font = screen->Tfont[screen->cur.fontsize]->fid;
1206: gcv.foreground = screen->Tforeground;
1207: gcv.background = screen->Tbackground;
1208: screen->TnormalGC = XCreateGC(
1209: screen->display, TWindow(screen),
1210: TEKgcFontMask+GCGraphicsExposures+GCForeground+GCBackground, &gcv);
1211:
1212: gcv.foreground = screen->Tcursorcolor;
1213: gcv.background = screen->Tbackground;
1214: gcv.function = GXinvert;
1215: gcv.plane_mask = screen->xorplane;
1216: screen->TcursorGC = XCreateGC(screen->display, TWindow(screen),
1217: GCFunction+GCPlaneMask+GCForeground+GCBackground , &gcv);
1218:
1219: if(term.flags & REVERSE_VIDEO) {
1220: TekReverseVideo(screen);
1221: } else
1222: TekBackground(screen);
1223:
1224: gcv.foreground = screen->Tforeground;
1225: gcv.line_style = LineOnOffDash;
1226: for(i = 0 ; i < TEKNUMLINES ; i++) {
1227: screen->linepat[i] = XCreateGC(
1228: screen->display, TWindow(screen),
1229: GCForeground+GCLineStyle, &gcv);
1230: XSetDashes(screen->display, screen->linepat[i], 0,
1231: dashes[i], dash_length[i]);
1232: }
1233: screen->margin = MARGIN1; /* Margin 1 */
1234: screen->cur.fontsize = LARGEFONT; /* set large font */
1235: screen->TekGIN = FALSE; /* GIN off */
1236:
1237:
1238: XDefineCursor(screen->display, TWindow(screen), screen->curs );
1239: if((screen->Ticonname = malloc((unsigned) screen->iconnamelen + 7)) == NULL)
1240: Error(ERROR_TWINNAME);
1241: strcpy(screen->Ticonname, screen->iconname);
1242: strcat(screen->Ticonname, "(Tek) ");
1243: screen->Ticonnamelen = strlen(screen->Ticonname);
1244: if((screen->Ttitlename = malloc((unsigned) screen->titlenamelen + 7)) == NULL)
1245: Error(ERROR_TWINNAME);
1246: strcpy(screen->Ttitlename, screen->titlename);
1247: strcat(screen->Ttitlename, "(Tek) ");
1248: screen->Ttitlenamelen = strlen(screen->Ttitlename);
1249: XStoreName (screen->display, TWindow(screen), screen->Ttitlename);
1250: XChangeProperty(screen->display, TWindow(screen), XA_WM_ICON_NAME,
1251: XA_STRING, 8, PropModeReplace, (unsigned char *)screen->Ticonname,
1252: screen->Ticonnamelen);
1253:
1254:
1255: tek = TekRecord = &Tek0;
1256: tek->next = (TekLink *)0;
1257: tek->count = 0;
1258: tek->ptr = tek->data;
1259: Tpushback = Tpushb;
1260: screen->cur_X = 0;
1261: screen->cur_Y = TEKHOME;
1262: line_pt = Tline;
1263: Ttoggled = TRUE;
1264: return(TRUE);
1265: }
1266:
1267: TekReverseVideo(screen)
1268: register TScreen *screen;
1269: {
1270: register int flag, i;
1271: XGCValues gcv;
1272:
1273:
1274: i = screen->Tbackground;
1275: screen->Tbackground = screen->Tforeground;
1276: screen->Tforeground = i;
1277: screen->Tcolor = (screen->Tcolor & ~C_FBMASK) | switchfb[screen->Tcolor
1278: & C_FBMASK];
1279:
1280: XSetForeground(screen->display, screen->TnormalGC,
1281: screen->Tforeground);
1282: XSetBackground(screen->display, screen->TnormalGC,
1283: screen->Tbackground);
1284:
1285: for(i = 0 ; i < TEKNUMLINES ; i++) {
1286: XSetForeground(screen->display, screen->linepat[i],
1287: screen->Tforeground);
1288: }
1289:
1290: if(screen->cellsused) {
1291: flag = (term.flags & REVERSE_VIDEO) != 0;
1292: screen->Tcursorcolor = screen->Tbackground | screen->xorplane;
1293: i = screen->select ? 2 : !flag;
1294: screen->colorcells[i].pixel = screen->Tcursorcolor;
1295: XStoreColor(screen->display, TekColormap, &screen->colorcells[i]);
1296: screen->colorcells[flag].pixel = screen->Tforeground |
1297: screen->xorplane;
1298: XStoreColor(screen->display, TekColormap, &screen->colorcells[flag]);
1299: } else
1300: screen->Tcursorcolor = screen->Tforeground;
1301:
1302: gcv.foreground = screen->Tcursorcolor;
1303: gcv.background = screen->Tbackground;
1304: XChangeGC(screen->display, screen->TcursorGC,
1305: GCForeground+GCBackground, &gcv);
1306:
1307: TekBackground(screen);
1308: }
1309:
1310: TekBackground(screen)
1311: register TScreen *screen;
1312: {
1313: if(TWindow(screen))
1314: XSetWindowBackground(screen->display, TWindow(screen),
1315: screen->Tbackground);
1316: }
1317:
1318: /*
1319: * Toggles cursor on or off at cursor position in screen.
1320: */
1321: TCursorToggle(toggle)
1322: int toggle;
1323: {
1324: register TScreen *screen = &term.screen;
1325: register int c, x, y;
1326: register T_fontsize *Tf;
1327:
1328: c = screen->cur.fontsize;
1329: Tf = &Tfontsize[c];
1330:
1331: x = (screen->cur_X * TekScale(screen)) + screen->border;
1332: y = ((TEKHEIGHT + TEKTOPPAD - screen->cur_Y) * TekScale(screen)) +
1333: screen->border + screen->tobaseline[c] - 2*(unsigned) Tf->Theight;
1334: if (toggle) {
1335: if (screen->select)
1336: XFillRectangle(
1337: screen->display, TWindow(screen), screen->TcursorGC,
1338: x, y,
1339: (unsigned) Tf->Twidth, (unsigned) Tf->Theight);
1340: else { /* fix to use different GC! */
1341: screen->Tbox[c]->x = x;
1342: screen->Tbox[c]->y = y ;
1343: XDrawLines(screen->display, TWindow(screen),
1344: screen->TcursorGC,
1345: screen->Tbox[c], NBOX, CoordModePrevious);
1346: }
1347: } else {
1348: if (screen->select)
1349: XClearArea(screen->display, TWindow(screen), x, y,
1350: (unsigned) Tf->Twidth, (unsigned) Tf->Theight, FALSE);
1351: else {
1352: screen->Tbox[c]->x = x;
1353: screen->Tbox[c]->y = y ;
1354: XDrawLines(screen->display, TWindow(screen),
1355: screen->TcursorGC,
1356: screen->Tbox[c], NBOX, CoordModePrevious);
1357: }
1358: }
1359: }
1360:
1361: TekSelect()
1362: {
1363: register TScreen *screen = &term.screen;
1364:
1365: XSetWindowBorder(screen->display, TWindow(screen), screen->bordercolor);
1366: }
1367:
1368: TekUnselect()
1369: {
1370: register TScreen *screen = &term.screen;
1371:
1372: XSetWindowBorderPixmap(screen->display, TWindow(screen), screen->graybordertile);
1373: }
1374:
1375: TekCopy()
1376: {
1377: register TekLink *Tp;
1378: register int fd;
1379: register TScreen *screen = &term.screen;
1380: register struct tm *tp;
1381: long l;
1382: char buf[32];
1383:
1384: /* for login windows, check that a user has logged in */
1385: if(L_flag && !checklogin()) {
1386: Bell();
1387: return;
1388: }
1389: time(&l);
1390: tp = localtime(&l);
1391: sprintf(buf, "COPY%02d-%02d-%02d.%02d:%02d:%02d", tp->tm_year,
1392: tp->tm_mon, tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec);
1.1.1.2 ! root 1393: if(access(buf, 0) >= 0) { /* file exists */
! 1394: if(access(buf, 2) < 0) {
1.1 root 1395: Bell();
1396: return;
1397: }
1.1.1.2 ! root 1398: } else if(access(".", 2) < 0) { /* can't write in directory */
1.1 root 1399: Bell();
1400: return;
1401: }
1.1.1.2 ! root 1402: if((fd = creat(buf, 0644)) < 0) {
1.1 root 1403: Bell();
1404: return;
1405: }
1406: chown(buf, screen->uid, screen->gid);
1407: sprintf(buf, "\033%c\033%c", screen->page.fontsize + '8',
1408: screen->page.linetype + '`');
1409: write(fd, buf, 4);
1410: Tp = &Tek0;
1411: do
1412: write(fd, (char *)Tp->data, Tp->count);
1413: while(Tp = Tp->next);
1414: close(fd);
1415: }
1416:
1417: #ifdef MODEMENU
1418: /*
1419: * TMENU_LARGE through TMENU_SMALL must be first, as they must be the same
1420: * as the font size values LARGEFONT through SMALLFONT
1421: */
1422: #define TMENU_LARGE 0
1423: #define TMENU_NUM2 (TMENU_LARGE+1)
1424: #define TMENU_NUM3 (TMENU_NUM2+1)
1425: #define TMENU_SMALL (TMENU_NUM3+1)
1426: #define TMENU_VTWIN (TMENU_SMALL+1)
1427: #define TMENU_LINE (TMENU_VTWIN+1)
1428: #define TMENU_PAGE (TMENU_LINE+1)
1429: #define TMENU_RESET (TMENU_PAGE+1)
1430: #define TMENU_COPY (TMENU_RESET+1)
1431: #define TMENU_VTMODE (TMENU_COPY+1)
1432: #define TMENU_HIDETEK (TMENU_VTMODE+1)
1433:
1434: static char *Ttext[] = {
1435: "Large Characters",
1436: "#2 Size Characters",
1437: "#3 Size Characters",
1438: "Small Characters",
1439: "VT Window Showing",
1440: "-",
1441: "PAGE",
1442: "RESET",
1443: "COPY",
1444: "Select VT Mode",
1445: "Hide Tek Window",
1446: 0,
1447: };
1448:
1449: static Tmodes curmodes;
1450: static int Tsize;
1451:
1452: Menu *Tsetupmenu(menu)
1453: register Menu **menu;
1454: {
1455: register TScreen *screen = &term.screen;
1456: register char **cp;
1457: register int size = screen->cur.fontsize;
1458: register int kflags = term.keyboard.flags;
1459:
1460: curmodes = screen->cur;
1461: if (*menu == NULL) {
1462: if ((*menu = NewMenu("Tektronix", re_verse)) == NULL)
1463: return(NULL);
1464: for(cp = Ttext ; *cp ; cp++)
1465: AddMenuItem(*menu, *cp);
1466: CheckItem(*menu, size);
1467: /* if(vshow = screen->show)
1468: CheckItem(*menu, TMENU_VTWIN);
1469: else
1470: DisableItem(*menu, TMENU_HIDETEK);
1471: */
1472: DisableItem(*menu, TMENU_LINE);
1473: Tsize = size;
1474: return(*menu);
1475: }
1476: if (Tsize != size) {
1477: UncheckItem(*menu, Tsize);
1478: CheckItem(*menu, Tsize = size);
1479: }
1480: /* if(vshow != screen->show) {
1481: SetItemCheck(*menu, TMENU_VTWIN, (vshow = screen->show));
1482: SetItemDisable(*menu, TMENU_HIDETEK, !vshow);
1483: }
1484: */
1485: return(*menu);
1486: }
1487:
1488: static char *changesize[] = {
1489: "\0338",
1490: "\0339",
1491: "\033:",
1492: "\033;",
1493: };
1494:
1495: Tdomenufunc(item)
1496: int item;
1497: {
1498: register TScreen *screen = &term.screen;
1499: register char *tp;
1500: register char *fp;
1501: Window win;
1502: int x, y;
1503:
1504: switch (item) {
1505: case TMENU_LARGE:
1506: case TMENU_NUM2:
1507: case TMENU_NUM3:
1508: case TMENU_SMALL:
1509: if(!Ttoggled) {
1510: TCursorToggle(TOGGLE);
1511: Ttoggled = TRUE;
1512: }
1513: if(Tbcnt < 0)
1514: Tbcnt = 0;
1515: for(fp = changesize[item], tp = &Tbptr[Tbcnt] ; *fp ; ) {
1516: *tp++ = *fp++;
1517: Tbcnt++;
1518: }
1519: break;
1520:
1521: case TMENU_RESET:
1522: bzero((char *)&curmodes, sizeof(Tmodes));
1523: /* drop through */
1524: case TMENU_PAGE:
1525: TekRefresh = (TekLink *)0;
1526: screen->cur = curmodes;
1527: TekPage();
1528: screen->cur_X = 0;
1529: screen->cur_Y = TEKHOME;
1530: break;
1531:
1532: case TMENU_COPY:
1533: TekCopy();
1534: break;
1535:
1536: case TMENU_HIDETEK:
1537: screen->Tshow = FALSE;
1538: XUnmapWindow(screen->display, TWindow(screen));
1539: SyncUnmap(TWindow(screen), TWINDOWEVENTS);
1540: reselectwindow(screen);
1541: TekRefresh = (TekLink *)0;
1542: /* drop through */
1543: case TMENU_VTMODE:
1544: if(TekRefresh)
1545: dorefresh();
1546: if(screen->TekEmu) {
1547: if(screen->logging) {
1548: FlushLog(screen);
1549: screen->logstart = buffer;
1550: }
1551: longjmp(Tekend, 1);
1552: } else
1553: XRaiseWindow(screen->display, VWindow(screen));
1554: break;
1555:
1556: case TMENU_VTWIN:
1557: /* if(screen->show = !screen->show) {
1558: if(VWindow(screen) || VTInit()) {
1559: XMapWindow(screen->display, VWindow(screen));
1560: screen->show = TRUE;
1561: }
1562: } else {
1563: screen->show = FALSE;
1564: XUnmapWindow(screen->display, VWindow(screen));
1565: SyncUnmap(VWindow(screen), WINDOWEVENTS);
1566: if(!screen->TekEmu) {
1567: if(TekRefresh)
1568: dorefresh();
1569: if(screen->logging) {
1570: FlushLog(screen);
1571: screen->logstart = Tbuffer;
1572: }
1573: screen->TekEmu = TRUE;
1574: longjmp(VTend, 1);
1575: }
1576: }
1577: */
1578: reselectwindow(screen);
1579: break;
1580: }
1581: if(TekRefresh)
1582: dorefresh();
1583: }
1584: #endif MODEMENU
1585:
1586:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.