![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.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 misc.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm |
1.1 root 1: /*
2: * $Source: /u1/X/xterm/RCS/misc.c,v $
3: * $Header: misc.c,v 10.101 86/12/02 08:49:20 swick Exp $
4: */
5:
6: #include <stdio.h>
7: #include <setjmp.h>
8: #include <signal.h>
9: #include <ctype.h>
10: #include <pwd.h>
11: #include <sys/time.h>
12: #include <sys/file.h>
13: #include <X/Xlib.h>
14: #include "scrollbar.h"
15: #include "ptyx.h"
16: #include "data.h"
17: #include "error.h"
18: #include "gray.ic"
19: #include "hilite.ic"
20: #include "icon.ic"
21: #include "tek_icon.ic"
22: #include "wait.ic"
23: #include "waitmask.ic"
24: #include "../cursors/left_ptr.cursor"
25: #include "../cursors/left_ptr_mask.cursor"
26: #include "../cursors/tcross.cursor"
27: #include "../cursors/tcross_mask.cursor"
28: #include "../cursors/xterm.cursor"
29: #include "../cursors/xterm_mask.cursor"
30:
31: #ifndef lint
32: static char csrg_id[] = "@(#)misc.c 1.8\t(Berkeley/CSRG)\t9/18/87";
33: static char sccs_id[] = "@(#)misc.c\tX10/6.6B\t1/9/87";
34: #endif lint
35:
36: xevents()
37: {
38: XEvent reply;
39: register XEvent *rep = & reply;
40: register Screen *screen = &term.screen;
41:
42: if(screen->scroll_amt)
43: FlushScroll(screen);
44: XPending ();
45: do {
46: XNextEvent (&reply);
47: xeventpass(&reply);
48: } while (QLength() > 0);
49: }
50:
51: xeventpass(rep)
52: register XEvent *rep;
53: {
54: register Screen *screen = &term.screen;
55: register Window window = rep->window;
56: register Window w;
57: register int i;
58:
59: switch ((int)rep->type) {
60: case KeyPressed:
61: Input (&term.keyboard, &term.screen,
62: (XKeyPressedEvent *)rep);
63: break;
64:
65: case ExposeWindow:
66: if(screen->sb && window == screen->sb->bar) {
67: #ifdef DEBUG
68: if(debug)
69: fputs("ExposeWindow scrollbar\n", stderr);
70: #endif DEBUG
71: if(((XExposeEvent *)rep)->subwindow ==
72: screen->sb->button) {
73: screen->sb->buttonstate = -1;
74: DrawButton(screen->sb);
75: } else if(((XExposeEvent *)rep)->subwindow ==
76: screen->sb->save) {
77: screen->sb->savestate = -1;
78: DrawSave(screen->sb);
79: }
80: break;
81: }
82: if (screen->active_icon) {
83: #ifdef DEBUG
84: fputs( "ExposeWindow icon\n", stderr );
85: #endif DEBUG
86: if (window == screen->iconVwin.window) {
87: if (!screen->icon_show) {
88: screen->mappedVwin = &screen->iconVwin;
89: screen->icon_show = TRUE;
90: screen->show = FALSE;
91: screen->timer = 0;
92: screen->holdoff = FALSE;
93: if(screen->fullTwin.window)
94: moveiconwindow( screen->fullTwin.window,
95: screen->fullVwin.window );
96: }
97: if (screen->TekEmu)
98: VTUnselect();
99: if (term.flags & ICONINPUT)
100: reselectwindow(screen);
101: else
102: unselectwindow(screen, INWINDOW);
103: screen->iconinput = FALSE;
104: VTExpose(rep);
105: } else if (window == screen->iconTwin.window) {
106: if (!screen->icon_show) {
107: screen->mappedTwin = &screen->iconTwin;
108: screen->icon_show = TRUE;
109: screen->Tshow = FALSE;
110: screen->timer = 0;
111: screen->holdoff = FALSE;
112: if (screen->fullVwin.window)
113: moveiconwindow( screen->fullVwin.window,
114: screen->fullTwin.window );
115: }
116: if (!screen->TekEmu)
117: TekUnselect();
118: if (term.flags & ICONINPUT)
119: reselectwindow(screen);
120: else
121: unselectwindow(screen, INWINDOW);
122: screen->iconinput = FALSE;
123: TekExpose(rep);
124: }
125: } else if (window == screen->iconVwin.window ||
126: window == screen->iconTwin.window) {
127: #ifdef DEBUG
128: if(debug)
129: fprintf(stderr, "ExposeWindow %s\n", window ==
130: screen->iconVwin.window ? "icon" : "Ticon");
131: #endif DEBUG
132: RefreshIcon(screen, window);
133: break;
134: }
135: if(Titlebar(screen) || screen->icon_show) {
136: /* icon_show is a kludge as the titlebar exposure event
137: * frequently arrives before the full window exposure event */
138: if(window == screen->title.tbar) {
139: #ifdef DEBUG
140: if(debug)
141: fputs("ExposeWindow title\n", stderr);
142: #endif DEBUG
143: VTTitleExpose((XExposeWindowEvent *)rep);
144: break;
145: } else if(window == screen->Ttitle.tbar) {
146: #ifdef DEBUG
147: if(debug)
148: fputs("ExposeWindow Ttitle\n", stderr);
149: #endif DEBUG
150: TekTitleExpose((XExposeWindowEvent *)rep);
151: break;
152: }
153: }
154: if(window == screen->fullVwin.window) {
155: #ifdef DEBUG
156: if(debug)
157: fputs("ExposeWindow VT\n", stderr);
158: #endif DEBUG
159: if(!screen->show) {
160: screen->mappedVwin = &screen->fullVwin;
161: if(screen->Ticonunmap) {
162: screen->Ticonunmap = FALSE;
163: XMapWindow( screen->fullTwin.window );
164: screen->Tshow = TRUE;
165: if(!screen->TekEmu) {
166: screen->holdoff = TRUE;
167: XUnmapTransparent(VWindow(screen));
168: XMapWindow(VWindow(screen));
169: break;
170: }
171: } else {
172: screen->timer = 0;
173: screen->holdoff = FALSE;
174: }
175: screen->show = TRUE;
176: reselectwindow(screen);
177: if(screen->icon_show && screen->deiconwarp)
178: DeiconWarp(screen);
179:
180: screen->icon_show = FALSE;
181: screen->iconinput = FALSE;
182: }
183: VTExpose(rep);
184: } else if(window == screen->fullTwin.window) {
185: #ifdef DEBUG
186: if(debug)
187: fputs("ExposeWindow Tek\n", stderr);
188: #endif DEBUG
189: if(!screen->Tshow) {
190: screen->mappedTwin = &screen->fullTwin;
191: if(screen->iconunmap) {
192: screen->iconunmap = FALSE;
193: XMapWindow( screen->fullVwin.window );
194: screen->show = TRUE;
195: if(screen->TekEmu) {
196: screen->holdoff = TRUE;
197: XUnmapTransparent(TWindow(screen));
198: XMapWindow(TWindow(screen));
199: break;
200: }
201: } else {
202: screen->timer = 0;
203: screen->holdoff = FALSE;
204: }
205: screen->Tshow = TRUE;
206: reselectwindow(screen);
207: if(screen->icon_show && screen->deiconwarp)
208: DeiconWarp(screen);
209: screen->icon_show = FALSE;
210: screen->iconinput = FALSE;
211: }
212: TekExpose(rep);
213: }
214: break;
215:
216: case ExposeRegion:
217: if (!screen->active_icon && window == screen->iconVwin.window ||
218: window == screen->iconTwin.window) {
219: #ifdef DEBUG
220: if(debug)
221: fprintf(stderr, "ExposeRegion %s\n", window ==
222: screen->iconVwin.window ? "icon" : "Ticon");
223: #endif DEBUG
224: RefreshIcon(screen, window);
225: break;
226: }
227: #ifdef DEBUG
228: if(debug)
229: fputs("ExposeRegion\n", stderr);
230: #endif DEBUG
231: if (((XExposeWindowEvent *)rep)->detail == ExposeCopy &&
232: screen->incopy <= 0) {
233: screen->incopy = 1;
234: if (screen->scrolls > 0)
235: screen->scrolls--;
236: }
237: if (HandleExposure (screen, rep))
238: screen->cursor_state = OFF;
239: break;
240:
241: case ExposeCopy:
242: #ifdef DEBUG
243: if(debug)
244: fputs("ExposeCopy\n", stderr);
245: #endif DEBUG
246: if (screen->incopy <= 0 && screen->scrolls > 0)
247: screen->scrolls--;
248: if (screen->scrolls)
249: screen->incopy = -1;
250: else
251: screen->incopy = 0;
252: break;
253:
254: case ButtonPressed:
255: if (screen->incopy)
256: CopyWait (screen);
257: if(window == screen->iconVwin.window) {
258: #ifdef DEBUG
259: if(debug)
260: fputs("ButtonPressed icon\n", stderr);
261: #endif DEBUG
262: XUnmapWindow(window);
263: if(screen->Ticonunmap && !screen->TekEmu) {
264: screen->Ticonunmap = FALSE;
265: XMapWindow(TWindow(screen));
266: screen->Tshow = TRUE;
267: screen->holdoff = TRUE;
268: }
269: XMapWindow(screen->fullVwin.window);
270: break;
271: } else if(window == screen->iconTwin.window) {
272: #ifdef DEBUG
273: if(debug)
274: fputs("ButtonPressed Ticon\n", stderr);
275: #endif DEBUG
276: XUnmapWindow(window);
277: if(screen->iconunmap && screen->TekEmu) {
278: screen->iconunmap = FALSE;
279: XMapWindow(VWindow(screen));
280: screen->show = TRUE;
281: screen->holdoff = TRUE;
282: }
283: XMapWindow(screen->fullTwin.window);
284: break;
285: }
286: /* drop through */
287: case ButtonReleased:
288: #ifdef DEBUG
289: if(debug)
290: fputs("ButtonPressed or ButtonReleased\n",
291: stderr);
292: #endif DEBUG
293: HandleButtons(&term, rep, screen->respond);
294: break;
295:
296: case UnmapWindow: /* full windows */
297: if (window == screen->fullVwin.window) {
298: #ifdef DEBUG
299: if(debug)
300: fputs("UnmapWindow VT\n", stderr);
301: #endif DEBUG
302: if (screen->fullVwin.titlebar)
303: VTTitleUnhilite();
304: screen->show = FALSE;
305: if(screen->Tshow) {
306: screen->Ticonunmap = TRUE;
307: screen->Tshow = FALSE;
308: XUnmapWindow( screen->fullTwin.window );
309: SyncUnmap( screen->fullTwin.window,
310: TWINDOWEVENTS );
311: }
312: } else if(window == screen->fullTwin.window) {
313: #ifdef DEBUG
314: if(debug)
315: fputs("UnmapWindow Tek\n", stderr);
316: #endif DEBUG
317: if (screen->fullTwin.titlebar)
318: TekTitleUnhilite();
319: screen->Tshow = FALSE;
320: if(screen->show) {
321: screen->iconunmap = TRUE;
322: screen->show = FALSE;
323: XUnmapWindow( screen->fullVwin.window );
324: SyncUnmap( screen->fullVwin.window,
325: WINDOWEVENTS );
326: }
327: }
328: reselectwindow(screen);
329: screen->timer = 0;
330: break;
331: case EnterWindow:
332: if(screen->sb) {
333: if(window == screen->sb->button) {
334: if((i = GetButtonState(screen->sb)) !=
335: BUTTON_NORMAL)
336: SetButtonState(screen->sb, i | HILITED);
337: break;
338: } else if(window == screen->sb->bar)
339: break;
340: }
341: if((window == VWindow(screen) || window == TWindow(screen)) &&
342: (((XEnterWindowEvent *)rep)->detail & 0xff) !=
343: IntoOrFromSubwindow) {
344: #ifdef DEBUG
345: if(debug)
346: fprintf(stderr, "EnterWindow %s\n", window ==
347: VWindow(screen) ? "VT" : "Tek");
348: #endif DEBUG
349: screen->autowindow = window;
350: DoEnterLeave(screen, EnterWindow);
351: }
352: break;
353: case LeaveWindow:
354: if(screen->sb) {
355: if(window == screen->sb->button) {
356: if((i = GetButtonState(screen->sb)) !=
357: BUTTON_NORMAL)
358: SetButtonState(screen->sb, i& ~HILITED);
359: break;
360: } else if(window == screen->sb->bar)
361: break;
362: }
363: if((window == VWindow(screen) || window == TWindow(screen)) &&
364: (((XEnterWindowEvent *)rep)->detail & 0xff) !=
365: IntoOrFromSubwindow)
366: #ifdef DEBUG
367: {
368: if(debug)
369: fprintf(stderr, "LeaveWindow %s\n", window ==
370: VWindow(screen) ? "VT" : "Tek");
371: #endif DEBUG
372: DoEnterLeave(screen, LeaveWindow);
373: #ifdef DEBUG
374: }
375: #endif DEBUG
376: break;
377: case FocusChange:
378: if(((XFocusChangeEvent *)rep)->detail == EnterWindow)
379: selectwindow(screen, FOCUS);
380: else
381: unselectwindow(screen, FOCUS);
382: break;
383: default:
384: break;
385: }
386: }
387:
388: selectwindow(screen, flag)
389: register Screen *screen;
390: register int flag;
391: {
392: if(screen->TekEmu) {
393: TekSelect();
394: if(!Ttoggled)
395: TCursorToggle(TOGGLE);
396: if(screen->cellsused) {
397: screen->colorcells[2].pixel =
398: screen->Tcursorcolor;
399: XStoreColor(&screen->colorcells[2]);
400: }
401: screen->select |= flag;
402: if(!Ttoggled)
403: TCursorToggle(TOGGLE);
404: return;
405: } else {
406: VTSelect();
407: if(screen->cursor_state &&
408: (screen->cursor_col != screen->cur_col ||
409: screen->cursor_row != screen->cur_row))
410: HideCursor();
411: screen->select |= flag;
412: if(screen->cursor_state)
413: ShowCursor();
414: return;
415: }
416: }
417:
418: unselectwindow(screen, flag)
419: register Screen *screen;
420: register int flag;
421: {
422: register int i;
423:
424: screen->select &= ~flag;
425: if(!screen->select) {
426: if(screen->TekEmu) {
427: TekUnselect();
428: if(!Ttoggled)
429: TCursorToggle(TOGGLE);
430: if(screen->cellsused) {
431: i = (term.flags & REVERSE_VIDEO) == 0;
432: screen->colorcells[i].pixel =
433: screen->Tcursorcolor;
434: XStoreColor(
435: &screen->colorcells[i]);
436: }
437: if(!Ttoggled)
438: TCursorToggle(TOGGLE);
439: return;
440: } else {
441: VTUnselect();
442: if(screen->cursor_state &&
443: (screen->cursor_col != screen->cur_col ||
444: screen->cursor_row != screen->cur_row))
445: HideCursor();
446: if(screen->cursor_state)
447: ShowCursor();
448: return;
449: }
450: }
451: }
452:
453: reselectwindow(screen)
454: register Screen *screen;
455: {
456: Window win;
457: int x, y;
458:
459: if(XQueryMouse(RootWindow, &x, &y, &win)) {
460: if(win && (win == VWindow(screen) || win == TWindow(screen))
461: && (!screen->icon_show
462: || (screen->active_icon && term.flags & ICONINPUT)))
463: selectwindow(screen, INWINDOW);
464: else unselectwindow(screen, INWINDOW);
465: }
466: }
467:
468: DeiconWarp(screen)
469: register Screen *screen;
470: {
471: if(screen->TekEmu)
472: XWarpMouse(TWindow(screen), TFullWidth(screen) / 2,
473: TFullHeight(screen) / 2);
474: else
475: XWarpMouse(VWindow(screen), FullWidth(screen) / 2,
476: FullHeight(screen) / 2);
477: }
478:
479: #define ENTERLEAVE 500000L
480:
481: DoEnterLeave(screen, type)
482: register Screen *screen;
483: int type;
484: {
485: if (!screen->autoraise && !screen->holdoff) {
486: if (type == EnterWindow)
487: selectwindow( screen, INWINDOW );
488: else unselectwindow( screen, INWINDOW );
489: return;
490: }
491:
492: screen->timer = type;
493: if(!screen->holdoff)
494: Timer(ENTERLEAVE);
495: }
496:
497: Timer(val)
498: long val;
499: {
500: struct itimerval it;
501:
502: bzero(&it, sizeof(it));
503: it.it_value.tv_usec = val;
504: setitimer(ITIMER_REAL, &it, (struct itimerval *)0);
505: }
506:
507: /*
508: * Handle window select/unselect.
509: *
510: * We enter from a SIGALRM; X I/O may be in progress,
511: * so just set a flag which is polled in in_put().
512: */
513: onalarm()
514: {
515: register Screen *screen = &term.screen;
516:
517: if(screen->timer == 0 || screen->holdoff) { /* extraneous alarm */
518: Timer(0L);
519: return;
520: }
521: doonalarmcode++;
522: }
523:
524: onalarmcode()
525: {
526: register Screen *screen = &term.screen;
527:
528: if(screen->timer == EnterWindow) {
529: #ifdef DEBUG
530: if(debug)
531: fprintf(stderr, "onalarm: EnterWindow %s\n",
532: screen->autoraise ? (screen->autowindow ==
533: VWindow(screen) ? "VT" : "Tek") : "");
534: #endif DEBUG
535: selectwindow(screen, INWINDOW);
536: if(screen->autoraise)
537: XRaiseWindow(screen->autowindow);
538: } else /* LeaveWindow */
539: #ifdef DEBUG
540: {
541: if(debug)
542: fputs("onalarm: LeaveWindow\n", stderr);
543: #endif DEBUG
544: unselectwindow(screen, INWINDOW);
545: #ifdef DEBUG
546: }
547: #endif DEBUG
548: screen->timer = 0;
549: doonalarmcode = 0;
550: }
551:
552: Pixmap make_hilite(fg, bg)
553: int fg, bg;
554: {
555: extern Pixmap Make_tile();
556:
557: return(Make_tile(hilite_width, hilite_height, hilite_bits, fg,
558: bg));
559: }
560:
561: Pixmap make_gray()
562: {
563: extern Pixmap Make_tile();
564:
565: return(Make_tile(gray_width, gray_height, gray_bits, BlackPixel,
566: WhitePixel));
567: }
568:
569: Cursor make_tcross(fg, bg, func)
570: int fg, bg, func;
571: {
572: return(XCreateCursor(tcross_width, tcross_height, tcross_bits,
573: tcross_mask_bits, tcross_x_hot, tcross_y_hot, fg, bg, func));
574: }
575:
576: Cursor make_xterm(fg, bg, func)
577: int fg, bg, func;
578: {
579: return(XCreateCursor(xterm_width, xterm_height, xterm_bits,
580: xterm_mask_bits, xterm_x_hot, xterm_y_hot, fg, bg, func));
581: }
582:
583: Cursor make_wait(fg, bg, func)
584: int fg, bg, func;
585: {
586: return(XCreateCursor(wait_width, wait_height, wait_bits, waitmask_bits,
587: wait_x_hot, wait_y_hot, fg, bg, func));
588: }
589:
590: Cursor make_arrow(fg, bg, func)
591: int fg, bg, func;
592: {
593: return(XCreateCursor(left_ptr_width, left_ptr_height, left_ptr_bits,
594: left_ptr_mask_bits, left_ptr_x_hot, left_ptr_y_hot, fg, bg, func));
595: }
596:
597: char *uniquesuffix(name)
598: char *name;
599: {
600: register int *np, *fp, i;
601: register Window *cp;
602: register int temp, j, k, exact, *number;
603: char *wname;
604: Window *children, parent;
605: int nchildren;
606: static char *suffix, sufbuf[10];
607: char *malloc();
608:
609: if(suffix)
610: return(suffix);
611: suffix = sufbuf;
612: if(!XQueryTree(RootWindow, &parent, &nchildren, &children) ||
613: nchildren < 1 || (number = (int *)malloc(nchildren * sizeof(int)))
614: == NULL)
615: return(suffix);
616: exact = FALSE;
617: i = strlen(name);
618: for(np = number, cp = children, j = nchildren ; j > 0 ; cp++, j--) {
619: if(!XFetchName(*cp, &wname) || wname == NULL)
620: continue;
621: if(strncmp(name, wname, i) == 0) {
622: if(wname[i] == 0 || strcmp(&wname[i], " (Tek)") == 0)
623: exact = TRUE;
624: else if(strncmp(&wname[i], " #", 2) == 0)
625: *np++ = atoi(&wname[i + 2]);
626: }
627: free(wname);
628: }
629: free((char *)children);
630: if(exact) {
631: if(np <= number)
632: strcpy(suffix, " #2");
633: else {
634: exact = np - number;
635: np = number;
636: /* shell sort */
637: for(i = exact / 2 ; i > 0 ; i /= 2)
638: for(k = i ; k < exact ; k++)
639: for(j = k - i ; j >= 0 &&
640: np[j] > np[j + i] ; j -= i) {
641: temp = np[j];
642: np[j] = np[j + i];
643: np[j + i] = temp;
644: }
645: /* make numbers unique */
646: for(fp = np + 1, i = exact - 1 ; i > 0 ; fp++, i--)
647: if(*fp != *np)
648: *++np = *fp;
649: /* find least unique number */
650: for(i = 2, fp = number ; fp <= np ; fp++) {
651: if(i < *fp)
652: break;
653: if(i == *fp)
654: i++;
655: }
656: sprintf(suffix, " #%d", i);
657: }
658: }
659: free((char *)number);
660: return(suffix);
661: }
662:
663: Bell()
664: {
665: extern Terminal term;
666: register Screen *screen = &term.screen;
667: register Window w;
668: register int width, height, xorPixel;
669:
670: if (screen->audiblebell)
671: XFeep(0);
672:
673: if (screen->visualbell) {
674: if (screen->TekEmu) {
675: if (screen->icon_show && !screen->active_icon) {
676: w = screen->iconTwin.window;
677: width = screen->iconTwin.width;
678: height = screen->iconTwin.height;
679: } else {
680: w = TWindow(screen);
681: width = TFullWidth(screen);
682: height = TFullHeight(screen);
683: }
684: } else {
685: if (screen->icon_show && !screen->active_icon) {
686: w = screen->iconVwin.window;
687: width = screen->iconVwin.width;
688: height = screen->iconVwin.height;
689: } else {
690: w = VWindow(screen);
691: width = FullWidth(screen);
692: height = FullHeight(screen);
693: }
694: }
695: xorPixel = screen->foreground ^ screen->background;
696: XPixFill(w, 0, 0, width, height, xorPixel, 0, GXxor, AllPlanes);
697: XFlush();
698: usleep(screen->visbelldelay * 1000);
699: XPixFill(w, 0, 0, width, height, xorPixel, 0, GXxor, AllPlanes);
700: }
701: }
702:
703: Redraw()
704: {
705: extern Terminal term;
706: register Screen *screen = &term.screen;
707:
708: if(VWindow(screen) && screen->show) {
709: VTExpose(NULL);
710: if(screen->scrollbar) {
711: XClear(screen->sb->bar);
712: XClear(screen->sb->region);
713: screen->sb->buttonstate = -1;
714: DrawButton(screen->sb);
715: screen->sb->savestate = -1;
716: DrawSave(screen->sb);
717: }
718: if(Titlebar(screen)) {
719: XClear(screen->title.tbar);
720: XClear(screen->title.left);
721: XClear(screen->title.right);
722: VTTitleExpose(NULL);
723: }
724: }
725: if(TWindow(screen) && screen->Tshow) {
726: TekExpose(NULL);
727: if(Titlebar(screen)) {
728: XClear(screen->Ttitle.tbar);
729: XClear(screen->Ttitle.left);
730: XClear(screen->Ttitle.right);
731: TekTitleExpose(NULL);
732: }
733: }
734: }
735:
736: IconInit(screen, bm, Tbm)
737: register Screen *screen;
738: char *bm, *Tbm;
739: {
740: register int w;
741:
742: again:
743: if(!bm && !Tbm) { /* use default bitmaps */
744: screen->iconbitmap.bits = icon_bits;
745: screen->Ticonbitmap.bits = tek_icon_bits;
746: screen->bitmapwidth = screen->iconbitmap.width =
747: screen->Ticonbitmap.width = icon_width;
748: screen->bitmapheight = screen->iconbitmap.height =
749: screen->Ticonbitmap.height = icon_height;
750: } else if(bm && !*bm && Tbm && !*Tbm) /* both empty means no bitmap */
751: screen->bitmapwidth = screen->bitmapheight = 0;
752: else { /* user defined bitmap(s) */
753: if(bm && *bm) {
754: if((w = XReadBitmapFile(bm, &screen->iconbitmap.width,
755: &screen->iconbitmap.height, &screen->iconbitmap.bits,
756: NULL, NULL)) == 0) {
757: /*
758: * Pretend there wasn't an icon specified
759: * and try for the default icon.
760: */
761: fprintf(stderr, "%s: Can't open %s\n",
762: xterm_name, bm);
763: bm = 0;
764: goto again;
765: } else if(w < 0) {
766: syntaxerror:
767: fprintf(stderr, "%s: Syntax error in %s\n",
768: xterm_name, bm);
769: Exit(ERROR_SYNTAXBITMAP);
770: }
771: screen->bitmapwidth = screen->iconbitmap.width;
772: screen->bitmapheight = screen->iconbitmap.height;
773: }
774: if(Tbm && *Tbm) {
775: if((w = XReadBitmapFile(Tbm, &screen->Ticonbitmap.width,
776: &screen->Ticonbitmap.height, &screen->Ticonbitmap.bits,
777: NULL, NULL)) == 0) {
778: /*
779: * Pretend there wasn't an icon specified
780: * and try for the default icon.
781: */
782: fprintf(stderr, "%s: Can't open %s\n",
783: xterm_name, Tbm);
784: Tbm = 0;
785: goto again;
786: } else if (w < 0)
787: goto syntaxerror;
788: if(screen->bitmapwidth < screen->Ticonbitmap.width)
789: screen->bitmapwidth = screen->Ticonbitmap.width;
790: if(screen->bitmapheight < screen->Ticonbitmap.height)
791: screen->bitmapheight =
792: screen->Ticonbitmap.height;
793: }
794: if(!screen->iconbitmap.bits) {
795: if(!screen->Ticonbitmap.bits) {
796: screen->Ticonbitmap.bits = tek_icon_bits;
797: screen->bitmapwidth = screen->Ticonbitmap.width
798: = icon_width;
799: screen->bitmapheight =
800: screen->Ticonbitmap.height = icon_height;
801: }
802: screen->iconbitmap.bits = screen->Ticonbitmap.bits;
803: screen->iconbitmap.width = screen->Ticonbitmap.width;
804: screen->iconbitmap.height = screen->Ticonbitmap.height;
805: } else if(!screen->Ticonbitmap.bits) {
806: if(!screen->iconbitmap.bits) {
807: screen->iconbitmap.bits = icon_bits;
808: screen->bitmapwidth = screen->iconbitmap.width
809: = icon_width;
810: screen->bitmapheight =
811: screen->iconbitmap.height = icon_height;
812: }
813: screen->Ticonbitmap.bits = screen->iconbitmap.bits;
814: screen->Ticonbitmap.width = screen->iconbitmap.width;
815: screen->Ticonbitmap.height = screen->iconbitmap.height;
816: }
817: }
818: if((screen->winname = malloc(strlen(win_name) + 10)) == NULL)
819: Error(ERROR_WINNAME);
820: strcpy(screen->winname, win_name);
821: if (douniquesuffix)
822: strcat(screen->winname, uniquesuffix(win_name));
823: screen->winnamelen = strlen(screen->winname);
824: IconRecalc(screen);
825: }
826:
827: IconRecalc(screen)
828: register Screen *screen;
829: {
830: register int i, w;
831:
832: if (screen->active_icon) return;
833:
834: w = XQueryWidth(screen->winname, screen->titlefont->id);
835: if(screen->bitmapwidth > 0) {
836: if(screen->textundericon) {
837: screen->icon_text_x = TITLEPAD;
838: screen->icon_text_y = screen->bitmapheight +
839: 2 * TITLEPAD;
840: screen->iconVwin.height = screen->bitmapheight +
841: screen->titlefont->height + 3 * TITLEPAD;
842: screen->iconbitmap.x = screen->Ticonbitmap.x =
843: screen->iconbitmap.y = screen->Ticonbitmap.y =
844: TITLEPAD;
845: if((i = screen->bitmapwidth - w) >= 0) {
846: screen->iconVwin.width = screen->bitmapwidth +
847: 2 * TITLEPAD;
848: screen->icon_text_x += i / 2;
849: } else {
850: screen->iconVwin.width = w + 2 * TITLEPAD;
851: i = (-i) / 2;
852: screen->iconbitmap.x += i;
853: screen->Ticonbitmap.x += i;
854: }
855: } else {
856: screen->icon_text_x = screen->bitmapwidth +
857: 2 * TITLEPAD;
858: screen->icon_text_y = TITLEPAD;
859: screen->iconVwin.width = w + screen->bitmapwidth +
860: 3 * TITLEPAD;
861: screen->iconbitmap.x = screen->Ticonbitmap.x =
862: screen->iconbitmap.y = screen->Ticonbitmap.y =
863: TITLEPAD;
864: if((i = screen->bitmapheight -
865: screen->titlefont->height) >= 0) {
866: screen->iconVwin.height = screen->bitmapheight +
867: 2 * TITLEPAD;
868: screen->icon_text_y += i / 2;
869: } else {
870: screen->iconVwin.height = screen->titlefont->height
871: + 2 * TITLEPAD;
872: i = (-i) / 2;
873: screen->iconbitmap.y += i;
874: screen->Ticonbitmap.y += i;
875: }
876: }
877: if((i = screen->iconbitmap.width - screen->Ticonbitmap.width)
878: >= 0)
879: screen->Ticonbitmap.x += i / 2;
880: else
881: screen->iconbitmap.x += (-i) / 2;
882: if((i = screen->iconbitmap.height - screen->Ticonbitmap.height)
883: >= 0)
884: screen->Ticonbitmap.y += i / 2;
885: else
886: screen->iconbitmap.y += (-i) / 2;
887: } else {
888: screen->icon_text_x = TITLEPAD;
889: screen->iconVwin.width = w + 2 * TITLEPAD;
890: screen->iconVwin.height = screen->titlefont->height + 2 * TITLEPAD;
891: }
892:
893: if (screen->iconVwin.window)
894: XChangeWindow( screen->iconVwin.window, screen->iconVwin.width,
895: screen->iconVwin.height );
896:
897: if (screen->iconTwin.window) {
898: screen->iconTwin.width = screen->iconVwin.width;
899: screen->iconTwin.height = screen->iconVwin.height;
900: XChangeWindow( screen->iconTwin.window, screen->iconTwin.width,
901: screen->iconTwin.height );
902: }
903:
904: icon_box[0].x = screen->icon_text_x - 2;
905: icon_box[0].y = screen->icon_text_y - 2;
906: icon_box[3].x = -(icon_box[1].x = w + 3);
907: icon_box[4].y = -(icon_box[2].y = screen->titlefont->height + 3);
908: }
909:
910: RefreshIcon(screen, window)
911: register Screen *screen;
912: Window window;
913: {
914: register BitmapBits *bb;
915: register int fg, bg;
916:
917: bb = screen->TekEmu ? &screen->Ticonbitmap : &screen->iconbitmap;
918: fg = screen->foreground;
919: bg = screen->background;
920: if(screen->bitmapwidth > 0)
921: XBitmapBitsPut(window, bb->x, bb->y, bb->width, bb->height,
922: bb->bits, fg, bg, (Bitmap)0, GXcopy, AllPlanes);
923: XText(window, screen->icon_text_x, screen->icon_text_y,
924: screen->winname, screen->winnamelen, screen->titlefont->id, fg, bg);
925: screen->icon_show = TRUE;
926: if(screen->iconinput)
927: IconBox(screen);
928: }
929:
930: IconBox(screen)
931: register Screen *screen;
932: {
933: if (screen->active_icon) return;
934:
935: XDraw(screen->TekEmu ? screen->iconTwin.window : screen->iconVwin.window,
936: icon_box, NBOX, 1, 1, screen->foreground, GXcopy, AllPlanes);
937: }
938:
939: /*
940: * Move win1's icon window to where win2's icon window is.
941: */
942: moveiconwindow(win1, win2)
943: register Window win1, win2;
944: {
945: WindowInfo wininfo1, wininfo2;
946:
947: XQueryWindow(win1, &wininfo1);
948: XQueryWindow(win2, &wininfo2);
949: if(wininfo1.assoc_wind && wininfo2.assoc_wind) {
950: XQueryWindow(wininfo2.assoc_wind, &wininfo2);
951: XMoveWindow(wininfo1.assoc_wind, wininfo2.x, wininfo2.y);
952: }
953: }
954:
955: IconGeometry(screen, ix, iy)
956: register Screen *screen;
957: register int *ix, *iy;
958: {
959: register int i;
960: int w, h;
961:
962: if(icon_geom) {
963: i = XParseGeometry(icon_geom, ix, iy, &w, &h);
964: /*
965: * XParseGeometry returns negative values in addition to
966: * setting the bitmask.
967: */
968: if((i & XValue) && (i & XNegative))
969: *ix = DisplayWidth() + *ix - screen->iconVwin.width - 2 *
970: screen->borderwidth;
971: if((i & YValue) && (i & YNegative))
972: *iy = DisplayHeight() + *iy - screen->iconVwin.height - 2 *
973: screen->borderwidth;
974: }
975: }
976:
977: InTitle(screen, window, x)
978: register Screen *screen;
979: Window window;
980: int x;
981: {
982: register int i, j;
983:
984: if(window == screen->title.tbar) {
985: i = (j = FullWidth(screen) / 2) - (screen->title.x -
986: screen->title_n_size);
987: j = x - j;
988: if(j < 0)
989: j = -j;
990: if(j < i) {
991: XUnmapWindow(VWindow(screen));
992: XMapWindow(screen->iconVwin.window);
993: return(TRUE);
994: }
995: } else {
996: i = (j = TFullWidth(screen) / 2) - (screen->Ttitle.x -
997: screen->title_n_size);
998: j = x - j;
999: if(j < 0)
1000: j = -j;
1001: if(j < i) {
1002: XUnmapWindow(TWindow(screen));
1003: XMapWindow(screen->iconTwin.window);
1004: return(TRUE);
1005: }
1006: }
1007: return(FALSE);
1008: }
1009:
1010: SyncUnmap(win, mask)
1011: register Window win;
1012: register int mask;
1013: {
1014: XEvent ev;
1015: register XEvent *rep = &ev;
1016:
1017: do { /* ignore events through unmap */
1018: XWindowEvent(win, mask, rep);
1019: } while(rep->type != UnmapWindow);
1020: }
1021:
1022: StartLog(screen)
1023: register Screen *screen;
1024: {
1025: register char *cp;
1026: register int i;
1027: static char *log_default;
1028: char *malloc(), *rindex();
1029: extern logpipe();
1030:
1031: if(screen->logging || (screen->inhibit & I_LOG))
1032: return;
1033: if(screen->logfile == NULL || *screen->logfile == 0) {
1034: if(screen->logfile)
1035: free(screen->logfile);
1036: if(log_default == NULL)
1037: mktemp(log_default = log_def_name);
1038: if((screen->logfile = malloc(strlen(log_default) + 1)) == NULL)
1039: return;
1040: strcpy(screen->logfile, log_default);
1041: }
1042: if(*screen->logfile == '|') { /* exec command */
1043: int p[2];
1044: static char *shell;
1045:
1046: if(pipe(p) < 0 || (i = fork()) < 0)
1047: return;
1048: if(i == 0) { /* child */
1049: close(p[1]);
1050: dup2(p[0], 0);
1051: close(p[0]);
1052: dup2(fileno(stderr), 1);
1053: dup2(fileno(stderr), 2);
1054: close(fileno(stderr));
1055: fileno(stderr) = 2;
1056: close(screen->display->fd);
1057: close(screen->respond);
1058: if(!shell) {
1059: register struct passwd *pw;
1060: char *getenv(), *malloc();
1061: struct passwd *getpwuid();
1062:
1063: if(((cp = getenv("SHELL")) == NULL || *cp == 0)
1064: && ((pw = getpwuid(screen->uid)) == NULL ||
1065: *(cp = pw->pw_shell) == 0) ||
1066: (shell = malloc(strlen(cp) + 1)) == NULL)
1067: shell = "/bin/sh";
1068: else
1069: strcpy(shell, cp);
1070: }
1071: signal(SIGHUP, SIG_DFL);
1072: signal(SIGCHLD, SIG_DFL);
1073: setgid(screen->gid);
1074: setuid(screen->uid);
1075: execl(shell, shell, "-c", &screen->logfile[1], 0);
1076: fprintf(stderr, "%s: Can't exec `%s'\n", xterm_name,
1077: &screen->logfile[1]);
1078: exit(ERROR_LOGEXEC);
1079: }
1080: close(p[0]);
1081: screen->logfd = p[1];
1082: signal(SIGPIPE, logpipe);
1083: } else {
1084: if(access(screen->logfile, F_OK) == 0) {
1085: if(access(screen->logfile, W_OK) < 0)
1086: return;
1087: } else if(cp = rindex(screen->logfile, '/')) {
1088: *cp = 0;
1089: i = access(screen->logfile, W_OK);
1090: *cp = '/';
1091: if(i < 0)
1092: return;
1093: } else if(access(".", W_OK) < 0)
1094: return;
1095: if((screen->logfd = open(screen->logfile, O_WRONLY | O_APPEND |
1096: O_CREAT, 0644)) < 0)
1097: return;
1098: chown(screen->logfile, screen->uid, screen->gid);
1099:
1100: }
1101: screen->logstart = screen->TekEmu ? Tbptr : bptr;
1102: screen->logging = TRUE;
1103: }
1104:
1105: CloseLog(screen)
1106: register Screen *screen;
1107: {
1108: if(!screen->logging || (screen->inhibit & I_LOG))
1109: return;
1110: FlushLog(screen);
1111: close(screen->logfd);
1112: screen->logging = FALSE;
1113: }
1114:
1115: FlushLog(screen)
1116: register Screen *screen;
1117: {
1118: register char *cp;
1119: register int i;
1120:
1121: cp = screen->TekEmu ? Tbptr : bptr;
1122: if((i = cp - screen->logstart) > 0)
1123: write(screen->logfd, screen->logstart, i);
1124: screen->logstart = screen->TekEmu ? Tbuffer : buffer;
1125: }
1126:
1127: logpipe()
1128: {
1129: register Screen *screen = &term.screen;
1130:
1131: if(screen->logging)
1132: CloseLog(screen);
1133: }
1134:
1135: do_osc(func)
1136: int (*func)();
1137: {
1138: register Screen *screen = &term.screen;
1139: register int mode, c;
1140: register char *cp;
1141: char buf[512];
1142: extern char *malloc();
1143:
1144: mode = 0;
1145: while(isdigit(c = (*func)()))
1146: mode = 10 * mode + (c - '0');
1147: cp = buf;
1148: while(isprint(c = (*func)()))
1149: *cp++ = c;
1150: *cp = 0;
1151: switch(mode) {
1152: case 0: /* new title */
1153: Retitle(buf);
1154: break;
1155: case 46: /* new log file */
1156: if((cp = malloc(strlen(buf) + 1)) == NULL)
1157: break;
1158: strcpy(cp, buf);
1159: if(screen->logfile)
1160: free(screen->logfile);
1161: screen->logfile = cp;
1162: break;
1163: #ifdef CHANGEFONT
1164: case 47: /* new screen font */
1165: if (VTChangeFont(screen, buf)) {
1166: XChangeWindow (VWindow(screen),
1167: FontWidth(screen) * (screen->max_col + 1) +
1168: 2 * screen->border + screen->scrollbar,
1169: FontHeight(screen) * (screen->max_row + 1) +
1170: screen->statusheight + Titlebar(screen)
1171: + 2 * screen->border);
1172: XSync(FALSE); /* synchronize */
1173: if(QLength() > 0)
1174: xevents();
1175: }
1176: break;
1177: }
1178: #endif
1179: }
1180:
1181: Retitle(name)
1182: register char *name;
1183: {
1184: register Screen *screen = &term.screen;
1185: register int w, i, j;
1186: char icon[512];
1187:
1188: free(screen->winname);
1189: if((screen->winname = malloc((screen->winnamelen = strlen(name)) + 1))
1190: == NULL)
1191: Error(ERROR_RTMALLOC1);
1192: strcpy(screen->winname, name);
1193: strcpy(icon, name);
1194: strcat(icon, " (icon)");
1195: IconRecalc(screen);
1196: if(screen->fullVwin.window) {
1197: XStoreName(screen->fullVwin.window, name);
1198: XStoreName(screen->iconVwin.window, icon);
1199: XChangeWindow(screen->iconVwin.window, screen->iconVwin.width,
1200: screen->iconVwin.height);
1201: if(screen->title.tbar) {
1202: w = FullWidth(screen);
1203: screen->title.fullwidth = XQueryWidth(name,
1204: screen->titlefont->id);
1205: if((screen->title.width = i = screen->title.fullwidth)
1206: > (j = w - 2 * (MINHILITE + screen->title_n_size + 1)))
1207: screen->title.width = (i = j) +
1208: screen->title_n_size;
1209: j = w - i - 2 * (screen->title_n_size + 1);
1210: i = j / 2;
1211: j -= i;
1212: screen->title.x = i + 1 + screen->title_n_size;
1213: screen->title.y = TITLEPAD;
1214: XClear(screen->title.tbar);
1215: XChangeWindow(screen->title.left, i,
1216: screen->titlefont->height);
1217: XConfigureWindow(screen->title.right, w - j - 1,
1218: TITLEPAD, j, screen->titlefont->height);
1219: VTTitleExpose((XExposeWindowEvent *)NULL);
1220: }
1221: }
1222: if(screen->fullTwin.window) {
1223: free(screen->Twinname);
1224: if((screen->Twinname = malloc((screen->Twinnamelen =
1225: screen->winnamelen + 6) + 1)) == NULL)
1226: Error(ERROR_RTMALLOC2);
1227: strcpy(screen->Twinname, name);
1228: strcat(screen->Twinname, " (Tek)");
1229: XStoreName(screen->fullTwin.window, screen->Twinname);
1230: XStoreName(screen->iconTwin.window, icon);
1231: XChangeWindow(screen->iconTwin.window, screen->iconTwin.width,
1232: screen->iconTwin.height);
1233: if(screen->Ttitle.tbar) {
1234: w = TFullWidth(screen);
1235: screen->Ttitle.fullwidth = XQueryWidth(screen->Twinname,
1236: screen->titlefont->id);
1237: if((screen->Ttitle.width = i = screen->Ttitle.fullwidth)
1238: > (j = w - 2 * (MINHILITE + screen->title_n_size + 1)))
1239: screen->Ttitle.width = (i = j) +
1240: screen->title_n_size;
1241: j = w - i - 2 * (screen->title_n_size + 1);
1242: i = j / 2;
1243: j -= i;
1244: screen->Ttitle.x = i + 1 + screen->title_n_size;
1245: screen->Ttitle.y = TITLEPAD;
1246: XClear(screen->Ttitle.tbar);
1247: XChangeWindow(screen->Ttitle.left, i,
1248: screen->titlefont->height);
1249: XConfigureWindow(screen->Ttitle.right, w - j - 1,
1250: TITLEPAD, j, screen->titlefont->height);
1251: TekTitleExpose((XExposeWindowEvent *)NULL);
1252: }
1253: }
1254: }
1255:
1256: Panic(s, a)
1257: char *s;
1258: int a;
1259: {
1260: #ifdef DEBUG
1261: if(debug) {
1262: fprintf(stderr, "%s: PANIC! ", xterm_name);
1263: fprintf(stderr, s, a);
1264: fputs("\r\n", stderr);
1265: fflush(stderr);
1266: }
1267: #endif DEBUG
1268: }
1269:
1270: SysError (i)
1271: int i;
1272: {
1273: fprintf (stderr, "%s: Error %d, errno %d:", xterm_name, i, errno);
1274: perror ("");
1275: Cleanup(i);
1276: }
1277:
1278: Error (i)
1279: int i;
1280: {
1281: fprintf (stderr, "%s: Error %d\n", xterm_name, i);
1282: Cleanup(i);
1283: }
1284:
1285: /*
1286: * cleanup by sending SIGHUP to client processes
1287: */
1288: Cleanup (code)
1289: int code;
1290: {
1291: #ifdef notdef
1292: extern Terminal term;
1293: register Screen *screen;
1294:
1295: screen = &term.screen;
1296: if (screen->pid > 1)
1297: killpg(getpgrp(screen->pid), SIGHUP);
1298: #endif
1299: Exit (code);
1300: }
1301:
1302: /*
1303: * sets the value of var to be arg in the Unix 4.2 BSD environment env.
1304: * Var should end with '=' (bindings are of the form "var=value").
1305: * This procedure assumes the memory for the first level of environ
1306: * was allocated using calloc, with enough extra room at the end so not
1307: * to have to do a realloc().
1308: */
1309: Setenv (var, value)
1310: register char *var, *value;
1311: {
1312: extern char **environ;
1313: register int index = 0;
1314: register int len = strlen(var);
1315:
1316: while (environ [index] != NULL) {
1317: if (strncmp (environ [index], var, len) == 0) {
1318: /* found it */
1319: environ[index] = (char *)malloc (len + strlen (value) + 1);
1320: strcpy (environ [index], var);
1321: strcat (environ [index], value);
1322: return;
1323: }
1324: index ++;
1325: }
1326:
1327: #ifdef DEBUG
1328: if (debug) fputs ("expanding env\n", stderr);
1329: #endif DEBUG
1330:
1331: environ [index] = (char *) malloc (len + strlen (value) + 1);
1332: strcpy (environ [index], var);
1333: strcat (environ [index], value);
1334: environ [++index] = NULL;
1335: }
1336:
1337: /*
1338: * returns a pointer to the first occurrence of s2 in s1,
1339: * or NULL if there are none.
1340: */
1341: char *strindex (s1, s2)
1342: register char *s1, *s2;
1343: {
1344: register char *s3;
1345: char *index();
1346:
1347: while ((s3=index(s1, *s2)) != NULL) {
1348: if (strncmp(s3, s2, strlen(s2)) == 0)
1349: return (s3);
1350: s1 = ++s3;
1351: }
1352: return (NULL);
1353: }
1354:
1355: xerror(d, ev)
1356: Display *d;
1357: register XErrorEvent *ev;
1358: {
1359: fprintf(stderr, "%s: %s\n", xterm_name,
1360: XErrDescrip(ev->error_code));
1361: fprintf(stderr, "Request code %d, func %d, serial #%ld, window %ld\n",
1362: ev->request_code, ev->func, ev->serial, (long)ev->window);
1363: Exit(ERROR_XERROR);
1364: }
1365:
1366: xioerror(d)
1367: Display *d;
1368: {
1369: perror(xterm_name);
1370: Exit(ERROR_XIOERROR);
1371: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.