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