![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to button.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm|
Return to button.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm |
1.1 root 1: /*
2: * $Source: /u1/X/xterm/RCS/button.c,v $
3: * $Header: button.c,v 10.103 86/12/02 09:49:20 swick Exp $
4: */
5:
6: #include <X/mit-copyright.h>
7:
8: /* Copyright Massachusetts Institute of Technology 1984, 1985 */
9: /*
10: button.c Handles button events in the terminal emulator.
11: does cut/paste operations, change modes via menu,
12: passes button events through to some applications.
13: J. Gettys.
14: */
15: #ifndef lint
16: static char csrg_id[] = "@(#)button.c 1.6\t(Berkeley/CSRG)\t9/18/87";
17: static char sccs_id[] = "@(#)button.c\tX10/6.6B\t12/26/86";
18: #endif lint
19: #include <stdio.h>
20: #include <signal.h>
21: #include <setjmp.h>
22: #include <ctype.h>
23: #include <X/Xlib.h>
24: #include "scrollbar.h"
25: #include "ptyx.h"
26: #include "data.h"
27: #include "error.h"
28: #ifdef MODEMENU
29: #include "menu.h"
30: #endif MODEMENU
31:
32: #define NBUTS 3
33: #define DIRS 2
34: #define UP 1
35: #define DOWN 0
36: #define SHIFTS 8 /* three keys, so eight combinations */
37: #define Coordinate(r,c) ((r) * ncols + (c))
38:
39: char *GetRestOfLine();
40: char *SaveText();
41: extern UnSaltText();
42: extern StartCut();
43: extern ReExecute();
44: extern EditorDown();
45:
46: extern ButtonUp();
47: extern DownButtonDown();
48: extern MiddleButtonDown();
49: extern UpButtonDown();
50: extern ModeMenu();
51: extern char *xterm_name;
52: extern Bogus(), Silence();
53: extern GINbutton();
54: /* due to LK201 limitations, not all of the below are actually possible */
55: static int (*bfunc[SHIFTS][DIRS][NBUTS])() = {
56: /* left middle right */
57: EditorDown, EditorDown, EditorDown, /* down | */
58: Silence, Silence, Silence, /* up |no shift */
59:
60: ReExecute, StartCut, Silence, /* down | */
61: Silence, Silence, UnSaltText, /* up |shift */
62:
63: EditorDown, EditorDown, EditorDown, /* down | */
64: Silence, Silence, Silence, /* up |meta */
65:
66: EditorDown, EditorDown, EditorDown, /* down | */
67: Silence, Silence, Silence, /* up |meta shift */
68:
69: ModeMenu, ModeMenu, ModeMenu, /* down | */
70: Silence, Silence, Silence, /* up |control */
71:
72: EditorDown, EditorDown, EditorDown, /* down | */
73: Silence, Silence, Silence, /* up |ctl shift */
74:
75: EditorDown, EditorDown, EditorDown, /* down | */
76: Silence, Silence, Silence, /* up |no shift */
77:
78: EditorDown, EditorDown, EditorDown, /* down | control */
79: Silence, Silence, Silence /* up |meta shift*/
80:
81: }; /* button, shift keys, and direction */
82: static int (*tfunc[SHIFTS][DIRS][NBUTS])() = {
83: /* left middle right */
84: ModeMenu, ModeMenu, ModeMenu, /* down | */
85: Silence, Silence, Silence, /* up |no shift */
86:
87: ModeMenu, ModeMenu, ModeMenu, /* down | */
88: Silence, Silence, Silence, /* up |shift */
89:
90: Bogus, Bogus, Bogus, /* down | */
91: Silence, Silence, Silence, /* up |meta */
92:
93: Bogus, Bogus, Bogus, /* down | */
94: Silence, Silence, Silence, /* up |meta shift */
95:
96: ModeMenu, ModeMenu, ModeMenu, /* down | */
97: Silence, Silence, Silence, /* up |control */
98:
99: ModeMenu, ModeMenu, ModeMenu, /* down | */
100: Silence, Silence, Silence, /* up |ctl shift */
101:
102: Bogus, Bogus, Bogus, /* down | */
103: Silence, Silence, Silence, /* up |no shift */
104:
105: Bogus, Bogus, Bogus, /* down | control */
106: Silence, Silence, Silence /* up |meta shift*/
107:
108: }; /* button, shift keys, and direction */
109: static int (*scrollfunc[SHIFTS][DIRS][NBUTS])() = {
110: /* left middle right */
111: DownButtonDown, ModeMenu, UpButtonDown, /* down | */
112: ButtonUp, Silence, ButtonUp, /* up |no shift */
113:
114: DownButtonDown, ModeMenu, UpButtonDown, /* down | */
115: ButtonUp, Silence, ButtonUp, /* up |shift */
116:
117: Bogus, Bogus, Bogus, /* down | */
118: Silence, Silence, Silence, /* up |meta */
119:
120: Bogus, Bogus, Bogus, /* down | */
121: Silence, Silence, Silence, /* up |meta shift */
122:
123: DownButtonDown, ModeMenu, UpButtonDown, /* down | */
124: ButtonUp, Silence, ButtonUp, /* up |control */
125:
126: Bogus, Bogus, Bogus, /* down | */
127: Silence, Silence, Silence, /* up |ctl shift */
128:
129: Bogus, Bogus, Bogus, /* down | */
130: Silence, Silence, Silence, /* up |no shift */
131:
132: Bogus, Bogus, Bogus, /* down | control */
133: Silence, Silence, Silence /* up |meta shift*/
134:
135: }; /* button, shift keys, and direction */
136: static int (*Tbfunc[SHIFTS][DIRS][NBUTS])() = {
137: /* left middle right */
138: GINbutton, GINbutton, GINbutton, /* down | */
139: Silence, Silence, Silence, /* up |no shift */
140:
141: GINbutton, GINbutton, GINbutton, /* down | */
142: Silence, Silence, Silence, /* up |shift */
143:
144: Bogus, Bogus, Bogus, /* down | */
145: Silence, Silence, Silence, /* up |meta */
146:
147: Bogus, Bogus, Bogus, /* down | */
148: Silence, Silence, Silence, /* up |meta shift */
149:
150: ModeMenu, ModeMenu, ModeMenu, /* down | */
151: Silence, Silence, Silence, /* up |control */
152:
153: Bogus, Bogus, Bogus, /* down | */
154: Silence, Silence, Silence, /* up |ctl shift */
155:
156: Bogus, Bogus, Bogus, /* down | */
157: Silence, Silence, Silence, /* up |no shift */
158:
159: Bogus, Bogus, Bogus, /* down | control */
160: Silence, Silence, Silence /* up |meta shift*/
161:
162: }; /* button, shift keys, and direction */
163:
164: extern Terminal term;
165:
166: static int crow, ccol; /* cut row and column */
167: static int ccoord;
168: static int ncols;
169:
170: HandleButtons(term, reply, pty)
171: register Terminal *term;
172: register XEvent *reply;
173: int pty; /* file descriptor of pty */
174: {
175: register Screen *screen = &term->screen;
176: int (*bp)();
177: int dir = DOWN;
178: /* so table above will be nice, we change left to right */
179: int button = 2 - ((XKeyOrButtonEvent *)reply)->detail & 0177;
180: int shift = KeyState(((XKeyOrButtonEvent *)reply)->detail);
181:
182: switch (reply->type) {
183: case ButtonPressed:
184: dir = DOWN;
185: break;
186: case ButtonReleased:
187: dir = UP;
188: break;
189: default:
190: break;
191: }
192: if(L_flag && !checklogin()) { /* if login window, check for login */
193: if(dir == DOWN)
194: Bell();
195: return;
196: }
197: bp = (screen->sb && (reply->window == screen->sb->bar ||
198: GetButtonState(screen->sb) != BUTTON_NORMAL)) ?
199: scrollfunc[shift][dir][button] :
200: ((Titlebar(screen) && (reply->window == screen->title.tbar ||
201: reply->window == screen->Ttitle.tbar)) ? tfunc[shift][dir][button] :
202: ((reply->window == TWindow(screen)) ? Tbfunc[shift][dir][button] :
203: bfunc[shift][dir][button]));
204: if (bp != NULL)
205: (*bp)(term, reply, pty);
206: else
207: Bell();
208: }
209:
210: UnSaltText(term, reply, pty)
211: register Terminal *term;
212: register XKeyOrButtonEvent *reply;
213: int pty; /* file descriptor of pty */
214: {
215: char *line;
216: int nbytes;
217: register char *lag, *cp, *end;
218:
219: line = XFetchBytes(&nbytes);
220: end = &line[nbytes];
221: lag = line;
222: for (cp = line; cp != end; cp++)
223: {
224: if (*cp != '\n') continue;
225: *cp = '\r';
226: write(pty, lag, cp - lag + 1);
227: lag = cp + 1;
228: }
229: if (lag != end)
230: write(pty, lag, end - lag);
231: free (line); /* free text from fetch */
232: }
233:
234: ReExecute(term, reply, pty)
235: register XKeyOrButtonEvent *reply;
236: Terminal *term;
237: int pty;
238: {
239: XKeyOrButtonEvent xevent;
240: register XKeyOrButtonEvent *ev = &xevent;
241: register Screen *screen = &term->screen;
242: register int xrow, xcol, mask, cursor, ignore;
243: register char *line;
244: int row, col;
245:
246: cursor = screen->curs;
247: if(!XGrabMouse(VWindow(screen), cursor,
248: mask = ButtonReleased | EnterWindow | LeaveWindow | MouseMoved)) {
249: Bell();
250: return;
251: }
252: ncols = screen->max_col + 1; /* needed by Coordinate() define */
253: if(NearestRowCol(reply->y, reply->x, &crow, &ccol) ||
254: crow > screen->max_row) {
255: Bell();
256: XUngrabMouse();
257: return;
258: }
259: xrow = crow;
260: xcol = ccol;
261: crow++;
262: ccol = 0;
263: ccoord = Coordinate(crow, ccol);
264: if (screen->cursor_state)
265: HideCursor ();
266: HiliteText(xrow, xcol, crow, 0, TRUE);
267: ignore = FALSE;
268: for( ; ; ) {
269: XMaskEvent(mask, ev);
270: switch(ev->type) {
271: case ButtonReleased:
272: if(xrow == crow - 1) {
273: line = GetRestOfLine(screen, xrow, xcol);
274: row = strlen(line);
275: write(pty, line, row);
276: line[row] = '\n';
277: XStoreBytes(line, row);
278: free (line); /* free text from fetch */
279: HiliteText(xrow, xcol, crow, 0, FALSE);
280: }
281: XUngrabMouse();
282: if (screen->cursor_set && !screen->cursor_state)
283: ShowCursor ();
284: return;
285: case LeaveWindow:
286: if(ev->window != VWindow(screen))
287: break;
288: if(xrow == crow - 1)
289: HiliteText(xrow, xcol, crow, 0, FALSE);
290: xrow = crow;
291: xcol = 0;
292: XGrabMouse(VWindow(screen), cursor, mask & ~MouseMoved);
293: ignore = TRUE;
294: break;
295: case EnterWindow:
296: if(ev->window != VWindow(screen))
297: break;
298: XGrabMouse(VWindow(screen), cursor, mask);
299: ignore = FALSE;
300: /* drop through */
301: case MouseMoved:
302: if(ignore)
303: break;
304: NearestRowCol(ev->y, ev->x, &row, &col);
305: if(row != crow - 1) {
306: if(xrow == crow - 1)
307: HiliteText(xrow, xcol, crow, 0, FALSE);
308: } else if(xrow == row)
309: TrackText(xrow, xcol, row, col);
310: else
311: HiliteText(row, col, crow, 0, TRUE);
312: xrow = row;
313: xcol = col;
314: break;
315: }
316: }
317: }
318:
319: char *GetRestOfLine(screen, row, col)
320: register Screen *screen;
321: register int row, col;
322: {
323: char *line;
324: int i;
325:
326: i = Length(screen, row, col, screen->max_col);
327: if((line = (char *)malloc(i + 2)) == NULL)
328: SysError(ERROR_BMALLOC);
329: SaveText(screen, row, col, screen->max_col, line);
330: line[i] = '\r';
331: line[i+1] = '\0';
332: return(line);
333: }
334:
335: StartCut(term, reply, pty)
336: register XKeyOrButtonEvent *reply;
337: Terminal *term;
338: int pty;
339: {
340: XKeyOrButtonEvent xevent;
341: register XKeyOrButtonEvent *ev = &xevent;
342: register Screen *screen = &term->screen;
343: register int xrow, xcol, mask, cursor, ignore;
344: int row, col;
345:
346: cursor = screen->curs;
347: if(!XGrabMouse(VWindow(screen), cursor,
348: mask = ButtonReleased | EnterWindow | LeaveWindow | MouseMoved)) {
349: Bell();
350: return;
351: }
352: ncols = screen->max_col + 1; /* needed by Coordinate() define */
353: NearestRowCol(reply->y, reply->x, &crow, &ccol);
354: ccoord = Coordinate(crow, ccol);
355: xrow = crow;
356: xcol = ccol;
357: ignore = FALSE;
358: if (screen->cursor_state)
359: HideCursor ();
360: for( ; ; ) {
361: XMaskEvent(mask, ev);
362: switch(ev->type) {
363: case ButtonReleased:
364: if(!ignore) {
365: row = crow;
366: col = ccol; /* SaltTextAway may alter these */
367: SaltTextAway(term, xrow, xcol, pty);
368: }
369: HiliteText(row, col, xrow, xcol, FALSE);
370: XUngrabMouse();
371: if (screen->cursor_set && !screen->cursor_state)
372: ShowCursor ();
373: return;
374: case LeaveWindow:
375: if(ev->window != VWindow(screen))
376: break;
377: HiliteText(crow, ccol, xrow, xcol, FALSE);
378: xrow = crow;
379: xcol = ccol;
380: XGrabMouse(VWindow(screen), cursor, mask & ~MouseMoved);
381: ignore = TRUE;
382: break;
383: case EnterWindow:
384: if(ev->window != VWindow(screen))
385: break;
386: XGrabMouse(VWindow(screen), cursor, mask);
387: ignore = FALSE;
388: /* drop through */
389: case MouseMoved:
390: if(ignore)
391: break;
392: NearestRowCol(ev->y, ev->x, &row, &col);
393: if(row != xrow || col != xcol) {
394: TrackText(xrow, xcol, row, col);
395: xrow = row;
396: xcol = col;
397: }
398: break;
399: }
400: }
401: }
402:
403: int NearestRowCol(y, x, r, c)
404: register int y, x;
405: int *r, *c;
406: {
407: register Screen *screen = &term.screen;
408: register row, col, i;
409: register char *ch;
410: register int passed_eol = FALSE;
411:
412: if((row = (y - screen->border - Titlebar(screen)) / FontHeight(screen))
413: < 0)
414: row = 0;
415: else if(row > screen->max_row)
416: row = screen->max_row;
417: i = FontWidth(screen);
418: if((col = (x - screen->border + (i / 3)) / i) < 0)
419: col = 0;
420: else if(col > screen->max_col) {
421: col = 0;
422: row++; /* this can be screen->max_row + 1 */
423: passed_eol = TRUE;
424: }
425: if(col > 0) {
426: for(i = screen->max_col,
427: ch = screen->buf[2 * (row + screen->topline)] + i ;
428: i > 0 && *ch == 0 ; ch--, i--);
429: if(col > i + 1) {
430: col = 0;
431: row++;
432: passed_eol = TRUE;
433: }
434: }
435: *r = row;
436: *c = col;
437: return(passed_eol);
438: }
439:
440: TrackText(frow, fcol, trow, tcol)
441: register int frow, fcol, trow, tcol;
442: {
443: register int f, t;
444:
445: f = Coordinate(frow, fcol);
446: t = Coordinate(trow, tcol);
447: if(f == t)
448: return;
449: if(f > ccoord) {
450: if(t < ccoord) {
451: HiliteText(crow, ccol, frow, fcol, FALSE);
452: HiliteText(trow, tcol, crow, ccol, TRUE);
453: } else if(t > f)
454: HiliteText(frow, fcol, trow, tcol, TRUE);
455: else
456: HiliteText(trow, tcol, frow, fcol, FALSE);
457: } else {
458: if(t > ccoord) {
459: HiliteText(frow, fcol, crow, ccol, FALSE);
460: HiliteText(crow, ccol, trow, tcol, TRUE);
461: } else if(t < f)
462: HiliteText(trow, tcol, frow, fcol, TRUE);
463: else
464: HiliteText(frow, fcol, trow, tcol, FALSE);
465: }
466: }
467:
468: HiliteText(frow, fcol, trow, tcol, hilite)
469: register int frow, fcol, trow, tcol;
470: int hilite;
471: {
472: register Screen *screen = &term.screen;
473: register int i, j;
474:
475: if((i = Coordinate(frow, fcol)) == (j = Coordinate(trow, tcol)))
476: return;
477: else if(i > j) {
478: i = frow;
479: j = fcol;
480: frow = trow;
481: fcol = tcol;
482: trow = i;
483: tcol = j;
484: }
485: if(hilite) {
486: i = screen->foreground;
487: screen->foreground = screen->background;
488: screen->background = i;
489: }
490: if(frow != trow) { /* do multiple rows */
491: if((i = screen->max_col - fcol + 1) > 0) { /* first row */
492: XPixSet(VWindow(screen), fcol * FontWidth(screen) +
493: screen->border, frow * FontHeight(screen) +
494: screen->border + Titlebar(screen), i * FontWidth(screen),
495: FontHeight(screen), screen->background);
496: ScrnRefresh(screen, frow, fcol, 1, i);
497: }
498: if((i = trow - frow - 1) > 0) { /* middle rows*/
499: j = screen->max_col + 1;
500: XPixSet(VWindow(screen), screen->border, (frow + 1) *
501: FontHeight(screen) + screen->border + Titlebar(screen),
502: j * FontWidth(screen), i * FontHeight(screen),
503: screen->background);
504: ScrnRefresh(screen, frow + 1, 0, i, j);
505: }
506: if(tcol > 0 && trow <= screen->max_row) { /* last row */
507: XPixSet(VWindow(screen), screen->border, trow *
508: FontHeight(screen) + screen->border + Titlebar(screen),
509: tcol * FontWidth(screen), FontHeight(screen),
510: screen->background);
511: ScrnRefresh(screen, trow, 0, 1, tcol);
512: }
513: } else { /* do single row */
514: i = tcol - fcol;
515: XPixSet(VWindow(screen), fcol* FontWidth(screen) + screen->border,
516: frow * FontHeight(screen) + screen->border + Titlebar(screen),
517: i * FontWidth(screen), FontHeight(screen), screen->background);
518: ScrnRefresh(screen, frow, fcol, 1, tcol - fcol);
519: }
520: if(hilite) {
521: i = screen->foreground;
522: screen->foreground = screen->background;
523: screen->background = i;
524: }
525: }
526:
527: SaltTextAway(term, row, col, pty)
528: Terminal *term;
529: register row, col;
530: int pty;
531: {
532: register Screen *screen = &term->screen;
533: register int i, j = 0;
534: register char *str; /* string to be saved */
535: char *line, *lp;
536:
537: /* first order of business is to guarantee that crow,ccol is before */
538: /* row,col. */
539: if ( row == crow ) { /* must exchange as pairs */
540: if ( ccol > col ) { /* may have to exchange columns */
541: register int tmp;
542: tmp = ccol; ccol = col; col = tmp;
543: }
544: }
545: else {
546: if ( crow > row ) { /* may have to exchange row and col */
547: register int tmp;
548: tmp = ccol; ccol = col; col = tmp;
549: tmp = crow; crow = row; row = tmp;
550: }
551: }
552:
553: if (ccol < 0) ccol = 0;
554: else if (ccol > screen->max_col) { crow++; ccol = 0; }
555: if (crow < 0) crow = ccol = 0;
556: else if (crow > screen->max_row) { crow = screen->max_row; ccol = 0; }
557:
558: if (row > screen->max_row) { row = screen->max_row + 1 ; col = 0; }
559: else if (--col > screen->max_col) col = screen->max_col;
560:
561: /* first we need to know how long the string is before we can save it*/
562:
563: if ( row == crow ) j = Length(screen, crow, ccol, col);
564: else { /* two cases, cut is on same line, cut spans multiple lines */
565: j += Length(screen, crow, ccol, screen->max_col) + 1;
566: for(i = crow + 1; i < row; i++)
567: j += Length(screen, i, 0, screen->max_col) + 1;
568: if (col >= 0)
569: j += Length(screen, row, 0, col);
570: }
571:
572: /* now get some memory to save it in */
573:
574: if((line = (char *)malloc(j + 1)) == NULL)
575: SysError(ERROR_BMALLOC2);
576: line[j] = '\0'; /* make sure it is null terminated */
577: lp = line; /* lp points to where to save the text */
578: if ( row == crow ) lp = SaveText(screen, row, ccol, col, lp);
579: else {
580: lp = SaveText(screen, crow, ccol, screen->max_col, lp);
581: *lp ++ = '\n'; /* put in newline at end of line */
582: for(i = crow +1; i < row; i++) {
583: lp = SaveText(screen, i, 0, screen->max_col, lp);
584: *lp ++ = '\n';
585: }
586: if (col >= 0)
587: lp = SaveText(screen, row, 0, col, lp);
588: }
589: *lp = '\0'; /* make sure we have end marked */
590:
591: XStoreBytes(line, j);
592: free(line);
593: }
594:
595: /* returns number of chars in line from scol to ecol out */
596: int Length(screen, row, scol, ecol)
597: register int row, scol, ecol;
598: register Screen *screen;
599: {
600: register char *ch;
601: int end = 0;
602:
603: ch = screen->buf[2 * (row + screen->topline)];
604: while (ecol >= scol && ch[ecol] == 0)
605: ecol--;
606: return (ecol - scol + 1);
607: }
608:
609: /* copies text into line, preallocated */
610: char *SaveText(screen, row, scol, ecol, lp)
611: int row;
612: int scol, ecol;
613: Screen *screen;
614: register char *lp; /* pointer to where to put the text */
615: {
616: register int i = 0;
617: register char *ch = screen->buf[2 * (row + screen->topline)];
618: register int c;
619:
620: if ((i = Length(screen, row, scol, ecol)) == 0) return(lp);
621: ecol = scol + i;
622: for (i = scol; i < ecol; i++) {
623: if ((c = ch[i]) == 0)
624: c = ' ';
625: else if(c < ' ') {
626: if(c == '\036')
627: c = '#';
628: else
629: c += 0x5f;
630: } else if(c == 0x7f)
631: c = 0x5f;
632: *lp++ = c;
633: }
634: return(lp);
635: }
636:
637: EditorDown (term, reply, pty)
638: Terminal *term;
639: register XKeyOrButtonEvent *reply;
640: int pty; /* file descriptor of pty */
641: {
642: register Screen *screen = &term->screen;
643: char line[6];
644: register unsigned row, col;
645: int button;
646:
647: if (!screen->send_mouse_pos) {
648: Bell();
649: return;
650: }
651: button = 2 - reply->detail & 0177;
652: row = (reply->y - screen->border - Titlebar(screen)) / FontHeight(screen);
653: col = (reply->x - screen->border) / FontWidth(screen);
654: strcpy(line, "\033[M");
655: line[3] = ' ' + button;
656: line[4] = ' ' + col + 1;
657: line[5] = ' ' + row + 1;
658: write(pty, line, 6);
659: }
660:
661: #ifdef ALLOWUNSHIFTEDSELECTION
662: UnshiftedSelectionInit()
663: {
664: register int i, j;
665:
666: /* copy table for shifted actions to table for unshifted
667: * actions. We assume the shifted actions are in bfunc[1]
668: * and the unshifted ones go in bfunc[0].
669: */
670: for (i = 0; i < DIRS; i++)
671: for (j = 0; j < NBUTS; j++)
672: bfunc[0][i][j] = bfunc[1][i][j];
673: }
674: #endif
675:
676: #ifdef MODEMENU
677: #define MAXWINDOWMENU 64
678: #define XTERMMENU 0
679: #define VTMENU 1
680: #define TEKMENU 2
681: #define SCROLLBARMENU 3
682: #ifndef NOWINDOWMENU
683: #define WINDOWMENU 4
684: #define NMENUS 5
685: #else NOWINDOWMENU
686: #define NMENUS 4
687: #endif NOWINDOWMENU
688:
689: static Menu *menus[NMENUS];
690: #ifndef NOWINDOWMENU
691: static char *namebuf[MAXWINDOWMENU + 1];
692: static char *wname;
693: static Window windows[MAXWINDOWMENU];
694: #endif NOWINDOWMENU
695:
696: ModeMenu(term, reply, pty)
697: Terminal *term;
698: register XKeyOrButtonEvent *reply;
699: int pty; /* file descriptor of pty */
700: {
701: register Screen *screen = &term->screen;
702: register Menu *menu;
703: register int type, item;
704: static int inited;
705: extern TekLink *TekRefresh;
706: extern int xeventpass();
707: extern Menu *setupmenu(), *Tsetupmenu(), *xsetupmenu();
708: #ifndef NOWINDOWMENU
709: extern Menu *wsetupmenu();
710: #endif NOWINDOWMENU
711: extern Menu *ssetupmenu();
712:
713: if((reply->window == screen->title.tbar || reply->window ==
714: screen->Ttitle.tbar) && InTitle(screen, reply->window,
715: reply->x))
716: return;
717: if(!inited) {
718: extern Pixmap Gray_Tile;
719: extern Cursor Menu_DefaultCursor;
720: extern char *Menu_DefaultFont;
721: extern FontInfo *Menu_DefaultFontInfo;
722:
723: inited++;
724: Gray_Tile = screen->graybordertile;
725: InitMenu(xterm_name);
726: Menu_DefaultCursor = screen->arrow;
727: if(strcmp(Menu_DefaultFont, f_t) == 0)
728: Menu_DefaultFontInfo = screen->titlefont;
729: }
730: if((reply->detail & 0177) == LeftButton)
731: type = XTERMMENU;
732: else if((reply->detail & 0177) == RightButton)
733: #ifndef NOWINDOWMENU
734: type = WINDOWMENU;
735: #else NOWINDOWMENU
736: {
737: Bell();
738: return;
739: }
740: #endif NOWINDOWMENU
741: else if(reply->window == VWindow(screen) || reply->window ==
742: screen->title.tbar)
743: type = VTMENU;
744: else if(reply->window == TWindow(screen) || reply->window ==
745: screen->Ttitle.tbar)
746: type = TEKMENU;
747: else
748: type = SCROLLBARMENU;
749: switch(type) {
750: case XTERMMENU:
751: if((menu = xsetupmenu(&menus[XTERMMENU])) == NULL)
752: return;
753: break;
754: case VTMENU:
755: if((menu = setupmenu(&menus[VTMENU])) == NULL)
756: return;
757: break;
758: #ifndef NOWINDOWMENU
759: case WINDOWMENU:
760: wname = (reply->window == screen->title.tbar || reply->window
761: == VWindow(screen)) ? screen->winname : screen->Twinname;
762: if((menu = wsetupmenu(&menus[WINDOWMENU])) == NULL)
763: return;
764: break;
765: #endif NOWINDOWMENU
766: case TEKMENU:
767: if((menu = Tsetupmenu(&menus[TEKMENU])) == NULL)
768: return;
769: screen->waitrefresh = TRUE;
770: break;
771: case SCROLLBARMENU:
772: if((menu = ssetupmenu(&menus[SCROLLBARMENU])) == NULL)
773: return;
774: break;
775: }
776: /*
777: * Make the window entry and leaving routines holdoff on setting
778: * the timer and on selecting or unselecting any windows. Then
779: * set the select mode manually.
780: */
781: screen->holdoff = TRUE;
782: SetMenuEventHandler(menu, xeventpass);
783: item = TrackMenu(menu, reply);
784: menusync();
785: screen->waitrefresh = FALSE;
786: screen->timer = 0;
787: screen->holdoff = FALSE;
788: reselectwindow(screen);
789:
790: if (item < 0) {
791: if(type == TEKMENU && TekRefresh)
792: dorefresh();
793: #ifndef NOWINDOWMENU
794: else if(type == WINDOWMENU)
795: wfree(menu);
796: #endif NOWINDOWMENU
797: return;
798: }
799: switch(type) {
800: case XTERMMENU:
801: xdomenufunc(item);
802: break;
803: case VTMENU:
804: domenufunc(item);
805: break;
806: #ifndef NOWINDOWMENU
807: case WINDOWMENU:
808: wdomenufunc(item);
809: wfree(menu);
810: break;
811: #endif NOWINDOWMENU
812: case TEKMENU:
813: Tdomenufunc(item);
814: break;
815: case SCROLLBARMENU:
816: sdomenufunc(item);
817: break;
818: }
819: }
820:
821: menusync()
822: {
823: XEvent ev;
824:
825: XSync(0);
826: while(QLength() > 0) {
827: XNextEvent(&ev);
828: xeventpass(&ev);
829: }
830: }
831:
832: #define XMENU_TITLE 0
833: #define XMENU_ACTIVEICON (XMENU_TITLE+1)
834: #define XMENU_ALLOWICONINPUT (XMENU_ACTIVEICON+1)
835: #define XMENU_AUTORAISE (XMENU_ALLOWICONINPUT+1)
836: #define XMENU_AUDIBLEBELL (XMENU_AUTORAISE+1)
837: #define XMENU_VISUALBELL (XMENU_AUDIBLEBELL+1)
838: #define XMENU_DEICONWARP (XMENU_VISUALBELL+1)
839: #define XMENU_SENDMOUSE (XMENU_DEICONWARP+1)
840: #define XMENU_LOG (XMENU_SENDMOUSE+1)
841: #define XMENU_LINE (XMENU_LOG+1)
842: #define XMENU_REDRAW (XMENU_LINE+1)
843: #define XMENU_RESUME (XMENU_REDRAW+1)
844: #define XMENU_SUSPEND (XMENU_RESUME+1)
845: #define XMENU_INTR (XMENU_SUSPEND+1)
846: #define XMENU_HANGUP (XMENU_INTR+1)
847: #define XMENU_TERM (XMENU_HANGUP+1)
848: #define XMENU_KILL (XMENU_TERM+1)
849:
850: static char *xtext[] = {
851: "Title Bar(s)",
852: "Active Icon",
853: "Allow Icon Input",
854: "Auto Raise",
855: "Audible Bell",
856: "Visual Bell",
857: "Deiconify Warp",
858: "Send Mouse Pos",
859: "Logging",
860: "-",
861: "Redraw",
862: "Continue",
863: "Suspend",
864: "Interrupt",
865: "Hangup",
866: "Terminate",
867: "Kill",
868: 0,
869: };
870:
871: static int xauto;
872: static int xabell;
873: static int xvbell;
874: static int xdeiconwarp;
875: static int xsendmouse;
876: static int xlog;
877: static int xtbar;
878: static int xactive_icon;
879: static int xallow_iconinput;
880:
881: Menu *xsetupmenu(menu)
882: register Menu **menu;
883: {
884: register Screen *screen = &term.screen;
885: register char **cp;
886: register int i;
887:
888: if (*menu == NULL) {
889: if ((*menu = NewMenu("xterm X10/6.6B", re_verse)) == NULL)
890: return(NULL);
891: for(cp = xtext ; *cp ; cp++)
892: AddMenuItem(*menu, *cp);
893: if(xtbar = (Titlebar(screen) > 0))
894: CheckItem(*menu, XMENU_TITLE);
895: if(xactive_icon = screen->active_icon)
896: CheckItem(*menu, XMENU_ACTIVEICON);
897: if(xallow_iconinput = (term.flags & ICONINPUT))
898: CheckItem(*menu, XMENU_ALLOWICONINPUT);
899: SetItemDisable(*menu, XMENU_ALLOWICONINPUT, !xactive_icon);
900: if(xauto = screen->autoraise)
901: CheckItem(*menu, XMENU_AUTORAISE);
902: if(xabell = screen->audiblebell)
903: CheckItem(*menu, XMENU_AUDIBLEBELL);
904: if(xvbell = screen->visualbell)
905: CheckItem(*menu, XMENU_VISUALBELL);
906: if(xdeiconwarp = screen->deiconwarp)
907: CheckItem(*menu, XMENU_DEICONWARP);
908: if(xlog = screen->logging)
909: CheckItem(*menu, XMENU_LOG);
910: if(xsendmouse = screen->send_mouse_pos)
911: CheckItem(*menu, XMENU_SENDMOUSE);
912: DisableItem(*menu, XMENU_LINE);
913: if(screen->inhibit & I_LOG)
914: DisableItem(*menu, XMENU_LOG);
915: if(screen->inhibit & I_SIGNAL)
916: for(i = XMENU_SUSPEND ; i <= XMENU_KILL ; i++)
917: DisableItem(*menu, i);
918: return(*menu);
919: }
920: if (xtbar != (Titlebar(screen) > 0))
921: SetItemCheck(*menu, XMENU_TITLE, (xtbar =
922: (Titlebar(screen) > 0)));
923: if (xactive_icon != screen->active_icon) {
924: SetItemCheck(*menu, XMENU_ACTIVEICON,
925: (xactive_icon = screen->active_icon));
926: SetItemDisable(*menu, XMENU_ALLOWICONINPUT, !xactive_icon);
927: }
928: if (xallow_iconinput != (term.flags & ICONINPUT))
929: SetItemCheck(*menu, XMENU_ALLOWICONINPUT,
930: (xallow_iconinput = (term.flags & ICONINPUT)));
931: if (xauto != screen->autoraise)
932: SetItemCheck(*menu, XMENU_AUTORAISE, (xauto =
933: screen->autoraise));
934: if (xabell != screen->audiblebell)
935: SetItemCheck(*menu, XMENU_AUDIBLEBELL, (xabell =
936: screen->audiblebell));
937: if (xvbell != screen->visualbell)
938: SetItemCheck(*menu, XMENU_VISUALBELL, (xvbell =
939: screen->visualbell));
940: if (xdeiconwarp != screen->deiconwarp)
941: SetItemCheck(*menu, XMENU_DEICONWARP, (xdeiconwarp =
942: screen->deiconwarp));
943: if (xsendmouse != screen->send_mouse_pos)
944: SetItemCheck(*menu, XMENU_SENDMOUSE,
945: (xsendmouse = screen->send_mouse_pos));
946: if (xlog != screen->logging)
947: SetItemCheck(*menu, XMENU_LOG, (xlog = screen->logging));
948: return(*menu);
949: }
950:
951: xdomenufunc(item)
952: int item;
953: {
954: register Screen *screen = &term.screen;
955:
956: switch (item) {
957: case XMENU_TITLE:
958: if(Titlebar(screen)) {
959: screen->fullVwin.titlebar =
960: screen->fullTwin.titlebar = 0;
961: if(VWindow(screen))
962: VTTitleHide();
963: if(TWindow(screen))
964: TekTitleHide();
965: } else {
966: screen->fullVwin.titlebar =
967: screen->fullTwin.titlebar = screen->titleheight;
968: if(VWindow(screen))
969: VTTitleShow(FALSE);
970: if(TWindow(screen))
971: TekTitleShow(FALSE);
972: }
973: break;
974:
975: case XMENU_ACTIVEICON:
976: screen->active_icon = !screen->active_icon;
977: if (screen->active_icon && !screen->fnt_icon) {
978: FontInfo *fInfo = XOpenFont( f_i );
979: screen->fnt_icon = fInfo->id;
980: screen->iconVwin.f_width = fInfo->width;
981: screen->iconVwin.f_height = fInfo->height;
982: }
983:
984: if (screen->iconVwin.window) {
985: SetIconSize( screen );
986: XSelectInput( screen->iconVwin.window,
987: screen->active_icon
988: && (term.flags & ICONINPUT)
989: ? ICONWINDOWEVENTS | ICONINPUTEVENTS
990: : ICONWINDOWEVENTS );
991: }
992:
993: if (screen->iconTwin.window) {
994: TSetIconSize( screen );
995: XSelectInput( screen->iconTwin.window,
996: screen->active_icon
997: && (term.flags & ICONINPUT)
998: ? TICONWINDOWEVENTS | ICONINPUTEVENTS
999: : TICONWINDOWEVENTS );
1000: }
1001:
1002: break;
1003:
1004: case XMENU_ALLOWICONINPUT:
1005: term.flags ^= ICONINPUT;
1006: if (screen->iconVwin.window)
1007: XSelectInput( screen->iconVwin.window,
1008: screen->active_icon
1009: && (term.flags & ICONINPUT)
1010: ? ICONWINDOWEVENTS | ICONINPUTEVENTS
1011: : ICONWINDOWEVENTS );
1012:
1013: if (screen->iconTwin.window)
1014: XSelectInput( screen->iconTwin.window,
1015: screen->active_icon
1016: && (term.flags & ICONINPUT)
1017: ? TICONWINDOWEVENTS | ICONINPUTEVENTS
1018: : TICONWINDOWEVENTS );
1019:
1020: break;
1021:
1022: case XMENU_AUTORAISE:
1023: screen->autoraise = !screen->autoraise;
1024: break;
1025:
1026: case XMENU_DEICONWARP:
1027: screen->deiconwarp = !screen->deiconwarp;
1028: break;
1029:
1030: case XMENU_AUDIBLEBELL:
1031: screen->audiblebell = !screen->audiblebell;
1032: break;
1033:
1034: case XMENU_VISUALBELL:
1035: screen->visualbell = !screen->visualbell;
1036: break;
1037:
1038: case XMENU_SENDMOUSE:
1039: screen->send_mouse_pos = !screen->send_mouse_pos;
1040: break;
1041:
1042: case XMENU_LOG:
1043: if(screen->logging)
1044: CloseLog(screen);
1045: else
1046: StartLog(screen);
1047: break;
1048:
1049: case XMENU_REDRAW:
1050: Redraw();
1051: break;
1052:
1053: case XMENU_RESUME:
1054: if(screen->pid > 1)
1055: killpg(getpgrp(screen->pid), SIGCONT);
1056: break;
1057:
1058: case XMENU_SUSPEND:
1059: if(screen->pid > 1)
1060: killpg(getpgrp(screen->pid), SIGTSTP);
1061: break;
1062:
1063: case XMENU_INTR:
1064: if(screen->pid > 1)
1065: killpg(getpgrp(screen->pid), SIGINT);
1066: break;
1067:
1068: case XMENU_HANGUP:
1069: if(screen->pid > 1)
1070: killpg(getpgrp(screen->pid), SIGHUP);
1071: break;
1072:
1073: case XMENU_TERM:
1074: if(screen->pid > 1)
1075: killpg(getpgrp(screen->pid), SIGTERM);
1076: break;
1077:
1078: case XMENU_KILL:
1079: if(screen->pid > 1)
1080: killpg(getpgrp(screen->pid), SIGKILL);
1081: break;
1082: }
1083: }
1084:
1085: #ifndef NOWINDOWMENU
1086: Menu *wsetupmenu(menu)
1087: register Menu **menu;
1088: {
1089: register Window *cp, *wp;
1090: register char **np;
1091: register int i, j;
1092: Window win, *children;
1093: int nchildren;
1094: char *name;
1095: WindowInfo winfo;
1096:
1097: if(!XQueryTree(RootWindow, &win, &nchildren, &children))
1098: return(NULL);
1099: if(nchildren > MAXWINDOWMENU)
1100: nchildren = MAXWINDOWMENU;
1101: if ((*menu = NewMenu("Windows", re_verse)) == NULL) {
1102: free((char *)children);
1103: return(NULL);
1104: }
1105: np = namebuf;
1106: wp = windows;
1107: for(i = nchildren, j = 0, cp = children ; i > 0 ; cp++, i--) {
1108: if(!XQueryWindow(*cp, &winfo))
1109: goto failed;
1110: if(winfo.mapped != IsMapped)
1111: continue;
1112: if(!XFetchName(*cp, &name)) {
1113: failed:
1114: free((char *)children);
1115: *np = NULL;
1116: wfree(*menu);
1117: return(NULL);
1118: }
1119: if(name == NULL)
1120: continue;
1121: AddMenuItem(*menu, *np++ = name);
1122: *wp++ = *cp;
1123: if(strcmp(wname, name) == 0)
1124: CheckItem(*menu, j);
1125: j++;
1126: }
1127: *np = NULL;
1128: free((char *)children);
1129: if(np > namebuf)
1130: return(*menu);
1131: DisposeMenu(*menu);
1132: return(NULL);
1133: }
1134:
1135: wdomenufunc(item)
1136: int item;
1137: {
1138: register Window w;
1139:
1140: if((w = windows[item]) != NULL)
1141: XRaiseWindow(w);
1142: }
1143:
1144: wfree(menu)
1145: Menu *menu;
1146: {
1147: register char **np;
1148:
1149: for(np = namebuf ; *np ; np++)
1150: free(*np);
1151: DisposeMenu(menu);
1152: }
1153: #endif NOWINDOWMENU
1154:
1155: MenuNewCursor(cur)
1156: register Cursor cur;
1157: {
1158: register Menu **menu;
1159: register int i;
1160: extern Cursor Menu_DefaultCursor;
1161:
1162: Menu_DefaultCursor = cur;
1163: for(i = XTERMMENU, menu = menus ; i <= TEKMENU ; menu++, i++) {
1164: if(!*menu)
1165: continue;
1166: (*menu)->menuCursor = cur;
1167: if((*menu)->menuWindow)
1168: XDefineCursor((*menu)->menuWindow, cur);
1169: }
1170: }
1171: #else MODEMENU
1172:
1173: ModeMenu(term, reply, pty)
1174: Terminal *term;
1175: register XKeyOrButtonEvent *reply;
1176: int pty; /* file descriptor of pty */
1177: {
1178: register Screen *screen = &term->screen;
1179:
1180: if((reply->window == screen->title.tbar || reply->window ==
1181: screen->Ttitle.tbar) && InTitle(screen, reply->window,
1182: reply->x))
1183: return;
1184: Bell();
1185: }
1186: #endif MODEMENU
1187:
1188: GINbutton(term, reply, pty)
1189: Terminal *term;
1190: XKeyOrButtonEvent *reply;
1191: int pty; /* file descriptor of pty */
1192: {
1193: register Screen *screen = &term->screen;
1194: register int i;
1195:
1196: if(screen->TekGIN) {
1197: i = "rml"[reply->detail & 0xff];
1198: if(reply->detail & ShiftMask)
1199: i = toupper(i);
1200: TekEnqMouse(i | 0x80); /* set high bit */
1201: TekGINoff();
1202: } else
1203: Bell();
1204: }
1205:
1206: Bogus(term, reply, pty)
1207: Terminal *term;
1208: XKeyOrButtonEvent *reply;
1209: int pty; /* file descriptor of pty */
1210: {
1211: Bell();
1212: }
1213:
1214: Silence(term, reply, pty)
1215: Terminal *term;
1216: XKeyOrButtonEvent *reply;
1217: int pty; /* file descriptor of pty */
1218: {
1219: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.