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